summary refs log tree commit diff
path: root/Test/A01grammar.ztst
blob: 217f7bea4f17686252692a75f9f76fc7dd6c1f21 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
#
# This file contains tests corresponding to the `Shell Grammar' texinfo node.
#

%prep

  mkdir basic.tmp && cd basic.tmp

  touch foo bar
  echo "'" >unmatched_quote.txt

%test
#
# Tests for `Simple Commands and Pipelines'
#

  # Test skipping early to ensure we run the remainder...
  if [[ -n $ZTST_test_skip ]]; then
    ZTST_skip="Test system verification for skipping"
  else
    print "This is standard output"
    print "This is standard error" >&2
    false
  fi
1:Test skipping if ZTST_test_skip is set
>This is standard output
?This is standard error

  echo foo | cat | sed 's/foo/bar/'
0:Basic pipeline handling
>bar

  false | true
0:Exit status of pipeline with builtins (true)

  true | false
1:Exit status of pipeline with builtins (false)

  false
  $nonexistent_variable
0:Executing command that evaluates to empty resets status

  false
  sleep 1 &
  print $?
  # a tidy test is a happy test
  wait $!
0:Starting background command resets status
>0

  false
  . /dev/null
0:Sourcing empty file resets status

  fn() { local foo; read foo; print $foo; }
  coproc fn
  print -p coproc test output
  read -p bar
  print $bar
0:Basic coprocess handling
>coproc test output

  true | false && print true || print false
0:Basic sublist (i)
>false

  false | true && print true || print false
0:Basic sublist (ii)
>true

  (cd /NonExistentDirectory >&/dev/null) || print false
0:Basic subshell list with error
>false

  { cd /NonExistentDirectory >&/dev/null } || print false
0:Basic current shell list with error
>false

#
# Tests for `Precommand Modifiers'
#
  - $ZTST_testdir/../Src/zsh -fc "[[ \$0 = \"-$ZTST_testdir/../Src/zsh\" ]]"
0:`-' precommand modifier

  echo f*
  noglob echo f*
0:`noglob' precommand modifier
>foo
>f*

  (exec /bin/sh; echo bar)
0:`exec' precommand modifier

  (exec -l $ZTST_testdir/../Src/zsh -fc 'echo $0' | sed 's%/.*/%%' )
0:`exec' with -l option
>-zsh

  (exec -a /bin/SPLATTER /bin/sh -c 'echo $0')
0:`exec' with -a option
>/bin/SPLATTER

  (exec -a/bin/SPLOOSH /bin/sh -c 'echo $0')
0:`exec' with -a option, no space
>/bin/SPLOOSH

  (exec -a foo* $ZTST_testdir/../Src/zsh -fc 'print -r -- ${(V)0}')
  (exec -a "" $ZTST_testdir/../Src/zsh -fc 'print -r -- ${(V)0}')
0:rationalisation of arguments to exec -a
>foo*
>

  (
    opts=(-a /bin/WHOOOSH)
    exec $opts /bin/sh -c 'echo $0'
  )
0:`exec' with -a option from expansion
>/bin/WHOOOSH

  (export FOO=bar; exec -c /bin/sh -c 'echo x${FOO}x')
0:`exec' with -c option
>xx

  (\exec /bin/sh -c 'echo Test one'; print Not reached)
  ('exec' /bin/sh -c 'echo Test two'; print Not reached)
  (\exec -c /bin/sh -c 'echo Test three'; print Not reached)
0:precommand modifiers with quotes
>Test one
>Test two
>Test three

  cat() { echo Function cat executed; }
  command cat && unfunction cat
