Adding upstream version 2:9.0.1378.upstream/2%9.0.1378upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2040 insertions, 0 deletions

diff --git a/src/testdir/test_vim9_cmd.vim b/src/testdir/test_vim9_cmd.vim
new file mode 100644
index 0000000..0fe6e7c
--- /dev/null
+++ b/src/testdir/test_vim9_cmd.vim
@@ -0,0 +1,2040 @@
+" Test commands that are not compiled in a :def function
+
+source check.vim
+import './vim9.vim' as v9
+source term_util.vim
+source view_util.vim
+
+def Test_vim9cmd()
+  var lines =<< trim END
+    vim9cmd var x = 123
+    let s:y = 'yes'
+    vim9c assert_equal(123, x)
+    vim9cm assert_equal('yes', y)
+  END
+  v9.CheckScriptSuccess(lines)
+
+  assert_fails('vim9cmd', 'E1164:')
+  assert_fails('legacy', 'E1234:')
+  assert_fails('vim9cmd echo "con" . "cat"', 'E15:')
+
+  lines =<< trim END
+      let str = 'con'
+      vim9cmd str .= 'cat'
+  END
+  v9.CheckScriptFailure(lines, 'E492:')
+
+  lines =<< trim END
+      vim9script
+      legacy echo "con" . "cat"
+      legacy let str = 'con'
+      legacy let str .= 'cat'
+  END
+  v9.CheckScriptSuccess(lines)
+
+  lines =<< trim END
+      vim9script
+      def Foo()
+        g:found_bar = "bar"
+      enddef
+      nmap ,; :vim9cmd <SID>Foo()<CR>
+  END
+  v9.CheckScriptSuccess(lines)
+
+  feedkeys(',;', 'xt')
+  assert_equal("bar", g:found_bar)
+  nunmap ,;
+  unlet g:found_bar
+
+  lines =<< trim END
+      vim9script
+      legacy echo 1'000
+  END
+  v9.CheckScriptFailure(lines, 'E115:')
+
+  lines =<< trim END
+      vim9script
+      echo .10
+  END
+  v9.CheckScriptSuccess(lines)
+  lines =<< trim END
+      vim9cmd echo .10
+  END
+  v9.CheckScriptSuccess(lines)
+  lines =<< trim END
+      vim9script
+      legacy echo .10
+  END
+  v9.CheckScriptFailure(lines, 'E15:')
+
+  echo v:version
+  assert_fails('vim9cmd echo version', 'E121:')
+  lines =<< trim END
+      vim9script
+      echo version
+  END
+  v9.CheckScriptFailure(lines, 'E121:')
+  lines =<< trim END
+      vim9script
+      legacy echo version
+  END
+  v9.CheckScriptSuccess(lines)
+enddef
+
+def Test_defcompile_fails()
+  assert_fails('defcompile NotExists', 'E1061:')
+  assert_fails('defcompile debug debug Test_defcompile_fails', 'E488:')
+  assert_fails('defcompile profile profile Test_defcompile_fails', 'E488:')
+enddef
+
+defcompile Test_defcompile_fails
+defcompile debug Test_defcompile_fails
+defcompile profile Test_defcompile_fails
+
+def Test_cmdmod_execute()
+  # "legacy" applies not only to the "exe" argument but also to the commands
+  var lines =<< trim END
+      vim9script
+
+      b:undo = 'let g:undone = 1 | let g:undtwo = 2'
+      legacy exe b:undo
+      assert_equal(1, g:undone)
+      assert_equal(2, g:undtwo)
+  END
+  v9.CheckScriptSuccess(lines)
+
+  # same for "vim9cmd" modifier
+  lines =<< trim END
+      let b:undo = 'g:undone = 11 | g:undtwo = 22'
+      vim9cmd exe b:undo
+      call assert_equal(11, g:undone)
+      call assert_equal(22, g:undtwo)
+  END
+  v9.CheckScriptSuccess(lines)
+  unlet b:undo
+  unlet g:undone
+  unlet g:undtwo
+
+  # "legacy" does not apply to a loaded script
+  lines =<< trim END
+      vim9script
+      export var exported = 'x'
+  END
+  writefile(lines, 'Xvim9import.vim', 'D')
+  lines =<< trim END
+      legacy exe "import './Xvim9import.vim'"
+  END
+  v9.CheckScriptSuccess(lines)
+
+  # "legacy" does not apply to a called function
+  lines =<< trim END
+      vim9script
+
+      def g:TheFunc()
+        if exists('something')
+          echo 'yes'
+        endif
+      enddef
+      legacy exe 'call g:TheFunc()'
+  END
+  v9.CheckScriptSuccess(lines)
+  delfunc g:TheFunc
+
+  # vim9cmd execute(cmd) executes code in vim9 script context
+  lines =<< trim END
+    vim9cmd execute("g:vim9executetest = 'bar'")
+    call assert_equal('bar', g:vim9executetest)
+  END
+  v9.CheckScriptSuccess(lines)
+  unlet g:vim9executetest
+
+  lines =<< trim END
+    vim9cmd execute(["g:vim9executetest1 = 'baz'", "g:vim9executetest2 = 'foo'"])
+    call assert_equal('baz', g:vim9executetest1)
+    call assert_equal('foo', g:vim9executetest2)
+  END
+  v9.CheckScriptSuccess(lines)
+  unlet g:vim9executetest1
+  unlet g:vim9executetest2
+
+  # legacy call execute(cmd) executes code in vim script context
+  lines =<< trim END
+    vim9script
+    legacy call execute("let g:vim9executetest = 'bar'")
+    assert_equal('bar', g:vim9executetest)
+  END
+  v9.CheckScriptSuccess(lines)
+  unlet g:vim9executetest
+
+  lines =<< trim END
+    vim9script
+    legacy call execute(["let g:vim9executetest1 = 'baz'", "let g:vim9executetest2 = 'foo'"])
+    assert_equal('baz', g:vim9executetest1)
+    assert_equal('foo', g:vim9executetest2)
+  END
+  v9.CheckScriptSuccess(lines)
+  unlet g:vim9executetest1
+  unlet g:vim9executetest2
+enddef
+
+def Test_edit_wildcards()
+  var filename = 'Xtest'
+  edit `=filename`
+  assert_equal('Xtest', bufname())
+
+  var filenr = 123
+  edit Xtest`=filenr`
+  assert_equal('Xtest123', bufname())
+
+  filenr = 77
+  edit `=filename``=filenr`
+  assert_equal('Xtest77', bufname())
+
+  edit X`=filename`xx`=filenr`yy
+  assert_equal('XXtestxx77yy', bufname())
+
+  v9.CheckDefFailure(['edit `=xxx`'], 'E1001:')
+  v9.CheckDefFailure(['edit `="foo"'], 'E1083:')
+
+  var files = ['file 1', 'file%2', 'file# 3']
+  args `=files`
+  assert_equal(files, argv())
+
+  filename = 'Xwindo'
+  windo edit `=filename`
+  assert_equal('Xwindo', bufname())
+
+  filename = 'Xtabdo'
+  tabdo edit `=filename`
+  assert_equal('Xtabdo', bufname())
+
+  filename = 'Xargdo'
+  argdo edit `=filename`
+  assert_equal('Xargdo', bufname())
+
+  :%bwipe!
+  filename = 'Xbufdo'
+  bufdo file `=filename`
+  assert_equal('Xbufdo', bufname())
+enddef
+
+def Test_expand_alternate_file()
+  var lines =<< trim END
+    edit Xfileone
+    var bone = bufnr()
+    edit Xfiletwo
+    var btwo = bufnr()
+    edit Xfilethree
+    var bthree = bufnr()
+
+    edit #
+    assert_equal(bthree, bufnr())
+    edit %%
+    assert_equal(btwo, bufnr())
+    edit %% # comment
+    assert_equal(bthree, bufnr())
+    edit %%yy
+    assert_equal('Xfiletwoyy', bufname())
+
+    exe "edit %%" .. bone
+    assert_equal(bone, bufnr())
+    exe "edit %%" .. btwo .. "xx"
+    assert_equal('Xfiletwoxx', bufname())
+
+    next Xfileone Xfiletwo Xfilethree
+    assert_equal('Xfileone', argv(0))
+    assert_equal('Xfiletwo', argv(1))
+    assert_equal('Xfilethree', argv(2))
+    next %%%zz
+    assert_equal('Xfileone', argv(0))
+    assert_equal('Xfiletwo', argv(1))
+    assert_equal('Xfilethreezz', argv(2))
+
+    v:oldfiles = ['Xonefile', 'Xtwofile']
+    edit %%<1
+    assert_equal('Xonefile', bufname())
+    edit %%<2
+    assert_equal('Xtwofile', bufname())
+    assert_fails('edit %%<3', 'E684:')
+
+    edit Xfileone.vim
+    edit Xfiletwo
+    edit %%:r
+    assert_equal('Xfileone', bufname())
+
+    assert_false(bufexists('altfoo'))
+    edit altfoo
+    edit bar
+    assert_true(bufexists('altfoo'))
+    assert_true(buflisted('altfoo'))
+    bdel %%
+    assert_true(bufexists('altfoo'))
+    assert_false(buflisted('altfoo'))
+    bwipe! altfoo
+    bwipe! bar
+  END
+  v9.CheckDefAndScriptSuccess(lines)
+enddef
+
+def Test_global_backtick_expansion()
+  var name = 'xxx'
+  new
+  setline(1, ['one', 'two', 'three'])
+  set nomod
+  g/two/edit `=name`
+  assert_equal('xxx', bufname())
+  bwipe!
+
+  new
+  setline(1, ['one', 'two', 'three'])
+  g/two/s/^/`=name`/
+  assert_equal('`=name`two', getline(2))
+  bwipe!
+enddef
+
+def Test_folddo_backtick_expansion()
+  new
+  var name = 'xxx'
+  folddoopen edit `=name`
+  assert_equal('xxx', bufname())
+  bwipe!
+
+  new
+  setline(1, ['one', 'two'])
+  set nomodified
+  :1,2fold
+  foldclose
+  folddoclose edit `=name`
+  assert_equal('xxx', bufname())
+  bwipe!
+
+  var lines =<< trim END
+      g:val = 'value'
+      def Test()
+        folddoopen echo `=g:val`
+      enddef
+      call Test()
+  END
+  v9.CheckScriptFailure(lines, 'E15: Invalid expression: "`=g:val`"')
+enddef
+
+def Test_hardcopy_wildcards()
+  CheckUnix
+  CheckFeature postscript
+
+  var outfile = 'print'
+  hardcopy > X`=outfile`.ps
+  assert_true(filereadable('Xprint.ps'))
+
+  delete('Xprint.ps')
+enddef
+
+def Test_syn_include_wildcards()
+  writefile(['syn keyword Found found'], 'Xthemine.vim', 'D')
+  var save_rtp = &rtp
+  &rtp = '.'
+
+  var fname = 'mine'
+  syn include @Group Xthe`=fname`.vim
+  assert_match('Found.* contained found', execute('syn list Found'))
+
+  &rtp = save_rtp
+enddef
+
+def Test_echo_linebreak()
+  var lines =<< trim END
+      vim9script
+      redir @a
+      echo 'one'
+            .. 'two'
+      redir END
+      assert_equal("\nonetwo", @a)
+  END
+  v9.CheckScriptSuccess(lines)
+
+  lines =<< trim END
+      vim9script
+      redir @a
+      echo 11 +
+            77
+            - 22
+      redir END
+      assert_equal("\n66", @a)
+  END
+  v9.CheckScriptSuccess(lines)
+enddef
+
+def Test_condition_types()
+  var lines =<< trim END
+      if 'text'
+      endif
+  END
+  v9.CheckDefAndScriptFailure(lines, 'E1135:', 1)
+
+  lines =<< trim END
+      if [1]
+      endif
+  END
+  v9.CheckDefFailure(lines, 'E1012:', 1)
+  v9.CheckScriptFailure(['vim9script'] + lines, 'E745:', 2)
+
+  lines =<< trim END
+      g:cond = 'text'
+      if g:cond
+      endif
+  END
+  v9.CheckDefExecAndScriptFailure(lines, 'E1135:', 2)
+
+  lines =<< trim END
+      g:cond = 0
+      if g:cond
+      elseif 'text'
+      endif
+  END
+  v9.CheckDefAndScriptFailure(lines, 'E1135:', 3)
+
+  lines =<< trim END
+      g:cond = 0
+      if g:cond
+      elseif 'text' garbage
+      endif
+  END
+  v9.CheckDefAndScriptFailure(lines, 'E488:', 3)
+
+  lines =<< trim END
+      g:cond = 0
+      if g:cond
+      elseif [1]
+      endif
+  END
+  v9.CheckDefFailure(lines, 'E1012:', 3)
+  v9.CheckScriptFailure(['vim9script'] + lines, 'E745:', 4)
+
+  lines =<< trim END
+      g:cond = 'text'
+      if 0
+      elseif g:cond
+      endif
+  END
+  v9.CheckDefExecAndScriptFailure(lines, 'E1135:', 3)
+
+  lines =<< trim END
+      while 'text'
+      endwhile
+  END
+  v9.CheckDefFailure(lines, 'E1012:', 1)
+  v9.CheckScriptFailure(['vim9script'] + lines, 'E1135:', 2)
+
+  lines =<< trim END
+      while [1]
+      endwhile
+  END
+  v9.CheckDefFailure(lines, 'E1012:', 1)
+  v9.CheckScriptFailure(['vim9script'] + lines, 'E745:', 2)
+
+  lines =<< trim END
+      g:cond = 'text'
+      while g:cond
+      endwhile
+  END
+  v9.CheckDefExecAndScriptFailure(lines, 'E1135:', 2)
+enddef
+
+def Test_if_linebreak()
+  var lines =<< trim END
+      vim9script
+      if 1 &&
+            true
+            || 1
+        g:res = 42
+      endif
+      assert_equal(42, g:res)
+  END
+  v9.CheckScriptSuccess(lines)
+  unlet g:res
+
+  lines =<< trim END
+      vim9script
+      if 1 &&
+            0
+        g:res = 0
+      elseif 0 ||
+              0
+              || 1
+        g:res = 12
+      endif
+      assert_equal(12, g:res)
+  END
+  v9.CheckScriptSuccess(lines)
+  unlet g:res
+enddef
+
+def Test_while_linebreak()
+  var lines =<< trim END
+      vim9script
+      var nr = 0
+      while nr <
+              10 + 3
+            nr = nr
+                  + 4
+      endwhile
+      assert_equal(16, nr)
+  END
+  v9.CheckScriptSuccess(lines)
+
+  lines =<< trim END
+      vim9script
+      var nr = 0
+      while nr
+            <
+              10
+              +
+              3
+            nr = nr
+                  +
+                  4
+      endwhile
+      assert_equal(16, nr)
+  END
+  v9.CheckScriptSuccess(lines)
+enddef
+
+def Test_for_linebreak()
+  var lines =<< trim END
+      vim9script
+      var nr = 0
+      for x
+            in
+              [1, 2, 3, 4]
+          nr = nr + x
+      endfor
+      assert_equal(10, nr)
+  END
+  v9.CheckScriptSuccess(lines)
+
+  lines =<< trim END
+      vim9script
+      var nr = 0
+      for x
+            in
+              [1, 2,
+                  3, 4
+                  ]
+          nr = nr
+                 +
+                  x
+      endfor
+      assert_equal(10, nr)
+  END
+  v9.CheckScriptSuccess(lines)
+enddef
+
+def s:MethodAfterLinebreak(arg: string)
+  arg
+    ->setline(1)
+enddef
+
+def Test_method_call_linebreak()
+  var lines =<< trim END
+      vim9script
+      var res = []
+      func RetArg(
+            arg
+            )
+            let s:res = a:arg
+      endfunc
+      [1,
+          2,
+          3]->RetArg()
+      assert_equal([1, 2, 3], res)
+  END
+  v9.CheckScriptSuccess(lines)
+
+  lines =<< trim END
+      new
+      var name = [1, 2]
+      name
+          ->copy()
+          ->setline(1)
+      assert_equal(['1', '2'], getline(1, 2))
+      bwipe!
+  END
+  v9.CheckDefAndScriptSuccess(lines)
+
+  lines =<< trim END
+      new
+      def Foo(): string
+        return 'the text'
+      enddef
+      def Bar(F: func): string
+        return F()
+      enddef
+      def Test()
+        Foo  ->Bar()
+             ->setline(1)
+      enddef
+      Test()
+      assert_equal('the text', getline(1))
+      bwipe!
+  END
+  v9.CheckDefAndScriptSuccess(lines)
+
+  lines =<< trim END
+      new
+      g:shortlist
+          ->copy()
+          ->setline(1)
+      assert_equal(['1', '2'], getline(1, 2))
+      bwipe!
+  END
+  g:shortlist = [1, 2]
+  v9.CheckDefAndScriptSuccess(lines)
+  unlet g:shortlist
+
+  new
+  MethodAfterLinebreak('foobar')
+  assert_equal('foobar', getline(1))
+  bwipe!
+
+  lines =<< trim END
+      vim9script
+      def Foo(): string
+          return '# some text'
+      enddef
+
+      def Bar(F: func): string
+          return F()
+      enddef
+
+      Foo->Bar()
+         ->setline(1)
+  END
+  v9.CheckScriptSuccess(lines)
+  assert_equal('# some text', getline(1))
+  bwipe!
+enddef
+
+def Test_method_call_whitespace()
+  var lines =<< trim END
+    new
+    var yank = 'text'
+    yank->setline(1)
+    yank  ->setline(2)
+    yank->  setline(3)
+    yank  ->  setline(4)
+    assert_equal(['text', 'text', 'text', 'text'], getline(1, 4))
+    bwipe!
+  END
+  v9.CheckDefAndScriptSuccess(lines)
+enddef
+
+def Test_method_and_user_command()
+  var lines =<< trim END
+      vim9script
+      def Cmd()
+        g:didFunc = 1
+      enddef
+      command Cmd g:didCmd = 1
+      Cmd
+      assert_equal(1, g:didCmd)
+      Cmd()
+      assert_equal(1, g:didFunc)
+      unlet g:didFunc
+      unlet g:didCmd
+
+      def InDefFunc()
+        Cmd
+        assert_equal(1, g:didCmd)
+        Cmd()
+        assert_equal(1, g:didFunc)
+        unlet g:didFunc
+        unlet g:didCmd
+      enddef
+      InDefFunc()
+  END
+  v9.CheckScriptSuccess(lines)
+enddef
+
+def Test_option_use_linebreak()
+  var lines =<< trim END
+      new
+      &matchpairs = '(:)'
+      &matchpairs->setline(1)
+      &matchpairs = '[:]'
+      &matchpairs   ->setline(2)
+      &matchpairs = '{:}'
+      &matchpairs  
+          ->setline(3)
+      assert_equal(['(:)', '[:]', '{:}'], getline(1, '$'))
+      bwipe!
+  END
+  v9.CheckDefAndScriptSuccess(lines)
+enddef
+
+def Test_use_register()
+  var lines =<< trim END
+      new
+      @a = 'one'
+      @a->setline(1)
+      @b = 'two'
+      @b   ->setline(2)
+      @c = 'three'
+      @c  
+          ->setline(3)
+      assert_equal(['one', 'two', 'three'], getline(1, '$'))
+      bwipe!
+  END
+  v9.CheckDefAndScriptSuccess(lines)
+
+  lines =<< trim END
+      @a = 'echo "text"'
+      @a
+  END
+  v9.CheckDefAndScriptFailure(lines, 'E1207:', 2)
+
+  lines =<< trim END
+      @a = 'echo "text"'
+      @a
+
+  END
+  v9.CheckDefAndScriptFailure(lines, 'E1207:', 2)
+
+  lines =<< trim END
+      @a = 'echo "text"'
+      @a
+          # comment
+  END
+  v9.CheckDefAndScriptFailure(lines, 'E1207:', 2)
+
+  lines =<< trim END
+      @/ = 'pattern'
+      @/
+  END
+  v9.CheckDefAndScriptFailure(lines, 'E1207:', 2)
+
+  lines =<< trim END
+      &opfunc = 'nothing'
+      &opfunc
+  END
+  v9.CheckDefAndScriptFailure(lines, 'E1207:', 2)
+  &opfunc = ''
+
+  lines =<< trim END
+      &l:showbreak = 'nothing'
+      &l:showbreak
+  END
+  v9.CheckDefAndScriptFailure(lines, 'E1207:', 2)
+  &l:showbreak = ''
+
+  lines =<< trim END
+      &g:showbreak = 'nothing'
+      &g:showbreak
+  END
+  v9.CheckDefAndScriptFailure(lines, 'E1207:', 2)
+  &g:showbreak = ''
+
+  lines =<< trim END
+      $SomeEnv = 'value'
+      $SomeEnv
+  END
+  v9.CheckDefAndScriptFailure(lines, 'E1207:', 2)
+  $SomeEnv = ''
+
+  lines =<< trim END
+      eval 'value'
+  END
+  v9.CheckDefAndScriptFailure(lines, 'E1207:', 1)
+
+  lines =<< trim END
+      eval "value"
+  END
+  v9.CheckDefAndScriptFailure(lines, 'E1207:', 1)
+enddef
+
+def Test_environment_use_linebreak()
+  var lines =<< trim END
+      new
+      $TESTENV = 'one'
+      $TESTENV->setline(1)
+      $TESTENV = 'two'
+      $TESTENV  ->setline(2)
+      $TESTENV = 'three'
+      $TESTENV  
+          ->setline(3)
+      assert_equal(['one', 'two', 'three'], getline(1, '$'))
+      bwipe!
+  END
+  v9.CheckDefAndScriptSuccess(lines)
+enddef
+
+def Test_skipped_expr_linebreak()
+  if 0
+    var x = []
+               ->map(() => 0)
+  endif
+enddef
+
+def Test_dict_member()
+   var test: dict<list<number>> = {data: [3, 1, 2]}
+   test.data->sort()
+   assert_equal({data: [1, 2, 3]}, test)
+   test.data
+      ->reverse()
+   assert_equal({data: [3, 2, 1]}, test)
+
+  var lines =<< trim END
+      vim9script
+      var test: dict<list<number>> = {data: [3, 1, 2]}
+      test.data->sort()
+      assert_equal({data: [1, 2, 3]}, test)
+  END
+  v9.CheckScriptSuccess(lines)
+enddef
+
+def Test_bar_after_command()
+  def RedrawAndEcho()
+    var x = 'did redraw'
+    redraw | echo x
+  enddef
+  RedrawAndEcho()
+  assert_match('did redraw', g:Screenline(&lines))
+
+  def CallAndEcho()
+    var x = 'did redraw'
+    reg_executing() | echo x
+  enddef
+  CallAndEcho()
+  assert_match('did redraw', g:Screenline(&lines))
+
+  if has('unix')
+    # bar in filter write command does not start new command
+    def WriteToShell()
+      new
+      setline(1, 'some text')
+      w !cat | cat > Xoutfile
+      bwipe!
+    enddef
+    WriteToShell()
+    assert_equal(['some text'], readfile('Xoutfile'))
+    delete('Xoutfile')
+
+    # bar in filter read command does not start new command
+    def ReadFromShell()
+      new
+      r! echo hello there | cat > Xoutfile
+      r !echo again | cat >> Xoutfile
+      bwipe!
+    enddef
+    ReadFromShell()
+    assert_equal(['hello there', 'again'], readfile('Xoutfile'))
+    delete('Xoutfile')
+  endif
+enddef
+
+def Test_filter_is_not_modifier()
+  var tags = [{a: 1, b: 2}, {x: 3, y: 4}]
+  filter(tags, ( _, v) => has_key(v, 'x') ? 1 : 0 )
+  assert_equal([{x: 3, y: 4}], tags)
+enddef
+
+def Test_command_modifier_filter()
+  var lines =<< trim END
+    final expected = "\nType Name Content\n  c  \"c   piyo"
+    @a = 'hoge'
+    @b = 'fuga'
+    @c = 'piyo'
+
+    assert_equal(execute('filter /piyo/ registers abc'), expected)
+  END
+  v9.CheckDefAndScriptSuccess(lines)
+
+  # also do this compiled
+  lines =<< trim END
+      @a = 'very specific z3d37dh234 string'
+      filter z3d37dh234 registers
+      assert_match('very specific z3d37dh234 string', g:Screenline(&lines))
+  END
+  v9.CheckDefAndScriptSuccess(lines)
+
+  lines =<< trim END
+      edit foobar
+      redir => g:filter_out
+      filter #foobar# ls
+      redir END
+      assert_match('"foobar"', g:filter_out)
+      unlet g:filter_out
+  END
+  v9.CheckDefAndScriptSuccess(lines)
+enddef
+
+def Test_win_command_modifiers()
+  assert_equal(1, winnr('$'))
+
+  set splitright
+  vsplit
+  assert_equal(2, winnr())
+  close
+  aboveleft vsplit
+  assert_equal(1, winnr())
+  close
+  set splitright&
+
+  vsplit
+  assert_equal(1, winnr())
+  close
+  belowright vsplit
+  assert_equal(2, winnr())
+  close
+  rightbelow vsplit
+  assert_equal(2, winnr())
+  close
+
+  if has('browse')
+    browse set
+    assert_equal('option-window', expand('%'))
+    close
+  endif
+
+  vsplit
+  botright split
+  assert_equal(3, winnr())
+  assert_equal(&columns, winwidth(0))
+  close
+  close
+
+  vsplit
+  topleft split
+  assert_equal(1, winnr())
+  assert_equal(&columns, winwidth(0))
+  close
+  close
+
+  gettabinfo()->len()->assert_equal(1)
+  tab split
+  gettabinfo()->len()->assert_equal(2)
+  tabclose
+
+  vertical new
+  assert_inrange(&columns / 2 - 2, &columns / 2 + 1, winwidth(0))
+  close
+enddef
+
+func Test_command_modifier_confirm()
+  CheckNotGui
+  CheckRunVimInTerminal
+
+  " Test for saving all the modified buffers
+  let lines =<< trim END
+    call setline(1, 'changed')
+    def Getout()
+      confirm write Xcmodfile
+    enddef
+  END
+  call writefile(lines, 'Xconfirmscript', 'D')
+  call writefile(['empty'], 'Xcmodfile')
+  let buf = RunVimInTerminal('-S Xconfirmscript', {'rows': 8})
+  call term_sendkeys(buf, ":call Getout()\n")
+  call WaitForAssert({-> assert_match('(Y)es, \[N\]o: ', term_getline(buf, 8))}, 1000)
+  call term_sendkeys(buf, "y")
+  call WaitForAssert({-> assert_match('(Y)es, \[N\]o: ', term_getline(buf, 8))}, 1000)
+  call term_sendkeys(buf, "\<CR>")
+  call TermWait(buf)
+  call StopVimInTerminal(buf)
+
+  call assert_equal(['changed'], readfile('Xcmodfile'))
+  call delete('Xcmodfile')
+  call delete('.Xcmodfile.swp')  " in case Vim was killed
+endfunc
+
+def Test_command_modifiers_keep()
+  if has('unix')
+    def DoTest(addRflag: bool, keepMarks: bool, hasMarks: bool)
+      new
+      setline(1, ['one', 'two', 'three'])
+      normal 1Gma
+      normal 2Gmb
+      normal 3Gmc
+      if addRflag
+        set cpo+=R
+      else
+        set cpo-=R
+      endif
+      if keepMarks
+        keepmarks :%!cat
+      else
+        :%!cat
+      endif
+      if hasMarks
+        assert_equal(1, line("'a"))
+        assert_equal(2, line("'b"))
+        assert_equal(3, line("'c"))
+      else
+        assert_equal(0, line("'a"))
+        assert_equal(0, line("'b"))
+        assert_equal(0, line("'c"))
+      endif
+      quit!
+    enddef
+    DoTest(false, false, true)
+    DoTest(true, false, false)
+    DoTest(false, true, true)
+    DoTest(true, true, true)
+    set cpo&vim
+
+    new
+    setline(1, ['one', 'two', 'three', 'four'])
+    assert_equal(4, line("$"))
+    normal 1Gma
+    normal 2Gmb
+    normal 3Gmc
+    lockmarks :1,2!wc
+    # line is deleted, marks don't move
+    assert_equal(3, line("$"))
+    assert_equal('four', getline(3))
+    assert_equal(1, line("'a"))
+    assert_equal(2, line("'b"))
+    assert_equal(3, line("'c"))
+    quit!
+  endif
+
+  edit Xone
+  edit Xtwo
+  assert_equal('Xone', expand('#'))
+  keepalt edit Xthree
+  assert_equal('Xone', expand('#'))
+
+  normal /a*b*
+  assert_equal('a*b*', histget("search"))
+  keeppatterns normal /c*d*
+  assert_equal('a*b*', histget("search"))
+
+  new
+  setline(1, range(10))
+  :10
+  normal gg
+  assert_equal(10, getpos("''")[1])
+  keepjumps normal 5G
+  assert_equal(10, getpos("''")[1])
+  quit!
+enddef
+
+def Test_bar_line_continuation()
+  var lines =<< trim END
+      au BufNewFile XveryNewFile g:readFile = 1
+          | g:readExtra = 2
+      g:readFile = 0
+      g:readExtra = 0
+      edit XveryNewFile
+      assert_equal(1, g:readFile)
+      assert_equal(2, g:readExtra)
+      bwipe!
+      au! BufNewFile
+
+      au BufNewFile XveryNewFile g:readFile = 1
+          | g:readExtra = 2
+          | g:readMore = 3
+      g:readFile = 0
+      g:readExtra = 0
+      g:readMore = 0
+      edit XveryNewFile
+      assert_equal(1, g:readFile)
+      assert_equal(2, g:readExtra)
+      assert_equal(3, g:readMore)
+      bwipe!
+      au! BufNewFile
+      unlet g:readFile
+      unlet g:readExtra
+      unlet g:readMore
+  END
+  v9.CheckDefAndScriptSuccess(lines)
+enddef
+
+def Test_command_modifier_other()
+  new Xsomefile
+  setline(1, 'changed')
+  var buf = bufnr()
+  hide edit Xotherfile
+  var info = getbufinfo(buf)
+  assert_equal(1, info[0].hidden)
+  assert_equal(1, info[0].changed)
+  edit Xsomefile
+  bwipe!
+
+  au BufNewFile Xcmofile g:readFile = 1
+  g:readFile = 0
+  edit Xcmofile
+  assert_equal(1, g:readFile)
+  bwipe!
+  g:readFile = 0
+  noautocmd edit Xcmofile
+  assert_equal(0, g:readFile)
+  au! BufNewFile
+  unlet g:readFile
+
+  noswapfile edit XnoSwap
+  assert_equal(false, &l:swapfile)
+  bwipe!
+
+  var caught = false
+  try
+    sandbox !ls
+  catch /E48:/
+    caught = true
+  endtry
+  assert_true(caught)
+
+  :8verbose g:verbose_now = &verbose
+  assert_equal(8, g:verbose_now)
+  unlet g:verbose_now
+enddef
+
+def s:EchoHere()
+  echomsg 'here'
+enddef
+def s:EchoThere()
+  unsilent echomsg 'there'
+enddef
+
+def Test_modifier_silent_unsilent()
+  echomsg 'last one'
+  silent echomsg "text"
+  assert_equal("\nlast one", execute(':1messages'))
+
+  silent! echoerr "error"
+
+  echomsg 'last one'
+  silent EchoHere()
+  assert_equal("\nlast one", execute(':1messages'))
+
+  silent EchoThere()
+  assert_equal("\nthere", execute(':1messages'))
+
+  try
+    silent eval [][0]
+  catch
+    echomsg "caught"
+  endtry
+  assert_equal("\ncaught", execute(':1messages'))
+
+  var lines =<< trim END
+      vim9script
+      set history=11
+      silent! while 0
+        set history=22
+      silent! endwhile
+      assert_equal(11, &history)
+      set history&
+  END
+  v9.CheckScriptSuccess(lines)
+enddef
+
+def Test_range_after_command_modifier()
+  v9.CheckScriptFailure(['vim9script', 'silent keepjump 1d _'], 'E1050: Colon required before a range: 1d _', 2)
+  new
+  setline(1, 'xxx')
+  v9.CheckScriptSuccess(['vim9script', 'silent keepjump :1d _'])
+  assert_equal('', getline(1))
+  bwipe!
+
+  var lines =<< trim END
+      legacy /pat/
+  END
+  v9.CheckDefExecAndScriptFailure(lines, 'E486: Pattern not found: pat')
+enddef
+
+def Test_silent_pattern()
+  new
+  silent! :/pat/put _
+  bwipe!
+enddef
+
+def Test_useless_command_modifier()
+  g:maybe = true
+  var lines =<< trim END
+      if g:maybe
+      silent endif
+  END
+  v9.CheckDefAndScriptFailure(lines, 'E1176:', 2)
+
+  lines =<< trim END
+      for i in [0]
+      silent endfor
+  END
+  v9.CheckDefFailure(lines, 'E1176:', 2)
+  v9.CheckScriptSuccess(['vim9script'] + lines)
+
+  lines =<< trim END
+      while g:maybe
+      silent endwhile
+  END
+  v9.CheckDefFailure(lines, 'E1176:', 2)
+  g:maybe = false
+  v9.CheckScriptSuccess(['vim9script'] + lines)
+
+  lines =<< trim END
+      silent try
+      finally
+      endtry
+  END
+  v9.CheckDefAndScriptFailure(lines, 'E1176:', 1)
+
+  lines =<< trim END
+      try
+      silent catch
+      endtry
+  END
+  v9.CheckDefAndScriptFailure(lines, 'E1176:', 2)
+
+  lines =<< trim END
+      try
+      silent finally
+      endtry
+  END
+  v9.CheckDefAndScriptFailure(lines, 'E1176:', 2)
+
+  lines =<< trim END
+      try
+      finally
+      silent endtry
+  END
+  v9.CheckDefAndScriptFailure(lines, 'E1176:', 3)
+
+  lines =<< trim END
+      leftabove
+  END
+  v9.CheckDefAndScriptFailure(lines, 'E1082:', 1)
+
+  lines =<< trim END
+      leftabove # comment
+  END
+  v9.CheckDefAndScriptFailure(lines, 'E1082:', 1)
+enddef
+
+def Test_eval_command()
+  var from = 3
+  var to = 5
+  g:val = 111
+  def Increment(nrs: list<number>)
+    for nr in nrs
+      g:val += nr
+    endfor
+  enddef
+  eval range(from, to)
+        ->Increment()
+  assert_equal(111 + 3 + 4 + 5, g:val)
+  unlet g:val
+
+  var lines =<< trim END
+    vim9script
+    g:caught = 'no'
+    try
+      eval 123 || 0
+    catch
+      g:caught = 'yes'
+    endtry
+    assert_equal('yes', g:caught)
+    unlet g:caught
+  END
+  v9.CheckScriptSuccess(lines)
+enddef
+
+def Test_map_command()
+  var lines =<< trim END
+      nnoremap <F3> :echo 'hit F3 #'<CR>
+      assert_equal(":echo 'hit F3 #'<CR>", maparg("<F3>", "n"))
+  END
+  v9.CheckDefAndScriptSuccess(lines)
+
+  # backslash before bar is not removed
+  lines =<< trim END
+      vim9script
+
+      def Init()
+        noremap <buffer> <F5> <ScriptCmd>MyFunc('a') \| MyFunc('b')<CR>
+      enddef
+      Init()
+      unmap <buffer> <F5>
+  END
+  v9.CheckScriptSuccess(lines)
+enddef
+
+def Test_normal_command()
+  new
+  setline(1, 'doesnotexist')
+  var caught = 0
+  try
+    exe "norm! \<C-]>"
+  catch /E433/
+    caught = 2
+  endtry
+  assert_equal(2, caught)
+
+  try
+    exe "norm! 3\<C-]>"
+  catch /E433/
+    caught = 3
+  endtry
+  assert_equal(3, caught)
+  bwipe!
+enddef
+
+def Test_put_command()
+  new
+  @p = 'ppp'
+  put p
+  assert_equal('ppp', getline(2))
+
+  put ='below'
+  assert_equal('below', getline(3))
+  put! ='above'
+  assert_equal('above', getline(3))
+  assert_equal('below', getline(4))
+
+  :2put =['a', 'b', 'c']
+  assert_equal(['ppp', 'a', 'b', 'c', 'above'], getline(2, 6))
+
+  :0put =  'first'
+  assert_equal('first', getline(1))
+  :1put! ='first again'
+  assert_equal('first again', getline(1))
+
+  # compute range at runtime
+  :%del
+  setline(1, range(1, 8))
+  @a = 'aaa'
+  :$-2put a
+  assert_equal('aaa', getline(7))
+
+  setline(1, range(1, 8))
+  :2
+  :+2put! a
+  assert_equal('aaa', getline(4))
+
+  []->mapnew(() => 0)
+  :$put ='end'
+  assert_equal('end', getline('$'))
+
+  bwipe!
+
+  v9.CheckDefFailure(['put =xxx'], 'E1001:')
+enddef
+
+def Test_put_with_linebreak()
+  new
+  var lines =<< trim END
+    vim9script
+    pu =split('abc', '\zs')
+            ->join()
+  END
+  v9.CheckScriptSuccess(lines)
+  getline(2)->assert_equal('a b c')
+  bwipe!
+enddef
+
+def Test_command_star_range()
+  new
+  setline(1, ['xxx foo xxx', 'xxx bar xxx', 'xxx foo xx bar'])
+  setpos("'<", [0, 1, 0, 0])
+  setpos("'>", [0, 3, 0, 0])
+  :*s/\(foo\|bar\)/baz/g
+  getline(1, 3)->assert_equal(['xxx baz xxx', 'xxx baz xxx', 'xxx baz xx baz'])
+
+  bwipe!
+enddef
+
+def Test_f_args()
+  var lines =<< trim END
+    vim9script
+
+    func SaveCmdArgs(...)
+      let g:args = a:000
+    endfunc
+
+    command -nargs=* TestFArgs call SaveCmdArgs(<f-args>)
+
+    TestFArgs
+    assert_equal([], g:args)
+
+    TestFArgs one two three
+    assert_equal(['one', 'two', 'three'], g:args)
+  END
+  v9.CheckScriptSuccess(lines)
+enddef
+
+def Test_user_command_comment()
+  command -nargs=1 Comd echom <q-args>
+
+  var lines =<< trim END
+      vim9script
+      Comd # comment
+  END
+  v9.CheckScriptSuccess(lines)
+
+  lines =<< trim END
+      vim9script
+      Comd# comment
+  END
+  v9.CheckScriptFailure(lines, 'E1144:')
+  delcommand Comd
+
+  lines =<< trim END
+      vim9script
+      command Foo echo 'Foo'
+      Foo3Bar
+  END
+  v9.CheckScriptFailure(lines, 'E1144: Command "Foo" is not followed by white space: Foo3Bar')
+
+  delcommand Foo
+enddef
+
+def Test_star_command()
+  var lines =<< trim END
+    vim9script
+    @s = 'g:success = 8'
+    set cpo+=*
+    exe '*s'
+    assert_equal(8, g:success)
+    unlet g:success
+    set cpo-=*
+    assert_fails("exe '*s'", 'E1050:')
+  END
+  v9.CheckScriptSuccess(lines)
+enddef
+
+def Test_cmd_argument_without_colon()
+  new Xawcfile
+  setline(1, ['a', 'b', 'c', 'd'])
+  write
+  edit +3 %
+  assert_equal(3, getcurpos()[1])
+  edit +/a %
+  assert_equal(1, getcurpos()[1])
+  bwipe
+  delete('Xawcfile')
+enddef
+
+def Test_ambiguous_user_cmd()
+  command Cmd1 eval 0
+  command Cmd2 eval 0
+  var lines =<< trim END
+      Cmd
+  END
+  v9.CheckDefAndScriptFailure(lines, 'E464:', 1)
+  delcommand Cmd1
+  delcommand Cmd2
+enddef
+
+def Test_command_not_recognized()
+  var lines =<< trim END
+    d.key = 'asdf'
+  END
+  v9.CheckDefFailure(lines, 'E1089: Unknown variable: d', 1)
+
+  lines =<< trim END
+    d['key'] = 'asdf'
+  END
+  v9.CheckDefFailure(lines, 'E1089: Unknown variable: d', 1)
+
+  lines =<< trim END
+    if 0
+      d.key = 'asdf'
+    endif
+  END
+  v9.CheckDefSuccess(lines)
+enddef
+
+def Test_magic_not_used()
+  new
+  for cmd in ['set magic', 'set nomagic']
+    exe cmd
+    setline(1, 'aaa')
+    s/.../bbb/
+    assert_equal('bbb', getline(1))
+  endfor
+
+  set magic
+  setline(1, 'aaa')
+  assert_fails('s/.\M../bbb/', 'E486:')
+  assert_fails('snomagic/.../bbb/', 'E486:')
+  assert_equal('aaa', getline(1))
+
+  bwipe!
+enddef
+
+def Test_gdefault_not_used()
+  new
+  for cmd in ['set gdefault', 'set nogdefault']
+    exe cmd
+    setline(1, 'aaa')
+    s/./b/
+    assert_equal('baa', getline(1))
+  endfor
+
+  set nogdefault
+  bwipe!
+enddef
+
+def s:SomeComplFunc(findstart: number, base: string): any
+  if findstart
+    return 0
+  else
+    return ['aaa', 'bbb']
+  endif
+enddef
+
+def Test_insert_complete()
+  # this was running into an error with the matchparen hack
+  new
+  set completefunc=SomeComplFunc
+  feedkeys("i\<c-x>\<c-u>\<Esc>", 'ntx')
+  assert_equal('aaa', getline(1))
+
+  set completefunc=
+  bwipe!
+enddef
+
+def Test_wincmd()
+  split
+  var id1 = win_getid()
+  if true
+    try | wincmd w | catch | endtry
+  endif
+  assert_notequal(id1, win_getid())
+  close
+
+  split
+  var id = win_getid()
+  split
+  :2wincmd o
+  assert_equal(id, win_getid())
+  only
+
+  split
+  split
+  assert_equal(3, winnr('$'))
+  :2wincmd c
+  assert_equal(2, winnr('$'))
+  only
+
+  split
+  split
+  assert_equal(3, winnr('$'))
+  :2wincmd q
+  assert_equal(2, winnr('$'))
+  only
+enddef
+
+def Test_windo_missing_endif()
+  var lines =<< trim END
+      windo if 1
+  END
+  v9.CheckDefExecFailure(lines, 'E171:', 1)
+enddef
+
+let s:theList = [1, 2, 3]
+
+def Test_lockvar()
+  s:theList[1] = 22
+  assert_equal([1, 22, 3], s:theList)
+  lockvar s:theList
+  assert_fails('theList[1] = 77', 'E741:')
+  unlockvar s:theList
+  s:theList[1] = 44
+  assert_equal([1, 44, 3], s:theList)
+
+  if 0
+    lockvar whatever
+  endif
+
+  g:lockme = [1, 2, 3]
+  lockvar 1 g:lockme
+  g:lockme[1] = 77
+  assert_equal([1, 77, 3], g:lockme)
+
+  lockvar 2 g:lockme
+  var caught = false
+  try
+    g:lockme[1] = 99
+  catch /E1119:/
+    caught = true
+  endtry
+  assert_true(caught)
+  assert_equal([1, 77, 3], g:lockme)
+  unlet g:lockme
+
+  # also for non-materialized list
+  g:therange = range(3)
+  lockvar 2 g:therange
+  caught = false
+  try
+    g:therange[1] = 99
+  catch /E1119:/
+    caught = true
+  endtry
+  assert_true(caught)
+  assert_equal([0, 1, 2], g:therange)
+  unlet g:therange
+
+  # use exclamation mark for locking deeper
+  g:nestedlist = [1, [2, 3], 4]
+  lockvar! g:nestedlist
+  try
+    g:nestedlist[1][0] = 9
+  catch /E1119:/
+    caught = true
+  endtry
+  assert_true(caught)
+  unlet g:nestedlist
+
+  var d = {a: 1, b: 2}
+  d.a = 3
+  d.b = 4
+  assert_equal({a: 3, b: 4}, d)
+  lockvar d.a
+  d.b = 5
+  var ex = ''
+  try
+    d.a = 6
+  catch
+    ex = v:exception
+  endtry
+  assert_match('E1121:', ex)
+  unlockvar d['a']
+  d.a = 7
+  assert_equal({a: 7, b: 5}, d)
+
+  caught = false
+  try
+    lockvar d.c
+  catch /E716/
+    caught = true
+  endtry
+  assert_true(caught)
+
+  var lines =<< trim END
+      vim9script
+      g:bl = 0z1122
+      lockvar g:bl
+      def Tryit()
+        g:bl[1] = 99
+      enddef
+      Tryit()
+  END
+  v9.CheckScriptFailure(lines, 'E741:', 1)
+
+  lines =<< trim END
+      vim9script
+      var theList = [1, 2, 3]
+      def SetList()
+        theList[1] = 22
+        assert_equal([1, 22, 3], theList)
+        lockvar theList
+        theList[1] = 77
+      enddef
+      SetList()
+  END
+  v9.CheckScriptFailure(lines, 'E1119', 4)
+
+  lines =<< trim END
+      vim9script
+      var theList = [1, 2, 3]
+      def AddToList()
+        lockvar theList
+        theList += [4]
+      enddef
+      AddToList()
+  END
+  v9.CheckScriptFailure(lines, 'E741', 2)
+
+  lines =<< trim END
+      vim9script
+      var theList = [1, 2, 3]
+      def AddToList()
+        lockvar theList
+        add(theList, 4)
+      enddef
+      AddToList()
+  END
+  v9.CheckScriptFailure(lines, 'E741', 2)
+
+  # can unlet a locked list item but not change it
+  lines =<< trim END
+    var ll = [1, 2, 3]
+    lockvar ll[1]
+    unlet ll[1]
+    assert_equal([1, 3], ll)
+  END
+  v9.CheckDefAndScriptSuccess(lines)
+  lines =<< trim END
+    var ll = [1, 2, 3]
+    lockvar ll[1]
+    ll[1] = 9
+  END
+  v9.CheckDefExecAndScriptFailure(lines, ['E1119:', 'E741'], 3)
+
+  # can unlet a locked dict item but not change it
+  lines =<< trim END
+    var dd = {a: 1, b: 2}
+    lockvar dd.a
+    unlet dd.a
+    assert_equal({b: 2}, dd)
+  END
+  v9.CheckDefAndScriptSuccess(lines)
+  lines =<< trim END
+    var dd = {a: 1, b: 2}
+    lockvar dd.a
+    dd.a = 3
+  END
+  v9.CheckDefExecAndScriptFailure(lines, ['E1121:', 'E741'], 3)
+
+  lines =<< trim END
+      var theList = [1, 2, 3]
+      lockvar theList
+  END
+  v9.CheckDefFailure(lines, 'E1178', 2)
+
+  lines =<< trim END
+      var theList = [1, 2, 3]
+      unlockvar theList
+  END
+  v9.CheckDefFailure(lines, 'E1178', 2)
+
+  lines =<< trim END
+      vim9script
+      var name = 'john'
+      lockvar nameX
+  END
+  v9.CheckScriptFailure(lines, 'E1246', 3)
+
+  lines =<< trim END
+      vim9script
+      var name = 'john'
+      def LockIt()
+        lockvar nameX
+      enddef
+      LockIt()
+  END
+  v9.CheckScriptFailure(lines, 'E1246', 1)
+
+  lines =<< trim END
+      vim9script
+      const name = 'john'
+      unlockvar name
+  END
+  v9.CheckScriptFailure(lines, 'E46', 3)
+
+  lines =<< trim END
+      vim9script
+      const name = 'john'
+      def UnLockIt()
+        unlockvar name
+      enddef
+      UnLockIt()
+  END
+  v9.CheckScriptFailure(lines, 'E46', 1)
+
+  lines =<< trim END
+      def _()
+        lockv
+      enddef
+      defcomp
+  END
+  v9.CheckScriptFailure(lines, 'E179', 1)
+
+  lines =<< trim END
+      def T()
+        unlet
+      enddef
+      defcomp
+  END
+  v9.CheckScriptFailure(lines, 'E179', 1)
+enddef
+
+def Test_substitute_expr()
+  var to = 'repl'
+  new
+  setline(1, 'one from two')
+  s/from/\=to
+  assert_equal('one repl two', getline(1))
+
+  setline(1, 'one from two')
+  s/from/\=to .. '_x'
+  assert_equal('one repl_x two', getline(1))
+
+  setline(1, 'one from two from three')
+  var also = 'also'
+  s/from/\=to .. '_' .. also/g#e
+  assert_equal('one repl_also two repl_also three', getline(1))
+
+  setline(1, 'abc abc abc')
+  for choice in [true, false]
+    :1s/abc/\=choice ? 'yes' : 'no'/
+  endfor
+  assert_equal('yes no abc', getline(1))
+
+  setline(1, 'from')
+  v9.CheckDefExecFailure(['s/from/\=g:notexist/'], 'E121: Undefined variable: g:notexist')
+
+  bwipe!
+
+  v9.CheckDefFailure(['s/from/\="x")/'], 'E488:')
+  v9.CheckDefFailure(['s/from/\="x"/9'], 'E488:')
+
+  v9.CheckDefExecFailure(['s/this/\="that"/'], 'E486:')
+
+  # When calling a function the right instruction list needs to be restored.
+  g:cond = true
+  var lines =<< trim END
+      vim9script
+      def Foo()
+          Bar([])
+      enddef
+      def Bar(l: list<number>)
+        if g:cond
+          s/^/\=Rep()/
+          for n in l[:]
+          endfor
+        endif
+      enddef
+      def Rep(): string
+          return 'rep'
+      enddef
+      new
+      Foo()
+      assert_equal('rep', getline(1))
+      bwipe!
+  END
+  v9.CheckScriptSuccess(lines)
+  unlet g:cond
+
+  # List results in multiple lines
+  new
+  setline(1, 'some text here')
+  s/text/\=['aaa', 'bbb', 'ccc']/
+  assert_equal(['some aaa', 'bbb', 'ccc', ' here'], getline(1, '$'))
+  bwipe!
+
+  # inside "if 0" substitute is ignored
+  if 0
+    s/a/\=nothing/ and | some more
+  endif
+enddef
+
+def Test_redir_to_var()
+  var result: string
+  redir => result
+    echo 'something'
+  redir END
+  assert_equal("\nsomething", result)
+
+  redir =>> result
+    echo 'more'
+  redir END
+  assert_equal("\nsomething\nmore", result)
+
+  var d: dict<string>
+  redir => d.redir
+    echo 'dict'
+  redir END
+  assert_equal({redir: "\ndict"}, d)
+
+  var l = ['a', 'b', 'c']
+  redir => l[1]
+    echo 'list'
+  redir END
+  assert_equal(['a', "\nlist", 'c'], l)
+
+  var dl = {l: ['x']}
+  redir => dl.l[0]
+    echo 'dict-list'
+  redir END
+  assert_equal({l: ["\ndict-list"]}, dl)
+
+  redir =>> d.redir
+    echo 'more'
+  redir END
+  assert_equal({redir: "\ndict\nmore"}, d)
+
+  var lines =<< trim END
+    redir => notexist
+  END
+  v9.CheckDefFailure(lines, 'E1089:')
+
+  lines =<< trim END
+    var text: string
+    redir => text
+  END
+  v9.CheckDefFailure(lines, 'E1185:')
+
+  lines =<< trim END
+    var ls = 'asdf'
+    redir => ls[1]
+    redir END
+  END
+  v9.CheckDefFailure(lines, 'E1141:')
+
+  lines =<< trim END
+      var text: string
+      redir => text
+        echo 'hello'
+        redir > Xnopfile
+      redir END
+  END
+  v9.CheckDefFailure(lines, 'E1092:')
+
+  lines =<< trim END
+      var text: number
+      redir => text
+        echo 'hello'
+      redir END
+  END
+  v9.CheckDefFailure(lines, 'E1012:')
+enddef
+
+def Test_echo_void()
+  var lines =<< trim END
+      vim9script
+      def NoReturn()
+        echo 'nothing'
+      enddef
+      echo NoReturn()
+  END
+  v9.CheckScriptFailure(lines, 'E1186:', 5)
+
+  lines =<< trim END
+      vim9script
+      def NoReturn()
+        echo 'nothing'
+      enddef
+      def Try()
+        echo NoReturn()
+      enddef
+      defcompile
+  END
+  v9.CheckScriptFailure(lines, 'E1186:', 1)
+enddef
+
+def Test_cmdwin_block()
+  augroup justTesting
+    autocmd BufEnter * {
+      echomsg 'in block'
+    }
+  augroup END
+  feedkeys('q:', 'xt')
+  redraw
+  feedkeys("aclose\<CR>", 'xt')
+
+  au! justTesting
+enddef
+
+def Test_var_not_cmd()
+  var lines =<< trim END
+      g:notexist:cmd
+  END
+  v9.CheckDefAndScriptFailure(lines, ['E1016: Cannot declare a global variable: g:notexist', "E1069: White space required after ':'"], 1)
+
+  lines =<< trim END
+      g-pat-cmd
+  END
+  v9.CheckDefAndScriptFailure(lines, 'E1241:', 1)
+  lines =<< trim END
+      g.pat.cmd
+  END
+  v9.CheckDefAndScriptFailure(lines, ['E1001: Variable not found: g', 'E121: Undefined variable: g'], 1)
+
+  lines =<< trim END
+      s:notexist:repl
+  END
+  v9.CheckDefAndScriptFailure(lines, ['E1101: Cannot declare a script variable in a function: s:notexist', "E1069: White space required after ':'"], 1)
+
+  lines =<< trim END
+      notexist:repl
+  END
+  v9.CheckDefAndScriptFailure(lines, ['E476:', 'E492:'], 1)
+
+  lines =<< trim END
+      s-pat-repl
+  END
+  v9.CheckDefAndScriptFailure(lines, 'E1241:', 1)
+  lines =<< trim END
+      s.pat.repl
+  END
+  v9.CheckDefAndScriptFailure(lines, ['E1001: Variable not found: s', 'E121: Undefined variable: s'], 1)
+
+  lines =<< trim END
+      w:notexist->len()
+  END
+  v9.CheckDefExecAndScriptFailure(lines, 'E121: Undefined variable: w:notexist', 1)
+
+  lines =<< trim END
+      b:notexist->len()
+  END
+  v9.CheckDefExecAndScriptFailure(lines, 'E121: Undefined variable: b:notexist', 1)
+
+  lines =<< trim END
+      t:notexist->len()
+  END
+  v9.CheckDefExecAndScriptFailure(lines, 'E121: Undefined variable: t:notexist', 1)
+enddef
+
+def Test_no_space_after_command()
+  var lines =<< trim END
+      g /pat/cmd
+  END
+  v9.CheckDefAndScriptFailure(lines, 'E1242:', 1)
+  lines =<< trim END
+      g #pat#cmd
+  END
+  v9.CheckDefAndScriptFailure(lines, 'E1242:', 1)
+
+  new
+  setline(1, 'some pat')
+  lines =<< trim END
+      g#pat#print
+  END
+  v9.CheckDefAndScriptSuccess(lines)
+  lines =<< trim END
+      g# pat#print
+  END
+  v9.CheckDefAndScriptSuccess(lines)
+  bwipe!
+
+  lines =<< trim END
+      s /pat/repl
+  END
+  v9.CheckDefAndScriptFailure(lines, 'E1242:', 1)
+  lines =<< trim END
+      s #pat#repl
+  END
+  v9.CheckDefAndScriptFailure(lines, 'E1242:', 1)
+  lines =<< trim END
+      s#pat#repl
+  END
+  v9.CheckDefExecAndScriptFailure(lines, 'E486:', 1)
+  lines =<< trim END
+      s# pat#repl
+  END
+  v9.CheckDefExecAndScriptFailure(lines, 'E486:', 1)
+enddef
+
+" Test for the 'previewpopup' option
+def Test_previewpopup()
+  set previewpopup=height:10,width:60
+  pedit Xppfile
+  var id = popup_findpreview()
+  assert_notequal(id, 0)
+  assert_match('Xppfile', popup_getoptions(id).title)
+  popup_clear()
+  set previewpopup&
+enddef
+
+def Test_syntax_enable_clear()
+  syntax clear
+  syntax enable
+  highlight clear String
+  assert_equal(true, hlget('String')->get(0, {})->get('default', false))
+  syntax clear
+enddef
+
+
+" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker