updated for version 7.3.1233

Problem:    Various Python problems.
Solution:   Fix VimTryEnd. Crash with debug build and PYTHONDUMPREFS=1. Memory
            leaks in StringToLine(), BufferMark() and convert_dl. (ZyX)

4 files changed, 897 insertions, 659 deletions

diff --git a/src/testdir/test86.in b/src/testdir/test86.in
index a46a70ac3..d8afc96d4 100644
--- a/src/testdir/test86.in
+++ b/src/testdir/test86.in
@@ -11,8 +11,8 @@ STARTTEST
 :set noswapfile
 :if !has('python') | e! test.ok | wq! test.out | endif
 :lang C
-:py import vim
 :fun Test()
+:py import vim
 :let l = []
 :py l=vim.bindeval('l')
 :py f=vim.bindeval('function("strlen")')
@@ -58,6 +58,9 @@ EOF
 :  $put =string(key) . ' : ' . string(Val)
 :  unlet key Val
 :endfor
+:py del dk
+:py del di
+:py del dv
 :"
 :" removing items with del
 :py del l[2]
@@ -176,12 +179,12 @@ EOF
 :unlockvar! l
 :"
 :" Function calls
-:function New(...)
-:return ['NewStart']+a:000+['NewEnd']
-:endfunction
-:function DictNew(...) dict
-:return ['DictNewStart']+a:000+['DictNewEnd', self]
-:endfunction
+:fun New(...)
+:   return ['NewStart']+a:000+['NewEnd']
+:endfun
+:fun DictNew(...) dict
+:   return ['DictNewStart']+a:000+['DictNewEnd', self]
+:endfun
 :let l=[function('New'), function('DictNew')]
 :py l=vim.bindeval('l')
 :py l.extend(list(l[0](1, 2, 3)))
@@ -211,6 +214,7 @@ EOF
 :   $put ='[0.0, 0.0]'
 :endif
 :let messages=[]
+:delfunction DictNew
 py <<EOF
 d=vim.bindeval('{}')
 m=vim.bindeval('messages')
@@ -220,15 +224,17 @@ def em(expr, g=globals(), l=locals()):
     except:
         m.extend([sys.exc_type.__name__])
 
-em('d["abc"]')
-em('d["abc"]="\\0"')
-em('d["abc"]=vim')
+em('d["abc1"]')
+em('d["abc1"]="\\0"')
+em('d["abc1"]=vim')
 em('d[""]=1')
 em('d["a\\0b"]=1')
 em('d[u"a\\0b"]=1')
 
-em('d.pop("abc")')
+em('d.pop("abc1")')
 em('d.popitem()')
+del em
+del m
 EOF
 :$put =messages
 :unlet messages
@@ -240,8 +246,8 @@ EOF
 :    let toput=s.' : '.join(map(['locked', 'scope'], 'v:val.":".pyeval(name.".".v:val)'), ';')
 :    $put =toput
 :endfor
-:silent! let d.abc=1
-:silent! let dl.abc=1
+:silent! let d.abc2=1
+:silent! let dl.abc3=1
 :py d.locked=True
 :py dl.locked=False
 :silent! let d.def=1
@@ -307,12 +313,15 @@ class T(threading.Thread):
             time.sleep(0.1)
 
 t = T()
+del T
 t.start()
 EOF
 :sleep 1
 :py t.running = False
 :py t.join()
 :py l[0] = t.t > 8  # check if the background thread is working
+:py del time
+:py del threading
 :$put =string(l)
 :"
 :" settrace
@@ -333,6 +342,8 @@ def trace_main():
 EOF
 :py sys.settrace(traceit)
 :py trace_main()
+:py del traceit
+:py del trace_main
 :py sys.settrace(None)
 :$put =string(l)
 :"
@@ -363,7 +374,7 @@ EOF
 :"
 :" Vars
 :let g:foo = 'bac'
-:let w:abc = 'def'
+:let w:abc3 = 'def'
 :let b:baz = 'bar'
 :let t:bar = 'jkl'
 :try
@@ -372,7 +383,7 @@ EOF
 :  put =pyeval('vim.vvars[''exception'']')
 :endtry
 :put =pyeval('vim.vars[''foo'']')
-:put =pyeval('vim.current.window.vars[''abc'']')
+:put =pyeval('vim.current.window.vars[''abc3'']')
 :put =pyeval('vim.current.buffer.vars[''baz'']')
 :put =pyeval('vim.current.tabpage.vars[''bar'']')
 :"
@@ -420,16 +431,16 @@ def ev(s, g=globals(), l=locals()):
         vim.command('let exc=' + repr(sys.exc_type.__name__))
         return 0
 EOF
-:function E(s)
+:fun E(s)
 :   python e(vim.eval('a:s'))
-:endfunction
-:function Ev(s)
+:endfun
+:fun Ev(s)
 :   let r=pyeval('ev(vim.eval("a:s"))')
 :   if exists('exc')
 :       throw exc
 :   endif
 :   return r
-:endfunction
+:endfun
 :py gopts1=vim.options
 :py wopts1=vim.windows[2].options
 :py wopts2=vim.windows[0].options
@@ -444,7 +455,7 @@ EOF
 :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',  'abc',  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    ]]
@@ -494,10 +505,27 @@ EOF
 :   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
 :"
 :" Test buffer object
 :vnew
@@ -517,7 +545,7 @@ cb = vim.current.buffer
 # Tests BufferAppend and BufferItem
 cb.append(b[0])
 # Tests BufferSlice and BufferAssSlice
-cb.append('abc') # Will be overwritten
+cb.append('abc5') # Will be overwritten
 cb[-1:] = b[:-2]
 # Test BufferLength and BufferAssSlice
 cb.append('def') # Will not be overwritten
@@ -541,13 +569,14 @@ b.name = 'bar'
 cb.append(b.name[-11:].replace(os.path.sep, '/'))
 cb.name = old_name
 cb.append(cb.name[-17:].replace(os.path.sep, '/'))
+del old_name
 # Test CheckBuffer
 for _b in vim.buffers:
     if _b is not cb:
         vim.command('bwipeout! ' + str(_b.number))
 del _b
 cb.append('valid: b:%s, cb:%s' % (repr(b.valid), repr(cb.valid)))
-for expr in ('b[1]','b[:] = ["A", "B"]','b[:]','b.append("abc")', 'b.name = "!"'):
+for expr in ('b[1]','b[:] = ["A", "B"]','b[:]','b.append("abc6")', 'b.name = "!"'):
     try:
         exec(expr)
     except vim.error:
@@ -557,6 +586,7 @@ for expr in ('b[1]','b[:] = ["A", "B"]','b[:]','b.append("abc")', 'b.name = "!"'
         # Should not happen in any case
         cb.append('No exception for ' + expr)
 vim.command('cd .')
+del b
 EOF
 :augroup BUFS
 :   autocmd!
@@ -598,6 +628,7 @@ for b in vim.buffers:
     # Check indexing: vim.buffers[number].number == number
     cb.append(str(b.number) + ':' + repr(vim.buffers[b.number]) + '=' + repr(b))
     prevnum = b.number
+del prevnum
 
 cb.append(str(len(vim.buffers)))
 
@@ -621,6 +652,8 @@ try:
     next(i4)
 except StopIteration:
     cb.append('StopIteration')
+del i4
+del bnums
 EOF
 :"
 :" Test vim.{tabpage,window}list and vim.{tabpage,window} objects
@@ -663,7 +696,11 @@ for t in vim.tabpages:
                     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(vim.windows)))
 if list(vim.windows) != list(vim.current.tabpage.windows):
     cb.append('!!!!!! Windows differ')
@@ -676,6 +713,7 @@ def H(o):
 cb.append('Current tab page: ' + repr(vim.current.tabpage))
 cb.append('Current window: ' + repr(vim.current.window) + ': ' + H(vim.current.window) + ' is ' + H(vim.current.tabpage.window))
 cb.append('Current buffer: ' + repr(vim.current.buffer) + ': ' + H(vim.current.buffer) + ' is ' + H(vim.current.window.buffer)+ ' is ' + H(vim.current.tabpage.window.buffer))
+del H
 # Assigning: fails
 try:
     vim.current.window = vim.tabpages[0].window
@@ -687,6 +725,7 @@ for attr in ('window', 'tabpage', 'buffer'):
         setattr(vim.current, attr, None)
     except TypeError:
         cb.append('Type error at assigning None to vim.current.' + attr)
+del attr
 
 # Assigning: success
 vim.current.tabpage = vim.tabpages[-2]
@@ -702,8 +741,13 @@ ts = list(vim.tabpages)
 for b in vim.buffers:
     if b is not cb:
         vim.command('bwipeout! ' + str(b.number))
+del b
 cb.append('w.valid: ' + repr([w.valid for w in ws]))
 cb.append('t.valid: ' + repr([t.valid for t in ts]))
+del w
+del t
+del ts
+del ws
 EOF
 :tabonly!
 :only!
@@ -722,6 +766,8 @@ for expr, attr in (
     ('vim.current.tabpage',              'TabPage'),
 ):
     cb.append(expr + ':' + attr + ':' + repr(type(eval(expr)) is getattr(vim, attr)))
+del expr
+del attr
 EOF
 :"
 :" Test __dir__() method
@@ -747,15 +793,15 @@ EOF
 :$put =string(pyeval('vim.Dictionary(a=1)'))
 :$put =string(pyeval('vim.Dictionary(((''a'', 1),))'))
 :$put =string(pyeval('vim.List()'))
-:$put =string(pyeval('vim.List(iter(''abc''))'))
+:$put =string(pyeval('vim.List(iter(''abc7''))'))
 :$put =string(pyeval('vim.Function(''tr'')'))
 :"
 :" Test stdout/stderr
 :redir => messages
-:py sys.stdout.write('abc') ; sys.stdout.write('def')
-:py sys.stderr.write('abc') ; sys.stderr.write('def')
-:py sys.stdout.writelines(iter('abc'))
-:py sys.stderr.writelines(iter('abc'))
+:py sys.stdout.write('abc8') ; sys.stdout.write('def')
+:py sys.stderr.write('abc9') ; sys.stderr.write('def')
+:py sys.stdout.writelines(iter('abcA'))
+:py sys.stderr.writelines(iter('abcB'))
 :redir END
 :$put =string(substitute(messages, '\d\+', '', 'g'))
 :" Test subclassing
@@ -776,7 +822,7 @@ class DupList(vim.List):
         return [super(DupList, self).__getitem__(idx)] * 2
 
 dl = DupList()
-dl2 = DupList(iter('abc'))
+dl2 = DupList(iter('abcC'))
 dl.extend(dl2[0])
 
 class DupFun(vim.Function):
@@ -789,6 +835,19 @@ EOF
 :$put =string(pyeval('dl'))
 :$put =string(pyeval('dl2'))
 :$put =string(pyeval('df(2)'))
