NOISSUE change uvim folder name to mnv

Signed-off-by: Mehmet Samet Duman <yongdohyun@projecttick.org>

1 files changed, 0 insertions, 4055 deletions

diff --git a/uvim/src/testdir/test_python2.mnv b/uvim/src/testdir/test_python2.mnv
deleted file mode 100644
index 3b1e0f853a..0000000000
--- a/uvim/src/testdir/test_python2.mnv
+++ /dev/null
@@ -1,4055 +0,0 @@
-" Test for python 2 commands.
-
-CheckFeature python
-CheckFeature quickfix
-
-" NOTE: This will cause errors when run under valgrind.
-" This would require recompiling Python with:
-"   ./configure --without-pymalloc
-" See http://svn.python.org/view/python/trunk/Misc/README.valgrind?view=markup
-"
-
-" This function should be called first. This sets up python functions used by
-" the other tests.
-func Test_AAA_python_setup()
-  py << trim EOF
-    import mnv
-    import sys
-
-    def emsg(ei):
-      return ei[0].__name__ + ':' + repr(ei[1].args)
-
-    def ee(expr, g=globals(), l=locals()):
-      try:
-        exec(expr, g, l)
-      except:
-        ei = sys.exc_info()
-        msg = emsg(ei)
-        msg = msg.replace('TypeError:(\'argument 1 ', 'TypeError:(\'')
-        if expr.find('None') > -1:
-          msg = msg.replace('TypeError:(\'iteration over non-sequence\',)',
-                        'TypeError:("\'NoneType\' object is not iterable",)')
-        if expr.find('FailingNumber') > -1:
-          msg = msg.replace(', not \'FailingNumber\'', '').replace('"', '\'')
-          msg = msg.replace('TypeError:(\'iteration over non-sequence\',)',
-                    'TypeError:("\'FailingNumber\' object is not iterable",)')
-        if msg.find('(\'\'') > -1 or msg.find('(\'can\'t') > -1:
-          msg = msg.replace('(\'', '("').replace('\',)', '",)')
-        # 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 expr == 'fd(self=[])':
-          # HACK: PyMapping_Check changed meaning
-          msg = msg.replace('AttributeError:(\'keys\',)',
-                  'TypeError:(\'unable to convert list to mnv dictionary\',)')
-        mnv.current.buffer.append(expr + ':' + msg)
-      else:
-        mnv.current.buffer.append(expr + ':NOT FAILED')
-  EOF
-endfunc
-
-func Test_pydo()
-  new
-
-  " Check deleting lines does not trigger an ml_get error.
-  call setline(1, ['one', 'two', 'three'])
-  pydo mnv.command("%d_")
-  call assert_equal([''], getline(1, '$'))
-
-  call setline(1, ['one', 'two', 'three'])
-  pydo mnv.command("1,2d_")
-  call assert_equal(['three'], getline(1, '$'))
-
-  call setline(1, ['one', 'two', 'three'])
-  pydo mnv.command("2,3d_"); return "REPLACED"
-  call assert_equal(['REPLACED'], getline(1, '$'))
-
-  call setline(1, ['one', 'two', 'three'])
-  2,3pydo mnv.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'])
-  pydo mnv.command("new")
-  call assert_equal(wincount + 1, winnr('$'))
-  bwipe!
-  bwipe!
-
-  " Try modifying a buffer with 'nomodifiable' set
-  set nomodifiable
-  call assert_fails('pydo toupper(line)', 'E21:')
-  set modifiable
-
-  " Invalid command
-  call AssertException(['pydo non_existing_cmd'],
-        \ "MNV(pydo):NameError: global name 'non_existing_cmd' is not defined")
-  call AssertException(["pydo raise Exception('test')"],
-        \ 'MNV(pydo):Exception: test')
-  call AssertException(["pydo {lambda}"],
-        \ 'MNV(pydo):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
-  pydo mnv.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_mnv_function()
-  " Check creating mnv.Function object
-
-  func s:foo()
-    return matchstr(expand('<sfile>'), '<SNR>\zs\d\+_foo$')
-  endfunc
-  let name = '<SNR>' . s:foo()
-
-  try
-    py f = mnv.bindeval('function("s:foo")')
-    call assert_equal(name, pyeval('f.name'))
-  catch
-    call assert_false(v:exception)
-  endtry
-
-  try
-    py f = mnv.Function('\x80\xfdR' + mnv.eval('s:foo()'))
-    call assert_equal(name, 'f.name'->pyeval())
-  catch
-    call assert_false(v:exception)
-  endtry
-
-  " Non-existing function attribute
-  call AssertException(["let x = pyeval('f.abc')"],
-        \ 'MNV(let):AttributeError: abc')
-
-  py del f
-  delfunc s:foo
-endfunc
-
-func Test_skipped_python_command_does_not_affect_pyxversion()
-  set pyxversion=0
-  if 0
-    python import mnv
-  endif
-  call assert_equal(0, &pyxversion)  " This assertion would have failed with MNV 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()
-  py mnv.buffers[ int( mnv.eval( 'bufnr("hidden")' ) ) ][:] = None
-  call assert_equal( line( '.' ), 11 )
-  call _CleanUpHiddenBuffer()
-endfunc
-
-func Test_Write_To_HiddenBuffer_Does_Not_Fix_Cursor_List()
-  call _SetUpHiddenBuffer()
-  py mnv.buffers[ int( mnv.eval( 'bufnr("hidden")' ) ) ][:] = [ 'test' ]
-  call assert_equal( line( '.' ), 11 )
-  call _CleanUpHiddenBuffer()
-endfunc
-
-func Test_Write_To_HiddenBuffer_Does_Not_Fix_Cursor_Str()
-  call _SetUpHiddenBuffer()
-  py mnv.buffers[ int( mnv.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()
-  py mnv.buffers[ int( mnv.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()
-
-  py mnv.current.buffer[:] = None
-  call assert_equal( line( '.' ), 1 )
-
-  bwipe!
-endfunc
-
-func Test_Write_To_Current_Buffer_Fixes_Cursor_List()
-  call _SetUpVisibleBuffer()
-
-  py mnv.current.buffer[:] = [ 'test' ]
-  call assert_equal( line( '.' ), 1 )
-
-  bwipe!
-endfunc
-
-func Test_Write_To_Current_Buffer_Fixes_Cursor_Str()
-  call _SetUpVisibleBuffer()
-
-  py mnv.current.buffer[-1] = None
-  call assert_equal( line( '.' ), 10 )
-
-  bwipe!
-endfunc
-
-func Test_Catch_Exception_Message()
-  try
-    py raise RuntimeError( 'TEST' )
-  catch /.*/
-    call assert_match( '^MNV(.*):RuntimeError: TEST$', v:exception )
-  endtry
-endfunc
-
-" Test for various heredoc syntax
-func Test_python_heredoc()
-  python << END
-s='A'
-END
-  python <<
-s+='B'
-.
-  python << trim END
-    s+='C'
-  END
-  python << trim
-    s+='D'
-  .
-  python << trim eof
-    s+='E'
-  eof
-python << trimm
-s+='F'
-trimm
-  call assert_equal('ABCDEF', pyxeval('s'))
-endfunc
-
-" Test for the buffer range object
-func Test_python_range()
-  new
-  call setline(1, ['one', 'two', 'three'])
-  py b = mnv.current.buffer
-  py r = b.range(1, 3)
-  call assert_equal(0, pyeval('r.start'))
-  call assert_equal(2, pyeval('r.end'))
-  call assert_equal('one', pyeval('r[0]'))
-  call assert_equal('one', pyeval('r[-3]'))
-  call assert_equal('three', pyeval('r[-4]'))
-  call assert_equal(['two', 'three'], pyeval('r[1:]'))
-  py r[0] = 'green'
-  call assert_equal(['green', 'two', 'three'], getline(1, '$'))
-  py r[0:2] = ['red', 'blue']
-  call assert_equal(['red', 'blue', 'three'], getline(1, '$'))
-  call assert_equal(['start', 'end', '__members__'], pyeval('r.__members__'))
-
-  " try different invalid start/end index for the range slice
-  %d
-  call setline(1, ['one', 'two', 'three'])
-  py r[-10:1] = ["a"]
-  py r[10:12] = ["b"]
-  py r[-10:-9] = ["c"]
-  py 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 = pyeval('r[:]')
-
-  " Non-existing range attribute
-  call AssertException(["let x = pyeval('r.abc')"],
-        \ 'MNV(let):AttributeError: abc')
-
-  close!
-endfunc
-
-" Test for the python tabpage object
-func Test_python_tabpage()
-  tabnew
-  py t = mnv.tabpages[1]
-  py wl = t.windows
-  tabclose
-  " Accessing a closed tabpage
-  call AssertException(["let n = pyeval('t.number')"],
-        \ 'MNV(let):mnv.error: attempt to refer to deleted tab page')
-  call AssertException(["let n = pyeval('len(wl)')"],
-        \ 'MNV(let):mnv.error: attempt to refer to deleted tab page')
-  call AssertException(["py w = wl[0]"],
-        \ 'MNV(python):mnv.error: attempt to refer to deleted tab page')
-  call AssertException(["py mnv.current.tabpage = t"],
-        \ 'MNV(python):mnv.error: attempt to refer to deleted tab page')
-  call assert_match('<tabpage object (deleted)', pyeval('repr(t)'))
-  %bw!
-endfunc
-
-" Test for the python window object
-func Test_python_window()
-  " Test for setting the window height
-  10new
-  py mnv.current.window.height = 5
-  call assert_equal(5, winheight(0))
-  py mnv.current.window.height = 3.2
-  call assert_equal(3, winheight(0))
-
-  " Test for setting the window width
-  10vnew
-  py mnv.current.window.width = 6
-  call assert_equal(6, winwidth(0))
-
-  " Try accessing a closed window
-  py w = mnv.current.window
-  py wopts = w.options
-  close
-  " Access the attributes of a closed window
-  call AssertException(["let n = pyeval('w.number')"],
-        \ 'MNV(let):mnv.error: attempt to refer to deleted window')
-  call AssertException(["py w.height = 5"],
-        \ 'MNV(python):mnv.error: attempt to refer to deleted window')
-  call AssertException(["py mnv.current.window = w"],
-        \ 'MNV(python):mnv.error: attempt to refer to deleted window')
-  " Try to set one of the options of the closed window
-  " The following caused an ASAN failure
-  call AssertException(["py wopts['list'] = False"],
-        \ 'mnv.error: attempt to refer to deleted window')
-  call assert_match('<window object (deleted)', pyeval("repr(w)"))
-  %bw!
-endfunc
-
-" Test for the python List object
-func Test_python_list()
-  let l = [1, 2]
-  py pl = mnv.bindeval('l')
-  call assert_equal(['locked', '__members__'], pyeval('pl.__members__'))
-
-  " Try to convert a null List
-  call AssertException(["py t = mnv.eval('test_null_list()')"],
-        \ 'MNV(python):SystemError: error return without exception set')
-
-  " Try to convert a List with a null List item
-  call AssertException(["py t = mnv.eval('[test_null_list()]')"],
-        \ 'MNV(python):SystemError: error return without exception set')
-
-  " Try to bind a null List variable (works because an empty list is used)
-  let cmds =<< trim END
-    let l = test_null_list()
-    py ll = mnv.bindeval('l')
-  END
-  call AssertException(cmds, '')
-
-  let l = []
-  py l = mnv.bindeval('l')
-  py f = mnv.bindeval('function("strlen")')
-  " Extending List directly with different types
-  py l.extend([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
-  py l[0] = 0
-  call assert_equal([0, "as'd", [1, 2, function("strlen"), {'a': 1}]], l)
-  py l[-2] = f
-  call assert_equal([0, function("strlen"), [1, 2, function("strlen"), {'a': 1}]], l)
-
-  " appending to a list
-  let l = [1, 2]
-  py ll = mnv.bindeval('l')
-  py ll[2] = 8
-  call assert_equal([1, 2, 8], l)
-
-  " Using dict as an index
-  call AssertException(['py ll[{}] = 10'],
-        \ 'MNV(python):TypeError: index must be int or slice, not dict')
-endfunc
-
-" Test for the python Tuple object
-func Test_python_tuple()
-  " Try to convert a null tuple
-  call AssertException(["py l = mnv.eval('test_null_tuple()')"],
-        \ 'MNV(python):SystemError: error return without exception set')
-
-  " Try to convert a Tuple with a null Tuple item
-  call AssertException(["py t = mnv.eval('(test_null_tuple(),)')"],
-        \ 'MNV(python):SystemError: error return without exception set')
-
-  " Try to convert a List with a null Tuple item
-  call AssertException(["py t = mnv.eval('[test_null_tuple()]')"],
-        \ 'MNV(python):SystemError: error return without exception set')
-
-  " Try to convert a Tuple with a null List item
-  call AssertException(["py t = mnv.eval('(test_null_list(),)')"],
-        \ 'MNV(python):SystemError: error return without exception set')
-
-  " Try to bind a null Tuple variable (works because an empty tuple is used)
-  let cmds =<< trim END
-    let t = test_null_tuple()
-    py tt = mnv.bindeval('t')
-  END
-  call AssertException(cmds, '')
-
-  " Creating a tuple using different iterators
-  py t1 = mnv.Tuple(['abc', 20, 1.2, (4, 5)])
-  call assert_equal(('abc', 20, 1.2, (4, 5)), pyeval('t1'))
-  py t2 = mnv.Tuple('abc')
-  call assert_equal(('a', 'b', 'c'), pyeval('t2'))
-  py t3 = mnv.Tuple({'color': 'red', 'model': 'ford'})
-  call assert_equal(('color', 'model'), pyeval('t3'))
-  py t4 = mnv.Tuple()
-  call assert_equal((), pyeval('t4'))
-  py t5 = mnv.Tuple(x**2 for x in range(5))
-  call assert_equal((0, 1, 4, 9, 16), pyeval('t5'))
-  py t6 = mnv.Tuple(('abc', 20, 1.2, (4, 5)))
-  call assert_equal(('abc', 20, 1.2, (4, 5)), pyeval('t6'))
-
-  " Convert between MNV tuple/list and python tuple/list
-  py t = mnv.Tuple(mnv.bindeval("('a', ('b',), ['c'], {'s': 'd'})"))
-  call assert_equal(('a', ('b',), ['c'], {'s': 'd'}), pyeval('t'))
-  call assert_equal(['a', ('b',), ['c'], {'s': 'd'}], pyeval('list(t)'))
-  call assert_equal(('a', ('b',), ['c'], {'s': 'd'}), pyeval('tuple(t)'))
-
-  py l = mnv.List(mnv.bindeval("['e', ('f',), ['g'], {'s': 'h'}]"))
-  call assert_equal(('e', ('f',), ['g'], {'s': 'h'}), pyeval('tuple(l)'))
-
-  " Tuple assignment
-  py tt = mnv.bindeval('("a", "b")')
-  call AssertException(['py tt[0] = 10'],
-        \ "MNV(python):TypeError: 'mnv.tuple' object does not support item assignment")
-  py tt = mnv.bindeval('("a", "b")')
-  call AssertException(['py tt[0:1] = (10, 20)'],
-        \ "MNV(python):TypeError: 'mnv.tuple' object does not support item assignment")
-
-  " iterating over tuple from Python
-  py print([x for x in mnv.bindeval("('a', 'b')")])
-
-  " modifying a list item within a tuple
-  let t = ('a', ['b', 'c'], 'd')
-  py mnv.bindeval('t')[1][1] = 'x'
-  call assert_equal(('a', ['b', 'x'], 'd'), t)
-
-  " length of a tuple
-  let t = ()
-  py p_t = mnv.bindeval('t')
-  call assert_equal(0, pyeval('len(p_t)'))
-  let t = ('a', )
-  py p_t = mnv.bindeval('t')
-  call assert_equal(1, pyeval('len(p_t)'))
-  let t = ('a', 'b', 'c')
-  py p_t = mnv.bindeval('t')
-  call assert_equal(3, pyeval('len(p_t)'))
-
-  " membership test
-  let t = ('a', 'b', 'c')
-  py p_t = mnv.bindeval('t')
-  call assert_true(pyeval("b'c' in p_t"))
-  call assert_true(pyeval("b'd' not in p_t"))
-
-  py x = mnv.eval('("a", (2), [3], {})')
-  call assert_equal(('a', '2', ['3'], {}), pyeval('x'))
-
-  " Using a keyword argument for a tuple
-  call AssertException(['py x = mnv.Tuple(a=1)'],
-        \ 'MNV(python):TypeError: tuple constructor does not accept keyword arguments')
-
-  " Using dict as an index
-  call AssertException(['py x = tt[{}]'],
-        \ 'MNV(python):TypeError: index must be int or slice, not dict')
-  call AssertException(['py x = tt["abc"]'],
-        \ 'MNV(python):TypeError: index must be int or slice, not str')
-
-  call AssertException(['py del tt.locked'],
-        \ 'MNV(python):AttributeError: cannot delete mnv.Tuple attributes')
-
-  call AssertException(['py tt.foobar = 1'],
-        \ 'MNV(python):AttributeError: cannot set attribute foobar')
-endfunc
-
-" Test for the python Dict object
-func Test_python_dict()
-  let d = {}
-  py pd = mnv.bindeval('d')
-  call assert_equal(['locked', 'scope', '__members__'],
-        \ pyeval('pd.__members__'))
-
-  " Try to convert a null Dict
-  call AssertException(["py t = mnv.eval('test_null_dict()')"],
-        \ 'MNV(python):SystemError: error return without exception set')
-
-  " Try to convert a Dict with a null List value
-  call AssertException(["py t = mnv.eval(\"{'a' : test_null_list()}\")"],
-        \ 'MNV(python):SystemError: error return without exception set')
-
-  " Try to convert a Dict with a null string key
-  py t = mnv.eval("{test_null_string() : 10}")
-  call assert_fails("let d = pyeval('t')", 'E859:')
-
-  " Dict length
-  let d = {'a' : 10, 'b' : 20}
-  py d = mnv.bindeval('d')
-  call assert_equal(2, pyeval('len(d)'))
-
-  " Deleting a non-existing key
-  call AssertException(["py del d['c']"], "MNV(python):KeyError: 'c'")
-endfunc
-
-" Extending Dictionary directly with different types
-func Test_python_dict_extend()
-  let d = {}
-  func d.f()
-    return 1
-  endfunc
-
-  py f = mnv.bindeval('function("strlen")')
-  py << trim EOF
-    d = mnv.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()
-    cmpfun = lambda a, b: cmp(repr(a), repr(b))
-    dk.sort(cmpfun)
-    dv.sort(cmpfun)
-    di.sort(cmpfun)
-  EOF
-
-  " Try extending a locked dictionary
-  lockvar d
-  call AssertException(["py d.update({'b' : 20})"],
-        \ 'MNV(python):mnv.error: dictionary is locked')
-  unlockvar d
-
-  call assert_equal(1, pyeval("d['f'](self={})"))
-  call assert_equal("['-1', '0', '1', 'b', 'f']", pyeval('repr(dk)'))
-  call assert_equal("['asd', -1L, <mnv.Function '1'>, <mnv.dictionary object at >, <mnv.list object at >]", substitute(pyeval('repr(dv)'),'0x\x\+','','g'))
-  call assert_equal("[('-1', <mnv.dictionary object at >), ('0', -1L), ('1', 'asd'), ('b', <mnv.list object at >), ('f', <mnv.Function '1'>)]", substitute(pyeval('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)))
-  py del dk
-  py del di
-  py del dv
-endfunc
-
-func Test_python_list_del_items()
-  " removing items with del
-  let l = [0, function("strlen"), [1, 2, function("strlen"), {'a': 1}]]
-  py l = mnv.bindeval('l')
-  py del l[2]
-  call assert_equal("[0, function('strlen')]", string(l))
-
-  let l = range(8)
-  py l = mnv.bindeval('l')
-  py del l[:3]
-  py 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]
-  py l = mnv.bindeval('l')
-  py del l[2:1]
-  call assert_equal([0, 1, 2, 3], l)
-  py del l[2:2]
-  call assert_equal([0, 1, 2, 3], l)
-  py del l[2:3]
-  call assert_equal([0, 1, 3], l)
-
-  let l = [0, 1, 2, 3]
-  py l = mnv.bindeval('l')
-  py del l[2:4]
-  call assert_equal([0, 1], l)
-
-  let l = [0, 1, 2, 3]
-  py l = mnv.bindeval('l')
-  py del l[2:5]
-  call assert_equal([0, 1], l)
-
-  let l = [0, 1, 2, 3]
-  py l = mnv.bindeval('l')
-  py 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]
-  py l = mnv.bindeval('l')
-  py del l[-1:2]
-  call assert_equal([0, 1, 2, 3], l)
-  py del l[-2:2]
-  call assert_equal([0, 1, 2, 3], l)
-  py del l[-3:2]
-  call assert_equal([0, 2, 3], l)
-
-  let l = [0, 1, 2, 3]
-  py l = mnv.bindeval('l')
-  py del l[-4:2]
-  call assert_equal([2, 3], l)
-
-  let l = [0, 1, 2, 3]
-  py l = mnv.bindeval('l')
-  py del l[-5:2]
-  call assert_equal([2, 3], l)
-
-  let l = [0, 1, 2, 3]
-  py l = mnv.bindeval('l')
-  py del l[-6:2]
-  call assert_equal([2, 3], l)
-
-  let l = [0, 1, 2, 3]
-  py l = mnv.bindeval('l')
-  py del l[::2]
-  call assert_equal([1, 3], l)
-
-  let l = [0, 1, 2, 3]
-  py l = mnv.bindeval('l')
-  py del l[3:0:-2]
-  call assert_equal([0, 2], l)
-
-  let l = [0, 1, 2, 3]
-  py l = mnv.bindeval('l')
-  py del l[2:4:-2]
-  let l = [0, 1, 2, 3]
-endfunc
-
-func Test_python_dict_del_items()
-  let d = eval("{'0' : -1, '1' : 'asd', 'b' : [1, 2, function('strlen')], 'f' : function('min'), '-1' : {'a': 1}}")
-  py d = mnv.bindeval('d')
-  py del d['-1']
-  py del d['f']
-  call assert_equal([1, 2, function('strlen')], pyeval('d.get(''b'', 1)'))
-  call assert_equal([1, 2, function('strlen')], pyeval('d.pop(''b'')'))
-  call assert_equal(1, pyeval('d.get(''b'', 1)'))
-  call assert_equal('asd', pyeval('d.pop(''1'', 2)'))
-  call assert_equal(2, pyeval('d.pop(''1'', 2)'))
-  call assert_equal('True', pyeval('repr(d.has_key(''0''))'))
-  call assert_equal('False', pyeval('repr(d.has_key(''1''))'))
-  call assert_equal('True', pyeval('repr(''0'' in d)'))
-  call assert_equal('False', pyeval('repr(''1'' in d)'))
-  call assert_equal("['0']", pyeval('repr(list(iter(d)))'))
-  call assert_equal({'0' : -1}, d)
-  call assert_equal("('0', -1L)", pyeval('repr(d.popitem())'))
-  call assert_equal('None', pyeval('repr(d.get(''0''))'))
-  call assert_equal('[]', pyeval('repr(list(iter(d)))'))
-endfunc
-
-" Slice assignment to a list
-func Test_python_slice_assignment()
-  let l = [0, 1, 2, 3]
-  py l = mnv.bindeval('l')
-  py l[0:0] = ['a']
-  call assert_equal(['a', 0, 1, 2, 3], l)
-
-  let l = [0, 1, 2, 3]
-  py l = mnv.bindeval('l')
-  py l[1:2] = ['b']
-  call assert_equal([0, 'b', 2, 3], l)
-
-  let l = [0, 1, 2, 3]
-  py l = mnv.bindeval('l')
-  py l[2:4] = ['c']
-  call assert_equal([0, 1, 'c'], l)
-
-  let l = [0, 1, 2, 3]
-  py l = mnv.bindeval('l')
-  py l[4:4] = ['d']
-  call assert_equal([0, 1, 2, 3, 'd'], l)
-
-  let l = [0, 1, 2, 3]
-  py l = mnv.bindeval('l')
-  py l[-1:2] = ['e']
-  call assert_equal([0, 1, 2, 'e', 3], l)
-
-  let l = [0, 1, 2, 3]
-  py l = mnv.bindeval('l')
-  py l[-10:2] = ['f']
-  call assert_equal(['f', 2, 3], l)
-
-  let l = [0, 1, 2, 3]
-  py l = mnv.bindeval('l')
-  py l[2:-10] = ['g']
-  call assert_equal([0, 1, 'g', 2, 3], l)
-
-  let l = []
-  py l = mnv.bindeval('l')
-  py l[0:0] = ['h']
-  call assert_equal(['h'], l)
-
-  let l = range(8)
-  py l = mnv.bindeval('l')
-  py l[2:6:2] = [10, 20]
-  call assert_equal([0, 1, 10, 3, 20, 5, 6, 7], l)
-
-  let l = range(8)
-  py l = mnv.bindeval('l')
-  py l[6:2:-2] = [10, 20]
-  call assert_equal([0, 1, 2, 3, 20, 5, 10, 7], l)
-
-  let l = range(8)
-  py l = mnv.bindeval('l')
-  py l[6:2] = ()
-  call assert_equal([0, 1, 2, 3, 4, 5, 6, 7], l)
-
-  let l = range(8)
-  py l = mnv.bindeval('l')
-  py l[6:2:1] = ()
-  call assert_equal([0, 1, 2, 3, 4, 5, 6, 7], l)
-
-  let l = range(8)
-  py l = mnv.bindeval('l')
-  py l[2:2:1] = ()
-  call assert_equal([0, 1, 2, 3, 4, 5, 6, 7], l)
-
-  call AssertException(["py x = l[10:11:0]"],
-        \ "MNV(python):ValueError: slice step cannot be zero")
-endfunc
-
-" Locked variables
-func Test_python_lockedvar()
-  new
-  py cb = mnv.current.buffer
-  let l = [0, 1, 2, 3]
-  py l = mnv.bindeval('l')
-  lockvar! l
-  py << trim EOF
-    try:
-        l[2]='i'
-    except mnv.error:
-        cb.append('l[2] threw mnv.error: ' + emsg(sys.exc_info()))
-  EOF
-  call assert_equal(['', "l[2] threw mnv.error: error:('list is locked',)"],
-        \ getline(1, '$'))
-
-  " Try to concatenate a locked list
-  call AssertException(['py l += [4, 5]'],
-        \ 'MNV(python):mnv.error: list is locked')
-
-  call assert_equal([0, 1, 2, 3], l)
-  unlockvar! l
-  close!
-endfunc
-
-" Test for calling a function
-func Test_python_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')]
-  py l = mnv.bindeval('l')
-  py l.extend(list(l[0](1, 2, 3)))
-  call assert_equal([function('New'), function('DictNew'), 'NewStart', 1, 2, 3, 'NewEnd'], l)
-  py 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)
-  py l.extend([l[0].name])
-  call assert_equal([function('New'), function('DictNew'), 'NewStart', 1, 2, 3, 'NewEnd', 'DictNewStart', 1, 2, 3, 'DictNewEnd', {'a': 'b'}, 'New'], l)
-  py ee('l[1](1, 2, 3)')
-  call assert_equal("l[1](1, 2, 3):error:('MNV:E725: Calling dict function without Dictionary: DictNew',)", getline(2))
-  %d
-  py f = l[0]
-  delfunction New
-  py ee('f(1, 2, 3)')
-  call assert_equal("f(1, 2, 3):error:('MNV:E117: Unknown function: New',)", getline(2))
-  close!
-  delfunction DictNew
-endfunc
-
-func Test_python_float()
-  let l = [0.0]
-  py l = mnv.bindeval('l')
-  py l.extend([0.0])
-  call assert_equal([0.0, 0.0], l)
-endfunc
-
-" Test for Dict key errors
-func Test_python_dict_key_error()
-  let messages = []
-  py << trim EOF
-    d = mnv.bindeval('{}')
-    m = mnv.bindeval('messages')
-    def em(expr, g=globals(), l=locals()):
-      try:
-        exec(expr, g, l)
-      except:
-        m.extend([sys.exc_type.__name__])
-
-    em('d["abc1"]')
-    em('d["abc1"]="\\0"')
-    em('d["abc1"]=mnv')
-    em('d[""]=1')
-    em('d["a\\0b"]=1')
-    em('d[u"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_python_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 'py ' .. name .. ' = mnv.bindeval("' .. s .. '")'
-    call add(res, s .. ' : ' .. join(map(['locked', 'scope'],
-          \ 'v:val .. ":" .. pyeval(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
-  py d.locked = True
-  py 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 'py ' .. name .. '=mnv.bindeval("' .. s .. '")'
-    call add(res, s .. ' : locked:' .. pyeval(name .. '.locked'))
-  endfor
-  call assert_equal(['l : locked:0', 'll : locked:1'], res)
-
-  silent! call extend(l, [0])
-  silent! call extend(ll, [0])
-  py l.locked = True
-  py 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
-  py a = mnv.bindeval('v:argv')
-  call AssertException(['py a.locked = 0'],
-        \ 'MNV(python):TypeError: cannot modify fixed list')
-endfunc
-
-" Test for locking/unlocking a tuple
-func Test_tuple_lock()
-  let t = (1, 2, 3)
-  py t = mnv.bindeval('t')
-  py t.locked = True
-  call assert_equal(1, islocked('t'))
-  py t.locked = False
-  call assert_equal(0, islocked('t'))
-endfunc
-
-" Test for pyeval()
-func Test_python_pyeval()
-  let l = pyeval('range(3)')
-  call assert_equal([0, 1, 2], l)
-
-  let t = pyeval('("a", "b", "c")')
-  call assert_equal(("a", "b", "c"), t)
-
-  let d = pyeval('{"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, pyeval('None'))
-  call assert_equal('', v:errmsg)
-
-  py v = mnv.eval('test_null_function()')
-  call assert_equal(v:none, pyeval('v'))
-
-  call assert_equal(0.0, pyeval('0.0'))
-
-  " Evaluate an invalid values
-  call AssertException(['let v = pyeval(''"\0"'')'], 'E859:')
-  call AssertException(['let v = pyeval(''{"\0" : 1}'')'], 'E859:')
-  call AssertException(['let v = pyeval("undefined_name")'],
-        \ "MNV(let):NameError: name 'undefined_name' is not defined")
-  call AssertException(['let v = pyeval("mnv")'], 'E859:')
-endfunc
-
-" Test for pyeval with locals
-func Test_python_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', pyeval('s', locals))
-  call assert_equal(0xbadb33f, pyeval('n', locals))
-  call assert_equal(d, pyeval('d', locals))
-  call assert_equal(l, pyeval('l', locals))
-  call assert_equal(t, pyeval('t', locals))
-  call assert_equal('a-b-c', 'b"-".join(t)'->pyeval({'t': ('a', 'b', 'c')}))
-
-  py << 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, pyeval('__UpdateDict( d, {"c": 3} )["c"]', locals))
-  call assert_equal(3, d['c'])
-
-  " check append lo list
-  call assert_equal(4, pyeval('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, pyeval('f("abc")', {'f': StrLen}))
-endfunc
-
-" Test for mnv.bindeval()
-func Test_python_mnv_bindeval()
-  " Float
-  let f = 3.14
-  py f = mnv.bindeval('f')
-  call assert_equal(3.14, pyeval('f'))
-
-  " Blob
-  let b = 0z12
-  py b = mnv.bindeval('b')
-  call assert_equal("\x12", pyeval('b'))
-
-  " Bool
-  call assert_equal(1, pyeval("mnv.bindeval('v:true')"))
-  call assert_equal(0, pyeval("mnv.bindeval('v:false')"))
-  call assert_equal(v:none, pyeval("mnv.bindeval('v:null')"))
-  call assert_equal(v:none, pyeval("mnv.bindeval('v:none')"))
-
-  " channel/job
-  if has('channel')
-    call assert_equal(v:none, pyeval("mnv.bindeval('test_null_channel()')"))
-  endif
-  if has('job')
-    call assert_equal(v:none, pyeval("mnv.bindeval('test_null_job()')"))
-  endif
-endfunc
-
-" threading
-" Running pydo 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_python_threading()
-  let l = [0]
-  py l = mnv.bindeval('l')
-  py << 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
-  py t.running = False
-  py t.join()
-
-  " Check if the background thread is working.  Count should be 10, but on a
-  " busy system (AppVeyor) it can be much lower.
-  py l[0] = t.t > 4
-  py del time
-  py del threading
-  py del t
-  call assert_equal([1], l)
-endfunc
-
-" settrace
-func Test_python_settrace()
-  let l = []
-  py l = mnv.bindeval('l')
-  py << trim EOF
-    import sys
-
-    def traceit(frame, event, arg):
-      global l
-      if event == "line":
-          l.extend([frame.f_lineno])
-      return traceit
-
-    def trace_main():
-      for i in range(5):
-        pass
-  EOF
-  py sys.settrace(traceit)
-  py trace_main()
-  py sys.settrace(None)
-  py del traceit
-  py del trace_main
-  call assert_equal([1, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 1], l)
-endfunc
-
-" Slice
-func Test_python_list_slice()
-  py ll = mnv.bindeval('[0, 1, 2, 3, 4, 5]')
-  py l = ll[:4]
-  call assert_equal([0, 1, 2, 3], pyeval('l'))
-  py l = ll[2:]
-  call assert_equal([2, 3, 4, 5], pyeval('l'))
-  py l = ll[:-4]
-  call assert_equal([0, 1], pyeval('l'))
-  py l = ll[-2:]
-  call assert_equal([4, 5], pyeval('l'))
-  py l = ll[2:4]
-  call assert_equal([2, 3], pyeval('l'))
-  py l = ll[4:2]
-  call assert_equal([], pyeval('l'))
-  py l = ll[-4:-2]
-  call assert_equal([2, 3], pyeval('l'))
-  py l = ll[-2:-4]
-  call assert_equal([], pyeval('l'))
-  py l = ll[:]
-  call assert_equal([0, 1, 2, 3, 4, 5], pyeval('l'))
-  py l = ll[0:6]
-  call assert_equal([0, 1, 2, 3, 4, 5], pyeval('l'))
-  py l = ll[-10:10]
-  call assert_equal([0, 1, 2, 3, 4, 5], pyeval('l'))
-  py l = ll[4:2:-1]
-  call assert_equal([4, 3], pyeval('l'))
-  py l = ll[::2]
-  call assert_equal([0, 2, 4], pyeval('l'))
-  py l = ll[4:2:1]
-  call assert_equal([], pyeval('l'))
-
-  " Error case: Use an invalid index
-  call AssertException(['py ll[-10] = 5'], 'MNV(python):mnv.error: internal error:')
-
-  " Use a step value of 0
-  call AssertException(['py ll[0:3:0] = [1, 2, 3]'],
-        \ 'MNV(python):ValueError: slice step cannot be zero')
-
-  " Error case: Invalid slice type
-  call AssertException(["py x = ll['abc']"],
-        \ 'MNV(python):TypeError: index must be int or slice, not str')
-  py del l
-
-  " Error case: List with a null list item
-  let l = [test_null_list()]
-  py ll = mnv.bindeval('l')
-  call AssertException(["py x = ll[:]"],
-        \ 'MNV(python):SystemError: error return without exception set')
-endfunc
-
-" Slice
-func Test_python_tuple_slice()
-  py tt = mnv.bindeval('(0, 1, 2, 3, 4, 5)')
-  py t = tt[:4]
-  call assert_equal((0, 1, 2, 3), pyeval('t'))
-  py t = tt[2:]
-  call assert_equal((2, 3, 4, 5), pyeval('t'))
-  py t = tt[:-4]
-  call assert_equal((0, 1), pyeval('t'))
-  py t = tt[-2:]
-  call assert_equal((4, 5), pyeval('t'))
-  py t = tt[2:4]
-  call assert_equal((2, 3), pyeval('t'))
-  py t = tt[4:2]
-  call assert_equal((), pyeval('t'))
-  py t = tt[-4:-2]
-  call assert_equal((2, 3), pyeval('t'))
-  py t = tt[-2:-4]
-  call assert_equal((), pyeval('t'))
-  py t = tt[:]
-  call assert_equal((0, 1, 2, 3, 4, 5), pyeval('t'))
-  py t = tt[0:6]
-  call assert_equal((0, 1, 2, 3, 4, 5), pyeval('t'))
-  py t = tt[-10:10]
-  call assert_equal((0, 1, 2, 3, 4, 5), pyeval('t'))
-  py t = tt[4:2:-1]
-  call assert_equal((4, 3), pyeval('t'))
-  py t = tt[::2]
-  call assert_equal((0, 2, 4), pyeval('t'))
-  py t = tt[4:2:1]
-  call assert_equal((), pyeval('t'))
-
-  " Error case: Use an invalid index
-  call AssertException(['py x = tt[-10]'], 'MNV(python):IndexError: tuple index out of range')
-
-  " Use a step value of 0
-  call AssertException(['py x = tt[0:3:0]'],
-        \ 'MNV(python):ValueError: slice step cannot be zero')
-
-  " Error case: Invalid slice type
-  call AssertException(["py x = tt['abc']"],
-        \ "MNV(python):TypeError: index must be int or slice, not str")
-
-  " Error case: List with a null tuple item
-  let t = (test_null_tuple(),)
-  py tt = mnv.bindeval('t')
-  call AssertException(["py x = tt[:]"], 'MNV(python):SystemError: error return without exception set')
-endfunc
-
-func Test_python_pytuple_to_mnvtuple()
-  let t = pyeval("('a', 'b')")
-  call assert_equal(('a', 'b'), t)
-  let t = pyeval("()")
-  call assert_equal((), t)
-  let t = pyeval("('x',)")
-  call assert_equal(('x',), t)
-  let t = pyeval("((1, 2), (), (3, 4))")
-  call assert_equal(((1, 2), (), (3, 4)), t)
-  let t = pyeval("((1, 2), {'a': 10}, [5, 6])")
-  call assert_equal(((1, 2), {'a': 10}, [5, 6]), t)
-
-  " Invalid python tuple
-  py << trim END
-    class FailingIter(object):
-      def __iter__(self):
-        raise NotImplementedError('iter')
-  END
-  call assert_fails('call pyeval("(1, FailingIter, 2)")',
-        \ 'E859: Failed to convert returned python object to a MNV value')
-
-  py del FailingIter
-endfunc
-
-" Test for tuple garbage collection
-func Test_python_tuple_garbage_collect()
-  let t = (1, (2, 3), [4, 5], {'a': 6})
-  py py_t = mnv.bindeval('t')
-  let save_testing = v:testing
-  let v:testing = 1
-  call test_garbagecollect_now()
-  let v:testing = save_testing
-
-  let new_t = pyeval('py_t')
-  call assert_equal((1, (2, 3), [4, 5], {'a': 6}), new_t)
-endfunc
-
-" Vars
-func Test_python_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', pyeval('mnv.vvars[''exception'']'))
-  endtry
-  call assert_equal('bac', pyeval('mnv.vars[''foo'']'))
-  call assert_equal('def', pyeval('mnv.current.window.vars[''abc3'']'))
-  call assert_equal('bar', pyeval('mnv.current.buffer.vars[''baz'']'))
-  call assert_equal('jkl', pyeval('mnv.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_python_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
-
-  py << trim EOF
-    def e(s, g=globals(), l=locals()):
-      try:
-        exec(s, g, l)
-      except:
-        mnv.command('return ' + repr(sys.exc_type.__name__))
-
-    def ev(s, g=globals(), l=locals()):
-      try:
-        return eval(s, g, l)
-      except:
-        mnv.command('let exc=' + repr(sys.exc_type.__name__))
-        return 0
-  EOF
-
-  func E(s)
-    python e(mnv.eval('a:s'))
-  endfunc
-
-  func Ev(s)
-    let r = pyeval('ev(mnv.eval("a:s"))')
-    if exists('exc')
-      throw exc
-    endif
-    return r
-  endfunc
-
-  py gopts1 = mnv.options
-  py wopts1 = mnv.windows[2].options
-  py wopts2 = mnv.windows[0].options
-  py wopts3 = mnv.windows[1].options
-  py bopts1 = mnv.buffers[mnv.bindeval("g:bufs")[2]].options
-  py bopts2 = mnv.buffers[mnv.bindeval("g:bufs")[1]].options
-  py bopts3 = mnv.buffers[mnv.bindeval("g:bufs")[0]].options
-  call add(g:res, 'wopts iters equal: ' ..
-        \ pyeval('list(wopts1) == list(wopts2)'))
-  call add(g:res, 'bopts iters equal: ' ..
-        \ pyeval('list(bopts1) == list(bopts2)'))
-  py gset = set(iter(gopts1))
-  py wset = set(iter(wopts1))
-  py 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
-    py oname = mnv.eval('oname')
-    py oval1 = mnv.bindeval('oval1')
-    py oval2 = mnv.bindeval('oval2')
-    py oval3 = mnv.bindeval('oval3')
-    if invval is 0 || invval is 1
-      py invval = bool(mnv.bindeval('invval'))
-    else
-      py invval = mnv.bindeval('invval')
-    endif
-    if bool
-      py oval1 = bool(oval1)
-      py oval2 = bool(oval2)
-      py oval3 = bool(oval3)
-    endif
-    call add(g:res, '>>> ' .. oname)
-    call add(g:res, '  g/w/b:' .. pyeval('oname in gset') .. '/' ..
-          \ pyeval('oname in wset') .. '/' .. pyeval('oname in bset'))
-    call add(g:res, '  g/w/b (in):' .. pyeval('oname in gopts1') .. '/' ..
-          \ pyeval('oname in wopts1') .. '/' .. pyeval('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
-  py del ev
-  py del e
-  only
-  for buf in g:bufs[1:]
-    execute 'bwipeout!' buf
-  endfor
-  py del gopts1
-  py del wopts1
-  py del wopts2
-  py del wopts3
-  py del bopts1
-  py del bopts2
-  py del bopts3
-  py del oval1
-  py del oval2
-  py del oval3
-  py del oname
-  py 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: ''
-      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: ''
-      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: ''
-      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: ''
-      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: '.,..,,'
-      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, pyeval("'' in mnv.options"))
-
-  " use an empty key to index mnv.options
-  call AssertException(["let v = pyeval(\"mnv.options['']\")"],
-        \ 'MNV(let):ValueError: empty keys are not allowed')
-  call AssertException(["py mnv.current.window.options[''] = 0"],
-        \ 'MNV(python):ValueError: empty keys are not allowed')
-  call AssertException(["py mnv.current.window.options[{}] = 0"],
-        \ 'MNV(python):TypeError: expected str() or unicode() instance, but got dict')
-
-  " set one of the number options to a very large number
-  let cmd = ["py mnv.options['previewheight'] = 9999999999999999"]
-  call AssertException(cmd, 'OverflowError:')
-
-  " unset a global-local string option
-  call AssertException(["py del mnv.options['errorformat']"],
-        \ 'MNV(python):ValueError: unable to unset global option errorformat')
-endfunc
-
-" Test for mnv.buffer object
-func Test_python_buffer()
-  new
-  call setline(1, "Hello\nWorld")
-  call assert_fails("let x = pyeval('mnv.current.buffer[0]')", 'E859:')
-  %bw!
-
-  edit Xfile1
-  let bnr1 = bufnr()
-  py cb = mnv.current.buffer
-  vnew Xfile2
-  let bnr2 = bufnr()
-  call setline(1, ['First line', 'Second line', 'Third line'])
-  py b = mnv.current.buffer
-  wincmd w
-
-  " Test for getting lines from the buffer using a slice
-  call assert_equal(['First line'], pyeval('b[-10:1]'))
-  call assert_equal(['Third line'], pyeval('b[2:10]'))
-  call assert_equal([], pyeval('b[2:0]'))
-  call assert_equal([], pyeval('b[10:12]'))
-  call assert_equal([], pyeval('b[-10:-8]'))
-  call AssertException(["py x = b[0:3:0]"],
-        \ "MNV(python):TypeError: sequence index must be integer, not 'slice'")
-  call AssertException(["py b[0:3:0] = 'abc'"],
-        \ "MNV(python):TypeError: sequence index must be integer, not 'slice'")
-  call AssertException(["py x = b[{}]"],
-        \ "MNV(python):TypeError: sequence index must be integer, not 'dict'")
-  call AssertException(["py b[{}] = 'abc'"],
-        \ "MNV(python):TypeError: sequence index must be integer, not 'dict'")
-
-  " Test for getting lines using a range
-  call AssertException(["py x = b.range(0,3)[0:2:0]"],
-        \ "MNV(python):TypeError: sequence index must be integer, not 'slice'")
-  call AssertException(["py b.range(0,3)[0:2:0] = 'abc'"],
-        \ "MNV(python):TypeError: sequence index must be integer, not 'slice'")
-
-  " Tests BufferAppend and BufferItem
-  py cb.append(b[0])
-  call assert_equal(['First line'], getbufline(bnr1, 2))
-  %d
-
-  " Try to append using out-of-range line number
-  call AssertException(["py b.append('abc', 10)"],
-        \ 'MNV(python):IndexError: line number out of range')
-
-  " Append a non-string item
-  call AssertException(["py b.append([22])"],
-        \ 'MNV(python):TypeError: expected str() or unicode() instance, but got int')
-
-  " Tests BufferSlice and BufferAssSlice
-  py cb.append('abc5') # Will be overwritten
-  py cb[-1:] = b[:-2]
-  call assert_equal(['First line'], getbufline(bnr1, 2))
-  %d
-
-  " Test BufferLength and BufferAssSlice
-  py cb.append('def') # Will not be overwritten
-  py 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
-  py cb.append('ghi') # Will be overwritten
-  py cb[-1] = repr((len(cb) - cb.mark('a')[0], cb.mark('a')[1]))
-  call assert_equal(['(3, 2)'], getbufline(bnr1, 4))
-  %d
-
-  " Test BufferRepr
-  py cb.append(repr(cb) + repr(b))
-  call assert_equal(['<buffer Xfile1><buffer Xfile2>'], getbufline(bnr1, 2))
-  %d
-
-  " Modify foreign buffer
-  py << trim EOF
-    b.append('foo')
-    b[0]='bar'
-    b[0:0]=['baz']
-    mnv.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 * python cb.append(mnv.eval('expand("<abuf>")') + ':BufFilePost:' + mnv.eval('bufnr("%")'))
-    autocmd BufFilePre * python cb.append(mnv.eval('expand("<abuf>")') + ':BufFilePre:' + mnv.eval('bufnr("%")'))
-  augroup END
-  py << 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
-  py << trim EOF
-    for _b in mnv.buffers:
-      if _b is not cb:
-        mnv.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
-
-  py << trim EOF
-    for expr in ('b[1]','b[:] = ["A", "B"]','b[:]','b.append("abc6")', 'b.name = "!"'):
-      try:
-        exec(expr)
-      except mnv.error:
-        pass
-      else:
-        # Usually a SEGV here
-        # Should not happen in any case
-        cb.append('No exception for ' + expr)
-    mnv.command('cd .')
-    del b
-  EOF
-  call assert_equal([''], getline(1, '$'))
-
-  " Delete all the lines in a buffer
-  call setline(1, ['a', 'b', 'c'])
-  py mnv.current.buffer[:] = []
-  call assert_equal([''], getline(1, '$'))
-
-  " Test for buffer marks
-  call assert_equal(v:none, pyeval("mnv.current.buffer.mark('r')"))
-
-  " Test for modifying a 'nomodifiable' buffer
-  setlocal nomodifiable
-  call AssertException(["py mnv.current.buffer[0] = 'abc'"],
-        \ "MNV(python):mnv.error: MNV:E21: Cannot make changes, 'modifiable' is off")
-  call AssertException(["py mnv.current.buffer[0] = None"],
-        \ "MNV(python):mnv.error: MNV:E21: Cannot make changes, 'modifiable' is off")
-  call AssertException(["py mnv.current.buffer[:] = None"],
-        \ "MNV(python):mnv.error: MNV:E21: Cannot make changes, 'modifiable' is off")
-  call AssertException(["py mnv.current.buffer[:] = []"],
-        \ "MNV(python):mnv.error: MNV:E21: Cannot make changes, 'modifiable' is off")
-  call AssertException(["py mnv.current.buffer.append('abc')"],
-        \ "MNV(python):mnv.error: MNV:E21: Cannot make changes, 'modifiable' is off")
-  call AssertException(["py mnv.current.buffer.append([])"],
-        \ "MNV(python):mnv.error: MNV:E21: Cannot make changes, 'modifiable' is off")
-  setlocal modifiable
-
-  augroup BUFS
-    autocmd!
-  augroup END
-  augroup! BUFS
-  %bw!
-
-  " Range object for a deleted buffer
-  new Xpbuffile
-  call setline(1, ['one', 'two', 'three'])
-  py b = mnv.current.buffer
-  py r = mnv.current.buffer.range(0, 2)
-  call assert_equal('<range Xpbuffile (0:2)>', pyeval('repr(r)'))
-  %bw!
-  call AssertException(['py r[:] = []'],
-        \ 'MNV(python):mnv.error: attempt to refer to deleted buffer')
-  call assert_match('<buffer object (deleted)', pyeval('repr(b)'))
-  call assert_match('<range object (for deleted buffer)', pyeval('repr(r)'))
-  call AssertException(["let n = pyeval('len(r)')"],
-        \ 'MNV(let):mnv.error: attempt to refer to deleted buffer')
-  call AssertException(["py r.append('abc')"],
-        \ 'MNV(python):mnv.error: attempt to refer to deleted buffer')
-
-  " object for a deleted buffer
-  call AssertException(["py b[0] = 'one'"],
-        \ 'MNV(python):mnv.error: attempt to refer to deleted buffer')
-  call AssertException(["py b.append('one')"],
-        \ 'MNV(python):mnv.error: attempt to refer to deleted buffer')
-  call AssertException(["let n = pyeval('len(b)')"],
-        \ 'MNV(let):mnv.error: attempt to refer to deleted buffer')
-  call AssertException(["py pos = b.mark('a')"],
-        \ 'MNV(python):mnv.error: attempt to refer to deleted buffer')
-  call AssertException(["py mnv.current.buffer = b"],
-        \ 'MNV(python):mnv.error: attempt to refer to deleted buffer')
-  call AssertException(["py rn = b.range(0, 2)"],
-        \ 'MNV(python):mnv.error: attempt to refer to deleted buffer')
-endfunc
-
-" Test mnv.buffers object
-func Test_python_buffers()
-  %bw!
-  edit Xpbuffile
-  py cb = mnv.current.buffer
-  set hidden
-  edit a
-  buffer #
-  edit b
-  buffer #
-  edit c
-  buffer #
-  py << trim EOF
-    try:
-      from __builtin__ import next
-    except ImportError:
-      next = lambda o: o.next()
-    # Check GCing iterator that was not fully exhausted
-    i = iter(mnv.buffers)
-    cb.append('i:' + str(next(i)))
-    # and also check creating more than one iterator at a time
-    i2 = iter(mnv.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(mnv.buffers)
-    cb.append('i3:' + str(next(i3)))
-    del i3
-  EOF
-  call assert_equal(['i:<buffer Xpbuffile>',
-        \ 'i2:<buffer Xpbuffile>', 'i:<buffer a>', 'i3:<buffer Xpbuffile>'],
-        \ getline(2, '$'))
-  %d
-
-  py << trim EOF
-    prevnum = 0
-    for b in mnv.buffers:
-      # Check buffer order
-      if prevnum >= b.number:
-        cb.append('!!! Buffer numbers not in strictly ascending order')
-      # Check indexing: mnv.buffers[number].number == number
-      cb.append(str(b.number) + ':' + repr(mnv.buffers[b.number]) + \
-                                                            '=' + repr(b))
-      prevnum = b.number
-    del prevnum
-
-    cb.append(str(len(mnv.buffers)))
-  EOF
-  call assert_equal([bufnr('Xpbuffile') .. ':<buffer Xpbuffile>=<buffer Xpbuffile>',
-        \ bufnr('a') .. ':<buffer a>=<buffer a>',
-        \ bufnr('b') .. ':<buffer b>=<buffer b>',
-        \ bufnr('c') .. ':<buffer c>=<buffer c>', '4'], getline(2, '$'))
-  %d
-
-  py << trim EOF
-    bnums = list(map(lambda b: b.number, mnv.buffers))[1:]
-
-    # Test wiping out buffer with existing iterator
-    i4 = iter(mnv.buffers)
-    cb.append('i4:' + str(next(i4)))
-    mnv.command('bwipeout! ' + str(bnums.pop(0)))
-    try:
-      next(i4)
-    except mnv.error:
-      pass
-    else:
-      cb.append('!!!! No mnv.error')
-    i4 = iter(mnv.buffers)
-    mnv.command('bwipeout! ' + str(bnums.pop(-1)))
-    mnv.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 Xpbuffile>',
-        \ 'i4:<buffer Xpbuffile>', 'StopIteration'], getline(2, '$'))
-  %bw!
-endfunc
-
-" Test mnv.{tabpage,window}list and mnv.{tabpage,window} objects
-func Test_python_tabpage_window()
-  %bw
-  edit Xpbuffile
-  py cb = mnv.current.buffer
-  tabnew 0
-  tabnew 1
-  vnew a.1
-  tabnew 2
-  vnew a.2
-  vnew b.2
-  vnew c.2
-
-  call assert_equal(4, pyeval('mnv.current.window.tabpage.number'))
-
-  py << trim EOF
-    cb.append('Number of tabs: ' + str(len(mnv.tabpages)))
-    cb.append('Current tab pages:')
-    def W(w):
-      if repr(w).find('(unknown)') != -1:
-        return '<window object (unknown)>'
-      else:
-        return repr(w)
-
-    start = len(cb)
-
-    def Cursor(w):
-      if w.buffer is cb:
-        return repr((start - w.cursor[0], w.cursor[1]))
-      else:
-        return repr(w.cursor)
-
-    for t in mnv.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 long:
-              raise TypeError
-            if aval < 0:
-              raise ValueError
-          except Exception:
-            cb.append('!!!!!! Error while getting attribute ' + attr + \
-                                            ': ' + sys.exc_type.__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(mnv.windows)))
-    if list(mnv.windows) != list(mnv.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 Xpbuffile>; 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('Xpbuffile'), 2, '$'))
-  %bw!
-endfunc
-
-" Test mnv.current
-func Test_python_mnv_current()
-  %bw
-  edit Xpbuffile
-  py cb = mnv.current.buffer
-  tabnew 0
-  tabnew 1
-  vnew a.1
-  tabnew 2
-  vnew a.2
-  vnew b.2
-  vnew c.2
-
-  py << trim EOF
-    def H(o):
-      return repr(o)
-    cb.append('Current tab page: ' + repr(mnv.current.tabpage))
-    cb.append('Current window: ' + repr(mnv.current.window) + ': ' + \
-               H(mnv.current.window) + ' is ' + H(mnv.current.tabpage.window))
-    cb.append('Current buffer: ' + repr(mnv.current.buffer) + ': ' + \
-               H(mnv.current.buffer) + ' is ' + H(mnv.current.window.buffer)+ \
-               ' is ' + H(mnv.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('Xpbuffile'), 2, '$'))
-  call deletebufline(bufnr('Xpbuffile'), 1, '$')
-
-  " Assigning: fails
-  py << trim EOF
-    try:
-      mnv.current.window = mnv.tabpages[0].window
-    except ValueError:
-      cb.append('ValueError at assigning foreign tab window')
-
-    for attr in ('window', 'tabpage', 'buffer'):
-      try:
-        setattr(mnv.current, attr, None)
-      except TypeError:
-        cb.append('Type error at assigning None to mnv.current.' + attr)
-    del attr
-  EOF
-
-  let expected =<< trim END
-    ValueError at assigning foreign tab window
-    Type error at assigning None to mnv.current.window
-    Type error at assigning None to mnv.current.tabpage
-    Type error at assigning None to mnv.current.buffer
-  END
-  call assert_equal(expected, getbufline(bufnr('Xpbuffile'), 2, '$'))
-  call deletebufline(bufnr('Xpbuffile'), 1, '$')
-
-  call setbufline(bufnr('Xpbuffile'), 1, 'python interface')
-  py << trim EOF
-    # Assigning: success
-    mnv.current.tabpage = mnv.tabpages[-2]
-    mnv.current.buffer = cb
-    mnv.current.window = mnv.windows[0]
-    mnv.current.window.cursor = (len(mnv.current.buffer), 0)
-    cb.append('Current tab page: ' + repr(mnv.current.tabpage))
-    cb.append('Current window: ' + repr(mnv.current.window))
-    cb.append('Current buffer: ' + repr(mnv.current.buffer))
-    cb.append('Current line: ' + repr(mnv.current.line))
-  EOF
-
-  let expected =<< trim END
-    Current tab page: <tabpage 2>
-    Current window: <window 0>
-    Current buffer: <buffer Xpbuffile>
-    Current line: 'python interface'
-  END
-  call assert_equal(expected, getbufline(bufnr('Xpbuffile'), 2, '$'))
-  py mnv.current.line = 'one line'
-  call assert_equal('one line', getline('.'))
-  call deletebufline(bufnr('Xpbuffile'), 1, '$')
-
-  py << trim EOF
-    ws = list(mnv.windows)
-    ts = list(mnv.tabpages)
-    for b in mnv.buffers:
-      if b is not cb:
-        mnv.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('Xpbuffile'), 2, '$'))
-  %bw!
-endfunc
-
-" Test types
-func Test_python_types()
-  %d
-  py cb = mnv.current.buffer
-  py << trim EOF
-    for expr, attr in (
-      ('mnv.vars',                         'Dictionary'),
-      ('mnv.options',                      'Options'),
-      ('mnv.bindeval("{}")',               'Dictionary'),
-      ('mnv.bindeval("[]")',               'List'),
-      ('mnv.bindeval("function(\'tr\')")', 'Function'),
-      ('mnv.current.buffer',               'Buffer'),
-      ('mnv.current.range',                'Range'),
-      ('mnv.current.window',               'Window'),
-      ('mnv.current.tabpage',              'TabPage'),
-    ):
-      cb.append(expr + ':' + attr + ':' + \
-                                repr(type(eval(expr)) is getattr(mnv, attr)))
-    del expr
-    del attr
-  EOF
-  let expected =<< trim END
-    mnv.vars:Dictionary:True
-    mnv.options:Options:True
-    mnv.bindeval("{}"):Dictionary:True
-    mnv.bindeval("[]"):List:True
-    mnv.bindeval("function('tr')"):Function:True
-    mnv.current.buffer:Buffer:True
-    mnv.current.range:Range:True
-    mnv.current.window:Window:True
-    mnv.current.tabpage:TabPage:True
-  END
-  call assert_equal(expected, getline(2, '$'))
-endfunc
-
-" Test __dir__() method
-func Test_python_dir_method()
-  %d
-  py cb = mnv.current.buffer
-  py << trim EOF
-    for name, o in (
-            ('current',    mnv.current),
-            ('buffer',     mnv.current.buffer),
-            ('window',     mnv.current.window),
-            ('tabpage',    mnv.current.tabpage),
-            ('range',      mnv.current.range),
-            ('dictionary', mnv.bindeval('{}')),
-            ('list',       mnv.bindeval('[]')),
-            ('tuple',       mnv.bindeval('()')),
-            ('function',   mnv.bindeval('function("tr")')),
-            ('output',     sys.stdout),
-        ):
-        cb.append(name + ':' + ','.join(dir(o)))
-    del name
-    del o
-  EOF
-  let expected =<< trim END
-    current:__dir__,__members__,buffer,line,range,tabpage,window
-    buffer:__dir__,__members__,append,mark,name,number,options,range,valid,vars
-    window:__dir__,__members__,buffer,col,cursor,height,number,options,row,tabpage,valid,vars,width
-    tabpage:__dir__,__members__,number,valid,vars,window,windows
-    range:__dir__,__members__,append,end,start
-    dictionary:__dir__,__members__,get,has_key,items,keys,locked,pop,popitem,scope,update,values
-    list:__dir__,__members__,extend,locked
-    tuple:__dir__,__members__,locked
-    function:__dir__,__members__,args,auto_rebind,self,softspace
-    output:__dir__,__members__,close,closed,flush,isatty,readable,seekable,softspace,writable,write,writelines
-  END
-  call assert_equal(expected, getline(2, '$'))
-endfunc
-
-" Test mnv.*.__new__
-func Test_python_new()
-  call assert_equal({}, pyeval('mnv.Dictionary({})'))
-  call assert_equal({'a': 1}, pyeval('mnv.Dictionary(a=1)'))
-  call assert_equal({'a': 1}, pyeval('mnv.Dictionary(((''a'', 1),))'))
-  call assert_equal([], pyeval('mnv.List()'))
-  call assert_equal((), pyeval('mnv.Tuple()'))
-  call assert_equal(['a', 'b', 'c', '7'], pyeval('mnv.List(iter(''abc7''))'))
-  call assert_equal(('a', 'b', 'c', '7'), pyeval('mnv.Tuple(iter(''abc7''))'))
-  call assert_equal(function('tr'), pyeval('mnv.Function(''tr'')'))
-  call assert_equal(function('tr', [123, 3, 4]),
-        \ pyeval('mnv.Function(''tr'', args=[123, 3, 4])'))
-  call assert_equal(function('tr'), pyeval('mnv.Function(''tr'', args=[])'))
-  call assert_equal(function('tr', {}),
-        \ pyeval('mnv.Function(''tr'', self={})'))
-  call assert_equal(function('tr', [123, 3, 4], {}),
-        \ pyeval('mnv.Function(''tr'', args=[123, 3, 4], self={})'))
-  call assert_equal(function('tr'),
-        \ pyeval('mnv.Function(''tr'', auto_rebind=False)'))
-  call assert_equal(function('tr', [123, 3, 4]),
-        \ pyeval('mnv.Function(''tr'', args=[123, 3, 4], auto_rebind=False)'))
-  call assert_equal(function('tr'),
-        \ pyeval('mnv.Function(''tr'', args=[], auto_rebind=False)'))
-  call assert_equal(function('tr', {}),
-        \ pyeval('mnv.Function(''tr'', self={}, auto_rebind=False)'))
-  call assert_equal(function('tr', [123, 3, 4], {}),
-        \ pyeval('mnv.Function(''tr'', args=[123, 3, 4], self={}, auto_rebind=False)'))
-endfunc
-
-" Test mnv.Function
-func Test_python_mnv_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': []})
-  py Pt = mnv.bindeval('Pt')
-  unlet Pt
-  py del Pt
-
-  call assert_equal(3, pyeval('mnv.strwidth("a\tb")'))
-
-  %bw!
-  py cb = mnv.current.buffer
-  py << 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: ' + mnv.Function('string')(ret)
-        cb.append(line)
-    a = mnv.Function('Args')
-    pa1 = mnv.Function('Args', args=['abcArgsPA1'])
-    pa2 = mnv.Function('Args', args=[])
-    pa3 = mnv.Function('Args', args=['abcArgsPA3'], self={'abcSelfPA3': 'abcSelfPA3Val'})
-    pa4 = mnv.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 = mnv.Function('SelfArgs')
-    psa1 = mnv.Function('SelfArgs', args=['abcArgsPSA1'])
-    psa2 = mnv.Function('SelfArgs', args=[])
-    psa3 = mnv.Function('SelfArgs', args=['abcArgsPSA3'], self={'abcSelfPSA3': 'abcSelfPSA3Val'})
-    psa4 = mnv.Function('SelfArgs', self={'abcSelfPSA4': 'abcSelfPSA4Val'})
-    psa5 = mnv.Function('SelfArgs', self={'abcSelfPSA5': 'abcSelfPSA5Val'}, auto_rebind=0)
-    psa6 = mnv.Function('SelfArgs', args=['abcArgsPSA6'], self={'abcSelfPSA6': 'abcSelfPSA6Val'}, auto_rebind=())
-    psa7 = mnv.Function('SelfArgs', args=['abcArgsPSA7'], auto_rebind=[])
-    psa8 = mnv.Function('SelfArgs', auto_rebind=False)
-    psa9 = mnv.Function('SelfArgs', self={'abcSelfPSA9': 'abcSelfPSA9Val'}, auto_rebind=True)
-    psaA = mnv.Function('SelfArgs', args=['abcArgsPSAA'], self={'abcSelfPSAA': 'abcSelfPSAAVal'}, auto_rebind=1)
-    psaB = mnv.Function('SelfArgs', args=['abcArgsPSAB'], auto_rebind={'abcARPSAB': 'abcARPSABVal'})
-    psaC = mnv.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 = mnv.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: <mnv.Function 'Args'>
-    pa1: <mnv.Function 'Args', args=['abcArgsPA1']>
-    pa2: <mnv.Function 'Args'>
-    pa3: <mnv.Function 'Args', args=['abcArgsPA3'], self={'abcSelfPA3': 'abcSelfPA3Val'}>
-    pa4: <mnv.Function 'Args', self={'abcSelfPA4': 'abcSelfPA4Val'}>
-    sa: <mnv.Function 'SelfArgs'>
-    psa1: <mnv.Function 'SelfArgs', args=['abcArgsPSA1']>
-    psa2: <mnv.Function 'SelfArgs'>
-    psa3: <mnv.Function 'SelfArgs', args=['abcArgsPSA3'], self={'abcSelfPSA3': 'abcSelfPSA3Val'}>
-    psa4: <mnv.Function 'SelfArgs', self={'abcSelfPSA4': 'abcSelfPSA4Val'}>
-    psa5: <mnv.Function 'SelfArgs', self={'abcSelfPSA5': 'abcSelfPSA5Val'}>
-    psa6: <mnv.Function 'SelfArgs', args=['abcArgsPSA6'], self={'abcSelfPSA6': 'abcSelfPSA6Val'}>
-    psa7: <mnv.Function 'SelfArgs', args=['abcArgsPSA7']>
-    psa8: <mnv.Function 'SelfArgs'>
-    psa9: <mnv.Function 'SelfArgs', self={'abcSelfPSA9': 'abcSelfPSA9Val'}, auto_rebind=True>
-    psaA: <mnv.Function 'SelfArgs', args=['abcArgsPSAA'], self={'abcSelfPSAA': 'abcSelfPSAAVal'}, auto_rebind=True>
-    psaB: <mnv.Function 'SelfArgs', args=['abcArgsPSAB']>
-    psaC: <mnv.Function 'SelfArgs'>
-    psar: <mnv.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'), pyeval('a'))
-  call assert_equal(function('Args', ['abcArgsPA1']), pyeval('pa1'))
-  call assert_equal(function('Args'), pyeval('pa2'))
-  call assert_equal(function('Args', ['abcArgsPA3'], {'abcSelfPA3': 'abcSelfPA3Val'}), pyeval('pa3'))
-  call assert_equal(function('Args', {'abcSelfPA4': 'abcSelfPA4Val'}), pyeval('pa4'))
-  call assert_equal(function('SelfArgs'), pyeval('sa'))
-  call assert_equal(function('SelfArgs', ['abcArgsPSA1']), pyeval('psa1'))
-  call assert_equal(function('SelfArgs'), pyeval('psa2'))
-  call assert_equal(function('SelfArgs', ['abcArgsPSA3'], {'abcSelfPSA3': 'abcSelfPSA3Val'}), pyeval('psa3'))
-  call assert_equal(function('SelfArgs', {'abcSelfPSA4': 'abcSelfPSA4Val'}), pyeval('psa4'))
-  call assert_equal(function('SelfArgs', {'abcSelfPSA5': 'abcSelfPSA5Val'}), pyeval('psa5'))
-  call assert_equal(function('SelfArgs', ['abcArgsPSA6'], {'abcSelfPSA6': 'abcSelfPSA6Val'}), pyeval('psa6'))
-  call assert_equal(function('SelfArgs', ['abcArgsPSA7']), pyeval('psa7'))
-  call assert_equal(function('SelfArgs'), pyeval('psa8'))
-  call assert_equal(function('SelfArgs', {'abcSelfPSA9': 'abcSelfPSA9Val'}), pyeval('psa9'))
-  call assert_equal(function('SelfArgs', ['abcArgsPSAA'], {'abcSelfPSAA': 'abcSelfPSAAVal'}), pyeval('psaA'))
-  call assert_equal(function('SelfArgs', ['abcArgsPSAB']), pyeval('psaB'))
-  call assert_equal(function('SelfArgs'), pyeval('psaC'))
-
-  let res = []
-  for v in ['sa', 'psa1', 'psa2', 'psa3', 'psa4', 'psa5', 'psa6', 'psa7',
-        \ 'psa8', 'psa9', 'psaA', 'psaB', 'psaC']
-    let d = {'f': pyeval(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)
-
-  py ecall('a()', a, )
-  py ecall('pa1()', pa1, )
-  py ecall('pa2()', pa2, )
-  py ecall('pa3()', pa3, )
-  py ecall('pa4()', pa4, )
-  py ecall('sa()', sa, )
-  py ecall('psa1()', psa1, )
-  py ecall('psa2()', psa2, )
-  py ecall('psa3()', psa3, )
-  py ecall('psa4()', psa4, )
-
-  py ecall('a(42, 43)', a, 42, 43)
-  py ecall('pa1(42, 43)', pa1, 42, 43)
-  py ecall('pa2(42, 43)', pa2, 42, 43)
-  py ecall('pa3(42, 43)', pa3, 42, 43)
-  py ecall('pa4(42, 43)', pa4, 42, 43)
-  py ecall('sa(42, 43)', sa, 42, 43)
-  py ecall('psa1(42, 43)', psa1, 42, 43)
-  py ecall('psa2(42, 43)', psa2, 42, 43)
-  py ecall('psa3(42, 43)', psa3, 42, 43)
-  py ecall('psa4(42, 43)', psa4, 42, 43)
-
-  py ecall('a(42, self={"20": 1})', a, 42, self={'20': 1})
-  py ecall('pa1(42, self={"20": 1})', pa1, 42, self={'20': 1})
-  py ecall('pa2(42, self={"20": 1})', pa2, 42, self={'20': 1})
-  py ecall('pa3(42, self={"20": 1})', pa3, 42, self={'20': 1})
-  py ecall('pa4(42, self={"20": 1})', pa4, 42, self={'20': 1})
-  py ecall('sa(42, self={"20": 1})', sa, 42, self={'20': 1})
-  py ecall('psa1(42, self={"20": 1})', psa1, 42, self={'20': 1})
-  py ecall('psa2(42, self={"20": 1})', psa2, 42, self={'20': 1})
-  py ecall('psa3(42, self={"20": 1})', psa3, 42, self={'20': 1})
-  py ecall('psa4(42, self={"20": 1})', psa4, 42, self={'20': 1})
-
-  py ecall('a(self={"20": 1})', a, self={'20': 1})
-  py ecall('pa1(self={"20": 1})', pa1, self={'20': 1})
-  py ecall('pa2(self={"20": 1})', pa2, self={'20': 1})
-  py ecall('pa3(self={"20": 1})', pa3, self={'20': 1})
-  py ecall('pa4(self={"20": 1})', pa4, self={'20': 1})
-  py ecall('sa(self={"20": 1})', sa, self={'20': 1})
-  py ecall('psa1(self={"20": 1})', psa1, self={'20': 1})
-  py ecall('psa2(self={"20": 1})', psa2, self={'20': 1})
-  py ecall('psa3(self={"20": 1})', psa3, self={'20': 1})
-  py ecall('psa4(self={"20": 1})', psa4, self={'20': 1})
-
-  py << trim EOF
-    def s(v):
-        if v is None:
-            return repr(v)
-        else:
-            return mnv.Function('string')(v)
-
-    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:('MNV:E725: Calling dict function without Dictionary: SelfArgs',)
-    psa1(): !exception: error:('MNV:E725: Calling dict function without Dictionary: SelfArgs',)
-    psa2(): !exception: error:('MNV: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:('MNV:E725: Calling dict function without Dictionary: SelfArgs',)
-    psa1(42, 43): !exception: error:('MNV:E725: Calling dict function without Dictionary: SelfArgs',)
-    psa2(42, 43): !exception: error:('MNV: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_python_stdin_stderr()
-  let caught_writeerr = 0
-  let caught_writelineerr = 0
-  redir => messages
-  py sys.stdout.write('abc8') ; sys.stdout.write('def')
-  try
-    py sys.stderr.write('abc9') ; sys.stderr.write('def')
-  catch /abc9def/
-    let caught_writeerr = 1
-  endtry
-  py sys.stdout.writelines(iter('abcA'))
-  try
-    py 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_python_subclass()
-  new
-  func Put(...)
-    return a:000
-  endfunc
-
-  py << trim EOF
-    class DupDict(mnv.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(mnv.List):
-      def __getitem__(self, idx):
-        return [super(DupList, self).__getitem__(idx)] * 2
-
-    dl = DupList()
-    dl2 = DupList(iter('abcC'))
-    dl.extend(dl2[0])
-
-    class DupFun(mnv.Function):
-      def __call__(self, arg):
-        return super(DupFun, self).__call__(arg, arg)
-
-    df = DupFun('Put')
-  EOF
-
-  call assert_equal(['a', 'dup_a'], sort(keys(pyeval('dd'))))
-  call assert_equal(['a', 'a'], pyeval('dl'))
-  call assert_equal(['a', 'b', 'c', 'C'], pyeval('dl2'))
-  call assert_equal([2, 2], pyeval('df(2)'))
-  call assert_equal(1, pyeval('dl') is# pyeval('dl'))
-  call assert_equal(1, pyeval('dd') is# pyeval('dd'))
-  call assert_equal(function('Put'), pyeval('df'))
-  delfunction Put
-  py << trim EOF
-    del DupDict
-    del DupList
-    del DupFun
-    del dd
-    del dl
-    del dl2
-    del df
-  EOF
-  close!
-endfunc
-
-" Test chdir
-func Test_python_chdir()
-  new Xpycfile
-  py cb = mnv.current.buffer
-  py << trim EOF
-    import os
-    fnamemodify = mnv.Function('fnamemodify')
-    cb.append(fnamemodify('.', ':p:h:t'))
-    cb.append(mnv.eval('@%'))
-    os.chdir('..')
-    path = fnamemodify('.', ':p:h:t')
-    if path != 'src' and path != 'src2':
-      # Running tests from a shadow directory, so move up another level
-      # This will result in @% looking like shadow/testdir/Xpycfile, hence the
-      # extra fnamemodify
-      os.chdir('..')
-      cb.append(fnamemodify('.', ':p:h:t'))
-      cb.append(fnamemodify(mnv.eval('@%'), ':s?^%s.??' % path).replace(os.path.sep, '/'))
-      os.chdir(path)
-      del path
-    else:
-      # Also accept running from src2/testdir/ for MS-Windows CI.
-      cb.append(fnamemodify('.', ':p:h:t').replace('src2', 'src'))
-      cb.append(mnv.eval('@%').replace(os.path.sep, '/'))
-    os.chdir('testdir')
-    cb.append(fnamemodify('.', ':p:h:t'))
-    cb.append(mnv.eval('@%'))
-    del fnamemodify
-  EOF
-  call assert_equal(['testdir', 'Xpycfile', 'src', 'testdir/Xpycfile', 'testdir',
-        \ 'Xpycfile'], getline(2, '$'))
-  close!
-  call AssertException(["py mnv.chdir(None)"], "MNV(python):TypeError:")
-endfunc
-
-" Test errors
-func Test_python_errors()
-  func F() dict
-  endfunc
-
-  func D()
-  endfunc
-
-  new
-  py cb = mnv.current.buffer
-
-  py << trim EOF
-    d = mnv.Dictionary()
-    ned = mnv.Dictionary(foo='bar', baz='abcD')
-    dl = mnv.Dictionary(a=1)
-    dl.locked = True
-    l = mnv.List()
-    ll = mnv.List('abcE')
-    ll.locked = True
-    nel = mnv.List('abcO')
-    f = mnv.Function('string')
-    fd = mnv.Function('F')
-    fdel = mnv.Function('D')
-    mnv.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
-            'u"\\0"',  # Fail PyString_AsStringAndSize(bytes, , NULL) check
-            '"\\0"',   # Fail PyString_AsStringAndSize(object, , 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
-            '{"": 1}',              # Empty key not allowed
-            '{u"": 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',
-        ) + (unsigned and ('-1',) or ())
-        + (natural and ('0',) or ()))
-
-    class FailingTrue(object):
-        def __nonzero__(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("> MNVCommand")
-    stringtochars_test('mnv.command(%s)')
-    ee('mnv.command("", 2)')
-    #! Not checked: mnv->python exceptions translating: checked later
-    cb.append("> MNVToPython")
-    #! Not checked: everything: needs errors in internal python functions
-    cb.append("> MNVEval")
-    stringtochars_test('mnv.eval(%s)')
-    ee('mnv.eval("", FailingTrue())')
-    #! Not checked: everything: needs errors in internal python functions
-    cb.append("> MNVEvalPy")
-    stringtochars_test('mnv.bindeval(%s)')
-    ee('mnv.eval("", 2)')
-    #! Not checked: mnv->python exceptions translating: checked later
-    cb.append("> MNVStrwidth")
-    stringtochars_test('mnv.strwidth(%s)')
-    cb.append("> MNVForeachRTP")
-    ee('mnv.foreach_rtp(None)')
-    ee('mnv.foreach_rtp(NoArgsCall())')
-    ee('mnv.foreach_rtp(FailingCall())')
-    ee('mnv.foreach_rtp(int, 2)')
-    cb.append('> import')
-    old_rtp = mnv.options['rtp']
-    mnv.options['rtp'] = os.getcwd().replace('\\', '\\\\').replace(',', '\\,')
-    ee('import xxx_no_such_module_xxx')
-    ee('import failing_import')
-    ee('import failing')
-    mnv.options['rtp'] = old_rtp
-    del old_rtp
-    cb.append("> Options")
-    cb.append(">> OptionsItem")
-    ee('mnv.options["abcQ"]')
-    ee('mnv.options[""]')
-    stringtochars_test('mnv.options[%s]')
-    cb.append(">> OptionsContains")
-    stringtochars_test('%s in mnv.options')
-    cb.append("> Dictionary")
-    cb.append(">> DictionaryConstructor")
-    ee('mnv.Dictionary("abcI")')
-    ##! Not checked: py_dict_alloc failure
-    cb.append(">> DictionarySetattr")
-    ee('del d.locked')
-    ee('d.locked = FailingTrue()')
-    ee('mnv.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('mnv.List(1, 2)')
-    ee('mnv.List(a=1)')
-    iter_test('mnv.List(%s)')
-    convertfrompyobject_test('mnv.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('mnv.Function("123")')
-    ee('mnv.Function("xxx_non_existent_function_xxx")')
-    ee('mnv.Function("xxx#non#existent#function#xxx")')
-    ee('mnv.Function("xxx_non_existent_function_xxx2", args=[])')
-    ee('mnv.Function("xxx_non_existent_function_xxx3", self={})')
-    ee('mnv.Function("xxx_non_existent_function_xxx4", args=[], self={})')
-    cb.append(">>> FunctionNew")
-    ee('mnv.Function("tr", self="abcFuncSelf")')
-    ee('mnv.Function("tr", args=427423)')
-    ee('mnv.Function("tr", self="abcFuncSelf2", args="abcFuncArgs2")')
-    ee('mnv.Function(self="abcFuncSelf2", args="abcFuncArgs2")')
-    ee('mnv.Function("tr", "", self="abcFuncSelf2", args="abcFuncArgs2")')
-    ee('mnv.Function("tr", "")')
-    cb.append(">> FunctionCall")
-    convertfrompyobject_test('f(%s)')
-    convertfrompymapping_test('fd(self=%s)')
-    cb.append("> TabPage")
-    cb.append(">> TabPageAttr")
-    ee('mnv.current.tabpage.xxx')
-    cb.append("> TabList")
-    cb.append(">> TabListItem")
-    ee('mnv.tabpages[1000]')
-    cb.append("> Window")
-    cb.append(">> WindowAttr")
-    ee('mnv.current.window.xxx')
-    cb.append(">> WindowSetattr")
-    ee('mnv.current.window.buffer = 0')
-    ee('mnv.current.window.cursor = (100000000, 100000000)')
-    ee('mnv.current.window.cursor = True')
-    number_test('mnv.current.window.height = %s', unsigned=True)
-    number_test('mnv.current.window.width = %s', unsigned=True)
-    ee('mnv.current.window.xxxxxx = True')
-    cb.append("> WinList")
-    cb.append(">> WinListItem")
-    ee('mnv.windows[1000]')
-    cb.append("> Buffer")
-    cb.append(">> StringToLine (indirect)")
-    ee('mnv.current.buffer[0] = "\\na"')
-    ee('mnv.current.buffer[0] = u"\\na"')
-    cb.append(">> SetBufferLine (indirect)")
-    ee('mnv.current.buffer[0] = True')
-    cb.append(">> SetBufferLineList (indirect)")
-    ee('mnv.current.buffer[:] = True')
-    ee('mnv.current.buffer[:] = ["\\na", "bc"]')
-    cb.append(">> InsertBufferLines (indirect)")
-    ee('mnv.current.buffer.append(None)')
-    ee('mnv.current.buffer.append(["\\na", "bc"])')
-    ee('mnv.current.buffer.append("\\nbc")')
-    cb.append(">> RBItem")
-    ee('mnv.current.buffer[100000000]')
-    cb.append(">> RBAsItem")
-    ee('mnv.current.buffer[100000000] = ""')
-    cb.append(">> BufferAttr")
-    ee('mnv.current.buffer.xxx')
-    cb.append(">> BufferSetattr")
-    ee('mnv.current.buffer.name = True')
-    ee('mnv.current.buffer.xxx = True')
-    cb.append(">> BufferMark")
-    ee('mnv.current.buffer.mark(0)')
-    ee('mnv.current.buffer.mark("abcM")')
-    ee('mnv.current.buffer.mark("!")')
-    cb.append(">> BufferRange")
-    ee('mnv.current.buffer.range(1, 2, 3)')
-    cb.append("> BufMap")
-    cb.append(">> BufMapItem")
-    ee('mnv.buffers[100000000]')
-    number_test('mnv.buffers[%s]', natural=True)
-    cb.append("> Current")
-    cb.append(">> CurrentGetattr")
-    ee('mnv.current.xxx')
-    cb.append(">> CurrentSetattr")
-    ee('mnv.current.line = True')
-    ee('mnv.current.buffer = True')
-    ee('mnv.current.window = True')
-    ee('mnv.current.tabpage = True')
-    ee('mnv.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:AttributeError:('cannot delete OutputObject attributes',)
-    >>> Testing NumberToLong using sys.stdout.softspace = %s
-    sys.stdout.softspace = []:TypeError:('expected int(), long() or something supporting coercing to long(), but got list',)
-    sys.stdout.softspace = None:TypeError:('expected int(), long() or something supporting coercing to long(), but got NoneType',)
-    sys.stdout.softspace = -1:ValueError:('number must be greater or equal to zero',)
-    <<< Finished
-    >>> Testing NumberToLong using sys.stderr.softspace = %s
-    sys.stderr.softspace = []:TypeError:('expected int(), long() or something supporting coercing to long(), but got list',)
-    sys.stderr.softspace = None:TypeError:('expected int(), long() or something supporting coercing to long(), but got NoneType',)
-    sys.stderr.softspace = -1: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: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):TypeError:('coercing to Unicode: need string or buffer, NoneType found',)
-    >> OutputWriteLines
-    sys.stdout.writelines(None):TypeError:("'NoneType' object is not iterable",)
-    sys.stdout.writelines([1]):TypeError:('coercing to Unicode: need string or buffer, int found',)
-    >>> Testing *Iter* using sys.stdout.writelines(%s)
-    sys.stdout.writelines(FailingIter()):NotImplementedError:('iter',)
-    sys.stdout.writelines(FailingIterNext()):NotImplementedError:('next',)
-    <<< Finished
-    > MNVCommand
-    >>> Testing StringToChars using mnv.command(%s)
-    mnv.command(1):TypeError:('expected str() or unicode() instance, but got int',)
-    mnv.command(u"\0"):TypeError:('expected string without null bytes',)
-    mnv.command("\0"):TypeError:('expected string without null bytes',)
-    <<< Finished
-    mnv.command("", 2):TypeError:('command() takes exactly one argument (2 given)',)
-    > MNVToPython
-    > MNVEval
-    >>> Testing StringToChars using mnv.eval(%s)
-    mnv.eval(1):TypeError:('expected str() or unicode() instance, but got int',)
-    mnv.eval(u"\0"):TypeError:('expected string without null bytes',)
-    mnv.eval("\0"):TypeError:('expected string without null bytes',)
-    <<< Finished
-    mnv.eval("", FailingTrue()):TypeError:('function takes exactly 1 argument (2 given)',)
-    > MNVEvalPy
-    >>> Testing StringToChars using mnv.bindeval(%s)
-    mnv.bindeval(1):TypeError:('expected str() or unicode() instance, but got int',)
-    mnv.bindeval(u"\0"):TypeError:('expected string without null bytes',)
-    mnv.bindeval("\0"):TypeError:('expected string without null bytes',)
-    <<< Finished
-    mnv.eval("", 2):TypeError:('function takes exactly 1 argument (2 given)',)
-    > MNVStrwidth
-    >>> Testing StringToChars using mnv.strwidth(%s)
-    mnv.strwidth(1):TypeError:('expected str() or unicode() instance, but got int',)
-    mnv.strwidth(u"\0"):TypeError:('expected string without null bytes',)
-    mnv.strwidth("\0"):TypeError:('expected string without null bytes',)
-    <<< Finished
-    > MNVForeachRTP
-    mnv.foreach_rtp(None):TypeError:("'NoneType' object is not callable",)
-    mnv.foreach_rtp(NoArgsCall()):TypeError:('__call__() takes exactly 1 argument (2 given)',)
-    mnv.foreach_rtp(FailingCall()):NotImplementedError:('call',)
-    mnv.foreach_rtp(int, 2):TypeError:('foreach_rtp() takes exactly one argument (2 given)',)
-    > import
-    import xxx_no_such_module_xxx:ImportError:('No module named xxx_no_such_module_xxx',)
-    import failing_import:ImportError:()
-    import failing:NotImplementedError:()
-    > Options
-    >> OptionsItem
-    mnv.options["abcQ"]:KeyError:('abcQ',)
-    mnv.options[""]:ValueError:('empty keys are not allowed',)
-    >>> Testing StringToChars using mnv.options[%s]
-    mnv.options[1]:TypeError:('expected str() or unicode() instance, but got int',)
-    mnv.options[u"\0"]:TypeError:('expected string without null bytes',)
-    mnv.options["\0"]:TypeError:('expected string without null bytes',)
-    <<< Finished
-    >> OptionsContains
-    >>> Testing StringToChars using %s in mnv.options
-    1 in mnv.options:TypeError:('expected str() or unicode() instance, but got int',)
-    u"\0" in mnv.options:TypeError:('expected string without null bytes',)
-    "\0" in mnv.options:TypeError:('expected string without null bytes',)
-    <<< Finished
-    > Dictionary
-    >> DictionaryConstructor
-    mnv.Dictionary("abcI"):ValueError:('expected sequence element of size 2, but got sequence of size 1',)
-    >> DictionarySetattr
-    del d.locked:AttributeError:('cannot delete mnv.Dictionary attributes',)
-    d.locked = FailingTrue():NotImplementedError:('bool',)
-    mnv.vvars.locked = False:TypeError:('cannot modify fixed dictionary',)
-    d.scope = True:AttributeError:('cannot set attribute scope',)
-    d.xxx = True:AttributeError:('cannot set attribute xxx',)
-    >> _DictionaryItem
-    d.get("a", 2, 3):TypeError:('function takes at most 2 arguments (3 given)',)
-    >>> Testing StringToChars using d.get(%s)
-    d.get(1):TypeError:('expected str() or unicode() instance, but got int',)
-    d.get(u"\0"):TypeError:('expected string without null bytes',)
-    d.get("\0"):TypeError:('expected string without null bytes',)
-    <<< Finished
-    d.pop("a"):KeyError:('a',)
-    dl.pop("a"):error:('dictionary is locked',)
-    >> DictionaryContains
-    "" in d:ValueError:('empty keys are not allowed',)
-    0 in d:TypeError:('expected str() or unicode() instance, but got int',)
-    >> DictionaryIterNext
-    for i in ned: ned["a"] = 1:RuntimeError:('hashtab changed during iteration',)
-    >> DictionaryAssItem
-    dl["b"] = 1:error:('dictionary is locked',)
-    >>> Testing StringToChars using d[%s] = 1
-    d[1] = 1:TypeError:('expected str() or unicode() instance, but got int',)
-    d[u"\0"] = 1:TypeError:('expected string without null bytes',)
-    d["\0"] = 1:TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing StringToChars using d["a"] = {%s : 1}
-    d["a"] = {1 : 1}:TypeError:('expected str() or unicode() instance, but got int',)
-    d["a"] = {u"\0" : 1}:TypeError:('expected string without null bytes',)
-    d["a"] = {"\0" : 1}:TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing StringToChars using d["a"] = {"abcF" : {%s : 1}}
-    d["a"] = {"abcF" : {1 : 1}}:TypeError:('expected str() or unicode() instance, but got int',)
-    d["a"] = {"abcF" : {u"\0" : 1}}:TypeError:('expected string without null bytes',)
-    d["a"] = {"abcF" : {"\0" : 1}}:TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing StringToChars using d["a"] = {"abcF" : Mapping({%s : 1})}
-    d["a"] = {"abcF" : Mapping({1 : 1})}:TypeError:('expected str() or unicode() instance, but got int',)
-    d["a"] = {"abcF" : Mapping({u"\0" : 1})}:TypeError:('expected string without null bytes',)
-    d["a"] = {"abcF" : Mapping({"\0" : 1})}:TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing *Iter* using d["a"] = {"abcF" : %s}
-    d["a"] = {"abcF" : FailingIter()}:TypeError:('unable to convert FailingIter to a MNV structure',)
-    d["a"] = {"abcF" : FailingIterNext()}:NotImplementedError:('next',)
-    <<< Finished
-    >>> Testing ConvertFromPyObject using d["a"] = {"abcF" : %s}
-    d["a"] = {"abcF" : None}:NOT FAILED
-    d["a"] = {"abcF" : {"": 1}}:ValueError:('empty keys are not allowed',)
-    d["a"] = {"abcF" : {u"": 1}}:ValueError:('empty keys are not allowed',)
-    d["a"] = {"abcF" : FailingMapping()}:NotImplementedError:('keys',)
-    d["a"] = {"abcF" : FailingMappingKey()}:NotImplementedError:('getitem:mappingkey',)
-    d["a"] = {"abcF" : FailingNumber()}:TypeError:('long() argument must be a string or a number',)
-    <<< Finished
-    >>> Testing StringToChars using d["a"] = Mapping({%s : 1})
-    d["a"] = Mapping({1 : 1}):TypeError:('expected str() or unicode() instance, but got int',)
-    d["a"] = Mapping({u"\0" : 1}):TypeError:('expected string without null bytes',)
-    d["a"] = Mapping({"\0" : 1}):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing StringToChars using d["a"] = Mapping({"abcG" : {%s : 1}})
-    d["a"] = Mapping({"abcG" : {1 : 1}}):TypeError:('expected str() or unicode() instance, but got int',)
-    d["a"] = Mapping({"abcG" : {u"\0" : 1}}):TypeError:('expected string without null bytes',)
-    d["a"] = Mapping({"abcG" : {"\0" : 1}}):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing StringToChars using d["a"] = Mapping({"abcG" : Mapping({%s : 1})})
-    d["a"] = Mapping({"abcG" : Mapping({1 : 1})}):TypeError:('expected str() or unicode() instance, but got int',)
-    d["a"] = Mapping({"abcG" : Mapping({u"\0" : 1})}):TypeError:('expected string without null bytes',)
-    d["a"] = Mapping({"abcG" : Mapping({"\0" : 1})}):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing *Iter* using d["a"] = Mapping({"abcG" : %s})
-    d["a"] = Mapping({"abcG" : FailingIter()}):TypeError:('unable to convert FailingIter to a MNV structure',)
-    d["a"] = Mapping({"abcG" : FailingIterNext()}):NotImplementedError:('next',)
-    <<< Finished
-    >>> Testing ConvertFromPyObject using d["a"] = Mapping({"abcG" : %s})
-    d["a"] = Mapping({"abcG" : None}):NOT FAILED
-    d["a"] = Mapping({"abcG" : {"": 1}}):ValueError:('empty keys are not allowed',)
-    d["a"] = Mapping({"abcG" : {u"": 1}}):ValueError:('empty keys are not allowed',)
-    d["a"] = Mapping({"abcG" : FailingMapping()}):NotImplementedError:('keys',)
-    d["a"] = Mapping({"abcG" : FailingMappingKey()}):NotImplementedError:('getitem:mappingkey',)
-    d["a"] = Mapping({"abcG" : FailingNumber()}):TypeError:('long() argument must be a string or a number',)
-    <<< Finished
-    >>> Testing *Iter* using d["a"] = %s
-    d["a"] = FailingIter():TypeError:('unable to convert FailingIter to a MNV structure',)
-    d["a"] = FailingIterNext():NotImplementedError:('next',)
-    <<< Finished
-    >>> Testing ConvertFromPyObject using d["a"] = %s
-    d["a"] = None:NOT FAILED
-    d["a"] = {"": 1}:ValueError:('empty keys are not allowed',)
-    d["a"] = {u"": 1}:ValueError:('empty keys are not allowed',)
-    d["a"] = FailingMapping():NotImplementedError:('keys',)
-    d["a"] = FailingMappingKey():NotImplementedError:('getitem:mappingkey',)
-    d["a"] = FailingNumber():TypeError:('long() argument must be a string or a number',)
-    <<< Finished
-    >> DictionaryUpdate
-    >>> kwargs
-    >>> iter
-    d.update(FailingMapping()):NotImplementedError:('keys',)
-    d.update([FailingIterNext()]):NotImplementedError:('next',)
-    d.update([FailingIterNextN(1)]):NotImplementedError:('next N',)
-    >>> Testing *Iter* using d.update(%s)
-    d.update(FailingIter()):NotImplementedError:('iter',)
-    d.update(FailingIterNext()):NotImplementedError:('next',)
-    <<< Finished
-    >>> Testing StringToChars using d.update({%s : 1})
-    d.update({1 : 1}):TypeError:('expected str() or unicode() instance, but got int',)
-    d.update({u"\0" : 1}):TypeError:('expected string without null bytes',)
-    d.update({"\0" : 1}):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing StringToChars using d.update({"abcF" : {%s : 1}})
-    d.update({"abcF" : {1 : 1}}):TypeError:('expected str() or unicode() instance, but got int',)
-    d.update({"abcF" : {u"\0" : 1}}):TypeError:('expected string without null bytes',)
-    d.update({"abcF" : {"\0" : 1}}):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing StringToChars using d.update({"abcF" : Mapping({%s : 1})})
-    d.update({"abcF" : Mapping({1 : 1})}):TypeError:('expected str() or unicode() instance, but got int',)
-    d.update({"abcF" : Mapping({u"\0" : 1})}):TypeError:('expected string without null bytes',)
-    d.update({"abcF" : Mapping({"\0" : 1})}):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing *Iter* using d.update({"abcF" : %s})
-    d.update({"abcF" : FailingIter()}):TypeError:('unable to convert FailingIter to a MNV structure',)
-    d.update({"abcF" : FailingIterNext()}):NotImplementedError:('next',)
-    <<< Finished
-    >>> Testing ConvertFromPyObject using d.update({"abcF" : %s})
-    d.update({"abcF" : None}):NOT FAILED
-    d.update({"abcF" : {"": 1}}):ValueError:('empty keys are not allowed',)
-    d.update({"abcF" : {u"": 1}}):ValueError:('empty keys are not allowed',)
-    d.update({"abcF" : FailingMapping()}):NotImplementedError:('keys',)
-    d.update({"abcF" : FailingMappingKey()}):NotImplementedError:('getitem:mappingkey',)
-    d.update({"abcF" : FailingNumber()}):TypeError:('long() argument must be a string or a number',)
-    <<< Finished
-    >>> Testing StringToChars using d.update(Mapping({%s : 1}))
-    d.update(Mapping({1 : 1})):TypeError:('expected str() or unicode() instance, but got int',)
-    d.update(Mapping({u"\0" : 1})):TypeError:('expected string without null bytes',)
-    d.update(Mapping({"\0" : 1})):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing StringToChars using d.update(Mapping({"abcG" : {%s : 1}}))
-    d.update(Mapping({"abcG" : {1 : 1}})):TypeError:('expected str() or unicode() instance, but got int',)
-    d.update(Mapping({"abcG" : {u"\0" : 1}})):TypeError:('expected string without null bytes',)
-    d.update(Mapping({"abcG" : {"\0" : 1}})):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing StringToChars using d.update(Mapping({"abcG" : Mapping({%s : 1})}))
-    d.update(Mapping({"abcG" : Mapping({1 : 1})})):TypeError:('expected str() or unicode() instance, but got int',)
-    d.update(Mapping({"abcG" : Mapping({u"\0" : 1})})):TypeError:('expected string without null bytes',)
-    d.update(Mapping({"abcG" : Mapping({"\0" : 1})})):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing *Iter* using d.update(Mapping({"abcG" : %s}))
-    d.update(Mapping({"abcG" : FailingIter()})):TypeError:('unable to convert FailingIter to a MNV structure',)
-    d.update(Mapping({"abcG" : FailingIterNext()})):NotImplementedError:('next',)
-    <<< Finished
-    >>> Testing ConvertFromPyObject using d.update(Mapping({"abcG" : %s}))
-    d.update(Mapping({"abcG" : None})):NOT FAILED
-    d.update(Mapping({"abcG" : {"": 1}})):ValueError:('empty keys are not allowed',)
-    d.update(Mapping({"abcG" : {u"": 1}})):ValueError:('empty keys are not allowed',)
-    d.update(Mapping({"abcG" : FailingMapping()})):NotImplementedError:('keys',)
-    d.update(Mapping({"abcG" : FailingMappingKey()})):NotImplementedError:('getitem:mappingkey',)
-    d.update(Mapping({"abcG" : FailingNumber()})):TypeError:('long() argument must be a string or a number',)
-    <<< Finished
-    >>> Testing *Iter* using d.update(%s)
-    d.update(FailingIter()):NotImplementedError:('iter',)
-    d.update(FailingIterNext()):NotImplementedError:('next',)
-    <<< Finished
-    >>> Testing ConvertFromPyObject using d.update(%s)
-    d.update(None):TypeError:("'NoneType' object is not iterable",)
-    d.update({"": 1}):ValueError:('empty keys are not allowed',)
-    d.update({u"": 1}):ValueError:('empty keys are not allowed',)
-    d.update(FailingMapping()):NotImplementedError:('keys',)
-    d.update(FailingMappingKey()):NotImplementedError:('getitem:mappingkey',)
-    d.update(FailingNumber()):TypeError:("'FailingNumber' object is not iterable",)
-    <<< Finished
-    >>> Testing StringToChars using d.update(((%s, 0),))
-    d.update(((1, 0),)):TypeError:('expected str() or unicode() instance, but got int',)
-    d.update(((u"\0", 0),)):TypeError:('expected string without null bytes',)
-    d.update((("\0", 0),)):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing StringToChars using d.update((("a", {%s : 1}),))
-    d.update((("a", {1 : 1}),)):TypeError:('expected str() or unicode() instance, but got int',)
-    d.update((("a", {u"\0" : 1}),)):TypeError:('expected string without null bytes',)
-    d.update((("a", {"\0" : 1}),)):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing StringToChars using d.update((("a", {"abcF" : {%s : 1}}),))
-    d.update((("a", {"abcF" : {1 : 1}}),)):TypeError:('expected str() or unicode() instance, but got int',)
-    d.update((("a", {"abcF" : {u"\0" : 1}}),)):TypeError:('expected string without null bytes',)
-    d.update((("a", {"abcF" : {"\0" : 1}}),)):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing StringToChars using d.update((("a", {"abcF" : Mapping({%s : 1})}),))
-    d.update((("a", {"abcF" : Mapping({1 : 1})}),)):TypeError:('expected str() or unicode() instance, but got int',)
-    d.update((("a", {"abcF" : Mapping({u"\0" : 1})}),)):TypeError:('expected string without null bytes',)
-    d.update((("a", {"abcF" : Mapping({"\0" : 1})}),)):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing *Iter* using d.update((("a", {"abcF" : %s}),))
-    d.update((("a", {"abcF" : FailingIter()}),)):TypeError:('unable to convert FailingIter to a MNV structure',)
-    d.update((("a", {"abcF" : FailingIterNext()}),)):NotImplementedError:('next',)
-    <<< Finished
-    >>> Testing ConvertFromPyObject using d.update((("a", {"abcF" : %s}),))
-    d.update((("a", {"abcF" : None}),)):error:("failed to add key 'a' to dictionary",)
-    d.update((("a", {"abcF" : {"": 1}}),)):ValueError:('empty keys are not allowed',)
-    d.update((("a", {"abcF" : {u"": 1}}),)):ValueError:('empty keys are not allowed',)
-    d.update((("a", {"abcF" : FailingMapping()}),)):NotImplementedError:('keys',)
-    d.update((("a", {"abcF" : FailingMappingKey()}),)):NotImplementedError:('getitem:mappingkey',)
-    d.update((("a", {"abcF" : FailingNumber()}),)):TypeError:('long() argument must be a string or a number',)
-    <<< Finished
-    >>> Testing StringToChars using d.update((("a", Mapping({%s : 1})),))
-    d.update((("a", Mapping({1 : 1})),)):TypeError:('expected str() or unicode() instance, but got int',)
-    d.update((("a", Mapping({u"\0" : 1})),)):TypeError:('expected string without null bytes',)
-    d.update((("a", Mapping({"\0" : 1})),)):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing StringToChars using d.update((("a", Mapping({"abcG" : {%s : 1}})),))
-    d.update((("a", Mapping({"abcG" : {1 : 1}})),)):TypeError:('expected str() or unicode() instance, but got int',)
-    d.update((("a", Mapping({"abcG" : {u"\0" : 1}})),)):TypeError:('expected string without null bytes',)
-    d.update((("a", Mapping({"abcG" : {"\0" : 1}})),)):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing StringToChars using d.update((("a", Mapping({"abcG" : Mapping({%s : 1})})),))
-    d.update((("a", Mapping({"abcG" : Mapping({1 : 1})})),)):TypeError:('expected str() or unicode() instance, but got int',)
-    d.update((("a", Mapping({"abcG" : Mapping({u"\0" : 1})})),)):TypeError:('expected string without null bytes',)
-    d.update((("a", Mapping({"abcG" : Mapping({"\0" : 1})})),)):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing *Iter* using d.update((("a", Mapping({"abcG" : %s})),))
-    d.update((("a", Mapping({"abcG" : FailingIter()})),)):TypeError:('unable to convert FailingIter to a MNV structure',)
-    d.update((("a", Mapping({"abcG" : FailingIterNext()})),)):NotImplementedError:('next',)
-    <<< Finished
-    >>> Testing ConvertFromPyObject using d.update((("a", Mapping({"abcG" : %s})),))
-    d.update((("a", Mapping({"abcG" : None})),)):error:("failed to add key 'a' to dictionary",)
-    d.update((("a", Mapping({"abcG" : {"": 1}})),)):ValueError:('empty keys are not allowed',)
-    d.update((("a", Mapping({"abcG" : {u"": 1}})),)):ValueError:('empty keys are not allowed',)
-    d.update((("a", Mapping({"abcG" : FailingMapping()})),)):NotImplementedError:('keys',)
-    d.update((("a", Mapping({"abcG" : FailingMappingKey()})),)):NotImplementedError:('getitem:mappingkey',)
-    d.update((("a", Mapping({"abcG" : FailingNumber()})),)):TypeError:('long() argument must be a string or a number',)
-    <<< Finished
-    >>> Testing *Iter* using d.update((("a", %s),))
-    d.update((("a", FailingIter()),)):TypeError:('unable to convert FailingIter to a MNV structure',)
-    d.update((("a", FailingIterNext()),)):NotImplementedError:('next',)
-    <<< Finished
-    >>> Testing ConvertFromPyObject using d.update((("a", %s),))
-    d.update((("a", None),)):error:("failed to add key 'a' to dictionary",)
-    d.update((("a", {"": 1}),)):ValueError:('empty keys are not allowed',)
-    d.update((("a", {u"": 1}),)):ValueError:('empty keys are not allowed',)
-    d.update((("a", FailingMapping()),)):NotImplementedError:('keys',)
-    d.update((("a", FailingMappingKey()),)):NotImplementedError:('getitem:mappingkey',)
-    d.update((("a", FailingNumber()),)):TypeError:('long() argument must be a string or a number',)
-    <<< Finished
-    >> DictionaryPopItem
-    d.popitem(1, 2):TypeError:('popitem() takes no arguments (2 given)',)
-    >> DictionaryHasKey
-    d.has_key():TypeError:('has_key() takes exactly one argument (0 given)',)
-    > List
-    >> ListConstructor
-    mnv.List(1, 2):TypeError:('function takes at most 1 argument (2 given)',)
-    mnv.List(a=1):TypeError:('list constructor does not accept keyword arguments',)
-    >>> Testing *Iter* using mnv.List(%s)
-    mnv.List(FailingIter()):NotImplementedError:('iter',)
-    mnv.List(FailingIterNext()):NotImplementedError:('next',)
-    <<< Finished
-    >>> Testing StringToChars using mnv.List([{%s : 1}])
-    mnv.List([{1 : 1}]):TypeError:('expected str() or unicode() instance, but got int',)
-    mnv.List([{u"\0" : 1}]):TypeError:('expected string without null bytes',)
-    mnv.List([{"\0" : 1}]):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing StringToChars using mnv.List([{"abcF" : {%s : 1}}])
-    mnv.List([{"abcF" : {1 : 1}}]):TypeError:('expected str() or unicode() instance, but got int',)
-    mnv.List([{"abcF" : {u"\0" : 1}}]):TypeError:('expected string without null bytes',)
-    mnv.List([{"abcF" : {"\0" : 1}}]):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing StringToChars using mnv.List([{"abcF" : Mapping({%s : 1})}])
-    mnv.List([{"abcF" : Mapping({1 : 1})}]):TypeError:('expected str() or unicode() instance, but got int',)
-    mnv.List([{"abcF" : Mapping({u"\0" : 1})}]):TypeError:('expected string without null bytes',)
-    mnv.List([{"abcF" : Mapping({"\0" : 1})}]):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing *Iter* using mnv.List([{"abcF" : %s}])
-    mnv.List([{"abcF" : FailingIter()}]):TypeError:('unable to convert FailingIter to a MNV structure',)
-    mnv.List([{"abcF" : FailingIterNext()}]):NotImplementedError:('next',)
-    <<< Finished
-    >>> Testing ConvertFromPyObject using mnv.List([{"abcF" : %s}])
-    mnv.List([{"abcF" : None}]):NOT FAILED
-    mnv.List([{"abcF" : {"": 1}}]):ValueError:('empty keys are not allowed',)
-    mnv.List([{"abcF" : {u"": 1}}]):ValueError:('empty keys are not allowed',)
-    mnv.List([{"abcF" : FailingMapping()}]):NotImplementedError:('keys',)
-    mnv.List([{"abcF" : FailingMappingKey()}]):NotImplementedError:('getitem:mappingkey',)
-    mnv.List([{"abcF" : FailingNumber()}]):TypeError:('long() argument must be a string or a number',)
-    <<< Finished
-    >>> Testing StringToChars using mnv.List([Mapping({%s : 1})])
-    mnv.List([Mapping({1 : 1})]):TypeError:('expected str() or unicode() instance, but got int',)
-    mnv.List([Mapping({u"\0" : 1})]):TypeError:('expected string without null bytes',)
-    mnv.List([Mapping({"\0" : 1})]):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing StringToChars using mnv.List([Mapping({"abcG" : {%s : 1}})])
-    mnv.List([Mapping({"abcG" : {1 : 1}})]):TypeError:('expected str() or unicode() instance, but got int',)
-    mnv.List([Mapping({"abcG" : {u"\0" : 1}})]):TypeError:('expected string without null bytes',)
-    mnv.List([Mapping({"abcG" : {"\0" : 1}})]):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing StringToChars using mnv.List([Mapping({"abcG" : Mapping({%s : 1})})])
-    mnv.List([Mapping({"abcG" : Mapping({1 : 1})})]):TypeError:('expected str() or unicode() instance, but got int',)
-    mnv.List([Mapping({"abcG" : Mapping({u"\0" : 1})})]):TypeError:('expected string without null bytes',)
-    mnv.List([Mapping({"abcG" : Mapping({"\0" : 1})})]):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing *Iter* using mnv.List([Mapping({"abcG" : %s})])
-    mnv.List([Mapping({"abcG" : FailingIter()})]):TypeError:('unable to convert FailingIter to a MNV structure',)
-    mnv.List([Mapping({"abcG" : FailingIterNext()})]):NotImplementedError:('next',)
-    <<< Finished
-    >>> Testing ConvertFromPyObject using mnv.List([Mapping({"abcG" : %s})])
-    mnv.List([Mapping({"abcG" : None})]):NOT FAILED
-    mnv.List([Mapping({"abcG" : {"": 1}})]):ValueError:('empty keys are not allowed',)
-    mnv.List([Mapping({"abcG" : {u"": 1}})]):ValueError:('empty keys are not allowed',)
-    mnv.List([Mapping({"abcG" : FailingMapping()})]):NotImplementedError:('keys',)
-    mnv.List([Mapping({"abcG" : FailingMappingKey()})]):NotImplementedError:('getitem:mappingkey',)
-    mnv.List([Mapping({"abcG" : FailingNumber()})]):TypeError:('long() argument must be a string or a number',)
-    <<< Finished
-    >>> Testing *Iter* using mnv.List([%s])
-    mnv.List([FailingIter()]):TypeError:('unable to convert FailingIter to a MNV structure',)
-    mnv.List([FailingIterNext()]):NotImplementedError:('next',)
-    <<< Finished
-    >>> Testing ConvertFromPyObject using mnv.List([%s])
-    mnv.List([None]):NOT FAILED
-    mnv.List([{"": 1}]):ValueError:('empty keys are not allowed',)
-    mnv.List([{u"": 1}]):ValueError:('empty keys are not allowed',)
-    mnv.List([FailingMapping()]):NotImplementedError:('keys',)
-    mnv.List([FailingMappingKey()]):NotImplementedError:('getitem:mappingkey',)
-    mnv.List([FailingNumber()]):TypeError:('long() argument must be a string or a number',)
-    <<< Finished
-    >> ListItem
-    l[1000]:IndexError:('list index out of range',)
-    >> ListAssItem
-    ll[1] = 2:error:('list is locked',)
-    l[1000] = 3:IndexError:('list index out of range',)
-    >> ListAssSlice
-    ll[1:100] = "abcJ":error:('list is locked',)
-    >>> Testing *Iter* using l[:] = %s
-    l[:] = FailingIter():NotImplementedError:('iter',)
-    l[:] = FailingIterNext():NotImplementedError:('next',)
-    <<< Finished
-    nel[1:10:2]  = "abcK":ValueError:('attempt to assign sequence of size greater than 2 to extended slice',)
-    ('a', 'b', 'c', 'O')
-    nel[1:10:2]  = "a":ValueError:('attempt to assign sequence of size 1 to extended slice of size 2',)
-    ('a', 'b', 'c', 'O')
-    nel[1:1:-1]  = "a":ValueError:('attempt to assign sequence of size greater than 0 to extended slice',)
-    ('a', 'b', 'c', 'O')
-    nel[:] = FailingIterNextN(2):NotImplementedError:('next N',)
-    ('a', 'b', 'c', 'O')
-    >>> Testing StringToChars using l[:] = [{%s : 1}]
-    l[:] = [{1 : 1}]:TypeError:('expected str() or unicode() instance, but got int',)
-    l[:] = [{u"\0" : 1}]:TypeError:('expected string without null bytes',)
-    l[:] = [{"\0" : 1}]:TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing StringToChars using l[:] = [{"abcF" : {%s : 1}}]
-    l[:] = [{"abcF" : {1 : 1}}]:TypeError:('expected str() or unicode() instance, but got int',)
-    l[:] = [{"abcF" : {u"\0" : 1}}]:TypeError:('expected string without null bytes',)
-    l[:] = [{"abcF" : {"\0" : 1}}]:TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing StringToChars using l[:] = [{"abcF" : Mapping({%s : 1})}]
-    l[:] = [{"abcF" : Mapping({1 : 1})}]:TypeError:('expected str() or unicode() instance, but got int',)
-    l[:] = [{"abcF" : Mapping({u"\0" : 1})}]:TypeError:('expected string without null bytes',)
-    l[:] = [{"abcF" : Mapping({"\0" : 1})}]:TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing *Iter* using l[:] = [{"abcF" : %s}]
-    l[:] = [{"abcF" : FailingIter()}]:TypeError:('unable to convert FailingIter to a MNV structure',)
-    l[:] = [{"abcF" : FailingIterNext()}]:NotImplementedError:('next',)
-    <<< Finished
-    >>> Testing ConvertFromPyObject using l[:] = [{"abcF" : %s}]
-    l[:] = [{"abcF" : None}]:NOT FAILED
-    l[:] = [{"abcF" : {"": 1}}]:ValueError:('empty keys are not allowed',)
-    l[:] = [{"abcF" : {u"": 1}}]:ValueError:('empty keys are not allowed',)
-    l[:] = [{"abcF" : FailingMapping()}]:NotImplementedError:('keys',)
-    l[:] = [{"abcF" : FailingMappingKey()}]:NotImplementedError:('getitem:mappingkey',)
-    l[:] = [{"abcF" : FailingNumber()}]:TypeError:('long() argument must be a string or a number',)
-    <<< Finished
-    >>> Testing StringToChars using l[:] = [Mapping({%s : 1})]
-    l[:] = [Mapping({1 : 1})]:TypeError:('expected str() or unicode() instance, but got int',)
-    l[:] = [Mapping({u"\0" : 1})]:TypeError:('expected string without null bytes',)
-    l[:] = [Mapping({"\0" : 1})]:TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing StringToChars using l[:] = [Mapping({"abcG" : {%s : 1}})]
-    l[:] = [Mapping({"abcG" : {1 : 1}})]:TypeError:('expected str() or unicode() instance, but got int',)
-    l[:] = [Mapping({"abcG" : {u"\0" : 1}})]:TypeError:('expected string without null bytes',)
-    l[:] = [Mapping({"abcG" : {"\0" : 1}})]:TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing StringToChars using l[:] = [Mapping({"abcG" : Mapping({%s : 1})})]
-    l[:] = [Mapping({"abcG" : Mapping({1 : 1})})]:TypeError:('expected str() or unicode() instance, but got int',)
-    l[:] = [Mapping({"abcG" : Mapping({u"\0" : 1})})]:TypeError:('expected string without null bytes',)
-    l[:] = [Mapping({"abcG" : Mapping({"\0" : 1})})]:TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing *Iter* using l[:] = [Mapping({"abcG" : %s})]
-    l[:] = [Mapping({"abcG" : FailingIter()})]:TypeError:('unable to convert FailingIter to a MNV structure',)
-    l[:] = [Mapping({"abcG" : FailingIterNext()})]:NotImplementedError:('next',)
-    <<< Finished
-    >>> Testing ConvertFromPyObject using l[:] = [Mapping({"abcG" : %s})]
-    l[:] = [Mapping({"abcG" : None})]:NOT FAILED
-    l[:] = [Mapping({"abcG" : {"": 1}})]:ValueError:('empty keys are not allowed',)
-    l[:] = [Mapping({"abcG" : {u"": 1}})]:ValueError:('empty keys are not allowed',)
-    l[:] = [Mapping({"abcG" : FailingMapping()})]:NotImplementedError:('keys',)
-    l[:] = [Mapping({"abcG" : FailingMappingKey()})]:NotImplementedError:('getitem:mappingkey',)
-    l[:] = [Mapping({"abcG" : FailingNumber()})]:TypeError:('long() argument must be a string or a number',)
-    <<< Finished
-    >>> Testing *Iter* using l[:] = [%s]
-    l[:] = [FailingIter()]:TypeError:('unable to convert FailingIter to a MNV structure',)
-    l[:] = [FailingIterNext()]:NotImplementedError:('next',)
-    <<< Finished
-    >>> Testing ConvertFromPyObject using l[:] = [%s]
-    l[:] = [None]:NOT FAILED
-    l[:] = [{"": 1}]:ValueError:('empty keys are not allowed',)
-    l[:] = [{u"": 1}]:ValueError:('empty keys are not allowed',)
-    l[:] = [FailingMapping()]:NotImplementedError:('keys',)
-    l[:] = [FailingMappingKey()]:NotImplementedError:('getitem:mappingkey',)
-    l[:] = [FailingNumber()]:TypeError:('long() argument must be a string or a number',)
-    <<< Finished
-    >> ListConcatInPlace
-    >>> Testing *Iter* using l.extend(%s)
-    l.extend(FailingIter()):NotImplementedError:('iter',)
-    l.extend(FailingIterNext()):NotImplementedError:('next',)
-    <<< Finished
-    >>> Testing StringToChars using l.extend([{%s : 1}])
-    l.extend([{1 : 1}]):TypeError:('expected str() or unicode() instance, but got int',)
-    l.extend([{u"\0" : 1}]):TypeError:('expected string without null bytes',)
-    l.extend([{"\0" : 1}]):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing StringToChars using l.extend([{"abcF" : {%s : 1}}])
-    l.extend([{"abcF" : {1 : 1}}]):TypeError:('expected str() or unicode() instance, but got int',)
-    l.extend([{"abcF" : {u"\0" : 1}}]):TypeError:('expected string without null bytes',)
-    l.extend([{"abcF" : {"\0" : 1}}]):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing StringToChars using l.extend([{"abcF" : Mapping({%s : 1})}])
-    l.extend([{"abcF" : Mapping({1 : 1})}]):TypeError:('expected str() or unicode() instance, but got int',)
-    l.extend([{"abcF" : Mapping({u"\0" : 1})}]):TypeError:('expected string without null bytes',)
-    l.extend([{"abcF" : Mapping({"\0" : 1})}]):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing *Iter* using l.extend([{"abcF" : %s}])
-    l.extend([{"abcF" : FailingIter()}]):TypeError:('unable to convert FailingIter to a MNV structure',)
-    l.extend([{"abcF" : FailingIterNext()}]):NotImplementedError:('next',)
-    <<< Finished
-    >>> Testing ConvertFromPyObject using l.extend([{"abcF" : %s}])
-    l.extend([{"abcF" : None}]):NOT FAILED
-    l.extend([{"abcF" : {"": 1}}]):ValueError:('empty keys are not allowed',)
-    l.extend([{"abcF" : {u"": 1}}]):ValueError:('empty keys are not allowed',)
-    l.extend([{"abcF" : FailingMapping()}]):NotImplementedError:('keys',)
-    l.extend([{"abcF" : FailingMappingKey()}]):NotImplementedError:('getitem:mappingkey',)
-    l.extend([{"abcF" : FailingNumber()}]):TypeError:('long() argument must be a string or a number',)
-    <<< Finished
-    >>> Testing StringToChars using l.extend([Mapping({%s : 1})])
-    l.extend([Mapping({1 : 1})]):TypeError:('expected str() or unicode() instance, but got int',)
-    l.extend([Mapping({u"\0" : 1})]):TypeError:('expected string without null bytes',)
-    l.extend([Mapping({"\0" : 1})]):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing StringToChars using l.extend([Mapping({"abcG" : {%s : 1}})])
-    l.extend([Mapping({"abcG" : {1 : 1}})]):TypeError:('expected str() or unicode() instance, but got int',)
-    l.extend([Mapping({"abcG" : {u"\0" : 1}})]):TypeError:('expected string without null bytes',)
-    l.extend([Mapping({"abcG" : {"\0" : 1}})]):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing StringToChars using l.extend([Mapping({"abcG" : Mapping({%s : 1})})])
-    l.extend([Mapping({"abcG" : Mapping({1 : 1})})]):TypeError:('expected str() or unicode() instance, but got int',)
-    l.extend([Mapping({"abcG" : Mapping({u"\0" : 1})})]):TypeError:('expected string without null bytes',)
-    l.extend([Mapping({"abcG" : Mapping({"\0" : 1})})]):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing *Iter* using l.extend([Mapping({"abcG" : %s})])
-    l.extend([Mapping({"abcG" : FailingIter()})]):TypeError:('unable to convert FailingIter to a MNV structure',)
-    l.extend([Mapping({"abcG" : FailingIterNext()})]):NotImplementedError:('next',)
-    <<< Finished
-    >>> Testing ConvertFromPyObject using l.extend([Mapping({"abcG" : %s})])
-    l.extend([Mapping({"abcG" : None})]):NOT FAILED
-    l.extend([Mapping({"abcG" : {"": 1}})]):ValueError:('empty keys are not allowed',)
-    l.extend([Mapping({"abcG" : {u"": 1}})]):ValueError:('empty keys are not allowed',)
-    l.extend([Mapping({"abcG" : FailingMapping()})]):NotImplementedError:('keys',)
-    l.extend([Mapping({"abcG" : FailingMappingKey()})]):NotImplementedError:('getitem:mappingkey',)
-    l.extend([Mapping({"abcG" : FailingNumber()})]):TypeError:('long() argument must be a string or a number',)
-    <<< Finished
-    >>> Testing *Iter* using l.extend([%s])
-    l.extend([FailingIter()]):TypeError:('unable to convert FailingIter to a MNV structure',)
-    l.extend([FailingIterNext()]):NotImplementedError:('next',)
-    <<< Finished
-    >>> Testing ConvertFromPyObject using l.extend([%s])
-    l.extend([None]):NOT FAILED
-    l.extend([{"": 1}]):ValueError:('empty keys are not allowed',)
-    l.extend([{u"": 1}]):ValueError:('empty keys are not allowed',)
-    l.extend([FailingMapping()]):NotImplementedError:('keys',)
-    l.extend([FailingMappingKey()]):NotImplementedError:('getitem:mappingkey',)
-    l.extend([FailingNumber()]):TypeError:('long() argument must be a string or a number',)
-    <<< Finished
-    >> ListSetattr
-    del l.locked:AttributeError:('cannot delete mnv.List attributes',)
-    l.locked = FailingTrue():NotImplementedError:('bool',)
-    l.xxx = True:AttributeError:('cannot set attribute xxx',)
-    > Function
-    >> FunctionConstructor
-    >>> FunctionConstructor
-    mnv.Function("123"):ValueError:('unnamed function 123 does not exist',)
-    mnv.Function("xxx_non_existent_function_xxx"):ValueError:('function xxx_non_existent_function_xxx does not exist',)
-    mnv.Function("xxx#non#existent#function#xxx"):NOT FAILED
-    mnv.Function("xxx_non_existent_function_xxx2", args=[]):ValueError:('function xxx_non_existent_function_xxx2 does not exist',)
-    mnv.Function("xxx_non_existent_function_xxx3", self={}):ValueError:('function xxx_non_existent_function_xxx3 does not exist',)
-    mnv.Function("xxx_non_existent_function_xxx4", args=[], self={}):ValueError:('function xxx_non_existent_function_xxx4 does not exist',)
-    >>> FunctionNew
-    mnv.Function("tr", self="abcFuncSelf"):TypeError:('unable to convert str to a MNV dictionary',)
-    mnv.Function("tr", args=427423):TypeError:('unable to convert int to a MNV list',)
-    mnv.Function("tr", self="abcFuncSelf2", args="abcFuncArgs2"):TypeError:('unable to convert str to a MNV dictionary',)
-    mnv.Function(self="abcFuncSelf2", args="abcFuncArgs2"):TypeError:('unable to convert str to a MNV dictionary',)
-    mnv.Function("tr", "", self="abcFuncSelf2", args="abcFuncArgs2"):TypeError:('unable to convert str to a MNV dictionary',)
-    mnv.Function("tr", ""):TypeError:('function takes exactly 1 argument (2 given)',)
-    >> FunctionCall
-    >>> Testing StringToChars using f({%s : 1})
-    f({1 : 1}):TypeError:('expected str() or unicode() instance, but got int',)
-    f({u"\0" : 1}):TypeError:('expected string without null bytes',)
-    f({"\0" : 1}):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing StringToChars using f({"abcF" : {%s : 1}})
-    f({"abcF" : {1 : 1}}):TypeError:('expected str() or unicode() instance, but got int',)
-    f({"abcF" : {u"\0" : 1}}):TypeError:('expected string without null bytes',)
-    f({"abcF" : {"\0" : 1}}):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing StringToChars using f({"abcF" : Mapping({%s : 1})})
-    f({"abcF" : Mapping({1 : 1})}):TypeError:('expected str() or unicode() instance, but got int',)
-    f({"abcF" : Mapping({u"\0" : 1})}):TypeError:('expected string without null bytes',)
-    f({"abcF" : Mapping({"\0" : 1})}):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing *Iter* using f({"abcF" : %s})
-    f({"abcF" : FailingIter()}):TypeError:('unable to convert FailingIter to a MNV structure',)
-    f({"abcF" : FailingIterNext()}):NotImplementedError:('next',)
-    <<< Finished
-    >>> Testing ConvertFromPyObject using f({"abcF" : %s})
-    f({"abcF" : None}):NOT FAILED
-    f({"abcF" : {"": 1}}):ValueError:('empty keys are not allowed',)
-    f({"abcF" : {u"": 1}}):ValueError:('empty keys are not allowed',)
-    f({"abcF" : FailingMapping()}):NotImplementedError:('keys',)
-    f({"abcF" : FailingMappingKey()}):NotImplementedError:('getitem:mappingkey',)
-    f({"abcF" : FailingNumber()}):TypeError:('long() argument must be a string or a number',)
-    <<< Finished
-    >>> Testing StringToChars using f(Mapping({%s : 1}))
-    f(Mapping({1 : 1})):TypeError:('expected str() or unicode() instance, but got int',)
-    f(Mapping({u"\0" : 1})):TypeError:('expected string without null bytes',)
-    f(Mapping({"\0" : 1})):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing StringToChars using f(Mapping({"abcG" : {%s : 1}}))
-    f(Mapping({"abcG" : {1 : 1}})):TypeError:('expected str() or unicode() instance, but got int',)
-    f(Mapping({"abcG" : {u"\0" : 1}})):TypeError:('expected string without null bytes',)
-    f(Mapping({"abcG" : {"\0" : 1}})):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing StringToChars using f(Mapping({"abcG" : Mapping({%s : 1})}))
-    f(Mapping({"abcG" : Mapping({1 : 1})})):TypeError:('expected str() or unicode() instance, but got int',)
-    f(Mapping({"abcG" : Mapping({u"\0" : 1})})):TypeError:('expected string without null bytes',)
-    f(Mapping({"abcG" : Mapping({"\0" : 1})})):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing *Iter* using f(Mapping({"abcG" : %s}))
-    f(Mapping({"abcG" : FailingIter()})):TypeError:('unable to convert FailingIter to a MNV structure',)
-    f(Mapping({"abcG" : FailingIterNext()})):NotImplementedError:('next',)
-    <<< Finished
-    >>> Testing ConvertFromPyObject using f(Mapping({"abcG" : %s}))
-    f(Mapping({"abcG" : None})):NOT FAILED
-    f(Mapping({"abcG" : {"": 1}})):ValueError:('empty keys are not allowed',)
-    f(Mapping({"abcG" : {u"": 1}})):ValueError:('empty keys are not allowed',)
-    f(Mapping({"abcG" : FailingMapping()})):NotImplementedError:('keys',)
-    f(Mapping({"abcG" : FailingMappingKey()})):NotImplementedError:('getitem:mappingkey',)
-    f(Mapping({"abcG" : FailingNumber()})):TypeError:('long() argument must be a string or a number',)
-    <<< Finished
-    >>> Testing *Iter* using f(%s)
-    f(FailingIter()):TypeError:('unable to convert FailingIter to a MNV structure',)
-    f(FailingIterNext()):NotImplementedError:('next',)
-    <<< Finished
-    >>> Testing ConvertFromPyObject using f(%s)
-    f(None):NOT FAILED
-    f({"": 1}):ValueError:('empty keys are not allowed',)
-    f({u"": 1}):ValueError:('empty keys are not allowed',)
-    f(FailingMapping()):NotImplementedError:('keys',)
-    f(FailingMappingKey()):NotImplementedError:('getitem:mappingkey',)
-    f(FailingNumber()):TypeError:('long() argument must be a string or a number',)
-    <<< Finished
-    >>> Testing StringToChars using fd(self={%s : 1})
-    fd(self={1 : 1}):TypeError:('expected str() or unicode() instance, but got int',)
-    fd(self={u"\0" : 1}):TypeError:('expected string without null bytes',)
-    fd(self={"\0" : 1}):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing StringToChars using fd(self={"abcF" : {%s : 1}})
-    fd(self={"abcF" : {1 : 1}}):TypeError:('expected str() or unicode() instance, but got int',)
-    fd(self={"abcF" : {u"\0" : 1}}):TypeError:('expected string without null bytes',)
-    fd(self={"abcF" : {"\0" : 1}}):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing StringToChars using fd(self={"abcF" : Mapping({%s : 1})})
-    fd(self={"abcF" : Mapping({1 : 1})}):TypeError:('expected str() or unicode() instance, but got int',)
-    fd(self={"abcF" : Mapping({u"\0" : 1})}):TypeError:('expected string without null bytes',)
-    fd(self={"abcF" : Mapping({"\0" : 1})}):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing *Iter* using fd(self={"abcF" : %s})
-    fd(self={"abcF" : FailingIter()}):TypeError:('unable to convert FailingIter to a MNV structure',)
-    fd(self={"abcF" : FailingIterNext()}):NotImplementedError:('next',)
-    <<< Finished
-    >>> Testing ConvertFromPyObject using fd(self={"abcF" : %s})
-    fd(self={"abcF" : None}):NOT FAILED
-    fd(self={"abcF" : {"": 1}}):ValueError:('empty keys are not allowed',)
-    fd(self={"abcF" : {u"": 1}}):ValueError:('empty keys are not allowed',)
-    fd(self={"abcF" : FailingMapping()}):NotImplementedError:('keys',)
-    fd(self={"abcF" : FailingMappingKey()}):NotImplementedError:('getitem:mappingkey',)
-    fd(self={"abcF" : FailingNumber()}):TypeError:('long() argument must be a string or a number',)
-    <<< Finished
-    >>> Testing StringToChars using fd(self=Mapping({%s : 1}))
-    fd(self=Mapping({1 : 1})):TypeError:('expected str() or unicode() instance, but got int',)
-    fd(self=Mapping({u"\0" : 1})):TypeError:('expected string without null bytes',)
-    fd(self=Mapping({"\0" : 1})):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing StringToChars using fd(self=Mapping({"abcG" : {%s : 1}}))
-    fd(self=Mapping({"abcG" : {1 : 1}})):TypeError:('expected str() or unicode() instance, but got int',)
-    fd(self=Mapping({"abcG" : {u"\0" : 1}})):TypeError:('expected string without null bytes',)
-    fd(self=Mapping({"abcG" : {"\0" : 1}})):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing StringToChars using fd(self=Mapping({"abcG" : Mapping({%s : 1})}))
-    fd(self=Mapping({"abcG" : Mapping({1 : 1})})):TypeError:('expected str() or unicode() instance, but got int',)
-    fd(self=Mapping({"abcG" : Mapping({u"\0" : 1})})):TypeError:('expected string without null bytes',)
-    fd(self=Mapping({"abcG" : Mapping({"\0" : 1})})):TypeError:('expected string without null bytes',)
-    <<< Finished
-    >>> Testing *Iter* using fd(self=Mapping({"abcG" : %s}))
-    fd(self=Mapping({"abcG" : FailingIter()})):TypeError:('unable to convert FailingIter to a MNV structure',)
-    fd(self=Mapping({"abcG" : FailingIterNext()})):NotImplementedError:('next',)
-    <<< Finished
-    >>> Testing ConvertFromPyObject using fd(self=Mapping({"abcG" : %s}))
-    fd(self=Mapping({"abcG" : None})):NOT FAILED
-    fd(self=Mapping({"abcG" : {"": 1}})):ValueError:('empty keys are not allowed',)
-    fd(self=Mapping({"abcG" : {u"": 1}})):ValueError:('empty keys are not allowed',)
-    fd(self=Mapping({"abcG" : FailingMapping()})):NotImplementedError:('keys',)
-    fd(self=Mapping({"abcG" : FailingMappingKey()})):NotImplementedError:('getitem:mappingkey',)
-    fd(self=Mapping({"abcG" : FailingNumber()})):TypeError:('long() argument must be a string or a number',)
-    <<< Finished
-    >>> Testing *Iter* using fd(self=%s)
-    fd(self=FailingIter()):TypeError:('unable to convert FailingIter to a MNV dictionary',)
-    fd(self=FailingIterNext()):TypeError:('unable to convert FailingIterNext to a MNV dictionary',)
-    <<< Finished
-    >>> Testing ConvertFromPyObject using fd(self=%s)
-    fd(self=None):TypeError:('unable to convert NoneType to a MNV dictionary',)
-    fd(self={"": 1}):ValueError:('empty keys are not allowed',)
-    fd(self={u"": 1}):ValueError:('empty keys are not allowed',)
-    fd(self=FailingMapping()):NotImplementedError:('keys',)
-    fd(self=FailingMappingKey()):NotImplementedError:('getitem:mappingkey',)
-    fd(self=FailingNumber()):TypeError:('unable to convert FailingNumber to a MNV dictionary',)
-    <<< Finished
-    >>> Testing ConvertFromPyMapping using fd(self=%s)
-    fd(self=[]):TypeError:('unable to convert list to a MNV dictionary',)
-    <<< Finished
-    > TabPage
-    >> TabPageAttr
-    mnv.current.tabpage.xxx:AttributeError:('xxx',)
-    > TabList
-    >> TabListItem
-    mnv.tabpages[1000]:IndexError:('no such tab page',)
-    > Window
-    >> WindowAttr
-    mnv.current.window.xxx:AttributeError:('xxx',)
-    >> WindowSetattr
-    mnv.current.window.buffer = 0:TypeError:('readonly attribute: buffer',)
-    mnv.current.window.cursor = (100000000, 100000000):error:('cursor position outside buffer',)
-    mnv.current.window.cursor = True:TypeError:('argument must be 2-item sequence, not bool',)
-    >>> Testing NumberToLong using mnv.current.window.height = %s
-    mnv.current.window.height = []:TypeError:('expected int(), long() or something supporting coercing to long(), but got list',)
-    mnv.current.window.height = None:TypeError:('expected int(), long() or something supporting coercing to long(), but got NoneType',)
-    mnv.current.window.height = -1:ValueError:('number must be greater or equal to zero',)
-    <<< Finished
-    >>> Testing NumberToLong using mnv.current.window.width = %s
-    mnv.current.window.width = []:TypeError:('expected int(), long() or something supporting coercing to long(), but got list',)
-    mnv.current.window.width = None:TypeError:('expected int(), long() or something supporting coercing to long(), but got NoneType',)
-    mnv.current.window.width = -1:ValueError:('number must be greater or equal to zero',)
-    <<< Finished
-    mnv.current.window.xxxxxx = True:AttributeError:('xxxxxx',)
-    > WinList
-    >> WinListItem
-    mnv.windows[1000]:IndexError:('no such window',)
-    > Buffer
-    >> StringToLine (indirect)
-    mnv.current.buffer[0] = "\na":error:('string cannot contain newlines',)
-    mnv.current.buffer[0] = u"\na":error:('string cannot contain newlines',)
-    >> SetBufferLine (indirect)
-    mnv.current.buffer[0] = True:TypeError:('bad argument type for built-in operation',)
-    >> SetBufferLineList (indirect)
-    mnv.current.buffer[:] = True:TypeError:('bad argument type for built-in operation',)
-    mnv.current.buffer[:] = ["\na", "bc"]:error:('string cannot contain newlines',)
-    >> InsertBufferLines (indirect)
-    mnv.current.buffer.append(None):TypeError:('bad argument type for built-in operation',)
-    mnv.current.buffer.append(["\na", "bc"]):error:('string cannot contain newlines',)
-    mnv.current.buffer.append("\nbc"):error:('string cannot contain newlines',)
-    >> RBItem
-    mnv.current.buffer[100000000]:IndexError:('line number out of range',)
-    >> RBAsItem
-    mnv.current.buffer[100000000] = "":IndexError:('line number out of range',)
-    >> BufferAttr
-    mnv.current.buffer.xxx:AttributeError:('xxx',)
-    >> BufferSetattr
-    mnv.current.buffer.name = True:TypeError:('expected str() or unicode() instance, but got bool',)
-    mnv.current.buffer.xxx = True:AttributeError:('xxx',)
-    >> BufferMark
-    mnv.current.buffer.mark(0):TypeError:('expected str() or unicode() instance, but got int',)
-    mnv.current.buffer.mark("abcM"):ValueError:('mark name must be a single character',)
-    mnv.current.buffer.mark("!"):error:('invalid mark name',)
-    >> BufferRange
-    mnv.current.buffer.range(1, 2, 3):TypeError:('function takes exactly 2 arguments (3 given)',)
-    > BufMap
-    >> BufMapItem
-    mnv.buffers[100000000]:KeyError:(100000000,)
-    >>> Testing NumberToLong using mnv.buffers[%s]
-    mnv.buffers[[]]:TypeError:('expected int(), long() or something supporting coercing to long(), but got list',)
-    mnv.buffers[None]:TypeError:('expected int(), long() or something supporting coercing to long(), but got NoneType',)
-    mnv.buffers[-1]:ValueError:('number must be greater than zero',)
-    mnv.buffers[0]:ValueError:('number must be greater than zero',)
-    <<< Finished
-    > Current
-    >> CurrentGetattr
-    mnv.current.xxx:AttributeError:('xxx',)
-    >> CurrentSetattr
-    mnv.current.line = True:TypeError:('bad argument type for built-in operation',)
-    mnv.current.buffer = True:TypeError:('expected mnv.Buffer object, but got bool',)
-    mnv.current.window = True:TypeError:('expected mnv.Window object, but got bool',)
-    mnv.current.tabpage = True:TypeError:('expected mnv.TabPage object, but got bool',)
-    mnv.current.xxx = True:AttributeError:('xxx',)
-  END
-
-  call assert_equal(expected, getline(2, '$'))
-  close!
-endfunc
-
-" Test import
-func Test_python_import()
-  new
-  py cb = mnv.current.buffer
-
-  py << trim EOF
-    sys.path.insert(0, os.path.join(os.getcwd(), 'python_before'))
-    sys.path.append(os.path.join(os.getcwd(), 'python_after'))
-    mnv.options['rtp'] = os.getcwd().replace(',', '\\,').replace('\\', '\\\\')
-    l = []
-    def callback(path):
-        l.append(path[-len('/testdir'):].replace(os.path.sep, '/'))
-    mnv.foreach_rtp(callback)
-    cb.append(repr(l))
-    del l
-    def callback(path):
-        return path[-len('/testdir'):].replace(os.path.sep, '/')
-    cb.append(repr(mnv.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('.pyc', '.py').replace(os.path.sep, '/')[-len('modulex/topmodule/__init__.py'):])
-    cb.append(tms.__file__.replace('.pyc', '.py').replace(os.path.sep, '/')[-len('modulex/topmodule/submodule/__init__.py'):])
-    cb.append(tmsss.__file__.replace('.pyc', '.py').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
-    ['/testdir']
-    '/testdir'
-    2,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(['py import a.b.c'], 'ImportError:')
-endfunc
-
-" Test exceptions
-func Test_python_exception()
-  func Exe(e)
-    execute a:e
-  endfunc
-
-  new
-  py cb = mnv.current.buffer
-
-  py << trim EOF
-    Exe = mnv.bindeval('function("Exe")')
-    ee('mnv.command("throw \'abcN\'")')
-    ee('Exe("throw \'def\'")')
-    ee('mnv.eval("Exe(\'throw \'\'ghi\'\'\')")')
-    ee('mnv.eval("Exe(\'echoerr \'\'jkl\'\'\')")')
-    ee('mnv.eval("Exe(\'xxx_non_existent_command_xxx\')")')
-    ee('mnv.eval("xxx_unknown_function_xxx()")')
-    ee('mnv.bindeval("Exe(\'xxx_non_existent_command_xxx\')")')
-    del Exe
-  EOF
-  delfunction Exe
-
-  let expected =<< trim END
-    mnv.command("throw 'abcN'"):error:('abcN',)
-    Exe("throw 'def'"):error:('def',)
-    mnv.eval("Exe('throw ''ghi''')"):error:('ghi',)
-    mnv.eval("Exe('echoerr ''jkl''')"):error:('MNV(echoerr):jkl',)
-    mnv.eval("Exe('xxx_non_existent_command_xxx')"):error:('MNV:E492: Not an editor command: xxx_non_existent_command_xxx',)
-    mnv.eval("xxx_unknown_function_xxx()"):error:('MNV:E117: Unknown function: xxx_unknown_function_xxx',)
-    mnv.bindeval("Exe('xxx_non_existent_command_xxx')"):error:('MNV:E492: Not an editor command: xxx_non_existent_command_xxx',)
-  END
-  call assert_equal(expected, getline(2, '$'))
-  close!
-endfunc
-
-" Regression: interrupting mnv.command propagates to next mnv.command
-func Test_python_keyboard_interrupt()
-  new
-  py cb = mnv.current.buffer
-  py << trim EOF
-    def test_keyboard_interrupt():
-        try:
-            mnv.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:
-            mnv.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! py test_keyboard_interrupt()
-  redir END
-  0 debuggreedy
-  call inputrestore()
-  py 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
-
-func Test_python_non_utf8_string()
-  smap <Esc>@ <A-@>
-  python mnv.command('redir => _tmp_smaps | smap | redir END')
-  python mnv.eval('_tmp_smaps').splitlines()
-  sunmap <Esc>@
-endfunc
-
-" mnv: shiftwidth=2 sts=2 expandtab