Tests for various python features.     vim: set ft=vim :

STARTTEST
:so small.vim
:set noswapfile
:if !has('python3') || !has('quickfix') | e! test.ok | wq! test.out | endif
:lang C
:fun Test()
:py3 import vim
:py3 cb = vim.current.buffer
:let l = []
:py3 l=vim.bindeval('l')
:py3 f=vim.bindeval('function("strlen")')
:" Extending List directly with different types
:py3 l+=[1, "as'd", [1, 2, f, {'a': 1}]]
:$put =string(l)
:$put =string(l[-1])
:try
:  $put =string(l[-4])
:catch
:  $put =v:exception[:13]
:endtry
:" List assignment
:py3 l[0]=0
:$put =string(l)
:py3 l[-2]=f
:$put =string(l)
:"
:" Extending Dictionary directly with different types
:let d = {}
:fun d.f()
:  return 1
:endfun
py3 << trim EOF
  d=vim.bindeval('d')
  d['1']='asd'
  d.update()  # Must not do anything, including throwing errors
  d.update(b=[1, 2, f])
  d.update((('-1', {'a': 1}),))
  d.update({'0': -1})
  dk = d.keys()
  dv = d.values()
  di = d.items()
  dk.sort(key=repr)
  dv.sort(key=repr)
  di.sort(key=repr)
EOF
:$put =py3eval('d[''f''](self={})')
:$put =py3eval('repr(dk)')
:$put =substitute(py3eval('repr(dv)'),'0x\x\+','','g')
:$put =substitute(py3eval('repr(di)'),'0x\x\+','','g')
:for [key, Val] in sort(items(d))
:  $put =string(key) . ' : ' . string(Val)
:  unlet key Val
:endfor
:py3 del dk
:py3 del di
:py3 del dv
:"
:" removing items with del
:py3 del l[2]
:$put =string(l)
:let l = range(8)
:py3 l=vim.bindeval('l')
:try
:   py3 del l[:3]
:   py3 del l[1:]
:catch
:   $put =v:exception
:endtry
:$put =string(l)
:"
:py3 del d['-1']
:py3 del d['f']
:$put =string(py3eval('d.get(''b'', 1)'))
:$put =string(py3eval('d.pop(''b'')'))
:$put =string(py3eval('d.get(''b'', 1)'))
:$put =string(py3eval('d.pop(''1'', 2)'))
:$put =string(py3eval('d.pop(''1'', 2)'))
:$put =py3eval('repr(d.has_key(''0''))')
:$put =py3eval('repr(d.has_key(''1''))')
:$put =py3eval('repr(''0'' in d)')
:$put =py3eval('repr(''1'' in d)')
:$put =py3eval('repr(list(iter(d)))')
:$put =string(d)
:$put =py3eval('repr(d.popitem())')
:$put =py3eval('repr(d.get(''0''))')
:$put =py3eval('repr(list(iter(d)))')
:"
:" removing items out of range: silently skip items that don't exist
:let l = [0, 1, 2, 3]
:py3 l=vim.bindeval('l')
:" The following two ranges delete nothing as they match empty list:
:py3 del l[2:1]
:$put =string(l)
:py3 del l[2:2]
:$put =string(l)
:py3 del l[2:3]
:$put =string(l)
:let l = [0, 1, 2, 3]
:py3 l=vim.bindeval('l')
:py3 del l[2:4]
:$put =string(l)
:let l = [0, 1, 2, 3]
:py3 l=vim.bindeval('l')
:py3 del l[2:5]
:$put =string(l)
:let l = [0, 1, 2, 3]
:py3 l=vim.bindeval('l')
:py3 del l[2:6]
:$put =string(l)
:let l = [0, 1, 2, 3]
:py3 l=vim.bindeval('l')
:" The following two ranges delete nothing as they match empty list:
:py3 del l[-1:2]
:$put =string(l)
:py3 del l[-2:2]
:$put =string(l)
:py3 del l[-3:2]
:$put =string(l)
:let l = [0, 1, 2, 3]
:py3 l=vim.bindeval('l')
:py3 del l[-4:2]
:$put =string(l)
:let l = [0, 1, 2, 3]
:py3 l=vim.bindeval('l')
:py3 del l[-5:2]
:$put =string(l)
:let l = [0, 1, 2, 3]
:py3 l=vim.bindeval('l')
:py3 del l[-6:2]
:$put =string(l)
:let l = [0, 1, 2, 3]
:py3 l=vim.bindeval('l')
:py3 del l[::2]
:$put =string(l)
:let l = [0, 1, 2, 3]
:py3 l=vim.bindeval('l')
:py3 del l[3:0:-2]
:$put =string(l)
:let l = [0, 1, 2, 3]
:py3 l=vim.bindeval('l')
:py3 del l[2:4:-2]
:$put =string(l)
:"
:" Slice assignment to a list
:let l = [0, 1, 2, 3]
:py3 l=vim.bindeval('l')
:py3 l[0:0]=['a']
:$put =string(l)
:let l = [0, 1, 2, 3]
:py3 l=vim.bindeval('l')
:py3 l[1:2]=['b']
:$put =string(l)
:let l = [0, 1, 2, 3]
:py3 l=vim.bindeval('l')
:py3 l[2:4]=['c']
:$put =string(l)
:let l = [0, 1, 2, 3]
:py3 l=vim.bindeval('l')
:py3 l[4:4]=['d']
:$put =string(l)
:let l = [0, 1, 2, 3]
:py3 l=vim.bindeval('l')
:py3 l[-1:2]=['e']
:$put =string(l)
:let l = [0, 1, 2, 3]
:py3 l=vim.bindeval('l')
:py3 l[-10:2]=['f']
:$put =string(l)
:let l = [0, 1, 2, 3]
:py3 l=vim.bindeval('l')
:py3 l[2:-10]=['g']
:$put =string(l)
:let l = []
:py3 l=vim.bindeval('l')
:py3 l[0:0]=['h']
:$put =string(l)
:let l = range(8)
:py3 l=vim.bindeval('l')
:py3 l[2:6:2] = [10, 20]
:$put =string(l)
:let l = range(8)
:py3 l=vim.bindeval('l')
:py3 l[6:2:-2] = [10, 20]
:$put =string(l)
:let l = range(8)
:py3 l=vim.bindeval('l')
:py3 l[6:2] = ()
:$put =string(l)
:let l = range(8)
:py3 l=vim.bindeval('l')
:py3 l[6:2:1] = ()
:$put =string(l)
:let l = range(8)
:py3 l=vim.bindeval('l')
:py3 l[2:2:1] = ()
:$put =string(l)
:"
:" Locked variables
:let l = [0, 1, 2, 3]
:py3 l=vim.bindeval('l')
:lockvar! l
py3 << trim EOF
  def emsg(ei):
      return ei[0].__name__ + ':' + repr(ei[1].args)

  try:
      l[2]='i'
  except vim.error:
      cb.append('l[2] threw vim.error: ' + emsg(sys.exc_info()))