0:`command' precommand modifier
<External command cat executed
>External command cat executed

  (command -p echo this is output)
  (\command -p echo this is more output)
  ('command' -p echo this is yet more output)
0: command -p without -v or -V
>this is output
>this is more output
>this is yet more output

  command -pv cat
  command -pv echo
  command -p -V cat
  command -p -V -- echo
0:command -p in combination
*>*/cat
>echo
>cat is /*/cat
>echo is a shell builtin

  args=(
  'command -pv cat'
  'command -pv echo'
  'command -p -V cat'
  'command -p -V -- echo'
  )
  for arg in $args; do
    ${=arg}
  done
0:command -p in combination, using expansion
*>*/cat
>echo
>cat is /*/cat
>echo is a shell builtin

  cd() { echo Not cd at all; }
  builtin cd . && unfunction cd
0:`builtin' precommand modifier

#
# Tests for `Complex Commands'
#

  if true; then
    print true-1
  elif true; then
    print true-2
  else
    print false
  fi
0:`if ...' (i)
>true-1

  if false; then
    print true-1
  elif true; then
    print true-2
  else
    print false
  fi
0:`if ...' (ii)
>true-2

  if false; then
    print true-1
  elif false; then
    print true-2
  else
    print false
  fi
0:`if ...' (iii)
>false

  if true;
    :
  fi
1d:`if ...' (iv)
?(eval):3: parse error near `fi'

  for name in word to term; do
    print $name
  done
0:`for' loop
>word
>to
>term

  for name
  in word to term; do
    print $name
  done
0:`for' loop with newline before in keyword
>word
>to
>term

  for (( name = 0; name < 3; name++ )); do
    print $name
  done
0:arithmetic `for' loop
>0
>1
>2

  for (( $(true); ; )); do break; done
  for (( ; $(true); )); do break; done
  for (( ; ; $(true) )); do break; done
  for (( ; $((1)); )); do break; done
0:regression test, nested cmdsubst in arithmetic `for' loop

  for keyvar valvar in key1 val1 key2 val2; do
     print key=$keyvar val=$valvar
  done
0:enhanced `for' syntax with two loop variables
>key=key1 val=val1
>key=key2 val=val2

  for keyvar valvar stuffvar in keyA valA stuffA keyB valB stuffB; do
     print key=$keyvar val=$valvar stuff=$stuffvar
  done
0:enhanced `for' syntax with three loop variables
>key=keyA val=valA stuff=stuffA
>key=keyB val=valB stuff=stuffB

  for in in in in in stop; do
    print in=$in
  done
0:compatibility of enhanced `for' syntax with standard syntax
>in=in
>in=in
>in=in
>in=stop

  name=0
  while (( name < 3 )); do
    print $name
    (( name++ ))
  done
0:`while' loop
>0
>1
>2

  name=0
  until (( name == 3 )); do
    print $name
    (( name++ ))
  done
0:`until' loop
>0
>1
>2

  repeat 3 do
    echo over and over
  done
0:`repeat' loop
>over and over
>over and over
>over and over

  word=Trinity
  case $word in
    Michaelmas) print 0
                ;;
    Hilary) print 1
            ;;
    Trinity) print 2
             ;;
    *) print 3
       ;;
  esac
0:`case', old syntax
>2

  word=Trinity
  case $word in
    (Michaelmas) print 0
                ;;
    (Hilary) print 1
            ;;
    (Trinity) print 2
             ;;
    (*) print 3
       ;;
  esac
0:`case', new syntax
>2

  word=Hilary
  case $word in
    (Michaelmas) print 0
                ;;
    (Hilary) print 1
            ;&
    (Trinity) print 2
             ;&
    (*) print 3
       ;;
  esac
0:`case', new syntax, cascaded
>1
>2
>3

  case whatever in
  (*) print yeah, right ;&
  esac
  print but well
0:'case', redundant final ";&"
>yeah, right
>but well

## Select now reads from stdin if the shell is not interactive.
## Its own output goes to stderr.
  (COLUMNS=80 LINES=3
  PS3="input> "
  select name in one two three; do
    print $name
  done)
0:`select' loop
<2
?1) one     2) two     3) three   
?input> input> 
>two

  function name1 name2 () { print This is $0; }
  name2
  name1 name2() { print This is still $0; }
  name2
0:`function' keyword
>This is name2
>This is still name2

  (time cat) >&/dev/null
