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

expect()
{
	echo expect "$@"
}

tool_var() {
        eval $1=\"\${$1:-$2}\"
        export $1
}

A="aaa bbb ccc"

unset B

tool_var        B       ${B:-"$A"}

expect '<aaa bbb ccc>'
recho "$A"
expect '<aaa bbb ccc>'
recho "$B"

eto_prepend() {
        eval $1=\'$2\''${'$1':+":"${'$1'}}'; export $1
}

foo=bar; export foo
eto_prepend foo baz
expect '<baz:bar>'
recho $foo
expect '<baz:bar>'
recho ${foo-"bar"}

aa='aaa bbb ccc'

expect '<aaa bbb ccc>'
recho ${zzz-"$aa"}
expect '<bar>'
recho ${zzz:-"bar"}
expect '<bar>'
recho "${zzz:-bar}"
expect '<bar>'
recho "${zzz:-"bar"}"

var=abcde
expect '<abcde>'
recho "${var:-xyz}"
expect '<abcde>'
recho "${var:=xyz}"
expect '<xyz>'
recho "${var:+xyz}"

set 'a b' c d e f
expect '<a b> <c> <d> <e> <f>'
recho ${1+"$@"}
expect '<a b>'
recho "${1-"$@"}"
expect '<a> <b>'
recho ${1-"$@"}
expect '<a b> <c> <d> <e> <f>'
recho "${1+$@}"
expect '<a b> <c> <d> <e> <f>'
recho "${1+"$@"}"

HOME=/usr/homes/chet
somevar=
expect "<$HOME>"
recho ${somevar:-~}
# This changed after bash-3.0, when the tilde implementation was redone.  It's
# not backward compatible, but it's very hard to be backward-compatible here,
# and I think the old behavior was a bug
expect '<~>'
recho "${somevar:-~}"
expect '<~>'
recho "${somevar:-"~"}"
expect '<\~>'
recho "${somevar:-\~}"
expect '<\ \~>'
recho "${somevar:-\ \~}"
expect '<\ \ \~>'
recho "${somevar:-\ \ \~}"

expect "<$HOME>"
recho ${somevar:-$HOME}
expect "<$HOME>"
recho "${somevar:-$HOME}"
expect "<$HOME>"
recho "${somevar:-"$HOME"}"
expect '<$HOME>'
recho "${somevar:-\$HOME}"
expect '<\ $HOME>'
recho "${somevar:-\ \$HOME}"
expect '<\ \ $HOME>'
recho "${somevar:-\ \ \$HOME}"

foo=bar
expect "<'bar'>"
recho "${foo+'$foo'}"
expect "<'bar'>"
recho "${fox='$foo'}"

P='*@*'
expect '<*@>'
recho "${P%"*"}"
expect '<*@>'
recho "${P%'*'}"

expect '<*@>'
recho ${P%"*"}
expect '<*@>'
recho ${P%'*'}

