To: vim_dev@googlegroups.com

Subject: Patch 7.3.1079

Fcc: outbox

From: Bram Moolenaar <Bram@moolenaar.net>

Mime-Version: 1.0

Content-Type: text/plain; charset=UTF-8

Content-Transfer-Encoding: 8bit

------------

Patch 7.3.1079

Problem:    Test 87 fails.

Solution:   Fix the test for Python 3.3. (ZyX)  Make it pass on 32 bit systems.

Files:	    src/testdir/test87.in, src/testdir/test87.ok

*** ../vim-7.3.1078/src/testdir/test87.in	2013-05-30 15:38:20.000000000 +0200

--- src/testdir/test87.in	2013-05-31 18:40:40.000000000 +0200

***************

*** 2,9 ****

  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

--- 2,7 ----

***************

*** 710,719 ****

  :"

  :" 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'))

  :redir END

  :$put =string(substitute(messages, '\d\+', '', 'g'))

  :" Test subclassing

--- 708,717 ----

  :"

  :" Test stdout/stderr

  :redir => messages

! :py3 sys.stdout.write('abc') ; sys.stdout.write('def')

! :py3 sys.stderr.write('abc') ; sys.stderr.write('def')

! :py3 sys.stdout.writelines(iter('abc'))

! :py3 sys.stderr.writelines(iter('abc'))

  :redir END

  :$put =string(substitute(messages, '\d\+', '', 'g'))

  :" Test subclassing

***************

*** 759,765 ****

          try:

              exec(expr, g, l)

          except Exception as e:

!             cb.append(expr + ':' + repr((e.__class__, e)))

          else:

              cb.append(expr + ':NOT FAILED')

      except Exception as e:

--- 757,766 ----

          try:

              exec(expr, g, l)

          except Exception as 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,793 ****

  def stringtochars_test(expr):

      return subexpr_test(expr, 'StringToChars', (

          '1',       # Fail type checks

!         'u"\\0"',  # Fail PyString_AsStringAndSize(bytes, , NULL) check

!         '"\\0"',   # Fail PyString_AsStringAndSize(object, , NULL) check

      ))

  class Mapping(object):

--- 787,794 ----

  def stringtochars_test(expr):

      return subexpr_test(expr, 'StringToChars', (

          '1',       # Fail type checks

!         'b"\\0"',  # Fail PyString_AsStringAndSize(object, , NULL) check

!         '"\\0"',   # Fail PyString_AsStringAndSize(bytes, , NULL) check

      ))

  class Mapping(object):

***************

*** 968,974 ****

  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 = True')

  ee('vim.current.window.height = "abc"')

  ee('vim.current.window.width  = "abc"')

--- 969,975 ----

  ee('vim.current.window.xxx')

  cb.append(">> WindowSetattr")

  ee('vim.current.window.buffer = 0')

! ee('vim.current.window.cursor = (100000000, 100000000)')

  ee('vim.current.window.cursor = True')

  ee('vim.current.window.height = "abc"')

  ee('vim.current.window.width  = "abc"')

***************

*** 989,997 ****

  ee('vim.current.buffer.append(["\\na", "bc"])')

  ee('vim.current.buffer.append("\\nbc")')

  cb.append(">> RBItem")

! ee('vim.current.buffer[10000000000]')

  cb.append(">> RBAsItem")

! ee('vim.current.buffer[10000000000] = ""')

  cb.append(">> BufferAttr")

  ee('vim.current.buffer.xxx')

  cb.append(">> BufferSetattr")

--- 990,998 ----

  ee('vim.current.buffer.append(["\\na", "bc"])')

  ee('vim.current.buffer.append("\\nbc")')

  cb.append(">> RBItem")

! ee('vim.current.buffer[100000000]')

  cb.append(">> RBAsItem")

! ee('vim.current.buffer[100000000] = ""')

  cb.append(">> BufferAttr")

  ee('vim.current.buffer.xxx')

  cb.append(">> BufferSetattr")

*** ../vim-7.3.1078/src/testdir/test87.ok	2013-05-30 13:37:23.000000000 +0200

--- src/testdir/test87.ok	2013-05-31 18:41:15.000000000 +0200

***************

*** 454,460 ****

  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("\0"):(<class 'TypeError'>, TypeError('expected bytes with no null',))

  <<< Finished

  d.pop("a"):(<class 'KeyError'>, KeyError('a',))