0:`time' keyword (status only)

  TIMEFMT='%E %mE %uE %* %m%mm %u%uu'; time (:)
0:`time' keyword with custom TIMEFMT
*?[0-9]##.[0-9](#c2)s [0-9]##ms [0-9]##us %\* %m%mm %u%uu

  if [[ -f foo && -d . && -n $ZTST_testdir ]]; then
    true
  else
    false
  fi
0:basic [[ ... ]] test

#
# Current shell execution with try/always form.
# We put those with errors in subshells so that any unhandled error doesn't
# propagate.
#

  {
     print The try block.
  } always {
     print The always block.
  }
  print After the always block.
0:Basic `always' syntax
>The try block.
>The always block.
>After the always block.

  ({
    print Position one.
    print ${*this is an error*}
    print Position two.
  } always {
    if (( TRY_BLOCK_ERROR )); then
      print An error occurred.
    else
      print No error occurred.
    fi
  }
  print Position three)
1:Always block with error not reset
>Position one.
>An error occurred.
?(eval):3: bad substitution

  ({
    print Stelle eins.
    print ${*voici une erreur}
    print Posizione due.
  } always {
    if (( TRY_BLOCK_ERROR )); then
      print Erratum factum est. Retro ponetur.
      (( TRY_BLOCK_ERROR = 0 ))
    else
      print unray touay foay anguageslay
    fi
  }
  print Status after always block is $?.)
0:Always block with error reset
>Stelle eins.
>Erratum factum est. Retro ponetur.
>Status after always block is 1.
?(eval):3: bad substitution

  fn() { { return } always { echo always 1 }; echo not executed }
  fn
  fn() { { echo try 2 } always { return }; echo not executed }
  fn
0:Always block interaction with return
>always 1
>try 2

# Outputting of structures from the wordcode is distinctly non-trivial,
# we probably ought to have more like the following...
  fn1() { { echo foo; } }
  fn2() { { echo foo; } always { echo bar; } }
  fn3() { ( echo foo; ) }
  functions fn1 fn2 fn3
0:Output of syntactic structures with and without always blocks
>fn1 () {
>	{
>		echo foo
>	}
>}
>fn2 () {
>	{
>		echo foo
>	} always {
>		echo bar
>	}
>}
>fn3 () {
>	(
>		echo foo
>	)
>}


#
# Tests for `Alternate Forms For Complex Commands'
#

  if (true) { print true-1 } elif (true) { print true-2 } else { print false }
  if (false) { print true-1 } elif (true) { print true-2 } else { print false }
  if (false) { print true-1 } elif (false) { print true-2 } else { print false }
0:Alternate `if' with braces
>true-1
>true-2
>false

  if { true } print true
  if { false } print false
0:Short form of `if'
>true

  eval "if"
1:Short form of `if' can't be too short
?(eval):1: parse error near `if'

  for name ( word1 word2 word3 ) print $name
0:Form of `for' with parentheses.
>word1
>word2
>word3

  for name in alpha beta gamma; print $name
0:Short form of `for'
>alpha
>beta
>gamma

  for (( val = 2; val < 10; val *= val )) print $val
0:Short arithmetic `for'
>2
>4

  foreach name ( verbiage words periphrasis )
    print $name
  end
0:Csh-like `for'
>verbiage
>words
>periphrasis

# see comment with braces used in if loops
  val=0;
  while (( val < 2 )) { print $((val++)); }
0:Alternative `while'
>0
>1

  val=2;
  until (( val == 0 )) { print $((val--)); }
0:Alternative `until'
>2
>1

  repeat 3 print Hip hip hooray
0:Short `repeat'
>Hip hip hooray
>Hip hip hooray
>Hip hip hooray

  case bravo {
    (alpha) print schmalpha
	    ;;
    (bravo) print schmavo
	    ;;
    (charlie) print schmarlie
	    ;;
  }
0:`case' with braces
>schmavo

  for word in artichoke bladderwort chrysanthemum Zanzibar
  case $word in
    (*der*) print $word contains the forbidden incantation der
         ;;
    (a*) print $word begins with a
         ;&
    ([[:upper:]]*) print $word either begins with a or an upper case letter
         ;|
    ([[:lower:]]*) print $word begins with a lower case letter
         ;|
    (*e*) print $word contains an e
         ;;
  esac
