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