Merge remote-tracking branch 'upstream/master' into aucmd_textputpostaucmd_textputpost

1 files changed, 0 insertions, 6236 deletions

diff --git a/src/nvim/testdir/test_quickfix.vim b/src/nvim/testdir/test_quickfix.vim
deleted file mode 100644
index 8dc4173d60..0000000000
--- a/src/nvim/testdir/test_quickfix.vim
+++ /dev/null
@@ -1,6236 +0,0 @@
-" Test for the quickfix feature.
-
-source check.vim
-source vim9.vim
-CheckFeature quickfix
-
-source screendump.vim
-
-set encoding=utf-8
-
-func s:setup_commands(cchar)
-  if a:cchar == 'c'
-    command! -nargs=* -bang Xlist <mods>clist<bang> <args>
-    command! -nargs=* Xgetexpr <mods>cgetexpr <args>
-    command! -nargs=* Xaddexpr <mods>caddexpr <args>
-    command! -nargs=* -count Xolder <mods><count>colder <args>
-    command! -nargs=* Xnewer <mods>cnewer <args>
-    command! -nargs=* Xopen <mods> copen <args>
-    command! -nargs=* Xwindow <mods>cwindow <args>
-    command! -nargs=* Xbottom <mods>cbottom <args>
-    command! -nargs=* Xclose <mods>cclose <args>
-    command! -nargs=* -bang Xfile <mods>cfile<bang> <args>
-    command! -nargs=* Xgetfile <mods>cgetfile <args>
-    command! -nargs=* Xaddfile <mods>caddfile <args>
-    command! -nargs=* -bang Xbuffer <mods>cbuffer<bang> <args>
-    command! -nargs=* Xgetbuffer <mods>cgetbuffer <args>
-    command! -nargs=* Xaddbuffer <mods>caddbuffer <args>
-    command! -nargs=* Xrewind <mods>crewind <args>
-    command! -count -nargs=* -bang Xnext <mods><count>cnext<bang> <args>
-    command! -count -nargs=* -bang Xprev <mods><count>cprev<bang> <args>
-    command! -nargs=* -bang Xfirst <mods>cfirst<bang> <args>
-    command! -nargs=* -bang Xlast <mods>clast<bang> <args>
-    command! -count -nargs=* -bang Xnfile <mods><count>cnfile<bang> <args>
-    command! -nargs=* -bang Xpfile <mods>cpfile<bang> <args>
-    command! -nargs=* Xexpr <mods>cexpr <args>
-    command! -count=999 -nargs=* Xvimgrep <mods> <count>vimgrep <args>
-    command! -nargs=* Xvimgrepadd <mods> vimgrepadd <args>
-    command! -nargs=* Xgrep <mods> grep <args>
-    command! -nargs=* Xgrepadd <mods> grepadd <args>
-    command! -nargs=* Xhelpgrep helpgrep <args>
-    command! -nargs=0 -count Xcc <count>cc
-    command! -count=1 -nargs=0 Xbelow <mods><count>cbelow
-    command! -count=1 -nargs=0 Xabove <mods><count>cabove
-    command! -count=1 -nargs=0 Xbefore <mods><count>cbefore
-    command! -count=1 -nargs=0 Xafter <mods><count>cafter
-    let g:Xgetlist = function('getqflist')
-    let g:Xsetlist = function('setqflist')
-    call setqflist([], 'f')
-  else
-    command! -nargs=* -bang Xlist <mods>llist<bang> <args>
-    command! -nargs=* Xgetexpr <mods>lgetexpr <args>
-    command! -nargs=* Xaddexpr <mods>laddexpr <args>
-    command! -nargs=* -count Xolder <mods><count>lolder <args>
-    command! -nargs=* Xnewer <mods>lnewer <args>
-    command! -nargs=* Xopen <mods> lopen <args>
-    command! -nargs=* Xwindow <mods>lwindow <args>
-    command! -nargs=* Xbottom <mods>lbottom <args>
-    command! -nargs=* Xclose <mods>lclose <args>
-    command! -nargs=* -bang Xfile <mods>lfile<bang> <args>
-    command! -nargs=* Xgetfile <mods>lgetfile <args>
-    command! -nargs=* Xaddfile <mods>laddfile <args>
-    command! -nargs=* -bang Xbuffer <mods>lbuffer<bang> <args>
-    command! -nargs=* Xgetbuffer <mods>lgetbuffer <args>
-    command! -nargs=* Xaddbuffer <mods>laddbuffer <args>
-    command! -nargs=* Xrewind <mods>lrewind <args>
-    command! -count -nargs=* -bang Xnext <mods><count>lnext<bang> <args>
-    command! -count -nargs=* -bang Xprev <mods><count>lprev<bang> <args>
-    command! -nargs=* -bang Xfirst <mods>lfirst<bang> <args>
-    command! -nargs=* -bang Xlast <mods>llast<bang> <args>
-    command! -count -nargs=* -bang Xnfile <mods><count>lnfile<bang> <args>
-    command! -nargs=* -bang Xpfile <mods>lpfile<bang> <args>
-    command! -nargs=* Xexpr <mods>lexpr <args>
-    command! -count=999 -nargs=* Xvimgrep <mods> <count>lvimgrep <args>
-    command! -nargs=* Xvimgrepadd <mods> lvimgrepadd <args>
-    command! -nargs=* Xgrep <mods> lgrep <args>
-    command! -nargs=* Xgrepadd <mods> lgrepadd <args>
-    command! -nargs=* Xhelpgrep lhelpgrep <args>
-    command! -nargs=0 -count Xcc <count>ll
-    command! -count=1 -nargs=0 Xbelow <mods><count>lbelow
-    command! -count=1 -nargs=0 Xabove <mods><count>labove
-    command! -count=1 -nargs=0 Xbefore <mods><count>lbefore
-    command! -count=1 -nargs=0 Xafter <mods><count>lafter
-    let g:Xgetlist = function('getloclist', [0])
-    let g:Xsetlist = function('setloclist', [0])
-    call setloclist(0, [], 'f')
-  endif
-endfunc
-
-" This must be run before any error lists are created.
-func Test_AA_cc_no_errors()
-  call assert_fails('cc', 'E42:')
-  call assert_fails('ll', 'E42:')
-endfunc
-
-" Tests for the :clist and :llist commands
-func XlistTests(cchar)
-  call s:setup_commands(a:cchar)
-
-  if a:cchar == 'l'
-      call assert_fails('llist', 'E776:')
-  endif
-  " With an empty list, command should return error
-  Xgetexpr []
-  silent! Xlist
-  call assert_true(v:errmsg ==# 'E42: No Errors')
-
-  " Populate the list and then try
-  let lines =<< trim END
-    non-error 1
-    Xtestfile1:1:3:Line1
-    non-error 2
-    Xtestfile2:2:2:Line2
-    non-error| 3
-    Xtestfile3:3:1:Line3
-  END
-  Xgetexpr lines
-
-  " List only valid entries
-  let l = split(execute('Xlist', ''), "\n")
-  call assert_equal([' 2 Xtestfile1:1 col 3: Line1',
-		   \ ' 4 Xtestfile2:2 col 2: Line2',
-		   \ ' 6 Xtestfile3:3 col 1: Line3'], l)
-
-  " List all the entries
-  let l = split(execute('Xlist!', ''), "\n")
-  call assert_equal([' 1: non-error 1', ' 2 Xtestfile1:1 col 3: Line1',
-		   \ ' 3: non-error 2', ' 4 Xtestfile2:2 col 2: Line2',
-		   \ ' 5: non-error| 3', ' 6 Xtestfile3:3 col 1: Line3'], l)
-
-  " List a range of errors
-  let l = split(execute('Xlist 3,6', ''), "\n")
-  call assert_equal([' 4 Xtestfile2:2 col 2: Line2',
-		   \ ' 6 Xtestfile3:3 col 1: Line3'], l)
-
-  let l = split(execute('Xlist! 3,4', ''), "\n")
-  call assert_equal([' 3: non-error 2', ' 4 Xtestfile2:2 col 2: Line2'], l)
-
-  let l = split(execute('Xlist -6,-4', ''), "\n")
-  call assert_equal([' 2 Xtestfile1:1 col 3: Line1'], l)
-
-  let l = split(execute('Xlist! -5,-3', ''), "\n")
-  call assert_equal([' 2 Xtestfile1:1 col 3: Line1',
-		   \ ' 3: non-error 2', ' 4 Xtestfile2:2 col 2: Line2'], l)
-
-  " Test for '+'
-  let l = split(execute('Xlist! +2', ''), "\n")
-  call assert_equal([' 2 Xtestfile1:1 col 3: Line1',
-		   \ ' 3: non-error 2', ' 4 Xtestfile2:2 col 2: Line2'], l)
-
-  " Ranged entries
-  call g:Xsetlist([{'lnum':10,'text':'Line1'},
-	      \ {'lnum':20,'col':10,'text':'Line2'},
-	      \ {'lnum':30,'col':15,'end_col':20,'text':'Line3'},
-	      \ {'lnum':40,'end_lnum':45,'text':'Line4'},
-	      \ {'lnum':50,'end_lnum':55,'col':15,'text':'Line5'},
-	      \ {'lnum':60,'end_lnum':65,'col':25,'end_col':35,'text':'Line6'}])
-  let l = split(execute('Xlist', ""), "\n")
-  call assert_equal([' 1:10: Line1',
-	      \ ' 2:20 col 10: Line2',
-	      \ ' 3:30 col 15-20: Line3',
-	      \ ' 4:40-45: Line4',
-	      \ ' 5:50-55 col 15: Line5',
-	      \ ' 6:60-65 col 25-35: Line6'], l)
-
-  " Different types of errors
-  call g:Xsetlist([{'lnum':10,'col':5,'type':'W', 'text':'Warning','nr':11},
-	      \ {'lnum':20,'col':10,'type':'e','text':'Error','nr':22},
-	      \ {'lnum':30,'col':15,'type':'i','text':'Info','nr':33},
-	      \ {'lnum':40,'col':20,'type':'x', 'text':'Other','nr':44},
-	      \ {'lnum':50,'col':25,'type':"\<C-A>",'text':'one','nr':55}])
-  let l = split(execute('Xlist', ""), "\n")
-  call assert_equal([' 1:10 col 5 warning  11: Warning',
-	      \ ' 2:20 col 10 error  22: Error',
-	      \ ' 3:30 col 15 info  33: Info',
-	      \ ' 4:40 col 20 x  44: Other',
-	      \ ' 5:50 col 25  55: one'], l)
-
-  " Test for module names, one needs to explicitly set `'valid':v:true` so
-  call g:Xsetlist([
-        \ {'lnum':10,'col':5,'type':'W','module':'Data.Text','text':'ModuleWarning','nr':11,'valid':v:true},
-        \ {'lnum':20,'col':10,'type':'W','module':'Data.Text','filename':'Data/Text.hs','text':'ModuleWarning','nr':22,'valid':v:true},
-        \ {'lnum':30,'col':15,'type':'W','filename':'Data/Text.hs','text':'FileWarning','nr':33,'valid':v:true}])
-  let l = split(execute('Xlist', ""), "\n")
-  call assert_equal([' 1 Data.Text:10 col 5 warning  11: ModuleWarning',
-	\ ' 2 Data.Text:20 col 10 warning  22: ModuleWarning',
-	\ ' 3 Data/Text.hs:30 col 15 warning  33: FileWarning'], l)
-
-  " Very long line should be displayed.
-  let text = 'Line' .. repeat('1234567890', 130)
-  let lines = ['Xtestfile9:2:9:' .. text]
-  Xgetexpr lines
-
-  let l = split(execute('Xlist', ''), "\n")
-  call assert_equal([' 1 Xtestfile9:2 col 9: ' .. text] , l)
-
-  " For help entries in the quickfix list, only the filename without directory
-  " should be displayed
-  Xhelpgrep setqflist()
-  let l = split(execute('Xlist 1', ''), "\n")
-  call assert_match('^ 1 [^\\/]\{-}:', l[0])
-
-  " Error cases
-  call assert_fails('Xlist abc', 'E488:')
-endfunc
-
-func Test_clist()
-  call XlistTests('c')
-  call XlistTests('l')
-endfunc
-
-" Tests for the :colder, :cnewer, :lolder and :lnewer commands
-" Note that this test assumes that a quickfix/location list is
-" already set by the caller.
-func XageTests(cchar)
-  call s:setup_commands(a:cchar)
-
-  if a:cchar == 'l'
-    " No location list for the current window
-    call assert_fails('lolder', 'E776:')
-    call assert_fails('lnewer', 'E776:')
-  endif
-
-  let list = [{'bufnr': bufnr('%'), 'lnum': 1}]
-  call g:Xsetlist(list)
-
-  " Jumping to a non existent list should return error
-  silent! Xolder 99
-  call assert_true(v:errmsg ==# 'E380: At bottom of quickfix stack')
-
-  silent! Xnewer 99
-  call assert_true(v:errmsg ==# 'E381: At top of quickfix stack')
-
-  " Add three quickfix/location lists
-  Xgetexpr ['Xtestfile1:1:3:Line1']
-  Xgetexpr ['Xtestfile2:2:2:Line2']
-  Xgetexpr ['Xtestfile3:3:1:Line3']
-
-  " Go back two lists
-  Xolder
-  let l = g:Xgetlist()
-  call assert_equal('Line2', l[0].text)
-
-  " Go forward two lists
-  Xnewer
-  let l = g:Xgetlist()
-  call assert_equal('Line3', l[0].text)
-
-  " Test for the optional count argument
-  Xolder 2
-  let l = g:Xgetlist()
-  call assert_equal('Line1', l[0].text)
-
-  Xnewer 2
-  let l = g:Xgetlist()
-  call assert_equal('Line3', l[0].text)
-endfunc
-
-func Test_cage()
-  call XageTests('c')
-  call XageTests('l')
-endfunc
-
-" Tests for the :cwindow, :lwindow :cclose, :lclose, :copen and :lopen
-" commands
-func XwindowTests(cchar)
-  call s:setup_commands(a:cchar)
-
-  " Opening the location list window without any errors should fail
-  if a:cchar == 'l'
-      call assert_fails('lopen', 'E776:')
-      call assert_fails('lwindow', 'E776:')
-  endif
-
-  " Create a list with no valid entries
-  Xgetexpr ['non-error 1', 'non-error 2', 'non-error 3']
-
-  " Quickfix/Location window should not open with no valid errors
-  Xwindow
-  call assert_true(winnr('$') == 1)
-
-  " Create a list with valid entries
-  let lines =<< trim END
-    Xtestfile1:1:3:Line1
-    Xtestfile2:2:2:Line2
-    Xtestfile3:3:1:Line3
-  END
-  Xgetexpr lines
-
-  " Open the window
-  Xwindow
-  call assert_true(winnr('$') == 2 && winnr() == 2 &&
-	\ getline('.') ==# 'Xtestfile1|1 col 3| Line1')
-  redraw!
-
-  " Close the window
-  Xclose
-  call assert_true(winnr('$') == 1)
-
-  " Create a list with no valid entries
-  Xgetexpr ['non-error 1', 'non-error 2', 'non-error 3']
-
-  " Open the window
-  Xopen 5
-  call assert_true(winnr('$') == 2 && getline('.') ==# '|| non-error 1'
-		      \  && winheight(0) == 5)
-
-  " Opening the window again, should move the cursor to that window
-  wincmd t
-  Xopen 7
-  call assert_true(winnr('$') == 2 && winnr() == 2 &&
-	\ winheight(0) == 7 &&
-	\ getline('.') ==# '|| non-error 1')
-
-  " :cnext in quickfix window should move to the next entry
-  Xnext
-  call assert_equal(2, g:Xgetlist({'idx' : 0}).idx)
-
-  " Calling cwindow should close the quickfix window with no valid errors
-  Xwindow
-  call assert_true(winnr('$') == 1)
-
-  " Specifying the width should adjust the width for a vertically split
-  " quickfix window.
-  vert Xopen
-  call assert_equal(10, winwidth(0))
-  vert Xopen 12
-  call assert_equal(12, winwidth(0))
-  Xclose
-
-  " Horizontally or vertically splitting the quickfix window should create a
-  " normal window/buffer
-  Xopen
-  wincmd s
-  call assert_equal(0, getwininfo(win_getid())[0].quickfix)
-  call assert_equal(0, getwininfo(win_getid())[0].loclist)
-  call assert_notequal('quickfix', &buftype)
-  close
-  Xopen
-  wincmd v
-  call assert_equal(0, getwininfo(win_getid())[0].quickfix)
-  call assert_equal(0, getwininfo(win_getid())[0].loclist)
-  call assert_notequal('quickfix', &buftype)
-  close
-  Xopen
-  Xclose
-
-  if a:cchar == 'c'
-      " Opening the quickfix window in multiple tab pages should reuse the
-      " quickfix buffer
-      let lines =<< trim END
-        Xtestfile1:1:3:Line1
-        Xtestfile2:2:2:Line2
-        Xtestfile3:3:1:Line3
-      END
-      Xgetexpr lines
-      Xopen
-      let qfbufnum = bufnr('%')
-      tabnew
-      Xopen
-      call assert_equal(qfbufnum, bufnr('%'))
-      new | only | tabonly
-  endif
-endfunc
-
-func Test_cwindow()
-  call XwindowTests('c')
-  call XwindowTests('l')
-endfunc
-
-func Test_copenHeight()
-  copen
-  wincmd H
-  let height = winheight(0)
-  copen 10
-  call assert_equal(height, winheight(0))
-  quit
-endfunc
-
-func Test_copenHeight_tabline()
-  set tabline=foo showtabline=2
-  copen
-  wincmd H
-  let height = winheight(0)
-  copen 10
-  call assert_equal(height, winheight(0))
-  quit
-  set tabline& showtabline&
-endfunc
-
-" Tests for the :cfile, :lfile, :caddfile, :laddfile, :cgetfile and :lgetfile
-" commands.
-func XfileTests(cchar)
-  call s:setup_commands(a:cchar)
-
-  let lines =<< trim END
-    Xtestfile1:700:10:Line 700
-    Xtestfile2:800:15:Line 800
-  END
-  call writefile(lines, 'Xqftestfile1')
-
-  enew!
-  Xfile Xqftestfile1
-  let l = g:Xgetlist()
-  call assert_true(len(l) == 2 &&
-	\ l[0].lnum == 700 && l[0].col == 10 && l[0].text ==# 'Line 700' &&
-	\ l[1].lnum == 800 && l[1].col == 15 && l[1].text ==# 'Line 800')
-
-  " Test with a non existent file
-  call assert_fails('Xfile non_existent_file', 'E40')
-
-  " Run cfile/lfile from a modified buffer
-  enew!
-  silent! put ='Quickfix'
-  silent! Xfile Xqftestfile1
-  call assert_true(v:errmsg ==# 'E37: No write since last change (add ! to override)')
-
-  call writefile(['Xtestfile3:900:30:Line 900'], 'Xqftestfile1')
-  Xaddfile Xqftestfile1
-  let l = g:Xgetlist()
-  call assert_true(len(l) == 3 &&
-	\ l[2].lnum == 900 && l[2].col == 30 && l[2].text ==# 'Line 900')
-
-  let lines =<< trim END
-    Xtestfile1:222:77:Line 222
-    Xtestfile2:333:88:Line 333
-  END
-  call writefile(lines, 'Xqftestfile1')
-
-  enew!
-  Xgetfile Xqftestfile1
-  let l = g:Xgetlist()
-  call assert_true(len(l) == 2 &&
-	\ l[0].lnum == 222 && l[0].col == 77 && l[0].text ==# 'Line 222' &&
-	\ l[1].lnum == 333 && l[1].col == 88 && l[1].text ==# 'Line 333')
-
-  " Test for a file with a long line and without a newline at the end
-  let text = repeat('x', 1024)
-  let t = 'a.txt:18:' . text
-  call writefile([t], 'Xqftestfile1', 'b')
-  silent! Xfile Xqftestfile1
-  call assert_equal(text, g:Xgetlist()[0].text)
-
-  call delete('Xqftestfile1')
-endfunc
-
-func Test_cfile()
-  call XfileTests('c')
-  call XfileTests('l')
-endfunc
-
-" Tests for the :cbuffer, :lbuffer, :caddbuffer, :laddbuffer, :cgetbuffer and
-" :lgetbuffer commands.
-func XbufferTests(cchar)
-  call s:setup_commands(a:cchar)
-
-  enew!
-  let lines =<< trim END
-    Xtestfile7:700:10:Line 700
-    Xtestfile8:800:15:Line 800
-  END
-  silent! call setline(1, lines)
-  Xbuffer!
-  let l = g:Xgetlist()
-  call assert_true(len(l) == 2 &&
-	\ l[0].lnum == 700 && l[0].col == 10 && l[0].text ==# 'Line 700' &&
-	\ l[1].lnum == 800 && l[1].col == 15 && l[1].text ==# 'Line 800')
-
-  enew!
-  let lines =<< trim END
-    Xtestfile9:900:55:Line 900
-    Xtestfile10:950:66:Line 950
-  END
-  silent! call setline(1, lines)
-  Xgetbuffer
-  let l = g:Xgetlist()
-  call assert_true(len(l) == 2 &&
-	\ l[0].lnum == 900 && l[0].col == 55 && l[0].text ==# 'Line 900' &&
-	\ l[1].lnum == 950 && l[1].col == 66 && l[1].text ==# 'Line 950')
-
-  enew!
-  let lines =<< trim END
-    Xtestfile11:700:20:Line 700
-    Xtestfile12:750:25:Line 750
-  END
-  silent! call setline(1, lines)
-  Xaddbuffer
-  let l = g:Xgetlist()
-  call assert_true(len(l) == 4 &&
-	\ l[1].lnum == 950 && l[1].col == 66 && l[1].text ==# 'Line 950' &&
-	\ l[2].lnum == 700 && l[2].col == 20 && l[2].text ==# 'Line 700' &&
-	\ l[3].lnum == 750 && l[3].col == 25 && l[3].text ==# 'Line 750')
-  enew!
-
-  " Check for invalid buffer
-  call assert_fails('Xbuffer 199', 'E474:')
-
-  " Check for unloaded buffer
-  edit Xtestfile1
-  let bnr = bufnr('%')
-  enew!
-  call assert_fails('Xbuffer ' . bnr, 'E681:')
-
-  " Check for invalid range
-  " Using Xbuffer will not run the range check in the cbuffer/lbuffer
-  " commands. So directly call the commands.
-  if (a:cchar == 'c')
-      call assert_fails('900,999cbuffer', 'E16:')
-  else
-      call assert_fails('900,999lbuffer', 'E16:')
-  endif
-endfunc
-
-func Test_cbuffer()
-  call XbufferTests('c')
-  call XbufferTests('l')
-endfunc
-
-func XexprTests(cchar)
-  call s:setup_commands(a:cchar)
-
-  call assert_fails('Xexpr 10', 'E777:')
-endfunc
-
-func Test_cexpr()
-  call XexprTests('c')
-  call XexprTests('l')
-endfunc
-
-" Tests for :cnext, :cprev, :cfirst, :clast commands
-func Xtest_browse(cchar)
-  call s:setup_commands(a:cchar)
-
-  call g:Xsetlist([], 'f')
-  " Jumping to first or next location list entry without any error should
-  " result in failure
-  if a:cchar == 'c'
-    let err = 'E42:'
-    let cmd = '$cc'
-  else
-    let err = 'E776:'
-    let cmd = '$ll'
-  endif
-  call assert_fails('Xnext', err)
-  call assert_fails('Xprev', err)
-  call assert_fails('Xnfile', err)
-  call assert_fails('Xpfile', err)
-  call assert_fails(cmd, err)
-
-  Xexpr ''
-  call assert_fails(cmd, 'E42:')
-
-  call s:create_test_file('Xqftestfile1')
-  call s:create_test_file('Xqftestfile2')
-
-  let lines =<< trim END
-    Xqftestfile1:5:Line5
-    Xqftestfile1:6:Line6
-    Xqftestfile2:10:Line10
-    Xqftestfile2:11:Line11
-    RegularLine1
-    RegularLine2
-  END
-  Xgetexpr lines
-
-  Xfirst
-  call assert_fails('-5Xcc', 'E16:')
-  call assert_fails('Xprev', 'E553')
-  call assert_fails('Xpfile', 'E553')
-  Xnfile
-  call assert_equal('Xqftestfile2', @%)
-  call assert_equal(10, line('.'))
-  Xpfile
-  call assert_equal('Xqftestfile1', @%)
-  call assert_equal(6, line('.'))
-  5Xcc
-  call assert_equal(5, g:Xgetlist({'idx':0}).idx)
-  2Xcc
-  call assert_equal(2, g:Xgetlist({'idx':0}).idx)
-  if a:cchar == 'c'
-    cc
-  else
-    ll
-  endif
-  call assert_equal(2, g:Xgetlist({'idx':0}).idx)
-  10Xcc
-  call assert_equal(6, g:Xgetlist({'idx':0}).idx)
-  Xlast
-  Xprev
-  call assert_equal('Xqftestfile2', @%)
-  call assert_equal(11, line('.'))
-  call assert_fails('Xnext', 'E553')
-  call assert_fails('Xnfile', 'E553')
-  " To process the range using quickfix list entries, directly use the
-  " quickfix commands (don't use the user defined commands)
-  if a:cchar == 'c'
-    $cc
-  else
-    $ll
-  endif
-  call assert_equal(6, g:Xgetlist({'idx':0}).idx)
-  Xrewind
-  call assert_equal('Xqftestfile1', @%)
-  call assert_equal(5, line('.'))
-
-  10Xnext
-  call assert_equal('Xqftestfile2', @%)
-  call assert_equal(11, line('.'))
-  10Xprev
-  call assert_equal('Xqftestfile1', @%)
-  call assert_equal(5, line('.'))
-
-  " Jumping to an error from the error window using cc command
-  let lines =<< trim END
-    Xqftestfile1:5:Line5
-    Xqftestfile1:6:Line6
-    Xqftestfile2:10:Line10
-    Xqftestfile2:11:Line11
-  END
-  Xgetexpr lines
-  Xopen
-  10Xcc
-  call assert_equal(11, line('.'))
-  call assert_equal('Xqftestfile2', @%)
-  Xopen
-  call cursor(2, 1)
-  if a:cchar == 'c'
-    .cc
-  else
-    .ll
-  endif
-  call assert_equal(6, line('.'))
-  call assert_equal('Xqftestfile1', @%)
-
-  " Jumping to an error from the error window (when only the error window is
-  " present)
-  Xopen | only
-  Xlast 1
-  call assert_equal(5, line('.'))
-  call assert_equal('Xqftestfile1', @%)
-
-  Xexpr ""
-  call assert_fails('Xnext', 'E42:')
-
-  call delete('Xqftestfile1')
-  call delete('Xqftestfile2')
-
-  " Should be able to use next/prev with invalid entries
-  Xexpr ""
-  call assert_equal(0, g:Xgetlist({'idx' : 0}).idx)
-  call assert_equal(0, g:Xgetlist({'size' : 0}).size)
-  Xaddexpr ['foo', 'bar', 'baz', 'quux', 'sh|moo']
-  call assert_equal(5, g:Xgetlist({'size' : 0}).size)
-  Xlast
-  call assert_equal(5, g:Xgetlist({'idx' : 0}).idx)
-  Xfirst
-  call assert_equal(1, g:Xgetlist({'idx' : 0}).idx)
-  2Xnext
-  call assert_equal(3, g:Xgetlist({'idx' : 0}).idx)
-endfunc
-
-func Test_browse()
-  call Xtest_browse('c')
-  call Xtest_browse('l')
-endfunc
-
-func s:test_xhelpgrep(cchar)
-  call s:setup_commands(a:cchar)
-  Xhelpgrep quickfix
-  Xopen
-  if a:cchar == 'c'
-    let title_text = ':helpgrep quickfix'
-  else
-    let title_text = ':lhelpgrep quickfix'
-  endif
-  call assert_true(w:quickfix_title =~ title_text, w:quickfix_title)
-
-  " Jumping to a help topic should open the help window
-  only
-  Xnext
-  call assert_true(&buftype == 'help')
-  call assert_true(winnr('$') == 2)
-  " Jumping to the next match should reuse the help window
-  Xnext
-  call assert_true(&buftype == 'help')
-  call assert_true(winnr() == 1)
-  call assert_true(winnr('$') == 2)
-  " Jumping to the next match from the quickfix window should reuse the help
-  " window
-  Xopen
-  Xnext
-  call assert_true(&buftype == 'help')
-  call assert_true(winnr() == 1)
-  call assert_true(winnr('$') == 2)
-  call assert_match('|\d\+ col \d\+-\d\+|', getbufline(winbufnr(2), 1)[0])
-
-  " This wipes out the buffer, make sure that doesn't cause trouble.
-  Xclose
-
-  " When the current window is vertically split, jumping to a help match
-  " should open the help window at the top.
-  only | enew
-  let w1 = win_getid()
-  vert new
-  let w2 = win_getid()
-  Xnext
-  let w3 = win_getid()
-  call assert_true(&buftype == 'help')
-  call assert_true(winnr() == 1)
-  " See jump_to_help_window() for details
-  let w2_width = winwidth(w2)
-  if w2_width != &columns && w2_width < 80
-    call assert_equal(['col', [['leaf', w3],
-          \ ['row', [['leaf', w2], ['leaf', w1]]]]], winlayout())
-  else
-    call assert_equal(['row', [['col', [['leaf', w3], ['leaf', w2]]],
-          \ ['leaf', w1]]] , winlayout())
-  endif
-
-  new | only
-  set buftype=help
-  set modified
-  call assert_fails('Xnext', 'E37:')
-  set nomodified
-  new | only
-
-  if a:cchar == 'l'
-      " When a help window is present, running :lhelpgrep should reuse the
-      " help window and not the current window
-      new | only
-      call g:Xsetlist([], 'f')
-      help index.txt
-      wincmd w
-      lhelpgrep quickfix
-      call assert_equal(1, winnr())
-      call assert_notequal([], getloclist(1))
-      call assert_equal([], getloclist(2))
-  endif
-
-  new | only
-
-  " Search for non existing help string
-  call assert_fails('Xhelpgrep a1b2c3', 'E480:')
-  " Invalid regular expression
-  call assert_fails('Xhelpgrep \@<!', 'E866:')
-endfunc
-
-func Test_helpgrep()
-  call s:test_xhelpgrep('c')
-  helpclose
-  call s:test_xhelpgrep('l')
-endfunc
-
-" When running the :helpgrep command, if an autocmd modifies the 'cpoptions'
-" value, then Vim crashes. (issue fixed by 7.2b-004 and 8.2.4453)
-func Test_helpgrep_restore_cpo_aucmd()
-  let save_cpo = &cpo
-  augroup QF_Test
-    au!
-    autocmd BufNew * set cpo=acd
-  augroup END
-
-  helpgrep quickfix
-  call assert_equal('acd', &cpo)
-  %bw!
-
-  set cpo&vim
-  augroup QF_Test
-    au!
-    autocmd BufReadPost * set cpo=
-  augroup END
-
-  helpgrep buffer
-  call assert_equal('', &cpo)
-
-  augroup QF_Test
-    au!
-  augroup END
-  %bw!
-  let &cpo = save_cpo
-endfunc
-
-func Test_errortitle()
-  augroup QfBufWinEnter
-    au!
-    au BufWinEnter * :let g:a=get(w:, 'quickfix_title', 'NONE')
-  augroup END
-  copen
-  let a=[{'lnum': 308, 'bufnr': bufnr(''), 'col': 58, 'valid': 1, 'vcol': 0, 'nr': 0, 'type': '', 'pattern': '', 'text': '    au BufWinEnter * :let g:a=get(w:, ''quickfix_title'', ''NONE'')'}]
-  call setqflist(a)
-  call assert_equal(':setqflist()', g:a)
-  augroup QfBufWinEnter
-    au!
-  augroup END
-  augroup! QfBufWinEnter
-endfunc
-
-func Test_vimgreptitle()
-  augroup QfBufWinEnter
-    au!
-    au BufWinEnter * :let g:a=get(w:, 'quickfix_title', 'NONE')
-  augroup END
-  try
-    vimgrep /pattern/j file
-  catch /E480/
-  endtry
-  copen
-  call assert_equal(':    vimgrep /pattern/j file', g:a)
-  augroup QfBufWinEnter
-    au!
-  augroup END
-  augroup! QfBufWinEnter
-endfunc
-
-func Test_bufwinenter_once()
-  augroup QfBufWinEnter
-    au!
-    au BufWinEnter * let g:got_afile ..= 'got ' .. expand('<afile>')
-  augroup END
-  let g:got_afile = ''
-  copen
-  call assert_equal('got quickfix', g:got_afile)
-
-  cclose
-  unlet g:got_afile
-  augroup QfBufWinEnter
-    au!
-  augroup END
-  augroup! QfBufWinEnter
-endfunc
-
-func XqfTitleTests(cchar)
-  call s:setup_commands(a:cchar)
-
-  Xgetexpr ['file:1:1:message']
-  let l = g:Xgetlist()
-  if a:cchar == 'c'
-    call setqflist(l, 'r')
-  else
-    call setloclist(0, l, 'r')
-  endif
-
-  Xopen
-  if a:cchar == 'c'
-    let title = ':setqflist()'
-  else
-    let title = ':setloclist()'
-  endif
-  call assert_equal(title, w:quickfix_title)
-  Xclose
-endfunc
-
-" Tests for quickfix window's title
-func Test_qf_title()
-  call XqfTitleTests('c')
-  call XqfTitleTests('l')
-endfunc
-
-" Tests for 'errorformat'
-func Test_efm()
-  let save_efm = &efm
-  set efm=%EEEE%m,%WWWW%m,%+CCCC%.%#,%-GGGG%.%#
-  cgetexpr ['WWWW', 'EEEE', 'CCCC']
-  let l = strtrans(string(map(getqflist(), '[v:val.text, v:val.valid]')))
-  call assert_equal("[['W', 1], ['E^@CCCC', 1]]", l)
-  cgetexpr ['WWWW', 'GGGG', 'EEEE', 'CCCC']
-  let l = strtrans(string(map(getqflist(), '[v:val.text, v:val.valid]')))
-  call assert_equal("[['W', 1], ['E^@CCCC', 1]]", l)
-  cgetexpr ['WWWW', 'GGGG', 'ZZZZ', 'EEEE', 'CCCC', 'YYYY']
-  let l = strtrans(string(map(getqflist(), '[v:val.text, v:val.valid]')))
-  call assert_equal("[['W', 1], ['ZZZZ', 0], ['E^@CCCC', 1], ['YYYY', 0]]", l)
-  let &efm = save_efm
-endfunc
-
-" This will test for problems in quickfix:
-" A. incorrectly copying location lists which caused the location list to show
-"    a different name than the file that was actually being displayed.
-" B. not reusing the window for which the location list window is opened but
-"    instead creating new windows.
-" C. make sure that the location list window is not reused instead of the
-"    window it belongs to.
-"
-" Set up the test environment:
-func ReadTestProtocol(name)
-  let base = substitute(a:name, '\v^test://(.*)%(\.[^.]+)?', '\1', '')
-  let word = substitute(base, '\v(.*)\..*', '\1', '')
-
-  setl modifiable
-  setl noreadonly
-  setl noswapfile
-  setl bufhidden=delete
-  %del _
-  " For problem 2:
-  " 'buftype' has to be set to reproduce the constant opening of new windows
-  setl buftype=nofile
-
-  call setline(1, word)
-
-  setl nomodified
-  setl nomodifiable
-  setl readonly
-  exe 'doautocmd BufRead ' . substitute(a:name, '\v^test://(.*)', '\1', '')
-endfunc
-
-func Test_locationlist()
-  enew
-
-  augroup testgroup
-    au!
-    autocmd BufReadCmd test://* call ReadTestProtocol(expand("<amatch>"))
-  augroup END
-
-  let words = [ "foo", "bar", "baz", "quux", "shmoo", "spam", "eggs" ]
-
-  let qflist = []
-  for word in words
-    call add(qflist, {'filename': 'test://' . word . '.txt', 'text': 'file ' . word . '.txt', })
-    " NOTE: problem 1:
-    " intentionally not setting 'lnum' so that the quickfix entries are not
-    " valid
-    eval qflist->setloclist(0, ' ')
-  endfor
-
-  " Test A
-  lrewind
-  enew
-  lopen
-  4lnext
-  vert split
-  wincmd L
-  lopen
-  wincmd p
-  lnext
-  let fileName = expand("%")
-  wincmd p
-  let locationListFileName = substitute(getline(line('.')), '\([^|]*\)|.*', '\1', '')
-  let fileName = substitute(fileName, '\\', '/', 'g')
-  let locationListFileName = substitute(locationListFileName, '\\', '/', 'g')
-  call assert_equal("test://bar.txt", fileName)
-  call assert_equal("test://bar.txt", locationListFileName)
-
-  wincmd n | only
-
-  " Test B:
-  lrewind
-  lopen
-  2
-  exe "normal \<CR>"
-  wincmd p
-  3
-  exe "normal \<CR>"
-  wincmd p
-  4
-  exe "normal \<CR>"
-  call assert_equal(2, winnr('$'))
-  wincmd n | only
-
-  " Test C:
-  lrewind
-  lopen
-  " Let's move the location list window to the top to check whether it (the
-  " first window found) will be reused when we try to open new windows:
-  wincmd K
-  2
-  exe "normal \<CR>"
-  wincmd p
-  3
-  exe "normal \<CR>"
-  wincmd p
-  4
-  exe "normal \<CR>"
-  1wincmd w
-  call assert_equal('quickfix', &buftype)
-  2wincmd w
-  let bufferName = expand("%")
-  let bufferName = substitute(bufferName, '\\', '/', 'g')
-  call assert_equal('test://quux.txt', bufferName)
-
-  wincmd n | only
-
-  augroup! testgroup
-endfunc
-
-func Test_locationlist_curwin_was_closed()
-  augroup testgroup
-    au!
-    autocmd BufReadCmd test_curwin.txt call R(expand("<amatch>"))
-  augroup END
-
-  func! R(n)
-    quit
-  endfunc
-
-  new
-  let q = []
-  call add(q, {'filename': 'test_curwin.txt' })
-  call setloclist(0, q)
-  call assert_fails('lrewind', 'E924:')
-
-  augroup! testgroup
-  delfunc R
-endfunc
-
-func Test_locationlist_cross_tab_jump()
-  call writefile(['loclistfoo'], 'loclistfoo')
-  call writefile(['loclistbar'], 'loclistbar')
-  set switchbuf=usetab
-
-  edit loclistfoo
-  tabedit loclistbar
-  silent lgrep loclistfoo loclist*
-  call assert_equal(1, tabpagenr())
-
-  enew | only | tabonly
-  set switchbuf&vim
-  call delete('loclistfoo')
-  call delete('loclistbar')
-endfunc
-
-" More tests for 'errorformat'
-func Test_efm1()
-    if !has('unix')
-	" The 'errorformat' setting is different on non-Unix systems.
-	" This test works only on Unix-like systems.
-	return
-    endif
-
-    let l =<< trim [DATA]
-      "Xtestfile", line 4.12: 1506-045 (S) Undeclared identifier fd_set.
-      "Xtestfile", line 6 col 19; this is an error
-      gcc -c -DHAVE_CONFIsing-prototypes -I/usr/X11R6/include  version.c
-      Xtestfile:9: parse error before `asd'
-      make: *** [vim] Error 1
-      in file "Xtestfile" linenr 10: there is an error
-
-      2 returned
-      "Xtestfile", line 11 col 1; this is an error
-      "Xtestfile", line 12 col 2; this is another error
-      "Xtestfile", line 14:10; this is an error in column 10
-      =Xtestfile=, line 15:10; this is another error, but in vcol 10 this time
-      "Xtestfile", linenr 16: yet another problem
-      Error in "Xtestfile" at line 17:
-      x should be a dot
-      	xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx    line 17
-                  ^
-      Error in "Xtestfile" at line 18:
-      x should be a dot
-      	xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx    line 18
-      .............^
-      Error in "Xtestfile" at line 19:
-      x should be a dot
-      	xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx    line 19
-      --------------^
-      Error in "Xtestfile" at line 20:
-      x should be a dot
-      	xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx    line 20
-      	       ^
-
-      Does anyone know what is the problem and how to correction it?
-      "Xtestfile", line 21 col 9: What is the title of the quickfix window?
-      "Xtestfile", line 22 col 9: What is the title of the quickfix window?
-    [DATA]
-
-    call writefile(l, 'Xerrorfile1')
-    call writefile(l[:-2], 'Xerrorfile2')
-
-    let m =<< [DATA]
-	xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx    line  2
-	xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx    line  3
-	xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx    line  4
-	xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx    line  5
-	xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx    line  6
-	xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx    line  7
-	xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx    line  8
-	xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx    line  9
-	xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx    line 10
-	xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx    line 11
-	xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx    line 12
-	xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx    line 13
-	xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx    line 14
-	xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx    line 15
-	xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx    line 16
-	xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx    line 17
-	xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx    line 18
-	xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx    line 19
-	xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx    line 20
-	xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx    line 21
-	xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx    line 22
-[DATA]
-    call writefile(m, 'Xtestfile')
-
-    let save_efm = &efm
-    set efm+==%f=\\,\ line\ %l%*\\D%v%*[^\ ]\ %m
-    set efm^=%AError\ in\ \"%f\"\ at\ line\ %l:,%Z%p^,%C%m
-
-    exe 'cf Xerrorfile2'
-    clast
-    copen
-    call assert_equal(':cf Xerrorfile2', w:quickfix_title)
-    wincmd p
-
-    exe 'cf Xerrorfile1'
-    call assert_equal([4, 12], [line('.'), col('.')])
-    cn
-    call assert_equal([6, 19], [line('.'), col('.')])
-    cn
-    call assert_equal([9, 2], [line('.'), col('.')])
-    cn
-    call assert_equal([10, 2], [line('.'), col('.')])
-    cn
-    call assert_equal([11, 1], [line('.'), col('.')])
-    cn
-    call assert_equal([12, 2], [line('.'), col('.')])
-    cn
-    call assert_equal([14, 10], [line('.'), col('.')])
-    cn
-    call assert_equal([15, 3, 10], [line('.'), col('.'), virtcol('.')])
-    cn
-    call assert_equal([16, 2], [line('.'), col('.')])
-    cn
-    call assert_equal([17, 6], [line('.'), col('.')])
-    cn
-    call assert_equal([18, 7], [line('.'), col('.')])
-    cn
-    call assert_equal([19, 8], [line('.'), col('.')])
-    cn
-    call assert_equal([20, 9], [line('.'), col('.')])
-    clast
-    cprev
-    cprev
-    wincmd w
-    call assert_equal(':cf Xerrorfile1', w:quickfix_title)
-    wincmd p
-
-    let &efm = save_efm
-    call delete('Xerrorfile1')
-    call delete('Xerrorfile2')
-    call delete('Xtestfile')
-endfunc
-
-" Test for quickfix directory stack support
-func s:dir_stack_tests(cchar)
-  call s:setup_commands(a:cchar)
-
-  let save_efm=&efm
-  set efm=%DEntering\ dir\ '%f',%f:%l:%m,%XLeaving\ dir\ '%f'
-
-  let lines =<< trim END
-    Entering dir 'dir1/a'
-    habits2.txt:1:Nine Healthy Habits
-    Entering dir 'b'
-    habits3.txt:2:0 Hours of television
-    habits2.txt:7:5 Small meals
-    Entering dir 'dir1/c'
-    habits4.txt:3:1 Hour of exercise
-    Leaving dir 'dir1/c'
-    Leaving dir 'dir1/a'
-    habits1.txt:4:2 Liters of water
-    Entering dir 'dir2'
-    habits5.txt:5:3 Cups of hot green tea
-    Leaving dir 'dir2'
-  END
-
-  Xexpr ""
-  for l in lines
-      Xaddexpr l
-  endfor
-
-  let qf = g:Xgetlist()
-
-  call assert_equal('dir1/a/habits2.txt', bufname(qf[1].bufnr))
-  call assert_equal(1, qf[1].lnum)
-  call assert_equal('dir1/a/b/habits3.txt', bufname(qf[3].bufnr))
-  call assert_equal(2, qf[3].lnum)
-  call assert_equal('dir1/a/habits2.txt', bufname(qf[4].bufnr))
-  call assert_equal(7, qf[4].lnum)
-  call assert_equal('dir1/c/habits4.txt', bufname(qf[6].bufnr))
-  call assert_equal(3, qf[6].lnum)
-  call assert_equal('habits1.txt', bufname(qf[9].bufnr))
-  call assert_equal(4, qf[9].lnum)
-  call assert_equal('dir2/habits5.txt', bufname(qf[11].bufnr))
-  call assert_equal(5, qf[11].lnum)
-
-  let &efm=save_efm
-endfunc
-
-" Tests for %D and %X errorformat options
-func Test_efm_dirstack()
-  " Create the directory stack and files
-  call mkdir('dir1')
-  call mkdir('dir1/a')
-  call mkdir('dir1/a/b')
-  call mkdir('dir1/c')
-  call mkdir('dir2')
-
-  let lines =<< trim END
-    Nine Healthy Habits
-    0 Hours of television
-    1 Hour of exercise
-    2 Liters of water
-    3 Cups of hot green tea
-    4 Short mental breaks
-    5 Small meals
-    6 AM wake up time
-    7 Minutes of laughter
-    8 Hours of sleep (at least)
-    9 PM end of the day and off to bed
-  END
-  call writefile(lines, 'habits1.txt')
-  call writefile(lines, 'dir1/a/habits2.txt')
-  call writefile(lines, 'dir1/a/b/habits3.txt')
-  call writefile(lines, 'dir1/c/habits4.txt')
-  call writefile(lines, 'dir2/habits5.txt')
-
-  call s:dir_stack_tests('c')
-  call s:dir_stack_tests('l')
-
-  call delete('dir1', 'rf')
-  call delete('dir2', 'rf')
-  call delete('habits1.txt')
-endfunc
-
-" Test for resync after continuing an ignored message
-func Xefm_ignore_continuations(cchar)
-  call s:setup_commands(a:cchar)
-
-  let save_efm = &efm
-
-  let &efm =
-	\ '%Eerror %m %l,' .
-	\ '%-Wignored %m %l,' .
-	\ '%+Cmore ignored %m %l,' .
-	\ '%Zignored end'
-  let lines =<< trim END
-    ignored warning 1
-    more ignored continuation 2
-    ignored end
-    error resync 4
-  END
-  Xgetexpr lines
-  let l = map(g:Xgetlist(), '[v:val.text, v:val.valid, v:val.lnum, v:val.type]')
-  call assert_equal([['resync', 1, 4, 'E']], l)
-
-  let &efm = save_efm
-endfunc
-
-func Test_efm_ignore_continuations()
-  call Xefm_ignore_continuations('c')
-  call Xefm_ignore_continuations('l')
-endfunc
-
-" Tests for invalid error format specifies
-func Xinvalid_efm_Tests(cchar)
-  call s:setup_commands(a:cchar)
-
-  let save_efm = &efm
-
-  set efm=%f:%l:%m,%f:%f:%l:%m
-  call assert_fails('Xexpr "abc.txt:1:Hello world"', 'E372:')
-
-  set efm=%f:%l:%m,%f:%l:%r:%m
-  call assert_fails('Xexpr "abc.txt:1:Hello world"', 'E373:')
-
-  set efm=%f:%l:%m,%O:%f:%l:%m
-  call assert_fails('Xexpr "abc.txt:1:Hello world"', 'E373:')
-
-  set efm=%f:%l:%m,%f:%l:%*[^a-z
-  call assert_fails('Xexpr "abc.txt:1:Hello world"', 'E374:')
-
-  set efm=%f:%l:%m,%f:%l:%*c
-  call assert_fails('Xexpr "abc.txt:1:Hello world"', 'E375:')
-
-  set efm=%f:%l:%m,%L%M%N
-  call assert_fails('Xexpr "abc.txt:1:Hello world"', 'E376:')
-
-  set efm=%f:%l:%m,%f:%l:%m:%R
-  call assert_fails('Xexpr "abc.txt:1:Hello world"', 'E377:')
-
-  " Invalid regular expression
-  set efm=%\\%%k
-  call assert_fails('Xexpr "abc.txt:1:Hello world"', 'E867:')
-
-  set efm=
-  call assert_fails('Xexpr "abc.txt:1:Hello world"', 'E378:')
-
-  " Empty directory name. When there is an error in parsing new entries, make
-  " sure the previous quickfix list is made the current list.
-  set efm&
-  cexpr ["one", "two"]
-  let qf_id = getqflist(#{id: 0}).id
-  set efm=%DEntering\ dir\ abc,%f:%l:%m
-  call assert_fails('Xexpr ["Entering dir abc", "abc.txt:1:Hello world"]', 'E379:')
-  call assert_equal(qf_id, getqflist(#{id: 0}).id)
-
-  let &efm = save_efm
-endfunc
-
-func Test_invalid_efm()
-  call Xinvalid_efm_Tests('c')
-  call Xinvalid_efm_Tests('l')
-endfunc
-
-" TODO:
-" Add tests for the following formats in 'errorformat'
-"	%r  %O
-func Test_efm2()
-  let save_efm = &efm
-
-  " Test for %s format in efm
-  set efm=%f:%s
-  cexpr 'Xtestfile:Line search text'
-  let l = getqflist()
-  call assert_equal('^\VLine search text\$', l[0].pattern)
-  call assert_equal(0, l[0].lnum)
-
-  let l = split(execute('clist', ''), "\n")
-  call assert_equal([' 1 Xtestfile:^\VLine search text\$:  '], l)
-
-  " Test for a long line
-  cexpr 'Xtestfile:' . repeat('a', 1026)
-  let l = getqflist()
-  call assert_equal('^\V' . repeat('a', 1019) . '\$', l[0].pattern)
-
-  " Test for %P, %Q and %t format specifiers
-  let lines =<< trim [DATA]
-    [Xtestfile1]
-    (1,17)  error: ';' missing
-    (21,2)  warning: variable 'z' not defined
-    (67,3)  error: end of file found before string ended
-    --
-
-    [Xtestfile2]
-    --
-
-    [Xtestfile3]
-    NEW compiler v1.1
-    (2,2)   warning: variable 'x' not defined
-    (67,3)  warning: 's' already defined
-    --
-  [DATA]
-
-  set efm=%+P[%f]%r,(%l\\,%c)%*[\ ]%t%*[^:]:\ %m,%+Q--%r
-  " To exercise the push/pop file functionality in quickfix, the test files
-  " need to be created.
-  call writefile(['Line1'], 'Xtestfile1')
-  call writefile(['Line2'], 'Xtestfile2')
-  call writefile(['Line3'], 'Xtestfile3')
-  cexpr ""
-  for l in lines
-      caddexpr l
-  endfor
-  let l = getqflist()
-  call assert_equal(12, len(l))
-  call assert_equal(21, l[2].lnum)
-  call assert_equal(2, l[2].col)
-  call assert_equal('w', l[2].type)
-  call assert_equal('e', l[3].type)
-  call delete('Xtestfile1')
-  call delete('Xtestfile2')
-  call delete('Xtestfile3')
-
-  " Test for %P, %Q with non-existing files
-  cexpr lines
-  let l = getqflist()
-  call assert_equal(14, len(l))
-  call assert_equal('[Xtestfile1]', l[0].text)
-  call assert_equal('[Xtestfile2]', l[6].text)
-  call assert_equal('[Xtestfile3]', l[9].text)
-
-  " Tests for %E, %C and %Z format specifiers
-  let lines =<< trim [DATA]
-    Error 275
-    line 42
-    column 3
-    ' ' expected after '--'
-  [DATA]
-
-  set efm=%EError\ %n,%Cline\ %l,%Ccolumn\ %c,%Z%m
-  cgetexpr lines
-  let l = getqflist()
-  call assert_equal(275, l[0].nr)
-  call assert_equal(42, l[0].lnum)
-  call assert_equal(3, l[0].col)
-  call assert_equal('E', l[0].type)
-  call assert_equal("\n' ' expected after '--'", l[0].text)
-
-  " Test for %>
-  let lines =<< trim [DATA]
-    Error in line 147 of foo.c:
-    unknown variable 'i'
-  [DATA]
-
-  set efm=unknown\ variable\ %m,%E%>Error\ in\ line\ %l\ of\ %f:,%Z%m
-  cgetexpr lines
-  let l = getqflist()
-  call assert_equal(147, l[0].lnum)
-  call assert_equal('E', l[0].type)
-  call assert_equal("\nunknown variable 'i'", l[0].text)
-
-  " Test for %A, %C and other formats
-  let lines =<< trim [DATA]
-    ==============================================================
-    FAIL: testGetTypeIdCachesResult (dbfacadeTest.DjsDBFacadeTest)
-    --------------------------------------------------------------
-    Traceback (most recent call last):
-      File "unittests/dbfacadeTest.py", line 89, in testFoo
-        self.assertEquals(34, dtid)
-      File "/usr/lib/python2.2/unittest.py", line 286, in
-     failUnlessEqual
-        raise self.failureException, \\
-    W:AssertionError: 34 != 33
-  
-    --------------------------------------------------------------
-    Ran 27 tests in 0.063s
-  [DATA]
-
-  set efm=%C\ %.%#,%A\ \ File\ \"%f\"\\,\ line\ %l%.%#,%Z%[%^\ ]%\\@=%t:%m
-  cgetexpr lines
-  let l = getqflist()
-  call assert_equal(8, len(l))
-  call assert_equal(89, l[4].lnum)
-  call assert_equal(1, l[4].valid)
-  call assert_equal('unittests/dbfacadeTest.py', bufname(l[4].bufnr))
-  call assert_equal('W', l[4].type)
-
-  " Test for %o
-  set efm=%f(%o):%l\ %m
-  cgetexpr ['Xotestfile(Language.PureScript.Types):20 Error']
-  call writefile(['Line1'], 'Xotestfile')
-  let l = getqflist()
-  call assert_equal(1, len(l), string(l))
-  call assert_equal('Language.PureScript.Types', l[0].module)
-  copen
-  call assert_equal('Language.PureScript.Types|20| Error', getline(1))
-  call feedkeys("\<CR>", 'xn')
-  call assert_equal('Xotestfile', expand('%:t'))
-  cclose
-  bd
-  call delete("Xotestfile")
-
-  " Test for a long module name
-  cexpr 'Xtest(' . repeat('m', 1026) . '):15 message'
-  let l = getqflist()
-  " call assert_equal(repeat('m', 1024), l[0].module)
-  call assert_equal(repeat('m', 1023), l[0].module)
-  call assert_equal(15, l[0].lnum)
-  call assert_equal('message', l[0].text)
-
-  " The following sequence of commands used to crash Vim
-  set efm=%W%m
-  cgetexpr ['msg1']
-  let l = getqflist()
-  call assert_equal(1, len(l), string(l))
-  call assert_equal('msg1', l[0].text)
-  set efm=%C%m
-  lexpr 'msg2'
-  let l = getloclist(0)
-  call assert_equal(1, len(l), string(l))
-  call assert_equal('msg2', l[0].text)
-  lopen
-  call setqflist([], 'r')
-  caddbuf
-  let l = getqflist()
-  call assert_equal(1, len(l), string(l))
-  call assert_equal('|| msg2', l[0].text)
-
-  " When matching error lines, case should be ignored. Test for this.
-  set noignorecase
-  let l=getqflist({'lines' : ['Xtest:FOO10:Line 20'], 'efm':'%f:foo%l:%m'})
-  call assert_equal(10, l.items[0].lnum)
-  call assert_equal('Line 20', l.items[0].text)
-  set ignorecase&
-
-  new | only
-  let &efm = save_efm
-endfunc
-
-" Test for '%t' (error type) field in 'efm'
-func Test_efm_error_type()
-  let save_efm = &efm
-
-  " error type
-  set efm=%f:%l:%t:%m
-  let lines =<< trim END
-    Xfile1:10:E:msg1
-    Xfile1:20:W:msg2
-    Xfile1:30:I:msg3
-    Xfile1:40:N:msg4
-    Xfile1:50:R:msg5
-  END
-  cexpr lines
-  let output = split(execute('clist'), "\n")
-  call assert_equal([
-        \ ' 1 Xfile1:10 error: msg1',
-        \ ' 2 Xfile1:20 warning: msg2',
-        \ ' 3 Xfile1:30 info: msg3',
-        \ ' 4 Xfile1:40 note: msg4',
-        \ ' 5 Xfile1:50 R: msg5'], output)
-
-  " error type and a error number
-  set efm=%f:%l:%t:%n:%m
-  let lines =<< trim END
-    Xfile1:10:E:2:msg1
-    Xfile1:20:W:4:msg2
-    Xfile1:30:I:6:msg3
-    Xfile1:40:N:8:msg4
-    Xfile1:50:R:3:msg5
-  END
-  cexpr lines
-  let output = split(execute('clist'), "\n")
-  call assert_equal([
-        \ ' 1 Xfile1:10 error   2: msg1',
-        \ ' 2 Xfile1:20 warning   4: msg2',
-        \ ' 3 Xfile1:30 info   6: msg3',
-        \ ' 4 Xfile1:40 note   8: msg4',
-        \ ' 5 Xfile1:50 R   3: msg5'], output)
-  let &efm = save_efm
-endfunc
-
-" Test for end_lnum ('%e') and end_col ('%k') fields in 'efm'
-func Test_efm_end_lnum_col()
-  let save_efm = &efm
-
-  " single line
-  set efm=%f:%l-%e:%c-%k:%t:%m
-  cexpr ["Xfile1:10-20:1-2:E:msg1", "Xfile1:20-30:2-3:W:msg2",]
-  let output = split(execute('clist'), "\n")
-  call assert_equal([
-        \ ' 1 Xfile1:10-20 col 1-2 error: msg1',
-        \ ' 2 Xfile1:20-30 col 2-3 warning: msg2'], output)
-
-  " multiple lines
-  set efm=%A%n)%m,%Z%f:%l-%e:%c-%k
-  let lines =<< trim END
-    1)msg1
-    Xfile1:14-24:1-2
-    2)msg2
-    Xfile1:24-34:3-4
-  END
-  cexpr lines
-  let output = split(execute('clist'), "\n")
-  call assert_equal([
-        \ ' 1 Xfile1:14-24 col 1-2 error   1: msg1',
-        \ ' 2 Xfile1:24-34 col 3-4 error   2: msg2'], output)
-  let &efm = save_efm
-endfunc
-
-func XquickfixChangedByAutocmd(cchar)
-  call s:setup_commands(a:cchar)
-  if a:cchar == 'c'
-    let ErrorNr = 'E925'
-    func! ReadFunc()
-      colder
-      cgetexpr []
-    endfunc
-  else
-    let ErrorNr = 'E926'
-    func! ReadFunc()
-      lolder
-      lgetexpr []
-    endfunc
-  endif
-
-  augroup QF_Test
-    au!
-    autocmd BufReadCmd test_changed.txt call ReadFunc()
-  augroup END
-
-  new | only
-  let words = [ "a", "b" ]
-  let qflist = []
-  for word in words
-    call add(qflist, {'filename': 'test_changed.txt'})
-    call g:Xsetlist(qflist, ' ')
-  endfor
-  call assert_fails('Xrewind', ErrorNr . ':')
-
-  augroup QF_Test
-    au!
-  augroup END
-
-  if a:cchar == 'c'
-    cexpr ["Xtest1:1:Line"]
-    cwindow
-    only
-    augroup QF_Test
-      au!
-      autocmd WinEnter * call setqflist([], 'f')
-    augroup END
-    call assert_fails('exe "normal \<CR>"', 'E925:')
-    augroup QF_Test
-      au!
-    augroup END
-  endif
-  %bw!
-endfunc
-
-func Test_quickfix_was_changed_by_autocmd()
-  call XquickfixChangedByAutocmd('c')
-  call XquickfixChangedByAutocmd('l')
-endfunc
-
-func Test_setloclist_in_autocommand()
-  call writefile(['test1', 'test2'], 'Xfile')
-  edit Xfile
-  let s:bufnr = bufnr()
-  call setloclist(1,
-        \ [{'bufnr' : s:bufnr, 'lnum' : 1, 'text' : 'test1'},
-        \  {'bufnr' : s:bufnr, 'lnum' : 2, 'text' : 'test2'}])
-
-  augroup Test_LocList
-    au!
-    autocmd BufEnter * call setloclist(1,
-          \ [{'bufnr' : s:bufnr, 'lnum' : 1, 'text' : 'test1'},
-          \  {'bufnr' : s:bufnr, 'lnum' : 2, 'text' : 'test2'}], 'r')
-  augroup END
-
-  lopen
-  call assert_fails('exe "normal j\<CR>"', 'E926:')
-
-  augroup Test_LocList
-    au!
-  augroup END
-  call delete('Xfile')
-endfunc
-
-func Test_caddbuffer_to_empty()
-  helpgr quickfix
-  call setqflist([], 'r')
-  cad
-  try
-    cn
-  catch
-    " number of matches is unknown
-    call assert_true(v:exception =~ 'E553:')
-  endtry
-  quit!
-endfunc
-
-func Test_cgetexpr_works()
-  " this must not crash Vim
-  cgetexpr [$x]
-  lgetexpr [$x]
-endfunc
-
-" Tests for the setqflist() and setloclist() functions
-func SetXlistTests(cchar, bnum)
-  call s:setup_commands(a:cchar)
-
-  call g:Xsetlist([{'bufnr': a:bnum, 'lnum': 1},
-	      \  {'bufnr': a:bnum, 'lnum': 2, 'end_lnum': 3, 'col': 4, 'end_col': 5}])
-  let l = g:Xgetlist()
-  call assert_equal(2, len(l))
-  call assert_equal(2, l[1].lnum)
-  call assert_equal(3, l[1].end_lnum)
-  call assert_equal(4, l[1].col)
-  call assert_equal(5, l[1].end_col)
-
-  Xnext
-  call g:Xsetlist([{'bufnr': a:bnum, 'lnum': 3}], 'a')
-  let l = g:Xgetlist()
-  call assert_equal(3, len(l))
-  Xnext
-  call assert_equal(3, line('.'))
-
-  " Appending entries to the list should not change the cursor position
-  " in the quickfix window
-  Xwindow
-  1
-  call g:Xsetlist([{'bufnr': a:bnum, 'lnum': 4},
-	      \  {'bufnr': a:bnum, 'lnum': 5}], 'a')
-  call assert_equal(1, line('.'))
-  close
-
-  call g:Xsetlist([{'bufnr': a:bnum, 'lnum': 3},
-	      \  {'bufnr': a:bnum, 'lnum': 4},
-	      \  {'bufnr': a:bnum, 'lnum': 5}], 'r')
-  let l = g:Xgetlist()
-  call assert_equal(3, len(l))
-  call assert_equal(5, l[2].lnum)
-
-  call g:Xsetlist([])
-  let l = g:Xgetlist()
-  call assert_equal(0, len(l))
-
-  " Tests for setting the 'valid' flag
-  call g:Xsetlist([{'bufnr':a:bnum, 'lnum':4, 'valid':0}])
-  Xwindow
-  call assert_equal(1, winnr('$'))
-  let l = g:Xgetlist()
-  call g:Xsetlist(l)
-  call assert_equal(0, g:Xgetlist()[0].valid)
-  " Adding a non-valid entry should not mark the list as having valid entries
-  call g:Xsetlist([{'bufnr':a:bnum, 'lnum':5, 'valid':0}], 'a')
-  Xwindow
-  call assert_equal(1, winnr('$'))
-
-  " :cnext/:cprev should still work even with invalid entries in the list
-  let l = [{'bufnr' : a:bnum, 'lnum' : 1, 'text' : '1', 'valid' : 0},
-	      \ {'bufnr' : a:bnum, 'lnum' : 2, 'text' : '2', 'valid' : 0}]
-  call g:Xsetlist(l)
-  Xnext
-  call assert_equal(2, g:Xgetlist({'idx' : 0}).idx)
-  Xprev
-  call assert_equal(1, g:Xgetlist({'idx' : 0}).idx)
-  " :cnext/:cprev should still work after appending invalid entries to an
-  " empty list
-  call g:Xsetlist([])
-  call g:Xsetlist(l, 'a')
-  Xnext
-  call assert_equal(2, g:Xgetlist({'idx' : 0}).idx)
-  Xprev
-  call assert_equal(1, g:Xgetlist({'idx' : 0}).idx)
-
-  call g:Xsetlist([{'text':'Text1', 'valid':1}])
-  Xwindow
-  call assert_equal(2, winnr('$'))
-  Xclose
-  let save_efm = &efm
-  set efm=%m
-  Xgetexpr 'TestMessage'
-  let l = g:Xgetlist()
-  call g:Xsetlist(l)
-  call assert_equal(1, g:Xgetlist()[0].valid)
-  let &efm = save_efm
-
-  " Error cases:
-  " Refer to a non-existing buffer and pass a non-dictionary type
-  call assert_fails("call g:Xsetlist([{'bufnr':998, 'lnum':4}," .
-	      \ " {'bufnr':999, 'lnum':5}])", 'E92:')
-  call g:Xsetlist([[1, 2,3]])
-  call assert_equal(0, len(g:Xgetlist()))
-  call assert_fails('call g:Xsetlist([], [])', 'E928:')
-  call g:Xsetlist([v:_null_dict])
-  call assert_equal([], g:Xgetlist())
-endfunc
-
-func Test_setqflist()
-  new Xtestfile | only
-  let bnum = bufnr('%')
-  call setline(1, range(1,5))
-
-  call SetXlistTests('c', bnum)
-  call SetXlistTests('l', bnum)
-
-  enew!
-  call delete('Xtestfile')
-endfunc
-
-func Xlist_empty_middle(cchar)
-  call s:setup_commands(a:cchar)
-
-  " create three quickfix lists
-  let @/ = 'Test_'
-  Xvimgrep // test_quickfix.vim
-  let testlen = len(g:Xgetlist())
-  call assert_true(testlen > 0)
-  Xvimgrep empty test_quickfix.vim
-  call assert_true(len(g:Xgetlist()) > 0)
-  Xvimgrep matches test_quickfix.vim
-  let matchlen = len(g:Xgetlist())
-  call assert_true(matchlen > 0)
-  Xolder
-  " make the middle list empty
-  call g:Xsetlist([], 'r')
-  call assert_true(len(g:Xgetlist()) == 0)
-  Xolder
-  call assert_equal(testlen, len(g:Xgetlist()))
-  Xnewer
-  Xnewer
-  call assert_equal(matchlen, len(g:Xgetlist()))
-endfunc
-
-func Test_setqflist_empty_middle()
-  call Xlist_empty_middle('c')
-  call Xlist_empty_middle('l')
-endfunc
-
-func Xlist_empty_older(cchar)
-  call s:setup_commands(a:cchar)
-
-  " create three quickfix lists
-  Xvimgrep one test_quickfix.vim
-  let onelen = len(g:Xgetlist())
-  call assert_true(onelen > 0)
-  Xvimgrep two test_quickfix.vim
-  let twolen = len(g:Xgetlist())
-  call assert_true(twolen > 0)
-  Xvimgrep three test_quickfix.vim
-  let threelen = len(g:Xgetlist())
-  call assert_true(threelen > 0)
-  Xolder 2
-  " make the first list empty, check the others didn't change
-  call g:Xsetlist([], 'r')
-  call assert_true(len(g:Xgetlist()) == 0)
-  Xnewer
-  call assert_equal(twolen, len(g:Xgetlist()))
-  Xnewer
-  call assert_equal(threelen, len(g:Xgetlist()))
-endfunc
-
-func Test_setqflist_empty_older()
-  call Xlist_empty_older('c')
-  call Xlist_empty_older('l')
-endfunc
-
-func XquickfixSetListWithAct(cchar)
-  call s:setup_commands(a:cchar)
-
-  let list1 = [{'filename': 'fnameA', 'text': 'A'},
-          \    {'filename': 'fnameB', 'text': 'B'}]
-  let list2 = [{'filename': 'fnameC', 'text': 'C'},
-          \    {'filename': 'fnameD', 'text': 'D'},
-          \    {'filename': 'fnameE', 'text': 'E'}]
-
-  " {action} is unspecified.  Same as specifying ' '.
-  new | only
-  silent! Xnewer 99
-  call g:Xsetlist(list1)
-  call g:Xsetlist(list2)
-  let li = g:Xgetlist()
-  call assert_equal(3, len(li))
-  call assert_equal('C', li[0]['text'])
-  call assert_equal('D', li[1]['text'])
-  call assert_equal('E', li[2]['text'])
-  silent! Xolder
-  let li = g:Xgetlist()
-  call assert_equal(2, len(li))
-  call assert_equal('A', li[0]['text'])
-  call assert_equal('B', li[1]['text'])
-
-  " {action} is specified ' '.
-  new | only
-  silent! Xnewer 99
-  call g:Xsetlist(list1)
-  call g:Xsetlist(list2, ' ')
-  let li = g:Xgetlist()
-  call assert_equal(3, len(li))
-  call assert_equal('C', li[0]['text'])
-  call assert_equal('D', li[1]['text'])
-  call assert_equal('E', li[2]['text'])
-  silent! Xolder
-  let li = g:Xgetlist()
-  call assert_equal(2, len(li))
-  call assert_equal('A', li[0]['text'])
-  call assert_equal('B', li[1]['text'])
-
-  " {action} is specified 'a'.
-  new | only
-  silent! Xnewer 99
-  call g:Xsetlist(list1)
-  call g:Xsetlist(list2, 'a')
-  let li = g:Xgetlist()
-  call assert_equal(5, len(li))
-  call assert_equal('A', li[0]['text'])
-  call assert_equal('B', li[1]['text'])
-  call assert_equal('C', li[2]['text'])
-  call assert_equal('D', li[3]['text'])
-  call assert_equal('E', li[4]['text'])
-
-  " {action} is specified 'r'.
-  new | only
-  silent! Xnewer 99
-  call g:Xsetlist(list1)
-  call g:Xsetlist(list2, 'r')
-  let li = g:Xgetlist()
-  call assert_equal(3, len(li))
-  call assert_equal('C', li[0]['text'])
-  call assert_equal('D', li[1]['text'])
-  call assert_equal('E', li[2]['text'])
-
-  " Test for wrong value.
-  new | only
-  call assert_fails("call g:Xsetlist(0)", 'E714:')
-  call assert_fails("call g:Xsetlist(list1, '')", 'E927:')
-  call assert_fails("call g:Xsetlist(list1, 'aa')", 'E927:')
-  call assert_fails("call g:Xsetlist(list1, ' a')", 'E927:')
-  call assert_fails("call g:Xsetlist(list1, 0)", 'E928:')
-endfunc
-
-func Test_setqflist_invalid_nr()
-  " The following command used to crash Vim
-  eval []->setqflist(' ', {'nr' : $XXX_DOES_NOT_EXIST})
-endfunc
-
-func Test_setqflist_user_sets_buftype()
-  call setqflist([{'text': 'foo'}, {'text': 'bar'}])
-  set buftype=quickfix
-  call setqflist([], 'a')
-  enew
-endfunc
-
-func Test_quickfix_set_list_with_act()
-  call XquickfixSetListWithAct('c')
-  call XquickfixSetListWithAct('l')
-endfunc
-
-func XLongLinesTests(cchar)
-  let l = g:Xgetlist()
-
-  call assert_equal(4, len(l))
-  call assert_equal(1, l[0].lnum)
-  call assert_equal(1, l[0].col)
-  call assert_equal(1975, len(l[0].text))
-  call assert_equal(2, l[1].lnum)
-  call assert_equal(1, l[1].col)
-  call assert_equal(4070, len(l[1].text))
-  call assert_equal(3, l[2].lnum)
-  call assert_equal(1, l[2].col)
-  call assert_equal(4070, len(l[2].text))
-  call assert_equal(4, l[3].lnum)
-  call assert_equal(1, l[3].col)
-  call assert_equal(10, len(l[3].text))
-
-  call g:Xsetlist([], 'r')
-endfunc
-
-func s:long_lines_tests(cchar)
-  call s:setup_commands(a:cchar)
-
-  let testfile = 'samples/quickfix.txt'
-
-  " file
-  exe 'Xgetfile' testfile
-  call XLongLinesTests(a:cchar)
-
-  " list
-  Xexpr readfile(testfile)
-  call XLongLinesTests(a:cchar)
-
-  " string
-  Xexpr join(readfile(testfile), "\n")
-  call XLongLinesTests(a:cchar)
-
-  " buffer
-  exe 'edit' testfile
-  exe 'Xbuffer' bufnr('%')
-  call XLongLinesTests(a:cchar)
-endfunc
-
-func Test_long_lines()
-  call s:long_lines_tests('c')
-  call s:long_lines_tests('l')
-endfunc
-
-func Test_cgetfile_on_long_lines()
-  " Problematic values if the line is longer than 4096 bytes.  Then 1024 bytes
-  " are read at a time.
-  for len in [4078, 4079, 4080, 5102, 5103, 5104, 6126, 6127, 6128, 7150, 7151, 7152]
-    let lines =<< trim END
-      /tmp/file1:1:1:aaa
-      /tmp/file2:1:1:%s
-      /tmp/file3:1:1:bbb
-      /tmp/file4:1:1:ccc
-    END
-    let lines[1] = substitute(lines[1], '%s', repeat('x', len), '')
-    call writefile(lines, 'Xcqetfile.txt')
-    cgetfile Xcqetfile.txt
-    call assert_equal(4, getqflist(#{size: v:true}).size, 'with length ' .. len)
-  endfor
-  call delete('Xcqetfile.txt')
-endfunc
-
-func s:create_test_file(filename)
-  let l = []
-  for i in range(1, 20)
-      call add(l, 'Line' . i)
-  endfor
-  call writefile(l, a:filename)
-endfunc
-
-func Test_switchbuf()
-  call s:create_test_file('Xqftestfile1')
-  call s:create_test_file('Xqftestfile2')
-  call s:create_test_file('Xqftestfile3')
-
-  new | only
-  edit Xqftestfile1
-  let file1_winid = win_getid()
-  new Xqftestfile2
-  let file2_winid = win_getid()
-  let lines =<< trim END
-    Xqftestfile1:5:Line5
-    Xqftestfile1:6:Line6
-    Xqftestfile2:10:Line10
-    Xqftestfile2:11:Line11
-    Xqftestfile3:15:Line15
-    Xqftestfile3:16:Line16
-  END
-  cgetexpr lines
-
-  new
-  let winid = win_getid()
-  cfirst | cnext
-  call assert_equal(winid, win_getid())
-  2cnext
-  call assert_equal(winid, win_getid())
-  2cnext
-  call assert_equal(winid, win_getid())
-
-  " Test for 'switchbuf' set to search for files in windows in the current
-  " tabpage and jump to an existing window (if present)
-  set switchbuf=useopen
-  enew
-  cfirst | cnext
-  call assert_equal(file1_winid, win_getid())
-  2cnext
-  call assert_equal(file2_winid, win_getid())
-  2cnext
-  call assert_equal(file2_winid, win_getid())
-
-  " Test for 'switchbuf' set to search for files in tabpages and jump to an
-  " existing tabpage (if present)
-  enew | only
-  set switchbuf=usetab
-  tabedit Xqftestfile1
-  tabedit Xqftestfile2
-  tabedit Xqftestfile3
-  tabfirst
-  cfirst | cnext
-  call assert_equal(2, tabpagenr())
-  2cnext
-  call assert_equal(3, tabpagenr())
-  6cnext
-  call assert_equal(4, tabpagenr())
-  2cpfile
-  call assert_equal(2, tabpagenr())
-  2cnfile
-  call assert_equal(4, tabpagenr())
-  tabfirst | tabonly | enew
-
-  " Test for 'switchbuf' set to open a new window for every file
-  set switchbuf=split
-  cfirst | cnext
-  call assert_equal(1, winnr('$'))
-  cnext | cnext
-  call assert_equal(2, winnr('$'))
-  cnext | cnext
-  call assert_equal(3, winnr('$'))
-
-  " Test for 'switchbuf' set to open a new tabpage for every file
-  set switchbuf=newtab
-  enew | only
-  cfirst | cnext
-  call assert_equal(1, tabpagenr('$'))
-  cnext | cnext
-  call assert_equal(2, tabpagenr('$'))
-  cnext | cnext
-  call assert_equal(3, tabpagenr('$'))
-  tabfirst | enew | tabonly | only
-
-  set switchbuf=uselast
-  split
-  let last_winid = win_getid()
-  copen
-  exe "normal 1G\<CR>"
-  call assert_equal(last_winid, win_getid())
-  enew | only
-
-  " With an empty 'switchbuf', jumping to a quickfix entry should open the
-  " file in an existing window (if present)
-  set switchbuf=
-  edit Xqftestfile1
-  let file1_winid = win_getid()
-  new Xqftestfile2
-  let file2_winid = win_getid()
-  copen
-  exe "normal 1G\<CR>"
-  call assert_equal(file1_winid, win_getid())
-  copen
-  exe "normal 3G\<CR>"
-  call assert_equal(file2_winid, win_getid())
-  copen | only
-  exe "normal 5G\<CR>"
-  call assert_equal(2, winnr('$'))
-  call assert_equal(1, bufwinnr('Xqftestfile3'))
-
-  " If only quickfix window is open in the current tabpage, jumping to an
-  " entry with 'switchbuf' set to 'usetab' should search in other tabpages.
-  enew | only
-  set switchbuf=usetab
-  tabedit Xqftestfile1
-  tabedit Xqftestfile2
-  tabedit Xqftestfile3
-  tabfirst
-  copen | only
-  clast
-  call assert_equal(4, tabpagenr())
-  tabfirst | tabonly | enew | only
-
-  " Jumping to a file that is not present in any of the tabpages and the
-  " current tabpage doesn't have any usable windows, should open it in a new
-  " window in the current tabpage.
-  copen | only
-  cfirst
-  call assert_equal(1, tabpagenr())
-  call assert_equal('Xqftestfile1', @%)
-
-  " If opening a file changes 'switchbuf', then the new value should be
-  " retained.
-  set modeline&vim
-  call writefile(["vim: switchbuf=split"], 'Xqftestfile1')
-  enew | only
-  set switchbuf&vim
-  cexpr "Xqftestfile1:1:10"
-  call assert_equal('split', &switchbuf)
-  call writefile(["vim: switchbuf=usetab"], 'Xqftestfile1')
-  enew | only
-  set switchbuf=useopen
-  cexpr "Xqftestfile1:1:10"
-  call assert_equal('usetab', &switchbuf)
-  call writefile(["vim: switchbuf&vim"], 'Xqftestfile1')
-  enew | only
-  set switchbuf=useopen
-  cexpr "Xqftestfile1:1:10"
-  call assert_equal('uselast', &switchbuf)
-
-  call delete('Xqftestfile1')
-  call delete('Xqftestfile2')
-  call delete('Xqftestfile3')
-  set switchbuf&vim
-
-  enew | only
-endfunc
-
-func Xadjust_qflnum(cchar)
-  call s:setup_commands(a:cchar)
-
-  enew | only
-
-  let fname = 'Xqftestfile' . a:cchar
-  call s:create_test_file(fname)
-  exe 'edit ' . fname
-
-  Xgetexpr [fname . ':5:Line5',
-	      \ fname . ':10:Line10',
-	      \ fname . ':15:Line15',
-	      \ fname . ':20:Line20']
-
-  6,14delete
-  call append(6, ['Buffer', 'Window'])
-
-  let l = g:Xgetlist()
-  call assert_equal(5, l[0].lnum)
-  call assert_equal(6, l[2].lnum)
-  call assert_equal(13, l[3].lnum)
-
-  " If a file doesn't have any quickfix entries, then deleting lines in the
-  " file should not update the quickfix list
-  call g:Xsetlist([], 'f')
-  1,2delete
-  call assert_equal([], g:Xgetlist())
-
-  enew!
-  call delete(fname)
-endfunc
-
-func Test_adjust_lnum()
-  call setloclist(0, [])
-  call Xadjust_qflnum('c')
-  call setqflist([])
-  call Xadjust_qflnum('l')
-endfunc
-
-" Tests for the :grep/:lgrep and :grepadd/:lgrepadd commands
-func s:test_xgrep(cchar)
-  call s:setup_commands(a:cchar)
-
-  " The following lines are used for the grep test. Don't remove.
-  " Grep_Test_Text: Match 1
-  " Grep_Test_Text: Match 2
-  " GrepAdd_Test_Text: Match 1
-  " GrepAdd_Test_Text: Match 2
-  enew! | only
-  set makeef&vim
-  silent Xgrep Grep_Test_Text: test_quickfix.vim
-  call assert_true(len(g:Xgetlist()) == 5)
-  Xopen
-  call assert_true(w:quickfix_title =~ '^:grep')
-  Xclose
-  enew
-  set makeef=Temp_File_##
-  silent Xgrepadd GrepAdd_Test_Text: test_quickfix.vim
-  call assert_true(len(g:Xgetlist()) == 9)
-
-  " Try with 'grepprg' set to 'internal'
-  set grepprg=internal
-  silent Xgrep Grep_Test_Text: test_quickfix.vim
-  silent Xgrepadd GrepAdd_Test_Text: test_quickfix.vim
-  call assert_true(len(g:Xgetlist()) == 9)
-  set grepprg&vim
-
-  call writefile(['Vim'], 'XtestTempFile')
-  set makeef=XtestTempFile
-  silent Xgrep Grep_Test_Text: test_quickfix.vim
-  call assert_equal(5, len(g:Xgetlist()))
-  call assert_false(filereadable('XtestTempFile'))
-  set makeef&vim
-endfunc
-
-func Test_grep()
-  if !has('unix')
-    " The grepprg may not be set on non-Unix systems
-    return
-  endif
-
-  call s:test_xgrep('c')
-  call s:test_xgrep('l')
-endfunc
-
-func Test_two_windows()
-  " Use one 'errorformat' for two windows.  Add an expression to each of them,
-  " make sure they each keep their own state.
-  set efm=%DEntering\ dir\ '%f',%f:%l:%m,%XLeaving\ dir\ '%f'
-  call mkdir('Xone/a', 'p')
-  call mkdir('Xtwo/a', 'p')
-  let lines = ['1', '2', 'one one one', '4', 'two two two', '6', '7']
-  call writefile(lines, 'Xone/a/one.txt')
-  call writefile(lines, 'Xtwo/a/two.txt')
-
-  new one
-  let one_id = win_getid()
-  lexpr ""
-  new two
-  let two_id = win_getid()
-  lexpr ""
-
-  laddexpr "Entering dir 'Xtwo/a'"
-  call win_gotoid(one_id)
-  laddexpr "Entering dir 'Xone/a'"
-  call win_gotoid(two_id)
-  laddexpr 'two.txt:5:two two two'
-  call win_gotoid(one_id)
-  laddexpr 'one.txt:3:one one one'
-
-  let loc_one = getloclist(one_id)
-  call assert_equal('Xone/a/one.txt', bufname(loc_one[1].bufnr))
-  call assert_equal(3, loc_one[1].lnum)
-
-  let loc_two = getloclist(two_id)
-  call assert_equal('Xtwo/a/two.txt', bufname(loc_two[1].bufnr))
-  call assert_equal(5, loc_two[1].lnum)
-
-  call win_gotoid(one_id)
-  bwipe!
-  call win_gotoid(two_id)
-  bwipe!
-  call delete('Xone', 'rf')
-  call delete('Xtwo', 'rf')
-endfunc
-
-func XbottomTests(cchar)
-  call s:setup_commands(a:cchar)
-
-  " Calling lbottom without any errors should fail
-  if a:cchar == 'l'
-      call assert_fails('lbottom', 'E776:')
-  endif
-
-  call g:Xsetlist([{'filename': 'foo', 'lnum': 42}])
-  Xopen
-  let wid = win_getid()
-  call assert_equal(1, line('.'))
-  wincmd w
-  call g:Xsetlist([{'filename': 'var', 'lnum': 24}], 'a')
-  Xbottom
-  call win_gotoid(wid)
-  call assert_equal(2, line('.'))
-  Xclose
-endfunc
-
-" Tests for the :cbottom and :lbottom commands
-func Test_cbottom()
-  call XbottomTests('c')
-  call XbottomTests('l')
-endfunc
-
-func HistoryTest(cchar)
-  call s:setup_commands(a:cchar)
-
-  " clear all lists after the first one, then replace the first one.
-  call g:Xsetlist([])
-  call assert_fails('Xolder 99', 'E380:')
-  let entry = {'filename': 'foo', 'lnum': 42}
-  call g:Xsetlist([entry], 'r')
-  call g:Xsetlist([entry, entry])
-  call g:Xsetlist([entry, entry, entry])
-  let res = split(execute(a:cchar . 'hist'), "\n")
-  call assert_equal(3, len(res))
-  let common = 'errors     :set' . (a:cchar == 'c' ? 'qf' : 'loc') . 'list()'
-  call assert_equal('  error list 1 of 3; 1 ' . common, res[0])
-  call assert_equal('  error list 2 of 3; 2 ' . common, res[1])
-  call assert_equal('> error list 3 of 3; 3 ' . common, res[2])
-
-  " Test for changing the quickfix lists
-  call assert_equal(3, g:Xgetlist({'nr' : 0}).nr)
-  exe '1' . a:cchar . 'hist'
-  call assert_equal(1, g:Xgetlist({'nr' : 0}).nr)
-  exe '3' . a:cchar . 'hist'
-  call assert_equal(3, g:Xgetlist({'nr' : 0}).nr)
-  call assert_fails('-2' . a:cchar . 'hist', 'E16:')
-  call assert_fails('4' . a:cchar . 'hist', 'E16:')
-
-  call g:Xsetlist([], 'f')
-  let l = split(execute(a:cchar . 'hist'), "\n")
-  call assert_equal('No entries', l[0])
-  if a:cchar == 'c'
-    call assert_fails('4chist', 'E16:')
-  else
-    call assert_fails('4lhist', 'E776:')
-  endif
-
-  " An empty list should still show the stack history
-  call g:Xsetlist([])
-  let res = split(execute(a:cchar . 'hist'), "\n")
-  call assert_equal('> error list 1 of 1; 0 ' . common, res[0])
-
-  call g:Xsetlist([], 'f')
-endfunc
-
-func Test_history()
-  call HistoryTest('c')
-  call HistoryTest('l')
-endfunc
-
-func Test_duplicate_buf()
-  " make sure we can get the highest buffer number
-  edit DoesNotExist
-  edit DoesNotExist2
-  let last_buffer = bufnr("$")
-
-  " make sure only one buffer is created
-  call writefile(['this one', 'that one'], 'Xgrepthis')
-  vimgrep one Xgrepthis
-  vimgrep one Xgrepthis
-  call assert_equal(last_buffer + 1, bufnr("$"))
-
-  call delete('Xgrepthis')
-endfunc
-
-" Quickfix/Location list set/get properties tests
-func Xproperty_tests(cchar)
-    call s:setup_commands(a:cchar)
-
-    " Error cases
-    call assert_fails('call g:Xgetlist(99)', 'E715:')
-    call assert_fails('call g:Xsetlist(99)', 'E714:')
-    call assert_fails('call g:Xsetlist([], "a", [])', 'E715:')
-
-    " Set and get the title
-    call g:Xsetlist([])
-    Xopen
-    wincmd p
-    call g:Xsetlist([{'filename':'foo', 'lnum':27}])
-    let s = g:Xsetlist([], 'a', {'title' : 'Sample'})
-    call assert_equal(0, s)
-    let d = g:Xgetlist({"title":1})
-    call assert_equal('Sample', d.title)
-    " Try setting title to a non-string value
-    call assert_equal(-1, g:Xsetlist([], 'a', {'title' : ['Test']}))
-    call assert_equal('Sample', g:Xgetlist({"title":1}).title)
-
-    Xopen
-    call assert_equal('Sample', w:quickfix_title)
-    Xclose
-
-    " Tests for action argument
-    silent! Xolder 999
-    let qfnr = g:Xgetlist({'all':1}).nr
-    call g:Xsetlist([], 'r', {'title' : 'N1'})
-    call assert_equal('N1', g:Xgetlist({'all':1}).title)
-    call g:Xsetlist([], ' ', {'title' : 'N2'})
-    call assert_equal(qfnr + 1, g:Xgetlist({'all':1}).nr)
-
-    let res = g:Xgetlist({'nr': 0})
-    call assert_equal(qfnr + 1, res.nr)
-    call assert_equal(['nr'], keys(res))
-
-    call g:Xsetlist([], ' ', {'title' : 'N3'})
-    call assert_equal('N2', g:Xgetlist({'nr':2, 'title':1}).title)
-
-    " Changing the title of an earlier quickfix list
-    call g:Xsetlist([], 'r', {'title' : 'NewTitle', 'nr' : 2})
-    call assert_equal('NewTitle', g:Xgetlist({'nr':2, 'title':1}).title)
-
-    " Changing the title of an invalid quickfix list
-    call assert_equal(-1, g:Xsetlist([], ' ',
-		\ {'title' : 'SomeTitle', 'nr' : 99}))
-    call assert_equal(-1, g:Xsetlist([], ' ',
-		\ {'title' : 'SomeTitle', 'nr' : 'abc'}))
-
-    if a:cchar == 'c'
-	copen
-	call assert_equal({'winid':win_getid()}, getqflist({'winid':1}))
-	cclose
-    endif
-
-    " Invalid arguments
-    call assert_fails('call g:Xgetlist([])', 'E715')
-    call assert_fails('call g:Xsetlist([], "a", [])', 'E715')
-    let s = g:Xsetlist([], 'a', {'abc':1})
-    call assert_equal(-1, s)
-
-    call assert_equal({}, g:Xgetlist({'abc':1}))
-    call assert_equal('', g:Xgetlist({'nr':99, 'title':1}).title)
-    call assert_equal('', g:Xgetlist({'nr':[], 'title':1}).title)
-
-    if a:cchar == 'l'
-	call assert_equal({}, getloclist(99, {'title': 1}))
-    endif
-
-    " Context related tests
-    let s = g:Xsetlist([], 'a', {'context':[1,2,3]})
-    call assert_equal(0, s)
-    call test_garbagecollect_now()
-    let d = g:Xgetlist({'context':1})
-    call assert_equal([1,2,3], d.context)
-    call g:Xsetlist([], 'a', {'context':{'color':'green'}})
-    let d = g:Xgetlist({'context':1})
-    call assert_equal({'color':'green'}, d.context)
-    call g:Xsetlist([], 'a', {'context':"Context info"})
-    let d = g:Xgetlist({'context':1})
-    call assert_equal("Context info", d.context)
-    call g:Xsetlist([], 'a', {'context':246})
-    let d = g:Xgetlist({'context':1})
-    call assert_equal(246, d.context)
-    " set other Vim data types as context
-    call g:Xsetlist([], 'a', {'context' : v:_null_blob})
-    call g:Xsetlist([], 'a', {'context' : ''})
-    call test_garbagecollect_now()
-    if a:cchar == 'l'
-	" Test for copying context across two different location lists
-	new | only
-	let w1_id = win_getid()
-	let l = [1]
-	call setloclist(0, [], 'a', {'context':l})
-	new
-	let w2_id = win_getid()
-	call add(l, 2)
-	call assert_equal([1, 2], getloclist(w1_id, {'context':1}).context)
-	call assert_equal([1, 2], getloclist(w2_id, {'context':1}).context)
-	unlet! l
-	call assert_equal([1, 2], getloclist(w2_id, {'context':1}).context)
-	only
-	call setloclist(0, [], 'f')
-	call assert_equal('', getloclist(0, {'context':1}).context)
-    endif
-
-    " Test for changing the context of previous quickfix lists
-    call g:Xsetlist([], 'f')
-    Xexpr "One"
-    Xexpr "Two"
-    Xexpr "Three"
-    call g:Xsetlist([], 'r', {'context' : [1], 'nr' : 1})
-    call g:Xsetlist([], 'a', {'context' : [2], 'nr' : 2})
-    " Also, check for setting the context using quickfix list number zero.
-    call g:Xsetlist([], 'r', {'context' : [3], 'nr' : 0})
-    call test_garbagecollect_now()
-    let l = g:Xgetlist({'nr' : 1, 'context' : 1})
-    call assert_equal([1], l.context)
-    let l = g:Xgetlist({'nr' : 2, 'context' : 1})
-    call assert_equal([2], l.context)
-    let l = g:Xgetlist({'nr' : 3, 'context' : 1})
-    call assert_equal([3], l.context)
-
-    " Test for changing the context through reference and for garbage
-    " collection of quickfix context
-    let l = ["red"]
-    call g:Xsetlist([], ' ', {'context' : l})
-    call add(l, "blue")
-    let x = g:Xgetlist({'context' : 1})
-    call add(x.context, "green")
-    call assert_equal(["red", "blue", "green"], l)
-    call assert_equal(["red", "blue", "green"], x.context)
-    unlet l
-    call test_garbagecollect_now()
-    let m = g:Xgetlist({'context' : 1})
-    call assert_equal(["red", "blue", "green"], m.context)
-
-    " Test for setting/getting items
-    Xexpr ""
-    let qfprev = g:Xgetlist({'nr':0})
-    let s = g:Xsetlist([], ' ', {'title':'Green',
-		\ 'items' : [{'filename':'F1', 'lnum':10}]})
-    call assert_equal(0, s)
-    let qfcur = g:Xgetlist({'nr':0})
-    call assert_true(qfcur.nr == qfprev.nr + 1)
-    let l = g:Xgetlist({'items':1})
-    call assert_equal('F1', bufname(l.items[0].bufnr))
-    call assert_equal(10, l.items[0].lnum)
-    call g:Xsetlist([], 'a', {'items' : [{'filename':'F2', 'lnum':20},
-		\  {'filename':'F2', 'lnum':30}]})
-    let l = g:Xgetlist({'items':1})
-    call assert_equal('F2', bufname(l.items[2].bufnr))
-    call assert_equal(30, l.items[2].lnum)
-    call g:Xsetlist([], 'r', {'items' : [{'filename':'F3', 'lnum':40}]})
-    let l = g:Xgetlist({'items':1})
-    call assert_equal('F3', bufname(l.items[0].bufnr))
-    call assert_equal(40, l.items[0].lnum)
-    call g:Xsetlist([], 'r', {'items' : []})
-    let l = g:Xgetlist({'items':1})
-    call assert_equal(0, len(l.items))
-
-    call g:Xsetlist([], 'r', {'title' : 'TestTitle'})
-    call g:Xsetlist([], 'r', {'items' : [{'filename' : 'F1', 'lnum' : 10, 'text' : 'L10'}]})
-    call g:Xsetlist([], 'r', {'items' : [{'filename' : 'F1', 'lnum' : 10, 'text' : 'L10'}]})
-    call assert_equal('TestTitle', g:Xgetlist({'title' : 1}).title)
-
-    " Test for getting id of window associated with a location list window
-    if a:cchar == 'l'
-      only
-      call assert_equal(0, g:Xgetlist({'all' : 1}).filewinid)
-      let wid = win_getid()
-      Xopen
-      call assert_equal(wid, g:Xgetlist({'filewinid' : 1}).filewinid)
-      wincmd w
-      call assert_equal(0, g:Xgetlist({'filewinid' : 1}).filewinid)
-      only
-    endif
-
-    " The following used to crash Vim with address sanitizer
-    call g:Xsetlist([], 'f')
-    call g:Xsetlist([], 'a', {'items' : [{'filename':'F1', 'lnum':10}]})
-    call assert_equal(10, g:Xgetlist({'items':1}).items[0].lnum)
-
-    " Try setting the items using a string
-    call assert_equal(-1, g:Xsetlist([], ' ', {'items' : 'Test'}))
-
-    " Save and restore the quickfix stack
-    call g:Xsetlist([], 'f')
-    call assert_equal(0, g:Xgetlist({'nr':'$'}).nr)
-    Xexpr "File1:10:Line1"
-    Xexpr "File2:20:Line2"
-    Xexpr "File3:30:Line3"
-    let last_qf = g:Xgetlist({'nr':'$'}).nr
-    call assert_equal(3, last_qf)
-    let qstack = []
-    for i in range(1, last_qf)
-	let qstack = add(qstack, g:Xgetlist({'nr':i, 'all':1}))
-    endfor
-    call g:Xsetlist([], 'f')
-    for i in range(len(qstack))
-	call g:Xsetlist([], ' ', qstack[i])
-    endfor
-    call assert_equal(3, g:Xgetlist({'nr':'$'}).nr)
-    call assert_equal(10, g:Xgetlist({'nr':1, 'items':1}).items[0].lnum)
-    call assert_equal(20, g:Xgetlist({'nr':2, 'items':1}).items[0].lnum)
-    call assert_equal(30, g:Xgetlist({'nr':3, 'items':1}).items[0].lnum)
-    call g:Xsetlist([], 'f')
-
-    " Swap two quickfix lists
-    Xexpr "File1:10:Line10"
-    Xexpr "File2:20:Line20"
-    Xexpr "File3:30:Line30"
-    call g:Xsetlist([], 'r', {'nr':1,'title':'Colors','context':['Colors']})
-    call g:Xsetlist([], 'r', {'nr':2,'title':'Fruits','context':['Fruits']})
-    let l1=g:Xgetlist({'nr':1,'all':1})
-    let l2=g:Xgetlist({'nr':2,'all':1})
-    let save_id = l1.id
-    let l1.id=l2.id
-    let l2.id=save_id
-    call g:Xsetlist([], 'r', l1)
-    call g:Xsetlist([], 'r', l2)
-    let newl1=g:Xgetlist({'nr':1,'all':1})
-    let newl2=g:Xgetlist({'nr':2,'all':1})
-    call assert_equal('Fruits', newl1.title)
-    call assert_equal(['Fruits'], newl1.context)
-    call assert_equal('Line20', newl1.items[0].text)
-    call assert_equal('Colors', newl2.title)
-    call assert_equal(['Colors'], newl2.context)
-    call assert_equal('Line10', newl2.items[0].text)
-    call g:Xsetlist([], 'f')
-
-    " Cannot specify both a non-empty list argument and a dict argument
-    call assert_fails("call g:Xsetlist([{}], ' ', {})", 'E475:')
-endfunc
-
-func Test_qf_property()
-    call Xproperty_tests('c')
-    call Xproperty_tests('l')
-endfunc
-
-" Test for setting the current index in the location/quickfix list
-func Xtest_setqfidx(cchar)
-  call s:setup_commands(a:cchar)
-
-  Xgetexpr "F1:10:1:Line1\nF2:20:2:Line2\nF3:30:3:Line3"
-  Xgetexpr "F4:10:1:Line1\nF5:20:2:Line2\nF6:30:3:Line3"
-  Xgetexpr "F7:10:1:Line1\nF8:20:2:Line2\nF9:30:3:Line3"
-
-  call g:Xsetlist([], 'a', {'nr' : 3, 'idx' : 2})
-  call g:Xsetlist([], 'a', {'nr' : 2, 'idx' : 2})
-  call g:Xsetlist([], 'a', {'nr' : 1, 'idx' : 3})
-  Xolder 2
-  Xopen
-  call assert_equal(3, line('.'))
-  Xnewer
-  call assert_equal(2, line('.'))
-  Xnewer
-  call assert_equal(2, line('.'))
-  " Update the current index with the quickfix window open
-  wincmd w
-  call g:Xsetlist([], 'a', {'nr' : 3, 'idx' : 3})
-  Xopen
-  call assert_equal(3, line('.'))
-  Xclose
-
-  " Set the current index to the last entry
-  call g:Xsetlist([], 'a', {'nr' : 1, 'idx' : '$'})
-  call assert_equal(3, g:Xgetlist({'nr' : 1, 'idx' : 0}).idx)
-  " A large value should set the index to the last index
-  call g:Xsetlist([], 'a', {'nr' : 1, 'idx' : 1})
-  call g:Xsetlist([], 'a', {'nr' : 1, 'idx' : 999})
-  call assert_equal(3, g:Xgetlist({'nr' : 1, 'idx' : 0}).idx)
-  " Invalid index values
-  call g:Xsetlist([], 'a', {'nr' : 1, 'idx' : -1})
-  call assert_equal(3, g:Xgetlist({'nr' : 1, 'idx' : 0}).idx)
-  call g:Xsetlist([], 'a', {'nr' : 1, 'idx' : 0})
-  call assert_equal(3, g:Xgetlist({'nr' : 1, 'idx' : 0}).idx)
-  call g:Xsetlist([], 'a', {'nr' : 1, 'idx' : 'xx'})
-  call assert_equal(3, g:Xgetlist({'nr' : 1, 'idx' : 0}).idx)
-  call assert_fails("call g:Xsetlist([], 'a', {'nr':1, 'idx':[]})", 'E745:')
-
-  call g:Xsetlist([], 'f')
-  new | only
-endfunc
-
-func Test_setqfidx()
-  call Xtest_setqfidx('c')
-  call Xtest_setqfidx('l')
-endfunc
-
-" Tests for the QuickFixCmdPre/QuickFixCmdPost autocommands
-func QfAutoCmdHandler(loc, cmd)
-  call add(g:acmds, a:loc . a:cmd)
-endfunc
-
-func Test_Autocmd()
-  autocmd QuickFixCmdPre * call QfAutoCmdHandler('pre', expand('<amatch>'))
-  autocmd QuickFixCmdPost * call QfAutoCmdHandler('post', expand('<amatch>'))
-
-  let g:acmds = []
-  cexpr "F1:10:Line 10"
-  caddexpr "F1:20:Line 20"
-  cgetexpr "F1:30:Line 30"
-  cexpr ""
-  caddexpr ""
-  cgetexpr ""
-  silent! cexpr non_existing_func()
-  silent! caddexpr non_existing_func()
-  silent! cgetexpr non_existing_func()
-  let l =<< trim END
-    precexpr
-    postcexpr
-    precaddexpr
-    postcaddexpr
-    precgetexpr
-    postcgetexpr
-    precexpr
-    postcexpr
-    precaddexpr
-    postcaddexpr
-    precgetexpr
-    postcgetexpr
-    precexpr
-    precaddexpr
-    precgetexpr
-  END
-  call assert_equal(l, g:acmds)
-
-  let g:acmds = []
-  enew! | call append(0, "F2:10:Line 10")
-  cbuffer!
-  enew! | call append(0, "F2:20:Line 20")
-  cgetbuffer
-  enew! | call append(0, "F2:30:Line 30")
-  caddbuffer
-
-  new
-  let bnum = bufnr('%')
-  bunload
-  exe 'silent! cbuffer! ' . bnum
-  exe 'silent! cgetbuffer ' . bnum
-  exe 'silent! caddbuffer ' . bnum
-  enew!
-  let l =<< trim END
-    precbuffer
-    postcbuffer
-    precgetbuffer
-    postcgetbuffer
-    precaddbuffer
-    postcaddbuffer
-    precbuffer
-    precgetbuffer
-    precaddbuffer
-  END
-  call assert_equal(l, g:acmds)
-
-  call writefile(['Xtest:1:Line1'], 'Xtest')
-  call writefile([], 'Xempty')
-  let g:acmds = []
-  cfile Xtest
-  caddfile Xtest
-  cgetfile Xtest
-  cfile Xempty
-  caddfile Xempty
-  cgetfile Xempty
-  silent! cfile do_not_exist
-  silent! caddfile do_not_exist
-  silent! cgetfile do_not_exist
-  let l =<< trim END
-    precfile
-    postcfile
-    precaddfile
-    postcaddfile
-    precgetfile
-    postcgetfile
-    precfile
-    postcfile
-    precaddfile
-    postcaddfile
-    precgetfile
-    postcgetfile
-    precfile
-    postcfile
-    precaddfile
-    postcaddfile
-    precgetfile
-    postcgetfile
-  END
-  call assert_equal(l, g:acmds)
-
-  let g:acmds = []
-  helpgrep quickfix
-  silent! helpgrep non_existing_help_topic
-  vimgrep test Xtest
-  vimgrepadd test Xtest
-  silent! vimgrep non_existing_test Xtest
-  silent! vimgrepadd non_existing_test Xtest
-  set makeprg=
-  silent! make
-  set makeprg&
-  let l =<< trim END
-    prehelpgrep
-    posthelpgrep
-    prehelpgrep
-    posthelpgrep
-    previmgrep
-    postvimgrep
-    previmgrepadd
-    postvimgrepadd
-    previmgrep
-    postvimgrep
-    previmgrepadd
-    postvimgrepadd
-    premake
-    postmake
-  END
-  call assert_equal(l, g:acmds)
-
-  if has('unix')
-    " Run this test only on Unix-like systems. The grepprg may not be set on
-    " non-Unix systems.
-    " The following lines are used for the grep test. Don't remove.
-    " Grep_Autocmd_Text: Match 1
-    " GrepAdd_Autocmd_Text: Match 2
-    let g:acmds = []
-    silent grep Grep_Autocmd_Text test_quickfix.vim
-    silent grepadd GrepAdd_Autocmd_Text test_quickfix.vim
-    silent grep abc123def Xtest
-    silent grepadd abc123def Xtest
-    set grepprg=internal
-    silent grep Grep_Autocmd_Text test_quickfix.vim
-    silent grepadd GrepAdd_Autocmd_Text test_quickfix.vim
-    silent lgrep Grep_Autocmd_Text test_quickfix.vim
-    silent lgrepadd GrepAdd_Autocmd_Text test_quickfix.vim
-    set grepprg&vim
-    let l =<< trim END
-      pregrep
-      postgrep
-      pregrepadd
-      postgrepadd
-      pregrep
-      postgrep
-      pregrepadd
-      postgrepadd
-      pregrep
-      postgrep
-      pregrepadd
-      postgrepadd
-      prelgrep
-      postlgrep
-      prelgrepadd
-      postlgrepadd
-    END
-    call assert_equal(l, g:acmds)
-  endif
-
-  call delete('Xtest')
-  call delete('Xempty')
-  au! QuickFixCmdPre
-  au! QuickFixCmdPost
-endfunc
-
-func Test_Autocmd_Exception()
-  set efm=%m
-  lgetexpr '?'
-
-  try
-    call DoesNotExit()
-  catch
-    lgetexpr '1'
-  finally
-    lgetexpr '1'
-  endtry
-
-  call assert_equal('1', getloclist(0)[0].text)
-
-  set efm&vim
-endfunc
-
-func Test_caddbuffer_wrong()
-  " This used to cause a memory access in freed memory.
-  let save_efm = &efm
-  set efm=%EEEE%m,%WWWW,%+CCCC%>%#,%GGGG%.#
-  cgetexpr ['WWWW', 'EEEE', 'CCCC']
-  let &efm = save_efm
-  caddbuffer
-  bwipe!
-endfunc
-
-func Test_caddexpr_wrong()
-  " This used to cause a memory access in freed memory.
-  cbuffer
-  cbuffer
-  copen
-  let save_efm = &efm
-  set efm=%
-  call assert_fails('caddexpr ""', 'E376:')
-  let &efm = save_efm
-endfunc
-
-func Test_dirstack_cleanup()
-  " This used to cause a memory access in freed memory.
-  let save_efm = &efm
-  lexpr '0'
-  lopen
-  fun X(c)
-    let save_efm=&efm
-    set efm=%D%f
-    if a:c == 'c'
-      caddexpr '::'
-    else
-      laddexpr ':0:0'
-    endif
-    let &efm=save_efm
-  endfun
-  call X('c')
-  call X('l')
-  call setqflist([], 'r')
-  caddbuffer
-  let &efm = save_efm
-endfunc
-
-" Tests for jumping to entries from the location list window and quickfix
-" window
-func Test_cwindow_jump()
-  set efm=%f%%%l%%%m
-  lgetexpr ["F1%10%Line 10", "F2%20%Line 20", "F3%30%Line 30"]
-  lopen | only
-  lfirst
-  call assert_true(winnr('$') == 2)
-  call assert_true(winnr() == 1)
-  " Location list for the new window should be set
-  call assert_true(getloclist(0)[2].text == 'Line 30')
-
-  " Open a scratch buffer
-  " Open a new window and create a location list
-  " Open the location list window and close the other window
-  " Jump to an entry.
-  " Should create a new window and jump to the entry. The scratch buffer
-  " should not be used.
-  enew | only
-  set buftype=nofile
-  below new
-  lgetexpr ["F1%10%Line 10", "F2%20%Line 20", "F3%30%Line 30"]
-  lopen
-  2wincmd c
-  lnext
-  call assert_true(winnr('$') == 3)
-  call assert_true(winnr() == 2)
-
-  " Open two windows with two different location lists
-  " Open the location list window and close the previous window
-  " Jump to an entry in the location list window
-  " Should open the file in the first window and not set the location list.
-  enew | only
-  lgetexpr ["F1%5%Line 5"]
-  below new
-  lgetexpr ["F1%10%Line 10", "F2%20%Line 20", "F3%30%Line 30"]
-  lopen
-  2wincmd c
-  lnext
-  call assert_true(winnr() == 1)
-  call assert_true(getloclist(0)[0].text == 'Line 5')
-
-  enew | only
-  cgetexpr ["F1%10%Line 10", "F2%20%Line 20", "F3%30%Line 30"]
-  copen
-  cnext
-  call assert_true(winnr('$') == 2)
-  call assert_true(winnr() == 1)
-
-  " open the quickfix buffer in two windows and jump to an entry. Should open
-  " the file in the first quickfix window.
-  enew | only
-  copen
-  let bnum = bufnr('')
-  exe 'sbuffer ' . bnum
-  wincmd b
-  cfirst
-  call assert_equal(2, winnr())
-  call assert_equal('F1', @%)
-  enew | only
-  exe 'sb' bnum
-  exe 'botright sb' bnum
-  wincmd t
-  clast
-  call assert_equal(2, winnr())
-  call assert_equal('quickfix', getwinvar(1, '&buftype'))
-  call assert_equal('quickfix', getwinvar(3, '&buftype'))
-
-  " Jumping to a file from the location list window should find a usable
-  " window by wrapping around the window list.
-  enew | only
-  call setloclist(0, [], 'f')
-  new | new
-  lgetexpr ["F1%10%Line 10", "F2%20%Line 20", "F3%30%Line 30"]
-  lopen
-  1close
-  call assert_equal(0, getloclist(3, {'id' : 0}).id)
-  lnext
-  call assert_equal(3, winnr())
-  call assert_equal(getloclist(1, {'id' : 0}).id, getloclist(3, {'id' : 0}).id)
-
-  enew | only
-  set efm&vim
-endfunc
-
-func Test_cwindow_highlight()
-  CheckScreendump
-
-  let lines =<< trim END
-    call setline(1, ['some', 'text', 'with', 'matches'])
-    write XCwindow
-    vimgrep e XCwindow
-    redraw
-    cwindow 4
-  END
-  call writefile(lines, 'XtestCwindow')
-  let buf = RunVimInTerminal('-S XtestCwindow', #{rows: 12})
-  call VerifyScreenDump(buf, 'Test_quickfix_cwindow_1', {})
-
-  call term_sendkeys(buf, ":cnext\<CR>")
-  call VerifyScreenDump(buf, 'Test_quickfix_cwindow_2', {})
-
-  " clean up
-  call StopVimInTerminal(buf)
-  call delete('XtestCwindow')
-  call delete('XCwindow')
-endfunc
-
-func XvimgrepTests(cchar)
-  call s:setup_commands(a:cchar)
-
-  let lines =<< trim END
-    Editor:VIM vim
-    Editor:Emacs EmAcS
-    Editor:Notepad NOTEPAD
-  END
-  call writefile(lines, 'Xtestfile1')
-  call writefile(['Linux', 'macOS', 'MS-Windows'], 'Xtestfile2')
-
-  " Error cases
-  call assert_fails('Xvimgrep /abc *', 'E682:')
-
-  let @/=''
-  call assert_fails('Xvimgrep // *', 'E35:')
-
-  call assert_fails('Xvimgrep abc', 'E683:')
-  call assert_fails('Xvimgrep a1b2c3 Xtestfile1', 'E480:')
-  call assert_fails('Xvimgrep pat Xa1b2c3', 'E480:')
-
-  Xexpr ""
-  Xvimgrepadd Notepad Xtestfile1
-  Xvimgrepadd macOS Xtestfile2
-  let l = g:Xgetlist()
-  call assert_equal(2, len(l))
-  call assert_equal('Editor:Notepad NOTEPAD', l[0].text)
-
-  10Xvimgrep #\cvim#g Xtestfile?
-  let l = g:Xgetlist()
-  call assert_equal(2, len(l))
-  call assert_equal(8, l[0].col)
-  call assert_equal(11, l[0].end_col)
-  call assert_equal(12, l[1].col)
-  call assert_equal(15, l[1].end_col)
-
-  1Xvimgrep ?Editor? Xtestfile*
-  let l = g:Xgetlist()
-  call assert_equal(1, len(l))
-  call assert_equal('Editor:VIM vim', l[0].text)
-
-  edit +3 Xtestfile2
-  Xvimgrep +\cemacs+j Xtestfile1
-  let l = g:Xgetlist()
-  call assert_equal('Xtestfile2', @%)
-  call assert_equal('Editor:Emacs EmAcS', l[0].text)
-
-  " Test for unloading a buffer after vimgrep searched the buffer
-  %bwipe
-  Xvimgrep /Editor/j Xtestfile*
-  call assert_equal(0, getbufinfo('Xtestfile1')[0].loaded)
-  call assert_equal([], getbufinfo('Xtestfile2'))
-
-  " Test for opening the dummy buffer used by vimgrep in a window. The new
-  " window should be closed
-  %bw!
-  augroup QF_Test
-    au!
-    autocmd BufReadPre * exe "sb " .. expand("<abuf>")
-  augroup END
-  call assert_fails("Xvimgrep /sublime/ Xtestfile1", 'E480:')
-  call assert_equal(1, winnr('$'))
-  augroup QF_Test
-    au!
-  augroup END
-
-  call delete('Xtestfile1')
-  call delete('Xtestfile2')
-endfunc
-
-" Tests for the :vimgrep command
-func Test_vimgrep()
-  call XvimgrepTests('c')
-  call XvimgrepTests('l')
-endfunc
-
-func Test_vimgrep_wildcards_expanded_once()
-  new X[id-01] file.txt
-  call setline(1, 'some text to search for')
-  vimgrep text %
-  bwipe!
-endfunc
-
-" Test for incsearch highlighting of the :vimgrep pattern
-" This test used to cause "E315: ml_get: invalid lnum" errors.
-func Test_vimgrep_incsearch()
-  CheckFunction test_override
-  enew
-  set incsearch
-  call test_override("char_avail", 1)
-
-  call feedkeys(":2vimgrep assert test_quickfix.vim test_cdo.vim\<CR>", "ntx")
-  let l = getqflist()
-  call assert_equal(2, len(l))
-
-  call test_override("ALL", 0)
-  set noincsearch
-endfunc
-
-" Test vimgrep with the last search pattern not set
-func Test_vimgrep_with_no_last_search_pat()
-  let lines =<< trim [SCRIPT]
-    call assert_fails('vimgrep // *', 'E35:')
-    call writefile(v:errors, 'Xresult')
-    qall!
-  [SCRIPT]
-  call writefile(lines, 'Xscript')
-  if RunVim([], [], '--clean -S Xscript')
-    call assert_equal([], readfile('Xresult'))
-  endif
-  call delete('Xscript')
-  call delete('Xresult')
-endfunc
-
-" Test vimgrep without swap file
-func Test_vimgrep_without_swap_file()
-  let lines =<< trim [SCRIPT]
-    vimgrep grep test_c*
-    call writefile(['done'], 'Xresult')
-    qall!
-  [SCRIPT]
-  call writefile(lines, 'Xscript')
-  if RunVim([], [], '--clean -n -S Xscript Xscript')
-    call assert_equal(['done'], readfile('Xresult'))
-  endif
-  call delete('Xscript')
-  call delete('Xresult')
-endfunc
-
-func Test_vimgrep_existing_swapfile()
-  call writefile(['match apple with apple'], 'Xapple')
-  call writefile(['swapfile'], '.Xapple.swp')
-  let g:foundSwap = 0
-  let g:ignoreSwapExists = 1
-  augroup grep
-    au SwapExists * let foundSwap = 1 | let v:swapchoice = 'e'
-  augroup END
-  vimgrep apple Xapple
-  call assert_equal(1, g:foundSwap)
-  call assert_match('.Xapple.swo', swapname(''))
-
-  call delete('Xapple')
-  call delete('Xapple.swp')
-  augroup grep
-    au! SwapExists
-  augroup END
-  unlet g:ignoreSwapExists
-endfunc
-
-func XfreeTests(cchar)
-  call s:setup_commands(a:cchar)
-
-  enew | only
-
-  " Deleting the quickfix stack should work even When the current list is
-  " somewhere in the middle of the stack
-  Xexpr ['Xfile1:10:10:Line 10', 'Xfile1:15:15:Line 15']
-  Xexpr ['Xfile2:20:20:Line 20', 'Xfile2:25:25:Line 25']
-  Xexpr ['Xfile3:30:30:Line 30', 'Xfile3:35:35:Line 35']
-  Xolder
-  call g:Xsetlist([], 'f')
-  call assert_equal(0, len(g:Xgetlist()))
-
-  " After deleting the stack, adding a new list should create a stack with a
-  " single list.
-  Xexpr ['Xfile1:10:10:Line 10', 'Xfile1:15:15:Line 15']
-  call assert_equal(1, g:Xgetlist({'all':1}).nr)
-
-  " Deleting the stack from a quickfix window should update/clear the
-  " quickfix/location list window.
-  Xexpr ['Xfile1:10:10:Line 10', 'Xfile1:15:15:Line 15']
-  Xexpr ['Xfile2:20:20:Line 20', 'Xfile2:25:25:Line 25']
-  Xexpr ['Xfile3:30:30:Line 30', 'Xfile3:35:35:Line 35']
-  Xolder
-  Xwindow
-  call g:Xsetlist([], 'f')
-  call assert_equal(2, winnr('$'))
-  call assert_equal(1, line('$'))
-  Xclose
-
-  " Deleting the stack from a non-quickfix window should update/clear the
-  " quickfix/location list window.
-  Xexpr ['Xfile1:10:10:Line 10', 'Xfile1:15:15:Line 15']
-  Xexpr ['Xfile2:20:20:Line 20', 'Xfile2:25:25:Line 25']
-  Xexpr ['Xfile3:30:30:Line 30', 'Xfile3:35:35:Line 35']
-  Xolder
-  Xwindow
-  wincmd p
-  call g:Xsetlist([], 'f')
-  call assert_equal(0, len(g:Xgetlist()))
-  wincmd p
-  call assert_equal(2, winnr('$'))
-  call assert_equal(1, line('$'))
-
-  " After deleting the location list stack, if the location list window is
-  " opened, then a new location list should be created. So opening the
-  " location list window again should not create a new window.
-  if a:cchar == 'l'
-      lexpr ['Xfile1:10:10:Line 10', 'Xfile1:15:15:Line 15']
-      wincmd p
-      lopen
-      call assert_equal(2, winnr('$'))
-  endif
-  Xclose
-endfunc
-
-" Tests for the quickfix free functionality
-func Test_qf_free()
-  call XfreeTests('c')
-  call XfreeTests('l')
-endfunc
-
-" Test for buffer overflow when parsing lines and adding new entries to
-" the quickfix list.
-func Test_bufoverflow()
-  set efm=%f:%l:%m
-  cgetexpr ['File1:100:' . repeat('x', 1025)]
-
-  set efm=%+GCompiler:\ %.%#,%f:%l:%m
-  cgetexpr ['Compiler: ' . repeat('a', 1015), 'File1:10:Hello World']
-
-  set efm=%DEntering\ directory\ %f,%f:%l:%m
-  cgetexpr ['Entering directory ' . repeat('a', 1006),
-	      \ 'File1:10:Hello World']
-  set efm&vim
-endfunc
-
-" Tests for getting the quickfix stack size
-func XsizeTests(cchar)
-  call s:setup_commands(a:cchar)
-
-  call g:Xsetlist([], 'f')
-  call assert_equal(0, g:Xgetlist({'nr':'$'}).nr)
-  call assert_equal('', g:Xgetlist({'nr':'$', 'all':1}).title)
-  call assert_equal(0, g:Xgetlist({'nr':0}).nr)
-
-  Xexpr "File1:10:Line1"
-  Xexpr "File2:20:Line2"
-  Xexpr "File3:30:Line3"
-  Xolder | Xolder
-  call assert_equal(3, g:Xgetlist({'nr':'$'}).nr)
-  call g:Xsetlist([], 'f')
-
-  Xexpr "File1:10:Line1"
-  Xexpr "File2:20:Line2"
-  Xexpr "File3:30:Line3"
-  Xolder | Xolder
-  call g:Xsetlist([], 'a', {'nr':'$', 'title':'Compiler'})
-  call assert_equal('Compiler', g:Xgetlist({'nr':3, 'all':1}).title)
-endfunc
-
-func Test_Qf_Size()
-  call XsizeTests('c')
-  call XsizeTests('l')
-endfunc
-
-func Test_cclose_from_copen()
-    augroup QF_Test
-	au!
-        au FileType qf :call assert_fails(':cclose', 'E788')
-    augroup END
-    copen
-    augroup QF_Test
-	au!
-    augroup END
-    augroup! QF_Test
-endfunc
-
-func Test_cclose_in_autocmd()
-  " Problem is only triggered if "starting" is zero, so that the OptionSet
-  " event will be triggered.
-  " call test_override('starting', 1)
-  augroup QF_Test
-    au!
-    au FileType qf :call assert_fails(':cclose', 'E788')
-  augroup END
-  copen
-  augroup QF_Test
-    au!
-  augroup END
-  augroup! QF_Test
-  " call test_override('starting', 0)
-endfunc
-
-" Check that ":file" without an argument is possible even when "curbuf->b_ro_locked"
-" is set.
-func Test_file_from_copen()
-  " Works without argument.
-  augroup QF_Test
-    au!
-    au FileType qf file
-  augroup END
-  copen
-
-  augroup QF_Test
-    au!
-  augroup END
-  cclose
-
-  " Fails with argument.
-  augroup QF_Test
-    au!
-    au FileType qf call assert_fails(':file foo', 'E788')
-  augroup END
-  copen
-  augroup QF_Test
-    au!
-  augroup END
-  cclose
-
-  augroup! QF_Test
-endfunc
-
-func Test_resize_from_copen()
-  augroup QF_Test
-    au!
-    au FileType qf resize 5
-  augroup END
-  try
-    " This should succeed without any exception.  No other buffers are
-    " involved in the autocmd.
-    copen
-  finally
-    augroup QF_Test
-      au!
-    augroup END
-    augroup! QF_Test
-  endtry
-endfunc
-
-func Test_filetype_autocmd()
-  " this changes the location list while it is in use to fill a buffer
-  lexpr ''
-  lopen
-  augroup FT_loclist
-    au FileType * call setloclist(0, [], 'f')
-  augroup END
-  silent! lolder
-  lexpr ''
-
-  augroup FT_loclist
-    au! FileType
-  augroup END
-endfunc
-
-func Test_vimgrep_with_textlock()
-  new
-
-  " Simple way to execute something with "textlock" set.
-  " Check that vimgrep without jumping can be executed.
-  au InsertCharPre * vimgrep /RunTheTest/j runtest.vim
-  normal ax
-  let qflist = getqflist()
-  call assert_true(len(qflist) > 0)
-  call assert_match('RunTheTest', qflist[0].text)
-  call setqflist([], 'r')
-  au! InsertCharPre
-
-  " Check that vimgrepadd without jumping can be executed.
-  au InsertCharPre * vimgrepadd /RunTheTest/j runtest.vim
-  normal ax
-  let qflist = getqflist()
-  call assert_true(len(qflist) > 0)
-  call assert_match('RunTheTest', qflist[0].text)
-  call setqflist([], 'r')
-  au! InsertCharPre
-
-  " Check that lvimgrep without jumping can be executed.
-  au InsertCharPre * lvimgrep /RunTheTest/j runtest.vim
-  normal ax
-  let qflist = getloclist(0)
-  call assert_true(len(qflist) > 0)
-  call assert_match('RunTheTest', qflist[0].text)
-  call setloclist(0, [], 'r')
-  au! InsertCharPre
-
-  " Check that lvimgrepadd without jumping can be executed.
-  au InsertCharPre * lvimgrepadd /RunTheTest/j runtest.vim
-  normal ax
-  let qflist = getloclist(0)
-  call assert_true(len(qflist) > 0)
-  call assert_match('RunTheTest', qflist[0].text)
-  call setloclist(0, [], 'r')
-  au! InsertCharPre
-
-  " trying to jump will give an error
-  au InsertCharPre * vimgrep /RunTheTest/ runtest.vim
-  call assert_fails('normal ax', 'E565:')
-  au! InsertCharPre
-
-  au InsertCharPre * vimgrepadd /RunTheTest/ runtest.vim
-  call assert_fails('normal ax', 'E565:')
-  au! InsertCharPre
-
-  au InsertCharPre * lvimgrep /RunTheTest/ runtest.vim
-  call assert_fails('normal ax', 'E565:')
-  au! InsertCharPre
-
-  au InsertCharPre * lvimgrepadd /RunTheTest/ runtest.vim
-  call assert_fails('normal ax', 'E565:')
-  au! InsertCharPre
-
-  bwipe!
-endfunc
-
-" Tests for the quickfix buffer b:changedtick variable
-func Xchangedtick_tests(cchar)
-  call s:setup_commands(a:cchar)
-
-  new | only
-
-  Xexpr "" | Xexpr "" | Xexpr ""
-
-  Xopen
-  Xolder
-  Xolder
-  Xaddexpr "F1:10:Line10"
-  Xaddexpr "F2:20:Line20"
-  call g:Xsetlist([{"filename":"F3", "lnum":30, "text":"Line30"}], 'a')
-  call g:Xsetlist([], 'f')
-  call assert_equal(8, getbufvar('%', 'changedtick'))
-  Xclose
-endfunc
-
-func Test_changedtick()
-  call Xchangedtick_tests('c')
-  call Xchangedtick_tests('l')
-endfunc
-
-" Tests for parsing an expression using setqflist()
-func Xsetexpr_tests(cchar)
-  call s:setup_commands(a:cchar)
-
-  let t = ["File1:10:Line10", "File1:20:Line20"]
-  call g:Xsetlist([], ' ', {'lines' : t})
-  call g:Xsetlist([], 'a', {'lines' : ["File1:30:Line30"]})
-
-  let l = g:Xgetlist()
-  call assert_equal(3, len(l))
-  call assert_equal(20, l[1].lnum)
-  call assert_equal('Line30', l[2].text)
-  call g:Xsetlist([], 'r', {'lines' : ["File2:5:Line5"]})
-  let l = g:Xgetlist()
-  call assert_equal(1, len(l))
-  call assert_equal('Line5', l[0].text)
-  call assert_equal(-1, g:Xsetlist([], 'a', {'lines' : 10}))
-  call assert_equal(-1, g:Xsetlist([], 'a', {'lines' : "F1:10:L10"}))
-
-  call g:Xsetlist([], 'f')
-  " Add entries to multiple lists
-  call g:Xsetlist([], 'a', {'nr' : 1, 'lines' : ["File1:10:Line10"]})
-  call g:Xsetlist([], 'a', {'nr' : 2, 'lines' : ["File2:20:Line20"]})
-  call g:Xsetlist([], 'a', {'nr' : 1, 'lines' : ["File1:15:Line15"]})
-  call g:Xsetlist([], 'a', {'nr' : 2, 'lines' : ["File2:25:Line25"]})
-  call assert_equal('Line15', g:Xgetlist({'nr':1, 'items':1}).items[1].text)
-  call assert_equal('Line25', g:Xgetlist({'nr':2, 'items':1}).items[1].text)
-
-  " Adding entries using a custom efm
-  set efm&
-  call g:Xsetlist([], ' ', {'efm' : '%f#%l#%m',
-				\ 'lines' : ["F1#10#L10", "F2#20#L20"]})
-  call assert_equal(20, g:Xgetlist({'items':1}).items[1].lnum)
-  call g:Xsetlist([], 'a', {'efm' : '%f#%l#%m', 'lines' : ["F3:30:L30"]})
-  call assert_equal('F3:30:L30', g:Xgetlist({'items':1}).items[2].text)
-  call assert_equal(20, g:Xgetlist({'items':1}).items[1].lnum)
-  call assert_equal(-1, g:Xsetlist([], 'a', {'efm' : [],
-				\ 'lines' : ['F1:10:L10']}))
-endfunc
-
-func Test_setexpr()
-  call Xsetexpr_tests('c')
-  call Xsetexpr_tests('l')
-endfunc
-
-" Tests for per quickfix/location list directory stack
-func Xmultidirstack_tests(cchar)
-  call s:setup_commands(a:cchar)
-
-  call g:Xsetlist([], 'f')
-  Xexpr "" | Xexpr ""
-
-  call g:Xsetlist([], 'a', {'nr' : 1, 'lines' : ["Entering dir 'Xone/a'"]})
-  call g:Xsetlist([], 'a', {'nr' : 2, 'lines' : ["Entering dir 'Xtwo/a'"]})
-  call g:Xsetlist([], 'a', {'nr' : 1, 'lines' : ["one.txt:3:one one one"]})
-  call g:Xsetlist([], 'a', {'nr' : 2, 'lines' : ["two.txt:5:two two two"]})
-
-  let l1 = g:Xgetlist({'nr':1, 'items':1})
-  let l2 = g:Xgetlist({'nr':2, 'items':1})
-  call assert_equal('Xone/a/one.txt', bufname(l1.items[1].bufnr))
-  call assert_equal(3, l1.items[1].lnum)
-  call assert_equal('Xtwo/a/two.txt', bufname(l2.items[1].bufnr))
-  call assert_equal(5, l2.items[1].lnum)
-endfunc
-
-func Test_multidirstack()
-  call mkdir('Xone/a', 'p')
-  call mkdir('Xtwo/a', 'p')
-  let lines = ['1', '2', 'one one one', '4', 'two two two', '6', '7']
-  call writefile(lines, 'Xone/a/one.txt')
-  call writefile(lines, 'Xtwo/a/two.txt')
-  let save_efm = &efm
-  set efm=%DEntering\ dir\ '%f',%f:%l:%m,%XLeaving\ dir\ '%f'
-
-  call Xmultidirstack_tests('c')
-  call Xmultidirstack_tests('l')
-
-  let &efm = save_efm
-  call delete('Xone', 'rf')
-  call delete('Xtwo', 'rf')
-endfunc
-
-" Tests for per quickfix/location list file stack
-func Xmultifilestack_tests(cchar)
-  call s:setup_commands(a:cchar)
-
-  call g:Xsetlist([], 'f')
-  Xexpr "" | Xexpr ""
-
-  call g:Xsetlist([], 'a', {'nr' : 1, 'lines' : ["[one.txt]"]})
-  call g:Xsetlist([], 'a', {'nr' : 2, 'lines' : ["[two.txt]"]})
-  call g:Xsetlist([], 'a', {'nr' : 1, 'lines' : ["(3,5) one one one"]})
-  call g:Xsetlist([], 'a', {'nr' : 2, 'lines' : ["(5,9) two two two"]})
-
-  let l1 = g:Xgetlist({'nr':1, 'items':1})
-  let l2 = g:Xgetlist({'nr':2, 'items':1})
-  call assert_equal('one.txt', bufname(l1.items[1].bufnr))
-  call assert_equal(3, l1.items[1].lnum)
-  call assert_equal('two.txt', bufname(l2.items[1].bufnr))
-  call assert_equal(5, l2.items[1].lnum)
-
-  " Test for start of a new error line in the same line where a previous
-  " error line ends with a file stack.
-  let efm_val = 'Error\ l%l\ in\ %f,'
-  let efm_val .= '%-P%>(%f%r,Error\ l%l\ in\ %m,%-Q)%r'
-  let lines =<< trim END
-    (one.txt
-    Error l4 in one.txt
-    ) (two.txt
-    Error l6 in two.txt
-    )
-    Error l8 in one.txt
-  END
-  let l = g:Xgetlist({'lines': lines, 'efm' : efm_val})
-  call assert_equal(3, len(l.items))
-  call assert_equal('one.txt', bufname(l.items[0].bufnr))
-  call assert_equal(4, l.items[0].lnum)
-  call assert_equal('one.txt', l.items[0].text)
-  call assert_equal('two.txt', bufname(l.items[1].bufnr))
-  call assert_equal(6, l.items[1].lnum)
-  call assert_equal('two.txt', l.items[1].text)
-  call assert_equal('one.txt', bufname(l.items[2].bufnr))
-  call assert_equal(8, l.items[2].lnum)
-  call assert_equal('', l.items[2].text)
-endfunc
-
-func Test_multifilestack()
-  let lines = ['1', '2', 'one one one', '4', 'two two two', '6', '7']
-  call writefile(lines, 'one.txt')
-  call writefile(lines, 'two.txt')
-  let save_efm = &efm
-  set efm=%+P[%f],(%l\\,%c)\ %m,%-Q
-
-  call Xmultifilestack_tests('c')
-  call Xmultifilestack_tests('l')
-
-  let &efm = save_efm
-  call delete('one.txt')
-  call delete('two.txt')
-endfunc
-
-" Tests for per buffer 'efm' setting
-func Test_perbuf_efm()
-  call writefile(["File1-10-Line10"], 'one.txt')
-  call writefile(["File2#20#Line20"], 'two.txt')
-  set efm=%f#%l#%m
-  new | only
-  new
-  setlocal efm=%f-%l-%m
-  cfile one.txt
-  wincmd w
-  caddfile two.txt
-
-  let l = getqflist()
-  call assert_equal(10, l[0].lnum)
-  call assert_equal('Line20', l[1].text)
-
-  set efm&
-  new | only
-  call delete('one.txt')
-  call delete('two.txt')
-endfunc
-
-" Open multiple help windows using ":lhelpgrep
-" This test used to crash Vim
-func Test_Multi_LL_Help()
-    new | only
-    lhelpgrep window
-    lopen
-    e#
-    lhelpgrep buffer
-    call assert_equal(3, winnr('$'))
-    call assert_true(len(getloclist(1)) != 0)
-    call assert_true(len(getloclist(2)) != 0)
-    new | only
-endfunc
-
-" Tests for adding new quickfix lists using setqflist()
-func XaddQf_tests(cchar)
-  call s:setup_commands(a:cchar)
-
-  " Create a new list using ' ' for action
-  call g:Xsetlist([], 'f')
-  call g:Xsetlist([], ' ', {'title' : 'Test1'})
-  let l = g:Xgetlist({'nr' : '$', 'all' : 1})
-  call assert_equal(1, l.nr)
-  call assert_equal('Test1', l.title)
-
-  " Create a new list using ' ' for action and '$' for 'nr'
-  call g:Xsetlist([], 'f')
-  call g:Xsetlist([], ' ', {'title' : 'Test2', 'nr' : '$'})
-  let l = g:Xgetlist({'nr' : '$', 'all' : 1})
-  call assert_equal(1, l.nr)
-  call assert_equal('Test2', l.title)
-
-  " Create a new list using 'a' for action
-  call g:Xsetlist([], 'f')
-  call g:Xsetlist([], 'a', {'title' : 'Test3'})
-  let l = g:Xgetlist({'nr' : '$', 'all' : 1})
-  call assert_equal(1, l.nr)
-  call assert_equal('Test3', l.title)
-
-  " Create a new list using 'a' for action and '$' for 'nr'
-  call g:Xsetlist([], 'f')
-  call g:Xsetlist([], 'a', {'title' : 'Test3', 'nr' : '$'})
-  call g:Xsetlist([], 'a', {'title' : 'Test4'})
-  let l = g:Xgetlist({'nr' : '$', 'all' : 1})
-  call assert_equal(1, l.nr)
-  call assert_equal('Test4', l.title)
-
-  " Adding a quickfix list should remove all the lists following the current
-  " list.
-  Xexpr "" | Xexpr "" | Xexpr ""
-  silent! 10Xolder
-  call g:Xsetlist([], ' ', {'title' : 'Test5'})
-  let l = g:Xgetlist({'nr' : '$', 'all' : 1})
-  call assert_equal(2, l.nr)
-  call assert_equal('Test5', l.title)
-
-  " Add a quickfix list using '$' as the list number.
-  let lastqf = g:Xgetlist({'nr':'$'}).nr
-  silent! 99Xolder
-  call g:Xsetlist([], ' ', {'nr' : '$', 'title' : 'Test6'})
-  let l = g:Xgetlist({'nr' : '$', 'all' : 1})
-  call assert_equal(lastqf + 1, l.nr)
-  call assert_equal('Test6', l.title)
-
-  " Add a quickfix list using 'nr' set to one more than the quickfix
-  " list size.
-  let lastqf = g:Xgetlist({'nr':'$'}).nr
-  silent! 99Xolder
-  call g:Xsetlist([], ' ', {'nr' : lastqf + 1, 'title' : 'Test7'})
-  let l = g:Xgetlist({'nr' : '$', 'all' : 1})
-  call assert_equal(lastqf + 1, l.nr)
-  call assert_equal('Test7', l.title)
-
-  " Add a quickfix list to a stack with 10 lists using 'nr' set to '$'
-  exe repeat('Xexpr "" |', 9) . 'Xexpr ""'
-  silent! 99Xolder
-  call g:Xsetlist([], ' ', {'nr' : '$', 'title' : 'Test8'})
-  let l = g:Xgetlist({'nr' : '$', 'all' : 1})
-  call assert_equal(10, l.nr)
-  call assert_equal('Test8', l.title)
-
-  " Add a quickfix list using 'nr' set to a value greater than 10
-  call assert_equal(-1, g:Xsetlist([], ' ', {'nr' : 12, 'title' : 'Test9'}))
-
-  " Try adding a quickfix list with 'nr' set to a value greater than the
-  " quickfix list size but less than 10.
-  call g:Xsetlist([], 'f')
-  Xexpr "" | Xexpr "" | Xexpr ""
-  silent! 99Xolder
-  call assert_equal(-1, g:Xsetlist([], ' ', {'nr' : 8, 'title' : 'Test10'}))
-
-  " Add a quickfix list using 'nr' set to a some string or list
-  call assert_equal(-1, g:Xsetlist([], ' ', {'nr' : [1,2], 'title' : 'Test11'}))
-endfunc
-
-func Test_add_qf()
-  call XaddQf_tests('c')
-  call XaddQf_tests('l')
-endfunc
-
-" Test for getting the quickfix list items from some text without modifying
-" the quickfix stack
-func XgetListFromLines(cchar)
-  call s:setup_commands(a:cchar)
-  call g:Xsetlist([], 'f')
-
-  let l = g:Xgetlist({'lines' : ["File2:20:Line20", "File2:30:Line30"]}).items
-  call assert_equal(2, len(l))
-  call assert_equal(30, l[1].lnum)
-
-  call assert_equal({}, g:Xgetlist({'lines' : 10}))
-  call assert_equal({}, g:Xgetlist({'lines' : 'File1:10:Line10'}))
-  call assert_equal([], g:Xgetlist({'lines' : []}).items)
-  call assert_equal([], g:Xgetlist({'lines' : [10, 20]}).items)
-
-  " Parse text using a custom efm
-  set efm&
-  let l = g:Xgetlist({'lines':['File3#30#Line30'], 'efm' : '%f#%l#%m'}).items
-  call assert_equal('Line30', l[0].text)
-  let l = g:Xgetlist({'lines':['File3:30:Line30'], 'efm' : '%f-%l-%m'}).items
-  call assert_equal('File3:30:Line30', l[0].text)
-  let l = g:Xgetlist({'lines':['File3:30:Line30'], 'efm' : [1,2]})
-  call assert_equal({}, l)
-  call assert_fails("call g:Xgetlist({'lines':['abc'], 'efm':'%2'})", 'E376:')
-  call assert_fails("call g:Xgetlist({'lines':['abc'], 'efm':''})", 'E378:')
-
-  " Make sure that the quickfix stack is not modified
-  call assert_equal(0, g:Xgetlist({'nr' : '$'}).nr)
-endfunc
-
-func Test_get_list_from_lines()
-  call XgetListFromLines('c')
-  call XgetListFromLines('l')
-endfunc
-
-" Tests for the quickfix list id
-func Xqfid_tests(cchar)
-  call s:setup_commands(a:cchar)
-
-  call g:Xsetlist([], 'f')
-  call assert_equal(0, g:Xgetlist({'id':0}).id)
-  Xexpr ''
-  let start_id = g:Xgetlist({'id' : 0}).id
-  Xexpr '' | Xexpr ''
-  Xolder
-  call assert_equal(start_id, g:Xgetlist({'id':0, 'nr':1}).id)
-  call assert_equal(start_id + 1, g:Xgetlist({'id':0, 'nr':0}).id)
-  call assert_equal(start_id + 2, g:Xgetlist({'id':0, 'nr':'$'}).id)
-  call assert_equal(0, g:Xgetlist({'id':0, 'nr':99}).id)
-  call assert_equal(2, g:Xgetlist({'id':start_id + 1, 'nr':0}).nr)
-  call assert_equal(0, g:Xgetlist({'id':99, 'nr':0}).id)
-  call assert_equal(0, g:Xgetlist({'id':"abc", 'nr':0}).id)
-
-  call g:Xsetlist([], 'a', {'id':start_id, 'context':[1,2]})
-  call assert_equal([1,2], g:Xgetlist({'nr':1, 'context':1}).context)
-  call g:Xsetlist([], 'a', {'id':start_id+1, 'lines':['F1:10:L10']})
-  call assert_equal('L10', g:Xgetlist({'nr':2, 'items':1}).items[0].text)
-  call assert_equal(-1, g:Xsetlist([], 'a', {'id':999, 'title':'Vim'}))
-  call assert_equal(-1, g:Xsetlist([], 'a', {'id':'abc', 'title':'Vim'}))
-
-  let qfid = g:Xgetlist({'id':0, 'nr':0})
-  call g:Xsetlist([], 'f')
-  call assert_equal(0, g:Xgetlist({'id':qfid, 'nr':0}).id)
-endfunc
-
-func Test_qf_id()
-  call Xqfid_tests('c')
-  call Xqfid_tests('l')
-endfunc
-
-func Xqfjump_tests(cchar)
-  call s:setup_commands(a:cchar)
-
-  call writefile(["Line1\tFoo", "Line2"], 'F1')
-  call writefile(["Line1\tBar", "Line2"], 'F2')
-  call writefile(["Line1\tBaz", "Line2"], 'F3')
-
-  call g:Xsetlist([], 'f')
-
-  " Tests for
-  "   Jumping to a line using a pattern
-  "   Jumping to a column greater than the last column in a line
-  "   Jumping to a line greater than the last line in the file
-  let l = []
-  for i in range(1, 7)
-    call add(l, {})
-  endfor
-  let l[0].filename='F1'
-  let l[0].pattern='Line1'
-  let l[1].filename='F2'
-  let l[1].pattern='Line1'
-  let l[2].filename='F3'
-  let l[2].pattern='Line1'
-  let l[3].filename='F3'
-  let l[3].lnum=1
-  let l[3].col=9
-  let l[3].vcol=1
-  let l[4].filename='F3'
-  let l[4].lnum=99
-  let l[5].filename='F3'
-  let l[5].lnum=1
-  let l[5].col=99
-  let l[5].vcol=1
-  let l[6].filename='F3'
-  let l[6].pattern='abcxyz'
-
-  call g:Xsetlist([], ' ', {'items' : l})
-  Xopen | only
-  2Xnext
-  call assert_equal(3, g:Xgetlist({'idx' : 0}).idx)
-  call assert_equal('F3', @%)
-  Xnext
-  call assert_equal(7, col('.'))
-  Xnext
-  call assert_equal(2, line('.'))
-  Xnext
-  call assert_equal(9, col('.'))
-  2
-  Xnext
-  call assert_equal(2, line('.'))
-
-  if a:cchar == 'l'
-    " When jumping to a location list entry in the location list window and
-    " no usable windows are available, then a new window should be opened.
-    enew! | new | only
-    call g:Xsetlist([], 'f')
-    setlocal buftype=nofile
-    new
-    let lines =<< trim END
-      F1:1:1:Line1
-      F1:2:2:Line2
-      F2:1:1:Line1
-      F2:2:2:Line2
-      F3:1:1:Line1
-      F3:2:2:Line2
-    END
-    call g:Xsetlist([], ' ', {'lines': lines})
-    Xopen
-    let winid = win_getid()
-    wincmd p
-    close
-    call win_gotoid(winid)
-    Xnext
-    call assert_equal(3, winnr('$'))
-    call assert_equal(1, winnr())
-    call assert_equal(2, line('.'))
-
-    " When jumping to an entry in the location list window and the window
-    " associated with the location list is not present and a window containing
-    " the file is already present, then that window should be used.
-    close
-    belowright new
-    call g:Xsetlist([], 'f')
-    edit F3
-    call win_gotoid(winid)
-    Xlast
-    call assert_equal(3, winnr())
-    call assert_equal(6, g:Xgetlist({'size' : 1}).size)
-    call assert_equal(winid, g:Xgetlist({'winid' : 1}).winid)
-  endif
-
-  " Cleanup
-  enew!
-  new | only
-
-  call delete('F1')
-  call delete('F2')
-  call delete('F3')
-endfunc
-
-func Test_qfjump()
-  call Xqfjump_tests('c')
-  call Xqfjump_tests('l')
-endfunc
-
-" Tests for the getqflist() and getloclist() functions when the list is not
-" present or is empty
-func Xgetlist_empty_tests(cchar)
-  call s:setup_commands(a:cchar)
-
-  " Empty quickfix stack
-  call g:Xsetlist([], 'f')
-  call assert_equal('', g:Xgetlist({'context' : 0}).context)
-  call assert_equal(0, g:Xgetlist({'id' : 0}).id)
-  call assert_equal(0, g:Xgetlist({'idx' : 0}).idx)
-  call assert_equal([], g:Xgetlist({'items' : 0}).items)
-  call assert_equal(0, g:Xgetlist({'nr' : 0}).nr)
-  call assert_equal(0, g:Xgetlist({'size' : 0}).size)
-  call assert_equal('', g:Xgetlist({'title' : 0}).title)
-  call assert_equal(0, g:Xgetlist({'winid' : 0}).winid)
-  call assert_equal(0, g:Xgetlist({'changedtick' : 0}).changedtick)
-  if a:cchar == 'c'
-    call assert_equal({'context' : '', 'id' : 0, 'idx' : 0,
-		  \ 'items' : [], 'nr' : 0, 'size' : 0, 'qfbufnr' : 0,
-		  \ 'title' : '', 'winid' : 0, 'changedtick': 0,
-                  \ 'quickfixtextfunc' : ''}, g:Xgetlist({'all' : 0}))
-  else
-    call assert_equal({'context' : '', 'id' : 0, 'idx' : 0,
-		\ 'items' : [], 'nr' : 0, 'size' : 0, 'title' : '',
-		\ 'winid' : 0, 'changedtick': 0, 'filewinid' : 0,
-		\ 'qfbufnr' : 0, 'quickfixtextfunc' : ''},
-		\ g:Xgetlist({'all' : 0}))
-  endif
-
-  " Quickfix window with empty stack
-  silent! Xopen
-  let qfwinid = (a:cchar == 'c') ? win_getid() : 0
-  let qfbufnr = (a:cchar == 'c') ? bufnr('') : 0
-  call assert_equal(qfwinid, g:Xgetlist({'winid' : 0}).winid)
-  Xclose
-
-  " Empty quickfix list
-  Xexpr ""
-  call assert_equal('', g:Xgetlist({'context' : 0}).context)
-  call assert_notequal(0, g:Xgetlist({'id' : 0}).id)
-  call assert_equal(0, g:Xgetlist({'idx' : 0}).idx)
-  call assert_equal([], g:Xgetlist({'items' : 0}).items)
-  call assert_notequal(0, g:Xgetlist({'nr' : 0}).nr)
-  call assert_equal(0, g:Xgetlist({'size' : 0}).size)
-  call assert_notequal('', g:Xgetlist({'title' : 0}).title)
-  call assert_equal(0, g:Xgetlist({'winid' : 0}).winid)
-  call assert_equal(1, g:Xgetlist({'changedtick' : 0}).changedtick)
-
-  let qfid = g:Xgetlist({'id' : 0}).id
-  call g:Xsetlist([], 'f')
-
-  " Non-existing quickfix identifier
-  call assert_equal('', g:Xgetlist({'id' : qfid, 'context' : 0}).context)
-  call assert_equal(0, g:Xgetlist({'id' : qfid}).id)
-  call assert_equal(0, g:Xgetlist({'id' : qfid, 'idx' : 0}).idx)
-  call assert_equal([], g:Xgetlist({'id' : qfid, 'items' : 0}).items)
-  call assert_equal(0, g:Xgetlist({'id' : qfid, 'nr' : 0}).nr)
-  call assert_equal(0, g:Xgetlist({'id' : qfid, 'size' : 0}).size)
-  call assert_equal('', g:Xgetlist({'id' : qfid, 'title' : 0}).title)
-  call assert_equal(0, g:Xgetlist({'id' : qfid, 'winid' : 0}).winid)
-  call assert_equal(0, g:Xgetlist({'id' : qfid, 'changedtick' : 0}).changedtick)
-  if a:cchar == 'c'
-    call assert_equal({'context' : '', 'id' : 0, 'idx' : 0, 'items' : [],
-		\ 'nr' : 0, 'size' : 0, 'title' : '', 'winid' : 0,
-		\ 'qfbufnr' : qfbufnr, 'quickfixtextfunc' : '',
-		\ 'changedtick' : 0}, g:Xgetlist({'id' : qfid, 'all' : 0}))
-  else
-    call assert_equal({'context' : '', 'id' : 0, 'idx' : 0, 'items' : [],
-		\ 'nr' : 0, 'size' : 0, 'title' : '', 'winid' : 0,
-		\ 'changedtick' : 0, 'filewinid' : 0, 'qfbufnr' : 0,
-                \ 'quickfixtextfunc' : ''},
-		\ g:Xgetlist({'id' : qfid, 'all' : 0}))
-  endif
-
-  " Non-existing quickfix list number
-  call assert_equal('', g:Xgetlist({'nr' : 5, 'context' : 0}).context)
-  call assert_equal(0, g:Xgetlist({'nr' : 5}).nr)
-  call assert_equal(0, g:Xgetlist({'nr' : 5, 'idx' : 0}).idx)
-  call assert_equal([], g:Xgetlist({'nr' : 5, 'items' : 0}).items)
-  call assert_equal(0, g:Xgetlist({'nr' : 5, 'id' : 0}).id)
-  call assert_equal(0, g:Xgetlist({'nr' : 5, 'size' : 0}).size)
-  call assert_equal('', g:Xgetlist({'nr' : 5, 'title' : 0}).title)
-  call assert_equal(0, g:Xgetlist({'nr' : 5, 'winid' : 0}).winid)
-  call assert_equal(0, g:Xgetlist({'nr' : 5, 'changedtick' : 0}).changedtick)
-  if a:cchar == 'c'
-    call assert_equal({'context' : '', 'id' : 0, 'idx' : 0, 'items' : [],
-		\ 'nr' : 0, 'size' : 0, 'title' : '', 'winid' : 0,
-		\ 'changedtick' : 0, 'qfbufnr' : qfbufnr,
-                \ 'quickfixtextfunc' : ''}, g:Xgetlist({'nr' : 5, 'all' : 0}))
-  else
-    call assert_equal({'context' : '', 'id' : 0, 'idx' : 0, 'items' : [],
-		\ 'nr' : 0, 'size' : 0, 'title' : '', 'winid' : 0,
-		\ 'changedtick' : 0, 'filewinid' : 0, 'qfbufnr' : 0,
-                \ 'quickfixtextfunc' : ''}, g:Xgetlist({'nr' : 5, 'all' : 0}))
-  endif
-endfunc
-
-func Test_empty_list_quickfixtextfunc()
-  " This was crashing.  Can only reproduce by running it in a separate Vim
-  " instance.
-  let lines =<< trim END
-      func s:Func(o)
-              cgetexpr '0'
-      endfunc
-      cope
-      let &quickfixtextfunc = 's:Func'
-      cgetfile [ex
-  END
-  call writefile(lines, 'Xquickfixtextfunc')
-  call RunVim([], [], '-e -s -S Xquickfixtextfunc -c qa')
-  call delete('Xquickfixtextfunc')
-endfunc
-
-func Test_getqflist()
-  call Xgetlist_empty_tests('c')
-  call Xgetlist_empty_tests('l')
-endfunc
-
-
-func Test_getqflist_invalid_nr()
-  " The following commands used to crash Vim
-  cexpr ""
-  call getqflist({'nr' : $XXX_DOES_NOT_EXIST_XXX})
-
-  " Cleanup
-  call setqflist([], 'r')
-endfunc
-
-" Tests for the quickfix/location list changedtick
-func Xqftick_tests(cchar)
-  call s:setup_commands(a:cchar)
-
-  call g:Xsetlist([], 'f')
-
-  Xexpr "F1:10:Line10"
-  let qfid = g:Xgetlist({'id' : 0}).id
-  call assert_equal(1, g:Xgetlist({'changedtick' : 0}).changedtick)
-  Xaddexpr "F2:20:Line20\nF2:21:Line21"
-  call assert_equal(2, g:Xgetlist({'changedtick' : 0}).changedtick)
-  call g:Xsetlist([], 'a', {'lines' : ["F3:30:Line30", "F3:31:Line31"]})
-  call assert_equal(3, g:Xgetlist({'changedtick' : 0}).changedtick)
-  call g:Xsetlist([], 'r', {'lines' : ["F4:40:Line40"]})
-  call assert_equal(4, g:Xgetlist({'changedtick' : 0}).changedtick)
-  call g:Xsetlist([], 'a', {'title' : 'New Title'})
-  call assert_equal(5, g:Xgetlist({'changedtick' : 0}).changedtick)
-
-  enew!
-  call append(0, ["F5:50:L50", "F6:60:L60"])
-  Xaddbuffer
-  call assert_equal(6, g:Xgetlist({'changedtick' : 0}).changedtick)
-  enew!
-
-  call g:Xsetlist([], 'a', {'context' : {'bus' : 'pci'}})
-  call assert_equal(7, g:Xgetlist({'changedtick' : 0}).changedtick)
-  call g:Xsetlist([{'filename' : 'F7', 'lnum' : 10, 'text' : 'L7'},
-	      \ {'filename' : 'F7', 'lnum' : 11, 'text' : 'L11'}], 'a')
-  call assert_equal(8, g:Xgetlist({'changedtick' : 0}).changedtick)
-  call g:Xsetlist([{'filename' : 'F7', 'lnum' : 10, 'text' : 'L7'},
-	      \ {'filename' : 'F7', 'lnum' : 11, 'text' : 'L11'}], ' ')
-  call assert_equal(1, g:Xgetlist({'changedtick' : 0}).changedtick)
-  call g:Xsetlist([{'filename' : 'F7', 'lnum' : 10, 'text' : 'L7'},
-	      \ {'filename' : 'F7', 'lnum' : 11, 'text' : 'L11'}], 'r')
-  call assert_equal(2, g:Xgetlist({'changedtick' : 0}).changedtick)
-
-  if isdirectory("Xone")
-    call delete("Xone", 'rf')
-  endif
-  call writefile(["F8:80:L80", "F8:81:L81"], "Xone")
-  Xfile Xone
-  call assert_equal(1, g:Xgetlist({'changedtick' : 0}).changedtick)
-  Xaddfile Xone
-  call assert_equal(2, g:Xgetlist({'changedtick' : 0}).changedtick)
-
-  " Test case for updating a non-current quickfix list
-  call g:Xsetlist([], 'f')
-  Xexpr "F1:1:L1"
-  Xexpr "F2:2:L2"
-  call g:Xsetlist([], 'a', {'nr' : 1, "lines" : ["F10:10:L10"]})
-  call assert_equal(1, g:Xgetlist({'changedtick' : 0}).changedtick)
-  call assert_equal(2, g:Xgetlist({'nr' : 1, 'changedtick' : 0}).changedtick)
-
-  call delete("Xone")
-endfunc
-
-func Test_qf_tick()
-  call Xqftick_tests('c')
-  call Xqftick_tests('l')
-endfunc
-
-" Test helpgrep with lang specifier
-func Xtest_helpgrep_with_lang_specifier(cchar)
-  call s:setup_commands(a:cchar)
-  Xhelpgrep Vim@en
-  call assert_equal('help', &filetype)
-  call assert_notequal(0, g:Xgetlist({'nr' : '$'}).nr)
-  new | only
-endfunc
-
-func Test_helpgrep_with_lang_specifier()
-  call Xtest_helpgrep_with_lang_specifier('c')
-  call Xtest_helpgrep_with_lang_specifier('l')
-endfunc
-
-" The following test used to crash Vim.
-" Open the location list window and close the regular window associated with
-" the location list. When the garbage collection runs now, it incorrectly
-" marks the location list context as not in use and frees the context.
-func Test_ll_window_ctx()
-  call setloclist(0, [], 'f')
-  call setloclist(0, [], 'a', {'context' : []})
-  lopen | only
-  call test_garbagecollect_now()
-  echo getloclist(0, {'context' : 1}).context
-  enew | only
-endfunc
-
-" The following test used to crash vim
-func Test_lfile_crash()
-  sp Xtest
-  au QuickFixCmdPre * bw
-  call assert_fails('lfile', 'E40')
-  au! QuickFixCmdPre
-endfunc
-
-" The following test used to crash vim
-func Test_lbuffer_crash()
-  sv Xtest
-  augroup QF_Test
-    au!
-    au QuickFixCmdPre,QuickFixCmdPost,BufEnter,BufLeave * bw
-  augroup END
-  lbuffer
-  augroup QF_Test
-    au!
-  augroup END
-endfunc
-
-" The following test used to crash vim
-func Test_lexpr_crash()
-  augroup QF_Test
-    au!
-    au QuickFixCmdPre,QuickFixCmdPost,BufEnter,BufLeave * call setloclist(0, [], 'f')
-  augroup END
-  lexpr ""
-  augroup QF_Test
-    au!
-  augroup END
-
-  enew | only
-  augroup QF_Test
-    au!
-    au BufNew * call setloclist(0, [], 'f')
-  augroup END
-  lexpr 'x:1:x'
-  augroup QF_Test
-    au!
-  augroup END
-
-  enew | only
-  lexpr ''
-  lopen
-  augroup QF_Test
-    au!
-    au FileType * call setloclist(0, [], 'f')
-  augroup END
-  lexpr ''
-  augroup QF_Test
-    au!
-  augroup END
-endfunc
-
-" The following test used to crash Vim
-func Test_lvimgrep_crash()
-  sv Xtest
-  augroup QF_Test
-    au!
-    au QuickFixCmdPre,QuickFixCmdPost,BufEnter,BufLeave * call setloclist(0, [], 'f')
-  augroup END
-  lvimgrep quickfix test_quickfix.vim
-  augroup QF_Test
-    au!
-  augroup END
-
-  new | only
-  augroup QF_Test
-    au!
-    au BufEnter * call setloclist(0, [], 'r')
-  augroup END
-  call assert_fails('lvimgrep Test_lvimgrep_crash *', 'E926:')
-  augroup QF_Test
-    au!
-  augroup END
-
-  enew | only
-endfunc
-
-func Test_lvimgrep_crash2()
-  au BufNewFile x sfind
-  call assert_fails('lvimgrep x x', 'E471:')
-  call assert_fails('lvimgrep x x x', 'E471:')
-
-  au! BufNewFile
-endfunc
-
-" Test for the position of the quickfix and location list window
-func Test_qfwin_pos()
-  " Open two windows
-  new | only
-  new
-  cexpr ['F1:10:L10']
-  copen
-  " Quickfix window should be the bottom most window
-  call assert_equal(3, winnr())
-  close
-  " Open at the very top
-  wincmd t
-  topleft copen
-  call assert_equal(1, winnr())
-  close
-  " open left of the current window
-  wincmd t
-  below new
-  leftabove copen
-  call assert_equal(2, winnr())
-  close
-  " open right of the current window
-  rightbelow copen
-  call assert_equal(3, winnr())
-  close
-endfunc
-
-" Tests for quickfix/location lists changed by autocommands when
-" :vimgrep/:lvimgrep commands are running.
-func Test_vimgrep_autocmd()
-  call setqflist([], 'f')
-  call writefile(['stars'], 'Xtest1.txt')
-  call writefile(['stars'], 'Xtest2.txt')
-
-  " Test 1:
-  " When searching for a pattern using :vimgrep, if the quickfix list is
-  " changed by an autocmd, the results should be added to the correct quickfix
-  " list.
-  autocmd BufRead Xtest2.txt cexpr '' | cexpr ''
-  silent vimgrep stars Xtest*.txt
-  call assert_equal(1, getqflist({'nr' : 0}).nr)
-  call assert_equal(3, getqflist({'nr' : '$'}).nr)
-  call assert_equal('Xtest2.txt', bufname(getqflist()[1].bufnr))
-  au! BufRead Xtest2.txt
-
-  " Test 2:
-  " When searching for a pattern using :vimgrep, if the quickfix list is
-  " freed, then a error should be given.
-  silent! %bwipe!
-  call setqflist([], 'f')
-  autocmd BufRead Xtest2.txt for i in range(10) | cexpr '' | endfor
-  call assert_fails('vimgrep stars Xtest*.txt', 'E925:')
-  au! BufRead Xtest2.txt
-
-  " Test 3:
-  " When searching for a pattern using :lvimgrep, if the location list is
-  " freed, then the command should error out.
-  silent! %bwipe!
-  let g:save_winid = win_getid()
-  autocmd BufRead Xtest2.txt call setloclist(g:save_winid, [], 'f')
-  call assert_fails('lvimgrep stars Xtest*.txt', 'E926:')
-  au! BufRead Xtest2.txt
-
-  call delete('Xtest1.txt')
-  call delete('Xtest2.txt')
-  call setqflist([], 'f')
-endfunc
-
-" Test for an autocmd changing the current directory when running vimgrep
-func Xvimgrep_autocmd_cd(cchar)
-  call s:setup_commands(a:cchar)
-
-  %bwipe
-  let save_cwd = getcwd()
-
-  augroup QF_Test
-    au!
-    autocmd BufRead * silent cd %:p:h
-  augroup END
-
-  10Xvimgrep /vim/ Xdir/**
-  let l = g:Xgetlist()
-  call assert_equal('f1.txt', bufname(l[0].bufnr))
-  call assert_equal('f2.txt', fnamemodify(bufname(l[2].bufnr), ':t'))
-
-  augroup QF_Test
-    au!
-  augroup END
-
-  exe 'cd ' . save_cwd
-endfunc
-
-func Test_vimgrep_autocmd_cd()
-  call mkdir('Xdir/a', 'p')
-  call mkdir('Xdir/b', 'p')
-  call writefile(['a_L1_vim', 'a_L2_vim'], 'Xdir/a/f1.txt')
-  call writefile(['b_L1_vim', 'b_L2_vim'], 'Xdir/b/f2.txt')
-  call Xvimgrep_autocmd_cd('c')
-  call Xvimgrep_autocmd_cd('l')
-  %bwipe
-  call delete('Xdir', 'rf')
-endfunc
-
-" The following test used to crash Vim
-func Test_lhelpgrep_autocmd()
-  lhelpgrep quickfix
-  augroup QF_Test
-    au!
-    autocmd QuickFixCmdPost * call setloclist(0, [], 'f')
-  augroup END
-  lhelpgrep buffer
-  call assert_equal('help', &filetype)
-  call assert_equal(0, getloclist(0, {'nr' : '$'}).nr)
-  lhelpgrep tabpage
-  call assert_equal('help', &filetype)
-  call assert_equal(1, getloclist(0, {'nr' : '$'}).nr)
-  augroup QF_Test
-    au!
-  augroup END
-
-  new | only
-  augroup QF_Test
-    au!
-    au BufEnter * call setqflist([], 'f')
-  augroup END
-  call assert_fails('helpgrep quickfix', 'E925:')
-  " run the test with a help window already open
-  help
-  wincmd w
-  call assert_fails('helpgrep quickfix', 'E925:')
-  augroup QF_Test
-    au!
-  augroup END
-
-  new | only
-  augroup QF_Test
-    au!
-    au BufEnter * call setqflist([], 'r')
-  augroup END
-  call assert_fails('helpgrep quickfix', 'E925:')
-  augroup QF_Test
-    au!
-  augroup END
-
-  new | only
-  augroup QF_Test
-    au!
-    au BufEnter * call setloclist(0, [], 'r')
-  augroup END
-  call assert_fails('lhelpgrep quickfix', 'E926:')
-  augroup QF_Test
-    au!
-  augroup END
-
-  " Replace the contents of a help window location list when it is still in
-  " use.
-  new | only
-  lhelpgrep quickfix
-  wincmd w
-  augroup QF_Test
-    au!
-    autocmd WinEnter * call setloclist(0, [], 'r')
-  augroup END
-  call assert_fails('lhelpgrep win_getid', 'E926:')
-  augroup QF_Test
-    au!
-  augroup END
-
-  %bw!
-endfunc
-
-" The following test used to crash Vim
-func Test_lhelpgrep_autocmd_free_loclist()
-  %bw!
-  lhelpgrep quickfix
-  wincmd w
-  augroup QF_Test
-    au!
-    autocmd WinEnter * call setloclist(0, [], 'f')
-  augroup END
-  lhelpgrep win_getid
-  wincmd w
-  wincmd w
-  wincmd w
-  augroup QF_Test
-    au!
-  augroup END
-  %bw!
-endfunc
-
-" Test for shortening/simplifying the file name when opening the
-" quickfix window or when displaying the quickfix list
-func Test_shorten_fname()
-  if !has('unix')
-    return
-  endif
-  %bwipe
-  " Create a quickfix list with a absolute path filename
-  let fname = getcwd() . '/test_quickfix.vim'
-  call setqflist([], ' ', {'lines':[fname . ":20:Line20"], 'efm':'%f:%l:%m'})
-  call assert_equal(fname, bufname('test_quickfix.vim'))
-  " Opening the quickfix window should simplify the file path
-  cwindow
-  call assert_equal('test_quickfix.vim', bufname('test_quickfix.vim'))
-  cclose
-  %bwipe
-  " Create a quickfix list with a absolute path filename
-  call setqflist([], ' ', {'lines':[fname . ":20:Line20"], 'efm':'%f:%l:%m'})
-  call assert_equal(fname, bufname('test_quickfix.vim'))
-  " Displaying the quickfix list should simplify the file path
-  silent! clist
-  call assert_equal('test_quickfix.vim', bufname('test_quickfix.vim'))
-  " Add a few entries for the same file with different paths and check whether
-  " the buffer name is shortened
-  %bwipe
-  call setqflist([], 'f')
-  call setqflist([{'filename' : 'test_quickfix.vim', 'lnum' : 10},
-        \ {'filename' : '../testdir/test_quickfix.vim', 'lnum' : 20},
-        \ {'filename' : fname, 'lnum' : 30}], ' ')
-  copen
-  call assert_equal(['test_quickfix.vim|10| ',
-        \ 'test_quickfix.vim|20| ',
-        \ 'test_quickfix.vim|30| '], getline(1, '$'))
-  cclose
-endfunc
-
-" Quickfix title tests
-" In the below tests, 'exe "cmd"' is used to invoke the quickfix commands.
-" Otherwise due to indentation, the title is set with spaces at the beginning
-" of the command.
-func Test_qftitle()
-  call writefile(["F1:1:Line1"], 'Xerr')
-
-  " :cexpr
-  exe "cexpr readfile('Xerr')"
-  call assert_equal(":cexpr readfile('Xerr')", getqflist({'title' : 1}).title)
-
-  " :cgetexpr
-  exe "cgetexpr readfile('Xerr')"
-  call assert_equal(":cgetexpr readfile('Xerr')",
-					\ getqflist({'title' : 1}).title)
-
-  " :caddexpr
-  call setqflist([], 'f')
-  exe "caddexpr readfile('Xerr')"
-  call assert_equal(":caddexpr readfile('Xerr')",
-					\ getqflist({'title' : 1}).title)
-
-  " :cbuffer
-  new Xerr
-  exe "cbuffer"
-  call assert_equal(':cbuffer (Xerr)', getqflist({'title' : 1}).title)
-
-  " :cgetbuffer
-  edit Xerr
-  exe "cgetbuffer"
-  call assert_equal(':cgetbuffer (Xerr)', getqflist({'title' : 1}).title)
-
-  " :caddbuffer
-  call setqflist([], 'f')
-  edit Xerr
-  exe "caddbuffer"
-  call assert_equal(':caddbuffer (Xerr)', getqflist({'title' : 1}).title)
-
-  " :cfile
-  exe "cfile Xerr"
-  call assert_equal(':cfile Xerr', getqflist({'title' : 1}).title)
-
-  " :cgetfile
-  exe "cgetfile Xerr"
-  call assert_equal(':cgetfile Xerr', getqflist({'title' : 1}).title)
-
-  " :caddfile
-  call setqflist([], 'f')
-  exe "caddfile Xerr"
-  call assert_equal(':caddfile Xerr', getqflist({'title' : 1}).title)
-
-  " :grep
-  set grepprg=internal
-  exe "grep F1 Xerr"
-  call assert_equal(':grep F1 Xerr', getqflist({'title' : 1}).title)
-
-  " :grepadd
-  call setqflist([], 'f')
-  exe "grepadd F1 Xerr"
-  call assert_equal(':grepadd F1 Xerr', getqflist({'title' : 1}).title)
-  set grepprg&vim
-
-  " :vimgrep
-  exe "vimgrep F1 Xerr"
-  call assert_equal(':vimgrep F1 Xerr', getqflist({'title' : 1}).title)
-
-  " :vimgrepadd
-  call setqflist([], 'f')
-  exe "vimgrepadd F1 Xerr"
-  call assert_equal(':vimgrepadd F1 Xerr', getqflist({'title' : 1}).title)
-
-  call setqflist(['F1:10:L10'], ' ')
-  call assert_equal(':setqflist()', getqflist({'title' : 1}).title)
-
-  call setqflist([], 'f')
-  call setqflist(['F1:10:L10'], 'a')
-  call assert_equal(':setqflist()', getqflist({'title' : 1}).title)
-
-  call setqflist([], 'f')
-  call setqflist(['F1:10:L10'], 'r')
-  call assert_equal(':setqflist()', getqflist({'title' : 1}).title)
-
-  close
-  call delete('Xerr')
-
-  call setqflist([], ' ', {'title' : 'Errors'})
-  copen
-  call assert_equal('Errors', w:quickfix_title)
-  call setqflist([], 'r', {'items' : [{'filename' : 'a.c', 'lnum' : 10}]})
-  call assert_equal('Errors', w:quickfix_title)
-  cclose
-
-  " Switching to another quickfix list in one tab page should update the
-  " quickfix window title and statusline in all the other tab pages also
-  call setqflist([], 'f')
-  %bw!
-  cgetexpr ['file_one:1:1: error in the first quickfix list']
-  call setqflist([], 'a', {'title': 'first quickfix list'})
-  cgetexpr ['file_two:2:1: error in the second quickfix list']
-  call setqflist([], 'a', {'title': 'second quickfix list'})
-  copen
-  wincmd t
-  tabnew two
-  copen
-  wincmd t
-  colder
-  call assert_equal('first quickfix list', gettabwinvar(1, 2, 'quickfix_title'))
-  call assert_equal('first quickfix list', gettabwinvar(2, 2, 'quickfix_title'))
-  call assert_equal(1, tabpagewinnr(1))
-  call assert_equal(1, tabpagewinnr(2))
-  tabnew
-  call setqflist([], 'a', {'title': 'new quickfix title'})
-  call assert_equal('new quickfix title', gettabwinvar(1, 2, 'quickfix_title'))
-  call assert_equal('new quickfix title', gettabwinvar(2, 2, 'quickfix_title'))
-  %bw!
-endfunc
-
-func Test_lbuffer_with_bwipe()
-  new
-  new
-  augroup nasty
-    au QuickFixCmdPre,QuickFixCmdPost,BufEnter,BufLeave * bwipe
-  augroup END
-  lbuffer
-  augroup nasty
-    au!
-  augroup END
-endfunc
-
-" Test for an autocmd freeing the quickfix/location list when cexpr/lexpr is
-" running
-func Xexpr_acmd_freelist(cchar)
-  call s:setup_commands(a:cchar)
-
-  " This was using freed memory (but with what events?)
-  augroup nasty
-    au QuickFixCmdPre,QuickFixCmdPost,BufEnter,BufLeave * call g:Xsetlist([], 'f')
-  augroup END
-  Xexpr "x"
-  augroup nasty
-    au!
-  augroup END
-endfunc
-
-func Test_cexpr_acmd_freelist()
-  call Xexpr_acmd_freelist('c')
-  call Xexpr_acmd_freelist('l')
-endfunc
-
-" Test for commands that create a new quickfix/location list and jump to the
-" first error automatically.
-func Xjumpto_first_error_test(cchar)
-  call s:setup_commands(a:cchar)
-
-  call s:create_test_file('Xtestfile1')
-  call s:create_test_file('Xtestfile2')
-  let l = ['Xtestfile1:2:Line2', 'Xtestfile2:4:Line4']
-
-  " Test for cexpr/lexpr
-  enew
-  Xexpr l
-  call assert_equal('Xtestfile1', @%)
-  call assert_equal(2, line('.'))
-
-  " Test for cfile/lfile
-  enew
-  call writefile(l, 'Xerr')
-  Xfile Xerr
-  call assert_equal('Xtestfile1', @%)
-  call assert_equal(2, line('.'))
-
-  " Test for cbuffer/lbuffer
-  edit Xerr
-  Xbuffer
-  call assert_equal('Xtestfile1', @%)
-  call assert_equal(2, line('.'))
-
-  call delete('Xerr')
-  call delete('Xtestfile1')
-  call delete('Xtestfile2')
-endfunc
-
-func Test_jumpto_first_error()
-  call Xjumpto_first_error_test('c')
-  call Xjumpto_first_error_test('l')
-endfunc
-
-" Test for a quickfix autocmd changing the quickfix/location list before
-" jumping to the first error in the new list.
-func Xautocmd_changelist(cchar)
-  call s:setup_commands(a:cchar)
-
-  " Test for cfile/lfile
-  call s:create_test_file('Xtestfile1')
-  call s:create_test_file('Xtestfile2')
-  Xexpr 'Xtestfile1:2:Line2'
-  autocmd QuickFixCmdPost * Xolder
-  call writefile(['Xtestfile2:4:Line4'], 'Xerr')
-  Xfile Xerr
-  call assert_equal('Xtestfile2', @%)
-  call assert_equal(4, line('.'))
-  autocmd! QuickFixCmdPost
-
-  " Test for cbuffer/lbuffer
-  call g:Xsetlist([], 'f')
-  Xexpr 'Xtestfile1:2:Line2'
-  autocmd QuickFixCmdPost * Xolder
-  call writefile(['Xtestfile2:4:Line4'], 'Xerr')
-  edit Xerr
-  Xbuffer
-  call assert_equal('Xtestfile2', @%)
-  call assert_equal(4, line('.'))
-  autocmd! QuickFixCmdPost
-
-  " Test for cexpr/lexpr
-  call g:Xsetlist([], 'f')
-  Xexpr 'Xtestfile1:2:Line2'
-  autocmd QuickFixCmdPost * Xolder
-  Xexpr 'Xtestfile2:4:Line4'
-  call assert_equal('Xtestfile2', @%)
-  call assert_equal(4, line('.'))
-  autocmd! QuickFixCmdPost
-
-  " The grepprg may not be set on non-Unix systems
-  if has('unix')
-    " Test for grep/lgrep
-    call g:Xsetlist([], 'f')
-    Xexpr 'Xtestfile1:2:Line2'
-    autocmd QuickFixCmdPost * Xolder
-    silent Xgrep Line5 Xtestfile2
-    call assert_equal('Xtestfile2', @%)
-    call assert_equal(5, line('.'))
-    autocmd! QuickFixCmdPost
-  endif
-
-  " Test for vimgrep/lvimgrep
-  call g:Xsetlist([], 'f')
-  Xexpr 'Xtestfile1:2:Line2'
-  autocmd QuickFixCmdPost * Xolder
-  silent Xvimgrep Line5 Xtestfile2
-  call assert_equal('Xtestfile2', @%)
-  call assert_equal(5, line('.'))
-  autocmd! QuickFixCmdPost
-
-  " Test for autocommands clearing the quickfix list before jumping to the
-  " first error. This should not result in an error
-  autocmd QuickFixCmdPost * call g:Xsetlist([], 'r')
-  let v:errmsg = ''
-  " Test for cfile/lfile
-  Xfile Xerr
-  call assert_true(v:errmsg !~# 'E42:')
-  " Test for cbuffer/lbuffer
-  edit Xerr
-  Xbuffer
-  call assert_true(v:errmsg !~# 'E42:')
-  " Test for cexpr/lexpr
-  Xexpr 'Xtestfile2:4:Line4'
-  call assert_true(v:errmsg !~# 'E42:')
-  " Test for grep/lgrep
-  " The grepprg may not be set on non-Unix systems
-  if has('unix')
-    silent Xgrep Line5 Xtestfile2
-    call assert_true(v:errmsg !~# 'E42:')
-  endif
-  " Test for vimgrep/lvimgrep
-  call assert_fails('silent Xvimgrep Line5 Xtestfile2', 'E480:')
-  autocmd! QuickFixCmdPost
-
-  call delete('Xerr')
-  call delete('Xtestfile1')
-  call delete('Xtestfile2')
-endfunc
-
-func Test_autocmd_changelist()
-  call Xautocmd_changelist('c')
-  call Xautocmd_changelist('l')
-endfunc
-
-" Tests for the ':filter /pat/ clist' command
-func Test_filter_clist()
-  cexpr ['Xfile1:10:10:Line 10', 'Xfile2:15:15:Line 15']
-  call assert_equal([' 2 Xfile2:15 col 15: Line 15'],
-			\ split(execute('filter /Line 15/ clist'), "\n"))
-  call assert_equal([' 1 Xfile1:10 col 10: Line 10'],
-			\ split(execute('filter /Xfile1/ clist'), "\n"))
-  call assert_equal([], split(execute('filter /abc/ clist'), "\n"))
-
-  call setqflist([{'module' : 'abc', 'pattern' : 'pat1'},
-			\ {'module' : 'pqr', 'pattern' : 'pat2'}], ' ')
-  call assert_equal([' 2 pqr:pat2:  '],
-			\ split(execute('filter /pqr/ clist'), "\n"))
-  call assert_equal([' 1 abc:pat1:  '],
-			\ split(execute('filter /pat1/ clist'), "\n"))
-endfunc
-
-" Tests for the "CTRL-W <CR>" command.
-func Xview_result_split_tests(cchar)
-  call s:setup_commands(a:cchar)
-
-  " Test that "CTRL-W <CR>" in a qf/ll window fails with empty list.
-  call g:Xsetlist([])
-  Xopen
-  let l:win_count = winnr('$')
-  call assert_fails('execute "normal! \<C-W>\<CR>"', 'E42')
-  call assert_equal(l:win_count, winnr('$'))
-  Xclose
-endfunc
-
-func Test_view_result_split()
-  call Xview_result_split_tests('c')
-  call Xview_result_split_tests('l')
-endfunc
-
-" Test that :cc sets curswant
-func Test_curswant()
-  helpgrep quickfix
-  normal! llll
-  1cc
-  call assert_equal(getcurpos()[4], virtcol('.'))
-  cclose | helpclose
-endfunc
-
-" Test for opening a file from the quickfix window using CTRL-W <Enter>
-" doesn't leave an empty buffer around.
-func Test_splitview()
-  call s:create_test_file('Xtestfile1')
-  call s:create_test_file('Xtestfile2')
-  new | only
-  let last_bufnr = bufnr('Test_sv_1', 1)
-  let l = ['Xtestfile1:2:Line2', 'Xtestfile2:4:Line4']
-  cgetexpr l
-  copen
-  let numbufs = len(getbufinfo())
-  exe "normal \<C-W>\<CR>"
-  copen
-  exe "normal j\<C-W>\<CR>"
-  " Make sure new empty buffers are not created
-  call assert_equal(numbufs, len(getbufinfo()))
-  " Creating a new buffer should use the next available buffer number
-  call assert_equal(last_bufnr + 4, bufnr("Test_sv_2", 1))
-  bwipe Test_sv_1
-  bwipe Test_sv_2
-  new | only
-
-  " When split opening files from location list window, make sure that two
-  " windows doesn't refer to the same location list
-  lgetexpr l
-  let locid = getloclist(0, {'id' : 0}).id
-  lopen
-  exe "normal \<C-W>\<CR>"
-  call assert_notequal(locid, getloclist(0, {'id' : 0}).id)
-  call assert_equal(0, getloclist(0, {'winid' : 0}).winid)
-  new | only
-
-  " When split opening files from a helpgrep location list window, a new help
-  " window should be opened with a copy of the location list.
-  lhelpgrep window
-  let locid = getloclist(0, {'id' : 0}).id
-  lwindow
-  exe "normal j\<C-W>\<CR>"
-  call assert_notequal(locid, getloclist(0, {'id' : 0}).id)
-  call assert_equal(0, getloclist(0, {'winid' : 0}).winid)
-  new | only
-
-  " Using :split or :vsplit from a quickfix window should behave like a :new
-  " or a :vnew command
-  copen
-  split
-  call assert_equal(3, winnr('$'))
-  let l = getwininfo()
-  call assert_equal([0, 0, 1], [l[0].quickfix, l[1].quickfix, l[2].quickfix])
-  close
-  copen
-  vsplit
-  let l = getwininfo()
-  call assert_equal([0, 0, 1], [l[0].quickfix, l[1].quickfix, l[2].quickfix])
-  new | only
-
-  call delete('Xtestfile1')
-  call delete('Xtestfile2')
-endfunc
-
-" Test for parsing entries using visual screen column
-func Test_viscol()
-  enew
-  call writefile(["Col1\tCol2\tCol3"], 'Xfile1')
-  edit Xfile1
-
-  " Use byte offset for column number
-  set efm&
-  cexpr "Xfile1:1:5:XX\nXfile1:1:9:YY\nXfile1:1:20:ZZ"
-  call assert_equal([5, 8], [col('.'), virtcol('.')])
-  cnext
-  call assert_equal([9, 12], [col('.'), virtcol('.')])
-  cnext
-  call assert_equal([14, 20], [col('.'), virtcol('.')])
-
-  " Use screen column offset for column number
-  set efm=%f:%l:%v:%m
-  cexpr "Xfile1:1:8:XX\nXfile1:1:12:YY\nXfile1:1:20:ZZ"
-  call assert_equal([5, 8], [col('.'), virtcol('.')])
-  cnext
-  call assert_equal([9, 12], [col('.'), virtcol('.')])
-  cnext
-  call assert_equal([14, 20], [col('.'), virtcol('.')])
-  cexpr "Xfile1:1:6:XX\nXfile1:1:15:YY\nXfile1:1:24:ZZ"
-  call assert_equal([5, 8], [col('.'), virtcol('.')])
-  cnext
-  call assert_equal([10, 16], [col('.'), virtcol('.')])
-  cnext
-  call assert_equal([14, 20], [col('.'), virtcol('.')])
-
-  enew
-  call writefile(["Col1\täü\töß\tCol4"], 'Xfile1')
-
-  " Use byte offset for column number
-  set efm&
-  cexpr "Xfile1:1:8:XX\nXfile1:1:11:YY\nXfile1:1:16:ZZ"
-  call assert_equal([8, 10], [col('.'), virtcol('.')])
-  cnext
-  call assert_equal([11, 17], [col('.'), virtcol('.')])
-  cnext
-  call assert_equal([16, 25], [col('.'), virtcol('.')])
-
-  " Use screen column offset for column number
-  set efm=%f:%l:%v:%m
-  cexpr "Xfile1:1:10:XX\nXfile1:1:17:YY\nXfile1:1:25:ZZ"
-  call assert_equal([8, 10], [col('.'), virtcol('.')])
-  cnext
-  call assert_equal([11, 17], [col('.'), virtcol('.')])
-  cnext
-  call assert_equal([16, 25], [col('.'), virtcol('.')])
-
-  " Use screen column number with a multi-line error message
-  enew
-  call writefile(["à test"], 'Xfile1')
-  set efm=%E===\ %f\ ===,%C%l:%v,%Z%m
-  cexpr ["=== Xfile1 ===", "1:3", "errormsg"]
-  call assert_equal('Xfile1', @%)
-  call assert_equal([0, 1, 4, 0], getpos('.'))
-
-  " Repeat previous test with byte offset %c: ensure that fix to issue #7145
-  " does not break this
-  set efm=%E===\ %f\ ===,%C%l:%c,%Z%m
-  cexpr ["=== Xfile1 ===", "1:3", "errormsg"]
-  call assert_equal('Xfile1', @%)
-  call assert_equal([0, 1, 3, 0], getpos('.'))
-
-  enew | only
-  set efm&
-  call delete('Xfile1')
-endfunc
-
-" Test for the quickfix window buffer
-func Xqfbuf_test(cchar)
-  call s:setup_commands(a:cchar)
-
-  " Quickfix buffer should be reused across closing and opening a quickfix
-  " window
-  Xexpr "F1:10:Line10"
-  Xopen
-  let qfbnum = bufnr('')
-  Xclose
-  " Even after the quickfix window is closed, the buffer should be loaded
-  call assert_true(bufloaded(qfbnum))
-  call assert_true(qfbnum, g:Xgetlist({'qfbufnr' : 0}).qfbufnr)
-  Xopen
-  " Buffer should be reused when opening the window again
-  call assert_equal(qfbnum, bufnr(''))
-  Xclose
-
-  " When quickfix buffer is wiped out, getqflist() should return 0
-  %bw!
-  Xexpr ""
-  Xopen
-  bw!
-  call assert_equal(0, g:Xgetlist({'qfbufnr': 0}).qfbufnr)
-
-  if a:cchar == 'l'
-    %bwipe
-    " For a location list, when both the file window and the location list
-    " window for the list are closed, then the buffer should be freed.
-    new | only
-    lexpr "F1:10:Line10"
-    let wid = win_getid()
-    lopen
-    let qfbnum = bufnr('')
-    call assert_match(qfbnum . ' %a-  "\[Location List]"', execute('ls'))
-    close
-    " When the location list window is closed, the buffer name should not
-    " change to 'Quickfix List'
-    call assert_match(qfbnum . 'u h-  "\[Location List]"', execute('ls!'))
-    call assert_true(bufloaded(qfbnum))
-
-    " After deleting a location list buffer using ":bdelete", opening the
-    " location list window should mark the buffer as a location list buffer.
-    exe "bdelete " . qfbnum
-    lopen
-    call assert_equal("quickfix", &buftype)
-    call assert_equal(1, getwininfo(win_getid(winnr()))[0].loclist)
-    call assert_equal(wid, getloclist(0, {'filewinid' : 0}).filewinid)
-    call assert_false(&swapfile)
-    lclose
-
-    " When the location list is cleared for the window, the buffer should be
-    " removed
-    call setloclist(0, [], 'f')
-    call assert_false(bufexists(qfbnum))
-    call assert_equal(0, getloclist(0, {'qfbufnr' : 0}).qfbufnr)
-
-    " When the location list is freed with the location list window open, the
-    " location list buffer should not be lost. It should be reused when the
-    " location list is again populated.
-    lexpr "F1:10:Line10"
-    lopen
-    let wid = win_getid()
-    let qfbnum = bufnr('')
-    wincmd p
-    call setloclist(0, [], 'f')
-    lexpr "F1:10:Line10"
-    lopen
-    call assert_equal(wid, win_getid())
-    call assert_equal(qfbnum, bufnr(''))
-    lclose
-
-    " When the window with the location list is closed, the buffer should be
-    " removed
-    new | only
-    call assert_false(bufexists(qfbnum))
-  endif
-endfunc
-
-func Test_qfbuf()
-  call Xqfbuf_test('c')
-  call Xqfbuf_test('l')
-endfunc
-
-" If there is an autocmd to use only one window, then opening the location
-" list window used to crash Vim.
-func Test_winonly_autocmd()
-  call s:create_test_file('Xtest1')
-  " Autocmd to show only one Vim window at a time
-  autocmd WinEnter * only
-  new
-  " Load the location list
-  lexpr "Xtest1:5:Line5\nXtest1:10:Line10\nXtest1:15:Line15"
-  let loclistid = getloclist(0, {'id' : 0}).id
-  " Open the location list window. Only this window will be shown and the file
-  " window is closed.
-  lopen
-  call assert_equal(loclistid, getloclist(0, {'id' : 0}).id)
-  " Jump to an entry in the location list and make sure that the cursor is
-  " positioned correctly.
-  ll 3
-  call assert_equal(loclistid, getloclist(0, {'id' : 0}).id)
-  call assert_equal('Xtest1', @%)
-  call assert_equal(15, line('.'))
-  " Cleanup
-  autocmd! WinEnter
-  new | only
-  call delete('Xtest1')
-endfunc
-
-" Test to make sure that an empty quickfix buffer is not reused for loading
-" a normal buffer.
-func Test_empty_qfbuf()
-  enew | only
-  call writefile(["Test"], 'Xfile1')
-  call setqflist([], 'f')
-  copen | only
-  let qfbuf = bufnr('')
-  edit Xfile1
-  call assert_notequal(qfbuf, bufnr(''))
-  enew
-  call delete('Xfile1')
-endfunc
-
-" Test for the :cbelow, :cabove, :lbelow and :labove commands.
-" And for the :cafter, :cbefore, :lafter and :lbefore commands.
-func Xtest_below(cchar)
-  call s:setup_commands(a:cchar)
-
-  " No quickfix/location list
-  call assert_fails('Xbelow', 'E42:')
-  call assert_fails('Xabove', 'E42:')
-  call assert_fails('Xbefore', 'E42:')
-  call assert_fails('Xafter', 'E42:')
-
-  " Empty quickfix/location list
-  call g:Xsetlist([])
-  call assert_fails('Xbelow', 'E42:')
-  call assert_fails('Xabove', 'E42:')
-  call assert_fails('Xbefore', 'E42:')
-  call assert_fails('Xafter', 'E42:')
-
-  call s:create_test_file('X1')
-  call s:create_test_file('X2')
-  call s:create_test_file('X3')
-  call s:create_test_file('X4')
-
-  " Invalid entries
-  edit X1
-  call g:Xsetlist(["E1", "E2"])
-  call assert_fails('Xbelow', 'E42:')
-  call assert_fails('Xabove', 'E42:')
-  call assert_fails('3Xbelow', 'E42:')
-  call assert_fails('4Xabove', 'E42:')
-  call assert_fails('Xbefore', 'E42:')
-  call assert_fails('Xafter', 'E42:')
-  call assert_fails('3Xbefore', 'E42:')
-  call assert_fails('4Xafter', 'E42:')
-
-  " Test the commands with various arguments
-  Xexpr ["X1:5:3:L5", "X2:5:2:L5", "X2:10:3:L10", "X2:15:4:L15", "X3:3:5:L3"]
-  edit +7 X2
-  Xabove
-  call assert_equal(['X2', 5], [@%, line('.')])
-  call assert_fails('Xabove', 'E553:')
-  normal 7G
-  Xbefore
-  call assert_equal(['X2', 5, 2], [@%, line('.'), col('.')])
-  call assert_fails('Xbefore', 'E553:')
-
-  normal 2j
-  Xbelow
-  call assert_equal(['X2', 10], [@%, line('.')])
-  normal 7G
-  Xafter
-  call assert_equal(['X2', 10, 3], [@%, line('.'), col('.')])
-
-  " Last error in this file
-  Xbelow 99
-  call assert_equal(['X2', 15], [@%, line('.')])
-  call assert_fails('Xbelow', 'E553:')
-  normal gg
-  Xafter 99
-  call assert_equal(['X2', 15, 4], [@%, line('.'), col('.')])
-  call assert_fails('Xafter', 'E553:')
-
-  " First error in this file
-  Xabove 99
-  call assert_equal(['X2', 5], [@%, line('.')])
-  call assert_fails('Xabove', 'E553:')
-  normal G
-  Xbefore 99
-  call assert_equal(['X2', 5, 2], [@%, line('.'), col('.')])
-  call assert_fails('Xbefore', 'E553:')
-
-  normal gg
-  Xbelow 2
-  call assert_equal(['X2', 10], [@%, line('.')])
-  normal gg
-  Xafter 2
-  call assert_equal(['X2', 10, 3], [@%, line('.'), col('.')])
-
-  normal G
-  Xabove 2
-  call assert_equal(['X2', 10], [@%, line('.')])
-  normal G
-  Xbefore 2
-  call assert_equal(['X2', 10, 3], [@%, line('.'), col('.')])
-
-  edit X4
-  call assert_fails('Xabove', 'E42:')
-  call assert_fails('Xbelow', 'E42:')
-  call assert_fails('Xbefore', 'E42:')
-  call assert_fails('Xafter', 'E42:')
-  if a:cchar == 'l'
-    " If a buffer has location list entries from some other window but not
-    " from the current window, then the commands should fail.
-    edit X1 | split | call setloclist(0, [], 'f')
-    call assert_fails('Xabove', 'E776:')
-    call assert_fails('Xbelow', 'E776:')
-    call assert_fails('Xbefore', 'E776:')
-    call assert_fails('Xafter', 'E776:')
-    close
-  endif
-
-  " Test for lines with multiple quickfix entries
-  let lines =<< trim END
-    X1:5:L5
-    X2:5:1:L5_1
-    X2:5:2:L5_2
-    X2:5:3:L5_3
-    X2:10:1:L10_1
-    X2:10:2:L10_2
-    X2:10:3:L10_3
-    X2:15:1:L15_1
-    X2:15:2:L15_2
-    X2:15:3:L15_3
-    X3:3:L3
-  END
-  Xexpr lines
-  edit +1 X2
-  Xbelow 2
-  call assert_equal(['X2', 10, 1], [@%, line('.'), col('.')])
-  normal 1G
-  Xafter 2
-  call assert_equal(['X2', 5, 2], [@%, line('.'), col('.')])
-
-  normal gg
-  Xbelow 99
-  call assert_equal(['X2', 15, 1], [@%, line('.'), col('.')])
-  normal gg
-  Xafter 99
-  call assert_equal(['X2', 15, 3], [@%, line('.'), col('.')])
-
-  normal G
-  Xabove 2
-  call assert_equal(['X2', 10, 1], [@%, line('.'), col('.')])
-  normal G
-  Xbefore 2
-  call assert_equal(['X2', 15, 2], [@%, line('.'), col('.')])
-
-  normal G
-  Xabove 99
-  call assert_equal(['X2', 5, 1], [@%, line('.'), col('.')])
-  normal G
-  Xbefore 99
-  call assert_equal(['X2', 5, 1], [@%, line('.'), col('.')])
-
-  normal 10G
-  Xabove
-  call assert_equal(['X2', 5, 1], [@%, line('.'), col('.')])
-  normal 10G$
-  2Xbefore
-  call assert_equal(['X2', 10, 2], [@%, line('.'), col('.')])
-
-  normal 10G
-  Xbelow
-  call assert_equal(['X2', 15, 1], [@%, line('.'), col('.')])
-  normal 9G
-  5Xafter
-  call assert_equal(['X2', 15, 2], [@%, line('.'), col('.')])
-
-  " Invalid range
-  if a:cchar == 'c'
-    call assert_fails('-2cbelow', 'E16:')
-    call assert_fails('-2cafter', 'E16:')
-  else
-    call assert_fails('-2lbelow', 'E16:')
-    call assert_fails('-2lafter', 'E16:')
-  endif
-
-  call delete('X1')
-  call delete('X2')
-  call delete('X3')
-  call delete('X4')
-endfunc
-
-func Test_cbelow()
-  call Xtest_below('c')
-  call Xtest_below('l')
-endfunc
-
-func Test_quickfix_count()
-  let commands =<< trim END
-    cNext
-    cNfile
-    cabove
-    cbelow
-    cfirst
-    clast
-    cnewer
-    cnext
-    cnfile
-    colder
-    cprevious
-    crewind
-    lNext
-    lNfile
-    labove
-    lbelow
-    lfirst
-    llast
-    lnewer
-    lnext
-    lnfile
-    lolder
-    lprevious
-    lrewind
-  END
-  for cmd in commands
-    call assert_fails('-1' .. cmd, 'E16:')
-    call assert_fails('.' .. cmd, 'E16:')
-    call assert_fails('%' .. cmd, 'E16:')
-    call assert_fails('$' .. cmd, 'E16:')
-  endfor
-endfunc
-
-" Test for aborting quickfix commands using QuickFixCmdPre
-func Xtest_qfcmd_abort(cchar)
-  call s:setup_commands(a:cchar)
-
-  call g:Xsetlist([], 'f')
-
-  " cexpr/lexpr
-  let e = ''
-  try
-    Xexpr ["F1:10:Line10", "F2:20:Line20"]
-  catch /.*/
-    let e = v:exception
-  endtry
-  call assert_equal('AbortCmd', e)
-  call assert_equal(0, g:Xgetlist({'nr' : '$'}).nr)
-
-  " cfile/lfile
-  call writefile(["F1:10:Line10", "F2:20:Line20"], 'Xfile1')
-  let e = ''
-  try
-    Xfile Xfile1
-  catch /.*/
-    let e = v:exception
-  endtry
-  call assert_equal('AbortCmd', e)
-  call assert_equal(0, g:Xgetlist({'nr' : '$'}).nr)
-  call delete('Xfile1')
-
-  " cgetbuffer/lgetbuffer
-  enew!
-  call append(0, ["F1:10:Line10", "F2:20:Line20"])
-  let e = ''
-  try
-    Xgetbuffer
-  catch /.*/
-    let e = v:exception
-  endtry
-  call assert_equal('AbortCmd', e)
-  call assert_equal(0, g:Xgetlist({'nr' : '$'}).nr)
-  enew!
-
-  " vimgrep/lvimgrep
-  let e = ''
-  try
-    Xvimgrep /func/ test_quickfix.vim
-  catch /.*/
-    let e = v:exception
-  endtry
-  call assert_equal('AbortCmd', e)
-  call assert_equal(0, g:Xgetlist({'nr' : '$'}).nr)
-
-  " helpgrep/lhelpgrep
-  let e = ''
-  try
-    Xhelpgrep quickfix
-  catch /.*/
-    let e = v:exception
-  endtry
-  call assert_equal('AbortCmd', e)
-  call assert_equal(0, g:Xgetlist({'nr' : '$'}).nr)
-
-  " grep/lgrep
-  if has('unix')
-    let e = ''
-    try
-      silent Xgrep func test_quickfix.vim
-    catch /.*/
-      let e = v:exception
-    endtry
-    call assert_equal('AbortCmd', e)
-    call assert_equal(0, g:Xgetlist({'nr' : '$'}).nr)
-  endif
-endfunc
-
-func Test_qfcmd_abort()
-  augroup QF_Test
-    au!
-    autocmd  QuickFixCmdPre * throw "AbortCmd"
-  augroup END
-
-  call Xtest_qfcmd_abort('c')
-  call Xtest_qfcmd_abort('l')
-
-  augroup QF_Test
-    au!
-  augroup END
-endfunc
-
-" Test for using a file in one of the parent directories.
-func Test_search_in_dirstack()
-  call mkdir('Xtestdir/a/b/c', 'p')
-  let save_cwd = getcwd()
-  call writefile(["X1_L1", "X1_L2"], 'Xtestdir/Xfile1')
-  call writefile(["X2_L1", "X2_L2"], 'Xtestdir/a/Xfile2')
-  call writefile(["X3_L1", "X3_L2"], 'Xtestdir/a/b/Xfile3')
-  call writefile(["X4_L1", "X4_L2"], 'Xtestdir/a/b/c/Xfile4')
-
-  let lines = "Entering dir Xtestdir\n" .
-	      \ "Entering dir a\n" .
-	      \ "Entering dir b\n" .
-	      \ "Xfile2:2:X2_L2\n" .
-	      \ "Leaving dir a\n" .
-	      \ "Xfile1:2:X1_L2\n" .
-	      \ "Xfile3:1:X3_L1\n" .
-	      \ "Entering dir c\n" .
-	      \ "Xfile4:2:X4_L2\n" .
-	      \ "Leaving dir c\n"
-  set efm=%DEntering\ dir\ %f,%XLeaving\ dir\ %f,%f:%l:%m
-  cexpr lines .. "Leaving dir Xtestdir|\n" | let next = 1
-  call assert_equal(11, getqflist({'size' : 0}).size)
-  call assert_equal(4, getqflist({'idx' : 0}).idx)
-  call assert_equal('X2_L2', getline('.'))
-  call assert_equal(1, next)
-  cnext
-  call assert_equal(6, getqflist({'idx' : 0}).idx)
-  call assert_equal('X1_L2', getline('.'))
-  cnext
-  call assert_equal(7, getqflist({'idx' : 0}).idx)
-  call assert_equal(1, line('$'))
-  call assert_equal('', getline(1))
-  cnext
-  call assert_equal(9, getqflist({'idx' : 0}).idx)
-  call assert_equal(1, line('$'))
-  call assert_equal('', getline(1))
-
-  set efm&
-  exe 'cd ' . save_cwd
-  call delete('Xtestdir', 'rf')
-endfunc
-
-" Test for :cquit
-func Test_cquit()
-  " Exit Vim with a non-zero value
-  if RunVim([], ["cquit 7"], '')
-    call assert_equal(7, v:shell_error)
-  endif
-
-  if RunVim([], ["50cquit"], '')
-    call assert_equal(50, v:shell_error)
-  endif
-
-  " Exit Vim with default value
-  if RunVim([], ["cquit"], '')
-    call assert_equal(1, v:shell_error)
-  endif
-
-  " Exit Vim with zero value
-  if RunVim([], ["cquit 0"], '')
-    call assert_equal(0, v:shell_error)
-  endif
-
-  " Exit Vim with negative value
-  call assert_fails('-3cquit', 'E16:')
-endfunc
-
-" Running :lhelpgrep command more than once in a help window, doesn't jump to
-" the help topic
-func Test_lhelpgrep_from_help_window()
-  call mkdir('Xtestdir/doc', 'p')
-  call writefile(['window'], 'Xtestdir/doc/a.txt')
-  call writefile(['buffer'], 'Xtestdir/doc/b.txt')
-  let save_rtp = &rtp
-  let &rtp = 'Xtestdir'
-  lhelpgrep window
-  lhelpgrep buffer
-  call assert_equal('b.txt', fnamemodify(@%, ":p:t"))
-  lhelpgrep window
-  call assert_equal('a.txt', fnamemodify(@%, ":p:t"))
-  let &rtp = save_rtp
-  call delete('Xtestdir', 'rf')
-  new | only!
-endfunc
-
-" Test for the crash fixed by 7.3.715
-func Test_setloclist_crash()
-  %bw!
-  let g:BufNum = bufnr()
-  augroup QF_Test
-    au!
-    au BufUnload * call setloclist(0, [{'bufnr':g:BufNum, 'lnum':1, 'col':1, 'text': 'tango down'}])
-  augroup END
-
-  try
-    lvimgrep /.*/ *.mak
-  catch /E926:/
-  endtry
-  call assert_equal('tango down', getloclist(0, {'items' : 0}).items[0].text)
-  call assert_equal(1, getloclist(0, {'size' : 0}).size)
-
-  augroup QF_Test
-    au!
-  augroup END
-  unlet g:BufNum
-  %bw!
-endfunc
-
-" Test for adding an invalid entry with the quickfix window open and making
-" sure that the window contents are not changed
-func Test_add_invalid_entry_with_qf_window()
-  call setqflist([], 'f')
-  cexpr "Xfile1:10:aa"
-  copen
-  call setqflist(['bb'], 'a')
-  call assert_equal(1, line('$'))
-  call assert_equal(['Xfile1|10| aa'], getline(1, '$'))
-  call assert_equal([{'lnum': 10                    , 'end_lnum': 0    , 'bufnr': bufnr('Xfile1') , 'col': 0   , 'end_col': 0    , 'pattern': '' , 'valid': 1 , 'vcol': 0 , 'nr': -1 , 'type': '' , 'module': '' , 'text': 'aa'}] , getqflist())
-
-  call setqflist([{'lnum': 10                                          , 'bufnr': bufnr('Xfile1') , 'col': 0                     , 'pattern': '' , 'valid': 1 , 'vcol': 0 , 'nr': -1 , 'type': '' , 'module': '' , 'text': 'aa'}] , 'r')
-  call assert_equal(1                               , line('$'))
-  call assert_equal(['Xfile1|10| aa']               , getline(1        , '$'))
-  call assert_equal([{'lnum': 10                    , 'end_lnum': 0    , 'bufnr': bufnr('Xfile1') , 'col': 0   , 'end_col': 0    , 'pattern': '' , 'valid': 1 , 'vcol': 0 , 'nr': -1 , 'type': '' , 'module': '' , 'text': 'aa'}] , getqflist())
-
-  call setqflist([{'lnum': 10                       , 'end_lnum': 0    , 'bufnr': bufnr('Xfile1') , 'col': 0   , 'end_col': 0    , 'pattern': '' , 'valid': 1 , 'vcol': 0 , 'nr': -1 , 'type': '' , 'module': '' , 'text': 'aa'}] , 'r')
-  call assert_equal(1                               , line('$'))
-  call assert_equal(['Xfile1|10| aa']               , getline(1        , '$'))
-  call assert_equal([{'lnum': 10                    , 'end_lnum': 0    , 'bufnr': bufnr('Xfile1') , 'col': 0   , 'end_col': 0    , 'pattern': '' , 'valid': 1 , 'vcol': 0 , 'nr': -1 , 'type': '' , 'module': '' , 'text': 'aa'}] , getqflist())
-
-  call setqflist([{'lnum': 10                       , 'end_lnum': -123 , 'bufnr': bufnr('Xfile1') , 'col': 0   , 'end_col': -456 , 'pattern': '' , 'valid': 1 , 'vcol': 0 , 'nr': -1 , 'type': '' , 'module': '' , 'text': 'aa'}] , 'r')
-  call assert_equal(1                               , line('$'))
-  call assert_equal(['Xfile1|10| aa']               , getline(1        , '$'))
-  call assert_equal([{'lnum': 10                    , 'end_lnum': -123 , 'bufnr': bufnr('Xfile1') , 'col': 0   , 'end_col': -456 , 'pattern': '' , 'valid': 1 , 'vcol': 0 , 'nr': -1 , 'type': '' , 'module': '' , 'text': 'aa'}] , getqflist())
-
-  call setqflist([{'lnum': 10                       , 'end_lnum': -123 , 'bufnr': bufnr('Xfile1') , 'col': 666 , 'end_col': 0    , 'pattern': '' , 'valid': 1 , 'vcol': 0 , 'nr': -1 , 'type': '' , 'module': '' , 'text': 'aa'}] , 'r')
-  call assert_equal(1                               , line('$'))
-  call assert_equal(['Xfile1|10 col 666| aa']       , getline(1        , '$'))
-  call assert_equal([{'lnum': 10                    , 'end_lnum': -123 , 'bufnr': bufnr('Xfile1') , 'col': 666 , 'end_col': 0    , 'pattern': '' , 'valid': 1 , 'vcol': 0 , 'nr': -1 , 'type': '' , 'module': '' , 'text': 'aa'}] , getqflist())
-
-  call setqflist([{'lnum': 10                       , 'end_lnum': -123 , 'bufnr': bufnr('Xfile1') , 'col': 666 , 'end_col': -456 , 'pattern': '' , 'valid': 1 , 'vcol': 0 , 'nr': -1 , 'type': '' , 'module': '' , 'text': 'aa'}] , 'r')
-  call assert_equal(1                               , line('$'))
-  call assert_equal(['Xfile1|10 col 666| aa']       , getline(1        , '$'))
-  call assert_equal([{'lnum': 10                    , 'end_lnum': -123 , 'bufnr': bufnr('Xfile1') , 'col': 666 , 'end_col': -456 , 'pattern': '' , 'valid': 1 , 'vcol': 0 , 'nr': -1 , 'type': '' , 'module': '' , 'text': 'aa'}] , getqflist())
-
-  call setqflist([{'lnum': 10                       , 'end_lnum': -123 , 'bufnr': bufnr('Xfile1') , 'col': 666 , 'end_col': 222  , 'pattern': '' , 'valid': 1 , 'vcol': 0 , 'nr': -1 , 'type': '' , 'module': '' , 'text': 'aa'}] , 'r')
-  call assert_equal(1                               , line('$'))
-  call assert_equal(['Xfile1|10 col 666-222| aa']   , getline(1        , '$'))
-  call assert_equal([{'lnum': 10                    , 'end_lnum': -123 , 'bufnr': bufnr('Xfile1') , 'col': 666 , 'end_col': 222  , 'pattern': '' , 'valid': 1 , 'vcol': 0 , 'nr': -1 , 'type': '' , 'module': '' , 'text': 'aa'}] , getqflist())
-
-  call setqflist([{'lnum': 10                       , 'end_lnum': 6 , 'bufnr': bufnr('Xfile1') , 'col': 666 , 'end_col': 222  , 'pattern': '' , 'valid': 1 , 'vcol': 0 , 'nr': -1 , 'type': '' , 'module': '' , 'text': 'aa'}] , 'r')
-  call assert_equal(1                               , line('$'))
-  call assert_equal(['Xfile1|10-6 col 666-222| aa'] , getline(1        , '$'))
-  call assert_equal([{'lnum': 10                    , 'end_lnum': 6 , 'bufnr': bufnr('Xfile1') , 'col': 666 , 'end_col': 222  , 'pattern': '' , 'valid': 1 , 'vcol': 0 , 'nr': -1 , 'type': '' , 'module': '' , 'text': 'aa'}] , getqflist())
-  cclose
-endfunc
-
-" Test for very weird problem: autocommand causes a failure, resulting opening
-" the quickfix window to fail. This still splits the window, but otherwise
-" should not mess up buffers.
-func Test_quickfix_window_fails_to_open()
-  CheckScreendump
-
-  let lines =<< trim END
-      anything
-      try
-        anything
-      endtry
-  END
-  call writefile(lines, 'XquickfixFails')
-
-  let lines =<< trim END
-      split XquickfixFails
-      silent vimgrep anything %
-      normal o
-      au BufLeave * ++once source XquickfixFails
-      " This will trigger the autocommand, which causes an error, what follows
-      " is aborted but the window was already split.
-      silent! cwindow
-  END
-  call writefile(lines, 'XtestWinFails')
-  let buf = RunVimInTerminal('-S XtestWinFails', #{rows: 13})
-  call VerifyScreenDump(buf, 'Test_quickfix_window_fails', {})
-
-  " clean up
-  call term_sendkeys(buf, ":bwipe!\<CR>")
-  call term_wait(buf)
-  call StopVimInTerminal(buf)
-  call delete('XtestWinFails')
-  call delete('XquickfixFails')
-endfunc
-
-" Test for updating the quickfix buffer whenever the associated quickfix list
-" is changed.
-func Xqfbuf_update(cchar)
-  call s:setup_commands(a:cchar)
-
-  Xexpr "F1:1:line1"
-  Xopen
-  call assert_equal(['F1|1| line1'], getline(1, '$'))
-  call assert_equal(1, g:Xgetlist({'changedtick' : 0}).changedtick)
-
-  " Test setqflist() using the 'lines' key in 'what'
-  " add a new entry
-  call g:Xsetlist([], 'a', {'lines' : ['F2:2: line2']})
-  call assert_equal(['F1|1| line1', 'F2|2| line2'], getline(1, '$'))
-  call assert_equal(2, g:Xgetlist({'changedtick' : 0}).changedtick)
-  " replace all the entries with a single entry
-  call g:Xsetlist([], 'r', {'lines' : ['F3:3: line3']})
-  call assert_equal(['F3|3| line3'], getline(1, '$'))
-  call assert_equal(3, g:Xgetlist({'changedtick' : 0}).changedtick)
-  " remove all the entries
-  call g:Xsetlist([], 'r', {'lines' : []})
-  call assert_equal([''], getline(1, '$'))
-  call assert_equal(4, g:Xgetlist({'changedtick' : 0}).changedtick)
-  " add a new list
-  call g:Xsetlist([], ' ', {'lines' : ['F4:4: line4']})
-  call assert_equal(['F4|4| line4'], getline(1, '$'))
-  call assert_equal(1, g:Xgetlist({'changedtick' : 0}).changedtick)
-
-  " Test setqflist() using the 'items' key in 'what'
-  " add a new entry
-  call g:Xsetlist([], 'a', {'items' : [{'filename' : 'F5', 'lnum' : 5, 'text' : 'line5'}]})
-  call assert_equal(['F4|4| line4', 'F5|5| line5'], getline(1, '$'))
-  call assert_equal(2, g:Xgetlist({'changedtick' : 0}).changedtick)
-  " replace all the entries with a single entry
-  call g:Xsetlist([], 'r', {'items' : [{'filename' : 'F6', 'lnum' : 6, 'text' : 'line6'}]})
-  call assert_equal(['F6|6| line6'], getline(1, '$'))
-  call assert_equal(3, g:Xgetlist({'changedtick' : 0}).changedtick)
-  " remove all the entries
-  call g:Xsetlist([], 'r', {'items' : []})
-  call assert_equal([''], getline(1, '$'))
-  call assert_equal(4, g:Xgetlist({'changedtick' : 0}).changedtick)
-  " add a new list
-  call g:Xsetlist([], ' ', {'items' : [{'filename' : 'F7', 'lnum' : 7, 'text' : 'line7'}]})
-  call assert_equal(['F7|7| line7'], getline(1, '$'))
-  call assert_equal(1, g:Xgetlist({'changedtick' : 0}).changedtick)
-
-  call g:Xsetlist([], ' ', {})
-  call assert_equal([''], getline(1, '$'))
-  call assert_equal(1, g:Xgetlist({'changedtick' : 0}).changedtick)
-
-  Xclose
-endfunc
-
-func Test_qfbuf_update()
-  call Xqfbuf_update('c')
-  call Xqfbuf_update('l')
-endfunc
-
-" Test for the :vimgrep 'f' flag (fuzzy match)
-func Xvimgrep_fuzzy_match(cchar)
-  call s:setup_commands(a:cchar)
-
-  Xvimgrep /three one/f Xfile*
-  let l = g:Xgetlist()
-  call assert_equal(2, len(l))
-  call assert_equal(['Xfile1', 1, 9, 'one two three'],
-        \ [bufname(l[0].bufnr), l[0].lnum, l[0].col, l[0].text])
-  call assert_equal(['Xfile2', 2, 1, 'three one two'],
-        \ [bufname(l[1].bufnr), l[1].lnum, l[1].col, l[1].text])
-
-  Xvimgrep /the/f Xfile*
-  let l = g:Xgetlist()
-  call assert_equal(3, len(l))
-  call assert_equal(['Xfile1', 1, 9, 'one two three'],
-        \ [bufname(l[0].bufnr), l[0].lnum, l[0].col, l[0].text])
-  call assert_equal(['Xfile2', 2, 1, 'three one two'],
-        \ [bufname(l[1].bufnr), l[1].lnum, l[1].col, l[1].text])
-  call assert_equal(['Xfile2', 4, 4, 'aaathreeaaa'],
-        \ [bufname(l[2].bufnr), l[2].lnum, l[2].col, l[2].text])
-
-  Xvimgrep /aaa/fg Xfile*
-  let l = g:Xgetlist()
-  call assert_equal(4, len(l))
-  call assert_equal(['Xfile1', 2, 1, 'aaaaaa'],
-        \ [bufname(l[0].bufnr), l[0].lnum, l[0].col, l[0].text])
-  call assert_equal(['Xfile1', 2, 4, 'aaaaaa'],
-        \ [bufname(l[1].bufnr), l[1].lnum, l[1].col, l[1].text])
-  call assert_equal(['Xfile2', 4, 1, 'aaathreeaaa'],
-        \ [bufname(l[2].bufnr), l[2].lnum, l[2].col, l[2].text])
-  call assert_equal(['Xfile2', 4, 9, 'aaathreeaaa'],
-        \ [bufname(l[3].bufnr), l[3].lnum, l[3].col, l[3].text])
-
-  call assert_fails('Xvimgrep /xyz/fg Xfile*', 'E480:')
-endfunc
-
-func Test_vimgrep_fuzzy_match()
-  call writefile(['one two three', 'aaaaaa'], 'Xfile1')
-  call writefile(['one', 'three one two', 'two', 'aaathreeaaa'], 'Xfile2')
-  call Xvimgrep_fuzzy_match('c')
-  call Xvimgrep_fuzzy_match('l')
-  call delete('Xfile1')
-  call delete('Xfile2')
-endfunc
-
-" Test for getting a specific item from a quickfix list
-func Xtest_getqflist_by_idx(cchar)
-  call s:setup_commands(a:cchar)
-  " Empty list
-  call assert_equal([], g:Xgetlist({'idx' : 1, 'items' : 0}).items)
-  Xexpr ['F1:10:L10', 'F1:20:L20']
-  let l = g:Xgetlist({'idx' : 2, 'items' : 0}).items
-  call assert_equal(bufnr('F1'), l[0].bufnr)
-  call assert_equal(20, l[0].lnum)
-  call assert_equal('L20', l[0].text)
-  call assert_equal([], g:Xgetlist({'idx' : -1, 'items' : 0}).items)
-  call assert_equal([], g:Xgetlist({'idx' : 3, 'items' : 0}).items)
-  call assert_equal({}, g:Xgetlist(#{idx: "abc"}))
-  %bwipe!
-endfunc
-
-func Test_getqflist_by_idx()
-  call Xtest_getqflist_by_idx('c')
-  call Xtest_getqflist_by_idx('l')
-endfunc
-
-" Test for the 'quickfixtextfunc' setting
-func Tqfexpr(info)
-  if a:info.quickfix
-    let qfl = getqflist({'id' : a:info.id, 'items' : 1}).items
-  else
-    let qfl = getloclist(a:info.winid, {'id' : a:info.id, 'items' : 1}).items
-  endif
-
-
-  let l = []
-  for idx in range(a:info.start_idx - 1, a:info.end_idx - 1)
-    let e = qfl[idx]
-    let s = ''
-    if e.bufnr != 0
-      let bname = bufname(e.bufnr)
-      let s ..= fnamemodify(bname, ':.')
-    endif
-    let s ..= '-'
-    let s ..= 'L' .. string(e.lnum) .. 'C' .. string(e.col) .. '-'
-    let s ..= e.text
-    call add(l, s)
-  endfor
-
-  return l
-endfunc
-
-func Xtest_qftextfunc(cchar)
-  call s:setup_commands(a:cchar)
-
-  set efm=%f:%l:%c:%m
-  set quickfixtextfunc=Tqfexpr
-  call assert_equal('Tqfexpr', &quickfixtextfunc)
-  call assert_equal('',
-        \ g:Xgetlist({'quickfixtextfunc' : 1}).quickfixtextfunc)
-  call g:Xsetlist([
-        \ { 'filename': 'F1', 'lnum': 10, 'col': 2,
-        \   'end_col': 7, 'text': 'green'},
-        \ { 'filename': 'F1', 'lnum': 20, 'end_lnum': 25, 'col': 4,
-        \   'end_col': 8, 'text': 'blue'},
-        \ ])
-
-  Xwindow
-  call assert_equal('F1-L10C2-green', getline(1))
-  call assert_equal('F1-L20C4-blue', getline(2))
-  Xclose
-  set quickfixtextfunc&vim
-  Xwindow
-  call assert_equal('F1|10 col 2-7| green', getline(1))
-  call assert_equal('F1|20-25 col 4-8| blue', getline(2))
-  Xclose
-
-  set efm=%f:%l:%c:%m
-  set quickfixtextfunc=Tqfexpr
-  " Update the list with only the cwindow
-  Xwindow
-  only
-  call g:Xsetlist([
-        \ { 'filename': 'F2', 'lnum': 20, 'col': 2,
-        \   'end_col': 7, 'text': 'red'}
-        \ ])
-  call assert_equal(['F2-L20C2-red'], getline(1, '$'))
-  new
-  Xclose
-  set efm&
-  set quickfixtextfunc&
-
-  " Test for per list 'quickfixtextfunc' setting
-  func PerQfText(info)
-    if a:info.quickfix
-      let qfl = getqflist({'id' : a:info.id, 'items' : 1}).items
-    else
-      let qfl = getloclist(a:info.winid, {'id' : a:info.id, 'items' : 1}).items
-    endif
-    if empty(qfl)
-      return []
-    endif
-    let l = []
-    for idx in range(a:info.start_idx - 1, a:info.end_idx - 1)
-      call add(l, 'Line ' .. qfl[idx].lnum .. ', Col ' .. qfl[idx].col)
-    endfor
-    return l
-  endfunc
-  set quickfixtextfunc=Tqfexpr
-  call g:Xsetlist([], ' ', {'quickfixtextfunc' : "PerQfText"})
-  Xaddexpr ['F1:10:2:green', 'F1:20:4:blue']
-  Xwindow
-  call assert_equal('Line 10, Col 2', getline(1))
-  call assert_equal('Line 20, Col 4', getline(2))
-  Xclose
-  call assert_equal(function('PerQfText'),
-        \ g:Xgetlist({'quickfixtextfunc' : 1}).quickfixtextfunc)
-  " Add entries to the list when the quickfix buffer is hidden
-  Xaddexpr ['F1:30:6:red']
-  Xwindow
-  call assert_equal('Line 30, Col 6', getline(3))
-  Xclose
-  call g:Xsetlist([], 'r', {'quickfixtextfunc' : ''})
-  call assert_equal('', g:Xgetlist({'quickfixtextfunc' : 1}).quickfixtextfunc)
-  set quickfixtextfunc&
-  delfunc PerQfText
-
-  " Non-existing function
-  set quickfixtextfunc=Tabc
-  call assert_fails("Xexpr ['F1:10:2:green', 'F1:20:4:blue']", 'E117:')
-  call assert_fails("Xwindow", 'E117:')
-  Xclose
-  set quickfixtextfunc&
-
-  " set option to a non-function
-  set quickfixtextfunc=[10,\ 20]
-  call assert_fails("Xexpr ['F1:10:2:green', 'F1:20:4:blue']", 'E117:')
-  call assert_fails("Xwindow", 'E117:')
-  Xclose
-  set quickfixtextfunc&
-
-  " set option to a function with different set of arguments
-  func Xqftext(a, b, c)
-    return a:a .. a:b .. a:c
-  endfunc
-  set quickfixtextfunc=Xqftext
-  call assert_fails("Xexpr ['F1:10:2:green', 'F1:20:4:blue']", 'E119:')
-  call assert_fails("Xwindow", 'E119:')
-  Xclose
-
-  " set option to a function that returns a list with non-strings
-  func Xqftext2(d)
-    return ['one', [], 'two']
-  endfunc
-  set quickfixtextfunc=Xqftext2
-  call assert_fails("Xexpr ['F1:10:2:green', 'F1:20:4:blue', 'F1:30:6:red']",
-                                                                  \ 'E730:')
-  call assert_fails('Xwindow', 'E730:')
-  call assert_equal(['one', 'F1|20 col 4| blue', 'F1|30 col 6| red'],
-        \ getline(1, '$'))
-  Xclose
-
-  set quickfixtextfunc&
-  delfunc Xqftext
-  delfunc Xqftext2
-
-  " set the global option to a lambda function
-  set quickfixtextfunc={d\ ->\ map(g:Xgetlist({'id'\ :\ d.id,\ 'items'\ :\ 1}).items[d.start_idx-1:d.end_idx-1],\ 'v:val.text')}
-  Xexpr ['F1:10:2:green', 'F1:20:4:blue']
-  Xwindow
-  call assert_equal(['green', 'blue'], getline(1, '$'))
-  Xclose
-  call assert_equal("{d -> map(g:Xgetlist({'id' : d.id, 'items' : 1}).items[d.start_idx-1:d.end_idx-1], 'v:val.text')}", &quickfixtextfunc)
-  set quickfixtextfunc&
-
-  " use a lambda function that returns an empty list
-  set quickfixtextfunc={d\ ->\ []}
-  Xexpr ['F1:10:2:green', 'F1:20:4:blue']
-  Xwindow
-  call assert_equal(['F1|10 col 2| green', 'F1|20 col 4| blue'],
-        \ getline(1, '$'))
-  Xclose
-  set quickfixtextfunc&
-
-  " use a lambda function that returns a list with empty strings
-  set quickfixtextfunc={d\ ->\ ['',\ '']}
-  Xexpr ['F1:10:2:green', 'F1:20:4:blue']
-  Xwindow
-  call assert_equal(['F1|10 col 2| green', 'F1|20 col 4| blue'],
-        \ getline(1, '$'))
-  Xclose
-  set quickfixtextfunc&
-
-  " set the per-quickfix list text function to a lambda function
-  call g:Xsetlist([], ' ',
-        \ {'quickfixtextfunc' :
-        \   {d -> map(g:Xgetlist({'id' : d.id, 'items' : 1}).items[d.start_idx-1:d.end_idx-1],
-        \ "'Line ' .. v:val.lnum .. ', Col ' .. v:val.col")}})
-  Xaddexpr ['F1:10:2:green', 'F1:20:4:blue']
-  Xwindow
-  call assert_equal('Line 10, Col 2', getline(1))
-  call assert_equal('Line 20, Col 4', getline(2))
-  Xclose
-  call assert_match("function('<lambda>\\d\\+')", string(g:Xgetlist({'quickfixtextfunc' : 1}).quickfixtextfunc))
-  call g:Xsetlist([], 'f')
-endfunc
-
-func Test_qftextfunc()
-  call Xtest_qftextfunc('c')
-  call Xtest_qftextfunc('l')
-endfunc
-
-func Test_qftextfunc_callback()
-  let lines =<< trim END
-    set efm=%f:%l:%c:%m
-
-    #" Test for using a function name
-    LET &qftf = 'g:Tqfexpr'
-    cexpr "F0:0:0:L0"
-    copen
-    call assert_equal('F0-L0C0-L0', getline(1))
-    cclose
-
-    #" Test for using a function()
-    set qftf=function('g:Tqfexpr')
-    cexpr "F1:1:1:L1"
-    copen
-    call assert_equal('F1-L1C1-L1', getline(1))
-    cclose
-
-    #" Using a funcref variable to set 'quickfixtextfunc'
-    VAR Fn = function('g:Tqfexpr')
-    LET &qftf = Fn
-    cexpr "F2:2:2:L2"
-    copen
-    call assert_equal('F2-L2C2-L2', getline(1))
-    cclose
-
-    #" Using string(funcref_variable) to set 'quickfixtextfunc'
-    LET Fn = function('g:Tqfexpr')
-    LET &qftf = string(Fn)
-    cexpr "F3:3:3:L3"
-    copen
-    call assert_equal('F3-L3C3-L3', getline(1))
-    cclose
-
-    #" Test for using a funcref()
-    set qftf=funcref('g:Tqfexpr')
-    cexpr "F4:4:4:L4"
-    copen
-    call assert_equal('F4-L4C4-L4', getline(1))
-    cclose
-
-    #" Using a funcref variable to set 'quickfixtextfunc'
-    LET Fn = funcref('g:Tqfexpr')
-    LET &qftf = Fn
-    cexpr "F5:5:5:L5"
-    copen
-    call assert_equal('F5-L5C5-L5', getline(1))
-    cclose
-
-    #" Using a string(funcref_variable) to set 'quickfixtextfunc'
-    LET Fn = funcref('g:Tqfexpr')
-    LET &qftf = string(Fn)
-    cexpr "F5:5:5:L5"
-    copen
-    call assert_equal('F5-L5C5-L5', getline(1))
-    cclose
-
-    #" Test for using a lambda function with set
-    VAR optval = "LSTART a LMIDDLE Tqfexpr(a) LEND"
-    LET optval = substitute(optval, ' ', '\\ ', 'g')
-    exe "set qftf=" .. optval
-    cexpr "F6:6:6:L6"
-    copen
-    call assert_equal('F6-L6C6-L6', getline(1))
-    cclose
-
-    #" Set 'quickfixtextfunc' to a lambda expression
-    LET &qftf = LSTART a LMIDDLE Tqfexpr(a) LEND
-    cexpr "F7:7:7:L7"
-    copen
-    call assert_equal('F7-L7C7-L7', getline(1))
-    cclose
-
-    #" Set 'quickfixtextfunc' to string(lambda_expression)
-    LET &qftf = "LSTART a LMIDDLE Tqfexpr(a) LEND"
-    cexpr "F8:8:8:L8"
-    copen
-    call assert_equal('F8-L8C8-L8', getline(1))
-    cclose
-
-    #" Set 'quickfixtextfunc' to a variable with a lambda expression
-    VAR Lambda = LSTART a LMIDDLE Tqfexpr(a) LEND
-    LET &qftf = Lambda
-    cexpr "F9:9:9:L9"
-    copen
-    call assert_equal('F9-L9C9-L9', getline(1))
-    cclose
-
-    #" Set 'quickfixtextfunc' to a string(variable with a lambda expression)
-    LET Lambda = LSTART a LMIDDLE Tqfexpr(a) LEND
-    LET &qftf = string(Lambda)
-    cexpr "F9:9:9:L9"
-    copen
-    call assert_equal('F9-L9C9-L9', getline(1))
-    cclose
-  END
-  call CheckLegacyAndVim9Success(lines)
-
-  " Test for using a script-local function name
-  func s:TqfFunc2(info)
-    let g:TqfFunc2Args = [a:info.start_idx, a:info.end_idx]
-    return ''
-  endfunc
-  let g:TqfFunc2Args = []
-  set quickfixtextfunc=s:TqfFunc2
-  cexpr "F10:10:10:L10"
-  cclose
-  call assert_equal([1, 1], g:TqfFunc2Args)
-
-  let &quickfixtextfunc = 's:TqfFunc2'
-  cexpr "F11:11:11:L11"
-  cclose
-  call assert_equal([1, 1], g:TqfFunc2Args)
-  delfunc s:TqfFunc2
-
-  " set 'quickfixtextfunc' to a partial with dict. This used to cause a crash.
-  func SetQftfFunc()
-    let params = {'qftf': function('g:DictQftfFunc')}
-    let &quickfixtextfunc = params.qftf
-  endfunc
-  func g:DictQftfFunc(_) dict
-  endfunc
-  call SetQftfFunc()
-  new
-  call SetQftfFunc()
-  bw
-  call test_garbagecollect_now()
-  new
-  set qftf=
-  wincmd w
-  set qftf=
-  :%bw!
-
-  " set per-quickfix list 'quickfixtextfunc' to a partial with dict. This used
-  " to cause a crash.
-  let &qftf = ''
-  func SetLocalQftfFunc()
-    let params = {'qftf': function('g:DictQftfFunc')}
-    call setqflist([], 'a', {'quickfixtextfunc' : params.qftf})
-  endfunc
-  call SetLocalQftfFunc()
-  call test_garbagecollect_now()
-  call setqflist([], 'a', {'quickfixtextfunc' : ''})
-  delfunc g:DictQftfFunc
-  delfunc SetQftfFunc
-  delfunc SetLocalQftfFunc
-  set efm&
-endfunc
-
-" Test for updating a location list for some other window and check that
-" 'qftextfunc' uses the correct location list.
-func Test_qftextfunc_other_loclist()
-  %bw!
-  call setloclist(0, [], 'f')
-
-  " create a window and a location list for it and open the location list
-  " window
-  lexpr ['F1:10:12:one', 'F1:20:14:two']
-  let w1_id = win_getid()
-  call setloclist(0, [], ' ',
-        \ {'lines': ['F1:10:12:one', 'F1:20:14:two'],
-        \  'quickfixtextfunc':
-        \    {d -> map(getloclist(d.winid, {'id' : d.id,
-        \                'items' : 1}).items[d.start_idx-1:d.end_idx-1],
-        \          "'Line ' .. v:val.lnum .. ', Col ' .. v:val.col")}})
-  lwindow
-  let w2_id = win_getid()
-
-  " create another window and a location list for it and open the location
-  " list window
-  topleft new
-  let w3_id = win_getid()
-  call setloclist(0, [], ' ',
-        \ {'lines': ['F2:30:32:eleven', 'F2:40:34:twelve'],
-        \  'quickfixtextfunc':
-        \    {d -> map(getloclist(d.winid, {'id' : d.id,
-        \                'items' : 1}).items[d.start_idx-1:d.end_idx-1],
-        \          "'Ligne ' .. v:val.lnum .. ', Colonne ' .. v:val.col")}})
-  lwindow
-  let w4_id = win_getid()
-
-  topleft new
-  lexpr ['F3:50:52:green', 'F3:60:54:blue']
-  let w5_id = win_getid()
-
-  " change the location list for some other window
-  call setloclist(0, [], 'r', {'lines': ['F3:55:56:aaa', 'F3:57:58:bbb']})
-  call setloclist(w1_id, [], 'r', {'lines': ['F1:62:63:bbb', 'F1:64:65:ccc']})
-  call setloclist(w3_id, [], 'r', {'lines': ['F2:76:77:ddd', 'F2:78:79:eee']})
-  call assert_equal(['Line 62, Col 63', 'Line 64, Col 65'],
-        \ getbufline(winbufnr(w2_id), 1, '$'))
-  call assert_equal(['Ligne 76, Colonne 77', 'Ligne 78, Colonne 79'],
-        \ getbufline(winbufnr(w4_id), 1, '$'))
-  call setloclist(w2_id, [], 'r', {'lines': ['F1:32:33:fff', 'F1:34:35:ggg']})
-  call setloclist(w4_id, [], 'r', {'lines': ['F2:46:47:hhh', 'F2:48:49:jjj']})
-  call assert_equal(['Line 32, Col 33', 'Line 34, Col 35'],
-        \ getbufline(winbufnr(w2_id), 1, '$'))
-  call assert_equal(['Ligne 46, Colonne 47', 'Ligne 48, Colonne 49'],
-        \ getbufline(winbufnr(w4_id), 1, '$'))
-
-  call win_gotoid(w5_id)
-  lwindow
-  call assert_equal(['F3|55 col 56| aaa', 'F3|57 col 58| bbb'],
-        \ getline(1, '$'))
-  %bw!
-endfunc
-
-func Test_locationlist_open_in_newtab()
-  call s:create_test_file('Xqftestfile1')
-  call s:create_test_file('Xqftestfile2')
-  call s:create_test_file('Xqftestfile3')
-
-  %bwipe!
-
-  let lines =<< trim END
-    Xqftestfile1:5:Line5
-    Xqftestfile2:10:Line10
-    Xqftestfile3:16:Line16
-  END
-  lgetexpr lines
-
-  silent! llast
-  call assert_equal(1, tabpagenr('$'))
-  call assert_equal('Xqftestfile3', bufname())
-
-  set switchbuf=newtab
-
-  silent! lfirst
-  call assert_equal(2, tabpagenr('$'))
-  call assert_equal('Xqftestfile1', bufname())
-
-  silent! lnext
-  call assert_equal(3, tabpagenr('$'))
-  call assert_equal('Xqftestfile2', bufname())
-
-  call delete('Xqftestfile1')
-  call delete('Xqftestfile2')
-  call delete('Xqftestfile3')
-  set switchbuf&vim
-
-  %bwipe!
-endfunc
-
-" Test for win_gettype() in quickfix and location list windows
-func Test_win_gettype()
-  copen
-  call assert_equal("quickfix", win_gettype())
-  let wid = win_getid()
-  wincmd p
-  call assert_equal("quickfix", win_gettype(wid))
-  cclose
-  lexpr ''
-  lopen
-  call assert_equal("loclist", win_gettype())
-  let wid = win_getid()
-  wincmd p
-  call assert_equal("loclist", win_gettype(wid))
-  lclose
-endfunc
-
-fun Test_vimgrep_nomatch()
-  call XexprTests('c')
-  call g:Xsetlist([{'lnum':10,'text':'Line1'}])
-  copen
-  if has("win32")
-    call assert_fails('vimgrep foo *.zzz', 'E479:')
-    let expected = [{'lnum': 10, 'bufnr': 0, 'end_lnum': 0, 'pattern': '', 'valid': 0, 'vcol': 0, 'nr': 0, 'module': '', 'type': '', 'end_col': 0, 'col': 0, 'text': 'Line1'}]
-  else
-    call assert_fails('vimgrep foo *.zzz', 'E480:')
-    let expected = []
-  endif
-  call assert_equal(expected, getqflist())
-  cclose
-endfunc
-
-" Test for opening the quickfix window in two tab pages and then closing one
-" of the quickfix windows. This should not make the quickfix buffer unlisted.
-" (github issue #9300).
-func Test_two_qf_windows()
-  cexpr "F1:1:line1"
-  copen
-  tabnew
-  copen
-  call assert_true(&buflisted)
-  cclose
-  tabfirst
-  call assert_true(&buflisted)
-  let bnum = bufnr()
-  cclose
-  " if all the quickfix windows are closed, then buffer should be unlisted.
-  call assert_false(buflisted(bnum))
-  %bw!
-
-  " Repeat the test for a location list
-  lexpr "F2:2:line2"
-  lopen
-  let bnum = bufnr()
-  tabnew
-  exe "buffer" bnum
-  tabfirst
-  lclose
-  tablast
-  call assert_true(buflisted(bnum))
-  tabclose
-  lopen
-  call assert_true(buflisted(bnum))
-  lclose
-  call assert_false(buflisted(bnum))
-  %bw!
-endfunc
-
-" Weird sequence of commands that caused entering a wiped-out buffer
-func Test_lopen_bwipe()
-  func R()
-    silent! tab lopen
-    e x
-    silent! lfile
-  endfunc
-
-  cal R()
-  cal R()
-  cal R()
-  bw!
-  delfunc R
-endfunc
-
-" Another sequence of commands that caused all buffers to be wiped out
-func Test_lopen_bwipe_all()
-  let lines =<< trim END
-    func R()
-      silent! tab lopen
-      e foo
-      silent! lfile
-    endfunc
-    cal R()
-    exe "norm \<C-W>\<C-V>0"
-    cal R()
-    bwipe
-
-    call writefile(['done'], 'Xresult')
-    qall!
-  END
-  call writefile(lines, 'Xscript')
-  if RunVim([], [], '-u NONE -n -X -Z -e -m -s -S Xscript')
-    call assert_equal(['done'], readfile('Xresult'))
-  endif
-
-  call delete('Xscript')
-  call delete('Xresult')
-endfunc
-
-" Test for calling setqflist() function recursively
-func Test_recursive_setqflist()
-  augroup QF_Test
-    au!
-    autocmd BufWinEnter quickfix call setqflist([], 'r')
-  augroup END
-
-  copen
-  call assert_fails("call setqflist([], 'a')", 'E952:')
-
-  augroup QF_Test
-    au!
-  augroup END
-  %bw!
-endfunc
-
-" Test for failure to create a new window when selecting a file from the
-" quickfix window
-func Test_cwindow_newwin_fails()
-  cgetexpr ["Xfile1:10:L10", "Xfile1:20:L20"]
-  cwindow
-  only
-  let qf_wid = win_getid()
-  " create the maximum number of scratch windows
-  let hor_win_count = (&lines - 1)/2
-  let hor_split_count = hor_win_count - 1
-  for s in range(1, hor_split_count) | new | set buftype=nofile | endfor
-  call win_gotoid(qf_wid)
-  call assert_fails('exe "normal \<CR>"', 'E36:')
-  %bw!
-endfunc
-
-" Test for updating the location list when only the location list window is
-" present and the corresponding file window is closed.
-func Test_loclist_update_with_llwin_only()
-  %bw!
-  new
-  wincmd w
-  lexpr ["Xfile1:1:Line1"]
-  lopen
-  wincmd p
-  close
-  call setloclist(2, [], 'r', {'lines': ["Xtest2:2:Line2"]})
-  call assert_equal(['Xtest2|2| Line2'], getbufline(winbufnr(2), 1, '$'))
-  %bw!
-endfunc
-
-" Test for getting the quickfix list after a buffer with an error is wiped out
-func Test_getqflist_wiped_out_buffer()
-  %bw!
-  cexpr ["Xtest1:34:Wiped out"]
-  let bnum = bufnr('Xtest1')
-  call assert_equal(bnum, getqflist()[0].bufnr)
-  bw Xtest1
-  call assert_equal(0, getqflist()[0].bufnr)
-  %bw!
-endfunc
-
-" Test for the status message that is displayed when opening a new quickfix
-" list
-func Test_qflist_statusmsg()
-  cexpr "1\n2"
-  cexpr "1\n2\n3\ntest_quickfix.vim:1:msg"
-  call assert_equal('(4 of 4): msg', v:statusmsg)
-  call setqflist([], 'f')
-  %bw!
-
-  " When creating a new quickfix list, if an autocmd changes the quickfix list
-  " in the stack, then an error message should be displayed.
-  augroup QF_Test
-    au!
-    au BufEnter test_quickfix.vim colder
-  augroup END
-  cexpr "1\n2"
-  call assert_fails('cexpr "1\n2\n3\ntest_quickfix.vim:1:msg"', 'E925:')
-  call setqflist([], 'f')
-  augroup QF_Test
-    au!
-  augroup END
-  %bw!
-
-  augroup QF_Test
-    au!
-    au BufEnter test_quickfix.vim caddexpr "4"
-  augroup END
-  call assert_fails('cexpr "1\n2\n3\ntest_quickfix.vim:1:msg"', 'E925:')
-  call setqflist([], 'f')
-  augroup QF_Test
-    au!
-  augroup END
-  %bw!
-endfunc
-
-func Test_quickfixtextfunc_recursive()
-  func s:QFTfunc(o)
-    cgete '0'
-  endfunc
-  copen
-  let &quickfixtextfunc = 's:QFTfunc'
-  cex ""
-
-  let &quickfixtextfunc = ''
-  cclose
-endfunc
-
-" Test for replacing the location list from an autocmd. This used to cause a
-" read from freed memory.
-func Test_loclist_replace_autocmd()
-  %bw!
-  call setloclist(0, [], 'f')
-  let s:bufnr = bufnr()
-  cal setloclist(0, [{'0': 0, '': ''}])
-  au BufEnter * cal setloclist(1, [{'t': ''}, {'bufnr': s:bufnr}], 'r')
-  lopen
-  try
-    exe "norm j\<CR>"
-  catch
-  endtry
-  lnext
-  %bw!
-  call setloclist(0, [], 'f')
-endfunc
-
-func s:QfTf(_)
-endfunc
-
-func Test_setqflist_cb_arg()
-  " This was changing the callback name in the dictionary.
-  let d = #{quickfixtextfunc: 's:QfTf'}
-  call setqflist([], 'a', d)
-  call assert_equal('s:QfTf', d.quickfixtextfunc)
-
-  call setqflist([], 'f')
-endfunc
-
-
-" vim: shiftwidth=2 sts=2 expandtab