moved to ./Test/D04parameter.ztst

1 files changed, 0 insertions, 528 deletions

diff --git a/Test/13parameter.ztst b/Test/13parameter.ztst
deleted file mode 100644
index 7304f31d7..000000000
--- a/Test/13parameter.ztst
+++ /dev/null
@@ -1,528 +0,0 @@
-# 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)'
-  print ${(e)foo}
-0:${(e)...}
->Howzat
-
-  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