Zsh Mailing List Archive
Messages sorted by: Reverse Date, Date, Thread, Author

Re: 4.0.1-pre-5 (solaris issues)



> In Solaris 8.  This is from part of 'make test' with a strait './configure ; 
> make':
> 
> Test ./A04redirect.ztst failed: output differs from expected as shown above 
> for:
> 
> ./V01zmodload.ztst: starting.
> Segmentation Fault

I don't have these problems under Solaris 8 if I compile with gcc 2.95.3
or Forte C 6.1u1.  However, if I use Forte with -xtarget=ultra -xarch=v9
(i.e., 64-bit), failures occur.
cd Test ; make check
make[1]: Entering directory `/tmp/obj-sun/Test'
if test -n "/opt/SUNWspro/bin/cc -xtarget=ultra -xarch=v9"; then \
  cd .. && \
  make MODDIR=`pwd`/Test/Modules install.modules > /dev/null; \
fi
for f in ../../zsh-4.0.1-pre-5/Test/*.ztst; do \
  ../Src/zsh +Z -f ../../zsh-4.0.1-pre-5/Test/ztst.zsh $f; \
done
../../zsh-4.0.1-pre-5/Test/A01grammar.ztst: starting.
This test hangs the shell when it fails...
../../zsh-4.0.1-pre-5/Test/A01grammar.ztst: all tests successful.
../../zsh-4.0.1-pre-5/Test/A02alias.ztst: starting.
../../zsh-4.0.1-pre-5/Test/A02alias.ztst: all tests successful.
../../zsh-4.0.1-pre-5/Test/A03quoting.ztst: starting.
../../zsh-4.0.1-pre-5/Test/A03quoting.ztst: all tests successful.
../../zsh-4.0.1-pre-5/Test/A04redirect.ztst: starting.
Test ../../zsh-4.0.1-pre-5/Test/A04redirect.ztst failed: bad status 1, expected 0 from:
  foo=bar
  cat <<'  HERE'
  $foo
  HERE
  eval "$(print 'cat <<HERE\n$foo\nHERE')"
Error output:
ZTST_execchunk:2: bad address
ZTST_execchunk:2: bad address
Was testing: Here-documents
../../zsh-4.0.1-pre-5/Test/A04redirect.ztst: test failed.
../../zsh-4.0.1-pre-5/Test/A05execution.ztst: starting.
../../zsh-4.0.1-pre-5/Test/A05execution.ztst: all tests successful.
../../zsh-4.0.1-pre-5/Test/B01cd.ztst: starting.
../../zsh-4.0.1-pre-5/Test/B01cd.ztst: all tests successful.
../../zsh-4.0.1-pre-5/Test/C01arith.ztst: starting.
../../zsh-4.0.1-pre-5/Test/C01arith.ztst: all tests successful.
../../zsh-4.0.1-pre-5/Test/C02cond.ztst: starting.
../../zsh-4.0.1-pre-5/Test/C02cond.ztst: all tests successful.
../../zsh-4.0.1-pre-5/Test/C03traps.ztst: starting.
This test takes at least three seconds...
This test, too, takes at least three seconds...
../../zsh-4.0.1-pre-5/Test/C03traps.ztst: all tests successful.
../../zsh-4.0.1-pre-5/Test/C04funcdef.ztst: starting.
../../zsh-4.0.1-pre-5/Test/C04funcdef.ztst: all tests successful.
../../zsh-4.0.1-pre-5/Test/D01prompt.ztst: starting.
../../zsh-4.0.1-pre-5/Test/D02glob.ztst: starting.
*** /tmp/zsh.ztst.out.6093	Tue May 22 11:53:42 2001
--- /tmp/zsh.ztst.tout.6093	Tue May 22 11:53:42 2001
***************
*** 1,154 ****
- 0:  [[ foo~ = foo~ ]]
- 0:  [[ foo~ = (foo~) ]]
- 0:  [[ foo~ = (foo~|) ]]
- 0:  [[ foo.c = *.c~boo* ]]
- 1:  [[ foo.c = *.c~boo*~foo* ]]
- 0:  [[ fofo = (fo#)# ]]
- 0:  [[ ffo = (fo#)# ]]
- 0:  [[ foooofo = (fo#)# ]]
- 0:  [[ foooofof = (fo#)# ]]
- 0:  [[ fooofoofofooo = (fo#)# ]]
- 1:  [[ foooofof = (fo##)# ]]
- 1:  [[ xfoooofof = (fo#)# ]]
- 1:  [[ foooofofx = (fo#)# ]]
- 0:  [[ ofxoofxo = ((ofo#x)#o)# ]]
- 1:  [[ ofooofoofofooo = (fo#)# ]]
- 0:  [[ foooxfooxfoxfooox = (fo#x)# ]]
- 1:  [[ foooxfooxofoxfooox = (fo#x)# ]]
- 0:  [[ foooxfooxfxfooox = (fo#x)# ]]
- 0:  [[ ofxoofxo = ((ofo#x)#o)# ]]
- 0:  [[ ofoooxoofxo = ((ofo#x)#o)# ]]
- 0:  [[ ofoooxoofxoofoooxoofxo = ((ofo#x)#o)# ]]
- 0:  [[ ofoooxoofxoofoooxoofxoo = ((ofo#x)#o)# ]]
- 1:  [[ ofoooxoofxoofoooxoofxofo = ((ofo#x)#o)# ]]
- 0:  [[ ofoooxoofxoofoooxoofxooofxofxo = ((ofo#x)#o)# ]]
- 0:  [[ aac = ((a))#a(c) ]]
- 0:  [[ ac = ((a))#a(c) ]]
- 1:  [[ c = ((a))#a(c) ]]
- 0:  [[ aaac = ((a))#a(c) ]]
- 1:  [[ baaac = ((a))#a(c) ]]
- 0:  [[ abcd = ?(a|b)c#d ]]
- 0:  [[ abcd = (ab|ab#)c#d ]]
- 0:  [[ acd = (ab|ab#)c#d ]]
- 0:  [[ abbcd = (ab|ab#)c#d ]]
- 0:  [[ effgz = (bc##d|ef#g?|(h|)i(j|k)) ]]
- 0:  [[ efgz = (bc##d|ef#g?|(h|)i(j|k)) ]]
- 0:  [[ egz = (bc##d|ef#g?|(h|)i(j|k)) ]]
- 0:  [[ egzefffgzbcdij = (bc##d|ef#g?|(h|)i(j|k))# ]]
- 1:  [[ egz = (bc##d|ef##g?|(h|)i(j|k)) ]]
- 0:  [[ ofoofo = (ofo##)# ]]
- 0:  [[ oxfoxoxfox = (oxf(ox)##)# ]]
- 1:  [[ oxfoxfox = (oxf(ox)##)# ]]
- 0:  [[ ofoofo = (ofo##|f)# ]]
- 0:  [[ foofoofo = (foo|f|fo)(f|ofo##)# ]]
- 0:  [[ oofooofo = (of|oofo##)# ]]
- 0:  [[ fffooofoooooffoofffooofff = (f#o#)# ]]
- 1:  [[ fffooofoooooffoofffooofffx = (f#o#)# ]]
- 0:  [[ fofoofoofofoo = (fo|foo)# ]]
- 0:  [[ foo = ((^x)) ]]
- 0:  [[ foo = ((^x)*) ]]
- 1:  [[ foo = ((^foo)) ]]
- 0:  [[ foo = ((^foo)*) ]]
- 0:  [[ foobar = ((^foo)) ]]
- 0:  [[ foobar = ((^foo)*) ]]
- 1:  [[ foot = z*~*x ]]
- 0:  [[ zoot = z*~*x ]]
- 1:  [[ foox = z*~*x ]]
- 1:  [[ zoox = z*~*x ]]
- 0:  [[ moo.cow = (*~*.*).(*~*.*) ]]
- 1:  [[ mad.moo.cow = (*~*.*).(*~*.*) ]]
- 0:  [[ moo.cow = (^*.*).(^*.*) ]]
- 1:  [[ sane.moo.cow = (^*.*).(^*.*) ]]
- 1:  [[ mucca.pazza = mu(^c#)?.pa(^z#)? ]]
- 1:  [[ _foo~ = _(|*[^~]) ]]
- 0:  [[ fff = ((^f)) ]]
- 0:  [[ fff = ((^f)#) ]]
- 0:  [[ fff = ((^f)##) ]]
- 0:  [[ ooo = ((^f)) ]]
- 0:  [[ ooo = ((^f)#) ]]
- 0:  [[ ooo = ((^f)##) ]]
- 0:  [[ foo = ((^f)) ]]
- 0:  [[ foo = ((^f)#) ]]
- 0:  [[ foo = ((^f)##) ]]
- 1:  [[ f = ((^f)) ]]
- 1:  [[ f = ((^f)#) ]]
- 1:  [[ f = ((^f)##) ]]
- 0:  [[ foot = (^z*|*x) ]]
- 1:  [[ zoot = (^z*|*x) ]]
- 0:  [[ foox = (^z*|*x) ]]
- 0:  [[ zoox = (^z*|*x) ]]
- 0:  [[ foo = (^foo)# ]]
- 1:  [[ foob = (^foo)b* ]]
- 0:  [[ foobb = (^foo)b* ]]
- 1:  [[ foob = (*~foo)b* ]]
- 0:  [[ foobb = (*~foo)b* ]]
- 1:  [[ zsh = ^z* ]]
- 0:  [[ a%1X = [[:alpha:][:punct:]]#[[:digit:]][^[:lower:]] ]]
- 1:  [[ a%1 = [[:alpha:][:punct:]]#[[:digit:]][^[:lower:]] ]]
- 0:  [[ [: = [[:]# ]]
- 0:  [[ :] = []:]# ]]
- 0:  [[ :] = [:]]# ]]
- 0:  [[ [ = [[] ]]
- 0:  [[ ] = []] ]]
- 0:  [[ [] = [^]]] ]]
- 0:  [[ fooxx = (#i)FOOXX ]]
- 1:  [[ fooxx = (#l)FOOXX ]]
- 0:  [[ FOOXX = (#l)fooxx ]]
- 1:  [[ fooxx = (#i)FOO(#I)X(#i)X ]]
- 0:  [[ fooXx = (#i)FOO(#I)X(#i)X ]]
- 0:  [[ fooxx = ((#i)FOOX)x ]]
- 1:  [[ fooxx = ((#i)FOOX)X ]]
- 1:  [[ BAR = (bar|(#i)foo) ]]
- 0:  [[ FOO = (bar|(#i)foo) ]]
- 0:  [[ Modules = (#i)*m* ]]
- 0:  [[ fooGRUD = (#i)(bar|(#I)foo|(#i)rod)grud ]]
- 1:  [[ FOOGRUD = (#i)(bar|(#I)foo|(#i)rod)grud ]]
- 0:  [[ readme = (#i)readme~README|readme ]]
- 0:  [[ readme = (#i)readme~README|readme~README ]]
- 0:  [[ 633 = <1-1000>33 ]]
- 0:  [[ 633 = <-1000>33 ]]
- 0:  [[ 633 = <1->33 ]]
- 0:  [[ 633 = <->33 ]]
- 0:  [[ READ.ME = (#ia1)readme ]]
- 1:  [[ READ..ME = (#ia1)readme ]]
- 0:  [[ README = (#ia1)readm ]]
- 0:  [[ READM = (#ia1)readme ]]
- 0:  [[ README = (#ia1)eadme ]]
- 0:  [[ EADME = (#ia1)readme ]]
- 0:  [[ READEM = (#ia1)readme ]]
- 1:  [[ ADME = (#ia1)readme ]]
- 1:  [[ README = (#ia1)read ]]
- 0:  [[ bob = (#a1)[b][b] ]]
- 1:  [[ bob = (#a1)[b][b]a ]]
- 0:  [[ bob = (#a1)[b]o[b]a ]]
- 1:  [[ bob = (#a1)[c]o[b] ]]
- 0:  [[ abcd = (#a2)XbcX ]]
- 0:  [[ abcd = (#a2)ad ]]
- 0:  [[ ad = (#a2)abcd ]]
- 0:  [[ abcd = (#a2)bd ]]
- 0:  [[ bd = (#a2)abcd ]]
- 0:  [[ badc = (#a2)abcd ]]
- 0:  [[ adbc = (#a2)abcd ]]
- 1:  [[ dcba = (#a2)abcd ]]
- 0:  [[ dcba = (#a3)abcd ]]
- 0:  [[ aabaXaaabY = (#a1)(a#b)#Y ]]
- 0:  [[ aabaXaaabY = (#a1)(a#b)(a#b)Y ]]
- 0:  [[ aaXaaaaabY = (#a1)(a#b)(a#b)Y ]]
- 0:  [[ aaaXaaabY = (#a1)(a##b)##Y ]]
- 0:  [[ aaaXbaabY = (#a1)(a##b)##Y ]]
- 1:  [[ read.me = (#ia1)README~READ.ME ]]
- 0:  [[ read.me = (#ia1)README~READ_ME ]]
- 1:  [[ read.me = (#ia1)README~(#a1)READ_ME ]]
- 0:  [[ test = *((#s)|/)test((#e)|/)* ]]
- 0:  [[ test/path = *((#s)|/)test((#e)|/)* ]]
- 0:  [[ path/test = *((#s)|/)test((#e)|/)* ]]
- 0:  [[ path/test/ohyes = *((#s)|/)test((#e)|/)* ]]
- 1:  [[ atest = *((#s)|/)test((#e)|/)* ]]
- 1:  [[ testy = *((#s)|/)test((#e)|/)* ]]
- 1:  [[ testy/path = *((#s)|/)test((#e)|/)* ]]
- 1:  [[ path/atest = *((#s)|/)test((#e)|/)* ]]
- 1:  [[ atest/path = *((#s)|/)test((#e)|/)* ]]
- 1:  [[ path/testy = *((#s)|/)test((#e)|/)* ]]
- 1:  [[ path/testy/ohyes = *((#s)|/)test((#e)|/)* ]]
- 1:  [[ path/atest/ohyes = *((#s)|/)test((#e)|/)* ]]
  0 tests failed.
--- 1 ----
Test ../../zsh-4.0.1-pre-5/Test/D02glob.ztst failed: output differs from expected as shown above for:
  globtest globtests
Error output:
/tmp/obj-sun/Test/../../zsh-4.0.1-pre-5/Test/../Misc/globtests:7: bad address
Was testing: zsh globbing
../../zsh-4.0.1-pre-5/Test/D02glob.ztst: test failed.
../../zsh-4.0.1-pre-5/Test/D03procsubst.ztst: starting.
../../zsh-4.0.1-pre-5/Test/D04parameter.ztst: starting.
../../zsh-4.0.1-pre-5/Test/D04parameter.ztst: all tests successful.
../../zsh-4.0.1-pre-5/Test/D05array.ztst: starting.
../../zsh-4.0.1-pre-5/Test/D05array.ztst: all tests successful.
../../zsh-4.0.1-pre-5/Test/D06subscript.ztst: starting.
../../zsh-4.0.1-pre-5/Test/D06subscript.ztst: all tests successful.
../../zsh-4.0.1-pre-5/Test/E01options.ztst: starting.
../../zsh-4.0.1-pre-5/Test/E01options.ztst: all tests successful.
../../zsh-4.0.1-pre-5/Test/E02xtrace.ztst: starting.
*** /tmp/zsh.ztst.out.6775	Tue May 22 11:53:54 2001
--- /tmp/zsh.ztst.tout.6775	Tue May 22 11:53:54 2001
***************
*** 1,26 ****
  Tracing: builtin
  Tracing: builtin 2>file
- Tracing: external
- Tracing: external 2>file
  Tracing: ( builtin )
  Tracing: ( builtin ) 2>file
- Tracing: ( external )
- Tracing: ( external ) 2>file
  Tracing: { builtin }
  Tracing: { builtin } 2>file
- Tracing: { external }
- Tracing: { external } 2>file
  Tracing: do builtin done
  Tracing: do builtin done 2>file
- Tracing: do external done
- Tracing: do external done 2>file
  Tracing: function
  Tracing: function 2>file
  Tracing: source
  Tracing: source 2>file
  +ZTST_execchunk:2> print Tracing: ( builtin ) 2>file
! +ZTST_execchunk:2> cat
  +ZTST_execchunk:2> print Tracing: { builtin } 2>file
! +ZTST_execchunk:2> cat
  +ZTST_execchunk:2> print Tracing: do builtin done 2>file
! +ZTST_execchunk:2> cat
--- 1,18 ----
  Tracing: builtin
  Tracing: builtin 2>file
  Tracing: ( builtin )
  Tracing: ( builtin ) 2>file
  Tracing: { builtin }
  Tracing: { builtin } 2>file
  Tracing: do builtin done
  Tracing: do builtin done 2>file
  Tracing: function
  Tracing: function 2>file
  Tracing: source
  Tracing: source 2>file
  +ZTST_execchunk:2> print Tracing: ( builtin ) 2>file
! ZTST_execchunk:2: bad address
  +ZTST_execchunk:2> print Tracing: { builtin } 2>file
! ZTST_execchunk:2: bad address
  +ZTST_execchunk:2> print Tracing: do builtin done 2>file
! ZTST_execchunk:2: bad address
Test ../../zsh-4.0.1-pre-5/Test/E02xtrace.ztst failed: output differs from expected as shown above for:
  set -x
  print 'Tracing: builtin'
  print 'Tracing: builtin 2>file' 2>xtrace.err
  cat <<<'Tracing: external'
  cat <<<'Tracing: external 2>file' 2>>xtrace.err
  ( print 'Tracing: ( builtin )' )
  ( print 'Tracing: ( builtin ) 2>file' ) 2>>xtrace.err
  ( cat <<<'Tracing: ( external )' )
  ( cat <<<'Tracing: ( external ) 2>file' ) 2>>xtrace.err
  { print 'Tracing: { builtin }' }
  { print 'Tracing: { builtin } 2>file' } 2>>xtrace.err
  { cat <<<'Tracing: { external }' }
  { cat <<<'Tracing: { external } 2>file' } 2>>xtrace.err
  repeat 1 do print 'Tracing: do builtin done'; done
  repeat 1 do print 'Tracing: do builtin done 2>file'; done 2>>xtrace.err
  repeat 1 do cat <<<'Tracing: do external done'; done
  repeat 1 do cat <<<'Tracing: do external done 2>file'; done 2>>xtrace.err
  xtf 'Tracing: function'
  xtf 'Tracing: function 2>file' 2>>xtrace.err
  . ./xt.in 'Tracing: source'
  . ./xt.in 'Tracing: source 2>file' 2>>xtrace.err
  set +x
  cat xtrace.err
Error output:
+ZTST_execchunk:2> print Tracing: builtin
+ZTST_execchunk:2> print Tracing: builtin 2>file
ZTST_execchunk:2: bad address
ZTST_execchunk:2: bad address
+ZTST_execchunk:2> print Tracing: ( builtin )
ZTST_execchunk:2: bad address
+ZTST_execchunk:2> print Tracing: { builtin }
ZTST_execchunk:2: bad address
+ZTST_execchunk:2> print Tracing: do builtin done
ZTST_execchunk:2: bad address
+ZTST_execchunk:2> xtf Tracing: function
+xtf:0> local regression_test_dummy_variable
+xtf:0> print Tracing: function
+ZTST_execchunk:2> xtf Tracing: function 2>file
+xtf:0> local regression_test_dummy_variable
+xtf:0> print Tracing: function 2>file
+ZTST_execchunk:2> . ./xt.in Tracing: source
+./xt.in:1> print Tracing: source
+ZTST_execchunk:2> . ./xt.in Tracing: source 2>file
+./xt.in:1> print Tracing: source 2>file
+ZTST_execchunk:2> set +x
Was testing: xtrace with and without redirection
../../zsh-4.0.1-pre-5/Test/E02xtrace.ztst: test failed.
../../zsh-4.0.1-pre-5/Test/V01zmodload.ztst: starting.
../../zsh-4.0.1-pre-5/Test/V01zmodload.ztst: all tests successful.
../../zsh-4.0.1-pre-5/Test/V02zregexparse.ztst: starting.
../../zsh-4.0.1-pre-5/Test/V02zregexparse.ztst: all tests successful.
../../zsh-4.0.1-pre-5/Test/Y01completion.ztst: starting.
../../zsh-4.0.1-pre-5/Test/Y01completion.ztst: all tests successful.
../../zsh-4.0.1-pre-5/Test/Y02compmatch.ztst: starting.
../../zsh-4.0.1-pre-5/Test/Y02compmatch.ztst: all tests successful.
../../zsh-4.0.1-pre-5/Test/Y03arguments.ztst: starting.
../../zsh-4.0.1-pre-5/Test/Y03arguments.ztst: all tests successful.
rm -rf Modules .zcompdump
make[1]: Leaving directory `/tmp/obj-sun/Test'
cd Test ; make check
make[1]: Entering directory `/tmp/obj-sun/Test'
if test -n "/opt/SUNWspro/bin/cc -xtarget=ultra -xarch=v9"; then \
  cd .. && \
  make MODDIR=`pwd`/Test/Modules install.modules > /dev/null; \
fi
for f in ../../zsh-4.0.1-pre-5/Test/*.ztst; do \
  ../Src/zsh +Z -f ../../zsh-4.0.1-pre-5/Test/ztst.zsh $f; \
done
../../zsh-4.0.1-pre-5/Test/A01grammar.ztst: starting.
ZTST_getsect: read section name: prep
ZTST_getchunk: read code chunk:
  mkdir basic.tmp && cd basic.tmp
  touch foo bar
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:

ZTST_getsect: read section name: test
ZTST_test: looking for new test
ZTST_test: examining line:
  echo foo | cat | sed 's/foo/bar/'
ZTST_getchunk: read code chunk:
  echo foo | cat | sed 's/foo/bar/'
ZTST_test: examining line:
>bar
ZTST_getredir: read redir for '>':
bar
ZTST_test: examining line:

Running test: Basic pipeline handling
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
bar
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  false | true
ZTST_getchunk: read code chunk:
  false | true
ZTST_test: examining line:

Running test: Exit status of pipeline with builtins (true)
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  true | false
ZTST_getchunk: read code chunk:
  true | false
ZTST_test: examining line:

Running test: Exit status of pipeline with builtins (false)
ZTST_test: expecting status: 1
ZTST_execchunk: status 1
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  fn() { local foo; read foo; print $foo; }
ZTST_getchunk: read code chunk:
  fn() { local foo; read foo; print $foo; }
  coproc fn
  print -p coproc test output
  read -p bar
  print $bar
ZTST_test: examining line:
>coproc test output
ZTST_getredir: read redir for '>':
coproc test output
ZTST_test: examining line:

Running test: Basic coprocess handling
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
coproc test output
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  true | false && print true || print false
ZTST_getchunk: read code chunk:
  true | false && print true || print false
ZTST_test: examining line:
>false
ZTST_getredir: read redir for '>':
false
ZTST_test: examining line:

Running test: Basic sublist (i)
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
false
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  false | true && print true || print false
ZTST_getchunk: read code chunk:
  false | true && print true || print false
ZTST_test: examining line:
>true
ZTST_getredir: read redir for '>':
true
ZTST_test: examining line:

Running test: Basic sublist (ii)
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
true
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  (cd /NonExistentDirectory >&/dev/null) || print false
ZTST_getchunk: read code chunk:
  (cd /NonExistentDirectory >&/dev/null) || print false
ZTST_test: examining line:
>false
ZTST_getredir: read redir for '>':
false
ZTST_test: examining line:

Running test: Basic subshell list with error
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
false
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  { cd /NonExistentDirectory >&/dev/null } || print false
ZTST_getchunk: read code chunk:
  { cd /NonExistentDirectory >&/dev/null } || print false
ZTST_test: examining line:
>false
ZTST_getredir: read redir for '>':
false
ZTST_test: examining line:

Running test: Basic current shell list with error
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
false
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  - $ZTST_testdir/../Src/zsh -fc "[[ \$0 = \"-$ZTST_testdir/../Src/zsh\" ]]"
ZTST_getchunk: read code chunk:
  - $ZTST_testdir/../Src/zsh -fc "[[ \$0 = \"-$ZTST_testdir/../Src/zsh\" ]]"
ZTST_test: examining line:

Running test: `-' precommand modifier
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  echo f*
ZTST_getchunk: read code chunk:
  echo f*
  noglob echo f*
ZTST_test: examining line:
>foo
ZTST_getredir: read redir for '>':
foo
f*
ZTST_test: examining line:

Running test: `noglob' precommand modifier
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
foo
f*
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  (exec /bin/sh; echo bar)
ZTST_getchunk: read code chunk:
  (exec /bin/sh; echo bar)
ZTST_test: examining line:

Running test: `exec' precommand modifier
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  cat() { echo Function cat executed; }
ZTST_getchunk: read code chunk:
  cat() { echo Function cat executed; }
  command cat && unfunction cat
ZTST_test: examining line:
<External command cat executed
ZTST_getredir: read redir for '<':
External command cat executed
ZTST_test: examining line:
>External command cat executed
ZTST_getredir: read redir for '>':
External command cat executed
ZTST_test: examining line:

Running test: `command' precommand modifier
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
External command cat executed
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  cd() { echo Not cd at all; }
ZTST_getchunk: read code chunk:
  cd() { echo Not cd at all; }
  builtin cd . && unfunction cd
ZTST_test: examining line:

Running test: `builtin' precommand modifier
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:

ZTST_test: examining line:
  if true; then
ZTST_getchunk: read code chunk:
  if true; then
    print true-1
  elif true; then
    print true-2
  else
    print false
  fi
ZTST_test: examining line:
>true-1
ZTST_getredir: read redir for '>':
true-1
ZTST_test: examining line:

Running test: `if ...' (i)
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
true-1
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  if false; then
ZTST_getchunk: read code chunk:
  if false; then
    print true-1
  elif true; then
    print true-2
  else
    print false
  fi
ZTST_test: examining line:
>true-2
ZTST_getredir: read redir for '>':
true-2
ZTST_test: examining line:

Running test: `if ...' (ii)
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
true-2
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  if false; then
ZTST_getchunk: read code chunk:
  if false; then
    print true-1
  elif false; then
    print true-2
  else
    print false
  fi
ZTST_test: examining line:
>false
ZTST_getredir: read redir for '>':
false
ZTST_test: examining line:

Running test: `if ...' (iii)
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
false
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  if true;
ZTST_getchunk: read code chunk:
  if true;
    :
  fi
ZTST_test: examining line:
?ZTST_execchunk:-1: parse error near `fi'
ZTST_getredir: read redir for '?':
ZTST_execchunk:-1: parse error near `fi'
ZTST_test: examining line:

Running test: `if ...' (iv)
ZTST_test: expecting status: 1
ZTST_execchunk: status 1
ZTST_test: test produced standard output:

ZTST_test: and standard error:
ZTST_execchunk:-1: parse error near `fi'
Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  for name in word to term; do
ZTST_getchunk: read code chunk:
  for name in word to term; do
    print $name
  done
ZTST_test: examining line:
>word
ZTST_getredir: read redir for '>':
word
to
term
ZTST_test: examining line:

Running test: `for' loop
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
word
to
term
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  for (( name = 0; name < 3; name++ )); do
ZTST_getchunk: read code chunk:
  for (( name = 0; name < 3; name++ )); do
    print $name
  done
ZTST_test: examining line:
>0
ZTST_getredir: read redir for '>':
0
1
2
ZTST_test: examining line:

Running test: arithmetic `for' loop
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
0
1
2
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  name=0
ZTST_getchunk: read code chunk:
  name=0
  while (( name < 3 )); do
    print $name
    (( name++ ))
  done
ZTST_test: examining line:
>0
ZTST_getredir: read redir for '>':
0
1
2
ZTST_test: examining line:

Running test: `while' loop
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
0
1
2
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  name=0
ZTST_getchunk: read code chunk:
  name=0
  until (( name == 3 )); do
    print $name
    (( name++ ))
  done
ZTST_test: examining line:
>0
ZTST_getredir: read redir for '>':
0
1
2
ZTST_test: examining line:

Running test: `until' loop
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
0
1
2
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  repeat 3 do
ZTST_getchunk: read code chunk:
  repeat 3 do
    echo over and over
  done
ZTST_test: examining line:
>over and over
ZTST_getredir: read redir for '>':
over and over
over and over
over and over
ZTST_test: examining line:

Running test: `repeat' loop
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
over and over
over and over
over and over
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  word=Trinity
ZTST_getchunk: read code chunk:
  word=Trinity
  case $word in
    Michaelmas) print 0
                ;;
    Hilary) print 1
            ;;
    Trinity) print 2
             ;;
    *) print 3
       ;;
  esac
ZTST_test: examining line:
>2
ZTST_getredir: read redir for '>':
2
ZTST_test: examining line:

Running test: `case' loop, old syntax
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
2
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  word=Trinity
ZTST_getchunk: read code chunk:
  word=Trinity
  case $word in
    (Michaelmas) print 0
                ;;
    (Hilary) print 1
            ;;
    (Trinity) print 2
             ;;
    (*) print 3
       ;;
  esac
ZTST_test: examining line:
>2
ZTST_getredir: read redir for '>':
2
ZTST_test: examining line:

Running test: `case' loop, new syntax
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
2
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  word=Hilary
ZTST_getchunk: read code chunk:
  word=Hilary
  case $word in
    (Michaelmas) print 0
                ;;
    (Hilary) print 1
            ;&
    (Trinity) print 2
             ;&
    (*) print 3
       ;;
  esac
ZTST_test: examining line:
>1
ZTST_getredir: read redir for '>':
1
2
3
ZTST_test: examining line:

Running test: `case' loop, new syntax, cascaded
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
1
2
3
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:

ZTST_test: examining line:
  function name1 name2 () { print This is $0; }
ZTST_getchunk: read code chunk:
  function name1 name2 () { print This is $0; }
  name2
  name1 name2() { print This is still $0; }
  name2
ZTST_test: examining line:
>This is name2
ZTST_getredir: read redir for '>':
This is name2
This is still name2
ZTST_test: examining line:

Running test: `function' keyword
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
This is name2
This is still name2
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  (time cat) >&/dev/null
ZTST_getchunk: read code chunk:
  (time cat) >&/dev/null
ZTST_test: examining line:

Running test: `time' keyword (status only)
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  if [[ -f foo && -d . && -n $ZTST_testdir ]]; then
ZTST_getchunk: read code chunk:
  if [[ -f foo && -d . && -n $ZTST_testdir ]]; then
    true
  else
    false
  fi
ZTST_test: examining line:

Running test: basic [[ ... ]] test
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:

ZTST_test: examining line:
  if (true) { print true-1 } elif (true) { print true-2 } else { print false }
ZTST_getchunk: read code chunk:
  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 }
ZTST_test: examining line:
>true-1
ZTST_getredir: read redir for '>':
true-1
true-2
false
ZTST_test: examining line:

Running test: Alternate `if' with braces
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
true-1
true-2
false
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  if true; print true
ZTST_getchunk: read code chunk:
  if true; print true
ZTST_test: examining line:
>true
ZTST_getredir: read redir for '>':
true
ZTST_test: examining line:

Running test: Short form of `if'
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
true
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  for name ( word1 word2 word3 ) print $name
ZTST_getchunk: read code chunk:
  for name ( word1 word2 word3 ) print $name
ZTST_test: examining line:
>word1
ZTST_getredir: read redir for '>':
word1
word2
word3
ZTST_test: examining line:

Running test: Form of `for' with parentheses.
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
word1
word2
word3
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  for name in alpha beta gamma; print $name
ZTST_getchunk: read code chunk:
  for name in alpha beta gamma; print $name
ZTST_test: examining line:
>alpha
ZTST_getredir: read redir for '>':
alpha
beta
gamma
ZTST_test: examining line:

Running test: Short form of `for'
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
alpha
beta
gamma
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  for (( val = 2; val < 10; val *= val )) print $val
ZTST_getchunk: read code chunk:
  for (( val = 2; val < 10; val *= val )) print $val
ZTST_test: examining line:
>2
ZTST_getredir: read redir for '>':
2
4
ZTST_test: examining line:

Running test: Short arithmetic `for'
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
2
4
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  foreach name ( verbiage words periphrasis )
ZTST_getchunk: read code chunk:
  foreach name ( verbiage words periphrasis )
    print $name
  end
ZTST_test: examining line:
>verbiage
ZTST_getredir: read redir for '>':
verbiage
words
periphrasis
ZTST_test: examining line:

Running test: Csh-like `for'
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
verbiage
words
periphrasis
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  val=0;
ZTST_getchunk: read code chunk:
  val=0;
  while (( val < 2 )) { print $((val++)); }
ZTST_test: examining line:
>0
ZTST_getredir: read redir for '>':
0
1
ZTST_test: examining line:

Running test: Alternative `while'
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
0
1
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  val=2;
ZTST_getchunk: read code chunk:
  val=2;
  until (( val == 0 )) { print $((val--)); }
ZTST_test: examining line:
>2
ZTST_getredir: read redir for '>':
2
1
ZTST_test: examining line:

Running test: Alternative `until'
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
2
1
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  repeat 3 print Hip hip hooray
ZTST_getchunk: read code chunk:
  repeat 3 print Hip hip hooray
ZTST_test: examining line:
>Hip hip hooray
ZTST_getredir: read redir for '>':
Hip hip hooray
Hip hip hooray
Hip hip hooray
ZTST_test: examining line:

Running test: Short `repeat'
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
Hip hip hooray
Hip hip hooray
Hip hip hooray
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  case bravo {
ZTST_getchunk: read code chunk:
  case bravo {
    (alpha) print schmalpha
	    ;;
    (bravo) print schmavo
	    ;;
    (charlie) print schmarlie
	    ;;
  }
ZTST_test: examining line:
>schmavo
ZTST_getredir: read redir for '>':
schmavo
ZTST_test: examining line:

Running test: `case' with braces
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
schmavo
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print 'This test hangs the shell when it fails...' >&8
ZTST_getchunk: read code chunk:
  print 'This test hangs the shell when it fails...' >&8
  name=0
  while (( name < 4375 )); do
    print -n $name
    (( name++ ))
  done < /dev/null | { read name; print done }
ZTST_test: examining line:
>done
ZTST_getredir: read redir for '>':
done
ZTST_test: examining line:

Running test: Bug regression: `while' loop with redirection and pipeline
ZTST_test: expecting status: 0
This test hangs the shell when it fails...
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
done
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: all tests successful
../../zsh-4.0.1-pre-5/Test/A01grammar.ztst: all tests successful.
../../zsh-4.0.1-pre-5/Test/A02alias.ztst: starting.
ZTST_getsect: read section name: prep
ZTST_getchunk: read code chunk:
  alias foo=echo
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:
  alias -g bar=echo
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:
  alias '\bar=echo'
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:

ZTST_getsect: read section name: test
ZTST_test: looking for new test
ZTST_test: examining line:
  foo foo
ZTST_getchunk: read code chunk:
  foo foo
ZTST_test: examining line:
>foo
ZTST_getredir: read redir for '>':
foo
ZTST_test: examining line:

Running test: Basic aliasing
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
foo
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  bar bar
ZTST_getchunk: read code chunk:
  bar bar
ZTST_test: examining line:
>echo
ZTST_getredir: read redir for '>':
echo
ZTST_test: examining line:

Running test: Global aliasing
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
echo
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  \foo foo
ZTST_getchunk: read code chunk:
  \foo foo
ZTST_test: examining line:
?ZTST_execchunk:2: command not found: foo
ZTST_getredir: read redir for '?':
ZTST_execchunk:2: command not found: foo
ZTST_test: examining line:

Running test: Not aliasing
ZTST_test: expecting status: 1
ZTST_execchunk: status 1
ZTST_test: test produced standard output:

ZTST_test: and standard error:
ZTST_execchunk:2: command not found: foo
Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  \bar \bar
ZTST_getchunk: read code chunk:
  \bar \bar
ZTST_test: examining line:
>bar
ZTST_getredir: read redir for '>':
bar
ZTST_test: examining line:

Running test: Aliasing with a backslash
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
bar
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: all tests successful
../../zsh-4.0.1-pre-5/Test/A02alias.ztst: all tests successful.
../../zsh-4.0.1-pre-5/Test/A03quoting.ztst: starting.
ZTST_getsect: read section name: test
ZTST_test: looking for new test
ZTST_test: examining line:
  print 'single  quotes'  "double  quotes"  `echo backquotes`
ZTST_getchunk: read code chunk:
  print 'single  quotes'  "double  quotes"  `echo backquotes`
ZTST_test: examining line:
>single  quotes double  quotes backquotes
ZTST_getredir: read redir for '>':
single  quotes double  quotes backquotes
ZTST_test: examining line:

Running test: Simple use of quotes
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
single  quotes double  quotes backquotes
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  foo=text
ZTST_getchunk: read code chunk:
  foo=text
  print -r '$foo\\\' "$foo\$foo\\\"\``echo bar`\`\"" `print -r $foo\\\``
ZTST_test: examining line:
>$foo\\\ text$foo\"`bar`" text`
ZTST_getredir: read redir for '>':
$foo\\\ text$foo\"`bar`" text`
ZTST_test: examining line:

Running test: Quoting inside quotes
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
$foo\\\ text$foo\"`bar`" text`
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print -r $'\'ut queant laxis\'\n"resonare fibris"'
ZTST_getchunk: read code chunk:
  print -r $'\'ut queant laxis\'\n"resonare fibris"'
ZTST_test: examining line:
>'ut queant laxis'
ZTST_getredir: read redir for '>':
'ut queant laxis'
"resonare fibris"
ZTST_test: examining line:

Running test: $'-style quotes
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
'ut queant laxis'
"resonare fibris"
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print -r ''''
ZTST_getchunk: read code chunk:
  print -r ''''
  setopt rcquotes
ZTST_test: examining line:
>
ZTST_getredir: read redir for '>':

ZTST_test: examining line:

Running test: No RC_QUOTES with single quotes
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print -r ''''
ZTST_getchunk: read code chunk:
  print -r ''''
  unsetopt rcquotes
ZTST_test: examining line:
>'
ZTST_getredir: read redir for '>':
'
ZTST_test: examining line:

Running test: Yes RC_QUOTES with single quotes
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
'
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: all tests successful
../../zsh-4.0.1-pre-5/Test/A03quoting.ztst: all tests successful.
../../zsh-4.0.1-pre-5/Test/A04redirect.ztst: starting.
ZTST_getsect: read section name: prep
ZTST_getchunk: read code chunk:
  mkdir redir.tmp && cd redir.tmp
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:

ZTST_getsect: read section name: test
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print 'This is file redir' >redir  &&  cat redir
ZTST_getchunk: read code chunk:
  print 'This is file redir' >redir  &&  cat redir
ZTST_test: examining line:
>This is file redir
ZTST_getredir: read redir for '>':
This is file redir
ZTST_test: examining line:

Running test: '>' and '<' redirection
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
This is file redir
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  rm -f redir
ZTST_getchunk: read code chunk:
  rm -f redir
  print 'This is still file redir' <>redir >&0  &&  cat <>redir
ZTST_test: examining line:
>This is still file redir
ZTST_getredir: read redir for '>':
This is still file redir
ZTST_test: examining line:

Running test: '<>' redirection
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
This is still file redir
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  rm -f redir
ZTST_getchunk: read code chunk:
  rm -f redir
  print 'With a bar' >|redir  &&  cat redir
ZTST_test: examining line:
>With a bar
ZTST_getredir: read redir for '>':
With a bar
ZTST_test: examining line:

Running test: '>|' redirection
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
With a bar
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  rm -f redir
ZTST_getchunk: read code chunk:
  rm -f redir
  print 'With a bang' >!redir  &&  cat redir
ZTST_test: examining line:
>With a bang
ZTST_getredir: read redir for '>':
With a bang
ZTST_test: examining line:

Running test: '>!' redirection
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
With a bang
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  rm -f redir
ZTST_getchunk: read code chunk:
  rm -f redir
  print 'Line 1' >>redir  &&  print 'Line 2' >>redir  &&  cat redir
ZTST_test: examining line:
>Line 1
ZTST_getredir: read redir for '>':
Line 1
Line 2
ZTST_test: examining line:

Running test: '>>' redirection
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
Line 1
Line 2
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  rm -f redir
ZTST_getchunk: read code chunk:
  rm -f redir
  print 'Line a' >>|redir  &&  print 'Line b' >>!redir
ZTST_test: examining line:

Running test: '>>|' and '>>!' redirection
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  foo=bar
ZTST_getchunk: read code chunk:
  foo=bar
  cat <<'  HERE'
  $foo
  HERE
  eval "$(print 'cat <<HERE\n$foo\nHERE')"
ZTST_test: examining line:
>  $foo
ZTST_getredir: read redir for '>':
  $foo
bar
ZTST_test: examining line:

Running test: Here-documents
ZTST_test: expecting status: 0
ZTST_execchunk: status 1
Test ../../zsh-4.0.1-pre-5/Test/A04redirect.ztst failed: bad status 1, expected 0 from:
  foo=bar
  cat <<'  HERE'
  $foo
  HERE
  eval "$(print 'cat <<HERE\n$foo\nHERE')"
Error output:
ZTST_execchunk:2: bad address
ZTST_execchunk:2: bad address
Was testing: Here-documents
../../zsh-4.0.1-pre-5/Test/A04redirect.ztst: test failed.
../../zsh-4.0.1-pre-5/Test/A05execution.ztst: starting.
ZTST_getsect: read section name: prep
ZTST_getchunk: read code chunk:
  storepath=($path)
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:
  mkdir command.tmp command.tmp/dir1 command.tmp/dir2
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:
  cd command.tmp
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:
  print '#!/bin/sh\necho This is top' >tstcmd
  print '#!/bin/sh\necho This is dir1' >dir1/tstcmd
  print '#!/bin/sh\necho This is dir2' >dir2/tstcmd
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:
  chmod 755 tstcmd dir1/tstcmd dir2/tstcmd
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:

ZTST_getsect: read section name: test
ZTST_test: looking for new test
ZTST_test: examining line:
  ./tstcmd
ZTST_getchunk: read code chunk:
  ./tstcmd
ZTST_test: examining line:
>This is top
ZTST_getredir: read redir for '>':
This is top
ZTST_test: examining line:

Running test: ./prog execution
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
This is top
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  path=($ZTST_testdir/command.tmp/dir1
ZTST_getchunk: read code chunk:
  path=($ZTST_testdir/command.tmp/dir1
        $ZTST_testdir/command.tmp/dir2
        .)
  tstcmd
  path=($storepath)
ZTST_test: examining line:
>This is dir1
ZTST_getredir: read redir for '>':
This is dir1
ZTST_test: examining line:

Running test: path (1)
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
This is dir1
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  path=(. command.tmp/dir{1,2})
ZTST_getchunk: read code chunk:
  path=(. command.tmp/dir{1,2})
  tstcmd
  path=($storepath)
ZTST_test: examining line:
>This is top
ZTST_getredir: read redir for '>':
This is top
ZTST_test: examining line:

Running test: path (2)
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
This is top
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  functst() { print $# arguments:; print -l $*; }
ZTST_getchunk: read code chunk:
  functst() { print $# arguments:; print -l $*; }
  functst "Eines Morgens" "als Gregor Samsa"
  functst ""
  functst "aus unrühigen Träumen erwachte"
  foo="fand er sich in seinem Bett"
  bar=
  rod="zu einem ungeheuren Ungeziefer verwandelt."
  functst $foo $bar $rod
  alias foo='print This is alias one'
ZTST_test: examining line:
>2 arguments:
ZTST_getredir: read redir for '>':
2 arguments:
Eines Morgens
als Gregor Samsa
1 arguments:

1 arguments:
aus unrühigen Träumen erwachte
2 arguments:
fand er sich in seinem Bett
zu einem ungeheuren Ungeziefer verwandelt.
ZTST_test: examining line:

Running test: function argument passing
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
2 arguments:
Eines Morgens
als Gregor Samsa
1 arguments:

1 arguments:
aus unrühigen Träumen erwachte
2 arguments:
fand er sich in seinem Bett
zu einem ungeheuren Ungeziefer verwandelt.
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  alias foo='print This is alias two'
ZTST_getchunk: read code chunk:
  alias foo='print This is alias two'
  fn() { foo; }
  fn
ZTST_test: examining line:
>This is alias one
ZTST_getredir: read redir for '>':
This is alias one
ZTST_test: examining line:

Running test: Aliases in functions
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
This is alias one
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  foo='Global foo'
ZTST_getchunk: read code chunk:
  foo='Global foo'
  traptst() { local foo="Local foo"; trap 'print $foo' EXIT; }
  traptst
ZTST_test: examining line:
>Global foo
ZTST_getredir: read redir for '>':
Global foo
ZTST_test: examining line:

Running test: EXIT trap environment
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
Global foo
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  functst() { return 0; print Ha ha; return 1; }
ZTST_getchunk: read code chunk:
  functst() { return 0; print Ha ha; return 1; }
  functst
ZTST_test: examining line:

Running test: return (1)
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  functst() { return 1; print Ho ho; return 0; }
ZTST_getchunk: read code chunk:
  functst() { return 1; print Ho ho; return 0; }
  functst
ZTST_test: examining line:

Running test: return (2)
ZTST_test: expecting status: 1
ZTST_execchunk: status 1
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  unfunction functst
ZTST_getchunk: read code chunk:
  unfunction functst
  fpath=(.)
  print "print This is functst." >functst
  autoload functst
  functst
ZTST_test: examining line:
>This is functst.
ZTST_getredir: read redir for '>':
This is functst.
ZTST_test: examining line:

Running test: autoloading (1)
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
This is functst.
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  unfunction functst
ZTST_getchunk: read code chunk:
  unfunction functst
  print "functst() { print This, too, is functst; }; print Hello." >functst
  typeset -fu functst
  functst
  functst
ZTST_test: examining line:
>Hello.
ZTST_getredir: read redir for '>':
Hello.
This, too, is functst
ZTST_test: examining line:

Running test: autoloading with initialization
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
Hello.
This, too, is functst
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  unfunction functst
ZTST_getchunk: read code chunk:
  unfunction functst
  print "print Yet another version" >functst
  functst() { autoload -X; }
  functst
ZTST_test: examining line:
>Yet another version
ZTST_getredir: read redir for '>':
Yet another version
ZTST_test: examining line:

Running test: autoloading via -X
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
Yet another version
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  chpwd() { print Changed to $PWD; }
ZTST_getchunk: read code chunk:
  chpwd() { print Changed to $PWD; }
  cd .
  unfunction chpwd
ZTST_test: examining line:
>Changed to $ZTST_testdir/command.tmp
ZTST_getredir: read redir for '>':
Changed to $ZTST_testdir/command.tmp
ZTST_test: examining line:

Running test: chpwd
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
Changed to /tmp/obj-sun/Test/command.tmp
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:

ZTST_test: examining line:
  fn() { TRAPEXIT() { print Exit; }; }
ZTST_getchunk: read code chunk:
  fn() { TRAPEXIT() { print Exit; }; }
  fn
ZTST_test: examining line:
>Exit
ZTST_getredir: read redir for '>':
Exit
ZTST_test: examining line:

Running test: TRAPEXIT
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
Exit
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  unfunction fn
ZTST_getchunk: read code chunk:
  unfunction fn
  print 'TRAPDEBUG() {
      print Line $LINENO
    }
    :
    unfunction TRAPDEBUG
  ' > fn
  autoload fn
  fn
  rm fn
ZTST_test: examining line:
>Line 1
ZTST_getredir: read redir for '>':
Line 1
Line 1
ZTST_test: examining line:

Running test: TRAPDEBUG
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
Line 1
Line 1
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  unfunction fn
ZTST_getchunk: read code chunk:
  unfunction fn
  print 'trap '\''print Line $LINENO'\'' DEBUG
    :
    trap - DEBUG
  ' > fn
  autoload fn
  fn
  rm fn
ZTST_test: examining line:
>Line 1
ZTST_getredir: read redir for '>':
Line 1
Line 2
ZTST_test: examining line:

Running test: trap DEBUG
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
Line 1
Line 2
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  TRAPZERR() { print Command failed; }
ZTST_getchunk: read code chunk:
  TRAPZERR() { print Command failed; }
  true
  false
  true
  false
  unfunction TRAPZERR
ZTST_test: examining line:
>Command failed
ZTST_getredir: read redir for '>':
Command failed
Command failed
ZTST_test: examining line:

Running test: TRAPZERR
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
Command failed
Command failed
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  trap 'print Command failed again.' ZERR
ZTST_getchunk: read code chunk:
  trap 'print Command failed again.' ZERR
  true
  false
  true
  false
  trap - ZERR
ZTST_test: examining line:
>Command failed again.
ZTST_getredir: read redir for '>':
Command failed again.
Command failed again.
ZTST_test: examining line:

Running test: trap ZERR
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
Command failed again.
Command failed again.
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: all tests successful
../../zsh-4.0.1-pre-5/Test/A05execution.ztst: all tests successful.
../../zsh-4.0.1-pre-5/Test/B01cd.ztst: starting.
ZTST_getsect: read section name: prep
ZTST_getchunk: read code chunk:
 mkdir cdtst.tmp cdtst.tmp/real cdtst.tmp/sub
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:
 ln -s ../real cdtst.tmp/sub/fake
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:
 setopt chaselinks
 cd .
 unsetopt chaselinks
 mydir=$PWD
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:

ZTST_getsect: read section name: test
ZTST_test: looking for new test
ZTST_test: examining line:
 cd cdtst.tmp/sub/fake &&
ZTST_getchunk: read code chunk:
 cd cdtst.tmp/sub/fake &&
 pwd &&
 print $PWD
ZTST_test: examining line:
>$mydir/cdtst.tmp/sub/fake
ZTST_getredir: read redir for '>':
$mydir/cdtst.tmp/sub/fake
$mydir/cdtst.tmp/sub/fake
ZTST_test: examining line:

Running test: Preserving symbolic links in the current directory string
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
/tmp/obj-sun/Test/cdtst.tmp/sub/fake
/tmp/obj-sun/Test/cdtst.tmp/sub/fake
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 cd ../../.. &&
ZTST_getchunk: read code chunk:
 cd ../../.. &&
 pwd &&
 print $PWD
ZTST_test: examining line:
>$mydir
ZTST_getredir: read redir for '>':
$mydir
$mydir
ZTST_test: examining line:

Running test: Changing directory up through symbolic links without following them
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
/tmp/obj-sun/Test
/tmp/obj-sun/Test
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 setopt chaselinks
ZTST_getchunk: read code chunk:
 setopt chaselinks
 cd cdtst.tmp/sub/fake &&
 pwd &&
 print $PWD
ZTST_test: examining line:
>$mydir/cdtst.tmp/real
ZTST_getredir: read redir for '>':
$mydir/cdtst.tmp/real
$mydir/cdtst.tmp/real
ZTST_test: examining line:

Running test: Resolving symbolic links with chaselinks set
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
/tmp/obj-sun/Test/cdtst.tmp/real
/tmp/obj-sun/Test/cdtst.tmp/real
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
%clean
ZTST_test: all tests successful
ZTST_getsect: read section name: clean
ZTST_getchunk: read code chunk:

../../zsh-4.0.1-pre-5/Test/B01cd.ztst: all tests successful.
../../zsh-4.0.1-pre-5/Test/C01arith.ztst: starting.
ZTST_getsect: read section name: test
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  integer light there
ZTST_getchunk: read code chunk:
  integer light there
  (( light = 42 )) &&
  let 'there = light' &&
  print $(( there ))
ZTST_test: examining line:
>42
ZTST_getredir: read redir for '>':
42
ZTST_test: examining line:

Running test: basic integer arithmetic
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
42
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  float light there
ZTST_getchunk: read code chunk:
  float light there
  integer rnd
  (( light = 3.1415 )) &&
  let 'there = light' &&
  print -- $(( rnd = there * 10000 ))
ZTST_test: examining line:
>31415
ZTST_getredir: read redir for '>':
31415
ZTST_test: examining line:

Running test: basic floating point arithmetic
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
31415
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print $(( 0x10 + 0X01 + 2#1010 ))
ZTST_getchunk: read code chunk:
  print $(( 0x10 + 0X01 + 2#1010 ))
ZTST_test: examining line:
>27
ZTST_getredir: read redir for '>':
27
ZTST_test: examining line:

Running test: base input
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
27
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  float light
ZTST_getchunk: read code chunk:
  float light
  (( light = 4 ))
  print $light
  typeset -F light
  print $light
ZTST_test: examining line:
>4.000000000e+00
ZTST_getredir: read redir for '>':
4.000000000e+00
4.0000000000
ZTST_test: examining line:

Running test: conversion to float
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
4.000000000e+00
4.0000000000
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  integer i
ZTST_getchunk: read code chunk:
  integer i
  (( i = 32.5 ))
  print $i
ZTST_test: examining line:
>32
ZTST_getredir: read redir for '>':
32
ZTST_test: examining line:

Running test: conversion to int
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
32
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  integer i
ZTST_getchunk: read code chunk:
  integer i
  (( i = 4 - - 3 * 7 << 1 & 7 ^ 1 | 16 ** 2 ))
  print $i
ZTST_test: examining line:
>1591
ZTST_getredir: read redir for '>':
1591
ZTST_test: examining line:

Running test: precedence (arithmetic)
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
1591
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print $(( 1 < 2 || 2 < 2 && 3 > 4 ))
ZTST_getchunk: read code chunk:
  print $(( 1 < 2 || 2 < 2 && 3 > 4 ))
ZTST_test: examining line:
>1
ZTST_getredir: read redir for '>':
1
ZTST_test: examining line:

Running test: precedence (logical)
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
1
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print $(( 1 + 4 ? 3 + 2 ? 4 + 3 ? 5 + 6 ? 4 * 8 : 0 : 0 : 0 : 0 ))
ZTST_getchunk: read code chunk:
  print $(( 1 + 4 ? 3 + 2 ? 4 + 3 ? 5 + 6 ? 4 * 8 : 0 : 0 : 0 : 0 ))
ZTST_test: examining line:
>32
ZTST_getredir: read redir for '>':
32
ZTST_test: examining line:

Running test: precedence (ternary)
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
32
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print $(( 3 ? 2 ))
ZTST_getchunk: read code chunk:
  print $(( 3 ? 2 ))
ZTST_test: examining line:
?ZTST_execchunk:2: ':' expected
ZTST_getredir: read redir for '?':
ZTST_execchunk:2: ':' expected
ZTST_test: examining line:

Running test: parsing ternary (1)
ZTST_test: expecting status: 1
ZTST_execchunk: status 1
ZTST_test: test produced standard output:

ZTST_test: and standard error:
ZTST_execchunk:2: ':' expected
Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print $(( 3 ? 2 : 1 : 4 ))
ZTST_getchunk: read code chunk:
  print $(( 3 ? 2 : 1 : 4 ))
ZTST_test: examining line:
?ZTST_execchunk:2: ':' without '?'
ZTST_getredir: read redir for '?':
ZTST_execchunk:2: ':' without '?'
ZTST_test: examining line:

Running test: parsing ternary (2)
ZTST_test: expecting status: 1
ZTST_execchunk: status 1
ZTST_test: test produced standard output:

ZTST_test: and standard error:
ZTST_execchunk:2: ':' without '?'
Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print $(( 0, 4 ? 3 : 1, 5 ))
ZTST_getchunk: read code chunk:
  print $(( 0, 4 ? 3 : 1, 5 ))
ZTST_test: examining line:
>5
ZTST_getredir: read redir for '>':
5
ZTST_test: examining line:

Running test: comma operator
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
5
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  foo=000
ZTST_getchunk: read code chunk:
  foo=000
  print $(( ##A + ##\C-a + #foo + $#foo ))
ZTST_test: examining line:
>117
ZTST_getredir: read redir for '>':
117
ZTST_test: examining line:

Running test: #, ## and $#
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
117
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  integer i
ZTST_getchunk: read code chunk:
  integer i
  (( i = 3 + 5 * 1.75 ))
  print $i
ZTST_test: examining line:
>11
ZTST_getredir: read redir for '>':
11
ZTST_test: examining line:

Running test: promotion to float
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
11
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  typeset x      &&
ZTST_getchunk: read code chunk:
  typeset x      &&
  (( x = 3.5 ))  &&
  print $x       &&
  (( x = 4 ))    &&
  print $x
ZTST_test: examining line:
>3.5
ZTST_getredir: read redir for '>':
3.5
4
ZTST_test: examining line:

Running test: use of scalars to store integers and floats
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
3.5
4
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  (( newarray[unsetvar]++ ))
ZTST_getchunk: read code chunk:
  (( newarray[unsetvar]++ ))
  (( newarray[unsetvar]++ ))
  print ${(t)newarray} ${#newarray} ${newarray[1]}
ZTST_test: examining line:
>array 1 2
ZTST_getredir: read redir for '>':
array 1 2
ZTST_test: examining line:

Running test: setting array elements in math context
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
array 1 2
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: all tests successful
../../zsh-4.0.1-pre-5/Test/C01arith.ztst: all tests successful.
../../zsh-4.0.1-pre-5/Test/C02cond.ztst: starting.
ZTST_getsect: read section name: prep
ZTST_getchunk: read code chunk:
  umask 077
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:
  mkdir cond.tmp
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:
  cd cond.tmp
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:
  touch	unmodified
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:
  touch zerolength
  chgrp $EGID zerolength
  print 'Garbuglio' >nonzerolength
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:
  mkdir modish
  chmod g+xs modish
  chmod u+s modish
  chmod +t modish
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:

ZTST_getsect: read section name: test
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  [[ -a zerolength && ! -a nonexistent ]]
ZTST_getchunk: read code chunk:
  [[ -a zerolength && ! -a nonexistent ]]
ZTST_test: examining line:

Running test: -a cond
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  # Find a block special file system.  This is a little tricky.
ZTST_getchunk: read code chunk:
  # Find a block special file system.  This is a little tricky.
  block=$(find /dev /devices -type b -print 2>/dev/null|head -1) &&
  [[ -b $block && ! -b zerolength ]]
ZTST_test: examining line:

Running test: -b cond
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  char=(/dev/tty*([1]))
ZTST_getchunk: read code chunk:
  char=(/dev/tty*([1]))
  [[ -c $char && ! -c $block ]]
ZTST_test: examining line:

Running test: -c cond
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  [[ -d . && ! -d zerolength ]]
ZTST_getchunk: read code chunk:
  [[ -d . && ! -d zerolength ]]
ZTST_test: examining line:

Running test: -d cond
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  [[ -e zerolength && ! -e nonexistent ]]
ZTST_getchunk: read code chunk:
  [[ -e zerolength && ! -e nonexistent ]]
ZTST_test: examining line:

Running test: -e cond
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  [[ -f zerolength && ! -f cond && ! -f $char && ! -f $block && ! -f . ]]
ZTST_getchunk: read code chunk:
  [[ -f zerolength && ! -f cond && ! -f $char && ! -f $block && ! -f . ]]
ZTST_test: examining line:

Running test: -f cond
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  [[ -g modish && ! -g zerolength ]]
ZTST_getchunk: read code chunk:
  [[ -g modish && ! -g zerolength ]]
ZTST_test: examining line:

Running test: -g cond
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  ln -s zerolength link
ZTST_getchunk: read code chunk:
  ln -s zerolength link
  [[ -h link && ! -h zerolength ]]
ZTST_test: examining line:

Running test: -h cond
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  [[ -k modish && ! -k zerolength ]]
ZTST_getchunk: read code chunk:
  [[ -k modish && ! -k zerolength ]]
ZTST_test: examining line:

Running test: -k cond
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  foo=foo
ZTST_getchunk: read code chunk:
  foo=foo
  bar=
  [[ -n $foo && ! -n $bar && ! -n '' ]]
ZTST_test: examining line:

Running test: -n cond
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  [[ -o rcs && ! -o norcs && -o noerrexit && ! -o errexit ]]
ZTST_getchunk: read code chunk:
  [[ -o rcs && ! -o norcs && -o noerrexit && ! -o errexit ]]
ZTST_test: examining line:

Running test: -o cond
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  if whence mkfifo >/dev/null; then
ZTST_getchunk: read code chunk:
  if whence mkfifo >/dev/null; then
    mkfifo pipe
  else
    mknod pipe p
  fi
  [[ -p pipe && ! -p zerolength ]]
ZTST_test: examining line:

Running test: -p cond
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  touch unmodish
ZTST_getchunk: read code chunk:
  touch unmodish
  chmod 000 unmodish
  [[ -r zerolength && ! -r unmodish ]]
  # This works around a bug in rm -f in some versions of Cygwin
  chmod 644 unmodish
ZTST_test: examining line:

Running test: -r cond
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  [[ -s nonzerolength && ! -s zerolength ]]
ZTST_getchunk: read code chunk:
  [[ -s nonzerolength && ! -s zerolength ]]
ZTST_test: examining line:

Running test: -s cond
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:

ZTST_test: examining line:
  [[ -u modish && ! -u zerolength ]]
ZTST_getchunk: read code chunk:
  [[ -u modish && ! -u zerolength ]]
ZTST_test: examining line:

Running test: -u cond
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  [[ -x $ZTST_srcdir/ztst.zsh && ! -x zerolength ]]
ZTST_getchunk: read code chunk:
  [[ -x $ZTST_srcdir/ztst.zsh && ! -x zerolength ]]
ZTST_test: examining line:

Running test: -x cond
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  [[ -z $bar && -z '' && ! -z $foo ]]
ZTST_getchunk: read code chunk:
  [[ -z $bar && -z '' && ! -z $foo ]]
ZTST_test: examining line:

Running test: -z cond
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  [[ -L link && ! -L zerolength ]]
ZTST_getchunk: read code chunk:
  [[ -L link && ! -L zerolength ]]
ZTST_test: examining line:

Running test: -L cond
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  [[ -O zerolength ]]
ZTST_getchunk: read code chunk:
  [[ -O zerolength ]]
ZTST_test: examining line:

Running test: -O cond
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  [[ -G zerolength ]]
ZTST_getchunk: read code chunk:
  [[ -G zerolength ]]
ZTST_test: examining line:

Running test: -G cond
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:

ZTST_test: examining line:
  sleep 1
ZTST_getchunk: read code chunk:
  sleep 1
  cat unmodified
  touch newnewnew
  [[ -N newnewnew && ! -N unmodified ]]
ZTST_test: examining line:

Running test: -N cond
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  [[ newnewnew -nt zerolength && ! (unmodified -nt zerolength) ]]
ZTST_getchunk: read code chunk:
  [[ newnewnew -nt zerolength && ! (unmodified -nt zerolength) ]]
ZTST_test: examining line:

Running test: -nt cond
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  [[ zerolength -ot newnewnew && ! (zerolength -ot unmodified) ]]
ZTST_getchunk: read code chunk:
  [[ zerolength -ot newnewnew && ! (zerolength -ot unmodified) ]]
ZTST_test: examining line:

Running test: -ot cond
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  [[ link -ef zerolength && ! (link -ef nonzerolength) ]]
ZTST_getchunk: read code chunk:
  [[ link -ef zerolength && ! (link -ef nonzerolength) ]]
ZTST_test: examining line:

Running test: -ef cond
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  [[ foo = foo && foo != bar && foo == foo && foo != '' ]]
ZTST_getchunk: read code chunk:
  [[ foo = foo && foo != bar && foo == foo && foo != '' ]]
ZTST_test: examining line:

Running test: =, == and != conds
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  [[ bar < foo && foo > bar ]]
ZTST_getchunk: read code chunk:
  [[ bar < foo && foo > bar ]]
ZTST_test: examining line:

Running test: < and > conds
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  [[ $(( 3 + 4 )) -eq 0x07 && $(( 5 * 2 )) -ne 0x10 ]]
ZTST_getchunk: read code chunk:
  [[ $(( 3 + 4 )) -eq 0x07 && $(( 5 * 2 )) -ne 0x10 ]]
ZTST_test: examining line:

Running test: -eq and -ne conds
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  [[ 3 -lt 04 && 05 -gt 2 ]]
ZTST_getchunk: read code chunk:
  [[ 3 -lt 04 && 05 -gt 2 ]]
ZTST_test: examining line:

Running test: -lt and -gt conds
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  [[ 3 -le 3 && ! (4 -le 3) ]]
ZTST_getchunk: read code chunk:
  [[ 3 -le 3 && ! (4 -le 3) ]]
ZTST_test: examining line:

Running test: -le cond
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  [[ 3 -ge 3 && ! (3 -ge 4) ]]
ZTST_getchunk: read code chunk:
  [[ 3 -ge 3 && ! (3 -ge 4) ]]
ZTST_test: examining line:

Running test: -ge cond
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  [[ 1 -lt 2 || 2 -lt 2 && 3 -gt 4 ]]
ZTST_getchunk: read code chunk:
  [[ 1 -lt 2 || 2 -lt 2 && 3 -gt 4 ]]
ZTST_test: examining line:

Running test: || and && in conds
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  [[ -e /dev/fd/0 ]]
ZTST_getchunk: read code chunk:
  [[ -e /dev/fd/0 ]]
ZTST_test: examining line:

Running test: /dev/fd support in conds handled by access
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  [[ -O /dev/fd/0 ]]
ZTST_getchunk: read code chunk:
  [[ -O /dev/fd/0 ]]
ZTST_test: examining line:

Running test: /dev/fd support in conds handled by stat
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  [[ ( -z foo && -z foo ) || -z foo ]]
ZTST_getchunk: read code chunk:
  [[ ( -z foo && -z foo ) || -z foo ]]
ZTST_test: examining line:

Running test: complex conds with skipping
ZTST_test: expecting status: 1
ZTST_execchunk: status 1
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  [ '' != bar -a '' = '' ]
ZTST_getchunk: read code chunk:
  [ '' != bar -a '' = '' ]
ZTST_test: examining line:

Running test: strings with `[' builtin
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  [ `echo 0` -lt `echo 1` ]
ZTST_getchunk: read code chunk:
  [ `echo 0` -lt `echo 1` ]
ZTST_test: examining line:

Running test: substituion in `[' builtin
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: all tests successful
../../zsh-4.0.1-pre-5/Test/C02cond.ztst: all tests successful.
../../zsh-4.0.1-pre-5/Test/C03traps.ztst: starting.
ZTST_getsect: read section name: prep
ZTST_getchunk: read code chunk:
  setopt localtraps
  mkdir traps.tmp && cd traps.tmp
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:

ZTST_getsect: read section name: test
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  fn1() {
ZTST_getchunk: read code chunk:
  fn1() {
    trap 'print EXIT1' EXIT
    fn2() { trap 'print EXIT2' EXIT; }
    fn2
  }
  fn1
ZTST_test: examining line:
>EXIT2
ZTST_getredir: read redir for '>':
EXIT2
EXIT1
ZTST_test: examining line:

Running test: Nested `trap ... EXIT'
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
EXIT2
EXIT1
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  fn1() {
ZTST_getchunk: read code chunk:
  fn1() {
    TRAPEXIT() { print EXIT1; }
    fn2() { TRAPEXIT() { print EXIT2; }; }
    fn2
  }
  fn1
ZTST_test: examining line:
>EXIT2
ZTST_getredir: read redir for '>':
EXIT2
EXIT1
ZTST_test: examining line:

Running test:  Nested TRAPEXIT
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
EXIT2
EXIT1
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  fn1() {
ZTST_getchunk: read code chunk:
  fn1() {
    trap 'print EXIT1' EXIT
    fn2() { trap - EXIT; }
    fn2
  }
  fn1
ZTST_test: examining line:
>EXIT1
ZTST_getredir: read redir for '>':
EXIT1
ZTST_test: examining line:

Running test: Nested `trap - EXIT' on `trap ... EXIT'
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
EXIT1
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  fn1() {
ZTST_getchunk: read code chunk:
  fn1() {
    TRAPEXIT() { print EXIT1; }
    fn2() { trap - EXIT; }
    fn2
  }
  fn1
ZTST_test: examining line:
>EXIT1
ZTST_getredir: read redir for '>':
EXIT1
ZTST_test: examining line:

Running test: Nested `trap - EXIT' on `TRAPEXIT'
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
EXIT1
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  fn1() {
ZTST_getchunk: read code chunk:
  fn1() {
    trap
    trap 'print INT1' INT
    fn2() { trap 'print INT2' INT; trap; }
    trap
    fn2
    trap
  }
  fn1
ZTST_test: examining line:
>trap -- 'print INT1' INT
ZTST_getredir: read redir for '>':
trap -- 'print INT1' INT
trap -- 'print INT2' INT
trap -- 'print INT1' INT
ZTST_test: examining line:

Running test:  Nested `trap ... INT', not triggered
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
trap -- 'print INT1' INT
trap -- 'print INT2' INT
trap -- 'print INT1' INT
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
   fn1() {
ZTST_getchunk: read code chunk:
   fn1() {
    trap
    TRAPINT() { print INT1; }
    fn2() { TRAPINT() { print INT2; }; trap; }
    trap
    fn2
    trap
  }
  fn1
ZTST_test: examining line:
>TRAPINT () {
ZTST_getredir: read redir for '>':
TRAPINT () {
	print INT1
}
TRAPINT () {
	print INT2
}
TRAPINT () {
	print INT1
}
ZTST_test: examining line:

Running test:  Nested `trap ... INT', not triggered
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
TRAPINT () {
	print INT1
}
TRAPINT () {
	print INT2
}
TRAPINT () {
	print INT1
}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  fn1() {
ZTST_getchunk: read code chunk:
  fn1() {
    trap 'print INT1' INT
    fn2() { trap - INT; trap; }
    trap
    fn2
    trap
  }
  fn1
ZTST_test: examining line:
>trap -- 'print INT1' INT
ZTST_getredir: read redir for '>':
trap -- 'print INT1' INT
trap -- 'print INT1' INT
ZTST_test: examining line:

Running test:  Nested `trap - INT' on untriggered `trap ... INT'
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
trap -- 'print INT1' INT
trap -- 'print INT1' INT
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:

ZTST_test: examining line:
  print 'This test takes at least three seconds...' >&8
ZTST_getchunk: read code chunk:
  print 'This test takes at least three seconds...' >&8
  fn1() {
    trap 'print TERM1' TERM
    fn2() { trap 'print TERM2; return 1' TERM; sleep 2; }
    fn2 &
    sleep 1
    kill -TERM $!
    sleep 2
  }
  fn1
ZTST_test: examining line:
>TERM2
ZTST_getredir: read redir for '>':
TERM2
ZTST_test: examining line:

Running test:  Nested `trap ... TERM', triggered on inner loop
ZTST_test: expecting status: 0
This test takes at least three seconds...
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
TERM2
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print 'This test, too, takes at least three seconds...' >&8
ZTST_getchunk: read code chunk:
  print 'This test, too, takes at least three seconds...' >&8
  fn1() {
    trap 'print TERM1; return 1' TERM
    fn2() { trap 'print TERM2; return 1' TERM; }
    fn2
    sleep 2
  }
  fn1 &
  sleep 1
  kill -TERM $!
  sleep 2
ZTST_test: examining line:
>TERM1
ZTST_getredir: read redir for '>':
TERM1
ZTST_test: examining line:

Running test:  Nested `trap ... TERM', triggered on outer loop
ZTST_test: expecting status: 0
This test, too, takes at least three seconds...
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
TERM1
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  TRAPZERR() { print error activated; }
ZTST_getchunk: read code chunk:
  TRAPZERR() { print error activated; }
  fn() { print start of fn; false; print end of fn; }
  fn
  fn() {
    setopt localoptions localtraps
    unfunction TRAPZERR
    print start of fn
    false
    print end of fn
  }
  fn
  unfunction TRAPZERR
  print finish
ZTST_test: examining line:
>start of fn
ZTST_getredir: read redir for '>':
start of fn
error activated
end of fn
start of fn
end of fn
finish
ZTST_test: examining line:

Running test:  basic localtraps handling
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
start of fn
error activated
end of fn
start of fn
end of fn
finish
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  TRAPZERR() { print 'ERR-or!'; }
ZTST_getchunk: read code chunk:
  TRAPZERR() { print 'ERR-or!'; }
  f() { print f; false; }
  t() { print t; }
  f
  f && t
  t && f && true
  t && f
  testunset() {
    setopt localtraps
    unset -f TRAPZERR
    print testunset
    false
    true
  }
  testunset
  f
ZTST_test: examining line:
>f
ZTST_getredir: read redir for '>':
f
ERR-or!
f
t
t
f
ERR-or!
testunset
f
ERR-or!
ZTST_test: examining line:

Running test:  more sophisticated error trapping
ZTST_test: expecting status: 1
ZTST_execchunk: status 1
../../zsh-4.0.1-pre-5/Test/C03traps.ztst: all tests successful.
../../zsh-4.0.1-pre-5/Test/C04funcdef.ztst: starting.
ZTST_getsect: read section name: test
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  function f$$ () {
ZTST_getchunk: read code chunk:
  function f$$ () {
    print regress expansion of function names
  }
  f$$
ZTST_test: examining line:
>regress expansion of function names
ZTST_getredir: read redir for '>':
regress expansion of function names
ZTST_test: examining line:

Running test: Regression test: `function f$$ () { ... }'
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
regress expansion of function names
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  function foo () print bar
ZTST_getchunk: read code chunk:
  function foo () print bar
  foo
ZTST_test: examining line:
>bar
ZTST_getredir: read redir for '>':
bar
ZTST_test: examining line:

Running test: Function definition without braces
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
bar
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: all tests successful
../../zsh-4.0.1-pre-5/Test/C04funcdef.ztst: all tests successful.
../../zsh-4.0.1-pre-5/Test/D01prompt.ztst: starting.
ZTST_getsect: read section name: prep
ZTST_getchunk: read code chunk:
  mydir=$PWD
  SHLVL=2
  setopt extendedglob
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:

ZTST_getsect: read section name: test
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  hash -d mydir=$mydir
ZTST_getchunk: read code chunk:
  hash -d mydir=$mydir
  print -P '  %%%):  %)
  %%~:  %~
  %%d:  %d
  %%1/: %1/
  %%h:  %h
  %%L:  %L
  %%M:  %M
  %%m:  %m
  %%n:  %n
  %%N:  %N
  %%i:  %i
  a%%{...%%}b:  a%{%}b
  '
ZTST_test: examining line:
>  %):  )
ZTST_getredir: read redir for '>':
  %):  )
  %~:  ~mydir
  %d:  $mydir
  %1/: ${mydir:t}
  %h:  0
  %L:  2
  %M:  $HOST
  %m:  ${HOST%%.*}
  %n:  $USERNAME
  %N:  ZTST_execchunk
  %i:  2
  a%{...%}b:  ab
  
ZTST_test: examining line:

Running test: Basic prompt escapes as shown.
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
  %):  )
  %~:  ~mydir
  %d:  /tmp/obj-sun/Test
  %1/: Test
  %h:  0
  %L:  2
  %M:  unknown
  %m:  unknown
  %n:  clint
  %N:  ZTST_execchunk
  %i:  2
  a%{...%}b:  ab
  
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  true
ZTST_getchunk: read code chunk:
  true
  print -P '%?'
  false
  print -P '%?'
ZTST_test: examining line:
>0
ZTST_getredir: read redir for '>':
0
1
ZTST_test: examining line:

Running test: `%?' prompt escape
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
0
1
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  PS4="%_> "
ZTST_getchunk: read code chunk:
  PS4="%_> "
  setopt xtrace
  if true; then true; else false; fi
  unsetopt xtrace
ZTST_test: examining line:
?if> true
ZTST_getredir: read redir for '?':
if> true
then> true
> unsetopt xtrace
ZTST_test: examining line:

Running test: `%_' prompt escape
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:
if> true
then> true
> unsetopt xtrace
Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  diff =(print -P '%#') =(print -P '%(!.#.%%)')
ZTST_getchunk: read code chunk:
  diff =(print -P '%#') =(print -P '%(!.#.%%)')
ZTST_test: examining line:

Running test: `%#' prompt escape and its equivalent
ZTST_test: expecting status: 0
../../zsh-4.0.1-pre-5/Test/D02glob.ztst: starting.
ZTST_getsect: read section name: prep
ZTST_getchunk: read code chunk:
  mkdir glob.tmp
  mkdir glob.tmp/dir1
  mkdir glob.tmp/dir2
  : >glob.tmp/{,{dir1,dir2}/}{a,b,c}
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:
  globtest () { $ZTST_testdir/../Src/zsh -f $ZTST_srcdir/../Misc/$1 }
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:
  regress_absolute_path_and_core_dump() {
    local absolute_dir=$(cd glob.tmp && pwd -P)
    [[ -n $absolute_dir ]] || return 1
    setopt localoptions extendedglob nullglob
    print $absolute_dir/**/*~/*
    setopt nonullglob nomatch
    print glob.tmp/**/*~(.)#
  }
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:

ZTST_getsect: read section name: test
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  globtest globtests
ZTST_getchunk: read code chunk:
  globtest globtests
ZTST_test: examining line:
>0:  [[ foo~ = foo~ ]]
ZTST_getredir: read redir for '>':
0:  [[ foo~ = foo~ ]]
0:  [[ foo~ = (foo~) ]]
0:  [[ foo~ = (foo~|) ]]
0:  [[ foo.c = *.c~boo* ]]
1:  [[ foo.c = *.c~boo*~foo* ]]
0:  [[ fofo = (fo#)# ]]
0:  [[ ffo = (fo#)# ]]
0:  [[ foooofo = (fo#)# ]]
0:  [[ foooofof = (fo#)# ]]
0:  [[ fooofoofofooo = (fo#)# ]]
1:  [[ foooofof = (fo##)# ]]
1:  [[ xfoooofof = (fo#)# ]]
1:  [[ foooofofx = (fo#)# ]]
0:  [[ ofxoofxo = ((ofo#x)#o)# ]]
1:  [[ ofooofoofofooo = (fo#)# ]]
0:  [[ foooxfooxfoxfooox = (fo#x)# ]]
1:  [[ foooxfooxofoxfooox = (fo#x)# ]]
0:  [[ foooxfooxfxfooox = (fo#x)# ]]
0:  [[ ofxoofxo = ((ofo#x)#o)# ]]
0:  [[ ofoooxoofxo = ((ofo#x)#o)# ]]
0:  [[ ofoooxoofxoofoooxoofxo = ((ofo#x)#o)# ]]
0:  [[ ofoooxoofxoofoooxoofxoo = ((ofo#x)#o)# ]]
1:  [[ ofoooxoofxoofoooxoofxofo = ((ofo#x)#o)# ]]
0:  [[ ofoooxoofxoofoooxoofxooofxofxo = ((ofo#x)#o)# ]]
0:  [[ aac = ((a))#a(c) ]]
0:  [[ ac = ((a))#a(c) ]]
1:  [[ c = ((a))#a(c) ]]
0:  [[ aaac = ((a))#a(c) ]]
1:  [[ baaac = ((a))#a(c) ]]
0:  [[ abcd = ?(a|b)c#d ]]
0:  [[ abcd = (ab|ab#)c#d ]]
0:  [[ acd = (ab|ab#)c#d ]]
0:  [[ abbcd = (ab|ab#)c#d ]]
0:  [[ effgz = (bc##d|ef#g?|(h|)i(j|k)) ]]
0:  [[ efgz = (bc##d|ef#g?|(h|)i(j|k)) ]]
0:  [[ egz = (bc##d|ef#g?|(h|)i(j|k)) ]]
0:  [[ egzefffgzbcdij = (bc##d|ef#g?|(h|)i(j|k))# ]]
1:  [[ egz = (bc##d|ef##g?|(h|)i(j|k)) ]]
0:  [[ ofoofo = (ofo##)# ]]
0:  [[ oxfoxoxfox = (oxf(ox)##)# ]]
1:  [[ oxfoxfox = (oxf(ox)##)# ]]
0:  [[ ofoofo = (ofo##|f)# ]]
0:  [[ foofoofo = (foo|f|fo)(f|ofo##)# ]]
0:  [[ oofooofo = (of|oofo##)# ]]
0:  [[ fffooofoooooffoofffooofff = (f#o#)# ]]
1:  [[ fffooofoooooffoofffooofffx = (f#o#)# ]]
0:  [[ fofoofoofofoo = (fo|foo)# ]]
0:  [[ foo = ((^x)) ]]
0:  [[ foo = ((^x)*) ]]
1:  [[ foo = ((^foo)) ]]
0:  [[ foo = ((^foo)*) ]]
0:  [[ foobar = ((^foo)) ]]
0:  [[ foobar = ((^foo)*) ]]
1:  [[ foot = z*~*x ]]
0:  [[ zoot = z*~*x ]]
1:  [[ foox = z*~*x ]]
1:  [[ zoox = z*~*x ]]
0:  [[ moo.cow = (*~*.*).(*~*.*) ]]
1:  [[ mad.moo.cow = (*~*.*).(*~*.*) ]]
0:  [[ moo.cow = (^*.*).(^*.*) ]]
1:  [[ sane.moo.cow = (^*.*).(^*.*) ]]
1:  [[ mucca.pazza = mu(^c#)?.pa(^z#)? ]]
1:  [[ _foo~ = _(|*[^~]) ]]
0:  [[ fff = ((^f)) ]]
0:  [[ fff = ((^f)#) ]]
0:  [[ fff = ((^f)##) ]]
0:  [[ ooo = ((^f)) ]]
0:  [[ ooo = ((^f)#) ]]
0:  [[ ooo = ((^f)##) ]]
0:  [[ foo = ((^f)) ]]
0:  [[ foo = ((^f)#) ]]
0:  [[ foo = ((^f)##) ]]
1:  [[ f = ((^f)) ]]
1:  [[ f = ((^f)#) ]]
1:  [[ f = ((^f)##) ]]
0:  [[ foot = (^z*|*x) ]]
1:  [[ zoot = (^z*|*x) ]]
0:  [[ foox = (^z*|*x) ]]
0:  [[ zoox = (^z*|*x) ]]
0:  [[ foo = (^foo)# ]]
1:  [[ foob = (^foo)b* ]]
0:  [[ foobb = (^foo)b* ]]
1:  [[ foob = (*~foo)b* ]]
0:  [[ foobb = (*~foo)b* ]]
1:  [[ zsh = ^z* ]]
0:  [[ a%1X = [[:alpha:][:punct:]]#[[:digit:]][^[:lower:]] ]]
1:  [[ a%1 = [[:alpha:][:punct:]]#[[:digit:]][^[:lower:]] ]]
0:  [[ [: = [[:]# ]]
0:  [[ :] = []:]# ]]
0:  [[ :] = [:]]# ]]
0:  [[ [ = [[] ]]
0:  [[ ] = []] ]]
0:  [[ [] = [^]]] ]]
0:  [[ fooxx = (#i)FOOXX ]]
1:  [[ fooxx = (#l)FOOXX ]]
0:  [[ FOOXX = (#l)fooxx ]]
1:  [[ fooxx = (#i)FOO(#I)X(#i)X ]]
0:  [[ fooXx = (#i)FOO(#I)X(#i)X ]]
0:  [[ fooxx = ((#i)FOOX)x ]]
1:  [[ fooxx = ((#i)FOOX)X ]]
1:  [[ BAR = (bar|(#i)foo) ]]
0:  [[ FOO = (bar|(#i)foo) ]]
0:  [[ Modules = (#i)*m* ]]
0:  [[ fooGRUD = (#i)(bar|(#I)foo|(#i)rod)grud ]]
1:  [[ FOOGRUD = (#i)(bar|(#I)foo|(#i)rod)grud ]]
0:  [[ readme = (#i)readme~README|readme ]]
0:  [[ readme = (#i)readme~README|readme~README ]]
0:  [[ 633 = <1-1000>33 ]]
0:  [[ 633 = <-1000>33 ]]
0:  [[ 633 = <1->33 ]]
0:  [[ 633 = <->33 ]]
0:  [[ READ.ME = (#ia1)readme ]]
1:  [[ READ..ME = (#ia1)readme ]]
0:  [[ README = (#ia1)readm ]]
0:  [[ READM = (#ia1)readme ]]
0:  [[ README = (#ia1)eadme ]]
0:  [[ EADME = (#ia1)readme ]]
0:  [[ READEM = (#ia1)readme ]]
1:  [[ ADME = (#ia1)readme ]]
1:  [[ README = (#ia1)read ]]
0:  [[ bob = (#a1)[b][b] ]]
1:  [[ bob = (#a1)[b][b]a ]]
0:  [[ bob = (#a1)[b]o[b]a ]]
1:  [[ bob = (#a1)[c]o[b] ]]
0:  [[ abcd = (#a2)XbcX ]]
0:  [[ abcd = (#a2)ad ]]
0:  [[ ad = (#a2)abcd ]]
0:  [[ abcd = (#a2)bd ]]
0:  [[ bd = (#a2)abcd ]]
0:  [[ badc = (#a2)abcd ]]
0:  [[ adbc = (#a2)abcd ]]
1:  [[ dcba = (#a2)abcd ]]
0:  [[ dcba = (#a3)abcd ]]
0:  [[ aabaXaaabY = (#a1)(a#b)#Y ]]
0:  [[ aabaXaaabY = (#a1)(a#b)(a#b)Y ]]
0:  [[ aaXaaaaabY = (#a1)(a#b)(a#b)Y ]]
0:  [[ aaaXaaabY = (#a1)(a##b)##Y ]]
0:  [[ aaaXbaabY = (#a1)(a##b)##Y ]]
1:  [[ read.me = (#ia1)README~READ.ME ]]
0:  [[ read.me = (#ia1)README~READ_ME ]]
1:  [[ read.me = (#ia1)README~(#a1)READ_ME ]]
0:  [[ test = *((#s)|/)test((#e)|/)* ]]
0:  [[ test/path = *((#s)|/)test((#e)|/)* ]]
0:  [[ path/test = *((#s)|/)test((#e)|/)* ]]
0:  [[ path/test/ohyes = *((#s)|/)test((#e)|/)* ]]
1:  [[ atest = *((#s)|/)test((#e)|/)* ]]
1:  [[ testy = *((#s)|/)test((#e)|/)* ]]
1:  [[ testy/path = *((#s)|/)test((#e)|/)* ]]
1:  [[ path/atest = *((#s)|/)test((#e)|/)* ]]
1:  [[ atest/path = *((#s)|/)test((#e)|/)* ]]
1:  [[ path/testy = *((#s)|/)test((#e)|/)* ]]
1:  [[ path/testy/ohyes = *((#s)|/)test((#e)|/)* ]]
1:  [[ path/atest/ohyes = *((#s)|/)test((#e)|/)* ]]
0 tests failed.
ZTST_test: examining line:

Running test: zsh globbing
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
0 tests failed.
ZTST_test: and standard error:
/tmp/obj-sun/Test/../../zsh-4.0.1-pre-5/Test/../Misc/globtests:7: bad address
*** /tmp/zsh.ztst.out.3856	Tue May 22 11:52:41 2001
--- /tmp/zsh.ztst.tout.3856	Tue May 22 11:52:41 2001
***************
*** 1,154 ****
- 0:  [[ foo~ = foo~ ]]
- 0:  [[ foo~ = (foo~) ]]
- 0:  [[ foo~ = (foo~|) ]]
- 0:  [[ foo.c = *.c~boo* ]]
- 1:  [[ foo.c = *.c~boo*~foo* ]]
- 0:  [[ fofo = (fo#)# ]]
- 0:  [[ ffo = (fo#)# ]]
- 0:  [[ foooofo = (fo#)# ]]
- 0:  [[ foooofof = (fo#)# ]]
- 0:  [[ fooofoofofooo = (fo#)# ]]
- 1:  [[ foooofof = (fo##)# ]]
- 1:  [[ xfoooofof = (fo#)# ]]
- 1:  [[ foooofofx = (fo#)# ]]
- 0:  [[ ofxoofxo = ((ofo#x)#o)# ]]
- 1:  [[ ofooofoofofooo = (fo#)# ]]
- 0:  [[ foooxfooxfoxfooox = (fo#x)# ]]
- 1:  [[ foooxfooxofoxfooox = (fo#x)# ]]
- 0:  [[ foooxfooxfxfooox = (fo#x)# ]]
- 0:  [[ ofxoofxo = ((ofo#x)#o)# ]]
- 0:  [[ ofoooxoofxo = ((ofo#x)#o)# ]]
- 0:  [[ ofoooxoofxoofoooxoofxo = ((ofo#x)#o)# ]]
- 0:  [[ ofoooxoofxoofoooxoofxoo = ((ofo#x)#o)# ]]
- 1:  [[ ofoooxoofxoofoooxoofxofo = ((ofo#x)#o)# ]]
- 0:  [[ ofoooxoofxoofoooxoofxooofxofxo = ((ofo#x)#o)# ]]
- 0:  [[ aac = ((a))#a(c) ]]
- 0:  [[ ac = ((a))#a(c) ]]
- 1:  [[ c = ((a))#a(c) ]]
- 0:  [[ aaac = ((a))#a(c) ]]
- 1:  [[ baaac = ((a))#a(c) ]]
- 0:  [[ abcd = ?(a|b)c#d ]]
- 0:  [[ abcd = (ab|ab#)c#d ]]
- 0:  [[ acd = (ab|ab#)c#d ]]
- 0:  [[ abbcd = (ab|ab#)c#d ]]
- 0:  [[ effgz = (bc##d|ef#g?|(h|)i(j|k)) ]]
- 0:  [[ efgz = (bc##d|ef#g?|(h|)i(j|k)) ]]
- 0:  [[ egz = (bc##d|ef#g?|(h|)i(j|k)) ]]
- 0:  [[ egzefffgzbcdij = (bc##d|ef#g?|(h|)i(j|k))# ]]
- 1:  [[ egz = (bc##d|ef##g?|(h|)i(j|k)) ]]
- 0:  [[ ofoofo = (ofo##)# ]]
- 0:  [[ oxfoxoxfox = (oxf(ox)##)# ]]
- 1:  [[ oxfoxfox = (oxf(ox)##)# ]]
- 0:  [[ ofoofo = (ofo##|f)# ]]
- 0:  [[ foofoofo = (foo|f|fo)(f|ofo##)# ]]
- 0:  [[ oofooofo = (of|oofo##)# ]]
- 0:  [[ fffooofoooooffoofffooofff = (f#o#)# ]]
- 1:  [[ fffooofoooooffoofffooofffx = (f#o#)# ]]
- 0:  [[ fofoofoofofoo = (fo|foo)# ]]
- 0:  [[ foo = ((^x)) ]]
- 0:  [[ foo = ((^x)*) ]]
- 1:  [[ foo = ((^foo)) ]]
- 0:  [[ foo = ((^foo)*) ]]
- 0:  [[ foobar = ((^foo)) ]]
- 0:  [[ foobar = ((^foo)*) ]]
- 1:  [[ foot = z*~*x ]]
- 0:  [[ zoot = z*~*x ]]
- 1:  [[ foox = z*~*x ]]
- 1:  [[ zoox = z*~*x ]]
- 0:  [[ moo.cow = (*~*.*).(*~*.*) ]]
- 1:  [[ mad.moo.cow = (*~*.*).(*~*.*) ]]
- 0:  [[ moo.cow = (^*.*).(^*.*) ]]
- 1:  [[ sane.moo.cow = (^*.*).(^*.*) ]]
- 1:  [[ mucca.pazza = mu(^c#)?.pa(^z#)? ]]
- 1:  [[ _foo~ = _(|*[^~]) ]]
- 0:  [[ fff = ((^f)) ]]
- 0:  [[ fff = ((^f)#) ]]
- 0:  [[ fff = ((^f)##) ]]
- 0:  [[ ooo = ((^f)) ]]
- 0:  [[ ooo = ((^f)#) ]]
- 0:  [[ ooo = ((^f)##) ]]
- 0:  [[ foo = ((^f)) ]]
- 0:  [[ foo = ((^f)#) ]]
- 0:  [[ foo = ((^f)##) ]]
- 1:  [[ f = ((^f)) ]]
- 1:  [[ f = ((^f)#) ]]
- 1:  [[ f = ((^f)##) ]]
- 0:  [[ foot = (^z*|*x) ]]
- 1:  [[ zoot = (^z*|*x) ]]
- 0:  [[ foox = (^z*|*x) ]]
- 0:  [[ zoox = (^z*|*x) ]]
- 0:  [[ foo = (^foo)# ]]
- 1:  [[ foob = (^foo)b* ]]
- 0:  [[ foobb = (^foo)b* ]]
- 1:  [[ foob = (*~foo)b* ]]
- 0:  [[ foobb = (*~foo)b* ]]
- 1:  [[ zsh = ^z* ]]
- 0:  [[ a%1X = [[:alpha:][:punct:]]#[[:digit:]][^[:lower:]] ]]
- 1:  [[ a%1 = [[:alpha:][:punct:]]#[[:digit:]][^[:lower:]] ]]
- 0:  [[ [: = [[:]# ]]
- 0:  [[ :] = []:]# ]]
- 0:  [[ :] = [:]]# ]]
- 0:  [[ [ = [[] ]]
- 0:  [[ ] = []] ]]
- 0:  [[ [] = [^]]] ]]
- 0:  [[ fooxx = (#i)FOOXX ]]
- 1:  [[ fooxx = (#l)FOOXX ]]
- 0:  [[ FOOXX = (#l)fooxx ]]
- 1:  [[ fooxx = (#i)FOO(#I)X(#i)X ]]
- 0:  [[ fooXx = (#i)FOO(#I)X(#i)X ]]
- 0:  [[ fooxx = ((#i)FOOX)x ]]
- 1:  [[ fooxx = ((#i)FOOX)X ]]
- 1:  [[ BAR = (bar|(#i)foo) ]]
- 0:  [[ FOO = (bar|(#i)foo) ]]
- 0:  [[ Modules = (#i)*m* ]]
- 0:  [[ fooGRUD = (#i)(bar|(#I)foo|(#i)rod)grud ]]
- 1:  [[ FOOGRUD = (#i)(bar|(#I)foo|(#i)rod)grud ]]
- 0:  [[ readme = (#i)readme~README|readme ]]
- 0:  [[ readme = (#i)readme~README|readme~README ]]
- 0:  [[ 633 = <1-1000>33 ]]
- 0:  [[ 633 = <-1000>33 ]]
- 0:  [[ 633 = <1->33 ]]
- 0:  [[ 633 = <->33 ]]
- 0:  [[ READ.ME = (#ia1)readme ]]
- 1:  [[ READ..ME = (#ia1)readme ]]
- 0:  [[ README = (#ia1)readm ]]
- 0:  [[ READM = (#ia1)readme ]]
- 0:  [[ README = (#ia1)eadme ]]
- 0:  [[ EADME = (#ia1)readme ]]
- 0:  [[ READEM = (#ia1)readme ]]
- 1:  [[ ADME = (#ia1)readme ]]
- 1:  [[ README = (#ia1)read ]]
- 0:  [[ bob = (#a1)[b][b] ]]
- 1:  [[ bob = (#a1)[b][b]a ]]
- 0:  [[ bob = (#a1)[b]o[b]a ]]
- 1:  [[ bob = (#a1)[c]o[b] ]]
- 0:  [[ abcd = (#a2)XbcX ]]
- 0:  [[ abcd = (#a2)ad ]]
- 0:  [[ ad = (#a2)abcd ]]
- 0:  [[ abcd = (#a2)bd ]]
- 0:  [[ bd = (#a2)abcd ]]
- 0:  [[ badc = (#a2)abcd ]]
- 0:  [[ adbc = (#a2)abcd ]]
- 1:  [[ dcba = (#a2)abcd ]]
- 0:  [[ dcba = (#a3)abcd ]]
- 0:  [[ aabaXaaabY = (#a1)(a#b)#Y ]]
- 0:  [[ aabaXaaabY = (#a1)(a#b)(a#b)Y ]]
- 0:  [[ aaXaaaaabY = (#a1)(a#b)(a#b)Y ]]
- 0:  [[ aaaXaaabY = (#a1)(a##b)##Y ]]
- 0:  [[ aaaXbaabY = (#a1)(a##b)##Y ]]
- 1:  [[ read.me = (#ia1)README~READ.ME ]]
- 0:  [[ read.me = (#ia1)README~READ_ME ]]
- 1:  [[ read.me = (#ia1)README~(#a1)READ_ME ]]
- 0:  [[ test = *((#s)|/)test((#e)|/)* ]]
- 0:  [[ test/path = *((#s)|/)test((#e)|/)* ]]
- 0:  [[ path/test = *((#s)|/)test((#e)|/)* ]]
- 0:  [[ path/test/ohyes = *((#s)|/)test((#e)|/)* ]]
- 1:  [[ atest = *((#s)|/)test((#e)|/)* ]]
- 1:  [[ testy = *((#s)|/)test((#e)|/)* ]]
- 1:  [[ testy/path = *((#s)|/)test((#e)|/)* ]]
- 1:  [[ path/atest = *((#s)|/)test((#e)|/)* ]]
- 1:  [[ atest/path = *((#s)|/)test((#e)|/)* ]]
- 1:  [[ path/testy = *((#s)|/)test((#e)|/)* ]]
- 1:  [[ path/testy/ohyes = *((#s)|/)test((#e)|/)* ]]
- 1:  [[ path/atest/ohyes = *((#s)|/)test((#e)|/)* ]]
  0 tests failed.
--- 1 ----
Test ../../zsh-4.0.1-pre-5/Test/D02glob.ztst failed: output differs from expected as shown above for:
  globtest globtests
Error output:
/tmp/obj-sun/Test/../../zsh-4.0.1-pre-5/Test/../Misc/globtests:7: bad address
Was testing: zsh globbing
../../zsh-4.0.1-pre-5/Test/D02glob.ztst: test failed.
../../zsh-4.0.1-pre-5/Test/D03procsubst.ztst: starting.
ZTST_getsect: read section name: prep
ZTST_getchunk: read code chunk:
  mkdir procsubst.tmp
  cd procsubst.tmp
  print 'First\tSecond\tThird\tFourth' >FILE1
  print 'Erste\tZweite\tDritte\tVierte' >FILE2
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:

ZTST_getsect: read section name: test
ZTST_test: looking for new test
ZTST_test: examining line:
  paste <(cut -f1 FILE1) <(cut -f3 FILE2)
ZTST_getchunk: read code chunk:
  paste <(cut -f1 FILE1) <(cut -f3 FILE2)
ZTST_test: examining line:
>First	Dritte
ZTST_getredir: read redir for '>':
First	Dritte
ZTST_test: examining line:

Running test: <(...) substitution
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
First	Dritte
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  paste <(cut -f2 FILE1) <(cut -f4 FILE2) > >(sed 's/e/E/g' >OUTFILE)
ZTST_getchunk: read code chunk:
  paste <(cut -f2 FILE1) <(cut -f4 FILE2) > >(sed 's/e/E/g' >OUTFILE)
  sleep 1	# since the sed is asynchronous
  cat OUTFILE
ZTST_test: examining line:
>SEcond	ViErtE
ZTST_getredir: read redir for '>':
SEcond	ViErtE
ZTST_test: examining line:

Running test: >(...) substitution
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
SEcond	ViErtE
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  diff =(cat FILE1) =(cat FILE2)
ZTST_getchunk: read code chunk:
  diff =(cat FILE1) =(cat FILE2)
ZTST_test: examining line:
>1c1
ZTST_getredir: read redir for '>':
1c1
< First	Second	Third	Fourth
---
> Erste	Zweite	Dritte	Vierte
ZTST_test: examining line:

Running test: =(...) substituion
ZTST_test: expecting status: 1
../../zsh-4.0.1-pre-5/Test/D04parameter.ztst: starting.
ZTST_getsect: read section name: prep
ZTST_getchunk: read code chunk:
  mkdir parameter.tmp
  cd parameter.tmp
  touch boringfile evenmoreboringfile
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:

ZTST_getsect: read section name: test
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  foo='the first parameter'
ZTST_getchunk: read code chunk:
  foo='the first parameter'
  bar='the second parameter'
  print -l $foo ${bar}
ZTST_test: examining line:
>the first parameter
ZTST_getredir: read redir for '>':
the first parameter
the second parameter
ZTST_test: examining line:

Running test: Basic scalar parameter substitution
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
the first parameter
the second parameter
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  array1=(the first array)
ZTST_getchunk: read code chunk:
  array1=(the first array)
  array2=(the second array)
  print -l $array1 ${array2}
ZTST_test: examining line:
>the
ZTST_getredir: read redir for '>':
the
first
array
the
second
array
ZTST_test: examining line:

Running test: Basic array parameter substitution
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
the
first
array
the
second
array
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  setopt ksharrays
ZTST_getchunk: read code chunk:
  setopt ksharrays
  print -l $array1 ${array2}
  unsetopt ksharrays
ZTST_test: examining line:
>the
ZTST_getredir: read redir for '>':
the
the
ZTST_test: examining line:

Running test: Basic ksharray substitution
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
the
the
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  setopt shwordsplit
ZTST_getchunk: read code chunk:
  setopt shwordsplit
  print -l $foo ${bar}
  unsetopt shwordsplit
ZTST_test: examining line:
>the
ZTST_getredir: read redir for '>':
the
first
parameter
the
second
parameter
ZTST_test: examining line:

Running test: Basic shwordsplit option handling
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
the
first
parameter
the
second
parameter
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print $+foo ${+foo} $+notappearinginthistest ${+notappearinginthistest}
ZTST_getchunk: read code chunk:
  print $+foo ${+foo} $+notappearinginthistest ${+notappearinginthistest}
ZTST_test: examining line:
>1 1 0 0
ZTST_getredir: read redir for '>':
1 1 0 0
ZTST_test: examining line:

Running test: $+...
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
1 1 0 0
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  set1=set1v
ZTST_getchunk: read code chunk:
  set1=set1v
  null1=
  print ${set1:-set1d} ${set1-set2d} ${null1:-null1d} ${null1-null2d} x
  print ${unset1:-unset1d} ${unset1-unset2d} x
ZTST_test: examining line:
>set1v set1v null1d x
ZTST_getredir: read redir for '>':
set1v set1v null1d x
unset1d unset2d x
ZTST_test: examining line:

Running test: ${...:-...} and ${...-...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
set1v set1v null1d x
unset1d unset2d x
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  set2=irrelevant
ZTST_getchunk: read code chunk:
  set2=irrelevant
  print ${set1:=set1d} ${set2::=set2d}
  print $set2
  wasnull1=
  wasnull2=
  print ${wasnull1=wasnull1d} ${wasnull2:=wasnull2d}
  print $wasnull1 $wasnull2
ZTST_test: examining line:
>set1v set2d
ZTST_getredir: read redir for '>':
set1v set2d
set2d
wasnull2d
wasnull2d
ZTST_test: examining line:

Running test: ${...:=...}, ${...::=...}, ${...=...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
set1v set2d
set2d
wasnull2d
wasnull2d
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  (print ${set1:?okhere}; print ${unset1:?exiting1}; print not reached;)
ZTST_getchunk: read code chunk:
  (print ${set1:?okhere}; print ${unset1:?exiting1}; print not reached;)
  (print ${null1?okhere}; print ${null1:?exiting2}; print not reached;)
ZTST_test: examining line:
>set1v
ZTST_getredir: read redir for '>':
set1v

ZTST_test: examining line:
?ZTST_execchunk:2: unset1: exiting1
ZTST_getredir: read redir for '?':
ZTST_execchunk:2: unset1: exiting1
ZTST_execchunk:2: null1: exiting2
ZTST_test: examining line:

Running test: ${...:?...}, ${...?...}
ZTST_test: expecting status: 1
ZTST_execchunk: status 1
ZTST_test: test produced standard output:
set1v
ZTST_test: and standard error:
ZTST_execchunk:2: unset1: exiting1
ZTST_execchunk:2: null1: exiting2
Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print ${set1:+word1} ${set1+word2} ${null1:+word3} ${null1+word4}
ZTST_getchunk: read code chunk:
  print ${set1:+word1} ${set1+word2} ${null1:+word3} ${null1+word4}
  print ${unset1:+word5} ${unset1+word6}
ZTST_test: examining line:
>word1 word2 word4
ZTST_getredir: read redir for '>':
word1 word2 word4

ZTST_test: examining line:

Running test: ${...:+...}, ${...+...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
word1 word2 word4
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  str1='This is very boring indeed.'
ZTST_getchunk: read code chunk:
  str1='This is very boring indeed.'
  print ${str1#*s}
  print ${str1##*s}
  print $str1##s
ZTST_test: examining line:
> is very boring indeed.
ZTST_getredir: read redir for '>':
 is very boring indeed.
 very boring indeed.
This is very boring indeed.##s
ZTST_test: examining line:

Running test: ${...#...}, ${...##...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
 is very boring indeed.
 very boring indeed.
This is very boring indeed.##s
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  str2='If you'\''re reading this you should go and fix some bugs instead.'
ZTST_getchunk: read code chunk:
  str2='If you'\''re reading this you should go and fix some bugs instead.'
  print ${str2%d*}
  print ${str2%%d*}
ZTST_test: examining line:
>If you're reading this you should go and fix some bugs instea
ZTST_getredir: read redir for '>':
If you're reading this you should go and fix some bugs instea
If you're rea
ZTST_test: examining line:

Running test: ${...%...}, ${...%%...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
If you're reading this you should go and fix some bugs instea
If you're rea
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  str1='does match'
ZTST_getchunk: read code chunk:
  str1='does match'
  str2='does not match'
  print ${str1:#does * match}
  print ${str2:#does * match}
ZTST_test: examining line:
>does match
ZTST_getredir: read redir for '>':
does match

ZTST_test: examining line:

Running test: ${...:#...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
does match
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  array1=(arthur boldly claws dogs every fight)
ZTST_getchunk: read code chunk:
  array1=(arthur boldly claws dogs every fight)
  print ${array1:#[aeiou]*}
  print ${(M)array1:#[aeiou]*}
ZTST_test: examining line:
>boldly claws dogs fight
ZTST_getredir: read redir for '>':
boldly claws dogs fight
arthur every
ZTST_test: examining line:

Running test: ${...:#...}, ${(M)...:#...} with array
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
boldly claws dogs fight
arthur every
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  str1="$array1"
ZTST_getchunk: read code chunk:
  str1="$array1"
  print ${str1/[aeiou]*g/a braw bricht moonlicht nicht the nic}
  print ${(S)str1/[aeiou]*g/relishe}
ZTST_test: examining line:
>a braw bricht moonlicht nicht the nicht
ZTST_getredir: read redir for '>':
a braw bricht moonlicht nicht the nicht
relishes every fight
ZTST_test: examining line:

Running test: scalar ${.../.../...}, ${(S).../.../...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
a braw bricht moonlicht nicht the nicht
relishes every fight
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print ${array1/[aeiou]*/Y}
ZTST_getchunk: read code chunk:
  print ${array1/[aeiou]*/Y}
  print ${(S)array1/[aeiou]*/Y}
ZTST_test: examining line:
>Y bY clY dY Y fY
ZTST_getredir: read redir for '>':
Y bY clY dY Y fY
Yrthur bYldly clYws dYgs Yvery fYght
ZTST_test: examining line:

Running test: array ${.../.../...}, ${(S).../.../...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
Y bY clY dY Y fY
Yrthur bYldly clYws dYgs Yvery fYght
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  str1='o this is so, so so very dull'
ZTST_getchunk: read code chunk:
  str1='o this is so, so so very dull'
  print ${str1//o*/Please no}
  print ${(S)str1//o*/Please no}
ZTST_test: examining line:
>Please no
ZTST_getredir: read redir for '>':
Please no
Please no this is sPlease no, sPlease no sPlease no very dull
ZTST_test: examining line:

Running test: scalar ${...//.../...}, ${(S)...//.../...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
Please no
Please no this is sPlease no, sPlease no sPlease no very dull
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print ${array1//[aeiou]*/Y}
ZTST_getchunk: read code chunk:
  print ${array1//[aeiou]*/Y}
  print ${(S)array1//[aeiou]*/Y}
ZTST_test: examining line:
>Y bY clY dY Y fY
ZTST_getredir: read redir for '>':
Y bY clY dY Y fY
YrthYr bYldly clYws dYgs YvYry fYght
ZTST_test: examining line:

Running test: array ${...//.../...}, ${(S)...//.../...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
Y bY clY dY Y fY
YrthYr bYldly clYws dYgs YvYry fYght
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print ${array1:/[aeiou]*/expletive deleted}
ZTST_getchunk: read code chunk:
  print ${array1:/[aeiou]*/expletive deleted}
ZTST_test: examining line:
>expletive deleted boldly claws dogs expletive deleted fight
ZTST_getredir: read redir for '>':
expletive deleted boldly claws dogs expletive deleted fight
ZTST_test: examining line:

Running test: array ${...:/...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
expletive deleted boldly claws dogs expletive deleted fight
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  str1='twocubed'
ZTST_getchunk: read code chunk:
  str1='twocubed'
  array=(the number of protons in an oxygen nucleus)
  print $#str1 ${#str1} "$#str1 ${#str1}" $#array ${#array} "$#array ${#array}"
ZTST_test: examining line:
>8 8 8 8 8 8 8 8
ZTST_getredir: read redir for '>':
8 8 8 8 8 8 8 8
ZTST_test: examining line:

Running test: ${#...}, $#...
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
8 8 8 8 8 8 8 8
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  array=(once bitten twice shy)
ZTST_getchunk: read code chunk:
  array=(once bitten twice shy)
  print IF${array}THEN
  print IF${^array}THEN
ZTST_test: examining line:
>IFonce bitten twice shyTHEN
ZTST_getredir: read redir for '>':
IFonce bitten twice shyTHEN
IFonceTHEN IFbittenTHEN IFtwiceTHEN IFshyTHEN
ZTST_test: examining line:

Running test: basic ${^...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
IFonce bitten twice shyTHEN
IFonceTHEN IFbittenTHEN IFtwiceTHEN IFshyTHEN
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  # Quote ${array} here because {...,...} doesn't like unquoted spaces.
ZTST_getchunk: read code chunk:
  # Quote ${array} here because {...,...} doesn't like unquoted spaces.
  print IF{"${array}",THEN}ELSE
  print IF{${^array},THEN}ELSE
ZTST_test: examining line:
>IFonce bitten twice shyELSE IFTHENELSE
ZTST_getredir: read redir for '>':
IFonce bitten twice shyELSE IFTHENELSE
IFonceELSE IFTHENELSE IFbittenELSE IFTHENELSE IFtwiceELSE IFTHENELSE IFshyELSE IFTHENELSE
ZTST_test: examining line:

Running test: combined ${^...} and {...,...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
IFonce bitten twice shyELSE IFTHENELSE
IFonceELSE IFTHENELSE IFbittenELSE IFTHENELSE IFtwiceELSE IFTHENELSE IFshyELSE IFTHENELSE
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  str1='one word'
ZTST_getchunk: read code chunk:
  str1='one word'
  print -l $str1 ${=str1} "split ${=str1}wise"
ZTST_test: examining line:
>one word
ZTST_getredir: read redir for '>':
one word
one
word
split one
wordwise
ZTST_test: examining line:

Running test: ${=...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
one word
one
word
split one
wordwise
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  str1='*'
ZTST_getchunk: read code chunk:
  str1='*'
  print $str1 ${~str1} $~str1
  setopt globsubst
  print $str1
  unsetopt globsubst
ZTST_test: examining line:
>* boringfile evenmoreboringfile boringfile evenmoreboringfile
ZTST_getredir: read redir for '>':
* boringfile evenmoreboringfile boringfile evenmoreboringfile
boringfile evenmoreboringfile
ZTST_test: examining line:

Running test: ${~...} and globsubst
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
* boringfile evenmoreboringfile boringfile evenmoreboringfile
boringfile evenmoreboringfile
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print -l "${$(print one word)}" "${=$(print two words)}"
ZTST_getchunk: read code chunk:
  print -l "${$(print one word)}" "${=$(print two words)}"
ZTST_test: examining line:
>one word
ZTST_getredir: read redir for '>':
one word
two
words
ZTST_test: examining line:

Running test: splitting of $(...) inside ${...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
one word
two
words
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print -l "${(f)$(print first line\\nsecond line\\nthird line)}"
ZTST_getchunk: read code chunk:
  print -l "${(f)$(print first line\\nsecond line\\nthird line)}"
ZTST_test: examining line:
>first line
ZTST_getredir: read redir for '>':
first line
second line
third line
ZTST_test: examining line:

Running test: ${(f)$(...)}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
first line
second line
third line
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print -l ${(A)newarray=splitting by numbers}
ZTST_getchunk: read code chunk:
  print -l ${(A)newarray=splitting by numbers}
  print -l ${(A)=newarray::=splitting by spaces, actually}
ZTST_test: examining line:
>splitting by numbers
ZTST_getredir: read redir for '>':
splitting by numbers
splitting
by
spaces,
actually
ZTST_test: examining line:

Running test: ${(A)...=...}, ${(A)...::=...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
splitting by numbers
splitting
by
spaces,
actually
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  newarray=("split me" "split me" "I\'m yours")
ZTST_getchunk: read code chunk:
  newarray=("split me" "split me" "I\'m yours")
  print -l "${(@)newarray}"
ZTST_test: examining line:
>split me
ZTST_getredir: read redir for '>':
split me
split me
I'm yours
ZTST_test: examining line:

Running test: "${(@)...}"
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
split me
split me
I'm yours
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  foo='$(print Howzat)'
ZTST_getchunk: read code chunk:
  foo='$(print Howzat)'
  print ${(e)foo}
ZTST_test: examining line:
>Howzat
ZTST_getredir: read redir for '>':
Howzat
ZTST_test: examining line:

Running test: ${(e)...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
Howzat
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  foo='I'\''m nearly out of my mind with tedium'
ZTST_getchunk: read code chunk:
  foo='I'\''m nearly out of my mind with tedium'
  bar=foo
  print ${(P)bar}
ZTST_test: examining line:
>I'm nearly out of my mind with tedium
ZTST_getredir: read redir for '>':
I'm nearly out of my mind with tedium
ZTST_test: examining line:

Running test: ${(P)...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
I'm nearly out of my mind with tedium
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  foo=(I could be watching that programme I recorded)
ZTST_getchunk: read code chunk:
  foo=(I could be watching that programme I recorded)
  print ${(o)foo}
  print ${(oi)foo}
  print ${(O)foo}
  print ${(Oi)foo}
ZTST_test: examining line:
>I I be could programme recorded that watching
ZTST_getredir: read redir for '>':
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
ZTST_test: examining line:

Running test: ${(o)...}, ${(O)...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
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
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  foo=(yOU KNOW, THE ONE WITH wILLIAM dALRYMPLE)
ZTST_getchunk: read code chunk:
  foo=(yOU KNOW, THE ONE WITH wILLIAM dALRYMPLE)
  bar=(doing that tour of India.)
  print ${(L)foo}
  print ${(U)bar}
ZTST_test: examining line:
>you know, the one with william dalrymple
ZTST_getredir: read redir for '>':
you know, the one with william dalrymple
DOING THAT TOUR OF INDIA.
ZTST_test: examining line:

Running test: ${(L)...}, ${(U)...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
you know, the one with william dalrymple
DOING THAT TOUR OF INDIA.
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  foo='instead here I am stuck by the computer'
ZTST_getchunk: read code chunk:
  foo='instead here I am stuck by the computer'
  print ${(C)foo}
ZTST_test: examining line:
>Instead Here I Am Stuck By The Computer
ZTST_getredir: read redir for '>':
Instead Here I Am Stuck By The Computer
ZTST_test: examining line:

Running test: ${(C)...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
Instead Here I Am Stuck By The Computer
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  foo=$'\x7f\x00'
ZTST_getchunk: read code chunk:
  foo=$'\x7f\x00'
  print ${(V)foo}
ZTST_test: examining line:
>^?^@
ZTST_getredir: read redir for '>':
^?^@
ZTST_test: examining line:

Running test: ${(V)...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
^?^@
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  foo='playing '\''stupid'\'' "games" \w\i\t\h $quoting.'
ZTST_getchunk: read code chunk:
  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}
ZTST_test: examining line:
>playing\ \'stupid\'\ \"games\"\ \\w\\i\\t\\h\ \$quoting.
ZTST_getredir: read redir for '>':
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.'
ZTST_test: examining line:

Running test: ${(q...)...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
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.'
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  foo="'and now' \"even the pubs\" \\a\\r\\e shut."
ZTST_getchunk: read code chunk:
  foo="'and now' \"even the pubs\" \\a\\r\\e shut."
  print -r ${(Q)foo}
ZTST_test: examining line:
>and now even the pubs are shut.
ZTST_getredir: read redir for '>':
and now even the pubs are shut.
ZTST_test: examining line:

Running test: ${(Q)...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
and now even the pubs are shut.
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  psvar=(dog)
ZTST_getchunk: read code chunk:
  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}
ZTST_test: examining line:
>It shouldn't $(happen) to a dog.
ZTST_getredir: read redir for '>':
It shouldn't $(happen) to a dog.
But what can you do?
ZTST_test: examining line:

Running test: ${(%)...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
It shouldn't $(happen) to a dog.
But what can you do?
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  foo='unmatched "'
ZTST_getchunk: read code chunk:
  foo='unmatched "'
  print ${(QX)foo}
ZTST_test: examining line:
?ZTST_execchunk:2: unmatched "
ZTST_getredir: read redir for '?':
ZTST_execchunk:2: unmatched "
ZTST_test: examining line:

Running test: ${(QX)...}
ZTST_test: expecting status: 1
ZTST_execchunk: status 1
ZTST_test: test produced standard output:

ZTST_test: and standard error:
ZTST_execchunk:2: unmatched "
Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  array=(characters in an array)
ZTST_getchunk: read code chunk:
  array=(characters in an array)
  print ${(c)#array}
ZTST_test: examining line:
>22
ZTST_getredir: read redir for '>':
22
ZTST_test: examining line:

Running test: ${(c)#...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
22
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print ${(w)#array}
ZTST_getchunk: read code chunk:
  print ${(w)#array}
  str='colon::bolon::solon'
  print ${(ws.:.)#str}
  print ${(Ws.:.)#str}
ZTST_test: examining line:
>4
ZTST_getredir: read redir for '>':
4
3
5
ZTST_test: examining line:

Running test: ${(w)...}, ${(W)...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
4
3
5
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  typeset -A assoc
ZTST_getchunk: read code chunk:
  typeset -A assoc
  assoc=(key1 val1 key2 val2)
  print ${(o)assoc}
  print ${(ok)assoc}
  print ${(ov)assoc}
  print ${(okv)assoc}
ZTST_test: examining line:
>val1 val2
ZTST_getredir: read redir for '>':
val1 val2
key1 key2
val1 val2
key1 key2 val1 val2
ZTST_test: examining line:

Running test: ${(k)...}, ${(v)...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
val1 val2
key1 key2
val1 val2
key1 key2 val1 val2
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  foo=(resulting words uproariously padded)
ZTST_getchunk: read code chunk:
  foo=(resulting words uproariously padded)
  print ${(pl.10..\x22..X.)foo}
ZTST_test: examining line:
>Xresulting """"Xwords roariously """Xpadded
ZTST_getredir: read redir for '>':
Xresulting """"Xwords roariously """Xpadded
ZTST_test: examining line:

Running test: ${(pl...)...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
Xresulting """"Xwords roariously """Xpadded
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  foo=(why in goodness name am I doing this)
ZTST_getchunk: read code chunk:
  foo=(why in goodness name am I doing this)
  print ${(r.5..!..?.)foo}
ZTST_test: examining line:
>why?! in?!! goodn name? am?!! I?!!! doing this?
ZTST_getredir: read redir for '>':
why?! in?!! goodn name? am?!! I?!!! doing this?
ZTST_test: examining line:

Running test: ${(r...)...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
why?! in?!! goodn name? am?!! I?!!! doing this?
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  array=(I\'m simply putting a brave face on)
ZTST_getchunk: read code chunk:
  array=(I\'m simply putting a brave face on)
  print ${(j:--:)array}
ZTST_test: examining line:
>I'm--simply--putting--a--brave--face--on
ZTST_getredir: read redir for '>':
I'm--simply--putting--a--brave--face--on
ZTST_test: examining line:

Running test: ${(j)...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
I'm--simply--putting--a--brave--face--on
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print ${(F)array}
ZTST_getchunk: read code chunk:
  print ${(F)array}
ZTST_test: examining line:
>I'm
ZTST_getredir: read redir for '>':
I'm
simply
putting
a
brave
face
on
ZTST_test: examining line:

Running test: ${(F)...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
I'm
simply
putting
a
brave
face
on
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  string='zometimez zis getz zplit on a z'
ZTST_getchunk: read code chunk:
  string='zometimez zis getz zplit on a z'
  print -l ${(s?z?)string}
ZTST_test: examining line:
>ometime
ZTST_getredir: read redir for '>':
ometime
 
is get
 
plit on a 
ZTST_test: examining line:

Running test: ${(s...)...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
ometime
 
is get
 
plit on a 
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  str=s
ZTST_getchunk: read code chunk:
  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}
ZTST_test: examining line:
>scalar array association-local integer-local float-local
ZTST_getredir: read redir for '>':
scalar array association-local integer-local float-local
ZTST_test: examining line:

Running test: ${(t)...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
scalar array association-local integer-local float-local
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  # it's not quite clear that these are actually right unless you know
ZTST_getchunk: read code chunk:
  # 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}
ZTST_test: examining line:
>wre is the white windmill, whispered walter wisely
ZTST_getredir: read redir for '>':
wre is the white windmill, whispered walter wisely
wly
where is the white windmill, wred walter wisely
where is the white windmill, wly
ZTST_test: examining line:

Running test: ${(S)...#...} etc.
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
wre is the white windmill, whispered walter wisely
wly
where is the white windmill, wred walter wisely
where is the white windmill, wly
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  setopt extendedglob
ZTST_getchunk: read code chunk:
  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:]]# }
ZTST_test: examining line:
>is the white windmill, whispered walter wisely
ZTST_getredir: read redir for '>':
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
ZTST_test: examining line:

Running test: ${(I:...:)...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
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
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print ${(MSI:1:)string##w[^[:space:]]# }
ZTST_getchunk: read code chunk:
  print ${(MSI:1:)string##w[^[:space:]]# }
ZTST_test: examining line:
>where 
ZTST_getredir: read redir for '>':
where 
ZTST_test: examining line:

Running test: ${(M...)...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
where 
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print ${(R)string//w[a-z]# #}
ZTST_getchunk: read code chunk:
  print ${(R)string//w[a-z]# #}
ZTST_test: examining line:
>is the , 
ZTST_getredir: read redir for '>':
is the , 
ZTST_test: examining line:

Running test: ${(R)...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
is the , 
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  # This (1) doesn't work with // or /
ZTST_getchunk: read code chunk:
  # 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}
ZTST_test: examining line:
>14 19
ZTST_getredir: read redir for '>':
14 19
ZTST_test: examining line:

Running test: ${(BE...)...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
14 19
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print ${(NS)string##white}
ZTST_getchunk: read code chunk:
  print ${(NS)string##white}
ZTST_test: examining line:
>5
ZTST_getredir: read redir for '>':
5
ZTST_test: examining line:

Running test: ${(N)...}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
5
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  string='abcdefghijklmnopqrstuvwxyz'
ZTST_getchunk: read code chunk:
  string='abcdefghijklmnopqrstuvwxyz'
  print ${${string%[aeiou]*}/(#m)?(#e)/${(U)MATCH}}
ZTST_test: examining line:
>abcdefghijklmnopqrsT
ZTST_getredir: read redir for '>':
abcdefghijklmnopqrsT
ZTST_test: examining line:

Running test: Rule 1:  Nested substitutions
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
abcdefghijklmnopqrsT
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  array=(et Swann avec cette muflerie intermittente)
ZTST_getchunk: read code chunk:
  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]}
ZTST_test: examining line:
>cette muflerie
ZTST_getredir: read redir for '>':
cette muflerie
cette
et
 r
 
ZTST_test: examining line:

Running test: Rule 2: Parameter subscripting
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
cette muflerie
cette
et
 r
 
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  foo=stringalongamax
ZTST_getchunk: read code chunk:
  foo=stringalongamax
  print ${${(P)foo[1,6]}[1,3]}
ZTST_test: examining line:
>qui
ZTST_getredir: read redir for '>':
qui
ZTST_test: examining line:

Running test: Rule 3: Parameter Name Replacement
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
qui
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print "${array[5,6]}"
ZTST_getchunk: read code chunk:
  print "${array[5,6]}"
  print "${(j.:.)array[1,2]}"
ZTST_test: examining line:
>muflerie intermittente
ZTST_getredir: read redir for '>':
muflerie intermittente
et:Swann
ZTST_test: examining line:

Running test: Rule 4: Double-Quoted Joining
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
muflerie intermittente
et:Swann
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print "${${array}[5,7]}"
ZTST_getchunk: read code chunk:
  print "${${array}[5,7]}"
  print "${${(@)array}[1,2]}"
ZTST_test: examining line:
>wan
ZTST_getredir: read redir for '>':
wan
et Swann
ZTST_test: examining line:

Running test: Rule 5: Nested Subscripting
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
wan
et Swann
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print "${${(@)array}[1,2]#?}"
ZTST_getchunk: read code chunk:
  print "${${(@)array}[1,2]#?}"
  print "${(@)${(@)array}[1,2]#?}"
ZTST_test: examining line:
>t Swann
ZTST_getredir: read redir for '>':
t Swann
t wann
ZTST_test: examining line:

Running test: Rule 6: Modifiers
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
t Swann
t wann
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  array=(she sells z shells by the z shore)
ZTST_getchunk: read code chunk:
  array=(she sells z shells by the z shore)
  (IFS='+'; print ${(s.s.)array})
ZTST_test: examining line:
>he+ ell +z+ hell +by+the+z+ hore
ZTST_getredir: read redir for '>':
he+ ell +z+ hell +by+the+z+ hore
ZTST_test: examining line:

Running test: Rule 7: Forced Joining, and 8: Forced splitting
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
he+ ell +z+ hell +by+the+z+ hore
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  setopt shwordsplit
ZTST_getchunk: read code chunk:
  setopt shwordsplit
  string='another poxy boring string'
  print -l ${${string}/o/ }
  unsetopt shwordsplit
ZTST_test: examining line:
>an
ZTST_getredir: read redir for '>':
an
ther
p
xy
b
ring
string
ZTST_test: examining line:

Running test: Rule 9: Shell Word Splitting
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
an
ther
p
xy
b
ring
string
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  setopt nonomatch
ZTST_getchunk: read code chunk:
  setopt nonomatch
  foo='b* e*'
  print ${(e)~foo}
  print ${(e)~=foo}
ZTST_test: examining line:
>b* e*
ZTST_getredir: read redir for '>':
b* e*
boringfile evenmoreboringfile
ZTST_test: examining line:

Running test: Rule 10: Re-Evaluation
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
b* e*
boringfile evenmoreboringfile
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  # ${bar} -> $bar  here would yield "bad substitution".
ZTST_getchunk: read code chunk:
  # ${bar} -> $bar  here would yield "bad substitution".
  bar=confinement
  print ${(el.20..X.)${bar}}
ZTST_test: examining line:
>XXXXXXXXXconfinement
ZTST_getredir: read redir for '>':
XXXXXXXXXconfinement
ZTST_test: examining line:

Running test: Rule 11: Padding
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
XXXXXXXXXconfinement
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  foo=(bar baz)
ZTST_getchunk: read code chunk:
  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*}
ZTST_test: examining line:
>b
ZTST_getredir: read redir for '>':
b
bar
a
1 b
1
a
1
b
1
a
 b
ZTST_test: examining line:

Running test: Examples in manual on parameter expansion
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
b
bar
a
1 b
1
a
1
b
1
a
 b
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  set If "this test fails" "we have broken" the shell again
ZTST_getchunk: read code chunk:
  set If "this test fails" "we have broken" the shell again
  print -l ${1+"$@"}
ZTST_test: examining line:
>If
ZTST_getredir: read redir for '>':
If
this test fails
we have broken
the
shell
again
ZTST_test: examining line:

Running test: Regression test of ${1+"$@"} bug
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
If
this test fails
we have broken
the
shell
again
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  set If "this test fails" "we have broken" the shell again
ZTST_getchunk: read code chunk:
  set If "this test fails" "we have broken" the shell again
  print -l "${(A)foo::=$@}"
  print -l $foo
ZTST_test: examining line:
>If this test fails we have broken the shell again
ZTST_getredir: read redir for '>':
If this test fails we have broken the shell again
If
this test fails
we have broken
the
shell
again
ZTST_test: examining line:

Running test: Regression test of "${(A)foo=$@}" bug
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
If this test fails we have broken the shell again
If
this test fails
we have broken
the
shell
again
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  set If "this test fails" maybe "we have finally fixed" the shell
ZTST_getchunk: read code chunk:
  set If "this test fails" maybe "we have finally fixed" the shell
  print -l ${=1+"$@"}
ZTST_test: examining line:
>If
ZTST_getredir: read redir for '>':
If
this
test
fails
maybe
we
have
finally
fixed
the
shell
ZTST_test: examining line:

Running test: Regression test of unfixed ${=1+"$@"} bug
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
If
this
test
fails
maybe
we
have
finally
fixed
the
shell
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  unset SHLVL
ZTST_getchunk: read code chunk:
  unset SHLVL
  (( SHLVL++ ))
  print $SHLVL
ZTST_test: examining line:
>1
ZTST_getredir: read redir for '>':
1
ZTST_test: examining line:

Running test: Unsetting and recreation of numerical special parameters
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
1
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  unset manpath
ZTST_getchunk: read code chunk:
  unset manpath
  print $+MANPATH
  manpath=(/here /there)
  print $MANPATH
  unset MANPATH
  print $+manpath
  MANPATH=/elsewhere:/somewhere
  print $manpath
ZTST_test: examining line:
>0
ZTST_getredir: read redir for '>':
0
/here:/there
0
/elsewhere /somewhere
ZTST_test: examining line:

Running test: Unsetting and recreation of tied special parameters
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
0
/here:/there
0
/elsewhere /somewhere
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: all tests successful
../../zsh-4.0.1-pre-5/Test/D04parameter.ztst: all tests successful.
../../zsh-4.0.1-pre-5/Test/D05array.ztst: starting.
ZTST_getsect: read section name: prep
ZTST_getchunk: read code chunk:
  foo=(a b c d e f g)
  mkdir array.tmp
  touch array.tmp/{1..9}
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:

ZTST_getsect: read section name: test
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  echo .$foo[1].
ZTST_getchunk: read code chunk:
  echo .$foo[1].
ZTST_test: examining line:
>.a.
ZTST_getredir: read redir for '>':
.a.
ZTST_test: examining line:

Running test: The first element
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
.a.
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  echo .$foo[1,4].
ZTST_getchunk: read code chunk:
  echo .$foo[1,4].
ZTST_test: examining line:
>.a b c d.
ZTST_getredir: read redir for '>':
.a b c d.
ZTST_test: examining line:

Running test: Normal multi-item indexing
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
.a b c d.
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  echo .$foo[1,0].
ZTST_getchunk: read code chunk:
  echo .$foo[1,0].
ZTST_test: examining line:
>..
ZTST_getredir: read redir for '>':
..
ZTST_test: examining line:

Running test: This should be empty
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
..
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  echo .$foo[4,1].
ZTST_getchunk: read code chunk:
  echo .$foo[4,1].
ZTST_test: examining line:
>..
ZTST_getredir: read redir for '>':
..
ZTST_test: examining line:

Running test: Another empty slice
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
..
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  echo .$foo[1,-8].
ZTST_getchunk: read code chunk:
  echo .$foo[1,-8].
ZTST_test: examining line:
>..
ZTST_getredir: read redir for '>':
..
ZTST_test: examining line:

Running test: An empty slice with a negative end
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
..
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  echo .$foo[0].
ZTST_getchunk: read code chunk:
  echo .$foo[0].
ZTST_test: examining line:
>.a.
ZTST_getredir: read redir for '>':
.a.
ZTST_test: examining line:

Running test: Treat 0 like 1
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
.a.
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  echo .$foo[0,0].
ZTST_getchunk: read code chunk:
  echo .$foo[0,0].
ZTST_test: examining line:
>.a.
ZTST_getredir: read redir for '>':
.a.
ZTST_test: examining line:

Running test: Treat 0,0 like 1,1.
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
.a.
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  echo .$foo[0,1].
ZTST_getchunk: read code chunk:
  echo .$foo[0,1].
ZTST_test: examining line:
>.a.
ZTST_getredir: read redir for '>':
.a.
ZTST_test: examining line:

Running test: Another weird way to access the first element
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
.a.
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  echo .$foo[3].
ZTST_getchunk: read code chunk:
  echo .$foo[3].
ZTST_test: examining line:
>.c.
ZTST_getredir: read redir for '>':
.c.
ZTST_test: examining line:

Running test: An inner element
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
.c.
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  echo .$foo[2,2].
ZTST_getchunk: read code chunk:
  echo .$foo[2,2].
ZTST_test: examining line:
>.b.
ZTST_getredir: read redir for '>':
.b.
ZTST_test: examining line:

Running test: Another inner element
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
.b.
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  echo .$foo[2,-4].
ZTST_getchunk: read code chunk:
  echo .$foo[2,-4].
ZTST_test: examining line:
>.b c d.
ZTST_getredir: read redir for '>':
.b c d.
ZTST_test: examining line:

Running test: A slice with a negative end
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
.b c d.
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  echo .$foo[-4,5].
ZTST_getchunk: read code chunk:
  echo .$foo[-4,5].
ZTST_test: examining line:
>.d e.
ZTST_getredir: read redir for '>':
.d e.
ZTST_test: examining line:

Running test: A slice with a negative start
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
.d e.
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  echo .$foo[-6,-2].
ZTST_getchunk: read code chunk:
  echo .$foo[-6,-2].
ZTST_test: examining line:
>.b c d e f.
ZTST_getredir: read redir for '>':
.b c d e f.
ZTST_test: examining line:

Running test: A slice with a negative start and end
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
.b c d e f.
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  setopt ksh_arrays
ZTST_getchunk: read code chunk:
  setopt ksh_arrays
  echo .${foo[1,2]}.
  unsetopt ksh_arrays
ZTST_test: examining line:
>.b c.
ZTST_getredir: read redir for '>':
.b c.
ZTST_test: examining line:

Running test: Ksh array indexing
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
.b c.
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  setopt ksh_arrays
ZTST_getchunk: read code chunk:
  setopt ksh_arrays
  echo .${foo[0,1]}.
  unsetopt ksh_arrays
ZTST_test: examining line:
>.a b.
ZTST_getredir: read redir for '>':
.a b.
ZTST_test: examining line:

Running test: Ksh array indexing (ii)
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
.a b.
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  setopt ksh_arrays
ZTST_getchunk: read code chunk:
  setopt ksh_arrays
  echo .${foo[1,-1]}.
  unsetopt ksh_arrays
ZTST_test: examining line:
>.b c d e f g.
ZTST_getredir: read redir for '>':
.b c d e f g.
ZTST_test: examining line:

Running test: Ksh array indexing (iii)
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
.b c d e f g.
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  cd array.tmp
ZTST_getchunk: read code chunk:
  cd array.tmp
  echo . ?([3,5]) .
  cd ..
ZTST_test: examining line:
>. 3 4 5 .
ZTST_getredir: read redir for '>':
. 3 4 5 .
ZTST_test: examining line:

Running test: Glob array indexing
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
. 3 4 5 .
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  cd array.tmp
ZTST_getchunk: read code chunk:
  cd array.tmp
  echo . ?([2,-2]) .
  cd ..
ZTST_test: examining line:
>. 2 3 4 5 6 7 8 .
ZTST_getredir: read redir for '>':
. 2 3 4 5 6 7 8 .
ZTST_test: examining line:

Running test: Glob array indexing (ii)
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
. 2 3 4 5 6 7 8 .
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  cd array.tmp
ZTST_getchunk: read code chunk:
  cd array.tmp
  echo . ?([-6,-4]) .
  cd ..
ZTST_test: examining line:
>. 4 5 6 .
ZTST_getredir: read redir for '>':
. 4 5 6 .
ZTST_test: examining line:

Running test: Glob array indexing (iii)
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
. 4 5 6 .
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: all tests successful
../../zsh-4.0.1-pre-5/Test/D05array.ztst: all tests successful.
../../zsh-4.0.1-pre-5/Test/D06subscript.ztst: starting.
ZTST_getsect: read section name: prep
ZTST_getchunk: read code chunk:
  s='Twinkle, twinkle, little *, [how] I [wonder] what?  You are!'
  a=('1' ']'  '?' '\2'  '\]' '\?'  '\\3' '\\]'  '\\?' '\\\4'  '\\\]' '\\\?')
  typeset -g -A A
  A=($a)
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:

ZTST_getsect: read section name: test
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  x=','
ZTST_getchunk: read code chunk:
  x=','
  print $s[(i)winkle] $s[(I)winkle]
  print ${s[(i)You are]} $#s
  print ${s[(r)$x,(R)$x]}
ZTST_test: examining line:
>2 11
ZTST_getredir: read redir for '>':
2 11
53 60
, twinkle, little *,
ZTST_test: examining line:

Running test: Scalar pattern subscripts without wildcards
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
2 11
53 60
, twinkle, little *,
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  x='*'
ZTST_getchunk: read code chunk:
  x='*'
  print $s[(i)*] $s[(i)\*] $s[(i)$x*] $s[(i)${(q)x}*] $s[(I)$x\*]
  print $s[(r)?,(R)\?] $s[(r)\?,(R)?]
  print $s[(r)\*,(R)*]
  print $s[(r)\],(R)\[]
ZTST_test: examining line:
>1 26 1 26 26
ZTST_getredir: read redir for '>':
1 26 1 26 26
Twinkle, twinkle, little *, [how] I [wonder] what? ?  You are!
*, [how] I [wonder] what?  You are!
] I [
ZTST_test: examining line:

Running test: Scalar pattern subscripts with wildcards
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
1 26 1 26 26
Twinkle, twinkle, little *, [how] I [wonder] what? ?  You are!
*, [how] I [wonder] what?  You are!
] I [
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  # $s[(R)x] actually is $s[0], but zsh treats 0 as 1 for subscripting.
ZTST_getchunk: read code chunk:
  # $s[(R)x] actually is $s[0], but zsh treats 0 as 1 for subscripting.
  print $s[(i)x] : $s[(I)x]
  print $s[(r)x] : $s[(R)x]
ZTST_test: examining line:
>61 : 0
ZTST_getredir: read redir for '>':
61 : 0
: T
ZTST_test: examining line:

Running test: Scalar pattern subscripts that do not match
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
61 : 0
: T
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print -R $s[$s[(i)\[]] $s[(i)$s[(r)\*]] $s[(i)${(q)s[(r)\]]}]
ZTST_getchunk: read code chunk:
  print -R $s[$s[(i)\[]] $s[(i)$s[(r)\*]] $s[(i)${(q)s[(r)\]]}]
ZTST_test: examining line:
>[ 1 33
ZTST_getredir: read redir for '>':
[ 1 33
ZTST_test: examining line:

Running test: Scalar subscripting using a pattern subscript to get the index
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
[ 1 33
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print -R $a[(r)?] $a[(R)?]
ZTST_getchunk: read code chunk:
  print -R $a[(r)?] $a[(R)?]
  print $a[(n:2:i)?] $a[(n:2:I)?]
  print $a[(i)\?] $a[(I)\?]
  print $a[(i)*] $a[(i)\*]
ZTST_test: examining line:
>1 ?
ZTST_getredir: read redir for '>':
1 ?
2 2
3 3
1 13
ZTST_test: examining line:

Running test: Array pattern subscripts
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
1 ?
2 2
3 3
1 13
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  # It'd be nice to do some of the following with (r), but we run into
ZTST_getchunk: read code chunk:
  # It'd be nice to do some of the following with (r), but we run into
  # limitations of the ztst script parsing of backslashes in the output.
  print -R $a[(i)\\\\?] $a[(i)\\\\\?]
  print -R $a[(i)\\\\\\\\?] $a[(i)\\\\\\\\\?]
  print -R ${a[(i)\\\\\\\\?]} ${a[(i)\\\\\\\\\?]}
  print -R "$a[(i)\\\\\\\\?] $a[(i)\\\\\\\\\?]"
  print -R $a[(i)\]] $a[(i)\\\\\]] $a[(i)\\\\\\\\\]] $a[(i)\\\\\\\\\\\\\]]
  print -R $a[(i)${(q)a[5]}] $a[(i)${(q)a[8]}] $a[(i)${(q)a[11]}]
  print -R $a[(i)${a[3]}] $a[(i)${a[6]}] $a[(i)${a[9]}] $a[(i)${a[12]}]
ZTST_test: examining line:
>4 6
ZTST_getredir: read redir for '>':
4 6
7 9
7 9
7 9
2 5 8 11
5 8 11
1 3 4 6
ZTST_test: examining line:

Running test: Array pattern subscripts with multiple backslashes
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
4 6
7 9
7 9
7 9
2 5 8 11
5 8 11
1 3 4 6
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print -R $A[1] $A[?] $A[\\\\3] $A[\\\]]
ZTST_getchunk: read code chunk:
  print -R $A[1] $A[?] $A[\\\\3] $A[\\\]]
  print -R $A[$a[11]]
  print -R $A[${(q)a[5]}]
ZTST_test: examining line:
>] \2 \\] \?
ZTST_getredir: read redir for '>':
] \2 \\] \?
\\\?
\\\?
ZTST_test: examining line:

Running test: Associative array lookup (direct subscripting)
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
] \2 \\] \?
\\\?
\\\?
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  # The (o) is necessary here for predictable output ordering
ZTST_getchunk: read code chunk:
  # The (o) is necessary here for predictable output ordering
  print -R $A[(I)\?] ${(o)A[(I)?]}
  print -R $A[(i)\\\\\\\\3]
  print -R $A[(I)\\\\\\\\\?] ${(o)A[(I)\\\\\\\\?]}
ZTST_test: examining line:
>? 1 ?
ZTST_getredir: read redir for '>':
? 1 ?
\\3
\\? \\3 \\?
ZTST_test: examining line:

Running test: Associative array lookup (pattern subscripting)
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
? 1 ?
\\3
\\? \\3 \\?
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print -R $A[(R)\?] : ${(o)A[(R)?]}
ZTST_getchunk: read code chunk:
  print -R $A[(R)\?] : ${(o)A[(R)?]}
  print -R $A[(R)\\\\\?] ${(o)A[(R)\\\\?]} ${(o)A[(R)\\\\\?]}
  print -R ${(o)A[(R)\\\\\\\\\]]}
ZTST_test: examining line:
>: ]
ZTST_getredir: read redir for '>':
: ]
\? \2 \? \?
\\]
ZTST_test: examining line:

Running test: Associative array lookup (reverse subscripting)
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
: ]
\? \2 \? \?
\\]
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  eval 'A[*]=star'
ZTST_getchunk: read code chunk:
  eval 'A[*]=star'
ZTST_test: examining line:
?ZTST_execchunk:2: A: attempt to set slice of associative array
ZTST_getredir: read redir for '?':
ZTST_execchunk:2: A: attempt to set slice of associative array
ZTST_test: examining line:

Running test: Illegal associative array assignment
ZTST_test: expecting status: 1
ZTST_execchunk: status 1
ZTST_test: test produced standard output:

ZTST_test: and standard error:
ZTST_execchunk:2: A: attempt to set slice of associative array
Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  x='*'
ZTST_getchunk: read code chunk:
  x='*'
  A[$x]=xstar
  A[${(q)x}]=qxstar
  print -R ${(k)A[(r)xstar]} $A[$x]
  print -R ${(k)A[(r)qxstar]} $A[${(q)x}]
  A[(e)*]=star
  A[\*]=backstar
  print -R ${(k)A[(r)star]} $A[(e)*]
  print -R ${(k)A[(r)backstar]} $A[\*]
ZTST_test: examining line:
>* xstar
ZTST_getredir: read redir for '>':
* xstar
\* qxstar
* star
\* backstar
ZTST_test: examining line:

Running test: Associative array assignment
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
* xstar
\* qxstar
* star
\* backstar
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  o='['
ZTST_getchunk: read code chunk:
  o='['
  c=']'
  A[\]]=cbrack
  A[\[]=obrack
  A[\\\[]=backobrack
  A[\\\]]=backcbrack
  print -R $A[$o] $A[$c] $A[\[] $A[\]] $A[\\\[] $A[\\\]]
  print -R $A[(i)\[] $A[(i)\]] $A[(i)\\\\\[] $A[(i)\\\\\]]
ZTST_test: examining line:
>obrack cbrack obrack cbrack backobrack backcbrack
ZTST_getredir: read redir for '>':
obrack cbrack obrack cbrack backobrack backcbrack
[ ] \[ \]
ZTST_test: examining line:

Running test: Associative array keys with open and close brackets
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
obrack cbrack obrack cbrack backobrack backcbrack
[ ] \[ \]
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print -R $A[$o] $A[$s[(r)\[]]
ZTST_getchunk: read code chunk:
  print -R $A[$o] $A[$s[(r)\[]]
  print -R $A[(r)$c] $A[(r)$s[(r)\]]]
  print -R $A[$A[(i)\\\\\]]]
ZTST_test: examining line:
>obrack obrack
ZTST_getredir: read redir for '>':
obrack obrack
] ]
backcbrack
ZTST_test: examining line:

Running test: Associative array lookup using a pattern subscript to get the key
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
obrack obrack
] ]
backcbrack
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print -R ${A[${A[(r)\\\\\\\\\]]}]::=zounds}
ZTST_getchunk: read code chunk:
  print -R ${A[${A[(r)\\\\\\\\\]]}]::=zounds}
  print -R ${A[${A[(r)\\\\\\\\\]]}]}
  print -R $A[\\\\\]]
ZTST_test: examining line:
>zounds
ZTST_getredir: read redir for '>':
zounds
zounds
zounds
ZTST_test: examining line:

Running test: Associative array substitution-assignment with reverse pattern subscript key
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
zounds
zounds
zounds
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print -R ${(o)A[(K)\]]}
ZTST_getchunk: read code chunk:
  print -R ${(o)A[(K)\]]}
  print -R ${(o)A[(K)\\\]]}
ZTST_test: examining line:
>\2 backcbrack cbrack star
ZTST_getredir: read redir for '>':
\2 backcbrack cbrack star
\\\4 \\\? star zounds
ZTST_test: examining line:

Running test: Associative array keys interpreted as patterns
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
\2 backcbrack cbrack star
\\\4 \\\? star zounds
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  typeset "A[one\"two\"three\"quotes]"=QQQ
ZTST_getchunk: read code chunk:
  typeset "A[one\"two\"three\"quotes]"=QQQ
  typeset 'A[one\"two\"three\"quotes]'=qqq
  print -R "$A[one\"two\"three\"quotes]"
  print -R $A[one\"two\"three\"quotes]
  A[one"two"three"four"quotes]=QqQq
  print -R $A[one"two"three"four"quotes]
  print -R $A[$A[(i)one\"two\"three\"quotes]]
  print -R "$A[$A[(i)one\"two\"three\"quotes]]"
ZTST_test: examining line:
>QQQ
ZTST_getredir: read redir for '>':
QQQ
qqq
QqQq
qqq
QQQ
ZTST_test: examining line:

Running test: Associative array keys with double quotes
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
QQQ
qqq
QqQq
qqq
QQQ
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print ${x::=$A[$A[(i)one\"two\"three\"quotes]]}
ZTST_getchunk: read code chunk:
  print ${x::=$A[$A[(i)one\"two\"three\"quotes]]}
  print $x
  print ${x::="$A[$A[(i)one\"two\"three\"quotes]]"}
  print $x
ZTST_test: examining line:
>qqq
ZTST_getredir: read redir for '>':
qqq
qqq
QQQ
QQQ
ZTST_test: examining line:

Running test: More keys with double quotes, used in assignment-expansion
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
qqq
qqq
QQQ
QQQ
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  qqq=lower
ZTST_getchunk: read code chunk:
  qqq=lower
  QQQ=upper
  print ${(P)A[one\"two\"three\"quotes]}
  print "${(P)A[$A[(i)one\"two\"three\"quotes]]}"
ZTST_test: examining line:
>lower
ZTST_getredir: read redir for '>':
lower
upper
ZTST_test: examining line:

Running test: Keys with double quotes and the (P) expansion flag
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
lower
upper
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: all tests successful
../../zsh-4.0.1-pre-5/Test/D06subscript.ztst: all tests successful.
../../zsh-4.0.1-pre-5/Test/E01options.ztst: starting.
ZTST_getsect: read section name: prep
ZTST_getchunk: read code chunk:
  mkdir options.tmp && cd options.tmp
  mkdir tmpcd
  touch tmpfile1 tmpfile2
  mydir=$PWD
  catpath=$(which cat)
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:

ZTST_getsect: read section name: test
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  alias echo='print foo'
ZTST_getchunk: read code chunk:
  alias echo='print foo'
  unsetopt aliases
  # use eval else aliases are all parsed at start
  eval echo bar
  setopt aliases
  eval echo bar
  unalias echo
ZTST_test: examining line:
>bar
ZTST_getredir: read redir for '>':
bar
foo bar
ZTST_test: examining line:

Running test: ALIASES option
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
bar
foo bar
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  setopt allexport
ZTST_getchunk: read code chunk:
  setopt allexport
  testpm1=exported
  unsetopt allexport
  testpm2=unexported
  print ${(t)testpm1}
  print ${(t)testpm2}
ZTST_test: examining line:
>scalar-export
ZTST_getredir: read redir for '>':
scalar-export
scalar
ZTST_test: examining line:
  
Running test: ALL_EXPORT option
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
scalar-export
scalar
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:
  
ZTST_test: examining line:
  # Count the number of directories on the stack.  Don't care what they are.
ZTST_getchunk: read code chunk:
  # Count the number of directories on the stack.  Don't care what they are.
  dircount() { dirs -v | tail -1 | awk '{ print $1 + 1}'; }
  unsetopt autopushd
  cd tmpcd
  dircount
  cd ..
  setopt autopushd
  cd tmpcd
  dircount
  cd ..
  unsetopt autopushd
ZTST_test: examining line:
>1
ZTST_getredir: read redir for '>':
1
2
ZTST_test: examining line:

Running test: AUTO_PUSHD option
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
1
2
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  unsetopt badpattern
ZTST_getchunk: read code chunk:
  unsetopt badpattern
  print [a
  setopt badpattern
  print [b
ZTST_test: examining line:
>[a
ZTST_getredir: read redir for '>':
[a
ZTST_test: examining line:
?ZTST_execchunk:2: bad pattern: [b
ZTST_getredir: read redir for '?':
ZTST_execchunk:2: bad pattern: [b
ZTST_test: examining line:

Running test: BAD_PATTERN option
ZTST_test: expecting status: 1
ZTST_execchunk: status 1
ZTST_test: test produced standard output:
[a
ZTST_test: and standard error:
ZTST_execchunk:2: bad pattern: [b
Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  unsetopt bareglobqual nomatch
ZTST_getchunk: read code chunk:
  unsetopt bareglobqual nomatch
  print *(.)
  setopt bareglobqual nomatch
  print *(.)
ZTST_test: examining line:
>*(.)
ZTST_getredir: read redir for '>':
*(.)
tmpfile1 tmpfile2
ZTST_test: examining line:

Running test: BARE_GLOB_QUAL option
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
*(.)
tmpfile1 tmpfile2
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  setopt braceccl
ZTST_getchunk: read code chunk:
  setopt braceccl
  print {abcd}
  unsetopt braceccl
  print {abcd}
ZTST_test: examining line:
>a b c d
ZTST_getredir: read redir for '>':
a b c d
{abcd}
ZTST_test: examining line:

Running test: BRACE_CCL option
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
a b c d
{abcd}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  setopt bsdecho
ZTST_getchunk: read code chunk:
  setopt bsdecho
  echo "histon\nimpington"
  echo -e "girton\ncottenham"
  unsetopt bsdecho
  echo "newnham\ncomberton"
ZTST_test: examining line:
>histon\nimpington
ZTST_getredir: read redir for '>':
histon\nimpington
girton
cottenham
newnham
comberton
ZTST_test: examining line:

Running test: BSD_ECHO option
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
histon\nimpington
girton
cottenham
newnham
comberton
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  unsetopt c_bases
ZTST_getchunk: read code chunk:
  unsetopt c_bases
  print $(( [#16]15 ))
  print $(( [#8]9 ))
  setopt c_bases
  print $(( [#16]31 ))
  print $(( [#8]17 ))
  setopt octal_zeroes
  print $(( [#8]19 ))
  unsetopt c_bases octal_zeroes
ZTST_test: examining line:
>16#F
ZTST_getredir: read redir for '>':
16#F
8#11
0x1F
8#21
023
ZTST_test: examining line:

Running test: C_BASES option
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
16#F
8#11
0x1F
8#21
023
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  setopt cdablevars
ZTST_getchunk: read code chunk:
  setopt cdablevars
  # only absolute paths are eligible for ~-expansion
  cdablevar1=tmpcd
  (cd cdablevar1)
  cdablevar2=$PWD/tmpcd
  cd cdablevar2
  cd ..
  print back in ${PWD:t}
  unsetopt cdablevars
  cd cdablevar2
ZTST_test: examining line:
>`print -P '%~'`/tmpcd
ZTST_getredir: read redir for '>':
`print -P '%~'`/tmpcd
back in options.tmp
ZTST_test: examining line:
?ZTST_execchunk:cd:2: no such file or directory: cdablevar1
ZTST_getredir: read redir for '?':
ZTST_execchunk:cd:2: no such file or directory: cdablevar1
ZTST_execchunk:cd:2: no such file or directory: cdablevar2
ZTST_test: examining line:

Running test: CDABLE_VARS option
ZTST_test: expecting status: 1
ZTST_execchunk: status 1
ZTST_test: test produced standard output:
/tmp/obj-sun/Test/options.tmp/tmpcd
back in options.tmp
ZTST_test: and standard error:
ZTST_execchunk:cd:2: no such file or directory: cdablevar1
ZTST_execchunk:cd:2: no such file or directory: cdablevar2
Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:

ZTST_test: examining line:
  setopt noclobber
ZTST_getchunk: read code chunk:
  setopt noclobber
  rm -f foo1 bar1 rod1
  echo waterbeach >foo1
  (echo landbeach >foo1)
  cat foo1
  (echo lode >>bar1)
  [[ -f bar1 ]] && print That shouldn\'t be there.
  echo denny >rod1
  echo wicken >>rod1
  cat rod1
  unsetopt noclobber
  rm -f foo2 bar2 rod2
  echo ely >foo2
  echo march >foo2
  cat foo2
  echo wimpole >>bar2
  cat bar2
  echo royston >rod2
  echo foxton >>rod2
  cat rod2
  rm -f foo* bar* rod*
ZTST_test: examining line:
>waterbeach
ZTST_getredir: read redir for '>':
waterbeach
denny
wicken
march
wimpole
royston
foxton
ZTST_test: examining line:
?ZTST_execchunk:2: file exists: foo1
ZTST_getredir: read redir for '?':
ZTST_execchunk:2: file exists: foo1
ZTST_execchunk:2: no such file or directory: bar1
ZTST_test: examining line:

Running test: CLOBBER option
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
waterbeach
denny
wicken
march
wimpole
royston
foxton
ZTST_test: and standard error:
ZTST_execchunk:2: file exists: foo1
ZTST_execchunk:2: no such file or directory: bar1
Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
   setopt cshjunkieloops
ZTST_getchunk: read code chunk:
   setopt cshjunkieloops
   eval 'for f in swaffham bulbeck; print $f; end'
   print next one should fail >&2
   unsetopt cshjunkieloops
   eval 'for f in chesterton arbury; print $f; end'
ZTST_test: examining line:
>swaffham
ZTST_getredir: read redir for '>':
swaffham
bulbeck
ZTST_test: examining line:
?next one should fail
ZTST_getredir: read redir for '?':
next one should fail
ZTST_execchunk:-1: parse error near `end'
ZTST_test: examining line:

Running test: CSH_JUNKIE_LOOPS option (for loop)
ZTST_test: expecting status: 1
ZTST_execchunk: status 1
ZTST_test: test produced standard output:
swaffham
bulbeck
ZTST_test: and standard error:
next one should fail
ZTST_execchunk:-1: parse error near `end'
Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  setopt cshjunkiequotes
ZTST_getchunk: read code chunk:
  setopt cshjunkiequotes
  print this should cause an error >&2
  eval "print 'line one
  line two'"
  print this should not >&2
  eval "print 'line three\\
  line four'"
  unsetopt cshjunkiequotes
ZTST_test: examining line:
>line three
ZTST_getredir: read redir for '>':
line three
  line four
ZTST_test: examining line:
?this should cause an error
ZTST_getredir: read redir for '?':
this should cause an error
ZTST_execchunk:-1: unmatched '
this should not
ZTST_test: examining line:

Running test: CSH_JUNKIE_QUOTES option
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line three
  line four
ZTST_test: and standard error:
this should cause an error
ZTST_execchunk:-1: unmatched '
this should not
Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  nullcmd() { print '$NULLCMD run'; }
ZTST_getchunk: read code chunk:
  nullcmd() { print '$NULLCMD run'; }
  readnullcmd() { print 'Running $READNULLCMD'; cat; }
  NULLCMD=nullcmd
  READNULLCMD=readnullcmd
  setopt cshnullcmd
  rm -f foo
  print "This should fail" >&2
  (>foo)
  print "This should succeed" >&2
  print "These are the contents of foo" >foo
  cat foo
  print "This should also fail" >&2
  (<foo)
  unsetopt cshnullcmd
  rm -f foo
  >foo
  <foo
  rm -f foo
ZTST_test: examining line:
>These are the contents of foo
ZTST_getredir: read redir for '>':
These are the contents of foo
Running $READNULLCMD
$NULLCMD run
ZTST_test: examining line:
?This should fail
ZTST_getredir: read redir for '?':
This should fail
ZTST_execchunk:2: redirection with no command
This should succeed
This should also fail
ZTST_execchunk:2: redirection with no command
ZTST_test: examining line:

Running test: CSH_NULL_CMD option
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
These are the contents of foo
Running $READNULLCMD
$NULLCMD run
ZTST_test: and standard error:
This should fail
ZTST_execchunk:2: redirection with no command
This should succeed
This should also fail
ZTST_execchunk:2: redirection with no command
Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  setopt nomatch cshnullglob
ZTST_getchunk: read code chunk:
  setopt nomatch cshnullglob
  print tmp* nothing* blah
  print -n 'hoping for no match: ' >&2
  (print nothing* blah)
  print >&2
  unsetopt cshnullglob nomatch
  print tmp* nothing* blah
  print nothing* blah
ZTST_test: examining line:
>tmpcd tmpfile1 tmpfile2 blah
ZTST_getredir: read redir for '>':
tmpcd tmpfile1 tmpfile2 blah
tmpcd tmpfile1 tmpfile2 nothing* blah
nothing* blah
ZTST_test: examining line:
?hoping for no match: ZTST_execchunk:2: no match
ZTST_getredir: read redir for '?':
hoping for no match: ZTST_execchunk:2: no match

ZTST_test: examining line:

Running test: CSH_NULL_GLOB option
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
tmpcd tmpfile1 tmpfile2 blah
tmpcd tmpfile1 tmpfile2 nothing* blah
nothing* blah
ZTST_test: and standard error:
hoping for no match: ZTST_execchunk:2: no match
Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  setopt NO_equals
ZTST_getchunk: read code chunk:
  setopt NO_equals
  print -n trick; print =cat
  setopt equals
  print -n trick; print =cat
ZTST_test: examining line:
>trick=cat
ZTST_getredir: read redir for '>':
trick=cat
trick$catpath
ZTST_test: examining line:

Running test: EQUALS option
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
trick=cat
trick/usr/bin/cat
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  TRAPZERR() { print ZERR trapped; }
ZTST_getchunk: read code chunk:
  TRAPZERR() { print ZERR trapped; }
  testfn() { setopt localoptions $2; print $1 before; false; print $1 after; }
  (testfn on errexit)
  testfn off
  unfunction TRAPZERR testfn
ZTST_test: examining line:
>on before
ZTST_getredir: read redir for '>':
on before
ZERR trapped
ZERR trapped
off before
ZERR trapped
off after
ZTST_test: examining line:

Running test: ERR_EXIT option
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
on before
ZERR trapped
ZERR trapped
off before
ZERR trapped
off after
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  (print before; setopt noexec; print after)
ZTST_getchunk: read code chunk:
  (print before; setopt noexec; print after)
ZTST_test: examining line:
>before
ZTST_getredir: read redir for '>':
before
ZTST_test: examining line:

Running test: NO_EXEC option
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
before
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  # The EXTENDED_GLOB test doesn't test globbing fully --- it just tests
ZTST_getchunk: read code chunk:
  # The EXTENDED_GLOB test doesn't test globbing fully --- it just tests
  # that certain patterns are treated literally with the option off
  # and as patterns with the option on.
  testfn() { print -n "$1 $2 $3 "; if [[ $1 = ${~2} ]];
             then print yes; else print no; fi; }
  tests=('a#' '?~b' '^aa')
  strings=('a' 'aa' 'b' 'a#' '?~b' '^aa')
  for opt in noextendedglob extendedglob; do
    setopt $opt
    for test in $tests; do
      for string in $strings; do
         testfn $string $test $opt
      done
    done
  done
ZTST_test: examining line:
>a a# noextendedglob no
ZTST_getredir: read redir for '>':
a a# noextendedglob no
aa a# noextendedglob no
b a# noextendedglob no
a# a# noextendedglob yes
?~b a# noextendedglob no
^aa a# noextendedglob no
a ?~b noextendedglob no
aa ?~b noextendedglob no
b ?~b noextendedglob no
a# ?~b noextendedglob no
?~b ?~b noextendedglob yes
^aa ?~b noextendedglob no
a ^aa noextendedglob no
aa ^aa noextendedglob no
b ^aa noextendedglob no
a# ^aa noextendedglob no
?~b ^aa noextendedglob no
^aa ^aa noextendedglob yes
a a# extendedglob yes
aa a# extendedglob yes
b a# extendedglob no
a# a# extendedglob no
?~b a# extendedglob no
^aa a# extendedglob no
a ?~b extendedglob yes
aa ?~b extendedglob no
b ?~b extendedglob no
a# ?~b extendedglob no
?~b ?~b extendedglob no
^aa ?~b extendedglob no
a ^aa extendedglob yes
aa ^aa extendedglob no
b ^aa extendedglob yes
a# ^aa extendedglob yes
?~b ^aa extendedglob yes
^aa ^aa extendedglob yes
ZTST_test: examining line:

Running test: EXTENDED_GLOB option
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
a a# noextendedglob no
aa a# noextendedglob no
b a# noextendedglob no
a# a# noextendedglob yes
?~b a# noextendedglob no
^aa a# noextendedglob no
a ?~b noextendedglob no
aa ?~b noextendedglob no
b ?~b noextendedglob no
a# ?~b noextendedglob no
?~b ?~b noextendedglob yes
^aa ?~b noextendedglob no
a ^aa noextendedglob no
aa ^aa noextendedglob no
b ^aa noextendedglob no
a# ^aa noextendedglob no
?~b ^aa noextendedglob no
^aa ^aa noextendedglob yes
a a# extendedglob yes
aa a# extendedglob yes
b a# extendedglob no
a# a# extendedglob no
?~b a# extendedglob no
^aa a# extendedglob no
a ?~b extendedglob yes
aa ?~b extendedglob no
b ?~b extendedglob no
a# ?~b extendedglob no
?~b ?~b extendedglob no
^aa ?~b extendedglob no
a ^aa extendedglob yes
aa ^aa extendedglob no
b ^aa extendedglob yes
a# ^aa extendedglob yes
?~b ^aa extendedglob yes
^aa ^aa extendedglob yes
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  foo() { print My name is $0; }
ZTST_getchunk: read code chunk:
  foo() { print My name is $0; }
  unsetopt functionargzero
  foo
  setopt functionargzero
  foo
  unfunction foo
ZTST_test: examining line:
>My name is ZTST_execchunk
ZTST_getredir: read redir for '>':
My name is ZTST_execchunk
My name is foo
ZTST_test: examining line:

Running test: FUNCTION_ARGZERO option
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
My name is ZTST_execchunk
My name is foo
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  setopt _NO_glob_
ZTST_getchunk: read code chunk:
  setopt _NO_glob_
  print tmp*
  set -o glob
  print tmp*
ZTST_test: examining line:
>tmp*
ZTST_getredir: read redir for '>':
tmp*
tmpcd tmpfile1 tmpfile2
ZTST_test: examining line:

Running test: GLOB option
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
tmp*
tmpcd tmpfile1 tmpfile2
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  showit() { local v;
ZTST_getchunk: read code chunk:
  showit() { local v;
             for v in first second third; do
               eval print \$$v \$\{\(t\)$v\}
	     done;
           }      
  setit() { typeset -x first=inside1;
            typeset +g -x second=inside2;
            typeset -g -x third=inside3;
            showit;
          }
  first=outside1 second=outside2 third=outside3
  unsetopt globalexport
  setit
  showit
  setopt globalexport
  setit
  showit
  unfunction setit showit
ZTST_test: examining line:
>inside1 scalar-local-export
ZTST_getredir: read redir for '>':
inside1 scalar-local-export
inside2 scalar-local-export
inside3 scalar-export
outside1 scalar
outside2 scalar
inside3 scalar-export
inside1 scalar-export
inside2 scalar-local-export
inside3 scalar-export
inside1 scalar-export
outside2 scalar
inside3 scalar-export
ZTST_test: examining line:

Running test: GLOBAL_EXPORT option
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
inside1 scalar-local-export
inside2 scalar-local-export
inside3 scalar-export
outside1 scalar
outside2 scalar
inside3 scalar-export
inside1 scalar-export
inside2 scalar-local-export
inside3 scalar-export
inside1 scalar-export
outside2 scalar
inside3 scalar-export
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  setopt globassign
ZTST_getchunk: read code chunk:
  setopt globassign
  foo=tmp*
  print $foo
  unsetopt globassign
  foo=tmp*
  print $foo
ZTST_test: examining line:
>tmpcd tmpfile1 tmpfile2
ZTST_getredir: read redir for '>':
tmpcd tmpfile1 tmpfile2
tmp*
ZTST_test: examining line:

Running test: GLOB_ASSIGN option
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
tmpcd tmpfile1 tmpfile2
tmp*
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  mkdir onlysomefiles
ZTST_getchunk: read code chunk:
  mkdir onlysomefiles
  touch onlysomefiles/.thisfile onlysomefiles/thatfile
  setopt globdots
  print onlysomefiles/*
  unsetopt globdots
  print onlysomefiles/*
  rm -rf onlysomefiles
ZTST_test: examining line:
>onlysomefiles/.thisfile onlysomefiles/thatfile
ZTST_getredir: read redir for '>':
onlysomefiles/.thisfile onlysomefiles/thatfile
onlysomefiles/thatfile
ZTST_test: examining line:

Running test: GLOB_DOTS option
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
onlysomefiles/.thisfile onlysomefiles/thatfile
onlysomefiles/thatfile
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  # we've tested this enough times already...
ZTST_getchunk: read code chunk:
  # we've tested this enough times already...
  # could add some stuff for other sorts of expansion
  foo='tmp*'
  setopt globsubst
  print ${foo}
  unsetopt globsubst
  print ${foo}
ZTST_test: examining line:
>tmpcd tmpfile1 tmpfile2
ZTST_getredir: read redir for '>':
tmpcd tmpfile1 tmpfile2
tmp*
ZTST_test: examining line:

Running test: GLOB_SUBST option
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
tmpcd tmpfile1 tmpfile2
tmp*
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  setopt ignorebraces
ZTST_getchunk: read code chunk:
  setopt ignorebraces
  echo X{a,b}Y
  unsetopt ignorebraces
  echo X{a,b}Y
ZTST_test: examining line:
>X{a,b}Y
ZTST_getredir: read redir for '>':
X{a,b}Y
XaY XbY
ZTST_test: examining line:

Running test: IGNORE_BRACES option
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
X{a,b}Y
XaY XbY
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  setopt ksh_arrays
ZTST_getchunk: read code chunk:
  setopt ksh_arrays
  array=(one two three)
  print $array $array[2]
  print ${array[0]} ${array[1]} ${array[2]} ${array[3]}
  unsetopt ksh_arrays
  print $array $array[2]
  print ${array[0]} ${array[1]} ${array[2]} ${array[3]}
  unset array
ZTST_test: examining line:
>one one[2]
ZTST_getredir: read redir for '>':
one one[2]
one two three
one two three two
one one two three
ZTST_test: examining line:

Running test: KSH_ARRAYS option
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
one one[2]
one two three
one two three two
one one two three
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  fpath=(.)
ZTST_getchunk: read code chunk:
  fpath=(.)
  echo >foo 'echo foo loaded; foo() { echo foo run; }'
  echo >bar 'bar() { echo bar run; }'
  setopt kshautoload
  autoload foo bar
  foo
  bar
  unfunction foo bar
  unsetopt kshautoload
  autoload foo bar
  foo
  bar
ZTST_test: examining line:
>foo loaded
ZTST_getredir: read redir for '>':
foo loaded
foo run
bar run
foo loaded
bar run
ZTST_test: examining line:

Running test: KSH_AUTOLOAD option
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
foo loaded
foo run
bar run
foo loaded
bar run
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:

ZTST_test: examining line:
  setopt kshoptionprint globassign
ZTST_getchunk: read code chunk:
  setopt kshoptionprint globassign
  print set
  setopt | grep kshoptionprint
  setopt | grep globassign
  unsetopt kshoptionprint
  print unset
  setopt | grep kshoptionprint
  setopt | grep globassign
  unsetopt globassign
ZTST_test: examining line:
>set
ZTST_getredir: read redir for '>':
set
kshoptionprint        on
globassign            on
unset
globassign
ZTST_test: examining line:

Running test: KSH_OPTION_PRINT option
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
set
kshoptionprint        on
globassign            on
unset
globassign
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  showopt() { setopt | egrep 'localoptions|ksharrays'; }
ZTST_getchunk: read code chunk:
  showopt() { setopt | egrep 'localoptions|ksharrays'; }
  f1() { setopt localoptions ksharrays; showopt }
  f2() { setopt ksharrays; showopt }
  setopt kshoptionprint
  showopt
  f1
  showopt
  f2
  showopt
  unsetopt ksh_arrays
ZTST_test: examining line:
>ksharrays             off
ZTST_getredir: read redir for '>':
ksharrays             off
localoptions          off
ksharrays             on
localoptions          on
ksharrays             off
localoptions          off
ksharrays             on
localoptions          off
ksharrays             on
localoptions          off
ZTST_test: examining line:

Running test: LOCAL_OPTIONS option
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
ksharrays             off
localoptions          off
ksharrays             on
localoptions          on
ksharrays             off
localoptions          off
ksharrays             on
localoptions          off
ksharrays             on
localoptions          off
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:

ZTST_test: examining line:
  fn() { local HOME=/any/old/name; print var=~ 'anything goes/here'=~; }
ZTST_getchunk: read code chunk:
  fn() { local HOME=/any/old/name; print var=~ 'anything goes/here'=~; }
  setopt magicequalsubst
  fn
  unsetopt magicequalsubst
  fn
ZTST_test: examining line:
>var=/any/old/name anything goes/here=/any/old/name
ZTST_getredir: read redir for '>':
var=/any/old/name anything goes/here=/any/old/name
var=~ anything goes/here=~
ZTST_test: examining line:

Running test: MAGIC_EQUAL_SUBST option
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
var=/any/old/name anything goes/here=/any/old/name
var=~ anything goes/here=~
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  setopt MARK_DIRS
ZTST_getchunk: read code chunk:
  setopt MARK_DIRS
  print tmp*
  unsetopt MARK_DIRS
  print tmp*
ZTST_test: examining line:
>tmpcd/ tmpfile1 tmpfile2
ZTST_getredir: read redir for '>':
tmpcd/ tmpfile1 tmpfile2
tmpcd tmpfile1 tmpfile2
ZTST_test: examining line:

Running test: MARK_DIRS option
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
tmpcd/ tmpfile1 tmpfile2
tmpcd tmpfile1 tmpfile2
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  print "This is in1" >in1
ZTST_getchunk: read code chunk:
  print "This is in1" >in1
  print "This is in2" >in2
  unsetopt multios
  print Test message >foo1 >foo2
  print foo1: $(<foo1)
  print foo2: $(<foo2)
  cat <in1 <in2
  setopt multios
  print Test message >foo1 >foo2
  sleep 1   # damn, race in multios
  print foo1: $(<foo1)
  print foo2: $(<foo2)
  cat <in1 <in2
  rm -f foo1 foo2 in1 in2
ZTST_test: examining line:
>foo1:
ZTST_getredir: read redir for '>':
foo1:
foo2: Test message
This is in2
foo1: Test message
foo2: Test message
This is in1
This is in2
ZTST_test: examining line:

Running test: MULTIOS option
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
foo1:
foo2: Test message
This is in2
foo1: Test message
foo2: Test message
This is in1
This is in2
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  unsetopt nomatch
ZTST_getchunk: read code chunk:
  unsetopt nomatch
  print with nonomatch: flooble*
  setopt nomatch
  print with nomatch flooble*
ZTST_test: examining line:
>with nonomatch: flooble*
ZTST_getredir: read redir for '>':
with nonomatch: flooble*
ZTST_test: examining line:
?ZTST_execchunk:2: no matches found: flooble*
ZTST_getredir: read redir for '?':
ZTST_execchunk:2: no matches found: flooble*
ZTST_test: examining line:

Running test: NOMATCH option
ZTST_test: expecting status: 1
ZTST_execchunk: status 1
ZTST_test: test produced standard output:
with nonomatch: flooble*
ZTST_test: and standard error:
ZTST_execchunk:2: no matches found: flooble*
Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  setopt nullglob nomatch
ZTST_getchunk: read code chunk:
  setopt nullglob nomatch
  print frooble* tmp*
  unsetopt nullglob nomatch
  print frooble* tmp*
ZTST_test: examining line:
>tmpcd tmpfile1 tmpfile2
ZTST_getredir: read redir for '>':
tmpcd tmpfile1 tmpfile2
frooble* tmpcd tmpfile1 tmpfile2
ZTST_test: examining line:

Running test: NULL_GLOB option
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
tmpcd tmpfile1 tmpfile2
frooble* tmpcd tmpfile1 tmpfile2
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: all tests successful
../../zsh-4.0.1-pre-5/Test/E01options.ztst: all tests successful.
../../zsh-4.0.1-pre-5/Test/E02xtrace.ztst: starting.
ZTST_getsect: read section name: prep
ZTST_getchunk: read code chunk:
  mkdir xtrace.tmp && cd xtrace.tmp
  function xtf {
    local regression_test_dummy_variable
    print "$*"
  }
  echo 'print "$*"' > xt.in
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:

ZTST_getsect: read section name: test
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  set -x
ZTST_getchunk: read code chunk:
  set -x
  print 'Tracing: builtin'
  print 'Tracing: builtin 2>file' 2>xtrace.err
  cat <<<'Tracing: external'
  cat <<<'Tracing: external 2>file' 2>>xtrace.err
  ( print 'Tracing: ( builtin )' )
  ( print 'Tracing: ( builtin ) 2>file' ) 2>>xtrace.err
  ( cat <<<'Tracing: ( external )' )
  ( cat <<<'Tracing: ( external ) 2>file' ) 2>>xtrace.err
  { print 'Tracing: { builtin }' }
  { print 'Tracing: { builtin } 2>file' } 2>>xtrace.err
  { cat <<<'Tracing: { external }' }
  { cat <<<'Tracing: { external } 2>file' } 2>>xtrace.err
  repeat 1 do print 'Tracing: do builtin done'; done
  repeat 1 do print 'Tracing: do builtin done 2>file'; done 2>>xtrace.err
  repeat 1 do cat <<<'Tracing: do external done'; done
  repeat 1 do cat <<<'Tracing: do external done 2>file'; done 2>>xtrace.err
  xtf 'Tracing: function'
  xtf 'Tracing: function 2>file' 2>>xtrace.err
  . ./xt.in 'Tracing: source'
  . ./xt.in 'Tracing: source 2>file' 2>>xtrace.err
  set +x
  cat xtrace.err
ZTST_test: examining line:
>Tracing: builtin
ZTST_getredir: read redir for '>':
Tracing: builtin
Tracing: builtin 2>file
Tracing: external
Tracing: external 2>file
Tracing: ( builtin )
Tracing: ( builtin ) 2>file
Tracing: ( external )
Tracing: ( external ) 2>file
Tracing: { builtin }
Tracing: { builtin } 2>file
Tracing: { external }
Tracing: { external } 2>file
Tracing: do builtin done
Tracing: do builtin done 2>file
Tracing: do external done
Tracing: do external done 2>file
Tracing: function
Tracing: function 2>file
Tracing: source
Tracing: source 2>file
+ZTST_execchunk:2> print Tracing: ( builtin ) 2>file
+ZTST_execchunk:2> cat
+ZTST_execchunk:2> print Tracing: { builtin } 2>file
+ZTST_execchunk:2> cat
+ZTST_execchunk:2> print Tracing: do builtin done 2>file
+ZTST_execchunk:2> cat
ZTST_test: examining line:
?+ZTST_execchunk:2> print Tracing: builtin
ZTST_getredir: read redir for '?':
+ZTST_execchunk:2> print Tracing: builtin
+ZTST_execchunk:2> print Tracing: builtin 2>file
+ZTST_execchunk:2> cat
+ZTST_execchunk:2> cat
+ZTST_execchunk:2> print Tracing: ( builtin )
+ZTST_execchunk:2> cat
+ZTST_execchunk:2> print Tracing: { builtin }
+ZTST_execchunk:2> cat
+ZTST_execchunk:2> print Tracing: do builtin done
+ZTST_execchunk:2> cat
+ZTST_execchunk:2> xtf Tracing: function
+xtf:0> local regression_test_dummy_variable
+xtf:0> print Tracing: function
+ZTST_execchunk:2> xtf Tracing: function 2>file
+xtf:0> local regression_test_dummy_variable
+xtf:0> print Tracing: function 2>file
+ZTST_execchunk:2> . ./xt.in Tracing: source
+./xt.in:1> print Tracing: source
+ZTST_execchunk:2> . ./xt.in Tracing: source 2>file
+./xt.in:1> print Tracing: source 2>file
+ZTST_execchunk:2> set +x
ZTST_test: examining line:

Running test: xtrace with and without redirection
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
Tracing: builtin
Tracing: builtin 2>file
Tracing: ( builtin )
Tracing: ( builtin ) 2>file
Tracing: { builtin }
Tracing: { builtin } 2>file
Tracing: do builtin done
Tracing: do builtin done 2>file
Tracing: function
Tracing: function 2>file
Tracing: source
Tracing: source 2>file
+ZTST_execchunk:2> print Tracing: ( builtin ) 2>file
ZTST_execchunk:2: bad address
+ZTST_execchunk:2> print Tracing: { builtin } 2>file
ZTST_execchunk:2: bad address
+ZTST_execchunk:2> print Tracing: do builtin done 2>file
ZTST_execchunk:2: bad address
ZTST_test: and standard error:
+ZTST_execchunk:2> print Tracing: builtin
+ZTST_execchunk:2> print Tracing: builtin 2>file
ZTST_execchunk:2: bad address
ZTST_execchunk:2: bad address
+ZTST_execchunk:2> print Tracing: ( builtin )
ZTST_execchunk:2: bad address
+ZTST_execchunk:2> print Tracing: { builtin }
ZTST_execchunk:2: bad address
+ZTST_execchunk:2> print Tracing: do builtin done
ZTST_execchunk:2: bad address
+ZTST_execchunk:2> xtf Tracing: function
+xtf:0> local regression_test_dummy_variable
+xtf:0> print Tracing: function
+ZTST_execchunk:2> xtf Tracing: function 2>file
+xtf:0> local regression_test_dummy_variable
+xtf:0> print Tracing: function 2>file
+ZTST_execchunk:2> . ./xt.in Tracing: source
+./xt.in:1> print Tracing: source
+ZTST_execchunk:2> . ./xt.in Tracing: source 2>file
+./xt.in:1> print Tracing: source 2>file
+ZTST_execchunk:2> set +x
*** /tmp/zsh.ztst.out.4541	Tue May 22 11:52:54 2001
--- /tmp/zsh.ztst.tout.4541	Tue May 22 11:52:54 2001
***************
*** 1,26 ****
  Tracing: builtin
  Tracing: builtin 2>file
- Tracing: external
- Tracing: external 2>file
  Tracing: ( builtin )
  Tracing: ( builtin ) 2>file
- Tracing: ( external )
- Tracing: ( external ) 2>file
  Tracing: { builtin }
  Tracing: { builtin } 2>file
- Tracing: { external }
- Tracing: { external } 2>file
  Tracing: do builtin done
  Tracing: do builtin done 2>file
- Tracing: do external done
- Tracing: do external done 2>file
  Tracing: function
  Tracing: function 2>file
  Tracing: source
  Tracing: source 2>file
  +ZTST_execchunk:2> print Tracing: ( builtin ) 2>file
! +ZTST_execchunk:2> cat
  +ZTST_execchunk:2> print Tracing: { builtin } 2>file
! +ZTST_execchunk:2> cat
  +ZTST_execchunk:2> print Tracing: do builtin done 2>file
! +ZTST_execchunk:2> cat
--- 1,18 ----
  Tracing: builtin
  Tracing: builtin 2>file
  Tracing: ( builtin )
  Tracing: ( builtin ) 2>file
  Tracing: { builtin }
  Tracing: { builtin } 2>file
  Tracing: do builtin done
  Tracing: do builtin done 2>file
  Tracing: function
  Tracing: function 2>file
  Tracing: source
  Tracing: source 2>file
  +ZTST_execchunk:2> print Tracing: ( builtin ) 2>file
! ZTST_execchunk:2: bad address
  +ZTST_execchunk:2> print Tracing: { builtin } 2>file
! ZTST_execchunk:2: bad address
  +ZTST_execchunk:2> print Tracing: do builtin done 2>file
! ZTST_execchunk:2: bad address
Test ../../zsh-4.0.1-pre-5/Test/E02xtrace.ztst failed: output differs from expected as shown above for:
  set -x
  print 'Tracing: builtin'
  print 'Tracing: builtin 2>file' 2>xtrace.err
  cat <<<'Tracing: external'
  cat <<<'Tracing: external 2>file' 2>>xtrace.err
  ( print 'Tracing: ( builtin )' )
  ( print 'Tracing: ( builtin ) 2>file' ) 2>>xtrace.err
  ( cat <<<'Tracing: ( external )' )
  ( cat <<<'Tracing: ( external ) 2>file' ) 2>>xtrace.err
  { print 'Tracing: { builtin }' }
  { print 'Tracing: { builtin } 2>file' } 2>>xtrace.err
  { cat <<<'Tracing: { external }' }
  { cat <<<'Tracing: { external } 2>file' } 2>>xtrace.err
  repeat 1 do print 'Tracing: do builtin done'; done
  repeat 1 do print 'Tracing: do builtin done 2>file'; done 2>>xtrace.err
  repeat 1 do cat <<<'Tracing: do external done'; done
  repeat 1 do cat <<<'Tracing: do external done 2>file'; done 2>>xtrace.err
  xtf 'Tracing: function'
  xtf 'Tracing: function 2>file' 2>>xtrace.err
  . ./xt.in 'Tracing: source'
  . ./xt.in 'Tracing: source 2>file' 2>>xtrace.err
  set +x
  cat xtrace.err
Error output:
+ZTST_execchunk:2> print Tracing: builtin
+ZTST_execchunk:2> print Tracing: builtin 2>file
ZTST_execchunk:2: bad address
ZTST_execchunk:2: bad address
+ZTST_execchunk:2> print Tracing: ( builtin )
ZTST_execchunk:2: bad address
+ZTST_execchunk:2> print Tracing: { builtin }
ZTST_execchunk:2: bad address
+ZTST_execchunk:2> print Tracing: do builtin done
ZTST_execchunk:2: bad address
+ZTST_execchunk:2> xtf Tracing: function
+xtf:0> local regression_test_dummy_variable
+xtf:0> print Tracing: function
+ZTST_execchunk:2> xtf Tracing: function 2>file
+xtf:0> local regression_test_dummy_variable
+xtf:0> print Tracing: function 2>file
+ZTST_execchunk:2> . ./xt.in Tracing: source
+./xt.in:1> print Tracing: source
+ZTST_execchunk:2> . ./xt.in Tracing: source 2>file
+./xt.in:1> print Tracing: source 2>file
+ZTST_execchunk:2> set +x
Was testing: xtrace with and without redirection
../../zsh-4.0.1-pre-5/Test/E02xtrace.ztst: test failed.
../../zsh-4.0.1-pre-5/Test/V01zmodload.ztst: starting.
ZTST_getsect: read section name: prep
ZTST_getchunk: read code chunk:
 mods=()
 while read name modfile link auto load funcs
 do
   [[ $name == \#* ]] && continue
   eval "$name $modfile $link $auto $load"
   [[ $link == no ]] && continue
   mods=($mods $name)
 done < $ZTST_testdir/../config.modules
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:

ZTST_getsect: read section name: test
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:

ZTST_test: examining line:
 zmodload -L
ZTST_getchunk: read code chunk:
 zmodload -L
ZTST_test: examining line:
>zmodload zsh/main
ZTST_getredir: read redir for '>':
zmodload zsh/main
zmodload zsh/parameter
ZTST_test: examining line:

Running test: List the loaded modules
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
zmodload zsh/main
zmodload zsh/parameter
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 zmodload zsh/main
ZTST_getchunk: read code chunk:
 zmodload zsh/main
ZTST_test: examining line:
?ZTST_execchunk:zmodload:2: module zsh/main already loaded.
ZTST_getredir: read redir for '?':
ZTST_execchunk:zmodload:2: module zsh/main already loaded.
ZTST_test: examining line:

Running test: Test reloading an already-loaded module
ZTST_test: expecting status: 1
ZTST_execchunk: status 1
ZTST_test: test produced standard output:

ZTST_test: and standard error:
ZTST_execchunk:zmodload:2: module zsh/main already loaded.
Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:

ZTST_test: examining line:
 for m in $mods
ZTST_getchunk: read code chunk:
 for m in $mods
 do
   zmodload -i $m || mods[(r)$m]=()
 done
ZTST_test: examining line:

Running test: Test loading of all compiled modules
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
The example module has now been set up.
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 zmodload -e $mods
ZTST_getchunk: read code chunk:
 zmodload -e $mods
ZTST_test: examining line:

Running test: Check that zsh believes the modules did load
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:

ZTST_test: examining line:
 zmodload -i bogus/notamodule
ZTST_getchunk: read code chunk:
 zmodload -i bogus/notamodule
ZTST_test: examining line:

Running test: Check that loading a nonexistent module fails
ZTST_test: expecting status: 1
ZTST_execchunk: status 1
ZTST_test: test produced standard output:

ZTST_test: and standard error:
ZTST_execchunk:2: failed to load module: bogus/notamodule
Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 zmodload -u bogus/notamodule
ZTST_getchunk: read code chunk:
 zmodload -u bogus/notamodule
ZTST_test: examining line:

Running test: Check that unloading a nonexistent module fails
ZTST_test: expecting status: 1
ZTST_execchunk: status 1
ZTST_test: test produced standard output:

ZTST_test: and standard error:
ZTST_execchunk:zmodload:2: no such module bogus/notamodule
Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:

ZTST_test: examining line:
 zmodload -ab bogus
ZTST_getchunk: read code chunk:
 zmodload -ab bogus
 zmodload -ub bogus
ZTST_test: examining line:

Running test: Add/remove autoloaded builtin
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 zmodload -ac bogus
ZTST_getchunk: read code chunk:
 zmodload -ac bogus
 zmodload -uc bogus
ZTST_test: examining line:

Running test: Add/remove autoloaded condition
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 zmodload -ap bogus
ZTST_getchunk: read code chunk:
 zmodload -ap bogus
 zmodload -up bogus
ZTST_test: examining line:

Running test: Add/remove autoloaded parameter
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 zmodload -af bogus
ZTST_getchunk: read code chunk:
 zmodload -af bogus
 zmodload -uf bogus
ZTST_test: examining line:

Running test: Add/remove autoloaded math function
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:

ZTST_test: examining line:
 if [[ $mods[(r)zsh/example] == zsh/example ]]; then
ZTST_getchunk: read code chunk:
 if [[ $mods[(r)zsh/example] == zsh/example ]]; then
   zmodload -u zsh/example
   zmodload -ab zsh/example example
   builtin example
   zmodload -e zsh/example
 else print -u8 Warning: zsh/example not linked: not checking autoloading
 fi
ZTST_test: examining line:

Running test: Autoload a module via a builtin
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
Thank you for using the example module.  Have a nice day.
The example module has now been set up.
Options: 
Arguments:
Name: example

Integer Parameter: 42
String Parameter: example
Array Parameter: example array
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 if [[ $mods[(r)zsh/example] == zsh/example ]]; then
ZTST_getchunk: read code chunk:
 if [[ $mods[(r)zsh/example] == zsh/example ]]; then
   zmodload -u zsh/example
   zmodload -ac -I zsh/example ex
   [[ exam -ex ple ]]
   zmodload -e zsh/example
 else :
 fi
ZTST_test: examining line:

Running test: Autoload a module via a condition
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
Thank you for using the example module.  Have a nice day.
The example module has now been set up.
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 if [[ $mods[(r)zsh/example] == zsh/example ]]; then
ZTST_getchunk: read code chunk:
 if [[ $mods[(r)zsh/example] == zsh/example ]]; then
   zmodload -u zsh/example
   zmodload -ap zsh/example exint
   : $exint
   zmodload -e zsh/example
 else :
 fi
ZTST_test: examining line:

Running test: Autoload a module via a parameter
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
Thank you for using the example module.  Have a nice day.
The example module has now been set up.
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 if [[ $mods[(r)zsh/example] == zsh/example ]]; then
ZTST_getchunk: read code chunk:
 if [[ $mods[(r)zsh/example] == zsh/example ]]; then
   zmodload -u zsh/example
   zmodload -af zsh/example sum
   (( sum(1) ))
   zmodload -e zsh/example
 else :
 fi
ZTST_test: examining line:

Running test: Autoload a module via a math function
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
Thank you for using the example module.  Have a nice day.
The example module has now been set up.
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:

ZTST_test: examining line:
 zmodload -A example=zsh/example
ZTST_getchunk: read code chunk:
 zmodload -A example=zsh/example
 zmodload -A
ZTST_test: examining line:
>example -> zsh/example
ZTST_getredir: read redir for '>':
example -> zsh/example
ZTST_test: examining line:

Running test: Test creating a module alias
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
example -> zsh/example
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 if [[ $mods[(r)zsh/example] == zsh/example ]]; then
ZTST_getchunk: read code chunk:
 if [[ $mods[(r)zsh/example] == zsh/example ]]; then
   zmodload -u example
   zmodload -ab example
   builtin example
   zmodload -e example
 else :
 fi
ZTST_test: examining line:

Running test: Unload/autoload the module via its alias
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
Thank you for using the example module.  Have a nice day.
The example module has now been set up.
Options: 
Arguments:
Name: example

Integer Parameter: 42
String Parameter: example
Array Parameter: example array
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 zmodload -R example
ZTST_getchunk: read code chunk:
 zmodload -R example
 zmodload -e example
ZTST_test: examining line:

Running test: Delete the module alias again
ZTST_test: expecting status: 1
ZTST_execchunk: status 1
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:

ZTST_test: examining line:
 mods[(r)zsh/main]=()
ZTST_getchunk: read code chunk:
 mods[(r)zsh/main]=()
 mods[(r)zsh/parameter]=()
 for m in $mods
 do
   zmodload -ud $m
 done
ZTST_test: examining line:

Running test: Remove module dependecies
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:

ZTST_test: examining line:
 zmodload -u $mods
ZTST_getchunk: read code chunk:
 zmodload -u $mods
ZTST_test: examining line:

Running test: Unload the modules loaded by this test suite
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
Thank you for using the example module.  Have a nice day.
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
%clean
ZTST_test: all tests successful
ZTST_getsect: read section name: clean
ZTST_getchunk: read code chunk:
 unset name modfile link auto load funcs mods m
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:

../../zsh-4.0.1-pre-5/Test/V01zmodload.ztst: all tests successful.
../../zsh-4.0.1-pre-5/Test/V02zregexparse.ztst: starting.
ZTST_getsect: read section name: prep
ZTST_getchunk: read code chunk:
  zmodload zsh/zutil
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:

ZTST_getsect: read section name: test
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 ''
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 ''
ZTST_test: examining line:

Running test: empty
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 a /a/
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 a /a/
ZTST_test: examining line:

Running test: element
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 aaaaaa /a/ \#
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 aaaaaa /a/ \#
ZTST_test: examining line:

Running test: closure
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 ab /a/ /b/
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 ab /a/ /b/
ZTST_test: examining line:

Running test: concatenation
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 a /a/ \| /b/
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 a /a/ \| /b/
ZTST_test: examining line:

Running test: alternation 1
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 b /a/ \| /b/
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 b /a/ \| /b/
ZTST_test: examining line:

Running test: alternation 2
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 a \( /a/ \)
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 a \( /a/ \)
ZTST_test: examining line:

Running test: grouping
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 abbaaab \( /a/ \| /b/ \) \#
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 abbaaab \( /a/ \| /b/ \) \#
ZTST_test: examining line:

Running test: alternation, grouping and closure
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 abcdef /ab/ %cd% /cdef/
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 abcdef /ab/ %cd% /cdef/
ZTST_test: examining line:

Running test: lookahead 1
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 abcdef /ab/ %ZZ% /cdef/
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 abcdef /ab/ %ZZ% /cdef/
ZTST_test: examining line:

Running test: lookahead 2
ZTST_test: expecting status: 1
ZTST_execchunk: status 1
ZTST_test: test produced standard output:

ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 abcd /ab/ %cd% '-print guard' ':print caction' /cd/
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 abcd /ab/ %cd% '-print guard' ':print caction' /cd/
ZTST_test: examining line:
>guard
ZTST_getredir: read redir for '>':
guard
ZTST_test: examining line:

Running test: pattern, lookahead, guard and completion action
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
guard
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 abcd /ab/ %cd% '-print guard; false' ':print caction' /cd/
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 abcd /ab/ %cd% '-print guard; false' ':print caction' /cd/
ZTST_test: examining line:
>guard
ZTST_getredir: read redir for '>':
guard
caction
ZTST_test: examining line:

Running test: guard failure
ZTST_test: expecting status: 1
ZTST_execchunk: status 1
ZTST_test: test produced standard output:
guard
caction
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 abcdef /ab/ '{print AB}' /cd/ '{print CD}' /ef/ '{print EF}'
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 abcdef /ab/ '{print AB}' /cd/ '{print CD}' /ef/ '{print EF}'
ZTST_test: examining line:
>AB
ZTST_getredir: read redir for '>':
AB
CD
EF
ZTST_test: examining line:

Running test: action
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
AB
CD
EF
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 aaa
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 aaa
  print $? $p1 $p2
ZTST_test: examining line:
>2 0 0
ZTST_getredir: read redir for '>':
2 0 0
ZTST_test: examining line:

Running test: aaa
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
2 0 0
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 aaa /a/
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 aaa /a/
  print $? $p1 $p2
ZTST_test: examining line:
>2 1 1
ZTST_getredir: read redir for '>':
2 1 1
ZTST_test: examining line:

Running test: aaa /a/
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
2 1 1
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 aaa /a/ /a/
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 aaa /a/ /a/
  print $? $p1 $p2
ZTST_test: examining line:
>2 2 2
ZTST_getredir: read redir for '>':
2 2 2
ZTST_test: examining line:

Running test: aaa 2*/a/
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
2 2 2
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 aaa /a/ /a/ /a/
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 aaa /a/ /a/ /a/
  print $? $p1 $p2
ZTST_test: examining line:
>0 3 3
ZTST_getredir: read redir for '>':
0 3 3
ZTST_test: examining line:

Running test: aaa 3*/a/
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
0 3 3
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 aaa /a/ /a/ /a/ /a/
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 aaa /a/ /a/ /a/ /a/
  print $? $p1 $p2
ZTST_test: examining line:
>1 3 3
ZTST_getredir: read redir for '>':
1 3 3
ZTST_test: examining line:

Running test: aaa 4*/a/
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
1 3 3
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 aaa /a/ /a/ /a/ /a/ /a/
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 aaa /a/ /a/ /a/ /a/ /a/
  print $? $p1 $p2
ZTST_test: examining line:
>1 3 3
ZTST_getredir: read redir for '>':
1 3 3
ZTST_test: examining line:

Running test: aaa 5*/a/
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
1 3 3
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 aaa /aaa/
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 aaa /aaa/
  print $? $p1 $p2
ZTST_test: examining line:
>0 3 3
ZTST_getredir: read redir for '>':
0 3 3
ZTST_test: examining line:

Running test: aaa /aaa/
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
0 3 3
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 aaa /aaa/ /a/
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 aaa /aaa/ /a/
  print $? $p1 $p2
ZTST_test: examining line:
>1 3 3
ZTST_getredir: read redir for '>':
1 3 3
ZTST_test: examining line:

Running test: aaa /aaa/ /a/
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
1 3 3
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 aaa /a/ \#
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 aaa /a/ \#
  print $? $p1 $p2
ZTST_test: examining line:
>0 3 3
ZTST_getredir: read redir for '>':
0 3 3
ZTST_test: examining line:

Running test: aaa /aaa/ #
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
0 3 3
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 aaa /a/ \# \#
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 aaa /a/ \# \#
  print $? $p1 $p2
ZTST_test: examining line:
>0 3 3
ZTST_getredir: read redir for '>':
0 3 3
ZTST_test: examining line:

Running test: aaa /aaa/ # #
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
0 3 3
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 aaa \( /a/ \)
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 aaa \( /a/ \)
  print $? $p1 $p2
ZTST_test: examining line:
>2 1 1
ZTST_getredir: read redir for '>':
2 1 1
ZTST_test: examining line:

Running test: aaa ( /a/ )
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
2 1 1
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 aaa \( /a/ \) \#
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 aaa \( /a/ \) \#
  print $? $p1 $p2
ZTST_test: examining line:
>0 3 3
ZTST_getredir: read redir for '>':
0 3 3
ZTST_test: examining line:

Running test: aaa ( /a/ ) #
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
0 3 3
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 aaa /a/ /b/
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 aaa /a/ /b/
  print $? $p1 $p2
ZTST_test: examining line:
>1 1 1
ZTST_getredir: read redir for '>':
1 1 1
ZTST_test: examining line:

Running test: aaa /a/ /b/
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
1 1 1
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 a /a/ '{print A}'
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 a /a/ '{print A}'
  print $? $p1 $p2
ZTST_test: examining line:
>A
ZTST_getredir: read redir for '>':
A
0 1 1
ZTST_test: examining line:

Running test: a /a/ '{A}'
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
A
0 1 1
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 a /b/ '{print A}'
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 a /b/ '{print A}'
  print $? $p1 $p2
ZTST_test: examining line:
>1 0 0
ZTST_getredir: read redir for '>':
1 0 0
ZTST_test: examining line:

Running test: a /b/ '{A}'
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
1 0 0
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 a /b/ ':print A' '{print B}'
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 a /b/ ':print A' '{print B}'
  print $? $p1 $p2
ZTST_test: examining line:
>A
ZTST_getredir: read redir for '>':
A
1 0 0
ZTST_test: examining line:

Running test: a /b/ ':A' '{B}'
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
A
1 0 0
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 ab /a/ '{print A}'
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 ab /a/ '{print A}'
  print $? $p1 $p2
ZTST_test: examining line:
>2 1 1
ZTST_getredir: read redir for '>':
2 1 1
ZTST_test: examining line:

Running test: ab /a/ '{A}'
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
2 1 1
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 ab /a/ '{print A}' /b/ '{print B}'
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 ab /a/ '{print A}' /b/ '{print B}'
  print $? $p1 $p2
ZTST_test: examining line:
>A
ZTST_getredir: read redir for '>':
A
B
0 2 2
ZTST_test: examining line:

Running test: ab /a/ '{A}' /b/ '{B}'
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
A
B
0 2 2
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 ab /a/ ':print A' '{print B}' /b/ ':print C' '{print D}'
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 ab /a/ ':print A' '{print B}' /b/ ':print C' '{print D}'
  print $? $p1 $p2
ZTST_test: examining line:
>B
ZTST_getredir: read redir for '>':
B
D
0 2 2
ZTST_test: examining line:

Running test: ab /a/ ':A' '{B}' /b/ ':C' '{D}'
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
B
D
0 2 2
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 abc /a/ '{print A}' /b/ '{print B}' /c/ '{print C}'
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 abc /a/ '{print A}' /b/ '{print B}' /c/ '{print C}'
  print $? $p1 $p2
ZTST_test: examining line:
>A
ZTST_getredir: read redir for '>':
A
B
C
0 3 3
ZTST_test: examining line:

Running test: abc /a/ '{A}' /b/ '{B}' /c/ '{C}'
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
A
B
C
0 3 3
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 abz /a/ '{print A}' /b/ '{print B}' /c/ '{print C}'
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 abz /a/ '{print A}' /b/ '{print B}' /c/ '{print C}'
  print $? $p1 $p2
ZTST_test: examining line:
>A
ZTST_getredir: read redir for '>':
A
1 2 2
ZTST_test: examining line:

Running test: abz /a/ '{A}' /b/ '{B}' /c/ '{C}'
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
A
1 2 2
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 azz /a/ '{print A}' /b/ '{print B}' /c/ '{print C}'
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 azz /a/ '{print A}' /b/ '{print B}' /c/ '{print C}'
  print $? $p1 $p2
ZTST_test: examining line:
>1 1 1
ZTST_getredir: read redir for '>':
1 1 1
ZTST_test: examining line:

Running test: azz /a/ '{A}' /b/ '{B}' /c/ '{C}'
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
1 1 1
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 aba '{print A}' /a/ '{print B}' /b/ '{print C}' /c/ '{print D}'
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 aba '{print A}' /a/ '{print B}' /b/ '{print C}' /c/ '{print D}'
  print $? $p1 $p2
ZTST_test: examining line:
>A
ZTST_getredir: read redir for '>':
A
B
1 2 2
ZTST_test: examining line:

Running test: aba '{A}' /a/ '{B}' /b/ '{C}' /c/ '{D}'
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
A
B
1 2 2
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 a /a/ '{print "$match[1]"}'
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 a /a/ '{print "$match[1]"}'
  print $? $p1 $p2
ZTST_test: examining line:
>a
ZTST_getredir: read redir for '>':
a
0 1 1
ZTST_test: examining line:

Running test: a /a/ '{M1}'
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
a
0 1 1
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 aaa /a/ '{print A}' //
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 aaa /a/ '{print A}' //
  print $? $p1 $p2
ZTST_test: examining line:
>A
ZTST_getredir: read redir for '>':
A
2 1 1
ZTST_test: examining line:

Running test: aaa /a/ '{A}' //
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
A
2 1 1
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 aaa /a/ '{print "$match[1]"}' // '{print A}'
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 aaa /a/ '{print "$match[1]"}' // '{print A}'
  print $? $p1 $p2
ZTST_test: examining line:
>a
ZTST_getredir: read redir for '>':
a
2 1 1
ZTST_test: examining line:

Running test: aaa /a/ '{M1}' // '{A}'
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
a
2 1 1
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 abcdef /a/ '{print $match[1]}' /b/ '{print $match[1]}' /c/ '{print $match[1]}' // '{print A}'
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 abcdef /a/ '{print $match[1]}' /b/ '{print $match[1]}' /c/ '{print $match[1]}' // '{print A}'
  print $? $p1 $p2
ZTST_test: examining line:
>a
ZTST_getredir: read redir for '>':
a
b
c
2 3 3
ZTST_test: examining line:

Running test: abcdef /a/ '{M1}' /b/ '{M1}' /c/ '{M1}' // '{A}'
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
a
b
c
2 3 3
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 abcdef /a/ '{print A}' /b/ '{print B}' /c/ '{print C}' // '{print D}'
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 abcdef /a/ '{print A}' /b/ '{print B}' /c/ '{print C}' // '{print D}'
  print $? $p1 $p2
ZTST_test: examining line:
>A
ZTST_getredir: read redir for '>':
A
B
C
2 3 3
ZTST_test: examining line:

Running test: abcdef /a/ '{A}' /b/ '{B}' /c/ '{C}' // '{D}'
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
A
B
C
2 3 3
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 a /a/ '{print A}' /b/ '{print B}'
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 a /a/ '{print A}' /b/ '{print B}'
  print $? $p1 $p2
ZTST_test: examining line:
>1 1 1
ZTST_getredir: read redir for '>':
1 1 1
ZTST_test: examining line:

Running test: a /a/ {A} /b/ {B}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
1 1 1
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 abcdef \
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 abcdef \
    /a/ '-print Ga:$p1:$p2:$match[1]' '{print Aa:$p1:$p2:$match[1]}' \
    /b/ '-print Gb:$p1:$p2:$match[1]' '{print Ab:$p1:$p2:$match[1]}' \
    /c/ '-print Gc:$p1:$p2:$match[1]' '{print Ac:$p1:$p2:$match[1]}' \
    //
  print $? $p1 $p2
ZTST_test: examining line:
>Ga:0:0:a
ZTST_getredir: read redir for '>':
Ga:0:0:a
Gb:1:1:b
Aa:1:1:a
Gc:2:2:c
Ab:2:2:b
Ac:3:3:c
2 3 3
ZTST_test: examining line:

Running test: abcdef /a/ -Ga {Aa} /b/ -Gb {Aa} /c/ -Gc {Ac} //
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
Ga:0:0:a
Gb:1:1:b
Aa:1:1:a
Gc:2:2:c
Ab:2:2:b
Ac:3:3:c
2 3 3
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 abcdef \
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 abcdef \
    /a/ '-print Ga:$p1:$p2:$match[1]' '{print Aa:$p1:$p2:$match[1]}' \
    /b/ '-print Gb:$p1:$p2:$match[1]' '{print Ab:$p1:$p2:$match[1]}' \
    /c/ '-print Gc:$p1:$p2:$match[1]' '{print Ac:$p1:$p2:$match[1]}' \
    '/[]/' ':print F:$p1:$p2'
  print $? $p1 $p2
ZTST_test: examining line:
>Ga:0:0:a
ZTST_getredir: read redir for '>':
Ga:0:0:a
Gb:1:1:b
Aa:1:1:a
Gc:2:2:c
Ab:2:2:b
F:3:3
1 3 3
ZTST_test: examining line:

Running test: abcdef /a/ -Ga {Aa} /b/ -Gb {Ab} /c/ -Gc {Ac} /[]/ :F
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
Ga:0:0:a
Gb:1:1:b
Aa:1:1:a
Gc:2:2:c
Ab:2:2:b
F:3:3
1 3 3
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 abcdef \
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 abcdef \
    /a/ '-print Ga:$p1:$p2:$match[1]' '{print Aa:$p1:$p2:$match[1]}' \
    /b/ '-print Gb:$p1:$p2:$match[1]' '{print Ab:$p1:$p2:$match[1]}' \
    /c/ '-print Gc:$p1:$p2:$match[1]' '{print Ac:$p1:$p2:$match[1]}' \
    \( '/[]/' ':print F1:$p1:$p2' \| /z/ ':print F2' \)
  print $? $p1 $p2
ZTST_test: examining line:
>Ga:0:0:a
ZTST_getredir: read redir for '>':
Ga:0:0:a
Gb:1:1:b
Aa:1:1:a
Gc:2:2:c
Ab:2:2:b
F1:3:3
F2
1 3 3
ZTST_test: examining line:

Running test: abcdef /a/ -Ga {Aa} /b/ -Gb {Ab} /c/ -Gc {Ac} ( /[]/ :F1 | /z/ :F2 )
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
Ga:0:0:a
Gb:1:1:b
Aa:1:1:a
Gc:2:2:c
Ab:2:2:b
F1:3:3
F2
1 3 3
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 a '/[]/' ':print A'
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 a '/[]/' ':print A'
  print $? $p1 $p2
ZTST_test: examining line:
>A
ZTST_getredir: read redir for '>':
A
1 0 0
ZTST_test: examining line:

Running test: a /[]/ :A
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
A
1 0 0
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 $'\0' $'/\0/' '{print A}'
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 $'\0' $'/\0/' '{print A}'
  print $? $p1 $p2
ZTST_test: examining line:
>A
ZTST_getredir: read redir for '>':
A
0 1 1
ZTST_test: examining line:

Running test: "\0" /\0/ {A}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
A
0 1 1
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 $'\0' $'/\0/' '{print A}' '/ /' '{print B}'  
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 $'\0' $'/\0/' '{print A}' '/ /' '{print B}'  
  print $? $p1 $p2
ZTST_test: examining line:
>1 1 1
ZTST_getredir: read redir for '>':
1 1 1
ZTST_test: examining line:

Running test: "\0" /\0/ {A} / / {B}
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
1 1 1
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 abcdef \(  '/?/' '{print $match[1]}' \) \#
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 abcdef \(  '/?/' '{print $match[1]}' \) \#
  print $? $p1 $p2
ZTST_test: examining line:
>a
ZTST_getredir: read redir for '>':
a
b
c
d
e
f
0 6 6
ZTST_test: examining line:

Running test: abcdef ( /?/ {M1} ) #
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
a
b
c
d
e
f
0 6 6
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 abcdef \(  '/c?|?/' '{print $match[1]}' \) \#
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 abcdef \(  '/c?|?/' '{print $match[1]}' \) \#
  print $? $p1 $p2
ZTST_test: examining line:
>a
ZTST_getredir: read redir for '>':
a
b
cd
e
f
0 6 6
ZTST_test: examining line:

Running test: abcdef ( /c?|?/ {M1} ) #
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
a
b
cd
e
f
0 6 6
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 abcacdef \( /a/ '{print $match[1]}' \| /b/ '{print $match[1]}' \| /c/ '{print $match[1]}' \) \#
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 abcacdef \( /a/ '{print $match[1]}' \| /b/ '{print $match[1]}' \| /c/ '{print $match[1]}' \) \#
  print $? $p1 $p2
ZTST_test: examining line:
>a
ZTST_getredir: read redir for '>':
a
b
c
a
1 5 5
ZTST_test: examining line:

Running test: abcacdef ( /a/ {M1} | /b/ {M1} | /c/ {M1} ) #
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
a
b
c
a
1 5 5
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 abcdef \( /a/ ':print A' \| /b/ ':print B' \| /c/ ':print C' \) \#
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 abcdef \( /a/ ':print A' \| /b/ ':print B' \| /c/ ':print C' \) \#
  print $? $p1 $p2
ZTST_test: examining line:
>A
ZTST_getredir: read redir for '>':
A
B
C
1 3 3
ZTST_test: examining line:

Running test: abcdef ( /a/ :A | /b/ :B | /c/ :C ) #
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
A
B
C
1 3 3
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 abcdef \( /a/ ':print A' '{print $match[1]}' \| /b/ ':print B' '{print $match[1]}' \| /c/ ':print C' '{print $match[1]}' \) \#
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 abcdef \( /a/ ':print A' '{print $match[1]}' \| /b/ ':print B' '{print $match[1]}' \| /c/ ':print C' '{print $match[1]}' \) \#
  print $? $p1 $p2
ZTST_test: examining line:
>a
ZTST_getredir: read redir for '>':
a
b
A
B
C
1 3 3
ZTST_test: examining line:

Running test: abcdef ( /a/ :A {M1} | /b/ :B {M1} | /c/ :C {M1} ) #
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
a
b
A
B
C
1 3 3
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 $'com\0xx' /$'[^\0]#\0'/ \( /$'[^\0]#\0'/ :'print A' /$'[^\0]#\0'/ :'print B' \) \#
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 $'com\0xx' /$'[^\0]#\0'/ \( /$'[^\0]#\0'/ :'print A' /$'[^\0]#\0'/ :'print B' \) \#
  print $? $p1 $p2
ZTST_test: examining line:
>A
ZTST_getredir: read redir for '>':
A
1 4 4
ZTST_test: examining line:

Running test: "com\0xx" /W/ ( /W/ :A /W/ :B ) #
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
A
1 4 4
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 $'com\0xx\0yy' /$'[^\0]#\0'/ \( /$'[^\0]#\0'/ :'print A' /$'[^\0]#\0'/ :'print B' \) \#
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 $'com\0xx\0yy' /$'[^\0]#\0'/ \( /$'[^\0]#\0'/ :'print A' /$'[^\0]#\0'/ :'print B' \) \#
  print $? $p1 $p2
ZTST_test: examining line:
>B
ZTST_getredir: read redir for '>':
B
1 7 7
ZTST_test: examining line:

Running test: "com\0xx\0yy" /W/ ( /W/ :A /W/ :B ) #
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
B
1 7 7
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 $'com\0xx\0yy\0zz' /$'[^\0]#\0'/ \( /$'[^\0]#\0'/ :'print A' /$'[^\0]#\0'/ :'print B' \) \#
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 $'com\0xx\0yy\0zz' /$'[^\0]#\0'/ \( /$'[^\0]#\0'/ :'print A' /$'[^\0]#\0'/ :'print B' \) \#
  print $? $p1 $p2
ZTST_test: examining line:
>A
ZTST_getredir: read redir for '>':
A
1 10 10
ZTST_test: examining line:

Running test: "com\0xx\0yy\0zz" /W/ ( /W/ :A /W/ :B ) #
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
A
1 10 10
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 abcdez /abc/ ':print A:$p1:$p2' /def/ ':print B:$p1:$p2'
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 abcdez /abc/ ':print A:$p1:$p2' /def/ ':print B:$p1:$p2'
  print $? $p1 $p2
ZTST_test: examining line:
>B:3:3
ZTST_getredir: read redir for '>':
B:3:3
1 3 3
ZTST_test: examining line:

Running test: abcdez /abc/ :A /def/ :B
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
B:3:3
1 3 3
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 abcdez /abc/+ ':print A:$p1:$p2' /def/ ':print B:$p1:$p2'
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 abcdez /abc/+ ':print A:$p1:$p2' /def/ ':print B:$p1:$p2'
  print $? $p1 $p2
ZTST_test: examining line:
>A:0:3
ZTST_getredir: read redir for '>':
A:0:3
B:0:3
1 0 3
ZTST_test: examining line:

Running test: abcdez /abc/+ :A /def/ :B
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
A:0:3
B:0:3
1 0 3
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 abcdez /abc/+ ':print A:$p1:$p2' // /def/ ':print B:$p1:$p2'
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 abcdez /abc/+ ':print A:$p1:$p2' // /def/ ':print B:$p1:$p2'
  print $? $p1 $p2
ZTST_test: examining line:
>A:0:3
ZTST_getredir: read redir for '>':
A:0:3
B:0:3
1 0 3
ZTST_test: examining line:

Running test: abcdez /abc/+ :A // /def/ :B
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
A:0:3
B:0:3
1 0 3
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 abcdez /abc/+ ':print A:$p1:$p2' //- /def/ ':print B:$p1:$p2'
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 abcdez /abc/+ ':print A:$p1:$p2' //- /def/ ':print B:$p1:$p2'
  print $? $p1 $p2
ZTST_test: examining line:
>B:3:3
ZTST_getredir: read redir for '>':
B:3:3
1 3 3
ZTST_test: examining line:

Running test: abcdez /abc/+ :A //- /def/ :B
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
B:3:3
1 3 3
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  zregexparse p1 p2 $'ZZZZ\0abcdef' $'/ZZZZ\0/' /abc/+ ':print A:$p1:$p2' /dee/ ':print B:$p1:$p2'
ZTST_getchunk: read code chunk:
  zregexparse p1 p2 $'ZZZZ\0abcdef' $'/ZZZZ\0/' /abc/+ ':print A:$p1:$p2' /dee/ ':print B:$p1:$p2'
  print $? $p1 $p2
ZTST_test: examining line:
>A:5:8
ZTST_getredir: read redir for '>':
A:5:8
B:5:8
1 5 8
ZTST_test: examining line:

Running test: "ZZZZ\0abcdef" /ZZZZ\0/ /abc/+ :A /dee/ :B
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
A:5:8
B:5:8
1 5 8
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: all tests successful
../../zsh-4.0.1-pre-5/Test/V02zregexparse.ztst: all tests successful.
../../zsh-4.0.1-pre-5/Test/Y01completion.ztst: starting.
ZTST_getsect: read section name: prep
ZTST_getchunk: read code chunk:
  . $ZTST_srcdir/comptest
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:
  mkdir comp.tmp
  cd comp.tmp
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:
  comptestinit -z $ZTST_testdir/../Src/zsh
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:
  mkdir dir1
  mkdir dir2
  touch file1
  touch file2
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:

ZTST_getsect: read section name: test
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  comptest $': \t\t\t\t\t\t\t'
ZTST_getchunk: read code chunk:
  comptest $': \t\t\t\t\t\t\t'
ZTST_test: examining line:
>line: {: }{}
ZTST_getredir: read redir for '>':
line: {: }{}
DESCRIPTION:{file}
DI:{dir1}
DI:{dir2}
FI:{file1}
FI:{file2}
line: {: dir1/}{}
line: {: dir2/}{}
line: {: file1}{}
line: {: file2}{}
line: {: dir1/}{}
line: {: dir2/}{}
ZTST_test: examining line:

Running test: directories and files
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {: }{}
DESCRIPTION:{file}
DI:{dir1}
DI:{dir2}
FI:{file1}
FI:{file2}
line: {: dir1/}{}
line: {: dir2/}{}
line: {: file1}{}
line: {: file2}{}
line: {: dir1/}{}
line: {: dir2/}{}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  comptesteval '_users () { compadd user1 user2 }'
ZTST_getchunk: read code chunk:
  comptesteval '_users () { compadd user1 user2 }'
  comptest $': ~\t\t\t\t\t'
ZTST_test: examining line:
>line: {: ~user}{}
ZTST_getredir: read redir for '>':
line: {: ~user}{}
line: {: ~user}{}
NO:{user1}
NO:{user2}
line: {: ~user1}{}
line: {: ~user2}{}
line: {: ~user1}{}
ZTST_test: examining line:

Running test: tilde
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {: ~user}{}
line: {: ~user}{}
NO:{user1}
NO:{user2}
line: {: ~user1}{}
line: {: ~user2}{}
line: {: ~user1}{}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  comptest $'echo ;:\C-b\C-b\t'
ZTST_getchunk: read code chunk:
  comptest $'echo ;:\C-b\C-b\t'
ZTST_test: examining line:
>line: {echo }{;:}
ZTST_getredir: read redir for '>':
line: {echo }{;:}
DESCRIPTION:{file}
DI:{dir1}
DI:{dir2}
FI:{file1}
FI:{file2}
ZTST_test: examining line:

Running test: tilde
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {echo }{;:}
DESCRIPTION:{file}
DI:{dir1}
DI:{dir2}
FI:{file1}
FI:{file2}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
%clean
ZTST_test: all tests successful
ZTST_getsect: read section name: clean
ZTST_getchunk: read code chunk:
  zmodload -ui zsh/zpty
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:

../../zsh-4.0.1-pre-5/Test/Y01completion.ztst: all tests successful.
../../zsh-4.0.1-pre-5/Test/Y02compmatch.ztst: starting.
ZTST_getsect: read section name: prep
ZTST_getchunk: read code chunk:
  . $ZTST_srcdir/comptest
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:
  mkdir match.tmp
  cd match.tmp
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:
  comptestinit -z $ZTST_testdir/../Src/zsh
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:
  list1=(IndianRed IndianRed2 IndianRed3 IndianRed4)
  test_code () {
	matcher=$1;
	list=$2;
	code="compdef _tst tst ; _tst () { echo -n '<COMPADD>';compadd -M '"
	code="$code$matcher"
	code="$code'  - ${(P)list} ; echo  -n '</COMPADD>'"
        code="$code; $extra_cmd"
        code="$code; echo -n '<INSERT_POSITIONS>'"
        code="$code; echo \$compstate[insert_positions]"
        code="$code; echo -n '</INSERT_POSITIONS>'"
        code="$code}"
	comptesteval "$code"
  }
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:

ZTST_getsect: read section name: test
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 test_code z: list1
ZTST_getchunk: read code chunk:
 test_code z: list1
 comptest  $'tst \t'
ZTST_test: examining line:
>line: {tst }{}
ZTST_getredir: read redir for '>':
line: {tst }{}
COMPADD:{_tst:compadd: unknown match specification character `z'}
INSERT_POSITIONS:{}
ZTST_test: examining line:

Running test: Match Error for "z:"
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst }{}
COMPADD:{_tst:compadd: unknown match specification character `z'}
INSERT_POSITIONS:{}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 test_code m: list1
ZTST_getchunk: read code chunk:
 test_code m: list1
 comptest  $'tst \t'
ZTST_test: examining line:
>line: {tst }{}
ZTST_getredir: read redir for '>':
line: {tst }{}
COMPADD:{_tst:compadd: missing patterns}
INSERT_POSITIONS:{}
ZTST_test: examining line:

Running test: Match Error for "m:"
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst }{}
COMPADD:{_tst:compadd: missing patterns}
INSERT_POSITIONS:{}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 test_code M: list1
ZTST_getchunk: read code chunk:
 test_code M: list1
 comptest $'tst \t'
ZTST_test: examining line:
>line: {tst }{}
ZTST_getredir: read redir for '>':
line: {tst }{}
COMPADD:{_tst:compadd: missing patterns}
INSERT_POSITIONS:{}
ZTST_test: examining line:

Running test: Match Error for "M:"
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst }{}
COMPADD:{_tst:compadd: missing patterns}
INSERT_POSITIONS:{}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 test_code r: list1
ZTST_getchunk: read code chunk:
 test_code r: list1
 comptest $'tst \t'
ZTST_test: examining line:
>line: {tst }{}
ZTST_getredir: read redir for '>':
line: {tst }{}
COMPADD:{_tst:compadd: missing patterns}
INSERT_POSITIONS:{}
ZTST_test: examining line:

Running test: Match Error "r:"
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst }{}
COMPADD:{_tst:compadd: missing patterns}
INSERT_POSITIONS:{}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 test_code R: list1
ZTST_getchunk: read code chunk:
 test_code R: list1
 comptest $'tst \t'
ZTST_test: examining line:
>line: {tst }{}
ZTST_getredir: read redir for '>':
line: {tst }{}
COMPADD:{_tst:compadd: missing patterns}
INSERT_POSITIONS:{}
ZTST_test: examining line:

Running test: Match Error "R:"
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst }{}
COMPADD:{_tst:compadd: missing patterns}
INSERT_POSITIONS:{}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 test_code l: list1
ZTST_getchunk: read code chunk:
 test_code l: list1
 comptest $'tst \t'
ZTST_test: examining line:
>line: {tst }{}
ZTST_getredir: read redir for '>':
line: {tst }{}
COMPADD:{_tst:compadd: missing patterns}
INSERT_POSITIONS:{}
ZTST_test: examining line:

Running test: Match Error for "l:"
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst }{}
COMPADD:{_tst:compadd: missing patterns}
INSERT_POSITIONS:{}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 test_code L: list1
ZTST_getchunk: read code chunk:
 test_code L: list1
 comptest $'tst \t'
ZTST_test: examining line:
>line: {tst }{}
ZTST_getredir: read redir for '>':
line: {tst }{}
COMPADD:{_tst:compadd: missing patterns}
INSERT_POSITIONS:{}
ZTST_test: examining line:

Running test: Match Error for "L:"
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst }{}
COMPADD:{_tst:compadd: missing patterns}
INSERT_POSITIONS:{}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 test_code 'm:{0-9' list1
ZTST_getchunk: read code chunk:
 test_code 'm:{0-9' list1
 comptest $'tst \t'
ZTST_test: examining line:
>line: {tst }{}
ZTST_getredir: read redir for '>':
line: {tst }{}
COMPADD:{_tst:compadd: unterminated character class}
INSERT_POSITIONS:{}
ZTST_test: examining line:

Running test: Match Error for "m:{0-9"
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst }{}
COMPADD:{_tst:compadd: unterminated character class}
INSERT_POSITIONS:{}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 test_code 'm:{0-9}' list1
ZTST_getchunk: read code chunk:
 test_code 'm:{0-9}' list1
 comptest $'tst \t'
ZTST_test: examining line:
>line: {tst }{}
ZTST_getredir: read redir for '>':
line: {tst }{}
COMPADD:{_tst:compadd: missing word pattern}
INSERT_POSITIONS:{}
ZTST_test: examining line:

Running test: Match Error for "m:{0-9}"
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst }{}
COMPADD:{_tst:compadd: missing word pattern}
INSERT_POSITIONS:{}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 test_code 'm:{0-9}={' list1
ZTST_getchunk: read code chunk:
 test_code 'm:{0-9}={' list1
 comptest $'tst \t'
ZTST_test: examining line:
>line: {tst }{}
ZTST_getredir: read redir for '>':
line: {tst }{}
COMPADD:{_tst:compadd: unterminated character class}
INSERT_POSITIONS:{}
ZTST_test: examining line:

Running test: Match Error for "m:{0-9}={"
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst }{}
COMPADD:{_tst:compadd: unterminated character class}
INSERT_POSITIONS:{}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 test_code 'm:{0-9}={0-' list1
ZTST_getchunk: read code chunk:
 test_code 'm:{0-9}={0-' list1
 comptest $'tst \t'
ZTST_test: examining line:
>line: {tst }{}
ZTST_getredir: read redir for '>':
line: {tst }{}
COMPADD:{_tst:compadd: unterminated character class}
INSERT_POSITIONS:{}
ZTST_test: examining line:

Running test: Match Error for "m:{0-9}={0-"
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst }{}
COMPADD:{_tst:compadd: unterminated character class}
INSERT_POSITIONS:{}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 test_code 'm:{0-9}={-' list1
ZTST_getchunk: read code chunk:
 test_code 'm:{0-9}={-' list1
 comptest $'tst \t'
ZTST_test: examining line:
>line: {tst }{}
ZTST_getredir: read redir for '>':
line: {tst }{}
COMPADD:{_tst:compadd: unterminated character class}
INSERT_POSITIONS:{}
ZTST_test: examining line:

Running test: Match Error for "m:{0-9}={-"
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst }{}
COMPADD:{_tst:compadd: unterminated character class}
INSERT_POSITIONS:{}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 test_code r: list1
ZTST_getchunk: read code chunk:
 test_code r: list1
 comptest $'tst \t'
ZTST_test: examining line:
>line: {tst }{}
ZTST_getredir: read redir for '>':
line: {tst }{}
COMPADD:{_tst:compadd: missing patterns}
INSERT_POSITIONS:{}
ZTST_test: examining line:

Running test: Match Error "r:"
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst }{}
COMPADD:{_tst:compadd: missing patterns}
INSERT_POSITIONS:{}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  example1_list=(
ZTST_getchunk: read code chunk:
  example1_list=(
	kshoptionprint        shglob              
	listambiguous         shinstdin           
	listbeep              shnullcmd           
	listpacked            shoptionletters     
	listrowsfirst         shortloops          
	listtypes             shwordsplit
   )
 options_matcher='L:|[nN][oO]= M:_= M:{A-Z}={a-z}'
 test_code $options_matcher example1_list
 comptest $'tst nolistbee\t'
ZTST_test: examining line:
>line: {tst nolistbeep }{}
ZTST_getredir: read redir for '>':
line: {tst nolistbeep }{}
COMPADD:{}
INSERT_POSITIONS:{14}
ZTST_test: examining line:

Running test: Documentation example for options, input "nolistbee"
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst nolistbeep }{}
COMPADD:{}
INSERT_POSITIONS:{14}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:

ZTST_test: examining line:
 test_code $options_matcher example1_list
ZTST_getchunk: read code chunk:
 test_code $options_matcher example1_list
 comptest $'tst list_bee\t'
ZTST_test: examining line:
>line: {tst list_beep }{}
ZTST_getredir: read redir for '>':
line: {tst list_beep }{}
COMPADD:{}
INSERT_POSITIONS:{13}
ZTST_test: examining line:

Running test: Documentation example for options, input "list_bee"
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst list_beep }{}
COMPADD:{}
INSERT_POSITIONS:{13}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 test_code $options_matcher example1_list
ZTST_getchunk: read code chunk:
 test_code $options_matcher example1_list
 comptest $'tst ListBee\t'
ZTST_test: examining line:
>line: {tst ListBeep }{}
ZTST_getredir: read redir for '>':
line: {tst ListBeep }{}
COMPADD:{}
INSERT_POSITIONS:{12}
ZTST_test: examining line:

Running test: Documentation example for options, input "ListBee"
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst ListBeep }{}
COMPADD:{}
INSERT_POSITIONS:{12}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 test_code $options_matcher example1_list
ZTST_getchunk: read code chunk:
 test_code $options_matcher example1_list
 comptest $'tst NOList\tB\t'
ZTST_test: examining line:
>line: {tst NOList}{}
ZTST_getredir: read redir for '>':
line: {tst NOList}{}
COMPADD:{}
INSERT_POSITIONS:{10}
NO:{NOListambiguous}
NO:{NOListbeep}
NO:{NOListpacked}
NO:{NOListrowsfirst}
NO:{NOListtypes}
line: {tst NOListBeep }{}
COMPADD:{}
INSERT_POSITIONS:{14}
ZTST_test: examining line:

Running test: Documentation example for options, input "NOList"
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst NOList}{}
COMPADD:{}
INSERT_POSITIONS:{10}
NO:{NOListambiguous}
NO:{NOListbeep}
NO:{NOListpacked}
NO:{NOListrowsfirst}
NO:{NOListtypes}
line: {tst NOListBeep }{}
COMPADD:{}
INSERT_POSITIONS:{14}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:

ZTST_test: examining line:
 test_code $options_matcher example1_list
ZTST_getchunk: read code chunk:
 test_code $options_matcher example1_list
 comptest $'tst NO_List\t__\tB\t'
ZTST_test: examining line:
>line: {tst NO_List}{}
ZTST_getredir: read redir for '>':
line: {tst NO_List}{}
COMPADD:{}
INSERT_POSITIONS:{11}
NO:{NO_Listambiguous}
NO:{NO_Listbeep}
NO:{NO_Listpacked}
NO:{NO_Listrowsfirst}
NO:{NO_Listtypes}
line: {tst NO_List__}{}
COMPADD:{}
INSERT_POSITIONS:{13}
NO:{NO_List__ambiguous}
NO:{NO_List__beep}
NO:{NO_List__packed}
NO:{NO_List__rowsfirst}
NO:{NO_List__types}
line: {tst NO_List__Beep }{}
COMPADD:{}
INSERT_POSITIONS:{17}
ZTST_test: examining line:

Running test: Documentation example for options, input "NO_List\t__\tB\t"
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst NO_List}{}
COMPADD:{}
INSERT_POSITIONS:{11}
NO:{NO_Listambiguous}
NO:{NO_Listbeep}
NO:{NO_Listpacked}
NO:{NO_Listrowsfirst}
NO:{NO_Listtypes}
line: {tst NO_List__}{}
COMPADD:{}
INSERT_POSITIONS:{13}
NO:{NO_List__ambiguous}
NO:{NO_List__beep}
NO:{NO_List__packed}
NO:{NO_List__rowsfirst}
NO:{NO_List__types}
line: {tst NO_List__Beep }{}
COMPADD:{}
INSERT_POSITIONS:{17}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 test_code $options_matcher example1_list
ZTST_getchunk: read code chunk:
 test_code $options_matcher example1_list
 comptest $'tst __\tN\t__o\t___\tlist_\tbeep__\t'
ZTST_test: examining line:
>line: {tst __}{}
ZTST_getredir: read redir for '>':
line: {tst __}{}
COMPADD:{}
INSERT_POSITIONS:{6}
NO:{__kshoptionprint}
NO:{__listambiguous}
NO:{__listbeep}
NO:{__listpacked}
NO:{__listrowsfirst}
NO:{__listtypes}
NO:{__shglob}
NO:{__shinstdin}
NO:{__shnullcmd}
NO:{__shoptionletters}
NO:{__shortloops}
NO:{__shwordsplit}
line: {tst __N}{}
COMPADD:{}
INSERT_POSITIONS:{}
line: {tst __N__o}{}
COMPADD:{}
INSERT_POSITIONS:{}
line: {tst __N__o___}{}
COMPADD:{}
INSERT_POSITIONS:{}
line: {tst __N__o___list_}{}
COMPADD:{}
INSERT_POSITIONS:{}
line: {tst __N__o___list_beep__}{}
COMPADD:{}
INSERT_POSITIONS:{}
ZTST_test: examining line:

Running test: Documentation example for options, input "__\tN\t__o\t___\tlist_\tbeep__\t" 
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst __}{}
COMPADD:{}
INSERT_POSITIONS:{6}
NO:{__kshoptionprint}
NO:{__listambiguous}
NO:{__listbeep}
NO:{__listpacked}
NO:{__listrowsfirst}
NO:{__listtypes}
NO:{__shglob}
NO:{__shinstdin}
NO:{__shnullcmd}
NO:{__shoptionletters}
NO:{__shortloops}
NO:{__shwordsplit}
line: {tst __N}{}
COMPADD:{}
INSERT_POSITIONS:{}
line: {tst __N__o}{}
COMPADD:{}
INSERT_POSITIONS:{}
line: {tst __N__o___}{}
COMPADD:{}
INSERT_POSITIONS:{}
line: {tst __N__o___list_}{}
COMPADD:{}
INSERT_POSITIONS:{}
line: {tst __N__o___list_beep__}{}
COMPADD:{}
INSERT_POSITIONS:{}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 test_code $options_matcher example1_list
ZTST_getchunk: read code chunk:
 test_code $options_matcher example1_list
 comptest $'tst __\tNo\t___\tlist_\tbeep__\t'
ZTST_test: examining line:
>line: {tst __}{}
ZTST_getredir: read redir for '>':
line: {tst __}{}
COMPADD:{}
INSERT_POSITIONS:{6}
NO:{__kshoptionprint}
NO:{__listambiguous}
NO:{__listbeep}
NO:{__listpacked}
NO:{__listrowsfirst}
NO:{__listtypes}
NO:{__shglob}
NO:{__shinstdin}
NO:{__shnullcmd}
NO:{__shoptionletters}
NO:{__shortloops}
NO:{__shwordsplit}
line: {tst __No}{}
COMPADD:{}
INSERT_POSITIONS:{}
line: {tst __No___}{}
COMPADD:{}
INSERT_POSITIONS:{}
line: {tst __No___list_}{}
COMPADD:{}
INSERT_POSITIONS:{}
line: {tst __No___list_beep__}{}
COMPADD:{}
INSERT_POSITIONS:{}
ZTST_test: examining line:

Running test: Documentation example for options, input "__\tNo\t___\tlist_\tbeep__\t" 
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst __}{}
COMPADD:{}
INSERT_POSITIONS:{6}
NO:{__kshoptionprint}
NO:{__listambiguous}
NO:{__listbeep}
NO:{__listpacked}
NO:{__listrowsfirst}
NO:{__listtypes}
NO:{__shglob}
NO:{__shinstdin}
NO:{__shnullcmd}
NO:{__shoptionletters}
NO:{__shortloops}
NO:{__shwordsplit}
line: {tst __No}{}
COMPADD:{}
INSERT_POSITIONS:{}
line: {tst __No___}{}
COMPADD:{}
INSERT_POSITIONS:{}
line: {tst __No___list_}{}
COMPADD:{}
INSERT_POSITIONS:{}
line: {tst __No___list_beep__}{}
COMPADD:{}
INSERT_POSITIONS:{}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:

ZTST_test: examining line:
 test_code $options_matcher example1_list
ZTST_getchunk: read code chunk:
 test_code $options_matcher example1_list
 comptest $'tst ___\tlist_\tbeep__\t'
ZTST_test: examining line:
>line: {tst ___}{}
ZTST_getredir: read redir for '>':
line: {tst ___}{}
COMPADD:{}
INSERT_POSITIONS:{7}
NO:{___kshoptionprint}
NO:{___listambiguous}
NO:{___listbeep}
NO:{___listpacked}
NO:{___listrowsfirst}
NO:{___listtypes}
NO:{___shglob}
NO:{___shinstdin}
NO:{___shnullcmd}
NO:{___shoptionletters}
NO:{___shortloops}
NO:{___shwordsplit}
line: {tst ___list_}{}
COMPADD:{}
INSERT_POSITIONS:{12}
NO:{___list_ambiguous}
NO:{___list_beep}
NO:{___list_packed}
NO:{___list_rowsfirst}
NO:{___list_types}
line: {tst ___list_beep__ }{}
COMPADD:{}
INSERT_POSITIONS:{18}
ZTST_test: examining line:

Running test: Documentation example for options, input "___\tlist_\tbeep__\t" 
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst ___}{}
COMPADD:{}
INSERT_POSITIONS:{7}
NO:{___kshoptionprint}
NO:{___listambiguous}
NO:{___listbeep}
NO:{___listpacked}
NO:{___listrowsfirst}
NO:{___listtypes}
NO:{___shglob}
NO:{___shinstdin}
NO:{___shnullcmd}
NO:{___shoptionletters}
NO:{___shortloops}
NO:{___shwordsplit}
line: {tst ___list_}{}
COMPADD:{}
INSERT_POSITIONS:{12}
NO:{___list_ambiguous}
NO:{___list_beep}
NO:{___list_packed}
NO:{___list_rowsfirst}
NO:{___list_types}
line: {tst ___list_beep__ }{}
COMPADD:{}
INSERT_POSITIONS:{18}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 test_code 'B:[nN][oO]= M:_= M:{A-Z}={a-z}' example1_list
ZTST_getchunk: read code chunk:
 test_code 'B:[nN][oO]= M:_= M:{A-Z}={a-z}' example1_list
 comptest $'tst __no_listbe\t'
ZTST_test: examining line:
>line: {tst __no_listbeep }{}
ZTST_getredir: read redir for '>':
line: {tst __no_listbeep }{}
COMPADD:{}
INSERT_POSITIONS:{17}
ZTST_test: examining line:

Running test: Documentation example for options, input "__no_listbe"
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst __no_listbeep }{}
COMPADD:{}
INSERT_POSITIONS:{17}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 test_code 'B:[nN][oO]= M:_= M:{A-Z}={a-z}' example1_list
ZTST_getchunk: read code chunk:
 test_code 'B:[nN][oO]= M:_= M:{A-Z}={a-z}' example1_list
 comptest $'tst nonono_listbe\t'
ZTST_test: examining line:
>line: {tst nonono_listbeep }{}
ZTST_getredir: read redir for '>':
line: {tst nonono_listbeep }{}
COMPADD:{}
INSERT_POSITIONS:{19}
ZTST_test: examining line:

Running test: Documentation example for options, input "nonono_listbe"
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst nonono_listbeep }{}
COMPADD:{}
INSERT_POSITIONS:{19}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 lower_insensitive_M="M:{a-z}={A-Z}"
ZTST_getchunk: read code chunk:
 lower_insensitive_M="M:{a-z}={A-Z}"
 lower_insensitive_m="m:{a-z}={A-Z}"
 example2_list=(ABC Abc abc)
 test_code $lower_insensitive_M example2_list
 comptest $'tst ab\tC\t'
ZTST_test: examining line:
>line: {tst ab}{}
ZTST_getredir: read redir for '>':
line: {tst ab}{}
COMPADD:{}
INSERT_POSITIONS:{6}
NO:{abC}
NO:{abc}
line: {tst abC }{}
COMPADD:{}
INSERT_POSITIONS:{7}
ZTST_test: examining line:

Running test: Documentation example for lowercase insenitive M, input "ab\tC\t"
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst ab}{}
COMPADD:{}
INSERT_POSITIONS:{6}
NO:{abC}
NO:{abc}
line: {tst abC }{}
COMPADD:{}
INSERT_POSITIONS:{7}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 test_code $lower_insensitive_m example2_list
ZTST_getchunk: read code chunk:
 test_code $lower_insensitive_m example2_list
 comptest $'tst A\t\t'
ZTST_test: examining line:
>line: {tst A}{}
ZTST_getredir: read redir for '>':
line: {tst A}{}
COMPADD:{}
INSERT_POSITIONS:{5}
NO:{ABC}
NO:{Abc}
line: {tst ABC}{}
COMPADD:{}
INSERT_POSITIONS:{5}
ZTST_test: examining line:

Running test: Documentation example for lowercase insenitive m, input "A\t\t" 
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst A}{}
COMPADD:{}
INSERT_POSITIONS:{5}
NO:{ABC}
NO:{Abc}
line: {tst ABC}{}
COMPADD:{}
INSERT_POSITIONS:{5}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 example3_list=(ABC Abc abc)
ZTST_getchunk: read code chunk:
 example3_list=(ABC Abc abc)
 case_insensitive_M="M:{a-zA-Z}={A-Za-z}"
 case_insensitive_m="m:{a-zA-Z}={A-Za-z}"
 test_code $case_insensitive_M example3_list
 comptest $'tst aB\t\t'
ZTST_test: examining line:
>line: {tst aB}{}
ZTST_getredir: read redir for '>':
line: {tst aB}{}
COMPADD:{}
INSERT_POSITIONS:{6}
NO:{aBC}
NO:{aBc}
line: {tst aBC}{}
COMPADD:{}
INSERT_POSITIONS:{6}
ZTST_test: examining line:

Running test: Documentation example for case insenitive M, input "aB\t\t"
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst aB}{}
COMPADD:{}
INSERT_POSITIONS:{6}
NO:{aBC}
NO:{aBc}
line: {tst aBC}{}
COMPADD:{}
INSERT_POSITIONS:{6}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:

ZTST_test: examining line:
 test_code $case_insensitive_m example3_list
ZTST_getchunk: read code chunk:
 test_code $case_insensitive_m example3_list
 comptest $'tst aB\t\t'
ZTST_test: examining line:
>line: {tst a}{BC}
ZTST_getredir: read redir for '>':
line: {tst a}{BC}
COMPADD:{}
INSERT_POSITIONS:{5:7}
line: {tst a}{BC}
COMPADD:{}
INSERT_POSITIONS:{5:7}
NO:{ABC}
NO:{Abc}
NO:{abc}
ZTST_test: examining line:

Running test: Documentation example for case insenitive m, input "aB\t\t"
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst a}{BC}
COMPADD:{}
INSERT_POSITIONS:{5:7}
line: {tst a}{BC}
COMPADD:{}
INSERT_POSITIONS:{5:7}
NO:{ABC}
NO:{Abc}
NO:{abc}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
  example4_matcher='r:|.=* r:|=*'
ZTST_getchunk: read code chunk:
  example4_matcher='r:|.=* r:|=*'
  example4_list=(comp.sources.unix comp.sources.misc 
  comp.graphics.algorithms comp.graphics.animation comp.graphics.api
  comp.graphics.apps comp.graphics.misc comp.graphics.packages
  comp.graphics.rendering comp.graphics.visualization comp.graphics.apps.alias
  comp.graphics.apps.gimp comp.graphics.apps.gnuplot
  comp.graphics.apps.lightwave comp.graphics.apps.pagemaker
  comp.graphics.apps.paint-shop-pro comp.graphics.apps.photoshop
  comp.graphics.apps.softimage comp.graphics.apps.ulead
  comp.graphics.rendering.misc comp.graphics.rendering.raytracing
  comp.graphics.rendering.renderman)
 test_code $example4_matcher example4_list
 comptest $'tst c.s.u\t'
ZTST_test: examining line:
>line: {tst comp.sources.unix }{}
ZTST_getredir: read redir for '>':
line: {tst comp.sources.unix }{}
COMPADD:{}
INSERT_POSITIONS:{21}
ZTST_test: examining line:

Running test: Documentation example using input c.s.u
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst comp.sources.unix }{}
COMPADD:{}
INSERT_POSITIONS:{21}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 test_code $example4_matcher example4_list
ZTST_getchunk: read code chunk:
 test_code $example4_matcher example4_list
 comptest $'tst c.g.\ta\t.\tp\ta\tg\t'
ZTST_test: examining line:
>line: {tst comp.graphics.}{}
ZTST_getredir: read redir for '>':
line: {tst comp.graphics.}{}
COMPADD:{}
INSERT_POSITIONS:{18}
line: {tst comp.graphics.a}{}
COMPADD:{}
INSERT_POSITIONS:{19}
NO:{comp.graphics.algorithms}
NO:{comp.graphics.animation}
NO:{comp.graphics.api}
NO:{comp.graphics.apps}
NO:{comp.graphics.apps.alias}
NO:{comp.graphics.apps.gimp}
NO:{comp.graphics.apps.gnuplot}
NO:{comp.graphics.apps.lightwave}
NO:{comp.graphics.apps.pagemaker}
NO:{comp.graphics.apps.paint-shop-pro}
NO:{comp.graphics.apps.photoshop}
NO:{comp.graphics.apps.softimage}
NO:{comp.graphics.apps.ulead}
line: {tst comp.graphics.apps.}{}
COMPADD:{}
INSERT_POSITIONS:{23}
line: {tst comp.graphics.apps.p}{}
COMPADD:{}
INSERT_POSITIONS:{24}
NO:{comp.graphics.apps.pagemaker}
NO:{comp.graphics.apps.paint-shop-pro}
NO:{comp.graphics.apps.photoshop}
line: {tst comp.graphics.apps.pa}{}
COMPADD:{}
INSERT_POSITIONS:{25}
NO:{comp.graphics.apps.pagemaker}
NO:{comp.graphics.apps.paint-shop-pro}
line: {tst comp.graphics.apps.pagemaker }{}
COMPADD:{}
INSERT_POSITIONS:{32}
ZTST_test: examining line:

Running test: Documentation example using input c.g.\ta\t.\tp\ta\tg\t
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst comp.graphics.}{}
COMPADD:{}
INSERT_POSITIONS:{18}
line: {tst comp.graphics.a}{}
COMPADD:{}
INSERT_POSITIONS:{19}
NO:{comp.graphics.algorithms}
NO:{comp.graphics.animation}
NO:{comp.graphics.api}
NO:{comp.graphics.apps}
NO:{comp.graphics.apps.alias}
NO:{comp.graphics.apps.gimp}
NO:{comp.graphics.apps.gnuplot}
NO:{comp.graphics.apps.lightwave}
NO:{comp.graphics.apps.pagemaker}
NO:{comp.graphics.apps.paint-shop-pro}
NO:{comp.graphics.apps.photoshop}
NO:{comp.graphics.apps.softimage}
NO:{comp.graphics.apps.ulead}
line: {tst comp.graphics.apps.}{}
COMPADD:{}
INSERT_POSITIONS:{23}
line: {tst comp.graphics.apps.p}{}
COMPADD:{}
INSERT_POSITIONS:{24}
NO:{comp.graphics.apps.pagemaker}
NO:{comp.graphics.apps.paint-shop-pro}
NO:{comp.graphics.apps.photoshop}
line: {tst comp.graphics.apps.pa}{}
COMPADD:{}
INSERT_POSITIONS:{25}
NO:{comp.graphics.apps.pagemaker}
NO:{comp.graphics.apps.paint-shop-pro}
line: {tst comp.graphics.apps.pagemaker }{}
COMPADD:{}
INSERT_POSITIONS:{32}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 test_code $example4_matcher example4_list
ZTST_getchunk: read code chunk:
 test_code $example4_matcher example4_list
 comptest $'tst c...pag\t'
ZTST_test: examining line:
>line: {tst comp.graphics.apps.pagemaker }{}
ZTST_getredir: read redir for '>':
line: {tst comp.graphics.apps.pagemaker }{}
COMPADD:{}
INSERT_POSITIONS:{32}
ZTST_test: examining line:

Running test: Documentation example using input c...pag\t
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst comp.graphics.apps.pagemaker }{}
COMPADD:{}
INSERT_POSITIONS:{32}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 test_code $example4_matcher example4_list
ZTST_getchunk: read code chunk:
 test_code $example4_matcher example4_list
 comptest $'tst c...pa\tg\t'
ZTST_test: examining line:
>line: {tst comp.graphics.apps.pa}{}
ZTST_getredir: read redir for '>':
line: {tst comp.graphics.apps.pa}{}
COMPADD:{}
INSERT_POSITIONS:{25}
line: {tst comp.graphics.apps.pagemaker }{}
COMPADD:{}
INSERT_POSITIONS:{32}
ZTST_test: examining line:

Running test: Documentation example using input c...pa\tg\t
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst comp.graphics.apps.pa}{}
COMPADD:{}
INSERT_POSITIONS:{25}
line: {tst comp.graphics.apps.pagemaker }{}
COMPADD:{}
INSERT_POSITIONS:{32}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 example5_matcher='r:|[.,_-]=* r:|=*'
ZTST_getchunk: read code chunk:
 example5_matcher='r:|[.,_-]=* r:|=*'
 example5_list=(veryverylongfile.c veryverylongheader.h)
 test_code $example5_matcher example5_list
 comptest $'tst  v.c\tv.h\t'
ZTST_test: examining line:
>line: {tst  veryverylongfile.c }{}
ZTST_getredir: read redir for '>':
line: {tst  veryverylongfile.c }{}
COMPADD:{}
INSERT_POSITIONS:{23}
line: {tst  veryverylongfile.c veryverylongheader.h }{}
COMPADD:{}
INSERT_POSITIONS:{44}
ZTST_test: examining line:

Running test: Documentation example using input v.c\t
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst  veryverylongfile.c }{}
COMPADD:{}
INSERT_POSITIONS:{23}
line: {tst  veryverylongfile.c veryverylongheader.h }{}
COMPADD:{}
INSERT_POSITIONS:{44}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:

ZTST_test: examining line:
 example6_list=(LikeTHIS FooHoo 5foo123 5bar234)
ZTST_getchunk: read code chunk:
 example6_list=(LikeTHIS FooHoo 5foo123 5bar234)
 test_code 'r:|[A-Z0-9]=* r:|=*' example6_list
 comptest $'tst H\t'
ZTST_test: examining line:
>line: {tst H}{}
ZTST_getredir: read redir for '>':
line: {tst H}{}
COMPADD:{}
INSERT_POSITIONS:{}
ZTST_test: examining line:

Running test: Documentation example using "r:|[A-Z0-9]=* r:|=*", input H
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst H}{}
COMPADD:{}
INSERT_POSITIONS:{}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 test_code 'r:|[A-Z0-9]=* r:|=*' example6_list
ZTST_getchunk: read code chunk:
 test_code 'r:|[A-Z0-9]=* r:|=*' example6_list
 comptest $'tst 2\t'
ZTST_test: examining line:
>line: {tst 2}{}
ZTST_getredir: read redir for '>':
line: {tst 2}{}
COMPADD:{}
INSERT_POSITIONS:{}
ZTST_test: examining line:

Running test: Documentation example using "r:|[A-Z0-9]=* r:|=*", input 2
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst 2}{}
COMPADD:{}
INSERT_POSITIONS:{}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 test_code 'r:|[A-Z0-9]=** r:|=*' example6_list
ZTST_getchunk: read code chunk:
 test_code 'r:|[A-Z0-9]=** r:|=*' example6_list
 comptest $'tst H\t'
ZTST_test: examining line:
>line: {tst H}{}
ZTST_getredir: read redir for '>':
line: {tst H}{}
COMPADD:{}
INSERT_POSITIONS:{4}
NO:{FooHoo}
NO:{LikeTHIS}
ZTST_test: examining line:

Running test: Documentation example using "r:|[A-Z0-9]=** r:|=*", input H
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst H}{}
COMPADD:{}
INSERT_POSITIONS:{4}
NO:{FooHoo}
NO:{LikeTHIS}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 test_code 'r:|[A-Z0-9]=** r:|=*' example6_list
ZTST_getchunk: read code chunk:
 test_code 'r:|[A-Z0-9]=** r:|=*' example6_list
 comptest $'tst 2\t\t'
ZTST_test: examining line:
>line: {tst 5}{23}
ZTST_getredir: read redir for '>':
line: {tst 5}{23}
COMPADD:{}
INSERT_POSITIONS:{5:7}
line: {tst 5}{23}
COMPADD:{}
INSERT_POSITIONS:{5:7}
NO:{5bar234}
NO:{5foo123}
ZTST_test: examining line:

Running test: Documentation example using "r:|[A-Z0-9]=** r:|=*", input 2
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst 5}{23}
COMPADD:{}
INSERT_POSITIONS:{5:7}
line: {tst 5}{23}
COMPADD:{}
INSERT_POSITIONS:{5:7}
NO:{5bar234}
NO:{5foo123}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 example7_matcher="r:[^A-Z0-9]||[A-Z0-9]=** r:|=*"
ZTST_getchunk: read code chunk:
 example7_matcher="r:[^A-Z0-9]||[A-Z0-9]=** r:|=*"
 example7_list=($example6_list)
 test_code $example7_matcher example7_list
 comptest $'tst H\t2\t'
ZTST_test: examining line:
>line: {tst FooHoo }{}
ZTST_getredir: read redir for '>':
line: {tst FooHoo }{}
COMPADD:{}
INSERT_POSITIONS:{10}
line: {tst FooHoo 5bar234 }{}
COMPADD:{}
INSERT_POSITIONS:{18}
ZTST_test: examining line:

Running test: Documentation example using "r:[^A-Z0-9]||[A-Z0-9]=** r:|=*"
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst FooHoo }{}
COMPADD:{}
INSERT_POSITIONS:{10}
line: {tst FooHoo 5bar234 }{}
COMPADD:{}
INSERT_POSITIONS:{18}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:

ZTST_test: examining line:
 workers_7311_matcher="m:{a-z}={A-Z} r:|[.,_-]=* r:|=*"
ZTST_getchunk: read code chunk:
 workers_7311_matcher="m:{a-z}={A-Z} r:|[.,_-]=* r:|=*"
 workers_7311_list=(Abc-Def-Ghij.txt Abc-def.ghi.jkl_mno.pqr.txt Abc_def_ghi_jkl_mno_pqr.txt)
 test_code $workers_7311_matcher workers_7311_list
 comptest $'tst a-a\t'
ZTST_test: examining line:
>line: {tst a-a}{}
ZTST_getredir: read redir for '>':
line: {tst a-a}{}
COMPADD:{}
INSERT_POSITIONS:{}
ZTST_test: examining line:

Running test: Bug from workers 7311
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst a-a}{}
COMPADD:{}
INSERT_POSITIONS:{}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 test_code $workers_7311_matcher workers_7311_list
ZTST_getchunk: read code chunk:
 test_code $workers_7311_matcher workers_7311_list
 comptest $'tst a\t\t-d.\t'
ZTST_test: examining line:
>line: {tst Abc}{}
ZTST_getredir: read redir for '>':
line: {tst Abc}{}
COMPADD:{}
INSERT_POSITIONS:{7}
line: {tst Abc}{}
COMPADD:{}
INSERT_POSITIONS:{7}
NO:{Abc-Def-Ghij.txt}
NO:{Abc-def.ghi.jkl_mno.pqr.txt}
NO:{Abc_def_ghi_jkl_mno_pqr.txt}
line: {tst Abc-def.ghi.jkl_mno.pqr.txt }{}
COMPADD:{}
INSERT_POSITIONS:{31}
ZTST_test: examining line:

Running test: Bug from workers_7311 
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst Abc}{}
COMPADD:{}
INSERT_POSITIONS:{7}
line: {tst Abc}{}
COMPADD:{}
INSERT_POSITIONS:{7}
NO:{Abc-Def-Ghij.txt}
NO:{Abc-def.ghi.jkl_mno.pqr.txt}
NO:{Abc_def_ghi_jkl_mno_pqr.txt}
line: {tst Abc-def.ghi.jkl_mno.pqr.txt }{}
COMPADD:{}
INSERT_POSITIONS:{31}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 workers_10886_matcher="r:|[A-Z0-9]=* r:|=*"
ZTST_getchunk: read code chunk:
 workers_10886_matcher="r:|[A-Z0-9]=* r:|=*"
 workers_10886_list=(BW UWB W)
 test_code $workers_10886_matcher workers_10886_list
 comptest $'tst W\t'
ZTST_test: examining line:
>line: {tst W }{}
ZTST_getredir: read redir for '>':
line: {tst W }{}
COMPADD:{}
INSERT_POSITIONS:{5}
ZTST_test: examining line:

Running test: Bug from workers 10886
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst W }{}
COMPADD:{}
INSERT_POSITIONS:{5}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 workers_11081_matcher='m:{a-zA-Z}={A-Za-z} r:|[.,_-]=* r:[^A-Z0-9]||[A-Z0-9]=* r:[A-Z0-9]||[^A-Z0-9]=* r:[^0-9]||[0-9]=* r:|=*'
ZTST_getchunk: read code chunk:
 workers_11081_matcher='m:{a-zA-Z}={A-Za-z} r:|[.,_-]=* r:[^A-Z0-9]||[A-Z0-9]=* r:[A-Z0-9]||[^A-Z0-9]=* r:[^0-9]||[0-9]=* r:|=*'
 workers_11081_list=(build.out build.out1 build.out2)
 test_code $workers_11081_matcher workers_11081_list
 comptest $'tst bui\t\t\t'
ZTST_test: examining line:
>line: {tst build.out}{}
ZTST_getredir: read redir for '>':
line: {tst build.out}{}
COMPADD:{}
INSERT_POSITIONS:{13}
line: {tst build.out}{}
COMPADD:{}
INSERT_POSITIONS:{13}
NO:{build.out}
NO:{build.out1}
NO:{build.out2}
line: {tst build.out}{}
COMPADD:{}
INSERT_POSITIONS:{13}
ZTST_test: examining line:

Running test: Bug from workers 11081
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst build.out}{}
COMPADD:{}
INSERT_POSITIONS:{13}
line: {tst build.out}{}
COMPADD:{}
INSERT_POSITIONS:{13}
NO:{build.out}
NO:{build.out1}
NO:{build.out2}
line: {tst build.out}{}
COMPADD:{}
INSERT_POSITIONS:{13}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:

ZTST_test: examining line:
 workers_11388_matcher='r:|[:.]=* r:|=*'
ZTST_getchunk: read code chunk:
 workers_11388_matcher='r:|[:.]=* r:|=*'
 workers_11388_list=(a.b:0 c.d:1)
 test_code $workers_11388_matcher workers_11388_list
 comptest $'tst :\t'
ZTST_test: examining line:
>line: {tst :}{}
ZTST_getredir: read redir for '>':
line: {tst :}{}
COMPADD:{}
INSERT_POSITIONS:{}
ZTST_test: examining line:

Running test: Non-bug from workers 11388
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst :}{}
COMPADD:{}
INSERT_POSITIONS:{}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 workers_11388_matcher='r:|[:.]=** r:|=*'
ZTST_getchunk: read code chunk:
 workers_11388_matcher='r:|[:.]=** r:|=*'
 workers_11388_list=(a.b:0 c.d:1)
 test_code $workers_11388_matcher workers_11388_list
 comptest $'tst :\t'
ZTST_test: examining line:
>line: {tst .:}{}
ZTST_getredir: read redir for '>':
line: {tst .:}{}
COMPADD:{}
INSERT_POSITIONS:{4:5:6}
ZTST_test: examining line:

Running test: Non-bug from workers 11388
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst .:}{}
COMPADD:{}
INSERT_POSITIONS:{4:5:6}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 workers_11586_matcher='r:|.=** r:[^0-9]||[0-9]=**'
ZTST_getchunk: read code chunk:
 workers_11586_matcher='r:|.=** r:[^0-9]||[0-9]=**'
 workers_11586_list=(c00.abc c01.abc.def.00.0)
 test_code $workers_11586_matcher workers_11586_list
 comptest $'tst c00\t.\ta\t'
ZTST_test: examining line:
>line: {tst c00}{}
ZTST_getredir: read redir for '>':
line: {tst c00}{}
COMPADD:{}
INSERT_POSITIONS:{6}
NO:{c00.abc}
NO:{c01.abc.def.00.0}
line: {tst c00.}{}
COMPADD:{}
INSERT_POSITIONS:{7:8}
NO:{c00.abc}
NO:{c01.abc.def.00.0}
line: {tst c00.abc }{}
COMPADD:{}
INSERT_POSITIONS:{11}
ZTST_test: examining line:

Running test: Bug from workers 11586
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst c00}{}
COMPADD:{}
INSERT_POSITIONS:{6}
NO:{c00.abc}
NO:{c01.abc.def.00.0}
line: {tst c00.}{}
COMPADD:{}
INSERT_POSITIONS:{7:8}
NO:{c00.abc}
NO:{c01.abc.def.00.0}
line: {tst c00.abc }{}
COMPADD:{}
INSERT_POSITIONS:{11}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 workers_12995a_matcher='r:|/=* r:|=*'
ZTST_getchunk: read code chunk:
 workers_12995a_matcher='r:|/=* r:|=*'
 workers_12995a_list=(u1 u1/q1 u1/q1/e1 u2 u2/q1 u2/q1/e2 u2/q1/e2/a1 u2/q1/e2/a2 u3 u3/q1 u4 u4/q u4/q/a1 u4/q/a2)
 test_code $workers_12995a_matcher workers_12995a_list
 comptest $'tst u/q/a\t'
ZTST_test: examining line:
>line: {tst u4/q/a}{}
ZTST_getredir: read redir for '>':
line: {tst u4/q/a}{}
COMPADD:{}
INSERT_POSITIONS:{10}
ZTST_test: examining line:

Running test: First test from workers 12995
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst u4/q/a}{}
COMPADD:{}
INSERT_POSITIONS:{10}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 workers_12995b_matcher='m:{a-z}={A-Z} r:|/=* r:|=*'
ZTST_getchunk: read code chunk:
 workers_12995b_matcher='m:{a-z}={A-Z} r:|/=* r:|=*'
 workers_12995b_list=(../Completion/Core ../Completion/Commands)
 test_code $workers_12995b_matcher workers_12995b_list 
 comptest $'tst ../com/cor\002\002\002\002\002\002\002\t'
ZTST_test: examining line:
>line: {tst ../Completion/Core }{}
ZTST_getredir: read redir for '>':
line: {tst ../Completion/Core }{}
COMPADD:{}
INSERT_POSITIONS:{22}
ZTST_test: examining line:

Running test: Second test from workers 12995
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst ../Completion/Core }{}
COMPADD:{}
INSERT_POSITIONS:{22}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 workers_13320_matcher='r:|[.,_-]=** r:[^0-9]||[0-9]=**'
ZTST_getchunk: read code chunk:
 workers_13320_matcher='r:|[.,_-]=** r:[^0-9]||[0-9]=**'
 workers_13320_list=(glibc-2.1.94-3.i386.rpm glibc-devel-2.1.94-3.i386.rpm)
 workers_13320_list=($workers_13320_list  glibc-profile-2.1.94-3.i386.rpm)
 test_code $workers_13320_matcher workers_13320_list
 comptest $'tst glibc-2.1\t'
ZTST_test: examining line:
>line: {tst glibc}{-2.1.94-3.i386.rpm}
ZTST_getredir: read redir for '>':
line: {tst glibc}{-2.1.94-3.i386.rpm}
COMPADD:{}
INSERT_POSITIONS:{9:27}
ZTST_test: examining line:

Running test: Test from workers 13320
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst glibc}{-2.1.94-3.i386.rpm}
COMPADD:{}
INSERT_POSITIONS:{9:27}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 test_code $workers_13320_matcher workers_13320_list
ZTST_getchunk: read code chunk:
 test_code $workers_13320_matcher workers_13320_list
 comptest $'tst g-2\t'
ZTST_test: examining line:
>line: {tst glibc}{-2.1.94-3.i386.rpm}
ZTST_getredir: read redir for '>':
line: {tst glibc}{-2.1.94-3.i386.rpm}
COMPADD:{}
INSERT_POSITIONS:{9:27}
ZTST_test: examining line:

Running test: Test from workers 13320
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst glibc}{-2.1.94-3.i386.rpm}
COMPADD:{}
INSERT_POSITIONS:{9:27}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 workers_13345a_matcher='r:|[.,_-]=**'
ZTST_getchunk: read code chunk:
 workers_13345a_matcher='r:|[.,_-]=**'
 workers_13345a_list=(A.B.C A.B.C.D A.C)
 test_code $workers_13345a_matcher workers_13345a_list
 comptest $'tst A.C\t'
ZTST_test: examining line:
>line: {tst A.C}{}
ZTST_getredir: read redir for '>':
line: {tst A.C}{}
COMPADD:{}
INSERT_POSITIONS:{5:7}
NO:{A.B.C}
NO:{A.B.C.D}
NO:{A.C}
ZTST_test: examining line:

Running test: First test from workers 13345
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst A.C}{}
COMPADD:{}
INSERT_POSITIONS:{5:7}
NO:{A.B.C}
NO:{A.B.C.D}
NO:{A.C}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:

ZTST_test: examining line:
 workers_13345b_matcher='r:|[.,_-]=** r:[^0-9]||[0-9]=**'
ZTST_getchunk: read code chunk:
 workers_13345b_matcher='r:|[.,_-]=** r:[^0-9]||[0-9]=**'
 workers_13345b_list=(a-b_1_2_2  a-b_2_0.gz a-b_2_0.zip)
 test_code $workers_13345b_matcher workers_13345b_list
 comptest $'tst a-b_2\t'
ZTST_test: examining line:
>line: {tst a-b_2_}{}
ZTST_getredir: read redir for '>':
line: {tst a-b_2_}{}
COMPADD:{}
INSERT_POSITIONS:{8:10}
ZTST_test: examining line:

Running test: Second test from workers 13345
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst a-b_2_}{}
COMPADD:{}
INSERT_POSITIONS:{8:10}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 workers_13382_matcher='r:|.=**'
ZTST_getchunk: read code chunk:
 workers_13382_matcher='r:|.=**'
 workers_13382_list=(a.b.c  a.b.c.d  aA.bB.cB.dA  aA.bB.cC.dD  aD.bC.cB.dA aA.bC.cB.dA)
 test_code $workers_13382_matcher workers_13382_list
 comptest $'tst a...\tA\tC\t'
ZTST_test: examining line:
>line: {tst a.b.c.d}{}
ZTST_getredir: read redir for '>':
line: {tst a.b.c.d}{}
COMPADD:{}
INSERT_POSITIONS:{5:7:9:11}
line: {tst a.b}{.cB.dA}
COMPADD:{}
INSERT_POSITIONS:{5:7:13}
line: {tst a}{.bC.cB.dA}
COMPADD:{}
INSERT_POSITIONS:{5:14}
NO:{aA.bC.cB.dA}
NO:{aD.bC.cB.dA}
ZTST_test: examining line:

Running test: Test for insert positions
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst a.b.c.d}{}
COMPADD:{}
INSERT_POSITIONS:{5:7:9:11}
line: {tst a.b}{.cB.dA}
COMPADD:{}
INSERT_POSITIONS:{5:7:13}
line: {tst a}{.bC.cB.dA}
COMPADD:{}
INSERT_POSITIONS:{5:14}
NO:{aA.bC.cB.dA}
NO:{aD.bC.cB.dA}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:

ZTST_test: examining line:
%clean
ZTST_test: all tests successful
ZTST_getsect: read section name: clean
ZTST_getchunk: read code chunk:
  zmodload -ui zsh/zpty
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:

../../zsh-4.0.1-pre-5/Test/Y02compmatch.ztst: all tests successful.
../../zsh-4.0.1-pre-5/Test/Y03arguments.ztst: starting.
ZTST_getsect: read section name: prep
ZTST_getchunk: read code chunk:
  . $ZTST_srcdir/comptest
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:
  mkdir comp.tmp
  cd comp.tmp
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:
  comptestinit -z $ZTST_testdir/../Src/zsh
  comptesteval 'compdef _tst tst'
  tst_arguments () { comptesteval "_tst () { _arguments ${${(@qq)*}} }" }
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:

ZTST_getsect: read section name: test
ZTST_test: looking for new test
ZTST_test: examining line:
 tst_arguments ':desc1:(arg1)'
ZTST_getchunk: read code chunk:
 tst_arguments ':desc1:(arg1)'
 comptest $'tst \t\C-wa\t\C-war\t\C-warg\t\C-warg1\t\C-wr\t\C-wx\t \ty \t'
ZTST_test: examining line:
>line: {tst arg1 }{}
ZTST_getredir: read redir for '>':
line: {tst arg1 }{}
line: {tst arg1 }{}
line: {tst arg1 }{}
line: {tst arg1 }{}
line: {tst arg1 }{}
line: {tst r}{}
line: {tst x}{}
line: {tst x }{}
MESSAGE:{no more arguments}
line: {tst x y }{}
MESSAGE:{no more arguments}
ZTST_test: examining line:

Running test: one non-option argument
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst arg1 }{}
line: {tst arg1 }{}
line: {tst arg1 }{}
line: {tst arg1 }{}
line: {tst arg1 }{}
line: {tst r}{}
line: {tst x}{}
line: {tst x }{}
MESSAGE:{no more arguments}
line: {tst x y }{}
MESSAGE:{no more arguments}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 tst_arguments ':desc1:(a b)'
ZTST_getchunk: read code chunk:
 tst_arguments ':desc1:(a b)'
 comptest $'tst \t'
ZTST_test: examining line:
>line: {tst }{}
ZTST_getredir: read redir for '>':
line: {tst }{}
DESCRIPTION:{desc1}
NO:{a}
NO:{b}
ZTST_test: examining line:

Running test: a and b
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst }{}
DESCRIPTION:{desc1}
NO:{a}
NO:{b}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 tst_arguments ':desc1:(arg1)' ':desc2:(arg2)' ':desc3:(arg3)'
ZTST_getchunk: read code chunk:
 tst_arguments ':desc1:(arg1)' ':desc2:(arg2)' ':desc3:(arg3)'
 comptest $'tst \t\t\t\C-w\C-w\C-w\C-d'
ZTST_test: examining line:
>line: {tst arg1 }{}
ZTST_getredir: read redir for '>':
line: {tst arg1 }{}
line: {tst arg1 arg2 }{}
line: {tst arg1 arg2 arg3 }{}
DESCRIPTION:{desc1}
NO:{arg1}
ZTST_test: examining line:

Running test: three arguments
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst arg1 }{}
line: {tst arg1 arg2 }{}
line: {tst arg1 arg2 arg3 }{}
DESCRIPTION:{desc1}
NO:{arg1}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 tst_arguments '1:desc1:(arg1)'
ZTST_getchunk: read code chunk:
 tst_arguments '1:desc1:(arg1)'
 comptest $'tst \t\t'
ZTST_test: examining line:
>line: {tst arg1 }{}
ZTST_getredir: read redir for '>':
line: {tst arg1 }{}
line: {tst arg1 }{}
MESSAGE:{no more arguments}
ZTST_test: examining line:

Running test: first argument
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst arg1 }{}
line: {tst arg1 }{}
MESSAGE:{no more arguments}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 tst_arguments '-\+[opt]'
ZTST_getchunk: read code chunk:
 tst_arguments '-\+[opt]'
 comptest $'tst -\C-d'
ZTST_test: examining line:
>DESCRIPTION:{option}
ZTST_getredir: read redir for '>':
DESCRIPTION:{option}
NO:{-+ -- opt}
ZTST_test: examining line:

Running test: -+
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
DESCRIPTION:{option}
NO:{-+ -- opt}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 tst_arguments -+o
ZTST_getchunk: read code chunk:
 tst_arguments -+o
 comptest $'tst -\t\t\t\C-w\C-w+\t\t\t'
ZTST_test: examining line:
>line: {tst -o }{}
ZTST_getredir: read redir for '>':
line: {tst -o }{}
line: {tst -o +o }{}
line: {tst -o +o }{}
MESSAGE:{no arguments}
line: {tst +o }{}
line: {tst +o -o }{}
line: {tst +o -o }{}
MESSAGE:{no arguments}
ZTST_test: examining line:

Running test: option beginning with + and -.
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst -o }{}
line: {tst -o +o }{}
line: {tst -o +o }{}
MESSAGE:{no arguments}
line: {tst +o }{}
line: {tst +o -o }{}
line: {tst +o -o }{}
MESSAGE:{no arguments}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 tst_arguments '-o:1:(a):2:(b)'
ZTST_getchunk: read code chunk:
 tst_arguments '-o:1:(a):2:(b)'
 comptest $'tst \t\t\t'
ZTST_test: examining line:
>line: {tst -o }{}
ZTST_getredir: read redir for '>':
line: {tst -o }{}
line: {tst -o a }{}
line: {tst -o a b }{}
ZTST_test: examining line:

Running test: two option arguments
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst -o }{}
line: {tst -o a }{}
line: {tst -o a b }{}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 tst_arguments '-x:arg:'
ZTST_getchunk: read code chunk:
 tst_arguments '-x:arg:'
 comptest $'tst -x\t'
ZTST_test: examining line:
>line: {tst -x }{}
ZTST_getredir: read redir for '>':
line: {tst -x }{}
ZTST_test: examining line:

Running test: sticky option argument
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst -x }{}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 tst_arguments '-x[desc]'
ZTST_getchunk: read code chunk:
 tst_arguments '-x[desc]'
 comptest $'tst -x\t'
ZTST_test: examining line:
>line: {tst -x }{}
ZTST_getredir: read redir for '>':
line: {tst -x }{}
ZTST_test: examining line:

Running test: end of option sequence
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst -x }{}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 tst_arguments '-x' ':arg:'
ZTST_getchunk: read code chunk:
 tst_arguments '-x' ':arg:'
 comptest $'tst -\t'
ZTST_test: examining line:
>line: {tst -}{}
ZTST_getredir: read redir for '>':
line: {tst -}{}
MESSAGE:{arg}
DESCRIPTION:{option}
NO:{-x}
ZTST_test: examining line:

Running test: argument beginning with minus
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst -}{}
MESSAGE:{arg}
DESCRIPTION:{option}
NO:{-x}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 tst_arguments '-o::optarg:(oa)' ':arg1:(a1)'
ZTST_getchunk: read code chunk:
 tst_arguments '-o::optarg:(oa)' ':arg1:(a1)'
 comptest $'tst -o\t\t'
ZTST_test: examining line:
>line: {tst -o }{}
ZTST_getredir: read redir for '>':
line: {tst -o }{}
line: {tst -o }{}
DESCRIPTION:{optarg}
NO:{oa}
DESCRIPTION:{arg1}
NO:{a1}
ZTST_test: examining line:

Running test: optional option argument
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst -o }{}
line: {tst -o }{}
DESCRIPTION:{optarg}
NO:{oa}
DESCRIPTION:{arg1}
NO:{a1}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 tst_arguments '-o:*a:a:(a)' ':A:(A)' ':B:(B)'
ZTST_getchunk: read code chunk:
 tst_arguments '-o:*a:a:(a)' ':A:(A)' ':B:(B)'
 comptest $'tst A -o a \t'
ZTST_test: examining line:
>line: {tst A -o a B }{}
ZTST_getredir: read redir for '>':
line: {tst A -o a B }{}
ZTST_test: examining line:

Running test: variable length option arguments
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst A -o a B }{}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 tst_arguments -s '-a' '-b' ':descr:{compadd - $+opt_args[-a]}'
ZTST_getchunk: read code chunk:
 tst_arguments -s '-a' '-b' ':descr:{compadd - $+opt_args[-a]}'
 comptest $'tst -ab \t'
ZTST_test: examining line:
>line: {tst -ab 1 }{}
ZTST_getredir: read redir for '>':
line: {tst -ab 1 }{}
ZTST_test: examining line:

Running test: opt_args
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst -ab 1 }{}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 tst_arguments '-a' '*::rest:{compadd - -b}'
ZTST_getchunk: read code chunk:
 tst_arguments '-a' '*::rest:{compadd - -b}'
 comptest $'tst arg -\t'
ZTST_test: examining line:
>line: {tst arg -b }{}
ZTST_getredir: read redir for '>':
line: {tst arg -b }{}
ZTST_test: examining line:

Running test: rest arguments
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst arg -b }{}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 tst_arguments '-e:*last:::b:{compadd "${(j:,:)words}"}' ':arg1:(arg1)'
ZTST_getchunk: read code chunk:
 tst_arguments '-e:*last:::b:{compadd "${(j:,:)words}"}' ':arg1:(arg1)'
 comptest $'tst -\t\tla\t\C-hst\t\t\eb\eb\C-b\t\t'
ZTST_test: examining line:
>line: {tst -e }{}
ZTST_getredir: read redir for '>':
line: {tst -e }{}
line: {tst -e  }{}
line: {tst -e  la }{}
line: {tst -e  last }{}
line: {tst -e  last arg1 }{}
line: {tst -e ,last }{ last arg1}
line: {tst -e ,last ,last,,last }{ last arg1}
ZTST_test: examining line:

Running test: words array in rest arguments
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst -e }{}
line: {tst -e  }{}
line: {tst -e  la }{}
line: {tst -e  last }{}
line: {tst -e  last arg1 }{}
line: {tst -e ,last }{ last arg1}
line: {tst -e ,last ,last,,last }{ last arg1}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 tst_arguments -s '-d+:msg1:' '*::msg2:{compadd $CURRENT}' 
ZTST_getchunk: read code chunk:
 tst_arguments -s '-d+:msg1:' '*::msg2:{compadd $CURRENT}' 
 comptest $'tst add \t\t\t'
ZTST_test: examining line:
>line: {tst add 2 }{}
ZTST_getredir: read redir for '>':
line: {tst add 2 }{}
line: {tst add 2 3 }{}
line: {tst add 2 3 4 }{}
ZTST_test: examining line:

Running test: opt_args
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst add 2 }{}
line: {tst add 2 3 }{}
line: {tst add 2 3 4 }{}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
 tst_arguments -s '-a' '-b' '-c' ':words:compadd - abyyy abzzz' 
ZTST_getchunk: read code chunk:
 tst_arguments -s '-a' '-b' '-c' ':words:compadd - abyyy abzzz' 
 comptest $'tst ab\t'
ZTST_test: examining line:
>line: {tst ab}{}
ZTST_getredir: read redir for '>':
line: {tst ab}{}
DESCRIPTION:{words}
NO:{abyyy}
NO:{abzzz}
ZTST_test: examining line:

Running test: options and words (zsh-workers:12257)
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
ZTST_test: test produced standard output:
line: {tst ab}{}
DESCRIPTION:{words}
NO:{abyyy}
NO:{abzzz}
ZTST_test: and standard error:

Test successful.
ZTST_test: looking for new test
ZTST_test: examining line:

ZTST_test: examining line:
%clean
ZTST_test: all tests successful
ZTST_getsect: read section name: clean
ZTST_getchunk: read code chunk:
  zmodload -ui zsh/zpty
ZTST_execchunk: status 0
ZTST_getchunk: read code chunk:

../../zsh-4.0.1-pre-5/Test/Y03arguments.ztst: all tests successful.
rm -rf Modules .zcompdump
make[1]: Leaving directory `/tmp/obj-sun/Test'


Messages sorted by: Reverse Date, Date, Thread, Author