Mercurial > vim

changeset 4663:bce2051173f0 v7.3.1079

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
updated for version 7.3.1079 Problem: Test 87 fails. Solution: Fix the test for Python 3.3. (ZyX) Make it pass on 32 bit systems.
author Bram Moolenaar <bram@vim.org>
date Fri, 31 May 2013 18:46:11 +0200
parents b792349dc858
children 662b09d15612
files src/testdir/test87.in src/testdir/test87.ok src/version.c
diffstat 3 files changed, 70 insertions(+), 67 deletions(-) [+]
line wrap: on
line diff
--- a/src/testdir/test87.in
+++ b/src/testdir/test87.in
@@ -2,8 +2,6 @@ Tests for various python features.     v
 
 STARTTEST
 :so small.vim
-:" HACK: currently crashes, skip the test
-:e! test.ok | wq! test.out
 :if !has('python3') | e! test.ok | wq! test.out | endif
 :lang C
 :py3 import vim
@@ -710,10 +708,10 @@ EOF
 :"
 :" 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'))
+: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'))
 :redir END
 :$put =string(substitute(messages, '\d\+', '', 'g'))
 :" Test subclassing
@@ -759,7 +757,10 @@ def ee(expr, g=globals(), l=locals()):
         try:
             exec(expr, g, l)
         except Exception as e:
-            cb.append(expr + ':' + repr((e.__class__, e)))
+            if sys.version_info >= (3, 3) and e.__class__ is AttributeError and str(e).find('has no attribute')>=0 and not str(e).startswith("'vim."):
+                cb.append(expr + ':' + repr((e.__class__, AttributeError(str(e)[str(e).rfind(" '") + 2:-1]))))
+            else:
+                cb.append(expr + ':' + repr((e.__class__, e)))
         else:
             cb.append(expr + ':NOT FAILED')
     except Exception as e:
@@ -786,8 +787,8 @@ def subexpr_test(expr, name, subexprs):
 def stringtochars_test(expr):
     return subexpr_test(expr, 'StringToChars', (
         '1',       # Fail type checks
-        'u"\\0"',  # Fail PyString_AsStringAndSize(bytes, , NULL) check
-        '"\\0"',   # Fail PyString_AsStringAndSize(object, , NULL) check
+        'b"\\0"',  # Fail PyString_AsStringAndSize(object, , NULL) check
+        '"\\0"',   # Fail PyString_AsStringAndSize(bytes, , NULL) check
     ))
 
 class Mapping(object):
@@ -968,7 +969,7 @@ cb.append(">> WindowAttr")
 ee('vim.current.window.xxx')
 cb.append(">> WindowSetattr")
 ee('vim.current.window.buffer = 0')
-ee('vim.current.window.cursor = (10000000000, 100000000)')
+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"')
@@ -989,9 +990,9 @@ ee('vim.current.buffer.append(None)')
 ee('vim.current.buffer.append(["\\na", "bc"])')
 ee('vim.current.buffer.append("\\nbc")')
 cb.append(">> RBItem")
-ee('vim.current.buffer[10000000000]')
+ee('vim.current.buffer[100000000]')
 cb.append(">> RBAsItem")
-ee('vim.current.buffer[10000000000] = ""')
+ee('vim.current.buffer[100000000] = ""')
 cb.append(">> BufferAttr")
 ee('vim.current.buffer.xxx')
 cb.append(">> BufferSetattr")
--- a/src/testdir/test87.ok
+++ b/src/testdir/test87.ok
@@ -454,7 +454,7 @@ d.xxx = True:(<class 'AttributeError'>, 
 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('object must be string',))
