1" Test various aspects of the Vim script language. 2" Most of this was formerly in test49. 3 4source check.vim 5source shared.vim 6 7"------------------------------------------------------------------------------- 8" Test environment {{{1 9"------------------------------------------------------------------------------- 10 11com! XpathINIT let g:Xpath = '' 12com! -nargs=1 -bar Xpath let g:Xpath = g:Xpath . <args> 13 14" Append a message to the "messages" file 15func Xout(text) 16 split messages 17 $put =a:text 18 wq 19endfunc 20 21com! -nargs=1 Xout call Xout(<args>) 22 23" MakeScript() - Make a script file from a function. {{{2 24" 25" Create a script that consists of the body of the function a:funcname. 26" Replace any ":return" by a ":finish", any argument variable by a global 27" variable, and every ":call" by a ":source" for the next following argument 28" in the variable argument list. This function is useful if similar tests are 29" to be made for a ":return" from a function call or a ":finish" in a script 30" file. 31func MakeScript(funcname, ...) 32 let script = tempname() 33 execute "redir! >" . script 34 execute "function" a:funcname 35 redir END 36 execute "edit" script 37 " Delete the "function" and the "endfunction" lines. Do not include the 38 " word "function" in the pattern since it might be translated if LANG is 39 " set. When MakeScript() is being debugged, this deletes also the debugging 40 " output of its line 3 and 4. 41 exec '1,/.*' . a:funcname . '(.*)/d' 42 /^\d*\s*endfunction\>/,$d 43 %s/^\d*//e 44 %s/return/finish/e 45 %s/\<a:\(\h\w*\)/g:\1/ge 46 normal gg0 47 let cnt = 0 48 while search('\<call\s*\%(\u\|s:\)\w*\s*(.*)', 'W') > 0 49 let cnt = cnt + 1 50 s/\<call\s*\%(\u\|s:\)\w*\s*(.*)/\='source ' . a:{cnt}/ 51 endwhile 52 g/^\s*$/d 53 write 54 bwipeout 55 return script 56endfunc 57 58" ExecAsScript - Source a temporary script made from a function. {{{2 59" 60" Make a temporary script file from the function a:funcname, ":source" it, and 61" delete it afterwards. However, if an exception is thrown the file may remain, 62" the caller should call DeleteTheScript() afterwards. 63let s:script_name = '' 64function! ExecAsScript(funcname) 65 " Make a script from the function passed as argument. 66 let s:script_name = MakeScript(a:funcname) 67 68 " Source and delete the script. 69 exec "source" s:script_name 70 call delete(s:script_name) 71 let s:script_name = '' 72endfunction 73 74function! DeleteTheScript() 75 if s:script_name 76 call delete(s:script_name) 77 let s:script_name = '' 78 endif 79endfunc 80 81com! -nargs=1 -bar ExecAsScript call ExecAsScript(<f-args>) 82 83 84"------------------------------------------------------------------------------- 85" Test 1: :endwhile in function {{{1 86" 87" Detect if a broken loop is (incorrectly) reactivated by the 88" :endwhile. Use a :return to prevent an endless loop, and make 89" this test first to get a meaningful result on an error before other 90" tests will hang. 91"------------------------------------------------------------------------------- 92 93function! T1_F() 94 Xpath 'a' 95 let first = 1 96 while 1 97 Xpath 'b' 98 if first 99 Xpath 'c' 100 let first = 0 101 break 102 else 103 Xpath 'd' 104 return 105 endif 106 endwhile 107endfunction 108 109function! T1_G() 110 Xpath 'h' 111 let first = 1 112 while 1 113 Xpath 'i' 114 if first 115 Xpath 'j' 116 let first = 0 117 break 118 else 119 Xpath 'k' 120 return 121 endif 122 if 1 " unmatched :if 123 endwhile 124endfunction 125 126func Test_endwhile_function() 127 XpathINIT 128 call T1_F() 129 Xpath 'F' 130 131 try 132 call T1_G() 133 catch 134 " Catch missing :endif 135 call assert_true(v:exception =~ 'E171') 136 Xpath 'x' 137 endtry 138 Xpath 'G' 139 140 call assert_equal('abcFhijxG', g:Xpath) 141endfunc 142 143"------------------------------------------------------------------------------- 144" Test 2: :endwhile in script {{{1 145" 146" Detect if a broken loop is (incorrectly) reactivated by the 147" :endwhile. Use a :finish to prevent an endless loop, and place 148" this test before others that might hang to get a meaningful result 149" on an error. 150" 151" This test executes the bodies of the functions T1_F and T1_G from 152" the previous test as script files (:return replaced by :finish). 153"------------------------------------------------------------------------------- 154 155func Test_endwhile_script() 156 XpathINIT 157 ExecAsScript T1_F 158 Xpath 'F' 159 call DeleteTheScript() 160 161 try 162 ExecAsScript T1_G 163 catch 164 " Catch missing :endif 165 call assert_true(v:exception =~ 'E171') 166 Xpath 'x' 167 endtry 168 Xpath 'G' 169 call DeleteTheScript() 170 171 call assert_equal('abcFhijxG', g:Xpath) 172endfunc 173 174"------------------------------------------------------------------------------- 175" Test 3: :if, :elseif, :while, :continue, :break {{{1 176"------------------------------------------------------------------------------- 177 178function Test_if_while() 179 XpathINIT 180 if 1 181 Xpath 'a' 182 let loops = 3 183 while loops > -1 " main loop: loops == 3, 2, 1 (which breaks) 184 if loops <= 0 185 let break_err = 1 186 let loops = -1 187 else 188 Xpath 'b' . loops 189 endif 190 if (loops == 2) 191 while loops == 2 " dummy loop 192 Xpath 'c' . loops 193 let loops = loops - 1 194 continue " stop dummy loop 195 Xpath 'd' . loops 196 endwhile 197 continue " continue main loop 198 Xpath 'e' . loops 199 elseif (loops == 1) 200 let p = 1 201 while p " dummy loop 202 Xpath 'f' . loops 203 let p = 0 204 break " break dummy loop 205 Xpath 'g' . loops 206 endwhile 207 Xpath 'h' . loops 208 unlet p 209 break " break main loop 210 Xpath 'i' . loops 211 endif 212 if (loops > 0) 213 Xpath 'j' . loops 214 endif 215 while loops == 3 " dummy loop 216 let loops = loops - 1 217 endwhile " end dummy loop 218 endwhile " end main loop 219 Xpath 'k' 220 else 221 Xpath 'l' 222 endif 223 Xpath 'm' 224 if exists("break_err") 225 Xpath 'm' 226 unlet break_err 227 endif 228 229 unlet loops 230 231 call assert_equal('ab3j3b2c2b1f1h1km', g:Xpath) 232endfunc 233 234"------------------------------------------------------------------------------- 235" Test 4: :return {{{1 236"------------------------------------------------------------------------------- 237 238function! T4_F() 239 if 1 240 Xpath 'a' 241 let loops = 3 242 while loops > 0 " 3: 2: 1: 243 Xpath 'b' . loops 244 if (loops == 2) 245 Xpath 'c' . loops 246 return 247 Xpath 'd' . loops 248 endif 249 Xpath 'e' . loops 250 let loops = loops - 1 251 endwhile 252 Xpath 'f' 253 else 254 Xpath 'g' 255 endif 256endfunction 257 258function Test_return() 259 XpathINIT 260 call T4_F() 261 Xpath '4' 262 263 call assert_equal('ab3e3b2c24', g:Xpath) 264endfunction 265 266 267"------------------------------------------------------------------------------- 268" Test 5: :finish {{{1 269" 270" This test executes the body of the function T4_F from the previous 271" test as a script file (:return replaced by :finish). 272"------------------------------------------------------------------------------- 273 274function Test_finish() 275 XpathINIT 276 ExecAsScript T4_F 277 Xpath '5' 278 call DeleteTheScript() 279 280 call assert_equal('ab3e3b2c25', g:Xpath) 281endfunction 282 283 284 285"------------------------------------------------------------------------------- 286" Test 6: Defining functions in :while loops {{{1 287" 288" Functions can be defined inside other functions. An inner function 289" gets defined when the outer function is executed. Functions may 290" also be defined inside while loops. Expressions in braces for 291" defining the function name are allowed. 292" 293" The functions are defined when sourcing the script, only the 294" resulting path is checked in the test function. 295"------------------------------------------------------------------------------- 296 297XpathINIT 298 299" The command CALL collects the argument of all its invocations in "calls" 300" when used from a function (that is, when the global variable "calls" needs 301" the "g:" prefix). This is to check that the function code is skipped when 302" the function is defined. For inner functions, do so only if the outer 303" function is not being executed. 304" 305let calls = "" 306com! -nargs=1 CALL 307 \ if !exists("calls") && !exists("outer") | 308 \ let g:calls = g:calls . <args> | 309 \ endif 310 311let i = 0 312while i < 3 313 let i = i + 1 314 if i == 1 315 Xpath 'a' 316 function! F1(arg) 317 CALL a:arg 318 let outer = 1 319 320 let j = 0 321 while j < 1 322 Xpath 'b' 323 let j = j + 1 324 function! G1(arg) 325 CALL a:arg 326 endfunction 327 Xpath 'c' 328 endwhile 329 endfunction 330 Xpath 'd' 331 332 continue 333 endif 334 335 Xpath 'e' . i 336 function! F{i}(i, arg) 337 CALL a:arg 338 let outer = 1 339 340 if a:i == 3 341 Xpath 'f' 342 endif 343 let k = 0 344 while k < 3 345 Xpath 'g' . k 346 let k = k + 1 347 function! G{a:i}{k}(arg) 348 CALL a:arg 349 endfunction 350 Xpath 'h' . k 351 endwhile 352 endfunction 353 Xpath 'i' 354 355endwhile 356 357if exists("*G1") 358 Xpath 'j' 359endif 360if exists("*F1") 361 call F1("F1") 362 if exists("*G1") 363 call G1("G1") 364 endif 365endif 366 367if exists("G21") || exists("G22") || exists("G23") 368 Xpath 'k' 369endif 370if exists("*F2") 371 call F2(2, "F2") 372 if exists("*G21") 373 call G21("G21") 374 endif 375 if exists("*G22") 376 call G22("G22") 377 endif 378 if exists("*G23") 379 call G23("G23") 380 endif 381endif 382 383if exists("G31") || exists("G32") || exists("G33") 384 Xpath 'l' 385endif 386if exists("*F3") 387 call F3(3, "F3") 388 if exists("*G31") 389 call G31("G31") 390 endif 391 if exists("*G32") 392 call G32("G32") 393 endif 394 if exists("*G33") 395 call G33("G33") 396 endif 397endif 398 399Xpath 'm' 400 401let g:test6_result = g:Xpath 402let g:test6_calls = calls 403 404unlet calls 405delfunction F1 406delfunction G1 407delfunction F2 408delfunction G21 409delfunction G22 410delfunction G23 411delfunction G31 412delfunction G32 413delfunction G33 414 415function Test_defining_functions() 416 call assert_equal('ade2ie3ibcg0h1g1h2g2h3fg0h1g1h2g2h3m', g:test6_result) 417 call assert_equal('F1G1F2G21G22G23F3G31G32G33', g:test6_calls) 418endfunc 419 420"------------------------------------------------------------------------------- 421" Test 7: Continuing on errors outside functions {{{1 422" 423" On an error outside a function, the script processing continues 424" at the line following the outermost :endif or :endwhile. When not 425" inside an :if or :while, the script processing continues at the next 426" line. 427"------------------------------------------------------------------------------- 428 429XpathINIT 430 431if 1 432 Xpath 'a' 433 while 1 434 Xpath 'b' 435 asdf 436 Xpath 'c' 437 break 438 endwhile | Xpath 'd' 439 Xpath 'e' 440endif | Xpath 'f' 441Xpath 'g' 442 443while 1 444 Xpath 'h' 445 if 1 446 Xpath 'i' 447 asdf 448 Xpath 'j' 449 endif | Xpath 'k' 450 Xpath 'l' 451 break 452endwhile | Xpath 'm' 453Xpath 'n' 454 455asdf 456Xpath 'o' 457 458asdf | Xpath 'p' 459Xpath 'q' 460 461let g:test7_result = g:Xpath 462 463func Test_error_in_script() 464 call assert_equal('abghinoq', g:test7_result) 465endfunc 466 467"------------------------------------------------------------------------------- 468" Test 8: Aborting and continuing on errors inside functions {{{1 469" 470" On an error inside a function without the "abort" attribute, the 471" script processing continues at the next line (unless the error was 472" in a :return command). On an error inside a function with the 473" "abort" attribute, the function is aborted and the script processing 474" continues after the function call; the value -1 is returned then. 475"------------------------------------------------------------------------------- 476 477XpathINIT 478 479function! T8_F() 480 if 1 481 Xpath 'a' 482 while 1 483 Xpath 'b' 484 asdf 485 Xpath 'c' 486 asdf | Xpath 'd' 487 Xpath 'e' 488 break 489 endwhile 490 Xpath 'f' 491 endif | Xpath 'g' 492 Xpath 'h' 493 494 while 1 495 Xpath 'i' 496 if 1 497 Xpath 'j' 498 asdf 499 Xpath 'k' 500 asdf | Xpath 'l' 501 Xpath 'm' 502 endif 503 Xpath 'n' 504 break 505 endwhile | Xpath 'o' 506 Xpath 'p' 507 508 return novar " returns (default return value 0) 509 Xpath 'q' 510 return 1 " not reached 511endfunction 512 513function! T8_G() abort 514 if 1 515 Xpath 'r' 516 while 1 517 Xpath 's' 518 asdf " returns -1 519 Xpath 't' 520 break 521 endwhile 522 Xpath 'v' 523 endif | Xpath 'w' 524 Xpath 'x' 525 526 return -4 " not reached 527endfunction 528 529function! T8_H() abort 530 while 1 531 Xpath 'A' 532 if 1 533 Xpath 'B' 534 asdf " returns -1 535 Xpath 'C' 536 endif 537 Xpath 'D' 538 break 539 endwhile | Xpath 'E' 540 Xpath 'F' 541 542 return -4 " not reached 543endfunction 544 545" Aborted functions (T8_G and T8_H) return -1. 546let g:test8_sum = (T8_F() + 1) - 4 * T8_G() - 8 * T8_H() 547Xpath 'X' 548let g:test8_result = g:Xpath 549 550func Test_error_in_function() 551 call assert_equal(13, g:test8_sum) 552 call assert_equal('abcefghijkmnoprsABX', g:test8_result) 553 554 delfunction T8_F 555 delfunction T8_G 556 delfunction T8_H 557endfunc 558 559 560"------------------------------------------------------------------------------- 561" Test 9: Continuing after aborted functions {{{1 562" 563" When a function with the "abort" attribute is aborted due to an 564" error, the next function back in the call hierarchy without an 565" "abort" attribute continues; the value -1 is returned then. 566"------------------------------------------------------------------------------- 567 568XpathINIT 569 570function! F() abort 571 Xpath 'a' 572 let result = G() " not aborted 573 Xpath 'b' 574 if result != 2 575 Xpath 'c' 576 endif 577 return 1 578endfunction 579 580function! G() " no abort attribute 581 Xpath 'd' 582 if H() != -1 " aborted 583 Xpath 'e' 584 endif 585 Xpath 'f' 586 return 2 587endfunction 588 589function! H() abort 590 Xpath 'g' 591 call I() " aborted 592 Xpath 'h' 593 return 4 594endfunction 595 596function! I() abort 597 Xpath 'i' 598 asdf " error 599 Xpath 'j' 600 return 8 601endfunction 602 603if F() != 1 604 Xpath 'k' 605endif 606 607let g:test9_result = g:Xpath 608 609delfunction F 610delfunction G 611delfunction H 612delfunction I 613 614func Test_func_abort() 615 call assert_equal('adgifb', g:test9_result) 616endfunc 617 618 619"------------------------------------------------------------------------------- 620" Test 10: :if, :elseif, :while argument parsing {{{1 621" 622" A '"' or '|' in an argument expression must not be mixed up with 623" a comment or a next command after a bar. Parsing errors should 624" be recognized. 625"------------------------------------------------------------------------------- 626 627XpathINIT 628 629function! MSG(enr, emsg) 630 let english = v:lang == "C" || v:lang =~ '^[Ee]n' 631 if a:enr == "" 632 Xout "TODO: Add message number for:" a:emsg 633 let v:errmsg = ":" . v:errmsg 634 endif 635 let match = 1 636 if v:errmsg !~ '^'.a:enr.':' || (english && v:errmsg !~ a:emsg) 637 let match = 0 638 if v:errmsg == "" 639 Xout "Message missing." 640 else 641 let v:errmsg = v:errmsg->escape('"') 642 Xout "Unexpected message:" v:errmsg 643 endif 644 endif 645 return match 646endfunc 647 648if 1 || strlen("\"") | Xpath 'a' 649 Xpath 'b' 650endif 651Xpath 'c' 652 653if 0 654elseif 1 || strlen("\"") | Xpath 'd' 655 Xpath 'e' 656endif 657Xpath 'f' 658 659while 1 || strlen("\"") | Xpath 'g' 660 Xpath 'h' 661 break 662endwhile 663Xpath 'i' 664 665let v:errmsg = "" 666if 1 ||| strlen("\"") | Xpath 'j' 667 Xpath 'k' 668endif 669Xpath 'l' 670if !MSG('E15', "Invalid expression") 671 Xpath 'm' 672endif 673 674let v:errmsg = "" 675if 0 676elseif 1 ||| strlen("\"") | Xpath 'n' 677 Xpath 'o' 678endif 679Xpath 'p' 680if !MSG('E15', "Invalid expression") 681 Xpath 'q' 682endif 683 684let v:errmsg = "" 685while 1 ||| strlen("\"") | Xpath 'r' 686 Xpath 's' 687 break 688endwhile 689Xpath 't' 690if !MSG('E15', "Invalid expression") 691 Xpath 'u' 692endif 693 694let g:test10_result = g:Xpath 695delfunction MSG 696 697func Test_expr_parsing() 698 call assert_equal('abcdefghilpt', g:test10_result) 699endfunc 700 701 702"------------------------------------------------------------------------------- 703" Test 11: :if, :elseif, :while argument evaluation after abort {{{1 704" 705" When code is skipped over due to an error, the boolean argument to 706" an :if, :elseif, or :while must not be evaluated. 707"------------------------------------------------------------------------------- 708 709XpathINIT 710 711let calls = 0 712 713function! P(num) 714 let g:calls = g:calls + a:num " side effect on call 715 return 0 716endfunction 717 718if 1 719 Xpath 'a' 720 asdf " error 721 Xpath 'b' 722 if P(1) " should not be called 723 Xpath 'c' 724 elseif !P(2) " should not be called 725 Xpath 'd' 726 else 727 Xpath 'e' 728 endif 729 Xpath 'f' 730 while P(4) " should not be called 731 Xpath 'g' 732 endwhile 733 Xpath 'h' 734endif 735Xpath 'x' 736 737let g:test11_calls = calls 738let g:test11_result = g:Xpath 739 740unlet calls 741delfunction P 742 743func Test_arg_abort() 744 call assert_equal(0, g:test11_calls) 745 call assert_equal('ax', g:test11_result) 746endfunc 747 748 749"------------------------------------------------------------------------------- 750" Test 12: Expressions in braces in skipped code {{{1 751" 752" In code skipped over due to an error or inactive conditional, 753" an expression in braces as part of a variable or function name 754" should not be evaluated. 755"------------------------------------------------------------------------------- 756 757XpathINIT 758 759function! NULL() 760 Xpath 'a' 761 return 0 762endfunction 763 764function! ZERO() 765 Xpath 'b' 766 return 0 767endfunction 768 769function! F0() 770 Xpath 'c' 771endfunction 772 773function! F1(arg) 774 Xpath 'e' 775endfunction 776 777let V0 = 1 778 779Xpath 'f' 780echo 0 ? F{NULL() + V{ZERO()}}() : 1 781 782Xpath 'g' 783if 0 784 Xpath 'h' 785 call F{NULL() + V{ZERO()}}() 786endif 787 788Xpath 'i' 789if 1 790 asdf " error 791 Xpath 'j' 792 call F1(F{NULL() + V{ZERO()}}()) 793endif 794 795Xpath 'k' 796if 1 797 asdf " error 798 Xpath 'l' 799 call F{NULL() + V{ZERO()}}() 800endif 801 802let g:test12_result = g:Xpath 803 804func Test_braces_skipped() 805 call assert_equal('fgik', g:test12_result) 806endfunc 807 808 809"------------------------------------------------------------------------------- 810" Test 13: Failure in argument evaluation for :while {{{1 811" 812" A failure in the expression evaluation for the condition of a :while 813" causes the whole :while loop until the matching :endwhile being 814" ignored. Continuation is at the next following line. 815"------------------------------------------------------------------------------- 816 817XpathINIT 818 819Xpath 'a' 820while asdf 821 Xpath 'b' 822 while 1 823 Xpath 'c' 824 break 825 endwhile 826 Xpath 'd' 827 break 828endwhile 829Xpath 'e' 830 831while asdf | Xpath 'f' | endwhile | Xpath 'g' 832Xpath 'h' 833let g:test13_result = g:Xpath 834 835func Test_while_fail() 836 call assert_equal('aeh', g:test13_result) 837endfunc 838 839 840"------------------------------------------------------------------------------- 841" Test 14: Failure in argument evaluation for :if {{{1 842" 843" A failure in the expression evaluation for the condition of an :if 844" does not cause the corresponding :else or :endif being matched to 845" a previous :if/:elseif. Neither of both branches of the failed :if 846" are executed. 847"------------------------------------------------------------------------------- 848 849XpathINIT 850 851function! F() 852 Xpath 'a' 853 let x = 0 854 if x " false 855 Xpath 'b' 856 elseif !x " always true 857 Xpath 'c' 858 let x = 1 859 if g:boolvar " possibly undefined 860 Xpath 'd' 861 else 862 Xpath 'e' 863 endif 864 Xpath 'f' 865 elseif x " never executed 866 Xpath 'g' 867 endif 868 Xpath 'h' 869endfunction 870 871let boolvar = 1 872call F() 873Xpath '-' 874 875unlet boolvar 876call F() 877let g:test14_result = g:Xpath 878 879delfunction F 880 881func Test_if_fail() 882 call assert_equal('acdfh-acfh', g:test14_result) 883endfunc 884 885 886"------------------------------------------------------------------------------- 887" Test 15: Failure in argument evaluation for :if (bar) {{{1 888" 889" Like previous test, except that the failing :if ... | ... | :endif 890" is in a single line. 891"------------------------------------------------------------------------------- 892 893XpathINIT 894 895function! F() 896 Xpath 'a' 897 let x = 0 898 if x " false 899 Xpath 'b' 900 elseif !x " always true 901 Xpath 'c' 902 let x = 1 903 if g:boolvar | Xpath 'd' | else | Xpath 'e' | endif 904 Xpath 'f' 905 elseif x " never executed 906 Xpath 'g' 907 endif 908 Xpath 'h' 909endfunction 910 911let boolvar = 1 912call F() 913Xpath '-' 914 915unlet boolvar 916call F() 917let g:test15_result = g:Xpath 918 919delfunction F 920 921func Test_if_bar_fail() 922 call assert_equal('acdfh-acfh', g:test15_result) 923endfunc 924 925"------------------------------------------------------------------------------- 926" Test 16: Double :else or :elseif after :else {{{1 927" 928" Multiple :elses or an :elseif after an :else are forbidden. 929"------------------------------------------------------------------------------- 930 931func T16_F() abort 932 if 0 933 Xpath 'a' 934 else 935 Xpath 'b' 936 else " aborts function 937 Xpath 'c' 938 endif 939 Xpath 'd' 940endfunc 941 942func T16_G() abort 943 if 0 944 Xpath 'a' 945 else 946 Xpath 'b' 947 elseif 1 " aborts function 948 Xpath 'c' 949 else 950 Xpath 'd' 951 endif 952 Xpath 'e' 953endfunc 954 955func T16_H() abort 956 if 0 957 Xpath 'a' 958 elseif 0 959 Xpath 'b' 960 else 961 Xpath 'c' 962 else " aborts function 963 Xpath 'd' 964 endif 965 Xpath 'e' 966endfunc 967 968func T16_I() abort 969 if 0 970 Xpath 'a' 971 elseif 0 972 Xpath 'b' 973 else 974 Xpath 'c' 975 elseif 1 " aborts function 976 Xpath 'd' 977 else 978 Xpath 'e' 979 endif 980 Xpath 'f' 981endfunc 982 983func Test_Multi_Else() 984 XpathINIT 985 try 986 call T16_F() 987 catch /E583:/ 988 Xpath 'e' 989 endtry 990 call assert_equal('be', g:Xpath) 991 992 XpathINIT 993 try 994 call T16_G() 995 catch /E584:/ 996 Xpath 'f' 997 endtry 998 call assert_equal('bf', g:Xpath) 999 1000 XpathINIT 1001 try 1002 call T16_H() 1003 catch /E583:/ 1004 Xpath 'f' 1005 endtry 1006 call assert_equal('cf', g:Xpath) 1007 1008 XpathINIT 1009 try 1010 call T16_I() 1011 catch /E584:/ 1012 Xpath 'g' 1013 endtry 1014 call assert_equal('cg', g:Xpath) 1015endfunc 1016 1017"------------------------------------------------------------------------------- 1018" Test 17: Nesting of unmatched :if or :endif inside a :while {{{1 1019" 1020" The :while/:endwhile takes precedence in nesting over an unclosed 1021" :if or an unopened :endif. 1022"------------------------------------------------------------------------------- 1023 1024" While loops inside a function are continued on error. 1025func T17_F() 1026 let loops = 3 1027 while loops > 0 1028 let loops -= 1 1029 Xpath 'a' . loops 1030 if (loops == 1) 1031 Xpath 'b' . loops 1032 continue 1033 elseif (loops == 0) 1034 Xpath 'c' . loops 1035 break 1036 elseif 1 1037 Xpath 'd' . loops 1038 " endif missing! 1039 endwhile " :endwhile after :if 1 1040 Xpath 'e' 1041endfunc 1042 1043func T17_G() 1044 let loops = 2 1045 while loops > 0 1046 let loops -= 1 1047 Xpath 'a' . loops 1048 if 0 1049 Xpath 'b' . loops 1050 " endif missing 1051 endwhile " :endwhile after :if 0 1052endfunc 1053 1054func T17_H() 1055 let loops = 2 1056 while loops > 0 1057 let loops -= 1 1058 Xpath 'a' . loops 1059 " if missing! 1060 endif " :endif without :if in while 1061 Xpath 'b' . loops 1062 endwhile 1063endfunc 1064 1065" Error continuation outside a function is at the outermost :endwhile or :endif. 1066XpathINIT 1067let v:errmsg = '' 1068let loops = 2 1069while loops > 0 1070 let loops -= 1 1071 Xpath 'a' . loops 1072 if 0 1073 Xpath 'b' . loops 1074 " endif missing! Following :endwhile fails. 1075endwhile | Xpath 'c' 1076Xpath 'd' 1077call assert_match('E171:', v:errmsg) 1078call assert_equal('a1d', g:Xpath) 1079 1080func Test_unmatched_if_in_while() 1081 XpathINIT 1082 call assert_fails('call T17_F()', 'E171:') 1083 call assert_equal('a2d2a1b1a0c0e', g:Xpath) 1084 1085 XpathINIT 1086 call assert_fails('call T17_G()', 'E171:') 1087 call assert_equal('a1a0', g:Xpath) 1088 1089 XpathINIT 1090 call assert_fails('call T17_H()', 'E580:') 1091 call assert_equal('a1b1a0b0', g:Xpath) 1092endfunc 1093 1094"------------------------------------------------------------------------------- 1095"------------------------------------------------------------------------------- 1096"------------------------------------------------------------------------------- 1097" Test 87 using (expr) ? funcref : funcref {{{1 1098" 1099" Vim needs to correctly parse the funcref and even when it does 1100" not execute the funcref, it needs to consume the trailing () 1101"------------------------------------------------------------------------------- 1102 1103func Add2(x1, x2) 1104 return a:x1 + a:x2 1105endfu 1106 1107func GetStr() 1108 return "abcdefghijklmnopqrstuvwxyp" 1109endfu 1110 1111func Test_funcref_with_condexpr() 1112 call assert_equal(5, function('Add2')(2,3)) 1113 1114 call assert_equal(3, 1 ? function('Add2')(1,2) : function('Add2')(2,3)) 1115 call assert_equal(5, 0 ? function('Add2')(1,2) : function('Add2')(2,3)) 1116 " Make sure, GetStr() still works. 1117 call assert_equal('abcdefghijk', GetStr()[0:10]) 1118endfunc 1119 1120" Test 90: Recognizing {} in variable name. {{{1 1121"------------------------------------------------------------------------------- 1122 1123func Test_curlies() 1124 let s:var = 66 1125 let ns = 's' 1126 call assert_equal(66, {ns}:var) 1127 1128 let g:a = {} 1129 let g:b = 't' 1130 let g:a[g:b] = 77 1131 call assert_equal(77, g:a['t']) 1132endfunc 1133 1134"------------------------------------------------------------------------------- 1135" Test 91: using type(). {{{1 1136"------------------------------------------------------------------------------- 1137 1138func Test_type() 1139 call assert_equal(0, type(0)) 1140 call assert_equal(1, type("")) 1141 call assert_equal(2, type(function("tr"))) 1142 call assert_equal(2, type(function("tr", [8]))) 1143 call assert_equal(3, type([])) 1144 call assert_equal(4, type({})) 1145 if has('float') 1146 call assert_equal(5, type(0.0)) 1147 endif 1148 call assert_equal(6, type(v:false)) 1149 call assert_equal(6, type(v:true)) 1150 call assert_equal(7, type(v:none)) 1151 call assert_equal(7, type(v:null)) 1152 call assert_equal(8, v:t_job) 1153 call assert_equal(9, v:t_channel) 1154 call assert_equal(v:t_number, type(0)) 1155 call assert_equal(v:t_string, type("")) 1156 call assert_equal(v:t_func, type(function("tr"))) 1157 call assert_equal(v:t_func, type(function("tr", [8]))) 1158 call assert_equal(v:t_list, type([])) 1159 call assert_equal(v:t_dict, type({})) 1160 if has('float') 1161 call assert_equal(v:t_float, type(0.0)) 1162 endif 1163 call assert_equal(v:t_bool, type(v:false)) 1164 call assert_equal(v:t_bool, type(v:true)) 1165 call assert_equal(v:t_none, type(v:none)) 1166 call assert_equal(v:t_none, type(v:null)) 1167 1168 call assert_fails("call type(test_void())", 'E685:') 1169 call assert_fails("call type(test_unknown())", 'E685:') 1170 1171 call assert_equal(0, 0 + v:false) 1172 call assert_equal(1, 0 + v:true) 1173 call assert_equal(0, 0 + v:none) 1174 call assert_equal(0, 0 + v:null) 1175 1176 call assert_equal('v:false', '' . v:false) 1177 call assert_equal('v:true', '' . v:true) 1178 call assert_equal('v:none', '' . v:none) 1179 call assert_equal('v:null', '' . v:null) 1180 1181 call assert_true(v:false == 0) 1182 call assert_false(v:false != 0) 1183 call assert_true(v:true == 1) 1184 call assert_false(v:true != 1) 1185 call assert_false(v:true == v:false) 1186 call assert_true(v:true != v:false) 1187 1188 call assert_true(v:null == 0) 1189 call assert_false(v:null != 0) 1190 call assert_true(v:none == 0) 1191 call assert_false(v:none != 0) 1192 1193 call assert_true(v:false is v:false) 1194 call assert_true(v:true is v:true) 1195 call assert_true(v:none is v:none) 1196 call assert_true(v:null is v:null) 1197 1198 call assert_false(v:false isnot v:false) 1199 call assert_false(v:true isnot v:true) 1200 call assert_false(v:none isnot v:none) 1201 call assert_false(v:null isnot v:null) 1202 1203 call assert_false(v:false is 0) 1204 call assert_false(v:true is 1) 1205 call assert_false(v:true is v:false) 1206 call assert_false(v:none is 0) 1207 call assert_false(v:null is 0) 1208 call assert_false(v:null is v:none) 1209 1210 call assert_true(v:false isnot 0) 1211 call assert_true(v:true isnot 1) 1212 call assert_true(v:true isnot v:false) 1213 call assert_true(v:none isnot 0) 1214 call assert_true(v:null isnot 0) 1215 call assert_true(v:null isnot v:none) 1216 1217 call assert_equal(v:false, eval(string(v:false))) 1218 call assert_equal(v:true, eval(string(v:true))) 1219 call assert_equal(v:none, eval(string(v:none))) 1220 call assert_equal(v:null, eval(string(v:null))) 1221 1222 call assert_equal(v:false, copy(v:false)) 1223 call assert_equal(v:true, copy(v:true)) 1224 call assert_equal(v:none, copy(v:none)) 1225 call assert_equal(v:null, copy(v:null)) 1226 1227 call assert_equal([v:false], deepcopy([v:false])) 1228 call assert_equal([v:true], deepcopy([v:true])) 1229 call assert_equal([v:none], deepcopy([v:none])) 1230 call assert_equal([v:null], deepcopy([v:null])) 1231 1232 call assert_true(empty(v:false)) 1233 call assert_false(empty(v:true)) 1234 call assert_true(empty(v:null)) 1235 call assert_true(empty(v:none)) 1236 1237 func ChangeYourMind() 1238 try 1239 return v:true 1240 finally 1241 return 'something else' 1242 endtry 1243 endfunc 1244 1245 call ChangeYourMind() 1246endfunc 1247 1248"------------------------------------------------------------------------------- 1249" Test 92: skipping code {{{1 1250"------------------------------------------------------------------------------- 1251 1252func Test_skip() 1253 let Fn = function('Test_type') 1254 call assert_false(0 && Fn[1]) 1255 call assert_false(0 && string(Fn)) 1256 call assert_false(0 && len(Fn)) 1257 let l = [] 1258 call assert_false(0 && l[1]) 1259 call assert_false(0 && string(l)) 1260 call assert_false(0 && len(l)) 1261 let f = 1.0 1262 call assert_false(0 && f[1]) 1263 call assert_false(0 && string(f)) 1264 call assert_false(0 && len(f)) 1265 let sp = v:null 1266 call assert_false(0 && sp[1]) 1267 call assert_false(0 && string(sp)) 1268 call assert_false(0 && len(sp)) 1269 1270endfunc 1271 1272"------------------------------------------------------------------------------- 1273" Test 93: :echo and string() {{{1 1274"------------------------------------------------------------------------------- 1275 1276func Test_echo_and_string() 1277 " String 1278 let a = 'foo bar' 1279 redir => result 1280 echo a 1281 echo string(a) 1282 redir END 1283 let l = split(result, "\n") 1284 call assert_equal(["foo bar", 1285 \ "'foo bar'"], l) 1286 1287 " Float 1288 if has('float') 1289 let a = -1.2e0 1290 redir => result 1291 echo a 1292 echo string(a) 1293 redir END 1294 let l = split(result, "\n") 1295 call assert_equal(["-1.2", 1296 \ "-1.2"], l) 1297 endif 1298 1299 " Funcref 1300 redir => result 1301 echo function('string') 1302 echo string(function('string')) 1303 redir END 1304 let l = split(result, "\n") 1305 call assert_equal(["string", 1306 \ "function('string')"], l) 1307 1308 " Recursive dictionary 1309 let a = {} 1310 let a["a"] = a 1311 redir => result 1312 echo a 1313 echo string(a) 1314 redir END 1315 let l = split(result, "\n") 1316 call assert_equal(["{'a': {...}}", 1317 \ "{'a': {...}}"], l) 1318 1319 " Recursive list 1320 let a = [0] 1321 let a[0] = a 1322 redir => result 1323 echo a 1324 echo string(a) 1325 redir END 1326 let l = split(result, "\n") 1327 call assert_equal(["[[...]]", 1328 \ "[[...]]"], l) 1329 1330 " Empty dictionaries in a list 1331 let a = {} 1332 redir => result 1333 echo [a, a, a] 1334 echo string([a, a, a]) 1335 redir END 1336 let l = split(result, "\n") 1337 call assert_equal(["[{}, {}, {}]", 1338 \ "[{}, {}, {}]"], l) 1339 1340 " Empty dictionaries in a dictionary 1341 let a = {} 1342 let b = {"a": a, "b": a} 1343 redir => result 1344 echo b 1345 echo string(b) 1346 redir END 1347 let l = split(result, "\n") 1348 call assert_equal(["{'a': {}, 'b': {}}", 1349 \ "{'a': {}, 'b': {}}"], l) 1350 1351 " Empty lists in a list 1352 let a = [] 1353 redir => result 1354 echo [a, a, a] 1355 echo string([a, a, a]) 1356 redir END 1357 let l = split(result, "\n") 1358 call assert_equal(["[[], [], []]", 1359 \ "[[], [], []]"], l) 1360 1361 " Empty lists in a dictionary 1362 let a = [] 1363 let b = {"a": a, "b": a} 1364 redir => result 1365 echo b 1366 echo string(b) 1367 redir END 1368 let l = split(result, "\n") 1369 call assert_equal(["{'a': [], 'b': []}", 1370 \ "{'a': [], 'b': []}"], l) 1371 1372 " Dictionaries in a list 1373 let a = {"one": "yes", "two": "yes", "three": "yes"} 1374 redir => result 1375 echo [a, a, a] 1376 echo string([a, a, a]) 1377 redir END 1378 let l = split(result, "\n") 1379 call assert_equal(["[{'one': 'yes', 'two': 'yes', 'three': 'yes'}, {...}, {...}]", 1380 \ "[{'one': 'yes', 'two': 'yes', 'three': 'yes'}, {'one': 'yes', 'two': 'yes', 'three': 'yes'}, {'one': 'yes', 'two': 'yes', 'three': 'yes'}]"], l) 1381 1382 " Dictionaries in a dictionary 1383 let a = {"one": "yes", "two": "yes", "three": "yes"} 1384 let b = {"a": a, "b": a} 1385 redir => result 1386 echo b 1387 echo string(b) 1388 redir END 1389 let l = split(result, "\n") 1390 call assert_equal(["{'a': {'one': 'yes', 'two': 'yes', 'three': 'yes'}, 'b': {...}}", 1391 \ "{'a': {'one': 'yes', 'two': 'yes', 'three': 'yes'}, 'b': {'one': 'yes', 'two': 'yes', 'three': 'yes'}}"], l) 1392 1393 " Lists in a list 1394 let a = [1, 2, 3] 1395 redir => result 1396 echo [a, a, a] 1397 echo string([a, a, a]) 1398 redir END 1399 let l = split(result, "\n") 1400 call assert_equal(["[[1, 2, 3], [...], [...]]", 1401 \ "[[1, 2, 3], [1, 2, 3], [1, 2, 3]]"], l) 1402 1403 " Lists in a dictionary 1404 let a = [1, 2, 3] 1405 let b = {"a": a, "b": a} 1406 redir => result 1407 echo b 1408 echo string(b) 1409 redir END 1410 let l = split(result, "\n") 1411 call assert_equal(["{'a': [1, 2, 3], 'b': [...]}", 1412 \ "{'a': [1, 2, 3], 'b': [1, 2, 3]}"], l) 1413 1414endfunc 1415 1416"------------------------------------------------------------------------------- 1417" Test 94: 64-bit Numbers {{{1 1418"------------------------------------------------------------------------------- 1419 1420func Test_num64() 1421 call assert_notequal( 4294967296, 0) 1422 call assert_notequal(-4294967296, 0) 1423 call assert_equal( 4294967296, 0xFFFFffff + 1) 1424 call assert_equal(-4294967296, -0xFFFFffff - 1) 1425 1426 call assert_equal( 9223372036854775807, 1 / 0) 1427 call assert_equal(-9223372036854775807, -1 / 0) 1428 call assert_equal(-9223372036854775807 - 1, 0 / 0) 1429 1430 if has('float') 1431 call assert_equal( 0x7FFFffffFFFFffff, float2nr( 1.0e150)) 1432 call assert_equal(-0x7FFFffffFFFFffff, float2nr(-1.0e150)) 1433 endif 1434 1435 let rng = range(0xFFFFffff, 0x100000001) 1436 call assert_equal([0xFFFFffff, 0x100000000, 0x100000001], rng) 1437 call assert_equal(0x100000001, max(rng)) 1438 call assert_equal(0xFFFFffff, min(rng)) 1439 call assert_equal(rng, sort(range(0x100000001, 0xFFFFffff, -1), 'N')) 1440endfunc 1441 1442"------------------------------------------------------------------------------- 1443" Test 95: lines of :append, :change, :insert {{{1 1444"------------------------------------------------------------------------------- 1445 1446function! DefineFunction(name, body) 1447 let func = join(['function! ' . a:name . '()'] + a:body + ['endfunction'], "\n") 1448 exec func 1449endfunction 1450 1451func Test_script_lines() 1452 " :append 1453 try 1454 call DefineFunction('T_Append', [ 1455 \ 'append', 1456 \ 'py <<EOS', 1457 \ '.', 1458 \ ]) 1459 catch 1460 call assert_report("Can't define function") 1461 endtry 1462 try 1463 call DefineFunction('T_Append', [ 1464 \ 'append', 1465 \ 'abc', 1466 \ ]) 1467 call assert_report("Shouldn't be able to define function") 1468 catch 1469 call assert_exception('Vim(function):E126: Missing :endfunction') 1470 endtry 1471 1472 " :change 1473 try 1474 call DefineFunction('T_Change', [ 1475 \ 'change', 1476 \ 'py <<EOS', 1477 \ '.', 1478 \ ]) 1479 catch 1480 call assert_report("Can't define function") 1481 endtry 1482 try 1483 call DefineFunction('T_Change', [ 1484 \ 'change', 1485 \ 'abc', 1486 \ ]) 1487 call assert_report("Shouldn't be able to define function") 1488 catch 1489 call assert_exception('Vim(function):E126: Missing :endfunction') 1490 endtry 1491 1492 " :insert 1493 try 1494 call DefineFunction('T_Insert', [ 1495 \ 'insert', 1496 \ 'py <<EOS', 1497 \ '.', 1498 \ ]) 1499 catch 1500 call assert_report("Can't define function") 1501 endtry 1502 try 1503 call DefineFunction('T_Insert', [ 1504 \ 'insert', 1505 \ 'abc', 1506 \ ]) 1507 call assert_report("Shouldn't be able to define function") 1508 catch 1509 call assert_exception('Vim(function):E126: Missing :endfunction') 1510 endtry 1511endfunc 1512 1513"------------------------------------------------------------------------------- 1514" Test 96: line continuation {{{1 1515" 1516" Undefined behavior was detected by ubsan with line continuation 1517" after an empty line. 1518"------------------------------------------------------------------------------- 1519func Test_script_emty_line_continuation() 1520 1521 \ 1522endfunc 1523 1524"------------------------------------------------------------------------------- 1525" Test 97: bitwise functions {{{1 1526"------------------------------------------------------------------------------- 1527func Test_bitwise_functions() 1528 " and 1529 call assert_equal(127, and(127, 127)) 1530 call assert_equal(16, and(127, 16)) 1531 eval 127->and(16)->assert_equal(16) 1532 call assert_equal(0, and(127, 128)) 1533 call assert_fails("call and([], 1)", 'E745:') 1534 call assert_fails("call and({}, 1)", 'E728:') 1535 if has('float') 1536 call assert_fails("call and(1.0, 1)", 'E805:') 1537 call assert_fails("call and(1, 1.0)", 'E805:') 1538 endif 1539 call assert_fails("call and(1, [])", 'E745:') 1540 call assert_fails("call and(1, {})", 'E728:') 1541 " or 1542 call assert_equal(23, or(16, 7)) 1543 call assert_equal(15, or(8, 7)) 1544 eval 8->or(7)->assert_equal(15) 1545 call assert_equal(123, or(0, 123)) 1546 call assert_fails("call or([], 1)", 'E745:') 1547 call assert_fails("call or({}, 1)", 'E728:') 1548 if has('float') 1549 call assert_fails("call or(1.0, 1)", 'E805:') 1550 call assert_fails("call or(1, 1.0)", 'E805:') 1551 endif 1552 call assert_fails("call or(1, [])", 'E745:') 1553 call assert_fails("call or(1, {})", 'E728:') 1554 " xor 1555 call assert_equal(0, xor(127, 127)) 1556 call assert_equal(111, xor(127, 16)) 1557 eval 127->xor(16)->assert_equal(111) 1558 call assert_equal(255, xor(127, 128)) 1559 if has('float') 1560 call assert_fails("call xor(1.0, 1)", 'E805:') 1561 call assert_fails("call xor(1, 1.0)", 'E805:') 1562 endif 1563 call assert_fails("call xor([], 1)", 'E745:') 1564 call assert_fails("call xor({}, 1)", 'E728:') 1565 call assert_fails("call xor(1, [])", 'E745:') 1566 call assert_fails("call xor(1, {})", 'E728:') 1567 " invert 1568 call assert_equal(65408, and(invert(127), 65535)) 1569 eval 127->invert()->and(65535)->assert_equal(65408) 1570 call assert_equal(65519, and(invert(16), 65535)) 1571 call assert_equal(65407, and(invert(128), 65535)) 1572 if has('float') 1573 call assert_fails("call invert(1.0)", 'E805:') 1574 endif 1575 call assert_fails("call invert([])", 'E745:') 1576 call assert_fails("call invert({})", 'E728:') 1577endfunc 1578 1579" Test trailing text after :endfunction {{{1 1580func Test_endfunction_trailing() 1581 call assert_false(exists('*Xtest')) 1582 1583 exe "func Xtest()\necho 'hello'\nendfunc\nlet done = 'yes'" 1584 call assert_true(exists('*Xtest')) 1585 call assert_equal('yes', done) 1586 delfunc Xtest 1587 unlet done 1588 1589 exe "func Xtest()\necho 'hello'\nendfunc|let done = 'yes'" 1590 call assert_true(exists('*Xtest')) 1591 call assert_equal('yes', done) 1592 delfunc Xtest 1593 unlet done 1594 1595 " trailing line break 1596 exe "func Xtest()\necho 'hello'\nendfunc\n" 1597 call assert_true(exists('*Xtest')) 1598 delfunc Xtest 1599 1600 set verbose=1 1601 exe "func Xtest()\necho 'hello'\nendfunc \" garbage" 1602 call assert_notmatch('W22:', split(execute('1messages'), "\n")[0]) 1603 call assert_true(exists('*Xtest')) 1604 delfunc Xtest 1605 1606 exe "func Xtest()\necho 'hello'\nendfunc garbage" 1607 call assert_match('W22:', split(execute('1messages'), "\n")[0]) 1608 call assert_true(exists('*Xtest')) 1609 delfunc Xtest 1610 set verbose=0 1611 1612 function Foo() 1613 echo 'hello' 1614 endfunction | echo 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx' 1615 delfunc Foo 1616endfunc 1617 1618func Test_delfunction_force() 1619 delfunc! Xtest 1620 delfunc! Xtest 1621 func Xtest() 1622 echo 'nothing' 1623 endfunc 1624 delfunc! Xtest 1625 delfunc! Xtest 1626endfunc 1627 1628" Test using bang after user command {{{1 1629func Test_user_command_with_bang() 1630 command -bang Nieuw let nieuw = 1 1631 Ni! 1632 call assert_equal(1, nieuw) 1633 unlet nieuw 1634 delcommand Nieuw 1635endfunc 1636 1637" Test for script-local function 1638func <SID>DoLast() 1639 call append(line('$'), "last line") 1640endfunc 1641 1642func s:DoNothing() 1643 call append(line('$'), "nothing line") 1644endfunc 1645 1646func Test_script_local_func() 1647 set nocp nomore viminfo+=nviminfo 1648 new 1649 nnoremap <buffer> _x :call <SID>DoNothing()<bar>call <SID>DoLast()<bar>delfunc <SID>DoNothing<bar>delfunc <SID>DoLast<cr> 1650 1651 normal _x 1652 call assert_equal('nothing line', getline(2)) 1653 call assert_equal('last line', getline(3)) 1654 enew! | close 1655endfunc 1656 1657func Test_script_expand_sfile() 1658 let lines =<< trim END 1659 func s:snr() 1660 return expand('<sfile>') 1661 endfunc 1662 let g:result = s:snr() 1663 END 1664 call writefile(lines, 'Xexpand') 1665 source Xexpand 1666 call assert_match('<SNR>\d\+_snr', g:result) 1667 source Xexpand 1668 call assert_match('<SNR>\d\+_snr', g:result) 1669 1670 call delete('Xexpand') 1671 unlet g:result 1672endfunc 1673 1674func Test_compound_assignment_operators() 1675 " Test for number 1676 let x = 1 1677 let x += 10 1678 call assert_equal(11, x) 1679 let x -= 5 1680 call assert_equal(6, x) 1681 let x *= 4 1682 call assert_equal(24, x) 1683 let x /= 3 1684 call assert_equal(8, x) 1685 let x %= 3 1686 call assert_equal(2, x) 1687 let x .= 'n' 1688 call assert_equal('2n', x) 1689 1690 " Test special cases: division or modulus with 0. 1691 let x = 1 1692 let x /= 0 1693 call assert_equal(0x7FFFFFFFFFFFFFFF, x) 1694 1695 let x = -1 1696 let x /= 0 1697 call assert_equal(-0x7FFFFFFFFFFFFFFF, x) 1698 1699 let x = 0 1700 let x /= 0 1701 call assert_equal(-0x7FFFFFFFFFFFFFFF - 1, x) 1702 1703 let x = 1 1704 let x %= 0 1705 call assert_equal(0, x) 1706 1707 let x = -1 1708 let x %= 0 1709 call assert_equal(0, x) 1710 1711 let x = 0 1712 let x %= 0 1713 call assert_equal(0, x) 1714 1715 " Test for string 1716 let x = 'str' 1717 let x .= 'ing' 1718 call assert_equal('string', x) 1719 let x += 1 1720 call assert_equal(1, x) 1721 1722 if has('float') 1723 " Test for float 1724 let x -= 1.5 1725 call assert_equal(-0.5, x) 1726 let x = 0.5 1727 let x += 4.5 1728 call assert_equal(5.0, x) 1729 let x -= 1.5 1730 call assert_equal(3.5, x) 1731 let x *= 3.0 1732 call assert_equal(10.5, x) 1733 let x /= 2.5 1734 call assert_equal(4.2, x) 1735 call assert_fails('let x %= 0.5', 'E734') 1736 call assert_fails('let x .= "f"', 'E734') 1737 endif 1738 1739 " Test for environment variable 1740 let $FOO = 1 1741 call assert_fails('let $FOO += 1', 'E734') 1742 call assert_fails('let $FOO -= 1', 'E734') 1743 call assert_fails('let $FOO *= 1', 'E734') 1744 call assert_fails('let $FOO /= 1', 'E734') 1745 call assert_fails('let $FOO %= 1', 'E734') 1746 let $FOO .= 's' 1747 call assert_equal('1s', $FOO) 1748 unlet $FOO 1749 1750 " Test for option variable (type: number) 1751 let &scrolljump = 1 1752 let &scrolljump += 5 1753 call assert_equal(6, &scrolljump) 1754 let &scrolljump -= 2 1755 call assert_equal(4, &scrolljump) 1756 let &scrolljump *= 3 1757 call assert_equal(12, &scrolljump) 1758 let &scrolljump /= 2 1759 call assert_equal(6, &scrolljump) 1760 let &scrolljump %= 5 1761 call assert_equal(1, &scrolljump) 1762 call assert_fails('let &scrolljump .= "j"', 'E734') 1763 set scrolljump&vim 1764 1765 " Test for register 1766 let @/ = 1 1767 call assert_fails('let @/ += 1', 'E734') 1768 call assert_fails('let @/ -= 1', 'E734') 1769 call assert_fails('let @/ *= 1', 'E734') 1770 call assert_fails('let @/ /= 1', 'E734') 1771 call assert_fails('let @/ %= 1', 'E734') 1772 let @/ .= 's' 1773 call assert_equal('1s', @/) 1774 let @/ = '' 1775endfunc 1776 1777func Test_refcount() 1778 " Immediate values 1779 call assert_equal(-1, test_refcount(1)) 1780 call assert_equal(-1, test_refcount('s')) 1781 call assert_equal(-1, test_refcount(v:true)) 1782 call assert_equal(0, test_refcount([])) 1783 call assert_equal(0, test_refcount({})) 1784 call assert_equal(0, test_refcount(0zff)) 1785 call assert_equal(0, test_refcount({-> line('.')})) 1786 if has('float') 1787 call assert_equal(-1, test_refcount(0.1)) 1788 endif 1789 if has('job') 1790 call assert_equal(0, test_refcount(job_start([&shell, &shellcmdflag, 'echo .']))) 1791 endif 1792 1793 " No refcount types 1794 let x = 1 1795 call assert_equal(-1, test_refcount(x)) 1796 let x = 's' 1797 call assert_equal(-1, test_refcount(x)) 1798 let x = v:true 1799 call assert_equal(-1, test_refcount(x)) 1800 if has('float') 1801 let x = 0.1 1802 call assert_equal(-1, test_refcount(x)) 1803 endif 1804 1805 " Check refcount 1806 let x = [] 1807 call assert_equal(1, test_refcount(x)) 1808 1809 let x = {} 1810 call assert_equal(1, x->test_refcount()) 1811 1812 let x = 0zff 1813 call assert_equal(1, test_refcount(x)) 1814 1815 let X = {-> line('.')} 1816 call assert_equal(1, test_refcount(X)) 1817 let Y = X 1818 call assert_equal(2, test_refcount(X)) 1819 1820 if has('job') 1821 let job = job_start([&shell, &shellcmdflag, 'echo .']) 1822 call assert_equal(1, test_refcount(job)) 1823 call assert_equal(1, test_refcount(job_getchannel(job))) 1824 call assert_equal(1, test_refcount(job)) 1825 endif 1826 1827 " Function arguments, copying and unassigning 1828 func ExprCheck(x, i) 1829 let i = a:i + 1 1830 call assert_equal(i, test_refcount(a:x)) 1831 let Y = a:x 1832 call assert_equal(i + 1, test_refcount(a:x)) 1833 call assert_equal(test_refcount(a:x), test_refcount(Y)) 1834 let Y = 0 1835 call assert_equal(i, test_refcount(a:x)) 1836 endfunc 1837 call ExprCheck([], 0) 1838 call ExprCheck({}, 0) 1839 call ExprCheck(0zff, 0) 1840 call ExprCheck({-> line('.')}, 0) 1841 if has('job') 1842 call ExprCheck(job, 1) 1843 call ExprCheck(job_getchannel(job), 1) 1844 call job_stop(job) 1845 endif 1846 delfunc ExprCheck 1847 1848 " Regarding function 1849 func Func(x) abort 1850 call assert_equal(2, test_refcount(function('Func'))) 1851 call assert_equal(0, test_refcount(funcref('Func'))) 1852 endfunc 1853 call assert_equal(1, test_refcount(function('Func'))) 1854 call assert_equal(0, test_refcount(function('Func', [1]))) 1855 call assert_equal(0, test_refcount(funcref('Func'))) 1856 call assert_equal(0, test_refcount(funcref('Func', [1]))) 1857 let X = function('Func') 1858 let Y = X 1859 call assert_equal(1, test_refcount(X)) 1860 let X = function('Func', [1]) 1861 let Y = X 1862 call assert_equal(2, test_refcount(X)) 1863 let X = funcref('Func') 1864 let Y = X 1865 call assert_equal(2, test_refcount(X)) 1866 let X = funcref('Func', [1]) 1867 let Y = X 1868 call assert_equal(2, test_refcount(X)) 1869 unlet X 1870 unlet Y 1871 call Func(1) 1872 delfunc Func 1873 1874 " Function with dict 1875 func DictFunc() dict 1876 call assert_equal(3, test_refcount(self)) 1877 endfunc 1878 let d = {'Func': function('DictFunc')} 1879 call assert_equal(1, test_refcount(d)) 1880 call assert_equal(0, test_refcount(d.Func)) 1881 call d.Func() 1882 unlet d 1883 delfunc DictFunc 1884endfunc 1885 1886func Test_funccall_garbage_collect() 1887 func Func(x, ...) 1888 call add(a:x, a:000) 1889 endfunc 1890 call Func([], []) 1891 " Must not crash cause by invalid freeing 1892 call test_garbagecollect_now() 1893 call assert_true(v:true) 1894 delfunc Func 1895endfunc 1896 1897func Test_function_defined_line() 1898 CheckNotGui 1899 1900 let lines =<< trim [CODE] 1901 " F1 1902 func F1() 1903 " F2 1904 func F2() 1905 " 1906 " 1907 " 1908 return 1909 endfunc 1910 " F3 1911 execute "func F3()\n\n\n\nreturn\nendfunc" 1912 " F4 1913 execute "func F4()\n 1914 \\n 1915 \\n 1916 \\n 1917 \return\n 1918 \endfunc" 1919 endfunc 1920 " F5 1921 execute "func F5()\n\n\n\nreturn\nendfunc" 1922 " F6 1923 execute "func F6()\n 1924 \\n 1925 \\n 1926 \\n 1927 \return\n 1928 \endfunc" 1929 call F1() 1930 verbose func F1 1931 verbose func F2 1932 verbose func F3 1933 verbose func F4 1934 verbose func F5 1935 verbose func F6 1936 qall! 1937 [CODE] 1938 1939 call writefile(lines, 'Xtest.vim') 1940 let res = system(GetVimCommandClean() .. ' -es -X -S Xtest.vim') 1941 call assert_equal(0, v:shell_error) 1942 1943 let m = matchstr(res, 'function F1()[^[:print:]]*[[:print:]]*') 1944 call assert_match(' line 2$', m) 1945 1946 let m = matchstr(res, 'function F2()[^[:print:]]*[[:print:]]*') 1947 call assert_match(' line 4$', m) 1948 1949 let m = matchstr(res, 'function F3()[^[:print:]]*[[:print:]]*') 1950 call assert_match(' line 11$', m) 1951 1952 let m = matchstr(res, 'function F4()[^[:print:]]*[[:print:]]*') 1953 call assert_match(' line 13$', m) 1954 1955 let m = matchstr(res, 'function F5()[^[:print:]]*[[:print:]]*') 1956 call assert_match(' line 21$', m) 1957 1958 let m = matchstr(res, 'function F6()[^[:print:]]*[[:print:]]*') 1959 call assert_match(' line 23$', m) 1960 1961 call delete('Xtest.vim') 1962endfunc 1963 1964" Test for missing :endif, :endfor, :endwhile and :endtry {{{1 1965func Test_missing_end() 1966 call writefile(['if 2 > 1', 'echo ">"'], 'Xscript') 1967 call assert_fails('source Xscript', 'E171:') 1968 call writefile(['for i in range(5)', 'echo i'], 'Xscript') 1969 call assert_fails('source Xscript', 'E170:') 1970 call writefile(['while v:true', 'echo "."'], 'Xscript') 1971 call assert_fails('source Xscript', 'E170:') 1972 call writefile(['try', 'echo "."'], 'Xscript') 1973 call assert_fails('source Xscript', 'E600:') 1974 call delete('Xscript') 1975 1976 " Using endfor with :while 1977 let caught_e732 = 0 1978 try 1979 while v:true 1980 endfor 1981 catch /E732:/ 1982 let caught_e732 = 1 1983 endtry 1984 call assert_equal(1, caught_e732) 1985 1986 " Using endwhile with :for 1987 let caught_e733 = 0 1988 try 1989 for i in range(1) 1990 endwhile 1991 catch /E733:/ 1992 let caught_e733 = 1 1993 endtry 1994 call assert_equal(1, caught_e733) 1995 1996 " Missing 'in' in a :for statement 1997 call assert_fails('for i range(1) | endfor', 'E690:') 1998endfunc 1999 2000" Test for deep nesting of if/for/while/try statements {{{1 2001func Test_deep_nest() 2002 if !CanRunVimInTerminal() 2003 throw 'Skipped: cannot run vim in terminal' 2004 endif 2005 2006 let lines =<< trim [SCRIPT] 2007 " Deep nesting of if ... endif 2008 func Test1() 2009 let @a = join(repeat(['if v:true'], 51), "\n") 2010 let @a ..= "\n" 2011 let @a ..= join(repeat(['endif'], 51), "\n") 2012 @a 2013 let @a = '' 2014 endfunc 2015 2016 " Deep nesting of for ... endfor 2017 func Test2() 2018 let @a = join(repeat(['for i in [1]'], 51), "\n") 2019 let @a ..= "\n" 2020 let @a ..= join(repeat(['endfor'], 51), "\n") 2021 @a 2022 let @a = '' 2023 endfunc 2024 2025 " Deep nesting of while ... endwhile 2026 func Test3() 2027 let @a = join(repeat(['while v:true'], 51), "\n") 2028 let @a ..= "\n" 2029 let @a ..= join(repeat(['endwhile'], 51), "\n") 2030 @a 2031 let @a = '' 2032 endfunc 2033 2034 " Deep nesting of try ... endtry 2035 func Test4() 2036 let @a = join(repeat(['try'], 51), "\n") 2037 let @a ..= "\necho v:true\n" 2038 let @a ..= join(repeat(['endtry'], 51), "\n") 2039 @a 2040 let @a = '' 2041 endfunc 2042 [SCRIPT] 2043 call writefile(lines, 'Xscript') 2044 2045 let buf = RunVimInTerminal('-S Xscript', {'rows': 6}) 2046 2047 " Deep nesting of if ... endif 2048 call term_sendkeys(buf, ":call Test1()\n") 2049 call WaitForAssert({-> assert_match('^E579:', term_getline(buf, 5))}) 2050 2051 " Deep nesting of for ... endfor 2052 call term_sendkeys(buf, ":call Test2()\n") 2053 call WaitForAssert({-> assert_match('^E585:', term_getline(buf, 5))}) 2054 2055 " Deep nesting of while ... endwhile 2056 call term_sendkeys(buf, ":call Test3()\n") 2057 call WaitForAssert({-> assert_match('^E585:', term_getline(buf, 5))}) 2058 2059 " Deep nesting of try ... endtry 2060 call term_sendkeys(buf, ":call Test4()\n") 2061 call WaitForAssert({-> assert_match('^E601:', term_getline(buf, 5))}) 2062 2063 "let l = '' 2064 "for i in range(1, 6) 2065 " let l ..= term_getline(buf, i) . "\n" 2066 "endfor 2067 "call assert_report(l) 2068 2069 call StopVimInTerminal(buf) 2070 call delete('Xscript') 2071endfunc 2072 2073" Test for <sfile>, <slnum> in a function {{{1 2074func Test_sfile_in_function() 2075 func Xfunc() 2076 call assert_match('..Test_sfile_in_function\[5]..Xfunc', expand('<sfile>')) 2077 call assert_equal('2', expand('<slnum>')) 2078 endfunc 2079 call Xfunc() 2080 delfunc Xfunc 2081endfunc 2082 2083"------------------------------------------------------------------------------- 2084" Modelines {{{1 2085" vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker 2086"------------------------------------------------------------------------------- 2087