expect '<*@*>'
recho ${P%""}
expect '<*@*>'
recho ${P#""}

expect '<*@*>'
recho ${P#"$foobar"}
expect '<*@*>'
recho ${P%"$foobar"}

s1=abcdefghijkl
s2=efgh

first=${s1/$s2*/}
expect '<abcd>'
recho $first

last=${s1##$first}
expect '<efghijkl>'
recho $last

shift $#
UNAME_RELEASE=${1:-4.2MP}

RELEASE=`expr "$UNAME_RELEASE" : '[^0-9]*\([0-9]*\)'` # 4
case "$RELEASE" in
"")     RELEASE=0 ;;
*)      RELEASE=`expr "$RELEASE" + 0` ;;
esac            
REL_LEVEL=`expr "$UNAME_RELEASE" : '[^0-9]*[0-9]*.\([0-9]*\)'`    # 1
REL_SUBLEVEL=`expr "$UNAME_RELEASE" : '[^0-9]*[0-9]*.[0-9]*.\([0-9]*\)'` # 2

expect '<4> <2>'
recho $RELEASE $REL_LEVEL $REL_SUBLEVEL

b1()
{
	b2 ${1+"$@"}
}

b2()
{	
	recho $*
	recho $#
}

expect '<1>'
b1 ''

expect '<bar> <2>'
b1 bar ''

expect '<bar> <2>'
b1 '' bar

expect '<4>'
b1 '' '' '' ''

NL="\\
"

NNL="+$NL+"

expect '<--\> <-->'
recho --$NL--
expect '<--\^J-->'
recho "--$NL--"

expect '<--+\> <+-->'
recho --$NNL--
expect '<--+\^J+-->'
recho "--$NNL--"

expect '<-+\> <+-\> <->'
recho -$NNL-$NL-

set ''
expect '<xy>'
recho "$*xy"
expect '<xy>'
recho "x$*y"
expect '<xy>'
recho "xy$*"
expect '<xy>'
recho x"$*"y
expect '<xy>'
recho xy"$*"
expect '<xy>'
recho "$*"xy
expect '<>'
recho "$*"
expect nothing
recho $*

unset undef ; set ""

expect '<>'
recho ${undef-"$*"}
expect '<xy>'
recho ${undef-"x$*y"}
expect '<xy>'
recho ${undef-"$*xy"}
expect '<xy>'
recho ${undef-"xy$*"}
expect '<xy>'
recho ${undef-x"$*"y}
expect '<xy>'
recho ${undef-xy"$*"}
expect '<xy>'
recho ${undef-"$*"xy}
expect '<>'
recho "${undef-$*}"
expect nothing
recho ${undef-$*}

expect '<>'
recho ${undef-"$zzz"}
expect '<x>'
recho x${undef-"$zzz"}
expect '<x>'
recho x${undef-"$@"}
expect nothing
recho ${undef-"$@"}
expect '<x>'
recho ${undef-"$zzz"}x
expect '<x>'
recho ${undef-"$@"}x
expect '<x>'
recho "$@"x
expect '<x>'
recho "$zzz"x
expect '<^?>'
recho ${undef-\7f}
expect '<^?>'
recho ${undef-"\7f"}

yyy=""
recho "$xxx"x
recho "$yyy"x

set "" "abd" ""
recho "$@"x
recho "$@"$xxx

OIFS="$IFS"

arg=a,b,c,d,e,f

IFS=,

export z=$arg

eval z1=\"$arg\"

IFS="$OIFS"

recho $z
recho $z1

# should give an error
abc\=def

zz="a b c d e"
declare a=$zz

recho "$a"
recho $a

recho $(echo "foo$(echo ")")")

# test backslash escapes

recho \a
recho \\a

recho "\a"
recho "\\a"

recho '\a'
recho '\\a'

recho $(zecho \a)
recho $(zecho \\a)

recho $(zecho "\a")
recho $(zecho "\\a")

recho $(zecho '\a')
recho $(zecho '\\a')

recho `zecho \a`
recho `zecho \\a`

recho `zecho "\a"`
recho `zecho "\\a"`

recho `zecho '\a'`
recho `zecho '\\a'`

a=foo

recho \$a
recho \\$a

recho "\$a"
recho "\\$a"

recho '\$a'
recho '\\$a'

recho $(zecho `zecho \a`)
recho $(zecho `zecho \\a`)

recho $(zecho `zecho "\a"`)
recho $(zecho `zecho "\\a"`)

recho $(zecho `zecho '\a'`)
recho $(zecho `zecho '\\a'`)

# should echo G { I K }
recho ${abc:-G { I } K }

abc=hi

# should echo hi K }
recho ${abc:-G { I } K }

# should echo a*
unset foo
recho "${foo:-"a"}*"

f ()
{
	echo "Number of args: $#"
	echo "<\${*-x}>: <${*-x}>"
	echo "<\${@-x}>: <${@-x}>"
}

f
f ''
f '' ''

set 1 2 3 4 5

