mirror of
git://git.code.sf.net/p/cdesktopenv/code
synced 2025-03-09 15:50:02 +00:00
dccf6b5ea8
- tests/*.sh: Backported many additional regression tests and test fixes from the alpha and beta releases of ksh93v-. - tests/alias.sh: Avoid trying to add vi to the hash table, as some platforms do not provide a vi(1) implementation installed as part of the default system. This fixes a regression test failure I was getting in one of my Linux virtual machines. - tests/builtins.sh: Fixed a bug in one of the regression tests that caused an incorrect total error count if any of the tests failed. - tests/sh_match.sh: Fixed a regression test failure on DragonFly BSD caused by the diff command printing an extra 'No differences encountered' line.
706 lines
24 KiB
Bash
Executable file
706 lines
24 KiB
Bash
Executable file
########################################################################
|
|
# #
|
|
# This software is part of the ast package #
|
|
# Copyright (c) 1982-2012 AT&T Intellectual Property #
|
|
# Copyright (c) 2020-2022 Contributors to ksh 93u+m #
|
|
# and is licensed under the #
|
|
# Eclipse Public License, Version 1.0 #
|
|
# by AT&T Intellectual Property #
|
|
# #
|
|
# A copy of the License is available at #
|
|
# http://www.eclipse.org/org/documents/epl-v10.html #
|
|
# (with md5 checksum b35adb5213ca9657e911e9befb180842) #
|
|
# #
|
|
# Information and Software Systems Research #
|
|
# AT&T Research #
|
|
# Florham Park NJ #
|
|
# #
|
|
# David Korn <dgk@research.att.com> #
|
|
# #
|
|
########################################################################
|
|
|
|
. "${SHTESTS_COMMON:-${0%/*}/_common}"
|
|
|
|
tmpPS4='+ [temp_PS4|L$LINENO|e$?] ' # used to avoid interference to ${.sh.match} from $PS4 set by shtests
|
|
|
|
integer j=4
|
|
base=/home/dgk/foo//bar
|
|
string1=$base/abcabcabc
|
|
if [[ ${string1:0} != "$string1" ]]
|
|
then err_exit "string1:0"
|
|
fi
|
|
if [[ ${string1: -1} != "c" ]]
|
|
then err_exit "string1: -1"
|
|
fi
|
|
if [[ ${string1:0:1000} != "$string1" ]]
|
|
then err_exit "string1:0"
|
|
fi
|
|
if [[ ${string1:1} != "${string1#?}" ]]
|
|
then err_exit "string1:1"
|
|
fi
|
|
if [[ ${string1:1:4} != home ]]
|
|
then err_exit "string1:1:4"
|
|
fi
|
|
if [[ ${string1: -5:4} != bcab ]]
|
|
then err_exit "string1: -5:4"
|
|
fi
|
|
if [[ ${string1:1:j} != home ]]
|
|
then err_exit "string1:1:j"
|
|
fi
|
|
if [[ ${string1:(j?1:0):j} != home ]]
|
|
then err_exit "string1:(j?1:0):j"
|
|
fi
|
|
if [[ ${string1%*zzz*} != "$string1" ]]
|
|
then err_exit "string1%*zzz*"
|
|
fi
|
|
if [[ ${string1%%*zzz*} != "$string1" ]]
|
|
then err_exit "string1%%*zzz*"
|
|
fi
|
|
if [[ ${string1#*zzz*} != "$string1" ]]
|
|
then err_exit "string1#*zzz*"
|
|
fi
|
|
if [[ ${string1##*zzz*} != "$string1" ]]
|
|
then err_exit "string1##*zzz*"
|
|
fi
|
|
if [[ ${string1%+(abc)} != "$base/abcabc" ]]
|
|
then err_exit "string1%+(abc)"
|
|
fi
|
|
if [[ ${string1%%+(abc)} != "$base/" ]]
|
|
then err_exit "string1%%+(abc)"
|
|
fi
|
|
if [[ ${string1%/*} != "$base" ]]
|
|
then err_exit "string1%/*"
|
|
fi
|
|
if [[ "${string1%/*}" != "$base" ]]
|
|
then err_exit '"string1%/*"'
|
|
fi
|
|
if [[ ${string1%"/*"} != "$string1" ]]
|
|
then err_exit 'string1%"/*"'
|
|
fi
|
|
if [[ ${string1%%/*} != "" ]]
|
|
then err_exit "string1%%/*"
|
|
fi
|
|
if [[ ${string1#*/bar} != /abcabcabc ]]
|
|
then err_exit "string1#*bar"
|
|
fi
|
|
if [[ ${string1##*/bar} != /abcabcabc ]]
|
|
then err_exit "string1#*bar"
|
|
fi
|
|
if [[ "${string1#@(*/bar|*/foo)}" != //bar/abcabcabc ]]
|
|
then err_exit "string1#@(*/bar|*/foo)"
|
|
fi
|
|
if [[ ${string1##@(*/bar|*/foo)} != /abcabcabc ]]
|
|
then err_exit "string1##@(*/bar|*/foo)"
|
|
fi
|
|
if [[ ${string1##*/@(bar|foo)} != /abcabcabc ]]
|
|
then err_exit "string1##*/@(bar|foo)"
|
|
fi
|
|
foo=abc
|
|
if [[ ${foo#a[b*} != abc ]]
|
|
then err_exit "abc#a[b*} != abc"
|
|
fi
|
|
if [[ ${foo//[0-9]/bar} != abc ]]
|
|
then err_exit '${foo//[0-9]/bar} not expanding correctly'
|
|
fi
|
|
foo='(abc)'
|
|
if [[ ${foo#'('} != 'abc)' ]]
|
|
then err_exit "(abc)#( != abc)"
|
|
fi
|
|
if [[ ${foo%')'} != '(abc' ]]
|
|
then err_exit "(abc)%) != (abc"
|
|
fi
|
|
foo=a123b456c
|
|
if [[ ${foo/[0-9]?/""} != a3b456c ]]
|
|
then err_exit '${foo/[0-9]?/""} not expanding correctly'
|
|
fi
|
|
if [[ ${foo//[0-9]/""} != abc ]]
|
|
then err_exit '${foo//[0-9]/""} not expanding correctly'
|
|
fi
|
|
if [[ ${foo/#a/b} != b123b456c ]]
|
|
then err_exit '${foo/#a/b} not expanding correctly'
|
|
fi
|
|
if [[ ${foo/#?/b} != b123b456c ]]
|
|
then err_exit '${foo/#?/b} not expanding correctly'
|
|
fi
|
|
if [[ ${foo/%c/b} != a123b456b ]]
|
|
then err_exit '${foo/%c/b} not expanding correctly'
|
|
fi
|
|
if [[ ${foo/%?/b} != a123b456b ]]
|
|
then err_exit '${foo/%?/b} not expanding correctly'
|
|
fi
|
|
while read -r pattern string expected
|
|
do if (( expected ))
|
|
then if [[ $string != $pattern ]]
|
|
then err_exit "$pattern does not match $string"
|
|
fi
|
|
if [[ ${string##$pattern} != "" ]]
|
|
then err_exit "\${$string##$pattern} not null"
|
|
fi
|
|
if [ "${string##$pattern}" != '' ]
|
|
then err_exit "\"\${$string##$pattern}\" not null"
|
|
fi
|
|
if [[ ${string/$pattern} != "" ]]
|
|
then err_exit "\${$string/$pattern} not null"
|
|
fi
|
|
else if [[ $string == $pattern ]]
|
|
then err_exit "$pattern matches $string"
|
|
fi
|
|
fi
|
|
done <<- \EOF
|
|
+(a)*+(a) aabca 1
|
|
!(*.o) foo.o 0
|
|
!(*.o) foo.c 1
|
|
EOF
|
|
xx=a/b/c/d/e
|
|
yy=${xx#*/}
|
|
if [[ $yy != b/c/d/e ]]
|
|
then err_exit '${xx#*/} != a/b/c/d/e when xx=a/b/c/d/e'
|
|
fi
|
|
if [[ ${xx//\//\\} != 'a\b\c\d\e' ]]
|
|
then err_exit '${xx//\//\\} not working'
|
|
fi
|
|
x=[123]def
|
|
if [[ "${x//\[@(*)\]/\{\1\}}" != {123}def ]]
|
|
then err_exit 'closing brace escape not working'
|
|
fi
|
|
xx=%28text%29
|
|
if [[ ${xx//%28/abc\)} != 'abc)text%29' ]]
|
|
then err_exit '${xx//%28/abc\)} not working'
|
|
fi
|
|
xx='a:b'
|
|
str='(){}[]*?|&^%$#@l'
|
|
for ((i=0 ; i < ${#str}; i++))
|
|
do [[ $(eval print -r -- \"\${xx//:/\\${str:i:1}}\") == "a${str:i:1}b" ]] || err_exit "substitution of \\${str:i:1}} failed"
|
|
[[ $(eval print -rn -- \"\${xx//:/\'${str:i:1}\'}\") == "a${str:i:1}b" ]] || err_exit "substitution of '${str:i:1}' failed"
|
|
[[ $(eval print -r -- \"\${xx//:/\"${str:i:1}\"}\") == "a${str:i:1}b" ]] || err_exit "substitution of \"${str:i:1}\" failed"
|
|
done
|
|
[[ ${xx//:/\\n} == 'a\nb' ]] || err_exit "substitution of \\\\n failed"
|
|
[[ ${xx//:/'\n'} == 'a\nb' ]] || err_exit "substitution of '\\n' failed"
|
|
[[ ${xx//:/"\n"} == 'a\nb' ]] || err_exit "substitution of \"\\n\" failed"
|
|
[[ ${xx//:/$'\n'} == $'a\nb' ]] || err_exit "substitution of \$'\\n' failed"
|
|
unset foo
|
|
foo=one/two/three
|
|
if [[ ${foo//'/'/_} != one_two_three ]]
|
|
then err_exit 'single quoting / in replacements failed'
|
|
fi
|
|
if [[ ${foo//"/"/_} != one_two_three ]]
|
|
then err_exit 'double quoting / in replacements failed'
|
|
fi
|
|
if [[ ${foo//\//_} != one_two_three ]]
|
|
then err_exit 'escaping / in replacements failed'
|
|
fi
|
|
function myexport
|
|
{
|
|
nameref var=$1
|
|
if (( $# > 1 ))
|
|
then export $1=$2
|
|
fi
|
|
if (( $# > 2 ))
|
|
then print $(myexport "$1" "$3" )
|
|
return
|
|
fi
|
|
typeset val
|
|
val=$(export | grep "^$1=")
|
|
print ${val#"$1="}
|
|
}
|
|
export dgk=base
|
|
if [[ $(myexport dgk fun) != fun ]]
|
|
then err_exit 'export inside function not working'
|
|
fi
|
|
val=$(export | grep "^dgk=")
|
|
if [[ ${val#dgk=} != base ]]
|
|
then err_exit 'export not restored after function call'
|
|
fi
|
|
if [[ $(myexport dgk fun fun2) != fun2 ]]
|
|
then err_exit 'export inside function not working with recursive function'
|
|
fi
|
|
val=$(export | grep "^dgk=")
|
|
if [[ ${val#dgk=} != base ]]
|
|
then err_exit 'export not restored after recursive function call'
|
|
fi
|
|
if [[ $(dgk=try3 myexport dgk) != try3 ]]
|
|
then err_exit 'name=value not added to export list with function call'
|
|
fi
|
|
val=$(export | grep "^dgk=")
|
|
if [[ ${val#dgk=} != base ]]
|
|
then err_exit 'export not restored name=value function call'
|
|
fi
|
|
unset zzz
|
|
if [[ $(myexport zzz fun) != fun ]]
|
|
then err_exit 'export inside function not working for zzz'
|
|
fi
|
|
if [[ $(export | grep "zzz=") ]]
|
|
then err_exit 'zzz exported after function call'
|
|
fi
|
|
set -- foo/bar bam/yes last/file/done
|
|
if [[ ${@/*\/@(*)/\1} != 'bar yes done' ]]
|
|
then err_exit '\1 not working with $@'
|
|
fi
|
|
var=(foo/bar bam/yes last/file/done)
|
|
if [[ ${var[@]/*\/@(*)/\1} != 'bar yes done' ]]
|
|
then err_exit '\1 not working with ${var[@]}'
|
|
fi
|
|
var='abc_d2ef.462abc %%'
|
|
if [[ ${var/+(\w)/Q} != 'Q.462abc %%' ]]
|
|
then err_exit '${var/+(\w)/Q} not workding'
|
|
fi
|
|
if [[ ${var//+(\w)/Q} != 'Q.Q %%' ]]
|
|
then err_exit '${var//+(\w)/Q} not workding'
|
|
fi
|
|
if [[ ${var//+(\S)/Q} != 'Q Q' ]]
|
|
then err_exit '${var//+(\S)/Q} not workding'
|
|
fi
|
|
|
|
var=$($SHELL -c 'v=/vin:/usr/vin r=vin; : ${v//vin/${r//v/b}};typeset -p .sh.match') 2> /dev/null
|
|
exp='typeset -a .sh.match=((vin vin) )'
|
|
[[ $var == "$exp" ]] || err_exit '.sh.match not correct when replacement pattern contains a substring match' \
|
|
"(expected $(printf %q "$exp"), got $(printf %q "$var"))"
|
|
|
|
foo='foo+bar+'
|
|
[[ $(print -r -- ${foo//+/'|'}) != 'foo|bar|' ]] && err_exit "\${foobar//+/'|'}"
|
|
[[ $(print -r -- ${foo//+/"|"}) != 'foo|bar|' ]] && err_exit '${foobar//+/"|"}'
|
|
[[ $(print -r -- "${foo//+/'|'}") != 'foo|bar|' ]] && err_exit '"${foobar//+/'"'|'"'}"'
|
|
[[ $(print -r -- "${foo//+/"|"}") != 'foo|bar|' ]] && err_exit '"${foobar//+/"|"}"'
|
|
|
|
(
|
|
PS4=$tmpPS4
|
|
unset x
|
|
x=abcedfg
|
|
: ${x%@(d)f@(g)}
|
|
[[ ${.sh.match[0]} == dfg ]] || err_exit '.sh.match[0] not dfg'
|
|
[[ ${.sh.match[1]} == d ]] || err_exit '.sh.match[1] not d'
|
|
[[ ${.sh.match[2]} == g ]] || err_exit '.sh.match[2] not g'
|
|
x=abcedddfg
|
|
: ${x%%+(d)f@(g)}
|
|
[[ ${.sh.match[1]} == ddd ]] || err_exit '.sh.match[1] not ddd'
|
|
exit $Errors
|
|
)
|
|
Errors=$?
|
|
|
|
unset a b
|
|
a='\[abc @(*) def\]'
|
|
b='[abc 123 def]'
|
|
[[ ${b//$a/\1} == 123 ]] || err_exit "\${var/pattern} not working with \[ in pattern"
|
|
unset foo
|
|
foo='(win32.i386) '
|
|
[[ ${foo/'('/'(x11-'} == '(x11-win32.i386) ' ]] || err_exit "\${var/pattern} not working with ' in pattern"
|
|
$SHELL -c $'v=\'$(hello)\'; [[ ${v//\'$(\'/-I\'$(\'} == -I"$v" ]]' 2> /dev/null || err_exit "\${var/pattern} not working with \$( as pattern"
|
|
unset X
|
|
$SHELL -c '[[ ! ${X[@]:0:300} ]]' 2> /dev/null || err_exit '${X[@]:0:300} with X undefined fails'
|
|
$SHELL -c '[[ ${@:0:300} == "$0" ]]' 2> /dev/null || err_exit '${@:0:300} with no arguments fails'
|
|
i=20030704
|
|
[[ ${i#{6}(?)} == 04 ]] || err_exit '${i#{6}(?)} not working'
|
|
[[ ${i#{6,6}(?)} == 04 ]] || err_exit '${i#{6,6}(?)} not working'
|
|
LC_ALL=posix
|
|
i=" ."
|
|
[[ $(printf "<%s>\n" ${i#' '}) == '<.>' ]] || err_exit 'printf "<%s>\n" ${i#' '} failed'
|
|
unset x
|
|
x=foo
|
|
[[ "${x%o}(1)" == "fo(1)" ]] || err_exit 'print ${}() treated as pattern'
|
|
unset i pattern string
|
|
string=ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghigklmnopqrstuvwxyz
|
|
integer i
|
|
for((i=0; i < ${#string}; i++))
|
|
do pattern+='@(?)'
|
|
done
|
|
|
|
(
|
|
PS4=$tmpPS4
|
|
[[ $(string=$string $SHELL -c ": \${string/$pattern/}; print \${.sh.match[26]}") == Z ]] || err_exit 'sh.match[26] not Z'
|
|
: ${string/$pattern/}
|
|
(( ${#.sh.match[@]} == 53 )) || err_exit '.sh.match has wrong number of elements'
|
|
[[ ${.sh.match[@]:2:4} == 'B C D E' ]] || err_exit '${.sh.match[@]:2:4} incorrect'
|
|
exit $Errors
|
|
)
|
|
Errors=$?
|
|
|
|
D=$';' E=$'\\\\' Q=$'"' S=$'\'' M='nested pattern substitution failed'
|
|
|
|
x='-(-)-'
|
|
[[ ${x/*%(())*/\1} == '(-)' ]] || err_exit $M
|
|
x='-(-)-)-'
|
|
[[ ${x/*%(())*/\1} == '(-)' ]] || err_exit $M
|
|
x='-(-()-)-'
|
|
[[ ${x/*%(())*/\1} == '()' ]] || err_exit $M
|
|
x='-(-\)-)-'
|
|
[[ ${x/*%(())*/\1} == '(-\)' ]] || err_exit $M
|
|
x='-(-\\)-)-'
|
|
[[ ${x/*%(())*/\1} == '(-\\)' ]] || err_exit $M
|
|
x='-(-(-)-'
|
|
[[ ${x/*%(())*/\1} == '(-)' ]] || err_exit $M
|
|
x='-(-(-)-)-'
|
|
[[ ${x/*%(())*/\1} == '(-)' ]] || err_exit $M
|
|
x='-(-[-]-)-'
|
|
[[ ${x/*%(()[])*/\1} == '(-[-]-)' ]] || err_exit $M
|
|
x='-[-(-)-]-'
|
|
[[ ${x/*%(()[])*/\1} == '(-)' ]] || err_exit $M
|
|
x='-(-[-)-]-'
|
|
[[ ${x/*%(()[])*/\1} == '-(-[-)-]-' ]] || err_exit $M
|
|
x='-(-[-]-)-'
|
|
[[ ${x/*%([]())*/\1} == '[-]' ]] || err_exit $M
|
|
x='-[-(-)-]-'
|
|
[[ ${x/*%([]())*/\1} == '[-(-)-]' ]] || err_exit $M
|
|
x='-(-[-)-]-'
|
|
[[ ${x/*%([]())*/\1} == '-(-[-)-]-' ]] || err_exit $M
|
|
|
|
x='-((-))-'
|
|
[[ ${x/*%(())*/\1} == '(-)' ]] || err_exit $M
|
|
x='-((-))-'
|
|
[[ ${x/~(-g)*%(())*/\1} == '((-))-' ]] || err_exit $M
|
|
x='-((-))-'
|
|
[[ ${x/~(-g:*)*%(())*/\1} == '(-)' ]] || err_exit $M
|
|
x='-((-))-'
|
|
[[ ${x/~(+g)*%(())*/\1} == '(-)' ]] || err_exit $M
|
|
x='-((-))-'
|
|
[[ ${x/~(+g:*)*%(())*/\1} == '(-)' ]] || err_exit $M
|
|
x='-((-))-'
|
|
[[ ${x/*(?)*%(())*(?)*/:\1:\2:\3:} == ':-(:(-):)-:' ]] || err_exit $M
|
|
x='-((-))-'
|
|
[[ ${x/~(-g)*(?)*%(())*(?)*/:\1:\2:\3:} == '::((-))::-' ]] || err_exit $M
|
|
x='-((-))-'
|
|
[[ ${x/~(-g:*(?))*%(())*(?)*/:\1:\2:\3:} == '::(-):)-:' ]] || err_exit $M
|
|
x='-((-))-'
|
|
[[ ${x/~(+g)*(?)*%(())*(?)*/:\1:\2:\3:} == ':-(:(-):)-:' ]] || err_exit $M
|
|
x='-((-))-'
|
|
[[ ${x/~(+g:*(?))*%(())*(?)*/:\1:\2:\3:} == ':-(:(-):)-:' ]] || err_exit $M
|
|
x='call(a+b,x/(c/d),(0));'
|
|
[[ ${x/+([[:alnum:]])*([[:space:]])@(*%(()))*/:\1:\2:\3:} == ':call::(a+b,x/(c/d),(0)):' ]] || err_exit $M
|
|
|
|
x='-(-;-)-'
|
|
[[ ${x/*%(()D${D})*/\1} == '-(-;-)-' ]] || err_exit $M
|
|
x='-(-);-'
|
|
[[ ${x/*%(()D${D})*/\1} == '(-)' ]] || err_exit $M
|
|
x='-(-)\;-'
|
|
[[ ${x/*%(()D${D})*/\1} == '(-)' ]] || err_exit $M
|
|
x='-(-\;-)-'
|
|
[[ ${x/*%(()D${D}E${E})*/\1} == '(-\;-)' ]] || err_exit $M
|
|
x='-(-)\;-'
|
|
[[ ${x/*%(()D${D}E${E})*/\1} == '(-)' ]] || err_exit $M
|
|
x='-(-(-)\;-)-'
|
|
[[ ${x/*%(()D${D}E${E})*/\1} == '(-)' ]] || err_exit $M
|
|
|
|
x='-(-")"-)-'
|
|
[[ ${x/*%(()Q${Q})*/\1} == '(-")"-)' ]] || err_exit $M
|
|
x='-(-\")"-)-'
|
|
[[ ${x/*%(()Q${Q})*/\1} == '(-\")"-)' ]] || err_exit $M
|
|
x='-(-\")\"-)-'
|
|
[[ ${x/*%(()Q${Q})*/\1} == '(-\")\"-)' ]] || err_exit $M
|
|
x=$'-(-\\\'")\\\'-)-'
|
|
[[ ${x/*%(()Q${S}Q${Q})*/\1} == $'(-\\\'")\\\'-)' ]] || err_exit $M
|
|
x=$'-(-\\\'")"-)-'
|
|
[[ ${x/*%(()Q${S}Q${Q})*/\1} == $'-(-\\\'")"-)-' ]] || err_exit $M
|
|
x=$'-(-\\\'")"\'-)-'
|
|
[[ ${x/*%(()Q${S}Q${Q})*/\1} == $'(-\\\'")"\'-)' ]] || err_exit $M
|
|
x=$'-(-\\"\')\'\\"-)-'
|
|
[[ ${x/*%(()Q${S}Q${Q})*/\1} == $'(-\\"\')\'\\"-)' ]] || err_exit $M
|
|
x=$'-(-\')\\\'\'-)-'
|
|
[[ ${x/*%(()Q${S}Q${Q})*/\1} == $'-(-\')\\\'\'-)-' ]] || err_exit $M
|
|
x=$'-(-\'")\'-)-'
|
|
[[ ${x/*%(()L${S}Q${Q})*/\1} == $'(-\'")\'-)' ]] || err_exit $M
|
|
x=$'-(-\\\'")"-)-'
|
|
[[ ${x/*%(()L${S}Q${Q})*/\1} == $'-(-\\\'")"-)-' ]] || err_exit $M
|
|
x=$'-(-\\\'")"\'-)-'
|
|
[[ ${x/*%(()L${S}Q${Q})*/\1} == $'(-\\\'")"\'-)' ]] || err_exit $M
|
|
x=$'-(-\\"\')\'\\"-)-'
|
|
[[ ${x/*%(()L${S}Q${Q})*/\1} == $'(-\\"\')\'\\"-)' ]] || err_exit $M
|
|
x=$'-(-\')\\\'\'-)-'
|
|
[[ ${x/*%(()L${S}Q${Q})*/\1} == $'-(-\')\\\'\'-)-' ]] || err_exit $M
|
|
x='-(-")"-)-'
|
|
[[ ${x/*%(()Q${Q})*/\1} == '(-")"-)' ]] || err_exit $M
|
|
x='-(-\")"-)-'
|
|
[[ ${x/*%(()Q${Q})*/\1} == '(-\")"-)' ]] || err_exit $M
|
|
x='-(-\")\"-)-'
|
|
[[ ${x/*%(()Q${Q})*/\1} == '(-\")\"-)' ]] || err_exit $M
|
|
|
|
x='-(-\)-)-'
|
|
[[ ${x/*%(()E${E})*/\1} == '(-\)-)' ]] || err_exit $M
|
|
x='-(-\\)-)-'
|
|
[[ ${x/*%(()E${E})*/\1} == '(-\\)' ]] || err_exit $M
|
|
x='-(-\")"-)-'
|
|
[[ ${x/*%(()E${E}Q${Q})*/\1} == '(-\")' ]] || err_exit $M
|
|
x='-(-\")\"-)-'
|
|
[[ ${x/*%(()E${E}Q${Q})*/\1} == '(-\")' ]] || err_exit $M
|
|
x=$'-(-\'")"-)-'
|
|
[[ ${x/*%(()E${E}Q${S}Q${Q})*/\1} == $'-(-\'")"-)-' ]] || err_exit $M
|
|
x=$'-(-\\\'")"-)-'
|
|
[[ ${x/*%(()E${E}Q${S}Q${Q})*/\1} == $'(-\\\'")"-)' ]] || err_exit $M
|
|
x=$'-(-\\"\')\'\\"-)-'
|
|
[[ ${x/*%(()E${E}Q${S}Q${Q})*/\1} == $'(-\\"\')\'\\"-)' ]] || err_exit $M
|
|
x=$'-(-\\\'")"-)-'
|
|
[[ ${x/*%(()E${E}L${S}Q${Q})*/\1} == $'(-\\\'")"-)' ]] || err_exit $M
|
|
x=$'-(-\\"\')\'\\"-)-'
|
|
[[ ${x/*%(()E${E}L${S}Q${Q})*/\1} == $'(-\\"\')\'\\"-)' ]] || err_exit $M
|
|
x=$'-(-\\"\')\\\'\\"-)-'
|
|
[[ ${x/*%(()E${E}L${S}Q${Q})*/\1} == $'(-\\"\')\\\'\\"-)' ]] || err_exit $M
|
|
x=$'-(-\\"\')\\\'\\"\'-)-'
|
|
[[ ${x/*%(()E${E}L${S}Q${Q})*/\1} == $'-(-\\"\')\\\'\\"\'-)-' ]] || err_exit $M
|
|
|
|
x='-(-;-)-'
|
|
[[ ${x/*%(()D\;)*/\1} == '-(-;-)-' ]] || err_exit $M
|
|
x='-(-);-'
|
|
[[ ${x/*%(()D\;)*/\1} == '(-)' ]] || err_exit $M
|
|
x='-(-)\;-'
|
|
[[ ${x/*%(()D\;)*/\1} == '(-)' ]] || err_exit $M
|
|
x='-(-\;-)-'
|
|
[[ ${x/*%(()D\;E\\)*/\1} == '(-\;-)' ]] || err_exit $M
|
|
x='-(-);-'
|
|
[[ ${x/*%(()D\;E\\)*/\1} == '(-)' ]] || err_exit $M
|
|
x='-(-)\;-'
|
|
[[ ${x/*%(()D\;E\\)*/\1} == '(-)' ]] || err_exit $M
|
|
x='-(-(-)\;-)-'
|
|
[[ ${x/*%(()D\;E\\)*/\1} == '(-)' ]] || err_exit $M
|
|
|
|
x='-(-")"-)-'
|
|
[[ ${x/*%(()Q\")*/\1} == '(-")"-)' ]] || err_exit $M
|
|
x='-(-\")"-)-'
|
|
[[ ${x/*%(()Q\")*/\1} == '(-\")"-)' ]] || err_exit $M
|
|
x='-(-\")\"-)-'
|
|
[[ ${x/*%(()Q\")*/\1} == '(-\")\"-)' ]] || err_exit $M
|
|
x=$'-(-\\\'")\\\'-)-'
|
|
[[ ${x/*%(()Q\'Q\")*/\1} == $'(-\\\'")\\\'-)' ]] || err_exit $M
|
|
x=$'-(-\\\'")"-)-'
|
|
[[ ${x/*%(()Q\'Q\")*/\1} == $'-(-\\\'")"-)-' ]] || err_exit $M
|
|
x=$'-(-\\\'")"\'-)-'
|
|
[[ ${x/*%(()Q\'Q\")*/\1} == $'(-\\\'")"\'-)' ]] || err_exit $M
|
|
x=$'-(-\\"\')\'\\"-)-'
|
|
[[ ${x/*%(()Q\'Q\")*/\1} == $'(-\\"\')\'\\"-)' ]] || err_exit $M
|
|
x=$'-(-\')\\\'\'-)-'
|
|
[[ ${x/*%(()Q\'Q\")*/\1} == $'-(-\')\\\'\'-)-' ]] || err_exit $M
|
|
x=$'-(-\'")\'-)-'
|
|
[[ ${x/*%(()L\'Q\")*/\1} == $'(-\'")\'-)' ]] || err_exit $M
|
|
x=$'-(-\\\'")"-)-'
|
|
[[ ${x/*%(()L\'Q\")*/\1} == $'-(-\\\'")"-)-' ]] || err_exit $M
|
|
x=$'-(-\\\'")"\'-)-'
|
|
[[ ${x/*%(()L\'Q\")*/\1} == $'(-\\\'")"\'-)' ]] || err_exit $M
|
|
x=$'-(-\\"\')\'\\"-)-'
|
|
[[ ${x/*%(()L\'Q\")*/\1} == $'(-\\"\')\'\\"-)' ]] || err_exit $M
|
|
x=$'-(-\')\\\'\'-)-'
|
|
[[ ${x/*%(()L\'Q\")*/\1} == $'-(-\')\\\'\'-)-' ]] || err_exit $M
|
|
x='-(-")"-)-'
|
|
[[ ${x/*%(()Q\")*/\1} == '(-")"-)' ]] || err_exit $M
|
|
x='-(-\")"-)-'
|
|
[[ ${x/*%(()Q\")*/\1} == '(-\")"-)' ]] || err_exit $M
|
|
x='-(-\")\"-)-'
|
|
[[ ${x/*%(()Q\")*/\1} == '(-\")\"-)' ]] || err_exit $M
|
|
|
|
x='-(-\)-)-'
|
|
[[ ${x/*%(()E\\)*/\1} == '(-\)-)' ]] || err_exit $M
|
|
x='-(-\\)-)-'
|
|
[[ ${x/*%(()E\\)*/\1} == '(-\\)' ]] || err_exit $M
|
|
x='-(-\")"-)-'
|
|
[[ ${x/*%(()E\\Q\")*/\1} == '(-\")' ]] || err_exit $M
|
|
x='-(-\")\"-)-'
|
|
[[ ${x/*%(()E\\Q\")*/\1} == '(-\")' ]] || err_exit $M
|
|
x=$'-(-\'")"-)-'
|
|
[[ ${x/*%(()E\\Q\'Q\")*/\1} == $'-(-\'")"-)-' ]] || err_exit $M
|
|
x=$'-(-\\\'")"-)-'
|
|
[[ ${x/*%(()E\\Q\'Q\")*/\1} == $'(-\\\'")"-)' ]] || err_exit $M
|
|
x=$'-(-\\"\')\'\\"-)-'
|
|
[[ ${x/*%(()E\\Q\'Q\")*/\1} == $'(-\\"\')\'\\"-)' ]] || err_exit $M
|
|
x=$'-(-\\\'")"-)-'
|
|
[[ ${x/*%(()E\\L\'Q\")*/\1} == $'(-\\\'")"-)' ]] || err_exit $M
|
|
x=$'-(-\\"\')\'\\"-)-'
|
|
[[ ${x/*%(()E\\L\'Q\")*/\1} == $'(-\\"\')\'\\"-)' ]] || err_exit $M
|
|
x=$'-(-\\"\')\\\'\\"-)-'
|
|
[[ ${x/*%(()E\\L\'Q\")*/\1} == $'(-\\"\')\\\'\\"-)' ]] || err_exit $M
|
|
x=$'-(-\\"\')\\\'\\"\'-)-'
|
|
[[ ${x/*%(()E\\L\'Q\")*/\1} == $'-(-\\"\')\\\'\\"\'-)-' ]] || err_exit $M
|
|
|
|
pattern=00
|
|
var=100
|
|
[[ $( print $(( ${var%%00} )) ) == 1 ]] || err_exit "arithmetic with embedded patterns fails"
|
|
[[ $( print $(( ${var%%$pattern} )) ) == 1 ]] || err_exit "arithmetic with embedded pattern variables fails"
|
|
if (PS4=$tmpPS4; [[ ax == @(a)* ]] && [[ ${.sh.match[1]:0:${#.sh.match[1]}} != a ]])
|
|
then err_exit '${.sh.match[1]:1:${#.sh.match[1]}} not expanding correctly'
|
|
fi
|
|
|
|
string='foo(d:\nt\box\something)bar'
|
|
expected='d:\nt\box\something'
|
|
[[ ${string/*\(+([!\)])\)*/\1} == "$expected" ]] || err_exit "substring expansion failed '${string/*\(+([!\)])\)*/\1}' returned -- '$expected' expected"
|
|
if ((SHOPT_MULTIBYTE)) &&
|
|
[[ $($SHELL -c $'export LC_ALL=C.UTF-8; print -r "\342\202\254\342\202\254\342\202\254\342\202\254w\342\202\254\342\202\254\342\202\254\342\202\254" | wc -m' 2>/dev/null) == 10 ]]
|
|
then LC_ALL=C.UTF-8 $SHELL -c b1=$'"\342\202\254\342\202\254\342\202\254\342\202\254w\342\202\254\342\202\254\342\202\254\342\202\254"; [[ ${b1:4:1} == w ]]' || err_exit 'multibyte ${var:offset:len} not working correctly'
|
|
fi
|
|
{ $SHELL -c 'unset x;[[ ${SHELL:$x} == $SHELL ]]';} 2> /dev/null || err_exit '${var:$x} fails when x is not set'
|
|
{ $SHELL -c 'x=;[[ ${SHELL:$x} == $SHELL ]]';} 2> /dev/null || err_exit '${var:$x} fails when x is null'
|
|
|
|
# subject mode pattern result #
|
|
set -- \
|
|
'a$z' 'E' '[$]|#' 'a($)z' \
|
|
'a#z' 'E' '[$]|#' 'a(#)z' \
|
|
'a$z' 'Elr' '[$]|#' 'a$z' \
|
|
'a#z' 'Elr' '[$]|#' 'a#z' \
|
|
'a$' 'E' '[$]|#' 'a($)' \
|
|
'a#' 'E' '[$]|#' 'a(#)' \
|
|
'a$' 'Elr' '[$]|#' 'a$' \
|
|
'a#' 'Elr' '[$]|#' 'a#' \
|
|
'$z' 'E' '[$]|#' '($)z' \
|
|
'#z' 'E' '[$]|#' '(#)z' \
|
|
'$z' 'Elr' '[$]|#' '$z' \
|
|
'#z' 'Elr' '[$]|#' '#z' \
|
|
'$' 'E' '[$]|#' '($)' \
|
|
'#' 'E' '[$]|#' '(#)' \
|
|
'$' 'Elr' '[$]|#' '($)' \
|
|
'#' 'Elr' '[$]|#' '(#)' \
|
|
'a$z' 'E' '\$|#' 'a$z()' \
|
|
'a$z' 'E' '\\$|#' 'a$z' \
|
|
'a$z' 'E' '\\\$|#' 'a($)z' \
|
|
'a#z' 'E' '\\\$|#' 'a(#)z' \
|
|
'a$z' 'Elr' '\\\$|#' 'a$z' \
|
|
'a#z' 'Elr' '\\\$|#' 'a#z' \
|
|
'a$' 'E' '\\\$|#' 'a($)' \
|
|
'a#' 'E' '\\\$|#' 'a(#)' \
|
|
'a$' 'Elr' '\\\$|#' 'a$' \
|
|
'a#' 'Elr' '\\\$|#' 'a#' \
|
|
'$z' 'E' '\\\$|#' '($)z' \
|
|
'#z' 'E' '\\\$|#' '(#)z' \
|
|
'$z' 'Elr' '\\\$|#' '$z' \
|
|
'#z' 'Elr' '\\\$|#' '#z' \
|
|
'$' 'E' '\\\$|#' '($)' \
|
|
'#' 'E' '\\\$|#' '(#)' \
|
|
'$' 'Elr' '\\\$|#' '($)' \
|
|
'#' 'Elr' '\\\$|#' '(#)' \
|
|
# do not delete this line #
|
|
unset i o
|
|
while (( $# >= 4 ))
|
|
do i=$1
|
|
eval o="\${i/~($2)$3/\\(\\0\\)}"
|
|
if [[ "$o" != "$4" ]]
|
|
then err_exit "i='$1'; \${i/~($2)$3/\\(\\0\\)} failed -- expected '$4', got '$o'"
|
|
fi
|
|
eval o="\${i/~($2)($3)/\\(\\1\\)}"
|
|
if [[ "$o" != "$4" ]]
|
|
then err_exit "i='$1'; \${i/~($2)($3)/\\(\\1\\)} failed -- expected '$4', got '$o'"
|
|
fi
|
|
shift 4
|
|
done
|
|
|
|
x='a one and a two'
|
|
[[ "${x//~(E)\<.\>/}" == ' one and two' ]] || err_exit "\< and \> not working in with ere's"
|
|
|
|
{
|
|
$SHELL -c 'typeset x="123" ; integer i=100 ; print -n "${x:i:5}"'
|
|
} 2> /dev/null || err_exit '${x:i:j} fails when i > strlen(x)'
|
|
|
|
got=$($SHELL -c 'A=""; B="B"; for I in ${A[@]} ${B[@]}; do echo "\"$I\""; done')
|
|
[[ $got == $'"B"' ]] || err_exit '"\"$I\"" fails when $I is empty string'
|
|
|
|
A='|'
|
|
[[ $A == $A ]] || err_exit 'With A="|", [[ $A == $A ]] does not match'
|
|
|
|
(
|
|
PS4=$tmpPS4
|
|
|
|
x="111 222 333 444 555 666"
|
|
[[ $x == ~(E)(...).(...).(...) ]]
|
|
[[ -v .sh.match[0] ]] || err_exit '[[ -v .sh.match[0] ]] should be true'
|
|
[[ -v .sh.match[3] ]] || err_exit '[[ -v .sh.match[3] ]] should be true'
|
|
[[ -v .sh.match[4] ]] && err_exit '[[ -v .sh.match[4] ]] should be false'
|
|
[[ ${#.sh.match[@]} == 4 ]] || err_exit "\${#.sh.match[@]} should be 4, not ${#.sh.match[@]}"
|
|
|
|
x="foo bar"
|
|
dummy=${x/~(E)(*)/}
|
|
[[ ${ print -v .sh.match;} ]] && err_exit 'print -v should show .sh.match empty when there are no matches'
|
|
|
|
exit $Errors
|
|
)
|
|
Errors=$?
|
|
|
|
if $SHELL -c 'set 1 2 3 4 5 6 7 8 9 10 11 12; : ${##[0-9]}' 2>/dev/null
|
|
then set 1 2 3 4 5 6 7 8 9 10 11 12
|
|
[[ ${##[0-9]} == 2 ]] || err_exit '${##[0-9]} should be 2 with $#==12'
|
|
[[ ${###[0-9]} == 2 ]] || err_exit '${###[0-9]} should be 2 with $#==12'
|
|
[[ ${#%[0-9]} == 1 ]] || err_exit '${#%[0-9]} should be 1 with $#==12'
|
|
[[ ${#%%[0-9]} == 1 ]] || err_exit '${#%%[0-9]} should be 1 with $#==12'
|
|
else err_exit '${##[0-9]} give syntax error'
|
|
fi
|
|
|
|
{
|
|
$SHELL -c 'x="a123 456 789z"; : ${x//{3}(\d)/ }' &
|
|
sleep .5; kill $!; wait $!
|
|
} 2> /dev/null || err_exit $'tokenizer can\'t handle ${var op {..} }'
|
|
|
|
|
|
function foo
|
|
{
|
|
typeset PS4=$tmpPS4 x="123 456 789 abc"
|
|
typeset dummy="${x/~(E-g)([[:digit:]][[:digit:]])((X)|([[:digit:]]))([[:blank:]])/_}"
|
|
exp=$'(\n\t[0]=\'123 \'\n\t[1]=12\n\t[2]=3\n\t[4]=3\n\t[5]=\' \'\n)'
|
|
[[ $(print -v .sh.match) == "$exp" ]] || err_exit '.sh.match not correct with alternations'
|
|
}
|
|
foo
|
|
|
|
(
|
|
PS4=$tmpPS4
|
|
x="a 1 b"
|
|
d=${x/~(E)(([[:digit:]])[[:space:]]*|([[:alpha:]]))/X}
|
|
[[ $(print -v .sh.match) == $'(\n\t[0]=a\n\t[1]=a\n\t[3]=a\n)' ]] || err_exit '.sh.match not sparse'
|
|
exit $Errors
|
|
)
|
|
Errors=$?
|
|
|
|
unset v
|
|
typeset -a arr=( 0 1 2 3 4 )
|
|
for v in "${arr[@]:5}"
|
|
do err_exit "\${arr[@]:5} should not generate $v"
|
|
break
|
|
done
|
|
for v in "${arr[@]:1:0}"
|
|
do err_exit "\${arr[@]:1:0} should not generate ${v:-empty_string}"
|
|
break
|
|
done
|
|
for v in "${arr[@]:0:-1}"
|
|
do err_exit "\${arr[@]:0:-1} should not generate ${v:-empty_string}"
|
|
break
|
|
done
|
|
|
|
set 1 2 3 4
|
|
for v in "${@:5}"
|
|
do err_exit "\${@:5} should not generate $v"
|
|
break
|
|
done
|
|
for v in "${@:1:0}"
|
|
do err_exit "\${@:1:0} should not generate ${v:-empty_string}"
|
|
break
|
|
done
|
|
for v in "${@:0:-1}"
|
|
do err_exit "\${@:0:-1} should not generate ${v:-empty_string}"
|
|
break
|
|
done
|
|
|
|
(
|
|
PS4=$tmpPS4
|
|
unset v d
|
|
v=abbbc
|
|
d="${v/~(E)b{2,4}/dummy}"
|
|
[[ ${.sh.match} == bbb ]] || err_exit '.sh.match wrong after ${s/~(E)b{2,4}/dummy}'
|
|
[[ $d == adummyc ]] || err_exit '${s/~(E)b{2,4}/dummy} not working'
|
|
exit $Errors
|
|
)
|
|
Errors=$?
|
|
|
|
# ======
|
|
# Test for a crash after unsetting ${.sh.match} then matching a pattern
|
|
$SHELL -c 'unset .sh.match; [[ bar == ba* ]]' || err_exit 'crash after unsetting .sh.match then trying to match a pattern'
|
|
|
|
# Tests for ${.sh.match} backported from ksh93v-
|
|
unset v d
|
|
v=abbbc
|
|
d="${v/~(E)b{2,4}/dummy}"
|
|
[[ ${.sh.match} == bbb ]] || err_exit '.sh.match wrong after ${s/~(E)b{2,4}/dummy}'
|
|
[[ $d == adummyc ]] || err_exit '${s/~(E)b{2,4}/dummy} not working'
|
|
|
|
x=1234
|
|
: "${x//~(X)([012])|([345])/}"
|
|
[[ ${.sh.match[1][600..602]} ]] && err_exit '${.sh.match[0][600..602]} is not the empty string'
|
|
|
|
: "${x//~(X)([012])|([345])/}"
|
|
x=$(print -v .sh.match)
|
|
compound co
|
|
typeset -m co.array=.sh.match
|
|
[[ $x == "$(print -v co.array)" ]] || err_exit 'typeset -m for .sh.match to compound variable not working (1)'
|
|
: "${x//~(X)([345])|([012])/}"
|
|
[[ $x == "$(print -v co.array)" ]] || err_exit 'typeset -m for .sh.match to compound variable not working (2)'
|
|
|
|
# ======
|
|
exit $((Errors<125?Errors:125))
|