+:$put =string(pyeval('dl') is# pyeval('dl'))
+:$put =string(pyeval('dd') is# pyeval('dd'))
+:$put =string(pyeval('df'))
+:delfunction Put
+py << EOF
+del DupDict
+del DupList
+del DupFun
+del dd
+del dl
+del dl2
+del df
+EOF
 :"
 :" Test chdir
 py << EOF
@@ -802,6 +861,7 @@ cb.append(vim.eval('@%').replace(os.path.sep, '/'))
 os.chdir('testdir')
 cb.append(fnamemodify('.', ':p:h:t'))
 cb.append(vim.eval('@%'))
+del fnamemodify
 EOF
 :"
 :" Test errors
@@ -828,11 +888,11 @@ def ee(expr, g=globals(), l=locals()):
     else:
         cb.append(expr + ':NOT FAILED')
 d = vim.Dictionary()
-ned = vim.Dictionary(foo='bar', baz='abc')
+ned = vim.Dictionary(foo='bar', baz='abcD')
 dl = vim.Dictionary(a=1)
 dl.locked = True
 l = vim.List()
-ll = vim.List('abc')
+ll = vim.List('abcE')
 ll.locked = True
 f = vim.Function('string')
 fd = vim.Function('F')
@@ -869,11 +929,11 @@ def convertfrompyobject_test(expr, recurse=True):
     # pydict_to_tv
     stringtochars_test(expr % '{%s : 1}')
     if recurse:
-        convertfrompyobject_test(expr % '{"abc" : %s}', False)
+        convertfrompyobject_test(expr % '{"abcF" : %s}', False)
     # pymap_to_tv
     stringtochars_test(expr % 'Mapping({%s : 1})')
     if recurse:
-        convertfrompyobject_test(expr % 'Mapping({"abc" : %s})', False)
+        convertfrompyobject_test(expr % 'Mapping({"abcG" : %s})', False)
     # pyseq_to_tv
     iter_test(expr)
     return subexpr_test(expr, 'ConvertFromPyObject', (
@@ -916,7 +976,7 @@ class FailingMappingKey(object):
         raise NotImplementedError
 
     def keys(self):
-        return list("abc")
+        return list("abcH")
 
 class FailingMapping(object):
     def __getitem__(self):
@@ -958,7 +1018,7 @@ cb.append("> VimStrwidth")
 ee('vim.strwidth(1)')
 cb.append("> Dictionary")
 cb.append(">> DictionaryConstructor")
-ee('vim.Dictionary("abc")')
+ee('vim.Dictionary("abcI")')
 ##! Not checked: py_dict_alloc failure
 cb.append(">> DictionarySetattr")
 ee('del d.locked')
@@ -973,6 +1033,7 @@ ee('d.pop("a")')
 ee('dl.pop("a")')
 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')
@@ -1002,7 +1063,7 @@ cb.append(">> ListAssItem")
 ee('ll[1] = 2')
 ee('l[1000] = 3')
 cb.append(">> ListAssSlice")
-ee('ll[1:100] = "abc"')
+ee('ll[1:100] = "abcJ"')
 #iter_test('l[:] = %s')
 convertfrompyobject_test('l[:] = [%s]')
 cb.append(">> ListConcatInPlace")
@@ -1033,8 +1094,8 @@ cb.append(">> WindowSetattr")
 ee('vim.current.window.buffer = 0')
 ee('vim.current.window.cursor = (100000000, 100000000)')
 ee('vim.current.window.cursor = True')
-ee('vim.current.window.height = "abc"')
-ee('vim.current.window.width  = "abc"')
+ee('vim.current.window.height = "abcK"')
+ee('vim.current.window.width  = "abcL"')
 ee('vim.current.window.xxxxxx = True')
 cb.append("> WinList")
 cb.append(">> WinListItem")
@@ -1044,7 +1105,7 @@ cb.append(">> StringToLine (indirect)")
 ee('vim.current.buffer[0] = "\\na"')
 cb.append(">> SetBufferLine (indirect)")
 ee('vim.current.buffer[0] = True')
-cb.append(">> SetBufferLines (indirect)")
+cb.append(">> SetBufferLineList (indirect)")
 ee('vim.current.buffer[:] = True')
 ee('vim.current.buffer[:] = ["\\na", "bc"]')
 cb.append(">> InsertBufferLines (indirect)")
@@ -1062,7 +1123,7 @@ ee('vim.current.buffer.name = True')
 ee('vim.current.buffer.xxx = True')
 cb.append(">> BufferMark")
 ee('vim.current.buffer.mark(0)')
-ee('vim.current.buffer.mark("abc")')
+ee('vim.current.buffer.mark("abcM")')
 ee('vim.current.buffer.mark("!")')
 cb.append(">> BufferRange")
 ee('vim.current.buffer.range(1, 2, 3)')
@@ -1079,7 +1140,28 @@ ee('vim.current.buffer = True')
 ee('vim.current.window = True')
 ee('vim.current.tabpage = True')
 ee('vim.current.xxx = True')
+del d
+del ned
+del dl
+del l
+del ll
+del f
+del fd
+del fdel
+del subexpr_test
+del stringtochars_test
+del Mapping
+del convertfrompyobject_test
+del convertfrompymapping_test
+del iter_test
+del FailingTrue
+del FailingIter
+del FailingIterNext
+del FailingMapping
+del FailingMappingKey
+del FailingList
 EOF
+:delfunction F
 :"
 :" Test import
 py << EOF
@@ -1093,6 +1175,10 @@ import before
 cb.append(before.dir)
 import after
 cb.append(after.dir)
+del before
+del after
+del d
+del ddir
 EOF
 :"
 :" Test exceptions
@@ -1101,18 +1187,48 @@ EOF
 :endfun
 py << EOF
 Exe = vim.bindeval('function("Exe")')
-ee('vim.command("throw \'abc\'")')
+ee('vim.command("throw \'abcN\'")')
 ee('Exe("throw \'def\'")')
 ee('vim.eval("Exe(\'throw \'\'ghi\'\'\')")')
 ee('vim.eval("Exe(\'echoerr \'\'jkl\'\'\')")')
 ee('vim.eval("Exe(\'xxx_non_existent_command_xxx\')")')
 ee('vim.bindeval("Exe(\'xxx_non_existent_command_xxx\')")')
+del Exe
+EOF
+:delfunction Exe
+:"
+:" Cleanup
+py << EOF
+del cb
+del ee
+del sys
+del os
+del vim
 EOF
 :endfun
 :"
-:call Test()
+:fun RunTest()
+:let checkrefs = !empty($PYTHONDUMPREFS)
+:let start = getline(1, '$')
+:for i in range(checkrefs ? 10 : 1)
+:   if i != 0
+:       %d _
+:       call setline(1, start)
+:   endif
+:   call Test()
+:   if i == 0
+:       let result = getline(1, '$')
+:   endif
+:endfor
+:if checkrefs
+:   %d _
+:   call setline(1, result)
+:endif
+:endfun
 :"
-:delfunc Test
+:call RunTest()
+:delfunction RunTest
+:delfunction Test
 :call garbagecollect(1)
 :"
 :/^start:/,$wq! test.out
diff --git a/src/testdir/test86.ok b/src/testdir/test86.ok
index ab6017be5..b4abcc28c 100644
--- a/src/testdir/test86.ok
+++ b/src/testdir/test86.ok
@@ -68,7 +68,7 @@ d : locked:0;scope:0
 dl : locked:1;scope:0
 v: : locked:2;scope:1
 g: : locked:0;scope:2
-d:{'abc': 1}
+d:{'abc2': 1}
 dl:{'def': 1}
 l : locked:0
 ll : locked:1
@@ -202,12 +202,12 @@ jkl
   B: 1:3 2:5 3:2 4:8
 >>> colorcolumn
   p/gopts1! KeyError
-  inv: 'abc'! KeyError
+  inv: 'abc4'! KeyError
   gopts1! KeyError
   p/wopts1: ''
-  inv: 'abc'! error
+  inv: 'abc4'! error
   p/bopts1! KeyError
-  inv: 'abc'! KeyError
+  inv: 'abc4'! KeyError
   bopts1! KeyError
   bopts2! KeyError
   bopts3! KeyError
@@ -415,20 +415,23 @@ output:__dir__,__members__,flush,softspace,write,writelines
 {'a': 1}
 {'a': 1}
 []
-['a', 'b', 'c']
+['a', 'b', 'c', '7']
 function('tr')
 '
 abcdef
 line  :
 abcdef
-abc
+abcA
 line  :
-abc'
+abcB'
 ['a', 'dup_a']
 ['a', 'a']
-['a', 'b', 'c']
+['a', 'b', 'c', 'C']
 [2, 2]
 [2, 2]
+1
+1
+function('Put')
 testdir
 test86.in
 src
@@ -456,7 +459,7 @@ vim.bindeval(1):TypeError:('expected str() or unicode() instance, but got int',)
 vim.strwidth(1):TypeError:('expected str() or unicode() instance, but got int',)
 > Dictionary
 >> DictionaryConstructor
-vim.Dictionary("abc"):ValueError:('expected sequence element of size 2, but got sequence of size 1',)
+vim.Dictionary("abcI"):ValueError:('expected sequence element of size 2, but got sequence of size 1',)
 >> DictionarySetattr
 del d.locked:AttributeError:('cannot delete vim.Dictionary attributes',)
 d.locked = FailingTrue():NotImplementedError:()
@@ -486,52 +489,52 @@ 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"] = {"abc" : {%s : 1}}
-d["a"] = {"abc" : {1 : 1}}:TypeError:('expected str() or unicode() instance, but got int',)
-d["a"] = {"abc" : {u"\0" : 1}}:TypeError:('expected string without null bytes',)
-d["a"] = {"abc" : {"\0" : 1}}:TypeError:('expected string without null bytes',)
+>>> 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"] = {"abc" : Mapping({%s : 1})}
-d["a"] = {"abc" : Mapping({1 : 1})}:TypeError:('expected str() or unicode() instance, but got int',)
-d["a"] = {"abc" : Mapping({u"\0" : 1})}:TypeError:('expected string without null bytes',)
-d["a"] = {"abc" : Mapping({"\0" : 1})}:TypeError:('expected string without null bytes',)
+>>> 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"] = {"abc" : %s}
-d["a"] = {"abc" : FailingIter()}:TypeError:('unable to convert FailingIter to vim structure',)
-d["a"] = {"abc" : FailingIterNext()}:NotImplementedError:()
+>>> Testing *Iter* using d["a"] = {"abcF" : %s}
+d["a"] = {"abcF" : FailingIter()}:TypeError:('unable to convert FailingIter to vim structure',)
+d["a"] = {"abcF" : FailingIterNext()}:NotImplementedError:()
 <<< Finished
->>> Testing ConvertFromPyObject using d["a"] = {"abc" : %s}
-d["a"] = {"abc" : None}:TypeError:('unable to convert NoneType to vim structure',)
-d["a"] = {"abc" : {"": 1}}:ValueError:('empty keys are not allowed',)
-d["a"] = {"abc" : {u"": 1}}:ValueError:('empty keys are not allowed',)
-d["a"] = {"abc" : FailingMapping()}:NotImplementedError:()
-d["a"] = {"abc" : FailingMappingKey()}:NotImplementedError:()
+>>> Testing ConvertFromPyObject using d["a"] = {"abcF" : %s}
+d["a"] = {"abcF" : None}:TypeError:('unable to convert NoneType to vim structure',)
+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:()
+d["a"] = {"abcF" : FailingMappingKey()}:NotImplementedError:()
 <<< 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({"abc" : {%s : 1}})
-d["a"] = Mapping({"abc" : {1 : 1}}):TypeError:('expected str() or unicode() instance, but got int',)
-d["a"] = Mapping({"abc" : {u"\0" : 1}}):TypeError:('expected string without null bytes',)
-d["a"] = Mapping({"abc" : {"\0" : 1}}):TypeError:('expected string without null bytes',)
+>>> 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({"abc" : Mapping({%s : 1})})
-d["a"] = Mapping({"abc" : Mapping({1 : 1})}):TypeError:('expected str() or unicode() instance, but got int',)
-d["a"] = Mapping({"abc" : Mapping({u"\0" : 1})}):TypeError:('expected string without null bytes',)
-d["a"] = Mapping({"abc" : Mapping({"\0" : 1})}):TypeError:('expected string without null bytes',)
+>>> 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({"abc" : %s})
-d["a"] = Mapping({"abc" : FailingIter()}):TypeError:('unable to convert FailingIter to vim structure',)
-d["a"] = Mapping({"abc" : FailingIterNext()}):NotImplementedError:()
+>>> Testing *Iter* using d["a"] = Mapping({"abcG" : %s})
+d["a"] = Mapping({"abcG" : FailingIter()}):TypeError:('unable to convert FailingIter to vim structure',)
+d["a"] = Mapping({"abcG" : FailingIterNext()}):NotImplementedError:()
 <<< Finished
->>> Testing ConvertFromPyObject using d["a"] = Mapping({"abc" : %s})
-d["a"] = Mapping({"abc" : None}):TypeError:('unable to convert NoneType to vim structure',)
-d["a"] = Mapping({"abc" : {"": 1}}):ValueError:('empty keys are not allowed',)
-d["a"] = Mapping({"abc" : {u"": 1}}):ValueError:('empty keys are not allowed',)
-d["a"] = Mapping({"abc" : FailingMapping()}):NotImplementedError:()
-d["a"] = Mapping({"abc" : FailingMappingKey()}):NotImplementedError:()
+>>> Testing ConvertFromPyObject using d["a"] = Mapping({"abcG" : %s})
+d["a"] = Mapping({"abcG" : None}):TypeError:('unable to convert NoneType to vim structure',)
+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:()
+d["a"] = Mapping({"abcG" : FailingMappingKey()}):NotImplementedError:()
 <<< Finished
 >>> Testing *Iter* using d["a"] = %s
 d["a"] = FailingIter():TypeError:('unable to convert FailingIter to vim structure',)
@@ -554,52 +557,52 @@ 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({"abc" : {%s : 1}})
-d.update({"abc" : {1 : 1}}):TypeError:('expected str() or unicode() instance, but got int',)
-d.update({"abc" : {u"\0" : 1}}):TypeError:('expected string without null bytes',)
-d.update({"abc" : {"\0" : 1}}):TypeError:('expected string without null bytes',)
+>>> 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({"abc" : Mapping({%s : 1})})
-d.update({"abc" : Mapping({1 : 1})}):TypeError:('expected str() or unicode() instance, but got int',)
-d.update({"abc" : Mapping({u"\0" : 1})}):TypeError:('expected string without null bytes',)
-d.update({"abc" : Mapping({"\0" : 1})}):TypeError:('expected string without null bytes',)
+>>> 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({"abc" : %s})
-d.update({"abc" : FailingIter()}):TypeError:('unable to convert FailingIter to vim structure',)
-d.update({"abc" : FailingIterNext()}):NotImplementedError:()
+>>> Testing *Iter* using d.update({"abcF" : %s})
+d.update({"abcF" : FailingIter()}):TypeError:('unable to convert FailingIter to vim structure',)
+d.update({"abcF" : FailingIterNext()}):NotImplementedError:()
 <<< Finished
->>> Testing ConvertFromPyObject using d.update({"abc" : %s})
-d.update({"abc" : None}):TypeError:('unable to convert NoneType to vim structure',)
-d.update({"abc" : {"": 1}}):ValueError:('empty keys are not allowed',)
-d.update({"abc" : {u"": 1}}):ValueError:('empty keys are not allowed',)
-d.update({"abc" : FailingMapping()}):NotImplementedError:()
-d.update({"abc" : FailingMappingKey()}):NotImplementedError:()
+>>> Testing ConvertFromPyObject using d.update({"abcF" : %s})
+d.update({"abcF" : None}):TypeError:('unable to convert NoneType to vim structure',)
+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:()
+d.update({"abcF" : FailingMappingKey()}):NotImplementedError:()
 <<< 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({"abc" : {%s : 1}}))
-d.update(Mapping({"abc" : {1 : 1}})):TypeError:('expected str() or unicode() instance, but got int',)
-d.update(Mapping({"abc" : {u"\0" : 1}})):TypeError:('expected string without null bytes',)
-d.update(Mapping({"abc" : {"\0" : 1}})):TypeError:('expected string without null bytes',)
+>>> 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({"abc" : Mapping({%s : 1})}))
-d.update(Mapping({"abc" : Mapping({1 : 1})})):TypeError:('expected str() or unicode() instance, but got int',)
-d.update(Mapping({"abc" : Mapping({u"\0" : 1})})):TypeError:('expected string without null bytes',)
-d.update(Mapping({"abc" : Mapping({"\0" : 1})})):TypeError:('expected string without null bytes',)
+>>> 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({"abc" : %s}))
-d.update(Mapping({"abc" : FailingIter()})):TypeError:('unable to convert FailingIter to vim structure',)
-d.update(Mapping({"abc" : FailingIterNext()})):NotImplementedError:()
+>>> Testing *Iter* using d.update(Mapping({"abcG" : %s}))
+d.update(Mapping({"abcG" : FailingIter()})):TypeError:('unable to convert FailingIter to vim structure',)
+d.update(Mapping({"abcG" : FailingIterNext()})):NotImplementedError:()
 <<< Finished
->>> Testing ConvertFromPyObject using d.update(Mapping({"abc" : %s}))
-d.update(Mapping({"abc" : None})):TypeError:('unable to convert NoneType to vim structure',)
-d.update(Mapping({"abc" : {"": 1}})):ValueError:('empty keys are not allowed',)
-d.update(Mapping({"abc" : {u"": 1}})):ValueError:('empty keys are not allowed',)
-d.update(Mapping({"abc" : FailingMapping()})):NotImplementedError:()
-d.update(Mapping({"abc" : FailingMappingKey()})):NotImplementedError:()
+>>> Testing ConvertFromPyObject using d.update(Mapping({"abcG" : %s}))
+d.update(Mapping({"abcG" : None})):TypeError:('unable to convert NoneType to vim structure',)
+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:()
+d.update(Mapping({"abcG" : FailingMappingKey()})):NotImplementedError:()
 <<< Finished
 >>> Testing *Iter* using d.update(%s)
 d.update(FailingIter()):NotImplementedError:()
@@ -622,52 +625,52 @@ d.update((("a", {1 : 1}),)):TypeError:('expected str() or unicode() instance, bu
 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", {"abc" : {%s : 1}}),))
-d.update((("a", {"abc" : {1 : 1}}),)):TypeError:('expected str() or unicode() instance, but got int',)
-d.update((("a", {"abc" : {u"\0" : 1}}),)):TypeError:('expected string without null bytes',)
-d.update((("a", {"abc" : {"\0" : 1}}),)):TypeError:('expected string without null bytes',)
+>>> 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", {"abc" : Mapping({%s : 1})}),))
-d.update((("a", {"abc" : Mapping({1 : 1})}),)):TypeError:('expected str() or unicode() instance, but got int',)
-d.update((("a", {"abc" : Mapping({u"\0" : 1})}),)):TypeError:('expected string without null bytes',)
-d.update((("a", {"abc" : Mapping({"\0" : 1})}),)):TypeError:('expected string without null bytes',)
+>>> 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", {"abc" : %s}),))
-d.update((("a", {"abc" : FailingIter()}),)):TypeError:('unable to convert FailingIter to vim structure',)
-d.update((("a", {"abc" : FailingIterNext()}),)):NotImplementedError:()
+>>> Testing *Iter* using d.update((("a", {"abcF" : %s}),))
+d.update((("a", {"abcF" : FailingIter()}),)):TypeError:('unable to convert FailingIter to vim structure',)
+d.update((("a", {"abcF" : FailingIterNext()}),)):NotImplementedError:()
 <<< Finished
->>> Testing ConvertFromPyObject using d.update((("a", {"abc" : %s}),))
-d.update((("a", {"abc" : None}),)):TypeError:('unable to convert NoneType to vim structure',)
-d.update((("a", {"abc" : {"": 1}}),)):ValueError:('empty keys are not allowed',)
-d.update((("a", {"abc" : {u"": 1}}),)):ValueError:('empty keys are not allowed',)
-d.update((("a", {"abc" : FailingMapping()}),)):NotImplementedError:()
-d.update((("a", {"abc" : FailingMappingKey()}),)):NotImplementedError:()
+>>> Testing ConvertFromPyObject using d.update((("a", {"abcF" : %s}),))
+d.update((("a", {"abcF" : None}),)):TypeError:('unable to convert NoneType to vim structure',)
+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:()
+d.update((("a", {"abcF" : FailingMappingKey()}),)):NotImplementedError:()
 <<< 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({"abc" : {%s : 1}})),))
-d.update((("a", Mapping({"abc" : {1 : 1}})),)):TypeError:('expected str() or unicode() instance, but got int',)
-d.update((("a", Mapping({"abc" : {u"\0" : 1}})),)):TypeError:('expected string without null bytes',)
-d.update((("a", Mapping({"abc" : {"\0" : 1}})),)):TypeError:('expected string without null bytes',)
+>>> 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({"abc" : Mapping({%s : 1})})),))
-d.update((("a", Mapping({"abc" : Mapping({1 : 1})})),)):TypeError:('expected str() or unicode() instance, but got int',)
-d.update((("a", Mapping({"abc" : Mapping({u"\0" : 1})})),)):TypeError:('expected string without null bytes',)
-d.update((("a", Mapping({"abc" : Mapping({"\0" : 1})})),)):TypeError:('expected string without null bytes',)
+>>> 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({"abc" : %s})),))
-d.update((("a", Mapping({"abc" : FailingIter()})),)):TypeError:('unable to convert FailingIter to vim structure',)
-d.update((("a", Mapping({"abc" : FailingIterNext()})),)):NotImplementedError:()
+>>> Testing *Iter* using d.update((("a", Mapping({"abcG" : %s})),))
+d.update((("a", Mapping({"abcG" : FailingIter()})),)):TypeError:('unable to convert FailingIter to vim structure',)
+d.update((("a", Mapping({"abcG" : FailingIterNext()})),)):NotImplementedError:()
 <<< Finished
->>> Testing ConvertFromPyObject using d.update((("a", Mapping({"abc" : %s})),))
-d.update((("a", Mapping({"abc" : None})),)):TypeError:('unable to convert NoneType to vim structure',)
-d.update((("a", Mapping({"abc" : {"": 1}})),)):ValueError:('empty keys are not allowed',)
-d.update((("a", Mapping({"abc" : {u"": 1}})),)):ValueError:('empty keys are not allowed',)
-d.update((("a", Mapping({"abc" : FailingMapping()})),)):NotImplementedError:()
-d.update((("a", Mapping({"abc" : FailingMappingKey()})),)):NotImplementedError:()
+>>> Testing ConvertFromPyObject using d.update((("a", Mapping({"abcG" : %s})),))
+d.update((("a", Mapping({"abcG" : None})),)):TypeError:('unable to convert NoneType to vim structure',)
+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:()
+d.update((("a", Mapping({"abcG" : FailingMappingKey()})),)):NotImplementedError:()
 <<< Finished
 >>> Testing *Iter* using d.update((("a", %s),))
 d.update((("a", FailingIter()),)):TypeError:('unable to convert FailingIter to vim structure',)
