function err_exit

alias err_exit='err_exit $LINENO'

Command=${0##*/}

integer Errors=0

tmp=$(mktemp -dt) || { err_exit mktemp -dt failed; exit 1; }

trap "cd /; rm -rf $tmp" EXIT

set -- \

go+r 0000 \

go-r 0044 \

ug=r 0330 \

go+w 0000 \

go-w 0022 \

ug=w 0550 \

go+x 0000 \

go-x 0011 \

ug=x 0660 \

go-rx 0055 \

uo-wx 0303 \

ug-rw 0660 \

o= 0007

while (( $# >= 2 ))

do umask 0

umask $1

g=$(umask)

[[ $g == $2 ]] || err_exit "umask 0; umask $1 failed -- expected $2, got $g"

shift 2

umask u=rwx,go=rx || err_exit "umask u=rws,go=rx failed"

if [[ $(umask -S) != u=rwx,g=rx,o=rx ]]

then err_exit 'umask -S incorrect'

pwd=$PWD

[[ $SHELL != /* ]] && SHELL=$pwd/$SHELL

cd $tmp || { err_exit "cd $tmp failed"; exit 1; }

um=$(umask -S)

rm -f foobar

> foobar

[[ -r foobar ]] || err_exit 'umask not being restored after subshell'

umask "$um"

rm -f foobar

> foobar

for i in 1 2

do print foobar*

rm -f foobar

done > out

if [[ "$(<out)" != "foobar"$'\n'"foobar*" ]]

then print -u2 "optimizer bug with file expansion"

rm -f out foobar

mkdir dir

if [[ $(print */) != dir/ ]]

then err_exit 'file expansion with trailing / not working'

if [[ $(print *) != dir ]]

then err_exit 'file expansion with single file not working'

print hi > .foo

if [[ $(print *) != dir ]]

then err_exit 'file expansion leading . not working'

date > dat1 || err_exit "date > dat1 failed"

test -r dat1 || err_exit "dat1 is not readable"

x=dat1

cat <$x > dat2 || err_exit "cat < $x > dat2 failed"

cat dat1 dat2 | cat | cat | cat > dat3 || err_exit "cat pipe failed"

cat > dat4 <<!

!

cat dat1 dat2 | cat | cat | cat > dat5 &

wait $!

set -- dat*

if (( $# != 5 ))

then err_exit "dat* matches only $# files"

if (command > foo\\abc) 2> /dev/null

then set -- foo*

if [[ $1 != 'foo\abc' ]]

then err_exit 'foo* does not match foo\abc'

fi

if ( : > TT* && : > TTfoo ) 2>/dev/null

then set -- TT*

if (( $# < 2 ))

then err_exit 'TT* not expanding when file TT* exists'

fi

cd ~- || err_exit "cd back failed"

cat > $tmp/script <<- !

#! $SHELL

print -r -- \$0

!

chmod 755 $tmp/script

if [[ $($tmp/script) != "$tmp/script" ]]

then err_exit '$0 not correct for #! script'

bar=foo

eval foo=\$bar

if [[ $foo != foo ]]

then err_exit 'eval foo=\$bar not working'

bar='foo=foo\ bar'

eval $bar

if [[ $foo != 'foo bar' ]]

then err_exit 'eval foo=\$bar, with bar="foo\ bar" not working'

cd /tmp

cd ../../tmp || err_exit "cd ../../tmp failed"

if [[ $PWD != /tmp ]]

then err_exit 'cd ../../tmp is not /tmp'

) | cat > $tmp/foobar &

wait $!

foobar=$( < $tmp/foobar)

if [[ $foobar != foobar ]]

then err_exit "$foobar is not foobar"

} > $tmp/foobar

if [[ $( < $tmp/foobar) != $'foo\nbar\nbam' ]]

then err_exit "output file pointer not shared correctly"

cat > $tmp/foobar <<\!

print foo

/bin/echo bar

print bam

!

chmod +x $tmp/foobar

if [[ $($tmp/foobar) != $'foo\nbar\nbam' ]]

then err_exit "script not working"

if [[ $($tmp/foobar | /bin/cat) != $'foo\nbar\nbam' ]]

then err_exit "script | cat not working"

if [[ $( $tmp/foobar) != $'foo\nbar\nbam' ]]

then err_exit "output file pointer not shared correctly"

rm -f $tmp/foobar

x=$( (print foo) ; (print bar) )

if [[ $x != $'foo\nbar' ]]

then err_exit " ( (print foo);(print bar ) failed"

x=$( (/bin/echo foo) ; (print bar) )

if [[ $x != $'foo\nbar' ]]

then err_exit " ( (/bin/echo);(print bar ) failed"

x=$( (/bin/echo foo) ; (/bin/echo bar) )

if [[ $x != $'foo\nbar' ]]

then err_exit " ( (/bin/echo);(/bin/echo bar ) failed"

cat > $tmp/script <<\!

if [[ -p /dev/fd/0 ]]

then builtin cat

cat - > /dev/null

[[ -p /dev/fd/0 ]] && print ok

else print no

!

chmod +x $tmp/script

case $( (print) | $tmp/script;:) in

ok) ;;

no) err_exit "[[ -p /dev/fd/0 ]] fails for standard input pipe" ;;

*) err_exit "builtin replaces standard input pipe" ;;

print 'print $0' > $tmp/script

print ". $tmp/script" > $tmp/scriptx

chmod +x $tmp/scriptx

if [[ $($tmp/scriptx) != $tmp/scriptx ]]

then err_exit '$0 not correct for . script'

cd $tmp || { err_exit "cd $tmp failed"; exit 1; }

print ./b > ./a; print ./c > b; print ./d > c; print ./e > d; print "echo \"hello there\"" > e

chmod 755 a b c d e

x=$(./a)

if [[ $x != "hello there" ]]

then err_exit "nested scripts failed"

x=$( (./a) | cat)

if [[ $x != "hello there" ]]

then err_exit "scripts in subshells fail"

cd ~- || err_exit "cd back failed"

x=$( (/bin/echo foo) 2> /dev/null )

if [[ $x != foo ]]

then err_exit "subshell in command substitution fails"

exec 1>&-

x=$(print hello)

if [[ $x != hello ]]

then err_exit "command subsitution with stdout closed failed"

cd $pwd

x=$(cat <<\! | $SHELL

if [[ $x != $'\n'hello ]]

then err_exit "$SHELL not working when standard input is a pipe"

x=$( (/bin/echo hello) 2> /dev/null )

if [[ $x != hello ]]

then err_exit "subshell in command substitution with 1 closed fails"

cat > $tmp/script <<- \!

read line 2> /dev/null

print done

!

if [[ $($SHELL $tmp/script <&-) != done ]]

then err_exit "executing script with 0 closed fails"

trap '' INT

cat > $tmp/script <<- \!

trap 'print bad' INT

kill -s INT $$

print good

!

chmod +x $tmp/script

if [[ $($SHELL $tmp/script) != good ]]

then err_exit "traps ignored by parent not ignored"

trap - INT

cat > $tmp/script <<- \!

read line

/bin/cat

!

if [[ $($SHELL $tmp/script <<!

) != two ]]

then err_exit "standard input not positioned correctly"

word=$(print $'foo\nbar' | { read line; /bin/cat;})

if [[ $word != bar ]]

then err_exit "pipe to { read line; /bin/cat;} not working"

word=$(print $'foo\nbar' | ( read line; /bin/cat) )

if [[ $word != bar ]]

then err_exit "pipe to ( read line; /bin/cat) not working"

if [[ $(print x{a,b}y) != 'xay xby' ]]

then err_exit 'brace expansion not working'

if [[ $(for i in foo bar

done) != $'foo\nbar' ]]

then err_exit 'for loop subshell optimizer bug'

unset a1