# $NetBSD: t_expand.sh,v 1.22 2019/05/04 02:52:22 kre Exp $
#
# Copyright (c) 2007, 2009 The NetBSD Foundation, Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
# 1. Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
# ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
# TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
# BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
# the implementation of "sh" to test
: ${TEST_SH:="/bin/sh"}
#
# This file tests the functions in expand.c.
#
delim_argv() {
str=
while [ $# -gt 0 ]; do
if [ -z "${str}" ]; then
str=">$1<"
else
str="${str} >$1<"
fi
shift
done
echo ${str}
}
atf_test_case dollar_at
dollar_at_head() {
atf_set descr "Somewhere between 2.0.2 and 3.0 the expansion" \
"of the \$@ variable had been broken. Check for" \
"this behavior."
}
dollar_at_body() {
# This one should work everywhere.
atf_check -s exit:0 -o inline:' EOL\n' -e empty \
${TEST_SH} -c 'echo "" "" | '" sed 's,\$,EOL,'"
# This code triggered the bug.
atf_check -s exit:0 -o inline:' EOL\n' -e empty \
${TEST_SH} -c 'set -- "" ""; echo "$@" | '" sed 's,\$,EOL,'"
atf_check -s exit:0 -o inline:'0\n' -e empty ${TEST_SH} -c \
'set -- -; shift; n_arg() { echo $#; }; n_arg "$@"'
}
atf_test_case dollar_at_unquoted_or_conditional
dollar_at_unquoted_or_conditional_head() {
atf_set descr 'Sometime during 2013 the expansion of "${1+$@}"' \
' (where $1 and $2 (and maybe more) are set)' \
' seems to have broken. Check for this bug.'
}
dollar_at_unquoted_or_conditional_body() {
atf_check -s exit:0 -o inline:'a\na\nb\nb\n' -e empty \
${TEST_SH} -c 'set -- "a a" "b b"; printf %s\\n $@'
atf_check -s exit:0 -o inline:'a\na\nb\nb\n' -e empty \
${TEST_SH} -c 'set -- "a a" "b b"; printf %s\\n ${1+$@}'
atf_check -s exit:0 -o inline:'a a\nb b\n' -e empty \
${TEST_SH} -c 'set -- "a a" "b b"; printf %s\\n "$@"'
atf_check -s exit:0 -o inline:'a a\nb b\n' -e empty \
${TEST_SH} -c 'set -- "a a" "b b"; printf %s\\n ${1+"$@"}'
# This is the one that fails when the bug is present
atf_check -s exit:0 -o inline:'a a\nb b\n' -e empty \
${TEST_SH} -c 'set -- "a a" "b b"; printf %s\\n "${1+$@}"'
}
atf_test_case dollar_at_with_text
dollar_at_with_text_head() {
atf_set descr "Test \$@ expansion when it is surrounded by text" \
"within the quotes. PR bin/33956."
}
dollar_at_with_text_body() {
cat <<'EOF' > h-f1
delim_argv() {
str=
while [ $# -gt 0 ]; do
if [ -z "${str}" ]; then
str=">$1<"
else
str="${str} >$1<"
fi
shift
done
echo "${str}"
}
EOF
cat <<'EOF' > h-f2
delim_argv() {
str=
while [ $# -gt 0 ]; do
str="${str}${str:+ }>$1<"
shift
done
echo "${str}"
}
EOF
chmod +x h-f1 h-f2
for f in 1 2
do
atf_check -s exit:0 -o inline:'\n' -e empty ${TEST_SH} -c \
". ./h-f${f}; "'set -- ; delim_argv $@'
atf_check -s exit:0 -o inline:'\n' -e empty ${TEST_SH} -c \
". ./h-f${f}; "'set -- ; delim_argv "$@"'
atf_check -s exit:0 -o inline:'>foobar<\n' -e empty \
${TEST_SH} -c \
". ./h-f${f}; "'set -- ; delim_argv "foo$@bar"'
atf_check -s exit:0 -o inline:'>foobar<\n' -e empty \
${TEST_SH} -c \
". ./h-f${f}; "'set -- ; delim_argv foo"$@"bar'
atf_check -s exit:0 -o inline:'>foo bar<\n' -e empty \
${TEST_SH} -c \
". ./h-f${f}; "'set -- ; delim_argv "foo $@ bar"'
atf_check -s exit:0 -o inline:'>foo bar<\n' -e empty \
${TEST_SH} -c \
". ./h-f${f}; "'set -- ; delim_argv foo" $@ "bar'
atf_check -s exit:0 -o inline:'>a< >b< >c<\n' -e empty \
${TEST_SH} -c \
". ./h-f${f}; "'set -- a b c; delim_argv "$@"'
atf_check -s exit:0 -o inline:'>fooa< >b< >cbar<\n' -e empty \
${TEST_SH} -c \
". ./h-f${f}; "'set -- a b c; delim_argv "foo$@bar"'
atf_check -s exit:0 -o inline:'>foo a< >b< >c bar<\n' -e empty \
${TEST_SH} -c \
". ./h-f${f}; "'set -- a b c; delim_argv "foo $@ bar"'
done
}
atf_test_case dollar_at_empty_and_conditional
dollar_at_empty_and_conditional_head() {
atf_set descr 'Test $@ expansion when there are no args, and ' \
'when conditionally expanded.'
}
dollar_at_empty_and_conditional_body() {
# same task, implementation different from previous,
# that these work is also a test...
cat <<'EOF' > h-f3
delim_argv() {
str=
for Arg; do
str="${str:+${str} }>${Arg}<"
done
printf '%s\n' "${str}"
}
EOF
chmod +x h-f3
# in these we give printf a first arg of "", which makes
# the first output char be \n, then the $@ produces anything else
# (we need to make sure we don't end up with:
# printf %s\\n
# -- that is, no operands for the %s, that's unspecified)
atf_check -s exit:0 -o inline:'\na a\nb b\n' -e empty \
${TEST_SH} -c 'set -- "a a" "b b"; printf %s\\n "" "$@"'
atf_check -s exit:0 -o inline:'\n' -e empty \
${TEST_SH} -c 'set -- ; printf %s\\n "" "$@"'
atf_check -s exit:0 -o inline:'\n' -e empty \
${TEST_SH} -c 'set -- ; printf %s\\n ""${1+"$@"}'
atf_check -s exit:0 -o inline:'\n' -e empty \
${TEST_SH} -c 'set -- ; printf %s\\n """${1+$@}"'
# in these we prefix (concat) the $@ expansion with "" to make
# sure there is always at least one arg for the %s in printf
# If there is anything else there, the prepended nothing vanishes
atf_check -s exit:0 -o inline:'a a\nb b\n' -e empty \
${TEST_SH} -c 'set -- "a a" "b b"; printf %s\\n """$@"'
atf_check -s exit:0 -o inline:'\n' -e empty \
${TEST_SH} -c 'set -- ; printf %s\\n """$@"'
atf_check -s exit:0 -o inline:'\n' -e empty \
${TEST_SH} -c 'set -- ; printf %s\\n ""${1+"$@"}'
atf_check -s exit:0 -o inline:'\n' -e empty \
${TEST_SH} -c 'set -- ; printf %s\\n """${1+$@}"'
atf_check -s exit:0 -o inline:'>a< >b< >c<\n' -e empty ${TEST_SH} -c \
'. ./h-f3; set -- a b c; delim_argv "${1+$@}"'
atf_check -s exit:0 -o inline:'>a< >b< >c<\n' -e empty ${TEST_SH} -c \
'. ./h-f3; set -- a b c; delim_argv ${1+"$@"}'
atf_check -s exit:0 -o inline:'>fooa< >b< >cbar<\n' -e empty \
${TEST_SH} -c \
'. ./h-f3; set -- a b c; delim_argv "foo${1+$@}bar"'
atf_check -s exit:0 -o inline:'>fooa< >b< >cbar<\n' -e empty \
${TEST_SH} -c \
'. ./h-f3; set -- a b c; delim_argv foo${1+"$@"}bar'
atf_check -s exit:0 -o inline:'>foo a< >b< >c bar<\n' -e empty \
${TEST_SH} -c \
'. ./h-f3; set -- a b c; delim_argv "foo ${1+$@} bar"'
atf_check -s exit:0 -o inline:'>foo a< >b< >c bar<\n' -e empty \
${TEST_SH} -c \
'. ./h-f3; set -- a b c; delim_argv "foo "${1+"$@"}" bar"'
# since $1 is not set, we get nothing ($@ is irrelevant)
# (note here we are not using printf, don't need to guarantee an arg)
atf_check -s exit:0 -o inline:'\n' -e empty ${TEST_SH} -c \
'. ./h-f3; set -- ; delim_argv ${1+"$@"}'
# here since $1 is not set we get "" as the special $@ properties
# do not apply, and ${foo+anything} generates nothing if foo is unset
atf_check -s exit:0 -o inline:'><\n' -e empty ${TEST_SH} -c \
'. ./h-f3; set -- ; delim_argv "${1+$@}"'
# in this one we get the initial "" followed by nothing
atf_check -s exit:0 -o inline:'><\n' -e empty ${TEST_SH} -c \
'. ./h-f3; set -- ; delim_argv ""${1+"$@"}'
# which we verify by changing the "" to X, and including Y
atf_check -s exit:0 -o inline:'>X<\n' -e empty ${TEST_SH} -c \
'. ./h-f3; set -- ; delim_argv X${1+"$@"Y}'
# and again, done differently (the ${1+...} produces nothing at all
atf_check -s exit:0 -o inline:'>X<\n' -e empty ${TEST_SH} -c \
'. ./h-f3; set -- ; delim_argv X ${1+"$@"}'
# in these two we get the initial "" and then nothing
atf_check -s exit:0 -o inline:'><\n' -e empty ${TEST_SH} -c \
'. ./h-f3; set -- ; delim_argv """${1+$@}"'
atf_check -s exit:0 -o inline:'>< ><\n' -e empty ${TEST_SH} -c \
'. ./h-f3; set -- ; delim_argv "" "${1+$@}"'
# now we repeat all those with $1 set (so we eval the $@)
atf_check -s exit:0 -o inline:'>a<\n' -e empty ${TEST_SH} -c \
'. ./h-f3; set -- a ; delim_argv ""${1+"$@"}'
atf_check -s exit:0 -o inline:'>XaY<\n' -e empty ${TEST_SH} -c \
'. ./h-f3; set -- a ; delim_argv X${1+"$@"Y}'
atf_check -s exit:0 -o inline:'>X< >a<\n' -e empty ${TEST_SH} -c \
'. ./h-f3; set -- a ; delim_argv X ${1+"$@"}'
atf_check -s exit:0 -o inline:'>a<\n' -e empty ${TEST_SH} -c \
'. ./h-f3; set -- a ; delim_argv """${1+$@}"'
atf_check -s exit:0 -o inline:'>< >a<\n' -e empty ${TEST_SH} -c \
'. ./h-f3; set -- a ; delim_argv "" "${1+$@}"'
# now we do all of those again, but testing $X instead of $1 (X set)
atf_check -s exit:0 -o inline:'\n' -e empty ${TEST_SH} -c \
'. ./h-f3; X=1; set -- ; delim_argv ${X+"$@"}'
atf_check -s exit:0 -o inline:'><\n' -e empty ${TEST_SH} -c \
'. ./h-f3; X=1; set -- ; delim_argv ""${X+"$@"}'
atf_check -s exit:0 -o inline:'>X<\n' -e empty ${TEST_SH} -c \
'. ./h-f3; X=1; set -- ; delim_argv X${X+"$@"}'
atf_check -s exit:0 -o inline:'>X<\n' -e empty ${TEST_SH} -c \
'. ./h-f3; X=1; set -- ; delim_argv X ${X+"$@"}'
atf_check -s exit:0 -o inline:'\n' -e empty ${TEST_SH} -c \
'. ./h-f3; X=1; set -- ; delim_argv "${X+$@}"'
atf_check -s exit:0 -o inline:'><\n' -e empty ${TEST_SH} -c \
'. ./h-f3; X=1; set -- ; delim_argv """${X+$@}"'
atf_check -s exit:0 -o inline:'><\n' -e empty ${TEST_SH} -c \
'. ./h-f3; X=1; set -- ; delim_argv "" "${X+$@}"'
atf_check -s exit:0 -o inline:'>a<\n' -e empty ${TEST_SH} -c \
'. ./h-f3; X=1; set -- a; delim_argv ${X+"$@"}'
atf_check -s exit:0 -o inline:'>a< >b<\n' -e empty ${TEST_SH} -c \
'. ./h-f3; X=1; set -- a b; delim_argv ${X+"$@"}'
atf_check -s exit:0 -o inline:'>a<\n' -e empty ${TEST_SH} -c \
'. ./h-f3; X=1; set -- a ; delim_argv ""${X+"$@"}'
atf_check -s exit:0 -o inline:'>Xa<\n' -e empty ${TEST_SH} -c \
'. ./h-f3; X=1; set -- a ; delim_argv X${X+"$@"}'
atf_check -s exit:0 -o inline:'>X< >a<\n' -e empty ${TEST_SH} -c \
'. ./h-f3; X=1; set -- a ; delim_argv X ${X+"$@"}'
atf_check -s exit:0 -o inline:'>a<\n' -e empty ${TEST_SH} -c \
'. ./h-f3; X=1; set -- a ; delim_argv """${X+$@}"'
atf_check -s exit:0 -o inline:'>a< >b<\n' -e empty ${TEST_SH} -c \
'. ./h-f3; X=1; set -- a b ; delim_argv """${X+$@}"'
atf_check -s exit:0 -o inline:'>< >a<\n' -e empty ${TEST_SH} -c \
'. ./h-f3; X=1; set -- a ; delim_argv "" "${X+$@}"'
atf_check -s exit:0 -o inline:'>< >a< >b<\n' -e empty ${TEST_SH} -c \
'. ./h-f3; X=1; set -- a b ; delim_argv "" "${X+$@}"'
# and again, but testing $X where X is unset
atf_check -s exit:0 -o inline:'\n' -e empty ${TEST_SH} -c \
'. ./h-f3; unset X; set -- ; delim_argv ${X+"$@"}'
atf_check -s exit:0 -o inline:'><\n' -e empty ${TEST_SH} -c \
'. ./h-f3; unset X; set -- ; delim_argv ""${X+"$@"}'
atf_check -s exit:0 -o inline:'>X<\n' -e empty ${TEST_SH} -c \
'. ./h-f3; unset X; set -- ; delim_argv X${X+"$@"}'
atf_check -s exit:0 -o inline:'>X<\n' -e empty ${TEST_SH} -c \
'. ./h-f3; unset X; set -- ; delim_argv X ${X+"$@"}'
atf_check -s exit:0 -o inline:'><\n' -e empty ${TEST_SH} -c \
'. ./h-f3; unset X; set -- ; delim_argv "${X+$@}"'
atf_check -s exit:0 -o inline:'><\n' -e empty ${TEST_SH} -c \
'. ./h-f3; unset X; set -- ; delim_argv """${X+$@}"'
atf_check -s exit:0 -o inline:'>< ><\n' -e empty ${TEST_SH} -c \
'. ./h-f3; unset X; set -- ; delim_argv "" "${X+$@}"'
atf_check -s exit:0 -o inline:'\n' -e empty ${TEST_SH} -c \
'. ./h-f3; unset X; set -- a; delim_argv ${X+"$@"}'
atf_check -s exit:0 -o inline:'\n' -e empty ${TEST_SH} -c \
'. ./h-f3; unset X; set -- a b; delim_argv ${X+"$@"}'
atf_check -s exit:0 -o inline:'><\n' -e empty ${TEST_SH} -c \
'. ./h-f3; unset X; set -- a ; delim_argv ""${X+"$@"}'
atf_check -s exit:0 -o inline:'>X<\n' -e empty ${TEST_SH} -c \
'. ./h-f3; unset X; set -- a ; delim_argv X${X+"$@"}'
atf_check -s exit:0 -o inline:'>X<\n' -e empty ${TEST_SH} -c \
'. ./h-f3; unset X; set -- a ; delim_argv X ${X+"$@"}'
atf_check -s exit:0 -o inline:'><\n' -e empty ${TEST_SH} -c \
'. ./h-f3; unset X; set -- a ; delim_argv """${X+$@}"'
atf_check -s exit:0 -o inline:'>< ><\n' -e empty ${TEST_SH} -c \
'. ./h-f3; unset X; set -- a; delim_argv "" "${X+$@}"'
# a few that stretch belief...
atf_check -s exit:0 -o inline:'>a< >b<\n' -e empty ${TEST_SH} -c \
'. ./h-f3; X=1; set -- a b ; delim_argv ${X+${1+"$@"}}'
atf_check -s exit:0 -o inline:'\n' -e empty ${TEST_SH} -c \
'. ./h-f3; X=1; set -- ; delim_argv ${X+${1+"$@"}}'
atf_check -s exit:0 -o inline:'\n' -e empty ${TEST_SH} -c \
'. ./h-f3; unset X; set -- a b ; delim_argv ${X+${1+"$@"}}'
# and now for something completely different
atf_check -s exit:0 -o inline:'>a< >b< >ca< >b< >c<\n' -e empty \
${TEST_SH} -c '. ./h-f3; set -- a b c; delim_argv "$@$@"'
atf_check -s exit:0 -o inline:'>a< >b< >ca b c<\n' -e empty \
${TEST_SH} -c '. ./h-f3; set -- a b c; delim_argv "$@$*"'
atf_check -s exit:0 -o inline:'>a b ca< >b< >c<\n' -e empty \
${TEST_SH} -c '. ./h-f3; set -- a b c; delim_argv "$*$@"'
atf_check -s exit:0 -o inline:'>a a++b + ca a< >< >b < > c<\n' \
-e empty ${TEST_SH} -c \
'. ./h-f3; set -- "a a" "" "b " " c"; IFS=+; delim_argv "$*$@"'
atf_check -s exit:0 -o inline:'>a< >a< >< >b < > ca+a< >< >b < > c<\n' \
-e empty ${TEST_SH} -c \
'. ./h-f3; set -- "a+a" "" "b " " c"; IFS=+; delim_argv $*"$@"'
}
atf_test_case strip
strip_head() {
atf_set descr "Checks that the %% operator works and strips" \
"the contents of a variable from the given point" \
"to the end"
}
strip_body() {
line='#define bindir "/usr/bin" /* comment */'
stripped='#define bindir "/usr/bin" '
# atf_expect_fail "PR bin/43469" -- now fixed
for exp in \
'${line%%/\**}' \
'${line%%"/*"*}' \
'${line%%'"'"'/*'"'"'*}' \
'"${line%%/\**}"' \
'"${line%%"/*"*}"' \
'"${line%%'"'"'/*'"'"'*}"' \
'${line%/\**}' \
'${line%"/*"*}' \
'${line%'"'"'/*'"'"'*}' \
'"${line%/\**}"' \
'"${line%"/*"*}"' \
'"${line%'"'"'/*'"'"'*}"'
do
atf_check -o inline:":$stripped:\n" -e empty ${TEST_SH} -c \
"line='${line}'; echo :${exp}:"
done
}
atf_test_case wrap_strip
wrap_strip_head() {
atf_set descr "Checks that the %% operator works and strips" \
"the contents of a variable from the given point" \
'to the end, and that \ \n sequences do not break it'
}
wrap_strip_body() {
line='#define bindir "/usr/bin" /* comment */'
stripped='#define bindir "/usr/bin" '
for exp in \
'${line\
%%/\**}' \
'${line%%"/\
*"*}' \
'${line%%'"'"'/*'"'"'\
*}' \
'"${li\
ne%%/\**}"' \
'"${line%%"\
/*"*}"' \
'"${line%\
%'"'"'/*'"'"'*}"' \
'${line\
%\
/\*\
*\
}' \
'${line%"/*\
"*\
}' \
'${line\
%\
'"'"'/*'"'"'*}' \
'"$\
{li\
ne%\
'"'"'/*'"'"'*}"'
do
atf_check -o inline:":$stripped:\n" -e empty ${TEST_SH} -c \
"line='${line}'; echo :${exp}:"
done
}
atf_test_case tilde
tilde_head() {
atf_set descr "Checks that the ~ expansions work"
}
tilde_body() {
for HOME in '' / /home/foo \
/a/very/long/home/directory/path/that/might/push/the/tilde/expansion/code/beyond/what/it/would/normally/ever/see/on/any/sane/system/and/perhaps/expose/some/bugs
do
export HOME
atf_check -s exit:0 -e empty \
-o inline:'HOME\t'"${HOME}"'
~\t'"${HOME}"'
~/foobar\t'"${HOME}"'/foobar
"$V"\t'"${HOME}"'
"$X"\t~
"$Y"\t'"${HOME}"':'"${HOME}"'
"$YY"\t'"${HOME}"'/foo:'"${HOME}"'/bar
"$Z"\t'"${HOME}"'/~
${U:-~}\t'"${HOME}"'
$V\t'"${HOME}"'
$X\t~
$Y\t'"${HOME}"':'"${HOME}"'
$YY\t'"${HOME}"'/foo:'"${HOME}"'/bar
$Z\t'"${HOME}"'/~
${U:=~}\t'"${HOME}"'
${UU:=~:~}\t'"${HOME}"':'"${HOME}"'
${UUU:=~/:~}\t'"${HOME}"'/:'"${HOME}"'
${U4:=~/:~/}\t'"${HOME}"'/:'"${HOME}"'/\n' \
${TEST_SH} -s <<- \EOF
unset -v U UU UUU U4
V=~
X="~"
Y=~:~ YY=~/foo:~/bar
Z=~/~
printf '%s\t%s\n' \
'HOME' "${HOME}" \
'~' ~ \
'~/foobar' ~/foobar \
'"$V"' "$V" \
'"$X"' "$X" \
'"$Y"' "$Y" \
'"$YY"' "$YY" \
'"$Z"' "$Z" \
'${U:-~}' ''${U:-~} \
'$V' ''$V \
'$X' ''$X \
'$Y' ''$Y \
'$YY' ''$YY \
'$Z' ''$Z \
'${U:=~}' ''${U:=~} \
'${UU:=~:~}' ''${UU:=~:~} \
'${UUU:=~/:~}' ''${UUU:=~/:~} \
'${U4:=~/:~/}' ''${U4:=~/:~/}
EOF
done
# Testing ~user is harder, so, perhaps later...
}
atf_test_case varpattern_backslashes
varpattern_backslashes_head() {
atf_set descr "Tests that protecting wildcards with backslashes" \
"works in variable patterns."
}
varpattern_backslashes_body() {
line='/foo/bar/*/baz'
stripped='/foo/bar/'
atf_check -o inline:'/foo/bar/\n' -e empty ${TEST_SH} -c \
'line="/foo/bar/*/baz"; echo ${line%%\**}'
}
atf_test_case arithmetic
arithmetic_head() {
atf_set descr "POSIX requires shell arithmetic to use signed" \
"long or a wider type. We use intmax_t, so at" \
"least 64 bits should be available. Make sure" \
"this is true."
}
arithmetic_body() {
atf_check -o inline:'3' -e empty ${TEST_SH} -c \
'printf %s $((1 + 2))'
atf_check -o inline:'2147483647' -e empty ${TEST_SH} -c \
'printf %s $((0x7fffffff))'
atf_check -o inline:'9223372036854775807' -e empty ${TEST_SH} -c \
'printf %s $(((1 << 63) - 1))'
}
atf_test_case iteration_on_null_parameter
iteration_on_null_parameter_head() {
atf_set descr "Check iteration of \$@ in for loop when set to null;" \
"the error \"sh: @: parameter not set\" is incorrect." \
"PR bin/48202."
}
iteration_on_null_parameter_body() {
atf_check -o empty -e empty ${TEST_SH} -c \
'N=; set -- ${N}; for X; do echo "[$X]"; done'
}
atf_test_case iteration_on_quoted_null_parameter
iteration_on_quoted_null_parameter_head() {
atf_set descr \
'Check iteration of "$@" in for loop when set to null;'
}
iteration_on_quoted_null_parameter_body() {
atf_check -o inline:'[]\n' -e empty ${TEST_SH} -c \
'N=; set -- "${N}"; for X; do echo "[$X]"; done'
}
atf_test_case iteration_on_null_or_null_parameter
iteration_on_null_or_null_parameter_head() {
atf_set descr \
'Check expansion of null parameter as default for another null'
}
iteration_on_null_or_null_parameter_body() {
atf_check -o empty -e empty ${TEST_SH} -c \
'N=; E=; set -- ${N:-${E}}; for X; do echo "[$X]"; done'
}
atf_test_case iteration_on_null_or_missing_parameter
iteration_on_null_or_missing_parameter_head() {
atf_set descr \
'Check expansion of missing parameter as default for another null'
}
iteration_on_null_or_missing_parameter_body() {
# atf_expect_fail 'PR bin/50834'
atf_check -o empty -e empty ${TEST_SH} -c \
'N=; set -- ${N:-}; for X; do echo "[$X]"; done'
}
####### The remaining tests use the following helper functions ...
nl='
'
reset()
{
TEST_NUM=0
TEST_FAILURES=''
TEST_FAIL_COUNT=0
TEST_ID="$1"
}
check()
{
fail=false
TEMP_FILE=$( mktemp OUT.XXXXXX )
TEST_NUM=$(( $TEST_NUM + 1 ))
MSG=
# our local shell (ATF_SHELL) better do quoting correctly...
# some of the tests expect us to expand $nl internally...
CMD="$1"
result="$( ${TEST_SH} -c "${CMD}" 2>"${TEMP_FILE}" )"
STATUS=$?
if [ "${STATUS}" -ne "$3" ]; then
MSG="${MSG}${MSG:+${nl}}[$TEST_NUM]"
MSG="${MSG} expected exit code $3, got ${STATUS}"
# don't actually fail just because of wrong exit code
# unless we either expected, or received "good"
# or something else is detected as incorrect as well.
case "$3/${STATUS}" in
(*/0|0/*) fail=true;;
esac
fi
if [ "$3" -eq 0 ]; then
if [ -s "${TEMP_FILE}" ]; then
MSG="${MSG}${MSG:+${nl}}[$TEST_NUM]"
MSG="${MSG} Messages produced on stderr unexpected..."
MSG="${MSG}${nl}$( cat "${TEMP_FILE}" )"
fail=true
fi
else
if ! [ -s "${TEMP_FILE}" ]; then
MSG="${MSG}${MSG:+${nl}}[$TEST_NUM]"
MSG="${MSG} Expected messages on stderr,"
MSG="${MSG} nothing produced"
fail=true
fi
fi
rm -f "${TEMP_FILE}"
# Remove newlines (use local shell for this)
oifs="$IFS"
IFS="$nl"
result="$(echo $result)"
IFS="$oifs"
if [ "$2" != "$result" ]
then
MSG="${MSG}${MSG:+${nl}}[$TEST_NUM]"
MSG="${MSG} Expected output '$2', received '$result'"
fail=true
fi
if $fail
then
MSG="${MSG}${MSG:+${nl}}[$TEST_NUM]"
MSG="${MSG} Full command: <<${CMD}>>"
fi
$fail && test -n "$TEST_ID" && {
TEST_FAILURES="${TEST_FAILURES}${TEST_FAILURES:+${nl}}"
TEST_FAILURES="${TEST_FAILURES}${TEST_ID}[$TEST_NUM]:"
TEST_FAILURES="${TEST_FAILURES} Test of '$1' failed.";
TEST_FAILURES="${TEST_FAILURES}${nl}${MSG}"
TEST_FAIL_COUNT=$(( $TEST_FAIL_COUNT + 1 ))
return 0
}
$fail && atf_fail "Test[$TEST_NUM] failed: $(
# ATF does not like newlines in messages, so change them...
printf '%s' "${MSG}" | tr '\n' ';'
)"
return 0
}
results()
{
test -n "$1" && atf_expect_fail "$1"
test -z "${TEST_ID}" && return 0
test -z "${TEST_FAILURES}" && return 0
echo >&2 "=========================================="
echo >&2 "While testing '${TEST_ID}'"
echo >&2 " - - - - - - - - - - - - - - - - -"
echo >&2 "${TEST_FAILURES}"
atf_fail \
"Test ${TEST_ID}: $TEST_FAIL_COUNT (of $TEST_NUM) subtests failed - see stderr"
}
####### End helpers
atf_test_case shell_params
shell_params_head() {
atf_set descr "Test correct operation of the numeric parameters"
}
shell_params_body() {
atf_require_prog mktemp
reset shell_params
check 'set -- a b c; echo "$#: $1 $2 $3"' '3: a b c' 0
check 'set -- a b c d e f g h i j k l m; echo "$#: ${1}0 ${10} $10"' \
'13: a0 j a0' 0
check 'x="$0"; set -- a b; y="$0";
[ "x${x}y" = "x${y}y" ] && echo OK || echo x="$x" y="$y"' \
'OK' 0
check "${TEST_SH} -c 'echo 0=\$0 1=\$1 2=\$2' a b c" '0=a 1=b 2=c' 0
echo 'echo 0="$0" 1="$1" 2="$2"' > helper.sh
check "${TEST_SH} helper.sh a b c" '0=helper.sh 1=a 2=b' 0
check 'set -- a bb ccc dddd eeeee ffffff ggggggg hhhhhhhh \
iiiiiiiii jjjjjjjjjj kkkkkkkkkkk
echo "${#}: ${#1} ${#2} ${#3} ${#4} ... ${#9} ${#10} ${#11}"' \
'11: 1 2 3 4 ... 9 10 11' 0
check 'set -- a b c; echo "$#: ${1-A} ${2-B} ${3-C} ${4-D} ${5-E}"' \
'3: a b c D E' 0
check 'set -- a "" c "" e
echo "$#: ${1:-A} ${2:-B} ${3:-C} ${4:-D} ${5:-E}"' \
'5: a B c D e' 0
check 'set -- a "" c "" e
echo "$#: ${1:+A} ${2:+B} ${3:+C} ${4:+D} ${5:+E}"' \
'5: A C E' 0
check 'set -- "abab*cbb"
echo "${1} ${1#a} ${1%b} ${1##ab} ${1%%b} ${1#*\*} ${1%\**}"' \
'abab*cbb bab*cbb abab*cb ab*cbb abab*cb cbb abab' 0
check 'set -- "abab?cbb"
echo "${1}:${1#*a}+${1%b*}-${1##*a}_${1%%b*}%${1#[ab]}=${1%?*}/${1%\?*}"' \
'abab?cbb:bab?cbb+abab?cb-b?cbb_a%bab?cbb=abab?cb/abab' 0
check 'set -- a "" c "" e; echo "${2:=b}"' '' 1
check 'set -- a b c d; echo ${4294967297}' '' 0 # result 'a' => ${1}
check 'set -- a b c; echo ${01}' 'a' 0
check "${TEST_SH} -c 'echo 0=\${00} 1=\${01} 2=\${02}' a b c" \
'0=a 1=b 2=c' 0
# by special request, for PaulG... (${0...} is not octal!)
# Posix XCU 2.5.1 (Issue 7 TC2 pg 2349 lines 74835..6):
# The digits denoting the positional parameters shall always
# be interpreted as a decimal value, even if there is a leading zero.
check \
'set -- a b c d e f g h i j k l m; echo "$#: ${08} ${010} ${011}"' \
'13: h j k' 0
results
}
atf_test_case var_with_embedded_cmdsub
var_with_embedded_cmdsub_head() {
atf_set descr "Test expansion of vars with embedded cmdsub"
}
var_with_embedded_cmdsub_body() {
reset var_with_embedded_cmdsub
check 'unset x; echo ${x-$(echo a)}$(echo b)' 'ab' 0 #1
check 'unset x; echo ${x:-$(echo a)}$(echo b)' 'ab' 0 #2
check 'x=""; echo ${x-$(echo a)}$(echo b)' 'b' 0 #3
check 'x=""; echo ${x:-$(echo a)}$(echo b)' 'ab' 0 #4
check 'x=c; echo ${x-$(echo a)}$(echo b)' 'cb' 0 #5
check 'x=c; echo ${x:-$(echo a)}$(echo b)' 'cb' 0 #6
check 'unset x; echo ${x+$(echo a)}$(echo b)' 'b' 0 #7
check 'unset x; echo ${x:+$(echo a)}$(echo b)' 'b' 0 #8
check 'x=""; echo ${x+$(echo a)}$(echo b)' 'ab' 0 #9
check 'x=""; echo ${x:+$(echo a)}$(echo b)' 'b' 0 #10
check 'x=c; echo ${x+$(echo a)}$(echo b)' 'ab' 0 #11
check 'x=c; echo ${x:+$(echo a)}$(echo b)' 'ab' 0 #12
check 'unset x; echo ${x=$(echo a)}$(echo b)' 'ab' 0 #13
check 'unset x; echo ${x:=$(echo a)}$(echo b)' 'ab' 0 #14
check 'x=""; echo ${x=$(echo a)}$(echo b)' 'b' 0 #15
check 'x=""; echo ${x:=$(echo a)}$(echo b)' 'ab' 0 #16
check 'x=c; echo ${x=$(echo a)}$(echo b)' 'cb' 0 #17
check 'x=c; echo ${x:=$(echo a)}$(echo b)' 'cb' 0 #18
check 'unset x; echo ${x?$(echo a)}$(echo b)' '' 2 #19
check 'unset x; echo ${x:?$(echo a)}$(echo b)' '' 2 #20
check 'x=""; echo ${x?$(echo a)}$(echo b)' 'b' 0 #21
check 'x=""; echo ${x:?$(echo a)}$(echo b)' '' 2 #22
check 'x=c; echo ${x?$(echo a)}$(echo b)' 'cb' 0 #23
check 'x=c; echo ${x:?$(echo a)}$(echo b)' 'cb' 0 #24
check 'unset x; echo ${x%$(echo a)}$(echo b)' 'b' 0 #25
check 'unset x; echo ${x%%$(echo a)}$(echo b)' 'b' 0 #26
check 'x=""; echo ${x%$(echo a)}$(echo b)' 'b' 0 #27
check 'x=""; echo ${x%%$(echo a)}$(echo b)' 'b' 0 #28
check 'x=c; echo ${x%$(echo a)}$(echo b)' 'cb' 0 #29
check 'x=c; echo ${x%%$(echo a)}$(echo b)' 'cb' 0 #30
check 'x=aa; echo ${x%$(echo "*a")}$(echo b)' 'ab' 0 #31
check 'x=aa; echo ${x%%$(echo "*a")}$(echo b)' 'b' 0 #32
check 'unset x; echo ${x#$(echo a)}$(echo b)' 'b' 0 #33
check 'unset x; echo ${x##$(echo a)}$(echo b)' 'b' 0 #34
check 'x=""; echo ${x#$(echo a)}$(echo b)' 'b' 0 #35
check 'x=""; echo ${x##$(echo a)}$(echo b)' 'b' 0 #36
check 'x=c; echo ${x#$(echo a)}$(echo b)' 'cb' 0 #37
check 'x=c; echo ${x##$(echo a)}$(echo b)' 'cb' 0 #38
check 'x=aa; echo ${x#$(echo "*a")}$(echo b)' 'ab' 0 #39
check 'x=aa; echo ${x##$(echo "*a")}$(echo b)' 'b' 0 #40
results
}
atf_test_case dollar_hash
dollar_hash_head() {
atf_set descr 'Test expansion of various aspects of $#'
}
dollar_hash_body() {
#
# $# looks like it should be so simple that it doesn't really
# need a test of its own, and used in that way, it really doesn't.
# But when we add braces ${#} we need to deal with the three
# (almost 4) different meanings of a # inside a ${} expansion...
#
# Note that some of these are just how we treat expansions that
# are unspecified by posix (as noted below.)
#
# 1. ${#} is just $# (number of params)
# 1.a ${\#} is nothing at all (error: invalid expansion)
# 1.b ${\#...} (anything after) is the same (invalid)
# 2. ${#VAR} is the length of the value VAR
# 2.a Including ${##} - the length of ${#}
# 3 ${VAR#pat} is the value of VAR with leading pat removed
# 3.a Including ${VAR#} which just removes leading nothing
# This is relevant in case of ${VAR#${X}} with X=''
# nb: not required by posix, see XCU 2.6.2
# 3.b ${##} is not a case of 3.a but rather 2.a
# 3.c Yet ${##pat} is a case of 3.a
# Including ${##${X}} where X='' or X='#'
# nb: not required by posix, see XCU 2.6.2
# 3.d And ${#\#} is invalid (error)
# 3.e But ${##\#} removes a leading # from the value of $#
# (so is just $# as there is no leading # there)
# nb: not required by posix, see XCU 2.6.2
# 4 ${VAR##pat} is the value of VAR with longest pat removed
# 4.a Including ${VAR##} which removes the longest nothing
# 4.b Which in this case includes ${###} (so is == $#)
# nb: not required by posix, see XCU 2.6.2
# 4.c But not ${##\#} which is $# with a leading '#' removed
# (and so is also == $#), i.e.: like ${###} but different.
# nb: not required by posix, see XCU 2.6.2
# 4.d As is ${###\#} or just ${####} - remove # (so just $#)
# nb: not required by posix, see XCU 2.6.2
#
reset dollar_hash
check 'set -- ; echo $#' '0' 0 # 1
check 'set -- a b c; echo $#' '3' 0 # 2
check 'set -- a b c d e f g h i j; echo $#' '10' 0 # 3
# rule 1
check 'set -- ; echo ${#}' '0' 0 # 4
check 'set -- a b c; echo ${#}' '3' 0 # 5
check 'set -- a b c d e f g h i j; echo ${#}' '10' 0 # 6
# rule 1.a
check 'set -- a b c; echo ${\#}' '' 2 # 7
# rule 1.b
check 'set -- a b c; echo ${\#:-foo}' '' 2 # 8
# rule 2
check 'VAR=12345; echo ${#VAR}' '5' 0 # 9
check 'VAR=123456789012; echo ${#VAR}' '12' 0 #10
# rule 2.a
check 'set -- ; echo ${##}' '1' 0 #11
check 'set -- a b c; echo ${##}' '1' 0 #12
check 'set -- a b c d e f g h i j; echo ${##}' '2' 0 #13
# rule 3
check 'VAR=12345; echo ${VAR#1}' '2345' 0 #14
check 'VAR=12345; echo ${VAR#2}' '12345' 0 #15
check 'VAR=#2345; echo ${VAR#\#}' '2345' 0 #16
check 'X=1; VAR=12345; echo ${VAR#${X}}' '2345' 0 #17
check 'X=1; VAR=#2345; echo ${VAR#${X}}' '#2345' 0 #18
# rule 3.a
check 'VAR=12345; echo ${VAR#}' '12345' 0 #19
check 'X=; VAR=12345; echo ${VAR#${X}}' '12345' 0 #20
# rule 3.b (tested above, rule 2.a)
# rule 3.c
check 'set -- ; echo ${##0}' '' 0 #21
check 'set -- a b c; echo ${##1}' '3' 0 #22
check 'set -- a b c d e f g h i j; echo ${##1}' '0' 0 #23
check 'X=0; set -- ; echo ${##${X}}' '' 0 #24
check 'X=; set -- ; echo ${##${X}}' '0' 0 #25
check 'X=1; set -- a b c; echo ${##${X}}' '3' 0 #26
check 'X=1; set -- a b c d e f g h i j; echo ${##${X}}' '0' 0 #27
check 'X=; set -- a b c d e f g h i j; echo ${##${X}}' '10' 0 #28
check 'X=#; VAR=#2345; echo ${VAR#${X}}' '2345' 0 #29
check 'X=#; VAR=12345; echo ${VAR#${X}}' '12345' 0 #30
# rule 3.d
check 'set -- a b c; echo ${#\#}' '' 2 #31
# rule 3.e
check 'set -- ; echo ${##\#}' '0' 0 #32
check 'set -- a b c d e f g h i j; echo ${##\#}' '10' 0 #33
# rule 4
check 'VAR=12345; echo ${VAR##1}' '2345' 0 #34
check 'VAR=12345; echo ${VAR##\1}' '2345' 0 #35
# rule 4.a
check 'VAR=12345; echo ${VAR##}' '12345' 0 #36
# rule 4.b
check 'set -- ; echo ${###}' '0' 0 #37
check 'set -- a b c d e f g h i j; echo ${###}' '10' 0 #38
# rule 4.c
check 'VAR=12345; echo ${VAR#\#}' '12345' 0 #39
check 'VAR=12345; echo ${VAR#\#1}' '12345' 0 #40
check 'VAR=#2345; echo ${VAR#\#}' '2345' 0 #41
check 'VAR=#12345; echo ${VAR#\#1}' '2345' 0 #42
check 'VAR=#2345; echo ${VAR#\#1}' '#2345' 0 #43
check 'set -- ; echo ${####}' '0' 0 #44
check 'set -- ; echo ${###\#}' '0' 0 #45
check 'set -- a b c d e f g h i j; echo ${####}' '10' 0 #46
check 'set -- a b c d e f g h i j; echo ${###\#}' '10' 0 #47
# now check for some more utter nonsense, not mentioned in the rules
# above (doesn't need to be)
check 'x=hello; set -- a b c; echo ${#x:-1}' '' 2 #48
check 'x=hello; set -- a b c; echo ${#x-1}' '' 2 #49
check 'x=hello; set -- a b c; echo ${#x:+1}' '' 2 #50
check 'x=hello; set -- a b c; echo ${#x+1}' '' 2 #51
check 'x=hello; set -- a b c; echo ${#x+1}' '' 2 #52
check 'x=hello; set -- a b c; echo ${#x:?msg}' '' 2 #53
check 'x=hello; set -- a b c; echo ${#x?msg}' '' 2 #54
check 'x=hello; set -- a b c; echo ${#x:=val}' '' 2 #55
check 'x=hello; set -- a b c; echo ${#x=val}' '' 2 #56
check 'x=hello; set -- a b c; echo ${#x#h}' '' 2 #57
check 'x=hello; set -- a b c; echo ${#x#*l}' '' 2 #58
check 'x=hello; set -- a b c; echo ${#x##*l}' '' 2 #59
check 'x=hello; set -- a b c; echo ${#x%o}' '' 2 #60
check 'x=hello; set -- a b c; echo ${#x%l*}' '' 2 #61
check 'x=hello; set -- a b c; echo ${#x%%l*}' '' 2 #62
# but just to be complete, these ones should work
check 'x=hello; set -- a b c; echo ${#%5}' '3' 0 #63
check 'x=hello; set -- a b c; echo ${#%3}' '' 0 #64
check 'x=hello; set -- a b c; echo ${#%?}' '' 0 #65
check 'X=#; set -- a b c; echo ${#%${X}}' '3' 0 #66
check 'X=3; set -- a b c; echo ${#%${X}}' '' 0 #67
check 'set -- a b c; echo ${#%%5}' '3' 0 #68
check 'set -- a b c; echo ${#%%3}' '' 0 #69
check 'set -- a b c d e f g h i j k l; echo ${#%1}' '12' 0 #70
check 'set -- a b c d e f g h i j k l; echo ${#%2}' '1' 0 #71
check 'set -- a b c d e f g h i j k l; echo ${#%?}' '1' 0 #72
check 'set -- a b c d e f g h i j k l; echo ${#%[012]}' '1' 0 #73
check 'set -- a b c d e f g h i j k l; echo ${#%[0-4]}' '1' 0 #74
check 'set -- a b c d e f g h i j k l; echo ${#%?2}' '' 0 #75
check 'set -- a b c d e f g h i j k l; echo ${#%1*}' '' 0 #76
check 'set -- a b c d e f g h i j k l; echo ${#%%2}' '1' 0 #77
check 'set -- a b c d e f g h i j k l; echo ${#%%1*}' '' 0 #78
# and this lot are stupid, as $# is never unset or null, but they do work...
check 'set -- a b c; echo ${#:-99}' '3' 0 #79
check 'set -- a b c; echo ${#-99}' '3' 0 #80
check 'set -- a b c; echo ${#:+99}' '99' 0 #81
check 'set -- a b c; echo ${#+99}' '99' 0 #82
check 'set -- a b c; echo ${#:?bogus}' '3' 0 #83
check 'set -- a b c; echo ${#?bogus}' '3' 0 #84
# even this utter nonsense is OK, as while special params cannot be
# set this way, here, as $# is not unset, or null, the assignment
# never happens (isn't even attempted)
check 'set -- a b c; echo ${#:=bogus}' '3' 0 #85
check 'set -- a b c; echo ${#=bogus}' '3' 0 #86
for n in 0 1 10 25 100 #87 #88 #89 #90 #91
do
check "(exit $n)"'; echo ${#?}' "${#n}" 0
done
results # results so far anyway...
# now we have some harder to verify cases, as they (must) check unknown values
# and hence the resuls cannot just be built into the script, but we have
# to use some tricks to validate them, so for these, just do regular testing
# and don't attempt to use the check helper function, nor to include
# these tests in the result summary. If anything has already failed, we
# do not get this far... From here on, first failure ends this test.
for opts in '' '-a' '-au' '-auf' '-aufe' # options safe enough to set
do
# Note the shell might have other (or these) opts set already
RES=$(${TEST_SH} -c "test -n '${opts}' && set ${opts};
printf '%s' \"\$-\";printf ' %s\\n' \"\${#-}\"") ||
atf_fail '${#-} test exited with status '"$?"
LEN="${RES##* }"
DMINUS="${RES% ${LEN}}"
if [ "${#DMINUS}" != "${LEN}" ]
then
atf_fail \
'${#-} test'" produced ${LEN} for opts ${DMINUS} (${RES})"
fi
done
for seq in a b c d e f g h i j
do
# now we are tryin to generate different pids for $$ and $!
# so we just run the test a number of times, and hope...
# On NetBSD pid randomisation will usually help the tests
eval "$(${TEST_SH} -c \
'(exit 0)& BG=$! LBG=${#!};
printf "SH=%s BG=%s LSH=%s LBG=%s" "$$" "$BG" "${#$}" "$LBG";
wait')"
if [ "${#SH}" != "${LSH}" ] || [ "${#BG}" != "${LBG}" ]
then
atf_fail \
'${#!] of '"${BG} was ${LBG}, expected ${#BG}"'; ${#$} of '"${SH} was ${LSH}, expected ${#SH}"
fi
done
}
atf_test_case dollar_star
dollar_star_head() {
atf_set descr 'Test expansion of various aspects of $*'
}
dollar_star_body() {
reset dollar_star
check 'set -- a b c; echo $# $*' '3 a b c' 0 # 1
check 'set -- a b c; echo $# "$*"' '3 a b c' 0 # 2
check 'set -- a "b c"; echo $# $*' '2 a b c' 0 # 3
check 'set -- a "b c"; echo $# "$*"' '2 a b c' 0 # 4
check 'set -- a b c; set -- $* ; echo $# $*' '3 a b c' 0 # 5
check 'set -- a b c; set -- "$*" ; echo $# $*' '1 a b c' 0 # 6
check 'set -- a "b c"; set -- $* ; echo $# $*' '3 a b c' 0 # 7
check 'set -- a "b c"; set -- "$*" ; echo $# $*' \
'1 a b c' 0 # 8
check 'IFS=". "; set -- a b c; echo $# $*' '3 a b c' 0 # 9
check 'IFS=". "; set -- a b c; echo $# "$*"' '3 a.b.c' 0 #10
check 'IFS=". "; set -- a "b c"; echo $# $*' '2 a b c' 0 #11
check 'IFS=". "; set -- a "b c"; echo $# "$*"' '2 a.b c' 0 #12
check 'IFS=". "; set -- a "b.c"; echo $# $*' '2 a b c' 0 #13
check 'IFS=". "; set -- a "b.c"; echo $# "$*"' '2 a.b.c' 0 #14
check 'IFS=". "; set -- a b c; set -- $* ; echo $# $*' \
'3 a b c' 0 #15
check 'IFS=". "; set -- a b c; set -- "$*" ; echo $# $*' \
'1 a b c' 0 #16
check 'IFS=". "; set -- a "b c"; set -- $* ; echo $# $*' \
'3 a b c' 0 #17
check 'IFS=". "; set -- a "b c"; set -- "$*" ; echo $# $*' \
'1 a b c' 0 #18
check 'IFS=". "; set -- a b c; set -- $* ; echo $# "$*"' \
'3 a.b.c' 0 #19
check 'IFS=". "; set -- a b c; set -- "$*" ; echo $# "$*"' \
'1 a.b.c' 0 #20
check 'IFS=". "; set -- a "b c"; set -- $* ; echo $# "$*"' \
'3 a.b.c' 0 #21
check 'IFS=". "; set -- a "b c"; set -- "$*" ; echo $# "$*"' \
'1 a.b c' 0 #22
results
}
atf_test_case dollar_star_in_word
dollar_star_in_word_head() {
atf_set descr 'Test expansion $* occurring in word of ${var:-word}'
}
dollar_star_in_word_body() {
reset dollar_star_in_word
unset xXx ; # just in case!
# Note that the expected results for these tests are identical
# to those from the dollar_star test. It should never make
# a difference whether we expand $* or ${unset:-$*}
# (note expanding ${unset:-"$*"} is different, that is not tested here)
check 'set -- a b c; echo $# ${xXx:-$*}' '3 a b c' 0 # 1
check 'set -- a b c; echo $# "${xXx:-$*}"' '3 a b c' 0 # 2
check 'set -- a "b c"; echo $# ${xXx:-$*}' '2 a b c' 0 # 3
check 'set -- a "b c"; echo $# "${xXx:-$*}"' '2 a b c' 0 # 4
check 'set -- a b c; set -- ${xXx:-$*} ; echo $# $*' '3 a b c' 0 # 5
check 'set -- a b c; set -- "${xXx:-$*}" ; echo $# $*' '1 a b c' 0 # 6
check 'set -- a "b c"; set -- ${xXx:-$*} ; echo $# $*' '3 a b c' 0 # 7
check 'set -- a "b c"; set -- "${xXx:-$*}" ; echo $# $*' \
'1 a b c' 0 # 8
check 'IFS=". "; set -- a b c; echo $# ${xXx:-$*}' '3 a b c' 0 # 9
check 'IFS=". "; set -- a b c; echo $# "${xXx:-$*}"' '3 a.b.c' 0 #10
check 'IFS=". "; set -- a "b c"; echo $# ${xXx:-$*}' '2 a b c' 0 #11
check 'IFS=". "; set -- a "b c"; echo $# "${xXx:-$*}"' '2 a.b c' 0 #12
check 'IFS=". "; set -- a "b.c"; echo $# ${xXx:-$*}' '2 a b c' 0 #13
check 'IFS=". "; set -- a "b.c"; echo $# "${xXx:-$*}"' '2 a.b.c' 0 #14
check 'IFS=". ";set -- a b c;set -- ${xXx:-$*};echo $# ${xXx:-$*}' \
'3 a b c' 0 #15
check 'IFS=". ";set -- a b c;set -- "${xXx:-$*}";echo $# ${xXx:-$*}' \
'1 a b c' 0 #16
check 'IFS=". ";set -- a "b c";set -- ${xXx:-$*};echo $# ${xXx:-$*}' \
'3 a b c' 0 #17
check 'IFS=". ";set -- a "b c";set -- "${xXx:-$*}";echo $# ${xXx:-$*}' \
'1 a b c' 0 #18
check 'IFS=". ";set -- a b c;set -- ${xXx:-$*};echo $# "${xXx:-$*}"' \
'3 a.b.c' 0 #19
check 'IFS=". ";set -- a b c;set -- "$*";echo $# "$*"' \
'1 a.b.c' 0 #20
check 'IFS=". ";set -- a "b c";set -- $*;echo $# "$*"' \
'3 a.b.c' 0 #21
check 'IFS=". ";set -- a "b c";set -- "$*";echo $# "$*"' \
'1 a.b c' 0 #22
results
}
atf_test_case dollar_star_with_empty_ifs
dollar_star_with_empty_ifs_head() {
atf_set descr 'Test expansion of $* with IFS=""'
}
dollar_star_with_empty_ifs_body() {
reset dollar_star_with_empty_ifs
check 'IFS=""; set -- a b c; echo $# $*' '3 a b c' 0 # 1
check 'IFS=""; set -- a b c; echo $# "$*"' '3 abc' 0 # 2
check 'IFS=""; set -- a "b c"; echo $# $*' '2 a b c' 0 # 3
check 'IFS=""; set -- a "b c"; echo $# "$*"' '2 ab c' 0 # 4
check 'IFS=""; set -- a "b.c"; echo $# $*' '2 a b.c' 0 # 5
check 'IFS=""; set -- a "b.c"; echo $# "$*"' '2 ab.c' 0 # 6
check 'IFS=""; set -- a b c; set -- $* ; echo $# $*' \
'3 a b c' 0 # 7
check 'IFS=""; set -- a b c; set -- "$*" ; echo $# $*' \
'1 abc' 0 # 8
check 'IFS=""; set -- a "b c"; set -- $* ; echo $# $*' \
'2 a b c' 0 # 9
check 'IFS=""; set -- a "b c"; set -- "$*" ; echo $# $*' \
'1 ab c' 0 #10
check 'IFS=""; set -- a b c; set -- $* ; echo $# "$*"' \
'3 abc' 0 #11
check 'IFS=""; set -- a b c; set -- "$*" ; echo $# "$*"' \
'1 abc' 0 #12
check 'IFS=""; set -- a "b c"; set -- $* ; echo $# "$*"' \
'2 ab c' 0 #13
check 'IFS=""; set -- a "b c"; set -- "$*" ; echo $# "$*"' \
'1 ab c' 0 #14
results # FIXED: 'PR bin/52090 expect 7 of 14 subtests to fail'
}
atf_test_case dollar_star_in_word_empty_ifs
dollar_star_in_word_empty_ifs_head() {
atf_set descr 'Test expansion of ${unset:-$*} with IFS=""'
}
dollar_star_in_word_empty_ifs_body() {
reset dollar_star_in_word_empty_ifs
unset xXx ; # just in case
# Note that the expected results for these tests are identical
# to those from the dollar_star_with_empty_ifs test. It should
# never make a difference whether we expand $* or ${unset:-$*}
# (note expanding ${unset:-"$*"} is different, that is not tested here)
check 'IFS="";set -- a b c;echo $# ${xXx:-$*}' '3 a b c' 0 # 1
check 'IFS="";set -- a b c;echo $# "${xXx:-$*}"' '3 abc' 0 # 2
check 'IFS="";set -- a "b c";echo $# ${xXx:-$*}' '2 a b c' 0 # 3
check 'IFS="";set -- a "b c";echo $# "${xXx:-$*}"' '2 ab c' 0 # 4
check 'IFS="";set -- a "b.c";echo $# ${xXx:-$*}' '2 a b.c' 0 # 5
check 'IFS="";set -- a "b.c";echo $# "${xXx:-$*}"' '2 ab.c' 0 # 6
check 'IFS="";set -- a b c;set -- ${xXx:-$*};echo $# ${xXx:-$*}' \
'3 a b c' 0 # 7
check 'IFS="";set -- a b c;set -- "${xXx:-$*}";echo $# ${xXx:-$*}' \
'1 abc' 0 # 8
check 'IFS="";set -- a "b c";set -- ${xXx:-$*};echo $# ${xXx:-$*}' \
'2 a b c' 0 # 9
check 'IFS="";set -- a "b c";set -- "${xXx:-$*}";echo $# ${xXx:-$*}' \
'1 ab c' 0 #10
check 'IFS="";set -- a b c;set -- ${xXx:-$*};echo $# "${xXx:-$*}"' \
'3 abc' 0 #11
check 'IFS="";set -- a b c;set -- "${xXx:-$*}";echo $# "${xXx:-$*}"' \
'1 abc' 0 #12
check 'IFS="";set -- a "b c";set -- ${xXx:-$*};echo $# "${xXx:-$*}"' \
'2 ab c' 0 #13
check 'IFS="";set -- a "b c";set -- "${xXx:-$*}";echo $# "${xXx:-$*}"' \
'1 ab c' 0 #14
results # FIXED: 'PR bin/52090 expect 7 of 14 subtests to fail'
}
atf_test_case dollar_star_in_quoted_word
dollar_star_in_quoted_word_head() {
atf_set descr 'Test expansion $* occurring in word of ${var:-"word"}'
}
dollar_star_in_quoted_word_body() {
reset dollar_star_in_quoted_word
unset xXx ; # just in case!
check 'set -- a b c; echo $# ${xXx:-"$*"}' '3 a b c' 0 # 1
check 'set -- a "b c"; echo $# ${xXx:-"$*"}' '2 a b c' 0 # 2
check 'set -- a b c; set -- ${xXx:-"$*"} ; echo $# ${xXx-"$*"}' \
'1 a b c' 0 # 3
check 'set -- a "b c"; set -- ${xXx:-"$*"} ; echo $# ${xXx-"$*"}' \
'1 a b c' 0 # 4
check 'set -- a b c; set -- ${xXx:-"$*"} ; echo $# ${xXx-"$*"}' \
'1 a b c' 0 # 5
check 'set -- a "b c"; set -- ${xXx:-"$*"} ; echo $# ${xXx-$*}' \
'1 a b c' 0 # 6
check 'set -- a b c; set -- ${xXx:-$*} ; echo $# ${xXx-"$*"}' \
'3 a b c' 0 # 7
check 'set -- a "b c"; set -- ${xXx:-$*} ; echo $# ${xXx-"$*"}' \
'3 a b c' 0 # 8
check 'IFS=". "; set -- a b c; echo $# ${xXx:-"$*"}' '3 a.b.c' 0 # 9
check 'IFS=". "; set -- a "b c"; echo $# ${xXx:-"$*"}' '2 a.b c' 0 #10
check 'IFS=". "; set -- a "b.c"; echo $# ${xXx:-"$*"}' '2 a.b.c' 0 #11
check 'IFS=". ";set -- a b c;set -- ${xXx:-"$*"};echo $# ${xXx:-"$*"}' \
'1 a.b.c' 0 #12
check 'IFS=". ";set -- a "b c";set -- ${xXx:-"$*"};echo $# ${xXx:-"$*"}' \
'1 a.b c' 0 #13
check 'IFS=". ";set -- a b c;set -- ${xXx:-$*};echo $# ${xXx:-"$*"}' \
'3 a.b.c' 0 #14
check 'IFS=". ";set -- a "b c";set -- ${xXx:-$*};echo $# ${xXx:-"$*"}' \
'3 a.b.c' 0 #15
check 'IFS=". ";set -- a b c;set -- ${xXx:-"$*"};echo $# ${xXx:-$*}' \
'1 a b c' 0 #16
check 'IFS=". ";set -- a "b c";set -- ${xXx:-"$*"};echo $# ${xXx:-$*}' \
'1 a b c' 0 #17
check 'IFS="";set -- a b c;echo $# ${xXx:-"$*"}' '3 abc' 0 #18
check 'IFS="";set -- a "b c";echo $# ${xXx:-"$*"}' '2 ab c' 0 #19
check 'IFS="";set -- a "b.c";echo $# ${xXx:-"$*"}' '2 ab.c' 0 #20
check 'IFS="";set -- a b c;set -- ${xXx:-"$*"};echo $# ${xXx:-"$*"}' \
'1 abc' 0 #21
check 'IFS="";set -- a "b c";set -- ${xXx:-"$*"};echo $# ${xXx:-"$*"}' \
'1 ab c' 0 #22
check 'IFS="";set -- a b c;set -- ${xXx:-$*};echo $# ${xXx:-"$*"}' \
'3 abc' 0 #23
check 'IFS="";set -- a "b c";set -- ${xXx:-$*};echo $# ${xXx:-"$*"}' \
'2 ab c' 0 #24
check 'IFS="";set -- a b c;set -- ${xXx:-"$*"};echo $# ${xXx:-$*}' \
'1 abc' 0 #25
check 'IFS="";set -- a "b c";set -- ${xXx:-"$*"};echo $# ${xXx:-$*}' \
'1 ab c' 0 #26
results # FIXED: 'PR bin/52090 - 2 of 26 subtests expected to fail'
}
atf_test_case dollar_at_in_field_split_context
dollar_at_in_field_split_context_head() {
atf_set descr 'Test "$@" wth field splitting -- PR bin/54112'
}
dollar_at_in_field_split_context_body() {
reset dollar_at_in_field_split_context
# the simple case (no field split) which always worked
check 'set -- ""; set -- ${0+"$@"}; echo $#' 1 0 #1
# The original failure case from the bash-bug list
check 'set -- ""; set -- ${0+"$@" "$@"}; echo $#' 2 0 #2
# slightly simpler cases that triggered the same issue
check 'set -- ""; set -- ${0+"$@" }; echo $#' 1 0 #3
check 'set -- ""; set -- ${0+ "$@"}; echo $#' 1 0 #4
check 'set -- ""; set -- ${0+ "$@" }; echo $#' 1 0 #5
# and the bizarre
check 'set -- ""; set -- ${0+"$@" "$@" "$@"}; echo $#' 3 0 #6
# repeat tests when there is more than one set empty numeric param
check 'set -- "" ""; set -- ${0+"$@"}; echo $#' 2 0 #7
check 'set -- "" ""; set -- ${0+"$@" "$@"}; echo $#' 4 0 #8
check 'set -- "" ""; set -- ${0+"$@" }; echo $#' 2 0 #9
check 'set -- "" ""; set -- ${0+ "$@"}; echo $#' 2 0 #10
check 'set -- "" ""; set -- ${0+ "$@" }; echo $#' 2 0 #11
check 'set -- "" ""; set -- ${0+"$@" "$@" "$@"}; echo $#' \
6 0 #12
# Next some checks of the way the NetBSD shell
# interprets some expressions that are POSIX unspecified.
# Other shells might fail these tests, without that
# being a problem. We retain these tests so accidental
# changes in our behaviour can be detected.
check 'set --; X=; set -- "$X$@"; echo $#' 0 0 #13
check 'set --; X=; set -- "$@$X"; echo $#' 0 0 #14
check 'set --; X=; set -- "$X$@$X"; echo $#' 0 0 #15
check 'set --; X=; set -- "$@$@"; echo $#' 0 0 #16
check 'set -- ""; X=; set -- "$X$@"; echo $#' 1 0 #17
check 'set -- ""; X=; set -- "$@$X"; echo $#' 1 0 #19
check 'set -- ""; X=; set -- "$X$@$X"; echo $#' 1 0 #19
check 'set -- ""; X=; set -- "$@$@"; echo $#' 1 0 #20
check 'set -- "" ""; X=; set -- "$X$@"; echo $#' 2 0 #21
check 'set -- "" ""; X=; set -- "$@$X"; echo $#' 2 0 #22
check 'set -- "" ""; X=; set -- "$X$@$X"; echo $#' 2 0 #23
# Yes, this next one really is (and should be) 3...
check 'set -- "" ""; X=; set -- "$@$@"; echo $#' 3 0 #24
results
}
atf_test_case embedded_nl
embedded_nl_head() {
atf_set descr 'Test literal \n in xxx string in ${var-xxx}'
}
embedded_nl_body() {
atf_check -s exit:0 -o inline:'a\nb\n' -e empty ${TEST_SH} <<- 'EOF'
unset V
X="${V-a
b}"
printf '%s\n' "${X}"
EOF
atf_check -s exit:0 -o inline:'a\nb\n' -e empty ${TEST_SH} <<- 'EOF'
unset V
X=${V-"a
b"}
printf '%s\n' "${X}"
EOF
# This should not generate a syntax error, see PR bin/53201
atf_check -s exit:0 -o inline:'abc\n' -e empty ${TEST_SH} <<- 'EOF'
V=abc
X=${V-a
b}
printf '%s\n' "${X}"
EOF
# Nor should any of these...
atf_check -s exit:0 -o inline:'a\nb\n' -e empty ${TEST_SH} <<- 'EOF'
unset V
X=${V-a
b}
printf '%s\n' "${X}"
EOF
atf_check -s exit:0 -o inline:'a\nb\n' -e empty ${TEST_SH} <<- 'EOF'
unset V
X=${V:=a
b}
printf '%s\n' "${X}"
EOF
atf_check -s exit:0 -o inline:'xa\nby\na\nb\n' -e empty \
${TEST_SH} <<- 'EOF'
unset V
X=x${V:=a
b}y
printf '%s\n' "${X}" "${V}"
EOF
}
check3()
{
check "X=foo; ${1}" "$2" 0
check "X=; ${1}" "$3" 0
check "unset X; ${1}" "$4" 0
}
atf_test_case alternative
alternative_head() {
atf_set descr 'Test various possibilities for ${var+xxx}'
}
alternative_body() {
reset alternative
# just to verify (validate) that the test method works as expected
# (this is currently the very first test performed in this test set)
check 'printf %s a b' ab 0 # 1
check3 'set -- ${X+bar}; echo "$#:$1"' 1:bar 1:bar 0: # 4
check3 'set -- ${X+}; echo "$#:$1"' 0: 0: 0: # 7
check3 'set -- ${X+""}; echo "$#:$1"' 1: 1: 0: # 10
check3 'set -- "${X+}"; echo "$#:$1"' 1: 1: 1: # 13
check3 'set -- "${X+bar}"; echo "$#:$1"' 1:bar 1:bar 1: # 16
check3 'set -- ${X+a b c}; echo "$#:$1"' 3:a 3:a 0: # 19
check3 'set -- ${X+"a b c"}; echo "$#:$1"' '1:a b c' '1:a b c' 0:
check3 'set -- "${X+a b c}"; echo "$#:$1"' '1:a b c' '1:a b c' 1:
check3 'set -- ${X+a b\ c}; echo "$#:$1"' 2:a 2:a 0: # 28
check3 'set -- ${X+"a b" c}; echo "$#:$1"' '2:a b' '2:a b' 0:
check3 'printf %s "" ${X+}' '' '' '' # 34
check3 'printf %s ""${X+bar}' bar bar '' # 37
check3 'Y=bar; printf %s ${X+x}${Y+y}' xy xy y # 40
check3 'Y=bar; printf %s ""${X+${Y+z}}' z z '' # 43
check3 'Y=; printf %s ""${X+${Y+z}}' z z '' # 46
check3 'unset Y; printf %s ""${X+${Y+z}}' '' '' '' # 49
check3 'Y=1; printf %s a ${X+"${Y+z}"}' az az a # 52
check3 'printf %s ${X+}x}' x} x} x} # 55
check3 'printf %s ${X+}}' } } } # 58
check3 'printf %s "" ${X+"}"x}' }x }x '' # 61
check3 'printf %s "" ${X+\}x}' }x }x '' # 64
check3 'printf %s "${X+\}x}"' }x }x '' # 67
check3 'printf %s "${X+\}}"' } } '' # 70
check3 'set -- ${X:+bar}; echo "$#:$1"' 1:bar 0: 0: # 73
check3 'set -- ${X:+}; echo "$#:$1"' 0: 0: 0: # 76
check3 'set -- ${X:+""}; echo "$#:$1"' 1: 0: 0: # 79
check3 'set -- "${X:+}"; echo "$#:$1"' 1: 1: 1: # 80
check3 'set -- "${X:+bar}"; echo "$#:$1"' 1:bar 1: 1: # 83
check3 'set -- ${X:+a b c}; echo "$#:$1"' 3:a 0: 0: # 86
check3 'set -- ${X:+"a b c"}; echo "$#:$1"' '1:a b c' 0: 0: # 89
check3 'set -- "${X:+a b c}"; echo "$#:$1"' '1:a b c' 1: 1: # 92
check3 'set -- ${X:+a b\ c}; echo "$#:$1"' 2:a 0: 0: # 95
check3 'set -- ${X:+"a b" c}; echo "$#:$1"' '2:a b' 0: 0: # 98
check3 'printf %s "" ${X:+}' '' '' '' #101
check3 'printf %s ""${X:+bar}' bar '' '' #104
check3 'Y=bar; printf %s ${X:+x}${Y:+y}' xy y y #107
check3 'Y=bar; printf %s ""${X:+${Y:+z}}' z '' '' #110
check3 'Y=; printf %s ""${X:+${Y+z}}' z '' '' #113
check3 'Y=; printf %s ""${X:+${Y:+z}}' '' '' '' #116
check3 'unset Y; printf %s ""${X:+${Y:+z}}' '' '' '' #119
check3 'Y=1; printf %s a ${X:+"${Y:+z}"}' az a a #122
check3 'printf %s ${X:+}x}' x} x} x} #125
check3 'printf %s ${X:+}}' } } } #128
check3 'printf %s "" ${X:+"}"x}' }x '' '' #131
check3 'printf %s "" ${X:+\}x}' }x '' '' #134
check3 'printf %s "${X:+\}x}"' }x '' '' #137
check3 'printf %s "${X:+\}}"' } '' '' #140
results
}
atf_test_case default
default_head() {
atf_set descr 'Test various possibilities for ${var-xxx}'
}
default_body() {
reset default
check3 'set -- ${X-bar}; echo "$#:$1"' 1:foo 0: 1:bar # 3
check3 'set -- ${X-}; echo "$#:$1"' 1:foo 0: 0: # 6
check3 'set -- ${X-""}; echo "$#:$1"' 1:foo 0: 1: # 9
check3 'set -- "${X-}"; echo "$#:$1"' 1:foo 1: 1: # 12
check3 'set -- "${X-bar}"; echo "$#:$1"' 1:foo 1: 1:bar # 15
check3 'set -- ${X-a b c}; echo "$#:$1"' 1:foo 0: 3:a # 18
check3 'set -- ${X-"a b c"}; echo "$#:$1"' 1:foo 0: '1:a b c' #21
check3 'set -- "${X-a b c}"; echo "$#:$1"' 1:foo 1: '1:a b c' #24
check3 'set -- ${X-a b\ c}; echo "$#:$1"' 1:foo 0: 2:a # 27
check3 'set -- ${X-"a b" c}; echo "$#:$1"' 1:foo 0: '2:a b' #30
check3 'printf %s "" ${X-}' foo '' '' # 33
check3 'printf %s ""${X-bar}' foo '' bar # 36
check3 'Y=bar; printf %s ${X-x}${Y-y}' foobar bar xbar # 39
check3 'Y=bar; printf %s ""${X-${Y-z}}' foo '' bar # 42
check3 'Y=; printf %s ""${X-${Y-z}}' foo '' '' # 45
check3 'unset Y; printf %s ""${X-${Y-z}}' foo '' z # 48
check3 'Y=1; printf %s a ${X-"${Y-z}"}' afoo a a1 # 51
check3 'printf %s ${X-}x}' foox} x} x} # 54
check3 'printf %s ${X-}}' foo} } } # 57
check3 'printf %s ${X-{}}' foo} } {} # 60
check3 'printf %s "" ${X-"}"x}' foo '' }x # 63
check3 'printf %s "" ${X-\}x}' foo '' }x # 66
check3 'printf %s "${X-\}x}"' foo '' }x # 69
check3 'printf %s "${X-\}}"' foo '' } # 72
check3 'set -- ${X:-bar}; echo "$#:$1"' 1:foo 1:bar 1:bar #75
check3 'set -- ${X:-}; echo "$#:$1"' 1:foo 0: 0: # 78
check3 'set -- ${X:-""}; echo "$#:$1"' 1:foo 1: 1: # 81
check3 'set -- "${X:-}"; echo "$#:$1"' 1:foo 1: 1: # 84
check3 'set -- "${X:-bar}"; echo "$#:$1"' 1:foo 1:bar 1:bar #87
check3 'set -- ${X:-a b c}; echo "$#:$1"' 1:foo 3:a 3:a # 90
check3 'set -- ${X:-"a b c"}; echo "$#:$1"' 1:foo '1:a b c' '1:a b c'
check3 'set -- "${X:-a b c}"; echo "$#:$1"' 1:foo '1:a b c' '1:a b c'
check3 'set -- ${X:-a b\ c}; echo "$#:$1"' 1:foo 2:a 2:a # 99
check3 'set -- ${X:-"a b" c}; echo "$#:$1"' 1:foo '2:a b' '2:a b'
check3 'printf %s "" ${X:-}' foo '' '' #105
check3 'printf %s ""${X:-bar}' foo bar bar #108
check3 'Y=bar; printf %s ${X:-x}${Y:-y}' foobar xbar xbar #111
check3 'Y=bar; printf %s ""${X:-${Y:-z}}' foo bar bar #114
check3 'Y=; printf %s ""${X:-${Y-z}}' foo '' '' #117
check3 'Y=; printf %s ""${X:-${Y:-z}}' foo z z #120
check3 'unset Y; printf %s ""${X:-${Y:-z}}' foo z z #123
check3 'Y=1; printf %s a ${X:-"${Y:-z}"}' afoo a1 a1 #126
check3 'printf %s ${X:-}x}' foox} x} x} #129
check3 'printf %s ${X:-}}' foo} } } #132
check3 'printf %s ${X:-{}}' foo} {} {} #135
check3 'printf %s "" ${X:-"}"x}' foo }x }x #138
check3 'printf %s "" ${X:-\}x}' foo }x }x #141
check3 'printf %s "${X:-\}x}"' foo }x }x #144
check3 'printf %s "${X:-\}}"' foo } } #147
results
}
atf_test_case assign
assign_head() {
atf_set descr 'Test various possibilities for ${var=xxx}'
}
assign_body() {
reset assign
check3 'set -- ${X=bar}; echo "$#:$1"' 1:foo 0: 1:bar # 3
check3 'set -- ${X=}; echo "$#:$1"' 1:foo 0: 0: # 6
check3 'set -- ${X=""}; echo "$#:$1"' 1:foo 0: 0: # 9
check3 'set -- "${X=}"; echo "$#:$1"' 1:foo 1: 1: # 12
check3 'set -- "${X=bar}"; echo "$#:$1"' 1:foo 1: 1:bar # 15
check3 'set -- ${X=a b c}; echo "$#:$1"' 1:foo 0: 3:a # 18
check3 'set -- ${X="a b c"}; echo "$#:$1"' 1:foo 0: 3:a # 21
check3 'set -- "${X=a b c}"; echo "$#:$1"' 1:foo 1: '1:a b c' #24
check3 'set -- ${X=a b\ c}; echo "$#:$1"' 1:foo 0: 3:a # 27
check3 'set -- ${X="a b" c}; echo "$#:$1"' 1:foo 0: 3:a # 30
check3 'printf %s "" ${X=}' foo '' '' # 33
check3 'printf %s ""${X=bar}' foo '' bar # 36
check3 'Y=bar; printf %s ${X=x}${Y=y}' foobar bar xbar # 39
check3 'Y=bar; printf %s ""${X=${Y=z}}' foo '' bar # 42
check3 'Y=; printf %s ""${X=${Y=z}}' foo '' '' # 45
check3 'unset Y; printf %s ""${X=${Y=z}}' foo '' z # 48
check3 'Y=1; printf %s a ${X="${Y=z}"}' afoo a a1 # 51
check3 'printf %s ${X=}x}' foox} x} x} # 54
check3 'printf %s ${X=}}' foo} } } # 57
check3 'printf %s ${X={}}' foo} } {} # 60
check3 'printf %s "" ${X="}"x}' foo '' }x # 63
check3 'printf %s "" ${X=\}x}' foo '' }x # 66
check3 'printf %s "${X=\}x}"' foo '' }x # 69
check3 'printf %s "${X=\}}"' foo '' } # 72
check3 'set -- ${X=a b c}; echo "$#:$1:$X"' 1:foo:foo 0:: '3:a:a b c'
check3 'set -- ${X="a b c"}; echo "$#:$1:$X"' 1:foo:foo 0:: '3:a:a b c'
check3 'set -- "${X=a b c}"; echo "$#:$1:$X"' \
1:foo:foo 1:: '1:a b c:a b c'
check3 'set -- ${X=a b\ c}; echo "$#:$1:$X"' 1:foo:foo 0:: '3:a:a b c'
check3 'set -- ${X="a b" c}; echo "$#:$1:$X"' 1:foo:foo 0:: '3:a:a b c'
check3 'printf %s ${X=}x}; printf :%s "${X-U}"' foox}:foo x}: x}: #90
check3 'printf %s ${X=}}; printf :%s "${X-U}"' foo}:foo }: }: #93
check3 'printf %s ${X={}}; printf :%s "${X-U}"' foo}:foo }: {}:{ #96
check3 'set -- ${X:=bar}; echo "$#:$1"' 1:foo 1:bar 1:bar # 99
check3 'set -- ${X:=}; echo "$#:$1"' 1:foo 0: 0: #102
check3 'set -- ${X:=""}; echo "$#:$1"' 1:foo 0: 0: #105
check3 'set -- "${X:=}"; echo "$#:$1"' 1:foo 1: 1: #108
check3 'set -- "${X:=bar}"; echo "$#:$1"' 1:foo 1:bar 1:bar #111
check3 'set -- ${X:=a b c}; echo "$#:$1"' 1:foo 3:a 3:a #114
check3 'set -- ${X:="a b c"}; echo "$#:$1"' 1:foo 3:a 3:a #117
check3 'set -- "${X:=a b c}"; echo "$#:$1"' 1:foo '1:a b c' '1:a b c'
check3 'set -- ${X:=a b\ c}; echo "$#:$1"' 1:foo 3:a 3:a #123
check3 'set -- ${X:="a b" c}; echo "$#:$1"' 1:foo 3:a 3:a #126
check3 'printf %s "" ${X:=}' foo '' '' #129
check3 'printf %s ""${X:=bar}' foo bar bar #132
check3 'Y=bar; printf %s ${X:=x}${Y:=y}' foobar xbar xbar #135
check3 'Y=bar; printf %s ""${X:=${Y:=z}}' foo bar bar #138
check3 'Y=; printf %s ""${X:=${Y=z}}' foo '' '' #141
check3 'Y=; printf %s ""${X:=${Y:=z}}' foo z z #144
check3 'unset Y; printf %s ""${X:=${Y:=z}}' foo z z #147
check3 'Y=1; printf %s a ${X:="${Y:=z}"}' afoo a1 a1 #150
check3 'printf %s ${X:=}x}' foox} x} x} #153
check3 'printf %s ${X:=}}' foo} } } #156
check3 'printf %s ${X:={}}' foo} {} {} #159
check3 'printf %s "" ${X:="}"x}' foo }x }x #162
check3 'printf %s "" ${X:=\}x}' foo }x }x #165
check3 'printf %s "${X:=\}x}"' foo }x }x #168
check3 'printf %s "${X:=\}}"' foo } } #171
check3 'set -- ${X:=a b c}; echo "$#:$1:$X"' \
1:foo:foo '3:a:a b c' '3:a:a b c' #174
check3 'set -- ${X:="a b c"}; echo "$#:$1:$X"' \
1:foo:foo '3:a:a b c' '3:a:a b c' #177
check3 'set -- "${X:=a b c}"; echo "$#:$1:$X"' \
1:foo:foo '1:a b c:a b c' '1:a b c:a b c' #180
check3 'set -- ${X:=a b\ c}; echo "$#:$1:$X"' \
1:foo:foo '3:a:a b c' '3:a:a b c' #183
check3 'set -- ${X:="a b" c}; echo "$#:$1:$X"' \
1:foo:foo '3:a:a b c' '3:a:a b c' #186
check3 'printf %s ${X:=}x}; printf :%s "${X-U}"' foox}:foo x}: x}:
check3 'printf %s ${X:=}}; printf :%s "${X-U}"' foo}:foo }: }:
check3 'printf %s ${X:=\}}; printf :%s "${X-U}"' foo:foo }:} }:}
check3 'printf %s ${X:={}}; printf :%s "${X-U}"' foo}:foo {}:{ {}:{
#198
results
}
atf_test_case error
error_head() {
atf_set descr 'Test various possibilities for ${var?xxx}'
}
error_body() {
reset error
check 'X=foo; printf %s ${X?X is not set}' foo 0 #1
check 'X=; printf %s ${X?X is not set}' '' 0 #2
check 'unset X; printf %s ${X?X is not set}' '' 2 #3
check 'X=foo; printf %s ${X?}' foo 0 #4
check 'X=; printf %s ${X?}' '' 0 #5
check 'unset X; printf %s ${X?}' '' 2 #6
check 'X=foo; printf %s ${X:?X is not set}' foo 0 #7
check 'X=; printf %s ${X:?X is not set}' '' 2 #8
check 'unset X; printf %s ${X:?X is not set}' '' 2 #9
check 'X=foo; printf %s ${X:?}' foo 0 #10
check 'X=; printf %s ${X:?}' '' 2 #11
check 'unset X; printf %s ${X:?}' '' 2 #12
results
}
atf_init_test_cases() {
# Listed here in the order ATF runs them, not the order from above
atf_add_test_case alternative
atf_add_test_case arithmetic
atf_add_test_case assign
atf_add_test_case default
atf_add_test_case dollar_at
atf_add_test_case dollar_at_empty_and_conditional
atf_add_test_case dollar_at_in_field_split_context
atf_add_test_case dollar_at_unquoted_or_conditional
atf_add_test_case dollar_at_with_text
atf_add_test_case dollar_hash
atf_add_test_case dollar_star
atf_add_test_case dollar_star_in_quoted_word
atf_add_test_case dollar_star_in_word
atf_add_test_case dollar_star_in_word_empty_ifs
atf_add_test_case dollar_star_with_empty_ifs
atf_add_test_case embedded_nl
atf_add_test_case error
atf_add_test_case iteration_on_null_parameter
atf_add_test_case iteration_on_quoted_null_parameter
atf_add_test_case iteration_on_null_or_null_parameter
atf_add_test_case iteration_on_null_or_missing_parameter
atf_add_test_case shell_params
atf_add_test_case strip
atf_add_test_case tilde
atf_add_test_case wrap_strip
atf_add_test_case var_with_embedded_cmdsub
atf_add_test_case varpattern_backslashes
}