0:`case' with mixed ;& and ;|
>artichoke begins with a
>artichoke either begins with a or an upper case letter
>artichoke begins with a lower case letter
>artichoke contains an e
>bladderwort contains the forbidden incantation der
>chrysanthemum begins with a lower case letter
>chrysanthemum contains an e
>Zanzibar either begins with a or an upper case letter

  print -u $ZTST_fd 'This test hangs the shell when it fails...'
  name=0
# The number 4375 here is chosen to produce more than 16384 bytes of output
  while (( name < 4375 )); do
    print -n $name
    (( name++ ))
  done < /dev/null | { read name; print done }
0:Bug regression: `while' loop with redirection and pipeline
>done

# This used to be buggy and print X at the end of each iteration.
  for f in 1 2 3 4; do
    print $f || break
  done && print X
0:Handling of ||'s and &&'s with a for loop in between
>1
>2
>3
>4
>X

# Same bug for &&, used to print `no' at the end of each iteration
  for f in 1 2 3 4; do
    false && print strange
  done || print no
0:Handling of &&'s and ||'s with a for loop in between
>no

  $ZTST_testdir/../Src/zsh -f unmatched_quote.txt
1:Parse error with file causes non-zero exit status
?unmatched_quote.txt:2: unmatched '

  $ZTST_testdir/../Src/zsh -f <unmatched_quote.txt
1:Parse error on standard input causes non-zero exit status
?zsh: unmatched '

  $ZTST_testdir/../Src/zsh -f -c "'"
1:Parse error on inline command causes non-zero exit status
?zsh:1: unmatched '

  $ZTST_testdir/../Src/zsh -f NonExistentScript
127q:Non-existent script causes exit status 127
?$ZTST_testdir/../Src/zsh: can't open input file: NonExistentScript

  (setopt nonomatch
  # use this to get stuff at start of line
  contents=$'# comment \'\necho value #with " stuff\n# comment\n#comment
  echo not#comment\n'
  eval 'VAR=$('"$contents"')'
  print -l $VAR)
0:comments within $(...)
>value
>not#comment

  . ./nonexistent
127: Attempt to "." non-existent file.
?(eval):.:1: no such file or directory: ./nonexistent

  echo '[[' >bad_syntax
  . ./bad_syntax
126: Attempt to "." file with bad syntax.
?./bad_syntax:2: parse error near `\n'
# `

  echo 'false' >dot_false
  . ./dot_false
  print $?
  echo 'true' >dot_true
  . ./dot_true
  print $?
0:Last status of successfully executed "." file is retained
>1
>0

  echo 'echo $?' >dot_status
  false
  . ./dot_status
0:"." file sees status from previous command
>1

  mkdir test_path_script
  print "#!/bin/sh\necho Found the script." >test_path_script/myscript
  chmod u+x test_path_script/myscript
  path=($PWD/test_path_script $path)
  export PATH
  $ZTST_testdir/../Src/zsh -f -o pathscript myscript
0:PATHSCRIPT option
>Found the script.

  $ZTST_testdir/../Src/zsh -f myscript
127q:PATHSCRIPT option not used.
?$ZTST_testdir/../Src/zsh: can't open input file: myscript
# '

  $ZTST_testdir/../Src/zsh -fc 'echo $0; echo $1' myargzero myargone
0:$0 is traditionally if bizarrely set to the first argument with -c
>myargzero
>myargone

  (setopt shglob
  eval '
  if ! (echo success1); then echo failure1; fi
  if !(echo success2); then echo failure2; fi
  print -l one two | while(read foo)do(print read it)done
  ')
0:Parentheses in shglob
>success1
>success2
>read it
>read it

  (
  mywrap() { echo BEGIN; true; echo END }
  mytest() { { exit 3 } always { mywrap }; print Exited before this }
  mytest
  print Exited before this, too
  )
3:Exit and always block with functions: simple
>BEGIN
>END

  (
  mytrue() { echo mytrue; return 0 }
  mywrap() { echo BEGIN; mytrue; echo END }
  mytest() { { exit 4 } always { mywrap }; print Exited before this }
  mytest
  print Exited before this, too
  )
4:Exit and always block with functions: nested
>BEGIN
>mytrue
>END

  (emulate sh -c '
   fn() {
    case $1 in
      ( one | two | three )
      print Matched $1
      ;;
      ( fo* | fi* | si* )
      print Pattern matched $1
      ;;
      ( []x | a[b]* )
      print Character class matched $1
      ;;
    esac
  }
  '
  which fn
  fn one
  fn two
  fn three
  fn four
  fn five
  fn six
  fn abecedinarian
  fn xylophone)
0: case word handling in sh emulation (SH_GLOB parentheses)
>fn () {
>	case $1 in
>		(one | two | three) print Matched $1 ;;
>		(fo* | fi* | si*) print Pattern matched $1 ;;
>		([]x | a[b]*) print Character class matched $1 ;;
>	esac
>}
>Matched one
>Matched two
>Matched three
>Pattern matched four
>Pattern matched five
>Pattern matched six
>Character class matched abecedinarian

  case grumph in
    ( no | (grumph) )
    print 1 OK
    ;;
  esac
  case snruf in
    ( fleer | (|snr(|[au]f)) )
    print 2 OK
    ;;
  esac
0: case patterns within words
>1 OK
>2 OK

  case horrible in
    ([a-m])(|[n-z])rr(|ib(um|le|ah)))
    print It worked
    ;;
  esac
  case "a string with separate words" in
    (*with separate*))
    print That worked, too
    ;;
  esac
0:Unbalanced parentheses and spaces with zsh pattern
>It worked
>That worked, too

  case horrible in
    (([a-m])(|[n-z])rr(|ib(um|le|ah)))
    print It worked
    ;;
  esac
  case "a string with separate words" in
    (*with separate*)
    print That worked, too
    ;;
  esac
0:Balanced parentheses and spaces with zsh pattern
>It worked
>That worked, too

  fn() {
    typeset ac_file="the else branch"
    case $ac_file in
      *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
      *.* ) break;;
      *)
      ;;
    esac
    print Stuff here
  }
  which fn
  fn
0:Long case with parsed alternatives turned back into text
>fn () {
>	typeset ac_file="the else branch" 
>	case $ac_file in
>		(*.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj)  ;;
>		(*.*) break ;;
>		(*)  ;;
>	esac
>	print Stuff here
>}
>Stuff here

  (exit 37)
  case $? in
    (37) echo $?
    ;;
  esac
0:case retains exit status for execution of cases
>37

  false
  case stuff in
    (nomatch) foo
    ;;
  esac
  echo $?
0:case sets exit status to zero if no patterns are matched
>0

  case match in
    (match) true; false; (exit 37)
    ;;
  esac
  echo $?
0:case keeps exit status of last command executed in compound-list
>37

  case '' in
    burble) print No.
    ;;
    spurble|) print Yes!
    ;;
    |burble) print Not quite.
    ;;
  esac
  case '' in
    burble) print No.
    ;;
    |burble) print Wow!
    ;;
    spurble|) print Sorry.
    ;;
  esac
  case '' in
    gurgle) print No.
    ;;
    wurgle||jurgle) print Yikes!
    ;;
    durgle|) print Hmm.
    ;;
    |zurgle) print Hah.
    ;;
  esac
  case '' in
    # Useless doubled empty string to check special case.
    ||jurgle) print Ok.
    ;;
  esac
0: case with no opening parentheses and empty string 
>Yes!
>Wow!
>Yikes!
>Ok.

  x=1
  x=2 | echo $x
  echo $x
0:Assignment-only current shell commands in LHS of pipelin
>1
>1