# $NetBSD: t_expand.sh,v 1.31 2026/03/27 19:02:46 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 /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

	# Verify that when HOME is "" expanding a bare ~
	# makes an empty word, not nothing (or anything else)
	HOME=""
	export HOME
	atf_check -s exit:0 -e empty -o inline:'1:<>\n' ${TEST_SH} -c \
		'set -- ~ ; IFS=, ; printf '"'%d:<%s>\\n'"' "$#" "$*"'
	atf_check -s exit:0 -e empty -o inline:'4:<,X,,/>\n' ${TEST_SH} -c \
		'set -- ~ X ~ ~/ ; IFS=, ; printf '"'%d:<%s>\\n'"' "$#" "$*"'

	# 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))'

	# The following used to use $(( (1 << 63) - 1 ))
	# but 1 << 63 in a 64 bit int overflows into the sign bit
	# which some shells treat as as error.   So use the following
	# less obvious formula instead:
	atf_check -o inline:'9223372036854775807' -e empty ${TEST_SH} -c \
		'printf %s $(( (( 1 << 62 ) - 1) * 2 + 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 dollar_star_unquoted
dollar_star_unquoted_head() {
	atf_set descr 'Test unquoted $* in various contexts'
}
dollar_star_unquoted_body() {
	reset dollar_star_unquoted

	check 'set -- ; set -- $* ; printf %d "$#"'		0	0   # 1
	check 'set -- a ; set -- $* ; printf %d "$#"'		1	0   # 2
	check 'set -- a b ; set -- $* ; printf %d "$#"'		2	0   # 3
	check 'set -- "" ; printf %d+ "$#"; set -- x$* ; printf %d "$#"' \
								1+1	0   # 4
	check 'set -- "" "" ; printf %d+ "$#"; set -- x$*y ; printf %d "$#"' \
								2+2	0   # 5

	# expect the following sub-test (+more) to fail currently, PR bin/60099
	check 'set -- a b+ c +d e; IFS=+; set -- $* ; printf %d "$#"' \
								6	0   # 6

	check 'set -- ; set -- x$*y; printf "%s," "$@"'		xy,	0   # 7
	check 'IFS=+ ; set -- ; set -- x$*y; printf "%s," "$@"' xy,	0   # 8
	check 'set -- ""; set -- x$*y; printf "%s," "$@"'	xy,	0   # 9
	check 'IFS=+ ; set -- ""; set -- x$*y; printf "%s," "$@"' \
								xy,	0   #10
	check 'set -- "" ""; set -- x$*y; printf "%s," "$@"'	x,y,	0   #11
	check 'IFS=+ ; set -- "" ""; set -- x$*y; printf "%s," "$@"' \
								x,y,	0   #12

		# The following tests test unspecified POSIX behaviour
		# (empty fields MAY be omitted from $* unquoted in this context)
		# They are included to detect unexpected changes in how
		# the NetBSD shell works, failures using other shells
		# should be investigated, but are not necessarily wrong.
	check 'set -- a "" b ; set -- $* ; printf %d "$#"'	2	0   #13
	check 'set -- a b "" ; set -- $* ; printf %d "$#"'	2	0   #14
	check 'set -- "" a b ; set -- $* ; printf %d "$#"'	2	0   #15
	check 'set -- "" a "" b "" ; set -- $* ; printf %d "$#"' 2	0   #16
	check 'set -- "" "" a b ; set -- $* ; printf %d "$#"'	2	0   #17
	check 'set -- a b "" "" ; set -- $* ; printf %d "$#"'	2	0   #18

	check 'set -- "" ; printf %d+ "$#"; set -- $* ; printf %d "$#"' \
								1+0	0   #19
	check 'set -- "" "" ; printf %d+ "$#"; set -- $* ; printf %d "$#"' \
								2+0	0   #20
	check 'set -- "" "" ; printf %d+ "$#"; set -- x$* ; printf %d "$#"' \
								2+1	0   #21
	check  \
	   'set -- "" "" "" ; printf %d+ "$#"; set -- x$*y ; printf %d "$#"' \
								3+2	0   #22
	check  \
	   'set -- "" "" "" "";printf %d+ "$#";set -- x$*y ;printf %d "$#"' \
								4+2	0   #23
	check 'set "" "";  for i in $* ; do printf %s\\n "z${i}z"; done' \
								''	0   #24

	# The following check that using a non-whitespace IFS[0] alters nothing.

	# While in the following, the actual answers might not be specified
	# by POSIX, that the same answer is generated in each of the tests
	# in each pair below is.

	# That is, empty fields are deleted or not, before field splitting
	# happens (according to the standard) so the value of IFS cannot be
	# relevant to whether that happens or not.

	check 'set -- "" "" ""; set -- x$*y; printf "%s," "$@"'	x,y,	0   #25
	check 'IFS=+ ; set -- "" "" ""; set -- x$*y; printf "%s," "$@"' \
								x,y,	0   #26

	check 'set -- a "" b ; set -- $* $* ; printf %d "$#"'	4	0   #27
	check 'IFS=+ ; set -- a "" b ; set -- $* $* ; printf %d "$#"' \
								4	0   #28

	check 'set -- "" a "" b "" ; set -- $* $* ; printf %d "$#"' 4	0   #29
	check 'IFS=+ ; set -- "" a "" b "" ; set -- $* $* ; printf %d "$#"' \
								4	0   #30

	check 'set -- a "" b ; set -- $*$* ; printf %d "$#"'	3	0   #31
	check 'IFS=+ ; set -- a "" b ; set -- $*$* ; printf %d "$#"' \
								3	0   #32

	check 'set -- "" a "" b "" ; set -- $*$* ; printf %d "$#"' 4	0   #33
	check 'IFS=+ ; set -- "" a "" b "" ; set -- $*$* ; printf %d "$#"' \
								4	0   #34

	check 'set -- "" a "" b "" ; set -- $*x$* ; printf %d "$#"' 5	0   #35
	check 'IFS=+ ; set -- "" a "" b "" ; set -- $*x$* ; printf %d "$#"' \
								5	0   #36

	check 'set -- "" a "" b "" ; set -- $*+$* ; printf %d "$#"' 5	0   #35
	check 'IFS=+ ; set -- "" a "" b "" ; set -- $*+$* ; printf %d "$#"' \
								5	0   #36

	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:	# 82
	check3	'set -- "${X:+bar}"; echo "$#:$1"'	1:bar 1: 1:	# 85

	check3	'set -- ${X:+a b c}; echo "$#:$1"'	3:a 0: 0:	# 88
	check3	'set -- ${X:+"a b c"}; echo "$#:$1"'	'1:a b c' 0: 0:	# 91
	check3	'set -- "${X:+a b c}"; echo "$#:$1"'	'1:a b c' 1: 1:	# 94
	check3	'set -- ${X:+a b\ c}; echo "$#:$1"'	2:a 0: 0:	# 97
	check3	'set -- ${X:+"a b" c}; echo "$#:$1"'	'2:a b' 0: 0:	#100

	check3	'printf %s "" ${X:+}'			''  ''  ''	#103
	check3	'printf %s ""${X:+bar}'			bar ''  ''	#106

	check3	'Y=bar; printf %s ${X:+x}${Y:+y}'	xy  y   y	#109
	check3	'Y=bar; printf %s ""${X:+${Y:+z}}'	z   ''  ''	#112
	check3	'Y=; printf %s ""${X:+${Y+z}}'		z   ''  ''	#115
	check3	'Y=; printf %s ""${X:+${Y:+z}}'		''  ''  ''	#118
	check3	'unset Y; printf %s ""${X:+${Y:+z}}'	''  ''  ''	#121
	check3	'Y=1; printf %s a ${X:+"${Y:+z}"}'	az  a	a	#124

	check3	'printf %s ${X:+}x}'			x}  x}  x}	#127
	check3	'printf %s ${X:+}}'			 }   }   }	#130
	check3	'printf %s "" ${X:+"}"x}'		}x  ''  ''	#133
	check3	'printf %s "" ${X:+\}x}'		}x  ''  ''	#136
	check3	'printf %s "${X:+\}x}"'			}x  ''  ''	#139
	check3	'printf %s "${X:+\}}"'			 }  ''  ''	#142

	# Tests for odd cases of field splitting (a long standing NetBSD sh bug)
	# Nb: fixed (a day) before these tests were added, no PR ever generated

	# The A B... just guarantee an arg for printf (and make test id easier)

	check3	'IFS=:; printf %s, A ${X:-a:b}'	   A,foo, A,a,b, A,a,b, #145
	check3	'IFS=:; printf %s, B "${X:-a:b}"'  B,foo, B,a:b, B,a:b, #148
	check3	'IFS=:; printf %s, C ${X:-"a:b"}'  C,foo, C,a:b, C,a:b, #151

	check3	'IFS=:; printf %s, D ${X:+a:b}'	   D,a,b, D,     D,     #154
	check3	'IFS=:; printf %s, E "${X:+a:b}"'  E,a:b, E,,    E,,    #157
	check3	'IFS=:; printf %s, F ${X:+"a:b"}'  F,a:b, F,     F,     #160

	check3	'IFS=:; printf %s, G ${X:=a:b}'	   G,foo, G,a,b, G,a,b, #163
	check3	'IFS=:; printf %s, H "${X:=a:b}"'  H,foo, H,a:b, H,a:b, #166
	check3	'IFS=:; printf %s, I ${X:="a:b"}'  I,foo, I,a,b, I,a,b, #169

	check3	'IFS=:; printf %s, J ${X-a:b}'     J,foo, J,     J,a,b, #172
	check3	'IFS=:; printf %s, K "${X-a:b}"'   K,foo, K,,    K,a:b, #175
	check3	'IFS=:; printf %s, L ${X-"a:b"}'   L,foo, L,     L,a:b, #178

	check3	'IFS=:; printf %s, M ${X+a:b}'     M,a,b, M,a,b, M,     #181
	check3	'IFS=:; printf %s, N "${X+a:b}"'   N,a:b, N,a:b, N,,    #184
	check3	'IFS=:; printf %s, O ${X+"a:b"}'   O,a:b, O,a:b, O,     #187

	check3	'IFS=:; printf %s, P ${X=a:b}'     P,foo, P,     P,a,b, #190
	check3	'IFS=:; printf %s, Q "${X=a:b}"'   Q,foo, Q,,    Q,a:b, #193
	check3	'IFS=:; printf %s, R ${X="a:b"}'   R,foo, R,     R,a,b, #196

	# It should make no difference what the IFS char is (but these passed).
	# (These are copies of the old NetBSD sh failing sub-tests from above)
	# The 6 tests that failed above are numbers 144 145 152 172 179 180

	# 144 & 145 are here as 198&199, 152=200, 172=205, 179=206, 180=207
	check3	'IFS=+; printf %s, S ${X:-a+b}'	   S,foo, S,a,b, S,a,b, #199
	check3	'IFS=+; printf %s, T ${X:+a+b}'	   T,a,b, T,     T,     #202
	check3	'IFS=+; printf %s, U ${X-a+b}'     U,foo, U,     U,a,b, #205
	check3	'IFS=+; printf %s, V ${X+a+b}'     V,a,b, V,a,b, V,     #208

	# But it did, ':' and '=' were treated differently than all others

	# These are more repeats of the failing tests from above, and add
	# 6 more failures (in old NetBSD shells) (the same failures as above)

	# 144 & 145 are here as 210&211, 152=212, 172=217, 179=218, 180=219
	check3	'IFS==; printf %s, W ${X:-a=b}'	   W,foo, W,a,b, W,a,b, #211
	check3	'IFS==; printf %s, X ${X:+a=b}'	   X,a,b, X,     X,     #214
	check3	'IFS==; printf %s, Y ${X-a=b}'     Y,foo, Y,     Y,a,b, #217
	check3	'IFS==; printf %s, Z ${X+a=b}'     Z,a,b, Z,a,b, Z,     #220

	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_test_case land_mine