-d.get(u"\0"):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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',))
@@ -465,22 +465,22 @@ for i in ned: ned["a"] = 1:(<class 'Runt
 dl["b"] = 1:(<class 'vim.error'>, error('dict is locked',))
 >>> Testing StringToChars using d[%s] = 1
 d[1] = 1:(<class 'TypeError'>, TypeError('object must be string',))
-d[u"\0"] = 1:(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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('object must be string',))
-d["a"] = {u"\0" : 1}:(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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('object must be string',))
-d["a"] = {"abc" : {u"\0" : 1}}:(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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',))
 <<< Finished
 >>> Testing StringToChars using d["a"] = {"abc" : Mapping({%s : 1})}
 d["a"] = {"abc" : Mapping({1 : 1})}:(<class 'TypeError'>, TypeError('object must be string',))
-d["a"] = {"abc" : Mapping({u"\0" : 1})}:(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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',))
 <<< Finished
 >>> Testing *Iter* using d["a"] = {"abc" : %s}
@@ -495,17 +495,17 @@ d["a"] = {"abc" : FailingMappingKey()}:(
 <<< Finished
 >>> Testing StringToChars using d["a"] = Mapping({%s : 1})
 d["a"] = Mapping({1 : 1}):(<class 'TypeError'>, TypeError('object must be string',))
-d["a"] = Mapping({u"\0" : 1}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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('object must be string',))
-d["a"] = Mapping({"abc" : {u"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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',))
 <<< Finished
 >>> Testing StringToChars using d["a"] = Mapping({"abc" : Mapping({%s : 1})})
 d["a"] = Mapping({"abc" : Mapping({1 : 1})}):(<class 'TypeError'>, TypeError('object must be string',))
-d["a"] = Mapping({"abc" : Mapping({u"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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',))
 <<< Finished
 >>> Testing *Iter* using d["a"] = Mapping({"abc" : %s})
@@ -539,17 +539,17 @@ d.update(FailingIterNext()):(<class 'Not
 <<< Finished
 >>> Testing StringToChars using d.update({%s : 1})
 d.update({1 : 1}):(<class 'TypeError'>, TypeError('object must be string',))
-d.update({u"\0" : 1}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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('object must be string',))
-d.update({"abc" : {u"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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',))
 <<< Finished
 >>> Testing StringToChars using d.update({"abc" : Mapping({%s : 1})})
 d.update({"abc" : Mapping({1 : 1})}):(<class 'TypeError'>, TypeError('object must be string',))
-d.update({"abc" : Mapping({u"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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',))
 <<< Finished
 >>> Testing *Iter* using d.update({"abc" : %s})
@@ -564,17 +564,17 @@ d.update({"abc" : FailingMappingKey()}):
 <<< Finished
 >>> Testing StringToChars using d.update(Mapping({%s : 1}))
 d.update(Mapping({1 : 1})):(<class 'TypeError'>, TypeError('object must be string',))
-d.update(Mapping({u"\0" : 1})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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('object must be string',))
-d.update(Mapping({"abc" : {u"\0" : 1}})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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',))
 <<< Finished
 >>> Testing StringToChars using d.update(Mapping({"abc" : Mapping({%s : 1})}))
 d.update(Mapping({"abc" : Mapping({1 : 1})})):(<class 'TypeError'>, TypeError('object must be string',))
-d.update(Mapping({"abc" : Mapping({u"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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',))
 <<< Finished
 >>> Testing *Iter* using d.update(Mapping({"abc" : %s}))
@@ -599,22 +599,22 @@ d.update(FailingMappingKey()):(<class 'N
 <<< Finished
 >>> Testing StringToChars using d.update(((%s, 0),))
 d.update(((1, 0),)):(<class 'TypeError'>, TypeError('object must be string',))
-d.update(((u"\0", 0),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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('object must be string',))
-d.update((("a", {u"\0" : 1}),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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('object must be string',))
-d.update((("a", {"abc" : {u"\0" : 1}}),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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',))
 <<< Finished
 >>> Testing StringToChars using d.update((("a", {"abc" : Mapping({%s : 1})}),))
 d.update((("a", {"abc" : Mapping({1 : 1})}),)):(<class 'TypeError'>, TypeError('object must be string',))
-d.update((("a", {"abc" : Mapping({u"\0" : 1})}),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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',))
 <<< Finished
 >>> Testing *Iter* using d.update((("a", {"abc" : %s}),))
@@ -629,17 +629,17 @@ d.update((("a", {"abc" : FailingMappingK
 <<< Finished
 >>> Testing StringToChars using d.update((("a", Mapping({%s : 1})),))
 d.update((("a", Mapping({1 : 1})),)):(<class 'TypeError'>, TypeError('object must be string',))
-d.update((("a", Mapping({u"\0" : 1})),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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('object must be string',))
-d.update((("a", Mapping({"abc" : {u"\0" : 1}})),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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',))
 <<< Finished
 >>> Testing StringToChars using d.update((("a", Mapping({"abc" : Mapping({%s : 1})})),))
 d.update((("a", Mapping({"abc" : Mapping({1 : 1})})),)):(<class 'TypeError'>, TypeError('object must be string',))
-d.update((("a", Mapping({"abc" : Mapping({u"\0" : 1})})),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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',))
 <<< Finished
 >>> Testing *Iter* using d.update((("a", Mapping({"abc" : %s})),))
@@ -676,17 +676,17 @@ vim.List(FailingIterNext()):(<class 'Not
 <<< Finished
 >>> Testing StringToChars using vim.List([{%s : 1}])
 vim.List([{1 : 1}]):(<class 'TypeError'>, TypeError('object must be string',))
-vim.List([{u"\0" : 1}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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('object must be string',))
-vim.List([{"abc" : {u"\0" : 1}}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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',))
 <<< Finished
 >>> Testing StringToChars using vim.List([{"abc" : Mapping({%s : 1})}])
 vim.List([{"abc" : Mapping({1 : 1})}]):(<class 'TypeError'>, TypeError('object must be string',))
-vim.List([{"abc" : Mapping({u"\0" : 1})}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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',))
 <<< Finished
 >>> Testing *Iter* using vim.List([{"abc" : %s}])
@@ -701,17 +701,17 @@ vim.List([{"abc" : FailingMappingKey()}]
 <<< Finished
 >>> Testing StringToChars using vim.List([Mapping({%s : 1})])
 vim.List([Mapping({1 : 1})]):(<class 'TypeError'>, TypeError('object must be string',))
-vim.List([Mapping({u"\0" : 1})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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('object must be string',))
-vim.List([Mapping({"abc" : {u"\0" : 1}})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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',))
 <<< Finished
 >>> Testing StringToChars using vim.List([Mapping({"abc" : Mapping({%s : 1})})])
 vim.List([Mapping({"abc" : Mapping({1 : 1})})]):(<class 'TypeError'>, TypeError('object must be string',))
-vim.List([Mapping({"abc" : Mapping({u"\0" : 1})})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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',))
 <<< Finished
 >>> Testing *Iter* using vim.List([Mapping({"abc" : %s})])
@@ -747,17 +747,17 @@ l[:] = FailingIterNext()::(<class 'NotIm
 <<< Finished
 >>> Testing StringToChars using l[:] = [{%s : 1}]
 l[:] = [{1 : 1}]:(<class 'TypeError'>, TypeError('object must be string',))
-l[:] = [{u"\0" : 1}]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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('object must be string',))
-l[:] = [{"abc" : {u"\0" : 1}}]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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',))
 <<< Finished
 >>> Testing StringToChars using l[:] = [{"abc" : Mapping({%s : 1})}]
 l[:] = [{"abc" : Mapping({1 : 1})}]:(<class 'TypeError'>, TypeError('object must be string',))
-l[:] = [{"abc" : Mapping({u"\0" : 1})}]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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',))
 <<< Finished
 >>> Testing *Iter* using l[:] = [{"abc" : %s}]
@@ -772,17 +772,17 @@ l[:] = [{"abc" : FailingMappingKey()}]:(
 <<< Finished
 >>> Testing StringToChars using l[:] = [Mapping({%s : 1})]
 l[:] = [Mapping({1 : 1})]:(<class 'TypeError'>, TypeError('object must be string',))
-l[:] = [Mapping({u"\0" : 1})]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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('object must be string',))
-l[:] = [Mapping({"abc" : {u"\0" : 1}})]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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',))
 <<< Finished
 >>> Testing StringToChars using l[:] = [Mapping({"abc" : Mapping({%s : 1})})]
 l[:] = [Mapping({"abc" : Mapping({1 : 1})})]:(<class 'TypeError'>, TypeError('object must be string',))
-l[:] = [Mapping({"abc" : Mapping({u"\0" : 1})})]:(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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',))
 <<< Finished
 >>> Testing *Iter* using l[:] = [Mapping({"abc" : %s})]
@@ -812,17 +812,17 @@ l.extend(FailingIterNext()):(<class 'Not
 <<< Finished
 >>> Testing StringToChars using l.extend([{%s : 1}])
 l.extend([{1 : 1}]):(<class 'TypeError'>, TypeError('object must be string',))
-l.extend([{u"\0" : 1}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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('object must be string',))
-l.extend([{"abc" : {u"\0" : 1}}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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',))
 <<< Finished
 >>> Testing StringToChars using l.extend([{"abc" : Mapping({%s : 1})}])
 l.extend([{"abc" : Mapping({1 : 1})}]):(<class 'TypeError'>, TypeError('object must be string',))
-l.extend([{"abc" : Mapping({u"\0" : 1})}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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',))
 <<< Finished
 >>> Testing *Iter* using l.extend([{"abc" : %s}])
@@ -837,17 +837,17 @@ l.extend([{"abc" : FailingMappingKey()}]
 <<< Finished
 >>> Testing StringToChars using l.extend([Mapping({%s : 1})])
 l.extend([Mapping({1 : 1})]):(<class 'TypeError'>, TypeError('object must be string',))
-l.extend([Mapping({u"\0" : 1})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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('object must be string',))
-l.extend([Mapping({"abc" : {u"\0" : 1}})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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',))
 <<< Finished
 >>> Testing StringToChars using l.extend([Mapping({"abc" : Mapping({%s : 1})})])
 l.extend([Mapping({"abc" : Mapping({1 : 1})})]):(<class 'TypeError'>, TypeError('object must be string',))
-l.extend([Mapping({"abc" : Mapping({u"\0" : 1})})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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',))
 <<< Finished
 >>> Testing *Iter* using l.extend([Mapping({"abc" : %s})])
@@ -882,17 +882,17 @@ vim.Function("xxx#non#existent#function#
 >> FunctionCall
 >>> Testing StringToChars using f({%s : 1})
 f({1 : 1}):(<class 'TypeError'>, TypeError('object must be string',))
-f({u"\0" : 1}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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('object must be string',))
-f({"abc" : {u"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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',))
 <<< Finished
 >>> Testing StringToChars using f({"abc" : Mapping({%s : 1})})
 f({"abc" : Mapping({1 : 1})}):(<class 'TypeError'>, TypeError('object must be string',))
-f({"abc" : Mapping({u"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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',))
 <<< Finished
 >>> Testing *Iter* using f({"abc" : %s})
@@ -907,17 +907,17 @@ f({"abc" : FailingMappingKey()}):(<class
 <<< Finished
 >>> Testing StringToChars using f(Mapping({%s : 1}))
 f(Mapping({1 : 1})):(<class 'TypeError'>, TypeError('object must be string',))
-f(Mapping({u"\0" : 1})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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('object must be string',))
-f(Mapping({"abc" : {u"\0" : 1}})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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',))
 <<< Finished
 >>> Testing StringToChars using f(Mapping({"abc" : Mapping({%s : 1})}))
 f(Mapping({"abc" : Mapping({1 : 1})})):(<class 'TypeError'>, TypeError('object must be string',))
-f(Mapping({"abc" : Mapping({u"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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',))
 <<< Finished
 >>> Testing *Iter* using f(Mapping({"abc" : %s}))
@@ -942,17 +942,17 @@ f(FailingMappingKey()):(<class 'NotImple
 <<< Finished
 >>> Testing StringToChars using fd(self={%s : 1})
 fd(self={1 : 1}):(<class 'TypeError'>, TypeError('object must be string',))
-fd(self={u"\0" : 1}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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('object must be string',))
-fd(self={"abc" : {u"\0" : 1}}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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',))
 <<< Finished
 >>> Testing StringToChars using fd(self={"abc" : Mapping({%s : 1})})
 fd(self={"abc" : Mapping({1 : 1})}):(<class 'TypeError'>, TypeError('object must be string',))
-fd(self={"abc" : Mapping({u"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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',))
 <<< Finished
 >>> Testing *Iter* using fd(self={"abc" : %s})
@@ -967,17 +967,17 @@ fd(self={"abc" : FailingMappingKey()}):(
 <<< Finished
 >>> Testing StringToChars using fd(self=Mapping({%s : 1}))
 fd(self=Mapping({1 : 1})):(<class 'TypeError'>, TypeError('object must be string',))
-fd(self=Mapping({u"\0" : 1})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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('object must be string',))
-fd(self=Mapping({"abc" : {u"\0" : 1}})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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',))
 <<< Finished
 >>> Testing StringToChars using fd(self=Mapping({"abc" : Mapping({%s : 1})}))
 fd(self=Mapping({"abc" : Mapping({1 : 1})})):(<class 'TypeError'>, TypeError('object must be string',))
-fd(self=Mapping({"abc" : Mapping({u"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))
+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',))
 <<< Finished
 >>> Testing *Iter* using fd(self=Mapping({"abc" : %s}))
@@ -1001,7 +1001,7 @@ fd(self=FailingMapping()):(<class 'NotIm
 fd(self=FailingMappingKey()):(<class 'NotImplementedError'>, NotImplementedError())
 <<< Finished
 >>> Testing ConvertFromPyMapping using fd(self=%s)
-fd(self=[]):(<class 'AttributeError'>, AttributeError("'list' object has no attribute 'keys'",))
+fd(self=[]):(<class 'AttributeError'>, AttributeError('keys',))
 <<< Finished
 > TabPage
 >> TabPageAttr
@@ -1014,7 +1014,7 @@ vim.tabpages[1000]:(<class 'IndexError'>
 vim.current.window.xxx:(<class 'AttributeError'>, AttributeError("'vim.window' object has no attribute 'xxx'",))
 >> WindowSetattr
 vim.current.window.buffer = 0:(<class 'TypeError'>, TypeError('readonly attribute',))
-vim.current.window.cursor = (10000000000, 100000000):(<class 'vim.error'>, error('cursor position outside 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('an integer is required',))
 vim.current.window.width  = "abc":(<class 'TypeError'>, TypeError('an integer is required',))
@@ -1035,9 +1035,9 @@ vim.current.buffer.append(None):(<class 
 vim.current.buffer.append(["\na", "bc"]):(<class 'vim.error'>, error('string cannot contain newlines',))
 vim.current.buffer.append("\nbc"):(<class 'vim.error'>, error('string cannot contain newlines',))
 >> RBItem
-vim.current.buffer[10000000000]:(<class 'IndexError'>, IndexError('line number out of range',))
+vim.current.buffer[100000000]:(<class 'IndexError'>, IndexError('line number out of range',))
 >> RBAsItem
-vim.current.buffer[10000000000] = "":(<class 'IndexError'>, IndexError('line number out of range',))
+vim.current.buffer[100000000] = "":(<class 'IndexError'>, IndexError('line number out of range',))
 >> BufferAttr
 vim.current.buffer.xxx:(<class 'AttributeError'>, AttributeError("'vim.buffer' object has no attribute 'xxx'",))
 >> BufferSetattr
--- a/src/version.c
+++ b/src/version.c
@@ -729,6 +729,8 @@ static char *(features[]) =
 static int included_patches[] =
 {   /* Add new patch number below this line */
 /**/
+    1079,
+/**/
     1078,
 /**/
     1077,