mirror of
git://git.code.sf.net/p/cdesktopenv/code
synced 2025-02-24 15:04:13 +00:00
2318de328a
The regression test suite used 'mktemp -dt' to create temporary directories, but that is not portable, e.g. it does not work on macOS, FreebSD or NetBSD. Installing a compatible 'mktemp' in another location in $PATH did not work either, as the regression test suite resets $PATH. src/cmd/ksh93/tests/*: - Replace many uses of 'mktemp -dt' by a portable and reasonably safe way to create a temporary directory. (cherry picked from commit 71f4c43703e3eff034009b4c8f4110bd32f4e209)
676 lines
20 KiB
Bash
Executable file
676 lines
20 KiB
Bash
Executable file
########################################################################
|
|
# #
|
|
# This software is part of the ast package #
|
|
# Copyright (c) 1982-2012 AT&T Intellectual Property #
|
|
# 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> #
|
|
# #
|
|
########################################################################
|
|
function err_exit
|
|
{
|
|
print -u2 -n "\t"
|
|
print -u2 -r ${Command}[$1]: "${@:2}"
|
|
let Errors+=1
|
|
}
|
|
alias err_exit='err_exit $LINENO'
|
|
|
|
Command=${0##*/}
|
|
integer Errors=0
|
|
|
|
tmp=$(
|
|
d=${TMPDIR:-/tmp}/ksh93.arrays.$$.${RANDOM:-0}
|
|
mkdir -m700 -- "$d" && CDPATH= cd -P -- "$d" && pwd
|
|
) || {
|
|
err_exit 'mkdir failed'
|
|
exit 1
|
|
}
|
|
trap 'cd / && rm -rf "$tmp"' EXIT
|
|
|
|
function fun
|
|
{
|
|
integer i
|
|
unset xxx
|
|
for i in 0 1
|
|
do xxx[$i]=$i
|
|
done
|
|
}
|
|
|
|
set -A x zero one two three four 'five six'
|
|
if [[ $x != zero ]]
|
|
then err_exit '$x is not element 0'
|
|
fi
|
|
if [[ ${x[0]} != zero ]]
|
|
then err_exit '${x[0] is not element 0'
|
|
fi
|
|
if (( ${#x[0]} != 4 ))
|
|
then err_exit "length of ${x[0]} is not 4"
|
|
fi
|
|
if (( ${#x[@]} != 6 ))
|
|
then err_exit 'number of elements of x is not 6'
|
|
fi
|
|
if [[ ${x[2]} != two ]]
|
|
then err_exit ' element two is not 2'
|
|
fi
|
|
if [[ ${x[@]:2:1} != two ]]
|
|
then err_exit ' ${x[@]:2:1} is not two'
|
|
fi
|
|
set -A y -- ${x[*]}
|
|
if [[ $y != zero ]]
|
|
then err_exit '$x is not element 0'
|
|
fi
|
|
if [[ ${y[0]} != zero ]]
|
|
then err_exit '${y[0] is not element 0'
|
|
fi
|
|
if (( ${#y[@]} != 7 ))
|
|
then err_exit 'number of elements of y is not 7'
|
|
fi
|
|
if [[ ${y[2]} != two ]]
|
|
then err_exit ' element two is not 2'
|
|
fi
|
|
set +A y nine ten
|
|
if [[ ${y[2]} != two ]]
|
|
then err_exit ' element two is not 2'
|
|
fi
|
|
if [[ ${y[0]} != nine ]]
|
|
then err_exit '${y[0] is not nine'
|
|
fi
|
|
unset y[4]
|
|
if (( ${#y[@]} != 6 ))
|
|
then err_exit 'number of elements of y is not 6'
|
|
fi
|
|
if (( ${#y[4]} != 0 ))
|
|
then err_exit 'string length of unset element is not 0'
|
|
fi
|
|
unset foo
|
|
if (( ${#foo[@]} != 0 ))
|
|
then err_exit 'number of elements of unset variable foo is not 0'
|
|
fi
|
|
foo=''
|
|
if (( ${#foo[0]} != 0 ))
|
|
then err_exit 'string length of null element is not 0'
|
|
fi
|
|
if (( ${#foo[@]} != 1 ))
|
|
then err_exit 'number of elements of null variable foo is not 1'
|
|
fi
|
|
unset foo
|
|
foo[0]=foo
|
|
foo[3]=bar
|
|
unset foo[0]
|
|
unset foo[3]
|
|
if (( ${#foo[@]} != 0 ))
|
|
then err_exit 'number of elements of left in variable foo is not 0'
|
|
fi
|
|
unset foo
|
|
foo[3]=bar
|
|
foo[0]=foo
|
|
unset foo[3]
|
|
unset foo[0]
|
|
if (( ${#foo[@]} != 0 ))
|
|
then err_exit 'number of elements of left in variable foo again is not 0'
|
|
fi
|
|
fun
|
|
if (( ${#xxx[@]} != 2 ))
|
|
then err_exit 'number of elements of left in variable xxx is not 2'
|
|
fi
|
|
fun
|
|
if (( ${#xxx[@]} != 2 ))
|
|
then err_exit 'number of elements of left in variable xxx again is not 2'
|
|
fi
|
|
set -A foo -- "${x[@]}"
|
|
if (( ${#foo[@]} != 6 ))
|
|
then err_exit 'number of elements of foo is not 6'
|
|
fi
|
|
if (( ${#PWD[@]} != 1 ))
|
|
then err_exit 'number of elements of PWD is not 1'
|
|
fi
|
|
unset x
|
|
x[2]=foo x[4]=bar
|
|
if (( ${#x[@]} != 2 ))
|
|
then err_exit 'number of elements of x is not 2'
|
|
fi
|
|
s[1]=1 c[1]=foo
|
|
if [[ ${c[s[1]]} != foo ]]
|
|
then err_exit 'c[1]=foo s[1]=1; ${c[s[1]]} != foo'
|
|
fi
|
|
unset s
|
|
typeset -Ai s
|
|
y=* z=[
|
|
s[$y]=1
|
|
s[$z]=2
|
|
if (( ${#s[@]} != 2 ))
|
|
then err_exit 'number of elements of is not 2'
|
|
fi
|
|
(( s[$z] = s[$z] + ${s[$y]} ))
|
|
if [[ ${s[$z]} != 3 ]]
|
|
then err_exit '[[ ${s[$z]} != 3 ]]'
|
|
fi
|
|
if (( s[$z] != 3 ))
|
|
then err_exit '(( s[$z] != 3 ))'
|
|
fi
|
|
(( s[$y] = s[$y] + ${s[$z]} ))
|
|
if [[ ${s[$y]} != 4 ]]
|
|
then err_exit '[[ ${s[$y]} != 4 ]]'
|
|
fi
|
|
if (( s[$y] != 4 ))
|
|
then err_exit '(( s[$y] != 4 ))'
|
|
fi
|
|
set -A y 2 4 6
|
|
typeset -i y
|
|
z=${y[@]}
|
|
typeset -R12 y
|
|
typeset -i y
|
|
if [[ ${y[@]} != "$z" ]]
|
|
then err_exit 'error in array conversion from int to R12'
|
|
fi
|
|
if (( ${#y[@]} != 3 ))
|
|
then err_exit 'error in count of array conversion from int to R12'
|
|
fi
|
|
unset abcdefg
|
|
: ${abcdefg[1]}
|
|
set | grep '^abcdefg$' >/dev/null && err_exit 'empty array variable in set list'
|
|
unset x y
|
|
x=1
|
|
typeset -i y[$x]=4
|
|
if [[ ${y[1]} != 4 ]]
|
|
then err_exit 'arithmetic expressions in typeset not working'
|
|
fi
|
|
unset foo
|
|
typeset foo=bar
|
|
typeset -A foo
|
|
if [[ ${foo[0]} != bar ]]
|
|
then err_exit 'initial value not preserved when typecast to associative'
|
|
fi
|
|
unset foo
|
|
foo=(one two)
|
|
typeset -A foo
|
|
foo[two]=3
|
|
if [[ ${#foo[*]} != 3 ]]
|
|
then err_exit 'conversion of indexed to associative array failed'
|
|
fi
|
|
set a b c d e f g h i j k l m
|
|
if [[ ${#} != 13 ]]
|
|
then err_exit '${#} not 13'
|
|
fi
|
|
unset xxx
|
|
xxx=foo
|
|
if [[ ${!xxx[@]} != 0 ]]
|
|
then err_exit '${!xxx[@]} for scalar not 0'
|
|
fi
|
|
if [[ ${11} != k ]]
|
|
then err_exit '${11} not working'
|
|
fi
|
|
if [[ ${@:4:1} != d ]]
|
|
then err_exit '${@:4:1} not working'
|
|
fi
|
|
foovar1=abc
|
|
foovar2=def
|
|
if [[ ${!foovar@} != +(foovar[[:alnum:]]?([ ])) ]]
|
|
then err_exit '${!foovar@} does not expand correctly'
|
|
fi
|
|
if [[ ${!foovar1} != foovar1 ]]
|
|
then err_exit '${!foovar1} != foovar1'
|
|
fi
|
|
unset xxx
|
|
: ${xxx[3]}
|
|
if [[ ${!xxx[@]} ]]
|
|
then err_exit '${!xxx[@]} should be null'
|
|
fi
|
|
integer i=0
|
|
{
|
|
set -x
|
|
xxx[++i]=1
|
|
set +x
|
|
} 2> /dev/null
|
|
if (( i != 1))
|
|
then err_exit 'execution trace side effects with array subscripts'
|
|
fi
|
|
unset list
|
|
: $(set -A list foo bar)
|
|
if (( ${#list[@]} != 0))
|
|
then err_exit '$(set -A list ...) leaves side effects'
|
|
fi
|
|
unset list
|
|
list= (foo bar bam)
|
|
( set -A list one two three four)
|
|
if [[ ${list[1]} != bar ]]
|
|
then err_exit 'array not restored after subshell'
|
|
fi
|
|
XPATH=/bin:/usr/bin:/usr/ucb:/usr/local/bin:.:/sbin:/usr/sbin
|
|
xpath=( $( IFS=: ; echo $XPATH ) )
|
|
if [[ $(print -r "${xpath[@]##*/}") != 'bin bin ucb bin . sbin sbin' ]]
|
|
then err_exit '${xpath[@]##*/} not applied to each element'
|
|
fi
|
|
foo=( zero one '' three four '' six)
|
|
integer n=-1
|
|
if [[ ${foo[@]:n} != six ]]
|
|
then err_exit 'array offset of -1 not working'
|
|
fi
|
|
if [[ ${foo[@]: -3:1} != four ]]
|
|
then err_exit 'array offset of -3:1 not working'
|
|
fi
|
|
$SHELL -c 'x=(if then else fi)' 2> /dev/null || err_exit 'reserved words in x=() assignment not working'
|
|
unset foo
|
|
foo=one
|
|
foo=( $foo two)
|
|
if [[ ${#foo[@]} != 2 ]]
|
|
then err_exit 'array getting unset before right hand side evaluation'
|
|
fi
|
|
foo=(143 3643 38732)
|
|
export foo
|
|
typeset -i foo
|
|
if [[ $($SHELL -c 'print $foo') != 143 ]]
|
|
then err_exit 'exporting indexed array not exporting 0-th element'
|
|
fi
|
|
( $SHELL -c '
|
|
unset foo
|
|
typeset -A foo=([0]=143 [1]=3643 [2]=38732)
|
|
export foo
|
|
typeset -i foo
|
|
[[ $($SHELL -c "print $foo") == 143 ]]'
|
|
) 2> /dev/null ||
|
|
err_exit 'exporting associative array not exporting 0-th element'
|
|
unset foo
|
|
typeset -A foo
|
|
foo[$((10))]=ok 2> /dev/null || err_exit 'arithmetic expression as subscript not working'
|
|
unset foo
|
|
typeset -A foo
|
|
integer foo=0
|
|
[[ $foo == 0 ]] || err_exit 'zero element of associative array not being set'
|
|
unset foo
|
|
typeset -A foo=( [two]=1)
|
|
for i in one three four five
|
|
do : ${foo[$i]}
|
|
done
|
|
if [[ ${!foo[@]} != two ]]
|
|
then err_exit 'error in subscript names'
|
|
fi
|
|
unset x
|
|
x=( 1 2 3)
|
|
(x[1]=8)
|
|
[[ ${x[1]} == 2 ]] || err_exit 'index array produce side effects in subshells'
|
|
x=( 1 2 3)
|
|
(
|
|
x+=(8)
|
|
[[ ${#x[@]} == 4 ]] || err_exit 'index array append in subshell error'
|
|
)
|
|
[[ ${#x[@]} == 3 ]] || err_exit 'index array append in subshell effects parent'
|
|
x=( [one]=1 [two]=2 [three]=3)
|
|
(x[two]=8)
|
|
[[ ${x[two]} == 2 ]] || err_exit 'associative array produce side effects in subshells'
|
|
unset x
|
|
x=( [one]=1 [two]=2 [three]=3)
|
|
(
|
|
x+=( [four]=4 )
|
|
[[ ${#x[@]} == 4 ]] || err_exit 'associative array append in subshell error'
|
|
)
|
|
[[ ${#x[@]} == 3 ]] || err_exit 'associative array append in subshell effects parent'
|
|
unset x
|
|
integer i
|
|
for ((i=0; i < 40; i++))
|
|
do x[i]=$i
|
|
done
|
|
[[ ${#x[@]} == 40 ]] || err_exit 'index arrays losing values'
|
|
[[ $( ($SHELL -c 'typeset -A var; (IFS=: ; set -A var a:b:c ;print ${var[@]});:' )2>/dev/null) == 'a b c' ]] || err_exit 'change associative to index failed'
|
|
unset foo
|
|
[[ $(foo=good
|
|
for ((i=0; i < 2; i++))
|
|
do [[ ${foo[i]} ]] && print ok
|
|
done) == ok ]] || err_exit 'invalid optimization for subscripted variables'
|
|
(
|
|
x=([foo]=bar)
|
|
set +A x bam
|
|
) 2> /dev/null && err_exit 'set +A with associative array should be an error'
|
|
unset bam foo
|
|
foo=0
|
|
typeset -A bam
|
|
unset bam[foo]
|
|
bam[foo]=value
|
|
[[ $bam == value ]] && err_exit 'unset associative array element error'
|
|
: only first element of an array can be exported
|
|
unset bam
|
|
print 'print ${var[0]} ${var[1]}' > $tmp/script
|
|
chmod +x $tmp/script
|
|
[[ $($SHELL -c "var=(foo bar);export var;$tmp/script") == foo ]] || err_exit 'export array not exporting just first element'
|
|
|
|
unset foo
|
|
set --allexport
|
|
foo=one
|
|
foo[1]=two
|
|
foo[0]=three
|
|
[[ $foo == three ]] || err_exit '--allexport not working with arrays'
|
|
set --noallexport
|
|
unset foo
|
|
|
|
cat > $tmp/script <<- \!
|
|
typeset -A foo
|
|
print foo${foo[abc]}
|
|
!
|
|
[[ $($SHELL -c "typeset -A foo;$tmp/script") == foo ]] 2> /dev/null || err_exit 'empty associative arrays not being cleared correctly before scripts'
|
|
[[ $($SHELL -c "typeset -A foo;foo[abc]=abc;$tmp/script") == foo ]] 2> /dev/null || err_exit 'associative arrays not being cleared correctly before scripts'
|
|
unset foo
|
|
foo=(one two)
|
|
[[ ${foo[@]:1} == two ]] || err_exit '${foo[@]:1} == two'
|
|
[[ ! ${foo[@]:2} ]] || err_exit '${foo[@]:2} not null'
|
|
unset foo
|
|
foo=one
|
|
[[ ! ${foo[@]:1} ]] || err_exit '${foo[@]:1} not null'
|
|
function EMPTY
|
|
{
|
|
typeset i
|
|
typeset -n ARRAY=$1
|
|
for i in ${!ARRAY[@]}
|
|
do unset ARRAY[$i]
|
|
done
|
|
}
|
|
unset foo
|
|
typeset -A foo
|
|
foo[bar]=bam
|
|
foo[x]=y
|
|
EMPTY foo
|
|
[[ $(typeset | grep foo$) == *associative* ]] || err_exit 'array lost associative attribute'
|
|
[[ ! ${foo[@]} ]] || err_exit 'array not empty'
|
|
[[ ! ${!foo[@]} ]] || err_exit 'array names not empty'
|
|
unset foo
|
|
foo=bar
|
|
set -- "${foo[@]:1}"
|
|
(( $# == 0 )) || err_exit '${foo[@]:1} should not have any values'
|
|
unset bar
|
|
exp=4
|
|
: ${_foo[bar=4]}
|
|
(( bar == 4 )) || err_exit "subscript of unset variable not evaluated -- expected '4', got '$got'"
|
|
unset bar
|
|
: ${_foo[bar=$exp]}
|
|
(( bar == $exp )) || err_exit "subscript of unset variable not evaluated -- expected '$exp', got '$got'"
|
|
unset foo bar
|
|
foo[5]=4
|
|
bar[4]=3
|
|
bar[0]=foo
|
|
foo[0]=bam
|
|
foo[4]=5
|
|
[[ ${!foo[2+2]} == 'foo[4]' ]] || err_exit '${!var[sub]} should be var[sub]'
|
|
[[ ${bar[${foo[5]}]} == 3 ]] || err_exit 'array subscript cannot be an array instance'
|
|
[[ $bar[4] == 3 ]] || err_exit '$bar[x] != ${bar[x]} inside [[ ]]'
|
|
(( $bar[4] == 3 )) || err_exit '$bar[x] != ${bar[x]} inside (( ))'
|
|
[[ $bar[$foo[5]] == 3 ]] || err_exit '$bar[foo[x]] != ${bar[foo[x]]} inside [[ ]]'
|
|
(( $bar[$foo[5]] == 3 )) || err_exit '$bar[foo[x]] != ${bar[foo[x]]} inside (( ))'
|
|
x=$bar[4]
|
|
[[ $x == 4 ]] && err_exit '$bar[4] should not be an array in an assignment'
|
|
x=${bar[$foo[5]]}
|
|
(( $x == 3 )) || err_exit '${bar[$foo[sub]]} not working'
|
|
[[ $($SHELL <<- \++EOF+++
|
|
typeset -i test_variable=0
|
|
typeset -A test_array
|
|
test_array[1]=100
|
|
read test_array[2] <<-!
|
|
2
|
|
!
|
|
read test_array[3] <<-!
|
|
3
|
|
!
|
|
test_array[3]=4
|
|
print "val=${test_array[3]}"
|
|
++EOF+++
|
|
) == val=4 ]] 2> /dev/null || err_exit 'after reading array[j] and assign array[j] fails'
|
|
[[ $($SHELL <<- \+++EOF+++
|
|
pastebin=( typeset -a form)
|
|
pastebin.form+=( name="name" data="clueless" )
|
|
print -r -- ${pastebin.form[0].name}
|
|
+++EOF+++
|
|
) == name ]] 2> /dev/null || err_exit 'indexed array in compound variable not working'
|
|
unset foo bar
|
|
: ${foo[bar=2]}
|
|
[[ $bar == 2 ]] || err_exit 'subscript not evaluated for unset variable'
|
|
unset foo bar
|
|
bar=1
|
|
typeset -a foo=([1]=ok [2]=no)
|
|
[[ $foo[bar] == ok ]] || err_exit 'typeset -a not working for simple assignment'
|
|
unset foo
|
|
typeset -a foo=([1]=(x=ok) [2]=(x=no))
|
|
[[ $(typeset | grep 'foo$') == *index* ]] || err_exit 'typeset -a not creating an indexed array'
|
|
foo+=([5]=good)
|
|
[[ $(typeset | grep 'foo$') == *index* ]] || err_exit 'append to indexed array not preserving array type'
|
|
unset foo
|
|
typeset -A foo=([1]=ok [2]=no)
|
|
[[ $foo[bar] == ok ]] && err_exit 'typeset -A not working for simple assignment'
|
|
unset foo
|
|
typeset -A foo=([1]=(x=ok) [2]=(x=no))
|
|
[[ ${foo[bar].x} == ok ]] && err_exit 'typeset -A not working for compound assignment'
|
|
[[ $($SHELL -c 'typeset -a foo;typeset | grep "foo$"' 2> /dev/null) == *index* ]] || err_exit 'typeset fails for indexed array with no elements'
|
|
xxxxx=(one)
|
|
[[ $(typeset | grep xxxxx$) == *'indexed array'* ]] || err_exit 'array of one element not an indexed array'
|
|
unset foo
|
|
foo[1]=(x=3 y=4)
|
|
{ [[ ${!foo[1].*} == 'foo[1].x foo[1].y' ]] ;} 2> /dev/null || err_exit '${!foo[sub].*} not expanding correctly'
|
|
unset x
|
|
x=( typeset -a foo=( [0]="a" [1]="b" [2]="c" ))
|
|
[[ ${@x.foo} == 'typeset -a'* ]] || err_exit 'x.foo is not an indexed array'
|
|
x=( typeset -A foo=( [0]="a" [1]="b" [2]="c" ))
|
|
[[ ${@x.foo} == 'typeset -A'* ]] || err_exit 'x.foo is not an associative array'
|
|
$SHELL -c $'x=(foo\n\tbar\nbam\n)' 2> /dev/null || err_exit 'compound array assignment with new-lines not working'
|
|
$SHELL -c $'x=(foo\n\tbar:\nbam\n)' 2> /dev/null || err_exit 'compound array assignment with labels not working'
|
|
$SHELL -c $'x=(foo\n\tdone\nbam\n)' 2> /dev/null || err_exit 'compound array assignment with reserved words not working'
|
|
[[ $($SHELL -c 'typeset -A A; print $(( A[foo].bar ))' 2> /dev/null) == 0 ]] || err_exit 'unset variable not evaluating to 0'
|
|
unset a
|
|
typeset -A a
|
|
a[a].z=1
|
|
a[z].z=2
|
|
unset a[a]
|
|
[[ ${!a[@]} == z ]] || err_exit '"unset a[a]" unsets entire array'
|
|
unset a
|
|
a=([x]=1 [y]=2 [z]=(foo=3 bar=4))
|
|
eval "b=$(printf "%B\n" a)"
|
|
eval "c=$(printf "%#B\n" a)"
|
|
[[ ${a[*]} == "${b[*]}" ]] || err_exit 'printf %B not preserving values for arrays'
|
|
[[ ${a[*]} == "${c[*]}" ]] || err_exit 'printf %#B not preserving values for arrays'
|
|
unset a
|
|
a=(zero one two three four)
|
|
a[6]=six
|
|
[[ ${a[-1]} == six ]] || err_exit 'a[-1] should be six'
|
|
[[ ${a[-3]} == four ]] || err_exit 'a[-3] should be four'
|
|
[[ ${a[-3..-1]} == 'four six' ]] || err_exit "a[-3,-1] should be 'four six'"
|
|
|
|
FILTER=(typeset scope)
|
|
FILTER[0].scope=include
|
|
FILTER[1].scope=exclude
|
|
[[ ${#FILTER[@]} == 2 ]] || err_exit "FILTER array should have two elements not ${#FILTER[@]}"
|
|
|
|
unset x
|
|
function x.get
|
|
{
|
|
print sub=${.sh.subscript}
|
|
}
|
|
x[2]=
|
|
z=$(: ${x[1]} )
|
|
[[ $z == sub=1 ]] || err_exit 'get function not invoked for index array'
|
|
|
|
unset x
|
|
typeset -A x
|
|
function x.get
|
|
{
|
|
print sub=${.sh.subscript}
|
|
}
|
|
x[2]=
|
|
z=$(: ${x[1]} )
|
|
[[ $z == sub=1 ]] || err_exit 'get function not invoked for associative array'
|
|
|
|
unset y
|
|
i=1
|
|
a=(11 22)
|
|
typeset -m y=a[i]
|
|
[[ $y == 22 ]] || err_exit 'typeset -m for index array not working'
|
|
[[ ${a[i]} || ${a[0]} != 11 ]] && err_exit 'typeset -m for index array not deleting element'
|
|
|
|
unset y
|
|
a=([0]=11 [1]=22)
|
|
typeset -m y=a[$i]
|
|
[[ $y == 22 ]] || err_exit 'typeset -m for associative array not working'
|
|
[[ ${a[$i]} || ${a[0]} != 11 ]] && err_exit 'typeset -m for associative array not deleting element'
|
|
unset x a j
|
|
|
|
typeset -a a=( [0]="aa" [1]="bb" [2]="cc" )
|
|
typeset -m 'j=a[0]'
|
|
typeset -m 'a[0]=a[1]'
|
|
typeset -m 'a[1]=j'
|
|
[[ ${a[@]} == 'bb aa cc' ]] || err_exit 'moving index array elements not working'
|
|
unset a j
|
|
|
|
typeset -A a=( [0]="aa" [1]="bb" [2]="cc" )
|
|
typeset -m 'j=a[0]'
|
|
typeset -m 'a[0]=a[1]'
|
|
typeset -m 'a[1]=j'
|
|
[[ ${a[@]} == 'bb aa cc' ]] || err_exit 'moving associative array elements not working'
|
|
unset a j
|
|
|
|
z=(a b c)
|
|
unset x
|
|
typeset -m x[1]=z
|
|
[[ ${x[1][@]} == 'a b c' ]] || err_exit 'moving indexed array to index array element not working'
|
|
|
|
unset x z
|
|
z=([0]=a [1]=b [2]=c)
|
|
typeset -m x[1]=z
|
|
[[ ${x[1][@]} == 'a b c' ]] || err_exit 'moving associative array to index array element not working'
|
|
|
|
{
|
|
typeset -a arr=(
|
|
float
|
|
)
|
|
} 2> /dev/null
|
|
[[ ${arr[0]} == float ]] || err_exit 'typeset -a should not expand alias for float'
|
|
unset arr
|
|
|
|
{
|
|
typeset -r -a arr=(
|
|
float
|
|
)
|
|
} 2> /dev/null
|
|
[[ ${arr[0]} == float ]] || err_exit 'typeset -r -a should not expand alias for float'
|
|
{
|
|
typeset -a arr2=(
|
|
typeset +r
|
|
)
|
|
} 2> /dev/null
|
|
[[ ${arr2[0]} == typeset ]] || err_exit 'typeset -a should not process declarations'
|
|
unset arr2
|
|
|
|
$SHELL 2> /dev/null -c $'typeset -a arr=(\nfor)' || err_exit 'typeset -a should allow reserved words as first argument'
|
|
|
|
$SHELL 2> /dev/null -c $'typeset -r -a arr=(\nfor)' || err_exit 'typeset -r -a should allow reserved words as first argument'
|
|
|
|
typeset arr2[6]
|
|
[[ ${#arr2[@]} == 0 ]] || err_exit 'declartion "typeset array[6]" should not show any elements'
|
|
|
|
arr2[1]=def
|
|
[[ ${arr2[1]} == def ]] || err_exit 'declaration "typeset array[6]" causes arrays causes wrong side effects'
|
|
|
|
unset foo
|
|
typeset foo[7]
|
|
[[ ${#foo[@]} == 0 ]] || err_exit 'typeset foo[7] should not have one element'
|
|
|
|
a=123 $SHELL 2> /dev/null -c 'integer a[5]=3 a[2]=4; unset a;x=0; ((a[++x]++));:' || err_exit 'unsetting array variable leaves side effect'
|
|
|
|
unset foo
|
|
foo=(aa bb cc)
|
|
foo=( ${foo[@]:1} )
|
|
[[ ${foo[@]} == 'bb cc' ]] || err_exit "indexed array assignment using parts of array for values gives wrong result of ${foo[@]}"
|
|
|
|
unset foo
|
|
foo=([xx]=aa [yy]=bb [zz]=cc)
|
|
foo=( ${foo[yy]} ${foo[zz]} )
|
|
[[ ${foo[@]} == 'bb cc' ]] || err_exit "associative array assignment using parts of array for values gives wrong result of ${foo[@]}"
|
|
|
|
unset foo
|
|
typeset -a foo=(abc=1 def=2)
|
|
[[ ${foo[1]} == def=2 ]] || err_exit "index array with elements containing = not working"
|
|
|
|
unset foo
|
|
typeset -a foo=( a b )
|
|
typeset -p foo[10]
|
|
[[ ${!foo[@]} == '0 1' ]] || err_exit 'typeset -p foo[10] has side effect'
|
|
|
|
unset foo
|
|
exp='typeset -a foo=((11 22) (66) )'
|
|
x=$(
|
|
typeset -a foo=( ( 11 22 ) ( 44 55 ) )
|
|
foo[1]=(66)
|
|
typeset -p foo
|
|
) 2> /dev/null
|
|
[[ $x == "$exp" ]] || err_exit 'setting element 1 to index fooay failed'
|
|
unset foo
|
|
exp='typeset -a foo=((11 22) (x=3))'
|
|
x=$(
|
|
typeset -a foo=( ( 11 22 ) ( 44 55 ) )
|
|
foo[1]=(x=3)
|
|
typeset -p foo
|
|
) 2> /dev/null
|
|
[[ $x == "$exp" ]] || err_exit 'setting element 1 of array to compound variable failed'
|
|
|
|
#test for cloning a very large index array - can core dump
|
|
(
|
|
trap 'x=$?;exit $(( $x!=0 ))' EXIT
|
|
$SHELL <<- \EOF
|
|
(
|
|
print '('
|
|
integer i
|
|
for ((i=0 ; i < 16384 ; i++ )) ; do
|
|
printf '\tinteger var%i=%i\n' i i
|
|
done
|
|
printf 'typeset -a ar=(\n'
|
|
for ((i=0 ; i < 16384 ; i++ )) ; do
|
|
printf '\t[%d]=%d\n' i i
|
|
done
|
|
print ')'
|
|
print ')'
|
|
) | read -C hugecpv
|
|
compound hugecpv2=hugecpv
|
|
v=$(typeset -p hugecpv)
|
|
[[ ${v/hugecpv/hugecpv2} == "$(typeset -p hugecpv2)" ]]
|
|
EOF
|
|
) 2> /dev/null || err_exit 'copying a large array fails'
|
|
|
|
unset foo
|
|
typeset -a foo
|
|
foo+=(bar)
|
|
[[ ${foo[0]} == bar ]] || 'appending to empty array not working'
|
|
|
|
unset isnull
|
|
typeset -A isnull
|
|
isnull[mdapp]=Y
|
|
: ${isnull[@]}
|
|
isnull[mdapp]=N
|
|
[[ ${isnull[*]} != *N* ]] && err_exit 'bug after ${arr[@]} with one element associative array'
|
|
|
|
unset arr2
|
|
arr2=()
|
|
typeset -A arr2
|
|
unset arr2
|
|
[[ $(typeset -p arr2) ]] && err_exit 'unset associative array of compound variables not working'
|
|
|
|
arr3=(x=3)
|
|
typeset -A arr3
|
|
[[ $(typeset -p arr3) == 'typeset -A arr3=()' ]] || err_exit 'typeset -A does not first unset compound variable.'
|
|
|
|
arr4=(x=3)
|
|
typeset -a arr4
|
|
[[ $(typeset -p arr4) == 'typeset -a arr4' ]] || err_exit 'typeset -a does not first unset compound variable.'
|
|
|
|
alias foo=bar
|
|
arr5=(foo bar)
|
|
[[ $(typeset -p arr5) == 'typeset -a arr5=(foo bar)' ]] || err_exit 'typeset expanding non-declaration aliases'
|
|
|
|
typeset -A Foo
|
|
Foo=( [a]=AA;[b]=BB)
|
|
[[ ${Foo[a]} == AA ]] || err_exit 'Fooa[a] is {Foo[a]} not AA'
|
|
|
|
exit $((Errors<125?Errors:125))
|