* 4.0.1-pre-5
@ 2001-05-22 9:23 Peter Stephenson
2001-05-22 15:11 ` 4.0.1-pre-5 (solaris issues) Jason Price
0 siblings, 1 reply; 7+ messages in thread
From: Peter Stephenson @ 2001-05-22 9:23 UTC (permalink / raw)
To: Zsh users list
I've uploaded
ftp://ftp.zsh.org/pub/development/zsh-4.0.1-pre-5.tar.gz
ftp://ftp.zsh.org/pub/development/zsh-4.0.1-pre-5.tar.bz2
There are no major changes this time, and the configuration problems seem
to have been resolved, so I will probably release 4.0.1 next week if
nothing serious turns up. If you aren't having any of the problems listed
below, you can probably just wait for the official release.
This isn't quite up to date with the archive, since I prepared it yesterday
when we were having problems with outgoing mail.
2001-05-21 Peter Stephenson <pws@csr.com>
* 14408: Test/C02cond.ztst: do chmod +w to work around rm -f
problem in Cygwin.
* unposted: Test/.distfiles: add Test/E01options.ztst.
2001-05-20 Peter Stephenson <pws@pwstephenson.fsnet.co.uk>
* 14396: Src/params.c, Test/D04paramater.ztst, Doc/Zsh/params.yo:
Fix bug that though path/PATH etc. were unset as a pair, they
didn't get recreated as a pair despite remaining special. Add
tests for this and fix in 14388. Add documentation for special
ties like path and PATH.
2001-05-20 Bart Schaefer <schaefer@zsh.org>
* unposted: Test/ztst.zsh: Handle line wrapping in ZTST_hashmark.
2001-05-20 Andrej Borsenkow <bor@zsh.org>
* 14401: Makefile.in, configure.in, Config/config.mk,
Config/installfns.sh, Doc/Makefile.in, Src/Makefile.in,
Src/mkmakemod.sh: do not assume scripts are directly executable
(they are not always on Cygwin) - use `sh script' instead
2001-05-20 Wayne Davison <wayned@users.sourceforge.net>
* last half of 14390: Src/params.c: Added some boundary checks
to the array-assignment code.
2001-05-19 Wayne Davison <wayned@users.sourceforge.net>
* 14389: Src/hashtable.c, Src/hist.c: Don't call addhistnode()
or removehashnode() on a HIST_TMPSTORE entry. Don't merge a
HIST_TMPSTORE entry with a previous "duplicate" line.
2001-05-18 Bart Schaefer <schaefer@zsh.org>
* 14388: Src/params.c, Src/subst.c: Correctly handle re-set of
of integer-typed special parameters such as SHLVL, after unset.
* 14385: Test/V01zmodload.ztst, Test/ztst.zsh: Fix typo in a
comment; print a warning when unable to test zsh/example; make
sure the file descriptor for that warning (and others in other
test files) is available even if ZTST_verbose has an unexpected
value.
2001-05-18 Peter Stephenson <pws@csr.com>
* not posted: Test/ztst.zsh, Test/E01options.ztst: added some more
options; made ztst.zsh more robust about ksharrays being set by
a test.
* 14382: Src/module.c: zmodload -uf wouldn't work even if the
math function hadn't been loaded yet.
2001-05-18 Sven Wischnowsky <wischnow@zsh.org>
* 14381: Src/subst.c: try to make ${(e)..} work for complicated
parameter expansions in the value; this means: keep Qstring
tokens unchanged if they are inside double quotes and
tokenizing patterns in parameter expansions
2001-05-18 Bart Schaefer <schaefer@zsh.org>
* unposted: Test/.distfiles, Test/V01zmodload.ztst: Add the basic
tests of zmodload functionality.
2001-05-18 Clint Adams <clint@zsh.org>
* 14378: Completion/Unix/Type/_tex: also work for
pdflatex, jadetex, and pdfjadetex.
2001-05-17 Tanaka Akira <akr@zsh.org>
* 14377: Completion/Unix/Command/_cvs: support new .cvspass format
introduced by cvs-1.11.1.
2001-05-17 Peter Stephenson <pws@csr.com>
* 14376: Completion/Unix/Command/_lp: type with compset.
2001-05-17 Bart Schaefer <schaefer@zsh.org>
* 14375: Src/Zle/zle_main.c: Permit signals to be handled during
read from the terminal in zleread(). (This changes only nested
calls from widgets such as incremental search; signals were never
queued for top-level reads.)
2001-05-16 Clint Adams <clint@zsh.org>
* 14361, 14362: Completion/Unix/Command/_modutils: use
state for modprobe so that modprobe -r will
complete multiple loaded modules. Also
handle more of modprobe's options.
2001-05-16 Sven Wischnowsky <wischnow@zsh.org>
* 14359: Src/Zle/zle_tricky.c: more fixage for expansion: just
convert the command line to the original when expansion
shouldn't or couldn't do something sensible on the line
2001-05-15 Wayne Davison <wayned@users.sourceforge.net>
* 14357: Src/hashtable.c, Src/hist.c, Src/zsh.h, Doc/Zsh/options.yo:
Added a "delayed drop" for ignored history entries.
2001-05-15 Oliver Kiddle <opk@zsh.org>
* 14355: Completion/Unix/Command/_modutils: fix bug where /sbin/lsmod
was redirected in instead of being run
2001-05-15 Sven Wischnowsky <wischnow@zsh.org>
* 14350: Completion/Base/Completer/_expand, Src/Zle/zle_tricky.c:
don't remove single and double quotes that are inside parameter
expansions; hopefully better handling of brace expansions in
_expand
2001-05-15 Peter Stephenson <pws@csr.com>
* 14348: Src/builtin.c: some idiot forgot to make GLOBAL_EXPORT
work with typeset -g.
2001-05-15 Sven Wischnowsky <wischnow@zsh.org>
* 14346: Src/parse.c: calculate the length of the region to map
(for mapped zwc files) correctly, including the
offset-page-boundary-adjustment
2001-05-15 Clint Adams <clint@zsh.org>
* 14341: Completion/Unix/Command/.distfiles,
Completion/Unix/Command/_modutils:
complete loaded Linux kernel modules for
rmmod or modprobe -r.
2001-05-14 Peter Stephenson <pws@csr.com>
* 14330: Completion/Base/Widget/_most_recent_file: handle filenames
which need quoted characters better.
2001-05-14 Sven Wischnowsky <wischnow@zsh.org>
* 14327: Src/exec.c: set list_pipe_job only for real pipelines
2001-05-11 Peter Stephenson <pws@csr.com>
* 14314: Src/Modules/stat.c: writing const variable under cygwin.
* 14313: Test/E01options.ztst, Test/ztst.zsh: new options tests.
2001-05-10 Wayne Davison <wayned@users.sourceforge.net>
* 14304: Src/hist.c: Fixed an obscure local-history bug that could
make the "history" command output something that was slightly wrong.
2001-05-10 Andrej Borsenkow <bor@zsh.org>
* users/3872: Src/Modules/zftp.c: rename inet_* to avoid clash
with Solaris 7 headers.
2001-05-10 Tanaka Akira <akr@zsh.org>
* 14295: Completion/Unix/Command/_cvs: support new cvs subcommands
`rannotate' and `rlog' introduced by cvs-1.11.1.
2001-05-10 Sven Wischnowsky <wischnow@zsh.org>
* 14293: Src/Zle/computil.c: barf if a empty string is given as
one of the separators for _values
2001-05-09 Bart Schaefer <schaefer@zsh.org>
* unposted: configure.in: Clean up 14275+14290 a bit at Andrej's
urging so as not to violate quite so many autoconf usage rules.
* 14290: configure.in: Use a different cache variable for the
Solaris-curses.h-mistake-fix from 14275.
2001-05-09 Oliver Kiddle <opk@zsh.org>
* 14266, 14283: Etc/FEATURES, StartupFiles/zshrc: update; in
particular to use new style completion in example startup file.
* 14282: Completion/Unix/Command/_chown: complete only files
that can be chowned.
* 14281: Completion/Base/Completer/_expand: insert redirection
operators when expanding after a redirection operator.
--
Peter Stephenson <pws@csr.com> Software Engineer
CSR Ltd., Unit 300, Science Park, Milton Road,
Cambridge, CB4 0XL, UK Tel: +44 (0)1223 392070
**********************************************************************
The information transmitted is intended only for the person or
entity to which it is addressed and may contain confidential
and/or privileged material.
Any review, retransmission, dissemination or other use of, or
taking of any action in reliance upon, this information by
persons or entities other than the intended recipient is
prohibited.
If you received this in error, please contact the sender and
delete the material from any computer.
**********************************************************************
^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: 4.0.1-pre-5 (solaris issues)
2001-05-22 9:23 4.0.1-pre-5 Peter Stephenson
@ 2001-05-22 15:11 ` Jason Price
2001-05-22 15:29 ` Bart Schaefer
2001-05-22 15:59 ` Clint Adams
0 siblings, 2 replies; 7+ messages in thread
From: Jason Price @ 2001-05-22 15:11 UTC (permalink / raw)
To: zsh-users; +Cc: Zsh users list
Some solaris issues still seem to linger around in pre-5.
In Solaris 8. This is from part of 'make test' with a strait './configure ;
make':
./A04redirect.ztst: starting.
*** /tmp/zsh.ztst.out.10981 Tue May 22 10:41:37 2001
--- /tmp/zsh.ztst.tout.10981 Tue May 22 10:41:37 2001
***************
*** 1,3 ****
out1 out2
! out1: All files
! out2: All files
--- 1,3 ----
out1 out2
! out1:
! out2:
Test ./A04redirect.ztst failed: output differs from expected as shown above
for:
print *
print "out1: $(<out1)\nout2: $(<out2)"
Was testing: read multio with globbing
And later in make test:
./V01zmodload.ztst: starting.
Segmentation Fault
------------------------------------------------------------------------------
In Solaris 7. This is also from 'make test' with './configure ; make':
./V01zmodload.ztst: starting.
Segmentation Fault
------------------------------------------------------------------------------
And in solaris 2.6, we've got lots of issues. First and formost, it won't
compile out of the box. When it does, you get:
gcc -c -I. -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -DHAVE_CONFIG_H -Wall
-Wno-implicit -Wmissing-prototypes -O2 -o exec.o exec.c
In file included from /usr/include/sys/wait.h:24,
from system.h:243,
from zsh.mdh:15,
from exec.c:30:
/usr/include/sys/resource.h:148: warning: `struct rlimit64' declared inside
parameter list
/usr/include/sys/resource.h:148: warning: its scope is only this definition
or declaration,
/usr/include/sys/resource.h:148: warning: which is probably not what you
want.
/usr/include/sys/resource.h:149: warning: `struct rlimit64' declared inside
parameter list
exec.c: In function `zsetlimit':
exec.c:179: invalid use of undefined type `struct rlimit64'
exec.c:179: invalid use of undefined type `struct rlimit64'
exec.c:180: invalid use of undefined type `struct rlimit64'
exec.c:180: invalid use of undefined type `struct rlimit64'
exec.c:181: arithmetic on pointer to an incomplete type
exec.c:181: warning: passing arg 2 of `setrlimit64' from incompatible
pointer type
exec.c:186: invalid use of undefined type `struct rlimit64'
exec.c:186: invalid use of undefined type `struct rlimit64'
exec.c: At top level:
exec.c:173: storage size of `current_limits' isn't known
exec.c:173: storage size of `limits' isn't known
make[2]: *** [exec.o] Error 1
make[2]: Leaving directory `/export/home/jprice/programs/zsh/zsh-lfs/Src'
make[1]: *** [modobjs] Error 2
make[1]: Leaving directory `/export/home/jprice/programs/zsh/zsh-lfs/Src'
make: *** [all] Error 1
and there are a fair number of other warnings in the make process. I can
send it along if needed.
Also, in solaris 2.6, if you do a './configure --disable-lfs ; make ; make
test', you get:
./V01zmodload.ztst: starting.
Segmentation Fault
I can give any more details that people may need/want. Let me know.
Jason
--
"Friendship is the bridge between lonely and loved, between a glance and a
gaze. It stretches from the fog into sunshine, hopelessness into faith,
between despair and joy. It crosses the chasm from hell and to heaven, from
God to man, and from you to me." --Unknown Jason Price jprice@gatech.edu
^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: 4.0.1-pre-5 (solaris issues)
2001-05-22 15:11 ` 4.0.1-pre-5 (solaris issues) Jason Price
@ 2001-05-22 15:29 ` Bart Schaefer
2001-05-22 15:42 ` Jason Price
2001-05-22 16:03 ` Andrej Borsenkow
2001-05-22 15:59 ` Clint Adams
1 sibling, 2 replies; 7+ messages in thread
From: Bart Schaefer @ 2001-05-22 15:29 UTC (permalink / raw)
To: Jason Price, zsh-users
On May 22, 11:11am, Jason Price wrote:
} Subject: Re: 4.0.1-pre-5 (solaris issues)
}
} In Solaris 8. This is from part of 'make test' with a strait './configure ;
} make':
}
} ./A04redirect.ztst: starting.
} *** /tmp/zsh.ztst.out.10981 Tue May 22 10:41:37 2001
} --- /tmp/zsh.ztst.tout.10981 Tue May 22 10:41:37 2001
} ***************
} *** 1,3 ****
} out1 out2
} ! out1: All files
} ! out2: All files
} --- 1,3 ----
} out1 out2
} ! out1:
} ! out2:
} Test ./A04redirect.ztst failed: output differs from expected as shown above
} for:
} print *
} print "out1: $(<out1)\nout2: $(<out2)"
} Was testing: read multio with globbing
This is a race condition; the "read multio" test depends on a background
job from the "setup multio" test.
} And later in make test:
}
} ./V01zmodload.ztst: starting.
} Segmentation Fault
}
} ------------------------------------------------------------------------------
}
} In Solaris 7. This is also from 'make test' with './configure ; make':
}
} ./V01zmodload.ztst: starting.
} Segmentation Fault
Please run "ZTST_verbose=2 make check TESTNUM=V01" so we can see where
this is happening.
} ------------------------------------------------------------------------------
}
} And in solaris 2.6, we've got lots of issues. First and formost, it won't
} compile out of the box.
That's right, it won't compile out of the box. I have an uncommitted edit
for /etc/MACHINES to document this. You must use --disable-lfs.
--
Bart Schaefer Brass Lantern Enterprises
http://www.well.com/user/barts http://www.brasslantern.com
Zsh: http://www.zsh.org | PHPerl Project: http://phperl.sourceforge.net
^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: 4.0.1-pre-5 (solaris issues)
2001-05-22 15:29 ` Bart Schaefer
@ 2001-05-22 15:42 ` Jason Price
2001-05-22 16:16 ` Bart Schaefer
2001-05-22 16:03 ` Andrej Borsenkow
1 sibling, 1 reply; 7+ messages in thread
From: Jason Price @ 2001-05-22 15:42 UTC (permalink / raw)
To: zsh-users
[-- Attachment #1: Type: text/plain, Size: 1439 bytes --]
> } Was testing: read multio with globbing
> This is a race condition; the "read multio" test depends on a background
> job from the "setup multio" test.
Is there something I can help test to track this one down?
> } ./V01zmodload.ztst: starting.
> } Segmentation Fault
> } ./V01zmodload.ztst: starting.
> } Segmentation Fault
> Please run "ZTST_verbose=2 make check TESTNUM=V01" so we can see where
> this is happening.
I have attached the 3 outputs from solaris 2.6, 2.7 and 2.8.
> That's right, it won't compile out of the box. I have an uncommitted edit
> for /etc/MACHINES to document this. You must use --disable-lfs.
I'm not sure if this is the best approach. There are a LOT of 2.6 installs
lying around a lot of shops. There are 2 ways that this can go: 1) they're
old boxes that arn't going to be touched, so we shouln't bother. Sun has
also announced that they will end of life solaris 2.6 in the next 6
months. I have my doubts that they will be able to make that one stick
however. 2) Since there is such a large install base, we should make it
easy to install.
I don't know which way to take it.
Jason
--
"Friendship is the bridge between lonely and loved, between a glance and a
gaze. It stretches from the fog into sunshine, hopelessness into faith,
between despair and joy. It crosses the chasm from hell and to heaven, from
God to man, and from you to me." --Unknown Jason Price jprice@gatech.edu
[-- Attachment #2: file-26 --]
[-- Type: text/plain, Size: 11537 bytes --]
cd Test ; make TESTNUM=V01 check
make[1]: Entering directory `/export/home/jprice/programs/zsh/zsh-no-lfs/Test'
if test -n "gcc"; then \
cd .. && \
make TESTNUM=V01 MODDIR=`pwd`/Test/Modules install.modules > /dev/null; \
fi
mkdir /export/home/jprice/programs/zsh/zsh-no-lfs/Test/Modules
mkdir /export/home/jprice/programs/zsh/zsh-no-lfs/Test/Modules/zsh
for f in ./V01*.ztst; do \
../Src/zsh +Z -f ./ztst.zsh $f; \
done
./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:
./V01zmodload.ztst: all tests successful.
rm -rf Modules .zcompdump
make[1]: Leaving directory `/export/home/jprice/programs/zsh/zsh-no-lfs/Test'
[-- Attachment #3: file-27 --]
[-- Type: text/plain, Size: 11366 bytes --]
cd Test ; make check
if test -n "gcc"; then \
cd .. && \
make MODDIR=`pwd`/Test/Modules install.modules > /dev/null; \
fi
mkdir /export/home/jprice/programs/zsh/zsh-4.0.1-pre-5/Test/Modules
mkdir /export/home/jprice/programs/zsh/zsh-4.0.1-pre-5/Test/Modules/zsh
for f in ./V01*.ztst; do \
../Src/zsh +Z -f ./ztst.zsh $f; \
done
./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:
./V01zmodload.ztst: all tests successful.
rm -rf Modules .zcompdump
[-- Attachment #4: file-28 --]
[-- Type: text/plain, Size: 11019 bytes --]
cd Test ; make check
make[1]: Entering directory `/programs/zsh/zsh-4.0.1-pre-5/Test'
if test -n "gcc"; then \
cd .. && \
make MODDIR=`pwd`/Test/Modules install.modules > /dev/null; \
fi
mkdir /programs/zsh/zsh-4.0.1-pre-5/Test/Modules
mkdir /programs/zsh/zsh-4.0.1-pre-5/Test/Modules/zsh
for f in ./V01*.ztst; do \
../Src/zsh +Z -f ./ztst.zsh $f; \
done
./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
Segmentation Fault
make[1]: [check] Error 139 (ignored)
rm -rf Modules .zcompdump
make[1]: Leaving directory `/programs/zsh/zsh-4.0.1-pre-5/Test'
^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: 4.0.1-pre-5 (solaris issues)
2001-05-22 15:11 ` 4.0.1-pre-5 (solaris issues) Jason Price
2001-05-22 15:29 ` Bart Schaefer
@ 2001-05-22 15:59 ` Clint Adams
1 sibling, 0 replies; 7+ messages in thread
From: Clint Adams @ 2001-05-22 15:59 UTC (permalink / raw)
To: Jason Price; +Cc: zsh-users
[-- Attachment #1: Type: text/plain, Size: 413 bytes --]
> 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.
[-- Attachment #2: sol8-64 --]
[-- Type: text/plain, Size: 12533 bytes --]
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'
[-- Attachment #3: sol8-64-verbose --]
[-- Type: text/plain, Size: 303882 bytes --]
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'
^ permalink raw reply [flat|nested] 7+ messages in thread
* RE: 4.0.1-pre-5 (solaris issues)
2001-05-22 15:29 ` Bart Schaefer
2001-05-22 15:42 ` Jason Price
@ 2001-05-22 16:03 ` Andrej Borsenkow
1 sibling, 0 replies; 7+ messages in thread
From: Andrej Borsenkow @ 2001-05-22 16:03 UTC (permalink / raw)
To: Bart Schaefer, Jason Price, zsh-users
> } And in solaris 2.6, we've got lots of issues. First and
> formost, it won't
> } compile out of the box.
>
> That's right, it won't compile out of the box. I have an uncommitted edit
> for /etc/MACHINES to document this. You must use --disable-lfs.
>
Could we just skip LFS detection on this system? I did this for GCC on
ReliantUNIX e.g. - just do not run tests.
-andrej
^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: 4.0.1-pre-5 (solaris issues)
2001-05-22 15:42 ` Jason Price
@ 2001-05-22 16:16 ` Bart Schaefer
0 siblings, 0 replies; 7+ messages in thread
From: Bart Schaefer @ 2001-05-22 16:16 UTC (permalink / raw)
To: zsh-users
(Please follow up to zsh-workers.)
On May 22, 11:42am, Jason Price wrote:
}
} > } Was testing: read multio with globbing
} > This is a race condition; the "read multio" test depends on a background
} > job from the "setup multio" test.
}
} Is there something I can help test to track this one down?
There's nothing to track down. It's a known problem. When you use a
multio like `print All files >*' as is done in the "setup multio" test,
there is an implicit background job started to write to each of the files,
and the stdout of the command is really a pipe to that job. The files do
not have any contents until that job flushes its buffers, so when the next
test immediately attempts to read from the files, it finds nothing.
It might suffice to stick "sleep 1" at the beginning of the "read multio"
test.
} > Please run "ZTST_verbose=2 make check TESTNUM=V01" so we can see where
} > this is happening.
}
} I have attached the 3 outputs from solaris 2.6, 2.7 and 2.8.
Only 2.8 shows a crash when verbose is set. Probaby that means there is
a wild pointer somewhere. However, this ...
Running test: Unload the modules loaded by this test suite
ZTST_test: expecting status: 0
ZTST_execchunk: status 0
Segmentation Fault
... does not agree with ...
On May 22, 4:44pm, Oliver Kiddle wrote:
}
} It is the very last zmodload in the loop which does zmodload -i for
} every module it found in config.modules (the `for m in $mods' loop).
} I've gone through typing the zmodload commands manually and it is always
} the last one which causes the segfault regardless of the order in which
} they are loaded.
That's rather baffling. What happens if you try leaving various ones out?
--
Bart Schaefer Brass Lantern Enterprises
http://www.well.com/user/barts http://www.brasslantern.com
Zsh: http://www.zsh.org | PHPerl Project: http://phperl.sourceforge.net
^ permalink raw reply [flat|nested] 7+ messages in thread
end of thread, other threads:[~2001-05-22 16:17 UTC | newest]
Thread overview: 7+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2001-05-22 9:23 4.0.1-pre-5 Peter Stephenson
2001-05-22 15:11 ` 4.0.1-pre-5 (solaris issues) Jason Price
2001-05-22 15:29 ` Bart Schaefer
2001-05-22 15:42 ` Jason Price
2001-05-22 16:16 ` Bart Schaefer
2001-05-22 16:03 ` Andrej Borsenkow
2001-05-22 15:59 ` Clint Adams
Code repositories for project(s) associated with this public inbox
https://git.vuxu.org/mirror/zsh/
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).