averello/macvim-mirror
1
0
Fork 0
mirror of https://github.com/macvim-dev/macvim.git synced 2026-06-11 15:37:29 +02:00
Code Issues Packages Projects Releases Wiki Activity

Workaround fix for test87

Browse Source
This commit is contained in:
Kazuki Sakamoto
2015-11-04 05:41:23 -08:00
parent b376c5c67d
commit 1332cbb7da
1 changed files with 117 additions and 117 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/testdir/test87.ok
+117 -117
View File
@@ -65,11 +65,11 @@ l[1](1, 2, 3):(<class 'vim.error'>, error('Vim:E725: Calling dict function witho
f(1, 2, 3):(<class 'vim.error'>, error('Vim:E117: Unknown function: New',))
[0.0, 0.0]
KeyError
TypeError
TypeError
ValueError
TypeError
TypeError
ValueError
ValueError
ValueError
KeyError
KeyError
d : locked:0;scope:0
@@ -513,30 +513,30 @@ sys.stdout.writelines(FailingIterNext()):(<class 'NotImplementedError'>, NotImpl
> VimCommand
>>> Testing StringToChars using vim.command(%s)
vim.command(1):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
vim.command(b"\0"):(<class 'TypeError'>, TypeError('expected bytes with no null',))
vim.command("\0"):(<class 'TypeError'>, TypeError('expected bytes with no null',))
vim.command(b"\0"):(<class 'ValueError'>, ValueError('embedded null byte',))
vim.command("\0"):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
vim.command("", 2):(<class 'TypeError'>, TypeError('command() takes exactly one argument (2 given)',))
> VimToPython
> VimEval
>>> Testing StringToChars using vim.eval(%s)
vim.eval(1):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
vim.eval(b"\0"):(<class 'TypeError'>, TypeError('expected bytes with no null',))
vim.eval("\0"):(<class 'TypeError'>, TypeError('expected bytes with no null',))
vim.eval(b"\0"):(<class 'ValueError'>, ValueError('embedded null byte',))
vim.eval("\0"):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
vim.eval("", FailingTrue()):(<class 'TypeError'>, TypeError('function takes exactly 1 argument (2 given)',))
> VimEvalPy
>>> Testing StringToChars using vim.bindeval(%s)
vim.bindeval(1):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
vim.bindeval(b"\0"):(<class 'TypeError'>, TypeError('expected bytes with no null',))
vim.bindeval("\0"):(<class 'TypeError'>, TypeError('expected bytes with no null',))
vim.bindeval(b"\0"):(<class 'ValueError'>, ValueError('embedded null byte',))
vim.bindeval("\0"):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
vim.eval("", 2):(<class 'TypeError'>, TypeError('function takes exactly 1 argument (2 given)',))
> VimStrwidth
>>> Testing StringToChars using vim.strwidth(%s)
vim.strwidth(1):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
vim.strwidth(b"\0"):(<class 'TypeError'>, TypeError('expected bytes with no null',))
vim.strwidth("\0"):(<class 'TypeError'>, TypeError('expected bytes with no null',))
vim.strwidth(b"\0"):(<class 'ValueError'>, ValueError('embedded null byte',))
vim.strwidth("\0"):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
> VimForeachRTP
vim.foreach_rtp(None):(<class 'TypeError'>, TypeError("'NoneType' object is not callable",))
@@ -553,14 +553,14 @@ vim.options["abcQ"]:(<class 'KeyError'>, KeyError('abcQ',))
vim.options[""]:(<class 'ValueError'>, ValueError('empty keys are not allowed',))
>>> Testing StringToChars using vim.options[%s]
vim.options[1]:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
vim.options[b"\0"]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
vim.options["\0"]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
vim.options[b"\0"]:(<class 'ValueError'>, ValueError('embedded null byte',))
vim.options["\0"]:(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>> OptionsContains
>>> Testing StringToChars using %s in vim.options
1 in vim.options:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
b"\0" in vim.options:(<class 'TypeError'>, TypeError('expected bytes with no null',))
"\0" in vim.options:(<class 'TypeError'>, TypeError('expected bytes with no null',))
b"\0" in vim.options:(<class 'ValueError'>, ValueError('embedded null byte',))
"\0" in vim.options:(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
> Dictionary
>> DictionaryConstructor
@@ -575,8 +575,8 @@ d.xxx = True:(<class 'AttributeError'>, AttributeError('cannot set attribute xxx
d.get("a", 2, 3):(<class 'TypeError'>, TypeError('function takes at most 2 arguments (3 given)',))
>>> Testing StringToChars using d.get(%s)
d.get(1):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d.get(b"\0"):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.get("\0"):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.get(b"\0"):(<class 'ValueError'>, ValueError('embedded null byte',))
d.get("\0"):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
d.pop("a"):(<class 'KeyError'>, KeyError('a',))
dl.pop("a"):(<class 'vim.error'>, error('dictionary is locked',))
@@ -589,23 +589,23 @@ for i in ned: ned["a"] = 1:(<class 'RuntimeError'>, RuntimeError('hashtab change
dl["b"] = 1:(<class 'vim.error'>, error('dictionary is locked',))
>>> Testing StringToChars using d[%s] = 1
d[1] = 1:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d[b"\0"] = 1:(<class 'TypeError'>, TypeError('expected bytes with no null',))
d["\0"] = 1:(<class 'TypeError'>, TypeError('expected bytes with no null',))
d[b"\0"] = 1:(<class 'ValueError'>, ValueError('embedded null byte',))
d["\0"] = 1:(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing StringToChars using d["a"] = {%s : 1}
d["a"] = {1 : 1}:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d["a"] = {b"\0" : 1}:(<class 'TypeError'>, TypeError('expected bytes with no null',))
d["a"] = {"\0" : 1}:(<class 'TypeError'>, TypeError('expected bytes with no null',))
d["a"] = {b"\0" : 1}:(<class 'ValueError'>, ValueError('embedded null byte',))
d["a"] = {"\0" : 1}:(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing StringToChars using d["a"] = {"abcF" : {%s : 1}}
d["a"] = {"abcF" : {1 : 1}}:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d["a"] = {"abcF" : {b"\0" : 1}}:(<class 'TypeError'>, TypeError('expected bytes with no null',))
d["a"] = {"abcF" : {"\0" : 1}}:(<class 'TypeError'>, TypeError('expected bytes with no null',))
d["a"] = {"abcF" : {b"\0" : 1}}:(<class 'ValueError'>, ValueError('embedded null byte',))
d["a"] = {"abcF" : {"\0" : 1}}:(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing StringToChars using d["a"] = {"abcF" : Mapping({%s : 1})}
d["a"] = {"abcF" : Mapping({1 : 1})}:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d["a"] = {"abcF" : Mapping({b"\0" : 1})}:(<class 'TypeError'>, TypeError('expected bytes with no null',))
d["a"] = {"abcF" : Mapping({"\0" : 1})}:(<class 'TypeError'>, TypeError('expected bytes with no null',))
d["a"] = {"abcF" : Mapping({b"\0" : 1})}:(<class 'ValueError'>, ValueError('embedded null byte',))
d["a"] = {"abcF" : Mapping({"\0" : 1})}:(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing *Iter* using d["a"] = {"abcF" : %s}
d["a"] = {"abcF" : FailingIter()}:(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -621,18 +621,18 @@ d["a"] = {"abcF" : FailingNumber()}:(<class 'NotImplementedError'>, NotImplement
<<< 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',))
d["a"] = Mapping({b"\0" : 1}):(<class 'ValueError'>, ValueError('embedded null byte',))
d["a"] = Mapping({"\0" : 1}):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing StringToChars using d["a"] = Mapping({"abcG" : {%s : 1}})
d["a"] = Mapping({"abcG" : {1 : 1}}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d["a"] = Mapping({"abcG" : {b"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d["a"] = Mapping({"abcG" : {"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d["a"] = Mapping({"abcG" : {b"\0" : 1}}):(<class 'ValueError'>, ValueError('embedded null byte',))
d["a"] = Mapping({"abcG" : {"\0" : 1}}):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing StringToChars using d["a"] = Mapping({"abcG" : Mapping({%s : 1})})
d["a"] = Mapping({"abcG" : Mapping({1 : 1})}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d["a"] = Mapping({"abcG" : Mapping({b"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d["a"] = Mapping({"abcG" : Mapping({"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d["a"] = Mapping({"abcG" : Mapping({b"\0" : 1})}):(<class 'ValueError'>, ValueError('embedded null byte',))
d["a"] = Mapping({"abcG" : Mapping({"\0" : 1})}):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing *Iter* using d["a"] = Mapping({"abcG" : %s})
d["a"] = Mapping({"abcG" : FailingIter()}):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -670,18 +670,18 @@ d.update(FailingIterNext()):(<class 'NotImplementedError'>, NotImplementedError(
<<< Finished
>>> Testing StringToChars using d.update({%s : 1})
d.update({1 : 1}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d.update({b"\0" : 1}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update({"\0" : 1}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update({b"\0" : 1}):(<class 'ValueError'>, ValueError('embedded null byte',))
d.update({"\0" : 1}):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing StringToChars using d.update({"abcF" : {%s : 1}})
d.update({"abcF" : {1 : 1}}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d.update({"abcF" : {b"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update({"abcF" : {"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update({"abcF" : {b"\0" : 1}}):(<class 'ValueError'>, ValueError('embedded null byte',))
d.update({"abcF" : {"\0" : 1}}):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing StringToChars using d.update({"abcF" : Mapping({%s : 1})})
d.update({"abcF" : Mapping({1 : 1})}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d.update({"abcF" : Mapping({b"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update({"abcF" : Mapping({"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update({"abcF" : Mapping({b"\0" : 1})}):(<class 'ValueError'>, ValueError('embedded null byte',))
d.update({"abcF" : Mapping({"\0" : 1})}):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing *Iter* using d.update({"abcF" : %s})
d.update({"abcF" : FailingIter()}):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -697,18 +697,18 @@ d.update({"abcF" : FailingNumber()}):(<class 'NotImplementedError'>, NotImplemen
<<< 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',))
d.update(Mapping({b"\0" : 1})):(<class 'ValueError'>, ValueError('embedded null byte',))
d.update(Mapping({"\0" : 1})):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing StringToChars using d.update(Mapping({"abcG" : {%s : 1}}))
d.update(Mapping({"abcG" : {1 : 1}})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d.update(Mapping({"abcG" : {b"\0" : 1}})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update(Mapping({"abcG" : {"\0" : 1}})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update(Mapping({"abcG" : {b"\0" : 1}})):(<class 'ValueError'>, ValueError('embedded null byte',))
d.update(Mapping({"abcG" : {"\0" : 1}})):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing StringToChars using d.update(Mapping({"abcG" : Mapping({%s : 1})}))
d.update(Mapping({"abcG" : Mapping({1 : 1})})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d.update(Mapping({"abcG" : Mapping({b"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update(Mapping({"abcG" : Mapping({"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update(Mapping({"abcG" : Mapping({b"\0" : 1})})):(<class 'ValueError'>, ValueError('embedded null byte',))
d.update(Mapping({"abcG" : Mapping({"\0" : 1})})):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing *Iter* using d.update(Mapping({"abcG" : %s}))
d.update(Mapping({"abcG" : FailingIter()})):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -736,23 +736,23 @@ d.update(FailingNumber()):(<class 'TypeError'>, TypeError("'FailingNumber' objec
<<< Finished
>>> Testing StringToChars using d.update(((%s, 0),))
d.update(((1, 0),)):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d.update(((b"\0", 0),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update((("\0", 0),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update(((b"\0", 0),)):(<class 'ValueError'>, ValueError('embedded null byte',))
d.update((("\0", 0),)):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing StringToChars using d.update((("a", {%s : 1}),))
d.update((("a", {1 : 1}),)):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d.update((("a", {b"\0" : 1}),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update((("a", {"\0" : 1}),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update((("a", {b"\0" : 1}),)):(<class 'ValueError'>, ValueError('embedded null byte',))
d.update((("a", {"\0" : 1}),)):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing StringToChars using d.update((("a", {"abcF" : {%s : 1}}),))
d.update((("a", {"abcF" : {1 : 1}}),)):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d.update((("a", {"abcF" : {b"\0" : 1}}),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update((("a", {"abcF" : {"\0" : 1}}),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update((("a", {"abcF" : {b"\0" : 1}}),)):(<class 'ValueError'>, ValueError('embedded null byte',))
d.update((("a", {"abcF" : {"\0" : 1}}),)):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing StringToChars using d.update((("a", {"abcF" : Mapping({%s : 1})}),))
d.update((("a", {"abcF" : Mapping({1 : 1})}),)):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d.update((("a", {"abcF" : Mapping({b"\0" : 1})}),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update((("a", {"abcF" : Mapping({"\0" : 1})}),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update((("a", {"abcF" : Mapping({b"\0" : 1})}),)):(<class 'ValueError'>, ValueError('embedded null byte',))
d.update((("a", {"abcF" : Mapping({"\0" : 1})}),)):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing *Iter* using d.update((("a", {"abcF" : %s}),))
d.update((("a", {"abcF" : FailingIter()}),)):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -768,18 +768,18 @@ d.update((("a", {"abcF" : FailingNumber()}),)):(<class 'NotImplementedError'>, N
<<< 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',))
d.update((("a", Mapping({b"\0" : 1})),)):(<class 'ValueError'>, ValueError('embedded null byte',))
d.update((("a", Mapping({"\0" : 1})),)):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing StringToChars using d.update((("a", Mapping({"abcG" : {%s : 1}})),))
d.update((("a", Mapping({"abcG" : {1 : 1}})),)):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d.update((("a", Mapping({"abcG" : {b"\0" : 1}})),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update((("a", Mapping({"abcG" : {"\0" : 1}})),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update((("a", Mapping({"abcG" : {b"\0" : 1}})),)):(<class 'ValueError'>, ValueError('embedded null byte',))
d.update((("a", Mapping({"abcG" : {"\0" : 1}})),)):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing StringToChars using d.update((("a", Mapping({"abcG" : Mapping({%s : 1})})),))
d.update((("a", Mapping({"abcG" : Mapping({1 : 1})})),)):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
d.update((("a", Mapping({"abcG" : Mapping({b"\0" : 1})})),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update((("a", Mapping({"abcG" : Mapping({"\0" : 1})})),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
d.update((("a", Mapping({"abcG" : Mapping({b"\0" : 1})})),)):(<class 'ValueError'>, ValueError('embedded null byte',))
d.update((("a", Mapping({"abcG" : Mapping({"\0" : 1})})),)):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> 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',))
@@ -819,18 +819,18 @@ vim.List(FailingIterNext()):(<class 'NotImplementedError'>, NotImplementedError(
<<< Finished
>>> Testing StringToChars using vim.List([{%s : 1}])
vim.List([{1 : 1}]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
vim.List([{b"\0" : 1}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
vim.List([{"\0" : 1}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
vim.List([{b"\0" : 1}]):(<class 'ValueError'>, ValueError('embedded null byte',))
vim.List([{"\0" : 1}]):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing StringToChars using vim.List([{"abcF" : {%s : 1}}])
vim.List([{"abcF" : {1 : 1}}]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
vim.List([{"abcF" : {b"\0" : 1}}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
vim.List([{"abcF" : {"\0" : 1}}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
vim.List([{"abcF" : {b"\0" : 1}}]):(<class 'ValueError'>, ValueError('embedded null byte',))
vim.List([{"abcF" : {"\0" : 1}}]):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing StringToChars using vim.List([{"abcF" : Mapping({%s : 1})}])
vim.List([{"abcF" : Mapping({1 : 1})}]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
vim.List([{"abcF" : Mapping({b"\0" : 1})}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
vim.List([{"abcF" : Mapping({"\0" : 1})}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
vim.List([{"abcF" : Mapping({b"\0" : 1})}]):(<class 'ValueError'>, ValueError('embedded null byte',))
vim.List([{"abcF" : Mapping({"\0" : 1})}]):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing *Iter* using vim.List([{"abcF" : %s}])
vim.List([{"abcF" : FailingIter()}]):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -846,18 +846,18 @@ vim.List([{"abcF" : FailingNumber()}]):(<class 'NotImplementedError'>, NotImplem
<<< 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',))
vim.List([Mapping({b"\0" : 1})]):(<class 'ValueError'>, ValueError('embedded null byte',))
vim.List([Mapping({"\0" : 1})]):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing StringToChars using vim.List([Mapping({"abcG" : {%s : 1}})])
vim.List([Mapping({"abcG" : {1 : 1}})]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
vim.List([Mapping({"abcG" : {b"\0" : 1}})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
vim.List([Mapping({"abcG" : {"\0" : 1}})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
vim.List([Mapping({"abcG" : {b"\0" : 1}})]):(<class 'ValueError'>, ValueError('embedded null byte',))
vim.List([Mapping({"abcG" : {"\0" : 1}})]):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing StringToChars using vim.List([Mapping({"abcG" : Mapping({%s : 1})})])
vim.List([Mapping({"abcG" : Mapping({1 : 1})})]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
vim.List([Mapping({"abcG" : Mapping({b"\0" : 1})})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
vim.List([Mapping({"abcG" : Mapping({"\0" : 1})})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
vim.List([Mapping({"abcG" : Mapping({b"\0" : 1})})]):(<class 'ValueError'>, ValueError('embedded null byte',))
vim.List([Mapping({"abcG" : Mapping({"\0" : 1})})]):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing *Iter* using vim.List([Mapping({"abcG" : %s})])
vim.List([Mapping({"abcG" : FailingIter()})]):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -904,18 +904,18 @@ nel[:] = FailingIterNextN(2):(<class 'NotImplementedError'>, NotImplementedError
(b'a', b'b', b'c', b'O')
>>> Testing StringToChars using l[:] = [{%s : 1}]
l[:] = [{1 : 1}]:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
l[:] = [{b"\0" : 1}]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
l[:] = [{"\0" : 1}]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
l[:] = [{b"\0" : 1}]:(<class 'ValueError'>, ValueError('embedded null byte',))
l[:] = [{"\0" : 1}]:(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing StringToChars using l[:] = [{"abcF" : {%s : 1}}]
l[:] = [{"abcF" : {1 : 1}}]:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
l[:] = [{"abcF" : {b"\0" : 1}}]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
l[:] = [{"abcF" : {"\0" : 1}}]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
l[:] = [{"abcF" : {b"\0" : 1}}]:(<class 'ValueError'>, ValueError('embedded null byte',))
l[:] = [{"abcF" : {"\0" : 1}}]:(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing StringToChars using l[:] = [{"abcF" : Mapping({%s : 1})}]
l[:] = [{"abcF" : Mapping({1 : 1})}]:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
l[:] = [{"abcF" : Mapping({b"\0" : 1})}]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
l[:] = [{"abcF" : Mapping({"\0" : 1})}]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
l[:] = [{"abcF" : Mapping({b"\0" : 1})}]:(<class 'ValueError'>, ValueError('embedded null byte',))
l[:] = [{"abcF" : Mapping({"\0" : 1})}]:(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing *Iter* using l[:] = [{"abcF" : %s}]
l[:] = [{"abcF" : FailingIter()}]:(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -931,18 +931,18 @@ l[:] = [{"abcF" : FailingNumber()}]:(<class 'NotImplementedError'>, NotImplement
<<< 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',))
l[:] = [Mapping({b"\0" : 1})]:(<class 'ValueError'>, ValueError('embedded null byte',))
l[:] = [Mapping({"\0" : 1})]:(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing StringToChars using l[:] = [Mapping({"abcG" : {%s : 1}})]
l[:] = [Mapping({"abcG" : {1 : 1}})]:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
l[:] = [Mapping({"abcG" : {b"\0" : 1}})]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
l[:] = [Mapping({"abcG" : {"\0" : 1}})]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
l[:] = [Mapping({"abcG" : {b"\0" : 1}})]:(<class 'ValueError'>, ValueError('embedded null byte',))
l[:] = [Mapping({"abcG" : {"\0" : 1}})]:(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing StringToChars using l[:] = [Mapping({"abcG" : Mapping({%s : 1})})]
l[:] = [Mapping({"abcG" : Mapping({1 : 1})})]:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
l[:] = [Mapping({"abcG" : Mapping({b"\0" : 1})})]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
l[:] = [Mapping({"abcG" : Mapping({"\0" : 1})})]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
l[:] = [Mapping({"abcG" : Mapping({b"\0" : 1})})]:(<class 'ValueError'>, ValueError('embedded null byte',))
l[:] = [Mapping({"abcG" : Mapping({"\0" : 1})})]:(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing *Iter* using l[:] = [Mapping({"abcG" : %s})]
l[:] = [Mapping({"abcG" : FailingIter()})]:(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -975,18 +975,18 @@ l.extend(FailingIterNext()):(<class 'NotImplementedError'>, NotImplementedError(
<<< Finished
>>> Testing StringToChars using l.extend([{%s : 1}])
l.extend([{1 : 1}]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
l.extend([{b"\0" : 1}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
l.extend([{"\0" : 1}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
l.extend([{b"\0" : 1}]):(<class 'ValueError'>, ValueError('embedded null byte',))
l.extend([{"\0" : 1}]):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing StringToChars using l.extend([{"abcF" : {%s : 1}}])
l.extend([{"abcF" : {1 : 1}}]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
l.extend([{"abcF" : {b"\0" : 1}}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
l.extend([{"abcF" : {"\0" : 1}}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
l.extend([{"abcF" : {b"\0" : 1}}]):(<class 'ValueError'>, ValueError('embedded null byte',))
l.extend([{"abcF" : {"\0" : 1}}]):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing StringToChars using l.extend([{"abcF" : Mapping({%s : 1})}])
l.extend([{"abcF" : Mapping({1 : 1})}]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
l.extend([{"abcF" : Mapping({b"\0" : 1})}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
l.extend([{"abcF" : Mapping({"\0" : 1})}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
l.extend([{"abcF" : Mapping({b"\0" : 1})}]):(<class 'ValueError'>, ValueError('embedded null byte',))
l.extend([{"abcF" : Mapping({"\0" : 1})}]):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing *Iter* using l.extend([{"abcF" : %s}])
l.extend([{"abcF" : FailingIter()}]):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -1002,18 +1002,18 @@ l.extend([{"abcF" : FailingNumber()}]):(<class 'NotImplementedError'>, NotImplem
<<< 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',))
l.extend([Mapping({b"\0" : 1})]):(<class 'ValueError'>, ValueError('embedded null byte',))
l.extend([Mapping({"\0" : 1})]):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing StringToChars using l.extend([Mapping({"abcG" : {%s : 1}})])
l.extend([Mapping({"abcG" : {1 : 1}})]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
l.extend([Mapping({"abcG" : {b"\0" : 1}})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
l.extend([Mapping({"abcG" : {"\0" : 1}})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
l.extend([Mapping({"abcG" : {b"\0" : 1}})]):(<class 'ValueError'>, ValueError('embedded null byte',))
l.extend([Mapping({"abcG" : {"\0" : 1}})]):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing StringToChars using l.extend([Mapping({"abcG" : Mapping({%s : 1})})])
l.extend([Mapping({"abcG" : Mapping({1 : 1})})]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
l.extend([Mapping({"abcG" : Mapping({b"\0" : 1})})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
l.extend([Mapping({"abcG" : Mapping({"\0" : 1})})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
l.extend([Mapping({"abcG" : Mapping({b"\0" : 1})})]):(<class 'ValueError'>, ValueError('embedded null byte',))
l.extend([Mapping({"abcG" : Mapping({"\0" : 1})})]):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing *Iter* using l.extend([Mapping({"abcG" : %s})])
l.extend([Mapping({"abcG" : FailingIter()})]):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -1051,18 +1051,18 @@ vim.Function("xxx#non#existent#function#xxx"):NOT FAILED
>> FunctionCall
>>> Testing StringToChars using f({%s : 1})
f({1 : 1}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
f({b"\0" : 1}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
f({"\0" : 1}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
f({b"\0" : 1}):(<class 'ValueError'>, ValueError('embedded null byte',))
f({"\0" : 1}):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing StringToChars using f({"abcF" : {%s : 1}})
f({"abcF" : {1 : 1}}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
f({"abcF" : {b"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
f({"abcF" : {"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
f({"abcF" : {b"\0" : 1}}):(<class 'ValueError'>, ValueError('embedded null byte',))
f({"abcF" : {"\0" : 1}}):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing StringToChars using f({"abcF" : Mapping({%s : 1})})
f({"abcF" : Mapping({1 : 1})}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
f({"abcF" : Mapping({b"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
f({"abcF" : Mapping({"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
f({"abcF" : Mapping({b"\0" : 1})}):(<class 'ValueError'>, ValueError('embedded null byte',))
f({"abcF" : Mapping({"\0" : 1})}):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing *Iter* using f({"abcF" : %s})
f({"abcF" : FailingIter()}):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -1078,18 +1078,18 @@ f({"abcF" : FailingNumber()}):(<class 'NotImplementedError'>, NotImplementedErro
<<< 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',))
f(Mapping({b"\0" : 1})):(<class 'ValueError'>, ValueError('embedded null byte',))
f(Mapping({"\0" : 1})):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing StringToChars using f(Mapping({"abcG" : {%s : 1}}))
f(Mapping({"abcG" : {1 : 1}})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
f(Mapping({"abcG" : {b"\0" : 1}})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
f(Mapping({"abcG" : {"\0" : 1}})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
f(Mapping({"abcG" : {b"\0" : 1}})):(<class 'ValueError'>, ValueError('embedded null byte',))
f(Mapping({"abcG" : {"\0" : 1}})):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing StringToChars using f(Mapping({"abcG" : Mapping({%s : 1})}))
f(Mapping({"abcG" : Mapping({1 : 1})})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
f(Mapping({"abcG" : Mapping({b"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
f(Mapping({"abcG" : Mapping({"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
f(Mapping({"abcG" : Mapping({b"\0" : 1})})):(<class 'ValueError'>, ValueError('embedded null byte',))
f(Mapping({"abcG" : Mapping({"\0" : 1})})):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing *Iter* using f(Mapping({"abcG" : %s}))
f(Mapping({"abcG" : FailingIter()})):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -1117,18 +1117,18 @@ f(FailingNumber()):(<class 'NotImplementedError'>, NotImplementedError('int',))
<<< Finished
>>> Testing StringToChars using fd(self={%s : 1})
fd(self={1 : 1}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
fd(self={b"\0" : 1}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
fd(self={"\0" : 1}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
fd(self={b"\0" : 1}):(<class 'ValueError'>, ValueError('embedded null byte',))
fd(self={"\0" : 1}):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing StringToChars using fd(self={"abcF" : {%s : 1}})
fd(self={"abcF" : {1 : 1}}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
fd(self={"abcF" : {b"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
fd(self={"abcF" : {"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
fd(self={"abcF" : {b"\0" : 1}}):(<class 'ValueError'>, ValueError('embedded null byte',))
fd(self={"abcF" : {"\0" : 1}}):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing StringToChars using fd(self={"abcF" : Mapping({%s : 1})})
fd(self={"abcF" : Mapping({1 : 1})}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
fd(self={"abcF" : Mapping({b"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
fd(self={"abcF" : Mapping({"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
fd(self={"abcF" : Mapping({b"\0" : 1})}):(<class 'ValueError'>, ValueError('embedded null byte',))
fd(self={"abcF" : Mapping({"\0" : 1})}):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing *Iter* using fd(self={"abcF" : %s})
fd(self={"abcF" : FailingIter()}):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -1144,18 +1144,18 @@ fd(self={"abcF" : FailingNumber()}):(<class 'NotImplementedError'>, NotImplement
<<< 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',))
fd(self=Mapping({b"\0" : 1})):(<class 'ValueError'>, ValueError('embedded null byte',))
fd(self=Mapping({"\0" : 1})):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing StringToChars using fd(self=Mapping({"abcG" : {%s : 1}}))
fd(self=Mapping({"abcG" : {1 : 1}})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
fd(self=Mapping({"abcG" : {b"\0" : 1}})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
fd(self=Mapping({"abcG" : {"\0" : 1}})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
fd(self=Mapping({"abcG" : {b"\0" : 1}})):(<class 'ValueError'>, ValueError('embedded null byte',))
fd(self=Mapping({"abcG" : {"\0" : 1}})):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing StringToChars using fd(self=Mapping({"abcG" : Mapping({%s : 1})}))
fd(self=Mapping({"abcG" : Mapping({1 : 1})})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
fd(self=Mapping({"abcG" : Mapping({b"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
fd(self=Mapping({"abcG" : Mapping({"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
fd(self=Mapping({"abcG" : Mapping({b"\0" : 1})})):(<class 'ValueError'>, ValueError('embedded null byte',))
fd(self=Mapping({"abcG" : Mapping({"\0" : 1})})):(<class 'ValueError'>, ValueError('embedded null byte',))
<<< Finished
>>> Testing *Iter* using fd(self=Mapping({"abcG" : %s}))
fd(self=Mapping({"abcG" : FailingIter()})):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))