land_mine_head() {
	atf_set descr 'Attempt to test for land mines left by expansions'
}
land_mine_body() {
	reset land_mine

	# Land mines (in this sense) are bugs left in the shell state
	# after an expansion, which very often are benign, and unnoticed
	# by the vast majority of ordinary code, but in odd cases can
	# cause weird failures.   Generally this happens when the word
	# containing the expansion is very long (after the expansion)

	# So this test case borrows a random sampling of other tests, adds
	# a whole bunch of text after the expansion in question, then
	# validates that the expansion happened exactly as it should.

	# A few of these were not all that randomly selected!

	# First, we need a long string to use.  We will use it both
	# expanded before the test (by ATF_SH), and expanded during
	# the test (by TEST_SH).

	# In what follows, use ${L} when ATF_SH is to expand L, and
	# just $L when TEST_SH is intended to expand it (except if the
	# braces are essential, naturally).  Just for clarity.

	L=AAAAAAAA			# ${#L} == 8
	L=${L}${L}${L}${L}		# ${#L} == 32
	L=${L}${L}${L}${L}		# ${#L} == 128
	L=${L}${L}${L}${L}		# ${#L} == 512
	L=${L}${L}			# ${#L} == 1024
	B=' '				# to insert a splitting place

	test ${#L} -eq 1024 || atf_skip "ATF_SH cannot make long strings"

	check	'set -- XX;
		 set -- word$@'"${L}"'; printf %d, "${#1}"'       1030,   0 # 1
	check "L='${L}'; "'set -- XX;
		 set -- word$@$L;       printf %d, "${#1}"'	  1030,   0 # 2
	check "L='${L}'; "'set -- XX;
		 set -- word$@"$L";     printf %d, "${#1}"'	  1030,   0 # 3
	check "L='${L}' B='${B}'; "'set -- XX;
		 set -- word$@$L$B$L;   printf %d, "$#" "${#1}" "${#2}"'    \
							   2,1030,1024,   0 # 4
	check "L='${L}' B='${B}'; "'set -- XX;
		 set -- word$@"$L"$B"$L"; printf %d, "$#" "${#1}" "${#2}"'  \
							   2,1030,1024,   0 # 5
	check "L='${L}' B='${B}'; "'set -- XX;
		 set -- word$@"$L$B$L"; printf %d, "$#" "${#1}" "${#2}"'    \
							       1,2055,0,  0 # 6


	check	'X=set; set --;
		 set -- "${X+$@}"'"${L}"'; printf %d, "${#1}"'    1024,   0 # 7
	check "L='${L}'; "'X=set; set --;
		 set -- "${X+$@}"$L;       printf %d, "${#1}"'    1024,   0 # 8
	check "L='${L}'; "'X=set; set --;
		 set -- "${X+$@}""$L";     printf %d, "${#1}"'    1024,   0 # 9
	check "L='${L}' B='${B}'; "'X=set; set --;
		 set -- "${X+$@}"$L$B$L;   printf %d, "$#" "${#1}" "${#2}"' \
							   2,1024,1024,   0 #10
	check "L='${L}' B='${B}'; "'X=set; set --;
		 set -- "${X+$@}""$L"$B"$L"; printf %d, "$#" "${#1}" "${#2}"' \
							   2,1024,1024,   0 #11
	check "L='${L}' B='${B}'; "'X=set; set --;
		 set -- "${X+$@}""$L$B$L"; printf %d, "$#" "${#1}" "${#2}"' \
							      1,2049,0,   0 #12
	check "L='${L}' B='${B}'; "'X=set; set --;
		 set -- "${X+$@}$L$B$L";   printf %d, "$#" "${#1}" "${#2}"' \
							      1,2049,0,   0 #13


	check "L='${L}' B='${B}'; "'
		 set -- ${L%AAA};	    printf %d, "$#" "${#1}" "${#2}"' \
							      1,1021,0,   0 #14
	check "L='${L}' B='${B}'; "'
		 set -- "${L%AAA}";	    printf %d, "$#" "${#1}" "${#2}"' \
							      1,1021,0,   0 #15
	check "L='${L}' B='${B}'; "'
		 set -- ${L#AAA};	    printf %d, "$#" "${#1}" "${#2}"' \
							      1,1021,0,   0 #16
	check "L='${L}' B='${B}'; "'
		 set -- "${L#AAA}";	    printf %d, "$#" "${#1}" "${#2}"' \
							      1,1021,0,   0 #17
	check "L='${L}' B='${B}'; "'
		 set -- ${L%AAA}$B${L#AAAA}; printf %d, "$#" "${#1}" "${#2}"' \
							    2,1021,1020,  0 #18
	check "L='${L}' B='${B}'; "'
		 set -- ${L#AAA}$B${L%AAAA}; printf %d, "$#" "${#1}" "${#2}"' \
							    2,1021,1020,  0 #19
	check "L='foo${L}${B}bar' B='${B}'; "'
		 set -- ${L#f?o};	    printf %d, "$#" "${#1}" "${#2}"' \
							      2,1024,3,   0 #20
	check "L='foo${L}${B}bar' B='${B}'; "'
		 set -- ${L%?ar};	    printf %d, "$#" "${#1}" "${#2}"' \
							      1,1027,0,   0 #21
	check "L='foo${B}${L}bar' B='${B}'; "'
		 set -- ${L#fo?};	    printf %d, "$#" "${#1}" "${#2}"' \
							      1,1027,0,   0 #22
	check "L='foo${B}${L}bar' B='${B}'; "'
		 set -- ${L%b??};	    printf %d, "$#" "${#1}" "${#2}"' \
							      2,3,1024,   0 #23

	check "set -- '${L}'"' a b c; shift;
		echo "$#: ${1-A} ${2-B} ${3-C} ${4-D} ${5-E}"'		    \
							 '3: a b c D E'   0 #24
	check 'set -- a "" c "" e '"'${L}'"';
	       echo "$#: ${1:-A} ${2:-B} ${3:-C} ${4:-D} ${5:-E} ${#6}"'    \
						    '6: a B c D e 1024'   0 #25
	check 'set -- a "" c "" e "" '"'${L}'"';
	       echo "$#: ${1:+A} ${2:+B} ${3:+C} ${4:+D} ${5:+E} ${6:+F}"'  \
							   '7: A  C  E '  0 #26

	check 'set -- "$(echo a)" $(echo b) "$(echo c d)" $(echo e f) '"'${L}'"'
		echo "$#: $1.$2.$3.$4.$5.${#6}"'  '6: a.b.c d.e.f.1024'   0 #27

	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_unquoted
	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 land_mine
	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
}