EOF
:$put =string(l)
:unlockvar! l
:"
:" Function calls
py3 << trim EOF
  import sys
  import re

  py33_type_error_pattern = re.compile('^__call__\(\) takes (\d+) positional argument but (\d+) were given$')
  py37_exception_repr = re.compile(r'([^\(\),])(\)+)$')

  def ee(expr, g=globals(), l=locals()):
      cb = vim.current.buffer
      try:
          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."):
                  msg = repr((e.__class__, AttributeError(str(e)[str(e).rfind(" '") + 2:-1])))
              elif sys.version_info >= (3, 3) and e.__class__ is ImportError and str(e).find('No module named \'') >= 0:
                  msg = repr((e.__class__, ImportError(str(e).replace("'", ''))))
              elif sys.version_info >= (3, 6) and e.__class__ is ModuleNotFoundError:
                  # Python 3.6 gives ModuleNotFoundError, change it to an ImportError
                  msg = repr((ImportError, ImportError(str(e).replace("'", ''))))
              elif sys.version_info >= (3, 3) and e.__class__ is TypeError:
                  m = py33_type_error_pattern.search(str(e))
                  if m:
                      msg = '__call__() takes exactly {0} positional argument ({1} given)'.format(m.group(1), m.group(2))
                      msg = repr((e.__class__, TypeError(msg)))
                  else:
                      msg = repr((e.__class__, e))
                      # Messages changed with Python 3.6, change new to old.
                      newmsg1 = """'argument must be str, bytes or bytearray, not None'"""
                      oldmsg1 = '''"Can't convert 'NoneType' object to str implicitly"'''
                      if msg.find(newmsg1) > -1:
                          msg = msg.replace(newmsg1, oldmsg1)
                      newmsg2 = """'argument must be str, bytes or bytearray, not int'"""
                      oldmsg2 = '''"Can't convert 'int' object to str implicitly"'''
                      if msg.find(newmsg2) > -1:
                          msg = msg.replace(newmsg2, oldmsg2)
              elif sys.version_info >= (3, 5) and e.__class__ is ValueError and str(e) == 'embedded null byte':
                  msg = repr((TypeError, TypeError('expected bytes with no null')))
              else:
                  msg = repr((e.__class__, e))
                  # Some Python versions say can't, others cannot.
                  if msg.find('can\'t') > -1:
                      msg = msg.replace('can\'t', 'cannot')
                  # Some Python versions use single quote, some double quote
                  if msg.find('"cannot ') > -1:
                      msg = msg.replace('"cannot ', '\'cannot ')
                  if msg.find(' attributes"') > -1:
                      msg = msg.replace(' attributes"', ' attributes\'')
              if sys.version_info >= (3, 7):
                  msg = py37_exception_repr.sub(r'\1,\2', msg)
              cb.append(expr + ':' + msg)
          else:
              cb.append(expr + ':NOT FAILED')
      except Exception as e:
          msg = repr((e.__class__, e))
          if sys.version_info >= (3, 7):
              msg = py37_exception_repr.sub(r'\1,\2', msg)
          cb.append(expr + '::' + msg)
EOF
:fun New(...)
:   return ['NewStart']+a:000+['NewEnd']
:endfun
:fun DictNew(...) dict
:   return ['DictNewStart']+a:000+['DictNewEnd', self]
:endfun
:let l=[function('New'), function('DictNew')]
:py3 l=vim.bindeval('l')
:py3 l.extend(list(l[0](1, 2, 3)))
:$put =string(l)
:py3 l.extend(list(l[1](1, 2, 3, self={'a': 'b'})))
:$put =string(l)
:py3 l+=[l[0].name]
:$put =string(l)
:py3 ee('l[1](1, 2, 3)')
:py3 f=l[0]
:delfunction New
:py3 ee('f(1, 2, 3)')
:if has('float')
:   let l=[0.0]
:   py3 l=vim.bindeval('l')
:   py3 l.extend([0.0])
:   $put =string(l)
:else
:   $put ='[0.0, 0.0]'
:endif
:let messages=[]
:delfunction DictNew
py3 << trim EOF
  import sys
  d=vim.bindeval('{}')
  m=vim.bindeval('messages')
  def em(expr, g=globals(), l=locals()):
      try:
          exec(expr, g, l)
      except Exception as e:
          if sys.version_info >= (3, 5) and e.__class__ is ValueError and str(e) == 'embedded null byte':
              m.extend([TypeError.__name__])
          else:
              m.extend([e.__class__.__name__])

  em('d["abc1"]')
  em('d["abc1"]="\\0"')
  em('d["abc1"]=vim')
  em('d[""]=1')
  em('d["a\\0b"]=1')
  em('d[b"a\\0b"]=1')

  em('d.pop("abc1")')
  em('d.popitem()')
  del em
  del m
EOF
:$put =messages
:unlet messages
:" locked and scope attributes
:let d={} | let dl={} | lockvar dl
:for s in split("d dl v: g:")
:    let name=tr(s, ':', 's')
:    execute 'py3 '.name.'=vim.bindeval("'.s.'")'
:    let toput=s.' : '.join(map(['locked', 'scope'], 'v:val.":".py3eval(name.".".v:val)'), ';')
:    $put =toput
:endfor
:silent! let d.abc2=1
:silent! let dl.abc3=1
:py3 d.locked=True
:py3 dl.locked=False
:silent! let d.def=1
:silent! let dl.def=1
:put ='d:'.string(d)
:put ='dl:'.string(dl)
:unlet d dl
:
:let l=[] | let ll=[] | lockvar ll
:for s in split("l ll")
:    let name=tr(s, ':', 's')
:    execute 'py3 '.name.'=vim.bindeval("'.s.'")'
:    let toput=s.' : locked:'.py3eval(name.'.locked')
:    $put =toput
:endfor
:silent! call extend(l, [0])
:silent! call extend(ll, [0])
:py3 l.locked=True
:py3 ll.locked=False
:silent! call extend(l, [1])
:silent! call extend(ll, [1])
:put ='l:'.string(l)
:put ='ll:'.string(ll)
:unlet l ll
:"
:" py3eval()
:let l=py3eval('[0, 1, 2]')
:$put =string(l)
:let d=py3eval('{"a": "b", "c": 1, "d": ["e"]}')
:$put =sort(items(d))
:let v:errmsg = ''
:$put ='py3eval(\"None\") = ' . py3eval('None') . v:errmsg
:if has('float')
:   let f=py3eval('0.0')
:   $put =string(f)
:else
:   $put ='0.0'
:endif
:" Invalid values:
:for e in ['"\0"', '{"\0": 1}', 'undefined_name', 'vim']
:   try
:      let v=py3eval(e)
:   catch
:      let toput=e.":\t".v:exception[:13]
:      $put =toput
:   endtry
:endfor
:"
:" threading
:let l = [0]
:py3 l=vim.bindeval('l')
py3 << trim EOF
  import threading
  import time

  class T(threading.Thread):
      def __init__(self):
          threading.Thread.__init__(self)
          self.t = 0
          self.running = True

      def run(self):
          while self.running:
              self.t += 1
              time.sleep(0.1)

  t = T()
  del T
  t.start()
EOF
:sleep 1
:py3 t.running = False
:py3 t.join()
:" Check if the background thread is working.  Count should be 10, but on a
:" busy system (AppVeyor) it can be much lower.
:py3 l[0] = t.t > 4
:py3 del time
:py3 del threading
:py3 del t
:$put =string(l)
:"
:" settrace
:let l = []
:py3 l=vim.bindeval('l')
py3 << trim EOF
  import sys

  def traceit(frame, event, arg):
      global l
      if event == "line":
          l += [frame.f_lineno]
      return traceit

  def trace_main():
      for i in range(5):
          pass
