diff --git a/src/testdir/test87.ok b/src/testdir/test87.ok
index 65bd596542..1d9b6e2578 100644
--- a/src/testdir/test87.ok
+++ b/src/testdir/test87.ok
@@ -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
-ValueError
+TypeError
 TypeError
 ValueError
-ValueError
-ValueError
+TypeError
+TypeError
 KeyError
 KeyError
 d : locked:0;scope:0
@@ -514,30 +514,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 'ValueError'>, ValueError('embedded null byte',))
-vim.command("\0"):(<class 'ValueError'>, ValueError('embedded null byte',))
+vim.command(b"\0"):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+vim.command("\0"):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 vim.command("", 2):(<class 'TypeError'>, TypeError('command() takes exactly one argument (2 given)',))
 > VimToPython
 > VimEval
 >>> Testing StringToChars using vim.eval(%s)
 vim.eval(1):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-vim.eval(b"\0"):(<class 'ValueError'>, ValueError('embedded null byte',))
-vim.eval("\0"):(<class 'ValueError'>, ValueError('embedded null byte',))
+vim.eval(b"\0"):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+vim.eval("\0"):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 vim.eval("", FailingTrue()):(<class 'TypeError'>, TypeError('function takes exactly 1 argument (2 given)',))
 > VimEvalPy
 >>> Testing StringToChars using vim.bindeval(%s)
 vim.bindeval(1):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-vim.bindeval(b"\0"):(<class 'ValueError'>, ValueError('embedded null byte',))
-vim.bindeval("\0"):(<class 'ValueError'>, ValueError('embedded null byte',))
+vim.bindeval(b"\0"):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+vim.bindeval("\0"):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 vim.eval("", 2):(<class 'TypeError'>, TypeError('function takes exactly 1 argument (2 given)',))
 > VimStrwidth
 >>> Testing StringToChars using vim.strwidth(%s)
 vim.strwidth(1):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-vim.strwidth(b"\0"):(<class 'ValueError'>, ValueError('embedded null byte',))
-vim.strwidth("\0"):(<class 'ValueError'>, ValueError('embedded null byte',))
+vim.strwidth(b"\0"):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+vim.strwidth("\0"):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 > VimForeachRTP
 vim.foreach_rtp(None):(<class 'TypeError'>, TypeError("'NoneType' object is not callable",))
@@ -554,14 +554,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 'ValueError'>, ValueError('embedded null byte',))
-vim.options["\0"]:(<class 'ValueError'>, ValueError('embedded null byte',))
+vim.options[b"\0"]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
+vim.options["\0"]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >> OptionsContains
 >>> Testing StringToChars using %s in vim.options
 1 in vim.options:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-b"\0" in vim.options:(<class 'ValueError'>, ValueError('embedded null byte',))
-"\0" in vim.options:(<class 'ValueError'>, ValueError('embedded null byte',))
+b"\0" in vim.options:(<class 'TypeError'>, TypeError('expected bytes with no null',))
+"\0" in vim.options:(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 > Dictionary
 >> DictionaryConstructor
@@ -576,8 +576,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 'ValueError'>, ValueError('embedded null byte',))
-d.get("\0"):(<class 'ValueError'>, ValueError('embedded null byte',))
+d.get(b"\0"):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+d.get("\0"):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 d.pop("a"):(<class 'KeyError'>, KeyError('a',))
 dl.pop("a"):(<class 'vim.error'>, error('dictionary is locked',))
