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

1 files changed, 0 insertions, 7284 deletions

diff --git a/src/nvim/testdir/test_vimscript.vim b/src/nvim/testdir/test_vimscript.vim
deleted file mode 100644
index b0c4baf7c2..0000000000
--- a/src/nvim/testdir/test_vimscript.vim
+++ /dev/null
@@ -1,7284 +0,0 @@
-" Test various aspects of the Vim script language.
-" Most of this was formerly in test49.vim (developed by Servatius Brandt
-" <Servatius.Brandt@fujitsu-siemens.com>)
-
-source check.vim
-source shared.vim
-source script_util.vim
-
-"-------------------------------------------------------------------------------
-" Test environment							    {{{1
-"-------------------------------------------------------------------------------
-
-" Append a message to the "messages" file
-func Xout(text)
-    split messages
-    $put =a:text
-    wq
-endfunc
-
-com! -nargs=1	     Xout     call Xout(<args>)
-
-" Create a new instance of Vim and run the commands in 'test' and then 'verify'
-" The commands in 'test' are expected to store the test results in the Xtest.out
-" file. If the test passes successfully, then Xtest.out should be empty.
-func RunInNewVim(test, verify)
-  let init =<< trim END
-    set cpo-=C            " support line-continuation in sourced script
-    source script_util.vim
-    XpathINIT
-    XloopINIT
-  END
-  let cleanup =<< trim END
-    call writefile(v:errors, 'Xtest.out')
-    qall
-  END
-  call writefile(init, 'Xtest.vim')
-  call writefile(a:test, 'Xtest.vim', 'a')
-  call writefile(a:verify, 'Xverify.vim')
-  call writefile(cleanup, 'Xverify.vim', 'a')
-  call RunVim([], [], "-S Xtest.vim -S Xverify.vim")
-  call assert_equal([], readfile('Xtest.out'))
-  call delete('Xtest.out')
-  call delete('Xtest.vim')
-  call delete('Xverify.vim')
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 1:   :endwhile in function					    {{{1
-"
-"	    Detect if a broken loop is (incorrectly) reactivated by the
-"	    :endwhile.  Use a :return to prevent an endless loop, and make
-"	    this test first to get a meaningful result on an error before other
-"	    tests will hang.
-"-------------------------------------------------------------------------------
-
-func T1_F()
-    Xpath 'a'
-    let first = 1
-    while 1
-	Xpath 'b'
-	if first
-	    Xpath 'c'
-	    let first = 0
-	    break
-	else
-	    Xpath 'd'
-	    return
-	endif
-    endwhile
-endfunc
-
-func T1_G()
-    Xpath 'h'
-    let first = 1
-    while 1
-	Xpath 'i'
-	if first
-	    Xpath 'j'
-	    let first = 0
-	    break
-	else
-	    Xpath 'k'
-	    return
-	endif
-	if 1	" unmatched :if
-    endwhile
-endfunc
-
-func Test_endwhile_function()
-  XpathINIT
-  call T1_F()
-  Xpath 'F'
-
-  try
-    call T1_G()
-  catch
-    " Catch missing :endif
-    call assert_true(v:exception =~ 'E171')
-    Xpath 'x'
-  endtry
-  Xpath 'G'
-
-  call assert_equal('abcFhijxG', g:Xpath)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 2:   :endwhile in script						    {{{1
-"
-"	    Detect if a broken loop is (incorrectly) reactivated by the
-"	    :endwhile.  Use a :finish to prevent an endless loop, and place
-"	    this test before others that might hang to get a meaningful result
-"	    on an error.
-"
-"	    This test executes the bodies of the functions T1_F and T1_G from
-"	    the previous test as script files (:return replaced by :finish).
-"-------------------------------------------------------------------------------
-
-func Test_endwhile_script()
-  XpathINIT
-  ExecAsScript T1_F
-  Xpath 'F'
-  call DeleteTheScript()
-
-  try
-    ExecAsScript T1_G
-  catch
-    " Catch missing :endif
-    call assert_true(v:exception =~ 'E171')
-    Xpath 'x'
-  endtry
-  Xpath 'G'
-  call DeleteTheScript()
-
-  call assert_equal('abcFhijxG', g:Xpath)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 3:   :if, :elseif, :while, :continue, :break			    {{{1
-"-------------------------------------------------------------------------------
-
-func Test_if_while()
-    XpathINIT
-    if 1
-	Xpath 'a'
-	let loops = 3
-	while loops > -1	    " main loop: loops == 3, 2, 1 (which breaks)
-	    if loops <= 0
-		let break_err = 1
-		let loops = -1
-	    else
-		Xpath 'b' . loops
-	    endif
-	    if (loops == 2)
-		while loops == 2 " dummy loop
-		    Xpath 'c' . loops
-		    let loops = loops - 1
-		    continue    " stop dummy loop
-		    Xpath 'd' . loops
-		endwhile
-		continue	    " continue main loop
-		Xpath 'e' . loops
-	    elseif (loops == 1)
-		let p = 1
-		while p	    " dummy loop
-		    Xpath 'f' . loops
-		    let p = 0
-		    break	    " break dummy loop
-		    Xpath 'g' . loops
-		endwhile
-		Xpath 'h' . loops
-		unlet p
-		break	    " break main loop
-		Xpath 'i' . loops
-	    endif
-	    if (loops > 0)
-		Xpath 'j' . loops
-	    endif
-	    while loops == 3    " dummy loop
-		let loops = loops - 1
-	    endwhile	    " end dummy loop
-	endwhile		    " end main loop
-	Xpath 'k'
-    else
-	Xpath 'l'
-    endif
-    Xpath 'm'
-    if exists("break_err")
-	Xpath 'm'
-	unlet break_err
-    endif
-
-    unlet loops
-
-    call assert_equal('ab3j3b2c2b1f1h1km', g:Xpath)
-endfunc
-
-" Check double quote after skipped "elseif" does not give error E15
-func Test_skipped_elseif()
-  if "foo" ==? "foo"
-      let result = "first"
-  elseif "foo" ==? "foo"
-      let result = "second"
-  endif
-  call assert_equal('first', result)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 4:   :return							    {{{1
-"-------------------------------------------------------------------------------
-
-func T4_F()
-    if 1
-	Xpath 'a'
-	let loops = 3
-	while loops > 0				"    3:  2:     1:
-	    Xpath 'b' . loops
-	    if (loops == 2)
-		Xpath 'c' . loops
-		return
-		Xpath 'd' . loops
-	    endif
-	    Xpath 'e' . loops
-	    let loops = loops - 1
-	endwhile
-	Xpath 'f'
-    else
-	Xpath 'g'
-    endif
-endfunc
-
-func Test_return()
-    XpathINIT
-    call T4_F()
-    Xpath '4'
-
-    call assert_equal('ab3e3b2c24', g:Xpath)
-endfunc
-
-
-"-------------------------------------------------------------------------------
-" Test 5:   :finish							    {{{1
-"
-"	    This test executes the body of the function T4_F from the previous
-"	    test as a script file (:return replaced by :finish).
-"-------------------------------------------------------------------------------
-
-func Test_finish()
-    XpathINIT
-    ExecAsScript T4_F
-    Xpath '5'
-    call DeleteTheScript()
-
-    call assert_equal('ab3e3b2c25', g:Xpath)
-endfunc
-
-
-
-"-------------------------------------------------------------------------------
-" Test 6:   Defining functions in :while loops				    {{{1
-"
-"	     Functions can be defined inside other functions.  An inner function
-"	     gets defined when the outer function is executed.  Functions may
-"	     also be defined inside while loops.  Expressions in braces for
-"	     defining the function name are allowed.
-"
-"	     The functions are defined when sourcing the script, only the
-"	     resulting path is checked in the test function.
-"-------------------------------------------------------------------------------
-
-XpathINIT
-
-" The command CALL collects the argument of all its invocations in "calls"
-" when used from a function (that is, when the global variable "calls" needs
-" the "g:" prefix).  This is to check that the function code is skipped when
-" the function is defined.  For inner functions, do so only if the outer
-" function is not being executed.
-"
-let calls = ""
-com! -nargs=1 CALL
-	    \ if !exists("calls") && !exists("outer") |
-	    \ let g:calls = g:calls . <args> |
-	    \ endif
-
-let i = 0
-while i < 3
-    let i = i + 1
-    if i == 1
-	Xpath 'a'
-	function! F1(arg)
-	    CALL a:arg
-	    let outer = 1
-
-	    let j = 0
-	    while j < 1
-		Xpath 'b'
-		let j = j + 1
-		function! G1(arg)
-		    CALL a:arg
-		endfunction
-		Xpath 'c'
-	    endwhile
-	endfunction
-	Xpath 'd'
-
-	continue
-    endif
-
-    Xpath 'e' . i
-    function! F{i}(i, arg)
-	CALL a:arg
-	let outer = 1
-
-	if a:i == 3
-	    Xpath 'f'
-	endif
-	let k = 0
-	while k < 3
-	    Xpath 'g' . k
-	    let k = k + 1
-	    function! G{a:i}{k}(arg)
-		CALL a:arg
-	    endfunction
-	    Xpath 'h' . k
-	endwhile
-    endfunction
-    Xpath 'i'
-
-endwhile
-
-if exists("*G1")
-    Xpath 'j'
-endif
-if exists("*F1")
-    call F1("F1")
-    if exists("*G1")
-       call G1("G1")
-    endif
-endif
-
-if exists("G21") || exists("G22") || exists("G23")
-    Xpath 'k'
-endif
-if exists("*F2")
-    call F2(2, "F2")
-    if exists("*G21")
-       call G21("G21")
-    endif
-    if exists("*G22")
-       call G22("G22")
-    endif
-    if exists("*G23")
-       call G23("G23")
-    endif
-endif
-
-if exists("G31") || exists("G32") || exists("G33")
-    Xpath 'l'
-endif
-if exists("*F3")
-    call F3(3, "F3")
-    if exists("*G31")
-       call G31("G31")
-    endif
-    if exists("*G32")
-       call G32("G32")
-    endif
-    if exists("*G33")
-       call G33("G33")
-    endif
-endif
-
-Xpath 'm'
-
-let g:test6_result = g:Xpath
-let g:test6_calls = calls
-
-unlet calls
-delfunction F1
-delfunction G1
-delfunction F2
-delfunction G21
-delfunction G22
-delfunction G23
-delfunction G31
-delfunction G32
-delfunction G33
-
-func Test_defining_functions()
-    call assert_equal('ade2ie3ibcg0h1g1h2g2h3fg0h1g1h2g2h3m', g:test6_result)
-    call assert_equal('F1G1F2G21G22G23F3G31G32G33', g:test6_calls)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 7:   Continuing on errors outside functions			    {{{1
-"
-"	    On an error outside a function, the script processing continues
-"	    at the line following the outermost :endif or :endwhile.  When not
-"	    inside an :if or :while, the script processing continues at the next
-"	    line.
-"-------------------------------------------------------------------------------
-
-XpathINIT
-
-if 1
-    Xpath 'a'
-    while 1
-	Xpath 'b'
-	asdf
-	Xpath 'c'
-	break
-    endwhile | Xpath 'd'
-    Xpath 'e'
-endif | Xpath 'f'
-Xpath 'g'
-
-while 1
-    Xpath 'h'
-    if 1
-	Xpath 'i'
-	asdf
-	Xpath 'j'
-    endif | Xpath 'k'
-    Xpath 'l'
-    break
-endwhile | Xpath 'm'
-Xpath 'n'
-
-asdf
-Xpath 'o'
-
-asdf | Xpath 'p'
-Xpath 'q'
-
-let g:test7_result = g:Xpath
-
-func Test_error_in_script()
-    call assert_equal('abghinoq', g:test7_result)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 8:   Aborting and continuing on errors inside functions		    {{{1
-"
-"	    On an error inside a function without the "abort" attribute, the
-"	    script processing continues at the next line (unless the error was
-"	    in a :return command).  On an error inside a function with the
-"	    "abort" attribute, the function is aborted and the script processing
-"	    continues after the function call; the value -1 is returned then.
-"-------------------------------------------------------------------------------
-
-XpathINIT
-
-func T8_F()
-    if 1
-	Xpath 'a'
-	while 1
-	    Xpath 'b'
-	    asdf
-	    Xpath 'c'
-	    asdf | Xpath 'd'
-	    Xpath 'e'
-	    break
-	endwhile
-	Xpath 'f'
-    endif | Xpath 'g'
-    Xpath 'h'
-
-    while 1
-	Xpath 'i'
-	if 1
-	    Xpath 'j'
-	    asdf
-	    Xpath 'k'
-	    asdf | Xpath 'l'
-	    Xpath 'm'
-	endif
-	Xpath 'n'
-	break
-    endwhile | Xpath 'o'
-    Xpath 'p'
-
-    return novar		" returns (default return value 0)
-    Xpath 'q'
-    return 1			" not reached
-endfunc
-
-func T8_G() abort
-    if 1
-	Xpath 'r'
-	while 1
-	    Xpath 's'
-	    asdf		" returns -1
-	    Xpath 't'
-	    break
-	endwhile
-	Xpath 'v'
-    endif | Xpath 'w'
-    Xpath 'x'
-
-    return -4			" not reached
-endfunc
-
-func T8_H() abort
-    while 1
-	Xpath 'A'
-	if 1
-	    Xpath 'B'
-	    asdf		" returns -1
-	    Xpath 'C'
-	endif
-	Xpath 'D'
-	break
-    endwhile | Xpath 'E'
-    Xpath 'F'
-
-    return -4			" not reached
-endfunc
-
-" Aborted functions (T8_G and T8_H) return -1.
-let g:test8_sum = (T8_F() + 1) - 4 * T8_G() - 8 * T8_H()
-Xpath 'X'
-let g:test8_result = g:Xpath
-
-func Test_error_in_function()
-    call assert_equal(13, g:test8_sum)
-    call assert_equal('abcefghijkmnoprsABX', g:test8_result)
-
-    delfunction T8_F
-    delfunction T8_G
-    delfunction T8_H
-endfunc
-
-
-"-------------------------------------------------------------------------------
-" Test 9:   Continuing after aborted functions				    {{{1
-"
-"	    When a function with the "abort" attribute is aborted due to an
-"	    error, the next function back in the call hierarchy without an
-"	    "abort" attribute continues; the value -1 is returned then.
-"-------------------------------------------------------------------------------
-
-XpathINIT
-
-func F() abort
-    Xpath 'a'
-    let result = G()	" not aborted
-    Xpath 'b'
-    if result != 2
-	Xpath 'c'
-    endif
-    return 1
-endfunc
-
-func G()		" no abort attribute
-    Xpath 'd'
-    if H() != -1	" aborted
-	Xpath 'e'
-    endif
-    Xpath 'f'
-    return 2
-endfunc
-
-func H() abort
-    Xpath 'g'
-    call I()		" aborted
-    Xpath 'h'
-    return 4
-endfunc
-
-func I() abort
-    Xpath 'i'
-    asdf		" error
-    Xpath 'j'
-    return 8
-endfunc
-
-if F() != 1
-    Xpath 'k'
-endif
-
-let g:test9_result = g:Xpath
-
-delfunction F
-delfunction G
-delfunction H
-delfunction I
-
-func Test_func_abort()
-    call assert_equal('adgifb', g:test9_result)
-endfunc
-
-
-"-------------------------------------------------------------------------------
-" Test 10:  :if, :elseif, :while argument parsing			    {{{1
-"
-"	    A '"' or '|' in an argument expression must not be mixed up with
-"	    a comment or a next command after a bar.  Parsing errors should
-"	    be recognized.
-"-------------------------------------------------------------------------------
-
-XpathINIT
-
-func MSG(enr, emsg)
-    let english = v:lang == "C" || v:lang =~ '^[Ee]n'
-    if a:enr == ""
-	Xout "TODO: Add message number for:" a:emsg
-	let v:errmsg = ":" . v:errmsg
-    endif
-    let match = 1
-    if v:errmsg !~ '^'.a:enr.':' || (english && v:errmsg !~ a:emsg)
-	let match = 0
-	if v:errmsg == ""
-	    Xout "Message missing."
-	else
-	    let v:errmsg = v:errmsg->escape('"')
-	    Xout "Unexpected message:" v:errmsg
-	endif
-    endif
-    return match
-endfunc
-
-if 1 || strlen("\"") | Xpath 'a'
-    Xpath 'b'
-endif
-Xpath 'c'
-
-if 0
-elseif 1 || strlen("\"") | Xpath 'd'
-    Xpath 'e'
-endif
-Xpath 'f'
-
-while 1 || strlen("\"") | Xpath 'g'
-    Xpath 'h'
-    break
-endwhile
-Xpath 'i'
-
-let v:errmsg = ""
-if 1 ||| strlen("\"") | Xpath 'j'
-    Xpath 'k'
-endif
-Xpath 'l'
-if !MSG('E15', "Invalid expression")
-    Xpath 'm'
-endif
-
-let v:errmsg = ""
-if 0
-elseif 1 ||| strlen("\"") | Xpath 'n'
-    Xpath 'o'
-endif
-Xpath 'p'
-if !MSG('E15', "Invalid expression")
-    Xpath 'q'
-endif
-
-let v:errmsg = ""
-while 1 ||| strlen("\"") | Xpath 'r'
-    Xpath 's'
-    break
-endwhile
-Xpath 't'
-if !MSG('E15', "Invalid expression")
-    Xpath 'u'
-endif
-
-let g:test10_result = g:Xpath
-delfunction MSG
-
-func Test_expr_parsing()
-    call assert_equal('abcdefghilpt', g:test10_result)
-endfunc
-
-
-"-------------------------------------------------------------------------------
-" Test 11:  :if, :elseif, :while argument evaluation after abort	    {{{1
-"
-"	    When code is skipped over due to an error, the boolean argument to
-"	    an :if, :elseif, or :while must not be evaluated.
-"-------------------------------------------------------------------------------
-
-XpathINIT
-
-let calls = 0
-
-func P(num)
-    let g:calls = g:calls + a:num   " side effect on call
-    return 0
-endfunc
-
-if 1
-    Xpath 'a'
-    asdf		" error
-    Xpath 'b'
-    if P(1)		" should not be called
-	Xpath 'c'
-    elseif !P(2)	" should not be called
-	Xpath 'd'
-    else
-	Xpath 'e'
-    endif
-    Xpath 'f'
-    while P(4)		" should not be called
-	Xpath 'g'
-    endwhile
-    Xpath 'h'
-endif
-Xpath 'x'
-
-let g:test11_calls = calls
-let g:test11_result = g:Xpath
-
-unlet calls
-delfunction P
-
-func Test_arg_abort()
-    call assert_equal(0, g:test11_calls)
-    call assert_equal('ax', g:test11_result)
-endfunc
-
-
-"-------------------------------------------------------------------------------
-" Test 12:  Expressions in braces in skipped code			    {{{1
-"
-"	    In code skipped over due to an error or inactive conditional,
-"	    an expression in braces as part of a variable or function name
-"	    should not be evaluated.
-"-------------------------------------------------------------------------------
-
-XpathINIT
-
-func NULL()
-    Xpath 'a'
-    return 0
-endfunc
-
-func ZERO()
-    Xpath 'b'
-    return 0
-endfunc
-
-func! F0()
-    Xpath 'c'
-endfunc
-
-func! F1(arg)
-    Xpath 'e'
-endfunc
-
-let V0 = 1
-
-Xpath 'f'
-echo 0 ? F{NULL() + V{ZERO()}}() : 1
-
-Xpath 'g'
-if 0
-    Xpath 'h'
-    call F{NULL() + V{ZERO()}}()
-endif
-
-Xpath 'i'
-if 1
-    asdf		" error
-    Xpath 'j'
-    call F1(F{NULL() + V{ZERO()}}())
-endif
-
-Xpath 'k'
-if 1
-    asdf		" error
-    Xpath 'l'
-    call F{NULL() + V{ZERO()}}()
-endif
-
-let g:test12_result = g:Xpath
-
-func Test_braces_skipped()
-    call assert_equal('fgik', g:test12_result)
-endfunc
-
-
-"-------------------------------------------------------------------------------
-" Test 13:  Failure in argument evaluation for :while			    {{{1
-"
-"	    A failure in the expression evaluation for the condition of a :while
-"	    causes the whole :while loop until the matching :endwhile being
-"	    ignored.  Continuation is at the next following line.
-"-------------------------------------------------------------------------------
-
-XpathINIT
-
-Xpath 'a'
-while asdf
-    Xpath 'b'
-    while 1
-	Xpath 'c'
-	break
-    endwhile
-    Xpath 'd'
-    break
-endwhile
-Xpath 'e'
-
-while asdf | Xpath 'f' | endwhile | Xpath 'g'
-Xpath 'h'
-let g:test13_result = g:Xpath
-
-func Test_while_fail()
-    call assert_equal('aeh', g:test13_result)
-endfunc
-
-
-"-------------------------------------------------------------------------------
-" Test 14:  Failure in argument evaluation for :if			    {{{1
-"
-"	    A failure in the expression evaluation for the condition of an :if
-"	    does not cause the corresponding :else or :endif being matched to
-"	    a previous :if/:elseif.  Neither of both branches of the failed :if
-"	    are executed.
-"-------------------------------------------------------------------------------
-
-XpathINIT
-
-function! F()
-    Xpath 'a'
-    let x = 0
-    if x		" false
-	Xpath 'b'
-    elseif !x		" always true
-	Xpath 'c'
-	let x = 1
-	if g:boolvar	" possibly undefined
-	    Xpath 'd'
-	else
-	    Xpath 'e'
-	endif
-	Xpath 'f'
-    elseif x		" never executed
-	Xpath 'g'
-    endif
-    Xpath 'h'
-endfunction
-
-let boolvar = 1
-call F()
-Xpath '-'
-
-unlet boolvar
-call F()
-let g:test14_result = g:Xpath
-
-delfunction F
-
-func Test_if_fail()
-    call assert_equal('acdfh-acfh', g:test14_result)
-endfunc
-
-
-"-------------------------------------------------------------------------------
-" Test 15:  Failure in argument evaluation for :if (bar)		    {{{1
-"
-"	    Like previous test, except that the failing :if ... | ... | :endif
-"	    is in a single line.
-"-------------------------------------------------------------------------------
-
-XpathINIT
-
-function! F()
-    Xpath 'a'
-    let x = 0
-    if x		" false
-	Xpath 'b'
-    elseif !x		" always true
-	Xpath 'c'
-	let x = 1
-	if g:boolvar | Xpath 'd' | else | Xpath 'e' | endif
-	Xpath 'f'
-    elseif x		" never executed
-	Xpath 'g'
-    endif
-    Xpath 'h'
-endfunction
-
-let boolvar = 1
-call F()
-Xpath '-'
-
-unlet boolvar
-call F()
-let g:test15_result = g:Xpath
-
-delfunction F
-
-func Test_if_bar_fail()
-    call assert_equal('acdfh-acfh', g:test15_result)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 16:  Double :else or :elseif after :else				    {{{1
-"
-"	    Multiple :elses or an :elseif after an :else are forbidden.
-"-------------------------------------------------------------------------------
-
-func T16_F() abort
-  if 0
-    Xpath 'a'
-  else
-    Xpath 'b'
-  else		" aborts function
-    Xpath 'c'
-  endif
-  Xpath 'd'
-endfunc
-
-func T16_G() abort
-  if 0
-    Xpath 'a'
-  else
-    Xpath 'b'
-  elseif 1		" aborts function
-    Xpath 'c'
-  else
-    Xpath 'd'
-  endif
-  Xpath 'e'
-endfunc
-
-func T16_H() abort
-  if 0
-    Xpath 'a'
-  elseif 0
-    Xpath 'b'
-  else
-    Xpath 'c'
-  else		" aborts function
-    Xpath 'd'
-  endif
-  Xpath 'e'
-endfunc
-
-func T16_I() abort
-  if 0
-    Xpath 'a'
-  elseif 0
-    Xpath 'b'
-  else
-    Xpath 'c'
-  elseif 1		" aborts function
-    Xpath 'd'
-  else
-    Xpath 'e'
-  endif
-  Xpath 'f'
-endfunc
-
-func Test_Multi_Else()
-  XpathINIT
-  try
-    call T16_F()
-  catch /E583:/
-    Xpath 'e'
-  endtry
-  call assert_equal('be', g:Xpath)
-
-  XpathINIT
-  try
-    call T16_G()
-  catch /E584:/
-    Xpath 'f'
-  endtry
-  call assert_equal('bf', g:Xpath)
-
-  XpathINIT
-  try
-    call T16_H()
-  catch /E583:/
-    Xpath 'f'
-  endtry
-  call assert_equal('cf', g:Xpath)
-
-  XpathINIT
-  try
-    call T16_I()
-  catch /E584:/
-    Xpath 'g'
-  endtry
-  call assert_equal('cg', g:Xpath)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 17:  Nesting of unmatched :if or :endif inside a :while		    {{{1
-"
-"	    The :while/:endwhile takes precedence in nesting over an unclosed
-"	    :if or an unopened :endif.
-"-------------------------------------------------------------------------------
-
-" While loops inside a function are continued on error.
-func T17_F()
-  let loops = 3
-  while loops > 0
-    let loops -= 1
-    Xpath 'a' . loops
-    if (loops == 1)
-      Xpath 'b' . loops
-      continue
-    elseif (loops == 0)
-      Xpath 'c' . loops
-      break
-    elseif 1
-      Xpath 'd' . loops
-    " endif missing!
-  endwhile	" :endwhile after :if 1
-  Xpath 'e'
-endfunc
-
-func T17_G()
-  let loops = 2
-  while loops > 0
-    let loops -= 1
-    Xpath 'a' . loops
-    if 0
-      Xpath 'b' . loops
-    " endif missing
-  endwhile	" :endwhile after :if 0
-endfunc
-
-func T17_H()
-  let loops = 2
-  while loops > 0
-    let loops -= 1
-    Xpath 'a' . loops
-    " if missing!
-    endif	" :endif without :if in while
-    Xpath 'b' . loops
-  endwhile
-endfunc
-
-" Error continuation outside a function is at the outermost :endwhile or :endif.
-XpathINIT
-let v:errmsg = ''
-let loops = 2
-while loops > 0
-    let loops -= 1
-    Xpath 'a' . loops
-    if 0
-	Xpath 'b' . loops
-    " endif missing! Following :endwhile fails.
-endwhile | Xpath 'c'
-Xpath 'd'
-call assert_match('E171:', v:errmsg)
-call assert_equal('a1d', g:Xpath)
-
-func Test_unmatched_if_in_while()
-  XpathINIT
-  call assert_fails('call T17_F()', 'E171:')
-  call assert_equal('a2d2a1b1a0c0e', g:Xpath)
-
-  XpathINIT
-  call assert_fails('call T17_G()', 'E171:')
-  call assert_equal('a1a0', g:Xpath)
-
-  XpathINIT
-  call assert_fails('call T17_H()', 'E580:')
-  call assert_equal('a1b1a0b0', g:Xpath)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 18:  Interrupt (Ctrl-C pressed)					    {{{1
-"
-"	    On an interrupt, the script processing is terminated immediately.
-"-------------------------------------------------------------------------------
-
-func Test_interrupt_while_if()
-  let test =<< trim [CODE]
-    try
-      if 1
-        Xpath 'a'
-        while 1
-          Xpath 'b'
-          if 1
-            Xpath 'c'
-            call interrupt()
-            call assert_report('should not get here')
-            break
-            finish
-          endif | call assert_report('should not get here')
-          call assert_report('should not get here')
-        endwhile | call assert_report('should not get here')
-        call assert_report('should not get here')
-      endif | call assert_report('should not get here')
-      call assert_report('should not get here')
-    catch /^Vim:Interrupt$/
-      Xpath 'd'
-    endtry | Xpath 'e'
-    Xpath 'f'
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('abcdef', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-func Test_interrupt_try()
-  let test =<< trim [CODE]
-    try
-      try
-        Xpath 'a'
-        call interrupt()
-        call assert_report('should not get here')
-      endtry | call assert_report('should not get here')
-      call assert_report('should not get here')
-    catch /^Vim:Interrupt$/
-      Xpath 'b'
-    endtry | Xpath 'c'
-    Xpath 'd'
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('abcd', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-func Test_interrupt_func_while_if()
-  let test =<< trim [CODE]
-    func F()
-      if 1
-        Xpath 'a'
-        while 1
-          Xpath 'b'
-          if 1
-            Xpath 'c'
-            call interrupt()
-            call assert_report('should not get here')
-            break
-            return
-          endif | call assert_report('should not get here')
-          call assert_report('should not get here')
-        endwhile | call assert_report('should not get here')
-        call assert_report('should not get here')
-      endif | call assert_report('should not get here')
-      call assert_report('should not get here')
-    endfunc
-
-    Xpath 'd'
-    try
-      call F() | call assert_report('should not get here')
-    catch /^Vim:Interrupt$/
-      Xpath 'e'
-    endtry | Xpath 'f'
-    Xpath 'g'
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('dabcefg', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-func Test_interrupt_func_try()
-  let test =<< trim [CODE]
-    func G()
-      try
-        Xpath 'a'
-        call interrupt()
-        call assert_report('should not get here')
-      endtry | call assert_report('should not get here')
-      call assert_report('should not get here')
-    endfunc
-
-    Xpath 'b'
-    try
-      call G() | call assert_report('should not get here')
-    catch /^Vim:Interrupt$/
-      Xpath 'c'
-    endtry | Xpath 'd'
-    Xpath 'e'
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('bacde', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 19:  Aborting on errors inside :try/:endtry			    {{{1
-"
-"	    An error in a command dynamically enclosed in a :try/:endtry region
-"	    aborts script processing immediately.  It does not matter whether
-"	    the failing command is outside or inside a function and whether a
-"	    function has an "abort" attribute.
-"-------------------------------------------------------------------------------
-
-func Test_try_error_abort_1()
-  let test =<< trim [CODE]
-    func F() abort
-      Xpath 'a'
-      asdf
-      call assert_report('should not get here')
-    endfunc
-
-    try
-      Xpath 'b'
-      call F()
-      call assert_report('should not get here')
-    endtry | call assert_report('should not get here')
-    call assert_report('should not get here')
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('ba', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-func Test_try_error_abort_2()
-  let test =<< trim [CODE]
-    func G()
-      Xpath 'a'
-      asdf
-      call assert_report('should not get here')
-    endfunc
-
-    try
-      Xpath 'b'
-      call G()
-      call assert_report('should not get here')
-    endtry | call assert_report('should not get here')
-    call assert_report('should not get here')
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('ba', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-func Test_try_error_abort_3()
-  let test =<< trim [CODE]
-    try
-      Xpath 'a'
-      asdf
-      call assert_report('should not get here')
-    endtry | call assert_report('should not get here')
-    call assert_report('should not get here')
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('a', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-func Test_try_error_abort_4()
-  let test =<< trim [CODE]
-    if 1
-      try
-        Xpath 'a'
-        asdf
-        call assert_report('should not get here')
-      endtry | call assert_report('should not get here')
-    endif | call assert_report('should not get here')
-    call assert_report('should not get here')
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('a', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-func Test_try_error_abort_5()
-  let test =<< trim [CODE]
-    let p = 1
-    while p
-      let p = 0
-      try
-        Xpath 'a'
-        asdf
-        call assert_report('should not get here')
-      endtry | call assert_report('should not get here')
-    endwhile | call assert_report('should not get here')
-    call assert_report('should not get here')
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('a', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-func Test_try_error_abort_6()
-  let test =<< trim [CODE]
-    let p = 1
-    Xpath 'a'
-    while p
-      Xpath 'b'
-      let p = 0
-      try
-        Xpath 'c'
-    endwhile | call assert_report('should not get here')
-    call assert_report('should not get here')
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('abc', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 20:  Aborting on errors after :try/:endtry			    {{{1
-"
-"	    When an error occurs after the last active :try/:endtry region has
-"	    been left, termination behavior is as if no :try/:endtry has been
-"	    seen.
-"-------------------------------------------------------------------------------
-
-func Test_error_after_try_1()
-  let test =<< trim [CODE]
-    let p = 1
-    while p
-      let p = 0
-      Xpath 'a'
-      try
-        Xpath 'b'
-      endtry
-      asdf
-      call assert_report('should not get here')
-    endwhile | call assert_report('should not get here')
-    Xpath 'c'
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('abc', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-func Test_error_after_try_2()
-  let test =<< trim [CODE]
-    while 1
-      try
-        Xpath 'a'
-        break
-        call assert_report('should not get here')
-      endtry
-    endwhile
-    Xpath 'b'
-    asdf
-    Xpath 'c'
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('abc', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-func Test_error_after_try_3()
-  let test =<< trim [CODE]
-    while 1
-      try
-        Xpath 'a'
-        break
-        call assert_report('should not get here')
-      finally
-        Xpath 'b'
-      endtry
-    endwhile
-    Xpath 'c'
-    asdf
-    Xpath 'd'
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('abcd', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-func Test_error_after_try_4()
-  let test =<< trim [CODE]
-    while 1
-      try
-        Xpath 'a'
-      finally
-        Xpath 'b'
-        break
-        call assert_report('should not get here')
-      endtry
-    endwhile
-    Xpath 'c'
-    asdf
-    Xpath 'd'
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('abcd', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-func Test_error_after_try_5()
-  let test =<< trim [CODE]
-    let p = 1
-    while p
-      let p = 0
-      try
-        Xpath 'a'
-        continue
-        call assert_report('should not get here')
-      endtry
-    endwhile
-    Xpath 'b'
-    asdf
-    Xpath 'c'
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('abc', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-func Test_error_after_try_6()
-  let test =<< trim [CODE]
-    let p = 1
-    while p
-      let p = 0
-      try
-        Xpath 'a'
-        continue
-        call assert_report('should not get here')
-      finally
-        Xpath 'b'
-      endtry
-    endwhile
-    Xpath 'c'
-    asdf
-    Xpath 'd'
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('abcd', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-func Test_error_after_try_7()
-  let test =<< trim [CODE]
-    let p = 1
-    while p
-      let p = 0
-      try
-        Xpath 'a'
-      finally
-        Xpath 'b'
-        continue
-        call assert_report('should not get here')
-      endtry
-    endwhile
-    Xpath 'c'
-    asdf
-    Xpath 'd'
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('abcd', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 21:  :finally for :try after :continue/:break/:return/:finish	    {{{1
-"
-"	    If a :try conditional stays inactive due to a preceding :continue,
-"	    :break, :return, or :finish, its :finally clause should not be
-"	    executed.
-"-------------------------------------------------------------------------------
-
-func Test_finally_after_loop_ctrl_statement()
-  let test =<< trim [CODE]
-    func F()
-      let loops = 2
-      while loops > 0
-        XloopNEXT
-        let loops = loops - 1
-        try
-          if loops == 1
-            Xloop 'a'
-            continue
-            call assert_report('should not get here')
-          elseif loops == 0
-            Xloop 'b'
-            break
-            call assert_report('should not get here')
-          endif
-
-          try		" inactive
-            call assert_report('should not get here')
-          finally
-            call assert_report('should not get here')
-          endtry
-        finally
-          Xloop 'c'
-        endtry
-        call assert_report('should not get here')
-      endwhile
-
-      try
-        Xpath 'd'
-        return
-        call assert_report('should not get here')
-        try		    " inactive
-          call assert_report('should not get here')
-        finally
-          call assert_report('should not get here')
-        endtry
-      finally
-        Xpath 'e'
-      endtry
-      call assert_report('should not get here')
-    endfunc
-
-    try
-      Xpath 'f'
-      call F()
-      Xpath 'g'
-      finish
-      call assert_report('should not get here')
-      try		" inactive
-        call assert_report('should not get here')
-      finally
-        call assert_report('should not get here')
-      endtry
-    finally
-      Xpath 'h'
-    endtry
-    call assert_report('should not get here')
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('fa2c2b3c3degh', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 22:  :finally for a :try after an error/interrupt/:throw		    {{{1
-"
-"	    If a :try conditional stays inactive due to a preceding error or
-"	    interrupt or :throw, its :finally clause should not be executed.
-"-------------------------------------------------------------------------------
-
-func Test_finally_after_error_in_func()
-  let test =<< trim [CODE]
-    func Error()
-      try
-        Xpath 'b'
-        asdf    " aborting error, triggering error exception
-        call assert_report('should not get here')
-      endtry
-      call assert_report('should not get here')
-    endfunc
-
-    Xpath 'a'
-    call Error()
-    call assert_report('should not get here')
-
-    if 1	" not active due to error
-      try	" not active since :if inactive
-        call assert_report('should not get here')
-      finally
-        call assert_report('should not get here')
-      endtry
-    endif
-
-    try		" not active due to error
-      call assert_report('should not get here')
-    finally
-      call assert_report('should not get here')
-    endtry
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('ab', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-func Test_finally_after_interrupt()
-  let test =<< trim [CODE]
-    func Interrupt()
-      try
-        Xpath 'a'
-        call interrupt()            " triggering interrupt exception
-        call assert_report('should not get here')
-      endtry
-    endfunc
-
-    Xpath 'b'
-    try
-      call Interrupt()
-    catch /^Vim:Interrupt$/
-      Xpath 'c'
-      finish
-    endtry
-    call assert_report('should not get here')
-
-    if 1	" not active due to interrupt
-      try	" not active since :if inactive
-        call assert_report('should not get here')
-      finally
-        call assert_report('should not get here')
-      endtry
-    endif
-
-    try		" not active due to interrupt
-      call assert_report('should not get here')
-    finally
-      call assert_report('should not get here')
-    endtry
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('bac', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-func Test_finally_after_throw()
-  let test =<< trim [CODE]
-    func Throw()
-      Xpath 'a'
-      throw 'xyz'
-    endfunc
-
-    Xpath 'b'
-    call Throw()
-    call assert_report('should not get here')
-
-    if 1	" not active due to :throw
-      try	" not active since :if inactive
-        call assert_report('should not get here')
-      finally
-        call assert_report('should not get here')
-      endtry
-    endif
-
-    try		" not active due to :throw
-      call assert_report('should not get here')
-    finally
-      call assert_report('should not get here')
-    endtry
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('ba', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 23:  :catch clauses for a :try after a :throw			    {{{1
-"
-"	    If a :try conditional stays inactive due to a preceding :throw,
-"	    none of its :catch clauses should be executed.
-"-------------------------------------------------------------------------------
-
-func Test_catch_after_throw()
-  let test =<< trim [CODE]
-    try
-      Xpath 'a'
-      throw "xyz"
-      call assert_report('should not get here')
-
-      if 1	" not active due to :throw
-        try	" not active since :if inactive
-          call assert_report('should not get here')
-        catch /xyz/
-          call assert_report('should not get here')
-        endtry
-      endif
-    catch /xyz/
-      Xpath 'b'
-    endtry
-
-    Xpath 'c'
-    throw "abc"
-    call assert_report('should not get here')
-
-    try		" not active due to :throw
-      call assert_report('should not get here')
-    catch /abc/
-      call assert_report('should not get here')
-    endtry
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('abc', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 24:  :endtry for a :try after a :throw				    {{{1
-"
-"	    If a :try conditional stays inactive due to a preceding :throw,
-"	    its :endtry should not rethrow the exception to the next surrounding
-"	    active :try conditional.
-"-------------------------------------------------------------------------------
-
-func Test_endtry_after_throw()
-  let test =<< trim [CODE]
-    try			" try 1
-      try		" try 2
-        Xpath 'a'
-        throw "xyz"	" makes try 2 inactive
-        call assert_report('should not get here')
-
-        try		" try 3
-          call assert_report('should not get here')
-        endtry	" no rethrow to try 1
-      catch /xyz/	" should catch although try 2 inactive
-        Xpath 'b'
-      endtry
-    catch /xyz/		" try 1 active, but exception already caught
-      call assert_report('should not get here')
-    endtry
-    Xpath 'c'
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('abc', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 27:  Executing :finally clauses after :return			    {{{1
-"
-"	    For a :return command dynamically enclosed in a :try/:endtry region,
-"	    :finally clauses are executed and the called function is ended.
-"-------------------------------------------------------------------------------
-
-func T27_F()
-  try
-    Xpath 'a'
-    try
-      Xpath 'b'
-      return
-      call assert_report('should not get here')
-    finally
-      Xpath 'c'
-    endtry
-    Xpath 'd'
-  finally
-    Xpath 'e'
-  endtry
-  call assert_report('should not get here')
-endfunc
-
-func T27_G()
-  try
-    Xpath 'f'
-    return
-    call assert_report('should not get here')
-  finally
-    Xpath 'g'
-    call T27_F()
-    Xpath 'h'
-  endtry
-  call assert_report('should not get here')
-endfunc
-
-func T27_H()
-  try
-    Xpath 'i'
-    call T27_G()
-    Xpath 'j'
-  finally
-    Xpath 'k'
-    return
-    call assert_report('should not get here')
-  endtry
-  call assert_report('should not get here')
-endfunction
-
-func Test_finally_after_return()
-  XpathINIT
-  try
-      Xpath 'l'
-      call T27_H()
-      Xpath 'm'
-  finally
-      Xpath 'n'
-  endtry
-  call assert_equal('lifgabcehjkmn', g:Xpath)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 28:  Executing :finally clauses after :finish			    {{{1
-"
-"	    For a :finish command dynamically enclosed in a :try/:endtry region,
-"	    :finally clauses are executed and the sourced file is finished.
-"
-"	    This test executes the bodies of the functions F, G, and H from the
-"	    previous test as script files (:return replaced by :finish).
-"-------------------------------------------------------------------------------
-
-func Test_finally_after_finish()
-  XpathINIT
-
-  let scriptF = MakeScript("T27_F")
-  let scriptG = MakeScript("T27_G", scriptF)
-  let scriptH = MakeScript("T27_H", scriptG)
-
-  try
-    Xpath 'A'
-    exec "source" scriptH
-    Xpath 'B'
-  finally
-    Xpath 'C'
-  endtry
-  Xpath 'D'
-  call assert_equal('AifgabcehjkBCD', g:Xpath)
-  call delete(scriptF)
-  call delete(scriptG)
-  call delete(scriptH)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 29:  Executing :finally clauses on errors			    {{{1
-"
-"	    After an error in a command dynamically enclosed in a :try/:endtry
-"	    region, :finally clauses are executed and the script processing is
-"	    terminated.
-"-------------------------------------------------------------------------------
-
-func Test_finally_after_error_1()
-  let test =<< trim [CODE]
-    func F()
-      while 1
-        try
-          Xpath 'a'
-          while 1
-            try
-              Xpath 'b'
-              asdf	    " error
-              call assert_report('should not get here')
-            finally
-              Xpath 'c'
-            endtry | call assert_report('should not get here')
-            call assert_report('should not get here')
-            break
-          endwhile
-          call assert_report('should not get here')
-        finally
-          Xpath 'd'
-        endtry | call assert_report('should not get here')
-        call assert_report('should not get here')
-        break
-      endwhile
-      call assert_report('should not get here')
-    endfunc
-
-    while 1
-      try
-        Xpath 'e'
-        while 1
-          call F()
-          call assert_report('should not get here')
-          break
-        endwhile  | call assert_report('should not get here')
-        call assert_report('should not get here')
-      finally
-        Xpath 'f'
-      endtry | call assert_report('should not get here')
-    endwhile | call assert_report('should not get here')
-    call assert_report('should not get here')
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('eabcdf', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-func Test_finally_after_error_2()
-  let test =<< trim [CODE]
-    func G() abort
-      if 1
-        try
-          Xpath 'a'
-          asdf	    " error
-          call assert_report('should not get here')
-        finally
-          Xpath 'b'
-        endtry | Xpath 'c'
-      endif | Xpath 'd'
-      call assert_report('should not get here')
-    endfunc
-
-    if 1
-      try
-        Xpath 'e'
-        call G()
-        call assert_report('should not get here')
-      finally
-        Xpath 'f'
-      endtry | call assert_report('should not get here')
-    endif | call assert_report('should not get here')
-    call assert_report('should not get here')
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('eabf', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 30:  Executing :finally clauses on interrupt			    {{{1
-"
-"	    After an interrupt in a command dynamically enclosed in
-"	    a :try/:endtry region, :finally clauses are executed and the
-"	    script processing is terminated.
-"-------------------------------------------------------------------------------
-
-func Test_finally_on_interrupt()
-  let test =<< trim [CODE]
-    func F()
-      try
-        Xloop 'a'
-        call interrupt()
-        call assert_report('should not get here')
-      finally
-        Xloop 'b'
-      endtry
-      call assert_report('should not get here')
-    endfunc
-
-    try
-      try
-        Xpath 'c'
-        try
-          Xpath 'd'
-          call interrupt()
-          call assert_report('should not get here')
-        finally
-          Xpath 'e'
-          try
-            Xpath 'f'
-            try
-              Xpath 'g'
-            finally
-              Xpath 'h'
-              try
-                Xpath 'i'
-                call interrupt()
-                call assert_report('should not get here')
-              endtry
-              call assert_report('should not get here')
-            endtry
-            call assert_report('should not get here')
-          endtry
-          call assert_report('should not get here')
-        endtry
-        call assert_report('should not get here')
-      finally
-        Xpath 'j'
-        try
-          Xpath 'k'
-          call F()
-          call assert_report('should not get here')
-        finally
-          Xpath 'l'
-          try
-            Xpath 'm'
-            XloopNEXT
-            ExecAsScript F
-            call assert_report('should not get here')
-          finally
-            Xpath 'n'
-          endtry
-          call assert_report('should not get here')
-        endtry
-        call assert_report('should not get here')
-      endtry
-      call assert_report('should not get here')
-    catch /^Vim:Interrupt$/
-      Xpath 'o'
-    endtry
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('cdefghijka1b1lma2b2no', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 31:  Executing :finally clauses after :throw			    {{{1
-"
-"	    After a :throw dynamically enclosed in a :try/:endtry region,
-"	    :finally clauses are executed and the script processing is
-"	    terminated.
-"-------------------------------------------------------------------------------
-
-func Test_finally_after_throw_2()
-  let test =<< trim [CODE]
-    func F()
-      try
-        Xloop 'a'
-        throw "exception"
-        call assert_report('should not get here')
-      finally
-        Xloop 'b'
-      endtry
-      call assert_report('should not get here')
-    endfunc
-
-    try
-      Xpath 'c'
-      try
-        Xpath 'd'
-        throw "exception"
-        call assert_report('should not get here')
-      finally
-        Xpath 'e'
-        try
-          Xpath 'f'
-          try
-            Xpath 'g'
-          finally
-            Xpath 'h'
-            try
-              Xpath 'i'
-              throw "exception"
-              call assert_report('should not get here')
-            endtry
-            call assert_report('should not get here')
-          endtry
-          call assert_report('should not get here')
-        endtry
-        call assert_report('should not get here')
-      endtry
-      call assert_report('should not get here')
-    finally
-      Xpath 'j'
-      try
-        Xpath 'k'
-        call F()
-        call assert_report('should not get here')
-      finally
-        Xpath 'l'
-        try
-          Xpath 'm'
-          XloopNEXT
-          ExecAsScript F
-          call assert_report('should not get here')
-        finally
-          Xpath 'n'
-        endtry
-        call assert_report('should not get here')
-      endtry
-      call assert_report('should not get here')
-    endtry
-    call assert_report('should not get here')
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('cdefghijka1b1lma2b2n', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 34:  :finally reason discarded by :continue			    {{{1
-"
-"	    When a :finally clause is executed due to a :continue, :break,
-"	    :return, :finish, error, interrupt or :throw, the jump reason is
-"	    discarded by a :continue in the finally clause.
-"-------------------------------------------------------------------------------
-
-func Test_finally_after_continue()
-  let test =<< trim [CODE]
-    func C(jump)
-      XloopNEXT
-      let loop = 0
-      while loop < 2
-        let loop = loop + 1
-        if loop == 1
-          try
-            if a:jump == "continue"
-              continue
-            elseif a:jump == "break"
-              break
-            elseif a:jump == "return" || a:jump == "finish"
-              return
-            elseif a:jump == "error"
-              asdf
-            elseif a:jump == "interrupt"
-              call interrupt()
-              let dummy = 0
-            elseif a:jump == "throw"
-              throw "abc"
-            endif
-          finally
-            continue	" discards jump that caused the :finally
-            call assert_report('should not get here')
-          endtry
-          call assert_report('should not get here')
-        elseif loop == 2
-          Xloop 'a'
-        endif
-      endwhile
-    endfunc
-
-    call C("continue")
-    Xpath 'b'
-    call C("break")
-    Xpath 'c'
-    call C("return")
-    Xpath 'd'
-    let g:jump = "finish"
-    ExecAsScript C
-    unlet g:jump
-    Xpath 'e'
-    try
-      call C("error")
-      Xpath 'f'
-    finally
-      Xpath 'g'
-      try
-        call C("interrupt")
-        Xpath 'h'
-      finally
-        Xpath 'i'
-        call C("throw")
-        Xpath 'j'
-      endtry
-    endtry
-    Xpath 'k'
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('a2ba3ca4da5ea6fga7hia8jk', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 35:  :finally reason discarded by :break				    {{{1
-"
-"	    When a :finally clause is executed due to a :continue, :break,
-"	    :return, :finish, error, interrupt or :throw, the jump reason is
-"	    discarded by a :break in the finally clause.
-"-------------------------------------------------------------------------------
-
-func Test_finally_discard_by_break()
-  let test =<< trim [CODE]
-    func B(jump)
-      XloopNEXT
-      let loop = 0
-      while loop < 2
-        let loop = loop + 1
-        if loop == 1
-          try
-            if a:jump == "continue"
-              continue
-            elseif a:jump == "break"
-              break
-            elseif a:jump == "return" || a:jump == "finish"
-              return
-            elseif a:jump == "error"
-              asdf
-            elseif a:jump == "interrupt"
-              call interrupt()
-              let dummy = 0
-            elseif a:jump == "throw"
-              throw "abc"
-            endif
-          finally
-            break	" discards jump that caused the :finally
-            call assert_report('should not get here')
-          endtry
-        elseif loop == 2
-          call assert_report('should not get here')
-        endif
-      endwhile
-      Xloop 'a'
-    endfunc
-
-    call B("continue")
-    Xpath 'b'
-    call B("break")
-    Xpath 'c'
-    call B("return")
-    Xpath 'd'
-    let g:jump = "finish"
-    ExecAsScript B
-    unlet g:jump
-    Xpath 'e'
-    try
-      call B("error")
-      Xpath 'f'
-    finally
-      Xpath 'g'
-      try
-        call B("interrupt")
-        Xpath 'h'
-      finally
-        Xpath 'i'
-        call B("throw")
-        Xpath 'j'
-      endtry
-    endtry
-    Xpath 'k'
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('a2ba3ca4da5ea6fga7hia8jk', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 36:  :finally reason discarded by :return			    {{{1
-"
-"	    When a :finally clause is executed due to a :continue, :break,
-"	    :return, :finish, error, interrupt or :throw, the jump reason is
-"	    discarded by a :return in the finally clause.
-"-------------------------------------------------------------------------------
-
-func Test_finally_discard_by_return()
-  let test =<< trim [CODE]
-    func R(jump, retval) abort
-      let loop = 0
-      while loop < 2
-        let loop = loop + 1
-        if loop == 1
-          try
-            if a:jump == "continue"
-              continue
-            elseif a:jump == "break"
-              break
-            elseif a:jump == "return"
-              return
-            elseif a:jump == "error"
-              asdf
-            elseif a:jump == "interrupt"
-              call interrupt()
-              let dummy = 0
-            elseif a:jump == "throw"
-              throw "abc"
-            endif
-          finally
-            return a:retval	" discards jump that caused the :finally
-            call assert_report('should not get here')
-          endtry
-        elseif loop == 2
-          call assert_report('should not get here')
-        endif
-      endwhile
-      call assert_report('should not get here')
-    endfunc
-
-    let sum =  -R("continue", -8)
-    Xpath 'a'
-    let sum = sum - R("break", -16)
-    Xpath 'b'
-    let sum = sum - R("return", -32)
-    Xpath 'c'
-    try
-      let sum = sum - R("error", -64)
-      Xpath 'd'
-    finally
-      Xpath 'e'
-      try
-        let sum = sum - R("interrupt", -128)
-        Xpath 'f'
-      finally
-        Xpath 'g'
-        let sum = sum - R("throw", -256)
-        Xpath 'h'
-      endtry
-    endtry
-    Xpath 'i'
-
-    let expected = 8 + 16 + 32 + 64 + 128 + 256
-    call assert_equal(sum, expected)
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('abcdefghi', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 37:  :finally reason discarded by :finish			    {{{1
-"
-"	    When a :finally clause is executed due to a :continue, :break,
-"	    :return, :finish, error, interrupt or :throw, the jump reason is
-"	    discarded by a :finish in the finally clause.
-"-------------------------------------------------------------------------------
-
-func Test_finally_discard_by_finish()
-  let test =<< trim [CODE]
-    func F(jump)	" not executed as function, transformed to a script
-      let loop = 0
-      while loop < 2
-        let loop = loop + 1
-        if loop == 1
-          try
-            if a:jump == "continue"
-              continue
-            elseif a:jump == "break"
-              break
-            elseif a:jump == "finish"
-              finish
-            elseif a:jump == "error"
-              asdf
-            elseif a:jump == "interrupt"
-              call interrupt()
-              let dummy = 0
-            elseif a:jump == "throw"
-              throw "abc"
-            endif
-          finally
-            finish	" discards jump that caused the :finally
-            call assert_report('should not get here')
-          endtry
-        elseif loop == 2
-          call assert_report('should not get here')
-        endif
-      endwhile
-      call assert_report('should not get here')
-    endfunc
-
-    let scriptF = MakeScript("F")
-    delfunction F
-
-    let g:jump = "continue"
-    exec "source" scriptF
-    Xpath 'a'
-    let g:jump = "break"
-    exec "source" scriptF
-    Xpath 'b'
-    let g:jump = "finish"
-    exec "source" scriptF
-    Xpath 'c'
-    try
-      let g:jump = "error"
-      exec "source" scriptF
-      Xpath 'd'
-    finally
-      Xpath 'e'
-      try
-        let g:jump = "interrupt"
-        exec "source" scriptF
-        Xpath 'f'
-      finally
-        Xpath 'g'
-        try
-          let g:jump = "throw"
-          exec "source" scriptF
-          Xpath 'h'
-        finally
-          Xpath 'i'
-        endtry
-      endtry
-    endtry
-    unlet g:jump
-    call delete(scriptF)
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('abcdefghi', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 38:  :finally reason discarded by an error			    {{{1
-"
-"	    When a :finally clause is executed due to a :continue, :break,
-"	    :return, :finish, error, interrupt or :throw, the jump reason is
-"	    discarded by an error in the finally clause.
-"-------------------------------------------------------------------------------
-
-func Test_finally_discard_by_error()
-  let test =<< trim [CODE]
-    func E(jump)
-      let loop = 0
-      while loop < 2
-        let loop = loop + 1
-        if loop == 1
-          try
-            if a:jump == "continue"
-              continue
-            elseif a:jump == "break"
-              break
-            elseif a:jump == "return" || a:jump == "finish"
-              return
-            elseif a:jump == "error"
-              asdf
-            elseif a:jump == "interrupt"
-              call interrupt()
-              let dummy = 0
-            elseif a:jump == "throw"
-              throw "abc"
-            endif
-          finally
-            asdf	" error; discards jump that caused the :finally
-          endtry
-        elseif loop == 2
-          call assert_report('should not get here')
-        endif
-      endwhile
-      call assert_report('should not get here')
-    endfunc
-
-    try
-      Xpath 'a'
-      call E("continue")
-      call assert_report('should not get here')
-    finally
-      try
-        Xpath 'b'
-        call E("break")
-        call assert_report('should not get here')
-      finally
-        try
-          Xpath 'c'
-          call E("return")
-          call assert_report('should not get here')
-        finally
-          try
-            Xpath 'd'
-            let g:jump = "finish"
-            ExecAsScript E
-            call assert_report('should not get here')
-          finally
-            unlet g:jump
-            try
-              Xpath 'e'
-              call E("error")
-              call assert_report('should not get here')
-            finally
-              try
-                Xpath 'f'
-                call E("interrupt")
-                call assert_report('should not get here')
-              finally
-                try
-                  Xpath 'g'
-                  call E("throw")
-                  call assert_report('should not get here')
-                finally
-                  Xpath 'h'
-                  delfunction E
-                endtry
-              endtry
-            endtry
-          endtry
-        endtry
-      endtry
-    endtry
-    call assert_report('should not get here')
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('abcdefgh', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 39:  :finally reason discarded by an interrupt			    {{{1
-"
-"	    When a :finally clause is executed due to a :continue, :break,
-"	    :return, :finish, error, interrupt or :throw, the jump reason is
-"	    discarded by an interrupt in the finally clause.
-"-------------------------------------------------------------------------------
-
-func Test_finally_discarded_by_interrupt()
-  let test =<< trim [CODE]
-    func I(jump)
-      let loop = 0
-      while loop < 2
-        let loop = loop + 1
-        if loop == 1
-          try
-            if a:jump == "continue"
-              continue
-            elseif a:jump == "break"
-              break
-            elseif a:jump == "return" || a:jump == "finish"
-              return
-            elseif a:jump == "error"
-              asdf
-            elseif a:jump == "interrupt"
-              call interrupt()
-              let dummy = 0
-            elseif a:jump == "throw"
-              throw "abc"
-            endif
-          finally
-            call interrupt()
-            let dummy = 0
-          endtry
-        elseif loop == 2
-          call assert_report('should not get here')
-        endif
-      endwhile
-      call assert_report('should not get here')
-    endfunc
-
-    try
-      try
-        Xpath 'a'
-        call I("continue")
-        call assert_report('should not get here')
-      finally
-        try
-          Xpath 'b'
-          call I("break")
-          call assert_report('should not get here')
-        finally
-          try
-            Xpath 'c'
-            call I("return")
-            call assert_report('should not get here')
-          finally
-            try
-              Xpath 'd'
-              let g:jump = "finish"
-              ExecAsScript I
-              call assert_report('should not get here')
-            finally
-              unlet g:jump
-              try
-                Xpath 'e'
-                call I("error")
-                call assert_report('should not get here')
-              finally
-                try
-                  Xpath 'f'
-                  call I("interrupt")
-                  call assert_report('should not get here')
-                finally
-                  try
-                    Xpath 'g'
-                    call I("throw")
-                    call assert_report('should not get here')
-                  finally
-                    Xpath 'h'
-                    delfunction I
-                  endtry
-                endtry
-              endtry
-            endtry
-          endtry
-        endtry
-      endtry
-      call assert_report('should not get here')
-    catch /^Vim:Interrupt$/
-      Xpath 'A'
-    endtry
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('abcdefghA', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 40:  :finally reason discarded by :throw				    {{{1
-"
-"	    When a :finally clause is executed due to a :continue, :break,
-"	    :return, :finish, error, interrupt or :throw, the jump reason is
-"	    discarded by a :throw in the finally clause.
-"-------------------------------------------------------------------------------
-
-func Test_finally_discard_by_throw()
-  let test =<< trim [CODE]
-    func T(jump)
-      let loop = 0
-      while loop < 2
-        let loop = loop + 1
-        if loop == 1
-          try
-            if a:jump == "continue"
-              continue
-            elseif a:jump == "break"
-              break
-            elseif a:jump == "return" || a:jump == "finish"
-              return
-            elseif a:jump == "error"
-              asdf
-            elseif a:jump == "interrupt"
-              call interrupt()
-              let dummy = 0
-            elseif a:jump == "throw"
-              throw "abc"
-            endif
-          finally
-            throw "xyz"	" discards jump that caused the :finally
-          endtry
-        elseif loop == 2
-          call assert_report('should not get here')
-        endif
-      endwhile
-      call assert_report('should not get here')
-    endfunc
-
-    try
-      Xpath 'a'
-      call T("continue")
-      call assert_report('should not get here')
-    finally
-      try
-        Xpath 'b'
-        call T("break")
-        call assert_report('should not get here')
-      finally
-        try
-          Xpath 'c'
-          call T("return")
-          call assert_report('should not get here')
-        finally
-          try
-            Xpath 'd'
-            let g:jump = "finish"
-            ExecAsScript T
-            call assert_report('should not get here')
-          finally
-            unlet g:jump
-            try
-              Xpath 'e'
-              call T("error")
-              call assert_report('should not get here')
-            finally
-              try
-                Xpath 'f'
-                call T("interrupt")
-                call assert_report('should not get here')
-              finally
-                try
-                  Xpath 'g'
-                  call T("throw")
-                  call assert_report('should not get here')
-                finally
-                  Xpath 'h'
-                  delfunction T
-                endtry
-              endtry
-            endtry
-          endtry
-        endtry
-      endtry
-    endtry
-    call assert_report('should not get here')
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('abcdefgh', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 49:  Throwing exceptions across functions			    {{{1
-"
-"	    When an exception is thrown but not caught inside a function, the
-"	    caller is checked for a matching :catch clause.
-"-------------------------------------------------------------------------------
-
-func T49_C()
-  try
-    Xpath 'a'
-    throw "arrgh"
-    call assert_report('should not get here')
-  catch /arrgh/
-    Xpath 'b'
-  endtry
-  Xpath 'c'
-endfunc
-
-func T49_T1()
-  XloopNEXT
-  try
-    Xloop 'd'
-    throw "arrgh"
-    call assert_report('should not get here')
-  finally
-    Xloop 'e'
-  endtry
-  Xloop 'f'
-endfunc
-
-func T49_T2()
-  try
-    Xpath 'g'
-    call T49_T1()
-    call assert_report('should not get here')
-  finally
-    Xpath 'h'
-  endtry
-  call assert_report('should not get here')
-endfunc
-
-func Test_throw_exception_across_funcs()
-  XpathINIT
-  XloopINIT
-  try
-    Xpath 'i'
-    call T49_C()            " throw and catch
-    Xpath 'j'
-  catch /.*/
-    call assert_report('should not get here')
-  endtry
-
-  try
-    Xpath 'k'
-    call T49_T1()  " throw, one level
-    call assert_report('should not get here')
-  catch /arrgh/
-    Xpath 'l'
-  catch /.*/
-    call assert_report('should not get here')
-  endtry
-
-  try
-    Xpath 'm'
-    call T49_T2()	" throw, two levels
-    call assert_report('should not get here')
-  catch /arrgh/
-    Xpath 'n'
-  catch /.*/
-    call assert_report('should not get here')
-  endtry
-  Xpath 'o'
-
-  call assert_equal('iabcjkd2e2lmgd3e3hno', g:Xpath)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 50:  Throwing exceptions across script files			    {{{1
-"
-"	    When an exception is thrown but not caught inside a script file,
-"	    the sourcing script or function is checked for a matching :catch
-"	    clause.
-"
-"	    This test executes the bodies of the functions C, T1, and T2 from
-"	    the previous test as script files (:return replaced by :finish).
-"-------------------------------------------------------------------------------
-
-func T50_F()
-  try
-    Xpath 'A'
-    exec "source" g:scriptC
-    Xpath 'B'
-  catch /.*/
-    call assert_report('should not get here')
-  endtry
-
-  try
-    Xpath 'C'
-    exec "source" g:scriptT1
-    call assert_report('should not get here')
-  catch /arrgh/
-    Xpath 'D'
-  catch /.*/
-    call assert_report('should not get here')
-  endtry
-endfunc
-
-func Test_throw_across_script()
-  XpathINIT
-  XloopINIT
-  let g:scriptC = MakeScript("T49_C")
-  let g:scriptT1 = MakeScript("T49_T1")
-  let scriptT2 = MakeScript("T49_T2", g:scriptT1)
-
-  try
-    Xpath 'E'
-    call T50_F()
-    Xpath 'F'
-    exec "source" scriptT2
-    call assert_report('should not get here')
-  catch /arrgh/
-    Xpath 'G'
-  catch /.*/
-    call assert_report('should not get here')
-  endtry
-  Xpath 'H'
-  call assert_equal('EAabcBCd2e2DFgd3e3hGH', g:Xpath)
-
-  call delete(g:scriptC)
-  call delete(g:scriptT1)
-  call delete(scriptT2)
-  unlet g:scriptC g:scriptT1 scriptT2
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 52:  Uncaught exceptions						    {{{1
-"
-"	    When an exception is thrown but not caught, an error message is
-"	    displayed when the script is terminated.  In case of an interrupt
-"	    or error exception, the normal interrupt or error message(s) are
-"	    displayed.
-"-------------------------------------------------------------------------------
-
-func Test_uncaught_exception_1()
-  CheckEnglish
-
-  let test =<< trim [CODE]
-    Xpath 'a'
-    throw "arrgh"
-    call assert_report('should not get here')`
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('E605: Exception not caught: arrgh', v:errmsg)
-    call assert_equal('a', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-func Test_uncaught_exception_2()
-  CheckEnglish
-
-  let test =<< trim [CODE]
-    try
-      Xpath 'a'
-      throw "oops"
-      call assert_report('should not get here')`
-    catch /arrgh/
-      call assert_report('should not get here')`
-    endtry
-    call assert_report('should not get here')`
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('E605: Exception not caught: oops', v:errmsg)
-    call assert_equal('a', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-func Test_uncaught_exception_3()
-  CheckEnglish
-
-  let test =<< trim [CODE]
-    func T()
-      Xpath 'c'
-      throw "brrr"
-      call assert_report('should not get here')`
-    endfunc
-
-    try
-      Xpath 'a'
-      throw "arrgh"
-      call assert_report('should not get here')`
-    catch /.*/
-      Xpath 'b'
-      call T()
-      call assert_report('should not get here')`
-    endtry
-    call assert_report('should not get here')`
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('E605: Exception not caught: brrr', v:errmsg)
-    call assert_equal('abc', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-func Test_uncaught_exception_4()
-  CheckEnglish
-
-  let test =<< trim [CODE]
-    try
-      Xpath 'a'
-      throw "arrgh"
-      call assert_report('should not get here')`
-    finally
-      Xpath 'b'
-      throw "brrr"
-      call assert_report('should not get here')`
-    endtry
-    call assert_report('should not get here')`
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('E605: Exception not caught: brrr', v:errmsg)
-    call assert_equal('ab', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-func Test_uncaught_exception_5()
-  CheckEnglish
-
-  " Need to catch and handle interrupt, otherwise the test will wait for the
-  " user to press <Enter> to continue
-  let test =<< trim [CODE]
-    try
-      try
-        Xpath 'a'
-        call interrupt()
-        call assert_report('should not get here')
-      endtry
-      call assert_report('should not get here')
-    catch /^Vim:Interrupt$/
-      Xpath 'b'
-    endtry
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('ab', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-func Test_uncaught_exception_6()
-  CheckEnglish
-
-  let test =<< trim [CODE]
-    try
-      Xpath 'a'
-      let x = novar	" error E121; exception: E121
-    catch /E15:/	" should not catch
-      call assert_report('should not get here')
-    endtry
-    call assert_report('should not get here')
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('a', g:Xpath)
-    call assert_equal('E121: Undefined variable: novar', v:errmsg)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-func Test_uncaught_exception_7()
-  CheckEnglish
-
-  let test =<< trim [CODE]
-    try
-      Xpath 'a'
-      " error E108/E488; exception: E488
-      unlet novar #
-    catch /E108:/       " should not catch
-      call assert_report('should not get here')
-    endtry
-    call assert_report('should not get here')
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('a', g:Xpath)
-    call assert_equal('E488: Trailing characters: #', v:errmsg)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 53:  Nesting errors: :endif/:else/:elseif			    {{{1
-"
-"	    For nesting errors of :if conditionals the correct error messages
-"	    should be given.
-"-------------------------------------------------------------------------------
-
-func Test_nested_if_else_errors()
-  CheckEnglish
-
-  " :endif without :if
-  let code =<< trim END
-    endif
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(endif):E580: :endif without :if')
-
-  " :endif without :if
-  let code =<< trim END
-    while 1
-      endif
-    endwhile
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(endif):E580: :endif without :if')
-
-  " :endif without :if
-  let code =<< trim END
-    try
-    finally
-      endif
-    endtry
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(endif):E580: :endif without :if')
-
-  " :endif without :if
-  let code =<< trim END
-    try
-      endif
-    endtry
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(endif):E580: :endif without :if')
-
-  " :endif without :if
-  let code =<< trim END
-    try
-      throw "a"
-    catch /a/
-      endif
-    endtry
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(endif):E580: :endif without :if')
-
-  " :else without :if
-  let code =<< trim END
-    else
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(else):E581: :else without :if')
-
-  " :else without :if
-  let code =<< trim END
-    while 1
-      else
-    endwhile
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(else):E581: :else without :if')
-
-  " :else without :if
-  let code =<< trim END
-    try
-    finally
-      else
-    endtry
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(else):E581: :else without :if')
-
-  " :else without :if
-  let code =<< trim END
-    try
-      else
-    endtry
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(else):E581: :else without :if')
-
-  " :else without :if
-  let code =<< trim END
-    try
-      throw "a"
-    catch /a/
-      else
-    endtry
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(else):E581: :else without :if')
-
-  " :elseif without :if
-  let code =<< trim END
-    elseif 1
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(elseif):E582: :elseif without :if')
-
-  " :elseif without :if
-  let code =<< trim END
-    while 1
-      elseif 1
-    endwhile
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(elseif):E582: :elseif without :if')
-
-  " :elseif without :if
-  let code =<< trim END
-    try
-    finally
-      elseif 1
-    endtry
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(elseif):E582: :elseif without :if')
-
-  " :elseif without :if
-  let code =<< trim END
-    try
-      elseif 1
-    endtry
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(elseif):E582: :elseif without :if')
-
-  " :elseif without :if
-  let code =<< trim END
-    try
-      throw "a"
-    catch /a/
-      elseif 1
-    endtry
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(elseif):E582: :elseif without :if')
-
-  " multiple :else
-  let code =<< trim END
-    if 1
-    else
-    else
-    endif
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(else):E583: multiple :else')
-
-  " :elseif after :else
-  let code =<< trim END
-    if 1
-    else
-    elseif 1
-    endif
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(elseif):E584: :elseif after :else')
-
-  call delete('Xtest')
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 54:  Nesting errors: :while/:endwhile				    {{{1
-"
-"	    For nesting errors of :while conditionals the correct error messages
-"	    should be given.
-"
-"	    This test reuses the function MESSAGES() from the previous test.
-"	    This functions checks the messages in g:msgfile.
-"-------------------------------------------------------------------------------
-
-func Test_nested_while_error()
-  CheckEnglish
-
-  " :endwhile without :while
-  let code =<< trim END
-    endwhile
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(endwhile):E588: :endwhile without :while')
-
-  " :endwhile without :while
-  let code =<< trim END
-    if 1
-      endwhile
-    endif
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(endwhile):E588: :endwhile without :while')
-
-  " Missing :endif
-  let code =<< trim END
-    while 1
-      if 1
-    endwhile
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(endwhile):E171: Missing :endif')
-
-  " :endwhile without :while
-  let code =<< trim END
-    try
-    finally
-      endwhile
-    endtry
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(endwhile):E588: :endwhile without :while')
-
-  " Missing :endtry
-  let code =<< trim END
-    while 1
-      try
-      finally
-    endwhile
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(endwhile):E600: Missing :endtry')
-
-  " Missing :endtry
-  let code =<< trim END
-    while 1
-      if 1
-        try
-        finally
-    endwhile
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(endwhile):E600: Missing :endtry')
-
-  " Missing :endif
-  let code =<< trim END
-    while 1
-      try
-      finally
-        if 1
-    endwhile
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(endwhile):E171: Missing :endif')
-
-  " :endwhile without :while
-  let code =<< trim END
-    try
-      endwhile
-    endtry
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(endwhile):E588: :endwhile without :while')
-
-  " :endwhile without :while
-  let code =<< trim END
-    while 1
-      try
-        endwhile
-      endtry
-    endwhile
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(endwhile):E588: :endwhile without :while')
-
-  " :endwhile without :while
-  let code =<< trim END
-    try
-      throw "a"
-    catch /a/
-      endwhile
-    endtry
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(endwhile):E588: :endwhile without :while')
-
-  " :endwhile without :while
-  let code =<< trim END
-    while 1
-      try
-        throw "a"
-      catch /a/
-        endwhile
-      endtry
-    endwhile
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(endwhile):E588: :endwhile without :while')
-
-  call delete('Xtest')
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 55:  Nesting errors: :continue/:break				    {{{1
-"
-"	    For nesting errors of :continue and :break commands the correct
-"	    error messages should be given.
-"
-"	    This test reuses the function MESSAGES() from the previous test.
-"	    This functions checks the messages in g:msgfile.
-"-------------------------------------------------------------------------------
-
-func Test_nested_cont_break_error()
-  CheckEnglish
-
-  " :continue without :while
-  let code =<< trim END
-    continue
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(continue):E586: :continue without :while or :for')
-
-  " :continue without :while
-  let code =<< trim END
-    if 1
-      continue
-    endif
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(continue):E586: :continue without :while or :for')
-
-  " :continue without :while
-  let code =<< trim END
-    try
-    finally
-      continue
-    endtry
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(continue):E586: :continue without :while or :for')
-
-  " :continue without :while
-  let code =<< trim END
-    try
-      continue
-    endtry
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(continue):E586: :continue without :while or :for')
-
-  " :continue without :while
-  let code =<< trim END
-    try
-      throw "a"
-    catch /a/
-      continue
-    endtry
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(continue):E586: :continue without :while or :for')
-
-  " :break without :while
-  let code =<< trim END
-    break
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(break):E587: :break without :while or :for')
-
-  " :break without :while
-  let code =<< trim END
-    if 1
-      break
-    endif
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(break):E587: :break without :while or :for')
-
-  " :break without :while
-  let code =<< trim END
-    try
-    finally
-      break
-    endtry
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(break):E587: :break without :while or :for')
-
-  " :break without :while
-  let code =<< trim END
-    try
-      break
-    endtry
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(break):E587: :break without :while or :for')
-
-  " :break without :while
-  let code =<< trim END
-    try
-      throw "a"
-    catch /a/
-      break
-    endtry
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(break):E587: :break without :while or :for')
-
-  call delete('Xtest')
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 56:  Nesting errors: :endtry					    {{{1
-"
-"	    For nesting errors of :try conditionals the correct error messages
-"	    should be given.
-"
-"	    This test reuses the function MESSAGES() from the previous test.
-"	    This functions checks the messages in g:msgfile.
-"-------------------------------------------------------------------------------
-
-func Test_nested_endtry_error()
-  CheckEnglish
-
-  " :endtry without :try
-  let code =<< trim END
-    endtry
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(endtry):E602: :endtry without :try')
-
-  " :endtry without :try
-  let code =<< trim END
-    if 1
-      endtry
-    endif
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(endtry):E602: :endtry without :try')
-
-  " :endtry without :try
-  let code =<< trim END
-    while 1
-      endtry
-    endwhile
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(endtry):E602: :endtry without :try')
-
-  " Missing :endif
-  let code =<< trim END
-    try
-        if 1
-    endtry
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(endtry):E171: Missing :endif')
-
-  " Missing :endwhile
-  let code =<< trim END
-    try
-      while 1
-    endtry
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(endtry):E170: Missing :endwhile')
-
-  " Missing :endif
-  let code =<< trim END
-    try
-    finally
-      if 1
-    endtry
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(endtry):E171: Missing :endif')
-
-  " Missing :endwhile
-  let code =<< trim END
-    try
-    finally
-      while 1
-    endtry
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(endtry):E170: Missing :endwhile')
-
-  " Missing :endif
-  let code =<< trim END
-    try
-      throw "a"
-    catch /a/
-      if 1
-    endtry
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(endtry):E171: Missing :endif')
-
-  " Missing :endwhile
-  let code =<< trim END
-    try
-      throw "a"
-    catch /a/
-      while 1
-    endtry
-  END
-  call writefile(code, 'Xtest')
-  call AssertException(['source Xtest'], 'Vim(endtry):E170: Missing :endwhile')
-
-  call delete('Xtest')
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 57:  v:exception and v:throwpoint for user exceptions		    {{{1
-"
-"	    v:exception evaluates to the value of the exception that was caught
-"	    most recently and is not finished.  (A caught exception is finished
-"	    when the next ":catch", ":finally", or ":endtry" is reached.)
-"	    v:throwpoint evaluates to the script/function name and line number
-"	    where that exception has been thrown.
-"-------------------------------------------------------------------------------
-
-func Test_user_exception_info()
-  CheckEnglish
-
-  XpathINIT
-  XloopINIT
-
-  func FuncException()
-    let g:exception = v:exception
-  endfunc
-
-  func FuncThrowpoint()
-    let g:throwpoint = v:throwpoint
-  endfunc
-
-  let scriptException  = MakeScript("FuncException")
-  let scriptThrowPoint = MakeScript("FuncThrowpoint")
-
-  command! CmdException  let g:exception  = v:exception
-  command! CmdThrowpoint let g:throwpoint = v:throwpoint
-
-  func T(arg, line)
-    if a:line == 2
-      throw a:arg		" in line 2
-    elseif a:line == 4
-      throw a:arg		" in line 4
-    elseif a:line == 6
-      throw a:arg		" in line 6
-    elseif a:line == 8
-      throw a:arg		" in line 8
-    endif
-  endfunc
-
-  func G(arg, line)
-    call T(a:arg, a:line)
-  endfunc
-
-  func F(arg, line)
-    call G(a:arg, a:line)
-  endfunc
-
-  let scriptT = MakeScript("T")
-  let scriptG = MakeScript("G", scriptT)
-  let scriptF = MakeScript("F", scriptG)
-
-  try
-    Xpath 'a'
-    call F("oops", 2)
-  catch /.*/
-    Xpath 'b'
-    let exception  = v:exception
-    let throwpoint = v:throwpoint
-    call assert_equal("oops", v:exception)
-    call assert_match('\<F\[1]\.\.G\[1]\.\.T\>', v:throwpoint)
-    call assert_match('\<2\>', v:throwpoint)
-
-    exec "let exception  = v:exception"
-    exec "let throwpoint = v:throwpoint"
-    call assert_equal("oops", v:exception)
-    call assert_match('\<F\[1]\.\.G\[1]\.\.T\>', v:throwpoint)
-    call assert_match('\<2\>', v:throwpoint)
-
-    CmdException
-    CmdThrowpoint
-    call assert_equal("oops", v:exception)
-    call assert_match('\<F\[1]\.\.G\[1]\.\.T\>', v:throwpoint)
-    call assert_match('\<2\>', v:throwpoint)
-
-    call FuncException()
-    call FuncThrowpoint()
-    call assert_equal("oops", v:exception)
-    call assert_match('\<F\[1]\.\.G\[1]\.\.T\>', v:throwpoint)
-    call assert_match('\<2\>', v:throwpoint)
-
-    exec "source" scriptException
-    exec "source" scriptThrowPoint
-    call assert_equal("oops", v:exception)
-    call assert_match('\<F\[1]\.\.G\[1]\.\.T\>', v:throwpoint)
-    call assert_match('\<2\>', v:throwpoint)
-
-    try
-      Xpath 'c'
-      call G("arrgh", 4)
-    catch /.*/
-      Xpath 'd'
-      let exception  = v:exception
-      let throwpoint = v:throwpoint
-      call assert_equal("arrgh", v:exception)
-      call assert_match('\<G\[1]\.\.T\>', v:throwpoint)
-      call assert_match('\<4\>', v:throwpoint)
-
-      try
-        Xpath 'e'
-        let g:arg = "autsch"
-        let g:line = 6
-        exec "source" scriptF
-      catch /.*/
-        Xpath 'f'
-        let exception  = v:exception
-        let throwpoint = v:throwpoint
-        call assert_equal("autsch", v:exception)
-        call assert_match(fnamemodify(scriptT, ':t'), v:throwpoint)
-        call assert_match('\<6\>', v:throwpoint)
-      finally
-        Xpath 'g'
-        let exception  = v:exception
-        let throwpoint = v:throwpoint
-        call assert_equal("arrgh", v:exception)
-        call assert_match('\<G\[1]\.\.T\>', v:throwpoint)
-        call assert_match('\<4\>', v:throwpoint)
-        try
-          Xpath 'h'
-          let g:arg = "brrrr"
-          let g:line = 8
-          exec "source" scriptG
-        catch /.*/
-          Xpath 'i'
-          let exception  = v:exception
-          let throwpoint = v:throwpoint
-          " Resolve scriptT for matching it against v:throwpoint.
-          call assert_equal("brrrr", v:exception)
-          call assert_match(fnamemodify(scriptT, ':t'), v:throwpoint)
-          call assert_match('\<8\>', v:throwpoint)
-        finally
-          Xpath 'j'
-          let exception  = v:exception
-          let throwpoint = v:throwpoint
-          call assert_equal("arrgh", v:exception)
-          call assert_match('\<G\[1]\.\.T\>', v:throwpoint)
-          call assert_match('\<4\>', v:throwpoint)
-        endtry
-        Xpath 'k'
-        let exception  = v:exception
-        let throwpoint = v:throwpoint
-        call assert_equal("arrgh", v:exception)
-        call assert_match('\<G\[1]\.\.T\>', v:throwpoint)
-        call assert_match('\<4\>', v:throwpoint)
-      endtry
-      Xpath 'l'
-      let exception  = v:exception
-      let throwpoint = v:throwpoint
-      call assert_equal("arrgh", v:exception)
-      call assert_match('\<G\[1]\.\.T\>', v:throwpoint)
-      call assert_match('\<4\>', v:throwpoint)
-    finally
-      Xpath 'm'
-      let exception  = v:exception
-      let throwpoint = v:throwpoint
-      call assert_equal("oops", v:exception)
-      call assert_match('\<F\[1]\.\.G\[1]\.\.T\>', v:throwpoint)
-      call assert_match('\<2\>', v:throwpoint)
-    endtry
-    Xpath 'n'
-    let exception  = v:exception
-    let throwpoint = v:throwpoint
-    call assert_equal("oops", v:exception)
-    call assert_match('\<F\[1]\.\.G\[1]\.\.T\>', v:throwpoint)
-    call assert_match('\<2\>', v:throwpoint)
-  finally
-    Xpath 'o'
-    let exception  = v:exception
-    let throwpoint = v:throwpoint
-    call assert_equal("", v:exception)
-    call assert_match('^$', v:throwpoint)
-    call assert_match('^$', v:throwpoint)
-  endtry
-
-  call assert_equal('abcdefghijklmno', g:Xpath)
-
-  unlet exception throwpoint
-  delfunction FuncException
-  delfunction FuncThrowpoint
-  call delete(scriptException)
-  call delete(scriptThrowPoint)
-  unlet scriptException scriptThrowPoint
-  delcommand CmdException
-  delcommand CmdThrowpoint
-  delfunction T
-  delfunction G
-  delfunction F
-  call delete(scriptT)
-  call delete(scriptG)
-  call delete(scriptF)
-  unlet scriptT scriptG scriptF
-endfunc
-
-"-------------------------------------------------------------------------------
-"
-" Test 58:  v:exception and v:throwpoint for error/interrupt exceptions	    {{{1
-"
-"	    v:exception and v:throwpoint work also for error and interrupt
-"	    exceptions.
-"-------------------------------------------------------------------------------
-
-func Test_execption_info_for_error()
-  CheckEnglish
-
-  let test =<< trim [CODE]
-    func T(line)
-      if a:line == 2
-        delfunction T		" error (function in use) in line 2
-      elseif a:line == 4
-        call interrupt()
-      endif
-    endfunc
-
-    while 1
-      try
-        Xpath 'a'
-        call T(2)
-        call assert_report('should not get here')
-      catch /.*/
-        Xpath 'b'
-        if v:exception !~ 'Vim(delfunction):'
-          call assert_report('should not get here')
-        endif
-        if v:throwpoint !~ '\<T\>'
-          call assert_report('should not get here')
-        endif
-        if v:throwpoint !~ '\<2\>'
-          call assert_report('should not get here')
-        endif
-      finally
-        Xpath 'c'
-        if v:exception != ""
-          call assert_report('should not get here')
-        endif
-        if v:throwpoint != ""
-          call assert_report('should not get here')
-        endif
-        break
-      endtry
-    endwhile
-
-    Xpath 'd'
-    if v:exception != ""
-      call assert_report('should not get here')
-    endif
-    if v:throwpoint != ""
-      call assert_report('should not get here')
-    endif
-
-    while 1
-      try
-        Xpath 'e'
-        call T(4)
-        call assert_report('should not get here')
-      catch /.*/
-        Xpath 'f'
-        if v:exception != 'Vim:Interrupt'
-          call assert_report('should not get here')
-        endif
-        if v:throwpoint !~ 'function T'
-          call assert_report('should not get here')
-        endif
-        if v:throwpoint !~ '\<4\>'
-          call assert_report('should not get here')
-        endif
-      finally
-        Xpath 'g'
-        if v:exception != ""
-          call assert_report('should not get here')
-        endif
-        if v:throwpoint != ""
-          call assert_report('should not get here')
-        endif
-        break
-      endtry
-    endwhile
-
-    Xpath 'h'
-    if v:exception != ""
-      call assert_report('should not get here')
-    endif
-    if v:throwpoint != ""
-      call assert_report('should not get here')
-    endif
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('abcdefgh', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-"-------------------------------------------------------------------------------
-"
-" Test 59:  v:exception and v:throwpoint when discarding exceptions	    {{{1
-"
-"	    When a :catch clause is left by a ":break" etc or an error or
-"	    interrupt exception, v:exception and v:throwpoint are reset.  They
-"	    are not affected by an exception that is discarded before being
-"	    caught.
-"-------------------------------------------------------------------------------
-func Test_exception_info_on_discard()
-  CheckEnglish
-
-  let test =<< trim [CODE]
-    let sfile = expand("<sfile>")
-
-    while 1
-      try
-        throw "x1"
-      catch /.*/
-        break
-      endtry
-    endwhile
-    call assert_equal('', v:exception)
-    call assert_equal('', v:throwpoint)
-
-    while 1
-      try
-        throw "x2"
-      catch /.*/
-        break
-      finally
-        call assert_equal('', v:exception)
-        call assert_equal('', v:throwpoint)
-      endtry
-      break
-    endwhile
-    call assert_equal('', v:exception)
-    call assert_equal('', v:throwpoint)
-
-    while 1
-      try
-        let errcaught = 0
-        try
-          try
-            throw "x3"
-          catch /.*/
-            let lnum = expand("<sflnum>")
-            asdf
-          endtry
-        catch /.*/
-          let errcaught = 1
-          call assert_match('Vim:E492: Not an editor command:', v:exception)
-          call assert_match('line ' .. (lnum + 1), v:throwpoint)
-        endtry
-      finally
-        call assert_equal(1, errcaught)
-        break
-      endtry
-    endwhile
-    call assert_equal('', v:exception)
-    call assert_equal('', v:throwpoint)
-
-    Xpath 'a'
-
-    while 1
-      try
-        let intcaught = 0
-        try
-          try
-            throw "x4"
-          catch /.*/
-            let lnum = expand("<sflnum>")
-            call interrupt()
-          endtry
-        catch /.*/
-          let intcaught = 1
-          call assert_match('Vim:Interrupt', v:exception)
-          call assert_match('line ' .. (lnum + 1), v:throwpoint)
-        endtry
-      finally
-        call assert_equal(1, intcaught)
-        break
-      endtry
-    endwhile
-    call assert_equal('', v:exception)
-    call assert_equal('', v:throwpoint)
-
-    Xpath 'b'
-
-    while 1
-      try
-        let errcaught = 0
-        try
-          try
-            if 1
-              let lnum = expand("<sflnum>")
-              throw "x5"
-            " missing endif
-          catch /.*/
-            call assert_report('should not get here')
-          endtry
-        catch /.*/
-          let errcaught = 1
-          call assert_match('Vim(catch):E171: Missing :endif:', v:exception)
-          call assert_match('line ' .. (lnum + 3), v:throwpoint)
-        endtry
-      finally
-        call assert_equal(1, errcaught)
-        break
-      endtry
-    endwhile
-    call assert_equal('', v:exception)
-    call assert_equal('', v:throwpoint)
-
-    Xpath 'c'
-
-    try
-      while 1
-        try
-          throw "x6"
-        finally
-          break
-        endtry
-        break
-      endwhile
-    catch /.*/
-      call assert_report('should not get here')
-    endtry
-    call assert_equal('', v:exception)
-    call assert_equal('', v:throwpoint)
-
-    try
-      while 1
-        try
-          throw "x7"
-        finally
-          break
-        endtry
-        break
-      endwhile
-    catch /.*/
-      call assert_report('should not get here')
-    finally
-      call assert_equal('', v:exception)
-      call assert_equal('', v:throwpoint)
-    endtry
-    call assert_equal('', v:exception)
-    call assert_equal('', v:throwpoint)
-
-    while 1
-      try
-        let errcaught = 0
-        try
-          try
-            throw "x8"
-          finally
-            let lnum = expand("<sflnum>")
-            asdf
-          endtry
-        catch /.*/
-          let errcaught = 1
-          call assert_match('Vim:E492: Not an editor command:', v:exception)
-          call assert_match('line ' .. (lnum + 1), v:throwpoint)
-        endtry
-      finally
-        call assert_equal(1, errcaught)
-        break
-      endtry
-    endwhile
-    call assert_equal('', v:exception)
-    call assert_equal('', v:throwpoint)
-
-    Xpath 'd'
-
-    while 1
-      try
-        let intcaught = 0
-        try
-          try
-            throw "x9"
-          finally
-            let lnum = expand("<sflnum>")
-            call interrupt()
-          endtry
-        catch /.*/
-          let intcaught = 1
-          call assert_match('Vim:Interrupt', v:exception)
-          call assert_match('line ' .. (lnum + 1), v:throwpoint)
-        endtry
-      finally
-        call assert_equal(1, intcaught)
-        break
-      endtry
-    endwhile
-    call assert_equal('', v:exception)
-    call assert_equal('', v:throwpoint)
-
-    Xpath 'e'
-
-    while 1
-      try
-        let errcaught = 0
-        try
-          try
-            if 1
-              let lnum = expand("<sflnum>")
-              throw "x10"
-            " missing endif
-          finally
-            call assert_equal('', v:exception)
-            call assert_equal('', v:throwpoint)
-          endtry
-        catch /.*/
-          let errcaught = 1
-          call assert_match('Vim(finally):E171: Missing :endif:', v:exception)
-          call assert_match('line ' .. (lnum + 3), v:throwpoint)
-        endtry
-      finally
-        call assert_equal(1, errcaught)
-        break
-      endtry
-    endwhile
-    call assert_equal('', v:exception)
-    call assert_equal('', v:throwpoint)
-
-    Xpath 'f'
-
-    while 1
-      try
-        let errcaught = 0
-        try
-          try
-            if 1
-              let lnum = expand("<sflnum>")
-              throw "x11"
-            " missing endif
-          endtry
-        catch /.*/
-          let errcaught = 1
-          call assert_match('Vim(endtry):E171: Missing :endif:', v:exception)
-          call assert_match('line ' .. (lnum + 3), v:throwpoint)
-        endtry
-      finally
-        call assert_equal(1, errcaught)
-        break
-      endtry
-    endwhile
-    call assert_equal('', v:exception)
-    call assert_equal('', v:throwpoint)
-
-    Xpath 'g'
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('abcdefg', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-"-------------------------------------------------------------------------------
-"
-" Test 60:  (Re)throwing v:exception; :echoerr.				    {{{1
-"
-"	    A user exception can be rethrown after catching by throwing
-"	    v:exception.  An error or interrupt exception cannot be rethrown
-"	    because Vim exceptions cannot be faked.  A Vim exception using the
-"	    value of v:exception can, however, be triggered by the :echoerr
-"	    command.
-"-------------------------------------------------------------------------------
-
-func Test_rethrow_exception_1()
-  XpathINIT
-  try
-    try
-      Xpath 'a'
-      throw "oops"
-    catch /oops/
-      Xpath 'b'
-      throw v:exception	" rethrow user exception
-    catch /.*/
-      call assert_report('should not get here')
-    endtry
-  catch /^oops$/			" catches rethrown user exception
-    Xpath 'c'
-  catch /.*/
-    call assert_report('should not get here')
-  endtry
-  call assert_equal('abc', g:Xpath)
-endfunc
-
-func Test_rethrow_exception_2()
-  XpathINIT
-  try
-    let caught = 0
-    try
-      Xpath 'a'
-      write /n/o/n/w/r/i/t/a/b/l/e/_/f/i/l/e
-      call assert_report('should not get here')
-    catch /^Vim(write):/
-      let caught = 1
-      throw v:exception	" throw error: cannot fake Vim exception
-    catch /.*/
-      call assert_report('should not get here')
-    finally
-      Xpath 'b'
-      call assert_equal(1, caught)
-    endtry
-  catch /^Vim(throw):/	" catches throw error
-    let caught = caught + 1
-  catch /.*/
-    call assert_report('should not get here')
-  finally
-    Xpath 'c'
-    call assert_equal(2, caught)
-  endtry
-  call assert_equal('abc', g:Xpath)
-endfunc
-
-func Test_rethrow_exception_3()
-  XpathINIT
-  try
-    let caught = 0
-    try
-      Xpath 'a'
-      asdf
-    catch /^Vim/		" catch error exception
-      let caught = 1
-      " Trigger Vim error exception with value specified after :echoerr
-      let value = substitute(v:exception, '^Vim\((.*)\)\=:', '', "")
-      echoerr value
-    catch /.*/
-      call assert_report('should not get here')
-    finally
-      Xpath 'b'
-      call assert_equal(1, caught)
-    endtry
-  catch /^Vim(echoerr):/
-    let caught = caught + 1
-    call assert_match(value, v:exception)
-  catch /.*/
-    call assert_report('should not get here')
-  finally
-    Xpath 'c'
-    call assert_equal(2, caught)
-  endtry
-  call assert_equal('abc', g:Xpath)
-endfunc
-
-func Test_rethrow_exception_3()
-  XpathINIT
-  try
-    let errcaught = 0
-    try
-      Xpath 'a'
-      let intcaught = 0
-      call interrupt()
-    catch /^Vim:/		" catch interrupt exception
-      let intcaught = 1
-      " Trigger Vim error exception with value specified after :echoerr
-      echoerr substitute(v:exception, '^Vim\((.*)\)\=:', '', "")
-    catch /.*/
-      call assert_report('should not get here')
-    finally
-      Xpath 'b'
-      call assert_equal(1, intcaught)
-    endtry
-  catch /^Vim(echoerr):/
-    let errcaught = 1
-    call assert_match('Interrupt', v:exception)
-  finally
-    Xpath 'c'
-    call assert_equal(1, errcaught)
-  endtry
-  call assert_equal('abc', g:Xpath)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 61:  Catching interrupt exceptions				    {{{1
-"
-"	    When an interrupt occurs inside a :try/:endtry region, an
-"	    interrupt exception is thrown and can be caught.  Its value is
-"	    "Vim:Interrupt".  If the interrupt occurs after an error or a :throw
-"	    but before a matching :catch is reached, all following :catches of
-"	    that try block are ignored, but the interrupt exception can be
-"	    caught by the next surrounding try conditional.  An interrupt is
-"	    ignored when there is a previous interrupt that has not been caught
-"	    or causes a :finally clause to be executed.
-"-------------------------------------------------------------------------------
-
-func Test_catch_intr_exception()
-  let test =<< trim [CODE]
-    while 1
-      try
-        try
-          Xpath 'a'
-          call interrupt()
-          call assert_report('should not get here')
-        catch /^Vim:Interrupt$/
-          Xpath 'b'
-        finally
-          Xpath 'c'
-        endtry
-      catch /.*/
-        call assert_report('should not get here')
-      finally
-        Xpath 'd'
-        break
-      endtry
-    endwhile
-
-    while 1
-      try
-        try
-          try
-            Xpath 'e'
-            asdf
-            call assert_report('should not get here')
-          catch /do_not_catch/
-            call assert_report('should not get here')
-          catch /.*/
-            Xpath 'f'
-            call interrupt()
-            call assert_report('should not get here')
-          catch /.*/
-            call assert_report('should not get here')
-          finally
-            Xpath 'g'
-            call interrupt()
-            call assert_report('should not get here')
-          endtry
-        catch /^Vim:Interrupt$/
-          Xpath 'h'
-        finally
-          Xpath 'i'
-        endtry
-      catch /.*/
-        call assert_report('should not get here')
-      finally
-        Xpath 'j'
-        break
-      endtry
-    endwhile
-
-    while 1
-      try
-        try
-          try
-            Xpath 'k'
-            throw "x"
-            call assert_report('should not get here')
-          catch /do_not_catch/
-            call assert_report('should not get here')
-          catch /x/
-            Xpath 'l'
-            call interrupt()
-            call assert_report('should not get here')
-          catch /.*/
-            call assert_report('should not get here')
-          endtry
-        catch /^Vim:Interrupt$/
-          Xpath 'm'
-        finally
-          Xpath 'n'
-        endtry
-      catch /.*/
-        call assert_report('should not get here')
-      finally
-        Xpath 'o'
-        break
-      endtry
-    endwhile
-
-    while 1
-      try
-        try
-          Xpath 'p'
-          call interrupt()
-          call assert_report('should not get here')
-        catch /do_not_catch/
-          call interrupt()
-          call assert_report('should not get here')
-        catch /^Vim:Interrupt$/
-          Xpath 'q'
-        finally
-          Xpath 'r'
-        endtry
-      catch /.*/
-        call assert_report('should not get here')
-      finally
-        Xpath 's'
-        break
-      endtry
-    endwhile
-
-    Xpath 't'
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('abcdefghijklmnopqrst', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 62:  Catching error exceptions					    {{{1
-"
-"	    An error inside a :try/:endtry region is converted to an exception
-"	    and can be caught.  The error exception has a "Vim(cmdname):" prefix
-"	    where cmdname is the name of the failing command, or a "Vim:" prefix
-"	    if no command name is known.  The "Vim" prefixes cannot be faked.
-"-------------------------------------------------------------------------------
-
-func Test_catch_err_exception_1()
-  XpathINIT
-  while 1
-    try
-      try
-        let caught = 0
-        unlet novar
-      catch /^Vim(unlet):/
-        Xpath 'a'
-        let caught = 1
-        let v:errmsg = substitute(v:exception, '^Vim(unlet):', '', "")
-      finally
-        Xpath 'b'
-        call assert_equal(1, caught)
-        call assert_match('E108: No such variable: "novar"', v:errmsg)
-      endtry
-    catch /.*/
-      call assert_report('should not get here')
-    finally
-      Xpath 'c'
-      break
-    endtry
-    call assert_report('should not get here')
-  endwhile
-  call assert_equal('abc', g:Xpath)
-endfunc
-
-func Test_catch_err_exception_2()
-  XpathINIT
-  while 1
-    try
-      try
-        let caught = 0
-        throw novar			" error in :throw
-      catch /^Vim(throw):/
-        Xpath 'a'
-        let caught = 1
-        let v:errmsg = substitute(v:exception, '^Vim(throw):', '', "")
-      finally
-        Xpath 'b'
-        call assert_equal(1, caught)
-        call assert_match('E121: Undefined variable: novar', v:errmsg)
-      endtry
-    catch /.*/
-      call assert_report('should not get here')
-    finally
-      Xpath 'c'
-      break
-    endtry
-    call assert_report('should not get here')
-  endwhile
-  call assert_equal('abc', g:Xpath)
-endfunc
-
-func Test_catch_err_exception_3()
-  XpathINIT
-  while 1
-    try
-      try
-        let caught = 0
-        throw "Vim:faked"		" error: cannot fake Vim exception
-      catch /^Vim(throw):/
-        Xpath 'a'
-        let caught = 1
-        let v:errmsg = substitute(v:exception, '^Vim(throw):', '', "")
-      finally
-        Xpath 'b'
-        call assert_equal(1, caught)
-        call assert_match("E608: Cannot :throw exceptions with 'Vim' prefix",
-              \ v:errmsg)
-      endtry
-    catch /.*/
-      call assert_report('should not get here')
-    finally
-      Xpath 'c'
-      break
-    endtry
-    call assert_report('should not get here')
-  endwhile
-  call assert_equal('abc', g:Xpath)
-endfunc
-
-func Test_catch_err_exception_4()
-  XpathINIT
-  func F()
-    while 1
-    " Missing :endwhile
-  endfunc
-
-  while 1
-    try
-      try
-        let caught = 0
-        call F()
-      catch /^Vim(endfunction):/
-        Xpath 'a'
-        let caught = 1
-        let v:errmsg = substitute(v:exception, '^Vim(endfunction):', '', "")
-      finally
-        Xpath 'b'
-        call assert_equal(1, caught)
-        call assert_match("E170: Missing :endwhile", v:errmsg)
-      endtry
-    catch /.*/
-      call assert_report('should not get here')
-    finally
-      Xpath 'c'
-      break
-    endtry
-    call assert_report('should not get here')
-  endwhile
-  call assert_equal('abc', g:Xpath)
-  delfunc F
-endfunc
-
-func Test_catch_err_exception_5()
-  XpathINIT
-  func F()
-    while 1
-    " Missing :endwhile
-  endfunc
-
-  while 1
-    try
-      try
-        let caught = 0
-        ExecAsScript F
-      catch /^Vim:/
-        Xpath 'a'
-        let caught = 1
-        let v:errmsg = substitute(v:exception, '^Vim:', '', "")
-      finally
-        Xpath 'b'
-        call assert_equal(1, caught)
-        call assert_match("E170: Missing :endwhile", v:errmsg)
-      endtry
-    catch /.*/
-      call assert_report('should not get here')
-    finally
-      Xpath 'c'
-      break
-    endtry
-    call assert_report('should not get here')
-  endwhile
-  call assert_equal('abc', g:Xpath)
-  delfunc F
-endfunc
-
-func Test_catch_err_exception_6()
-  XpathINIT
-  func G()
-    call G()
-  endfunc
-
-  while 1
-    try
-      let mfd_save = &mfd
-      set mfd=3
-      try
-        let caught = 0
-        call G()
-      catch /^Vim(call):/
-        Xpath 'a'
-        let caught = 1
-        let v:errmsg = substitute(v:exception, '^Vim(call):', '', "")
-      finally
-        Xpath 'b'
-        call assert_equal(1, caught)
-        call assert_match("E132: Function call depth is higher than 'maxfuncdepth'", v:errmsg)
-      endtry
-    catch /.*/
-      call assert_report('should not get here')
-    finally
-      Xpath 'c'
-      let &mfd = mfd_save
-      break
-    endtry
-    call assert_report('should not get here')
-  endwhile
-  call assert_equal('abc', g:Xpath)
-  delfunc G
-endfunc
-
-func Test_catch_err_exception_7()
-  XpathINIT
-  func H()
-    return H()
-  endfunc
-
-  while 1
-    try
-      let mfd_save = &mfd
-      set mfd=3
-      try
-        let caught = 0
-        call H()
-      catch /^Vim(return):/
-        Xpath 'a'
-        let caught = 1
-        let v:errmsg = substitute(v:exception, '^Vim(return):', '', "")
-      finally
-        Xpath 'b'
-        call assert_equal(1, caught)
-        call assert_match("E132: Function call depth is higher than 'maxfuncdepth'", v:errmsg)
-      endtry
-    catch /.*/
-      call assert_report('should not get here')
-    finally
-      Xpath 'c'
-      let &mfd = mfd_save
-      break		" discard error for $VIMNOERRTHROW
-    endtry
-    call assert_report('should not get here')
-  endwhile
-
-  call assert_equal('abc', g:Xpath)
-  delfunc H
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 63:  Suppressing error exceptions by :silent!.			    {{{1
-"
-"	    A :silent! command inside a :try/:endtry region suppresses the
-"	    conversion of errors to an exception and the immediate abortion on
-"	    error.  When the commands executed by the :silent! themselves open
-"	    a new :try/:endtry region, conversion of errors to exception and
-"	    immediate abortion is switched on again - until the next :silent!
-"	    etc.  The :silent! has the effect of setting v:errmsg to the error
-"	    message text (without displaying it) and continuing with the next
-"	    script line.
-"
-"	    When a command triggering autocommands is executed by :silent!
-"	    inside a :try/:endtry, the autocommand execution is not suppressed
-"	    on error.
-"
-"	    This test reuses the function MSG() from the previous test.
-"-------------------------------------------------------------------------------
-
-func Test_silent_exception()
-  XpathINIT
-  XloopINIT
-  let g:taken = ""
-
-  func S(n) abort
-    XloopNEXT
-    let g:taken = g:taken . "E" . a:n
-    let v:errmsg = ""
-    exec "asdf" . a:n
-
-    " Check that ":silent!" continues:
-    Xloop 'a'
-
-    " Check that ":silent!" sets "v:errmsg":
-    call assert_match("E492: Not an editor command", v:errmsg)
-  endfunc
-
-  func Foo()
-    while 1
-      try
-        try
-          let caught = 0
-          " This is not silent:
-          call S(3)
-        catch /^Vim:/
-          Xpath 'b'
-          let caught = 1
-          let errmsg3 = substitute(v:exception, '^Vim:', '', "")
-          silent! call S(4)
-        finally
-          call assert_equal(1, caught)
-          Xpath 'c'
-          call assert_match("E492: Not an editor command", errmsg3)
-          silent! call S(5)
-          " Break out of try conditionals that cover ":silent!".  This also
-          " discards the aborting error when $VIMNOERRTHROW is non-zero.
-          break
-        endtry
-      catch /.*/
-        call assert_report('should not get here')
-      endtry
-    endwhile
-    " This is a double ":silent!" (see caller).
-    silent! call S(6)
-  endfunc
-
-  func Bar()
-    try
-      silent! call S(2)
-      silent! execute "call Foo() | call S(7)"
-      silent! call S(8)
-    endtry	" normal end of try cond that covers ":silent!"
-    " This has a ":silent!" from the caller:
-    call S(9)
-  endfunc
-
-  silent! call S(1)
-  silent! call Bar()
-  silent! call S(10)
-
-  call assert_equal("E1E2E3E4E5E6E7E8E9E10", g:taken)
-
-  augroup TMP
-    au!
-    autocmd BufWritePost * Xpath 'd'
-  augroup END
-
-  Xpath 'e'
-  silent! write /i/m/p/o/s/s/i/b/l/e
-  Xpath 'f'
-
-  call assert_equal('a2a3ba5ca6a7a8a9a10a11edf', g:Xpath)
-
-  augroup TMP
-    au!
-  augroup END
-  augroup! TMP
-  delfunction S
-  delfunction Foo
-  delfunction Bar
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 64:  Error exceptions after error, interrupt or :throw		    {{{1
-"
-"	    When an error occurs after an interrupt or a :throw but before
-"	    a matching :catch is reached, all following :catches of that try
-"	    block are ignored, but the error exception can be caught by the next
-"	    surrounding try conditional.  Any previous error exception is
-"	    discarded.  An error is ignored when there is a previous error that
-"	    has not been caught.
-"-------------------------------------------------------------------------------
-
-func Test_exception_after_error_1()
-  XpathINIT
-  while 1
-    try
-      try
-        Xpath 'a'
-        let caught = 0
-        while 1
-          if 1
-          " Missing :endif
-        endwhile	" throw error exception
-      catch /^Vim(/
-        Xpath 'b'
-        let caught = 1
-      finally
-        Xpath 'c'
-        call assert_equal(1, caught)
-      endtry
-    catch /.*/
-      call assert_report('should not get here')
-    finally
-      Xpath 'd'
-      break
-    endtry
-    call assert_report('should not get here')
-  endwhile
-  call assert_equal('abcd', g:Xpath)
-endfunc
-
-func Test_exception_after_error_2()
-  XpathINIT
-  while 1
-    try
-      try
-        Xpath 'a'
-        let caught = 0
-        try
-          if 1
-          " Missing :endif
-        catch /.*/	" throw error exception
-          call assert_report('should not get here')
-        catch /.*/
-          call assert_report('should not get here')
-        endtry
-      catch /^Vim(/
-        Xpath 'b'
-        let caught = 1
-      finally
-        Xpath 'c'
-        call assert_equal(1, caught)
-      endtry
-    catch /.*/
-      call assert_report('should not get here')
-    finally
-      Xpath 'd'
-      break
-    endtry
-    call assert_report('should not get here')
-  endwhile
-  call assert_equal('abcd', g:Xpath)
-endfunc
-
-func Test_exception_after_error_3()
-  XpathINIT
-  while 1
-    try
-      try
-        let caught = 0
-        try
-          Xpath 'a'
-          call interrupt()
-        catch /do_not_catch/
-          call assert_report('should not get here')
-          if 1
-          " Missing :endif
-        catch /.*/	" throw error exception
-          call assert_report('should not get here')
-        catch /.*/
-          call assert_report('should not get here')
-        endtry
-      catch /^Vim(/
-        Xpath 'b'
-        let caught = 1
-      finally
-        Xpath 'c'
-        call assert_equal(1, caught)
-      endtry
-    catch /.*/
-      call assert_report('should not get here')
-    finally
-      Xpath 'd'
-      break
-    endtry
-    call assert_report('should not get here')
-  endwhile
-  call assert_equal('abcd', g:Xpath)
-endfunc
-
-func Test_exception_after_error_4()
-  XpathINIT
-  while 1
-    try
-      try
-        let caught = 0
-        try
-          Xpath 'a'
-          throw "x"
-        catch /do_not_catch/
-          call assert_report('should not get here')
-          if 1
-          " Missing :endif
-        catch /x/	" throw error exception
-          call assert_report('should not get here')
-        catch /.*/
-          call assert_report('should not get here')
-        endtry
-      catch /^Vim(/
-        Xpath 'b'
-        let caught = 1
-      finally
-        Xpath 'c'
-        call assert_equal(1, caught)
-      endtry
-    catch /.*/
-      call assert_report('should not get here')
-    finally
-      Xpath 'd'
-      break
-    endtry
-    call assert_report('should not get here')
-  endwhile
-  call assert_equal('abcd', g:Xpath)
-endfunc
-
-func Test_exception_after_error_5()
-  XpathINIT
-  while 1
-    try
-      try
-        let caught = 0
-        Xpath 'a'
-        endif		" :endif without :if; throw error exception
-        if 1
-        " Missing :endif
-      catch /do_not_catch/ " ignore new error
-        call assert_report('should not get here')
-      catch /^Vim(endif):/
-        Xpath 'b'
-        let caught = 1
-      catch /^Vim(/
-        call assert_report('should not get here')
-      finally
-        Xpath 'c'
-        call assert_equal(1, caught)
-      endtry
-    catch /.*/
-      call assert_report('should not get here')
-    finally
-      Xpath 'd'
-      break
-    endtry
-    call assert_report('should not get here')
-  endwhile
-  call assert_equal('abcd', g:Xpath)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 65:  Errors in the /pattern/ argument of a :catch		    {{{1
-"
-"	    On an error in the /pattern/ argument of a :catch, the :catch does
-"	    not match.  Any following :catches of the same :try/:endtry don't
-"	    match either.  Finally clauses are executed.
-"-------------------------------------------------------------------------------
-
-func Test_catch_pattern_error()
-  CheckEnglish
-  XpathINIT
-
-  try
-    try
-      Xpath 'a'
-      throw "oops"
-    catch /^oops$/
-      Xpath 'b'
-    catch /\)/		" not checked; exception has already been caught
-      call assert_report('should not get here')
-    endtry
-    Xpath 'c'
-  catch /.*/
-    call assert_report('should not get here')
-  endtry
-  call assert_equal('abc', g:Xpath)
-
-  XpathINIT
-  func F()
-    try
-      try
-        try
-          Xpath 'a'
-          throw "ab"
-        catch /abc/	" does not catch
-          call assert_report('should not get here')
-        catch /\)/	" error; discards exception
-          call assert_report('should not get here')
-        catch /.*/	" not checked
-          call assert_report('should not get here')
-        finally
-          Xpath 'b'
-        endtry
-        call assert_report('should not get here')
-      catch /^ab$/	" checked, but original exception is discarded
-        call assert_report('should not get here')
-      catch /^Vim(catch):/
-        Xpath 'c'
-        call assert_match('Vim(catch):E475: Invalid argument:', v:exception)
-      finally
-        Xpath 'd'
-      endtry
-      Xpath 'e'
-    catch /.*/
-      call assert_report('should not get here')
-    endtry
-    Xpath 'f'
-  endfunc
-
-  call F()
-  call assert_equal('abcdef', g:Xpath)
-
-  delfunc F
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 66:  Stop range :call on error, interrupt, or :throw		    {{{1
-"
-"	    When a function which is multiply called for a range since it
-"	    doesn't handle the range itself has an error in a command
-"	    dynamically enclosed by :try/:endtry or gets an interrupt or
-"	    executes a :throw, no more calls for the remaining lines in the
-"	    range are made.  On an error in a command not dynamically enclosed
-"	    by :try/:endtry, the function is executed again for the remaining
-"	    lines in the range.
-"-------------------------------------------------------------------------------
-
-func Test_stop_range_on_error()
-  let test =<< trim [CODE]
-    let file = tempname()
-    exec "edit" file
-    call setline(1, ['line 1', 'line 2', 'line 3'])
-    let taken = ""
-    let expected = "G1EF1E(1)F1E(2)F1E(3)G2EF2E(1)G3IF3I(1)G4TF4T(1)G5AF5A(1)"
-
-    func F(reason, n) abort
-      let g:taken = g:taken .. "F" .. a:n ..
-                          \ substitute(a:reason, '\(\l\).*', '\u\1', "") ..
-                          \ "(" .. line(".") .. ")"
-
-      if a:reason == "error"
-        asdf
-      elseif a:reason == "interrupt"
-        call interrupt()
-      elseif a:reason == "throw"
-        throw "xyz"
-      elseif a:reason == "aborting error"
-        XloopNEXT
-        call assert_equal(g:taken, g:expected)
-        try
-          bwipeout!
-          call delete(g:file)
-          asdf
-        endtry
-      endif
-    endfunc
-
-    func G(reason, n)
-      let g:taken = g:taken .. "G" .. a:n ..
-                              \ substitute(a:reason, '\(\l\).*', '\u\1', "")
-      1,3call F(a:reason, a:n)
-    endfunc
-
-    Xpath 'a'
-    call G("error", 1)
-    try
-      Xpath 'b'
-      try
-        call G("error", 2)
-        call assert_report('should not get here')
-      finally
-        Xpath 'c'
-        try
-          call G("interrupt", 3)
-          call assert_report('should not get here')
-        finally
-          Xpath 'd'
-          try
-            call G("throw", 4)
-            call assert_report('should not get here')
-          endtry
-        endtry
-      endtry
-    catch /xyz/
-      Xpath 'e'
-    catch /.*/
-      call assert_report('should not get here')
-    endtry
-    Xpath 'f'
-    call G("aborting error", 5)
-    call assert_report('should not get here')
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('abcdef', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 67:  :throw across :call command					    {{{1
-"
-"	    On a call command, an exception might be thrown when evaluating the
-"	    function name, during evaluation of the arguments, or when the
-"	    function is being executed.  The exception can be caught by the
-"	    caller.
-"-------------------------------------------------------------------------------
-
-func THROW(x, n)
-  if a:n == 1
-    Xpath 'A'
-  elseif a:n == 2
-    Xpath 'B'
-  elseif a:n == 3
-    Xpath 'C'
-  endif
-  throw a:x
-endfunc
-
-func NAME(x, n)
-  if a:n == 1
-    call assert_report('should not get here')
-  elseif a:n == 2
-    Xpath 'D'
-  elseif a:n == 3
-    Xpath 'E'
-  elseif a:n == 4
-    Xpath 'F'
-  endif
-  return a:x
-endfunc
-
-func ARG(x, n)
-  if a:n == 1
-    call assert_report('should not get here')
-  elseif a:n == 2
-    call assert_report('should not get here')
-  elseif a:n == 3
-    Xpath 'G'
-  elseif a:n == 4
-    Xpath 'I'
-  endif
-  return a:x
-endfunc
-
-func Test_throw_across_call_cmd()
-  XpathINIT
-
-  func F(x, n)
-    if a:n == 2
-      call assert_report('should not get here')
-    elseif a:n == 4
-      Xpath 'a'
-    endif
-  endfunc
-
-  while 1
-    try
-      let v:errmsg = ""
-
-      while 1
-        try
-          Xpath 'b'
-          call {NAME(THROW("name", 1), 1)}(ARG(4711, 1), 1)
-          call assert_report('should not get here')
-        catch /^name$/
-          Xpath 'c'
-        catch /.*/
-          call assert_report('should not get here')
-        finally
-          call assert_equal("", v:errmsg)
-          let v:errmsg = ""
-          break
-        endtry
-      endwhile
-
-      while 1
-        try
-          Xpath 'd'
-          call {NAME("F", 2)}(ARG(THROW("arg", 2), 2), 2)
-          call assert_report('should not get here')
-        catch /^arg$/
-          Xpath 'e'
-        catch /.*/
-          call assert_report('should not get here')
-        finally
-          call assert_equal("", v:errmsg)
-          let v:errmsg = ""
-          break
-        endtry
-      endwhile
-
-      while 1
-        try
-          Xpath 'f'
-          call {NAME("THROW", 3)}(ARG("call", 3), 3)
-          call assert_report('should not get here')
-        catch /^call$/
-          Xpath 'g'
-        catch /^0$/	    " default return value
-          call assert_report('should not get here')
-        catch /.*/
-          call assert_report('should not get here')
-        finally
-          call assert_equal("", v:errmsg)
-          let v:errmsg = ""
-          break
-        endtry
-      endwhile
-
-      while 1
-        try
-          Xpath 'h'
-          call {NAME("F", 4)}(ARG(4711, 4), 4)
-          Xpath 'i'
-        catch /.*/
-          call assert_report('should not get here')
-        finally
-          call assert_equal("", v:errmsg)
-          let v:errmsg = ""
-          break
-        endtry
-      endwhile
-
-    catch /^0$/	    " default return value
-      call assert_report('should not get here')
-    catch /.*/
-      call assert_report('should not get here')
-    finally
-      call assert_equal("", v:errmsg)
-      let v:errmsg = ""
-      break
-    endtry
-  endwhile
-
-  call assert_equal('bAcdDBefEGCghFIai', g:Xpath)
-  delfunction F
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 68:  :throw across function calls in expressions			    {{{1
-"
-"	    On a function call within an expression, an exception might be
-"	    thrown when evaluating the function name, during evaluation of the
-"	    arguments, or when the function is being executed.  The exception
-"	    can be caught by the caller.
-"
-"	    This test reuses the functions THROW(), NAME(), and ARG() from the
-"	    previous test.
-"-------------------------------------------------------------------------------
-
-func Test_throw_across_call_expr()
-  XpathINIT
-
-  func F(x, n)
-    if a:n == 2
-      call assert_report('should not get here')
-    elseif a:n == 4
-      Xpath 'a'
-    endif
-    return a:x
-  endfunction
-
-  while 1
-    try
-      let error = 0
-      let v:errmsg = ""
-
-      while 1
-        try
-          Xpath 'b'
-          let var1 = {NAME(THROW("name", 1), 1)}(ARG(4711, 1), 1)
-          call assert_report('should not get here')
-        catch /^name$/
-          Xpath 'c'
-        catch /.*/
-          call assert_report('should not get here')
-        finally
-          call assert_equal("", v:errmsg)
-          let v:errmsg = ""
-          break
-        endtry
-      endwhile
-      call assert_true(!exists('var1'))
-
-      while 1
-        try
-          Xpath 'd'
-          let var2 = {NAME("F", 2)}(ARG(THROW("arg", 2), 2), 2)
-          call assert_report('should not get here')
-        catch /^arg$/
-          Xpath 'e'
-        catch /.*/
-          call assert_report('should not get here')
-        finally
-          call assert_equal("", v:errmsg)
-          let v:errmsg = ""
-          break
-        endtry
-      endwhile
-      call assert_true(!exists('var2'))
-
-      while 1
-        try
-          Xpath 'f'
-          let var3 = {NAME("THROW", 3)}(ARG("call", 3), 3)
-          call assert_report('should not get here')
-        catch /^call$/
-          Xpath 'g'
-        catch /^0$/	    " default return value
-          call assert_report('should not get here')
-        catch /.*/
-          call assert_report('should not get here')
-        finally
-          call assert_equal("", v:errmsg)
-          let v:errmsg = ""
-          break
-        endtry
-      endwhile
-      call assert_true(!exists('var3'))
-
-      while 1
-        try
-          Xpath 'h'
-          let var4 = {NAME("F", 4)}(ARG(4711, 4), 4)
-          Xpath 'i'
-        catch /.*/
-          call assert_report('should not get here')
-        finally
-          call assert_equal("", v:errmsg)
-          let v:errmsg = ""
-          break
-        endtry
-      endwhile
-      call assert_true(exists('var4') && var4 == 4711)
-
-    catch /^0$/	    " default return value
-      call assert_report('should not get here')
-    catch /.*/
-      call assert_report('should not get here')
-    finally
-      call assert_equal("", v:errmsg)
-      break
-    endtry
-  endwhile
-
-  call assert_equal('bAcdDBefEGCghFIai', g:Xpath)
-  delfunc F
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 76:  Errors, interrupts, :throw during expression evaluation	    {{{1
-"
-"	    When a function call made during expression evaluation is aborted
-"	    due to an error inside a :try/:endtry region or due to an interrupt
-"	    or a :throw, the expression evaluation is aborted as well.	No
-"	    message is displayed for the cancelled expression evaluation.  On an
-"	    error not inside :try/:endtry, the expression evaluation continues.
-"-------------------------------------------------------------------------------
-
-func Test_expr_eval_error()
-  let test =<< trim [CODE]
-    let taken = ""
-
-    func ERR(n)
-      let g:taken = g:taken .. "E" .. a:n
-      asdf
-    endfunc
-
-    func ERRabort(n) abort
-      let g:taken = g:taken .. "A" .. a:n
-      asdf
-    endfunc	" returns -1; may cause follow-up msg for illegal var/func name
-
-    func WRAP(n, arg)
-      let g:taken = g:taken .. "W" .. a:n
-      let g:saved_errmsg = v:errmsg
-      return arg
-    endfunc
-
-    func INT(n)
-      let g:taken = g:taken .. "I" .. a:n
-      call interrupt()
-    endfunc
-
-    func THR(n)
-      let g:taken = g:taken .. "T" .. a:n
-      throw "should not be caught"
-    endfunc
-
-    func CONT(n)
-      let g:taken = g:taken .. "C" .. a:n
-    endfunc
-
-    func MSG(n)
-      let g:taken = g:taken .. "M" .. a:n
-      let errmsg = (a:n >= 37 && a:n <= 44) ? g:saved_errmsg : v:errmsg
-      let msgptn = (a:n >= 10 && a:n <= 27) ? "^$" : "asdf"
-      call assert_match(msgptn, errmsg)
-      let v:errmsg = ""
-      let g:saved_errmsg = ""
-    endfunc
-
-    let v:errmsg = ""
-
-    try
-      let t = 1
-      while t <= 9
-        Xloop 'a'
-        try
-          if t == 1
-            let v{ERR(t) + CONT(t)} = 0
-          elseif t == 2
-            let v{ERR(t) + CONT(t)}
-          elseif t == 3
-            let var = exists('v{ERR(t) + CONT(t)}')
-          elseif t == 4
-            unlet v{ERR(t) + CONT(t)}
-          elseif t == 5
-            function F{ERR(t) + CONT(t)}()
-            endfunction
-          elseif t == 6
-            function F{ERR(t) + CONT(t)}
-          elseif t == 7
-            let var = exists('*F{ERR(t) + CONT(t)}')
-          elseif t == 8
-            delfunction F{ERR(t) + CONT(t)}
-          elseif t == 9
-            let var = ERR(t) + CONT(t)
-          endif
-        catch /asdf/
-          " v:errmsg is not set when the error message is converted to an
-          " exception.  Set it to the original error message.
-          let v:errmsg = substitute(v:exception, '^Vim:', '', "")
-        catch /^Vim\((\a\+)\)\=:/
-          " An error exception has been thrown after the original error.
-          let v:errmsg = ""
-        finally
-          call MSG(t)
-          let t = t + 1
-          XloopNEXT
-          continue	" discard an aborting error
-        endtry
-      endwhile
-    catch /.*/
-      call assert_report('should not get here')
-    endtry
-
-    try
-      let t = 10
-      while t <= 18
-        Xloop 'b'
-        try
-          if t == 10
-            let v{INT(t) + CONT(t)} = 0
-          elseif t == 11
-            let v{INT(t) + CONT(t)}
-          elseif t == 12
-            let var = exists('v{INT(t) + CONT(t)}')
-          elseif t == 13
-            unlet v{INT(t) + CONT(t)}
-          elseif t == 14
-            function F{INT(t) + CONT(t)}()
-            endfunction
-          elseif t == 15
-            function F{INT(t) + CONT(t)}
-          elseif t == 16
-            let var = exists('*F{INT(t) + CONT(t)}')
-          elseif t == 17
-            delfunction F{INT(t) + CONT(t)}
-          elseif t == 18
-            let var = INT(t) + CONT(t)
-          endif
-        catch /^Vim\((\a\+)\)\=:\(Interrupt\)\@!/
-          " An error exception has been triggered after the interrupt.
-          let v:errmsg = substitute(v:exception, '^Vim\((\a\+)\)\=:', '', "")
-        finally
-          call MSG(t)
-          let t = t + 1
-          XloopNEXT
-          continue	" discard interrupt
-        endtry
-      endwhile
-    catch /.*/
-      call assert_report('should not get here')
-    endtry
-
-    try
-      let t = 19
-      while t <= 27
-        Xloop 'c'
-        try
-          if t == 19
-            let v{THR(t) + CONT(t)} = 0
-          elseif t == 20
-            let v{THR(t) + CONT(t)}
-          elseif t == 21
-            let var = exists('v{THR(t) + CONT(t)}')
-          elseif t == 22
-            unlet v{THR(t) + CONT(t)}
-          elseif t == 23
-            function F{THR(t) + CONT(t)}()
-            endfunction
-          elseif t == 24
-            function F{THR(t) + CONT(t)}
-          elseif t == 25
-            let var = exists('*F{THR(t) + CONT(t)}')
-          elseif t == 26
-            delfunction F{THR(t) + CONT(t)}
-          elseif t == 27
-            let var = THR(t) + CONT(t)
-          endif
-        catch /^Vim\((\a\+)\)\=:/
-          " An error exception has been triggered after the :throw.
-          let v:errmsg = substitute(v:exception, '^Vim\((\a\+)\)\=:', '', "")
-        finally
-          call MSG(t)
-          let t = t + 1
-          XloopNEXT
-          continue	" discard exception
-        endtry
-      endwhile
-    catch /.*/
-      call assert_report('should not get here')
-    endtry
-
-    let v{ERR(28) + CONT(28)} = 0
-    call MSG(28)
-    let v{ERR(29) + CONT(29)}
-    call MSG(29)
-    let var = exists('v{ERR(30) + CONT(30)}')
-    call MSG(30)
-    unlet v{ERR(31) + CONT(31)}
-    call MSG(31)
-    function F{ERR(32) + CONT(32)}()
-    endfunction
-    call MSG(32)
-    function F{ERR(33) + CONT(33)}
-    call MSG(33)
-    let var = exists('*F{ERR(34) + CONT(34)}')
-    call MSG(34)
-    delfunction F{ERR(35) + CONT(35)}
-    call MSG(35)
-    let var = ERR(36) + CONT(36)
-    call MSG(36)
-
-    let saved_errmsg = ""
-
-    let v{WRAP(37, ERRabort(37)) + CONT(37)} = 0
-    call MSG(37)
-    let v{WRAP(38, ERRabort(38)) + CONT(38)}
-    call MSG(38)
-    let var = exists('v{WRAP(39, ERRabort(39)) + CONT(39)}')
-    call MSG(39)
-    unlet v{WRAP(40, ERRabort(40)) + CONT(40)}
-    call MSG(40)
-    function F{WRAP(41, ERRabort(41)) + CONT(41)}()
-    endfunction
-    call MSG(41)
-    function F{WRAP(42, ERRabort(42)) + CONT(42)}
-    call MSG(42)
-    let var = exists('*F{WRAP(43, ERRabort(43)) + CONT(43)}')
-    call MSG(43)
-    delfunction F{WRAP(44, ERRabort(44)) + CONT(44)}
-    call MSG(44)
-    let var = ERRabort(45) + CONT(45)
-    call MSG(45)
-    Xpath 'd'
-
-    let expected = ""
-          \ .. "E1M1E2M2E3M3E4M4E5M5E6M6E7M7E8M8E9M9"
-          \ .. "I10M10I11M11I12M12I13M13I14M14I15M15I16M16I17M17I18M18"
-          \ .. "T19M19T20M20T21M21T22M22T23M23T24M24T25M25T26M26T27M27"
-          \ .. "E28C28M28E29C29M29E30C30M30E31C31M31E32C32M32E33C33M33"
-          \ .. "E34C34M34E35C35M35E36C36M36"
-          \ .. "A37W37C37M37A38W38C38M38A39W39C39M39A40W40C40M40A41W41C41M41"
-          \ .. "A42W42C42M42A43W43C43M43A44W44C44M44A45C45M45"
-    call assert_equal(expected, taken)
-  [CODE]
-  let verify =<< trim [CODE]
-    let expected = "a1a2a3a4a5a6a7a8a9"
-                      \ .. "b10b11b12b13b14b15b16b17b18"
-                      \ .. "c19c20c21c22c23c24c25c26c27d"
-    call assert_equal(expected, g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 77:  Errors, interrupts, :throw in name{brace-expression}	    {{{1
-"
-"	    When a function call made during evaluation of an expression in
-"	    braces as part of a function name after ":function" is aborted due
-"	    to an error inside a :try/:endtry region or due to an interrupt or
-"	    a :throw, the expression evaluation is aborted as well, and the
-"	    function definition is ignored, skipping all commands to the
-"	    ":endfunction".  On an error not inside :try/:endtry, the expression
-"	    evaluation continues and the function gets defined, and can be
-"	    called and deleted.
-"-------------------------------------------------------------------------------
-func Test_brace_expr_error()
-  let test =<< trim [CODE]
-    func ERR() abort
-      Xloop 'a'
-      asdf
-    endfunc					" returns -1
-
-    func OK()
-      Xloop 'b'
-      let v:errmsg = ""
-      return 0
-    endfunc
-
-    let v:errmsg = ""
-
-    Xpath 'c'
-    func F{1 + ERR() + OK()}(arg)
-      " F0 should be defined.
-      if exists("a:arg") && a:arg == "calling"
-        Xpath 'd'
-      else
-        call assert_report('should not get here')
-      endif
-    endfunction
-    call assert_equal("", v:errmsg)
-    XloopNEXT
-
-    Xpath 'e'
-    call F{1 + ERR() + OK()}("calling")
-    call assert_equal("", v:errmsg)
-    XloopNEXT
-
-    Xpath 'f'
-    delfunction F{1 + ERR() + OK()}
-    call assert_equal("", v:errmsg)
-    XloopNEXT
-
-    try
-      while 1
-        try
-          Xpath 'g'
-          func G{1 + ERR() + OK()}(arg)
-            " G0 should not be defined, and the function body should be
-            " skipped.
-            call assert_report('should not get here')
-            " Use an unmatched ":finally" to check whether the body is
-            " skipped when an error occurs in ERR().  This works whether or
-            " not the exception is converted to an exception.
-            finally
-              call assert_report('should not get here')
-            endtry
-          try
-            call assert_report('should not get here')
-          endfunction
-
-          call assert_report('should not get here')
-        catch /asdf/
-          " Jumped to when the function is not defined and the body is
-          " skipped.
-          Xpath 'h'
-        catch /.*/
-          call assert_report('should not get here')
-        finally
-          Xpath 'i'
-          break
-        endtry			" jumped to when the body is not skipped
-      endwhile
-    catch /.*/
-      call assert_report('should not get here')
-    endtry
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('ca1b1ea2b2dfa3b3ga4hi', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 78:  Messages on parsing errors in expression evaluation		    {{{1
-"
-"	    When an expression evaluation detects a parsing error, an error
-"	    message is given and converted to an exception, and the expression
-"	    evaluation is aborted.
-"-------------------------------------------------------------------------------
-func Test_expr_eval_error_msg()
-  CheckEnglish
-
-  let test =<< trim [CODE]
-    let taken = ""
-
-    func F(n)
-      let g:taken = g:taken . "F" . a:n
-    endfunc
-
-    func MSG(n, enr, emsg)
-      let g:taken = g:taken . "M" . a:n
-      call assert_match('^' .. a:enr .. ':', v:errmsg)
-      call assert_match(a:emsg, v:errmsg)
-    endfunc
-
-    func CONT(n)
-      let g:taken = g:taken . "C" . a:n
-    endfunc
-
-    let v:errmsg = ""
-    try
-      let t = 1
-      while t <= 14
-        let g:taken = g:taken . "T" . t
-        let v:errmsg = ""
-        try
-          if t == 1
-            let v{novar + CONT(t)} = 0
-          elseif t == 2
-            let v{novar + CONT(t)}
-          elseif t == 3
-            let var = exists('v{novar + CONT(t)}')
-          elseif t == 4
-            unlet v{novar + CONT(t)}
-          elseif t == 5
-            function F{novar + CONT(t)}()
-            endfunction
-          elseif t == 6
-            function F{novar + CONT(t)}
-          elseif t == 7
-            let var = exists('*F{novar + CONT(t)}')
-          elseif t == 8
-            delfunction F{novar + CONT(t)}
-          elseif t == 9
-            echo novar + CONT(t)
-          elseif t == 10
-            echo v{novar + CONT(t)}
-          elseif t == 11
-            echo F{novar + CONT(t)}
-          elseif t == 12
-            let var = novar + CONT(t)
-          elseif t == 13
-            let var = v{novar + CONT(t)}
-          elseif t == 14
-            let var = F{novar + CONT(t)}()
-          endif
-        catch /^Vim\((\a\+)\)\=:/
-          Xloop 'a'
-          " v:errmsg is not set when the error message is converted to an
-          " exception.  Set it to the original error message.
-          let v:errmsg = substitute(v:exception, '^Vim\((\a\+)\)\=:', '', "")
-        finally
-          Xloop 'b'
-          if t <= 8 && t != 3 && t != 7
-            call MSG(t, 'E475', 'Invalid argument\>')
-          else
-            call MSG(t, 'E121', "Undefined variable")
-          endif
-          let t = t + 1
-          XloopNEXT
-          continue	" discard an aborting error
-        endtry
-      endwhile
-    catch /.*/
-      call assert_report('should not get here')
-    endtry
-
-    func T(n, expr, enr, emsg)
-      try
-        let g:taken = g:taken . "T" . a:n
-        let v:errmsg = ""
-        try
-          execute "let var = " . a:expr
-        catch /^Vim\((\a\+)\)\=:/
-          Xloop 'c'
-          " v:errmsg is not set when the error message is converted to an
-          " exception.  Set it to the original error message.
-          let v:errmsg = substitute(v:exception, '^Vim\((\a\+)\)\=:', '', "")
-        finally
-          Xloop 'd'
-          call MSG(a:n, a:enr, a:emsg)
-          XloopNEXT
-          " Discard an aborting error:
-          return
-        endtry
-      catch /.*/
-        call assert_report('should not get here')
-      endtry
-    endfunc
-
-    call T(15, 'Nofunc() + CONT(15)',	'E117',	"Unknown function")
-    call T(16, 'F(1 2 + CONT(16))',	'E116',	"Invalid arguments")
-    call T(17, 'F(1, 2) + CONT(17)',	'E118',	"Too many arguments")
-    call T(18, 'F() + CONT(18)',	'E119',	"Not enough arguments")
-    call T(19, '{(1} + CONT(19)',	'E110',	"Missing ')'")
-    call T(20, '("abc"[1) + CONT(20)',	'E111',	"Missing ']'")
-    call T(21, '(1 +) + CONT(21)',	'E15',	"Invalid expression")
-    call T(22, '1 2 + CONT(22)',	'E488',	"Trailing characters: 2 +")
-    call T(23, '(1 ? 2) + CONT(23)',	'E109',	"Missing ':' after '?'")
-    call T(24, '("abc) + CONT(24)',	'E114',	"Missing quote")
-    call T(25, "('abc) + CONT(25)",	'E115',	"Missing quote")
-    call T(26, '& + CONT(26)',		'E112', "Option name missing")
-    call T(27, '&asdf + CONT(27)',	'E113', "Unknown option")
-
-    let expected = ""
-      \ .. "T1M1T2M2T3M3T4M4T5M5T6M6T7M7T8M8T9M9T10M10T11M11T12M12T13M13T14M14"
-      \ .. "T15M15T16M16T17M17T18M18T19M19T20M20T21M21T22M22T23M23T24M24T25M25"
-      \ .. "T26M26T27M27"
-
-    call assert_equal(expected, taken)
-  [CODE]
-  let verify =<< trim [CODE]
-    let expected = "a1b1a2b2a3b3a4b4a5b5a6b6a7b7a8b8a9b9a10b10a11b11a12b12"
-                  \ .. "a13b13a14b14c15d15c16d16c17d17c18d18c19d19c20d20"
-                  \ .. "c21d21c22d22c23d23c24d24c25d25c26d26c27d27"
-    call assert_equal(expected, g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 79:  Throwing one of several errors for the same command		    {{{1
-"
-"	    When several errors appear in a row (for instance during expression
-"	    evaluation), the first as the most specific one is used when
-"	    throwing an error exception.  If, however, a syntax error is
-"	    detected afterwards, this one is used for the error exception.
-"	    On a syntax error, the next command is not executed, on a normal
-"	    error, however, it is (relevant only in a function without the
-"	    "abort" flag).  v:errmsg is not set.
-"
-"	    If throwing error exceptions is configured off, v:errmsg is always
-"	    set to the latest error message, that is, to the more general
-"	    message or the syntax error, respectively.
-"-------------------------------------------------------------------------------
-func Test_throw_multi_error()
-  CheckEnglish
-
-  let test =<< trim [CODE]
-    func NEXT(cmd)
-      exec a:cmd . " | Xloop 'a'"
-    endfun
-
-    call NEXT('echo novar')			" (checks nextcmd)
-    XloopNEXT
-    call NEXT('let novar #')			" (skips nextcmd)
-    XloopNEXT
-    call NEXT('unlet novar #')			" (skips nextcmd)
-    XloopNEXT
-    call NEXT('let {novar}')			" (skips nextcmd)
-    XloopNEXT
-    call NEXT('unlet{ novar}')			" (skips nextcmd)
-
-    call assert_equal('a1', g:Xpath)
-    XpathINIT
-    XloopINIT
-
-    func EXEC(cmd)
-      exec a:cmd
-    endfunc
-
-    try
-      while 1				" dummy loop
-        try
-          let v:errmsg = ""
-          call EXEC('echo novar')	" normal error
-        catch /^Vim\((\a\+)\)\=:/
-          Xpath 'b'
-          call assert_match('E121: Undefined variable: novar', v:exception)
-        finally
-          Xpath 'c'
-          call assert_equal("", v:errmsg)
-          break
-        endtry
-      endwhile
-
-      Xpath 'd'
-      let cmd = "let"
-      while cmd != ""
-        try
-          let v:errmsg = ""
-          call EXEC(cmd . ' novar #')		" normal plus syntax error
-        catch /^Vim\((\a\+)\)\=:/
-          Xloop 'e'
-          call assert_match('E488: Trailing characters', v:exception)
-        finally
-          Xloop 'f'
-          call assert_equal("", v:errmsg)
-          if cmd == "let"
-            let cmd = "unlet"
-          else
-            let cmd = ""
-          endif
-          XloopNEXT
-          continue
-        endtry
-      endwhile
-
-      Xpath 'g'
-      let cmd = "let"
-      while cmd != ""
-        try
-          let v:errmsg = ""
-          call EXEC(cmd . ' {novar}')		" normal plus syntax error
-        catch /^Vim\((\a\+)\)\=:/
-          Xloop 'h'
-          call assert_match('E475: Invalid argument: {novar}', v:exception)
-        finally
-          Xloop 'i'
-          call assert_equal("", v:errmsg)
-          if cmd == "let"
-            let cmd = "unlet"
-          else
-            let cmd = ""
-          endif
-          XloopNEXT
-          continue
-        endtry
-      endwhile
-    catch /.*/
-      call assert_report('should not get here')
-    endtry
-    Xpath 'j'
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('bcde1f1e2f2gh3i3h4i4j', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 80:  Syntax error in expression for illegal :elseif		    {{{1
-"
-"	    If there is a syntax error in the expression after an illegal
-"	    :elseif, an error message is given (or an error exception thrown)
-"	    for the illegal :elseif rather than the expression error.
-"-------------------------------------------------------------------------------
-func Test_if_syntax_error()
-  CheckEnglish
-
-  let test =<< trim [CODE]
-    let v:errmsg = ""
-    if 0
-    else
-    elseif 1 ||| 2
-    endif
-    Xpath 'a'
-    call assert_match('E584: :elseif after :else', v:errmsg)
-
-    let v:errmsg = ""
-    if 1
-    else
-    elseif 1 ||| 2
-    endif
-    Xpath 'b'
-    call assert_match('E584: :elseif after :else', v:errmsg)
-
-    let v:errmsg = ""
-    elseif 1 ||| 2
-    Xpath 'c'
-    call assert_match('E582: :elseif without :if', v:errmsg)
-
-    let v:errmsg = ""
-    while 1
-      elseif 1 ||| 2
-    endwhile
-    Xpath 'd'
-    call assert_match('E582: :elseif without :if', v:errmsg)
-
-    while 1
-      try
-        try
-          let v:errmsg = ""
-          if 0
-          else
-          elseif 1 ||| 2
-          endif
-        catch /^Vim\((\a\+)\)\=:/
-          Xpath 'e'
-          call assert_match('E584: :elseif after :else', v:exception)
-        finally
-          Xpath 'f'
-          call assert_equal("", v:errmsg)
-        endtry
-      catch /.*/
-      call assert_report('should not get here')
-      finally
-        Xpath 'g'
-        break
-      endtry
-    endwhile
-
-    while 1
-      try
-        try
-          let v:errmsg = ""
-          if 1
-          else
-          elseif 1 ||| 2
-          endif
-        catch /^Vim\((\a\+)\)\=:/
-          Xpath 'h'
-          call assert_match('E584: :elseif after :else', v:exception)
-        finally
-          Xpath 'i'
-          call assert_equal("", v:errmsg)
-        endtry
-      catch /.*/
-        call assert_report('should not get here')
-      finally
-        Xpath 'j'
-        break
-      endtry
-    endwhile
-
-    while 1
-      try
-        try
-          let v:errmsg = ""
-          elseif 1 ||| 2
-        catch /^Vim\((\a\+)\)\=:/
-          Xpath 'k'
-          call assert_match('E582: :elseif without :if', v:exception)
-        finally
-          Xpath 'l'
-          call assert_equal("", v:errmsg)
-        endtry
-      catch /.*/
-        call assert_report('should not get here')
-      finally
-        Xpath 'm'
-        break
-      endtry
-    endwhile
-
-    while 1
-      try
-        try
-          let v:errmsg = ""
-          while 1
-              elseif 1 ||| 2
-          endwhile
-        catch /^Vim\((\a\+)\)\=:/
-          Xpath 'n'
-          call assert_match('E582: :elseif without :if', v:exception)
-        finally
-          Xpath 'o'
-          call assert_equal("", v:errmsg)
-        endtry
-      catch /.*/
-        call assert_report('should not get here')
-      finally
-        Xpath 'p'
-        break
-      endtry
-    endwhile
-    Xpath 'q'
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('abcdefghijklmnopq', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 81:  Discarding exceptions after an error or interrupt		    {{{1
-"
-"	    When an exception is thrown from inside a :try conditional without
-"	    :catch and :finally clauses and an error or interrupt occurs before
-"	    the :endtry is reached, the exception is discarded.
-"-------------------------------------------------------------------------------
-
-func Test_discard_exception_after_error_1()
-  let test =<< trim [CODE]
-    try
-      Xpath 'a'
-      try
-        Xpath 'b'
-        throw "arrgh"
-        call assert_report('should not get here')
-        if 1
-        call assert_report('should not get here')
-        " error after :throw: missing :endif
-      endtry
-      call assert_report('should not get here')
-    catch /arrgh/
-      call assert_report('should not get here')
-    endtry
-    call assert_report('should not get here')
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('ab', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-" interrupt the code before the endtry is invoked
-func Test_discard_exception_after_error_2()
-  XpathINIT
-  let lines =<< trim [CODE]
-    try
-      Xpath 'a'
-      try
-        Xpath 'b'
-        throw "arrgh"
-        call assert_report('should not get here')
-      endtry                      " interrupt here
-      call assert_report('should not get here')
-    catch /arrgh/
-      call assert_report('should not get here')
-    endtry
-    call assert_report('should not get here')
-  [CODE]
-  call writefile(lines, 'Xscript')
-
-  breakadd file 7 Xscript
-  try
-    let caught_intr = 0
-    debuggreedy
-    call feedkeys(":source Xscript\<CR>quit\<CR>", "xt")
-  catch /^Vim:Interrupt$/
-    call assert_match('Xscript, line 7', v:throwpoint)
-    let caught_intr = 1
-  endtry
-  0debuggreedy
-  call assert_equal(1, caught_intr)
-  call assert_equal('ab', g:Xpath)
-  breakdel *
-  call delete('Xscript')
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 82:  Ignoring :catch clauses after an error or interrupt		    {{{1
-"
-"	    When an exception is thrown and an error or interrupt occurs before
-"	    the matching :catch clause is reached, the exception is discarded
-"	    and the :catch clause is ignored (also for the error or interrupt
-"	    exception being thrown then).
-"-------------------------------------------------------------------------------
-
-func Test_ignore_catch_after_error_1()
-  let test =<< trim [CODE]
-    try
-      try
-        Xpath 'a'
-        throw "arrgh"
-        call assert_report('should not get here')
-        if 1
-        call assert_report('should not get here')
-        " error after :throw: missing :endif
-      catch /.*/
-        call assert_report('should not get here')
-      catch /.*/
-        call assert_report('should not get here')
-      endtry
-      call assert_report('should not get here')
-    catch /arrgh/
-      call assert_report('should not get here')
-    endtry
-    call assert_report('should not get here')
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('a', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-func Test_ignore_catch_after_error_2()
-  let test =<< trim [CODE]
-    func E()
-      try
-        try
-          Xpath 'a'
-          throw "arrgh"
-          call assert_report('should not get here')
-          if 1
-          call assert_report('should not get here')
-          " error after :throw: missing :endif
-        catch /.*/
-          call assert_report('should not get here')
-        catch /.*/
-          call assert_report('should not get here')
-        endtry
-        call assert_report('should not get here')
-      catch /arrgh/
-        call assert_report('should not get here')
-      endtry
-    endfunc
-
-    call E()
-    call assert_report('should not get here')
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('a', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-" interrupt right before a catch is invoked in a script
-func Test_ignore_catch_after_intr_1()
-  XpathINIT
-  let lines =<< trim [CODE]
-    try
-      try
-        Xpath 'a'
-        throw "arrgh"
-        call assert_report('should not get here')
-      catch /.*/              " interrupt here
-        call assert_report('should not get here')
-      catch /.*/
-        call assert_report('should not get here')
-      endtry
-      call assert_report('should not get here')
-    catch /arrgh/
-      call assert_report('should not get here')
-    endtry
-    call assert_report('should not get here')
-  [CODE]
-  call writefile(lines, 'Xscript')
-
-  breakadd file 6 Xscript
-  try
-    let caught_intr = 0
-    debuggreedy
-    call feedkeys(":source Xscript\<CR>quit\<CR>", "xt")
-  catch /^Vim:Interrupt$/
-    call assert_match('Xscript, line 6', v:throwpoint)
-    let caught_intr = 1
-  endtry
-  0debuggreedy
-  call assert_equal(1, caught_intr)
-  call assert_equal('a', g:Xpath)
-  breakdel *
-  call delete('Xscript')
-endfunc
-
-" interrupt right before a catch is invoked inside a function.
-func Test_ignore_catch_after_intr_2()
-  XpathINIT
-  func F()
-    try
-      try
-        Xpath 'a'
-        throw "arrgh"
-        call assert_report('should not get here')
-      catch /.*/              " interrupt here
-        call assert_report('should not get here')
-      catch /.*/
-        call assert_report('should not get here')
-      endtry
-      call assert_report('should not get here')
-    catch /arrgh/
-      call assert_report('should not get here')
-    endtry
-    call assert_report('should not get here')
-  endfunc
-
-  breakadd func 6 F
-  try
-    let caught_intr = 0
-    debuggreedy
-    call feedkeys(":call F()\<CR>quit\<CR>", "xt")
-  catch /^Vim:Interrupt$/
-    call assert_match('\.F, line 6', v:throwpoint)
-    let caught_intr = 1
-  endtry
-  0debuggreedy
-  call assert_equal(1, caught_intr)
-  call assert_equal('a', g:Xpath)
-  breakdel *
-  delfunc F
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 83:  Executing :finally clauses after an error or interrupt	    {{{1
-"
-"	    When an exception is thrown and an error or interrupt occurs before
-"	    the :finally of the innermost :try is reached, the exception is
-"	    discarded and the :finally clause is executed.
-"-------------------------------------------------------------------------------
-
-func Test_finally_after_error()
-  let test =<< trim [CODE]
-    try
-      Xpath 'a'
-      try
-        Xpath 'b'
-        throw "arrgh"
-        call assert_report('should not get here')
-        if 1
-        call assert_report('should not get here')
-        " error after :throw: missing :endif
-      finally
-        Xpath 'c'
-      endtry
-      call assert_report('should not get here')
-    catch /arrgh/
-      call assert_report('should not get here')
-    endtry
-    call assert_report('should not get here')
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('abc', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-" interrupt the code right before the finally is invoked
-func Test_finally_after_intr()
-  XpathINIT
-  let lines =<< trim [CODE]
-    try
-      Xpath 'a'
-      try
-        Xpath 'b'
-        throw "arrgh"
-        call assert_report('should not get here')
-      finally		" interrupt here
-        Xpath 'c'
-      endtry
-      call assert_report('should not get here')
-    catch /arrgh/
-      call assert_report('should not get here')
-    endtry
-    call assert_report('should not get here')
-  [CODE]
-  call writefile(lines, 'Xscript')
-
-  breakadd file 7 Xscript
-  try
-    let caught_intr = 0
-    debuggreedy
-    call feedkeys(":source Xscript\<CR>quit\<CR>", "xt")
-  catch /^Vim:Interrupt$/
-    call assert_match('Xscript, line 7', v:throwpoint)
-    let caught_intr = 1
-  endtry
-  0debuggreedy
-  call assert_equal(1, caught_intr)
-  call assert_equal('abc', g:Xpath)
-  breakdel *
-  call delete('Xscript')
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 84:  Exceptions in autocommand sequences.			    {{{1
-"
-"	    When an exception occurs in a sequence of autocommands for
-"	    a specific event, the rest of the sequence is not executed.  The
-"	    command that triggered the autocommand execution aborts, and the
-"	    exception is propagated to the caller.
-"
-"	    For the FuncUndefined event under a function call expression or
-"	    :call command, the function is not executed, even when it has
-"	    been defined by the autocommands before the exception occurred.
-"-------------------------------------------------------------------------------
-
-func Test_autocmd_exception()
-  let test =<< trim [CODE]
-    func INT()
-      call interrupt()
-    endfunc
-
-    aug TMP
-      autocmd!
-
-      autocmd User x1 Xpath 'a'
-      autocmd User x1 throw "x1"
-      autocmd User x1 call assert_report('should not get here')
-
-      autocmd User x2 Xpath 'b'
-      autocmd User x2 asdf
-      autocmd User x2 call assert_report('should not get here')
-
-      autocmd User x3 Xpath 'c'
-      autocmd User x3 call INT()
-      autocmd User x3 call assert_report('should not get here')
-
-      autocmd FuncUndefined U1 func U1()
-      autocmd FuncUndefined U1   call assert_report('should not get here')
-      autocmd FuncUndefined U1 endfunc
-      autocmd FuncUndefined U1 Xpath 'd'
-      autocmd FuncUndefined U1 throw "U1"
-      autocmd FuncUndefined U1 call assert_report('should not get here')
-
-      autocmd FuncUndefined U2 func U2()
-      autocmd FuncUndefined U2   call assert_report('should not get here')
-      autocmd FuncUndefined U2 endfunc
-      autocmd FuncUndefined U2 Xpath 'e'
-      autocmd FuncUndefined U2 ASDF
-      autocmd FuncUndefined U2 call assert_report('should not get here')
-
-      autocmd FuncUndefined U3 func U3()
-      autocmd FuncUndefined U3   call assert_report('should not get here')
-      autocmd FuncUndefined U3 endfunc
-      autocmd FuncUndefined U3 Xpath 'f'
-      autocmd FuncUndefined U3 call INT()
-      autocmd FuncUndefined U3 call assert_report('should not get here')
-    aug END
-
-    try
-      try
-        Xpath 'g'
-        doautocmd User x1
-      catch /x1/
-        Xpath 'h'
-      endtry
-
-      while 1
-        try
-          Xpath 'i'
-          doautocmd User x2
-        catch /asdf/
-          Xpath 'j'
-        finally
-          Xpath 'k'
-          break
-        endtry
-      endwhile
-
-      while 1
-        try
-          Xpath 'l'
-          doautocmd User x3
-        catch /Vim:Interrupt/
-          Xpath 'm'
-        finally
-          Xpath 'n'
-          " ... but break loop for caught interrupt exception,
-          " or discard interrupt and break loop if $VIMNOINTTHROW
-          break
-        endtry
-      endwhile
-
-      if exists("*U1") | delfunction U1 | endif
-      if exists("*U2") | delfunction U2 | endif
-      if exists("*U3") | delfunction U3 | endif
-
-      try
-        Xpath 'o'
-        call U1()
-      catch /U1/
-        Xpath 'p'
-      endtry
-
-      while 1
-        try
-          Xpath 'q'
-          call U2()
-        catch /ASDF/
-          Xpath 'r'
-        finally
-          Xpath 's'
-          " ... but break loop for caught error exception,
-          " or discard error and break loop if $VIMNOERRTHROW
-          break
-        endtry
-      endwhile
-
-      while 1
-        try
-          Xpath 't'
-          call U3()
-        catch /Vim:Interrupt/
-          Xpath 'u'
-        finally
-          Xpath 'v'
-          " ... but break loop for caught interrupt exception,
-          " or discard interrupt and break loop if $VIMNOINTTHROW
-          break
-        endtry
-      endwhile
-    catch /.*/
-      call assert_report('should not get here')
-    endtry
-    Xpath 'w'
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('gahibjklcmnodpqerstfuvw', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 85:  Error exceptions in autocommands for I/O command events	    {{{1
-"
-"	    When an I/O command is inside :try/:endtry, autocommands to be
-"	    executed after it should be skipped on an error (exception) in the
-"	    command itself or in autocommands to be executed before the command.
-"	    In the latter case, the I/O command should not be executed either.
-"	    Example 1: BufWritePre, :write, BufWritePost
-"	    Example 2: FileReadPre, :read, FileReadPost.
-"-------------------------------------------------------------------------------
-
-func Test_autocmd_error_io_exception()
-  let test =<< trim [CODE]
-    " Remove the autocommands for the events specified as arguments in all used
-    " autogroups.
-    func Delete_autocommands(...)
-      let augfile = tempname()
-      while 1
-        try
-          exec "redir >" . augfile
-          aug
-          redir END
-          exec "edit" augfile
-          g/^$/d
-          norm G$
-          let wrap = "w"
-          while search('\%(  \|^\)\@<=.\{-}\%(  \)\@=', wrap) > 0
-            let wrap = "W"
-            exec "norm y/  \n"
-            let argno = 1
-            while argno <= a:0
-              exec "au!" escape(@", " ") a:{argno}
-              let argno = argno + 1
-            endwhile
-          endwhile
-        catch /.*/
-        finally
-          bwipeout!
-          call delete(augfile)
-          break
-        endtry
-      endwhile
-    endfunc
-
-    call Delete_autocommands("BufWritePre", "BufWritePost")
-
-    while 1
-      try
-        try
-          let post = 0
-          aug TMP
-            au! BufWritePost * let post = 1
-          aug END
-          write /n/o/n/e/x/i/s/t/e/n/t
-        catch /^Vim(write):/
-          Xpath 'a'
-          call assert_match("E212: Can't open file for writing", v:exception)
-        finally
-          Xpath 'b'
-          call assert_equal(0, post)
-          au! TMP
-          aug! TMP
-        endtry
-      catch /.*/
-        call assert_report('should not get here')
-      finally
-        Xpath 'c'
-        break
-      endtry
-    endwhile
-
-    while 1
-      try
-        try
-          let post = 0
-          aug TMP
-            au! BufWritePre  * asdf
-            au! BufWritePost * let post = 1
-          aug END
-          let tmpfile = tempname()
-          exec "write" tmpfile
-        catch /^Vim\((write)\)\=:/
-          Xpath 'd'
-          call assert_match('E492: Not an editor command', v:exception)
-        finally
-          Xpath 'e'
-          if filereadable(tmpfile)
-            call assert_report('should not get here')
-          endif
-          call assert_equal(0, post)
-          au! TMP
-          aug! TMP
-        endtry
-      catch /.*/
-        call assert_report('should not get here')
-      finally
-        Xpath 'f'
-        break
-      endtry
-    endwhile
-
-    call delete(tmpfile)
-
-    call Delete_autocommands("BufWritePre", "BufWritePost",
-          \ "BufReadPre", "BufReadPost", "FileReadPre", "FileReadPost")
-
-    while 1
-      try
-        try
-          let post = 0
-          aug TMP
-            au! FileReadPost * let post = 1
-          aug END
-          let caught = 0
-          read /n/o/n/e/x/i/s/t/e/n/t
-        catch /^Vim(read):/
-          Xpath 'g'
-          call assert_match("E484: Can't open file", v:exception)
-        finally
-          Xpath 'h'
-          call assert_equal(0, post)
-          au! TMP
-          aug! TMP
-        endtry
-      catch /.*/
-        call assert_report('should not get here')
-      finally
-        Xpath 'i'
-        break
-      endtry
-    endwhile
-
-    while 1
-      try
-        let infile = tempname()
-        let tmpfile = tempname()
-        call writefile(["XYZ"], infile)
-        exec "edit" tmpfile
-        try
-          Xpath 'j'
-          try
-            let post = 0
-            aug TMP
-              au! FileReadPre  * asdf
-              au! FileReadPost * let post = 1
-            aug END
-            exec "0read" infile
-          catch /^Vim\((read)\)\=:/
-            Xpath 'k'
-            call assert_match('E492: Not an editor command', v:exception)
-          finally
-            Xpath 'l'
-            if getline("1") == "XYZ"
-              call assert_report('should not get here')
-            endif
-            call assert_equal(0, post)
-            au! TMP
-            aug! TMP
-          endtry
-        finally
-          Xpath 'm'
-          bwipeout!
-        endtry
-      catch /.*/
-        call assert_report('should not get here')
-      finally
-        Xpath 'n'
-        break
-      endtry
-    endwhile
-
-    call delete(infile)
-    call delete(tmpfile)
-  [CODE]
-  let verify =<< trim [CODE]
-    call assert_equal('abcdefghijklmn', g:Xpath)
-  [CODE]
-  call RunInNewVim(test, verify)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 87   using (expr) ? funcref : funcref				    {{{1
-"
-"	    Vim needs to correctly parse the funcref and even when it does
-"	    not execute the funcref, it needs to consume the trailing ()
-"-------------------------------------------------------------------------------
-
-func Add2(x1, x2)
-  return a:x1 + a:x2
-endfu
-
-func GetStr()
-  return "abcdefghijklmnopqrstuvwxyp"
-endfu
-
-func Test_funcref_with_condexpr()
-  call assert_equal(5, function('Add2')(2,3))
-
-  call assert_equal(3, 1 ? function('Add2')(1,2) : function('Add2')(2,3))
-  call assert_equal(5, 0 ? function('Add2')(1,2) : function('Add2')(2,3))
-  " Make sure, GetStr() still works.
-  call assert_equal('abcdefghijk', GetStr()[0:10])
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 90:  Recognizing {} in variable name.			    {{{1
-"-------------------------------------------------------------------------------
-
-func Test_curlies()
-    let s:var = 66
-    let ns = 's'
-    call assert_equal(66, {ns}:var)
-
-    let g:a = {}
-    let g:b = 't'
-    let g:a[g:b] = 77
-    call assert_equal(77, g:a['t'])
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 91:  using type().					    {{{1
-"-------------------------------------------------------------------------------
-
-func Test_type()
-    call assert_equal(0, type(0))
-    call assert_equal(1, type(""))
-    call assert_equal(2, type(function("tr")))
-    call assert_equal(2, type(function("tr", [8])))
-    call assert_equal(3, type([]))
-    call assert_equal(4, type({}))
-    call assert_equal(5, type(0.0))
-    call assert_equal(6, type(v:false))
-    call assert_equal(6, type(v:true))
-    call assert_equal(7, type(v:null))
-    call assert_equal(v:t_number, type(0))
-    call assert_equal(v:t_string, type(""))
-    call assert_equal(v:t_func, type(function("tr")))
-    call assert_equal(v:t_list, type([]))
-    call assert_equal(v:t_dict, type({}))
-    call assert_equal(v:t_float, type(0.0))
-    call assert_equal(v:t_bool, type(v:false))
-    call assert_equal(v:t_bool, type(v:true))
-    call assert_equal(v:t_string, type(v:_null_string))
-    call assert_equal(v:t_list, type(v:_null_list))
-    call assert_equal(v:t_dict, type(v:_null_dict))
-    call assert_equal(v:t_blob, type(v:_null_blob))
-
-    call assert_equal(0, 0 + v:false)
-    call assert_equal(1, 0 + v:true)
-    " call assert_equal(0, 0 + v:none)
-    call assert_equal(0, 0 + v:null)
-
-    call assert_equal('v:false', '' . v:false)
-    call assert_equal('v:true', '' . v:true)
-    " call assert_equal('v:none', '' . v:none)
-    call assert_equal('v:null', '' . v:null)
-
-    call assert_true(v:false == 0)
-    call assert_false(v:false != 0)
-    call assert_true(v:true == 1)
-    call assert_false(v:true != 1)
-    call assert_false(v:true == v:false)
-    call assert_true(v:true != v:false)
-
-    call assert_true(v:null == 0)
-    call assert_false(v:null != 0)
-    " call assert_true(v:none == 0)
-    " call assert_false(v:none != 0)
-
-    call assert_true(v:false is v:false)
-    call assert_true(v:true is v:true)
-    " call assert_true(v:none is v:none)
-    call assert_true(v:null is v:null)
-
-    call assert_false(v:false isnot v:false)
-    call assert_false(v:true isnot v:true)
-    " call assert_false(v:none isnot v:none)
-    call assert_false(v:null isnot v:null)
-
-    call assert_false(v:false is 0)
-    call assert_false(v:true is 1)
-    call assert_false(v:true is v:false)
-    " call assert_false(v:none is 0)
-    call assert_false(v:null is 0)
-    " call assert_false(v:null is v:none)
-
-    call assert_true(v:false isnot 0)
-    call assert_true(v:true isnot 1)
-    call assert_true(v:true isnot v:false)
-    " call assert_true(v:none isnot 0)
-    call assert_true(v:null isnot 0)
-    " call assert_true(v:null isnot v:none)
-
-    call assert_equal(v:false, eval(string(v:false)))
-    call assert_equal(v:true, eval(string(v:true)))
-    " call assert_equal(v:none, eval(string(v:none)))
-    call assert_equal(v:null, eval(string(v:null)))
-
-    call assert_equal(v:false, copy(v:false))
-    call assert_equal(v:true, copy(v:true))
-    " call assert_equal(v:none, copy(v:none))
-    call assert_equal(v:null, copy(v:null))
-
-    call assert_equal([v:false], deepcopy([v:false]))
-    call assert_equal([v:true], deepcopy([v:true]))
-    " call assert_equal([v:none], deepcopy([v:none]))
-    call assert_equal([v:null], deepcopy([v:null]))
-
-    call assert_true(empty(v:false))
-    call assert_false(empty(v:true))
-    call assert_true(empty(v:null))
-    " call assert_true(empty(v:none))
-
-    func ChangeYourMind()
-	try
-	    return v:true
-	finally
-	    return 'something else'
-	endtry
-    endfunc
-
-    call ChangeYourMind()
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 92:  skipping code                       {{{1
-"-------------------------------------------------------------------------------
-
-func Test_skip()
-    let Fn = function('Test_type')
-    call assert_false(0 && Fn[1])
-    call assert_false(0 && string(Fn))
-    call assert_false(0 && len(Fn))
-    let l = []
-    call assert_false(0 && l[1])
-    call assert_false(0 && string(l))
-    call assert_false(0 && len(l))
-    let f = 1.0
-    call assert_false(0 && f[1])
-    call assert_false(0 && string(f))
-    call assert_false(0 && len(f))
-    let sp = v:null
-    call assert_false(0 && sp[1])
-    call assert_false(0 && string(sp))
-    call assert_false(0 && len(sp))
-
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 93:  :echo and string()					    {{{1
-"-------------------------------------------------------------------------------
-
-func Test_echo_and_string()
-    " String
-    let a = 'foo bar'
-    redir => result
-    echo a
-    echo string(a)
-    redir END
-    let l = split(result, "\n")
-    call assert_equal(["foo bar",
-		     \ "'foo bar'"], l)
-
-    " Float
-    if has('float')
-	let a = -1.2e0
-	redir => result
-	echo a
-	echo string(a)
-	redir END
-	let l = split(result, "\n")
-	call assert_equal(["-1.2",
-			 \ "-1.2"], l)
-    endif
-
-    " Funcref
-    redir => result
-    echo function('string')
-    echo string(function('string'))
-    redir END
-    let l = split(result, "\n")
-    call assert_equal(["string",
-		     \ "function('string')"], l)
-
-    " Empty dictionaries in a list
-    let a = {}
-    redir => result
-    echo [a, a, a]
-    echo string([a, a, a])
-    redir END
-    let l = split(result, "\n")
-    call assert_equal(["[{}, {}, {}]",
-		     \ "[{}, {}, {}]"], l)
-
-    " Empty dictionaries in a dictionary
-    let a = {}
-    let b = {"a": a, "b": a}
-    redir => result
-    echo b
-    echo string(b)
-    redir END
-    let l = split(result, "\n")
-    call assert_equal(["{'a': {}, 'b': {}}",
-		     \ "{'a': {}, 'b': {}}"], l)
-
-    " Empty lists in a list
-    let a = []
-    redir => result
-    echo [a, a, a]
-    echo string([a, a, a])
-    redir END
-    let l = split(result, "\n")
-    call assert_equal(["[[], [], []]",
-		     \ "[[], [], []]"], l)
-
-    " Empty lists in a dictionary
-    let a = []
-    let b = {"a": a, "b": a}
-    redir => result
-    echo b
-    echo string(b)
-    redir END
-    let l = split(result, "\n")
-    call assert_equal(["{'a': [], 'b': []}",
-		     \ "{'a': [], 'b': []}"], l)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 94:  64-bit Numbers					    {{{1
-"-------------------------------------------------------------------------------
-
-func Test_num64()
-    call assert_notequal( 4294967296, 0)
-    call assert_notequal(-4294967296, 0)
-    call assert_equal( 4294967296,  0xFFFFffff + 1)
-    call assert_equal(-4294967296, -0xFFFFffff - 1)
-
-    call assert_equal( 9223372036854775807,  1 / 0)
-    call assert_equal(-9223372036854775807, -1 / 0)
-    call assert_equal(-9223372036854775807 - 1,  0 / 0)
-
-    if has('float')
-      call assert_equal( 0x7FFFffffFFFFffff, float2nr( 1.0e150))
-      call assert_equal(-0x7FFFffffFFFFffff, float2nr(-1.0e150))
-    endif
-
-    let rng = range(0xFFFFffff, 0x100000001)
-    call assert_equal([0xFFFFffff, 0x100000000, 0x100000001], rng)
-    call assert_equal(0x100000001, max(rng))
-    call assert_equal(0xFFFFffff, min(rng))
-    call assert_equal(rng, sort(range(0x100000001, 0xFFFFffff, -1), 'N'))
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 95:  lines of :append, :change, :insert			    {{{1
-"-------------------------------------------------------------------------------
-
-func DefineFunction(name, body)
-    let func = join(['function! ' . a:name . '()'] + a:body + ['endfunction'], "\n")
-    exec func
-endfunc
-
-func Test_script_lines()
-    " :append
-    try
-	call DefineFunction('T_Append', [
-		    \ 'append',
-		    \ 'py <<EOS',
-		    \ '.',
-		    \ ])
-    catch
-	call assert_report("Can't define function")
-    endtry
-    try
-	call DefineFunction('T_Append', [
-		    \ 'append',
-		    \ 'abc',
-		    \ ])
-	call assert_report("Shouldn't be able to define function")
-    catch
-	call assert_exception('Vim(function):E126: Missing :endfunction')
-    endtry
-
-    " :change
-    try
-	call DefineFunction('T_Change', [
-		    \ 'change',
-		    \ 'py <<EOS',
-		    \ '.',
-		    \ ])
-    catch
-	call assert_report("Can't define function")
-    endtry
-    try
-	call DefineFunction('T_Change', [
-		    \ 'change',
-		    \ 'abc',
-		    \ ])
-	call assert_report("Shouldn't be able to define function")
-    catch
-	call assert_exception('Vim(function):E126: Missing :endfunction')
-    endtry
-
-    " :insert
-    try
-	call DefineFunction('T_Insert', [
-		    \ 'insert',
-		    \ 'py <<EOS',
-		    \ '.',
-		    \ ])
-    catch
-	call assert_report("Can't define function")
-    endtry
-    try
-	call DefineFunction('T_Insert', [
-		    \ 'insert',
-		    \ 'abc',
-		    \ ])
-	call assert_report("Shouldn't be able to define function")
-    catch
-	call assert_exception('Vim(function):E126: Missing :endfunction')
-    endtry
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 96:  line continuation						    {{{1
-"
-"	    Undefined behavior was detected by ubsan with line continuation
-"	    after an empty line.
-"-------------------------------------------------------------------------------
-func Test_script_empty_line_continuation()
-
-    \
-endfunc
-
-"-------------------------------------------------------------------------------
-" Test 97:  bitwise functions						    {{{1
-"-------------------------------------------------------------------------------
-func Test_bitwise_functions()
-    " and
-    call assert_equal(127, and(127, 127))
-    call assert_equal(16, and(127, 16))
-    eval 127->and(16)->assert_equal(16)
-    call assert_equal(0, and(127, 128))
-    call assert_fails("call and(1.0, 1)", 'E805:')
-    call assert_fails("call and([], 1)", 'E745:')
-    call assert_fails("call and({}, 1)", 'E728:')
-    call assert_fails("call and(1, 1.0)", 'E805:')
-    call assert_fails("call and(1, [])", 'E745:')
-    call assert_fails("call and(1, {})", 'E728:')
-    " or
-    call assert_equal(23, or(16, 7))
-    call assert_equal(15, or(8, 7))
-    eval 8->or(7)->assert_equal(15)
-    call assert_equal(123, or(0, 123))
-    call assert_fails("call or(1.0, 1)", 'E805:')
-    call assert_fails("call or([], 1)", 'E745:')
-    call assert_fails("call or({}, 1)", 'E728:')
-    call assert_fails("call or(1, 1.0)", 'E805:')
-    call assert_fails("call or(1, [])", 'E745:')
-    call assert_fails("call or(1, {})", 'E728:')
-    " xor
-    call assert_equal(0, xor(127, 127))
-    call assert_equal(111, xor(127, 16))
-    eval 127->xor(16)->assert_equal(111)
-    call assert_equal(255, xor(127, 128))
-    call assert_fails("call xor(1.0, 1)", 'E805:')
-    call assert_fails("call xor([], 1)", 'E745:')
-    call assert_fails("call xor({}, 1)", 'E728:')
-    call assert_fails("call xor(1, 1.0)", 'E805:')
-    call assert_fails("call xor(1, [])", 'E745:')
-    call assert_fails("call xor(1, {})", 'E728:')
-    " invert
-    call assert_equal(65408, and(invert(127), 65535))
-    eval 127->invert()->and(65535)->assert_equal(65408)
-    call assert_equal(65519, and(invert(16), 65535))
-    call assert_equal(65407, and(invert(128), 65535))
-    call assert_fails("call invert(1.0)", 'E805:')
-    call assert_fails("call invert([])", 'E745:')
-    call assert_fails("call invert({})", 'E728:')
-endfunc
-
-" Test using bang after user command				    {{{1
-func Test_user_command_with_bang()
-    command -bang Nieuw let nieuw = 1
-    Ni!
-    call assert_equal(1, nieuw)
-    unlet nieuw
-    delcommand Nieuw
-endfunc
-
-func Test_script_expand_sfile()
-  let lines =<< trim END
-    func s:snr()
-      return expand('<sfile>')
-    endfunc
-    let g:result = s:snr()
-  END
-  call writefile(lines, 'Xexpand')
-  source Xexpand
-  call assert_match('<SNR>\d\+_snr', g:result)
-  source Xexpand
-  call assert_match('<SNR>\d\+_snr', g:result)
-
-  call delete('Xexpand')
-  unlet g:result
-endfunc
-
-func Test_compound_assignment_operators()
-    " Test for number
-    let x = 1
-    let x += 10
-    call assert_equal(11, x)
-    let x -= 5
-    call assert_equal(6, x)
-    let x *= 4
-    call assert_equal(24, x)
-    let x /= 3
-    call assert_equal(8, x)
-    let x %= 3
-    call assert_equal(2, x)
-    let x .= 'n'
-    call assert_equal('2n', x)
-
-    " Test special cases: division or modulus with 0.
-    let x = 1
-    let x /= 0
-    call assert_equal(0x7FFFFFFFFFFFFFFF, x)
-
-    let x = -1
-    let x /= 0
-    call assert_equal(-0x7FFFFFFFFFFFFFFF, x)
-
-    let x = 0
-    let x /= 0
-    call assert_equal(-0x7FFFFFFFFFFFFFFF - 1, x)
-
-    let x = 1
-    let x %= 0
-    call assert_equal(0, x)
-
-    let x = -1
-    let x %= 0
-    call assert_equal(0, x)
-
-    let x = 0
-    let x %= 0
-    call assert_equal(0, x)
-
-    " Test for string
-    let x = 'str'
-    let x .= 'ing'
-    call assert_equal('string', x)
-    let x += 1
-    call assert_equal(1, x)
-
-    if has('float')
-      " Test for float
-      let x -= 1.5
-      call assert_equal(-0.5, x)
-      let x = 0.5
-      let x += 4.5
-      call assert_equal(5.0, x)
-      let x -= 1.5
-      call assert_equal(3.5, x)
-      let x *= 3.0
-      call assert_equal(10.5, x)
-      let x /= 2.5
-      call assert_equal(4.2, x)
-      call assert_fails('let x %= 0.5', 'E734')
-      call assert_fails('let x .= "f"', 'E734')
-      let x = !3.14
-      call assert_equal(0.0, x)
-
-      " integer and float operations
-      let x = 1
-      let x *= 2.1
-      call assert_equal(2.1, x)
-      let x = 1
-      let x /= 0.25
-      call assert_equal(4.0, x)
-      let x = 1
-      call assert_fails('let x %= 0.25', 'E734:')
-      let x = 1
-      call assert_fails('let x .= 0.25', 'E734:')
-      let x = 1.0
-      call assert_fails('let x += [1.1]', 'E734:')
-    endif
-
-    " Test for environment variable
-    let $FOO = 1
-    call assert_fails('let $FOO += 1', 'E734')
-    call assert_fails('let $FOO -= 1', 'E734')
-    call assert_fails('let $FOO *= 1', 'E734')
-    call assert_fails('let $FOO /= 1', 'E734')
-    call assert_fails('let $FOO %= 1', 'E734')
-    let $FOO .= 's'
-    call assert_equal('1s', $FOO)
-    unlet $FOO
-
-    " Test for option variable (type: number)
-    let &scrolljump = 1
-    let &scrolljump += 5
-    call assert_equal(6, &scrolljump)
-    let &scrolljump -= 2
-    call assert_equal(4, &scrolljump)
-    let &scrolljump *= 3
-    call assert_equal(12, &scrolljump)
-    let &scrolljump /= 2
-    call assert_equal(6, &scrolljump)
-    let &scrolljump %= 5
-    call assert_equal(1, &scrolljump)
-    call assert_fails('let &scrolljump .= "j"', 'E734:')
-    set scrolljump&vim
-
-    let &foldlevelstart = 2
-    let &foldlevelstart -= 1
-    call assert_equal(1, &foldlevelstart)
-    let &foldlevelstart -= 1
-    call assert_equal(0, &foldlevelstart)
-    let &foldlevelstart = 2
-    let &foldlevelstart -= 2
-    call assert_equal(0, &foldlevelstart)
-
-    " Test for register
-    let @/ = 1
-    call assert_fails('let @/ += 1', 'E734:')
-    call assert_fails('let @/ -= 1', 'E734:')
-    call assert_fails('let @/ *= 1', 'E734:')
-    call assert_fails('let @/ /= 1', 'E734:')
-    call assert_fails('let @/ %= 1', 'E734:')
-    let @/ .= 's'
-    call assert_equal('1s', @/)
-    let @/ = ''
-endfunc
-
-func Test_unlet_env()
-    let $TESTVAR = 'yes'
-    call assert_equal('yes', $TESTVAR)
-    call assert_fails('lockvar $TESTVAR', 'E940')
-    call assert_fails('unlockvar $TESTVAR', 'E940')
-    call assert_equal('yes', $TESTVAR)
-    if 0
-        unlet $TESTVAR
-    endif
-    call assert_equal('yes', $TESTVAR)
-    unlet $TESTVAR
-    call assert_equal('', $TESTVAR)
-endfunc
-
-" Test for missing :endif, :endfor, :endwhile and :endtry           {{{1
-func Test_missing_end()
-  call writefile(['if 2 > 1', 'echo ">"'], 'Xscript')
-  call assert_fails('source Xscript', 'E171:')
-  call writefile(['for i in range(5)', 'echo i'], 'Xscript')
-  call assert_fails('source Xscript', 'E170:')
-  call writefile(['while v:true', 'echo "."'], 'Xscript')
-  call assert_fails('source Xscript', 'E170:')
-  call writefile(['try', 'echo "."'], 'Xscript')
-  call assert_fails('source Xscript', 'E600:')
-  call delete('Xscript')
-
-  " Using endfor with :while
-  let caught_e732 = 0
-  try
-    while v:true
-    endfor
-  catch /E732:/
-    let caught_e732 = 1
-  endtry
-  call assert_equal(1, caught_e732)
-
-  " Using endwhile with :for
-  let caught_e733 = 0
-  try
-    for i in range(1)
-    endwhile
-  catch /E733:/
-    let caught_e733 = 1
-  endtry
-  call assert_equal(1, caught_e733)
-
-  " Using endfunc with :if
-  call assert_fails('exe "if 1 | endfunc | endif"', 'E193:')
-
-  " Missing 'in' in a :for statement
-  call assert_fails('for i range(1) | endfor', 'E690:')
-
-  " Incorrect number of variables in for
-  call assert_fails('for [i,] in range(3) | endfor', 'E475:')
-endfunc
-
-" Test for deep nesting of if/for/while/try statements              {{{1
-func Test_deep_nest()
-  CheckRunVimInTerminal
-
-  let lines =<< trim [SCRIPT]
-    " Deep nesting of if ... endif
-    func Test1()
-      let @a = join(repeat(['if v:true'], 51), "\n")
-      let @a ..= "\n"
-      let @a ..= join(repeat(['endif'], 51), "\n")
-      @a
-      let @a = ''
-    endfunc
-
-    " Deep nesting of for ... endfor
-    func Test2()
-      let @a = join(repeat(['for i in [1]'], 51), "\n")
-      let @a ..= "\n"
-      let @a ..= join(repeat(['endfor'], 51), "\n")
-      @a
-      let @a = ''
-    endfunc
-
-    " Deep nesting of while ... endwhile
-    func Test3()
-      let @a = join(repeat(['while v:true'], 51), "\n")
-      let @a ..= "\n"
-      let @a ..= join(repeat(['endwhile'], 51), "\n")
-      @a
-      let @a = ''
-    endfunc
-
-    " Deep nesting of try ... endtry
-    func Test4()
-      let @a = join(repeat(['try'], 51), "\n")
-      let @a ..= "\necho v:true\n"
-      let @a ..= join(repeat(['endtry'], 51), "\n")
-      @a
-      let @a = ''
-    endfunc
-
-    " Deep nesting of function ... endfunction
-    func Test5()
-      let @a = join(repeat(['function X()'], 51), "\n")
-      let @a ..= "\necho v:true\n"
-      let @a ..= join(repeat(['endfunction'], 51), "\n")
-      @a
-      let @a = ''
-    endfunc
-  [SCRIPT]
-  call writefile(lines, 'Xscript')
-
-  let buf = RunVimInTerminal('-S Xscript', {'rows': 6})
-
-  " Deep nesting of if ... endif
-  call term_sendkeys(buf, ":call Test1()\n")
-  call term_wait(buf)
-  call WaitForAssert({-> assert_match('^E579:', term_getline(buf, 5))})
-
-  " Deep nesting of for ... endfor
-  call term_sendkeys(buf, ":call Test2()\n")
-  call term_wait(buf)
-  call WaitForAssert({-> assert_match('^E585:', term_getline(buf, 5))})
-
-  " Deep nesting of while ... endwhile
-  call term_sendkeys(buf, ":call Test3()\n")
-  call term_wait(buf)
-  call WaitForAssert({-> assert_match('^E585:', term_getline(buf, 5))})
-
-  " Deep nesting of try ... endtry
-  call term_sendkeys(buf, ":call Test4()\n")
-  call term_wait(buf)
-  call WaitForAssert({-> assert_match('^E601:', term_getline(buf, 5))})
-
-  " Deep nesting of function ... endfunction
-  call term_sendkeys(buf, ":call Test5()\n")
-  call term_wait(buf)
-  call WaitForAssert({-> assert_match('^E1058:', term_getline(buf, 4))})
-  call term_sendkeys(buf, "\<C-C>\n")
-  call term_wait(buf)
-
-  "let l = ''
-  "for i in range(1, 6)
-  "  let l ..= term_getline(buf, i) . "\n"
-  "endfor
-  "call assert_report(l)
-
-  call StopVimInTerminal(buf)
-  call delete('Xscript')
-endfunc
-
-" Test for errors in converting to float from various types         {{{1
-func Test_float_conversion_errors()
-  if has('float')
-    call assert_fails('let x = 4.0 % 2.0', 'E804')
-    call assert_fails('echo 1.1[0]', 'E806')
-    call assert_fails('echo sort([function("min"), 1], "f")', 'E891:')
-    call assert_fails('echo 3.2 == "vim"', 'E892:')
-    call assert_fails('echo sort([[], 1], "f")', 'E893:')
-    call assert_fails('echo sort([{}, 1], "f")', 'E894:')
-    call assert_fails('echo 3.2 == v:true', 'E362:')
-    " call assert_fails('echo 3.2 == v:none', 'E907:')
-  endif
-endfunc
-
-" invalid function names               {{{1
-func Test_invalid_function_names()
-  " function name not starting with capital
-  let caught_e128 = 0
-  try
-    func! g:test()
-      echo "test"
-    endfunc
-  catch /E128:/
-    let caught_e128 = 1
-  endtry
-  call assert_equal(1, caught_e128)
-
-  " function name includes a colon
-  let caught_e884 = 0
-  try
-    func! b:test()
-      echo "test"
-    endfunc
-  catch /E884:/
-    let caught_e884 = 1
-  endtry
-  call assert_equal(1, caught_e884)
-
-  " function name followed by #
-  let caught_e128 = 0
-  try
-    func! test2() "#
-      echo "test2"
-    endfunc
-  catch /E128:/
-    let caught_e128 = 1
-  endtry
-  call assert_equal(1, caught_e128)
-
-  " function name starting with/without "g:", buffer-local funcref.
-  function! g:Foo(n)
-    return 'called Foo(' . a:n . ')'
-  endfunction
-  let b:my_func = function('Foo')
-  call assert_equal('called Foo(1)', b:my_func(1))
-  call assert_equal('called Foo(2)', g:Foo(2))
-  call assert_equal('called Foo(3)', Foo(3))
-  delfunc g:Foo
-
-  " script-local function used in Funcref must exist.
-  let lines =<< trim END
-    func s:Testje()
-      return "foo"
-    endfunc
-    let Bar = function('s:Testje')
-    call assert_equal(0, exists('s:Testje'))
-    call assert_equal(1, exists('*s:Testje'))
-    call assert_equal(1, exists('Bar'))
-    call assert_equal(1, exists('*Bar'))
-  END
-  call writefile(lines, 'Xscript')
-  source Xscript
-  call delete('Xscript')
-endfunc
-
-" substring and variable name              {{{1
-func Test_substring_var()
-  let str = 'abcdef'
-  let n = 3
-  call assert_equal('def', str[n:])
-  call assert_equal('abcd', str[:n])
-  call assert_equal('d', str[n:n])
-  unlet n
-  let nn = 3
-  call assert_equal('def', str[nn:])
-  call assert_equal('abcd', str[:nn])
-  call assert_equal('d', str[nn:nn])
-  unlet nn
-  let b:nn = 4
-  call assert_equal('ef', str[b:nn:])
-  call assert_equal('abcde', str[:b:nn])
-  call assert_equal('e', str[b:nn:b:nn])
-  unlet b:nn
-endfunc
-
-" Test using s: with a typed command              {{{1
-func Test_typed_script_var()
-  CheckRunVimInTerminal
-
-  let buf = RunVimInTerminal('', {'rows': 6})
-
-  " Deep nesting of if ... endif
-  call term_sendkeys(buf, ":echo get(s:, 'foo', 'x')\n")
-  call TermWait(buf)
-  call WaitForAssert({-> assert_match('^E116:', term_getline(buf, 5))})
-
-  call StopVimInTerminal(buf)
-endfunc
-
-func Test_for_over_string()
-  let res = ''
-  for c in 'aéc̀d'
-    let res ..= c .. '-'
-  endfor
-  call assert_equal('a-é-c̀-d-', res)
-
-  let res = ''
-  for c in ''
-    let res ..= c .. '-'
-  endfor
-  call assert_equal('', res)
-
-  let res = ''
-  for c in v:_null_string
-    let res ..= c .. '-'
-  endfor
-  call assert_equal('', res)
-endfunc
-
-"-------------------------------------------------------------------------------
-" Modelines								    {{{1
-" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker
-"-------------------------------------------------------------------------------