EOF
:py3 sys.settrace(traceit)
:py3 trace_main()
:py3 sys.settrace(None)
:py3 del traceit
:py3 del trace_main
:$put =string(l)
:"
:" Slice
:py3 ll = vim.bindeval('[0, 1, 2, 3, 4, 5]')
:py3 l = ll[:4]
:$put =string(py3eval('l'))
:py3 l = ll[2:]
:$put =string(py3eval('l'))
:py3 l = ll[:-4]
:$put =string(py3eval('l'))
:py3 l = ll[-2:]
:$put =string(py3eval('l'))
:py3 l = ll[2:4]
:$put =string(py3eval('l'))
:py3 l = ll[4:2]
:$put =string(py3eval('l'))
:py3 l = ll[-4:-2]
:$put =string(py3eval('l'))
:py3 l = ll[-2:-4]
:$put =string(py3eval('l'))
:py3 l = ll[:]
:$put =string(py3eval('l'))
:py3 l = ll[0:6]
:$put =string(py3eval('l'))
:py3 l = ll[-10:10]
:$put =string(py3eval('l'))
:py3 l = ll[4:2:-1]
:$put =string(py3eval('l'))
:py3 l = ll[::2]
:$put =string(py3eval('l'))
:py3 l = ll[4:2:1]
:$put =string(py3eval('l'))
:py3 del l
:"
:" Vars
:let g:foo = 'bac'
:let w:abc3 = 'def'
:let b:baz = 'bar'
:let t:bar = 'jkl'
:try
:  throw "Abc"
:catch
:  put =py3eval('vim.vvars[''exception'']')
:endtry
:put =py3eval('vim.vars[''foo'']')
:put =py3eval('vim.current.window.vars[''abc3'']')
:put =py3eval('vim.current.buffer.vars[''baz'']')
:put =py3eval('vim.current.tabpage.vars[''bar'']')
:"
:" Options
:" paste:          boolean, global
:" previewheight   number,  global
:" operatorfunc:   string,  global
:" number:         boolean, window-local
:" numberwidth:    number,  window-local
:" colorcolumn:    string,  window-local
:" statusline:     string,  window-local/global
:" autoindent:     boolean, buffer-local
:" shiftwidth:     number,  buffer-local
:" omnifunc:       string,  buffer-local
:" preserveindent: boolean, buffer-local/global
:" path:           string,  buffer-local/global
:let g:bufs=[bufnr('%')]
:new
:let g:bufs+=[bufnr('%')]
:vnew
:let g:bufs+=[bufnr('%')]
:wincmd j
:vnew
:let g:bufs+=[bufnr('%')]
:wincmd l
:fun RecVars(opt)
:  let gval =string(eval('&g:'.a:opt))
:  let wvals=join(map(range(1, 4),  'v:val.":".string(getwinvar(v:val, "&".a:opt))'))
:  let bvals=join(map(copy(g:bufs), 'v:val.":".string(getbufvar(v:val, "&".a:opt))'))
:  put ='  G: '.gval
:  put ='  W: '.wvals
:  put ='  B: '.wvals
:endfun
py3 << trim EOF
  def e(s, g=globals(), l=locals()):
      try:
          exec(s, g, l)
      except Exception as e:
          vim.command('return ' + repr(e.__class__.__name__))

  def ev(s, g=globals(), l=locals()):
      try:
          return eval(s, g, l)
      except Exception as e:
          vim.command('let exc=' + repr(e.__class__.__name__))
          return 0