@@ -590,23 +590,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 'ValueError'>, ValueError('embedded null byte',))
-d["\0"] = 1:(<class 'ValueError'>, ValueError('embedded null byte',))
+d[b"\0"] = 1:(<class 'TypeError'>, TypeError('expected bytes with no null',))
+d["\0"] = 1:(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing StringToChars using d["a"] = {%s : 1}
 d["a"] = {1 : 1}:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-d["a"] = {b"\0" : 1}:(<class 'ValueError'>, ValueError('embedded null byte',))
-d["a"] = {"\0" : 1}:(<class 'ValueError'>, ValueError('embedded null byte',))
+d["a"] = {b"\0" : 1}:(<class 'TypeError'>, TypeError('expected bytes with no null',))
+d["a"] = {"\0" : 1}:(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing StringToChars using d["a"] = {"abcF" : {%s : 1}}
 d["a"] = {"abcF" : {1 : 1}}:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-d["a"] = {"abcF" : {b"\0" : 1}}:(<class 'ValueError'>, ValueError('embedded null byte',))
-d["a"] = {"abcF" : {"\0" : 1}}:(<class 'ValueError'>, ValueError('embedded null byte',))
+d["a"] = {"abcF" : {b"\0" : 1}}:(<class 'TypeError'>, TypeError('expected bytes with no null',))
+d["a"] = {"abcF" : {"\0" : 1}}:(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing StringToChars using d["a"] = {"abcF" : Mapping({%s : 1})}
 d["a"] = {"abcF" : Mapping({1 : 1})}:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-d["a"] = {"abcF" : Mapping({b"\0" : 1})}:(<class 'ValueError'>, ValueError('embedded null byte',))
-d["a"] = {"abcF" : Mapping({"\0" : 1})}:(<class 'ValueError'>, ValueError('embedded null byte',))
+d["a"] = {"abcF" : Mapping({b"\0" : 1})}:(<class 'TypeError'>, TypeError('expected bytes with no null',))
+d["a"] = {"abcF" : Mapping({"\0" : 1})}:(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing *Iter* using d["a"] = {"abcF" : %s}
 d["a"] = {"abcF" : FailingIter()}:(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -622,18 +622,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 'ValueError'>, ValueError('embedded null byte',))
-d["a"] = Mapping({"\0" : 1}):(<class 'ValueError'>, ValueError('embedded null byte',))
+d["a"] = Mapping({b"\0" : 1}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+d["a"] = Mapping({"\0" : 1}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing StringToChars using d["a"] = Mapping({"abcG" : {%s : 1}})
 d["a"] = Mapping({"abcG" : {1 : 1}}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-d["a"] = Mapping({"abcG" : {b"\0" : 1}}):(<class 'ValueError'>, ValueError('embedded null byte',))
-d["a"] = Mapping({"abcG" : {"\0" : 1}}):(<class 'ValueError'>, ValueError('embedded null byte',))
+d["a"] = Mapping({"abcG" : {b"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+d["a"] = Mapping({"abcG" : {"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing StringToChars using d["a"] = Mapping({"abcG" : Mapping({%s : 1})})
 d["a"] = Mapping({"abcG" : Mapping({1 : 1})}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-d["a"] = Mapping({"abcG" : Mapping({b"\0" : 1})}):(<class 'ValueError'>, ValueError('embedded null byte',))
-d["a"] = Mapping({"abcG" : Mapping({"\0" : 1})}):(<class 'ValueError'>, ValueError('embedded null byte',))
+d["a"] = Mapping({"abcG" : Mapping({b"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+d["a"] = Mapping({"abcG" : Mapping({"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing *Iter* using d["a"] = Mapping({"abcG" : %s})
 d["a"] = Mapping({"abcG" : FailingIter()}):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -671,18 +671,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 'ValueError'>, ValueError('embedded null byte',))
-d.update({"\0" : 1}):(<class 'ValueError'>, ValueError('embedded null byte',))
+d.update({b"\0" : 1}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+d.update({"\0" : 1}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing StringToChars using d.update({"abcF" : {%s : 1}})
 d.update({"abcF" : {1 : 1}}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-d.update({"abcF" : {b"\0" : 1}}):(<class 'ValueError'>, ValueError('embedded null byte',))
-d.update({"abcF" : {"\0" : 1}}):(<class 'ValueError'>, ValueError('embedded null byte',))
+d.update({"abcF" : {b"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+d.update({"abcF" : {"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing StringToChars using d.update({"abcF" : Mapping({%s : 1})})
 d.update({"abcF" : Mapping({1 : 1})}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-d.update({"abcF" : Mapping({b"\0" : 1})}):(<class 'ValueError'>, ValueError('embedded null byte',))
-d.update({"abcF" : Mapping({"\0" : 1})}):(<class 'ValueError'>, ValueError('embedded null byte',))
+d.update({"abcF" : Mapping({b"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+d.update({"abcF" : Mapping({"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing *Iter* using d.update({"abcF" : %s})
 d.update({"abcF" : FailingIter()}):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -698,18 +698,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 'ValueError'>, ValueError('embedded null byte',))
-d.update(Mapping({"\0" : 1})):(<class 'ValueError'>, ValueError('embedded null byte',))
+d.update(Mapping({b"\0" : 1})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+d.update(Mapping({"\0" : 1})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing StringToChars using d.update(Mapping({"abcG" : {%s : 1}}))
 d.update(Mapping({"abcG" : {1 : 1}})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-d.update(Mapping({"abcG" : {b"\0" : 1}})):(<class 'ValueError'>, ValueError('embedded null byte',))
-d.update(Mapping({"abcG" : {"\0" : 1}})):(<class 'ValueError'>, ValueError('embedded null byte',))
+d.update(Mapping({"abcG" : {b"\0" : 1}})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+d.update(Mapping({"abcG" : {"\0" : 1}})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing StringToChars using d.update(Mapping({"abcG" : Mapping({%s : 1})}))
 d.update(Mapping({"abcG" : Mapping({1 : 1})})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-d.update(Mapping({"abcG" : Mapping({b"\0" : 1})})):(<class 'ValueError'>, ValueError('embedded null byte',))
-d.update(Mapping({"abcG" : Mapping({"\0" : 1})})):(<class 'ValueError'>, ValueError('embedded null byte',))
+d.update(Mapping({"abcG" : Mapping({b"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+d.update(Mapping({"abcG" : Mapping({"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing *Iter* using d.update(Mapping({"abcG" : %s}))
 d.update(Mapping({"abcG" : FailingIter()})):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -737,23 +737,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 'ValueError'>, ValueError('embedded null byte',))
-d.update((("\0", 0),)):(<class 'ValueError'>, ValueError('embedded null byte',))
+d.update(((b"\0", 0),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+d.update((("\0", 0),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing StringToChars using d.update((("a", {%s : 1}),))
 d.update((("a", {1 : 1}),)):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-d.update((("a", {b"\0" : 1}),)):(<class 'ValueError'>, ValueError('embedded null byte',))
-d.update((("a", {"\0" : 1}),)):(<class 'ValueError'>, ValueError('embedded null byte',))
+d.update((("a", {b"\0" : 1}),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+d.update((("a", {"\0" : 1}),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing StringToChars using d.update((("a", {"abcF" : {%s : 1}}),))
 d.update((("a", {"abcF" : {1 : 1}}),)):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-d.update((("a", {"abcF" : {b"\0" : 1}}),)):(<class 'ValueError'>, ValueError('embedded null byte',))
-d.update((("a", {"abcF" : {"\0" : 1}}),)):(<class 'ValueError'>, ValueError('embedded null byte',))
+d.update((("a", {"abcF" : {b"\0" : 1}}),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+d.update((("a", {"abcF" : {"\0" : 1}}),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing StringToChars using d.update((("a", {"abcF" : Mapping({%s : 1})}),))
 d.update((("a", {"abcF" : Mapping({1 : 1})}),)):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-d.update((("a", {"abcF" : Mapping({b"\0" : 1})}),)):(<class 'ValueError'>, ValueError('embedded null byte',))
-d.update((("a", {"abcF" : Mapping({"\0" : 1})}),)):(<class 'ValueError'>, ValueError('embedded null byte',))
+d.update((("a", {"abcF" : Mapping({b"\0" : 1})}),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+d.update((("a", {"abcF" : Mapping({"\0" : 1})}),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing *Iter* using d.update((("a", {"abcF" : %s}),))
 d.update((("a", {"abcF" : FailingIter()}),)):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -769,18 +769,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 'ValueError'>, ValueError('embedded null byte',))
-d.update((("a", Mapping({"\0" : 1})),)):(<class 'ValueError'>, ValueError('embedded null byte',))
+d.update((("a", Mapping({b"\0" : 1})),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+d.update((("a", Mapping({"\0" : 1})),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing StringToChars using d.update((("a", Mapping({"abcG" : {%s : 1}})),))
 d.update((("a", Mapping({"abcG" : {1 : 1}})),)):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-d.update((("a", Mapping({"abcG" : {b"\0" : 1}})),)):(<class 'ValueError'>, ValueError('embedded null byte',))
-d.update((("a", Mapping({"abcG" : {"\0" : 1}})),)):(<class 'ValueError'>, ValueError('embedded null byte',))
+d.update((("a", Mapping({"abcG" : {b"\0" : 1}})),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+d.update((("a", Mapping({"abcG" : {"\0" : 1}})),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing StringToChars using d.update((("a", Mapping({"abcG" : Mapping({%s : 1})})),))
 d.update((("a", Mapping({"abcG" : Mapping({1 : 1})})),)):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-d.update((("a", Mapping({"abcG" : Mapping({b"\0" : 1})})),)):(<class 'ValueError'>, ValueError('embedded null byte',))
-d.update((("a", Mapping({"abcG" : Mapping({"\0" : 1})})),)):(<class 'ValueError'>, ValueError('embedded null byte',))
+d.update((("a", Mapping({"abcG" : Mapping({b"\0" : 1})})),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+d.update((("a", Mapping({"abcG" : Mapping({"\0" : 1})})),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing *Iter* using d.update((("a", Mapping({"abcG" : %s})),))
 d.update((("a", Mapping({"abcG" : FailingIter()})),)):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -820,18 +820,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 'ValueError'>, ValueError('embedded null byte',))
-vim.List([{"\0" : 1}]):(<class 'ValueError'>, ValueError('embedded null byte',))
+vim.List([{b"\0" : 1}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+vim.List([{"\0" : 1}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing StringToChars using vim.List([{"abcF" : {%s : 1}}])
 vim.List([{"abcF" : {1 : 1}}]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-vim.List([{"abcF" : {b"\0" : 1}}]):(<class 'ValueError'>, ValueError('embedded null byte',))
-vim.List([{"abcF" : {"\0" : 1}}]):(<class 'ValueError'>, ValueError('embedded null byte',))
+vim.List([{"abcF" : {b"\0" : 1}}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+vim.List([{"abcF" : {"\0" : 1}}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing StringToChars using vim.List([{"abcF" : Mapping({%s : 1})}])
 vim.List([{"abcF" : Mapping({1 : 1})}]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-vim.List([{"abcF" : Mapping({b"\0" : 1})}]):(<class 'ValueError'>, ValueError('embedded null byte',))
-vim.List([{"abcF" : Mapping({"\0" : 1})}]):(<class 'ValueError'>, ValueError('embedded null byte',))
+vim.List([{"abcF" : Mapping({b"\0" : 1})}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+vim.List([{"abcF" : Mapping({"\0" : 1})}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing *Iter* using vim.List([{"abcF" : %s}])
 vim.List([{"abcF" : FailingIter()}]):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -847,18 +847,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 'ValueError'>, ValueError('embedded null byte',))
-vim.List([Mapping({"\0" : 1})]):(<class 'ValueError'>, ValueError('embedded null byte',))
+vim.List([Mapping({b"\0" : 1})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+vim.List([Mapping({"\0" : 1})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing StringToChars using vim.List([Mapping({"abcG" : {%s : 1}})])
 vim.List([Mapping({"abcG" : {1 : 1}})]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-vim.List([Mapping({"abcG" : {b"\0" : 1}})]):(<class 'ValueError'>, ValueError('embedded null byte',))
-vim.List([Mapping({"abcG" : {"\0" : 1}})]):(<class 'ValueError'>, ValueError('embedded null byte',))
+vim.List([Mapping({"abcG" : {b"\0" : 1}})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+vim.List([Mapping({"abcG" : {"\0" : 1}})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing StringToChars using vim.List([Mapping({"abcG" : Mapping({%s : 1})})])
 vim.List([Mapping({"abcG" : Mapping({1 : 1})})]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-vim.List([Mapping({"abcG" : Mapping({b"\0" : 1})})]):(<class 'ValueError'>, ValueError('embedded null byte',))
-vim.List([Mapping({"abcG" : Mapping({"\0" : 1})})]):(<class 'ValueError'>, ValueError('embedded null byte',))
+vim.List([Mapping({"abcG" : Mapping({b"\0" : 1})})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+vim.List([Mapping({"abcG" : Mapping({"\0" : 1})})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing *Iter* using vim.List([Mapping({"abcG" : %s})])
 vim.List([Mapping({"abcG" : FailingIter()})]):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -905,18 +905,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 'ValueError'>, ValueError('embedded null byte',))
-l[:] = [{"\0" : 1}]:(<class 'ValueError'>, ValueError('embedded null byte',))
+l[:] = [{b"\0" : 1}]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
+l[:] = [{"\0" : 1}]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing StringToChars using l[:] = [{"abcF" : {%s : 1}}]
 l[:] = [{"abcF" : {1 : 1}}]:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-l[:] = [{"abcF" : {b"\0" : 1}}]:(<class 'ValueError'>, ValueError('embedded null byte',))
-l[:] = [{"abcF" : {"\0" : 1}}]:(<class 'ValueError'>, ValueError('embedded null byte',))
+l[:] = [{"abcF" : {b"\0" : 1}}]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
+l[:] = [{"abcF" : {"\0" : 1}}]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing StringToChars using l[:] = [{"abcF" : Mapping({%s : 1})}]
 l[:] = [{"abcF" : Mapping({1 : 1})}]:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-l[:] = [{"abcF" : Mapping({b"\0" : 1})}]:(<class 'ValueError'>, ValueError('embedded null byte',))
-l[:] = [{"abcF" : Mapping({"\0" : 1})}]:(<class 'ValueError'>, ValueError('embedded null byte',))
+l[:] = [{"abcF" : Mapping({b"\0" : 1})}]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
+l[:] = [{"abcF" : Mapping({"\0" : 1})}]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing *Iter* using l[:] = [{"abcF" : %s}]
 l[:] = [{"abcF" : FailingIter()}]:(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -932,18 +932,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 'ValueError'>, ValueError('embedded null byte',))
-l[:] = [Mapping({"\0" : 1})]:(<class 'ValueError'>, ValueError('embedded null byte',))
+l[:] = [Mapping({b"\0" : 1})]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
+l[:] = [Mapping({"\0" : 1})]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing StringToChars using l[:] = [Mapping({"abcG" : {%s : 1}})]
 l[:] = [Mapping({"abcG" : {1 : 1}})]:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-l[:] = [Mapping({"abcG" : {b"\0" : 1}})]:(<class 'ValueError'>, ValueError('embedded null byte',))
-l[:] = [Mapping({"abcG" : {"\0" : 1}})]:(<class 'ValueError'>, ValueError('embedded null byte',))
+l[:] = [Mapping({"abcG" : {b"\0" : 1}})]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
+l[:] = [Mapping({"abcG" : {"\0" : 1}})]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing StringToChars using l[:] = [Mapping({"abcG" : Mapping({%s : 1})})]
 l[:] = [Mapping({"abcG" : Mapping({1 : 1})})]:(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-l[:] = [Mapping({"abcG" : Mapping({b"\0" : 1})})]:(<class 'ValueError'>, ValueError('embedded null byte',))
-l[:] = [Mapping({"abcG" : Mapping({"\0" : 1})})]:(<class 'ValueError'>, ValueError('embedded null byte',))
+l[:] = [Mapping({"abcG" : Mapping({b"\0" : 1})})]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
+l[:] = [Mapping({"abcG" : Mapping({"\0" : 1})})]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing *Iter* using l[:] = [Mapping({"abcG" : %s})]
 l[:] = [Mapping({"abcG" : FailingIter()})]:(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -976,18 +976,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 'ValueError'>, ValueError('embedded null byte',))
-l.extend([{"\0" : 1}]):(<class 'ValueError'>, ValueError('embedded null byte',))
+l.extend([{b"\0" : 1}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+l.extend([{"\0" : 1}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing StringToChars using l.extend([{"abcF" : {%s : 1}}])
 l.extend([{"abcF" : {1 : 1}}]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-l.extend([{"abcF" : {b"\0" : 1}}]):(<class 'ValueError'>, ValueError('embedded null byte',))
-l.extend([{"abcF" : {"\0" : 1}}]):(<class 'ValueError'>, ValueError('embedded null byte',))
+l.extend([{"abcF" : {b"\0" : 1}}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+l.extend([{"abcF" : {"\0" : 1}}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing StringToChars using l.extend([{"abcF" : Mapping({%s : 1})}])
 l.extend([{"abcF" : Mapping({1 : 1})}]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-l.extend([{"abcF" : Mapping({b"\0" : 1})}]):(<class 'ValueError'>, ValueError('embedded null byte',))
-l.extend([{"abcF" : Mapping({"\0" : 1})}]):(<class 'ValueError'>, ValueError('embedded null byte',))
+l.extend([{"abcF" : Mapping({b"\0" : 1})}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+l.extend([{"abcF" : Mapping({"\0" : 1})}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing *Iter* using l.extend([{"abcF" : %s}])
 l.extend([{"abcF" : FailingIter()}]):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -1003,18 +1003,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 'ValueError'>, ValueError('embedded null byte',))
-l.extend([Mapping({"\0" : 1})]):(<class 'ValueError'>, ValueError('embedded null byte',))
+l.extend([Mapping({b"\0" : 1})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+l.extend([Mapping({"\0" : 1})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing StringToChars using l.extend([Mapping({"abcG" : {%s : 1}})])
 l.extend([Mapping({"abcG" : {1 : 1}})]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-l.extend([Mapping({"abcG" : {b"\0" : 1}})]):(<class 'ValueError'>, ValueError('embedded null byte',))
-l.extend([Mapping({"abcG" : {"\0" : 1}})]):(<class 'ValueError'>, ValueError('embedded null byte',))
+l.extend([Mapping({"abcG" : {b"\0" : 1}})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+l.extend([Mapping({"abcG" : {"\0" : 1}})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing StringToChars using l.extend([Mapping({"abcG" : Mapping({%s : 1})})])
 l.extend([Mapping({"abcG" : Mapping({1 : 1})})]):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-l.extend([Mapping({"abcG" : Mapping({b"\0" : 1})})]):(<class 'ValueError'>, ValueError('embedded null byte',))
-l.extend([Mapping({"abcG" : Mapping({"\0" : 1})})]):(<class 'ValueError'>, ValueError('embedded null byte',))
+l.extend([Mapping({"abcG" : Mapping({b"\0" : 1})})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+l.extend([Mapping({"abcG" : Mapping({"\0" : 1})})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing *Iter* using l.extend([Mapping({"abcG" : %s})])
 l.extend([Mapping({"abcG" : FailingIter()})]):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -1052,18 +1052,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 'ValueError'>, ValueError('embedded null byte',))
-f({"\0" : 1}):(<class 'ValueError'>, ValueError('embedded null byte',))
+f({b"\0" : 1}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+f({"\0" : 1}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing StringToChars using f({"abcF" : {%s : 1}})
 f({"abcF" : {1 : 1}}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-f({"abcF" : {b"\0" : 1}}):(<class 'ValueError'>, ValueError('embedded null byte',))
-f({"abcF" : {"\0" : 1}}):(<class 'ValueError'>, ValueError('embedded null byte',))
+f({"abcF" : {b"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+f({"abcF" : {"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing StringToChars using f({"abcF" : Mapping({%s : 1})})
 f({"abcF" : Mapping({1 : 1})}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-f({"abcF" : Mapping({b"\0" : 1})}):(<class 'ValueError'>, ValueError('embedded null byte',))
-f({"abcF" : Mapping({"\0" : 1})}):(<class 'ValueError'>, ValueError('embedded null byte',))
+f({"abcF" : Mapping({b"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+f({"abcF" : Mapping({"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing *Iter* using f({"abcF" : %s})
 f({"abcF" : FailingIter()}):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -1079,18 +1079,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 'ValueError'>, ValueError('embedded null byte',))
-f(Mapping({"\0" : 1})):(<class 'ValueError'>, ValueError('embedded null byte',))
+f(Mapping({b"\0" : 1})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+f(Mapping({"\0" : 1})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing StringToChars using f(Mapping({"abcG" : {%s : 1}}))
 f(Mapping({"abcG" : {1 : 1}})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-f(Mapping({"abcG" : {b"\0" : 1}})):(<class 'ValueError'>, ValueError('embedded null byte',))
-f(Mapping({"abcG" : {"\0" : 1}})):(<class 'ValueError'>, ValueError('embedded null byte',))
+f(Mapping({"abcG" : {b"\0" : 1}})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+f(Mapping({"abcG" : {"\0" : 1}})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing StringToChars using f(Mapping({"abcG" : Mapping({%s : 1})}))
 f(Mapping({"abcG" : Mapping({1 : 1})})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-f(Mapping({"abcG" : Mapping({b"\0" : 1})})):(<class 'ValueError'>, ValueError('embedded null byte',))
-f(Mapping({"abcG" : Mapping({"\0" : 1})})):(<class 'ValueError'>, ValueError('embedded null byte',))
+f(Mapping({"abcG" : Mapping({b"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+f(Mapping({"abcG" : Mapping({"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing *Iter* using f(Mapping({"abcG" : %s}))
 f(Mapping({"abcG" : FailingIter()})):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -1118,18 +1118,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 'ValueError'>, ValueError('embedded null byte',))
-fd(self={"\0" : 1}):(<class 'ValueError'>, ValueError('embedded null byte',))
+fd(self={b"\0" : 1}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+fd(self={"\0" : 1}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing StringToChars using fd(self={"abcF" : {%s : 1}})
 fd(self={"abcF" : {1 : 1}}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-fd(self={"abcF" : {b"\0" : 1}}):(<class 'ValueError'>, ValueError('embedded null byte',))
-fd(self={"abcF" : {"\0" : 1}}):(<class 'ValueError'>, ValueError('embedded null byte',))
+fd(self={"abcF" : {b"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+fd(self={"abcF" : {"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing StringToChars using fd(self={"abcF" : Mapping({%s : 1})})
 fd(self={"abcF" : Mapping({1 : 1})}):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-fd(self={"abcF" : Mapping({b"\0" : 1})}):(<class 'ValueError'>, ValueError('embedded null byte',))
-fd(self={"abcF" : Mapping({"\0" : 1})}):(<class 'ValueError'>, ValueError('embedded null byte',))
+fd(self={"abcF" : Mapping({b"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+fd(self={"abcF" : Mapping({"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing *Iter* using fd(self={"abcF" : %s})
 fd(self={"abcF" : FailingIter()}):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))
@@ -1145,18 +1145,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 'ValueError'>, ValueError('embedded null byte',))
-fd(self=Mapping({"\0" : 1})):(<class 'ValueError'>, ValueError('embedded null byte',))
+fd(self=Mapping({b"\0" : 1})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+fd(self=Mapping({"\0" : 1})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing StringToChars using fd(self=Mapping({"abcG" : {%s : 1}}))
 fd(self=Mapping({"abcG" : {1 : 1}})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-fd(self=Mapping({"abcG" : {b"\0" : 1}})):(<class 'ValueError'>, ValueError('embedded null byte',))
-fd(self=Mapping({"abcG" : {"\0" : 1}})):(<class 'ValueError'>, ValueError('embedded null byte',))
+fd(self=Mapping({"abcG" : {b"\0" : 1}})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+fd(self=Mapping({"abcG" : {"\0" : 1}})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing StringToChars using fd(self=Mapping({"abcG" : Mapping({%s : 1})}))
 fd(self=Mapping({"abcG" : Mapping({1 : 1})})):(<class 'TypeError'>, TypeError('expected bytes() or str() instance, but got int',))
-fd(self=Mapping({"abcG" : Mapping({b"\0" : 1})})):(<class 'ValueError'>, ValueError('embedded null byte',))
-fd(self=Mapping({"abcG" : Mapping({"\0" : 1})})):(<class 'ValueError'>, ValueError('embedded null byte',))
+fd(self=Mapping({"abcG" : Mapping({b"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+fd(self=Mapping({"abcG" : Mapping({"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
 <<< Finished
 >>> Testing *Iter* using fd(self=Mapping({"abcG" : %s}))
 fd(self=Mapping({"abcG" : FailingIter()})):(<class 'TypeError'>, TypeError('unable to convert FailingIter to vim structure',))