--- 454,460 ----

  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(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,486 ****

  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["\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"] = {"\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" : {"\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({"\0" : 1})}:(<class 'TypeError'>, TypeError('expected bytes with no null',))

  <<< Finished

  >>> Testing *Iter* using d["a"] = {"abc" : %s}

--- 465,486 ----

  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[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"] = {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" : {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({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,511 ****

  <<< 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({"\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" : {"\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({"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))

  <<< Finished

  >>> Testing *Iter* using d["a"] = Mapping({"abc" : %s})

--- 495,511 ----

  <<< Finished

  >>> Testing StringToChars using d["a"] = Mapping({%s : 1})

  d["a"] = Mapping({1 : 1}):(<class 'TypeError'>, TypeError('object must be string',))

! 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" : {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({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,555 ****

  <<< 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({"\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" : {"\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({"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))

  <<< Finished

  >>> Testing *Iter* using d.update({"abc" : %s})

--- 539,555 ----

  <<< Finished

  >>> Testing StringToChars using d.update({%s : 1})

  d.update({1 : 1}):(<class 'TypeError'>, TypeError('object must be string',))

! 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" : {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({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,580 ****

  <<< 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({"\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" : {"\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({"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))

  <<< Finished

  >>> Testing *Iter* using d.update(Mapping({"abc" : %s}))

--- 564,580 ----

  <<< Finished

  >>> Testing StringToChars using d.update(Mapping({%s : 1}))

  d.update(Mapping({1 : 1})):(<class 'TypeError'>, TypeError('object must be string',))

! 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" : {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({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,620 ****

  <<< 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((("\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", {"\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" : {"\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({"\0" : 1})}),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))

  <<< Finished

  >>> Testing *Iter* using d.update((("a", {"abc" : %s}),))

--- 599,620 ----

  <<< Finished

  >>> Testing StringToChars using d.update(((%s, 0),))

  d.update(((1, 0),)):(<class 'TypeError'>, TypeError('object must be string',))

! 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", {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" : {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({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,645 ****

  <<< 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({"\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" : {"\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({"\0" : 1})})),)):(<class 'TypeError'>, TypeError('expected bytes with no null',))

  <<< Finished

  >>> Testing *Iter* using d.update((("a", Mapping({"abc" : %s})),))

--- 629,645 ----

  <<< 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({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" : {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({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,692 ****

  <<< 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([{"\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" : {"\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({"\0" : 1})}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))

  <<< Finished

  >>> Testing *Iter* using vim.List([{"abc" : %s}])

--- 676,692 ----

  <<< Finished

  >>> Testing StringToChars using vim.List([{%s : 1}])

  vim.List([{1 : 1}]):(<class 'TypeError'>, TypeError('object must be string',))

! 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" : {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({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,717 ****

  <<< 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({"\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" : {"\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({"\0" : 1})})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))

  <<< Finished

  >>> Testing *Iter* using vim.List([Mapping({"abc" : %s})])

--- 701,717 ----

  <<< Finished

  >>> Testing StringToChars using vim.List([Mapping({%s : 1})])

  vim.List([Mapping({1 : 1})]):(<class 'TypeError'>, TypeError('object must be string',))

! 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" : {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({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,763 ****

  <<< 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[:] = [{"\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" : {"\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({"\0" : 1})}]:(<class 'TypeError'>, TypeError('expected bytes with no null',))

  <<< Finished

  >>> Testing *Iter* using l[:] = [{"abc" : %s}]

--- 747,763 ----

  <<< Finished

  >>> Testing StringToChars using l[:] = [{%s : 1}]

  l[:] = [{1 : 1}]:(<class 'TypeError'>, TypeError('object must be string',))

! 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" : {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({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,788 ****

  <<< 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({"\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" : {"\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({"\0" : 1})})]:(<class 'TypeError'>, TypeError('expected bytes with no null',))

  <<< Finished

  >>> Testing *Iter* using l[:] = [Mapping({"abc" : %s})]

--- 772,788 ----

  <<< Finished

  >>> Testing StringToChars using l[:] = [Mapping({%s : 1})]

  l[:] = [Mapping({1 : 1})]:(<class 'TypeError'>, TypeError('object must be string',))

! 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" : {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({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,828 ****

  <<< 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([{"\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" : {"\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({"\0" : 1})}]):(<class 'TypeError'>, TypeError('expected bytes with no null',))

  <<< Finished

  >>> Testing *Iter* using l.extend([{"abc" : %s}])

--- 812,828 ----

  <<< Finished

  >>> Testing StringToChars using l.extend([{%s : 1}])

  l.extend([{1 : 1}]):(<class 'TypeError'>, TypeError('object must be string',))

! 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" : {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({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,853 ****

  <<< 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({"\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" : {"\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({"\0" : 1})})]):(<class 'TypeError'>, TypeError('expected bytes with no null',))

  <<< Finished

  >>> Testing *Iter* using l.extend([Mapping({"abc" : %s})])

--- 837,853 ----

  <<< Finished

  >>> Testing StringToChars using l.extend([Mapping({%s : 1})])

  l.extend([Mapping({1 : 1})]):(<class 'TypeError'>, TypeError('object must be string',))

! 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" : {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({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,898 ****

  >> 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({"\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" : {"\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({"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))

  <<< Finished

  >>> Testing *Iter* using f({"abc" : %s})

--- 882,898 ----

  >> FunctionCall

  >>> Testing StringToChars using f({%s : 1})

  f({1 : 1}):(<class 'TypeError'>, TypeError('object must be string',))

! 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" : {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({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,923 ****

  <<< 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({"\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" : {"\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({"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))

  <<< Finished

  >>> Testing *Iter* using f(Mapping({"abc" : %s}))

--- 907,923 ----

  <<< Finished

  >>> Testing StringToChars using f(Mapping({%s : 1}))

  f(Mapping({1 : 1})):(<class 'TypeError'>, TypeError('object must be string',))

! 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" : {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({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,958 ****

  <<< 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={"\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" : {"\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({"\0" : 1})}):(<class 'TypeError'>, TypeError('expected bytes with no null',))

  <<< Finished

  >>> Testing *Iter* using fd(self={"abc" : %s})

--- 942,958 ----

  <<< Finished

  >>> Testing StringToChars using fd(self={%s : 1})

  fd(self={1 : 1}):(<class 'TypeError'>, TypeError('object must be string',))

! 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" : {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({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,983 ****

  <<< 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({"\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" : {"\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({"\0" : 1})})):(<class 'TypeError'>, TypeError('expected bytes with no null',))

  <<< Finished

  >>> Testing *Iter* using fd(self=Mapping({"abc" : %s}))

--- 967,983 ----

  <<< Finished

  >>> Testing StringToChars using fd(self=Mapping({%s : 1}))

  fd(self=Mapping({1 : 1})):(<class 'TypeError'>, TypeError('object must be string',))

! 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" : {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({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,1007 ****

  fd(self=FailingMappingKey()):(<class 'NotImplementedError'>, NotImplementedError())

  <<< Finished

  >>> Testing ConvertFromPyMapping using fd(self=%s)

! fd(self=[]):(<class 'AttributeError'>, AttributeError("'list' object has no attribute 'keys'",))

  <<< Finished

  > TabPage

  >> TabPageAttr

--- 1001,1007 ----

  fd(self=FailingMappingKey()):(<class 'NotImplementedError'>, NotImplementedError())

  <<< Finished

  >>> Testing ConvertFromPyMapping using fd(self=%s)

! fd(self=[]):(<class 'AttributeError'>, AttributeError('keys',))

  <<< Finished

  > TabPage

  >> TabPageAttr

***************

*** 1014,1020 ****

  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 = 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',))

--- 1014,1020 ----

  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 = (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,1043 ****

  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',))

  >> RBAsItem

! vim.current.buffer[10000000000] = "":(<class 'IndexError'>, IndexError('line number out of range',))

  >> BufferAttr

  vim.current.buffer.xxx:(<class 'AttributeError'>, AttributeError("'vim.buffer' object has no attribute 'xxx'",))

  >> BufferSetattr

--- 1035,1043 ----

  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[100000000]:(<class 'IndexError'>, IndexError('line number out of range',))

  >> RBAsItem

! 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

*** ../vim-7.3.1078/src/version.c	2013-05-30 22:43:57.000000000 +0200

--- src/version.c	2013-05-31 18:41:58.000000000 +0200

***************

*** 730,731 ****

--- 730,733 ----

  {   /* Add new patch number below this line */

+ /**/

+     1079,

  /**/

-- 

hundred-and-one symptoms of being an internet addict:

29. Your phone bill comes to your doorstep in a box.

 /// Bram Moolenaar -- Bram@Moolenaar.net -- http://www.Moolenaar.net   \\\

///        sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ \\\

\\\  an exciting new programming language -- http://www.Zimbu.org        ///

 \\\            help me help AIDS victims -- http://ICCF-Holland.org    ///