EOF
:fun E(s)
:   python3 e(vim.eval('a:s'))
:endfun
:fun Ev(s)
:   let r=py3eval('ev(vim.eval("a:s"))')
:   if exists('exc')
:       throw exc
:   endif
:   return r
:endfun
:py3 gopts1=vim.options
:py3 wopts1=vim.windows[2].options
:py3 wopts2=vim.windows[0].options
:py3 wopts3=vim.windows[1].options
:py3 bopts1=vim.buffers[vim.bindeval("g:bufs")[2]].options
:py3 bopts2=vim.buffers[vim.bindeval("g:bufs")[1]].options
:py3 bopts3=vim.buffers[vim.bindeval("g:bufs")[0]].options
:$put ='wopts iters equal: '.py3eval('list(wopts1) == list(wopts2)')
:$put ='bopts iters equal: '.py3eval('list(bopts1) == list(bopts2)')
:py3 gset=set(iter(gopts1))
:py3 wset=set(iter(wopts1))
:py3 bset=set(iter(bopts1))
:set path=.,..,,
:let lst=[]
:let lst+=[['paste',          1,     0,     1,     2,      1,    1,      0    ]]
:let lst+=[['previewheight',  5,     1,     6,     'a',    0,    1,      0    ]]
:let lst+=[['operatorfunc',   'A',   'B',   'C',   2,      0,    1,      0    ]]
:let lst+=[['number',         0,     1,     1,     0,      1,    0,      1    ]]
:let lst+=[['numberwidth',    2,     3,     5,     -100,   0,    0,      1    ]]
:let lst+=[['colorcolumn',    '+1',  '+2',  '+3',  'abc4',  0,    0,      1    ]]
:let lst+=[['statusline',     '1',   '2',   '4',   0,      0,    1,      1    ]]
:let lst+=[['autoindent',     0,     1,     1,     2,      1,    0,      2    ]]
:let lst+=[['shiftwidth',     0,     2,     1,     3,      0,    0,      2    ]]
:let lst+=[['omnifunc',       'A',   'B',   'C',   1,      0,    0,      2    ]]
:let lst+=[['preserveindent', 0,     1,     1,     2,      1,    1,      2    ]]
:let lst+=[['path',           '.,,', ',,',  '.',   0,      0,    1,      2    ]]
:for       [oname,            oval1, oval2, oval3, invval, bool, global, local] in lst
:   py3 oname=vim.eval('oname')
:   py3 oval1=vim.bindeval('oval1')
:   py3 oval2=vim.bindeval('oval2')
:   py3 oval3=vim.bindeval('oval3')
:   if invval is 0 || invval is 1
:       py3 invval=bool(vim.bindeval('invval'))
:   else
:       py3 invval=vim.bindeval('invval')
:   endif
:   if bool
:       py3 oval1=bool(oval1)
:       py3 oval2=bool(oval2)
:       py3 oval3=bool(oval3)
:   endif
:   put ='>>> '.oname
:   $put ='  g/w/b:'.py3eval('oname in gset').'/'.py3eval('oname in wset').'/'.py3eval('oname in bset')
:   $put ='  g/w/b (in):'.py3eval('oname in gopts1').'/'.py3eval('oname in wopts1').'/'.py3eval('oname in bopts1')
:   for v in ['gopts1', 'wopts1', 'bopts1']
:       try
:           put ='  p/'.v.': '.Ev('repr('.v.'['''.oname.'''])')
:       catch
:           put ='  p/'.v.'! '.v:exception
:       endtry
:       let r=E(v.'['''.oname.''']=invval')
:       if r isnot 0
:           put ='  inv: '.string(invval).'! '.r
:       endif
:       for vv in (v is# 'gopts1' ? [v] : [v, v[:-2].'2', v[:-2].'3'])
:           let val=substitute(vv, '^.opts', 'oval', '')
:           let r=E(vv.'['''.oname.''']='.val)
:           if r isnot 0
:               put ='  '.vv.'! '.r
:           endif
:       endfor
:   endfor
:   call RecVars(oname)
:   for v in ['wopts3', 'bopts3']
:       let r=E('del '.v.'["'.oname.'"]')
:       if r isnot 0
:           put ='  del '.v.'! '.r
:       endif
:   endfor
:   call RecVars(oname)
:endfor
:delfunction RecVars
:delfunction E
:delfunction Ev
:py3 del ev
:py3 del e
:only
:for buf in g:bufs[1:]
:   execute 'bwipeout!' buf
:endfor
:py3 del gopts1
:py3 del wopts1
:py3 del wopts2
:py3 del wopts3
:py3 del bopts1
:py3 del bopts2
:py3 del bopts3
:py3 del oval1
:py3 del oval2
:py3 del oval3
:py3 del oname
:py3 del invval
:"
:" Test buffer object
:vnew
:put ='First line'
:put ='Second line'
:put ='Third line'
:1 delete _
:py3 b=vim.current.buffer
:wincmd w
:mark a
:augroup BUFS
:   autocmd BufFilePost * python3 cb.append(vim.eval('expand("<abuf>")') + ':BufFilePost:' + vim.eval('bufnr("%")'))
:   autocmd BufFilePre * python3 cb.append(vim.eval('expand("<abuf>")') + ':BufFilePre:' + vim.eval('bufnr("%")'))
:augroup END
py3 << trim EOF
  # Tests BufferAppend and BufferItem
  cb.append(b[0])
  # Tests BufferSlice and BufferAssSlice
  cb.append('abc5') # Will be overwritten
  cb[-1:] = b[:-2]
  # Test BufferLength and BufferAssSlice
  cb.append('def') # Will not be overwritten
  cb[len(cb):] = b[:]
  # Test BufferAssItem and BufferMark
  cb.append('ghi') # Will be overwritten
  cb[-1] = repr((len(cb) - cb.mark('a')[0], cb.mark('a')[1]))
  # Test BufferRepr
  cb.append(repr(cb) + repr(b))
  # Modify foreign buffer
  b.append('foo')
  b[0]='bar'
  b[0:0]=['baz']
  vim.command('call append("$", getbufline(%i, 1, "$"))' % b.number)
  # Test assigning to name property
  import os
  old_name = cb.name
  cb.name = 'foo'
  cb.append(cb.name[-11:].replace(os.path.sep, '/'))
  b.name = 'bar'
  cb.append(b.name[-11:].replace(os.path.sep, '/'))
  cb.name = old_name
  cb.append(cb.name[-17:].replace(os.path.sep, '/'))
  del old_name
  # Test CheckBuffer
  for _b in vim.buffers:
      if _b is not cb:
          vim.command('bwipeout! ' + str(_b.number))
  del _b
  cb.append('valid: b:%s, cb:%s' % (repr(b.valid), repr(cb.valid)))
  for expr in ('b[1]','b[:] = ["A", "B"]','b[:]','b.append("abc6")'):
      try:
          exec(expr)
      except vim.error:
          pass
      else:
          # Usually a SEGV here
          # Should not happen in any case
          cb.append('No exception for ' + expr)
  vim.command('cd .')
  del b
EOF
:"
:" Test vim.buffers object
:set hidden
:edit a
:buffer #
:edit b
:buffer #
:edit c
:buffer #
py3 << trim EOF
  # Check GCing iterator that was not fully exhausted
  i = iter(vim.buffers)
  cb.append('i:' + str(next(i)))
  # and also check creating more than one iterator at a time
  i2 = iter(vim.buffers)
  cb.append('i2:' + str(next(i2)))
  cb.append('i:' + str(next(i)))
  # The following should trigger GC and not cause any problems
  del i
  del i2
  i3 = iter(vim.buffers)
  cb.append('i3:' + str(next(i3)))
  del i3

  prevnum = 0
  for b in vim.buffers:
      # Check buffer order
      if prevnum >= b.number:
          cb.append('!!! Buffer numbers not in strictly ascending order')
      # Check indexing: vim.buffers[number].number == number
      cb.append(str(b.number) + ':' + repr(vim.buffers[b.number]) + '=' + repr(b))
      prevnum = b.number
  del prevnum

  cb.append(str(len(vim.buffers)))

  bnums = list(map(lambda b: b.number, vim.buffers))[1:]

  # Test wiping out buffer with existing iterator
  i4 = iter(vim.buffers)
  cb.append('i4:' + str(next(i4)))
  vim.command('bwipeout! ' + str(bnums.pop(0)))
  try:
      next(i4)
  except vim.error:
      pass
  else:
      cb.append('!!!! No vim.error')
  i4 = iter(vim.buffers)
  vim.command('bwipeout! ' + str(bnums.pop(-1)))
  vim.command('bwipeout! ' + str(bnums.pop(-1)))
  cb.append('i4:' + str(next(i4)))
  try:
      next(i4)
  except StopIteration:
      cb.append('StopIteration')
  del i4
  del bnums
EOF
:"
:" Test vim.{tabpage,window}list and vim.{tabpage,window} objects
:tabnew 0
:tabnew 1
:vnew a.1
:tabnew 2
:vnew a.2
:vnew b.2
:vnew c.2
py3 << trim EOF
  cb.append('Number of tabs: ' + str(len(vim.tabpages)))
  cb.append('Current tab pages:')

  def W(w):
      if '(unknown)' in repr(w):
          return '<window object (unknown)>'
      else:
          return repr(w)

  def Cursor(w, start=len(cb)):
      if w.buffer is cb:
          return repr((start - w.cursor[0], w.cursor[1]))
      else:
          return repr(w.cursor)

  for t in vim.tabpages:
      cb.append('  ' + repr(t) + '(' + str(t.number) + ')' + ': ' + str(len(t.windows)) + ' windows, current is ' + W(t.window))
      cb.append('  Windows:')
      for w in t.windows:
          cb.append('    ' + W(w) + '(' + str(w.number) + ')' + ': displays buffer ' + repr(w.buffer) + '; cursor is at ' + Cursor(w))
          # Other values depend on the size of the terminal, so they are checked partly:
          for attr in ('height', 'row', 'width', 'col'):
              try:
                  aval = getattr(w, attr)
                  if type(aval) is not int:
                      raise TypeError
                  if aval < 0:
                      raise ValueError
              except Exception as e:
                  cb.append('!!!!!! Error while getting attribute ' + attr + ': ' + e.__class__.__name__)
          del aval
          del attr
          w.cursor = (len(w.buffer), 0)
  del W
  del Cursor
  cb.append('Number of windows in current tab page: ' + str(len(vim.windows)))
  if list(vim.windows) != list(vim.current.tabpage.windows):
      cb.append('!!!!!! Windows differ')
EOF
:"
:" Test vim.current
py3 << trim EOF
  def H(o):
      return repr(o)
  cb.append('Current tab page: ' + repr(vim.current.tabpage))
  cb.append('Current window: ' + repr(vim.current.window) + ': ' + H(vim.current.window) + ' is ' + H(vim.current.tabpage.window))
  cb.append('Current buffer: ' + repr(vim.current.buffer) + ': ' + H(vim.current.buffer) + ' is ' + H(vim.current.window.buffer)+ ' is ' + H(vim.current.tabpage.window.buffer))
  del H
  # Assigning: fails
  try:
      vim.current.window = vim.tabpages[0].window
  except ValueError:
      cb.append('ValueError at assigning foreign tab window')

  for attr in ('window', 'tabpage', 'buffer'):
      try:
          setattr(vim.current, attr, None)
      except TypeError:
          cb.append('Type error at assigning None to vim.current.' + attr)
  del attr

  # Assigning: success
  vim.current.tabpage = vim.tabpages[-2]
  vim.current.buffer = cb
  vim.current.window = vim.windows[0]
  vim.current.window.cursor = (len(vim.current.buffer), 0)
  cb.append('Current tab page: ' + repr(vim.current.tabpage))
  cb.append('Current window: ' + repr(vim.current.window))
  cb.append('Current buffer: ' + repr(vim.current.buffer))
  cb.append('Current line: ' + repr(vim.current.line))
  ws = list(vim.windows)
  ts = list(vim.tabpages)
  for b in vim.buffers:
      if b is not cb:
          vim.command('bwipeout! ' + str(b.number))
  del b
  cb.append('w.valid: ' + repr([w.valid for w in ws]))
  cb.append('t.valid: ' + repr([t.valid for t in ts]))
  del w
  del t
  del ts
  del ws
EOF
:tabonly!
:only!
:"
:" Test types
py3 << trim EOF
  for expr, attr in (
      ('vim.vars',                         'Dictionary'),
      ('vim.options',                      'Options'),
      ('vim.bindeval("{}")',               'Dictionary'),
      ('vim.bindeval("[]")',               'List'),
      ('vim.bindeval("function(\'tr\')")', 'Function'),
      ('vim.current.buffer',               'Buffer'),
      ('vim.current.range',                'Range'),
      ('vim.current.window',               'Window'),
      ('vim.current.tabpage',              'TabPage'),
  ):
      cb.append(expr + ':' + attr + ':' + repr(type(eval(expr)) is getattr(vim, attr)))
  del expr
  del attr
EOF
:"
:" Test __dir__() method
py3 << trim EOF
  for name, o in (
          ('current',    vim.current),
          ('buffer',     vim.current.buffer),
          ('window',     vim.current.window),
          ('tabpage',    vim.current.tabpage),
          ('range',      vim.current.range),
          ('dictionary', vim.bindeval('{}')),
          ('list',       vim.bindeval('[]')),
          ('function',   vim.bindeval('function("tr")')),
          ('output',     sys.stdout),
      ):
      cb.append(name + ':' + ','.join(dir(o)))
  del name
  del o
EOF
:"
:" Test vim.*.__new__
:$put =string(py3eval('vim.Dictionary({})'))
:$put =string(py3eval('vim.Dictionary(a=1)'))
:$put =string(py3eval('vim.Dictionary(((''a'', 1),))'))
:$put =string(py3eval('vim.List()'))
:$put =string(py3eval('vim.List(iter(''abc7''))'))
:$put =string(py3eval('vim.Function(''tr'')'))
:$put =string(py3eval('vim.Function(''tr'', args=[123, 3, 4])'))
:$put =string(py3eval('vim.Function(''tr'', args=[])'))
:$put =string(py3eval('vim.Function(''tr'', self={})'))
:$put =string(py3eval('vim.Function(''tr'', args=[123, 3, 4], self={})'))
:$put ='auto_rebind'
:$put =string(py3eval('vim.Function(''tr'', auto_rebind=False)'))
:$put =string(py3eval('vim.Function(''tr'', args=[123, 3, 4], auto_rebind=False)'))
:$put =string(py3eval('vim.Function(''tr'', args=[], auto_rebind=False)'))
:$put =string(py3eval('vim.Function(''tr'', self={}, auto_rebind=False)'))
:$put =string(py3eval('vim.Function(''tr'', args=[123, 3, 4], self={}, auto_rebind=False)'))
:"
:" Test vim.Function
:function Args(...)
:   return a:000
:endfunction
:function SelfArgs(...) dict
:   return [a:000, self]
:endfunction
:" The following four lines should not crash
:let Pt = function('tr', [[]], {'l': []})
:py3 Pt = vim.bindeval('Pt')
:unlet Pt
:py3 del Pt
py3 << trim EOF
  def ecall(out_prefix, func, *args, **kwargs):
      line = out_prefix + ': '
      try:
          ret = func(*args, **kwargs)
      except Exception:
          line += '!exception: ' + emsg(sys.exc_info())
      else:
          line += '!result: ' + str(vim.Function('string')(ret), 'utf-8')
      cb.append(line)
  a = vim.Function('Args')
  pa1 = vim.Function('Args', args=['abcArgsPA1'])
  pa2 = vim.Function('Args', args=[])
  pa3 = vim.Function('Args', args=['abcArgsPA3'], self={'abcSelfPA3': 'abcSelfPA3Val'})
  pa4 = vim.Function('Args', self={'abcSelfPA4': 'abcSelfPA4Val'})
  cb.append('a: ' + repr(a))
  cb.append('pa1: ' + repr(pa1))
  cb.append('pa2: ' + repr(pa2))
  cb.append('pa3: ' + repr(pa3))
  cb.append('pa4: ' + repr(pa4))
  sa = vim.Function('SelfArgs')
  psa1 = vim.Function('SelfArgs', args=['abcArgsPSA1'])
  psa2 = vim.Function('SelfArgs', args=[])
  psa3 = vim.Function('SelfArgs', args=['abcArgsPSA3'], self={'abcSelfPSA3': 'abcSelfPSA3Val'})
  psa4 = vim.Function('SelfArgs', self={'abcSelfPSA4': 'abcSelfPSA4Val'})
  psa5 = vim.Function('SelfArgs', self={'abcSelfPSA5': 'abcSelfPSA5Val'}, auto_rebind=0)
  psa6 = vim.Function('SelfArgs', args=['abcArgsPSA6'], self={'abcSelfPSA6': 'abcSelfPSA6Val'}, auto_rebind=())
  psa7 = vim.Function('SelfArgs', args=['abcArgsPSA7'], auto_rebind=[])
  psa8 = vim.Function('SelfArgs', auto_rebind=False)
  psa9 = vim.Function('SelfArgs', self={'abcSelfPSA9': 'abcSelfPSA9Val'}, auto_rebind=True)
  psaA = vim.Function('SelfArgs', args=['abcArgsPSAA'], self={'abcSelfPSAA': 'abcSelfPSAAVal'}, auto_rebind=1)
  psaB = vim.Function('SelfArgs', args=['abcArgsPSAB'], auto_rebind={'abcARPSAB': 'abcARPSABVal'})
  psaC = vim.Function('SelfArgs', auto_rebind=['abcARPSAC'])
  cb.append('sa: ' + repr(sa))
  cb.append('psa1: ' + repr(psa1))
  cb.append('psa2: ' + repr(psa2))
  cb.append('psa3: ' + repr(psa3))
  cb.append('psa4: ' + repr(psa4))
  cb.append('psa5: ' + repr(psa5))
  cb.append('psa6: ' + repr(psa6))
  cb.append('psa7: ' + repr(psa7))
  cb.append('psa8: ' + repr(psa8))
  cb.append('psa9: ' + repr(psa9))
  cb.append('psaA: ' + repr(psaA))
  cb.append('psaB: ' + repr(psaB))
  cb.append('psaC: ' + repr(psaC))

  psar = vim.Function('SelfArgs', args=[{'abcArgsPSAr': 'abcArgsPSArVal'}], self={'abcSelfPSAr': 'abcSelfPSArVal'})
  psar.args[0]['abcArgsPSAr2'] = [psar.self, psar.args[0]]
  psar.self['rec'] = psar
  psar.self['self'] = psar.self
  psar.self['args'] = psar.args

  try:
      cb.append('psar: ' + repr(psar))
  except Exception:
      cb.append('!!!!!!!! Caught exception: ' + emsg(sys.exc_info()))
EOF
:$put ='s(a): '.string(py3eval('a'))
:$put ='s(pa1): '.string(py3eval('pa1'))
:$put ='s(pa2): '.string(py3eval('pa2'))
:$put ='s(pa3): '.string(py3eval('pa3'))
:$put ='s(pa4): '.string(py3eval('pa4'))
:$put ='s(sa): '.string(py3eval('sa'))
:$put ='s(psa1): '.string(py3eval('psa1'))
:$put ='s(psa2): '.string(py3eval('psa2'))
:$put ='s(psa3): '.string(py3eval('psa3'))
:$put ='s(psa4): '.string(py3eval('psa4'))
:$put ='s(psa5): '.string(py3eval('psa5'))
:$put ='s(psa6): '.string(py3eval('psa6'))
:$put ='s(psa7): '.string(py3eval('psa7'))
:$put ='s(psa8): '.string(py3eval('psa8'))
:$put ='s(psa9): '.string(py3eval('psa9'))
:$put ='s(psaA): '.string(py3eval('psaA'))
:$put ='s(psaB): '.string(py3eval('psaB'))
:$put ='s(psaC): '.string(py3eval('psaC'))
:
:for v in ['sa', 'psa1', 'psa2', 'psa3', 'psa4', 'psa5', 'psa6', 'psa7', 'psa8', 'psa9', 'psaA', 'psaB', 'psaC']
:   let d = {'f': py3eval(v)}
:   $put ='d.'.v.'(): '.string(d.f())
:endfor
:
:py3 ecall('a()', a, )
:py3 ecall('pa1()', pa1, )
:py3 ecall('pa2()', pa2, )
:py3 ecall('pa3()', pa3, )
:py3 ecall('pa4()', pa4, )
:py3 ecall('sa()', sa, )
:py3 ecall('psa1()', psa1, )
:py3 ecall('psa2()', psa2, )
:py3 ecall('psa3()', psa3, )
:py3 ecall('psa4()', psa4, )
:
:py3 ecall('a(42, 43)', a, 42, 43)
:py3 ecall('pa1(42, 43)', pa1, 42, 43)
:py3 ecall('pa2(42, 43)', pa2, 42, 43)
:py3 ecall('pa3(42, 43)', pa3, 42, 43)
:py3 ecall('pa4(42, 43)', pa4, 42, 43)
:py3 ecall('sa(42, 43)', sa, 42, 43)
:py3 ecall('psa1(42, 43)', psa1, 42, 43)
:py3 ecall('psa2(42, 43)', psa2, 42, 43)
:py3 ecall('psa3(42, 43)', psa3, 42, 43)
:py3 ecall('psa4(42, 43)', psa4, 42, 43)
:
:py3 ecall('a(42, self={"20": 1})', a, 42, self={'20': 1})
:py3 ecall('pa1(42, self={"20": 1})', pa1, 42, self={'20': 1})
:py3 ecall('pa2(42, self={"20": 1})', pa2, 42, self={'20': 1})
:py3 ecall('pa3(42, self={"20": 1})', pa3, 42, self={'20': 1})
:py3 ecall('pa4(42, self={"20": 1})', pa4, 42, self={'20': 1})
:py3 ecall('sa(42, self={"20": 1})', sa, 42, self={'20': 1})
:py3 ecall('psa1(42, self={"20": 1})', psa1, 42, self={'20': 1})
:py3 ecall('psa2(42, self={"20": 1})', psa2, 42, self={'20': 1})
:py3 ecall('psa3(42, self={"20": 1})', psa3, 42, self={'20': 1})
:py3 ecall('psa4(42, self={"20": 1})', psa4, 42, self={'20': 1})
:
:py3 ecall('a(self={"20": 1})', a, self={'20': 1})
:py3 ecall('pa1(self={"20": 1})', pa1, self={'20': 1})
:py3 ecall('pa2(self={"20": 1})', pa2, self={'20': 1})
:py3 ecall('pa3(self={"20": 1})', pa3, self={'20': 1})
:py3 ecall('pa4(self={"20": 1})', pa4, self={'20': 1})
:py3 ecall('sa(self={"20": 1})', sa, self={'20': 1})
:py3 ecall('psa1(self={"20": 1})', psa1, self={'20': 1})
:py3 ecall('psa2(self={"20": 1})', psa2, self={'20': 1})
:py3 ecall('psa3(self={"20": 1})', psa3, self={'20': 1})
:py3 ecall('psa4(self={"20": 1})', psa4, self={'20': 1})
py3 << trim EOF
  def s(v):
      if v is None:
          return repr(v)
      else:
          return str(vim.Function('string')(v), 'utf-8')

  cb.append('a.args: ' + s(a.args))
  cb.append('pa1.args: ' + s(pa1.args))
  cb.append('pa2.args: ' + s(pa2.args))
  cb.append('pa3.args: ' + s(pa3.args))
  cb.append('pa4.args: ' + s(pa4.args))
  cb.append('sa.args: ' + s(sa.args))
  cb.append('psa1.args: ' + s(psa1.args))
  cb.append('psa2.args: ' + s(psa2.args))
  cb.append('psa3.args: ' + s(psa3.args))
  cb.append('psa4.args: ' + s(psa4.args))

  cb.append('a.self: ' + s(a.self))
  cb.append('pa1.self: ' + s(pa1.self))
  cb.append('pa2.self: ' + s(pa2.self))
  cb.append('pa3.self: ' + s(pa3.self))
  cb.append('pa4.self: ' + s(pa4.self))
  cb.append('sa.self: ' + s(sa.self))
  cb.append('psa1.self: ' + s(psa1.self))
  cb.append('psa2.self: ' + s(psa2.self))
  cb.append('psa3.self: ' + s(psa3.self))
  cb.append('psa4.self: ' + s(psa4.self))

  cb.append('a.name: ' + s(a.name))
  cb.append('pa1.name: ' + s(pa1.name))
  cb.append('pa2.name: ' + s(pa2.name))
  cb.append('pa3.name: ' + s(pa3.name))
  cb.append('pa4.name: ' + s(pa4.name))
  cb.append('sa.name: ' + s(sa.name))
  cb.append('psa1.name: ' + s(psa1.name))
  cb.append('psa2.name: ' + s(psa2.name))
  cb.append('psa3.name: ' + s(psa3.name))
  cb.append('psa4.name: ' + s(psa4.name))

  cb.append('a.auto_rebind: ' + s(a.auto_rebind))
  cb.append('pa1.auto_rebind: ' + s(pa1.auto_rebind))
  cb.append('pa2.auto_rebind: ' + s(pa2.auto_rebind))
  cb.append('pa3.auto_rebind: ' + s(pa3.auto_rebind))
  cb.append('pa4.auto_rebind: ' + s(pa4.auto_rebind))
  cb.append('sa.auto_rebind: ' + s(sa.auto_rebind))
  cb.append('psa1.auto_rebind: ' + s(psa1.auto_rebind))
  cb.append('psa2.auto_rebind: ' + s(psa2.auto_rebind))
  cb.append('psa3.auto_rebind: ' + s(psa3.auto_rebind))
  cb.append('psa4.auto_rebind: ' + s(psa4.auto_rebind))
  cb.append('psa5.auto_rebind: ' + s(psa5.auto_rebind))
  cb.append('psa6.auto_rebind: ' + s(psa6.auto_rebind))
  cb.append('psa7.auto_rebind: ' + s(psa7.auto_rebind))
  cb.append('psa8.auto_rebind: ' + s(psa8.auto_rebind))
  cb.append('psa9.auto_rebind: ' + s(psa9.auto_rebind))
  cb.append('psaA.auto_rebind: ' + s(psaA.auto_rebind))
  cb.append('psaB.auto_rebind: ' + s(psaB.auto_rebind))
  cb.append('psaC.auto_rebind: ' + s(psaC.auto_rebind))

  del s

  del a
  del pa1
  del pa2
  del pa3
  del pa4
  del sa
  del psa1
  del psa2
  del psa3
  del psa4
  del psa5
  del psa6
  del psa7
  del psa8
  del psa9
  del psaA
  del psaB
  del psaC
  del psar

  del ecall
EOF
:"
:" Test stdout/stderr
:redir => messages
:py3 sys.stdout.write('abc8') ; sys.stdout.write('def')
:py3 sys.stderr.write('abc9') ; sys.stderr.write('def')
:py3 sys.stdout.writelines(iter('abcA'))
:py3 sys.stderr.writelines(iter('abcB'))
:redir END
:$put =string(substitute(messages, '\d\+', '', 'g'))
:" Test subclassing
:fun Put(...)
:   $put =string(a:000)
:   return a:000
:endfun
py3 << trim EOF
  class DupDict(vim.Dictionary):
      def __setitem__(self, key, value):
          super(DupDict, self).__setitem__(key, value)
          super(DupDict, self).__setitem__('dup_' + key, value)
  dd = DupDict()
  dd['a'] = 'b'

  class DupList(vim.List):
      def __getitem__(self, idx):
          return [super(DupList, self).__getitem__(idx)] * 2

  dl = DupList()
  dl2 = DupList(iter('abcC'))
  dl.extend(dl2[0])

  class DupFun(vim.Function):
      def __call__(self, arg):
          return super(DupFun, self).__call__(arg, arg)

  df = DupFun('Put')
EOF
:$put =string(sort(keys(py3eval('dd'))))
:$put =string(py3eval('dl'))
:$put =string(py3eval('dl2'))
:$put =string(py3eval('df(2)'))
:$put =string(py3eval('dl') is# py3eval('dl'))
:$put =string(py3eval('dd') is# py3eval('dd'))
:$put =string(py3eval('df'))
:delfunction Put
py3 << trim EOF
  del DupDict
  del DupList
  del DupFun
  del dd
  del dl
  del dl2
  del df
EOF
:"
:" Test chdir
py3 << trim EOF
  import os
  fnamemodify = vim.Function('fnamemodify')
  cb.append(str(fnamemodify('.', ':p:h:t')))
  cb.append(vim.eval('@%'))
  os.chdir('..')
  path = fnamemodify('.', ':p:h:t')
  if path != b'src':
    # Running tests from a shadow directory, so move up another level
    # This will result in @% looking like shadow/testdir/test87.in, hence the
    # slicing to remove the leading path and path separator
    os.chdir('..')
    cb.append(str(fnamemodify('.', ':p:h:t')))
    cb.append(vim.eval('@%')[len(path)+1:].replace(os.path.sep, '/'))
    os.chdir(path)
  else:
    cb.append(str(fnamemodify('.', ':p:h:t')))
    cb.append(vim.eval('@%').replace(os.path.sep, '/'))
  del path
  os.chdir('testdir')
  cb.append(str(fnamemodify('.', ':p:h:t')))
  cb.append(vim.eval('@%'))
  del fnamemodify
EOF
:"
:" Test errors
:fun F() dict
:endfun
:fun D()
:endfun
py3 << trim EOF
  d = vim.Dictionary()
  ned = vim.Dictionary(foo='bar', baz='abcD')
  dl = vim.Dictionary(a=1)
  dl.locked = True
  l = vim.List()
  ll = vim.List('abcE')
  ll.locked = True
  nel = vim.List('abcO')
  f = vim.Function('string')
  fd = vim.Function('F')
  fdel = vim.Function('D')
  vim.command('delfunction D')

  def subexpr_test(expr, name, subexprs):
      cb.append('>>> Testing %s using %s' % (name, expr))
      for subexpr in subexprs:
          ee(expr % subexpr)
      cb.append('<<< Finished')

  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):
      def __init__(self, d):
          self.d = d

      def __getitem__(self, key):
          return self.d[key]

      def keys(self):
          return self.d.keys()

      def items(self):
          return self.d.items()

  def convertfrompyobject_test(expr, recurse=True):
      # pydict_to_tv
      stringtochars_test(expr % '{%s : 1}')
      if recurse:
          convertfrompyobject_test(expr % '{"abcF" : %s}', False)
      # pymap_to_tv
      stringtochars_test(expr % 'Mapping({%s : 1})')
      if recurse:
          convertfrompyobject_test(expr % 'Mapping({"abcG" : %s})', False)
      # pyseq_to_tv
      iter_test(expr)
      return subexpr_test(expr, 'ConvertFromPyObject', (
          'None',                 # Not conversible
          '{b"": 1}',             # Empty key not allowed
          '{"": 1}',              # Same, but with unicode object
          'FailingMapping()',     #
          'FailingMappingKey()',  #
          'FailingNumber()',      #
      ))

  def convertfrompymapping_test(expr):
      convertfrompyobject_test(expr)
      return subexpr_test(expr, 'ConvertFromPyMapping', (
          '[]',
      ))

  def iter_test(expr):
      return subexpr_test(expr, '*Iter*', (
          'FailingIter()',
          'FailingIterNext()',
      ))

  def number_test(expr, natural=False, unsigned=False):
      if natural:
          unsigned = True
      return subexpr_test(expr, 'NumberToLong', (
          '[]',
          'None',
      ) + (('-1',) if unsigned else ())
      + (('0',) if natural else ()))

  class FailingTrue(object):
      def __bool__(self):
          raise NotImplementedError('bool')

  class FailingIter(object):
      def __iter__(self):
          raise NotImplementedError('iter')

  class FailingIterNext(object):
      def __iter__(self):
          return self

      def __next__(self):
          raise NotImplementedError('next')

  class FailingIterNextN(object):
      def __init__(self, n):
          self.n = n

      def __iter__(self):
          return self

      def __next__(self):
          if self.n:
              self.n -= 1
              return 1
          else:
              raise NotImplementedError('next N')

  class FailingMappingKey(object):
      def __getitem__(self, item):
          raise NotImplementedError('getitem:mappingkey')

      def keys(self):
          return list("abcH")

  class FailingMapping(object):
      def __getitem__(self):
          raise NotImplementedError('getitem:mapping')

      def keys(self):
          raise NotImplementedError('keys')

  class FailingList(list):
      def __getitem__(self, idx):
          if i == 2:
              raise NotImplementedError('getitem:list')
          else:
              return super(FailingList, self).__getitem__(idx)

  class NoArgsCall(object):
      def __call__(self):
          pass

  class FailingCall(object):
      def __call__(self, path):
          raise NotImplementedError('call')

  class FailingNumber(object):
      def __int__(self):
          raise NotImplementedError('int')

  cb.append("> Output")
  cb.append(">> OutputSetattr")
  ee('del sys.stdout.softspace')
  number_test('sys.stdout.softspace = %s', unsigned=True)
  number_test('sys.stderr.softspace = %s', unsigned=True)
  ee('assert sys.stdout.isatty()==False')
  ee('assert sys.stdout.seekable()==False')
  ee('sys.stdout.close()')
  ee('sys.stdout.flush()')
  ee('assert sys.stderr.isatty()==False')
  ee('assert sys.stderr.seekable()==False')
  ee('sys.stderr.close()')
  ee('sys.stderr.flush()')
  ee('sys.stdout.attr = None')
  cb.append(">> OutputWrite")
  ee('assert sys.stdout.writable()==True')
  ee('assert sys.stdout.readable()==False')
  ee('assert sys.stderr.writable()==True')
  ee('assert sys.stderr.readable()==False')
  ee('assert sys.stdout.closed()==False')
  ee('assert sys.stderr.closed()==False')
  ee('assert sys.stdout.errors=="strict"')
  ee('assert sys.stderr.errors=="strict"')
  ee('assert sys.stdout.encoding==sys.stderr.encoding')
  ee('sys.stdout.write(None)')
  cb.append(">> OutputWriteLines")
  ee('sys.stdout.writelines(None)')
  ee('sys.stdout.writelines([1])')
  iter_test('sys.stdout.writelines(%s)')
  cb.append("> VimCommand")
  stringtochars_test('vim.command(%s)')
  ee('vim.command("", 2)')
  #! Not checked: vim->python exceptions translating: checked later
  cb.append("> VimToPython")
  #! Not checked: everything: needs errors in internal python functions
  cb.append("> VimEval")
  stringtochars_test('vim.eval(%s)')
  ee('vim.eval("", FailingTrue())')
  #! Not checked: everything: needs errors in internal python functions
  cb.append("> VimEvalPy")
  stringtochars_test('vim.bindeval(%s)')
  ee('vim.eval("", 2)')
  #! Not checked: vim->python exceptions translating: checked later
  cb.append("> VimStrwidth")
  stringtochars_test('vim.strwidth(%s)')
  cb.append("> VimForeachRTP")
  ee('vim.foreach_rtp(None)')
  ee('vim.foreach_rtp(NoArgsCall())')
  ee('vim.foreach_rtp(FailingCall())')
  ee('vim.foreach_rtp(int, 2)')
  cb.append('> import')
  old_rtp = vim.options['rtp']
  vim.options['rtp'] = os.getcwd().replace('\\', '\\\\').replace(',', '\\,')
  ee('import xxx_no_such_module_xxx')
  ee('import failing_import')
  ee('import failing')
  vim.options['rtp'] = old_rtp
  del old_rtp
  cb.append("> Options")
  cb.append(">> OptionsItem")
  ee('vim.options["abcQ"]')
  ee('vim.options[""]')
  stringtochars_test('vim.options[%s]')
  cb.append(">> OptionsContains")
  stringtochars_test('%s in vim.options')
  cb.append("> Dictionary")
  cb.append(">> DictionaryConstructor")
  ee('vim.Dictionary("abcI")')
  ##! Not checked: py_dict_alloc failure
  cb.append(">> DictionarySetattr")
  ee('del d.locked')
  ee('d.locked = FailingTrue()')
  ee('vim.vvars.locked = False')
  ee('d.scope = True')
  ee('d.xxx = True')
  cb.append(">> _DictionaryItem")
  ee('d.get("a", 2, 3)')
  stringtochars_test('d.get(%s)')
  ee('d.pop("a")')
  ee('dl.pop("a")')
  cb.append(">> DictionaryContains")
  ee('"" in d')
  ee('0 in d')
  cb.append(">> DictionaryIterNext")
  ee('for i in ned: ned["a"] = 1')
  del i
  cb.append(">> DictionaryAssItem")
  ee('dl["b"] = 1')
  stringtochars_test('d[%s] = 1')
  convertfrompyobject_test('d["a"] = %s')
  cb.append(">> DictionaryUpdate")
  cb.append(">>> kwargs")
  cb.append(">>> iter")
  ee('d.update(FailingMapping())')
  ee('d.update([FailingIterNext()])')
  ee('d.update([FailingIterNextN(1)])')
  iter_test('d.update(%s)')
  convertfrompyobject_test('d.update(%s)')
  stringtochars_test('d.update(((%s, 0),))')
  convertfrompyobject_test('d.update((("a", %s),))')
  cb.append(">> DictionaryPopItem")
  ee('d.popitem(1, 2)')
  cb.append(">> DictionaryHasKey")
  ee('d.has_key()')
  cb.append("> List")
  cb.append(">> ListConstructor")
  ee('vim.List(1, 2)')
  ee('vim.List(a=1)')
  iter_test('vim.List(%s)')
  convertfrompyobject_test('vim.List([%s])')
  cb.append(">> ListItem")
  ee('l[1000]')
  cb.append(">> ListAssItem")
  ee('ll[1] = 2')
  ee('l[1000] = 3')
  cb.append(">> ListAssSlice")
  ee('ll[1:100] = "abcJ"')
  iter_test('l[:] = %s')
  ee('nel[1:10:2]  = "abcK"')
  cb.append(repr(tuple(nel)))
  ee('nel[1:10:2]  = "a"')
  cb.append(repr(tuple(nel)))
  ee('nel[1:1:-1]  = "a"')
  cb.append(repr(tuple(nel)))
  ee('nel[:] = FailingIterNextN(2)')
  cb.append(repr(tuple(nel)))
  convertfrompyobject_test('l[:] = [%s]')
  cb.append(">> ListConcatInPlace")
  iter_test('l.extend(%s)')
  convertfrompyobject_test('l.extend([%s])')
  cb.append(">> ListSetattr")
  ee('del l.locked')
  ee('l.locked = FailingTrue()')
  ee('l.xxx = True')
  cb.append("> Function")
  cb.append(">> FunctionConstructor")
  cb.append(">>> FunctionConstructor")
  ee('vim.Function("123")')
  ee('vim.Function("xxx_non_existent_function_xxx")')
  ee('vim.Function("xxx#non#existent#function#xxx")')
  ee('vim.Function("xxx_non_existent_function_xxx2", args=[])')
  ee('vim.Function("xxx_non_existent_function_xxx3", self={})')
  ee('vim.Function("xxx_non_existent_function_xxx4", args=[], self={})')
  cb.append(">>> FunctionNew")
  ee('vim.Function("tr", self="abcFuncSelf")')
  ee('vim.Function("tr", args=427423)')
  ee('vim.Function("tr", self="abcFuncSelf2", args="abcFuncArgs2")')
  ee('vim.Function(self="abcFuncSelf2", args="abcFuncArgs2")')
  ee('vim.Function("tr", "", self="abcFuncSelf2", args="abcFuncArgs2")')
  ee('vim.Function("tr", "")')
  cb.append(">> FunctionCall")
  convertfrompyobject_test('f(%s)')
  convertfrompymapping_test('fd(self=%s)')
  cb.append("> TabPage")
  cb.append(">> TabPageAttr")
  ee('vim.current.tabpage.xxx')
  cb.append("> TabList")
  cb.append(">> TabListItem")
  ee('vim.tabpages[1000]')
  cb.append("> Window")
  cb.append(">> WindowAttr")
  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')
  number_test('vim.current.window.height = %s', unsigned=True)
  number_test('vim.current.window.width = %s', unsigned=True)
  ee('vim.current.window.xxxxxx = True')
  cb.append("> WinList")
  cb.append(">> WinListItem")
  ee('vim.windows[1000]')
  cb.append("> Buffer")
  cb.append(">> StringToLine (indirect)")
  ee('vim.current.buffer[0] = "\\na"')
  ee('vim.current.buffer[0] = b"\\na"')
  cb.append(">> SetBufferLine (indirect)")
  ee('vim.current.buffer[0] = True')
  cb.append(">> SetBufferLineList (indirect)")
  ee('vim.current.buffer[:] = True')
  ee('vim.current.buffer[:] = ["\\na", "bc"]')
  cb.append(">> InsertBufferLines (indirect)")
  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[100000000]')
  cb.append(">> RBAsItem")
  ee('vim.current.buffer[100000000] = ""')
  cb.append(">> BufferAttr")
  ee('vim.current.buffer.xxx')
  cb.append(">> BufferSetattr")
  ee('vim.current.buffer.name = True')
  ee('vim.current.buffer.xxx = True')
  cb.append(">> BufferMark")
  ee('vim.current.buffer.mark(0)')
  ee('vim.current.buffer.mark("abcM")')
  ee('vim.current.buffer.mark("!")')
  cb.append(">> BufferRange")
  ee('vim.current.buffer.range(1, 2, 3)')
  cb.append("> BufMap")
  cb.append(">> BufMapItem")
  ee('vim.buffers[100000000]')
  number_test('vim.buffers[%s]', natural=True)
  cb.append("> Current")
  cb.append(">> CurrentGetattr")
  ee('vim.current.xxx')
  cb.append(">> CurrentSetattr")
  ee('vim.current.line = True')
  ee('vim.current.buffer = True')
  ee('vim.current.window = True')
  ee('vim.current.tabpage = True')
  ee('vim.current.xxx = True')
  del d
  del ned
  del dl
  del l
  del ll
  del nel
  del f
  del fd
  del fdel
  del subexpr_test
  del stringtochars_test
  del Mapping
  del convertfrompyobject_test
  del convertfrompymapping_test
  del iter_test
  del number_test
  del FailingTrue
  del FailingIter
  del FailingIterNext
  del FailingIterNextN
  del FailingMapping
  del FailingMappingKey
  del FailingList
  del NoArgsCall
  del FailingCall
  del FailingNumber
EOF
:delfunction F
:"
:" Test import
py3 << trim EOF
  sys.path.insert(0, os.path.join(os.getcwd(), 'python_before'))
  sys.path.append(os.path.join(os.getcwd(), 'python_after'))
  vim.options['rtp'] = os.getcwd().replace(',', '\\,').replace('\\', '\\\\')
  l = []
  def callback(path):
      l.append(os.path.relpath(path))
  vim.foreach_rtp(callback)
  cb.append(repr(l))
  del l
  def callback(path):
      return os.path.relpath(path)
  cb.append(repr(vim.foreach_rtp(callback)))
  del callback
  from module import dir as d
  from modulex import ddir
  cb.append(d + ',' + ddir)
  import before
  cb.append(before.dir)
  import after
  cb.append(after.dir)
  import topmodule as tm
  import topmodule.submodule as tms
  import topmodule.submodule.subsubmodule.subsubsubmodule as tmsss
  cb.append(tm.__file__.replace(os.path.sep, '/')[-len('modulex/topmodule/__init__.py'):])
  cb.append(tms.__file__.replace(os.path.sep, '/')[-len('modulex/topmodule/submodule/__init__.py'):])
  cb.append(tmsss.__file__.replace(os.path.sep, '/')[-len('modulex/topmodule/submodule/subsubmodule/subsubsubmodule.py'):])
  del before
  del after
  del d
  del ddir
  del tm
  del tms
  del tmsss
EOF
:"
:" Test exceptions
:fun Exe(e)
:   execute a:e
:endfun
py3 << trim EOF
  Exe = vim.bindeval('function("Exe")')
  ee('vim.command("throw \'abcN\'")')
  ee('Exe("throw \'def\'")')
  ee('vim.eval("Exe(\'throw \'\'ghi\'\'\')")')
  ee('vim.eval("Exe(\'echoerr \'\'jkl\'\'\')")')
  ee('vim.eval("Exe(\'xxx_non_existent_command_xxx\')")')
  ee('vim.eval("xxx_unknown_function_xxx()")')
  ee('vim.bindeval("Exe(\'xxx_non_existent_command_xxx\')")')
  del Exe
EOF
:delfunction Exe
:"
:" Regression: interrupting vim.command propagates to next vim.command
py3 << trim EOF
  def test_keyboard_interrupt():
      try:
          vim.command('while 1 | endwhile')
      except KeyboardInterrupt:
          cb.append('Caught KeyboardInterrupt')
      except Exception:
          cb.append('!!!!!!!! Caught exception: ' + emsg(sys.exc_info()))
      else:
          cb.append('!!!!!!!! No exception')
      try:
          vim.command('$ put =\'Running :put\'')
      except KeyboardInterrupt:
          cb.append('!!!!!!!! Caught KeyboardInterrupt')
      except Exception:
          cb.append('!!!!!!!! Caught exception: ' + emsg(sys.exc_info()))
      else:
          cb.append('No exception')
EOF
:debuggreedy
:call inputsave()
:call feedkeys("s\ns\ns\ns\nq\n")
:redir => output
:debug silent! py3 test_keyboard_interrupt()
:redir END
:0 debuggreedy
:call inputrestore()
:silent $put =output
:unlet output
:py3 del test_keyboard_interrupt
:"
:" Cleanup
py3 << trim EOF
  del cb
  del ee
  del emsg
  del sys
  del os
  del vim
EOF
:endfun
:"
:fun RunTest()
:let checkrefs = !empty($PYTHONDUMPREFS)
:let start = getline(1, '$')
:for i in range(checkrefs ? 10 : 1)
:   if i != 0
:       %d _
:       call setline(1, start)
:   endif
:   call Test()
:   if i == 0
:       let result = getline(1, '$')
:   endif
:endfor
:if checkrefs
:   %d _
:   call setline(1, result)
:endif
:endfun
:"
:call RunTest()
:delfunction RunTest
:delfunction Test
:call garbagecollect(1)
:"
:/^start:/,$wq! test.out
:/^start:/,$w! test.out
:" vim: et ts=4 isk-=\:
:while getchar(0) isnot 0|endwhile
ENDTEST

start: