Changeset View
Changeset View
Standalone View
Standalone View
bin/sh/t_builtins.sh
- This file was added.
# $NetBSD: t_builtins.sh,v 1.6 2021/05/18 21:37:56 kre Exp $ | |||||
# | |||||
# Copyright (c) 2018 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 various sh builtin utilities. | |||||
# | |||||
# Those utilities that are really external programs, which are builtin in | |||||
# for (mostly) performance (printf, kill, test, ...), are tested elsewhere. | |||||
# We do test the builtin "echo" here as (in NetBSD) it is different than | |||||
# the external one. | |||||
# | |||||
# The (mostly special) builtins which appear to be more syntax than command | |||||
# are tested in other test programs, rather than here (break, continue...) | |||||
# | |||||
# And finally, those which are fundamental to the operation of the shell, | |||||
# like wait, set, shift, ... are also tested in other test programs where | |||||
# all their operations can be more thoroughly verified. | |||||
# | |||||
# This leaves those which need to be built in (cd, umask, ...) but whose | |||||
# purpose is mostly to alter the environment in which the shell operates | |||||
# of that of the commands it runs. These tests act in co-operation with | |||||
# other tests exist here (where thy do) by not duplicating tests run | |||||
# elsewhere (ulimit is one example) but just adding to those. | |||||
# One day these might be unified. | |||||
# | |||||
# We do test both standard use of the builtins (where they are standard) | |||||
# and NetBSD sh extensions (when run on a shell with no support, such tests | |||||
# should be skipped.) | |||||
# | |||||
# Utility function able to test whether most of the builtins exist in | |||||
# the shell being tested. | |||||
have_builtin() | |||||
{ | |||||
${TEST_SH} -c "( $3 $1 $4 ) >/dev/null 2>&1" && | |||||
LC_ALL=C ${TEST_SH} -c \ | |||||
'case "$( (type '"$1"') 2>&1)" in | |||||
(*built*) exit 0 ;; | |||||
(*reserved*) exit 0 ;; # zsh!! (reserved words are builtin) | |||||
esac | |||||
exit 1' || | |||||
{ | |||||
test -z "$2" && atf_skip "${TEST_SH} has no '$1$5' built-in" | |||||
return 1; | |||||
} | |||||
return 0 | |||||
} | |||||
# And another to test if the shell being tested is the NetBSD shell, | |||||
# as we use these tests both to test standards conformance (correctness) | |||||
# which should be possible for all shells, and to test NetBSD | |||||
# extensions (which we mostly do by testing if the extension exists) | |||||
# and NetBSD sh behaviour for what is unspecified by the standard | |||||
# (so we will be notified via test failure should that unspecified | |||||
# behaviour alter) for which we have to discover if that shell is the | |||||
# one being tested. | |||||
is_netbsd_sh() | |||||
{ | |||||
unset NETBSD_SHELL 2>/dev/null | |||||
test -n "$( ${TEST_SH} -c 'printf %s "${NETBSD_SHELL}"')" | |||||
} | |||||
### Helper functions | |||||
nl=' | |||||
' | |||||
reset() | |||||
{ | |||||
TEST_NUM=0 | |||||
TEST_FAILURES='' | |||||
TEST_FAIL_COUNT=0 | |||||
TEST_ID="$1" | |||||
# These are used in check() | |||||
atf_require_prog tr | |||||
atf_require_prog printf | |||||
atf_require_prog mktemp | |||||
} | |||||
# Test run & validate. | |||||
# | |||||
# $1 is the command to run (via sh -c) | |||||
# $2 is the expected output | |||||
# $3 is the expected exit status from sh | |||||
# $4 is optional extra data for the error msg (if there is one) | |||||
# | |||||
# Stderr is exxpected to be empty, unless the expected exit code ($3) is != 0 | |||||
# in which case some message there is expected (and nothing is a failure). | |||||
# When non-zero exit is expected, we note a different (non-zero) value | |||||
# observed, but do not fail the test because of that. | |||||
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" | |||||
# determine what the test generates, preserving trailing \n's | |||||
result="$( ${TEST_SH} -c "${CMD}" 2>"${TEMP_FILE}" && printf X )" | |||||
STATUS=$? | |||||
result="${result%X}" | |||||
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}" | |||||
if [ "$2" != "${result}" ] | |||||
then | |||||
MSG="${MSG}${MSG:+${nl}}[$TEST_NUM]" | |||||
MSG="${MSG} Expected: <<$2>>, received: <<$result>>" | |||||
fail=true | |||||
fi | |||||
if $fail | |||||
then | |||||
if [ -n "$4" ]; then | |||||
MSG="${MSG}${MSG:+${nl}}[$TEST_NUM] Note: ${4}" | |||||
fi | |||||
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 colon | |||||
colon_head() { | |||||
atf_set "descr" "Tests the shell special builtin ':' command" | |||||
} | |||||
colon_body() { | |||||
have_builtin : || return 0 | |||||
atf_check -s exit:0 -e empty -o empty ${TEST_SH} -c ":" | |||||
# ':' is a special builtin, so we should exit on redirect error | |||||
# and variable assignments should persist (stupid, but it is the rule) | |||||
atf_check -s not-exit:0 -e not-empty -o empty ${TEST_SH} -c \ | |||||
": >/foo/bar; printf %s No-exit-BUG" | |||||
atf_check -s exit:0 -e empty -o inline:OK ${TEST_SH} -c \ | |||||
'X=BUG; X=OK : ; printf %s "${X}"' | |||||
} | |||||
atf_test_case echo | |||||
echo_head() { | |||||
atf_set "descr" "Tests the shell builtin version of echo" | |||||
} | |||||
echo_body() { | |||||
have_builtin echo || return 0 | |||||
if ! is_netbsd_sh; then | |||||
atf_skip \ | |||||
"${TEST_SH%% *} is not the NetBSD shell, this test is for it alone" | |||||
return 0 | |||||
fi | |||||
reset echo | |||||
check 'echo "hello world"' "hello world${nl}" 0 | |||||
check 'echo hello world' "hello world${nl}" 0 | |||||
check 'echo -n "hello world"' "hello world" 0 | |||||
check 'IFS=:; echo hello world' "hello world${nl}" 0 | |||||
check 'IFS=; echo hello world' "hello world${nl}" 0 | |||||
check 'echo -e "hello world"' "hello world${nl}" 0 | |||||
check 'echo -e hello world' "hello world${nl}" 0 | |||||
check 'IFS=:; echo -e hello world' "hello world${nl}" 0 | |||||
# only one of the options is used | |||||
check 'echo -e -n "hello world"' "-n hello world${nl}" 0 | |||||
check 'echo -n -e "hello world"' "-e hello world" 0 | |||||
# and only when it is alone | |||||
check 'echo -en "hello world"' "-en hello world${nl}" 0 | |||||
check 'echo -ne "hello world"' "-ne hello world${nl}" 0 | |||||
# echo is specifically required to *not* support -- | |||||
check 'echo -- "hello world"' "-- hello world${nl}" 0 | |||||
# similarly any other unknown option is simply part of the output | |||||
for OPT in a b c v E N Q V 0 1 2 @ , \? \[ \] \( \; . \* -help -version | |||||
do | |||||
check "echo '-${OPT}' foo" "-${OPT} foo${nl}" 0 | |||||
done | |||||
# Now test the \\ expansions, with and without -e | |||||
# We rely upon printf %b (tested elsewhere, not only a sh test) | |||||
# to verify the output when the \\ is supposed to be expanded. | |||||
for E in '' -e | |||||
do | |||||
for B in a b c e f n r t v \\ 04 010 012 0177 | |||||
do | |||||
S="test string with \\${B} in it" | |||||
if [ -z "${E}" ]; then | |||||
R="${S}${nl}" | |||||
else | |||||
R="$(printf '%b\nX' "${S}")" | |||||
R=${R%X} | |||||
fi | |||||
check "echo $E '${S}'" "${R}" 0 | |||||
done | |||||
done | |||||
check 'echo foo >&-' "" 1 | |||||
check 'echo foo >&- 2>&-; echo $?; echo $?' "1${nl}0${nl}" 0 | |||||
results | |||||
} | |||||
atf_test_case eval | |||||
eval_head() { | |||||
atf_set "descr" "Tests the shell special builtin 'eval'" | |||||
} | |||||
eval_body() { | |||||
have_builtin eval || return 0 | |||||
atf_check -s exit:0 -e empty -o empty ${TEST_SH} -c 'eval "exit 0"' | |||||
atf_check -s exit:1 -e empty -o empty ${TEST_SH} -c 'eval "exit 1"' | |||||
atf_check -s exit:0 -e empty -o empty ${TEST_SH} -c 'eval exit 0' | |||||
atf_check -s exit:1 -e empty -o empty ${TEST_SH} -c 'eval exit 1' | |||||
atf_check -s exit:0 -e empty -o inline:0 ${TEST_SH} -c \ | |||||
'eval true; printf %d $?' | |||||
atf_check -s exit:0 -e empty -o inline:1 ${TEST_SH} -c \ | |||||
'eval false; printf %d $?' | |||||
atf_check -s exit:0 -e empty -o inline:abc ${TEST_SH} -c \ | |||||
'X=a Y=b Z=c; for V in X Y Z; do eval "printf %s \$$V"; done' | |||||
atf_check -s exit:0 -e empty -o inline:abc ${TEST_SH} -c \ | |||||
'X=a Y=b Z=c; for V in X Y Z; do eval printf %s \$$V; done' | |||||
atf_check -s exit:0 -e empty -o inline:XYZ ${TEST_SH} -c \ | |||||
'for V in X Y Z; do eval "${V}=${V}"; done; printf %s "$X$Y$Z"' | |||||
# make sure eval'd strings affect the shell environment | |||||
atf_check -s exit:0 -e empty -o inline:/b/ ${TEST_SH} -c \ | |||||
'X=a; eval "X=b"; printf /%s/ "${X-unset}"' | |||||
atf_check -s exit:0 -e empty -o inline:/b/ ${TEST_SH} -c \ | |||||
'X=a; Y=X; Z=b; eval "$Y=$Z"; printf /%s/ "${X-unset}"' | |||||
atf_check -s exit:0 -e empty -o inline:/unset/ ${TEST_SH} -c \ | |||||
'X=a; eval "unset X"; printf /%s/ "${X-unset}"' | |||||
atf_check -s exit:0 -e empty -o inline:// ${TEST_SH} -c \ | |||||
'unset X; eval "X="; printf /%s/ "${X-unset}"' | |||||
atf_check -s exit:0 -e empty -o inline:'2 y Z ' ${TEST_SH} -c \ | |||||
'set -- X y Z; eval shift; printf "%s " "$#" "$@"' | |||||
# ensure an error in an eval'd string causes the shell to exit | |||||
# unless 'eval' is preceded by 'command' (in which case the | |||||
# string is not eval'd but execution continues) | |||||
atf_check -s not-exit:0 -e not-empty -o empty ${TEST_SH} -c \ | |||||
'eval "if done"; printf %s status=$?' | |||||
atf_check -s exit:0 -e not-empty -o 'match:status=[1-9]' \ | |||||
${TEST_SH} -c \ | |||||
'command eval "if done"; printf %s status=$?' | |||||
atf_check -s not-exit:0 -e not-empty \ | |||||
-o 'match:status=[1-9]' -o 'not-match:[XY]' ${TEST_SH} -c \ | |||||
'command eval "printf X; if done; printf Y" | |||||
S=$?; printf %s status=$S; exit $S' | |||||
# whether 'X' is output here is (or should be) unspecified. | |||||
atf_check -s not-exit:0 -e not-empty \ | |||||
-o 'match:status=[1-9]' -o 'not-match:Y' ${TEST_SH} -c \ | |||||
'command eval "printf X | |||||
if done | |||||
printf Y" | |||||
S=$?; printf %s status=$S; exit $S' | |||||
if is_netbsd_sh | |||||
then | |||||
# but on NetBSD we expect that X to appear... | |||||
atf_check -s not-exit:0 -e not-empty -o 'match:X' \ | |||||
-o 'match:status=[1-9]' -o 'not-match:Y' ${TEST_SH} -c \ | |||||
'command eval "printf X | |||||
if done | |||||
printf Y" | |||||
S=$?; printf %s status=$S; exit $S' | |||||
fi | |||||
} | |||||
atf_test_case exec | |||||
exec_head() { | |||||
atf_set "descr" "Tests the shell special builtin 'exec'" | |||||
} | |||||
exec_body() { | |||||
have_builtin exec || return 0 | |||||
atf_check -s exit:0 -e empty -o inline:OK ${TEST_SH} -c \ | |||||
'exec printf OK; printf BROKEN; exit 3' | |||||
atf_check -s exit:3 -e empty -o inline:OKOK ${TEST_SH} -c \ | |||||
'(exec printf OK); printf OK; exit 3' | |||||
} | |||||
atf_test_case export | |||||
export_head() { | |||||
atf_set "descr" "Tests the shell builtin 'export'" | |||||
} | |||||
export_body() { | |||||
have_builtin export || return 0 | |||||
atf_check -s exit:0 -e empty -o empty ${TEST_SH} -c 'export VAR' | |||||
atf_check -s exit:0 -e empty -o empty ${TEST_SH} -c 'export VAR=abc' | |||||
atf_check -s exit:0 -e empty -o empty ${TEST_SH} -c 'export V A R' | |||||
atf_check -s exit:0 -e empty -o empty ${TEST_SH} -c \ | |||||
'export V A=1 R=2' | |||||
atf_require_prog printenv | |||||
atf_check -s exit:1 -e empty -o empty ${TEST_SH} -c \ | |||||
'unset VAR || exit 7; export VAR; printenv VAR' | |||||
atf_check -s exit:0 -e empty -o inline:\\n ${TEST_SH} -c \ | |||||
'unset VAR || exit 7; export VAR=; printenv VAR' | |||||
atf_check -s exit:0 -e empty -o inline:\\n ${TEST_SH} -c \ | |||||
'unset VAR || exit 7; VAR=; export VAR; printenv VAR' | |||||
atf_check -s exit:0 -e empty -o inline:\\n ${TEST_SH} -c \ | |||||
'unset VAR || exit 7; export VAR; VAR=; printenv VAR' | |||||
atf_check -s exit:0 -e empty -o inline:XYZ\\n ${TEST_SH} -c \ | |||||
'unset VAR || exit 7; export VAR=XYZ; printenv VAR' | |||||
atf_check -s exit:0 -e empty -o inline:ABC\\n ${TEST_SH} -c \ | |||||
'VAR=ABC; export VAR; printenv VAR' | |||||
atf_check -s exit:0 -e empty -o inline:ABC\\n ${TEST_SH} -c \ | |||||
'unset VAR || exit 7; export VAR; VAR=ABC; printenv VAR' | |||||
atf_check -s exit:0 -e empty -o inline:ABC\\nXYZ\\n ${TEST_SH} -c \ | |||||
'VAR=ABC; export VAR; printenv VAR; VAR=XYZ; printenv VAR' | |||||
atf_check -s exit:0 -e empty -o inline:ABC\\nXYZ\\n ${TEST_SH} -c \ | |||||
'unset VAR || exit 7; export VAR; | |||||
VAR=ABC; printenv VAR; VAR=XYZ; printenv VAR' | |||||
# don't check VAR=value, some shells provide meaningless quoting... | |||||
atf_check -s exit:0 -e empty -o match:VAR= -o match:foobar \ | |||||
${TEST_SH} -c \ | |||||
'VAR=foobar ; export VAR ; export -p' | |||||
atf_check -s exit:0 -e empty -o match:VAR= -o match:foobar \ | |||||
${TEST_SH} -c \ | |||||
'export VAR=foobar ; export -p' | |||||
atf_check -s exit:0 -e empty -o match:VAR\$ ${TEST_SH} -c \ | |||||
'unset VAR ; export VAR ; export -p' | |||||
atf_check -s exit:0 -e empty -o not-match:VAR ${TEST_SH} -c \ | |||||
'export VAR ; unset VAR ; export -p' | |||||
atf_check -s exit:0 -e empty -o not-match:VAR -o not-match:foobar \ | |||||
${TEST_SH} -c \ | |||||
'VAR=foobar; export VAR ; unset VAR ; export -p' | |||||
atf_check -s exit:0 -e empty -o match:VAR= -o match:FOUND=foobar \ | |||||
${TEST_SH} -c \ | |||||
'export VAR=foobar; V=$(export -p); | |||||
unset VAR; eval "$V"; export -p; | |||||
printf %s\\n FOUND=${VAR-unset}' | |||||
atf_check -s exit:0 -e empty -o match:VAR -o match:FOUND=unset \ | |||||
${TEST_SH} -c \ | |||||
'export VAR; V=$(export -p); | |||||
unset VAR; eval "$V"; export -p; | |||||
printf %s\\n FOUND=${VAR-unset}' | |||||
atf_check -s exit:1 -e empty -o inline:ABC\\nXYZ\\n ${TEST_SH} -c \ | |||||
'VAR=ABC; export VAR; printenv VAR; VAR=XYZ; printenv VAR; | |||||
unset VAR; printenv VAR; VAR=PQR; printenv VAR' | |||||
atf_check -s exit:0 -e empty -o inline:ABC\\nXYZ\\nVAR=unset\\nMNO\\n \ | |||||
${TEST_SH} -c \ | |||||
'VAR=ABC; export VAR; printenv VAR; VAR=XYZ; printenv VAR; | |||||
unset VAR; printf %s\\n "VAR=${VAR-unset}"; printenv VAR; | |||||
VAR=PQR; printenv VAR; VAR=MNO; export VAR; printenv VAR' | |||||
} | |||||
atf_test_case export_nbsd | |||||
export_nbsd_head() { | |||||
atf_set "descr" "Tests NetBSD extensions to the shell builtin 'export'" | |||||
} | |||||
export_nbsd_body() { | |||||
have_builtin "export" "" "" "-n foo" ' -n' || return 0 | |||||
atf_require_prog printenv | |||||
atf_check -s exit:1 -e empty -o inline:ABC\\nXYZ\\n ${TEST_SH} -c \ | |||||
'VAR=ABC; export VAR; printenv VAR; VAR=XYZ; printenv VAR; | |||||
export -n VAR; printenv VAR; VAR=PQR; printenv VAR' | |||||
atf_check -s exit:0 -e empty -o inline:ABC\\nXYZ\\nVAR=XYZ\\nMNO\\n \ | |||||
${TEST_SH} -c \ | |||||
'VAR=ABC; export VAR; printenv VAR; VAR=XYZ; printenv VAR; | |||||
export -n VAR; printf %s\\n "VAR=${VAR-unset}"; printenv VAR; | |||||
VAR=PQR; printenv VAR; VAR=MNO; export VAR; printenv VAR' | |||||
have_builtin "export" "" "" -x ' -x' || return 0 | |||||
atf_check -s exit:1 -e empty -o empty ${TEST_SH} -c \ | |||||
'export VAR=exported; export -x VAR; printenv VAR' | |||||
atf_check -s exit:1 -e empty -o empty ${TEST_SH} -c \ | |||||
'export VAR=exported; export -x VAR; VAR=local; printenv VAR' | |||||
atf_check -s exit:0 -e empty -o inline:once\\nx\\n ${TEST_SH} -c \ | |||||
'export VAR=exported | |||||
export -x VAR | |||||
VAR=once printenv VAR | |||||
printenv VAR || printf %s\\n x' | |||||
atf_check -s not-exit:0 -e not-empty -o empty ${TEST_SH} -c \ | |||||
'export VAR=exported; export -x VAR; export VAR=FOO' | |||||
have_builtin export '' 'export VAR;' '-q VAR' ' -q' || return 0 | |||||
atf_check -s exit:1 -o empty -e empty ${TEST_SH} -c \ | |||||
'unset VAR; VAR=set; export -q VAR' | |||||
atf_check -s exit:0 -o empty -e empty ${TEST_SH} -c \ | |||||
'export VAR=set; export -q VAR' | |||||
atf_check -s exit:1 -o empty -e empty ${TEST_SH} -c \ | |||||
'VAR=set; RW=set; export -q VAR RW' | |||||
atf_check -s exit:1 -o empty -e empty ${TEST_SH} -c \ | |||||
'VAR=set; export RO=set; export -q VAR RO' | |||||
atf_check -s exit:0 -o empty -e empty ${TEST_SH} -c \ | |||||
'export VAR=set RO=set; export -q VAR RO' | |||||
atf_check -s exit:1 -o empty -e empty ${TEST_SH} -c \ | |||||
'unset VAR; export -q VAR' | |||||
# next one is the same as the have_builtin test, so "cannot" fail... | |||||
atf_check -s exit:0 -o empty -e empty ${TEST_SH} -c \ | |||||
'unset VAR; export VAR; export -q VAR' | |||||
# if we have -q we should also have -p var... | |||||
# What's more, we are testing NetBSD sh, so we know output format. | |||||
atf_check -s exit:0 -e empty -o match:VAR=foobar \ | |||||
${TEST_SH} -c \ | |||||
'VAR=foobar ; export VAR ; export -p VAR' | |||||
atf_check -s exit:0 -e empty -o inline:1 \ | |||||
${TEST_SH} -c \ | |||||
'VAR=foobar ; export VAR ; | |||||
printf %d $(export -p VAR | wc -l)' | |||||
atf_check -s exit:0 -e empty \ | |||||
-o inline:'export VAR=foobar\nexport OTHER\n' \ | |||||
${TEST_SH} -c \ | |||||
'VAR=foobar; export VAR OTHER; export -p VAR OTHER' | |||||
atf_check -s exit:0 -e empty \ | |||||
-o inline:'export A=aaa\nexport B\nexport D='"''"'\n' \ | |||||
${TEST_SH} -c \ | |||||
'A=aaa D= C=foo; unset B; export A B D; | |||||
export -p A B C D' | |||||
} | |||||
atf_test_case getopts | |||||
getopts_head() { | |||||
atf_set "descr" "Tests the shell builtin 'getopts'" | |||||
} | |||||
getopts_body() { | |||||
have_builtin getopts "" "f() {" "a x; }; f -a" || return 0 | |||||
} | |||||
atf_test_case jobs | |||||
jobs_head() { | |||||
atf_set "descr" "Tests the shell builting 'jobs' command" | |||||
} | |||||
jobs_body() { | |||||
have_builtin jobs || return 0 | |||||
atf_require_prog sleep | |||||
# note that POSIX requires that we reference $! otherwise | |||||
# the shell is not required to remember the process... | |||||
atf_check -s exit:0 -e empty -o match:sleep -o match:Running \ | |||||
${TEST_SH} -c 'sleep 1 & P=$!; jobs; wait' | |||||
atf_check -s exit:0 -e empty -o match:sleep -o match:Done \ | |||||
${TEST_SH} -c 'sleep 1 & P=$!; sleep 2; jobs; wait' | |||||
} | |||||
atf_test_case read | |||||
read_head() { | |||||
atf_set "descr" "Tests the shell builtin read command" | |||||
} | |||||
read_body() { | |||||
have_builtin read "" "echo x|" "var" || return 0 | |||||
} | |||||
atf_test_case readonly | |||||
readonly_head() { | |||||
atf_set "descr" "Tests the shell builtin 'readonly'" | |||||
} | |||||
readonly_body() { | |||||
have_builtin readonly || return 0 | |||||
atf_check -s exit:0 -e empty -o empty ${TEST_SH} -c 'readonly VAR' | |||||
atf_check -s exit:0 -e empty -o empty ${TEST_SH} -c 'readonly VAR=abc' | |||||
atf_check -s exit:0 -e empty -o empty ${TEST_SH} -c 'readonly V A R' | |||||
atf_check -s exit:0 -e empty -o empty ${TEST_SH} -c 'readonly V A=1 R=2' | |||||
atf_check -s exit:0 -e empty -o inline:unset ${TEST_SH} -c \ | |||||
'unset VAR; readonly VAR; printf %s ${VAR-unset}' | |||||
atf_check -s exit:0 -e empty -o inline:set ${TEST_SH} -c \ | |||||
'unset VAR; readonly VAR=set; printf %s ${VAR-unset}' | |||||
atf_check -s exit:0 -e empty -o inline:set ${TEST_SH} -c \ | |||||
'VAR=initial; readonly VAR=set; printf %s ${VAR-unset}' | |||||
atf_check -s not-exit:0 -e not-empty -o empty ${TEST_SH} -c \ | |||||
'readonly VAR=initial; VAR=new; printf %s "${VAR}"' | |||||
# don't check VAR=value, some shells provide meaningless quoting... | |||||
atf_check -s exit:0 -e empty -o match:VAR= -o match:foobar \ | |||||
${TEST_SH} -c \ | |||||
'VAR=foobar ; readonly VAR ; readonly -p' | |||||
atf_check -s exit:0 -e empty -o match:VAR= -o match:foobar \ | |||||
${TEST_SH} -c \ | |||||
'readonly VAR=foobar ; readonly -p' | |||||
atf_check -s exit:0 -e empty -o match:VAR= -o match:foobar \ | |||||
-o not-match:badvalue ${TEST_SH} -c \ | |||||
'VAR=badvalue; readonly VAR=foobar ; readonly -p' | |||||
atf_check -s exit:0 -e empty -o match:VAR\$ ${TEST_SH} -c \ | |||||
'unset VAR ; readonly VAR ; readonly -p' | |||||
# checking that readonly -p works (to reset stuff) is a pain... | |||||
# particularly since not all shells say "readonly..." by default | |||||
atf_check -s exit:0 -e empty -o match:MYVAR= -o match:FOUND=foobar \ | |||||
${TEST_SH} -c \ | |||||
'V=$(readonly MYVAR=foobar; readonly -p | grep " MYVAR") | |||||
unset MYVAR; eval "$V"; readonly -p; | |||||
printf %s\\n FOUND=${MYVAR-unset}' | |||||
atf_check -s exit:0 -e empty -o match:MYVAR\$ -o match:FOUND=unset \ | |||||
${TEST_SH} -c \ | |||||
'V=$(readonly MYVAR; readonly -p | grep " MYVAR") | |||||
unset MYVAR; eval "$V"; readonly -p; | |||||
printf %s\\n "FOUND=${MYVAR-unset}"' | |||||
atf_check -s exit:0 -e empty -o match:MYVAR= -o match:FOUND=empty \ | |||||
${TEST_SH} -c \ | |||||
'V=$(readonly MYVAR=; readonly -p | grep " MYVAR") | |||||
unset VAR; eval "$V"; readonly -p; | |||||
printf %s\\n "FOUND=${MYVAR-unset&}${MYVAR:-empty}"' | |||||
# don't test stderr, some shells inist on generating a message for an | |||||
# unset of a readonly var (rather than simply having unset make $?=1) | |||||
atf_check -s not-exit:0 -e empty -o empty ${TEST_SH} -c \ | |||||
'unset VAR; readonly VAR=set; | |||||
unset VAR 2>/dev/null && printf %s ${VAR:-XX}' | |||||
atf_check -s not-exit:0 -e ignore -o empty ${TEST_SH} -c \ | |||||
'unset VAR; readonly VAR=set; unset VAR && printf %s ${VAR:-XX}' | |||||
atf_check -s exit:0 -e ignore -o inline:set ${TEST_SH} -c \ | |||||
'unset VAR; readonly VAR=set; unset VAR; printf %s ${VAR-unset}' | |||||
} | |||||
atf_test_case readonly_nbsd | |||||
readonly_nbsd_head() { | |||||
atf_set "descr" "Tests NetBSD extensions to 'readonly'" | |||||
} | |||||
readonly_nbsd_body() { | |||||
have_builtin readonly '' 'readonly VAR;' '-q VAR' ' -q' || return 0 | |||||
atf_check -s exit:1 -o empty -e empty ${TEST_SH} -c \ | |||||
'VAR=set; readonly -q VAR' | |||||
atf_check -s exit:0 -o empty -e empty ${TEST_SH} -c \ | |||||
'readonly VAR=set; readonly -q VAR' | |||||
atf_check -s exit:1 -o empty -e empty ${TEST_SH} -c \ | |||||
'VAR=set; RW=set; readonly -q VAR RW' | |||||
atf_check -s exit:1 -o empty -e empty ${TEST_SH} -c \ | |||||
'VAR=set; readonly RO=set; readonly -q VAR RO' | |||||
atf_check -s exit:0 -o empty -e empty ${TEST_SH} -c \ | |||||
'readonly VAR=set RO=set; readonly -q VAR RO' | |||||
atf_check -s exit:1 -o empty -e empty ${TEST_SH} -c \ | |||||
'unset VAR; readonly -q VAR' | |||||
# next one is the same as the have_builtin test, so "cannot" fail... | |||||
atf_check -s exit:0 -o empty -e empty ${TEST_SH} -c \ | |||||
'unset VAR; readonly VAR; readonly -q VAR' | |||||
# if we have -q we should also have -p var... | |||||
# What's more, we are testing NetBSD sh, so we know output format. | |||||
atf_check -s exit:0 -e empty -o match:VAR=foobar \ | |||||
${TEST_SH} -c \ | |||||
'VAR=foobar ; readonly VAR ; readonly -p VAR' | |||||
atf_check -s exit:0 -e empty -o inline:1 \ | |||||
${TEST_SH} -c \ | |||||
'VAR=foobar ; readonly VAR ; | |||||
printf %d $(readonly -p VAR | wc -l)' | |||||
atf_check -s exit:0 -e empty \ | |||||
-o inline:'readonly VAR=foobar\nreadonly OTHER\n' \ | |||||
${TEST_SH} -c \ | |||||
'VAR=foobar; readonly VAR OTHER; readonly -p VAR OTHER' | |||||
atf_check -s exit:0 -e empty \ | |||||
-o inline:'readonly A=aaa\nreadonly B\nreadonly D='"''"'\n' \ | |||||
${TEST_SH} -c \ | |||||
'A=aaa D= C=foo; unset B; readonly A B D; | |||||
readonly -p A B C D' | |||||
} | |||||
atf_test_case cd_pwd | |||||
cd_pwd_head() { | |||||
atf_set "descr" "Tests the shell builtins 'cd' & 'pwd'" | |||||
} | |||||
cd_pwd_body() { | |||||
have_builtin cd "" "HOME=/;" || return 0 | |||||
have_builtin pwd || return 0 | |||||
} | |||||
atf_test_case true_false | |||||
true_false_head() { | |||||
atf_set "descr" "Tests the 'true' and 'false' shell builtin commands" | |||||
} | |||||
true_false_body() { | |||||
have_builtin true || return 0 | |||||
atf_check -s exit:0 -e empty -o empty ${TEST_SH} -c true | |||||
# true is not a special builtin, so errors do not cause exit | |||||
# but we should still get an error from the broken redirect | |||||
# and the exit status of true should be false... | |||||
atf_check -s exit:0 -e not-empty -o inline:OK ${TEST_SH} -c \ | |||||
"true >/foo/bar && printf %s NOT-; printf %s OK" | |||||
# and var-assigns should not affect the current sh env | |||||
atf_check -s exit:0 -e empty -o inline:IS-OK ${TEST_SH} -c \ | |||||
'X=OK; X=BROKEN true && printf %s IS-; printf %s "${X}"' | |||||
have_builtin false "" ! || return 0 | |||||
atf_check -s exit:1 -e empty -o empty ${TEST_SH} -c false | |||||
} | |||||
atf_test_case type | |||||
type_head() { | |||||
atf_set "descr" "Tests the sh builtin 'type' command" | |||||
} | |||||
type_body() { | |||||
have_builtin type "" "" type || return 0 | |||||
} | |||||
# This currently has its own t_ulimit - either merge that here, | |||||
# or delete this one and keep that... ulimit -n is also tested in | |||||
# the t_redir tests, as that affects the shell's use of file descriptors | |||||
atf_test_case ulimit | |||||
ulimit_head() { | |||||
atf_set "descr" "Tests the sh builtin 'ulimit'" | |||||
} | |||||
ulimit_body() { | |||||
have_builtin ulimit || return 0 | |||||
} | |||||
atf_test_case umask | |||||
umask_head() { | |||||
atf_set "descr" "Tests the sh builtin 'umask'" | |||||
} | |||||
umask_body() { | |||||
have_builtin umask || return 0 | |||||
atf_require_prog touch | |||||
atf_require_prog stat | |||||
atf_require_prog rm | |||||
atf_require_prog chmod | |||||
reset umask | |||||
# 8 octal digits | |||||
for M in 0 1 2 3 4 5 6 7 | |||||
do | |||||
# Test numbers start: 1 25 49 73 97 121 145 169 | |||||
# 8 combinations of each to test (64 inner loops) | |||||
# 3 tests in each loop, hence 192 subtests in all | |||||
# Test numbers from loop above, plus (below) and the next 2 | |||||
#+ 1 4 7 10 13 | |||||
for T in "0${M}" "00${M}" "0${M}0" "0${M}00" "0${M}${M}" \ | |||||
"0${M}${M}0" "0${M}${M}${M}" "0${M}0${M}" | |||||
#+ 16 19 22 | |||||
do | |||||
# umask turns bits off, calculate which bits will be on... | |||||
D=$(( 0777 & ~ T )) # for directories | |||||
F=$(( $D & ~ 0111 )) # and files with no 'x' bits | |||||
# Note: $(( )) always produces decimal, so we test that format | |||||
# (see '%d' in printf of stat result) | |||||
# need chmod or we might have no perm to rmdir TD | |||||
{ chmod +rwx TF TFT TD; rm -fr TF TFT TD; } 2>/dev/null || : | |||||
# check that the umask applies to files created by the shell | |||||
check \ | |||||
"umask $T; > TF; printf %d \$(stat -nf %#Lp TF)" \ | |||||
"$F" 0 "$F is $(printf %#o $F)" # 1 4 7 10 ... | |||||
# and to files created by commands that the shell runs | |||||
check \ | |||||
"umask $T; touch TFT; printf %d \$(stat -nf %#Lp TFT)" \ | |||||
"$F" 0 "$F is $(printf %#o $F)" # 2 5 8 11 ... | |||||
# and to directories created b ... (directories keep 'x') | |||||
check \ | |||||
"umask $T; mkdir TD; printf %d \$(stat -nf %#Lp TD)" \ | |||||
"$D" 0 "$D is $(printf %#o $D)" # 3 6 9 12 ... | |||||
done | |||||
done | |||||
# Now add a few more tests with less regular u/g/m masks | |||||
# In here, include tests where umask value has no leading '0' | |||||
# 10 loops, the same 3 tests in each loop, 30 more subtests | |||||
# from 193 .. 222 | |||||
# 193 196 199 202 205 208 211 214 217 220 | |||||
for T in 013 047 722 0772 027 123 421 0124 0513 067 | |||||
do | |||||
D=$(( 0777 & ~ 0$T )) | |||||
F=$(( $D & ~ 0111 )) | |||||
{ chmod +rwx TF TFT TD; rm -fr TF TFT TD; } 2>/dev/null || : | |||||
check \ | |||||
"umask $T; > TF; printf %d \$(stat -nf %#Lp TF)" \ | |||||
"$F" 0 "$F is $(printf %#o $F)" # +0 | |||||
check \ | |||||
"umask $T; touch TFT; printf %d \$(stat -nf %#Lp TFT)" \ | |||||
"$F" 0 "$F is $(printf %#o $F)" # +1 | |||||
check \ | |||||
"umask $T; mkdir TD; printf %d \$(stat -nf %#Lp TD)" \ | |||||
"$D" 0 "$D is $(printf %#o $D)" # +2 | |||||
done | |||||
results | |||||
} | |||||
atf_test_case unset | |||||
unset_head() { | |||||
atf_set "descr" "Tests the sh builtin 'unset'" | |||||
} | |||||
unset_body() { | |||||
have_builtin unset || return 0 | |||||
} | |||||
atf_test_case hash | |||||
hash_head() { | |||||
atf_set "descr" "Tests the sh builtin 'hash' (ash extension)" | |||||
} | |||||
hash_body() { | |||||
have_builtin hash || return 0 | |||||
} | |||||
atf_test_case jobid | |||||
jobid_head() { | |||||
atf_set "descr" "Tests sh builtin 'jobid' (NetBSD extension)" | |||||
} | |||||
jobid_body() { | |||||
# have_builtin jobid || return 0 No simple jobid command test | |||||
$TEST_SH -c '(exit 0)& jobid $!' >/dev/null 2>&1 || { | |||||
atf_skip "${TEST_SH} has no 'jobid' built-in" | |||||
return 0 | |||||
} | |||||
} | |||||
atf_test_case let | |||||
let_head() { | |||||
atf_set "descr" "Tests the sh builtin 'let' (common extension from ksh)" | |||||
} | |||||
let_body() { | |||||
have_builtin let "" "" 1 || return 0 | |||||
} | |||||
atf_test_case local | |||||
local_head() { | |||||
atf_set "descr" "Tests the shell builtin 'local' (common extension)" | |||||
} | |||||
local_body() { | |||||
have_builtin local "" "f () {" "X; }; f" || return 0 | |||||
} | |||||
atf_test_case setvar | |||||
setvar_head() { | |||||
atf_set "descr" "Tests the shell builtin 'setvar' (BSD extension)" | |||||
} | |||||
setvar_body() { | |||||
have_builtin setvar || return 0 | |||||
atf_check -s exit:0 -e empty -o inline:foo ${TEST_SH} -c \ | |||||
'unset PQ && setvar PQ foo; printf %s "${PQ-not set}"' | |||||
atf_check -s exit:0 -e empty -o inline:abcd ${TEST_SH} -c \ | |||||
'for x in a b c d; do setvar "$x" "$x"; done; | |||||
printf %s "$a$b$c$d"' | |||||
atf_check -s exit:0 -e empty -o empty ${TEST_SH} -c \ | |||||
'a=1; b=2; c=3; d=4 | |||||
for x in a b c d; do setvar "$x" ""; done; | |||||
printf %s "$a$b$c$d"' | |||||
} | |||||
atf_test_case fdflags | |||||
fdflags_head() { | |||||
atf_set "descr" \ | |||||
"Tests basic operation of sh builtin 'fdflags' (NetBSD extension)" | |||||
} | |||||
fdflags_body() { | |||||
have_builtin fdflags || return 0 | |||||
} | |||||
atf_test_case fdflags__s | |||||
fdflags__s_head() { | |||||
atf_set "descr" "Checks setting/clearing flags on file descriptors" | |||||
} | |||||
fdflags__s_body() { | |||||
have_builtin fdflags || return 0 | |||||
} | |||||
atf_test_case fdflags__v | |||||
fdflags__v_head() { | |||||
atf_set "descr" "Checks verbose operation of fdflags" | |||||
} | |||||
fdflags__v_body() { | |||||
have_builtin fdflags || return 0 | |||||
} | |||||
atf_test_case fdflags__v_s | |||||
fdflags__v_s_head() { | |||||
atf_set "descr" "tests verbose operation of fdflags -s" | |||||
} | |||||
fdflags__v_s_body() { | |||||
have_builtin fdflags || return 0 | |||||
} | |||||
atf_test_case fdflags_multiple_fd | |||||
fdflags_multiple_fd_head() { | |||||
atf_set "descr" "Checks operation of fdflags with more than one fd" | |||||
} | |||||
fdflags_multiple_fd_body() { | |||||
have_builtin fdflags || return 0 | |||||
} | |||||
atf_test_case fdflags_one_flag_at_a_time | |||||
fdflags_one_flag_at_a_time_head() { | |||||
atf_set "descr" "Tests all possible fdflags flags, and combinations" | |||||
} | |||||
fdflags_one_flag_at_a_time_body() { | |||||
have_builtin fdflags || return 0 | |||||
} | |||||
atf_test_case fdflags_save_restore | |||||
fdflags_save_restore_head() { | |||||
atf_set "descr" 'Verify that fd flags can be saved and restored' | |||||
} | |||||
fdflags_save_restore_body() { | |||||
have_builtin fdflags || return 0 | |||||
} | |||||
atf_test_case fdflags_names_abbreviated | |||||
fdflags_names_abbreviated_head() { | |||||
atf_set "descr" 'Tests using abbreviated names for fdflags' | |||||
} | |||||
fdflags_names_abbreviated_body() { | |||||
have_builtin fdflags || return 0 | |||||
} | |||||
atf_test_case fdflags_xx_errors | |||||
fdflags_xx_errors_head() { | |||||
atf_set "descr" 'Check various erroneous fdflags uses' | |||||
} | |||||
fdflags_xx_errors_body() { | |||||
have_builtin fdflags || return 0 | |||||
} | |||||
atf_init_test_cases() { | |||||
# "standard" builtin commands in sh | |||||
# no tests of the "very special" (almost syntax) builtins | |||||
# (break/continue/return) - they're tested enough elsewhere | |||||
atf_add_test_case cd_pwd | |||||
atf_add_test_case colon | |||||
atf_add_test_case echo | |||||
atf_add_test_case eval | |||||
atf_add_test_case exec | |||||
atf_add_test_case export | |||||
atf_add_test_case getopts | |||||
atf_add_test_case jobs | |||||
atf_add_test_case read | |||||
atf_add_test_case readonly | |||||
atf_add_test_case true_false | |||||
atf_add_test_case type | |||||
atf_add_test_case ulimit | |||||
atf_add_test_case umask | |||||
atf_add_test_case unset | |||||
# exit/wait/set/shift/trap/alias/unalias/. should have their own tests | |||||
# fc/times/fg/bg/% are too messy to contemplate for now | |||||
# command ?? (probably should have some tests) | |||||
# Note that builtin versions of, printf, kill, ... are tested separately | |||||
# (these are all "optional" builtins) | |||||
# (echo is tested here because NetBSD sh builtin echo and /bin/echo | |||||
# are different) | |||||
atf_add_test_case export_nbsd | |||||
atf_add_test_case hash | |||||
atf_add_test_case jobid | |||||
atf_add_test_case let | |||||
atf_add_test_case local | |||||
atf_add_test_case readonly_nbsd | |||||
atf_add_test_case setvar | |||||
# inputrc should probably be tested in libedit tests (somehow) | |||||
# fdflags has a bunch of test cases | |||||
# Always run one test, so we get at least "skipped" result | |||||
atf_add_test_case fdflags | |||||
# but no need to say "skipped" lots more times... | |||||
have_builtin fdflags available && { | |||||
atf_add_test_case fdflags__s | |||||
atf_add_test_case fdflags__v | |||||
atf_add_test_case fdflags__v_s | |||||
atf_add_test_case fdflags_multiple_fd | |||||
atf_add_test_case fdflags_names_abbreviated | |||||
atf_add_test_case fdflags_one_flag_at_a_time | |||||
atf_add_test_case fdflags_save_restore | |||||
atf_add_test_case fdflags_xx_errors | |||||
} | |||||
return 0 | |||||
} |