From af23d173883f47fd02a9a380c719e4428370b484 Mon Sep 17 00:00:00 2001 From: dundargoc <33953936+dundargoc@users.noreply.github.com> Date: Tue, 7 Mar 2023 04:13:04 +0100 Subject: test: move oldtests to test directory (#22536) The new oldtest directory is in test/old/testdir. The reason for this is that many tests have hardcoded the parent directory name to be 'testdir'. --- src/nvim/testdir/test_vimscript.vim | 7284 ----------------------------------- 1 file changed, 7284 deletions(-) delete mode 100644 src/nvim/testdir/test_vimscript.vim (limited to 'src/nvim/testdir/test_vimscript.vim') 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 -" ) - -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() - -" 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 . | - \ 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" -