From 78d7bfd94f82bb286399e4c1a0ae863999db2221 Mon Sep 17 00:00:00 2001
From: Bart Schaefer <barts@users.sourceforge.net>
Date: Mon, 8 Oct 2001 10:09:08 +0000
Subject: Equivalence of $(...) and `...` in ${(e)...}.

---
 Test/D04parameter.ztst | 555 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 555 insertions(+)
 create mode 100644 Test/D04parameter.ztst

(limited to 'Test')

diff --git a/Test/D04parameter.ztst b/Test/D04parameter.ztst
new file mode 100644
index 000000000..9506f56e4
--- /dev/null
+++ b/Test/D04parameter.ztst
@@ -0,0 +1,555 @@
+# Test parameter expansion.  Phew.
+
+%prep
+
+  mkdir parameter.tmp
+  cd parameter.tmp
+  touch boringfile evenmoreboringfile
+
+%test
+
+  foo='the first parameter'
+  bar='the second parameter'
+  print -l $foo ${bar}
+0:Basic scalar parameter substitution
+>the first parameter
+>the second parameter
+
+  array1=(the first array)
+  array2=(the second array)
+  print -l $array1 ${array2}
+0:Basic array parameter substitution
+>the
+>first
+>array
+>the
+>second
+>array
+
+  setopt ksharrays
+  print -l $array1 ${array2}
+  unsetopt ksharrays
+0:Basic ksharray substitution
+>the
+>the
+
+  setopt shwordsplit
+  print -l $foo ${bar}
+  unsetopt shwordsplit
+0:Basic shwordsplit option handling
+>the
+>first
+>parameter
+>the
+>second
+>parameter
+
+  print $+foo ${+foo} $+notappearinginthistest ${+notappearinginthistest}
+0:$+...
+>1 1 0 0
+
+  set1=set1v
+  null1=
+  print ${set1:-set1d} ${set1-set2d} ${null1:-null1d} ${null1-null2d} x
+  print ${unset1:-unset1d} ${unset1-unset2d} x
+0:${...:-...} and ${...-...}
+>set1v set1v null1d x
+>unset1d unset2d x
+
+  set2=irrelevant
+  print ${set1:=set1d} ${set2::=set2d}
+  print $set2
+  wasnull1=
+  wasnull2=
+  print ${wasnull1=wasnull1d} ${wasnull2:=wasnull2d}
+  print $wasnull1 $wasnull2
+0:${...:=...}, ${...::=...}, ${...=...}
+>set1v set2d
+>set2d
+>wasnull2d
+>wasnull2d
+
+  (print ${set1:?okhere}; print ${unset1:?exiting1}; print not reached;)
+  (print ${null1?okhere}; print ${null1:?exiting2}; print not reached;)
+1:${...:?...}, ${...?...}
+>set1v
+>
+?ZTST_execchunk:2: unset1: exiting1
+?ZTST_execchunk:2: null1: exiting2
+
+  print ${set1:+word1} ${set1+word2} ${null1:+word3} ${null1+word4}
+  print ${unset1:+word5} ${unset1+word6}
+0:${...:+...}, ${...+...}
+>word1 word2 word4
+>
+
+  str1='This is very boring indeed.'
+  print ${str1#*s}
+  print ${str1##*s}
+  print $str1##s
+0:${...#...}, ${...##...}
+> is very boring indeed.
+> very boring indeed.
+>This is very boring indeed.##s
+
+  str2='If you'\''re reading this you should go and fix some bugs instead.'
+  print ${str2%d*}
+  print ${str2%%d*}
+0:${...%...}, ${...%%...}
+>If you're reading this you should go and fix some bugs instea
+>If you're rea
+
+  str1='does match'
+  str2='does not match'
+  print ${str1:#does * match}
+  print ${str2:#does * match}
+0:${...:#...}
+>does match
+>
+
+  array1=(arthur boldly claws dogs every fight)
+  print ${array1:#[aeiou]*}
+  print ${(M)array1:#[aeiou]*}
+0:${...:#...}, ${(M)...:#...} with array
+>boldly claws dogs fight
+>arthur every
+
+  str1="$array1"
+  print ${str1/[aeiou]*g/a braw bricht moonlicht nicht the nic}
+  print ${(S)str1/[aeiou]*g/relishe}
+0:scalar ${.../.../...}, ${(S).../.../...}
+>a braw bricht moonlicht nicht the nicht
+>relishes every fight
+
+  print ${array1/[aeiou]*/Y}
+  print ${(S)array1/[aeiou]*/Y}
+0:array ${.../.../...}, ${(S).../.../...}
+>Y bY clY dY Y fY
+>Yrthur bYldly clYws dYgs Yvery fYght
+
+  str1='o this is so, so so very dull'
+  print ${str1//o*/Please no}
+  print ${(S)str1//o*/Please no}
+0:scalar ${...//.../...}, ${(S)...//.../...}
+>Please no
+>Please no this is sPlease no, sPlease no sPlease no very dull
+
+  print ${array1//[aeiou]*/Y}
+  print ${(S)array1//[aeiou]*/Y}
+0:array ${...//.../...}, ${(S)...//.../...}
+>Y bY clY dY Y fY
+>YrthYr bYldly clYws dYgs YvYry fYght
+
+  print ${array1:/[aeiou]*/expletive deleted}
+0:array ${...:/...}
+>expletive deleted boldly claws dogs expletive deleted fight
+
+  str1='twocubed'
+  array=(the number of protons in an oxygen nucleus)
+  print $#str1 ${#str1} "$#str1 ${#str1}" $#array ${#array} "$#array ${#array}"
+0:${#...}, $#...
+>8 8 8 8 8 8 8 8
+
+  array=(once bitten twice shy)
+  print IF${array}THEN
+  print IF${^array}THEN
+0:basic ${^...}
+>IFonce bitten twice shyTHEN
+>IFonceTHEN IFbittenTHEN IFtwiceTHEN IFshyTHEN
+
+  # Quote ${array} here because {...,...} doesn't like unquoted spaces.
+  print IF{"${array}",THEN}ELSE
+  print IF{${^array},THEN}ELSE
+0:combined ${^...} and {...,...}
+>IFonce bitten twice shyELSE IFTHENELSE
+>IFonceELSE IFTHENELSE IFbittenELSE IFTHENELSE IFtwiceELSE IFTHENELSE IFshyELSE IFTHENELSE
+
+  str1='one word'
+  print -l $str1 ${=str1} "split ${=str1}wise"
+0:${=...}
+>one word
+>one
+>word
+>split one
+>wordwise
+
+  str1='*'
+  print $str1 ${~str1} $~str1
+  setopt globsubst
+  print $str1
+  unsetopt globsubst
+0:${~...} and globsubst
+>* boringfile evenmoreboringfile boringfile evenmoreboringfile
+>boringfile evenmoreboringfile
+
+  print -l "${$(print one word)}" "${=$(print two words)}"
+0:splitting of $(...) inside ${...}
+>one word
+>two
+>words
+
+  print -l "${(f)$(print first line\\nsecond line\\nthird line)}"
+0:${(f)$(...)}
+>first line
+>second line
+>third line
+
+  print -l ${(A)newarray=splitting by numbers}
+  print -l ${(A)=newarray::=splitting by spaces, actually}
+0:${(A)...=...}, ${(A)...::=...}
+>splitting by numbers
+>splitting
+>by
+>spaces,
+>actually
+
+  newarray=("split me" "split me" "I\'m yours")
+  print -l "${(@)newarray}"
+0:"${(@)...}"
+>split me
+>split me
+>I'm yours
+
+  foo='$(print Howzat usay)'
+  print -l ${(e)foo}
+0:${(e)...}
+>Howzat
+>usay
+
+  foo='`print Howzat usay`'
+  print -l ${(e)foo}
+0:Regress ${(e)...} with backticks (see zsh-workers/15871)
+>Howzat
+>usay
+
+  foo='I'\''m nearly out of my mind with tedium'
+  bar=foo
+  print ${(P)bar}
+0:${(P)...}
+>I'm nearly out of my mind with tedium
+
+  foo=(I could be watching that programme I recorded)
+  print ${(o)foo}
+  print ${(oi)foo}
+  print ${(O)foo}
+  print ${(Oi)foo}
+0:${(o)...}, ${(O)...}
+>I I be could programme recorded that watching
+>be could I I programme recorded that watching
+>watching that recorded programme could be I I
+>watching that recorded programme I I could be
+
+  foo=(yOU KNOW, THE ONE WITH wILLIAM dALRYMPLE)
+  bar=(doing that tour of India.)
+  print ${(L)foo}
+  print ${(U)bar}
+0:${(L)...}, ${(U)...}
+>you know, the one with william dalrymple
+>DOING THAT TOUR OF INDIA.
+
+  foo='instead here I am stuck by the computer'
+  print ${(C)foo}
+0:${(C)...}
+>Instead Here I Am Stuck By The Computer
+
+  foo=$'\x7f\x00'
+  print ${(V)foo}
+0:${(V)...}
+>^?^@
+
+  foo='playing '\''stupid'\'' "games" \w\i\t\h $quoting.'
+  print -r ${(q)foo}
+  print -r ${(qq)foo}
+  print -r ${(qqq)foo}
+  print -r ${(qqqq)foo}
+0:${(q...)...}
+>playing\ \'stupid\'\ \"games\"\ \\w\\i\\t\\h\ \$quoting.
+>'playing '\''stupid'\'' "games" \w\i\t\h $quoting.'
+>"playing 'stupid' \"games\" \\w\\i\\t\\h \$quoting."
+>$'playing \'stupid\' "games" \\w\\i\\t\\h $quoting.'
+
+  foo="'and now' \"even the pubs\" \\a\\r\\e shut."
+  print -r ${(Q)foo}
+0:${(Q)...}
+>and now even the pubs are shut.
+
+  psvar=(dog)
+  setopt promptsubst
+  foo='It shouldn'\''t $(happen) to a %1v.'
+  bar='But `echo what can you do\?`'
+  print -r ${(%)foo}
+  print -r ${(%%)bar}
+0:${(%)...}
+>It shouldn't $(happen) to a dog.
+>But what can you do?
+
+  foo='unmatched "'
+  print ${(QX)foo}
+1:${(QX)...}
+?ZTST_execchunk:2: unmatched "
+
+  array=(characters in an array)
+  print ${(c)#array}
+0:${(c)#...}
+>22
+
+  print ${(w)#array}
+  str='colon::bolon::solon'
+  print ${(ws.:.)#str}
+  print ${(Ws.:.)#str}
+0:${(w)...}, ${(W)...}
+>4
+>3
+>5
+
+  typeset -A assoc
+  assoc=(key1 val1 key2 val2)
+  print ${(o)assoc}
+  print ${(ok)assoc}
+  print ${(ov)assoc}
+  print ${(okv)assoc}
+0:${(k)...}, ${(v)...}
+>val1 val2
+>key1 key2
+>val1 val2
+>key1 key2 val1 val2
+
+  foo=(resulting words uproariously padded)
+  print ${(pl.10..\x22..X.)foo}
+0:${(pl...)...}
+>Xresulting """"Xwords roariously """Xpadded
+
+  foo=(why in goodness name am I doing this)
+  print ${(r.5..!..?.)foo}
+0:${(r...)...}
+>why?! in?!! goodn name? am?!! I?!!! doing this?
+
+  array=(I\'m simply putting a brave face on)
+  print ${(j:--:)array}
+0:${(j)...}
+>I'm--simply--putting--a--brave--face--on
+
+  print ${(F)array}
+0:${(F)...}
+>I'm
+>simply
+>putting
+>a
+>brave
+>face
+>on
+
+  string='zometimez zis getz zplit on a z'
+  print -l ${(s?z?)string}
+0:${(s...)...}
+>ometime
+> 
+>is get
+> 
+>plit on a 
+
+  str=s
+  arr=(a)
+  typeset -A ass
+  ass=(a a)
+  integer i
+  float f
+  print ${(t)str} ${(t)arr} ${(t)ass} ${(t)i} ${(t)f}
+0:${(t)...}
+>scalar array association-local integer-local float-local
+
+  # it's not quite clear that these are actually right unless you know
+  # the algorithm:  search along the string for the point at which the
+  # first (last) match occurs, for ## (%%), then take the shortest possible
+  # version of that for # (%).  it's as good a definition as anything.
+  string='where is the white windmill, whispered walter wisely'
+  print ${(S)string#h*e}
+  print ${(S)string##h*e}
+  print ${(S)string%h*e}
+  print ${(S)string%%h*e}
+0:${(S)...#...} etc.
+>wre is the white windmill, whispered walter wisely
+>wly
+>where is the white windmill, wred walter wisely
+>where is the white windmill, wly
+
+  setopt extendedglob
+  print ${(SI:1:)string##w[^[:space:]]# }
+  print ${(SI:1+1:)string##w[^[:space:]]# }
+  print ${(SI:1+1+1:)string##w[^[:space:]]# }
+  print ${(SI:1+1+1+1:)string##w[^[:space:]]# }
+0:${(I:...:)...}
+>is the white windmill, whispered walter wisely
+>where is the windmill, whispered walter wisely
+>where is the white whispered walter wisely
+>where is the white windmill, walter wisely
+
+  print ${(MSI:1:)string##w[^[:space:]]# }
+0:${(M...)...}
+>where 
+
+  print ${(R)string//w[a-z]# #}
+0:${(R)...}
+>is the , 
+
+  # This (1) doesn't work with // or /
+  #      (2) perhaps ought to be 18, to be consistent with normal zsh
+  #          substring indexing and with backreferences.
+  print ${(BES)string##white}
+0:${(BE...)...}
+>14 19
+
+  print ${(NS)string##white}
+0:${(N)...}
+>5
+
+  string='abcdefghijklmnopqrstuvwxyz'
+  print ${${string%[aeiou]*}/(#m)?(#e)/${(U)MATCH}}
+0:Rule 1:  Nested substitutions
+>abcdefghijklmnopqrsT
+
+  array=(et Swann avec cette muflerie intermittente)
+  string="qui reparaissait chez lui"
+  print ${array[4,5]}
+  print ${array[4,5][1]}
+  print ${array[4,5][1][2,3]}
+  print ${string[4,5]}
+  print ${string[4,5][1]}
+0:Rule 2: Parameter subscripting
+>cette muflerie
+>cette
+>et
+> r
+> 
+
+  foo=stringalongamax
+  print ${${(P)foo[1,6]}[1,3]}
+0:Rule 3: Parameter Name Replacement
+>qui
+
+  print "${array[5,6]}"
+  print "${(j.:.)array[1,2]}"
+0:Rule 4: Double-Quoted Joining
+>muflerie intermittente
+>et:Swann
+
+  print "${${array}[5,7]}"
+  print "${${(@)array}[1,2]}"
+0:Rule 5: Nested Subscripting
+>wan
+>et Swann
+
+  print "${${(@)array}[1,2]#?}"
+  print "${(@)${(@)array}[1,2]#?}"
+0:Rule 6: Modifiers
+>t Swann
+>t wann
+
+  array=(she sells z shells by the z shore)
+  (IFS='+'; print ${(s.s.)array})
+0:Rule 7: Forced Joining, and 8: Forced splitting
+>he+ ell +z+ hell +by+the+z+ hore
+
+  setopt shwordsplit
+  string='another poxy boring string'
+  print -l ${${string}/o/ }
+  unsetopt shwordsplit
+0:Rule 9: Shell Word Splitting
+>an
+>ther
+>p
+>xy
+>b
+>ring
+>string
+
+  setopt nonomatch
+  foo='b* e*'
+  print ${(e)~foo}
+  print ${(e)~=foo}
+0:Rule 10: Re-Evaluation
+>b* e*
+>boringfile evenmoreboringfile
+
+  # ${bar} -> $bar  here would yield "bad substitution".
+  bar=confinement
+  print ${(el.20..X.)${bar}}
+0:Rule 11: Padding
+>XXXXXXXXXconfinement
+
+  foo=(bar baz)
+  bar=(ax1 bx1)
+  print "${(@)${foo}[1]}"
+  print "${${(@)foo}[1]}"
+  print -l ${(s/x/)bar}
+  print -l ${(j/x/s/x/)bar}
+  print -l ${(s/x/)bar%%1*}
+0:Examples in manual on parameter expansion
+>b
+>bar
+>a
+>1 b
+>1
+>a
+>1
+>b
+>1
+>a
+> b
+
+  set If "this test fails" "we have broken" the shell again
+  print -l ${1+"$@"}
+0:Regression test of ${1+"$@"} bug
+>If
+>this test fails
+>we have broken
+>the
+>shell
+>again
+
+  set If "this test fails" "we have broken" the shell again
+  print -l "${(A)foo::=$@}"
+  print -l $foo
+0:Regression test of "${(A)foo=$@}" bug
+>If this test fails we have broken the shell again
+>If
+>this test fails
+>we have broken
+>the
+>shell
+>again
+
+  set If "this test fails" maybe "we have finally fixed" the shell
+  print -l ${=1+"$@"}
+0:Regression test of unfixed ${=1+"$@"} bug
+>If
+>this
+>test
+>fails
+>maybe
+>we
+>have
+>finally
+>fixed
+>the
+>shell
+
+  unset SHLVL
+  (( SHLVL++ ))
+  print $SHLVL
+0:Unsetting and recreation of numerical special parameters
+>1
+
+  unset manpath
+  print $+MANPATH
+  manpath=(/here /there)
+  print $MANPATH
+  unset MANPATH
+  print $+manpath
+  MANPATH=/elsewhere:/somewhere
+  print $manpath
+0:Unsetting and recreation of tied special parameters
+>0
+>/here:/there
+>0
+>/elsewhere /somewhere
-- 
cgit 1.4.1