[thirdparty/bash.git] / tests / new-exp.tests

# must do this because posix mode causes process substitution to be disabled
# and flagged as a syntax error, which causes the shell to exit
set +o posix

expect()
{
        echo expect "$@"
}

HOME=/usr/homes/chet	# to make the check against new-exp.right work
expect '<foo bar>'
recho "${undef-"foo bar"}"	# should be foo bar
expect '<foo>'
recho "${und="foo"}"		# should be foo

expect "<$HOME>"
recho ${HOME-"}"}
expect "<$HOME>"
recho "${HOME-'}'}"
expect "<$HOME>"
recho "${HOME-"}"}"

expect $0: 'HOME: }: syntax error: operand expected (error token is "}")'
recho "${HOME:`echo }`}"	# should be a math error -- bad substring substitution

expect unset
_ENV=oops
x=${_ENV[(_$-=0)+(_=1)-_${-%%*i*}]}
echo ${x:-unset}

expect "<$HOME>"
recho ${HOME}
expect "<$HOME>"
recho ${HOME:-`echo }`}
expect "<$HOME>"
recho ${HOME:-`echo "}"`}
expect "<$HOME>"
recho "${HOME:-`echo "}"`}"
expect "<$HOME>"
recho "$(echo "${HOME}")"
expect "<$HOME>"
recho "$(echo "$(echo ${HOME})")"
expect "<$HOME>"
recho "$(echo "$(echo "${HOME}")")"

P=*@*
expect '<*@*>'
recho "${P%"*"}"	# 
expect '<*@*>'
recho "${P%'*'}"	# 
expect '<@*>'
recho "${P#\*}"		# should be @*

expect '<)>'
recho "$(echo ")")"	# should be )
expect '<")">'
recho "$(echo "\")\"")"	# should be ")"

foo='abcd   '
expect '<-abcd> <->'
recho -${foo}-		# should be -abcd -
expect '<-abcd> <->'
recho -${foo% *}-	# should be -abcd -
expect '<-abcd->'
recho -${foo%% *}-	# should be -abcd-

foo=bar
expect '<bar foo>'
echo -n $foo' ' ; echo foo

expect '<bar foo>'
echo -n $foo" " ; echo foo

expect '<bar foo>'
echo -n "$foo " ; echo foo

expect '<barfoo>'
echo -e "$foo\c " ; echo foo

expect '<barfoo>'
echo -e $foo"\c " ; echo foo

# make sure backslashes are preserved in front of characters that are not
# valid backslash escapes
expect '<\x>'
echo -e '\x'

# substring tests
z=abcdefghijklmnop
expect '<abcd>'
recho ${z:0:4}