expect '<5>'
recho ${#}
expect '<5>'
recho ${#:foo}
expect '<5>'
recho ${#:-foo}
expect '<5>'
recho ${#-posparams}
expect '<5>'
recho ${#:-posparams}

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

expect nothing
recho $!
expect nothing
recho ${!}

expect nothing
recho $8
expect nothing
recho ${8}

shift $#

expect '<0>'
recho ${#}
expect '<0>'
recho ${#:foo}
expect '<0>'
recho ${#:-foo}
expect '<0>'
recho ${#-posparams}
expect '<0>'
recho ${#:-posparams}

expect '<posparams>'
recho ${!-posparams}
expect '<posparams>'
recho ${!:-posparams}

expect '<2>'
recho ${#-}

expect '<0>'
recho ${#-posparams}

expect '<0>'
recho ${#?:-xyz}

expect '<1>'
recho ${#?}

set a b c d e

expect '<5>'
recho ${#}
expect '<5>'
recho ${#?:-xyz}

shift $#

expect '<0>'
recho ${#:-foo}

expect a bad substitution error
recho ${#:}
expect a bad substitution error
recho ${#/}
expect a bad substitution error
recho ${#%}
expect a bad substitution error
recho ${#=}
expect a bad substitution error
recho ${#+}
expect a bad substitution error
recho ${#1xyz}

expect a math syntax error
recho ${#:%}

expect '<0>'
recho ${#:-}

set --
unset a b

x=a
y=b

IFS=+

expect '<a+b>'
recho $x+$y
expect '<+>'
recho $a+$b

expect '<+>'
recho + "$@"
expect '<+>'
recho +"$@"

# variants of nested curly braces inside ${...} expressions

# IFS is not the standard one

expect '<G { I>' '<K>' '<}>'
recho ${gik:-G { I } K }

abc=hi

expect '<hi>' '<K>' '<}>'
recho ${abc:-G { I } K }

# reset IFS to the default
IFS=' 	
'

# nested ${...} inside ${...} are handled specially
unset XXX FOO BAR
expect '<xxx>' '<yyy>'
XXX=xxx
FOO=${BAR:-${XXX} yyy}
recho $FOO

# this was a bug in versions of bash prior to bash-2.04-release
set -- ''
expect 1
echo $#
expect '<>'
recho "${@}"
expect '<>'
recho "${@-}"
expect '<>'
recho "${@:-}"

# this was a bug in bash-2.04, fixed in 2.05
set -- a b
expect '<:a:>' '<:b:>'
for i in "${@-}"; do recho :$i:; done

# I believe that ksh93 does these wrong -- we're using the rhs, so shouldn't
# it behave the same as ""?
set --
expect '<>'
recho "${@-}"
expect '<>'
recho "${@:-}"
Commit	Line	Data
ccc6cda3 JA	1	expect()
	2	{
	3	echo expect "$@"
	4	}
	5
	6	tool_var() {
	7	eval $1=\"\${$1:-$2}\"
	8	export $1
	9	}
	10
	11	A="aaa bbb ccc"
	12
	13	unset B
	14
	15	tool_var B ${B:-"$A"}
	16
	17	expect '<aaa bbb ccc>'
	18	recho "$A"
	19	expect '<aaa bbb ccc>'
	20	recho "$B"
	21
	22	eto_prepend() {
	23	eval $1=\'$2\''${'$1':+":"${'$1'}}'; export $1
	24	}
	25
	26	foo=bar; export foo
	27	eto_prepend foo baz
	28	expect '<baz:bar>'
	29	recho $foo
	30	expect '<baz:bar>'
	31	recho ${foo-"bar"}
	32
	33	aa='aaa bbb ccc'
	34
	35	expect '<aaa bbb ccc>'
	36	recho ${zzz-"$aa"}
	37	expect '<bar>'
	38	recho ${zzz:-"bar"}
	39	expect '<bar>'
	40	recho "${zzz:-bar}"
	41	expect '<bar>'
	42	recho "${zzz:-"bar"}"
	43
	44	var=abcde
	45	expect '<abcde>'
	46	recho "${var:-xyz}"
	47	expect '<abcde>'
	48	recho "${var:=xyz}"
	49	expect '<xyz>'
	50	recho "${var:+xyz}"
	51
	52	set 'a b' c d e f
	53	expect '<a b> <c> <d> <e> <f>'
	54	recho ${1+"$@"}
	55	expect '<a b>'
	56	recho "${1-"$@"}"
	57	expect '<a> <b>'
	58	recho ${1-"$@"}
	59	expect '<a b> <c> <d> <e> <f>'
	60	recho "${1+$@}"
	61	expect '<a b> <c> <d> <e> <f>'
	62	recho "${1+"$@"}"
	63
	64	HOME=/usr/homes/chet
65	somevar=
66	expect "<$HOME>"
67	recho ${somevar:-~}
95732b49 JA	68	# This changed after bash-3.0, when the tilde implementation was redone. It's
	69	# not backward compatible, but it's very hard to be backward-compatible here,
	70	# and I think the old behavior was a bug
	71	expect '<~>'
ccc6cda3 JA	72	recho "${somevar:-~}"
	73	expect '<~>'
	74	recho "${somevar:-"~"}"
	75	expect '<\~>'
	76	recho "${somevar:-\~}"
	77	expect '<\ \~>'
	78	recho "${somevar:-\ \~}"
	79	expect '<\ \ \~>'
	80	recho "${somevar:-\ \ \~}"
	81
	82	expect "<$HOME>"
	83	recho ${somevar:-$HOME}
	84	expect "<$HOME>"
	85	recho "${somevar:-$HOME}"
	86	expect "<$HOME>"
	87	recho "${somevar:-"$HOME"}"
	88	expect '<$HOME>'
	89	recho "${somevar:-\$HOME}"
	90	expect '<\ $HOME>'
	91	recho "${somevar:-\ \$HOME}"
	92	expect '<\ \ $HOME>'
	93	recho "${somevar:-\ \ \$HOME}"
	94
	95	foo=bar
	96	expect "<'bar'>"
	97	recho "${foo+'$foo'}"
	98	expect "<'bar'>"
	99	recho "${fox='$foo'}"
	100
	101	P='@'
7117c2d2	102	expect '<*@>'
ccc6cda3	103	recho "${P%"*"}"
7117c2d2	104	expect '<*@>'
ccc6cda3 JA	105	recho "${P%'*'}"
	106
	107	expect '<*@>'
	108	recho ${P%"*"}
	109	expect '<*@>'
	110	recho ${P%'*'}
	111
	112	expect '<@>'
	113	recho ${P%""}
	114	expect '<@>'
	115	recho ${P#""}
	116
	117	expect '<@>'
	118	recho ${P#"$foobar"}
	119	expect '<@>'
	120	recho ${P%"$foobar"}
	121
	122	s1=abcdefghijkl
	123	s2=efgh
	124
	125	first=${s1/$s2*/}
	126	expect '<abcd>'
	127	recho $first
	128
	129	last=${s1##$first}
	130	expect '<efghijkl>'
	131	recho $last
	132
	133	shift $#
	134	UNAME_RELEASE=${1:-4.2MP}
	135
	136	RELEASE=`expr "$UNAME_RELEASE" : '[^0-9]\([0-9]\)'` # 4
	137	case "$RELEASE" in
	138	"") RELEASE=0 ;;
	139	*) RELEASE=`expr "$RELEASE" + 0` ;;
	140	esac
	141	REL_LEVEL=`expr "$UNAME_RELEASE" : '[^0-9][0-9].\([0-9]*\)'` # 1
	142	REL_SUBLEVEL=`expr "$UNAME_RELEASE" : '[^0-9][0-9].[0-9].\([0-9]\)'` # 2
	143
	144	expect '<4> <2>'
	145	recho $RELEASE $REL_LEVEL $REL_SUBLEVEL
	146
	147	b1()
	148	{
	149	b2 ${1+"$@"}
	150	}
	151
	152	b2()
	153	{
	154	recho $*
	155	recho $#
	156	}
	157
	158	expect '<1>'
	159	b1 ''
	160
	161	expect '<bar> <2>'
	162	b1 bar ''
	163
	164	expect '<bar> <2>'
	165	b1 '' bar
	166
	167	expect '<4>'
	168	b1 '' '' '' ''
169
170	NL="\\
171	"
172
173	NNL="+$NL+"
174
175	expect '<--\> <-->'
176	recho --$NL--
177	expect '<--\^J-->'
178	recho "--$NL--"
179
180	expect '<--+\> <+-->'
181	recho --$NNL--
182	expect '<--+\^J+-->'
183	recho "--$NNL--"
184
185	expect '<-+\> <+-\> <->'
186	recho -$NNL-$NL-
187
188	set ''
189	expect '<xy>'
190	recho "$*xy"
191	expect '<xy>'
192	recho "x$*y"
193	expect '<xy>'
194	recho "xy$*"
cce855bc JA	195	expect '<xy>'
	196	recho x"$*"y
	197	expect '<xy>'
	198	recho xy"$*"
	199	expect '<xy>'
	200	recho "$*"xy
ccc6cda3 JA	201	expect '<>'
	202	recho "$*"
	203	expect nothing
	204	recho $*
	205
	206	unset undef ; set ""
	207
cce855bc JA	208	expect '<>'
	209	recho ${undef-"$*"}
	210	expect '<xy>'
	211	recho ${undef-"x$*y"}
	212	expect '<xy>'
	213	recho ${undef-"$*xy"}
	214	expect '<xy>'
	215	recho ${undef-"xy$*"}
	216	expect '<xy>'
	217	recho ${undef-x"$*"y}
	218	expect '<xy>'
	219	recho ${undef-xy"$*"}
	220	expect '<xy>'
	221	recho ${undef-"$*"xy}
	222	expect '<>'
	223	recho "${undef-$*}"
	224	expect nothing
	225	recho ${undef-$*}
	226
	227	expect '<>'
ccc6cda3	228	recho ${undef-"$zzz"}
cce855bc	229	expect '<x>'
ccc6cda3	230	recho x${undef-"$zzz"}
cce855bc	231	expect '<x>'
ccc6cda3	232	recho x${undef-"$@"}
cce855bc	233	expect nothing
ccc6cda3	234	recho ${undef-"$@"}
cce855bc	235	expect '<x>'
ccc6cda3	236	recho ${undef-"$zzz"}x
cce855bc	237	expect '<x>'
ccc6cda3	238	recho ${undef-"$@"}x
cce855bc	239	expect '<x>'
ccc6cda3	240	recho "$@"x
cce855bc	241	expect '<x>'
ccc6cda3	242	recho "$zzz"x
cce855bc	243	expect '<^?>'
ccc6cda3	244	recho ${undef-\7f}
cce855bc	245	expect '<^?>'
ccc6cda3 JA	246	recho ${undef-"\7f"}
	247
	248	yyy=""
	249	recho "$xxx"x
	250	recho "$yyy"x
	251
	252	set "" "abd" ""
	253	recho "$@"x
	254	recho "$@"$xxx
	255
	256	OIFS="$IFS"
	257
	258	arg=a,b,c,d,e,f
	259
	260	IFS=,
	261
	262	export z=$arg
	263
	264	eval z1=\"$arg\"
	265
	266	IFS="$OIFS"
	267
	268	recho $z
	269	recho $z1
	270
	271	# should give an error
	272	abc\=def
	273
	274	zz="a b c d e"
	275	declare a=$zz
	276
	277	recho "$a"
	278	recho $a
	279
	280	recho $(echo "foo$(echo ")")")
	281
	282	# test backslash escapes
	283
	284	recho \a
	285	recho \\a
	286
	287	recho "\a"
	288	recho "\\a"
	289
	290	recho '\a'
	291	recho '\\a'
	292
	293	recho $(zecho \a)
	294	recho $(zecho \\a)
	295
	296	recho $(zecho "\a")
	297	recho $(zecho "\\a")
	298
	299	recho $(zecho '\a')
	300	recho $(zecho '\\a')
	301
	302	recho `zecho \a`
	303	recho `zecho \\a`
	304
	305	recho `zecho "\a"`
	306	recho `zecho "\\a"`
	307
	308	recho `zecho '\a'`
	309	recho `zecho '\\a'`
310
311	a=foo
312
313	recho \$a
314	recho \\$a
315
316	recho "\$a"
317	recho "\\$a"
318
319	recho '\$a'
320	recho '\\$a'
321
322	recho $(zecho `zecho \a`)
323	recho $(zecho `zecho \\a`)
324
325	recho $(zecho `zecho "\a"`)
326	recho $(zecho `zecho "\\a"`)
327
328	recho $(zecho `zecho '\a'`)
329	recho $(zecho `zecho '\\a'`)
330
331	# should echo G { I K }
332	recho ${abc:-G { I } K }
333
334	abc=hi
335
336	# should echo hi K }
337	recho ${abc:-G { I } K }
338
339	# should echo a*
340	unset foo
341	recho "${foo:-"a"}*"
cce855bc JA	342
	343	f ()
	344	{
	345	echo "Number of args: $#"
	346	echo "<\${-x}>: <${-x}>"
	347	echo "<\${@-x}>: <${@-x}>"
	348	}
	349
	350	f
	351	f ''
	352	f '' ''
	353
	354	set 1 2 3 4 5
	355
	356	expect '<5>'
	357	recho ${#}
	358	expect '<5>'
	359	recho ${#:foo}
	360	expect '<5>'
	361	recho ${#:-foo}
	362	expect '<5>'
	363	recho ${#-posparams}
	364	expect '<5>'
	365	recho ${#:-posparams}
	366
	367	expect '<0>'
	368	recho ${#!}
	369
	370	expect nothing
	371	recho $!
	372	expect nothing
	373	recho ${!}
	374
	375	expect nothing
	376	recho $8
	377	expect nothing
	378	recho ${8}
	379
	380	shift $#
	381
	382	expect '<0>'
	383	recho ${#}
	384	expect '<0>'
	385	recho ${#:foo}
	386	expect '<0>'
	387	recho ${#:-foo}
	388	expect '<0>'
	389	recho ${#-posparams}
	390	expect '<0>'
	391	recho ${#:-posparams}
	392
	393	expect '<posparams>'
	394	recho ${!-posparams}
	395	expect '<posparams>'
	396	recho ${!:-posparams}
	397
	398	expect '<2>'
	399	recho ${#-}
	400
	401	expect '<0>'
	402	recho ${#-posparams}
	403
	404	expect '<0>'
	405	recho ${#?:-xyz}
406
407	expect '<1>'
408	recho ${#?}
409
410	set a b c d e
411
412	expect '<5>'
413	recho ${#}
414	expect '<5>'
415	recho ${#?:-xyz}
416
417	shift $#
418
419	expect '<0>'
420	recho ${#:-foo}
421
422	expect a bad substitution error
423	recho ${#:}
424	expect a bad substitution error
425	recho ${#/}
426	expect a bad substitution error
427	recho ${#%}
428	expect a bad substitution error
429	recho ${#=}
430	expect a bad substitution error
431	recho ${#+}
432	expect a bad substitution error
433	recho ${#1xyz}
434
435	expect a math syntax error
436	recho ${#:%}
437
438	expect '<0>'
439	recho ${#:-}
b72432fd JA	440
	441	set --
	442	unset a b
	443
	444	x=a
	445	y=b
	446
	447	IFS=+
	448
	449	expect '<a+b>'
	450	recho $x+$y
	451	expect '<+>'
	452	recho $a+$b
	453
	454	expect '<+>'
	455	recho + "$@"
	456	expect '<+>'
	457	recho +"$@"
	458
bb70624e JA	459	# variants of nested curly braces inside ${...} expressions
	460
	461	# IFS is not the standard one
	462
b72432fd JA	463	expect '<G { I>' '<K>' '<}>'
	464	recho ${gik:-G { I } K }
	465
	466	abc=hi
	467
	468	expect '<hi>' '<K>' '<}>'
	469	recho ${abc:-G { I } K }
bb70624e JA	470
	471	# reset IFS to the default
	472	IFS='
	473	'
	474
	475	# nested ${...} inside ${...} are handled specially
	476	unset XXX FOO BAR
	477	expect '<xxx>' '<yyy>'
	478	XXX=xxx
	479	FOO=${BAR:-${XXX} yyy}
	480	recho $FOO
	481
	482	# this was a bug in versions of bash prior to bash-2.04-release
	483	set -- ''
	484	expect 1
	485	echo $#
	486	expect '<>'
28ef6c31 JA	487	recho "${@}"
	488	expect '<>'
	489	recho "${@-}"
	490	expect '<>'
	491	recho "${@:-}"
	492
	493	# this was a bug in bash-2.04, fixed in 2.05
	494	set -- a b
	495	expect '<:a:>' '<:b:>'
	496	for i in "${@-}"; do recho :$i:; done
	497
	498	# I believe that ksh93 does these wrong -- we're using the rhs, so shouldn't
	499	# it behave the same as ""?
	500	set --
	501	expect '<>'
	502	recho "${@-}"
	503	expect '<>'
bb70624e	504	recho "${@:-}"