mirror of
git://git.code.sf.net/p/zsh/code
synced 2024-04-30 05:45:16 +02:00
8f5fe841a6
This is a special case where TRAPEXIT is unset within a TRAPEXIT as it should never run in a nested context, so just save the function structure temporarily on the heap.
1101 lines
21 KiB
Plaintext
1101 lines
21 KiB
Plaintext
# Tests for both trap builtin and TRAP* functions.
|
|
|
|
%prep
|
|
|
|
setopt localtraps
|
|
mkdir traps.tmp && cd traps.tmp
|
|
|
|
%test
|
|
|
|
fn1() {
|
|
trap 'print EXIT1' EXIT
|
|
fn2() { trap 'print EXIT2' EXIT; }
|
|
fn2
|
|
}
|
|
fn1
|
|
0:Nested `trap ... EXIT'
|
|
>EXIT2
|
|
>EXIT1
|
|
|
|
fn1() {
|
|
TRAPEXIT() { print EXIT1; }
|
|
fn2() { TRAPEXIT() { print EXIT2; }; }
|
|
fn2
|
|
}
|
|
fn1
|
|
0: Nested TRAPEXIT
|
|
>EXIT2
|
|
>EXIT1
|
|
|
|
fn1() {
|
|
trap 'print EXIT1' EXIT
|
|
fn2() { trap - EXIT; }
|
|
fn2
|
|
}
|
|
fn1
|
|
0:Nested `trap - EXIT' on `trap ... EXIT'
|
|
>EXIT1
|
|
|
|
fn1() {
|
|
TRAPEXIT() { print EXIT1; }
|
|
fn2() { trap - EXIT; }
|
|
fn2
|
|
}
|
|
fn1
|
|
0:Nested `trap - EXIT' on `TRAPEXIT'
|
|
>EXIT1
|
|
|
|
# We can't test an EXIT trap for the shell as a whole, because
|
|
# we're inside a function scope which we don't leave when the
|
|
# subshell exits. Not sure if that's the correct behaviour, but
|
|
# it's sort of consistent.
|
|
( fn1() { trap 'print Function 1 going' EXIT; exit; print Not reached; }
|
|
fn2() { trap 'print Function 2 going' EXIT; fn1; print Not reached; }
|
|
fn2
|
|
)
|
|
0:EXIT traps on functions when exiting from function
|
|
>Function 1 going
|
|
>Function 2 going
|
|
|
|
# $ZTST_exe is relative to the parent directory.
|
|
# We ought to fix this in ztst.zsh...
|
|
(cd ..
|
|
$ZTST_exe -fc 'TRAPEXIT() { print Exited.; }')
|
|
0:EXIT traps on a script
|
|
>Exited.
|
|
|
|
trap -
|
|
trap
|
|
trap int INT
|
|
trap sigterm SIGTERM
|
|
trap quit 3
|
|
trap
|
|
0: Outputting traps correctly
|
|
>trap -- int INT
|
|
>trap -- quit QUIT
|
|
>trap -- sigterm TERM
|
|
|
|
fn1() {
|
|
trap -
|
|
trap
|
|
trap 'print INT1' INT
|
|
fn2() { trap 'print INT2' INT; trap; }
|
|
trap
|
|
fn2
|
|
trap
|
|
}
|
|
fn1
|
|
0: Nested `trap ... INT', not triggered
|
|
>trap -- 'print INT1' INT
|
|
>trap -- 'print INT2' INT
|
|
>trap -- 'print INT1' INT
|
|
|
|
fn1() {
|
|
trap -
|
|
trap
|
|
TRAPINT() { print INT1; }
|
|
fn2() { TRAPINT() { print INT2; }; trap; }
|
|
trap
|
|
fn2
|
|
trap
|
|
}
|
|
fn1
|
|
0: Nested TRAPINT, not triggered
|
|
>TRAPINT () {
|
|
> print INT1
|
|
>}
|
|
>TRAPINT () {
|
|
> print INT2
|
|
>}
|
|
>TRAPINT () {
|
|
> print INT1
|
|
>}
|
|
|
|
fn1() {
|
|
trap -
|
|
trap 'print INT1' INT
|
|
fn2() { trap - INT; trap; }
|
|
trap
|
|
fn2
|
|
trap
|
|
}
|
|
fn1
|
|
0: Nested `trap - INT' on untriggered `trap ... INT'
|
|
>trap -- 'print INT1' INT
|
|
>trap -- 'print INT1' INT
|
|
|
|
# Testing the triggering of traps here is very unpleasant.
|
|
# The delays are attempts to avoid race conditions, though there is
|
|
# no guarantee that they will work. Note the subtlety that the
|
|
# `sleep' in the function which receives the trap does *not* get the
|
|
# signal, only the parent shell, which is waiting for a SIGCHILD.
|
|
# (At least, that's what I think is happening.) Thus we have to wait at
|
|
# least the full two seconds to make sure we have got the output from the
|
|
# execution of the trap.
|
|
|
|
print -u $ZTST_fd 'This test takes at least three seconds...'
|
|
fn1() {
|
|
trap 'print TERM1' TERM
|
|
fn2() { trap 'print TERM2; return 1' TERM; sleep 2; }
|
|
fn2 &
|
|
sleep 1
|
|
kill -TERM $!
|
|
sleep 2
|
|
}
|
|
fn1
|
|
0: Nested `trap ... TERM', triggered on inner loop
|
|
>TERM2
|
|
|
|
print -u $ZTST_fd 'This test, too, takes at least three seconds...'
|
|
fn1() {
|
|
trap 'print TERM1; return 1' TERM
|
|
fn2() { trap 'print TERM2; return 1' TERM; }
|
|
fn2
|
|
sleep 2
|
|
}
|
|
fn1 &
|
|
sleep 1
|
|
kill -TERM $!
|
|
sleep 2
|
|
0: Nested `trap ... TERM', triggered on outer loop
|
|
>TERM1
|
|
|
|
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
|
|
0: basic localtraps handling
|
|
>start of fn
|
|
>error activated
|
|
>end of fn
|
|
>start of fn
|
|
>end of fn
|
|
>finish
|
|
|
|
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
|
|
print status $?
|
|
unfunction TRAPZERR
|
|
0: more sophisticated error trapping
|
|
>f
|
|
>ERR-or!
|
|
>f
|
|
>t
|
|
>f
|
|
>t
|
|
>f
|
|
>ERR-or!
|
|
>testunset
|
|
>f
|
|
>ERR-or!
|
|
>status 1
|
|
|
|
f() {
|
|
setopt localtraps
|
|
TRAPWINCH() { print "Window changed. That wrecked the test."; }
|
|
}
|
|
f
|
|
f
|
|
functions TRAPWINCH
|
|
1:Unsetting ordinary traps with localtraps.
|
|
|
|
#
|
|
# Returns from within traps are a perennial problem.
|
|
# The following two apply to returns in and around standard
|
|
# ksh-style traps. The intention is that a return value from
|
|
# within the function is preserved (i.e. statuses set by the trap
|
|
# are ignored) unless the trap explicitly executes `return', which makes
|
|
# it return from the enclosing function.
|
|
#
|
|
fn() { trap 'true' EXIT; return 1; }
|
|
fn
|
|
1: ksh-style EXIT traps preserve return value
|
|
|
|
inner() { trap 'return 3' EXIT; return 2; }
|
|
outer() { inner; return 1; }
|
|
outer
|
|
3: ksh-style EXIT traps can force return status of enclosing function
|
|
|
|
# Autoloaded traps are horrid, but unfortunately people expect
|
|
# them to work if we support them.
|
|
echo "print Running exit trap" >TRAPEXIT
|
|
${${ZTST_exe##[^/]*}:-$ZTST_testdir/$ZTST_exe} -fc '
|
|
fpath=(. $fpath)
|
|
autoload TRAPEXIT
|
|
print "Exiting, attempt 1"
|
|
exit
|
|
print "What?"
|
|
'
|
|
${${ZTST_exe##[^/]*}:-$ZTST_testdir/$ZTST_exe} -fc '
|
|
fpath=(. $fpath)
|
|
autoload TRAPEXIT;
|
|
fn() { print Some function }
|
|
fn
|
|
print "Exiting, attempt 2"
|
|
exit
|
|
'
|
|
0: autoloaded TRAPEXIT (exit status > 128 indicates an old bug is back)
|
|
>Exiting, attempt 1
|
|
>Running exit trap
|
|
>Some function
|
|
>Exiting, attempt 2
|
|
>Running exit trap
|
|
|
|
print -u $ZTST_fd Another test that takes three seconds
|
|
gotsig=0
|
|
signal_handler() {
|
|
echo "parent received signal"
|
|
gotsig=1
|
|
}
|
|
child() {
|
|
sleep 1
|
|
echo "child sending signal"
|
|
kill -15 $parentpid
|
|
sleep 2
|
|
echo "child exiting"
|
|
exit 33
|
|
}
|
|
parentpid=$$
|
|
child &
|
|
childpid=$!
|
|
trap signal_handler 15
|
|
echo "parent waiting"
|
|
wait $childpid
|
|
cstatus=$?
|
|
echo "wait #1 finished, gotsig=$gotsig, status=$cstatus"
|
|
gotsig=0
|
|
wait $childpid
|
|
cstatus=$?
|
|
echo "wait #2 finished, gotsig=$gotsig, status=$cstatus"
|
|
0:waiting for trapped signal
|
|
>parent waiting
|
|
>child sending signal
|
|
>parent received signal
|
|
>wait #1 finished, gotsig=1, status=143
|
|
>child exiting
|
|
>wait #2 finished, gotsig=0, status=33
|
|
|
|
fn1() {
|
|
setopt errexit
|
|
trap 'echo error1' ZERR
|
|
false
|
|
print Shouldn\'t get here 1a
|
|
}
|
|
fn2() {
|
|
setopt errexit
|
|
trap 'echo error2' ZERR
|
|
return 1
|
|
print Shouldn\'t get here 2a
|
|
}
|
|
fn3() {
|
|
setopt errexit
|
|
TRAPZERR() { echo error3; }
|
|
false
|
|
print Shouldn\'t get here 3a
|
|
}
|
|
fn4() {
|
|
setopt errexit
|
|
TRAPZERR() { echo error4; }
|
|
return 1
|
|
print Shouldn\'t get here 4a
|
|
}
|
|
(fn1; print Shouldn\'t get here 1b)
|
|
(fn2; print Shouldn\'t get here 2b)
|
|
(fn3; print Shouldn\'t get here 3b)
|
|
(fn4; print Shouldn\'t get here 4b)
|
|
1: Combination of ERR_EXIT and ZERR trap
|
|
>error1
|
|
>error2
|
|
>error3
|
|
>error4
|
|
|
|
fn1() { TRAPZERR() { print trap; return 42; }; false; print Broken; }
|
|
(fn1)
|
|
print Working $?
|
|
0: Force return of containing function from TRAPZERR.
|
|
>trap
|
|
>Working 42
|
|
|
|
fn2() { trap 'print trap; return 42' ZERR; false; print Broken }
|
|
(fn2)
|
|
print Working $?
|
|
0: Return with non-zero status triggered from within trap '...' ZERR.
|
|
>trap
|
|
>Working 42
|
|
|
|
fn3() { TRAPZERR() { print trap; return 0; }; false; print OK this time; }
|
|
(fn3)
|
|
print Working $?
|
|
0: Normal return from TRAPZERR.
|
|
>trap
|
|
>OK this time
|
|
>Working 0
|
|
|
|
fn4() { trap 'print trap; return 0' ZERR; false; print Broken; }
|
|
(fn4)
|
|
print Working $?
|
|
0: Return with zero status triggered from within trap '...' ZERR.
|
|
>trap
|
|
>Working 0
|
|
|
|
{ trap 'echo This subshell is exiting' EXIT; } | cat
|
|
0: EXIT trap set in current shell at left of pipeline
|
|
>This subshell is exiting
|
|
|
|
( trap 'echo This subshell is also exiting' EXIT; ) | cat
|
|
0: EXIT trap set in subshell at left of pipeline
|
|
>This subshell is also exiting
|
|
|
|
( trap 'echo Should only appear once at the end' EXIT
|
|
( : trap reset here ) | cat
|
|
: trap not reset but not part of shell command list | cat
|
|
echo nothing after this should appear $( : trap reset here too)
|
|
)
|
|
0: EXIT trap set in subshell reset in subsubshell
|
|
>nothing after this should appear
|
|
>Should only appear once at the end
|
|
|
|
echo $( trap 'echo command substitution exited' EXIT )
|
|
0: EXIT trap set in command substitution
|
|
>command substitution exited
|
|
|
|
(cd ..; $ZTST_exe -fc 'setopt posixtraps;
|
|
TRAPEXIT() { print Exited; }
|
|
fn1() { trap; }
|
|
setopt localtraps # should be ignored by EXIT
|
|
fn2() { TRAPEXIT() { print No, really exited; } }
|
|
fn1
|
|
fn2
|
|
fn1')
|
|
0:POSIX_TRAPS option
|
|
>TRAPEXIT () {
|
|
> print Exited
|
|
>}
|
|
>TRAPEXIT () {
|
|
> print No, really exited
|
|
>}
|
|
>No, really exited
|
|
|
|
(cd ..; $ZTST_exe -fc 'unsetopt posixtraps;
|
|
echo start program
|
|
emulate sh -c '\''testfn() {
|
|
echo start function
|
|
set -o | grep posixtraps
|
|
trap "echo EXIT TRAP TRIGGERED" EXIT
|
|
echo end function
|
|
}'\''
|
|
testfn
|
|
echo program continuing
|
|
echo end of program')
|
|
0:POSIX_TRAPS effect on EXIT trap is sticky
|
|
>start program
|
|
>start function
|
|
>noposixtraps off
|
|
>end function
|
|
>program continuing
|
|
>end of program
|
|
>EXIT TRAP TRIGGERED
|
|
|
|
(cd ..; $ZTST_exe -fc '
|
|
echo entering program
|
|
emulate sh -c '\''trap "echo POSIX exit trap triggered" EXIT'\''
|
|
fn() {
|
|
trap "echo native zsh function-local exit trap triggered" EXIT
|
|
echo entering native zsh function
|
|
}
|
|
fn
|
|
echo exiting program
|
|
')
|
|
0:POSIX EXIT trap can have nested native mode EXIT trap
|
|
>entering program
|
|
>entering native zsh function
|
|
>native zsh function-local exit trap triggered
|
|
>exiting program
|
|
>POSIX exit trap triggered
|
|
|
|
(cd ..; $ZTST_exe -fc '
|
|
echo entering program
|
|
emulate sh -c '\''spt() { trap "echo POSIX exit trap triggered" EXIT; }'\''
|
|
fn() {
|
|
trap "echo native zsh function-local exit trap triggered" EXIT
|
|
echo entering native zsh function
|
|
}
|
|
spt
|
|
fn
|
|
echo exiting program
|
|
')
|
|
0:POSIX EXIT trap not replaced if defined within function
|
|
>entering program
|
|
>entering native zsh function
|
|
>native zsh function-local exit trap triggered
|
|
>exiting program
|
|
>POSIX exit trap triggered
|
|
|
|
(set -e
|
|
printf "a\nb\n" | while read line
|
|
do
|
|
[[ $line = a* ]] || continue
|
|
((ctr++))
|
|
[[ $line = foo ]]
|
|
done
|
|
echo "ctr = $ctr"
|
|
)
|
|
1:ERREXIT in loop with simple commands
|
|
|
|
(set -e
|
|
f()
|
|
{
|
|
false && false
|
|
}
|
|
if false; then
|
|
:
|
|
else
|
|
# ERR_EXIT should trigger on return from function, not in function.
|
|
f
|
|
echo Fail 1
|
|
echo Fail 2
|
|
f
|
|
echo Fail 3
|
|
fi)
|
|
1:ERREXIT with false from inside && within function
|
|
|
|
(set -e
|
|
f()
|
|
{
|
|
}
|
|
if false; then
|
|
:
|
|
else
|
|
f
|
|
echo Succeed 1
|
|
echo Succeed 2
|
|
f
|
|
echo Succeed 3
|
|
fi)
|
|
0:ERREXIT not triggered on empty function after false in if.
|
|
>Succeed 1
|
|
>Succeed 2
|
|
>Succeed 3
|
|
|
|
(set -e
|
|
if false; then
|
|
else
|
|
a=$(false)
|
|
print This should not appear
|
|
fi
|
|
)
|
|
1:ERREXIT is triggered in an else block after a cmd subst returning false
|
|
|
|
fn() {
|
|
emulate -L zsh
|
|
setopt errreturn
|
|
if false; then
|
|
false
|
|
print No.
|
|
else
|
|
print Oh, yes
|
|
fi
|
|
}
|
|
fn
|
|
0:ERR_RETURN not triggered in if condition
|
|
>Oh, yes
|
|
|
|
fn() {
|
|
emulate -L zsh
|
|
setopt errreturn
|
|
if true; then
|
|
false
|
|
print No.
|
|
else
|
|
print No, no.
|
|
fi
|
|
}
|
|
fn
|
|
1:ERR_RETURN in "if"
|
|
|
|
fn() {
|
|
emulate -L zsh
|
|
setopt errreturn
|
|
if false; then
|
|
print No.
|
|
else
|
|
false
|
|
print No, no.
|
|
fi
|
|
}
|
|
fn
|
|
1:ERR_RETURN in "else" branch (regression test)
|
|
|
|
$ZTST_testdir/../Src/zsh -f =(<<<"
|
|
if false; then
|
|
:
|
|
else
|
|
if [[ -n '' ]]; then
|
|
a=2
|
|
fi
|
|
print Yes
|
|
fi
|
|
")
|
|
0:ERR_RETURN when false "if" is the first statement in an "else" (regression)
|
|
>Yes
|
|
F:Must be tested with a top-level script rather than source or function
|
|
|
|
fn() {
|
|
emulate -L zsh
|
|
setopt errreturn
|
|
print before
|
|
false
|
|
print after
|
|
}
|
|
fn
|
|
1:ERR_RETURN, basic case
|
|
>before
|
|
|
|
fn() {
|
|
emulate -L zsh
|
|
setopt errreturn
|
|
print before
|
|
! true
|
|
! false
|
|
print after
|
|
}
|
|
fn
|
|
0:ERR_RETURN with "!"
|
|
>before
|
|
>after
|
|
|
|
fn() {
|
|
emulate -L zsh
|
|
setopt errreturn
|
|
print before
|
|
! true
|
|
! false
|
|
false
|
|
print after
|
|
}
|
|
fn
|
|
1:ERR_RETURN with "!" and a following false
|
|
>before
|
|
|
|
fn() {
|
|
emulate -L zsh
|
|
setopt errreturn
|
|
print before
|
|
! if true; then
|
|
false
|
|
fi
|
|
print after
|
|
}
|
|
fn
|
|
0:ERR_RETURN with "!" suppressed inside complex structure
|
|
>before
|
|
>after
|
|
|
|
fn() {
|
|
emulate -L zsh
|
|
setopt errreturn
|
|
print before
|
|
if true; then
|
|
false
|
|
fi
|
|
print after
|
|
}
|
|
fn
|
|
1:ERR_RETURN with no "!" suppression (control case)
|
|
>before
|
|
|
|
(setopt err_return
|
|
fn() {
|
|
print before-in
|
|
false && false
|
|
}
|
|
print before-out
|
|
fn
|
|
print after-out
|
|
)
|
|
1:ERR_RETURN with "&&" in function (regression test)
|
|
>before-out
|
|
>before-in
|
|
|
|
(setopt err_return
|
|
fn() {
|
|
print before-in
|
|
false && false
|
|
print after-in
|
|
}
|
|
print before-out
|
|
fn
|
|
print after-out
|
|
)
|
|
0:ERR_RETURN not triggered on LHS of "&&" in function
|
|
>before-out
|
|
>before-in
|
|
>after-in
|
|
>after-out
|
|
|
|
(setopt err_return
|
|
fn() {
|
|
print before-in
|
|
true && false
|
|
print after-in
|
|
}
|
|
print before-out
|
|
fn
|
|
print after-out
|
|
)
|
|
1:ERR_RETURN triggered on RHS of "&&" in function
|
|
>before-out
|
|
>before-in
|
|
|
|
(set -o err_return
|
|
fn() {
|
|
print before-in
|
|
{ false; true } && true
|
|
print after-in
|
|
}
|
|
print before-out
|
|
fn && true
|
|
print after-out
|
|
)
|
|
0:ERR_RETURN not triggered on LHS of "&&" in function on LHS of "&&" (regression test)
|
|
>before-out
|
|
>before-in
|
|
>after-in
|
|
>after-out
|
|
|
|
mkdir -p zdotdir
|
|
print >zdotdir/.zshenv '
|
|
setopt norcs errreturn
|
|
fn() {
|
|
if false; then
|
|
print Bad
|
|
else
|
|
print Good
|
|
fi
|
|
print Better
|
|
}
|
|
fn
|
|
print In .zshenv'
|
|
ZDOTDIR=$PWD/zdotdir $ZTST_testdir/../Src/zsh -c 'true'
|
|
0:ERR_RETURN within initialisation code with special flags
|
|
>Good
|
|
>Better
|
|
>In .zshenv
|
|
|
|
unsetopt errreturn
|
|
fn2() {
|
|
if true; then
|
|
false
|
|
fi
|
|
}
|
|
fn1() {
|
|
setopt localoptions errreturn
|
|
fn2
|
|
print $?
|
|
}
|
|
fn1
|
|
print fn1 done
|
|
0:ERR_RETURN caused by function returning false from within shell construct
|
|
>fn1 done
|
|
|
|
fn2() {
|
|
if false; then
|
|
print Bad
|
|
else
|
|
print Good
|
|
fi
|
|
}
|
|
fn() {
|
|
setopt localoptions err_return
|
|
fn2 || true
|
|
}
|
|
fn
|
|
0:ERR_RETURN in "else" branch in nested function
|
|
>Good
|
|
|
|
(setopt err_exit
|
|
! true
|
|
print OK
|
|
)
|
|
0:ERR_EXIT not triggered by "! true"
|
|
>OK
|
|
|
|
(setopt err_exit
|
|
fn() { true }
|
|
! fn
|
|
print OK
|
|
)
|
|
0:ERR_EXIT not triggered by "! fn"
|
|
>OK
|
|
|
|
(setopt err_exit
|
|
false && true
|
|
print OK
|
|
)
|
|
0:ERR_EXIT not triggered by "false && true"
|
|
>OK
|
|
|
|
(setopt err_exit
|
|
fn() {
|
|
false && true
|
|
}
|
|
fn
|
|
print OK
|
|
)
|
|
1:ERR_EXIT not triggered by "false && true" but by return from fn
|
|
|
|
(setopt err_exit
|
|
for x in y; do
|
|
false && true
|
|
done
|
|
print OK
|
|
)
|
|
0:ERR_EXIT not triggered by status 1 at end of for
|
|
>OK
|
|
|
|
(setopt err_exit
|
|
fn() {
|
|
for x in y; do
|
|
false && true
|
|
done
|
|
}
|
|
fn
|
|
print OK
|
|
)
|
|
1:ERR_EXIT not triggered by status 1 at end of for but by return from fn
|
|
|
|
(setopt err_exit
|
|
repeat 1; do
|
|
false && true
|
|
done
|
|
print OK
|
|
)
|
|
0:ERR_EXIT not triggered by status 1 at end of repeat
|
|
>OK
|
|
|
|
(setopt err_exit
|
|
fn() {
|
|
repeat 1; do
|
|
false && true
|
|
done
|
|
}
|
|
fn
|
|
print OK
|
|
)
|
|
1:ERR_EXIT not triggered by status 1 at end of repeat but by return from fn
|
|
|
|
(setopt err_exit
|
|
if true; then
|
|
false && true
|
|
fi
|
|
print OK
|
|
)
|
|
0:ERR_EXIT not triggered by status 1 at end of if
|
|
>OK
|
|
|
|
(setopt err_exit
|
|
fn() {
|
|
if true; then
|
|
false && true
|
|
fi
|
|
}
|
|
fn
|
|
print OK
|
|
)
|
|
1:ERR_EXIT not triggered by status 1 at end of if but by return from fn
|
|
|
|
(setopt err_exit
|
|
loop=true
|
|
while print COND; $loop; do
|
|
loop=false
|
|
false && true
|
|
done
|
|
print OK
|
|
)
|
|
0:ERR_EXIT not triggered by status 1 at end of while
|
|
>COND
|
|
>COND
|
|
>OK
|
|
|
|
(setopt err_exit
|
|
fn() {
|
|
loop=true
|
|
while print COND; $loop; do
|
|
loop=false
|
|
false && true
|
|
done
|
|
}
|
|
fn
|
|
print OK
|
|
)
|
|
1:ERR_EXIT not triggered by status 1 at end of while but by return from fn
|
|
>COND
|
|
>COND
|
|
|
|
(setopt err_exit
|
|
{
|
|
false && true
|
|
} always {
|
|
print ALWAYS
|
|
}
|
|
print OK
|
|
)
|
|
0:ERR_EXIT not triggered by status 1 at end of always
|
|
>ALWAYS
|
|
>OK
|
|
|
|
(setopt err_exit
|
|
fn() {
|
|
{
|
|
false && true
|
|
} always {
|
|
print ALWAYS
|
|
}
|
|
}
|
|
fn
|
|
print OK
|
|
)
|
|
1:ERR_EXIT not triggered by status 1 at end of always but by return from fn
|
|
>ALWAYS
|
|
|
|
(setopt err_exit
|
|
{
|
|
false && true
|
|
}
|
|
print OK
|
|
)
|
|
0:ERR_EXIT not triggered by status 1 at end of { }
|
|
>OK
|
|
|
|
(setopt err_exit
|
|
fn() {
|
|
{
|
|
false && true
|
|
}
|
|
}
|
|
fn
|
|
print OK
|
|
)
|
|
1:ERR_EXIT not triggered by status 1 at end of { } but by return from fn
|
|
|
|
unsetopt err_exit err_return
|
|
(setopt err_exit
|
|
for x in y; do
|
|
false
|
|
done
|
|
print OK
|
|
)
|
|
1:ERR_EXIT triggered by status 1 within for
|
|
|
|
(setopt err_exit
|
|
integer x=0
|
|
while (( ! x++ )); do
|
|
false
|
|
done
|
|
print OK
|
|
)
|
|
1:ERR_EXIT triggered by status 1 within while
|
|
|
|
(setopt err_exit
|
|
repeat 1; do
|
|
false
|
|
done
|
|
print OK
|
|
)
|
|
1:ERR_EXIT triggered by status 1 within repeat
|
|
|
|
(setopt err_exit
|
|
if true; then
|
|
false
|
|
fi
|
|
print OK
|
|
)
|
|
1:ERR_EXIT triggered by status 1 within if
|
|
|
|
(setopt err_exit
|
|
{
|
|
false
|
|
}
|
|
print OK
|
|
)
|
|
1:ERR_EXIT triggered by status 1 within { }
|
|
|
|
(setopt err_exit
|
|
() {
|
|
false && true
|
|
print Still functioning
|
|
false && true
|
|
}
|
|
print OK
|
|
)
|
|
1:ERR_EXIT triggered by status 1 at end of anon func
|
|
>Still functioning
|
|
|
|
(setopt err_exit
|
|
loop=true; while print loop $? >&2; $loop; do loop=false; false && true; done
|
|
print done $? >&2
|
|
)
|
|
0: ERR_EXIT neither triggered inside loop nor triggered by while statement
|
|
?loop 0
|
|
?loop 1
|
|
?done 1
|
|
|
|
(setopt err_exit
|
|
{ loop=true; while print loop $? >&2; $loop; do loop=false; false && true; done } || false
|
|
print done $? >&2
|
|
)
|
|
1: ERR_EXIT not triggered inside loop but triggered by rhs of ||
|
|
?loop 0
|
|
?loop 1
|
|
|
|
(setopt err_exit
|
|
eval 'loop=true; while print loop $? >&2; $loop; do loop=false; false && true; done'
|
|
print done $? >&2
|
|
)
|
|
1: ERR_EXIT not triggered inside loop but triggered by eval
|
|
?loop 0
|
|
?loop 1
|
|
|
|
(setopt err_exit
|
|
source <(echo 'loop=true; while print loop $? >&2; $loop; do loop=false; false && true; done')
|
|
print done $? >&2
|
|
)
|
|
1: ERR_EXIT not triggered inside loop but triggered by source
|
|
?loop 0
|
|
?loop 1
|
|
|
|
(setopt err_exit
|
|
v=$(loop=true; while print loop $? >&2; $loop; do loop=false; false && true; done)
|
|
print done $? >&2
|
|
)
|
|
1: ERR_EXIT not triggered inside loop but triggered by command substitution
|
|
?loop 0
|
|
?loop 1
|
|
|
|
if zmodload zsh/system 2>/dev/null; then
|
|
(
|
|
trap 'echo TERM; exit 2' TERM
|
|
trap 'echo EXIT' EXIT
|
|
kill -s TERM "$sysparams[pid]"
|
|
echo 'FATAL: we should never get here!' 1>&2
|
|
exit 1
|
|
)
|
|
else
|
|
ZTST_skip="zsh/system library not found."
|
|
fi
|
|
2:EXIT trap from TERM trap
|
|
>TERM
|
|
>EXIT
|
|
|
|
# Should not get "hello" in the single quotes.
|
|
(
|
|
trap "echo hello" EXIT;
|
|
{ :; } | { read line; print "'$line'"; }
|
|
)
|
|
0:EXIT trap not called in LHS of pipeline: Shell construct on LHS
|
|
>''
|
|
>hello
|
|
|
|
(
|
|
trap "echo hello" EXIT;
|
|
cat </dev/null | { read line; print "'$line'"; }
|
|
)
|
|
0:EXIT trap not called in LHS of pipeline: External command on LHS
|
|
>''
|
|
>hello
|
|
|
|
$ZTST_testdir/../Src/zsh -f =(<<<"
|
|
trap handler EXIT
|
|
handler() {
|
|
echoa
|
|
echo b
|
|
}
|
|
echoa() {
|
|
echo a
|
|
}
|
|
exit0() {
|
|
exit
|
|
}
|
|
main() {
|
|
exit0
|
|
}
|
|
main
|
|
")
|
|
0:No early exit from nested function in EXIT trap.
|
|
>a
|
|
>b
|
|
|
|
$ZTST_testdir/../Src/zsh -fc 'fn() { exit 13; }; trap fn EXIT; exit'
|
|
13:Explicit exit in exit trap overrides status
|
|
|
|
$ZTST_testdir/../Src/zsh -fc 'fn() { exit $?+8; }; trap fn EXIT; exit 7'
|
|
15:Progated exit status through exit trap
|
|
|
|
$ZTST_testdir/../Src/zsh -fc 'fn() { exit 13; }; trap fn EXIT'
|
|
13:Explicit exit in exit trap overrides implicit exit status
|
|
|
|
$ZTST_testdir/../Src/zsh -fc 'fn() { exit 0; }; trap fn EXIT; false'
|
|
0:Explicit exit status 0 in exit trap overrides implicit non-zero status
|
|
|
|
$ZTST_testdir/../Src/zsh -f <<<'fn() { exit 13; }; trap fn EXIT; false'
|
|
13:Exit status from exit trap, script-like path
|
|
|
|
$ZTST_testdir/../Src/zsh -f <<<'fn() { exit 0; }; trap fn EXIT; false'
|
|
0:Explicit exit status overrides implicit: script-like code path
|
|
|
|
$ZTST_testdir/../Src/zsh -f <<<$'
|
|
trap \'echo $1; exit; echo $2\' USR1
|
|
fn() {
|
|
echo fn1
|
|
kill -s USR1 $$
|
|
echo fn2
|
|
}
|
|
echo out1
|
|
fn trap1 trap2
|
|
echo out2
|
|
'
|
|
0:'exit' in trap causes calling function to return
|
|
>out1
|
|
>fn1
|
|
>trap1
|
|
# As of 5.7.1-test-2, the output was "out1 fn1 trap1 fn2" (on separate lines).
|
|
|
|
TRAPEXIT() { echo This is TRAPEXIT; }
|
|
TRAPEXIT
|
|
TRAPEXIT
|
|
TRAPEXIT
|
|
0:No memory problems with explicit call to TRAPEXIT.
|
|
>This is TRAPEXIT
|
|
>This is TRAPEXIT
|
|
>This is TRAPEXIT
|
|
>This is TRAPEXIT
|
|
# Three explicit calls, one implicit call at function exit.
|
|
|
|
%clean
|
|
|
|
rm -f TRAPEXIT
|
|
|