@@ -693,52 +696,52 @@ vim.List([{1 : 1}]):TypeError:('expected str() or unicode() instance, but got in
 vim.List([{u"\0" : 1}]):TypeError:('expected string without null bytes',)
 vim.List([{"\0" : 1}]):TypeError:('expected string without null bytes',)
 <<< Finished
->>> Testing StringToChars using vim.List([{"abc" : {%s : 1}}])
-vim.List([{"abc" : {1 : 1}}]):TypeError:('expected str() or unicode() instance, but got int',)
-vim.List([{"abc" : {u"\0" : 1}}]):TypeError:('expected string without null bytes',)
-vim.List([{"abc" : {"\0" : 1}}]):TypeError:('expected string without null bytes',)
+>>> Testing StringToChars using vim.List([{"abcF" : {%s : 1}}])
+vim.List([{"abcF" : {1 : 1}}]):TypeError:('expected str() or unicode() instance, but got int',)
+vim.List([{"abcF" : {u"\0" : 1}}]):TypeError:('expected string without null bytes',)
+vim.List([{"abcF" : {"\0" : 1}}]):TypeError:('expected string without null bytes',)
 <<< Finished
->>> Testing StringToChars using vim.List([{"abc" : Mapping({%s : 1})}])
-vim.List([{"abc" : Mapping({1 : 1})}]):TypeError:('expected str() or unicode() instance, but got int',)
-vim.List([{"abc" : Mapping({u"\0" : 1})}]):TypeError:('expected string without null bytes',)
-vim.List([{"abc" : Mapping({"\0" : 1})}]):TypeError:('expected string without null bytes',)
+>>> Testing StringToChars using vim.List([{"abcF" : Mapping({%s : 1})}])
+vim.List([{"abcF" : Mapping({1 : 1})}]):TypeError:('expected str() or unicode() instance, but got int',)
+vim.List([{"abcF" : Mapping({u"\0" : 1})}]):TypeError:('expected string without null bytes',)
+vim.List([{"abcF" : Mapping({"\0" : 1})}]):TypeError:('expected string without null bytes',)
 <<< Finished
->>> Testing *Iter* using vim.List([{"abc" : %s}])
-vim.List([{"abc" : FailingIter()}]):TypeError:('unable to convert FailingIter to vim structure',)
-vim.List([{"abc" : FailingIterNext()}]):NotImplementedError:()
+>>> Testing *Iter* using vim.List([{"abcF" : %s}])
+vim.List([{"abcF" : FailingIter()}]):TypeError:('unable to convert FailingIter to vim structure',)
+vim.List([{"abcF" : FailingIterNext()}]):NotImplementedError:()
 <<< Finished
->>> Testing ConvertFromPyObject using vim.List([{"abc" : %s}])
-vim.List([{"abc" : None}]):TypeError:('unable to convert NoneType to vim structure',)
-vim.List([{"abc" : {"": 1}}]):ValueError:('empty keys are not allowed',)
-vim.List([{"abc" : {u"": 1}}]):ValueError:('empty keys are not allowed',)
-vim.List([{"abc" : FailingMapping()}]):NotImplementedError:()
-vim.List([{"abc" : FailingMappingKey()}]):NotImplementedError:()
+>>> Testing ConvertFromPyObject using vim.List([{"abcF" : %s}])
+vim.List([{"abcF" : None}]):TypeError:('unable to convert NoneType to vim structure',)
+vim.List([{"abcF" : {"": 1}}]):ValueError:('empty keys are not allowed',)
+vim.List([{"abcF" : {u"": 1}}]):ValueError:('empty keys are not allowed',)
+vim.List([{"abcF" : FailingMapping()}]):NotImplementedError:()
+vim.List([{"abcF" : FailingMappingKey()}]):NotImplementedError:()
 <<< Finished
 >>> Testing StringToChars using vim.List([Mapping({%s : 1})])
 vim.List([Mapping({1 : 1})]):TypeError:('expected str() or unicode() instance, but got int',)
 vim.List([Mapping({u"\0" : 1})]):TypeError:('expected string without null bytes',)
 vim.List([Mapping({"\0" : 1})]):TypeError:('expected string without null bytes',)
 <<< Finished
->>> Testing StringToChars using vim.List([Mapping({"abc" : {%s : 1}})])
-vim.List([Mapping({"abc" : {1 : 1}})]):TypeError:('expected str() or unicode() instance, but got int',)
-vim.List([Mapping({"abc" : {u"\0" : 1}})]):TypeError:('expected string without null bytes',)
-vim.List([Mapping({"abc" : {"\0" : 1}})]):TypeError:('expected string without null bytes',)
+>>> Testing StringToChars using vim.List([Mapping({"abcG" : {%s : 1}})])
+vim.List([Mapping({"abcG" : {1 : 1}})]):TypeError:('expected str() or unicode() instance, but got int',)
+vim.List([Mapping({"abcG" : {u"\0" : 1}})]):TypeError:('expected string without null bytes',)
+vim.List([Mapping({"abcG" : {"\0" : 1}})]):TypeError:('expected string without null bytes',)
 <<< Finished
->>> Testing StringToChars using vim.List([Mapping({"abc" : Mapping({%s : 1})})])
-vim.List([Mapping({"abc" : Mapping({1 : 1})})]):TypeError:('expected str() or unicode() instance, but got int',)
-vim.List([Mapping({"abc" : Mapping({u"\0" : 1})})]):TypeError:('expected string without null bytes',)
-vim.List([Mapping({"abc" : Mapping({"\0" : 1})})]):TypeError:('expected string without null bytes',)
+>>> Testing StringToChars using vim.List([Mapping({"abcG" : Mapping({%s : 1})})])
+vim.List([Mapping({"abcG" : Mapping({1 : 1})})]):TypeError:('expected str() or unicode() instance, but got int',)
+vim.List([Mapping({"abcG" : Mapping({u"\0" : 1})})]):TypeError:('expected string without null bytes',)
+vim.List([Mapping({"abcG" : Mapping({"\0" : 1})})]):TypeError:('expected string without null bytes',)
 <<< Finished
->>> Testing *Iter* using vim.List([Mapping({"abc" : %s})])
-vim.List([Mapping({"abc" : FailingIter()})]):TypeError:('unable to convert FailingIter to vim structure',)
-vim.List([Mapping({"abc" : FailingIterNext()})]):NotImplementedError:()
+>>> Testing *Iter* using vim.List([Mapping({"abcG" : %s})])
+vim.List([Mapping({"abcG" : FailingIter()})]):TypeError:('unable to convert FailingIter to vim structure',)
+vim.List([Mapping({"abcG" : FailingIterNext()})]):NotImplementedError:()
 <<< Finished
->>> Testing ConvertFromPyObject using vim.List([Mapping({"abc" : %s})])
-vim.List([Mapping({"abc" : None})]):TypeError:('unable to convert NoneType to vim structure',)
-vim.List([Mapping({"abc" : {"": 1}})]):ValueError:('empty keys are not allowed',)
-vim.List([Mapping({"abc" : {u"": 1}})]):ValueError:('empty keys are not allowed',)
-vim.List([Mapping({"abc" : FailingMapping()})]):NotImplementedError:()
-vim.List([Mapping({"abc" : FailingMappingKey()})]):NotImplementedError:()
+>>> Testing ConvertFromPyObject using vim.List([Mapping({"abcG" : %s})])
+vim.List([Mapping({"abcG" : None})]):TypeError:('unable to convert NoneType to vim structure',)
+vim.List([Mapping({"abcG" : {"": 1}})]):ValueError:('empty keys are not allowed',)
+vim.List([Mapping({"abcG" : {u"": 1}})]):ValueError:('empty keys are not allowed',)
+vim.List([Mapping({"abcG" : FailingMapping()})]):NotImplementedError:()
+vim.List([Mapping({"abcG" : FailingMappingKey()})]):NotImplementedError:()
 <<< Finished
 >>> Testing *Iter* using vim.List([%s])
 vim.List([FailingIter()]):TypeError:('unable to convert FailingIter to vim structure',)
@@ -757,58 +760,58 @@ l[1000]:IndexError:('list index out of range',)
 ll[1] = 2:error:('list is locked',)
 l[1000] = 3:IndexError:('list index out of range',)
 >> ListAssSlice
-ll[1:100] = "abc":error:('list is locked',)
+ll[1:100] = "abcJ":error:('list is locked',)
 >>> 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[:] = [{"abc" : {%s : 1}}]
-l[:] = [{"abc" : {1 : 1}}]:TypeError:('expected str() or unicode() instance, but got int',)
-l[:] = [{"abc" : {u"\0" : 1}}]:TypeError:('expected string without null bytes',)
-l[:] = [{"abc" : {"\0" : 1}}]:TypeError:('expected string without null bytes',)
+>>> 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[:] = [{"abc" : Mapping({%s : 1})}]
-l[:] = [{"abc" : Mapping({1 : 1})}]:TypeError:('expected str() or unicode() instance, but got int',)
-l[:] = [{"abc" : Mapping({u"\0" : 1})}]:TypeError:('expected string without null bytes',)
-l[:] = [{"abc" : Mapping({"\0" : 1})}]:TypeError:('expected string without null bytes',)
+>>> 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[:] = [{"abc" : %s}]
-l[:] = [{"abc" : FailingIter()}]:TypeError:('unable to convert FailingIter to vim structure',)
-l[:] = [{"abc" : FailingIterNext()}]:NotImplementedError:()
+>>> Testing *Iter* using l[:] = [{"abcF" : %s}]
+l[:] = [{"abcF" : FailingIter()}]:TypeError:('unable to convert FailingIter to vim structure',)
+l[:] = [{"abcF" : FailingIterNext()}]:NotImplementedError:()
 <<< Finished
->>> Testing ConvertFromPyObject using l[:] = [{"abc" : %s}]
-l[:] = [{"abc" : None}]:TypeError:('unable to convert NoneType to vim structure',)
-l[:] = [{"abc" : {"": 1}}]:ValueError:('empty keys are not allowed',)
-l[:] = [{"abc" : {u"": 1}}]:ValueError:('empty keys are not allowed',)
-l[:] = [{"abc" : FailingMapping()}]:NotImplementedError:()
-l[:] = [{"abc" : FailingMappingKey()}]:NotImplementedError:()
+>>> Testing ConvertFromPyObject using l[:] = [{"abcF" : %s}]
+l[:] = [{"abcF" : None}]:TypeError:('unable to convert NoneType to vim structure',)
+l[:] = [{"abcF" : {"": 1}}]:ValueError:('empty keys are not allowed',)
+l[:] = [{"abcF" : {u"": 1}}]:ValueError:('empty keys are not allowed',)
+l[:] = [{"abcF" : FailingMapping()}]:NotImplementedError:()
+l[:] = [{"abcF" : FailingMappingKey()}]:NotImplementedError:()
 <<< 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({"abc" : {%s : 1}})]
-l[:] = [Mapping({"abc" : {1 : 1}})]:TypeError:('expected str() or unicode() instance, but got int',)
-l[:] = [Mapping({"abc" : {u"\0" : 1}})]:TypeError:('expected string without null bytes',)
-l[:] = [Mapping({"abc" : {"\0" : 1}})]:TypeError:('expected string without null bytes',)
+>>> 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({"abc" : Mapping({%s : 1})})]
-l[:] = [Mapping({"abc" : Mapping({1 : 1})})]:TypeError:('expected str() or unicode() instance, but got int',)
-l[:] = [Mapping({"abc" : Mapping({u"\0" : 1})})]:TypeError:('expected string without null bytes',)
-l[:] = [Mapping({"abc" : Mapping({"\0" : 1})})]:TypeError:('expected string without null bytes',)
+>>> 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({"abc" : %s})]
-l[:] = [Mapping({"abc" : FailingIter()})]:TypeError:('unable to convert FailingIter to vim structure',)
-l[:] = [Mapping({"abc" : FailingIterNext()})]:NotImplementedError:()
+>>> Testing *Iter* using l[:] = [Mapping({"abcG" : %s})]
+l[:] = [Mapping({"abcG" : FailingIter()})]:TypeError:('unable to convert FailingIter to vim structure',)
+l[:] = [Mapping({"abcG" : FailingIterNext()})]:NotImplementedError:()
 <<< Finished
->>> Testing ConvertFromPyObject using l[:] = [Mapping({"abc" : %s})]
-l[:] = [Mapping({"abc" : None})]:TypeError:('unable to convert NoneType to vim structure',)
-l[:] = [Mapping({"abc" : {"": 1}})]:ValueError:('empty keys are not allowed',)
-l[:] = [Mapping({"abc" : {u"": 1}})]:ValueError:('empty keys are not allowed',)
-l[:] = [Mapping({"abc" : FailingMapping()})]:NotImplementedError:()
-l[:] = [Mapping({"abc" : FailingMappingKey()})]:NotImplementedError:()
+>>> Testing ConvertFromPyObject using l[:] = [Mapping({"abcG" : %s})]
+l[:] = [Mapping({"abcG" : None})]:TypeError:('unable to convert NoneType to vim structure',)
+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:()
+l[:] = [Mapping({"abcG" : FailingMappingKey()})]:NotImplementedError:()
 <<< Finished
 >>> Testing *Iter* using l[:] = [%s]
 l[:] = [FailingIter()]:TypeError:('unable to convert FailingIter to vim structure',)
@@ -827,52 +830,52 @@ l.extend([{1 : 1}]):TypeError:('expected str() or unicode() instance, but got in
 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([{"abc" : {%s : 1}}])
-l.extend([{"abc" : {1 : 1}}]):TypeError:('expected str() or unicode() instance, but got int',)
-l.extend([{"abc" : {u"\0" : 1}}]):TypeError:('expected string without null bytes',)
-l.extend([{"abc" : {"\0" : 1}}]):TypeError:('expected string without null bytes',)
+>>> 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([{"abc" : Mapping({%s : 1})}])
-l.extend([{"abc" : Mapping({1 : 1})}]):TypeError:('expected str() or unicode() instance, but got int',)
-l.extend([{"abc" : Mapping({u"\0" : 1})}]):TypeError:('expected string without null bytes',)
-l.extend([{"abc" : Mapping({"\0" : 1})}]):TypeError:('expected string without null bytes',)
+>>> 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([{"abc" : %s}])
-l.extend([{"abc" : FailingIter()}]):TypeError:('unable to convert FailingIter to vim structure',)
-l.extend([{"abc" : FailingIterNext()}]):NotImplementedError:()
+>>> Testing *Iter* using l.extend([{"abcF" : %s}])
+l.extend([{"abcF" : FailingIter()}]):TypeError:('unable to convert FailingIter to vim structure',)
+l.extend([{"abcF" : FailingIterNext()}]):NotImplementedError:()
 <<< Finished
->>> Testing ConvertFromPyObject using l.extend([{"abc" : %s}])
-l.extend([{"abc" : None}]):TypeError:('unable to convert NoneType to vim structure',)
-l.extend([{"abc" : {"": 1}}]):ValueError:('empty keys are not allowed',)
-l.extend([{"abc" : {u"": 1}}]):ValueError:('empty keys are not allowed',)
-l.extend([{"abc" : FailingMapping()}]):NotImplementedError:()
-l.extend([{"abc" : FailingMappingKey()}]):NotImplementedError:()
+>>> Testing ConvertFromPyObject using l.extend([{"abcF" : %s}])
+l.extend([{"abcF" : None}]):TypeError:('unable to convert NoneType to vim structure',)
+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:()
+l.extend([{"abcF" : FailingMappingKey()}]):NotImplementedError:()
 <<< 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({"abc" : {%s : 1}})])
-l.extend([Mapping({"abc" : {1 : 1}})]):TypeError:('expected str() or unicode() instance, but got int',)
-l.extend([Mapping({"abc" : {u"\0" : 1}})]):TypeError:('expected string without null bytes',)
-l.extend([Mapping({"abc" : {"\0" : 1}})]):TypeError:('expected string without null bytes',)
+>>> 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({"abc" : Mapping({%s : 1})})])
-l.extend([Mapping({"abc" : Mapping({1 : 1})})]):TypeError:('expected str() or unicode() instance, but got int',)
-l.extend([Mapping({"abc" : Mapping({u"\0" : 1})})]):TypeError:('expected string without null bytes',)
-l.extend([Mapping({"abc" : Mapping({"\0" : 1})})]):TypeError:('expected string without null bytes',)
+>>> 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({"abc" : %s})])
-l.extend([Mapping({"abc" : FailingIter()})]):TypeError:('unable to convert FailingIter to vim structure',)
-l.extend([Mapping({"abc" : FailingIterNext()})]):NotImplementedError:()
+>>> Testing *Iter* using l.extend([Mapping({"abcG" : %s})])
+l.extend([Mapping({"abcG" : FailingIter()})]):TypeError:('unable to convert FailingIter to vim structure',)
+l.extend([Mapping({"abcG" : FailingIterNext()})]):NotImplementedError:()
 <<< Finished
->>> Testing ConvertFromPyObject using l.extend([Mapping({"abc" : %s})])
-l.extend([Mapping({"abc" : None})]):TypeError:('unable to convert NoneType to vim structure',)
-l.extend([Mapping({"abc" : {"": 1}})]):ValueError:('empty keys are not allowed',)
-l.extend([Mapping({"abc" : {u"": 1}})]):ValueError:('empty keys are not allowed',)
-l.extend([Mapping({"abc" : FailingMapping()})]):NotImplementedError:()
-l.extend([Mapping({"abc" : FailingMappingKey()})]):NotImplementedError:()
+>>> Testing ConvertFromPyObject using l.extend([Mapping({"abcG" : %s})])
+l.extend([Mapping({"abcG" : None})]):TypeError:('unable to convert NoneType to vim structure',)
+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:()
+l.extend([Mapping({"abcG" : FailingMappingKey()})]):NotImplementedError:()
 <<< Finished
 >>> Testing *Iter* using l.extend([%s])
 l.extend([FailingIter()]):TypeError:('unable to convert FailingIter to vim structure',)