expect '<efg> <nop>'
recho ${z:4:3} ${z:${#z}-3:3}

expect '<efg> <nop>'
recho ${z:4:3} ${z: -3:3}

expect '<hijklmnop>'
recho ${z:7:30}

expect '<abcdefghijklmnop>'
recho ${z:0:100}

expect '<abcdefghijklmnop>'
recho ${z:0:${#z}}

set 'ab cd' 'ef' 'gh ij' 'kl mn' 'op'
expect '<ab cd> <ef>'
recho "${@:1:2}"

expect '<gh ij> <kl mn>'
recho "${@:3:2}"

expect '<gh ij> <kl mn> <op>'
recho "${@:3:4}"

expect '<ab cd> <ef> <gh ij> <kl mn> <op>'
recho "${@:1:$#}"

# indirect variable references
expect '<abcdefghijklmnop>'
recho ${!9:-$z}

ef=4
expect '<4>'
recho ${!2}

expect '<op>'
recho ${!#}

set a b c d e
a=
expect '<abcdefghijklmnop>'
recho ${a:-$z}
expect '<abcdefghijklmnop>'
recho ${!1:-$z}

expect nothing
recho ${a-$z}
expect nothing
recho ${!1-$z}

set -u
expect $0: ABX: unbound variable
( recho ${ABX} )
set +u

expect $0: '$6: cannot assign in this way'
recho ${6="arg6"}

v=abcde

# sed-like variable substitution
expect '<xxcde>'
recho ${v/a[a-z]/xx}
expect '<axxde>'
recho ${v/a??/axx}
expect '<abxyz>'
recho ${v/c??/xyz}
expect '<abbcde>'
recho ${v/#a/ab}
expect '<abcde>'
recho ${v/#d/ab}
expect '<abcabe>'
recho ${v/d/ab}
expect '<abcdlast>'
recho ${v/%?/last}
expect '<abcde>'
recho ${v/%x/last}

av=(abcd efgh ijkl mnop qrst uvwx)

expect '<xxcd>'
recho ${av/??/xx}
expect '<abxx>'
recho ${av/%??/xx}
expect '<xxgh>'
recho ${av[1]/??/xx}
expect '<efgh>'
recho ${av[1]/%ab/xx}
expect '<xxfgh>'
recho ${av[1]/#?/xx}
expect '<zagh>'
recho ${av[1]/??/za}
expect '<zaza>'
recho ${av[1]//??/za}
expect '<zagh>'
recho ${av[1]//#??/za}
expect '<efza>'
recho ${av[1]//%??/za}

expect '<yyy> <yyy> <yyy> <yyy> <yyy> <yyy>'
recho ${av[@]/*/yyy}
expect '<yyy> <yyy> <yyy> <yyy> <yyy> <yyy>'
recho ${av[@]/#*/yyy}
expect '<yyy> <yyy> <yyy> <yyy> <yyy> <yyy>'
recho ${av[@]/%*/yyy}
expect '<yyy> <efgh> <ijkl> <mnop> <qrst> <uvwx>'
recho ${av[@]/a*/yyy}
expect '<abxx> <efxx> <ijxx> <mnxx> <qrxx> <uvxx>'
recho ${av[@]/%??/xx}

set abcd efgh ijkl mnop qrst uvwx

expect '<xxcd>'
recho ${1/??/xx}
expect '<xxcd> <xxgh> <xxkl> <xxop> <xxst> <xxwx>'
recho ${@/??/xx}
expect '<xxcd> <xxgh> <xxkl> <xxop> <xxst> <xxwx>'
recho ${@/%??/xx}
expect '<zaza>'
recho ${3//??/za}
expect '<efza>'
recho ${3//%??/za}
expect '<zaza> <zaza> <zaza> <zaza> <zaza> <zaza>'
recho ${@//??/za}
expect '<zacd> <zagh> <zakl> <zaop> <zast> <zawx>'
recho ${@//#??/za}
expect '<yyy> <yyy> <yyy> <yyy> <yyy> <yyy>'
recho ${@//*/yyy}
expect '<yyy> <efgh> <ijkl> <mnop> <qrst> <uvwx>'
recho ${@//a*/yyy}
expect '<abcd> <efgh> <ijkl> <mnop> <qrst> <uvwyyy>'
recho ${@//%x*/yyy}

expect a newline
echo $abmcde

# sneaky way to replace a newline in a variable value with something else
AVAR=$'This\nstring\nhas\nmultiple\nlines.'
echo "${AVAR}"

eval BVAR=\"\${AVAR//$'\n'/-}\"
echo "$BVAR"

unset AVAR BVAR

# run process substitution tests in a subshell so that syntax errors
# caused by a shell not implementing process substitution (e.g., one
# built on a NeXT) will not cause the whole test to exit prematurely
${THIS_SH} ./new-exp1.sub

# run the tests of $(<filename) in a subshell to avoid cluttering up
# this script
${THIS_SH} ./new-exp2.sub

expect '<6>'
recho ${#:-foo}
expect $0: '${#:}: bad substitution'
echo ${#:}

expect "<'>"
recho "'"
expect '<">'
recho '"'
expect '<"hello">'
recho "\"hello\""

shift $#
unset foo
z=abcdef
z1='abc def'

expect '<>'
recho ${foo:-""}
expect nothing
recho ${foo:-"$@"}
expect '<>'
recho "${foo:-$@}"

# unset var
expect '<>'
recho ${foo:-"$zbcd"}
expect nothing
recho ${foo:-$zbcd}

# set var
expect '<abcdef>'
recho ${foo:-"$z"}
expect '<abc def>'
recho ${foo:-"$z1"}

expect '<abcdef>'
recho ${foo:-$z}
expect '<abc> <def>'
recho ${foo:-$z1}

expect '<abcdef>'
recho "${foo:-$z}"
expect '<abc def>'
recho "${foo:-$z1}"

expect '<abcdef>'
recho "${foo:-"$z"}"
# this disagrees with sh and ksh, but I think it is right according
# to posix.2.
expect '<abc def>'
recho "${foo:-"$z1"}"

set ab cd ef gh
expect '<ab> <cd> <ef> <gh>'
recho ${foo:-"$@"}
expect '<ab> <cd> <ef> <gh>'
recho "${foo:-$@}"
expect '<ab> <cd> <ef> <gh>'
recho "${foo:-"$@"}"

shift $#
expect nothing
recho $xxx"$@"
expect nothing
recho ${foo:-$xxx"$@"}
expect '<>'
recho "${foo:-$xxx$@}"
expect '<>'
recho "${foo:-$xxx"$@"}"

expect nothing
recho $xxx"$@"
expect nothing
recho "$xxx$@"
expect nothing
recho "$@"$xxx

expect '<>'
recho $xxx""
expect '<>'
recho $xxx''
expect '<>'
recho ''$xxx
expect '<>'
recho ""$xxx

AB='abcdefghijklmnopqrstuvwxyz'

recho ${AB:7:15}
recho ${AB:15:7}

recho ${AB:20}

recho ${AB:0}
recho ${AB:0:20}

recho ${AB:10:7}
recho ${AB:10:3+4}
recho ${AB:20/2:3+4}

set 1 2 3 4 5 6
recho \""${*:2:2}"\"

IFS=:
recho \""${*:2:2}"\"

IFS=$' \t\n'

z=123456

recho \""${z:2:2}"\"
recho \""${z:2}"\"
recho \""${z:2:4}"\"
recho \""${z:2:6}"\"

set $'\1' $'\2' $'\177'

recho $*
recho $@

recho ${*}
recho ${@}

xx=one/two/two
recho ${xx%/*}
recho ${xx/\/two}

yy=oneonetwo
recho ${yy//one}
recho ${yy/\/one}

xx=oneonetwo

recho ${xx/one}
recho ${xx//one}
recho ${xx/\/one}

# out-of-range substrings
var=abc
c=${var:3}
expect nothing
recho $c
c=${var:4}
expect nothing
recho $c
expect '<./new-exp.tests: -2: substring expression < 0>'
c=${var:0:-2}

var=abcdefghi
c=${var:3:12}
recho $c
c=${var:4:20}
recho $c

# make sure null patterns work
xxx=endocrine
yyy=n
unset zzz

recho ${xxx/$yyy/*}
recho ${xxx//$yyy/*}

recho ${xxx/$zzz/*}
recho ${xxx//$zzz/*}

recho ${xxx//%${zzz}/}
recho ${xxx//%${zzz}}
recho ${xxx//#${zzz}/}
recho ${xxx//#${zzz}}

# another case that caused a core dump in bash-2.0
XPATH=/usr/bin:/bin:/usr/local/bin:/usr/gnu/bin::/usr/bin/X11:/sbin:/usr/sbin

recho ${XPATH//:/ }

xx=(ar as at au av aw ax ay az)

recho ${xx[@]/a/}
recho ${xx[@]//a/}

recho ${xx[*]/a/}
recho ${xx[*]//a/}

recho ${xx[@]%?}
recho ${xx[*]%?}

recho ${xx[@]#?}
recho ${xx[*]#?}

set -- ar as at au av aw ax ay az

recho ${@/a/}
recho ${@//a/}

recho ${*/a/}
recho ${*//a/}

recho ${@%?}
recho ${*%?}

recho ${@#?}
recho ${*#?}

shift $#
set -u
( recho $9 ; echo after 1)
( recho ${9} ; echo after 2)
( recho $UNSET ; echo after 3)
( recho ${UNSET} ; echo after 4)
( recho "$UNSET" ; echo after 5)
( recho "${UNSET}" ; echo after 6)
( recho "${#UNSET}" ; echo after 7)
set +u

RECEIVED="12345"
recho "${RECEIVED:$((${#RECEIVED}-1)):1}"
RECEIVED="12345#"
recho "${RECEIVED:$((${#RECEIVED}-1)):1}"
RECEIVED="#"
recho "${RECEIVED:$((${#RECEIVED}-1)):1}"
RECEIVED=""
recho "${RECEIVED:$((${#RECEIVED}-1)):1}"

# tests of new prefix expansion ${!prefix*}
${THIS_SH} ./new-exp3.sub

# these caused errors and core dumps in versions before bash-2.04
c=""
echo ${c//${$(($#-1))}/x/}

set a b c d e f g
recho "$@"

set -- ${@:1:$(($# - 2))}
recho "$@"

set a b
recho ${@:1:$(($# - 2))}

recho ${@:1:0}
recho ${@:1:1}
recho ${@:1:2}

recho "${*:1:0}"

# this is an error -- negative expression
set a
recho ${@:1:$(($# - 2))}

# this must be last!
expect $0: 'ABXD: parameter unset'
recho ${ABXD:?"parameter unset"}
Commit	Line	Data
d166f048 JA	1	# must do this because posix mode causes process substitution to be disabled
	2	# and flagged as a syntax error, which causes the shell to exit
	3	set +o posix
	4
726f6388 JA	5	expect()
	6	{
	7	echo expect "$@"
	8	}
	9
	10	HOME=/usr/homes/chet # to make the check against new-exp.right work
	11	expect '<foo bar>'
	12	recho "${undef-"foo bar"}" # should be foo bar
	13	expect '<foo>'
	14	recho "${und="foo"}" # should be foo
	15
	16	expect "<$HOME>"
	17	recho ${HOME-"}"}
	18	expect "<$HOME>"
	19	recho "${HOME-'}'}"
	20	expect "<$HOME>"
	21	recho "${HOME-"}"}"
	22
ccc6cda3 JA	23	expect $0: 'HOME: }: syntax error: operand expected (error token is "}")'
ccc6cda3 JA	24	recho "${HOME:`echo }`}" # should be a math error -- bad substring substitution
726f6388	25
ccc6cda3 JA	26	expect unset
ccc6cda3 JA	27	_ENV=oops
cce855bc	28	x=${_ENV[(_$-=0)+(_=1)-_${-%%i}]}
ccc6cda3	29	echo ${x:-unset}
726f6388 JA	30
	31	expect "<$HOME>"
	32	recho ${HOME}
	33	expect "<$HOME>"
	34	recho ${HOME:-`echo }`}
	35	expect "<$HOME>"
	36	recho ${HOME:-`echo "}"`}
	37	expect "<$HOME>"
	38	recho "${HOME:-`echo "}"`}"
	39	expect "<$HOME>"
	40	recho "$(echo "${HOME}")"
	41	expect "<$HOME>"
	42	recho "$(echo "$(echo ${HOME})")"
	43	expect "<$HOME>"
	44	recho "$(echo "$(echo "${HOME}")")"
	45
	46	P=@
ccc6cda3 JA	47	expect '<@>'
	48	recho "${P%"*"}" #
	49	expect '<@>'
	50	recho "${P%'*'}" #
726f6388 JA	51	expect '<@*>'
	52	recho "${P#\}" # should be @
	53
	54	expect '<)>'
	55	recho "$(echo ")")" # should be )
	56	expect '<")">'
	57	recho "$(echo "\")\"")" # should be ")"
	58
	59	foo='abcd '
	60	expect '<-abcd> <->'
	61	recho -${foo}- # should be -abcd -
	62	expect '<-abcd> <->'
	63	recho -${foo% *}- # should be -abcd -
	64	expect '<-abcd->'
	65	recho -${foo%% *}- # should be -abcd-
	66
726f6388 JA	67	foo=bar
	68	expect '<bar foo>'
	69	echo -n $foo' ' ; echo foo
	70
	71	expect '<bar foo>'
	72	echo -n $foo" " ; echo foo
	73
	74	expect '<bar foo>'
	75	echo -n "$foo " ; echo foo
	76
ccc6cda3	77	expect '<barfoo>'
726f6388 JA	78	echo -e "$foo\c " ; echo foo
726f6388 JA	79
ccc6cda3	80	expect '<barfoo>'
726f6388 JA	81	echo -e $foo"\c " ; echo foo
726f6388 JA	82
d166f048 JA	83	# make sure backslashes are preserved in front of characters that are not
	84	# valid backslash escapes
	85	expect '<\x>'
	86	echo -e '\x'
	87
ccc6cda3 JA	88	# substring tests
	89	z=abcdefghijklmnop
	90	expect '<abcd>'
	91	recho ${z:0:4}
	92
	93	expect '<efg> <nop>'
	94	recho ${z:4:3} ${z:${#z}-3:3}
	95
d166f048 JA	96	expect '<efg> <nop>'
	97	recho ${z:4:3} ${z: -3:3}
	98
ccc6cda3 JA	99	expect '<hijklmnop>'
	100	recho ${z:7:30}
	101
	102	expect '<abcdefghijklmnop>'
	103	recho ${z:0:100}
	104
	105	expect '<abcdefghijklmnop>'
	106	recho ${z:0:${#z}}
	107
	108	set 'ab cd' 'ef' 'gh ij' 'kl mn' 'op'
	109	expect '<ab cd> <ef>'
	110	recho "${@:1:2}"
	111
	112	expect '<gh ij> <kl mn>'
	113	recho "${@:3:2}"
	114
	115	expect '<gh ij> <kl mn> <op>'
	116	recho "${@:3:4}"
	117
	118	expect '<ab cd> <ef> <gh ij> <kl mn> <op>'
	119	recho "${@:1:$#}"
	120
	121	# indirect variable references
	122	expect '<abcdefghijklmnop>'
	123	recho ${!9:-$z}
	124
	125	ef=4
	126	expect '<4>'
	127	recho ${!2}
	128
	129	expect '<op>'
	130	recho ${!#}
	131
	132	set a b c d e
	133	a=
	134	expect '<abcdefghijklmnop>'
	135	recho ${a:-$z}
	136	expect '<abcdefghijklmnop>'
	137	recho ${!1:-$z}
	138
	139	expect nothing
	140	recho ${a-$z}
	141	expect nothing
	142	recho ${!1-$z}
	143
726f6388 JA	144	set -u
726f6388 JA	145	expect $0: ABX: unbound variable
d166f048	146	( recho ${ABX} )
726f6388 JA	147	set +u
	148
	149	expect $0: '$6: cannot assign in this way'
	150	recho ${6="arg6"}
	151
ccc6cda3 JA	152	v=abcde
	153
	154	# sed-like variable substitution
	155	expect '<xxcde>'
	156	recho ${v/a[a-z]/xx}
	157	expect '<axxde>'
	158	recho ${v/a??/axx}
	159	expect '<abxyz>'
	160	recho ${v/c??/xyz}
	161	expect '<abbcde>'
	162	recho ${v/#a/ab}
	163	expect '<abcde>'
	164	recho ${v/#d/ab}
	165	expect '<abcabe>'
	166	recho ${v/d/ab}
	167	expect '<abcdlast>'
	168	recho ${v/%?/last}
	169	expect '<abcde>'
	170	recho ${v/%x/last}
	171
	172	av=(abcd efgh ijkl mnop qrst uvwx)
	173
	174	expect '<xxcd>'
	175	recho ${av/??/xx}
	176	expect '<abxx>'
	177	recho ${av/%??/xx}
	178	expect '<xxgh>'
	179	recho ${av[1]/??/xx}
	180	expect '<efgh>'
	181	recho ${av[1]/%ab/xx}
	182	expect '<xxfgh>'
	183	recho ${av[1]/#?/xx}
	184	expect '<zagh>'
	185	recho ${av[1]/??/za}
	186	expect '<zaza>'
	187	recho ${av[1]//??/za}
	188	expect '<zagh>'
	189	recho ${av[1]//#??/za}
	190	expect '<efza>'
	191	recho ${av[1]//%??/za}
	192
	193	expect '<yyy> <yyy> <yyy> <yyy> <yyy> <yyy>'
	194	recho ${av[@]/*/yyy}
	195	expect '<yyy> <yyy> <yyy> <yyy> <yyy> <yyy>'
	196	recho ${av[@]/#*/yyy}
	197	expect '<yyy> <yyy> <yyy> <yyy> <yyy> <yyy>'
	198	recho ${av[@]/%*/yyy}
	199	expect '<yyy> <efgh> <ijkl> <mnop> <qrst> <uvwx>'
	200	recho ${av[@]/a*/yyy}
	201	expect '<abxx> <efxx> <ijxx> <mnxx> <qrxx> <uvxx>'
	202	recho ${av[@]/%??/xx}
	203
	204	set abcd efgh ijkl mnop qrst uvwx
	205
	206	expect '<xxcd>'
	207	recho ${1/??/xx}
	208	expect '<xxcd> <xxgh> <xxkl> <xxop> <xxst> <xxwx>'
	209	recho ${@/??/xx}
	210	expect '<xxcd> <xxgh> <xxkl> <xxop> <xxst> <xxwx>'
	211	recho ${@/%??/xx}
	212	expect '<zaza>'
	213	recho ${3//??/za}
	214	expect '<efza>'
	215	recho ${3//%??/za}
216	expect '<zaza> <zaza> <zaza> <zaza> <zaza> <zaza>'
217	recho ${@//??/za}
218	expect '<zacd> <zagh> <zakl> <zaop> <zast> <zawx>'
219	recho ${@//#??/za}
220	expect '<yyy> <yyy> <yyy> <yyy> <yyy> <yyy>'
221	recho ${@//*/yyy}
222	expect '<yyy> <efgh> <ijkl> <mnop> <qrst> <uvwx>'
223	recho ${@//a*/yyy}
224	expect '<abcd> <efgh> <ijkl> <mnop> <qrst> <uvwyyy>'
225	recho ${@//%x*/yyy}
226
726f6388 JA	227	expect a newline
	228	echo $abmcde
	229
bb70624e JA	230	# sneaky way to replace a newline in a variable value with something else
	231	AVAR=$'This\nstring\nhas\nmultiple\nlines.'
	232	echo "${AVAR}"
	233
	234	eval BVAR=\"\${AVAR//$'\n'/-}\"
	235	echo "$BVAR"
	236
	237	unset AVAR BVAR
	238
d166f048 JA	239	# run process substitution tests in a subshell so that syntax errors
	240	# caused by a shell not implementing process substitution (e.g., one
	241	# built on a NeXT) will not cause the whole test to exit prematurely
cce855bc	242	${THIS_SH} ./new-exp1.sub
ccc6cda3	243
cce855bc JA	244	# run the tests of $(<filename) in a subshell to avoid cluttering up
	245	# this script
	246	${THIS_SH} ./new-exp2.sub
	247
	248	expect '<6>'
	249	recho ${#:-foo}
ccc6cda3 JA	250	expect $0: '${#:}: bad substitution'
	251	echo ${#:}
	252
	253	expect "<'>"
	254	recho "'"
	255	expect '<">'
	256	recho '"'
	257	expect '<"hello">'
	258	recho "\"hello\""
	259
	260	shift $#
	261	unset foo
	262	z=abcdef
	263	z1='abc def'
	264
	265	expect '<>'
	266	recho ${foo:-""}
	267	expect nothing
	268	recho ${foo:-"$@"}
	269	expect '<>'
	270	recho "${foo:-$@}"
	271
	272	# unset var
	273	expect '<>'
	274	recho ${foo:-"$zbcd"}
	275	expect nothing
	276	recho ${foo:-$zbcd}
	277
	278	# set var
	279	expect '<abcdef>'
	280	recho ${foo:-"$z"}
	281	expect '<abc def>'
	282	recho ${foo:-"$z1"}
	283
	284	expect '<abcdef>'
	285	recho ${foo:-$z}
	286	expect '<abc> <def>'
	287	recho ${foo:-$z1}
	288
	289	expect '<abcdef>'
	290	recho "${foo:-$z}"
	291	expect '<abc def>'
	292	recho "${foo:-$z1}"
	293
	294	expect '<abcdef>'
	295	recho "${foo:-"$z"}"
	296	# this disagrees with sh and ksh, but I think it is right according
	297	# to posix.2.
	298	expect '<abc def>'
	299	recho "${foo:-"$z1"}"
	300
	301	set ab cd ef gh
	302	expect '<ab> <cd> <ef> <gh>'
	303	recho ${foo:-"$@"}
	304	expect '<ab> <cd> <ef> <gh>'
	305	recho "${foo:-$@}"
	306	expect '<ab> <cd> <ef> <gh>'
	307	recho "${foo:-"$@"}"
	308
	309	shift $#
	310	expect nothing
	311	recho $xxx"$@"
	312	expect nothing
	313	recho ${foo:-$xxx"$@"}
314	expect '<>'
315	recho "${foo:-$xxx$@}"
316	expect '<>'
317	recho "${foo:-$xxx"$@"}"
318
319	expect nothing
320	recho $xxx"$@"
321	expect nothing
322	recho "$xxx$@"
323	expect nothing
324	recho "$@"$xxx
325
326	expect '<>'
327	recho $xxx""
328	expect '<>'
329	recho $xxx''
330	expect '<>'
331	recho ''$xxx
332	expect '<>'
333	recho ""$xxx
334
335	AB='abcdefghijklmnopqrstuvwxyz'
336
337	recho ${AB:7:15}
338	recho ${AB:15:7}
339
340	recho ${AB:20}
341
342	recho ${AB:0}
343	recho ${AB:0:20}
344
345	recho ${AB:10:7}
346	recho ${AB:10:3+4}
347	recho ${AB:20/2:3+4}
348
349	set 1 2 3 4 5 6
350	recho \""${*:2:2}"\"
351
352	IFS=:
353	recho \""${*:2:2}"\"
354
355	IFS=$' \t\n'
356
357	z=123456
358
359	recho \""${z:2:2}"\"
360	recho \""${z:2}"\"
361	recho \""${z:2:4}"\"
362	recho \""${z:2:6}"\"
363
364	set $'\1' $'\2' $'\177'
365
366	recho $*
367	recho $@
368
369	recho ${*}
370	recho ${@}
371
372	xx=one/two/two
373	recho ${xx%/*}
374	recho ${xx/\/two}
375
376	yy=oneonetwo
377	recho ${yy//one}
378	recho ${yy/\/one}
379
380	xx=oneonetwo
381
382	recho ${xx/one}
383	recho ${xx//one}
384	recho ${xx/\/one}
385
d166f048 JA	386	# out-of-range substrings
	387	var=abc
	388	c=${var:3}
	389	expect nothing
	390	recho $c
	391	c=${var:4}
	392	expect nothing
	393	recho $c
	394	expect '<./new-exp.tests: -2: substring expression < 0>'
	395	c=${var:0:-2}
	396
	397	var=abcdefghi
	398	c=${var:3:12}
	399	recho $c
	400	c=${var:4:20}
	401	recho $c
	402
	403	# make sure null patterns work
	404	xxx=endocrine
	405	yyy=n
	406	unset zzz
	407
	408	recho ${xxx/$yyy/*}
	409	recho ${xxx//$yyy/*}
	410
	411	recho ${xxx/$zzz/*}
	412	recho ${xxx//$zzz/*}
	413
bb70624e JA	414	recho ${xxx//%${zzz}/}
	415	recho ${xxx//%${zzz}}
	416	recho ${xxx//#${zzz}/}
	417	recho ${xxx//#${zzz}}
	418
d166f048 JA	419	# another case that caused a core dump in bash-2.0
	420	XPATH=/usr/bin:/bin:/usr/local/bin:/usr/gnu/bin::/usr/bin/X11:/sbin:/usr/sbin
	421
	422	recho ${XPATH//:/ }
	423
	424	xx=(ar as at au av aw ax ay az)
	425
	426	recho ${xx[@]/a/}
	427	recho ${xx[@]//a/}
	428
	429	recho ${xx[*]/a/}
	430	recho ${xx[*]//a/}
	431
	432	recho ${xx[@]%?}
	433	recho ${xx[*]%?}
	434
	435	recho ${xx[@]#?}
	436	recho ${xx[*]#?}
	437
	438	set -- ar as at au av aw ax ay az
	439
	440	recho ${@/a/}
	441	recho ${@//a/}
	442
	443	recho ${*/a/}
	444	recho ${*//a/}
	445
	446	recho ${@%?}
	447	recho ${*%?}
	448
	449	recho ${@#?}
	450	recho ${*#?}
	451
	452	shift $#
	453	set -u
	454	( recho $9 ; echo after 1)
	455	( recho ${9} ; echo after 2)
	456	( recho $UNSET ; echo after 3)
	457	( recho ${UNSET} ; echo after 4)
	458	( recho "$UNSET" ; echo after 5)
	459	( recho "${UNSET}" ; echo after 6)
	460	( recho "${#UNSET}" ; echo after 7)
	461	set +u
	462
cce855bc JA	463	RECEIVED="12345"
	464	recho "${RECEIVED:$((${#RECEIVED}-1)):1}"
	465	RECEIVED="12345#"
	466	recho "${RECEIVED:$((${#RECEIVED}-1)):1}"
	467	RECEIVED="#"
	468	recho "${RECEIVED:$((${#RECEIVED}-1)):1}"
	469	RECEIVED=""
	470	recho "${RECEIVED:$((${#RECEIVED}-1)):1}"
	471
bb70624e JA	472	# tests of new prefix expansion ${!prefix*}
	473	${THIS_SH} ./new-exp3.sub
	474
	475	# these caused errors and core dumps in versions before bash-2.04
	476	c=""
	477	echo ${c//${$(($#-1))}/x/}
	478
	479	set a b c d e f g
	480	recho "$@"
	481
	482	set -- ${@:1:$(($# - 2))}
	483	recho "$@"
	484
	485	set a b
	486	recho ${@:1:$(($# - 2))}
	487
	488	recho ${@:1:0}
	489	recho ${@:1:1}
	490	recho ${@:1:2}
	491
	492	recho "${*:1:0}"
	493
	494	# this is an error -- negative expression
	495	set a
	496	recho ${@:1:$(($# - 2))}
	497
726f6388 JA	498	# this must be last!
	499	expect $0: 'ABXD: parameter unset'
	500	recho ${ABXD:?"parameter unset"}