Gitiles
Code Review Sign In
gerrit.omnirom.org / android_external_vim / refs/heads/android-16 / . / src / testdir / test_python3.vim
blob: bd000ef05adabb095aab2ffb1a8525ad7faedf1e [file] [log] [blame] [edit]
" Test for python 3 commands.
CheckFeature python3
func Create_vim_list()
return [1]
endfunction
func Create_vim_tuple()
return ('a', 'b')
endfunction
func Create_vim_dict()
return {'a': 1}
endfunction
let s:system_error_pat = 'Vim(py3):SystemError: \(<built-in function eval> returned NULL without setting an \(error\|exception\)\|error return without exception set\)'
" This function should be called first. This sets up python functions used by
" the other tests.
func Test_AAA_python3_setup()
py3 << trim EOF
import vim
import sys
import re
py33_type_error_pattern = re.compile(r'^__call__\(\) takes (\d+) positional argument but (\d+) were given$')
py37_exception_repr = re.compile(r'([^\(\),])(\)+)$')
py39_type_error_pattern = re.compile(r'\w+\.([^(]+\(\) takes)')
py310_type_error_pattern = re.compile(r'takes (\d+) positional argument but (\d+) were given')
def emsg(ei):
return ei[0].__name__ + ':' + repr(ei[1].args)
def ee(expr, g=globals(), l=locals()):
cb = vim.current.buffer
try:
try:
exec(expr, g, l)
except Exception as e:
if sys.version_info >= (3, 3) and e.__class__ is AttributeError and str(e).find('has no attribute')>=0 and not str(e).startswith("'vim."):
msg = repr((e.__class__, AttributeError(str(e)[str(e).rfind(" '") + 2:-1])))
elif sys.version_info >= (3, 3) and e.__class__ is ImportError and str(e).find('No module named \'') >= 0:
msg = repr((e.__class__, ImportError(str(e).replace("'", ''))))
elif sys.version_info >= (3, 6) and e.__class__ is ModuleNotFoundError:
# Python 3.6 gives ModuleNotFoundError, change it to an ImportError
msg = repr((ImportError, ImportError(str(e).replace("'", ''))))
elif sys.version_info >= (3, 3) and e.__class__ is TypeError:
m = py33_type_error_pattern.search(str(e))
if m:
msg = '__call__() takes exactly {0} positional argument ({1} given)'.format(m.group(1), m.group(2))
msg = repr((e.__class__, TypeError(msg)))
else:
msg = repr((e.__class__, e))
# Messages changed with Python 3.6, change new to old.
newmsg1 = """'argument must be str, bytes or bytearray, not None'"""
oldmsg1 = '''"Can't convert 'NoneType' object to str implicitly"'''
if msg.find(newmsg1) > -1:
msg = msg.replace(newmsg1, oldmsg1)
newmsg2 = """'argument must be str, bytes or bytearray, not int'"""
oldmsg2 = '''"Can't convert 'int' object to str implicitly"'''
if msg.find(newmsg2) > -1:
msg = msg.replace(newmsg2, oldmsg2)
# Python 3.9 reports errors like "vim.command() takes ..." instead of "command() takes ..."
msg = py39_type_error_pattern.sub(r'\1', msg)
msg = py310_type_error_pattern.sub(r'takes exactly \1 positional argument (\2 given)', msg)
elif sys.version_info >= (3, 5) and e.__class__ is ValueError and str(e) == 'embedded null byte':
msg = repr((TypeError, TypeError('expected bytes with no null')))
else:
msg = repr((e.__class__, e))
# Some Python versions say can't, others cannot.
if msg.find('can\'t') > -1:
msg = msg.replace('can\'t', 'cannot')
# Some Python versions use single quote, some double quote
if msg.find('"cannot ') > -1:
msg = msg.replace('"cannot ', '\'cannot ')
if msg.find(' attributes"') > -1:
msg = msg.replace(' attributes"', ' attributes\'')
if sys.version_info >= (3, 7):
msg = py37_exception_repr.sub(r'\1,\2', msg)
cb.append(expr + ':' + msg)
else:
cb.append(expr + ':NOT FAILED')
except Exception as e:
msg = repr((e.__class__, e))
if sys.version_info >= (3, 7):
msg = py37_exception_repr.sub(r'\1,\2', msg)
cb.append(expr + '::' + msg)
EOF
endfunc
func Test_py3do()
new
" Check deleting lines does not trigger an ml_get error.
call setline(1, ['one', 'two', 'three'])
py3do vim.command("%d_")
call assert_equal([''], getline(1, '$'))
call setline(1, ['one', 'two', 'three'])
py3do vim.command("1,2d_")
call assert_equal(['three'], getline(1, '$'))
call setline(1, ['one', 'two', 'three'])
py3do vim.command("2,3d_"); return "REPLACED"
call assert_equal(['REPLACED'], getline(1, '$'))
call setline(1, ['one', 'two', 'three'])
2,3py3do vim.command("1,2d_"); return "REPLACED"
call assert_equal(['three'], getline(1, '$'))
bwipe!
" Check switching to another buffer does not trigger an ml_get error.
new
let wincount = winnr('$')
call setline(1, ['one', 'two', 'three'])
py3do vim.command("new")
call assert_equal(wincount + 1, winnr('$'))
bwipe!
bwipe!
" Try modifying a buffer with 'nomodifiable' set
set nomodifiable
call assert_fails('py3do toupper(line)', 'E21:')
set modifiable
" Invalid command
call AssertException(['py3do non_existing_cmd'],
\ "Vim(py3do):NameError: name 'non_existing_cmd' is not defined")
call AssertException(["py3do raise Exception('test')"],
\ 'Vim(py3do):Exception: test')
call AssertException(["py3do {lambda}"],
\ 'Vim(py3do):SyntaxError: invalid syntax')
endfunc
func Test_set_cursor()
" Check that setting the cursor position works.
new
call setline(1, ['first line', 'second line'])
normal gg
py3do vim.current.window.cursor = (1, 5)
call assert_equal([1, 6], [line('.'), col('.')])
" Check that movement after setting cursor position keeps current column.
normal j
call assert_equal([2, 6], [line('.'), col('.')])
endfunc
func Test_vim_function()
" Check creating vim.Function object
func s:foo()
return matchstr(expand('<sfile>'), '<SNR>\zs\d\+_foo$')
endfunc
let name = '<SNR>' . s:foo()
try
py3 f = vim.bindeval('function("s:foo")')
call assert_equal(name, py3eval('f.name'))
catch
call assert_false(v:exception)
endtry
try
py3 f = vim.Function(b'\x80\xfdR' + vim.eval('s:foo()').encode())
call assert_equal(name, 'f.name'->py3eval())
catch
call assert_false(v:exception)
endtry
" Non-existing function attribute
call AssertException(["let x = py3eval('f.abc')"],
\ "Vim(let):AttributeError: 'vim.function' object has no attribute 'abc'")
py3 del f
delfunc s:foo
endfunc
func Test_skipped_python3_command_does_not_affect_pyxversion()
set pyxversion=0
if 0
python3 import vim
endif
call assert_equal(0, &pyxversion) " This assertion would have failed with Vim 8.0.0251. (pyxversion was introduced in 8.0.0251.)
endfunc
func _SetUpHiddenBuffer()
new
edit hidden
setlocal bufhidden=hide
enew
let lnum = 0
while lnum < 10
call append( 1, string( lnum ) )
let lnum = lnum + 1
endwhile
normal G
call assert_equal( line( '.' ), 11 )
endfunc
func _CleanUpHiddenBuffer()
bwipe! hidden
bwipe!
endfunc
func Test_Write_To_HiddenBuffer_Does_Not_Fix_Cursor_Clear()
call _SetUpHiddenBuffer()
py3 vim.buffers[ int( vim.eval( 'bufnr("hidden")' ) ) ][:] = None
call assert_equal( line( '.' ), 11 )
call _CleanUpHiddenBuffer()
endfunc
func Test_Write_To_HiddenBuffer_Does_Not_Fix_Cursor_List()
call _SetUpHiddenBuffer()
py3 vim.buffers[ int( vim.eval( 'bufnr("hidden")' ) ) ][:] = [ 'test' ]
call assert_equal( line( '.' ), 11 )
call _CleanUpHiddenBuffer()
endfunc
func Test_Write_To_HiddenBuffer_Does_Not_Fix_Cursor_Str()
call _SetUpHiddenBuffer()
py3 vim.buffers[ int( vim.eval( 'bufnr("hidden")' ) ) ][0] = 'test'
call assert_equal( line( '.' ), 11 )
call _CleanUpHiddenBuffer()
endfunc
func Test_Write_To_HiddenBuffer_Does_Not_Fix_Cursor_ClearLine()
call _SetUpHiddenBuffer()
py3 vim.buffers[ int( vim.eval( 'bufnr("hidden")' ) ) ][0] = None
call assert_equal( line( '.' ), 11 )
call _CleanUpHiddenBuffer()
endfunc
func _SetUpVisibleBuffer()
new
let lnum = 0
while lnum < 10
call append( 1, string( lnum ) )
let lnum = lnum + 1
endwhile
normal G
call assert_equal( line( '.' ), 11 )
endfunc
func Test_Write_To_Current_Buffer_Fixes_Cursor_Clear()
call _SetUpVisibleBuffer()
py3 vim.current.buffer[:] = None
call assert_equal( line( '.' ), 1 )
bwipe!
endfunc
func Test_Write_To_Current_Buffer_Fixes_Cursor_List()
call _SetUpVisibleBuffer()
py3 vim.current.buffer[:] = [ 'test' ]
call assert_equal( line( '.' ), 1 )
bwipe!
endfunc
func Test_Write_To_Current_Buffer_Fixes_Cursor_Str()
call _SetUpVisibleBuffer()
py3 vim.current.buffer[-1] = None
call assert_equal( line( '.' ), 10 )
bwipe!
endfunc
func Test_Catch_Exception_Message()
try
py3 raise RuntimeError( 'TEST' )
catch /.*/
call assert_match( '^Vim(.*):RuntimeError: TEST$', v:exception )
endtry
endfunc
func Test_unicode()
" this crashed Vim once
if &tenc != ''
throw "Skipped: 'termencoding' is not empty"
endif
set encoding=utf32
py3 print('hello')
if !has('win32')
set encoding=debug
py3 print('hello')
set encoding=euc-tw
py3 print('hello')
endif
set encoding=utf8
endfunc
" Test vim.eval() with various types.
func Test_python3_vim_eval()
call assert_equal("\n8", execute('py3 print(vim.eval("3+5"))'))
call assert_equal("\n3.140000", execute('py3 print(vim.eval("1.01+2.13"))'))
call assert_equal("\n0.000000", execute('py3 print(vim.eval("0.0/(1.0/0.0)"))'))
call assert_equal("\n0.000000", execute('py3 print(vim.eval("0.0/(1.0/0.0)"))'))
call assert_equal("\n-0.000000", execute('py3 print(vim.eval("0.0/(-1.0/0.0)"))'))
" Commented out: output of infinity and nan depend on platforms.
" call assert_equal("\ninf", execute('py3 print(vim.eval("1.0/0.0"))'))
" call assert_equal("\n-inf", execute('py3 print(vim.eval("-1.0/0.0"))'))
" call assert_equal("\n-nan", execute('py3 print(vim.eval("0.0/0.0"))'))
call assert_equal("\nabc", execute('py3 print(vim.eval("\"abc\""))'))
call assert_equal("\n['1', '2']", execute('py3 print(vim.eval("[1, 2]"))'))
call assert_equal("\n{'1': '2'}", execute('py3 print(vim.eval("{1:2}"))'))
call assert_equal("\nTrue", execute('py3 print(vim.eval("v:true"))'))
call assert_equal("\nFalse", execute('py3 print(vim.eval("v:false"))'))
call assert_equal("\nNone", execute('py3 print(vim.eval("v:null"))'))
call assert_equal("\nNone", execute('py3 print(vim.eval("v:none"))'))
call assert_equal("\nb'\\xab\\x12'", execute('py3 print(vim.eval("0zab12"))'))
call assert_fails('py3 vim.eval("1+")', 'E15: Invalid expression')
endfunc
" Test range objects, see :help python-range
func Test_python3_range()
new
py3 b = vim.current.buffer
call setline(1, range(1, 6))
py3 r = b.range(2, 4)
call assert_equal(6, py3eval('len(b)'))
call assert_equal(3, py3eval('len(r)'))
call assert_equal('3', py3eval('b[2]'))
call assert_equal('4', py3eval('r[2]'))
call assert_fails('py3 r[3] = "x"', ['Traceback', 'IndexError: line number out of range'])
call assert_fails('py3 x = r[3]', ['Traceback', 'IndexError: line number out of range'])
call assert_fails('py3 r["a"] = "x"', ['Traceback', 'TypeError: index must be int or slice, not str'])
call assert_fails('py3 x = r["a"]', ['Traceback', 'TypeError: index must be int or slice, not str'])
py3 del r[:]
call assert_equal(['1', '5', '6'], getline(1, '$'))
%d | call setline(1, range(1, 6))
py3 r = b.range(2, 5)
py3 del r[2]
call assert_equal(['1', '2', '3', '5', '6'], getline(1, '$'))
%d | call setline(1, range(1, 6))
py3 r = b.range(2, 4)
py3 vim.command("%d,%dnorm Ax" % (r.start + 1, r.end + 1))
call assert_equal(['1', '2x', '3x', '4x', '5', '6'], getline(1, '$'))
%d | call setline(1, range(1, 4))
py3 r = b.range(2, 3)
py3 r.append(['a', 'b'])
call assert_equal(['1', '2', '3', 'a', 'b', '4'], getline(1, '$'))
py3 r.append(['c', 'd'], 0)
call assert_equal(['1', 'c', 'd', '2', '3', 'a', 'b', '4'], getline(1, '$'))
%d | call setline(1, range(1, 5))
py3 r = b.range(2, 4)
py3 r.append('a')
call assert_equal(['1', '2', '3', '4', 'a', '5'], getline(1, '$'))
py3 r.append('b', 1)
call assert_equal(['1', '2', 'b', '3', '4', 'a', '5'], getline(1, '$'))
bwipe!
endfunc
" Test for resetting options with local values to global values
func Test_python3_opt_reset_local_to_global()
new
py3 curbuf = vim.current.buffer
py3 curwin = vim.current.window
" List of buffer-local options. Each list item has [option name, global
" value, buffer-local value, buffer-local value after reset] to use in the
" test.
let bopts = [
\ ['autoread', 1, 0, -1],
\ ['equalprg', 'geprg', 'leprg', ''],
\ ['keywordprg', 'gkprg', 'lkprg', ''],
\ ['path', 'gpath', 'lpath', ''],
\ ['backupcopy', 'yes', 'no', ''],
\ ['tags', 'gtags', 'ltags', ''],
\ ['tagcase', 'ignore', 'match', ''],
\ ['define', 'gdef', 'ldef', ''],
\ ['include', 'ginc', 'linc', ''],
\ ['dict', 'gdict', 'ldict', ''],
\ ['thesaurus', 'gtsr', 'ltsr', ''],
\ ['thesaurusfunc', 'Gtsrfu', 'Ltsrfu', ''],
\ ['formatprg', 'gfprg', 'lfprg', ''],
\ ['errorformat', '%f:%l:%m', '%s-%l-%m', ''],
\ ['grepprg', 'ggprg', 'lgprg', ''],
\ ['makeprg', 'gmprg', 'lmprg', ''],
\ ['cryptmethod', 'blowfish2', 'zip', ''],
\ ['lispwords', 'abc', 'xyz', ''],
\ ['makeencoding', 'utf-8', 'latin1', ''],
\ ['undolevels', 100, 200, -123456]]
if has('balloon_eval')
call add(bopts, ['balloonexpr', 'gbexpr', 'lbexpr', ''])
endif
" Set the global and buffer-local option values and then clear the
" buffer-local option value.
for opt in bopts
py3 << trim END
pyopt = vim.bindeval("opt")
vim.options[pyopt[0]] = pyopt[1]
curbuf.options[pyopt[0]] = pyopt[2]
END
exe "call assert_equal(opt[2], &" .. opt[0] .. ")"
exe "call assert_equal(opt[1], &g:" .. opt[0] .. ")"
exe "call assert_equal(opt[2], &l:" .. opt[0] .. ")"
py3 del curbuf.options[pyopt[0]]
exe "call assert_equal(opt[1], &" .. opt[0] .. ")"
exe "call assert_equal(opt[1], &g:" .. opt[0] .. ")"
exe "call assert_equal(opt[3], &l:" .. opt[0] .. ")"
exe "set " .. opt[0] .. "&"
endfor
" Set the global and window-local option values and then clear the
" window-local option value.
let wopts = [
\ ['fillchars', 'fold:>', 'fold:+', ''],
\ ['listchars', 'tab:>>', 'tab:--', ''],
\ ['scrolloff', 5, 10, -1],
\ ['showbreak', '>>', '++', ''],
\ ['sidescrolloff', 6, 12, -1],
\ ['statusline', '%<%f', '%<%F', ''],
\ ['virtualedit', 'block', 'insert', '']]
for opt in wopts
py3 << trim
pyopt = vim.bindeval("opt")
vim.options[pyopt[0]] = pyopt[1]
curwin.options[pyopt[0]] = pyopt[2]
.
exe "call assert_equal(opt[2], &" .. opt[0] .. ")"
exe "call assert_equal(opt[1], &g:" .. opt[0] .. ")"
exe "call assert_equal(opt[2], &l:" .. opt[0] .. ")"
py3 del curwin.options[pyopt[0]]
exe "call assert_equal(opt[1], &" .. opt[0] .. ")"
exe "call assert_equal(opt[1], &g:" .. opt[0] .. ")"
exe "call assert_equal(opt[3], &l:" .. opt[0] .. ")"
exe "set " .. opt[0] .. "&"
endfor
close!
endfunc
" Test for various heredoc syntax
func Test_python3_heredoc()
python3 << END
s='A'
END
python3 <<
s+='B'
.
python3 << trim END
s+='C'
END
python3 << trim
s+='D'
.
python3 << trim eof
s+='E'
eof
python3 << trimm
s+='F'
trimm
call assert_equal('ABCDEF', pyxeval('s'))
endfunc
" Test for the buffer range object
func Test_python3_range2()
new
call setline(1, ['one', 'two', 'three'])
py3 b = vim.current.buffer
py3 r = b.range(1, 3)
call assert_equal(0, py3eval('r.start'))
call assert_equal(2, py3eval('r.end'))
call assert_equal('one', py3eval('r[0]'))
call assert_equal('one', py3eval('r[-3]'))
call AssertException(["let x = py3eval('r[-4]')"],
\ 'Vim(let):IndexError: line number out of range')
call assert_equal(['two', 'three'], py3eval('r[1:]'))
py3 r[0] = 'green'
call assert_equal(['green', 'two', 'three'], getline(1, '$'))
py3 r[0:2] = ['red', 'blue']
call assert_equal(['red', 'blue', 'three'], getline(1, '$'))
" try different invalid start/end index for the range slice
%d
call setline(1, ['one', 'two', 'three'])
py3 r[-10:1] = ["a"]
py3 r[10:12] = ["b"]
py3 r[-10:-9] = ["c"]
py3 r[1:0] = ["d"]
call assert_equal(['c', 'd', 'a', 'two', 'three', 'b'], getline(1, '$'))
" The following code used to trigger an ml_get error
%d
let x = py3eval('r[:]')
" Non-existing range attribute
call AssertException(["let x = py3eval('r.abc')"],
\ "Vim(let):AttributeError: 'vim.range' object has no attribute 'abc'")
close!
endfunc
" Test for the python tabpage object
func Test_python3_tabpage()
tabnew
py3 t = vim.tabpages[1]
py3 wl = t.windows
tabclose
" Accessing a closed tabpage
call AssertException(["let n = py3eval('t.number')"],
\ 'Vim(let):vim.error: attempt to refer to deleted tab page')
call AssertException(["let n = py3eval('len(wl)')"],
\ 'Vim(let):vim.error: attempt to refer to deleted tab page')
call AssertException(["py3 w = wl[0]"],
\ 'Vim(py3):vim.error: attempt to refer to deleted tab page')
call AssertException(["py3 vim.current.tabpage = t"],
\ 'Vim(py3):vim.error: attempt to refer to deleted tab page')
call assert_match('<tabpage object (deleted)', py3eval('repr(t)'))
%bw!
endfunc
" Test for the python window object
func Test_python3_window()
" Test for setting the window height
10new
py3 vim.current.window.height = 5
call assert_equal(5, winheight(0))
py3 vim.current.window.height = 3.2
call assert_equal(3, winheight(0))
" Test for setting the window width
10vnew
py3 vim.current.window.width = 6
call assert_equal(6, winwidth(0))
" Try accessing a closed window
py3 w = vim.current.window
py3 wopts = w.options
close
" Access the attributes of a closed window
call AssertException(["let n = py3eval('w.number')"],
\ 'Vim(let):vim.error: attempt to refer to deleted window')
call AssertException(["py3 w.height = 5"],
\ 'Vim(py3):vim.error: attempt to refer to deleted window')
call AssertException(["py3 vim.current.window = w"],
\ 'Vim(py3):vim.error: attempt to refer to deleted window')
" Try to set one of the options of the closed window
" The following caused ASAN failure
call AssertException(["py3 wopts['list'] = False"],
\ 'Vim(py3):vim.error: attempt to refer to deleted window')
call assert_match('<window object (deleted)', py3eval("repr(w)"))
%bw!
endfunc
" This was causing trouble because "curbuf" was not matching curwin->w_buffer
func Test_python3_window_set_height()
enew!
call setline(1, ['aaa', 'bbb', 'ccc'])
call cursor(2, 1)
set foldmethod=expr
new
wincmd w
python3 vim.windows[0].height = 5
call assert_equal(5, winheight(1))
call feedkeys('j', 'xt')
call assert_equal(3, getpos('.')[1])
bwipe!
bwipe!
endfunc
" Test for the python List object
func Test_python3_list()
" Try to convert a null List
call AssertException(["py3 t = vim.eval('test_null_list()')"],
\ s:system_error_pat)
" Try to convert a List with a null List item
call AssertException(["py3 t = vim.eval('[test_null_list()]')"],
\ s:system_error_pat)
" Try to bind a null List variable (works because an empty list is used)
let cmds =<< trim END
let l = test_null_list()
py3 ll = vim.bindeval('l')
END
call AssertException(cmds, '')
let l = []
py3 l = vim.bindeval('l')
py3 f = vim.bindeval('function("strlen")')
" Extending List directly with different types
py3 l += [1, "as'd", [1, 2, f, {'a': 1}]]
call assert_equal([1, "as'd", [1, 2, function("strlen"), {'a': 1}]], l)
call assert_equal([1, 2, function("strlen"), {'a': 1}], l[-1])
call assert_fails('echo l[-4]', 'E684:')
" List assignment
py3 l[0] = 0
call assert_equal([0, "as'd", [1, 2, function("strlen"), {'a': 1}]], l)
py3 l[-2] = f
call assert_equal([0, function("strlen"), [1, 2, function("strlen"), {'a': 1}]], l)
" appending to a list
let l = [1, 2]
py3 ll = vim.bindeval('l')
py3 ll[2] = 8
call assert_equal([1, 2, 8], l)
" iterating over list from Python
py3 print([x for x in vim.Function("getline")(1, 2)])
" Using dict as an index
call AssertException(['py3 ll[{}] = 10'],
\ 'Vim(py3):TypeError: index must be int or slice, not dict')
endfunc
" Test for the python Tuple object
func Test_python3_tuple()
" Try to convert a null tuple
call AssertException(["py3 l = vim.eval('test_null_tuple()')"],
\ s:system_error_pat)
" Try to convert a Tuple with a null Tuple item
call AssertException(["py3 t = vim.eval('(test_null_tuple(),)')"],
\ s:system_error_pat)
" Try to convert a List with a null Tuple item
call AssertException(["py3 t = vim.eval('[test_null_tuple()]')"],
\ s:system_error_pat)
" Try to convert a Tuple with a null List item
call AssertException(["py3 t = vim.eval('(test_null_list(),)')"],
\ s:system_error_pat)
" Try to bind a null Tuple variable (works because an empty tuple is used)
let cmds =<< trim END
let t = test_null_tuple()
py3 tt = vim.bindeval('t')
END
call AssertException(cmds, '')
" Creating a tuple using different iterators
py3 t1 = vim.Tuple(['abc', 20, 1.2, (4, 5)])
call assert_equal(('abc', 20, 1.2, (4, 5)), py3eval('t1'))
py3 t2 = vim.Tuple('abc')
call assert_equal(('a', 'b', 'c'), py3eval('t2'))
py3 t3 = vim.Tuple({'color': 'red', 'model': 'ford'})
call assert_equal(('color', 'model'), py3eval('t3'))
py3 t4 = vim.Tuple()
call assert_equal((), py3eval('t4'))
py3 t5 = vim.Tuple(x**2 for x in range(5))
call assert_equal((0, 1, 4, 9, 16), py3eval('t5'))
py3 t6 = vim.Tuple(('abc', 20, 1.2, (4, 5)))
call assert_equal(('abc', 20, 1.2, (4, 5)), py3eval('t6'))
" Convert between Vim tuple/list and python tuple/list
py3 t = vim.Tuple(vim.bindeval("('a', ('b',), ['c'], {'s': 'd'})"))
call assert_equal(('a', ('b',), ['c'], {'s': 'd'}), py3eval('t'))
call assert_equal(['a', ('b',), ['c'], {'s': 'd'}], py3eval('list(t)'))
call assert_equal(('a', ('b',), ['c'], {'s': 'd'}), py3eval('tuple(t)'))
py3 l = vim.List(vim.bindeval("['e', ('f',), ['g'], {'s': 'h'}]"))
call assert_equal(('e', ('f',), ['g'], {'s': 'h'}), py3eval('tuple(l)'))
" Tuple assignment
py3 tt = vim.bindeval('("a", "b")')
call AssertException(['py3 tt[0] = 10'],
\ "Vim(py3):TypeError: 'vim.tuple' object does not support item assignment")
py3 tt = vim.bindeval('("a", "b")')
call AssertException(['py3 tt[0:1] = (10, 20)'],
\ "Vim(py3):TypeError: 'vim.tuple' object does not support item assignment")
" iterating over tuple from Python
py3 print([x for x in vim.bindeval("('a', 'b')")])
" modifying a list item within a tuple
let t = ('a', ['b', 'c'], 'd')
py3 vim.bindeval('t')[1][1] = 'x'
call assert_equal(('a', ['b', 'x'], 'd'), t)
" length of a tuple
let t = ()
py3 p_t = vim.bindeval('t')
call assert_equal(0, py3eval('len(p_t)'))
let t = ('a', )
py3 p_t = vim.bindeval('t')
call assert_equal(1, py3eval('len(p_t)'))
let t = ('a', 'b', 'c')
py3 p_t = vim.bindeval('t')
call assert_equal(3, py3eval('len(p_t)'))
" membership test
let t = ('a', 'b', 'c')
py3 p_t = vim.bindeval('t')
call assert_true(py3eval("b'c' in p_t"))
call assert_true(py3eval("b'd' not in p_t"))
py3 x = vim.eval('("a", (2), [3], {})')
call assert_equal(('a', '2', ['3'], {}), py3eval('x'))
" Using a keyword argument for a tuple
call AssertException(['py3 x = vim.Tuple(a=1)'],
\ 'Vim(py3):TypeError: tuple constructor does not accept keyword arguments')
" Using dict as an index
call AssertException(['py3 x = tt[{}]'],
\ 'Vim(py3):TypeError: index must be int or slice, not dict')
call AssertException(['py3 x = tt["abc"]'],
\ 'Vim(py3):TypeError: index must be int or slice, not str')
call AssertException(['py3 del tt.locked'],
\ 'Vim(py3):AttributeError: cannot delete vim.Tuple attributes')
call AssertException(['py3 tt.foobar = 1'],
\ 'Vim(py3):AttributeError: cannot set attribute foobar')
endfunc
" Test for the python Dict object
func Test_python3_dict()
" Try to convert a null Dict
call AssertException(["py3 t = vim.eval('test_null_dict()')"],
\ s:system_error_pat)
" Try to convert a Dict with a null List value
call AssertException(["py3 t = vim.eval(\"{'a' : test_null_list()}\")"],
\ s:system_error_pat)
" Try to convert a Dict with a null string key
py3 t = vim.eval("{test_null_string() : 10}")
call assert_fails("let d = py3eval('t')", 'E859:')
" Dict length
let d = {'a' : 10, 'b' : 20}
py3 d = vim.bindeval('d')
call assert_equal(2, py3eval('len(d)'))
" Deleting a non-existing key
call AssertException(["py3 del d['c']"], "Vim(py3):KeyError: 'c'")
endfunc
" Extending Dictionary directly with different types
func Test_python3_dict_extend()
let d = {}
func d.f()
return 1
endfunc
py3 f = vim.bindeval('function("strlen")')
py3 << trim EOF
d = vim.bindeval('d')
d['1'] = 'asd'
d.update() # Must not do anything, including throwing errors
d.update(b = [1, 2, f])
d.update((('-1', {'a': 1}),))
d.update({'0': -1})
dk = d.keys()
dv = d.values()
di = d.items()
dk.sort(key=repr)
dv.sort(key=repr)
di.sort(key=repr)
EOF
" Try extending a locked dictionary
lockvar d
call AssertException(["py3 d.update({'b' : 20})"],
\ 'Vim(py3):vim.error: dictionary is locked')
unlockvar d
call assert_equal(1, py3eval("d['f'](self={})"))
call assert_equal("[b'-1', b'0', b'1', b'b', b'f']", py3eval('repr(dk)'))
call assert_equal("[-1, <vim.Function '1'>, <vim.dictionary object at >, <vim.list object at >, b'asd']", substitute(py3eval('repr(dv)'),'0x\x\+','','g'))
call assert_equal("[(b'-1', <vim.dictionary object at >), (b'0', -1), (b'1', b'asd'), (b'b', <vim.list object at >), (b'f', <vim.Function '1'>)]", substitute(py3eval('repr(di)'),'0x\x\+','','g'))
call assert_equal(['0', '1', 'b', 'f', '-1'], keys(d))
call assert_equal("[-1, 'asd', [1, 2, function('strlen')], function('1'), {'a': 1}]", string(values(d)))
py3 del dk
py3 del di
py3 del dv
endfunc
func Test_python3_list_del_items()
" removing items with del
let l = [0, function("strlen"), [1, 2, function("strlen"), {'a': 1}]]
py3 l = vim.bindeval('l')
py3 del l[2]
call assert_equal("[0, function('strlen')]", string(l))
let l = range(8)
py3 l = vim.bindeval('l')
py3 del l[:3]
py3 del l[1:]
call assert_equal([3], l)
" removing items out of range: silently skip items that don't exist
" The following two ranges delete nothing as they match empty list:
let l = [0, 1, 2, 3]
py3 l = vim.bindeval('l')
py3 del l[2:1]
call assert_equal([0, 1, 2, 3], l)
py3 del l[2:2]
call assert_equal([0, 1, 2, 3], l)
py3 del l[2:3]
call assert_equal([0, 1, 3], l)
let l = [0, 1, 2, 3]
py3 l = vim.bindeval('l')
py3 del l[2:4]
call assert_equal([0, 1], l)
let l = [0, 1, 2, 3]
py3 l = vim.bindeval('l')
py3 del l[2:5]
call assert_equal([0, 1], l)
let l = [0, 1, 2, 3]
py3 l = vim.bindeval('l')
py3 del l[2:6]
call assert_equal([0, 1], l)
" The following two ranges delete nothing as they match empty list:
let l = [0, 1, 2, 3]
py3 l = vim.bindeval('l')
py3 del l[-1:2]
call assert_equal([0, 1, 2, 3], l)
py3 del l[-2:2]
call assert_equal([0, 1, 2, 3], l)
py3 del l[-3:2]
call assert_equal([0, 2, 3], l)
let l = [0, 1, 2, 3]
py3 l = vim.bindeval('l')
py3 del l[-4:2]
call assert_equal([2, 3], l)
let l = [0, 1, 2, 3]
py3 l = vim.bindeval('l')
py3 del l[-5:2]
call assert_equal([2, 3], l)
let l = [0, 1, 2, 3]
py3 l = vim.bindeval('l')
py3 del l[-6:2]
call assert_equal([2, 3], l)
let l = [0, 1, 2, 3]
py3 l = vim.bindeval('l')
py3 del l[::2]
call assert_equal([1, 3], l)
let l = [0, 1, 2, 3]
py3 l = vim.bindeval('l')
py3 del l[3:0:-2]
call assert_equal([0, 2], l)
let l = [0, 1, 2, 3]
py3 l = vim.bindeval('l')
py3 del l[2:4:-2]
let l = [0, 1, 2, 3]
endfunc
func Test_python3_dict_del_items()
let d = eval("{'0' : -1, '1' : 'asd', 'b' : [1, 2, function('strlen')], 'f' : function('min'), '-1' : {'a': 1}}")
py3 d = vim.bindeval('d')
py3 del d['-1']
py3 del d['f']
call assert_equal([1, 2, function('strlen')], py3eval('d.get(''b'', 1)'))
call assert_equal([1, 2, function('strlen')], py3eval('d.pop(''b'')'))
call assert_equal(1, py3eval('d.get(''b'', 1)'))
call assert_equal('asd', py3eval('d.pop(''1'', 2)'))
call assert_equal(2, py3eval('d.pop(''1'', 2)'))
call assert_equal('True', py3eval('repr(d.has_key(''0''))'))
call assert_equal('False', py3eval('repr(d.has_key(''1''))'))
call assert_equal('True', py3eval('repr(''0'' in d)'))
call assert_equal('False', py3eval('repr(''1'' in d)'))
call assert_equal("[b'0']", py3eval('repr(list(iter(d)))'))
call assert_equal({'0' : -1}, d)
call assert_equal("(b'0', -1)", py3eval('repr(d.popitem())'))
call assert_equal('None', py3eval('repr(d.get(''0''))'))
call assert_equal('[]', py3eval('repr(list(iter(d)))'))
endfunc
" Slice assignment to a list
func Test_python3_slice_assignment()
let l = [0, 1, 2, 3]
py3 l = vim.bindeval('l')
py3 l[0:0] = ['a']
call assert_equal(['a', 0, 1, 2, 3], l)
let l = [0, 1, 2, 3]
py3 l = vim.bindeval('l')
py3 l[1:2] = ['b']
call assert_equal([0, 'b', 2, 3], l)
let l = [0, 1, 2, 3]
py3 l = vim.bindeval('l')
py3 l[2:4] = ['c']
call assert_equal([0, 1, 'c'], l)
let l = [0, 1, 2, 3]
py3 l = vim.bindeval('l')
py3 l[4:4] = ['d']
call assert_equal([0, 1, 2, 3, 'd'], l)
let l = [0, 1, 2, 3]
py3 l = vim.bindeval('l')
py3 l[-1:2] = ['e']
call assert_equal([0, 1, 2, 'e', 3], l)
let l = [0, 1, 2, 3]
py3 l = vim.bindeval('l')
py3 l[-10:2] = ['f']
call assert_equal(['f', 2, 3], l)
let l = [0, 1, 2, 3]
py3 l = vim.bindeval('l')
py3 l[2:-10] = ['g']
call assert_equal([0, 1, 'g', 2, 3], l)
let l = []
py3 l = vim.bindeval('l')
py3 l[0:0] = ['h']
call assert_equal(['h'], l)
let l = range(8)
py3 l = vim.bindeval('l')
py3 l[2:6:2] = [10, 20]
call assert_equal([0, 1, 10, 3, 20, 5, 6, 7], l)
let l = range(8)
py3 l = vim.bindeval('l')
py3 l[6:2:-2] = [10, 20]
call assert_equal([0, 1, 2, 3, 20, 5, 10, 7], l)
let l = range(8)
py3 l = vim.bindeval('l')
py3 l[6:2] = ()
call assert_equal([0, 1, 2, 3, 4, 5, 6, 7], l)
let l = range(8)
py3 l = vim.bindeval('l')
py3 l[6:2:1] = ()
call assert_equal([0, 1, 2, 3, 4, 5, 6, 7], l)
let l = range(8)
py3 l = vim.bindeval('l')
py3 l[2:2:1] = ()
call assert_equal([0, 1, 2, 3, 4, 5, 6, 7], l)
call AssertException(["py3 x = l[10:11:0]"],
\ "Vim(py3):ValueError: slice step cannot be zero")
endfunc
" Locked variables
func Test_python3_lockedvar()
new
py3 cb = vim.current.buffer
let l = [0, 1, 2, 3]
py3 l = vim.bindeval('l')
lockvar! l
py3 << trim EOF
try:
l[2]='i'
except vim.error:
cb.append('l[2] threw vim.error: ' + emsg(sys.exc_info()))
EOF
call assert_equal(['', "l[2] threw vim.error: error:('list is locked',)"],
\ getline(1, '$'))
" Try to concatenate a locked list
call AssertException(['py3 l += [4, 5]'], 'Vim(py3):vim.error: list is locked')
call assert_equal([0, 1, 2, 3], l)
unlockvar! l
close!
endfunc
" Test for calling a function
func Test_python3_function_call()
func New(...)
return ['NewStart'] + a:000 + ['NewEnd']
endfunc
func DictNew(...) dict
return ['DictNewStart'] + a:000 + ['DictNewEnd', self]
endfunc
new
let l = [function('New'), function('DictNew')]
py3 l = vim.bindeval('l')
py3 l.extend(list(l[0](1, 2, 3)))
call assert_equal([function('New'), function('DictNew'), 'NewStart', 1, 2, 3, 'NewEnd'], l)
py3 l.extend(list(l[1](1, 2, 3, self={'a': 'b'})))
call assert_equal([function('New'), function('DictNew'), 'NewStart', 1, 2, 3, 'NewEnd', 'DictNewStart', 1, 2, 3, 'DictNewEnd', {'a': 'b'}], l)
py3 l += [[l[0].name]]
call assert_equal([function('New'), function('DictNew'), 'NewStart', 1, 2, 3, 'NewEnd', 'DictNewStart', 1, 2, 3, 'DictNewEnd', {'a': 'b'}, ['New']], l)
py3 ee('l[1](1, 2, 3)')
call assert_equal("l[1](1, 2, 3):(<class 'vim.error'>, error('Vim:E725: Calling dict function without Dictionary: DictNew',))", getline(2))
%d
py3 f = l[0]
delfunction New
py3 ee('f(1, 2, 3)')
call assert_equal("f(1, 2, 3):(<class 'vim.error'>, error('Vim:E117: Unknown function: New',))", getline(2))
close!
delfunction DictNew
endfunc
func Test_python3_float()
let l = [0.0]
py3 l = vim.bindeval('l')
py3 l.extend([0.0])
call assert_equal([0.0, 0.0], l)
endfunc
" Test for Dict key errors
func Test_python3_dict_key_error()
let messages = []
py3 << trim EOF
import sys
d = vim.bindeval('{}')
m = vim.bindeval('messages')
def em(expr, g=globals(), l=locals()):
try:
exec(expr, g, l)
except Exception as e:
if sys.version_info >= (3, 5) and e.__class__ is ValueError and str(e) == 'embedded null byte':
m.extend([TypeError.__name__])
else:
m.extend([e.__class__.__name__])
em('d["abc1"]')
em('d["abc1"]="\\0"')
em('d["abc1"]=vim')
em('d[""]=1')
em('d["a\\0b"]=1')
em('d[b"a\\0b"]=1')
em('d.pop("abc1")')
em('d.popitem()')
del em
del m
EOF
call assert_equal(['KeyError', 'TypeError', 'TypeError', 'ValueError',
\ 'TypeError', 'TypeError', 'KeyError', 'KeyError'], messages)
unlet messages
endfunc
" Test for locked and scope attributes
func Test_python3_lock_scope_attr()
let d = {} | let dl = {} | lockvar dl
let res = []
for s in split("d dl v: g:")
let name = tr(s, ':', 's')
execute 'py3 ' .. name .. ' = vim.bindeval("' .. s .. '")'
call add(res, s .. ' : ' .. join(map(['locked', 'scope'],
\ 'v:val .. ":" .. py3eval(name .. "." .. v:val)'), ';'))
endfor
call assert_equal(['d : locked:0;scope:0', 'dl : locked:1;scope:0',
\ 'v: : locked:2;scope:1', 'g: : locked:0;scope:2'], res)
silent! let d.abc2 = 1
silent! let dl.abc3 = 1
py3 d.locked = True
py3 dl.locked = False
silent! let d.def = 1
silent! let dl.def = 1
call assert_equal({'abc2': 1}, d)
call assert_equal({'def': 1}, dl)
unlet d dl
let l = [] | let ll = [] | lockvar ll
let res = []
for s in split("l ll")
let name = tr(s, ':', 's')
execute 'py3 ' .. name .. '=vim.bindeval("' .. s .. '")'
call add(res, s .. ' : locked:' .. py3eval(name .. '.locked'))
endfor
call assert_equal(['l : locked:0', 'll : locked:1'], res)
silent! call extend(l, [0])
silent! call extend(ll, [0])
py3 l.locked = True
py3 ll.locked = False
silent! call extend(l, [1])
silent! call extend(ll, [1])
call assert_equal([0], l)
call assert_equal([1], ll)
unlet l ll
" Try changing an attribute of a fixed list
py3 a = vim.bindeval('v:argv')
call AssertException(['py3 a.locked = 0'],
\ 'Vim(py3):TypeError: cannot modify fixed list')
endfunc
" Test for locking/unlocking a tuple
func Test_tuple_lock()
let t = (1, 2, 3)
py3 t = vim.bindeval('t')
py3 t.locked = True
call assert_equal(1, islocked('t'))
py3 t.locked = False
call assert_equal(0, islocked('t'))
endfunc
" Test for py3eval()
func Test_python3_pyeval()
let l = py3eval('[0, 1, 2]')
call assert_equal([0, 1, 2], l)
let t = py3eval('("a", "b", "c")')
call assert_equal(("a", "b", "c"), t)
let d = py3eval('{"a": "b", "c": 1, "d": ["e"]}')
call assert_equal([['a', 'b'], ['c', 1], ['d', ['e']]], sort(items(d)))
let v:errmsg = ''
call assert_equal(v:none, py3eval('None'))
call assert_equal('', v:errmsg)
py3 v = vim.eval('test_null_function()')
call assert_equal(v:none, py3eval('v'))
call assert_equal(0.0, py3eval('0.0'))
" Evaluate an invalid values
call AssertException(['let v = py3eval(''"\0"'')'], 'E859:')
call AssertException(['let v = py3eval(''{"\0" : 1}'')'], 'E859:')
call AssertException(['let v = py3eval("undefined_name")'],
\ "Vim(let):NameError: name 'undefined_name' is not defined")
call AssertException(['let v = py3eval("vim")'], 'E859:')
endfunc
" Test for py3eval with locals
func Test_python3_pyeval_locals()
let str = 'a string'
let num = 0xbadb33f
let d = {'a': 1, 'b': 2, 'c': str}
let l = [ str, num, d ]
let t = ( str, num, d )
let locals = #{
\ s: str,
\ n: num,
\ d: d,
\ l: l,
\ t: t,
\ }
" check basics
call assert_equal('a string', py3eval('s', locals))
call assert_equal(0xbadb33f, py3eval('n', locals))
call assert_equal(d, py3eval('d', locals))
call assert_equal(l, py3eval('l', locals))
call assert_equal(t, py3eval('t', locals))
call assert_equal('a,b,c', py3eval('b",".join(l)', {'l': ['a', 'b', 'c']}))
call assert_equal('hello', 's'->py3eval({'s': 'hello'}))
call assert_equal('a,b,c', 'b",".join(l)'->py3eval({'l': ['a', 'b', 'c']}))
call assert_equal('a-b-c', 'b"-".join(t)'->py3eval({'t': ('a', 'b', 'c')}))
py3 << trim EOF
def __UpdateDict(d, upd):
d.update(upd)
return d
def __ExtendList(l, *args):
l.extend(*args)
return l
EOF
" check assign to dict member works like bindeval
call assert_equal(3, py3eval('__UpdateDict( d, {"c": 3} )["c"]', locals))
call assert_equal(3, d['c'])
" check append lo list
call assert_equal(4, py3eval('len(__ExtendList(l, ["new item"]))', locals))
call assert_equal("new item", l[-1])
" check calling a function
let StrLen = function('strlen')
call assert_equal(3, py3eval('f("abc")', {'f': StrLen}))
endfunc
" Test for vim.bindeval()
func Test_python3_vim_bindeval()
" Float
let f = 3.14
py3 f = vim.bindeval('f')
call assert_equal(3.14, py3eval('f'))
" Blob
let b = 0z12
py3 b = vim.bindeval('b')
call assert_equal("\x12", py3eval('b'))
" Bool
call assert_equal(1, py3eval("vim.bindeval('v:true')"))
call assert_equal(0, py3eval("vim.bindeval('v:false')"))
call assert_equal(v:none, py3eval("vim.bindeval('v:null')"))
call assert_equal(v:none, py3eval("vim.bindeval('v:none')"))
" channel/job
if has('channel')
call assert_equal(v:none, py3eval("vim.bindeval('test_null_channel()')"))
endif
if has('job')
call assert_equal(v:none, py3eval("vim.bindeval('test_null_job()')"))
endif
endfunc
" threading
" Running py3do command (Test_pydo) before this test, stops the python thread
" from running. So this test should be run before the pydo test
func Test_aaa_python3_threading()
let l = [0]
py3 l = vim.bindeval('l')
py3 << trim EOF
import threading
import time
class T(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
self.t = 0
self.running = True
def run(self):
while self.running:
self.t += 1
time.sleep(0.1)
t = T()
del T
t.start()
EOF
sleep 1
py3 t.running = False
py3 t.join()
" Check if the background thread is working. Count should be 10, but on a
" busy system (AppVeyor) it can be much lower.
py3 l[0] = t.t > 4
py3 del time
py3 del threading
py3 del t
call assert_equal([1], l)
endfunc
" settrace
func Test_python3_settrace()
let l = []
py3 l = vim.bindeval('l')
py3 << trim EOF
import sys
def traceit(frame, event, arg):
global l
if event == "line":
l += [frame.f_lineno]
return traceit
def trace_main():
for i in range(5):
pass
EOF
py3 sys.settrace(traceit)
py3 trace_main()
py3 sys.settrace(None)
py3 del traceit
py3 del trace_main
call assert_equal([1, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 1], l)
endfunc
" Slice
func Test_python3_list_slice()
py3 ll = vim.bindeval('[0, 1, 2, 3, 4, 5]')
py3 l = ll[:4]
call assert_equal([0, 1, 2, 3], py3eval('l'))
py3 l = ll[2:]
call assert_equal([2, 3, 4, 5], py3eval('l'))
py3 l = ll[:-4]
call assert_equal([0, 1], py3eval('l'))
py3 l = ll[-2:]
call assert_equal([4, 5], py3eval('l'))
py3 l = ll[2:4]
call assert_equal([2, 3], py3eval('l'))
py3 l = ll[4:2]
call assert_equal([], py3eval('l'))
py3 l = ll[-4:-2]
call assert_equal([2, 3], py3eval('l'))
py3 l = ll[-2:-4]
call assert_equal([], py3eval('l'))
py3 l = ll[:]
call assert_equal([0, 1, 2, 3, 4, 5], py3eval('l'))
py3 l = ll[0:6]
call assert_equal([0, 1, 2, 3, 4, 5], py3eval('l'))
py3 l = ll[-10:10]
call assert_equal([0, 1, 2, 3, 4, 5], py3eval('l'))
py3 l = ll[4:2:-1]
call assert_equal([4, 3], py3eval('l'))
py3 l = ll[::2]
call assert_equal([0, 2, 4], py3eval('l'))
py3 l = ll[4:2:1]
call assert_equal([], py3eval('l'))
" Error case: Use an invalid index
call AssertException(['py3 ll[-10] = 5'], 'Vim(py3):vim.error: internal error:')
" Use a step value of 0
call AssertException(['py3 ll[0:3:0] = [1, 2, 3]'],
\ 'Vim(py3):ValueError: slice step cannot be zero')
" Error case: Invalid slice type
call AssertException(["py3 x = ll['abc']"],
\ "Vim(py3):TypeError: index must be int or slice, not str")
py3 del l
" Error case: List with a null list item
let l = [test_null_list()]
py3 ll = vim.bindeval('l')
call AssertException(["py3 x = ll[:]"],
\ s:system_error_pat)
endfunc
" Slice
func Test_python3_tuple_slice()
py3 tt = vim.bindeval('(0, 1, 2, 3, 4, 5)')
py3 t = tt[:4]
call assert_equal((0, 1, 2, 3), py3eval('t'))
py3 t = tt[2:]
call assert_equal((2, 3, 4, 5), py3eval('t'))
py3 t = tt[:-4]
call assert_equal((0, 1), py3eval('t'))
py3 t = tt[-2:]
call assert_equal((4, 5), py3eval('t'))
py3 t = tt[2:4]
call assert_equal((2, 3), py3eval('t'))
py3 t = tt[4:2]
call assert_equal((), py3eval('t'))
py3 t = tt[-4:-2]
call assert_equal((2, 3), py3eval('t'))
py3 t = tt[-2:-4]
call assert_equal((), py3eval('t'))
py3 t = tt[:]
call assert_equal((0, 1, 2, 3, 4, 5), py3eval('t'))
py3 t = tt[0:6]
call assert_equal((0, 1, 2, 3, 4, 5), py3eval('t'))
py3 t = tt[-10:10]
call assert_equal((0, 1, 2, 3, 4, 5), py3eval('t'))
py3 t = tt[4:2:-1]
call assert_equal((4, 3), py3eval('t'))
py3 t = tt[::2]
call assert_equal((0, 2, 4), py3eval('t'))
py3 t = tt[4:2:1]
call assert_equal((), py3eval('t'))
" Error case: Use an invalid index
call AssertException(['py3 x = tt[-10]'], 'Vim(py3):IndexError: tuple index out of range')
" Use a step value of 0
call AssertException(['py3 x = tt[0:3:0]'],
\ 'Vim(py3):ValueError: slice step cannot be zero')
" Error case: Invalid slice type
call AssertException(["py3 x = tt['abc']"],
\ "Vim(py3):TypeError: index must be int or slice, not str")
" Error case: List with a null tuple item
let t = (test_null_tuple(),)
py3 tt = vim.bindeval('t')
call AssertException(["py3 x = tt[:]"], s:system_error_pat)
endfunc
func Test_python3_pytuple_to_vimtuple()
let t = py3eval("('a', 'b')")
call assert_equal(('a', 'b'), t)
let t = py3eval("()")
call assert_equal((), t)
let t = py3eval("('x',)")
call assert_equal(('x',), t)
let t = py3eval("((1, 2), (), (3, 4))")
call assert_equal(((1, 2), (), (3, 4)), t)
let t = py3eval("((1, 2), {'a': 10}, [5, 6])")
call assert_equal(((1, 2), {'a': 10}, [5, 6]), t)
" Invalid python tuple
py3 << trim END
class FailingIter(object):
def __iter__(self):
raise NotImplementedError('iter')
END
call assert_fails('call py3eval("(1, FailingIter, 2)")',
\ 'E859: Failed to convert returned python object to a Vim value')
py3 del FailingIter
endfunc
" Test for tuple garbage collection
func Test_python3_tuple_garbage_collect()
let t = (1, (2, 3), [4, 5], {'a': 6})
py3 py_t = vim.bindeval('t')
let save_testing = v:testing
let v:testing = 1
call test_garbagecollect_now()
let v:testing = save_testing
let new_t = py3eval('py_t')
call assert_equal((1, (2, 3), [4, 5], {'a': 6}), new_t)
endfunc
" Vars
func Test_python3_vars()
let g:foo = 'bac'
let w:abc3 = 'def'
let b:baz = 'bar'
let t:bar = 'jkl'
try
throw "Abc"
catch /Abc/
call assert_equal('Abc', py3eval('vim.vvars[''exception'']'))
endtry
call assert_equal('bac', py3eval('vim.vars[''foo'']'))
call assert_equal('def', py3eval('vim.current.window.vars[''abc3'']'))
call assert_equal('bar', py3eval('vim.current.buffer.vars[''baz'']'))
call assert_equal('jkl', py3eval('vim.current.tabpage.vars[''bar'']'))
endfunc
" Options
" paste: boolean, global
" previewheight number, global
" operatorfunc: string, global
" number: boolean, window-local
" numberwidth: number, window-local
" colorcolumn: string, window-local
" statusline: string, window-local/global
" autoindent: boolean, buffer-local
" shiftwidth: number, buffer-local
" omnifunc: string, buffer-local
" preserveindent: boolean, buffer-local/global
" path: string, buffer-local/global
func Test_python3_opts()
let g:res = []
let g:bufs = [bufnr('%')]
new
let g:bufs += [bufnr('%')]
vnew
let g:bufs += [bufnr('%')]
wincmd j
vnew
let g:bufs += [bufnr('%')]
wincmd l
func RecVars(opt)
let gval = string(eval('&g:' .. a:opt))
let wvals = join(map(range(1, 4),
\ 'v:val .. ":" .. string(getwinvar(v:val, "&" .. a:opt))'))
let bvals = join(map(copy(g:bufs),
\ 'v:val .. ":" .. string(getbufvar(v:val, "&" .. a:opt))'))
call add(g:res, ' G: ' .. gval)
call add(g:res, ' W: ' .. wvals)
call add(g:res, ' B: ' .. wvals)
endfunc
py3 << trim EOF
def e(s, g=globals(), l=locals()):
try:
exec(s, g, l)
except Exception as e:
vim.command('return ' + repr(e.__class__.__name__))
def ev(s, g=globals(), l=locals()):
try:
return eval(s, g, l)
except Exception as e:
vim.command('let exc=' + repr(e.__class__.__name__))
return 0
EOF
func E(s)
python3 e(vim.eval('a:s'))
endfunc
func Ev(s)
let r = py3eval('ev(vim.eval("a:s"))')
if exists('exc')
throw exc
endif
return r
endfunc
py3 gopts1 = vim.options
py3 wopts1 = vim.windows[2].options
py3 wopts2 = vim.windows[0].options
py3 wopts3 = vim.windows[1].options
py3 bopts1 = vim.buffers[vim.bindeval("g:bufs")[2]].options
py3 bopts2 = vim.buffers[vim.bindeval("g:bufs")[1]].options
py3 bopts3 = vim.buffers[vim.bindeval("g:bufs")[0]].options
call add(g:res, 'wopts iters equal: ' ..
\ py3eval('list(wopts1) == list(wopts2)'))
call add(g:res, 'bopts iters equal: ' ..
\ py3eval('list(bopts1) == list(bopts2)'))
py3 gset = set(iter(gopts1))
py3 wset = set(iter(wopts1))
py3 bset = set(iter(bopts1))
set path=.,..,,
let lst = []
let lst += [['paste', 1, 0, 1, 2, 1, 1, 0]]
let lst += [['previewheight', 5, 1, 6, 'a', 0, 1, 0]]
let lst += [['operatorfunc', 'A', 'B', 'C', 2, 0, 1, 0]]
let lst += [['number', 0, 1, 1, 0, 1, 0, 1]]
let lst += [['numberwidth', 2, 3, 5, -100, 0, 0, 1]]
let lst += [['colorcolumn', '+1', '+2', '+3', 'abc4', 0, 0, 1]]
let lst += [['statusline', '1', '2', '4', 0, 0, 1, 1]]
let lst += [['autoindent', 0, 1, 1, 2, 1, 0, 2]]
let lst += [['shiftwidth', 0, 2, 1, 3, 0, 0, 2]]
let lst += [['omnifunc', 'A', 'B', 'C', 1, 0, 0, 2]]
let lst += [['preserveindent', 0, 1, 1, 2, 1, 1, 2]]
let lst += [['path', '.,,', ',,', '.', 0, 0, 1, 2]]
for [oname, oval1, oval2, oval3, invval, bool, global, local] in lst
py3 oname = vim.eval('oname')
py3 oval1 = vim.bindeval('oval1')
py3 oval2 = vim.bindeval('oval2')
py3 oval3 = vim.bindeval('oval3')
if invval is 0 || invval is 1
py3 invval = bool(vim.bindeval('invval'))
else
py3 invval = vim.bindeval('invval')
endif
if bool
py3 oval1 = bool(oval1)
py3 oval2 = bool(oval2)
py3 oval3 = bool(oval3)
endif
call add(g:res, '>>> ' .. oname)
call add(g:res, ' g/w/b:' .. py3eval('oname in gset') .. '/' ..
\ py3eval('oname in wset') .. '/' .. py3eval('oname in bset'))
call add(g:res, ' g/w/b (in):' .. py3eval('oname in gopts1') .. '/' ..
\ py3eval('oname in wopts1') .. '/' .. py3eval('oname in bopts1'))
for v in ['gopts1', 'wopts1', 'bopts1']
try
call add(g:res, ' p/' .. v .. ': ' .. Ev('repr(' .. v .. '[''' .. oname .. '''])'))
catch
call add(g:res, ' p/' .. v .. '! ' .. v:exception)
endtry
let r = E(v .. '[''' .. oname .. ''']=invval')
if r isnot 0
call add(g:res, ' inv: ' .. string(invval) .. '! ' .. r)
endif
for vv in (v is# 'gopts1' ? [v] : [v, v[:-2] .. '2', v[:-2] .. '3'])
let val = substitute(vv, '^.opts', 'oval', '')
let r = E(vv .. '[''' .. oname .. ''']=' .. val)
if r isnot 0
call add(g:res, ' ' .. vv .. '! ' .. r)
endif
endfor
endfor
call RecVars(oname)
for v in ['wopts3', 'bopts3']
let r = E('del ' .. v .. '["' .. oname .. '"]')
if r isnot 0
call add(g:res, ' del ' .. v .. '! ' .. r)
endif
endfor
call RecVars(oname)
endfor
delfunction RecVars
delfunction E
delfunction Ev
py3 del ev
py3 del e
only
for buf in g:bufs[1:]
execute 'bwipeout!' buf
endfor
py3 del gopts1
py3 del wopts1
py3 del wopts2
py3 del wopts3
py3 del bopts1
py3 del bopts2
py3 del bopts3
py3 del oval1
py3 del oval2
py3 del oval3
py3 del oname
py3 del invval
let expected =<< trim END
wopts iters equal: 1
bopts iters equal: 1
>>> paste
g/w/b:1/0/0
g/w/b (in):1/0/0
p/gopts1: False
p/wopts1! KeyError
inv: 2! KeyError
wopts1! KeyError
wopts2! KeyError
wopts3! KeyError
p/bopts1! KeyError
inv: 2! KeyError
bopts1! KeyError
bopts2! KeyError
bopts3! KeyError
G: 1
W: 1:1 2:1 3:1 4:1
B: 1:1 2:1 3:1 4:1
del wopts3! KeyError
del bopts3! KeyError
G: 1
W: 1:1 2:1 3:1 4:1
B: 1:1 2:1 3:1 4:1
>>> previewheight
g/w/b:1/0/0
g/w/b (in):1/0/0
p/gopts1: 12
inv: 'a'! TypeError
p/wopts1! KeyError
inv: 'a'! KeyError
wopts1! KeyError
wopts2! KeyError
wopts3! KeyError
p/bopts1! KeyError
inv: 'a'! KeyError
bopts1! KeyError
bopts2! KeyError
bopts3! KeyError
G: 5
W: 1:5 2:5 3:5 4:5
B: 1:5 2:5 3:5 4:5
del wopts3! KeyError
del bopts3! KeyError
G: 5
W: 1:5 2:5 3:5 4:5
B: 1:5 2:5 3:5 4:5
>>> operatorfunc
g/w/b:1/0/0
g/w/b (in):1/0/0
p/gopts1: b''
inv: 2! TypeError
p/wopts1! KeyError
inv: 2! KeyError
wopts1! KeyError
wopts2! KeyError
wopts3! KeyError
p/bopts1! KeyError
inv: 2! KeyError
bopts1! KeyError
bopts2! KeyError
bopts3! KeyError
G: 'A'
W: 1:'A' 2:'A' 3:'A' 4:'A'
B: 1:'A' 2:'A' 3:'A' 4:'A'
del wopts3! KeyError
del bopts3! KeyError
G: 'A'
W: 1:'A' 2:'A' 3:'A' 4:'A'
B: 1:'A' 2:'A' 3:'A' 4:'A'
>>> number
g/w/b:0/1/0
g/w/b (in):0/1/0
p/gopts1! KeyError
inv: 0! KeyError
gopts1! KeyError
p/wopts1: False
p/bopts1! KeyError
inv: 0! KeyError
bopts1! KeyError
bopts2! KeyError
bopts3! KeyError
G: 0
W: 1:1 2:1 3:0 4:0
B: 1:1 2:1 3:0 4:0
del wopts3! ValueError
del bopts3! KeyError
G: 0
W: 1:1 2:1 3:0 4:0
B: 1:1 2:1 3:0 4:0
>>> numberwidth
g/w/b:0/1/0
g/w/b (in):0/1/0
p/gopts1! KeyError
inv: -100! KeyError
gopts1! KeyError
p/wopts1: 4
inv: -100! error
p/bopts1! KeyError
inv: -100! KeyError
bopts1! KeyError
bopts2! KeyError
bopts3! KeyError
G: 4
W: 1:3 2:5 3:2 4:4
B: 1:3 2:5 3:2 4:4
del wopts3! ValueError
del bopts3! KeyError
G: 4
W: 1:3 2:5 3:2 4:4
B: 1:3 2:5 3:2 4:4
>>> colorcolumn
g/w/b:0/1/0
g/w/b (in):0/1/0
p/gopts1! KeyError
inv: 'abc4'! KeyError
gopts1! KeyError
p/wopts1: b''
inv: 'abc4'! error
p/bopts1! KeyError
inv: 'abc4'! KeyError
bopts1! KeyError
bopts2! KeyError
bopts3! KeyError
G: ''
W: 1:'+2' 2:'+3' 3:'+1' 4:''
B: 1:'+2' 2:'+3' 3:'+1' 4:''
del wopts3! ValueError
del bopts3! KeyError
G: ''
W: 1:'+2' 2:'+3' 3:'+1' 4:''
B: 1:'+2' 2:'+3' 3:'+1' 4:''
>>> statusline
g/w/b:1/1/0
g/w/b (in):1/1/0
p/gopts1: b''
inv: 0! TypeError
p/wopts1: None
inv: 0! TypeError
p/bopts1! KeyError
inv: 0! KeyError
bopts1! KeyError
bopts2! KeyError
bopts3! KeyError
G: '1'
W: 1:'2' 2:'4' 3:'1' 4:'1'
B: 1:'2' 2:'4' 3:'1' 4:'1'
del bopts3! KeyError
G: '1'
W: 1:'2' 2:'1' 3:'1' 4:'1'
B: 1:'2' 2:'1' 3:'1' 4:'1'
>>> autoindent
g/w/b:0/0/1
g/w/b (in):0/0/1
p/gopts1! KeyError
inv: 2! KeyError
gopts1! KeyError
p/wopts1! KeyError
inv: 2! KeyError
wopts1! KeyError
wopts2! KeyError
wopts3! KeyError
p/bopts1: False
G: 0
W: 1:0 2:1 3:0 4:1
B: 1:0 2:1 3:0 4:1
del wopts3! KeyError
del bopts3! ValueError
G: 0
W: 1:0 2:1 3:0 4:1
B: 1:0 2:1 3:0 4:1
>>> shiftwidth
g/w/b:0/0/1
g/w/b (in):0/0/1
p/gopts1! KeyError
inv: 3! KeyError
gopts1! KeyError
p/wopts1! KeyError
inv: 3! KeyError
wopts1! KeyError
wopts2! KeyError
wopts3! KeyError
p/bopts1: 8
G: 8
W: 1:0 2:2 3:8 4:1
B: 1:0 2:2 3:8 4:1
del wopts3! KeyError
del bopts3! ValueError
G: 8
W: 1:0 2:2 3:8 4:1
B: 1:0 2:2 3:8 4:1
>>> omnifunc
g/w/b:0/0/1
g/w/b (in):0/0/1
p/gopts1! KeyError
inv: 1! KeyError
gopts1! KeyError
p/wopts1! KeyError
inv: 1! KeyError
wopts1! KeyError
wopts2! KeyError
wopts3! KeyError
p/bopts1: b''
inv: 1! TypeError
G: ''
W: 1:'A' 2:'B' 3:'' 4:'C'
B: 1:'A' 2:'B' 3:'' 4:'C'
del wopts3! KeyError
del bopts3! ValueError
G: ''
W: 1:'A' 2:'B' 3:'' 4:'C'
B: 1:'A' 2:'B' 3:'' 4:'C'
>>> preserveindent
g/w/b:0/0/1
g/w/b (in):0/0/1
p/gopts1! KeyError
inv: 2! KeyError
gopts1! KeyError
p/wopts1! KeyError
inv: 2! KeyError
wopts1! KeyError
wopts2! KeyError
wopts3! KeyError
p/bopts1: False
G: 0
W: 1:0 2:1 3:0 4:1
B: 1:0 2:1 3:0 4:1
del wopts3! KeyError
del bopts3! ValueError
G: 0
W: 1:0 2:1 3:0 4:1
B: 1:0 2:1 3:0 4:1
>>> path
g/w/b:1/0/1
g/w/b (in):1/0/1
p/gopts1: b'.,..,,'
inv: 0! TypeError
p/wopts1! KeyError
inv: 0! KeyError
wopts1! KeyError
wopts2! KeyError
wopts3! KeyError
p/bopts1: None
inv: 0! TypeError
G: '.,,'
W: 1:'.,,' 2:',,' 3:'.,,' 4:'.'
B: 1:'.,,' 2:',,' 3:'.,,' 4:'.'
del wopts3! KeyError
G: '.,,'
W: 1:'.,,' 2:',,' 3:'.,,' 4:'.,,'
B: 1:'.,,' 2:',,' 3:'.,,' 4:'.,,'
END
call assert_equal(expected, g:res)
unlet g:res
call assert_equal(0, py3eval("'' in vim.options"))
" use an empty key to index vim.options
call AssertException(["let v = py3eval(\"vim.options['']\")"],
\ 'Vim(let):ValueError: empty keys are not allowed')
call AssertException(["py3 vim.current.window.options[''] = 0"],
\ 'Vim(py3):ValueError: empty keys are not allowed')
call AssertException(["py3 vim.current.window.options[{}] = 0"],
\ 'Vim(py3):TypeError: expected bytes() or str() instance, but got dict')
" set one of the number options to a very large number
let cmd = ["py3 vim.options['previewheight'] = 9999999999999999"]
call AssertException(cmd, "Vim(py3):OverflowError:")
" unset a global-local string option
call AssertException(["py3 del vim.options['errorformat']"],
\ 'Vim(py3):ValueError: unable to unset global option errorformat')
endfunc
" Test for vim.buffer object
func Test_python3_buffer()
new
call setline(1, "Hello\nWorld")
call assert_fails("let x = py3eval('vim.current.buffer[0]')", 'E859:')
%bw!
edit Xfile1
let bnr1 = bufnr()
py3 cb = vim.current.buffer
vnew Xfile2
let bnr2 = bufnr()
call setline(1, ['First line', 'Second line', 'Third line'])
py3 b = vim.current.buffer
wincmd w
" Test for getting lines from the buffer using a slice
call assert_equal(['First line'], py3eval('b[-10:1]'))
call assert_equal(['Third line'], py3eval('b[2:10]'))
call assert_equal([], py3eval('b[2:0]'))
call assert_equal([], py3eval('b[10:12]'))
call assert_equal([], py3eval('b[-10:-8]'))
call AssertException(["py3 x = b[0:3:0]"],
\ 'Vim(py3):ValueError: slice step cannot be zero')
call AssertException(["py3 b[0:3:0] = 'abc'"],
\ 'Vim(py3):ValueError: slice step cannot be zero')
call AssertException(["py3 x = b[{}]"],
\ 'Vim(py3):TypeError: index must be int or slice, not dict')
call AssertException(["py3 b[{}] = 'abc'"],
\ 'Vim(py3):TypeError: index must be int or slice, not dict')
" Test for getting lines using a range
call AssertException(["py3 x = b.range(0,3)[0:2:0]"],
\ "Vim(py3):ValueError: slice step cannot be zero")
call AssertException(["py3 b.range(0,3)[0:2:0] = 'abc'"],
\ "Vim(py3):ValueError: slice step cannot be zero")
" Tests BufferAppend and BufferItem
py3 cb.append(b[0])
call assert_equal(['First line'], getbufline(bnr1, 2))
%d
" Try to append using out-of-range line number
call AssertException(["py3 b.append('abc', 10)"],
\ 'Vim(py3):IndexError: line number out of range')
" Append a non-string item
call AssertException(["py3 b.append([22])"],
\ 'Vim(py3):TypeError: expected bytes() or str() instance, but got int')
" Tests BufferSlice and BufferAssSlice
py3 cb.append('abc5') # Will be overwritten
py3 cb[-1:] = b[:-2]
call assert_equal(['First line'], getbufline(bnr1, 2))
%d
" Test BufferLength and BufferAssSlice
py3 cb.append('def') # Will not be overwritten
py3 cb[len(cb):] = b[:]
call assert_equal(['def', 'First line', 'Second line', 'Third line'],
\ getbufline(bnr1, 2, '$'))
%d
" Test BufferAssItem and BufferMark
call setbufline(bnr1, 1, ['one', 'two', 'three'])
call cursor(1, 3)
normal ma
py3 cb.append('ghi') # Will be overwritten
py3 cb[-1] = repr((len(cb) - cb.mark('a')[0], cb.mark('a')[1]))
call assert_equal(['(3, 2)'], getbufline(bnr1, 4))
%d
" Test BufferRepr
py3 cb.append(repr(cb) + repr(b))
call assert_equal(['<buffer Xfile1><buffer Xfile2>'], getbufline(bnr1, 2))
%d
" Modify foreign buffer
py3 << trim EOF
b.append('foo')
b[0]='bar'
b[0:0]=['baz']
vim.command('call append("$", getbufline(%i, 1, "$"))' % b.number)
EOF
call assert_equal(['baz', 'bar', 'Second line', 'Third line', 'foo'],
\ getbufline(bnr2, 1, '$'))
%d
" Test assigning to name property
augroup BUFS
autocmd BufFilePost * python3 cb.append(vim.eval('expand("<abuf>")') + ':BufFilePost:' + vim.eval('bufnr("%")'))
autocmd BufFilePre * python3 cb.append(vim.eval('expand("<abuf>")') + ':BufFilePre:' + vim.eval('bufnr("%")'))
augroup END
py3 << trim EOF
import os
old_name = cb.name
cb.name = 'foo'
cb.append(cb.name[-11:].replace(os.path.sep, '/'))
b.name = 'bar'
cb.append(b.name[-11:].replace(os.path.sep, '/'))
cb.name = old_name
cb.append(cb.name[-14:].replace(os.path.sep, '/'))
del old_name
EOF
call assert_equal([bnr1 .. ':BufFilePre:' .. bnr1,
\ bnr1 .. ':BufFilePost:' .. bnr1,
\ 'testdir/foo',
\ bnr2 .. ':BufFilePre:' .. bnr2,
\ bnr2 .. ':BufFilePost:' .. bnr2,
\ 'testdir/bar',
\ bnr1 .. ':BufFilePre:' .. bnr1,
\ bnr1 .. ':BufFilePost:' .. bnr1,
\ 'testdir/Xfile1'], getbufline(bnr1, 2, '$'))
%d
" Test CheckBuffer
py3 << trim EOF
for _b in vim.buffers:
if _b is not cb:
vim.command('bwipeout! ' + str(_b.number))
del _b
cb.append('valid: b:%s, cb:%s' % (repr(b.valid), repr(cb.valid)))
EOF
call assert_equal('valid: b:False, cb:True', getline(2))
%d
py3 << trim EOF
for expr in ('b[1]','b[:] = ["A", "B"]','b[:]','b.append("abc6")'):
try:
exec(expr)
except vim.error:
pass
else:
# Usually a SEGV here
# Should not happen in any case
cb.append('No exception for ' + expr)
vim.command('cd .')
del b
EOF
call assert_equal([''], getline(1, '$'))
" Delete all the lines in a buffer
call setline(1, ['a', 'b', 'c'])
py3 vim.current.buffer[:] = []
call assert_equal([''], getline(1, '$'))
" Test for buffer marks
call assert_equal(v:none, py3eval("vim.current.buffer.mark('r')"))
" Test for modifying a 'nomodifiable' buffer
setlocal nomodifiable
call AssertException(["py3 vim.current.buffer[0] = 'abc'"],
\ "Vim(py3):vim.error: Vim:E21: Cannot make changes, 'modifiable' is off")
call AssertException(["py3 vim.current.buffer[0] = None"],
\ "Vim(py3):vim.error: Vim:E21: Cannot make changes, 'modifiable' is off")
call AssertException(["py3 vim.current.buffer[:] = None"],
\ "Vim(py3):vim.error: Vim:E21: Cannot make changes, 'modifiable' is off")
call AssertException(["py3 vim.current.buffer[:] = []"],
\ "Vim(py3):vim.error: Vim:E21: Cannot make changes, 'modifiable' is off")
call AssertException(["py3 vim.current.buffer.append('abc')"],
\ "Vim(py3):vim.error: Vim:E21: Cannot make changes, 'modifiable' is off")
call AssertException(["py3 vim.current.buffer.append([])"],
\ "Vim(py3):vim.error: Vim:E21: Cannot make changes, 'modifiable' is off")
setlocal modifiable
augroup BUFS
autocmd!
augroup END
augroup! BUFS
%bw!
" Range object for a deleted buffer
new Xp3buffile
call setline(1, ['one', 'two', 'three'])
py3 b = vim.current.buffer
py3 r = vim.current.buffer.range(0, 2)
call assert_equal('<range Xp3buffile (0:2)>', py3eval('repr(r)'))
%bw!
call AssertException(['py3 r[:] = []'],
\ 'Vim(py3):vim.error: attempt to refer to deleted buffer')
call assert_match('<buffer object (deleted)', py3eval('repr(b)'))
call assert_match('<range object (for deleted buffer)', py3eval('repr(r)'))
call AssertException(["let n = py3eval('len(r)')"],
\ 'Vim(let):vim.error: attempt to refer to deleted buffer')
call AssertException(["py3 r.append('abc')"],
\ 'Vim(py3):vim.error: attempt to refer to deleted buffer')
" object for a deleted buffer
call AssertException(["py3 b[0] = 'one'"],
\ 'Vim(py3):vim.error: attempt to refer to deleted buffer')
call AssertException(["py3 b.append('one')"],
\ 'Vim(py3):vim.error: attempt to refer to deleted buffer')
call AssertException(["let n = py3eval('len(b)')"],
\ 'Vim(let):vim.error: attempt to refer to deleted buffer')
call AssertException(["py3 pos = b.mark('a')"],
\ 'Vim(py3):vim.error: attempt to refer to deleted buffer')
call AssertException(["py3 vim.current.buffer = b"],
\ 'Vim(py3):vim.error: attempt to refer to deleted buffer')
call AssertException(["py3 rn = b.range(0, 2)"],
\ 'Vim(py3):vim.error: attempt to refer to deleted buffer')
endfunc
" Test vim.buffers object
func Test_python3_buffers()
%bw!
edit Xp3buffile
py3 cb = vim.current.buffer
set hidden
edit a
buffer #
edit b
buffer #
edit c
buffer #
py3 << trim EOF
# Check GCing iterator that was not fully exhausted
i = iter(vim.buffers)
cb.append('i:' + str(next(i)))
# and also check creating more than one iterator at a time
i2 = iter(vim.buffers)
cb.append('i2:' + str(next(i2)))
cb.append('i:' + str(next(i)))
# The following should trigger GC and not cause any problems
del i
del i2
i3 = iter(vim.buffers)
cb.append('i3:' + str(next(i3)))
del i3
EOF
call assert_equal(['i:<buffer Xp3buffile>',
\ 'i2:<buffer Xp3buffile>', 'i:<buffer a>', 'i3:<buffer Xp3buffile>'],
\ getline(2, '$'))
%d
py3 << trim EOF
prevnum = 0
for b in vim.buffers:
# Check buffer order
if prevnum >= b.number:
cb.append('!!! Buffer numbers not in strictly ascending order')
# Check indexing: vim.buffers[number].number == number
cb.append(str(b.number) + ':' + repr(vim.buffers[b.number]) + \
'=' + repr(b))
prevnum = b.number
del prevnum
cb.append(str(len(vim.buffers)))
EOF
call assert_equal([bufnr('Xp3buffile') .. ':<buffer Xp3buffile>=<buffer Xp3buffile>',
\ bufnr('a') .. ':<buffer a>=<buffer a>',
\ bufnr('b') .. ':<buffer b>=<buffer b>',
\ bufnr('c') .. ':<buffer c>=<buffer c>', '4'], getline(2, '$'))
%d
py3 << trim EOF
bnums = list(map(lambda b: b.number, vim.buffers))[1:]
# Test wiping out buffer with existing iterator
i4 = iter(vim.buffers)
cb.append('i4:' + str(next(i4)))
vim.command('bwipeout! ' + str(bnums.pop(0)))
try:
next(i4)
except vim.error:
pass
else:
cb.append('!!!! No vim.error')
i4 = iter(vim.buffers)
vim.command('bwipeout! ' + str(bnums.pop(-1)))
vim.command('bwipeout! ' + str(bnums.pop(-1)))
cb.append('i4:' + str(next(i4)))
try:
next(i4)
except StopIteration:
cb.append('StopIteration')
del i4
del bnums
EOF
call assert_equal(['i4:<buffer Xp3buffile>',
\ 'i4:<buffer Xp3buffile>', 'StopIteration'], getline(2, '$'))
%bw!
endfunc
" Test vim.{tabpage,window}list and vim.{tabpage,window} objects
func Test_python3_tabpage_window()
%bw
edit Xp3buffile
py3 cb = vim.current.buffer
tabnew 0
tabnew 1
vnew a.1
tabnew 2
vnew a.2
vnew b.2
vnew c.2
py3 << trim EOF
cb.append('Number of tabs: ' + str(len(vim.tabpages)))
cb.append('Current tab pages:')
def W(w):
if '(unknown)' in repr(w):
return '<window object (unknown)>'
else:
return repr(w)
def Cursor(w, start=len(cb)):
if w.buffer is cb:
return repr((start - w.cursor[0], w.cursor[1]))
else:
return repr(w.cursor)
for t in vim.tabpages:
cb.append(' ' + repr(t) + '(' + str(t.number) + ')' + ': ' + \
str(len(t.windows)) + ' windows, current is ' + W(t.window))
cb.append(' Windows:')
for w in t.windows:
cb.append(' ' + W(w) + '(' + str(w.number) + ')' + \
': displays buffer ' + repr(w.buffer) + \
'; cursor is at ' + Cursor(w))
# Other values depend on the size of the terminal, so they are checked
# partly:
for attr in ('height', 'row', 'width', 'col'):
try:
aval = getattr(w, attr)
if type(aval) is not int:
raise TypeError
if aval < 0:
raise ValueError
except Exception as e:
cb.append('!!!!!! Error while getting attribute ' + attr + \
': ' + e.__class__.__name__)
del aval
del attr
w.cursor = (len(w.buffer), 0)
del W
del Cursor
cb.append('Number of windows in current tab page: ' + \
str(len(vim.windows)))
if list(vim.windows) != list(vim.current.tabpage.windows):
cb.append('!!!!!! Windows differ')
EOF
let expected =<< trim END
Number of tabs: 4
Current tab pages:
<tabpage 0>(1): 1 windows, current is <window object (unknown)>
Windows:
<window object (unknown)>(1): displays buffer <buffer Xp3buffile>; cursor is at (2, 0)
<tabpage 1>(2): 1 windows, current is <window object (unknown)>
Windows:
<window object (unknown)>(1): displays buffer <buffer 0>; cursor is at (1, 0)
<tabpage 2>(3): 2 windows, current is <window object (unknown)>
Windows:
<window object (unknown)>(1): displays buffer <buffer a.1>; cursor is at (1, 0)
<window object (unknown)>(2): displays buffer <buffer 1>; cursor is at (1, 0)
<tabpage 3>(4): 4 windows, current is <window 0>
Windows:
<window 0>(1): displays buffer <buffer c.2>; cursor is at (1, 0)
<window 1>(2): displays buffer <buffer b.2>; cursor is at (1, 0)
<window 2>(3): displays buffer <buffer a.2>; cursor is at (1, 0)
<window 3>(4): displays buffer <buffer 2>; cursor is at (1, 0)
Number of windows in current tab page: 4
END
call assert_equal(expected, getbufline(bufnr('Xp3buffile'), 2, '$'))
%bw!
endfunc
" Test vim.current
func Test_python3_vim_current()
%bw
edit Xpy3cfile
py3 cb = vim.current.buffer
tabnew 0
tabnew 1
vnew a.1
tabnew 2
vnew a.2
vnew b.2
vnew c.2
py3 << trim EOF
def H(o):
return repr(o)
cb.append('Current tab page: ' + repr(vim.current.tabpage))
cb.append('Current window: ' + repr(vim.current.window) + ': ' + \
H(vim.current.window) + ' is ' + H(vim.current.tabpage.window))
cb.append('Current buffer: ' + repr(vim.current.buffer) + ': ' + \
H(vim.current.buffer) + ' is ' + H(vim.current.window.buffer)+ \
' is ' + H(vim.current.tabpage.window.buffer))
del H
EOF
let expected =<< trim END
Current tab page: <tabpage 3>
Current window: <window 0>: <window 0> is <window 0>
Current buffer: <buffer c.2>: <buffer c.2> is <buffer c.2> is <buffer c.2>
END
call assert_equal(expected, getbufline(bufnr('Xpy3cfile'), 2, '$'))
call deletebufline(bufnr('Xpy3cfile'), 1, '$')
" Assigning: fails
py3 << trim EOF
try:
vim.current.window = vim.tabpages[0].window
except ValueError:
cb.append('ValueError at assigning foreign tab window')
for attr in ('window', 'tabpage', 'buffer'):
try:
setattr(vim.current, attr, None)
except TypeError:
cb.append('Type error at assigning None to vim.current.' + attr)
del attr
EOF
let expected =<< trim END
ValueError at assigning foreign tab window
Type error at assigning None to vim.current.window
Type error at assigning None to vim.current.tabpage
Type error at assigning None to vim.current.buffer
END
call assert_equal(expected, getbufline(bufnr('Xpy3cfile'), 2, '$'))
call deletebufline(bufnr('Xpy3cfile'), 1, '$')
call setbufline(bufnr('Xpy3cfile'), 1, 'python interface')
py3 << trim EOF
# Assigning: success
vim.current.tabpage = vim.tabpages[-2]
vim.current.buffer = cb
vim.current.window = vim.windows[0]
vim.current.window.cursor = (len(vim.current.buffer), 0)
cb.append('Current tab page: ' + repr(vim.current.tabpage))
cb.append('Current window: ' + repr(vim.current.window))
cb.append('Current buffer: ' + repr(vim.current.buffer))
cb.append('Current line: ' + repr(vim.current.line))
EOF
let expected =<< trim END
Current tab page: <tabpage 2>
Current window: <window 0>
Current buffer: <buffer Xpy3cfile>
Current line: 'python interface'
END
call assert_equal(expected, getbufline(bufnr('Xpy3cfile'), 2, '$'))
py3 vim.current.line = 'one line'
call assert_equal('one line', getline('.'))
call deletebufline(bufnr('Xpy3cfile'), 1, '$')
py3 << trim EOF
ws = list(vim.windows)
ts = list(vim.tabpages)
for b in vim.buffers:
if b is not cb:
vim.command('bwipeout! ' + str(b.number))
del b
cb.append('w.valid: ' + repr([w.valid for w in ws]))
cb.append('t.valid: ' + repr([t.valid for t in ts]))
del w
del t
del ts
del ws
EOF
let expected =<< trim END
w.valid: [True, False]
t.valid: [True, False, True, False]
END
call assert_equal(expected, getbufline(bufnr('Xpy3cfile'), 2, '$'))
%bw!
endfunc
" Test types
func Test_python3_types()
%d
py3 cb = vim.current.buffer
py3 << trim EOF
for expr, attr in (
('vim.vars', 'Dictionary'),
('vim.options', 'Options'),
('vim.bindeval("{}")', 'Dictionary'),
('vim.bindeval("[]")', 'List'),
('vim.bindeval("function(\'tr\')")', 'Function'),
('vim.current.buffer', 'Buffer'),
('vim.current.range', 'Range'),
('vim.current.window', 'Window'),
('vim.current.tabpage', 'TabPage'),
):
cb.append(expr + ':' + attr + ':' + \
repr(type(eval(expr)) is getattr(vim, attr)))
del expr
del attr
EOF
let expected =<< trim END
vim.vars:Dictionary:True
vim.options:Options:True
vim.bindeval("{}"):Dictionary:True
vim.bindeval("[]"):List:True
vim.bindeval("function('tr')"):Function:True
vim.current.buffer:Buffer:True
vim.current.range:Range:True
vim.current.window:Window:True
vim.current.tabpage:TabPage:True
END
call assert_equal(expected, getline(2, '$'))
endfunc
" Test __dir__() method
func Test_python3_dir_method()
%d
py3 cb = vim.current.buffer
py3 << trim EOF
for name, o in (
('current', vim.current),
('buffer', vim.current.buffer),
('window', vim.current.window),
('tabpage', vim.current.tabpage),
('range', vim.current.range),
('dictionary', vim.bindeval('{}')),
('list', vim.bindeval('[]')),
('tuple', vim.bindeval('()')),
('function', vim.bindeval('function("tr")')),
('output', sys.stdout),
):
cb.append(name + ':' + ','.join(dir(o)))
del name
del o
EOF
let expected =<< trim END
current:__dir__,buffer,line,range,tabpage,window
buffer:__dir__,append,mark,name,number,options,range,valid,vars
window:__dir__,buffer,col,cursor,height,number,options,row,tabpage,valid,vars,width
tabpage:__dir__,number,valid,vars,window,windows
range:__dir__,append,end,start
dictionary:__dir__,get,has_key,items,keys,locked,pop,popitem,scope,update,values
list:__dir__,extend,locked
tuple:__dir__,locked
function:__dir__,args,auto_rebind,self,softspace
output:__dir__,close,closed,flush,isatty,readable,seekable,softspace,writable,write,writelines
END
call assert_equal(expected, getline(2, '$'))
endfunc
" Test vim.*.__new__
func Test_python3_new()
call assert_equal({}, py3eval('vim.Dictionary({})'))
call assert_equal({'a': 1}, py3eval('vim.Dictionary(a=1)'))
call assert_equal({'a': 1}, py3eval('vim.Dictionary(((''a'', 1),))'))
call assert_equal([], py3eval('vim.List()'))
call assert_equal((), py3eval('vim.Tuple()'))
call assert_equal(['a', 'b', 'c', '7'], py3eval('vim.List(iter(''abc7''))'))
call assert_equal(('a', 'b', 'c', '7'), py3eval('vim.Tuple(iter(''abc7''))'))
call assert_equal(function('tr'), py3eval('vim.Function(''tr'')'))
call assert_equal(function('tr', [123, 3, 4]),
\ py3eval('vim.Function(''tr'', args=[123, 3, 4])'))
call assert_equal(function('tr'), py3eval('vim.Function(''tr'', args=[])'))
call assert_equal(function('tr', {}),
\ py3eval('vim.Function(''tr'', self={})'))
call assert_equal(function('tr', [123, 3, 4], {}),
\ py3eval('vim.Function(''tr'', args=[123, 3, 4], self={})'))
call assert_equal(function('tr'),
\ py3eval('vim.Function(''tr'', auto_rebind=False)'))
call assert_equal(function('tr', [123, 3, 4]),
\ py3eval('vim.Function(''tr'', args=[123, 3, 4], auto_rebind=False)'))
call assert_equal(function('tr'),
\ py3eval('vim.Function(''tr'', args=[], auto_rebind=False)'))
call assert_equal(function('tr', {}),
\ py3eval('vim.Function(''tr'', self={}, auto_rebind=False)'))
call assert_equal(function('tr', [123, 3, 4], {}),
\ py3eval('vim.Function(''tr'', args=[123, 3, 4], self={}, auto_rebind=False)'))
endfunc
" Test vim.Function
func Test_python3_vim_func()
func Args(...)
return a:000
endfunc
func SelfArgs(...) dict
return [a:000, self]
endfunc
" The following four lines should not crash
let Pt = function('tr', [[]], {'l': []})
py3 Pt = vim.bindeval('Pt')
unlet Pt
py3 del Pt
call assert_equal(3, py3eval('vim.strwidth("a\tb")'))
%bw!
py3 cb = vim.current.buffer
py3 << trim EOF
def ecall(out_prefix, func, *args, **kwargs):
line = out_prefix + ': '
try:
ret = func(*args, **kwargs)
except Exception:
line += '!exception: ' + emsg(sys.exc_info())
else:
line += '!result: ' + str(vim.Function('string')(ret), 'utf-8')
cb.append(line)
a = vim.Function('Args')
pa1 = vim.Function('Args', args=['abcArgsPA1'])
pa2 = vim.Function('Args', args=[])
pa3 = vim.Function('Args', args=['abcArgsPA3'], self={'abcSelfPA3': 'abcSelfPA3Val'})
pa4 = vim.Function('Args', self={'abcSelfPA4': 'abcSelfPA4Val'})
cb.append('a: ' + repr(a))
cb.append('pa1: ' + repr(pa1))
cb.append('pa2: ' + repr(pa2))
cb.append('pa3: ' + repr(pa3))
cb.append('pa4: ' + repr(pa4))
sa = vim.Function('SelfArgs')
psa1 = vim.Function('SelfArgs', args=['abcArgsPSA1'])
psa2 = vim.Function('SelfArgs', args=[])
psa3 = vim.Function('SelfArgs', args=['abcArgsPSA3'], self={'abcSelfPSA3': 'abcSelfPSA3Val'})
psa4 = vim.Function('SelfArgs', self={'abcSelfPSA4': 'abcSelfPSA4Val'})
psa5 = vim.Function('SelfArgs', self={'abcSelfPSA5': 'abcSelfPSA5Val'}, auto_rebind=0)
psa6 = vim.Function('SelfArgs', args=['abcArgsPSA6'], self={'abcSelfPSA6': 'abcSelfPSA6Val'}, auto_rebind=())
psa7 = vim.Function('SelfArgs', args=['abcArgsPSA7'], auto_rebind=[])
psa8 = vim.Function('SelfArgs', auto_rebind=False)
psa9 = vim.Function('SelfArgs', self={'abcSelfPSA9': 'abcSelfPSA9Val'}, auto_rebind=True)
psaA = vim.Function('SelfArgs', args=['abcArgsPSAA'], self={'abcSelfPSAA': 'abcSelfPSAAVal'}, auto_rebind=1)
psaB = vim.Function('SelfArgs', args=['abcArgsPSAB'], auto_rebind={'abcARPSAB': 'abcARPSABVal'})
psaC = vim.Function('SelfArgs', auto_rebind=['abcARPSAC'])
cb.append('sa: ' + repr(sa))
cb.append('psa1: ' + repr(psa1))
cb.append('psa2: ' + repr(psa2))
cb.append('psa3: ' + repr(psa3))
cb.append('psa4: ' + repr(psa4))
cb.append('psa5: ' + repr(psa5))
cb.append('psa6: ' + repr(psa6))
cb.append('psa7: ' + repr(psa7))
cb.append('psa8: ' + repr(psa8))
cb.append('psa9: ' + repr(psa9))
cb.append('psaA: ' + repr(psaA))
cb.append('psaB: ' + repr(psaB))
cb.append('psaC: ' + repr(psaC))
psar = vim.Function('SelfArgs', args=[{'abcArgsPSAr': 'abcArgsPSArVal'}], self={'abcSelfPSAr': 'abcSelfPSArVal'})
psar.args[0]['abcArgsPSAr2'] = [psar.self, psar.args[0]]
psar.self['rec'] = psar
psar.self['self'] = psar.self
psar.self['args'] = psar.args
try:
cb.append('psar: ' + repr(psar))
except Exception:
cb.append('!!!!!!!! Caught exception: ' + emsg(sys.exc_info()))
EOF
let expected =<< trim END
a: <vim.Function 'Args'>
pa1: <vim.Function 'Args', args=['abcArgsPA1']>
pa2: <vim.Function 'Args'>
pa3: <vim.Function 'Args', args=['abcArgsPA3'], self={'abcSelfPA3': 'abcSelfPA3Val'}>
pa4: <vim.Function 'Args', self={'abcSelfPA4': 'abcSelfPA4Val'}>
sa: <vim.Function 'SelfArgs'>
psa1: <vim.Function 'SelfArgs', args=['abcArgsPSA1']>
psa2: <vim.Function 'SelfArgs'>
psa3: <vim.Function 'SelfArgs', args=['abcArgsPSA3'], self={'abcSelfPSA3': 'abcSelfPSA3Val'}>
psa4: <vim.Function 'SelfArgs', self={'abcSelfPSA4': 'abcSelfPSA4Val'}>
psa5: <vim.Function 'SelfArgs', self={'abcSelfPSA5': 'abcSelfPSA5Val'}>
psa6: <vim.Function 'SelfArgs', args=['abcArgsPSA6'], self={'abcSelfPSA6': 'abcSelfPSA6Val'}>
psa7: <vim.Function 'SelfArgs', args=['abcArgsPSA7']>
psa8: <vim.Function 'SelfArgs'>
psa9: <vim.Function 'SelfArgs', self={'abcSelfPSA9': 'abcSelfPSA9Val'}, auto_rebind=True>
psaA: <vim.Function 'SelfArgs', args=['abcArgsPSAA'], self={'abcSelfPSAA': 'abcSelfPSAAVal'}, auto_rebind=True>
psaB: <vim.Function 'SelfArgs', args=['abcArgsPSAB']>
psaC: <vim.Function 'SelfArgs'>
psar: <vim.Function 'SelfArgs', args=[{'abcArgsPSAr2': [{'rec': function('SelfArgs', [{...}], {...}), 'self': {...}, 'abcSelfPSAr': 'abcSelfPSArVal', 'args': [{...}]}, {...}], 'abcArgsPSAr': 'abcArgsPSArVal'}], self={'rec': function('SelfArgs', [{'abcArgsPSAr2': [{...}, {...}], 'abcArgsPSAr': 'abcArgsPSArVal'}], {...}), 'self': {...}, 'abcSelfPSAr': 'abcSelfPSArVal', 'args': [{'abcArgsPSAr2': [{...}, {...}], 'abcArgsPSAr': 'abcArgsPSArVal'}]}>
END
call assert_equal(expected, getline(2, '$'))
%d
call assert_equal(function('Args'), py3eval('a'))
call assert_equal(function('Args', ['abcArgsPA1']), py3eval('pa1'))
call assert_equal(function('Args'), py3eval('pa2'))
call assert_equal(function('Args', ['abcArgsPA3'], {'abcSelfPA3': 'abcSelfPA3Val'}), py3eval('pa3'))
call assert_equal(function('Args', {'abcSelfPA4': 'abcSelfPA4Val'}), py3eval('pa4'))
call assert_equal(function('SelfArgs'), py3eval('sa'))
call assert_equal(function('SelfArgs', ['abcArgsPSA1']), py3eval('psa1'))
call assert_equal(function('SelfArgs'), py3eval('psa2'))
call assert_equal(function('SelfArgs', ['abcArgsPSA3'], {'abcSelfPSA3': 'abcSelfPSA3Val'}), py3eval('psa3'))
call assert_equal(function('SelfArgs', {'abcSelfPSA4': 'abcSelfPSA4Val'}), py3eval('psa4'))
call assert_equal(function('SelfArgs', {'abcSelfPSA5': 'abcSelfPSA5Val'}), py3eval('psa5'))
call assert_equal(function('SelfArgs', ['abcArgsPSA6'], {'abcSelfPSA6': 'abcSelfPSA6Val'}), py3eval('psa6'))
call assert_equal(function('SelfArgs', ['abcArgsPSA7']), py3eval('psa7'))
call assert_equal(function('SelfArgs'), py3eval('psa8'))
call assert_equal(function('SelfArgs', {'abcSelfPSA9': 'abcSelfPSA9Val'}), py3eval('psa9'))
call assert_equal(function('SelfArgs', ['abcArgsPSAA'], {'abcSelfPSAA': 'abcSelfPSAAVal'}), py3eval('psaA'))
call assert_equal(function('SelfArgs', ['abcArgsPSAB']), py3eval('psaB'))
call assert_equal(function('SelfArgs'), py3eval('psaC'))
let res = []
for v in ['sa', 'psa1', 'psa2', 'psa3', 'psa4', 'psa5', 'psa6', 'psa7',
\ 'psa8', 'psa9', 'psaA', 'psaB', 'psaC']
let d = {'f': py3eval(v)}
call add(res, 'd.' .. v .. '(): ' .. string(d.f()))
endfor
let expected =<< trim END
d.sa(): [[], {'f': function('SelfArgs')}]
d.psa1(): [['abcArgsPSA1'], {'f': function('SelfArgs', ['abcArgsPSA1'])}]
d.psa2(): [[], {'f': function('SelfArgs')}]
d.psa3(): [['abcArgsPSA3'], {'abcSelfPSA3': 'abcSelfPSA3Val'}]
d.psa4(): [[], {'abcSelfPSA4': 'abcSelfPSA4Val'}]
d.psa5(): [[], {'abcSelfPSA5': 'abcSelfPSA5Val'}]
d.psa6(): [['abcArgsPSA6'], {'abcSelfPSA6': 'abcSelfPSA6Val'}]
d.psa7(): [['abcArgsPSA7'], {'f': function('SelfArgs', ['abcArgsPSA7'])}]
d.psa8(): [[], {'f': function('SelfArgs')}]
d.psa9(): [[], {'f': function('SelfArgs', {'abcSelfPSA9': 'abcSelfPSA9Val'})}]
d.psaA(): [['abcArgsPSAA'], {'f': function('SelfArgs', ['abcArgsPSAA'], {'abcSelfPSAA': 'abcSelfPSAAVal'})}]
d.psaB(): [['abcArgsPSAB'], {'f': function('SelfArgs', ['abcArgsPSAB'])}]
d.psaC(): [[], {'f': function('SelfArgs')}]
END
call assert_equal(expected, res)
py3 ecall('a()', a, )
py3 ecall('pa1()', pa1, )
py3 ecall('pa2()', pa2, )
py3 ecall('pa3()', pa3, )
py3 ecall('pa4()', pa4, )
py3 ecall('sa()', sa, )
py3 ecall('psa1()', psa1, )
py3 ecall('psa2()', psa2, )
py3 ecall('psa3()', psa3, )
py3 ecall('psa4()', psa4, )
py3 ecall('a(42, 43)', a, 42, 43)
py3 ecall('pa1(42, 43)', pa1, 42, 43)
py3 ecall('pa2(42, 43)', pa2, 42, 43)
py3 ecall('pa3(42, 43)', pa3, 42, 43)
py3 ecall('pa4(42, 43)', pa4, 42, 43)
py3 ecall('sa(42, 43)', sa, 42, 43)
py3 ecall('psa1(42, 43)', psa1, 42, 43)
py3 ecall('psa2(42, 43)', psa2, 42, 43)
py3 ecall('psa3(42, 43)', psa3, 42, 43)
py3 ecall('psa4(42, 43)', psa4, 42, 43)
py3 ecall('a(42, self={"20": 1})', a, 42, self={'20': 1})
py3 ecall('pa1(42, self={"20": 1})', pa1, 42, self={'20': 1})
py3 ecall('pa2(42, self={"20": 1})', pa2, 42, self={'20': 1})
py3 ecall('pa3(42, self={"20": 1})', pa3, 42, self={'20': 1})
py3 ecall('pa4(42, self={"20": 1})', pa4, 42, self={'20': 1})
py3 ecall('sa(42, self={"20": 1})', sa, 42, self={'20': 1})
py3 ecall('psa1(42, self={"20": 1})', psa1, 42, self={'20': 1})
py3 ecall('psa2(42, self={"20": 1})', psa2, 42, self={'20': 1})
py3 ecall('psa3(42, self={"20": 1})', psa3, 42, self={'20': 1})
py3 ecall('psa4(42, self={"20": 1})', psa4, 42, self={'20': 1})
py3 ecall('a(self={"20": 1})', a, self={'20': 1})
py3 ecall('pa1(self={"20": 1})', pa1, self={'20': 1})
py3 ecall('pa2(self={"20": 1})', pa2, self={'20': 1})
py3 ecall('pa3(self={"20": 1})', pa3, self={'20': 1})
py3 ecall('pa4(self={"20": 1})', pa4, self={'20': 1})
py3 ecall('sa(self={"20": 1})', sa, self={'20': 1})
py3 ecall('psa1(self={"20": 1})', psa1, self={'20': 1})
py3 ecall('psa2(self={"20": 1})', psa2, self={'20': 1})
py3 ecall('psa3(self={"20": 1})', psa3, self={'20': 1})
py3 ecall('psa4(self={"20": 1})', psa4, self={'20': 1})
py3 << trim EOF
def s(v):
if v is None:
return repr(v)
else:
return str(vim.Function('string')(v), 'utf-8')
cb.append('a.args: ' + s(a.args))
cb.append('pa1.args: ' + s(pa1.args))
cb.append('pa2.args: ' + s(pa2.args))
cb.append('pa3.args: ' + s(pa3.args))
cb.append('pa4.args: ' + s(pa4.args))
cb.append('sa.args: ' + s(sa.args))
cb.append('psa1.args: ' + s(psa1.args))
cb.append('psa2.args: ' + s(psa2.args))
cb.append('psa3.args: ' + s(psa3.args))
cb.append('psa4.args: ' + s(psa4.args))
cb.append('a.self: ' + s(a.self))
cb.append('pa1.self: ' + s(pa1.self))
cb.append('pa2.self: ' + s(pa2.self))
cb.append('pa3.self: ' + s(pa3.self))
cb.append('pa4.self: ' + s(pa4.self))
cb.append('sa.self: ' + s(sa.self))
cb.append('psa1.self: ' + s(psa1.self))
cb.append('psa2.self: ' + s(psa2.self))
cb.append('psa3.self: ' + s(psa3.self))
cb.append('psa4.self: ' + s(psa4.self))
cb.append('a.name: ' + s(a.name))
cb.append('pa1.name: ' + s(pa1.name))
cb.append('pa2.name: ' + s(pa2.name))
cb.append('pa3.name: ' + s(pa3.name))
cb.append('pa4.name: ' + s(pa4.name))
cb.append('sa.name: ' + s(sa.name))
cb.append('psa1.name: ' + s(psa1.name))
cb.append('psa2.name: ' + s(psa2.name))
cb.append('psa3.name: ' + s(psa3.name))
cb.append('psa4.name: ' + s(psa4.name))
cb.append('a.auto_rebind: ' + s(a.auto_rebind))
cb.append('pa1.auto_rebind: ' + s(pa1.auto_rebind))
cb.append('pa2.auto_rebind: ' + s(pa2.auto_rebind))
cb.append('pa3.auto_rebind: ' + s(pa3.auto_rebind))
cb.append('pa4.auto_rebind: ' + s(pa4.auto_rebind))
cb.append('sa.auto_rebind: ' + s(sa.auto_rebind))
cb.append('psa1.auto_rebind: ' + s(psa1.auto_rebind))
cb.append('psa2.auto_rebind: ' + s(psa2.auto_rebind))
cb.append('psa3.auto_rebind: ' + s(psa3.auto_rebind))
cb.append('psa4.auto_rebind: ' + s(psa4.auto_rebind))
cb.append('psa5.auto_rebind: ' + s(psa5.auto_rebind))
cb.append('psa6.auto_rebind: ' + s(psa6.auto_rebind))
cb.append('psa7.auto_rebind: ' + s(psa7.auto_rebind))
cb.append('psa8.auto_rebind: ' + s(psa8.auto_rebind))
cb.append('psa9.auto_rebind: ' + s(psa9.auto_rebind))
cb.append('psaA.auto_rebind: ' + s(psaA.auto_rebind))
cb.append('psaB.auto_rebind: ' + s(psaB.auto_rebind))
cb.append('psaC.auto_rebind: ' + s(psaC.auto_rebind))
del s
del a
del pa1
del pa2
del pa3
del pa4
del sa
del psa1
del psa2
del psa3
del psa4
del psa5
del psa6
del psa7
del psa8
del psa9
del psaA
del psaB
del psaC
del psar
del ecall
EOF
let expected =<< trim END
a(): !result: []
pa1(): !result: ['abcArgsPA1']
pa2(): !result: []
pa3(): !result: ['abcArgsPA3']
pa4(): !result: []
sa(): !exception: error:('Vim:E725: Calling dict function without Dictionary: SelfArgs',)
psa1(): !exception: error:('Vim:E725: Calling dict function without Dictionary: SelfArgs',)
psa2(): !exception: error:('Vim:E725: Calling dict function without Dictionary: SelfArgs',)
psa3(): !result: [['abcArgsPSA3'], {'abcSelfPSA3': 'abcSelfPSA3Val'}]
psa4(): !result: [[], {'abcSelfPSA4': 'abcSelfPSA4Val'}]
a(42, 43): !result: [42, 43]
pa1(42, 43): !result: ['abcArgsPA1', 42, 43]
pa2(42, 43): !result: [42, 43]
pa3(42, 43): !result: ['abcArgsPA3', 42, 43]
pa4(42, 43): !result: [42, 43]
sa(42, 43): !exception: error:('Vim:E725: Calling dict function without Dictionary: SelfArgs',)
psa1(42, 43): !exception: error:('Vim:E725: Calling dict function without Dictionary: SelfArgs',)
psa2(42, 43): !exception: error:('Vim:E725: Calling dict function without Dictionary: SelfArgs',)
psa3(42, 43): !result: [['abcArgsPSA3', 42, 43], {'abcSelfPSA3': 'abcSelfPSA3Val'}]
psa4(42, 43): !result: [[42, 43], {'abcSelfPSA4': 'abcSelfPSA4Val'}]
a(42, self={"20": 1}): !result: [42]
pa1(42, self={"20": 1}): !result: ['abcArgsPA1', 42]
pa2(42, self={"20": 1}): !result: [42]
pa3(42, self={"20": 1}): !result: ['abcArgsPA3', 42]
pa4(42, self={"20": 1}): !result: [42]
sa(42, self={"20": 1}): !result: [[42], {'20': 1}]
psa1(42, self={"20": 1}): !result: [['abcArgsPSA1', 42], {'20': 1}]
psa2(42, self={"20": 1}): !result: [[42], {'20': 1}]
psa3(42, self={"20": 1}): !result: [['abcArgsPSA3', 42], {'20': 1}]
psa4(42, self={"20": 1}): !result: [[42], {'20': 1}]
a(self={"20": 1}): !result: []
pa1(self={"20": 1}): !result: ['abcArgsPA1']
pa2(self={"20": 1}): !result: []
pa3(self={"20": 1}): !result: ['abcArgsPA3']
pa4(self={"20": 1}): !result: []
sa(self={"20": 1}): !result: [[], {'20': 1}]
psa1(self={"20": 1}): !result: [['abcArgsPSA1'], {'20': 1}]
psa2(self={"20": 1}): !result: [[], {'20': 1}]
psa3(self={"20": 1}): !result: [['abcArgsPSA3'], {'20': 1}]
psa4(self={"20": 1}): !result: [[], {'20': 1}]
a.args: None
pa1.args: ['abcArgsPA1']
pa2.args: None
pa3.args: ['abcArgsPA3']
pa4.args: None
sa.args: None
psa1.args: ['abcArgsPSA1']
psa2.args: None
psa3.args: ['abcArgsPSA3']
psa4.args: None
a.self: None
pa1.self: None
pa2.self: None
pa3.self: {'abcSelfPA3': 'abcSelfPA3Val'}
pa4.self: {'abcSelfPA4': 'abcSelfPA4Val'}
sa.self: None
psa1.self: None
psa2.self: None
psa3.self: {'abcSelfPSA3': 'abcSelfPSA3Val'}
psa4.self: {'abcSelfPSA4': 'abcSelfPSA4Val'}
a.name: 'Args'
pa1.name: 'Args'
pa2.name: 'Args'
pa3.name: 'Args'
pa4.name: 'Args'
sa.name: 'SelfArgs'
psa1.name: 'SelfArgs'
psa2.name: 'SelfArgs'
psa3.name: 'SelfArgs'
psa4.name: 'SelfArgs'
a.auto_rebind: 1
pa1.auto_rebind: 1
pa2.auto_rebind: 1
pa3.auto_rebind: 0
pa4.auto_rebind: 0
sa.auto_rebind: 1
psa1.auto_rebind: 1
psa2.auto_rebind: 1
psa3.auto_rebind: 0
psa4.auto_rebind: 0
psa5.auto_rebind: 0
psa6.auto_rebind: 0
psa7.auto_rebind: 1
psa8.auto_rebind: 1
psa9.auto_rebind: 1
psaA.auto_rebind: 1
psaB.auto_rebind: 1
psaC.auto_rebind: 1
END
call assert_equal(expected, getline(2, '$'))
%bw!
endfunc
" Test stdout/stderr
func Test_python3_stdin_stderr()
let caught_writeerr = 0
let caught_writelineerr = 0
redir => messages
py3 sys.stdout.write('abc8') ; sys.stdout.write('def')
try
py3 sys.stderr.write('abc9') ; sys.stderr.write('def')
catch /abc9def/
let caught_writeerr = 1
endtry
py3 sys.stdout.writelines(iter('abcA'))
try
py3 sys.stderr.writelines(iter('abcB'))
catch /abcB/
let caught_writelineerr = 1
endtry
redir END
call assert_equal("\nabc8def\nabcA", messages)
call assert_equal(1, caught_writeerr)
call assert_equal(1, caught_writelineerr)
endfunc
" Test subclassing
func Test_python3_subclass()
new
func Put(...)
return a:000
endfunc
py3 << trim EOF
class DupDict(vim.Dictionary):
def __setitem__(self, key, value):
super(DupDict, self).__setitem__(key, value)
super(DupDict, self).__setitem__('dup_' + key, value)
dd = DupDict()
dd['a'] = 'b'
class DupList(vim.List):
def __getitem__(self, idx):
return [super(DupList, self).__getitem__(idx)] * 2
dl = DupList()
dl2 = DupList(iter('abcC'))
dl.extend(dl2[0])
class DupFun(vim.Function):
def __call__(self, arg):
return super(DupFun, self).__call__(arg, arg)
df = DupFun('Put')
EOF
call assert_equal(['a', 'dup_a'], sort(keys(py3eval('dd'))))
call assert_equal(['a', 'a'], py3eval('dl'))
call assert_equal(['a', 'b', 'c', 'C'], py3eval('dl2'))
call assert_equal([2, 2], py3eval('df(2)'))
call assert_equal(1, py3eval('dl') is# py3eval('dl'))
call assert_equal(1, py3eval('dd') is# py3eval('dd'))
call assert_equal(function('Put'), py3eval('df'))
delfunction Put
py3 << trim EOF
del DupDict
del DupList
del DupFun
del dd
del dl
del dl2
del df
EOF
close!
endfunc
" Test chdir
func Test_python3_chdir()
new Xp3cdfile
py3 cb = vim.current.buffer
py3 << trim EOF
import os
fnamemodify = vim.Function('fnamemodify')
cb.append(str(fnamemodify('.', ':p:h:t')))
cb.append(vim.eval('@%'))
os.chdir('..')
path = fnamemodify('.', ':p:h:t')
if path != b'src' and path != b'src2':
# Running tests from a shadow directory, so move up another level
# This will result in @% looking like shadow/testdir/Xp3cdfile, hence the
# slicing to remove the leading path and path separator
os.chdir('..')
cb.append(str(fnamemodify('.', ':p:h:t')))
cb.append(vim.eval('@%')[len(path)+1:].replace(os.path.sep, '/'))
os.chdir(path)
else:
# Also accept running from src2/testdir/ for MS-Windows CI.
cb.append(str(fnamemodify('.', ':p:h:t').replace(b'src2', b'src')))
cb.append(vim.eval('@%').replace(os.path.sep, '/'))
del path
os.chdir('testdir')
cb.append(str(fnamemodify('.', ':p:h:t')))
cb.append(vim.eval('@%'))
del fnamemodify
EOF
call assert_equal(["b'testdir'", 'Xp3cdfile', "b'src'", 'testdir/Xp3cdfile',
\"b'testdir'", 'Xp3cdfile'], getline(2, '$'))
close!
call AssertException(["py3 vim.chdir(None)"], "Vim(py3):TypeError:")
endfunc
" Test errors
func Test_python3_errors()
func F() dict
endfunc
func D()
endfunc
new
py3 cb = vim.current.buffer
py3 << trim EOF
import os
d = vim.Dictionary()
ned = vim.Dictionary(foo='bar', baz='abcD')
dl = vim.Dictionary(a=1)
dl.locked = True
l = vim.List()
ll = vim.List('abcE')
ll.locked = True
nel = vim.List('abcO')
f = vim.Function('string')
fd = vim.Function('F')
fdel = vim.Function('D')
vim.command('delfunction D')
def subexpr_test(expr, name, subexprs):
cb.append('>>> Testing %s using %s' % (name, expr))
for subexpr in subexprs:
ee(expr % subexpr)
cb.append('<<< Finished')
def stringtochars_test(expr):
return subexpr_test(expr, 'StringToChars', (
'1', # Fail type checks
'b"\\0"', # Fail PyString_AsStringAndSize(object, , NULL) check
'"\\0"', # Fail PyString_AsStringAndSize(bytes, , NULL) check
))
class Mapping(object):
def __init__(self, d):
self.d = d
def __getitem__(self, key):
return self.d[key]
def keys(self):
return self.d.keys()
def items(self):
return self.d.items()
def convertfrompyobject_test(expr, recurse=True):
# pydict_to_tv
stringtochars_test(expr % '{%s : 1}')
if recurse:
convertfrompyobject_test(expr % '{"abcF" : %s}', False)
# pymap_to_tv
stringtochars_test(expr % 'Mapping({%s : 1})')
if recurse:
convertfrompyobject_test(expr % 'Mapping({"abcG" : %s})', False)
# pyseq_to_tv
iter_test(expr)
return subexpr_test(expr, 'ConvertFromPyObject', (
'None', # Not conversible
'{b"": 1}', # Empty key not allowed
'{"": 1}', # Same, but with unicode object
'FailingMapping()', #
'FailingMappingKey()', #
'FailingNumber()', #
))
def convertfrompymapping_test(expr):
convertfrompyobject_test(expr)
return subexpr_test(expr, 'ConvertFromPyMapping', (
'[]',
))
def iter_test(expr):
return subexpr_test(expr, '*Iter*', (
'FailingIter()',
'FailingIterNext()',
))
def number_test(expr, natural=False, unsigned=False):
if natural:
unsigned = True
return subexpr_test(expr, 'NumberToLong', (
'[]',
'None',
) + (('-1',) if unsigned else ())
+ (('0',) if natural else ()))
class FailingTrue(object):
def __bool__(self):
raise NotImplementedError('bool')
class FailingIter(object):
def __iter__(self):
raise NotImplementedError('iter')
class FailingIterNext(object):
def __iter__(self):
return self
def __next__(self):
raise NotImplementedError('next')
class FailingIterNextN(object):
def __init__(self, n):
self.n = n
def __iter__(self):
return self
def __next__(self):
if self.n:
self.n -= 1
return 1
else:
raise NotImplementedError('next N')
class FailingMappingKey(object):
def __getitem__(self, item):
raise NotImplementedError('getitem:mappingkey')
def keys(self):
return list("abcH")
class FailingMapping(object):
def __getitem__(self):
raise NotImplementedError('getitem:mapping')
def keys(self):
raise NotImplementedError('keys')
class FailingList(list):
def __getitem__(self, idx):
if i == 2:
raise NotImplementedError('getitem:list')
else:
return super(FailingList, self).__getitem__(idx)
class NoArgsCall(object):
def __call__(self):
pass
class FailingCall(object):
def __call__(self, path):
raise NotImplementedError('call')
class FailingNumber(object):
def __int__(self):
raise NotImplementedError('int')
cb.append("> Output")
cb.append(">> OutputSetattr")
ee('del sys.stdout.softspace')
number_test('sys.stdout.softspace = %s', unsigned=True)
number_test('sys.stderr.softspace = %s', unsigned=True)
ee('assert sys.stdout.isatty()==False')
ee('assert sys.stdout.seekable()==False')
ee('sys.stdout.close()')
ee('sys.stdout.flush()')
ee('assert sys.stderr.isatty()==False')
ee('assert sys.stderr.seekable()==False')
ee('sys.stderr.close()')
ee('sys.stderr.flush()')
ee('sys.stdout.attr = None')
cb.append(">> OutputWrite")
ee('assert sys.stdout.writable()==True')
ee('assert sys.stdout.readable()==False')
ee('assert sys.stderr.writable()==True')
ee('assert sys.stderr.readable()==False')
ee('assert sys.stdout.closed()==False')
ee('assert sys.stderr.closed()==False')
ee('assert sys.stdout.errors=="strict"')
ee('assert sys.stderr.errors=="strict"')
ee('assert sys.stdout.encoding==sys.stderr.encoding')
ee('sys.stdout.write(None)')
cb.append(">> OutputWriteLines")
ee('sys.stdout.writelines(None)')
ee('sys.stdout.writelines([1])')
iter_test('sys.stdout.writelines(%s)')
cb.append("> VimCommand")
stringtochars_test('vim.command(%s)')
ee('vim.command("", 2)')
#! Not checked: vim->python exceptions translating: checked later
cb.append("> VimToPython")
#! Not checked: everything: needs errors in internal python functions
cb.append("> VimEval")
stringtochars_test('vim.eval(%s)')
ee('vim.eval("", FailingTrue())')
#! Not checked: everything: needs errors in internal python functions
cb.append("> VimEvalPy")
stringtochars_test('vim.bindeval(%s)')
ee('vim.eval("", 2)')
#! Not checked: vim->python exceptions translating: checked later
cb.append("> VimStrwidth")
stringtochars_test('vim.strwidth(%s)')
cb.append("> VimForeachRTP")
ee('vim.foreach_rtp(None)')
ee('vim.foreach_rtp(NoArgsCall())')
ee('vim.foreach_rtp(FailingCall())')
ee('vim.foreach_rtp(int, 2)')
cb.append('> import')
old_rtp = vim.options['rtp']
vim.options['rtp'] = os.getcwd().replace('\\', '\\\\').replace(',', '\\,')
ee('import xxx_no_such_module_xxx')
ee('import failing_import')
ee('import failing')
vim.options['rtp'] = old_rtp
del old_rtp
cb.append("> Options")
cb.append(">> OptionsItem")
ee('vim.options["abcQ"]')
ee('vim.options[""]')
stringtochars_test('vim.options[%s]')
cb.append(">> OptionsContains")
stringtochars_test('%s in vim.options')
cb.append("> Dictionary")
cb.append(">> DictionaryConstructor")
ee('vim.Dictionary("abcI")')
##! Not checked: py_dict_alloc failure
cb.append(">> DictionarySetattr")
ee('del d.locked')
ee('d.locked = FailingTrue()')
ee('vim.vvars.locked = False')
ee('d.scope = True')
ee('d.xxx = True')
cb.append(">> _DictionaryItem")
ee('d.get("a", 2, 3)')
stringtochars_test('d.get(%s)')
ee('d.pop("a")')
ee('dl.pop("a")')
cb.append(">> DictionaryContains")
ee('"" in d')
ee('0 in d')
cb.append(">> DictionaryIterNext")
ee('for i in ned: ned["a"] = 1')
del i
cb.append(">> DictionaryAssItem")
ee('dl["b"] = 1')
stringtochars_test('d[%s] = 1')
convertfrompyobject_test('d["a"] = %s')
cb.append(">> DictionaryUpdate")
cb.append(">>> kwargs")
cb.append(">>> iter")
ee('d.update(FailingMapping())')
ee('d.update([FailingIterNext()])')
ee('d.update([FailingIterNextN(1)])')
iter_test('d.update(%s)')
convertfrompyobject_test('d.update(%s)')
stringtochars_test('d.update(((%s, 0),))')
convertfrompyobject_test('d.update((("a", %s),))')
cb.append(">> DictionaryPopItem")
ee('d.popitem(1, 2)')
cb.append(">> DictionaryHasKey")
ee('d.has_key()')
cb.append("> List")
cb.append(">> ListConstructor")
ee('vim.List(1, 2)')
ee('vim.List(a=1)')
iter_test('vim.List(%s)')
convertfrompyobject_test('vim.List([%s])')
cb.append(">> ListItem")
ee('l[1000]')
cb.append(">> ListAssItem")
ee('ll[1] = 2')
ee('l[1000] = 3')
cb.append(">> ListAssSlice")
ee('ll[1:100] = "abcJ"')
iter_test('l[:] = %s')
ee('nel[1:10:2] = "abcK"')
cb.append(repr(tuple(nel)))
ee('nel[1:10:2] = "a"')
cb.append(repr(tuple(nel)))
ee('nel[1:1:-1] = "a"')
cb.append(repr(tuple(nel)))
ee('nel[:] = FailingIterNextN(2)')
cb.append(repr(tuple(nel)))
convertfrompyobject_test('l[:] = [%s]')
cb.append(">> ListConcatInPlace")
iter_test('l.extend(%s)')
convertfrompyobject_test('l.extend([%s])')
cb.append(">> ListSetattr")
ee('del l.locked')
ee('l.locked = FailingTrue()')
ee('l.xxx = True')
cb.append("> Function")
cb.append(">> FunctionConstructor")
cb.append(">>> FunctionConstructor")
ee('vim.Function("123")')
ee('vim.Function("xxx_non_existent_function_xxx")')
ee('vim.Function("xxx#non#existent#function#xxx")')
ee('vim.Function("xxx_non_existent_function_xxx2", args=[])')
ee('vim.Function("xxx_non_existent_function_xxx3", self={})')
ee('vim.Function("xxx_non_existent_function_xxx4", args=[], self={})')
cb.append(">>> FunctionNew")
ee('vim.Function("tr", self="abcFuncSelf")')
ee('vim.Function("tr", args=427423)')
ee('vim.Function("tr", self="abcFuncSelf2", args="abcFuncArgs2")')
ee('vim.Function(self="abcFuncSelf2", args="abcFuncArgs2")')
ee('vim.Function("tr", "", self="abcFuncSelf2", args="abcFuncArgs2")')
ee('vim.Function("tr", "")')
cb.append(">> FunctionCall")
convertfrompyobject_test('f(%s)')
convertfrompymapping_test('fd(self=%s)')
cb.append("> TabPage")
cb.append(">> TabPageAttr")
ee('vim.current.tabpage.xxx')
cb.append("> TabList")
cb.append(">> TabListItem")
ee('vim.tabpages[1000]')
cb.append("> Window")
cb.append(">> WindowAttr")
ee('vim.current.window.xxx')
cb.append(">> WindowSetattr")
ee('vim.current.window.buffer = 0')
ee('vim.current.window.cursor = (100000000, 100000000)')
ee('vim.current.window.cursor = True')
number_test('vim.current.window.height = %s', unsigned=True)
number_test('vim.current.window.width = %s', unsigned=True)
ee('vim.current.window.xxxxxx = True')
cb.append("> WinList")
cb.append(">> WinListItem")
ee('vim.windows[1000]')
cb.append("> Buffer")
cb.append(">> StringToLine (indirect)")
ee('vim.current.buffer[0] = "\\na"')
ee('vim.current.buffer[0] = b"\\na"')
cb.append(">> SetBufferLine (indirect)")
ee('vim.current.buffer[0] = True')
cb.append(">> SetBufferLineList (indirect)")
ee('vim.current.buffer[:] = True')
ee('vim.current.buffer[:] = ["\\na", "bc"]')
cb.append(">> InsertBufferLines (indirect)")
ee('vim.current.buffer.append(None)')
ee('vim.current.buffer.append(["\\na", "bc"])')
ee('vim.current.buffer.append("\\nbc")')
cb.append(">> RBItem")
ee('vim.current.buffer[100000000]')
cb.append(">> RBAsItem")
ee('vim.current.buffer[100000000] = ""')
cb.append(">> BufferAttr")
ee('vim.current.buffer.xxx')
cb.append(">> BufferSetattr")
ee('vim.current.buffer.name = True')
ee('vim.current.buffer.xxx = True')
cb.append(">> BufferMark")
ee('vim.current.buffer.mark(0)')
ee('vim.current.buffer.mark("abcM")')
ee('vim.current.buffer.mark("!")')
cb.append(">> BufferRange")
ee('vim.current.buffer.range(1, 2, 3)')
cb.append("> BufMap")
cb.append(">> BufMapItem")
ee('vim.buffers[100000000]')
number_test('vim.buffers[%s]', natural=True)
cb.append("> Current")
cb.append(">> CurrentGetattr")
ee('vim.current.xxx')
cb.append(">> CurrentSetattr")
ee('vim.current.line = True')
ee('vim.current.buffer = True')
ee('vim.current.window = True')
ee('vim.current.tabpage = True')
ee('vim.current.xxx = True')
del d
del ned
del dl
del l
del ll
del nel
del f
del fd
del fdel
del subexpr_test
del stringtochars_test
del Mapping
del convertfrompyobject_test
del convertfrompymapping_test
del iter_test
del number_test
del FailingTrue
del FailingIter
del FailingIterNext
del FailingIterNextN
del FailingMapping
del FailingMappingKey
del FailingList
del NoArgsCall
del FailingCall
del FailingNumber
EOF
delfunction F
let expected =<< trim END
> Output
>> OutputSetattr
del sys.stdout.softspace:(<class 'AttributeError'>, AttributeError('cannot delete OutputObject attributes',))
>>> Testing NumberToLong using sys.stdout.softspace = %s
sys.stdout.softspace = []:(<class 'TypeError'>, TypeError('expected int() or something supporting coercing to int(), but got list',))
sys.stdout.softspace = None:(<class 'TypeError'>, TypeError('expected int() or something supporting coercing to int(), but got NoneType',))
sys.stdout.softspace = -1:(<class 'ValueError'>, ValueError('number must be greater or equal to zero',))
<<< Finished
>>> Testing NumberToLong using sys.stderr.softspace = %s
sys.stderr.softspace = []:(<class 'TypeError'>, TypeError('expected int() or something supporting coercing to int(), but got list',))
sys.stderr.softspace = None:(<class 'TypeError'>, TypeError('expected int() or something supporting coercing to int(), but got NoneType',))
sys.stderr.softspace = -1:(<class 'ValueError'>, ValueError('number must be greater or equal to zero',))
<<< Finished
assert sys.stdout.isatty()==False:NOT FAILED
assert sys.stdout.seekable()==False:NOT FAILED
sys.stdout.close():NOT FAILED
sys.stdout.flush():NOT FAILED
assert sys.stderr.isatty()==False:NOT FAILED
assert sys.stderr.seekable()==False:NOT FAILED
sys.stderr.close():NOT FAILED
sys.stderr.flush():NOT FAILED
sys.stdout.attr = None:(<class 'AttributeError'>, AttributeError('invalid attribute: attr',))
>> OutputWrite
assert sys.stdout.writable()==True:NOT FAILED
assert sys.stdout.readable()==False:NOT FAILED
assert sys.stderr.writable()==True:NOT FAILED
assert sys.stderr.readable()==False:NOT FAILED
assert sys.stdout.closed()==False:NOT FAILED
assert sys.stderr.closed()==False:NOT FAILED
assert sys.stdout.errors=="strict":NOT FAILED
assert sys.stderr.errors=="strict":NOT FAILED
assert sys.stdout.encoding==sys.stderr.encoding:NOT FAILED
sys.stdout.write(None):(<class 'TypeError'>, TypeError("Can't convert 'NoneType' object to str implicitly",))
>> OutputWriteLines
sys.stdout.writelines(None):(<class 'TypeError'>, TypeError("'NoneType' object is not iterable",))
sys.stdout.writelines([1]):(<class 'TypeError'>, TypeError("Can't convert 'int' object to str implicitly",))
>>> Testing *Iter* using sys.stdout.writelines(%s)
sys.stdout.writelines(FailingIter()):(<class 'NotImplementedError'>, NotImplementedError('iter',))
sys.stdout.writelines(FailingIterNext()):(<class 'NotImplementedError'>, NotImplementedError('next',))
<<< Finished
> VimCommand
>>> Testing StringToChars using vim.command(%s)
vim.command(1):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
vim.command(b"\0"):(<class 'TypeError'>, TypeError('expected bytes with no null',))
vim.command("\0"):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
vim.command("", 2):(<class 'TypeError'>, TypeError('command() takes exactly one argument (2 given)',))
> VimToPython
> VimEval
>>> Testing StringToChars using vim.eval(%s)
vim.eval(1):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
vim.eval(b"\0"):(<class 'TypeError'>, TypeError('expected bytes with no null',))
vim.eval("\0"):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
vim.eval("", FailingTrue()):(<class 'TypeError'>, TypeError('function takes exactly 1 argument (2 given)',))
> VimEvalPy
>>> Testing StringToChars using vim.bindeval(%s)
vim.bindeval(1):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
vim.bindeval(b"\0"):(<class 'TypeError'>, TypeError('expected bytes with no null',))
vim.bindeval("\0"):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
vim.eval("", 2):(<class 'TypeError'>, TypeError('function takes exactly 1 argument (2 given)',))
> VimStrwidth
>>> Testing StringToChars using vim.strwidth(%s)
vim.strwidth(1):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
vim.strwidth(b"\0"):(<class 'TypeError'>, TypeError('expected bytes with no null',))
vim.strwidth("\0"):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
> VimForeachRTP
vim.foreach_rtp(None):(<class 'TypeError'>, TypeError("'NoneType' object is not callable",))
vim.foreach_rtp(NoArgsCall()):(<class 'TypeError'>, TypeError('__call__() takes exactly 1 positional argument (2 given)',))
vim.foreach_rtp(FailingCall()):(<class 'NotImplementedError'>, NotImplementedError('call',))
vim.foreach_rtp(int, 2):(<class 'TypeError'>, TypeError('foreach_rtp() takes exactly one argument (2 given)',))
> import
import xxx_no_such_module_xxx:(<class 'ImportError'>, ImportError('No module named xxx_no_such_module_xxx',))
import failing_import:(<class 'ImportError'>, ImportError())
import failing:(<class 'NotImplementedError'>, NotImplementedError())
> Options
>> OptionsItem
vim.options["abcQ"]:(<class 'KeyError'>, KeyError('abcQ',))
vim.options[""]:(<class 'ValueError'>, ValueError('empty keys are not allowed',))
>>> Testing StringToChars using vim.options[%s]
vim.options[1]:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
vim.options[b"\0"]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
vim.options["\0"]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>> OptionsContains
>>> Testing StringToChars using %s in vim.options
1 in vim.options:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
b"\0" in vim.options:(<class 'TypeError'>, TypeError('expected bytes with no null',))
"\0" in vim.options:(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
> Dictionary
>> DictionaryConstructor
vim.Dictionary("abcI"):(<class 'ValueError'>, ValueError('expected sequence element of size 2, but got sequence of size 1',))
>> DictionarySetattr
del d.locked:(<class 'AttributeError'>, AttributeError('cannot delete vim.Dictionary attributes',))
d.locked = FailingTrue():(<class 'NotImplementedError'>, NotImplementedError('bool',))
vim.vvars.locked = False:(<class 'TypeError'>, TypeError('cannot modify fixed dictionary',))
d.scope = True:(<class 'AttributeError'>, AttributeError('cannot set attribute scope',))
d.xxx = True:(<class 'AttributeError'>, AttributeError('cannot set attribute xxx',))
>> _DictionaryItem
d.get("a", 2, 3):(<class 'TypeError'>, TypeError('function takes at most 2 arguments (3 given)',))
>>> Testing StringToChars using d.get(%s)
d.get(1):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d.get(b"\0"):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.get("\0"):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
d.pop("a"):(<class 'KeyError'>, KeyError('a',))
dl.pop("a"):(<class 'vim.error'>, error('dictionary is locked',))
>> DictionaryContains
"" in d:(<class 'ValueError'>, ValueError('empty keys are not allowed',))
0 in d:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
>> DictionaryIterNext
for i in ned: ned["a"] = 1:(<class 'RuntimeError'>, RuntimeError('hashtab changed during iteration',))
>> DictionaryAssItem
dl["b"] = 1:(<class 'vim.error'>, error('dictionary is locked',))
>>> Testing StringToChars using d[%s] = 1
d[1] = 1:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d[b"\0"] = 1:(<class 'TypeError'>, TypeError('expected bytes with no null',))
d["\0"] = 1:(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing StringToChars using d["a"] = {%s : 1}
d["a"] = {1 : 1}:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d["a"] = {b"\0" : 1}:(<class 'TypeError'>, TypeError('expected bytes with no null',))
d["a"] = {"\0" : 1}:(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing StringToChars using d["a"] = {"abcF" : {%s : 1}}
d["a"] = {"abcF" : {1 : 1}}:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d["a"] = {"abcF" : {b"\0" : 1}}:(<class 'TypeError'>, TypeError('expected bytes with no null',))
d["a"] = {"abcF" : {"\0" : 1}}:(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing StringToChars using d["a"] = {"abcF" : Mapping({%s : 1})}
d["a"] = {"abcF" : Mapping({1 : 1})}:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d["a"] = {"abcF" : Mapping({b"\0" : 1})}:(<class 'TypeError'>, TypeError('expected bytes with no null',))
d["a"] = {"abcF" : Mapping({"\0" : 1})}:(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing *Iter* using d["a"] = {"abcF" : %s}
d["a"] = {"abcF" : FailingIter()}:(<class 'TypeError'>, TypeError('unable to convert FailingIter to a Vim structure',))
d["a"] = {"abcF" : FailingIterNext()}:(<class 'NotImplementedError'>, NotImplementedError('next',))
<<< Finished
>>> Testing ConvertFromPyObject using d["a"] = {"abcF" : %s}
d["a"] = {"abcF" : None}:NOT FAILED
d["a"] = {"abcF" : {b"": 1}}:(<class 'ValueError'>, ValueError('empty keys are not allowed',))
d["a"] = {"abcF" : {"": 1}}:(<class 'ValueError'>, ValueError('empty keys are not allowed',))
d["a"] = {"abcF" : FailingMapping()}:(<class 'NotImplementedError'>, NotImplementedError('keys',))
d["a"] = {"abcF" : FailingMappingKey()}:(<class 'NotImplementedError'>, NotImplementedError('getitem:mappingkey',))
d["a"] = {"abcF" : FailingNumber()}:(<class 'NotImplementedError'>, NotImplementedError('int',))
<<< Finished
>>> Testing StringToChars using d["a"] = Mapping({%s : 1})
d["a"] = Mapping({1 : 1}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d["a"] = Mapping({b"\0" : 1}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d["a"] = Mapping({"\0" : 1}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing StringToChars using d["a"] = Mapping({"abcG" : {%s : 1}})
d["a"] = Mapping({"abcG" : {1 : 1}}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d["a"] = Mapping({"abcG" : {b"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d["a"] = Mapping({"abcG" : {"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing StringToChars using d["a"] = Mapping({"abcG" : Mapping({%s : 1})})
d["a"] = Mapping({"abcG" : Mapping({1 : 1})}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d["a"] = Mapping({"abcG" : Mapping({b"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d["a"] = Mapping({"abcG" : Mapping({"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing *Iter* using d["a"] = Mapping({"abcG" : %s})
d["a"] = Mapping({"abcG" : FailingIter()}):(<class 'TypeError'>, TypeError('unable to convert FailingIter to a Vim structure',))
d["a"] = Mapping({"abcG" : FailingIterNext()}):(<class 'NotImplementedError'>, NotImplementedError('next',))
<<< Finished
>>> Testing ConvertFromPyObject using d["a"] = Mapping({"abcG" : %s})
d["a"] = Mapping({"abcG" : None}):NOT FAILED
d["a"] = Mapping({"abcG" : {b"": 1}}):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
d["a"] = Mapping({"abcG" : {"": 1}}):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
d["a"] = Mapping({"abcG" : FailingMapping()}):(<class 'NotImplementedError'>, NotImplementedError('keys',))
d["a"] = Mapping({"abcG" : FailingMappingKey()}):(<class 'NotImplementedError'>, NotImplementedError('getitem:mappingkey',))
d["a"] = Mapping({"abcG" : FailingNumber()}):(<class 'NotImplementedError'>, NotImplementedError('int',))
<<< Finished
>>> Testing *Iter* using d["a"] = %s
d["a"] = FailingIter():(<class 'TypeError'>, TypeError('unable to convert FailingIter to a Vim structure',))
d["a"] = FailingIterNext():(<class 'NotImplementedError'>, NotImplementedError('next',))
<<< Finished
>>> Testing ConvertFromPyObject using d["a"] = %s
d["a"] = None:NOT FAILED
d["a"] = {b"": 1}:(<class 'ValueError'>, ValueError('empty keys are not allowed',))
d["a"] = {"": 1}:(<class 'ValueError'>, ValueError('empty keys are not allowed',))
d["a"] = FailingMapping():(<class 'NotImplementedError'>, NotImplementedError('keys',))
d["a"] = FailingMappingKey():(<class 'NotImplementedError'>, NotImplementedError('getitem:mappingkey',))
d["a"] = FailingNumber():(<class 'NotImplementedError'>, NotImplementedError('int',))
<<< Finished
>> DictionaryUpdate
>>> kwargs
>>> iter
d.update(FailingMapping()):(<class 'NotImplementedError'>, NotImplementedError('keys',))
d.update([FailingIterNext()]):(<class 'NotImplementedError'>, NotImplementedError('next',))
d.update([FailingIterNextN(1)]):(<class 'NotImplementedError'>, NotImplementedError('next N',))
>>> Testing *Iter* using d.update(%s)
d.update(FailingIter()):(<class 'NotImplementedError'>, NotImplementedError('iter',))
d.update(FailingIterNext()):(<class 'NotImplementedError'>, NotImplementedError('next',))
<<< Finished
>>> Testing StringToChars using d.update({%s : 1})
d.update({1 : 1}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d.update({b"\0" : 1}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update({"\0" : 1}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing StringToChars using d.update({"abcF" : {%s : 1}})
d.update({"abcF" : {1 : 1}}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d.update({"abcF" : {b"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update({"abcF" : {"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing StringToChars using d.update({"abcF" : Mapping({%s : 1})})
d.update({"abcF" : Mapping({1 : 1})}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d.update({"abcF" : Mapping({b"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update({"abcF" : Mapping({"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing *Iter* using d.update({"abcF" : %s})
d.update({"abcF" : FailingIter()}):(<class 'TypeError'>, TypeError('unable to convert FailingIter to a Vim structure',))
d.update({"abcF" : FailingIterNext()}):(<class 'NotImplementedError'>, NotImplementedError('next',))
<<< Finished
>>> Testing ConvertFromPyObject using d.update({"abcF" : %s})
d.update({"abcF" : None}):NOT FAILED
d.update({"abcF" : {b"": 1}}):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
d.update({"abcF" : {"": 1}}):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
d.update({"abcF" : FailingMapping()}):(<class 'NotImplementedError'>, NotImplementedError('keys',))
d.update({"abcF" : FailingMappingKey()}):(<class 'NotImplementedError'>, NotImplementedError('getitem:mappingkey',))
d.update({"abcF" : FailingNumber()}):(<class 'NotImplementedError'>, NotImplementedError('int',))
<<< Finished
>>> Testing StringToChars using d.update(Mapping({%s : 1}))
d.update(Mapping({1 : 1})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d.update(Mapping({b"\0" : 1})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update(Mapping({"\0" : 1})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing StringToChars using d.update(Mapping({"abcG" : {%s : 1}}))
d.update(Mapping({"abcG" : {1 : 1}})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d.update(Mapping({"abcG" : {b"\0" : 1}})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update(Mapping({"abcG" : {"\0" : 1}})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing StringToChars using d.update(Mapping({"abcG" : Mapping({%s : 1})}))
d.update(Mapping({"abcG" : Mapping({1 : 1})})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d.update(Mapping({"abcG" : Mapping({b"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update(Mapping({"abcG" : Mapping({"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing *Iter* using d.update(Mapping({"abcG" : %s}))
d.update(Mapping({"abcG" : FailingIter()})):(<class 'TypeError'>, TypeError('unable to convert FailingIter to a Vim structure',))
d.update(Mapping({"abcG" : FailingIterNext()})):(<class 'NotImplementedError'>, NotImplementedError('next',))
<<< Finished
>>> Testing ConvertFromPyObject using d.update(Mapping({"abcG" : %s}))
d.update(Mapping({"abcG" : None})):NOT FAILED
d.update(Mapping({"abcG" : {b"": 1}})):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
d.update(Mapping({"abcG" : {"": 1}})):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
d.update(Mapping({"abcG" : FailingMapping()})):(<class 'NotImplementedError'>, NotImplementedError('keys',))
d.update(Mapping({"abcG" : FailingMappingKey()})):(<class 'NotImplementedError'>, NotImplementedError('getitem:mappingkey',))
d.update(Mapping({"abcG" : FailingNumber()})):(<class 'NotImplementedError'>, NotImplementedError('int',))
<<< Finished
>>> Testing *Iter* using d.update(%s)
d.update(FailingIter()):(<class 'NotImplementedError'>, NotImplementedError('iter',))
d.update(FailingIterNext()):(<class 'NotImplementedError'>, NotImplementedError('next',))
<<< Finished
>>> Testing ConvertFromPyObject using d.update(%s)
d.update(None):(<class 'TypeError'>, TypeError("'NoneType' object is not iterable",))
d.update({b"": 1}):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
d.update({"": 1}):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
d.update(FailingMapping()):(<class 'NotImplementedError'>, NotImplementedError('keys',))
d.update(FailingMappingKey()):(<class 'NotImplementedError'>, NotImplementedError('getitem:mappingkey',))
d.update(FailingNumber()):(<class 'TypeError'>, TypeError("'FailingNumber' object is not iterable",))
<<< Finished
>>> Testing StringToChars using d.update(((%s, 0),))
d.update(((1, 0),)):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d.update(((b"\0", 0),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update((("\0", 0),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing StringToChars using d.update((("a", {%s : 1}),))
d.update((("a", {1 : 1}),)):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d.update((("a", {b"\0" : 1}),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update((("a", {"\0" : 1}),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing StringToChars using d.update((("a", {"abcF" : {%s : 1}}),))
d.update((("a", {"abcF" : {1 : 1}}),)):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d.update((("a", {"abcF" : {b"\0" : 1}}),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update((("a", {"abcF" : {"\0" : 1}}),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing StringToChars using d.update((("a", {"abcF" : Mapping({%s : 1})}),))
d.update((("a", {"abcF" : Mapping({1 : 1})}),)):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d.update((("a", {"abcF" : Mapping({b"\0" : 1})}),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update((("a", {"abcF" : Mapping({"\0" : 1})}),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing *Iter* using d.update((("a", {"abcF" : %s}),))
d.update((("a", {"abcF" : FailingIter()}),)):(<class 'TypeError'>, TypeError('unable to convert FailingIter to a Vim structure',))
d.update((("a", {"abcF" : FailingIterNext()}),)):(<class 'NotImplementedError'>, NotImplementedError('next',))
<<< Finished
>>> Testing ConvertFromPyObject using d.update((("a", {"abcF" : %s}),))
d.update((("a", {"abcF" : None}),)):(<class 'vim.error'>, error("failed to add key 'a' to dictionary",))
d.update((("a", {"abcF" : {b"": 1}}),)):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
d.update((("a", {"abcF" : {"": 1}}),)):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
d.update((("a", {"abcF" : FailingMapping()}),)):(<class 'NotImplementedError'>, NotImplementedError('keys',))
d.update((("a", {"abcF" : FailingMappingKey()}),)):(<class 'NotImplementedError'>, NotImplementedError('getitem:mappingkey',))
d.update((("a", {"abcF" : FailingNumber()}),)):(<class 'NotImplementedError'>, NotImplementedError('int',))
<<< Finished
>>> Testing StringToChars using d.update((("a", Mapping({%s : 1})),))
d.update((("a", Mapping({1 : 1})),)):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d.update((("a", Mapping({b"\0" : 1})),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update((("a", Mapping({"\0" : 1})),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing StringToChars using d.update((("a", Mapping({"abcG" : {%s : 1}})),))
d.update((("a", Mapping({"abcG" : {1 : 1}})),)):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d.update((("a", Mapping({"abcG" : {b"\0" : 1}})),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update((("a", Mapping({"abcG" : {"\0" : 1}})),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing StringToChars using d.update((("a", Mapping({"abcG" : Mapping({%s : 1})})),))
d.update((("a", Mapping({"abcG" : Mapping({1 : 1})})),)):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d.update((("a", Mapping({"abcG" : Mapping({b"\0" : 1})})),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update((("a", Mapping({"abcG" : Mapping({"\0" : 1})})),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing *Iter* using d.update((("a", Mapping({"abcG" : %s})),))
d.update((("a", Mapping({"abcG" : FailingIter()})),)):(<class 'TypeError'>, TypeError('unable to convert FailingIter to a Vim structure',))
d.update((("a", Mapping({"abcG" : FailingIterNext()})),)):(<class 'NotImplementedError'>, NotImplementedError('next',))
<<< Finished
>>> Testing ConvertFromPyObject using d.update((("a", Mapping({"abcG" : %s})),))
d.update((("a", Mapping({"abcG" : None})),)):(<class 'vim.error'>, error("failed to add key 'a' to dictionary",))
d.update((("a", Mapping({"abcG" : {b"": 1}})),)):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
d.update((("a", Mapping({"abcG" : {"": 1}})),)):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
d.update((("a", Mapping({"abcG" : FailingMapping()})),)):(<class 'NotImplementedError'>, NotImplementedError('keys',))
d.update((("a", Mapping({"abcG" : FailingMappingKey()})),)):(<class 'NotImplementedError'>, NotImplementedError('getitem:mappingkey',))
d.update((("a", Mapping({"abcG" : FailingNumber()})),)):(<class 'NotImplementedError'>, NotImplementedError('int',))
<<< Finished
>>> Testing *Iter* using d.update((("a", %s),))
d.update((("a", FailingIter()),)):(<class 'TypeError'>, TypeError('unable to convert FailingIter to a Vim structure',))
d.update((("a", FailingIterNext()),)):(<class 'NotImplementedError'>, NotImplementedError('next',))
<<< Finished
>>> Testing ConvertFromPyObject using d.update((("a", %s),))
d.update((("a", None),)):(<class 'vim.error'>, error("failed to add key 'a' to dictionary",))
d.update((("a", {b"": 1}),)):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
d.update((("a", {"": 1}),)):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
d.update((("a", FailingMapping()),)):(<class 'NotImplementedError'>, NotImplementedError('keys',))
d.update((("a", FailingMappingKey()),)):(<class 'NotImplementedError'>, NotImplementedError('getitem:mappingkey',))
d.update((("a", FailingNumber()),)):(<class 'NotImplementedError'>, NotImplementedError('int',))
<<< Finished
>> DictionaryPopItem
d.popitem(1, 2):(<class 'TypeError'>, TypeError('popitem() takes no arguments (2 given)',))
>> DictionaryHasKey
d.has_key():(<class 'TypeError'>, TypeError('has_key() takes exactly one argument (0 given)',))
> List
>> ListConstructor
vim.List(1, 2):(<class 'TypeError'>, TypeError('function takes at most 1 argument (2 given)',))
vim.List(a=1):(<class 'TypeError'>, TypeError('list constructor does not accept keyword arguments',))
>>> Testing *Iter* using vim.List(%s)
vim.List(FailingIter()):(<class 'NotImplementedError'>, NotImplementedError('iter',))
vim.List(FailingIterNext()):(<class 'NotImplementedError'>, NotImplementedError('next',))
<<< Finished
>>> Testing StringToChars using vim.List([{%s : 1}])
vim.List([{1 : 1}]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
vim.List([{b"\0" : 1}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
vim.List([{"\0" : 1}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing StringToChars using vim.List([{"abcF" : {%s : 1}}])
vim.List([{"abcF" : {1 : 1}}]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
vim.List([{"abcF" : {b"\0" : 1}}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
vim.List([{"abcF" : {"\0" : 1}}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing StringToChars using vim.List([{"abcF" : Mapping({%s : 1})}])
vim.List([{"abcF" : Mapping({1 : 1})}]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
vim.List([{"abcF" : Mapping({b"\0" : 1})}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
vim.List([{"abcF" : Mapping({"\0" : 1})}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing *Iter* using vim.List([{"abcF" : %s}])
vim.List([{"abcF" : FailingIter()}]):(<class 'TypeError'>, TypeError('unable to convert FailingIter to a Vim structure',))
vim.List([{"abcF" : FailingIterNext()}]):(<class 'NotImplementedError'>, NotImplementedError('next',))
<<< Finished
>>> Testing ConvertFromPyObject using vim.List([{"abcF" : %s}])
vim.List([{"abcF" : None}]):NOT FAILED
vim.List([{"abcF" : {b"": 1}}]):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
vim.List([{"abcF" : {"": 1}}]):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
vim.List([{"abcF" : FailingMapping()}]):(<class 'NotImplementedError'>, NotImplementedError('keys',))
vim.List([{"abcF" : FailingMappingKey()}]):(<class 'NotImplementedError'>, NotImplementedError('getitem:mappingkey',))
vim.List([{"abcF" : FailingNumber()}]):(<class 'NotImplementedError'>, NotImplementedError('int',))
<<< Finished
>>> Testing StringToChars using vim.List([Mapping({%s : 1})])
vim.List([Mapping({1 : 1})]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
vim.List([Mapping({b"\0" : 1})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
vim.List([Mapping({"\0" : 1})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing StringToChars using vim.List([Mapping({"abcG" : {%s : 1}})])
vim.List([Mapping({"abcG" : {1 : 1}})]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
vim.List([Mapping({"abcG" : {b"\0" : 1}})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
vim.List([Mapping({"abcG" : {"\0" : 1}})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing StringToChars using vim.List([Mapping({"abcG" : Mapping({%s : 1})})])
vim.List([Mapping({"abcG" : Mapping({1 : 1})})]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
vim.List([Mapping({"abcG" : Mapping({b"\0" : 1})})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
vim.List([Mapping({"abcG" : Mapping({"\0" : 1})})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing *Iter* using vim.List([Mapping({"abcG" : %s})])
vim.List([Mapping({"abcG" : FailingIter()})]):(<class 'TypeError'>, TypeError('unable to convert FailingIter to a Vim structure',))
vim.List([Mapping({"abcG" : FailingIterNext()})]):(<class 'NotImplementedError'>, NotImplementedError('next',))
<<< Finished
>>> Testing ConvertFromPyObject using vim.List([Mapping({"abcG" : %s})])
vim.List([Mapping({"abcG" : None})]):NOT FAILED
vim.List([Mapping({"abcG" : {b"": 1}})]):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
vim.List([Mapping({"abcG" : {"": 1}})]):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
vim.List([Mapping({"abcG" : FailingMapping()})]):(<class 'NotImplementedError'>, NotImplementedError('keys',))
vim.List([Mapping({"abcG" : FailingMappingKey()})]):(<class 'NotImplementedError'>, NotImplementedError('getitem:mappingkey',))
vim.List([Mapping({"abcG" : FailingNumber()})]):(<class 'NotImplementedError'>, NotImplementedError('int',))
<<< Finished
>>> Testing *Iter* using vim.List([%s])
vim.List([FailingIter()]):(<class 'TypeError'>, TypeError('unable to convert FailingIter to a Vim structure',))
vim.List([FailingIterNext()]):(<class 'NotImplementedError'>, NotImplementedError('next',))
<<< Finished
>>> Testing ConvertFromPyObject using vim.List([%s])
vim.List([None]):NOT FAILED
vim.List([{b"": 1}]):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
vim.List([{"": 1}]):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
vim.List([FailingMapping()]):(<class 'NotImplementedError'>, NotImplementedError('keys',))
vim.List([FailingMappingKey()]):(<class 'NotImplementedError'>, NotImplementedError('getitem:mappingkey',))
vim.List([FailingNumber()]):(<class 'NotImplementedError'>, NotImplementedError('int',))
<<< Finished
>> ListItem
l[1000]:(<class 'IndexError'>, IndexError('list index out of range',))
>> ListAssItem
ll[1] = 2:(<class 'vim.error'>, error('list is locked',))
l[1000] = 3:(<class 'IndexError'>, IndexError('list index out of range',))
>> ListAssSlice
ll[1:100] = "abcJ":(<class 'vim.error'>, error('list is locked',))
>>> Testing *Iter* using l[:] = %s
l[:] = FailingIter():(<class 'NotImplementedError'>, NotImplementedError('iter',))
l[:] = FailingIterNext():(<class 'NotImplementedError'>, NotImplementedError('next',))
<<< Finished
nel[1:10:2] = "abcK":(<class 'ValueError'>, ValueError('attempt to assign sequence of size greater than 2 to extended slice',))
(b'a', b'b', b'c', b'O')
nel[1:10:2] = "a":(<class 'ValueError'>, ValueError('attempt to assign sequence of size 1 to extended slice of size 2',))
(b'a', b'b', b'c', b'O')
nel[1:1:-1] = "a":(<class 'ValueError'>, ValueError('attempt to assign sequence of size greater than 0 to extended slice',))
(b'a', b'b', b'c', b'O')
nel[:] = FailingIterNextN(2):(<class 'NotImplementedError'>, NotImplementedError('next N',))
(b'a', b'b', b'c', b'O')
>>> Testing StringToChars using l[:] = [{%s : 1}]
l[:] = [{1 : 1}]:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
l[:] = [{b"\0" : 1}]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
l[:] = [{"\0" : 1}]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing StringToChars using l[:] = [{"abcF" : {%s : 1}}]
l[:] = [{"abcF" : {1 : 1}}]:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
l[:] = [{"abcF" : {b"\0" : 1}}]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
l[:] = [{"abcF" : {"\0" : 1}}]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing StringToChars using l[:] = [{"abcF" : Mapping({%s : 1})}]
l[:] = [{"abcF" : Mapping({1 : 1})}]:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
l[:] = [{"abcF" : Mapping({b"\0" : 1})}]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
l[:] = [{"abcF" : Mapping({"\0" : 1})}]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing *Iter* using l[:] = [{"abcF" : %s}]
l[:] = [{"abcF" : FailingIter()}]:(<class 'TypeError'>, TypeError('unable to convert FailingIter to a Vim structure',))
l[:] = [{"abcF" : FailingIterNext()}]:(<class 'NotImplementedError'>, NotImplementedError('next',))
<<< Finished
>>> Testing ConvertFromPyObject using l[:] = [{"abcF" : %s}]
l[:] = [{"abcF" : None}]:NOT FAILED
l[:] = [{"abcF" : {b"": 1}}]:(<class 'ValueError'>, ValueError('empty keys are not allowed',))
l[:] = [{"abcF" : {"": 1}}]:(<class 'ValueError'>, ValueError('empty keys are not allowed',))
l[:] = [{"abcF" : FailingMapping()}]:(<class 'NotImplementedError'>, NotImplementedError('keys',))
l[:] = [{"abcF" : FailingMappingKey()}]:(<class 'NotImplementedError'>, NotImplementedError('getitem:mappingkey',))
l[:] = [{"abcF" : FailingNumber()}]:(<class 'NotImplementedError'>, NotImplementedError('int',))
<<< Finished
>>> Testing StringToChars using l[:] = [Mapping({%s : 1})]
l[:] = [Mapping({1 : 1})]:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
l[:] = [Mapping({b"\0" : 1})]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
l[:] = [Mapping({"\0" : 1})]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing StringToChars using l[:] = [Mapping({"abcG" : {%s : 1}})]
l[:] = [Mapping({"abcG" : {1 : 1}})]:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
l[:] = [Mapping({"abcG" : {b"\0" : 1}})]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
l[:] = [Mapping({"abcG" : {"\0" : 1}})]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing StringToChars using l[:] = [Mapping({"abcG" : Mapping({%s : 1})})]
l[:] = [Mapping({"abcG" : Mapping({1 : 1})})]:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
l[:] = [Mapping({"abcG" : Mapping({b"\0" : 1})})]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
l[:] = [Mapping({"abcG" : Mapping({"\0" : 1})})]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing *Iter* using l[:] = [Mapping({"abcG" : %s})]
l[:] = [Mapping({"abcG" : FailingIter()})]:(<class 'TypeError'>, TypeError('unable to convert FailingIter to a Vim structure',))
l[:] = [Mapping({"abcG" : FailingIterNext()})]:(<class 'NotImplementedError'>, NotImplementedError('next',))
<<< Finished
>>> Testing ConvertFromPyObject using l[:] = [Mapping({"abcG" : %s})]
l[:] = [Mapping({"abcG" : None})]:NOT FAILED
l[:] = [Mapping({"abcG" : {b"": 1}})]:(<class 'ValueError'>, ValueError('empty keys are not allowed',))
l[:] = [Mapping({"abcG" : {"": 1}})]:(<class 'ValueError'>, ValueError('empty keys are not allowed',))
l[:] = [Mapping({"abcG" : FailingMapping()})]:(<class 'NotImplementedError'>, NotImplementedError('keys',))
l[:] = [Mapping({"abcG" : FailingMappingKey()})]:(<class 'NotImplementedError'>, NotImplementedError('getitem:mappingkey',))
l[:] = [Mapping({"abcG" : FailingNumber()})]:(<class 'NotImplementedError'>, NotImplementedError('int',))
<<< Finished
>>> Testing *Iter* using l[:] = [%s]
l[:] = [FailingIter()]:(<class 'TypeError'>, TypeError('unable to convert FailingIter to a Vim structure',))
l[:] = [FailingIterNext()]:(<class 'NotImplementedError'>, NotImplementedError('next',))
<<< Finished
>>> Testing ConvertFromPyObject using l[:] = [%s]
l[:] = [None]:NOT FAILED
l[:] = [{b"": 1}]:(<class 'ValueError'>, ValueError('empty keys are not allowed',))
l[:] = [{"": 1}]:(<class 'ValueError'>, ValueError('empty keys are not allowed',))
l[:] = [FailingMapping()]:(<class 'NotImplementedError'>, NotImplementedError('keys',))
l[:] = [FailingMappingKey()]:(<class 'NotImplementedError'>, NotImplementedError('getitem:mappingkey',))
l[:] = [FailingNumber()]:(<class 'NotImplementedError'>, NotImplementedError('int',))
<<< Finished
>> ListConcatInPlace
>>> Testing *Iter* using l.extend(%s)
l.extend(FailingIter()):(<class 'NotImplementedError'>, NotImplementedError('iter',))
l.extend(FailingIterNext()):(<class 'NotImplementedError'>, NotImplementedError('next',))
<<< Finished
>>> Testing StringToChars using l.extend([{%s : 1}])
l.extend([{1 : 1}]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
l.extend([{b"\0" : 1}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
l.extend([{"\0" : 1}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing StringToChars using l.extend([{"abcF" : {%s : 1}}])
l.extend([{"abcF" : {1 : 1}}]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
l.extend([{"abcF" : {b"\0" : 1}}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
l.extend([{"abcF" : {"\0" : 1}}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing StringToChars using l.extend([{"abcF" : Mapping({%s : 1})}])
l.extend([{"abcF" : Mapping({1 : 1})}]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
l.extend([{"abcF" : Mapping({b"\0" : 1})}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
l.extend([{"abcF" : Mapping({"\0" : 1})}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing *Iter* using l.extend([{"abcF" : %s}])
l.extend([{"abcF" : FailingIter()}]):(<class 'TypeError'>, TypeError('unable to convert FailingIter to a Vim structure',))
l.extend([{"abcF" : FailingIterNext()}]):(<class 'NotImplementedError'>, NotImplementedError('next',))
<<< Finished
>>> Testing ConvertFromPyObject using l.extend([{"abcF" : %s}])
l.extend([{"abcF" : None}]):NOT FAILED
l.extend([{"abcF" : {b"": 1}}]):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
l.extend([{"abcF" : {"": 1}}]):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
l.extend([{"abcF" : FailingMapping()}]):(<class 'NotImplementedError'>, NotImplementedError('keys',))
l.extend([{"abcF" : FailingMappingKey()}]):(<class 'NotImplementedError'>, NotImplementedError('getitem:mappingkey',))
l.extend([{"abcF" : FailingNumber()}]):(<class 'NotImplementedError'>, NotImplementedError('int',))
<<< Finished
>>> Testing StringToChars using l.extend([Mapping({%s : 1})])
l.extend([Mapping({1 : 1})]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
l.extend([Mapping({b"\0" : 1})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
l.extend([Mapping({"\0" : 1})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing StringToChars using l.extend([Mapping({"abcG" : {%s : 1}})])
l.extend([Mapping({"abcG" : {1 : 1}})]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
l.extend([Mapping({"abcG" : {b"\0" : 1}})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
l.extend([Mapping({"abcG" : {"\0" : 1}})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing StringToChars using l.extend([Mapping({"abcG" : Mapping({%s : 1})})])
l.extend([Mapping({"abcG" : Mapping({1 : 1})})]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
l.extend([Mapping({"abcG" : Mapping({b"\0" : 1})})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
l.extend([Mapping({"abcG" : Mapping({"\0" : 1})})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing *Iter* using l.extend([Mapping({"abcG" : %s})])
l.extend([Mapping({"abcG" : FailingIter()})]):(<class 'TypeError'>, TypeError('unable to convert FailingIter to a Vim structure',))
l.extend([Mapping({"abcG" : FailingIterNext()})]):(<class 'NotImplementedError'>, NotImplementedError('next',))
<<< Finished
>>> Testing ConvertFromPyObject using l.extend([Mapping({"abcG" : %s})])
l.extend([Mapping({"abcG" : None})]):NOT FAILED
l.extend([Mapping({"abcG" : {b"": 1}})]):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
l.extend([Mapping({"abcG" : {"": 1}})]):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
l.extend([Mapping({"abcG" : FailingMapping()})]):(<class 'NotImplementedError'>, NotImplementedError('keys',))
l.extend([Mapping({"abcG" : FailingMappingKey()})]):(<class 'NotImplementedError'>, NotImplementedError('getitem:mappingkey',))
l.extend([Mapping({"abcG" : FailingNumber()})]):(<class 'NotImplementedError'>, NotImplementedError('int',))
<<< Finished
>>> Testing *Iter* using l.extend([%s])
l.extend([FailingIter()]):(<class 'TypeError'>, TypeError('unable to convert FailingIter to a Vim structure',))
l.extend([FailingIterNext()]):(<class 'NotImplementedError'>, NotImplementedError('next',))
<<< Finished
>>> Testing ConvertFromPyObject using l.extend([%s])
l.extend([None]):NOT FAILED
l.extend([{b"": 1}]):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
l.extend([{"": 1}]):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
l.extend([FailingMapping()]):(<class 'NotImplementedError'>, NotImplementedError('keys',))
l.extend([FailingMappingKey()]):(<class 'NotImplementedError'>, NotImplementedError('getitem:mappingkey',))
l.extend([FailingNumber()]):(<class 'NotImplementedError'>, NotImplementedError('int',))
<<< Finished
>> ListSetattr
del l.locked:(<class 'AttributeError'>, AttributeError('cannot delete vim.List attributes',))
l.locked = FailingTrue():(<class 'NotImplementedError'>, NotImplementedError('bool',))
l.xxx = True:(<class 'AttributeError'>, AttributeError('cannot set attribute xxx',))
> Function
>> FunctionConstructor
>>> FunctionConstructor
vim.Function("123"):(<class 'ValueError'>, ValueError('unnamed function 123 does not exist',))
vim.Function("xxx_non_existent_function_xxx"):(<class 'ValueError'>, ValueError('function xxx_non_existent_function_xxx does not exist',))
vim.Function("xxx#non#existent#function#xxx"):NOT FAILED
vim.Function("xxx_non_existent_function_xxx2", args=[]):(<class 'ValueError'>, ValueError('function xxx_non_existent_function_xxx2 does not exist',))
vim.Function("xxx_non_existent_function_xxx3", self={}):(<class 'ValueError'>, ValueError('function xxx_non_existent_function_xxx3 does not exist',))
vim.Function("xxx_non_existent_function_xxx4", args=[], self={}):(<class 'ValueError'>, ValueError('function xxx_non_existent_function_xxx4 does not exist',))
>>> FunctionNew
vim.Function("tr", self="abcFuncSelf"):(<class 'AttributeError'>, AttributeError('keys',))
vim.Function("tr", args=427423):(<class 'TypeError'>, TypeError('unable to convert int to a Vim list',))
vim.Function("tr", self="abcFuncSelf2", args="abcFuncArgs2"):(<class 'AttributeError'>, AttributeError('keys',))
vim.Function(self="abcFuncSelf2", args="abcFuncArgs2"):(<class 'AttributeError'>, AttributeError('keys',))
vim.Function("tr", "", self="abcFuncSelf2", args="abcFuncArgs2"):(<class 'AttributeError'>, AttributeError('keys',))
vim.Function("tr", ""):(<class 'TypeError'>, TypeError('function takes exactly 1 argument (2 given)',))
>> FunctionCall
>>> Testing StringToChars using f({%s : 1})
f({1 : 1}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
f({b"\0" : 1}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
f({"\0" : 1}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing StringToChars using f({"abcF" : {%s : 1}})
f({"abcF" : {1 : 1}}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
f({"abcF" : {b"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
f({"abcF" : {"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing StringToChars using f({"abcF" : Mapping({%s : 1})})
f({"abcF" : Mapping({1 : 1})}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
f({"abcF" : Mapping({b"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
f({"abcF" : Mapping({"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing *Iter* using f({"abcF" : %s})
f({"abcF" : FailingIter()}):(<class 'TypeError'>, TypeError('unable to convert FailingIter to a Vim structure',))
f({"abcF" : FailingIterNext()}):(<class 'NotImplementedError'>, NotImplementedError('next',))
<<< Finished
>>> Testing ConvertFromPyObject using f({"abcF" : %s})
f({"abcF" : None}):NOT FAILED
f({"abcF" : {b"": 1}}):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
f({"abcF" : {"": 1}}):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
f({"abcF" : FailingMapping()}):(<class 'NotImplementedError'>, NotImplementedError('keys',))
f({"abcF" : FailingMappingKey()}):(<class 'NotImplementedError'>, NotImplementedError('getitem:mappingkey',))
f({"abcF" : FailingNumber()}):(<class 'NotImplementedError'>, NotImplementedError('int',))
<<< Finished
>>> Testing StringToChars using f(Mapping({%s : 1}))
f(Mapping({1 : 1})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
f(Mapping({b"\0" : 1})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
f(Mapping({"\0" : 1})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing StringToChars using f(Mapping({"abcG" : {%s : 1}}))
f(Mapping({"abcG" : {1 : 1}})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
f(Mapping({"abcG" : {b"\0" : 1}})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
f(Mapping({"abcG" : {"\0" : 1}})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing StringToChars using f(Mapping({"abcG" : Mapping({%s : 1})}))
f(Mapping({"abcG" : Mapping({1 : 1})})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
f(Mapping({"abcG" : Mapping({b"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
f(Mapping({"abcG" : Mapping({"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing *Iter* using f(Mapping({"abcG" : %s}))
f(Mapping({"abcG" : FailingIter()})):(<class 'TypeError'>, TypeError('unable to convert FailingIter to a Vim structure',))
f(Mapping({"abcG" : FailingIterNext()})):(<class 'NotImplementedError'>, NotImplementedError('next',))
<<< Finished
>>> Testing ConvertFromPyObject using f(Mapping({"abcG" : %s}))
f(Mapping({"abcG" : None})):NOT FAILED
f(Mapping({"abcG" : {b"": 1}})):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
f(Mapping({"abcG" : {"": 1}})):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
f(Mapping({"abcG" : FailingMapping()})):(<class 'NotImplementedError'>, NotImplementedError('keys',))
f(Mapping({"abcG" : FailingMappingKey()})):(<class 'NotImplementedError'>, NotImplementedError('getitem:mappingkey',))
f(Mapping({"abcG" : FailingNumber()})):(<class 'NotImplementedError'>, NotImplementedError('int',))
<<< Finished
>>> Testing *Iter* using f(%s)
f(FailingIter()):(<class 'TypeError'>, TypeError('unable to convert FailingIter to a Vim structure',))
f(FailingIterNext()):(<class 'NotImplementedError'>, NotImplementedError('next',))
<<< Finished
>>> Testing ConvertFromPyObject using f(%s)
f(None):NOT FAILED
f({b"": 1}):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
f({"": 1}):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
f(FailingMapping()):(<class 'NotImplementedError'>, NotImplementedError('keys',))
f(FailingMappingKey()):(<class 'NotImplementedError'>, NotImplementedError('getitem:mappingkey',))
f(FailingNumber()):(<class 'NotImplementedError'>, NotImplementedError('int',))
<<< Finished
>>> Testing StringToChars using fd(self={%s : 1})
fd(self={1 : 1}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
fd(self={b"\0" : 1}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
fd(self={"\0" : 1}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing StringToChars using fd(self={"abcF" : {%s : 1}})
fd(self={"abcF" : {1 : 1}}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
fd(self={"abcF" : {b"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
fd(self={"abcF" : {"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing StringToChars using fd(self={"abcF" : Mapping({%s : 1})})
fd(self={"abcF" : Mapping({1 : 1})}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
fd(self={"abcF" : Mapping({b"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
fd(self={"abcF" : Mapping({"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing *Iter* using fd(self={"abcF" : %s})
fd(self={"abcF" : FailingIter()}):(<class 'TypeError'>, TypeError('unable to convert FailingIter to a Vim structure',))
fd(self={"abcF" : FailingIterNext()}):(<class 'NotImplementedError'>, NotImplementedError('next',))
<<< Finished
>>> Testing ConvertFromPyObject using fd(self={"abcF" : %s})
fd(self={"abcF" : None}):NOT FAILED
fd(self={"abcF" : {b"": 1}}):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
fd(self={"abcF" : {"": 1}}):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
fd(self={"abcF" : FailingMapping()}):(<class 'NotImplementedError'>, NotImplementedError('keys',))
fd(self={"abcF" : FailingMappingKey()}):(<class 'NotImplementedError'>, NotImplementedError('getitem:mappingkey',))
fd(self={"abcF" : FailingNumber()}):(<class 'NotImplementedError'>, NotImplementedError('int',))
<<< Finished
>>> Testing StringToChars using fd(self=Mapping({%s : 1}))
fd(self=Mapping({1 : 1})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
fd(self=Mapping({b"\0" : 1})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
fd(self=Mapping({"\0" : 1})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing StringToChars using fd(self=Mapping({"abcG" : {%s : 1}}))
fd(self=Mapping({"abcG" : {1 : 1}})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
fd(self=Mapping({"abcG" : {b"\0" : 1}})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
fd(self=Mapping({"abcG" : {"\0" : 1}})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing StringToChars using fd(self=Mapping({"abcG" : Mapping({%s : 1})}))
fd(self=Mapping({"abcG" : Mapping({1 : 1})})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
fd(self=Mapping({"abcG" : Mapping({b"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
fd(self=Mapping({"abcG" : Mapping({"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
<<< Finished
>>> Testing *Iter* using fd(self=Mapping({"abcG" : %s}))
fd(self=Mapping({"abcG" : FailingIter()})):(<class 'TypeError'>, TypeError('unable to convert FailingIter to a Vim structure',))
fd(self=Mapping({"abcG" : FailingIterNext()})):(<class 'NotImplementedError'>, NotImplementedError('next',))
<<< Finished
>>> Testing ConvertFromPyObject using fd(self=Mapping({"abcG" : %s}))
fd(self=Mapping({"abcG" : None})):NOT FAILED
fd(self=Mapping({"abcG" : {b"": 1}})):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
fd(self=Mapping({"abcG" : {"": 1}})):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
fd(self=Mapping({"abcG" : FailingMapping()})):(<class 'NotImplementedError'>, NotImplementedError('keys',))
fd(self=Mapping({"abcG" : FailingMappingKey()})):(<class 'NotImplementedError'>, NotImplementedError('getitem:mappingkey',))
fd(self=Mapping({"abcG" : FailingNumber()})):(<class 'NotImplementedError'>, NotImplementedError('int',))
<<< Finished
>>> Testing *Iter* using fd(self=%s)
fd(self=FailingIter()):(<class 'TypeError'>, TypeError('unable to convert FailingIter to a Vim dictionary',))
fd(self=FailingIterNext()):(<class 'TypeError'>, TypeError('unable to convert FailingIterNext to a Vim dictionary',))
<<< Finished
>>> Testing ConvertFromPyObject using fd(self=%s)
fd(self=None):(<class 'TypeError'>, TypeError('unable to convert NoneType to a Vim dictionary',))
fd(self={b"": 1}):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
fd(self={"": 1}):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
fd(self=FailingMapping()):(<class 'NotImplementedError'>, NotImplementedError('keys',))
fd(self=FailingMappingKey()):(<class 'NotImplementedError'>, NotImplementedError('getitem:mappingkey',))
fd(self=FailingNumber()):(<class 'TypeError'>, TypeError('unable to convert FailingNumber to a Vim dictionary',))
<<< Finished
>>> Testing ConvertFromPyMapping using fd(self=%s)
fd(self=[]):(<class 'AttributeError'>, AttributeError('keys',))
<<< Finished
> TabPage
>> TabPageAttr
vim.current.tabpage.xxx:(<class 'AttributeError'>, AttributeError("'vim.tabpage' object has no attribute 'xxx'",))
> TabList
>> TabListItem
vim.tabpages[1000]:(<class 'IndexError'>, IndexError('no such tab page',))
> Window
>> WindowAttr
vim.current.window.xxx:(<class 'AttributeError'>, AttributeError("'vim.window' object has no attribute 'xxx'",))
>> WindowSetattr
vim.current.window.buffer = 0:(<class 'TypeError'>, TypeError('readonly attribute: buffer',))
vim.current.window.cursor = (100000000, 100000000):(<class 'vim.error'>, error('cursor position outside buffer',))
vim.current.window.cursor = True:(<class 'TypeError'>, TypeError('argument must be 2-item sequence, not bool',))
>>> Testing NumberToLong using vim.current.window.height = %s
vim.current.window.height = []:(<class 'TypeError'>, TypeError('expected int() or something supporting coercing to int(), but got list',))
vim.current.window.height = None:(<class 'TypeError'>, TypeError('expected int() or something supporting coercing to int(), but got NoneType',))
vim.current.window.height = -1:(<class 'ValueError'>, ValueError('number must be greater or equal to zero',))
<<< Finished
>>> Testing NumberToLong using vim.current.window.width = %s
vim.current.window.width = []:(<class 'TypeError'>, TypeError('expected int() or something supporting coercing to int(), but got list',))
vim.current.window.width = None:(<class 'TypeError'>, TypeError('expected int() or something supporting coercing to int(), but got NoneType',))
vim.current.window.width = -1:(<class 'ValueError'>, ValueError('number must be greater or equal to zero',))
<<< Finished
vim.current.window.xxxxxx = True:(<class 'AttributeError'>, AttributeError('xxxxxx',))
> WinList
>> WinListItem
vim.windows[1000]:(<class 'IndexError'>, IndexError('no such window',))
> Buffer
>> StringToLine (indirect)
vim.current.buffer[0] = "\na":(<class 'vim.error'>, error('string cannot contain newlines',))
vim.current.buffer[0] = b"\na":(<class 'vim.error'>, error('string cannot contain newlines',))
>> SetBufferLine (indirect)
vim.current.buffer[0] = True:(<class 'TypeError'>, TypeError('bad argument type for built-in operation',))
>> SetBufferLineList (indirect)
vim.current.buffer[:] = True:(<class 'TypeError'>, TypeError('bad argument type for built-in operation',))
vim.current.buffer[:] = ["\na", "bc"]:(<class 'vim.error'>, error('string cannot contain newlines',))
>> InsertBufferLines (indirect)
vim.current.buffer.append(None):(<class 'TypeError'>, TypeError('bad argument type for built-in operation',))
vim.current.buffer.append(["\na", "bc"]):(<class 'vim.error'>, error('string cannot contain newlines',))
vim.current.buffer.append("\nbc"):(<class 'vim.error'>, error('string cannot contain newlines',))
>> RBItem
vim.current.buffer[100000000]:(<class 'IndexError'>, IndexError('line number out of range',))
>> RBAsItem
vim.current.buffer[100000000] = "":(<class 'IndexError'>, IndexError('line number out of range',))
>> BufferAttr
vim.current.buffer.xxx:(<class 'AttributeError'>, AttributeError("'vim.buffer' object has no attribute 'xxx'",))
>> BufferSetattr
vim.current.buffer.name = True:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got bool',))
vim.current.buffer.xxx = True:(<class 'AttributeError'>, AttributeError('xxx',))
>> BufferMark
vim.current.buffer.mark(0):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
vim.current.buffer.mark("abcM"):(<class 'ValueError'>, ValueError('mark name must be a single character',))
vim.current.buffer.mark("!"):(<class 'vim.error'>, error('invalid mark name',))
>> BufferRange
vim.current.buffer.range(1, 2, 3):(<class 'TypeError'>, TypeError('function takes exactly 2 arguments (3 given)',))
> BufMap
>> BufMapItem
vim.buffers[100000000]:(<class 'KeyError'>, KeyError(100000000,))
>>> Testing NumberToLong using vim.buffers[%s]
vim.buffers[[]]:(<class 'TypeError'>, TypeError('expected int() or something supporting coercing to int(), but got list',))
vim.buffers[None]:(<class 'TypeError'>, TypeError('expected int() or something supporting coercing to int(), but got NoneType',))
vim.buffers[-1]:(<class 'ValueError'>, ValueError('number must be greater than zero',))
vim.buffers[0]:(<class 'ValueError'>, ValueError('number must be greater than zero',))
<<< Finished
> Current
>> CurrentGetattr
vim.current.xxx:(<class 'AttributeError'>, AttributeError("'vim.currentdata' object has no attribute 'xxx'",))
>> CurrentSetattr
vim.current.line = True:(<class 'TypeError'>, TypeError('bad argument type for built-in operation',))
vim.current.buffer = True:(<class 'TypeError'>, TypeError('expected vim.Buffer object, but got bool',))
vim.current.window = True:(<class 'TypeError'>, TypeError('expected vim.Window object, but got bool',))
vim.current.tabpage = True:(<class 'TypeError'>, TypeError('expected vim.TabPage object, but got bool',))
vim.current.xxx = True:(<class 'AttributeError'>, AttributeError('xxx',))
END
let actual = getline(2, '$')
let n_expected = len(expected)
let n_actual = len(actual)
call assert_equal(n_expected, n_actual, 'number of lines to compare')
" Compare line by line so the errors are easier to understand. Missing lines
" are compared with an empty string.
for i in range(n_expected > n_actual ? n_expected : n_actual)
call assert_equal(i >= n_expected ? '' : expected[i], i >= n_actual ? '' : actual[i])
endfor
close!
endfunc
" Test import
func Test_python3_import()
new
py3 cb = vim.current.buffer
py3 << trim EOF
sys.path.insert(0, os.path.join(os.getcwd(), 'python_before'))
sys.path.append(os.path.join(os.getcwd(), 'python_after'))
vim.options['rtp'] = os.getcwd().replace(',', '\\,').replace('\\', '\\\\')
l = []
def callback(path):
l.append(os.path.relpath(path))
vim.foreach_rtp(callback)
cb.append(repr(l))
del l
def callback(path):
return os.path.relpath(path)
cb.append(repr(vim.foreach_rtp(callback)))
del callback
from module import dir as d
from modulex import ddir
cb.append(d + ',' + ddir)
import before
cb.append(before.dir)
import after
cb.append(after.dir)
import topmodule as tm
import topmodule.submodule as tms
import topmodule.submodule.subsubmodule.subsubsubmodule as tmsss
cb.append(tm.__file__.replace(os.path.sep, '/')[-len('modulex/topmodule/__init__.py'):])
cb.append(tms.__file__.replace(os.path.sep, '/')[-len('modulex/topmodule/submodule/__init__.py'):])
cb.append(tmsss.__file__.replace(os.path.sep, '/')[-len('modulex/topmodule/submodule/subsubmodule/subsubsubmodule.py'):])
del before
del after
del d
del ddir
del tm
del tms
del tmsss
EOF
let expected =<< trim END
['.']
'.'
3,xx
before
after
pythonx/topmodule/__init__.py
pythonx/topmodule/submodule/__init__.py
pythonx/topmodule/submodule/subsubmodule/subsubsubmodule.py
END
call assert_equal(expected, getline(2, '$'))
close!
" Try to import a non-existing module with a dot (.)
call AssertException(['py3 import a.b.c'], "No module named 'a'")
endfunc
" Test exceptions
func Test_python3_exception()
func Exe(e)
execute a:e
endfunc
new
py3 cb = vim.current.buffer
py3 << trim EOF
Exe = vim.bindeval('function("Exe")')
ee('vim.command("throw \'abcN\'")')
ee('Exe("throw \'def\'")')
ee('vim.eval("Exe(\'throw \'\'ghi\'\'\')")')
ee('vim.eval("Exe(\'echoerr \'\'jkl\'\'\')")')
ee('vim.eval("Exe(\'xxx_non_existent_command_xxx\')")')
ee('vim.eval("xxx_unknown_function_xxx()")')
ee('vim.bindeval("Exe(\'xxx_non_existent_command_xxx\')")')
del Exe
EOF
delfunction Exe
let expected =<< trim END
vim.command("throw 'abcN'"):(<class 'vim.error'>, error('abcN',))
Exe("throw 'def'"):(<class 'vim.error'>, error('def',))
vim.eval("Exe('throw ''ghi''')"):(<class 'vim.error'>, error('ghi',))
vim.eval("Exe('echoerr ''jkl''')"):(<class 'vim.error'>, error('Vim(echoerr):jkl',))
vim.eval("Exe('xxx_non_existent_command_xxx')"):(<class 'vim.error'>, error('Vim:E492: Not an editor command: xxx_non_existent_command_xxx',))
vim.eval("xxx_unknown_function_xxx()"):(<class 'vim.error'>, error('Vim:E117: Unknown function: xxx_unknown_function_xxx',))
vim.bindeval("Exe('xxx_non_existent_command_xxx')"):(<class 'vim.error'>, error('Vim:E492: Not an editor command: xxx_non_existent_command_xxx',))
END
call assert_equal(expected, getline(2, '$'))
close!
endfunc
" Regression: interrupting vim.command propagates to next vim.command
func Test_python3_keyboard_interrupt()
new
py3 cb = vim.current.buffer
py3 << trim EOF
def test_keyboard_interrupt():
try:
vim.command('while 1 | endwhile')
except KeyboardInterrupt:
cb.append('Caught KeyboardInterrupt')
except Exception:
cb.append('!!!!!!!! Caught exception: ' + emsg(sys.exc_info()))
else:
cb.append('!!!!!!!! No exception')
try:
vim.command('$ put =\'Running :put\'')
except KeyboardInterrupt:
cb.append('!!!!!!!! Caught KeyboardInterrupt')
except Exception:
cb.append('!!!!!!!! Caught exception: ' + emsg(sys.exc_info()))
else:
cb.append('No exception')
EOF
debuggreedy
call inputsave()
call feedkeys("s\ns\ns\ns\nq\n")
redir => output
debug silent! py3 test_keyboard_interrupt()
redir END
0 debuggreedy
call inputrestore()
py3 del test_keyboard_interrupt
let expected =<< trim END
Caught KeyboardInterrupt
Running :put
No exception
END
call assert_equal(expected, getline(2, '$'))
call assert_equal('', output)
close!
endfunc
" Regression: Iterator for a Vim object should hold a reference.
func Test_python3_iter_ref()
let g:list_iter_ref_count_increase = -1
let g:tuple_iter_ref_count_increase = -1
let g:dict_iter_ref_count_increase = -1
let g:bufmap_iter_ref_count_increase = -1
let g:options_iter_ref_count_increase = -1
py3 << trim EOF
import sys
import vim
def test_python3_iter_ref():
create_list = vim.Function('Create_vim_list')
v = create_list()
base_ref_count = sys.getrefcount(v)
for el in v:
vim.vars['list_iter_ref_count_increase'] = sys.getrefcount(v) - base_ref_count
create_tuple = vim.Function('Create_vim_tuple')
v = create_tuple()
base_ref_count = sys.getrefcount(v)
for el in v:
vim.vars['tuple_iter_ref_count_increase'] = sys.getrefcount(v) - base_ref_count
create_dict = vim.Function('Create_vim_dict')
v = create_dict()
base_ref_count = sys.getrefcount(v)
for el in v:
vim.vars['dict_iter_ref_count_increase'] = sys.getrefcount(v) - base_ref_count
v = vim.buffers
base_ref_count = sys.getrefcount(v)
for el in v:
vim.vars['bufmap_iter_ref_count_increase'] = sys.getrefcount(v) - base_ref_count
v = vim.options
base_ref_count = sys.getrefcount(v)
for el in v:
vim.vars['options_iter_ref_count_increase'] = sys.getrefcount(v) - base_ref_count
test_python3_iter_ref()
EOF
call assert_equal(1, g:list_iter_ref_count_increase)
call assert_equal(1, g:tuple_iter_ref_count_increase)
call assert_equal(1, g:dict_iter_ref_count_increase)
if py3eval('sys.version_info[:2] < (3, 13)')
call assert_equal(1, g:bufmap_iter_ref_count_increase)
else
call assert_equal(0, g:bufmap_iter_ref_count_increase)
endif
call assert_equal(1, g:options_iter_ref_count_increase)
endfunc
func Test_python3_non_utf8_string()
smap <Esc>@ <A-@>
py3 vim.command('redir => _tmp_smaps | smap | redir END')
py3 vim.eval('_tmp_smaps').splitlines()
sunmap <Esc>@
endfunc
func Test_python3_fold_hidden_buffer()
CheckFeature folding
set fdm=expr fde=Fde(v:lnum)
let b:regex = '^'
func Fde(lnum)
let ld = [{}]
let lines = bufnr('%')->getbufline(1, '$')
let was_import = 0
for lnum in range(1, len(lines))
let line = lines[lnum]
call add(ld, {'a': b:regex})
let ld[lnum].foldexpr = was_import ? 1 : '>1'
let was_import = 1
endfor
return ld[a:lnum].foldexpr
endfunc
call setline(1, repeat([''], 15) + repeat(['from'], 3))
eval repeat(['x'], 17)->writefile('Xa.txt', 'D')
split Xa.txt
py3 import vim
py3 b = vim.current.buffer
py3 aaa = b[:]
hide
py3 b[:] = aaa
set fdm& fde&
delfunc Fde
bwipe! Xa.txt
endfunc
" Test to catch regression fix #10437.
func Test_python3_hidden_buf_mod_does_not_mess_up_display()
CheckRunVimInTerminal
let testfile = 'Xtest.vim'
let lines =<< trim END
set hidden number
new
hide
sil call setline(1, repeat(['aaa'], &lines) + ['bbbbbb'])
fu Func()
python3 << EOF
import vim
b = vim.buffers[2]
b[:] = ['', '']
EOF
endfu
norm! Gzb
call feedkeys(":call Func()\r", 'n')
END
call writefile(lines, testfile, 'D')
let rows = 10
let bufnr = term_start([GetVimProg(), '--clean', '-S', testfile], {'term_rows': rows})
call TermWait(bufnr, 100)
call assert_equal('run', job_status(term_getjob(bufnr)))
let g:test_is_flaky = 0
call WaitForAssert({-> assert_match('^ 3 aaa$', term_getline(bufnr, 1))})
call WaitForAssert({-> assert_match('^ 11 bbbbbb$', term_getline(bufnr, rows - 1))})
call term_sendkeys(bufnr, ":qall!\<CR>")
call WaitForAssert({-> assert_equal('dead', job_status(term_getjob(bufnr)))})
exe bufnr . 'bwipe!'
endfunc
" vim: shiftwidth=2 sts=2 expandtab