@@ -900,52 +903,52 @@ 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({"abc" : {%s : 1}})
-f({"abc" : {1 : 1}}):TypeError:('expected str() or unicode() instance, but got int',)
-f({"abc" : {u"\0" : 1}}):TypeError:('expected string without null bytes',)
-f({"abc" : {"\0" : 1}}):TypeError:('expected string without null bytes',)
+>>> 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({"abc" : Mapping({%s : 1})})
-f({"abc" : Mapping({1 : 1})}):TypeError:('expected str() or unicode() instance, but got int',)
-f({"abc" : Mapping({u"\0" : 1})}):TypeError:('expected string without null bytes',)
-f({"abc" : Mapping({"\0" : 1})}):TypeError:('expected string without null bytes',)
+>>> 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({"abc" : %s})
-f({"abc" : FailingIter()}):TypeError:('unable to convert FailingIter to vim structure',)
-f({"abc" : FailingIterNext()}):NotImplementedError:()
+>>> Testing *Iter* using f({"abcF" : %s})
+f({"abcF" : FailingIter()}):TypeError:('unable to convert FailingIter to vim structure',)
+f({"abcF" : FailingIterNext()}):NotImplementedError:()
 <<< Finished
->>> Testing ConvertFromPyObject using f({"abc" : %s})
-f({"abc" : None}):TypeError:('unable to convert NoneType to vim structure',)
-f({"abc" : {"": 1}}):ValueError:('empty keys are not allowed',)
-f({"abc" : {u"": 1}}):ValueError:('empty keys are not allowed',)
-f({"abc" : FailingMapping()}):NotImplementedError:()
-f({"abc" : FailingMappingKey()}):NotImplementedError:()
+>>> Testing ConvertFromPyObject using f({"abcF" : %s})
+f({"abcF" : None}):TypeError:('unable to convert NoneType to vim structure',)
+f({"abcF" : {"": 1}}):ValueError:('empty keys are not allowed',)
+f({"abcF" : {u"": 1}}):ValueError:('empty keys are not allowed',)
+f({"abcF" : FailingMapping()}):NotImplementedError:()
+f({"abcF" : FailingMappingKey()}):NotImplementedError:()
 <<< 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({"abc" : {%s : 1}}))
-f(Mapping({"abc" : {1 : 1}})):TypeError:('expected str() or unicode() instance, but got int',)
-f(Mapping({"abc" : {u"\0" : 1}})):TypeError:('expected string without null bytes',)
-f(Mapping({"abc" : {"\0" : 1}})):TypeError:('expected string without null bytes',)
+>>> 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({"abc" : Mapping({%s : 1})}))
-f(Mapping({"abc" : Mapping({1 : 1})})):TypeError:('expected str() or unicode() instance, but got int',)
-f(Mapping({"abc" : Mapping({u"\0" : 1})})):TypeError:('expected string without null bytes',)
-f(Mapping({"abc" : Mapping({"\0" : 1})})):TypeError:('expected string without null bytes',)
+>>> 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({"abc" : %s}))
-f(Mapping({"abc" : FailingIter()})):TypeError:('unable to convert FailingIter to vim structure',)
-f(Mapping({"abc" : FailingIterNext()})):NotImplementedError:()
+>>> Testing *Iter* using f(Mapping({"abcG" : %s}))
+f(Mapping({"abcG" : FailingIter()})):TypeError:('unable to convert FailingIter to vim structure',)
+f(Mapping({"abcG" : FailingIterNext()})):NotImplementedError:()
 <<< Finished
->>> Testing ConvertFromPyObject using f(Mapping({"abc" : %s}))
-f(Mapping({"abc" : None})):TypeError:('unable to convert NoneType to vim structure',)
-f(Mapping({"abc" : {"": 1}})):ValueError:('empty keys are not allowed',)
-f(Mapping({"abc" : {u"": 1}})):ValueError:('empty keys are not allowed',)
-f(Mapping({"abc" : FailingMapping()})):NotImplementedError:()
-f(Mapping({"abc" : FailingMappingKey()})):NotImplementedError:()
+>>> Testing ConvertFromPyObject using f(Mapping({"abcG" : %s}))
+f(Mapping({"abcG" : None})):TypeError:('unable to convert NoneType to vim structure',)
+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:()
+f(Mapping({"abcG" : FailingMappingKey()})):NotImplementedError:()
 <<< Finished
 >>> Testing *Iter* using f(%s)
 f(FailingIter()):TypeError:('unable to convert FailingIter to vim structure',)
@@ -963,52 +966,52 @@ 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={"abc" : {%s : 1}})
-fd(self={"abc" : {1 : 1}}):TypeError:('expected str() or unicode() instance, but got int',)
-fd(self={"abc" : {u"\0" : 1}}):TypeError:('expected string without null bytes',)
-fd(self={"abc" : {"\0" : 1}}):TypeError:('expected string without null bytes',)
+>>> 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={"abc" : Mapping({%s : 1})})
-fd(self={"abc" : Mapping({1 : 1})}):TypeError:('expected str() or unicode() instance, but got int',)
-fd(self={"abc" : Mapping({u"\0" : 1})}):TypeError:('expected string without null bytes',)
-fd(self={"abc" : Mapping({"\0" : 1})}):TypeError:('expected string without null bytes',)
+>>> 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={"abc" : %s})
-fd(self={"abc" : FailingIter()}):TypeError:('unable to convert FailingIter to vim structure',)
-fd(self={"abc" : FailingIterNext()}):NotImplementedError:()
+>>> Testing *Iter* using fd(self={"abcF" : %s})
+fd(self={"abcF" : FailingIter()}):TypeError:('unable to convert FailingIter to vim structure',)
+fd(self={"abcF" : FailingIterNext()}):NotImplementedError:()
 <<< Finished
->>> Testing ConvertFromPyObject using fd(self={"abc" : %s})
-fd(self={"abc" : None}):TypeError:('unable to convert NoneType to vim structure',)
-fd(self={"abc" : {"": 1}}):ValueError:('empty keys are not allowed',)
-fd(self={"abc" : {u"": 1}}):ValueError:('empty keys are not allowed',)
-fd(self={"abc" : FailingMapping()}):NotImplementedError:()
-fd(self={"abc" : FailingMappingKey()}):NotImplementedError:()
+>>> Testing ConvertFromPyObject using fd(self={"abcF" : %s})
+fd(self={"abcF" : None}):TypeError:('unable to convert NoneType to vim structure',)
+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:()
+fd(self={"abcF" : FailingMappingKey()}):NotImplementedError:()
 <<< 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({"abc" : {%s : 1}}))
-fd(self=Mapping({"abc" : {1 : 1}})):TypeError:('expected str() or unicode() instance, but got int',)
-fd(self=Mapping({"abc" : {u"\0" : 1}})):TypeError:('expected string without null bytes',)
-fd(self=Mapping({"abc" : {"\0" : 1}})):TypeError:('expected string without null bytes',)
+>>> 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({"abc" : Mapping({%s : 1})}))
-fd(self=Mapping({"abc" : Mapping({1 : 1})})):TypeError:('expected str() or unicode() instance, but got int',)
-fd(self=Mapping({"abc" : Mapping({u"\0" : 1})})):TypeError:('expected string without null bytes',)
-fd(self=Mapping({"abc" : Mapping({"\0" : 1})})):TypeError:('expected string without null bytes',)
+>>> 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({"abc" : %s}))
-fd(self=Mapping({"abc" : FailingIter()})):TypeError:('unable to convert FailingIter to vim structure',)
-fd(self=Mapping({"abc" : FailingIterNext()})):NotImplementedError:()
+>>> Testing *Iter* using fd(self=Mapping({"abcG" : %s}))
+fd(self=Mapping({"abcG" : FailingIter()})):TypeError:('unable to convert FailingIter to vim structure',)
+fd(self=Mapping({"abcG" : FailingIterNext()})):NotImplementedError:()
 <<< Finished
->>> Testing ConvertFromPyObject using fd(self=Mapping({"abc" : %s}))
-fd(self=Mapping({"abc" : None})):TypeError:('unable to convert NoneType to vim structure',)
-fd(self=Mapping({"abc" : {"": 1}})):ValueError:('empty keys are not allowed',)
-fd(self=Mapping({"abc" : {u"": 1}})):ValueError:('empty keys are not allowed',)
-fd(self=Mapping({"abc" : FailingMapping()})):NotImplementedError:()
-fd(self=Mapping({"abc" : FailingMappingKey()})):NotImplementedError:()
+>>> Testing ConvertFromPyObject using fd(self=Mapping({"abcG" : %s}))
+fd(self=Mapping({"abcG" : None})):TypeError:('unable to convert NoneType to vim structure',)
+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:()
+fd(self=Mapping({"abcG" : FailingMappingKey()})):NotImplementedError:()
 <<< Finished
 >>> Testing *Iter* using fd(self=%s)
 fd(self=FailingIter()):TypeError:('unable to convert FailingIter to vim dictionary',)
@@ -1037,8 +1040,8 @@ vim.current.window.xxx:AttributeError:('xxx',)
 vim.current.window.buffer = 0:TypeError:('readonly attribute: buffer',)
 vim.current.window.cursor = (100000000, 100000000):error:('cursor position outside buffer',)
 vim.current.window.cursor = True:TypeError:('argument must be 2-item sequence, not bool',)
-vim.current.window.height = "abc":TypeError:('expected int(), long() or something supporting coercing to long(), but got str',)
-vim.current.window.width  = "abc":TypeError:('expected int(), long() or something supporting coercing to long(), but got str',)
+vim.current.window.height = "abcK":TypeError:('expected int(), long() or something supporting coercing to long(), but got str',)
+vim.current.window.width  = "abcL":TypeError:('expected int(), long() or something supporting coercing to long(), but got str',)
 vim.current.window.xxxxxx = True:AttributeError:('xxxxxx',)
 > WinList
 >> WinListItem
@@ -1048,7 +1051,7 @@ vim.windows[1000]:IndexError:('no such window',)
 vim.current.buffer[0] = "\na":error:('string cannot contain newlines',)
 >> SetBufferLine (indirect)
 vim.current.buffer[0] = True:TypeError:('bad argument type for built-in operation',)
->> SetBufferLines (indirect)
+>> SetBufferLineList (indirect)
 vim.current.buffer[:] = True:TypeError:('bad argument type for built-in operation',)
 vim.current.buffer[:] = ["\na", "bc"]:error:('string cannot contain newlines',)
 >> InsertBufferLines (indirect)
@@ -1066,7 +1069,7 @@ vim.current.buffer.name = True:TypeError:('expected str() or unicode() instance,
 vim.current.buffer.xxx = True:AttributeError:('xxx',)
 >> BufferMark
 vim.current.buffer.mark(0):TypeError:('expected str() or unicode() instance, but got int',)
-vim.current.buffer.mark("abc"):ValueError:('mark name must be a single character',)
+vim.current.buffer.mark("abcM"):ValueError:('mark name must be a single character',)
 vim.current.buffer.mark("!"):error:('invalid mark name',)
 >> BufferRange
 vim.current.buffer.range(1, 2, 3):TypeError:('function takes exactly 2 arguments (3 given)',)
@@ -1086,7 +1089,7 @@ vim.current.xxx = True:AttributeError:('xxx',)
 2,xx
 before
 after
-vim.command("throw 'abc'"):error:('abc',)
+vim.command("throw 'abcN'"):error:('abcN',)
 Exe("throw 'def'"):error:('def',)
 vim.eval("Exe('throw ''ghi''')"):error:('ghi',)
 vim.eval("Exe('echoerr ''jkl''')"):error:('Vim(echoerr):jkl',)
diff --git a/src/testdir/test87.in b/src/testdir/test87.in
index 1223ca96a..6b89117be 100644
--- a/src/testdir/test87.in
+++ b/src/testdir/test87.in
@@ -5,8 +5,8 @@ STARTTEST
 :set noswapfile
 :if !has('python3') | e! test.ok | wq! test.out | endif
 :lang C
-:py3 import vim
 :fun Test()
+:py3 import vim
 :let l = []
 :py3 l=vim.bindeval('l')
 :py3 f=vim.bindeval('function("strlen")')
@@ -51,6 +51,9 @@ EOF
 :  $put =string(key) . ' : ' . string(Val)
 :  unlet key Val
 :endfor
+:py3 del dk
+:py3 del di
+:py3 del dv
 :"
 :" removing items with del
 :py3 del l[2]
@@ -169,12 +172,12 @@ EOF
 :unlockvar! l
 :"
 :" Function calls
-:function New(...)
-:return ['NewStart']+a:000+['NewEnd']
-:endfunction
-:function DictNew(...) dict
-:return ['DictNewStart']+a:000+['DictNewEnd', self]
-:endfunction
+:fun New(...)
+:   return ['NewStart']+a:000+['NewEnd']
+:endfun
+:fun DictNew(...) dict
+:   return ['DictNewStart']+a:000+['DictNewEnd', self]
+:endfun
 :let l=[function('New'), function('DictNew')]
 :py3 l=vim.bindeval('l')
 :py3 l.extend(list(l[0](1, 2, 3)))
@@ -204,7 +207,8 @@ EOF
 :   $put ='[0.0, 0.0]'
 :endif
 :let messages=[]
-:py3 <<EOF
+:delfunction DictNew
+py3 <<EOF
 d=vim.bindeval('{}')
 m=vim.bindeval('messages')
 def em(expr, g=globals(), l=locals()):
@@ -213,15 +217,17 @@ def em(expr, g=globals(), l=locals()):
     except Exception as e:
         m.extend([e.__class__.__name__])
 
-em('d["abc"]')
-em('d["abc"]="\\0"')
-em('d["abc"]=vim')
+em('d["abc1"]')
+em('d["abc1"]="\\0"')
+em('d["abc1"]=vim')
 em('d[""]=1')
 em('d["a\\0b"]=1')
 em('d[b"a\\0b"]=1')
 
-em('d.pop("abc")')
+em('d.pop("abc1")')
 em('d.popitem()')
+del em
+del m
 EOF
 :$put =messages
 :unlet messages
@@ -233,8 +239,8 @@ EOF
 :    let toput=s.' : '.join(map(['locked', 'scope'], 'v:val.":".py3eval(name.".".v:val)'), ';')
 :    $put =toput
 :endfor
-:silent! let d.abc=1
-:silent! let dl.abc=1
+:silent! let d.abc2=1
+:silent! let dl.abc3=1
 :py3 d.locked=True
 :py3 dl.locked=False
 :silent! let d.def=1
@@ -300,12 +306,15 @@ class T(threading.Thread):
             time.sleep(0.1)
 
 t = T()
+del T
 t.start()
 EOF
 :sleep 1
 :py3 t.running = False
 :py3 t.join()
 :py3 l[0] = t.t > 8  # check if the background thread is working
+:py3 del time
+:py3 del threading
 :$put =string(l)
 :"
 :" settrace
@@ -326,12 +335,14 @@ def trace_main():
 EOF
 :py3 sys.settrace(traceit)
 :py3 trace_main()
+:py3 del traceit
+:py3 del trace_main
 :py3 sys.settrace(None)
 :$put =string(l)
 :"
 :" Vars
 :let g:foo = 'bac'
-:let w:abc = 'def'
+:let w:abc3 = 'def'
 :let b:baz = 'bar'
 :let t:bar = 'jkl'
 :try
@@ -340,7 +351,7 @@ EOF
 :  put =py3eval('vim.vvars[''exception'']')
 :endtry
 :put =py3eval('vim.vars[''foo'']')
-:put =py3eval('vim.current.window.vars[''abc'']')
+:put =py3eval('vim.current.window.vars[''abc3'']')
 :put =py3eval('vim.current.buffer.vars[''baz'']')
 :put =py3eval('vim.current.tabpage.vars[''bar'']')
 :"
@@ -388,16 +399,16 @@ def ev(s, g=globals(), l=locals()):
         vim.command('let exc=' + repr(e.__class__.__name__))
         return 0
 EOF
-:function E(s)
+:fun E(s)
 :   python3 e(vim.eval('a:s'))
-:endfunction
-:function Ev(s)
+:endfun
+:fun Ev(s)
 :   let r=py3eval('ev(vim.eval("a:s"))')
 :   if exists('exc')
 :       throw exc
 :   endif
 :   return r
-:endfunction
+:endfun
 :py3 gopts1=vim.options
 :py3 wopts1=vim.windows[2].options
 :py3 wopts2=vim.windows[0].options
@@ -412,7 +423,7 @@ EOF
 :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',  'abc',  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    ]]
@@ -462,10 +473,27 @@ EOF
 :   endfor
 :   call RecVars(oname)
 :endfor
+:delfunction RecVars
+:delfunction E
+:delfunction Ev
+:py3 del ev
+:py3 del e
 :only
 :for buf in g:bufs[1:]
 :   execute 'bwipeout!' buf
 :endfor
+:py3 del gopts1
+:py3 del wopts1
+:py3 del wopts2
+:py3 del wopts3
+:py3 del bopts1
+:py3 del bopts2
+:py3 del bopts3
+:py3 del oval1
+:py3 del oval2
+:py3 del oval3
+:py3 del oname
+:py3 del invval
 :"
 :" Test buffer object
 :vnew
@@ -485,7 +513,7 @@ cb = vim.current.buffer
 # Tests BufferAppend and BufferItem
 cb.append(b[0])
 # Tests BufferSlice and BufferAssSlice
-cb.append('abc') # Will be overwritten
+cb.append('abc5') # Will be overwritten
 cb[-1:] = b[:-2]
 # Test BufferLength and BufferAssSlice
 cb.append('def') # Will not be overwritten
@@ -509,13 +537,14 @@ b.name = 'bar'
 cb.append(b.name[-11:].replace(os.path.sep, '/'))
 cb.name = old_name
 cb.append(cb.name[-17:].replace(os.path.sep, '/'))
+del old_name
 # Test CheckBuffer
 for _b in vim.buffers:
     if _b is not cb:
         vim.command('bwipeout! ' + str(_b.number))
 del _b
 cb.append('valid: b:%s, cb:%s' % (repr(b.valid), repr(cb.valid)))
-for expr in ('b[1]','b[:] = ["A", "B"]','b[:]','b.append("abc")'):
+for expr in ('b[1]','b[:] = ["A", "B"]','b[:]','b.append("abc6")'):
     try:
         exec(expr)
     except vim.error:
@@ -525,6 +554,7 @@ for expr in ('b[1]','b[:] = ["A", "B"]','b[:]','b.append("abc")'):
         # Should not happen in any case
         cb.append('No exception for ' + expr)
 vim.command('cd .')
+del b
 EOF
 :"
 :" Test vim.buffers object
@@ -558,6 +588,7 @@ for b in vim.buffers:
     # Check indexing: vim.buffers[number].number == number
     cb.append(str(b.number) + ':' + repr(vim.buffers[b.number]) + '=' + repr(b))
     prevnum = b.number
+del prevnum
 
 cb.append(str(len(vim.buffers)))
 
@@ -581,6 +612,8 @@ try:
     next(i4)
 except StopIteration:
     cb.append('StopIteration')
+del i4
+del bnums
 EOF
 :"
 :" Test vim.{tabpage,window}list and vim.{tabpage,window} objects
@@ -622,7 +655,11 @@ for t in vim.tabpages:
                     raise ValueError
             except Exception as e:
                 cb.append('!!!!!! Error while getting attribute ' + attr + ': ' + e.__class__.__name__)
+        del aval
+        del attr
         w.cursor = (len(w.buffer), 0)
+del W
+del Cursor
 cb.append('Number of windows in current tab page: ' + str(len(vim.windows)))
 if list(vim.windows) != list(vim.current.tabpage.windows):
     cb.append('!!!!!! Windows differ')
@@ -635,6 +672,7 @@ def H(o):
 cb.append('Current tab page: ' + repr(vim.current.tabpage))
 cb.append('Current window: ' + repr(vim.current.window) + ': ' + H(vim.current.window) + ' is ' + H(vim.current.tabpage.window))
 cb.append('Current buffer: ' + repr(vim.current.buffer) + ': ' + H(vim.current.buffer) + ' is ' + H(vim.current.window.buffer)+ ' is ' + H(vim.current.tabpage.window.buffer))
+del H
 # Assigning: fails
 try:
     vim.current.window = vim.tabpages[0].window
@@ -646,6 +684,7 @@ for attr in ('window', 'tabpage', 'buffer'):
         setattr(vim.current, attr, None)
     except TypeError:
         cb.append('Type error at assigning None to vim.current.' + attr)
+del attr
 
 # Assigning: success
 vim.current.tabpage = vim.tabpages[-2]
@@ -661,8 +700,13 @@ ts = list(vim.tabpages)
 for b in vim.buffers:
     if b is not cb:
         vim.command('bwipeout! ' + str(b.number))
+del b
 cb.append('w.valid: ' + repr([w.valid for w in ws]))
 cb.append('t.valid: ' + repr([t.valid for t in ts]))
+del w
+del t
+del ts
+del ws
 EOF
 :tabonly!
 :only!
@@ -681,6 +725,8 @@ for expr, attr in (
     ('vim.current.tabpage',              'TabPage'),
 ):
     cb.append(expr + ':' + attr + ':' + repr(type(eval(expr)) is getattr(vim, attr)))
+del expr
+del attr
 EOF
 :"
 :" Test __dir__() method
@@ -706,15 +752,15 @@ EOF
 :$put =string(py3eval('vim.Dictionary(a=1)'))
 :$put =string(py3eval('vim.Dictionary(((''a'', 1),))'))
 :$put =string(py3eval('vim.List()'))
-:$put =string(py3eval('vim.List(iter(''abc''))'))
+:$put =string(py3eval('vim.List(iter(''abc7''))'))
 :$put =string(py3eval('vim.Function(''tr'')'))
 :"
 :" Test stdout/stderr
 :redir => messages
-:py3 sys.stdout.write('abc') ; sys.stdout.write('def')
-:py3 sys.stderr.write('abc') ; sys.stderr.write('def')
-:py3 sys.stdout.writelines(iter('abc'))
-:py3 sys.stderr.writelines(iter('abc'))
+:py3 sys.stdout.write('abc8') ; sys.stdout.write('def')
+:py3 sys.stderr.write('abc9') ; sys.stderr.write('def')
+:py3 sys.stdout.writelines(iter('abcA'))
+:py3 sys.stderr.writelines(iter('abcB'))
 :redir END
 :$put =string(substitute(messages, '\d\+', '', 'g'))
 :" Test subclassing
@@ -735,7 +781,7 @@ class DupList(vim.List):
         return [super(DupList, self).__getitem__(idx)] * 2
 
 dl = DupList()
-dl2 = DupList(iter('abc'))
+dl2 = DupList(iter('abcC'))
 dl.extend(dl2[0])
 
 class DupFun(vim.Function):
@@ -748,6 +794,19 @@ EOF
 :$put =string(py3eval('dl'))
 :$put =string(py3eval('dl2'))
 :$put =string(py3eval('df(2)'))
+:$put =string(py3eval('dl') is# py3eval('dl'))
+:$put =string(py3eval('dd') is# py3eval('dd'))
+:$put =string(py3eval('df'))
+:delfunction Put
+py3 << EOF
+del DupDict
+del DupList
+del DupFun
+del dd
+del dl
+del dl2
+del df
+EOF
 :"
 :" Test chdir
 py3 << EOF
@@ -761,6 +820,7 @@ cb.append(vim.eval('@%').replace(os.path.sep, '/'))
 os.chdir('testdir')
 cb.append(str(fnamemodify('.', ':p:h:t')))
 cb.append(vim.eval('@%'))
+del fnamemodify
 EOF
 :"
 :" Test errors
@@ -784,11 +844,11 @@ def ee(expr, g=globals(), l=locals()):
         cb.append(expr + '::' + repr((e.__class__, e)))
 
 d = vim.Dictionary()
-ned = vim.Dictionary(foo='bar', baz='abc')
+ned = vim.Dictionary(foo='bar', baz='abcD')
 dl = vim.Dictionary(a=1)
 dl.locked = True
 l = vim.List()
-ll = vim.List('abc')
+ll = vim.List('abcE')
 ll.locked = True
 f = vim.Function('string')
 fd = vim.Function('F')
@@ -825,11 +885,11 @@ def convertfrompyobject_test(expr, recurse=True):
     # pydict_to_tv
     stringtochars_test(expr % '{%s : 1}')
     if recurse:
-        convertfrompyobject_test(expr % '{"abc" : %s}', False)
+        convertfrompyobject_test(expr % '{"abcF" : %s}', False)
     # pymap_to_tv
     stringtochars_test(expr % 'Mapping({%s : 1})')
     if recurse:
-        convertfrompyobject_test(expr % 'Mapping({"abc" : %s})', False)
+        convertfrompyobject_test(expr % 'Mapping({"abcG" : %s})', False)
     # pyseq_to_tv
     iter_test(expr)
     return subexpr_test(expr, 'ConvertFromPyObject', (
@@ -872,7 +932,7 @@ class FailingMappingKey(object):
         raise NotImplementedError
 
     def keys(self):
-        return list("abc")
+        return list("abcH")
 
 class FailingMapping(object):
     def __getitem__(self):
@@ -914,7 +974,7 @@ cb.append("> VimStrwidth")
 ee('vim.strwidth(1)')
 cb.append("> Dictionary")
 cb.append(">> DictionaryConstructor")
-ee('vim.Dictionary("abc")')
+ee('vim.Dictionary("abcI")')
 ##! Not checked: py_dict_alloc failure
 cb.append(">> DictionarySetattr")
 ee('del d.locked')
@@ -929,6 +989,7 @@ ee('d.pop("a")')
 ee('dl.pop("a")')
 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')
@@ -958,7 +1019,7 @@ cb.append(">> ListAssItem")
 ee('ll[1] = 2')
 ee('l[1000] = 3')
 cb.append(">> ListAssSlice")
-ee('ll[1:100] = "abc"')
+ee('ll[1:100] = "abcJ"')
 iter_test('l[:] = %s')
 convertfrompyobject_test('l[:] = [%s]')
 cb.append(">> ListConcatInPlace")
@@ -989,8 +1050,8 @@ cb.append(">> WindowSetattr")
 ee('vim.current.window.buffer = 0')
 ee('vim.current.window.cursor = (100000000, 100000000)')
 ee('vim.current.window.cursor = True')
-ee('vim.current.window.height = "abc"')
-ee('vim.current.window.width  = "abc"')
+ee('vim.current.window.height = "abcK"')
+ee('vim.current.window.width  = "abcL"')
 ee('vim.current.window.xxxxxx = True')
 cb.append("> WinList")
 cb.append(">> WinListItem")
@@ -1000,7 +1061,7 @@ cb.append(">> StringToLine (indirect)")
 ee('vim.current.buffer[0] = "\\na"')
 cb.append(">> SetBufferLine (indirect)")
 ee('vim.current.buffer[0] = True')
-cb.append(">> SetBufferLines (indirect)")
+cb.append(">> SetBufferLineList (indirect)")
 ee('vim.current.buffer[:] = True')
 ee('vim.current.buffer[:] = ["\\na", "bc"]')
 cb.append(">> InsertBufferLines (indirect)")
@@ -1018,7 +1079,7 @@ ee('vim.current.buffer.name = True')
 ee('vim.current.buffer.xxx = True')
 cb.append(">> BufferMark")
 ee('vim.current.buffer.mark(0)')
-ee('vim.current.buffer.mark("abc")')
+ee('vim.current.buffer.mark("abcM")')
 ee('vim.current.buffer.mark("!")')
 cb.append(">> BufferRange")
 ee('vim.current.buffer.range(1, 2, 3)')
@@ -1035,7 +1096,28 @@ ee('vim.current.buffer = True')
 ee('vim.current.window = True')
 ee('vim.current.tabpage = True')
 ee('vim.current.xxx = True')
+del d
+del ned
+del dl
+del l
+del ll
+del f
+del fd
+del fdel
+del subexpr_test
+del stringtochars_test
+del Mapping
+del convertfrompyobject_test
+del convertfrompymapping_test
+del iter_test
+del FailingTrue
+del FailingIter
+del FailingIterNext
+del FailingMapping
+del FailingMappingKey
+del FailingList
 EOF
+:delfunction F
 :"
 :" Test import
 py3 << EOF
@@ -1049,6 +1131,10 @@ import before
 cb.append(before.dir)
 import after
 cb.append(after.dir)
+del before
+del after
+del d
+del ddir
 EOF
 :"
 :" Test exceptions
@@ -1057,18 +1143,48 @@ EOF
 :endfun
 py3 << EOF
 Exe = vim.bindeval('function("Exe")')
-ee('vim.command("throw \'abc\'")')
+ee('vim.command("throw \'abcN\'")')
 ee('Exe("throw \'def\'")')
 ee('vim.eval("Exe(\'throw \'\'ghi\'\'\')")')
 ee('vim.eval("Exe(\'echoerr \'\'jkl\'\'\')")')
 ee('vim.eval("Exe(\'xxx_non_existent_command_xxx\')")')
 ee('vim.bindeval("Exe(\'xxx_non_existent_command_xxx\')")')
+del Exe
+EOF
+:delfunction Exe
+:"
+:" Cleanup
+py3 << EOF
+del cb
+del ee
+del sys
+del os
+del vim
 EOF
 :endfun
 :"
-:call Test()
+:fun RunTest()
+:let checkrefs = !empty($PYTHONDUMPREFS)
+:let start = getline(1, '$')
+:for i in range(checkrefs ? 10 : 1)
+:   if i != 0
+:       %d _
+:       call setline(1, start)
+:   endif
+:   call Test()
+:   if i == 0
+:       let result = getline(1, '$')
+:   endif
+:endfor
+:if checkrefs
+:   %d _
+:   call setline(1, result)
+:endif
+:endfun
 :"
-:delfunc Test
+:call RunTest()
+:delfunction RunTest
+:delfunction Test
 :call garbagecollect(1)
 :"
 :/^start:/,$wq! test.out
diff --git a/src/testdir/test87.ok b/src/testdir/test87.ok
index b975eccb4..78b23074a 100644
--- a/src/testdir/test87.ok
+++ b/src/testdir/test87.ok
@@ -68,7 +68,7 @@ d : locked:0;scope:0
 dl : locked:1;scope:0
 v: : locked:2;scope:1
 g: : locked:0;scope:2
-d:{'abc': 1}
+d:{'abc2': 1}
 dl:{'def': 1}
 l : locked:0
 ll : locked:1
@@ -191,12 +191,12 @@ jkl
   B: 1:3 2:5 3:2 4:8
 >>> colorcolumn
   p/gopts1! KeyError
-  inv: 'abc'! KeyError
+  inv: 'abc4'! KeyError
   gopts1! KeyError
   p/wopts1: b''
-  inv: 'abc'! error
+  inv: 'abc4'! error
   p/bopts1! KeyError
-  inv: 'abc'! KeyError
+  inv: 'abc4'! KeyError
   bopts1! KeyError
   bopts2! KeyError
   bopts3! KeyError
@@ -404,20 +404,23 @@ output:__dir__,flush,softspace,write,writelines
 {'a': 1}
 {'a': 1}
 []
-['a', 'b', 'c']
+['a', 'b', 'c', '7']
 function('tr')
 '
 abcdef
 line  :
 abcdef
-abc
+abcA
 line  :
-abc'
+abcB'
 ['a', 'dup_a']
 ['a', 'a']
-['a', 'b', 'c']
+['a', 'b', 'c', 'C']
 [2, 2]
 [2, 2]
+1
+1
+function('Put')
 b'testdir'
 test87.in
 b'src'
@@ -449,7 +452,7 @@ vim.bindeval(1):(<class 'TypeError'>, TypeError('expected bytes() or str() insta
 vim.strwidth(1):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
 > Dictionary
 >> DictionaryConstructor
-vim.Dictionary("abc"):(<class 'ValueError'>, ValueError('expected sequence element of size 2, but got sequence of size 1',))
+vim.Dictionary("abcI"):(<class 'ValueError'>, ValueError('expected sequence element of size 2, but got sequence of size 1',))
 >> DictionarySetattr
 del d.locked:(<class 'AttributeError'>, AttributeError('cannot delete vim.Dictionary attributes',))
 d.locked = FailingTrue():(<class 'NotImplementedError'>, NotImplementedError())
@@ -479,52 +482,52 @@ d["a"] = {1 : 1}:(<class 'TypeError'>, TypeError('expected bytes() or str() inst
 d["a"] = {b"\0" : 1}:(<class 'TypeError'>, TypeError('expected bytes with no null',))
 d["a"] = {"\0" : 1}:(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing StringToChars using d["a"] = {"abc" : {%s : 1}}
-d["a"] = {"abc" : {1 : 1}}:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-d["a"] = {"abc" : {b"\0" : 1}}:(<class 'TypeError'>, TypeError('expected bytes with no null',))
-d["a"] = {"abc" : {"\0" : 1}}:(<class 'TypeError'>, TypeError('expected bytes with no null',))
+>>> Testing StringToChars using d["a"] = {"abcF" : {%s : 1}}
+d["a"] = {"abcF" : {1 : 1}}:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
+d["a"] = {"abcF" : {b"\0" : 1}}:(<class 'TypeError'>, TypeError('expected bytes with no null',))
+d["a"] = {"abcF" : {"\0" : 1}}:(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing StringToChars using d["a"] = {"abc" : Mapping({%s : 1})}
-d["a"] = {"abc" : Mapping({1 : 1})}:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-d["a"] = {"abc" : Mapping({b"\0" : 1})}:(<class 'TypeError'>, TypeError('expected bytes with no null',))
-d["a"] = {"abc" : Mapping({"\0" : 1})}:(<class 'TypeError'>, TypeError('expected bytes with no null',))
+>>> Testing StringToChars using d["a"] = {"abcF" : Mapping({%s : 1})}
+d["a"] = {"abcF" : Mapping({1 : 1})}:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
+d["a"] = {"abcF" : Mapping({b"\0" : 1})}:(<class 'TypeError'>, TypeError('expected bytes with no null',))
+d["a"] = {"abcF" : Mapping({"\0" : 1})}:(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing *Iter* using d["a"] = {"abc" : %s}
-d["a"] = {"abc" : FailingIter()}:(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
-d["a"] = {"abc" : FailingIterNext()}:(<class 'NotImplementedError'>, NotImplementedError())
+>>> Testing *Iter* using d["a"] = {"abcF" : %s}
+d["a"] = {"abcF" : FailingIter()}:(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
+d["a"] = {"abcF" : FailingIterNext()}:(<class 'NotImplementedError'>, NotImplementedError())
 <<< Finished
->>> Testing ConvertFromPyObject using d["a"] = {"abc" : %s}
-d["a"] = {"abc" : None}:(<class 'TypeError'>, TypeError('unable to convert NoneType to vim structure',))
-d["a"] = {"abc" : {b"": 1}}:(<class 'ValueError'>, ValueError('empty keys are not allowed',))
-d["a"] = {"abc" : {"": 1}}:(<class 'ValueError'>, ValueError('empty keys are not allowed',))
-d["a"] = {"abc" : FailingMapping()}:(<class 'NotImplementedError'>, NotImplementedError())
-d["a"] = {"abc" : FailingMappingKey()}:(<class 'NotImplementedError'>, NotImplementedError())
+>>> Testing ConvertFromPyObject using d["a"] = {"abcF" : %s}
+d["a"] = {"abcF" : None}:(<class 'TypeError'>, TypeError('unable to convert NoneType to vim structure',))
+d["a"] = {"abcF" : {b"": 1}}:(<class 'ValueError'>, ValueError('empty keys are not allowed',))
+d["a"] = {"abcF" : {"": 1}}:(<class 'ValueError'>, ValueError('empty keys are not allowed',))
+d["a"] = {"abcF" : FailingMapping()}:(<class 'NotImplementedError'>, NotImplementedError())
+d["a"] = {"abcF" : FailingMappingKey()}:(<class 'NotImplementedError'>, NotImplementedError())
 <<< Finished
 >>> Testing StringToChars using d["a"] = Mapping({%s : 1})
 d["a"] = Mapping({1 : 1}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
 d["a"] = Mapping({b"\0" : 1}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 d["a"] = Mapping({"\0" : 1}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing StringToChars using d["a"] = Mapping({"abc" : {%s : 1}})
-d["a"] = Mapping({"abc" : {1 : 1}}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-d["a"] = Mapping({"abc" : {b"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
-d["a"] = Mapping({"abc" : {"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+>>> Testing StringToChars using d["a"] = Mapping({"abcG" : {%s : 1}})
+d["a"] = Mapping({"abcG" : {1 : 1}}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
+d["a"] = Mapping({"abcG" : {b"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+d["a"] = Mapping({"abcG" : {"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing StringToChars using d["a"] = Mapping({"abc" : Mapping({%s : 1})})
-d["a"] = Mapping({"abc" : Mapping({1 : 1})}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-d["a"] = Mapping({"abc" : Mapping({b"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
-d["a"] = Mapping({"abc" : Mapping({"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+>>> Testing StringToChars using d["a"] = Mapping({"abcG" : Mapping({%s : 1})})
+d["a"] = Mapping({"abcG" : Mapping({1 : 1})}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
+d["a"] = Mapping({"abcG" : Mapping({b"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+d["a"] = Mapping({"abcG" : Mapping({"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing *Iter* using d["a"] = Mapping({"abc" : %s})
-d["a"] = Mapping({"abc" : FailingIter()}):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
-d["a"] = Mapping({"abc" : FailingIterNext()}):(<class 'NotImplementedError'>, NotImplementedError())
+>>> Testing *Iter* using d["a"] = Mapping({"abcG" : %s})
+d["a"] = Mapping({"abcG" : FailingIter()}):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
+d["a"] = Mapping({"abcG" : FailingIterNext()}):(<class 'NotImplementedError'>, NotImplementedError())
 <<< Finished
->>> Testing ConvertFromPyObject using d["a"] = Mapping({"abc" : %s})
-d["a"] = Mapping({"abc" : None}):(<class 'TypeError'>, TypeError('unable to convert NoneType to vim structure',))
-d["a"] = Mapping({"abc" : {b"": 1}}):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
-d["a"] = Mapping({"abc" : {"": 1}}):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
-d["a"] = Mapping({"abc" : FailingMapping()}):(<class 'NotImplementedError'>, NotImplementedError())
-d["a"] = Mapping({"abc" : FailingMappingKey()}):(<class 'NotImplementedError'>, NotImplementedError())
+>>> Testing ConvertFromPyObject using d["a"] = Mapping({"abcG" : %s})
+d["a"] = Mapping({"abcG" : None}):(<class 'TypeError'>, TypeError('unable to convert NoneType to vim structure',))
+d["a"] = Mapping({"abcG" : {b"": 1}}):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
+d["a"] = Mapping({"abcG" : {"": 1}}):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
+d["a"] = Mapping({"abcG" : FailingMapping()}):(<class 'NotImplementedError'>, NotImplementedError())
+d["a"] = Mapping({"abcG" : FailingMappingKey()}):(<class 'NotImplementedError'>, NotImplementedError())
 <<< Finished
 >>> Testing *Iter* using d["a"] = %s
 d["a"] = FailingIter():(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -551,52 +554,52 @@ d.update({1 : 1}):(<class 'TypeError'>, TypeError('expected bytes() or str() ins
 d.update({b"\0" : 1}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 d.update({"\0" : 1}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing StringToChars using d.update({"abc" : {%s : 1}})
-d.update({"abc" : {1 : 1}}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-d.update({"abc" : {b"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
-d.update({"abc" : {"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+>>> Testing StringToChars using d.update({"abcF" : {%s : 1}})
+d.update({"abcF" : {1 : 1}}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
+d.update({"abcF" : {b"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+d.update({"abcF" : {"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing StringToChars using d.update({"abc" : Mapping({%s : 1})})
-d.update({"abc" : Mapping({1 : 1})}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-d.update({"abc" : Mapping({b"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
-d.update({"abc" : Mapping({"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+>>> Testing StringToChars using d.update({"abcF" : Mapping({%s : 1})})
+d.update({"abcF" : Mapping({1 : 1})}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
+d.update({"abcF" : Mapping({b"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+d.update({"abcF" : Mapping({"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing *Iter* using d.update({"abc" : %s})
-d.update({"abc" : FailingIter()}):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
-d.update({"abc" : FailingIterNext()}):(<class 'NotImplementedError'>, NotImplementedError())
+>>> Testing *Iter* using d.update({"abcF" : %s})
+d.update({"abcF" : FailingIter()}):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
+d.update({"abcF" : FailingIterNext()}):(<class 'NotImplementedError'>, NotImplementedError())
 <<< Finished
->>> Testing ConvertFromPyObject using d.update({"abc" : %s})
-d.update({"abc" : None}):(<class 'TypeError'>, TypeError('unable to convert NoneType to vim structure',))
-d.update({"abc" : {b"": 1}}):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
-d.update({"abc" : {"": 1}}):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
-d.update({"abc" : FailingMapping()}):(<class 'NotImplementedError'>, NotImplementedError())
-d.update({"abc" : FailingMappingKey()}):(<class 'NotImplementedError'>, NotImplementedError())
+>>> Testing ConvertFromPyObject using d.update({"abcF" : %s})
+d.update({"abcF" : None}):(<class 'TypeError'>, TypeError('unable to convert NoneType to vim structure',))
+d.update({"abcF" : {b"": 1}}):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
+d.update({"abcF" : {"": 1}}):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
+d.update({"abcF" : FailingMapping()}):(<class 'NotImplementedError'>, NotImplementedError())
+d.update({"abcF" : FailingMappingKey()}):(<class 'NotImplementedError'>, NotImplementedError())
 <<< Finished
 >>> Testing StringToChars using d.update(Mapping({%s : 1}))
 d.update(Mapping({1 : 1})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
 d.update(Mapping({b"\0" : 1})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 d.update(Mapping({"\0" : 1})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing StringToChars using d.update(Mapping({"abc" : {%s : 1}}))
-d.update(Mapping({"abc" : {1 : 1}})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-d.update(Mapping({"abc" : {b"\0" : 1}})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
-d.update(Mapping({"abc" : {"\0" : 1}})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+>>> Testing StringToChars using d.update(Mapping({"abcG" : {%s : 1}}))
+d.update(Mapping({"abcG" : {1 : 1}})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
+d.update(Mapping({"abcG" : {b"\0" : 1}})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+d.update(Mapping({"abcG" : {"\0" : 1}})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing StringToChars using d.update(Mapping({"abc" : Mapping({%s : 1})}))
-d.update(Mapping({"abc" : Mapping({1 : 1})})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-d.update(Mapping({"abc" : Mapping({b"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
-d.update(Mapping({"abc" : Mapping({"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+>>> Testing StringToChars using d.update(Mapping({"abcG" : Mapping({%s : 1})}))
+d.update(Mapping({"abcG" : Mapping({1 : 1})})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
+d.update(Mapping({"abcG" : Mapping({b"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+d.update(Mapping({"abcG" : Mapping({"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing *Iter* using d.update(Mapping({"abc" : %s}))
-d.update(Mapping({"abc" : FailingIter()})):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
-d.update(Mapping({"abc" : FailingIterNext()})):(<class 'NotImplementedError'>, NotImplementedError())
+>>> Testing *Iter* using d.update(Mapping({"abcG" : %s}))
+d.update(Mapping({"abcG" : FailingIter()})):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
+d.update(Mapping({"abcG" : FailingIterNext()})):(<class 'NotImplementedError'>, NotImplementedError())
 <<< Finished
->>> Testing ConvertFromPyObject using d.update(Mapping({"abc" : %s}))
-d.update(Mapping({"abc" : None})):(<class 'TypeError'>, TypeError('unable to convert NoneType to vim structure',))
-d.update(Mapping({"abc" : {b"": 1}})):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
-d.update(Mapping({"abc" : {"": 1}})):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
-d.update(Mapping({"abc" : FailingMapping()})):(<class 'NotImplementedError'>, NotImplementedError())
-d.update(Mapping({"abc" : FailingMappingKey()})):(<class 'NotImplementedError'>, NotImplementedError())
+>>> Testing ConvertFromPyObject using d.update(Mapping({"abcG" : %s}))
+d.update(Mapping({"abcG" : None})):(<class 'TypeError'>, TypeError('unable to convert NoneType to vim structure',))
+d.update(Mapping({"abcG" : {b"": 1}})):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
+d.update(Mapping({"abcG" : {"": 1}})):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
+d.update(Mapping({"abcG" : FailingMapping()})):(<class 'NotImplementedError'>, NotImplementedError())
+d.update(Mapping({"abcG" : FailingMappingKey()})):(<class 'NotImplementedError'>, NotImplementedError())
 <<< Finished
 >>> Testing *Iter* using d.update(%s)
 d.update(FailingIter()):(<class 'NotImplementedError'>, NotImplementedError())
@@ -619,52 +622,52 @@ d.update((("a", {1 : 1}),)):(<class 'TypeError'>, TypeError('expected bytes() or
 d.update((("a", {b"\0" : 1}),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 d.update((("a", {"\0" : 1}),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing StringToChars using d.update((("a", {"abc" : {%s : 1}}),))
-d.update((("a", {"abc" : {1 : 1}}),)):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-d.update((("a", {"abc" : {b"\0" : 1}}),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
-d.update((("a", {"abc" : {"\0" : 1}}),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+>>> Testing StringToChars using d.update((("a", {"abcF" : {%s : 1}}),))
+d.update((("a", {"abcF" : {1 : 1}}),)):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
+d.update((("a", {"abcF" : {b"\0" : 1}}),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+d.update((("a", {"abcF" : {"\0" : 1}}),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing StringToChars using d.update((("a", {"abc" : Mapping({%s : 1})}),))
-d.update((("a", {"abc" : Mapping({1 : 1})}),)):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-d.update((("a", {"abc" : Mapping({b"\0" : 1})}),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
-d.update((("a", {"abc" : Mapping({"\0" : 1})}),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+>>> Testing StringToChars using d.update((("a", {"abcF" : Mapping({%s : 1})}),))
+d.update((("a", {"abcF" : Mapping({1 : 1})}),)):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
+d.update((("a", {"abcF" : Mapping({b"\0" : 1})}),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+d.update((("a", {"abcF" : Mapping({"\0" : 1})}),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing *Iter* using d.update((("a", {"abc" : %s}),))
-d.update((("a", {"abc" : FailingIter()}),)):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
-d.update((("a", {"abc" : FailingIterNext()}),)):(<class 'NotImplementedError'>, NotImplementedError())
+>>> Testing *Iter* using d.update((("a", {"abcF" : %s}),))
+d.update((("a", {"abcF" : FailingIter()}),)):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
+d.update((("a", {"abcF" : FailingIterNext()}),)):(<class 'NotImplementedError'>, NotImplementedError())
 <<< Finished
->>> Testing ConvertFromPyObject using d.update((("a", {"abc" : %s}),))
-d.update((("a", {"abc" : None}),)):(<class 'TypeError'>, TypeError('unable to convert NoneType to vim structure',))
-d.update((("a", {"abc" : {b"": 1}}),)):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
-d.update((("a", {"abc" : {"": 1}}),)):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
-d.update((("a", {"abc" : FailingMapping()}),)):(<class 'NotImplementedError'>, NotImplementedError())
-d.update((("a", {"abc" : FailingMappingKey()}),)):(<class 'NotImplementedError'>, NotImplementedError())
+>>> Testing ConvertFromPyObject using d.update((("a", {"abcF" : %s}),))
+d.update((("a", {"abcF" : None}),)):(<class 'TypeError'>, TypeError('unable to convert NoneType to vim structure',))
+d.update((("a", {"abcF" : {b"": 1}}),)):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
+d.update((("a", {"abcF" : {"": 1}}),)):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
+d.update((("a", {"abcF" : FailingMapping()}),)):(<class 'NotImplementedError'>, NotImplementedError())
+d.update((("a", {"abcF" : FailingMappingKey()}),)):(<class 'NotImplementedError'>, NotImplementedError())
 <<< Finished
 >>> Testing StringToChars using d.update((("a", Mapping({%s : 1})),))
 d.update((("a", Mapping({1 : 1})),)):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
 d.update((("a", Mapping({b"\0" : 1})),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 d.update((("a", Mapping({"\0" : 1})),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing StringToChars using d.update((("a", Mapping({"abc" : {%s : 1}})),))
-d.update((("a", Mapping({"abc" : {1 : 1}})),)):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-d.update((("a", Mapping({"abc" : {b"\0" : 1}})),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
-d.update((("a", Mapping({"abc" : {"\0" : 1}})),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+>>> Testing StringToChars using d.update((("a", Mapping({"abcG" : {%s : 1}})),))
+d.update((("a", Mapping({"abcG" : {1 : 1}})),)):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
+d.update((("a", Mapping({"abcG" : {b"\0" : 1}})),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+d.update((("a", Mapping({"abcG" : {"\0" : 1}})),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing StringToChars using d.update((("a", Mapping({"abc" : Mapping({%s : 1})})),))
-d.update((("a", Mapping({"abc" : Mapping({1 : 1})})),)):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-d.update((("a", Mapping({"abc" : Mapping({b"\0" : 1})})),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
-d.update((("a", Mapping({"abc" : Mapping({"\0" : 1})})),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+>>> Testing StringToChars using d.update((("a", Mapping({"abcG" : Mapping({%s : 1})})),))
+d.update((("a", Mapping({"abcG" : Mapping({1 : 1})})),)):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
+d.update((("a", Mapping({"abcG" : Mapping({b"\0" : 1})})),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+d.update((("a", Mapping({"abcG" : Mapping({"\0" : 1})})),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing *Iter* using d.update((("a", Mapping({"abc" : %s})),))
-d.update((("a", Mapping({"abc" : FailingIter()})),)):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
-d.update((("a", Mapping({"abc" : FailingIterNext()})),)):(<class 'NotImplementedError'>, NotImplementedError())
+>>> Testing *Iter* using d.update((("a", Mapping({"abcG" : %s})),))
+d.update((("a", Mapping({"abcG" : FailingIter()})),)):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
+d.update((("a", Mapping({"abcG" : FailingIterNext()})),)):(<class 'NotImplementedError'>, NotImplementedError())
 <<< Finished
->>> Testing ConvertFromPyObject using d.update((("a", Mapping({"abc" : %s})),))
-d.update((("a", Mapping({"abc" : None})),)):(<class 'TypeError'>, TypeError('unable to convert NoneType to vim structure',))
-d.update((("a", Mapping({"abc" : {b"": 1}})),)):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
-d.update((("a", Mapping({"abc" : {"": 1}})),)):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
-d.update((("a", Mapping({"abc" : FailingMapping()})),)):(<class 'NotImplementedError'>, NotImplementedError())
-d.update((("a", Mapping({"abc" : FailingMappingKey()})),)):(<class 'NotImplementedError'>, NotImplementedError())
+>>> Testing ConvertFromPyObject using d.update((("a", Mapping({"abcG" : %s})),))
+d.update((("a", Mapping({"abcG" : None})),)):(<class 'TypeError'>, TypeError('unable to convert NoneType to vim structure',))
+d.update((("a", Mapping({"abcG" : {b"": 1}})),)):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
+d.update((("a", Mapping({"abcG" : {"": 1}})),)):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
+d.update((("a", Mapping({"abcG" : FailingMapping()})),)):(<class 'NotImplementedError'>, NotImplementedError())
+d.update((("a", Mapping({"abcG" : FailingMappingKey()})),)):(<class 'NotImplementedError'>, NotImplementedError())
 <<< Finished
 >>> Testing *Iter* using d.update((("a", %s),))
 d.update((("a", FailingIter()),)):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -694,52 +697,52 @@ vim.List([{1 : 1}]):(<class 'TypeError'>, TypeError('expected bytes() or str() i
 vim.List([{b"\0" : 1}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 vim.List([{"\0" : 1}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing StringToChars using vim.List([{"abc" : {%s : 1}}])
-vim.List([{"abc" : {1 : 1}}]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-vim.List([{"abc" : {b"\0" : 1}}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
-vim.List([{"abc" : {"\0" : 1}}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+>>> Testing StringToChars using vim.List([{"abcF" : {%s : 1}}])
+vim.List([{"abcF" : {1 : 1}}]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
+vim.List([{"abcF" : {b"\0" : 1}}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+vim.List([{"abcF" : {"\0" : 1}}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing StringToChars using vim.List([{"abc" : Mapping({%s : 1})}])
-vim.List([{"abc" : Mapping({1 : 1})}]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-vim.List([{"abc" : Mapping({b"\0" : 1})}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
-vim.List([{"abc" : Mapping({"\0" : 1})}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+>>> Testing StringToChars using vim.List([{"abcF" : Mapping({%s : 1})}])
+vim.List([{"abcF" : Mapping({1 : 1})}]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
+vim.List([{"abcF" : Mapping({b"\0" : 1})}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+vim.List([{"abcF" : Mapping({"\0" : 1})}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing *Iter* using vim.List([{"abc" : %s}])
-vim.List([{"abc" : FailingIter()}]):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
-vim.List([{"abc" : FailingIterNext()}]):(<class 'NotImplementedError'>, NotImplementedError())
+>>> Testing *Iter* using vim.List([{"abcF" : %s}])
+vim.List([{"abcF" : FailingIter()}]):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
+vim.List([{"abcF" : FailingIterNext()}]):(<class 'NotImplementedError'>, NotImplementedError())
 <<< Finished
->>> Testing ConvertFromPyObject using vim.List([{"abc" : %s}])
-vim.List([{"abc" : None}]):(<class 'TypeError'>, TypeError('unable to convert NoneType to vim structure',))
-vim.List([{"abc" : {b"": 1}}]):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
-vim.List([{"abc" : {"": 1}}]):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
-vim.List([{"abc" : FailingMapping()}]):(<class 'NotImplementedError'>, NotImplementedError())
-vim.List([{"abc" : FailingMappingKey()}]):(<class 'NotImplementedError'>, NotImplementedError())
+>>> Testing ConvertFromPyObject using vim.List([{"abcF" : %s}])
+vim.List([{"abcF" : None}]):(<class 'TypeError'>, TypeError('unable to convert NoneType to vim structure',))
+vim.List([{"abcF" : {b"": 1}}]):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
+vim.List([{"abcF" : {"": 1}}]):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
+vim.List([{"abcF" : FailingMapping()}]):(<class 'NotImplementedError'>, NotImplementedError())
+vim.List([{"abcF" : FailingMappingKey()}]):(<class 'NotImplementedError'>, NotImplementedError())
 <<< Finished
 >>> Testing StringToChars using vim.List([Mapping({%s : 1})])
 vim.List([Mapping({1 : 1})]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
 vim.List([Mapping({b"\0" : 1})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 vim.List([Mapping({"\0" : 1})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing StringToChars using vim.List([Mapping({"abc" : {%s : 1}})])
-vim.List([Mapping({"abc" : {1 : 1}})]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-vim.List([Mapping({"abc" : {b"\0" : 1}})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
-vim.List([Mapping({"abc" : {"\0" : 1}})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+>>> Testing StringToChars using vim.List([Mapping({"abcG" : {%s : 1}})])
+vim.List([Mapping({"abcG" : {1 : 1}})]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
+vim.List([Mapping({"abcG" : {b"\0" : 1}})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+vim.List([Mapping({"abcG" : {"\0" : 1}})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing StringToChars using vim.List([Mapping({"abc" : Mapping({%s : 1})})])
-vim.List([Mapping({"abc" : Mapping({1 : 1})})]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-vim.List([Mapping({"abc" : Mapping({b"\0" : 1})})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
-vim.List([Mapping({"abc" : Mapping({"\0" : 1})})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+>>> Testing StringToChars using vim.List([Mapping({"abcG" : Mapping({%s : 1})})])
+vim.List([Mapping({"abcG" : Mapping({1 : 1})})]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
+vim.List([Mapping({"abcG" : Mapping({b"\0" : 1})})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+vim.List([Mapping({"abcG" : Mapping({"\0" : 1})})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing *Iter* using vim.List([Mapping({"abc" : %s})])
-vim.List([Mapping({"abc" : FailingIter()})]):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
-vim.List([Mapping({"abc" : FailingIterNext()})]):(<class 'NotImplementedError'>, NotImplementedError())
+>>> Testing *Iter* using vim.List([Mapping({"abcG" : %s})])
+vim.List([Mapping({"abcG" : FailingIter()})]):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
+vim.List([Mapping({"abcG" : FailingIterNext()})]):(<class 'NotImplementedError'>, NotImplementedError())
 <<< Finished
->>> Testing ConvertFromPyObject using vim.List([Mapping({"abc" : %s})])
-vim.List([Mapping({"abc" : None})]):(<class 'TypeError'>, TypeError('unable to convert NoneType to vim structure',))
-vim.List([Mapping({"abc" : {b"": 1}})]):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
-vim.List([Mapping({"abc" : {"": 1}})]):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
-vim.List([Mapping({"abc" : FailingMapping()})]):(<class 'NotImplementedError'>, NotImplementedError())
-vim.List([Mapping({"abc" : FailingMappingKey()})]):(<class 'NotImplementedError'>, NotImplementedError())
+>>> Testing ConvertFromPyObject using vim.List([Mapping({"abcG" : %s})])
+vim.List([Mapping({"abcG" : None})]):(<class 'TypeError'>, TypeError('unable to convert NoneType to vim structure',))
+vim.List([Mapping({"abcG" : {b"": 1}})]):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
+vim.List([Mapping({"abcG" : {"": 1}})]):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
+vim.List([Mapping({"abcG" : FailingMapping()})]):(<class 'NotImplementedError'>, NotImplementedError())
+vim.List([Mapping({"abcG" : FailingMappingKey()})]):(<class 'NotImplementedError'>, NotImplementedError())
 <<< Finished
 >>> Testing *Iter* using vim.List([%s])
 vim.List([FailingIter()]):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -758,7 +761,7 @@ l[1000]:(<class 'IndexError'>, IndexError('list index out of range',))
 ll[1] = 2:(<class 'vim.error'>, error('list is locked',))
 l[1000] = 3:(<class 'IndexError'>, IndexError('list index out of range',))
 >> ListAssSlice
-ll[1:100] = "abc":(<class 'vim.error'>, error('list is locked',))
+ll[1:100] = "abcJ":(<class 'vim.error'>, error('list is locked',))
 >>> Testing *Iter* using l[:] = %s
 l[:] = FailingIter():(<class 'NotImplementedError'>, NotImplementedError())
 l[:] = FailingIterNext()::(<class 'NotImplementedError'>, NotImplementedError())
@@ -768,52 +771,52 @@ l[:] = [{1 : 1}]:(<class 'TypeError'>, TypeError('expected bytes() or str() inst
 l[:] = [{b"\0" : 1}]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
 l[:] = [{"\0" : 1}]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing StringToChars using l[:] = [{"abc" : {%s : 1}}]
-l[:] = [{"abc" : {1 : 1}}]:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-l[:] = [{"abc" : {b"\0" : 1}}]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
-l[:] = [{"abc" : {"\0" : 1}}]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
+>>> Testing StringToChars using l[:] = [{"abcF" : {%s : 1}}]
+l[:] = [{"abcF" : {1 : 1}}]:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
+l[:] = [{"abcF" : {b"\0" : 1}}]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
+l[:] = [{"abcF" : {"\0" : 1}}]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing StringToChars using l[:] = [{"abc" : Mapping({%s : 1})}]
-l[:] = [{"abc" : Mapping({1 : 1})}]:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-l[:] = [{"abc" : Mapping({b"\0" : 1})}]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
-l[:] = [{"abc" : Mapping({"\0" : 1})}]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
+>>> Testing StringToChars using l[:] = [{"abcF" : Mapping({%s : 1})}]
+l[:] = [{"abcF" : Mapping({1 : 1})}]:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
+l[:] = [{"abcF" : Mapping({b"\0" : 1})}]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
+l[:] = [{"abcF" : Mapping({"\0" : 1})}]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing *Iter* using l[:] = [{"abc" : %s}]
-l[:] = [{"abc" : FailingIter()}]:(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
-l[:] = [{"abc" : FailingIterNext()}]:(<class 'NotImplementedError'>, NotImplementedError())
+>>> Testing *Iter* using l[:] = [{"abcF" : %s}]
+l[:] = [{"abcF" : FailingIter()}]:(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
+l[:] = [{"abcF" : FailingIterNext()}]:(<class 'NotImplementedError'>, NotImplementedError())
 <<< Finished
->>> Testing ConvertFromPyObject using l[:] = [{"abc" : %s}]
-l[:] = [{"abc" : None}]:(<class 'TypeError'>, TypeError('unable to convert NoneType to vim structure',))
-l[:] = [{"abc" : {b"": 1}}]:(<class 'ValueError'>, ValueError('empty keys are not allowed',))
-l[:] = [{"abc" : {"": 1}}]:(<class 'ValueError'>, ValueError('empty keys are not allowed',))
-l[:] = [{"abc" : FailingMapping()}]:(<class 'NotImplementedError'>, NotImplementedError())
-l[:] = [{"abc" : FailingMappingKey()}]:(<class 'NotImplementedError'>, NotImplementedError())
+>>> Testing ConvertFromPyObject using l[:] = [{"abcF" : %s}]
+l[:] = [{"abcF" : None}]:(<class 'TypeError'>, TypeError('unable to convert NoneType to vim structure',))
+l[:] = [{"abcF" : {b"": 1}}]:(<class 'ValueError'>, ValueError('empty keys are not allowed',))
+l[:] = [{"abcF" : {"": 1}}]:(<class 'ValueError'>, ValueError('empty keys are not allowed',))
+l[:] = [{"abcF" : FailingMapping()}]:(<class 'NotImplementedError'>, NotImplementedError())
+l[:] = [{"abcF" : FailingMappingKey()}]:(<class 'NotImplementedError'>, NotImplementedError())
 <<< Finished
 >>> Testing StringToChars using l[:] = [Mapping({%s : 1})]
 l[:] = [Mapping({1 : 1})]:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
 l[:] = [Mapping({b"\0" : 1})]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
 l[:] = [Mapping({"\0" : 1})]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing StringToChars using l[:] = [Mapping({"abc" : {%s : 1}})]
-l[:] = [Mapping({"abc" : {1 : 1}})]:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-l[:] = [Mapping({"abc" : {b"\0" : 1}})]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
-l[:] = [Mapping({"abc" : {"\0" : 1}})]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
+>>> Testing StringToChars using l[:] = [Mapping({"abcG" : {%s : 1}})]
+l[:] = [Mapping({"abcG" : {1 : 1}})]:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
+l[:] = [Mapping({"abcG" : {b"\0" : 1}})]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
+l[:] = [Mapping({"abcG" : {"\0" : 1}})]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing StringToChars using l[:] = [Mapping({"abc" : Mapping({%s : 1})})]
-l[:] = [Mapping({"abc" : Mapping({1 : 1})})]:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-l[:] = [Mapping({"abc" : Mapping({b"\0" : 1})})]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
-l[:] = [Mapping({"abc" : Mapping({"\0" : 1})})]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
+>>> Testing StringToChars using l[:] = [Mapping({"abcG" : Mapping({%s : 1})})]
+l[:] = [Mapping({"abcG" : Mapping({1 : 1})})]:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
+l[:] = [Mapping({"abcG" : Mapping({b"\0" : 1})})]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
+l[:] = [Mapping({"abcG" : Mapping({"\0" : 1})})]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing *Iter* using l[:] = [Mapping({"abc" : %s})]
-l[:] = [Mapping({"abc" : FailingIter()})]:(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
-l[:] = [Mapping({"abc" : FailingIterNext()})]:(<class 'NotImplementedError'>, NotImplementedError())
+>>> Testing *Iter* using l[:] = [Mapping({"abcG" : %s})]
+l[:] = [Mapping({"abcG" : FailingIter()})]:(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
+l[:] = [Mapping({"abcG" : FailingIterNext()})]:(<class 'NotImplementedError'>, NotImplementedError())
 <<< Finished
->>> Testing ConvertFromPyObject using l[:] = [Mapping({"abc" : %s})]
-l[:] = [Mapping({"abc" : None})]:(<class 'TypeError'>, TypeError('unable to convert NoneType to vim structure',))
-l[:] = [Mapping({"abc" : {b"": 1}})]:(<class 'ValueError'>, ValueError('empty keys are not allowed',))
-l[:] = [Mapping({"abc" : {"": 1}})]:(<class 'ValueError'>, ValueError('empty keys are not allowed',))
-l[:] = [Mapping({"abc" : FailingMapping()})]:(<class 'NotImplementedError'>, NotImplementedError())
-l[:] = [Mapping({"abc" : FailingMappingKey()})]:(<class 'NotImplementedError'>, NotImplementedError())
+>>> Testing ConvertFromPyObject using l[:] = [Mapping({"abcG" : %s})]
+l[:] = [Mapping({"abcG" : None})]:(<class 'TypeError'>, TypeError('unable to convert NoneType to vim structure',))
+l[:] = [Mapping({"abcG" : {b"": 1}})]:(<class 'ValueError'>, ValueError('empty keys are not allowed',))
+l[:] = [Mapping({"abcG" : {"": 1}})]:(<class 'ValueError'>, ValueError('empty keys are not allowed',))
+l[:] = [Mapping({"abcG" : FailingMapping()})]:(<class 'NotImplementedError'>, NotImplementedError())
+l[:] = [Mapping({"abcG" : FailingMappingKey()})]:(<class 'NotImplementedError'>, NotImplementedError())
 <<< Finished
 >>> Testing *Iter* using l[:] = [%s]
 l[:] = [FailingIter()]:(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -836,52 +839,52 @@ l.extend([{1 : 1}]):(<class 'TypeError'>, TypeError('expected bytes() or str() i
 l.extend([{b"\0" : 1}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 l.extend([{"\0" : 1}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing StringToChars using l.extend([{"abc" : {%s : 1}}])
-l.extend([{"abc" : {1 : 1}}]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-l.extend([{"abc" : {b"\0" : 1}}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
-l.extend([{"abc" : {"\0" : 1}}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+>>> Testing StringToChars using l.extend([{"abcF" : {%s : 1}}])
+l.extend([{"abcF" : {1 : 1}}]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
+l.extend([{"abcF" : {b"\0" : 1}}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+l.extend([{"abcF" : {"\0" : 1}}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing StringToChars using l.extend([{"abc" : Mapping({%s : 1})}])
-l.extend([{"abc" : Mapping({1 : 1})}]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-l.extend([{"abc" : Mapping({b"\0" : 1})}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
-l.extend([{"abc" : Mapping({"\0" : 1})}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+>>> Testing StringToChars using l.extend([{"abcF" : Mapping({%s : 1})}])
+l.extend([{"abcF" : Mapping({1 : 1})}]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
+l.extend([{"abcF" : Mapping({b"\0" : 1})}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+l.extend([{"abcF" : Mapping({"\0" : 1})}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing *Iter* using l.extend([{"abc" : %s}])
-l.extend([{"abc" : FailingIter()}]):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
-l.extend([{"abc" : FailingIterNext()}]):(<class 'NotImplementedError'>, NotImplementedError())
+>>> Testing *Iter* using l.extend([{"abcF" : %s}])
+l.extend([{"abcF" : FailingIter()}]):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
+l.extend([{"abcF" : FailingIterNext()}]):(<class 'NotImplementedError'>, NotImplementedError())
 <<< Finished
->>> Testing ConvertFromPyObject using l.extend([{"abc" : %s}])
-l.extend([{"abc" : None}]):(<class 'TypeError'>, TypeError('unable to convert NoneType to vim structure',))
-l.extend([{"abc" : {b"": 1}}]):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
-l.extend([{"abc" : {"": 1}}]):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
-l.extend([{"abc" : FailingMapping()}]):(<class 'NotImplementedError'>, NotImplementedError())
-l.extend([{"abc" : FailingMappingKey()}]):(<class 'NotImplementedError'>, NotImplementedError())
+>>> Testing ConvertFromPyObject using l.extend([{"abcF" : %s}])
+l.extend([{"abcF" : None}]):(<class 'TypeError'>, TypeError('unable to convert NoneType to vim structure',))
+l.extend([{"abcF" : {b"": 1}}]):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
+l.extend([{"abcF" : {"": 1}}]):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
+l.extend([{"abcF" : FailingMapping()}]):(<class 'NotImplementedError'>, NotImplementedError())
+l.extend([{"abcF" : FailingMappingKey()}]):(<class 'NotImplementedError'>, NotImplementedError())
 <<< Finished
 >>> Testing StringToChars using l.extend([Mapping({%s : 1})])
 l.extend([Mapping({1 : 1})]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
 l.extend([Mapping({b"\0" : 1})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 l.extend([Mapping({"\0" : 1})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing StringToChars using l.extend([Mapping({"abc" : {%s : 1}})])
-l.extend([Mapping({"abc" : {1 : 1}})]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-l.extend([Mapping({"abc" : {b"\0" : 1}})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
-l.extend([Mapping({"abc" : {"\0" : 1}})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+>>> Testing StringToChars using l.extend([Mapping({"abcG" : {%s : 1}})])
+l.extend([Mapping({"abcG" : {1 : 1}})]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
+l.extend([Mapping({"abcG" : {b"\0" : 1}})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+l.extend([Mapping({"abcG" : {"\0" : 1}})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing StringToChars using l.extend([Mapping({"abc" : Mapping({%s : 1})})])
-l.extend([Mapping({"abc" : Mapping({1 : 1})})]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-l.extend([Mapping({"abc" : Mapping({b"\0" : 1})})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
-l.extend([Mapping({"abc" : Mapping({"\0" : 1})})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+>>> Testing StringToChars using l.extend([Mapping({"abcG" : Mapping({%s : 1})})])
+l.extend([Mapping({"abcG" : Mapping({1 : 1})})]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
+l.extend([Mapping({"abcG" : Mapping({b"\0" : 1})})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+l.extend([Mapping({"abcG" : Mapping({"\0" : 1})})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing *Iter* using l.extend([Mapping({"abc" : %s})])
-l.extend([Mapping({"abc" : FailingIter()})]):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
-l.extend([Mapping({"abc" : FailingIterNext()})]):(<class 'NotImplementedError'>, NotImplementedError())
+>>> Testing *Iter* using l.extend([Mapping({"abcG" : %s})])
+l.extend([Mapping({"abcG" : FailingIter()})]):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
+l.extend([Mapping({"abcG" : FailingIterNext()})]):(<class 'NotImplementedError'>, NotImplementedError())
 <<< Finished
->>> Testing ConvertFromPyObject using l.extend([Mapping({"abc" : %s})])
-l.extend([Mapping({"abc" : None})]):(<class 'TypeError'>, TypeError('unable to convert NoneType to vim structure',))
-l.extend([Mapping({"abc" : {b"": 1}})]):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
-l.extend([Mapping({"abc" : {"": 1}})]):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
-l.extend([Mapping({"abc" : FailingMapping()})]):(<class 'NotImplementedError'>, NotImplementedError())
-l.extend([Mapping({"abc" : FailingMappingKey()})]):(<class 'NotImplementedError'>, NotImplementedError())
+>>> Testing ConvertFromPyObject using l.extend([Mapping({"abcG" : %s})])
+l.extend([Mapping({"abcG" : None})]):(<class 'TypeError'>, TypeError('unable to convert NoneType to vim structure',))
+l.extend([Mapping({"abcG" : {b"": 1}})]):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
+l.extend([Mapping({"abcG" : {"": 1}})]):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
+l.extend([Mapping({"abcG" : FailingMapping()})]):(<class 'NotImplementedError'>, NotImplementedError())
+l.extend([Mapping({"abcG" : FailingMappingKey()})]):(<class 'NotImplementedError'>, NotImplementedError())
 <<< Finished
 >>> Testing *Iter* using l.extend([%s])
 l.extend([FailingIter()]):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -909,52 +912,52 @@ f({1 : 1}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance,
 f({b"\0" : 1}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 f({"\0" : 1}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing StringToChars using f({"abc" : {%s : 1}})
-f({"abc" : {1 : 1}}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-f({"abc" : {b"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
-f({"abc" : {"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+>>> Testing StringToChars using f({"abcF" : {%s : 1}})
+f({"abcF" : {1 : 1}}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
+f({"abcF" : {b"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+f({"abcF" : {"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing StringToChars using f({"abc" : Mapping({%s : 1})})
-f({"abc" : Mapping({1 : 1})}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-f({"abc" : Mapping({b"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
-f({"abc" : Mapping({"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+>>> Testing StringToChars using f({"abcF" : Mapping({%s : 1})})
+f({"abcF" : Mapping({1 : 1})}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
+f({"abcF" : Mapping({b"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+f({"abcF" : Mapping({"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing *Iter* using f({"abc" : %s})
-f({"abc" : FailingIter()}):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
-f({"abc" : FailingIterNext()}):(<class 'NotImplementedError'>, NotImplementedError())
+>>> Testing *Iter* using f({"abcF" : %s})
+f({"abcF" : FailingIter()}):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
+f({"abcF" : FailingIterNext()}):(<class 'NotImplementedError'>, NotImplementedError())
 <<< Finished
->>> Testing ConvertFromPyObject using f({"abc" : %s})
-f({"abc" : None}):(<class 'TypeError'>, TypeError('unable to convert NoneType to vim structure',))
-f({"abc" : {b"": 1}}):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
-f({"abc" : {"": 1}}):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
-f({"abc" : FailingMapping()}):(<class 'NotImplementedError'>, NotImplementedError())
-f({"abc" : FailingMappingKey()}):(<class 'NotImplementedError'>, NotImplementedError())
+>>> Testing ConvertFromPyObject using f({"abcF" : %s})
+f({"abcF" : None}):(<class 'TypeError'>, TypeError('unable to convert NoneType to vim structure',))
+f({"abcF" : {b"": 1}}):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
+f({"abcF" : {"": 1}}):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
+f({"abcF" : FailingMapping()}):(<class 'NotImplementedError'>, NotImplementedError())
+f({"abcF" : FailingMappingKey()}):(<class 'NotImplementedError'>, NotImplementedError())
 <<< Finished
 >>> Testing StringToChars using f(Mapping({%s : 1}))
 f(Mapping({1 : 1})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
 f(Mapping({b"\0" : 1})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 f(Mapping({"\0" : 1})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing StringToChars using f(Mapping({"abc" : {%s : 1}}))
-f(Mapping({"abc" : {1 : 1}})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-f(Mapping({"abc" : {b"\0" : 1}})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
-f(Mapping({"abc" : {"\0" : 1}})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+>>> Testing StringToChars using f(Mapping({"abcG" : {%s : 1}}))
+f(Mapping({"abcG" : {1 : 1}})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
+f(Mapping({"abcG" : {b"\0" : 1}})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+f(Mapping({"abcG" : {"\0" : 1}})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing StringToChars using f(Mapping({"abc" : Mapping({%s : 1})}))
-f(Mapping({"abc" : Mapping({1 : 1})})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-f(Mapping({"abc" : Mapping({b"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
-f(Mapping({"abc" : Mapping({"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+>>> Testing StringToChars using f(Mapping({"abcG" : Mapping({%s : 1})}))
+f(Mapping({"abcG" : Mapping({1 : 1})})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
+f(Mapping({"abcG" : Mapping({b"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+f(Mapping({"abcG" : Mapping({"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing *Iter* using f(Mapping({"abc" : %s}))
-f(Mapping({"abc" : FailingIter()})):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
-f(Mapping({"abc" : FailingIterNext()})):(<class 'NotImplementedError'>, NotImplementedError())
+>>> Testing *Iter* using f(Mapping({"abcG" : %s}))
+f(Mapping({"abcG" : FailingIter()})):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
+f(Mapping({"abcG" : FailingIterNext()})):(<class 'NotImplementedError'>, NotImplementedError())
 <<< Finished
->>> Testing ConvertFromPyObject using f(Mapping({"abc" : %s}))
-f(Mapping({"abc" : None})):(<class 'TypeError'>, TypeError('unable to convert NoneType to vim structure',))
-f(Mapping({"abc" : {b"": 1}})):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
-f(Mapping({"abc" : {"": 1}})):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
-f(Mapping({"abc" : FailingMapping()})):(<class 'NotImplementedError'>, NotImplementedError())
-f(Mapping({"abc" : FailingMappingKey()})):(<class 'NotImplementedError'>, NotImplementedError())
+>>> Testing ConvertFromPyObject using f(Mapping({"abcG" : %s}))
+f(Mapping({"abcG" : None})):(<class 'TypeError'>, TypeError('unable to convert NoneType to vim structure',))
+f(Mapping({"abcG" : {b"": 1}})):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
+f(Mapping({"abcG" : {"": 1}})):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
+f(Mapping({"abcG" : FailingMapping()})):(<class 'NotImplementedError'>, NotImplementedError())
+f(Mapping({"abcG" : FailingMappingKey()})):(<class 'NotImplementedError'>, NotImplementedError())
 <<< Finished
 >>> Testing *Iter* using f(%s)
 f(FailingIter()):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -972,52 +975,52 @@ fd(self={1 : 1}):(<class 'TypeError'>, TypeError('expected bytes() or str() inst
 fd(self={b"\0" : 1}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 fd(self={"\0" : 1}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing StringToChars using fd(self={"abc" : {%s : 1}})
-fd(self={"abc" : {1 : 1}}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-fd(self={"abc" : {b"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
-fd(self={"abc" : {"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+>>> Testing StringToChars using fd(self={"abcF" : {%s : 1}})
+fd(self={"abcF" : {1 : 1}}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
+fd(self={"abcF" : {b"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+fd(self={"abcF" : {"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing StringToChars using fd(self={"abc" : Mapping({%s : 1})})
-fd(self={"abc" : Mapping({1 : 1})}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-fd(self={"abc" : Mapping({b"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
-fd(self={"abc" : Mapping({"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+>>> Testing StringToChars using fd(self={"abcF" : Mapping({%s : 1})})
+fd(self={"abcF" : Mapping({1 : 1})}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
+fd(self={"abcF" : Mapping({b"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+fd(self={"abcF" : Mapping({"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing *Iter* using fd(self={"abc" : %s})
-fd(self={"abc" : FailingIter()}):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
-fd(self={"abc" : FailingIterNext()}):(<class 'NotImplementedError'>, NotImplementedError())
+>>> Testing *Iter* using fd(self={"abcF" : %s})
+fd(self={"abcF" : FailingIter()}):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
+fd(self={"abcF" : FailingIterNext()}):(<class 'NotImplementedError'>, NotImplementedError())
 <<< Finished
->>> Testing ConvertFromPyObject using fd(self={"abc" : %s})
-fd(self={"abc" : None}):(<class 'TypeError'>, TypeError('unable to convert NoneType to vim structure',))
-fd(self={"abc" : {b"": 1}}):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
-fd(self={"abc" : {"": 1}}):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
-fd(self={"abc" : FailingMapping()}):(<class 'NotImplementedError'>, NotImplementedError())
-fd(self={"abc" : FailingMappingKey()}):(<class 'NotImplementedError'>, NotImplementedError())
+>>> Testing ConvertFromPyObject using fd(self={"abcF" : %s})
+fd(self={"abcF" : None}):(<class 'TypeError'>, TypeError('unable to convert NoneType to vim structure',))
+fd(self={"abcF" : {b"": 1}}):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
+fd(self={"abcF" : {"": 1}}):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
+fd(self={"abcF" : FailingMapping()}):(<class 'NotImplementedError'>, NotImplementedError())
+fd(self={"abcF" : FailingMappingKey()}):(<class 'NotImplementedError'>, NotImplementedError())
 <<< Finished
 >>> Testing StringToChars using fd(self=Mapping({%s : 1}))
 fd(self=Mapping({1 : 1})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
 fd(self=Mapping({b"\0" : 1})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 fd(self=Mapping({"\0" : 1})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing StringToChars using fd(self=Mapping({"abc" : {%s : 1}}))
-fd(self=Mapping({"abc" : {1 : 1}})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-fd(self=Mapping({"abc" : {b"\0" : 1}})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
-fd(self=Mapping({"abc" : {"\0" : 1}})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+>>> Testing StringToChars using fd(self=Mapping({"abcG" : {%s : 1}}))
+fd(self=Mapping({"abcG" : {1 : 1}})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
+fd(self=Mapping({"abcG" : {b"\0" : 1}})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+fd(self=Mapping({"abcG" : {"\0" : 1}})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing StringToChars using fd(self=Mapping({"abc" : Mapping({%s : 1})}))
-fd(self=Mapping({"abc" : Mapping({1 : 1})})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-fd(self=Mapping({"abc" : Mapping({b"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
-fd(self=Mapping({"abc" : Mapping({"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+>>> Testing StringToChars using fd(self=Mapping({"abcG" : Mapping({%s : 1})}))
+fd(self=Mapping({"abcG" : Mapping({1 : 1})})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
+fd(self=Mapping({"abcG" : Mapping({b"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+fd(self=Mapping({"abcG" : Mapping({"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
->>> Testing *Iter* using fd(self=Mapping({"abc" : %s}))
-fd(self=Mapping({"abc" : FailingIter()})):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
-fd(self=Mapping({"abc" : FailingIterNext()})):(<class 'NotImplementedError'>, NotImplementedError())
+>>> Testing *Iter* using fd(self=Mapping({"abcG" : %s}))
+fd(self=Mapping({"abcG" : FailingIter()})):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
+fd(self=Mapping({"abcG" : FailingIterNext()})):(<class 'NotImplementedError'>, NotImplementedError())
 <<< Finished
->>> Testing ConvertFromPyObject using fd(self=Mapping({"abc" : %s}))
-fd(self=Mapping({"abc" : None})):(<class 'TypeError'>, TypeError('unable to convert NoneType to vim structure',))
-fd(self=Mapping({"abc" : {b"": 1}})):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
-fd(self=Mapping({"abc" : {"": 1}})):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
-fd(self=Mapping({"abc" : FailingMapping()})):(<class 'NotImplementedError'>, NotImplementedError())
-fd(self=Mapping({"abc" : FailingMappingKey()})):(<class 'NotImplementedError'>, NotImplementedError())
+>>> Testing ConvertFromPyObject using fd(self=Mapping({"abcG" : %s}))
+fd(self=Mapping({"abcG" : None})):(<class 'TypeError'>, TypeError('unable to convert NoneType to vim structure',))
+fd(self=Mapping({"abcG" : {b"": 1}})):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
+fd(self=Mapping({"abcG" : {"": 1}})):(<class 'ValueError'>, ValueError('empty keys are not allowed',))
+fd(self=Mapping({"abcG" : FailingMapping()})):(<class 'NotImplementedError'>, NotImplementedError())
+fd(self=Mapping({"abcG" : FailingMappingKey()})):(<class 'NotImplementedError'>, NotImplementedError())
 <<< Finished
 >>> Testing *Iter* using fd(self=%s)
 fd(self=FailingIter()):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim dictionary',))
@@ -1046,8 +1049,8 @@ vim.current.window.xxx:(<class 'AttributeError'>, AttributeError("'vim.window' o
 vim.current.window.buffer = 0:(<class 'TypeError'>, TypeError('readonly attribute: buffer',))
 vim.current.window.cursor = (100000000, 100000000):(<class 'vim.error'>, error('cursor position outside buffer',))
 vim.current.window.cursor = True:(<class 'TypeError'>, TypeError('argument must be 2-item sequence, not bool',))
-vim.current.window.height = "abc":(<class 'TypeError'>, TypeError('expected int() or something supporting coercing to int(), but got str',))
-vim.current.window.width  = "abc":(<class 'TypeError'>, TypeError('expected int() or something supporting coercing to int(), but got str',))
+vim.current.window.height = "abcK":(<class 'TypeError'>, TypeError('expected int() or something supporting coercing to int(), but got str',))
+vim.current.window.width  = "abcL":(<class 'TypeError'>, TypeError('expected int() or something supporting coercing to int(), but got str',))
 vim.current.window.xxxxxx = True:(<class 'AttributeError'>, AttributeError('xxxxxx',))
 > WinList
 >> WinListItem
@@ -1057,7 +1060,7 @@ vim.windows[1000]:(<class 'IndexError'>, IndexError('no such window',))
 vim.current.buffer[0] = "\na":(<class 'vim.error'>, error('string cannot contain newlines',))
 >> SetBufferLine (indirect)
 vim.current.buffer[0] = True:(<class 'TypeError'>, TypeError('bad argument type for built-in operation',))
->> SetBufferLines (indirect)
+>> SetBufferLineList (indirect)
 vim.current.buffer[:] = True:(<class 'TypeError'>, TypeError('bad argument type for built-in operation',))
 vim.current.buffer[:] = ["\na", "bc"]:(<class 'vim.error'>, error('string cannot contain newlines',))
 >> InsertBufferLines (indirect)
@@ -1075,7 +1078,7 @@ vim.current.buffer.name = True:(<class 'TypeError'>, TypeError('expected bytes()
 vim.current.buffer.xxx = True:(<class 'AttributeError'>, AttributeError('xxx',))
 >> BufferMark
 vim.current.buffer.mark(0):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-vim.current.buffer.mark("abc"):(<class 'ValueError'>, ValueError('mark name must be a single character',))
+vim.current.buffer.mark("abcM"):(<class 'ValueError'>, ValueError('mark name must be a single character',))
 vim.current.buffer.mark("!"):(<class 'vim.error'>, error('invalid mark name',))
 >> BufferRange
 vim.current.buffer.range(1, 2, 3):(<class 'TypeError'>, TypeError('function takes exactly 2 arguments (3 given)',))
@@ -1095,7 +1098,7 @@ vim.current.xxx = True:(<class 'AttributeError'>, AttributeError('xxx',))
 3,xx
 before
 after
-vim.command("throw 'abc'"):(<class 'vim.error'>, error('abc',))
+vim.command("throw 'abcN'"):(<class 'vim.error'>, error('abcN',))
 Exe("throw 'def'"):(<class 'vim.error'>, error('def',))
 vim.eval("Exe('throw ''ghi''')"):(<class 'vim.error'>, error('ghi',))
 vim.eval("Exe('echoerr ''jkl''')"):(<class 'vim.error'>, error('Vim(echoerr):jkl',))