mirror of
git://git.code.sf.net/p/zsh/code
synced 2024-10-01 16:31:53 +02:00
5aa648a5f2
"setopt localoptions" is to use a function for the final test (since it destroys all the variables in the environment). This allows us to directly test that the environment was properly restored after the function call, and ensures that the caller (ZTST_execchunk, which directly exec'ed the test code) still has all the vars that it expects in the environment (such as ZTST_verbose, options, and ZTST_mainopts).
369 lines
7.1 KiB
Plaintext
369 lines
7.1 KiB
Plaintext
# There are certain usages of typeset and its synonyms that it is not
|
||
# possible to test here, because they must appear at the top level and
|
||
# everything that follows is processed by an "eval" within a function.
|
||
|
||
# Equivalences:
|
||
# declare typeset
|
||
# export typeset -x and typeset -x implies -g
|
||
# float typeset -E
|
||
# functions typeset -f
|
||
# integer typeset -i
|
||
# local typeset +g -m approximately
|
||
# readonly typeset -r
|
||
|
||
# Tested elsewhere:
|
||
# Equivalence of autoload and typeset -fu A05execution
|
||
# Associative array creation & assignment D04parameter, D06subscript
|
||
# Effects of GLOBAL_EXPORT E01options
|
||
# Function tracing (typeset -ft) E02xtrace
|
||
|
||
# Not yet tested:
|
||
# Case conversion (-l, -u)
|
||
# Assorted illegal flag combinations
|
||
|
||
%prep
|
||
|
||
setopt noglob
|
||
|
||
scalar=scalar
|
||
array=(a r r a y)
|
||
|
||
scope00() {
|
||
typeset scalar
|
||
scalar=local
|
||
typeset -a array
|
||
array=(l o c a l)
|
||
print $scalar $array
|
||
}
|
||
scope01() {
|
||
local scalar
|
||
scalar=local
|
||
local -a array
|
||
array=(l o c a l)
|
||
print $scalar $array
|
||
}
|
||
scope02() {
|
||
declare scalar
|
||
scalar=local
|
||
declare -a array
|
||
array=(l o c a l)
|
||
print $scalar $array
|
||
}
|
||
scope10() {
|
||
export outer=outer
|
||
/bin/sh -fc 'echo $outer'
|
||
}
|
||
scope11() {
|
||
typeset -x outer=outer
|
||
/bin/sh -fc 'echo $outer'
|
||
}
|
||
scope12() {
|
||
local -x outer=inner
|
||
/bin/sh -fc 'echo $outer'
|
||
}
|
||
scope13() {
|
||
local -xT OUTER outer
|
||
outer=(i n n e r)
|
||
/bin/sh -fc 'echo $OUTER'
|
||
}
|
||
|
||
# Bug? `typeset -h' complains that ! # $ * - ? @ are not identifiers.
|
||
stress00() {
|
||
typeset -h +g -m [[:alpha:]_]*
|
||
unset -m [[:alpha:]_]*
|
||
typeset +m [[:alpha:]_]*
|
||
}
|
||
|
||
%test
|
||
|
||
typeset +m scalar array
|
||
0:Report types of parameters with typeset +m
|
||
>scalar
|
||
>array array
|
||
|
||
scope00
|
||
print $scalar $array
|
||
0:Simple local declarations
|
||
>local l o c a l
|
||
>scalar a r r a y
|
||
|
||
scope01
|
||
print $scalar $array
|
||
0:Equivalence of local and typeset in functions
|
||
>local l o c a l
|
||
>scalar a r r a y
|
||
|
||
scope02
|
||
print $scalar $array
|
||
0:Basic equivalence of declare and typeset
|
||
>local l o c a l
|
||
>scalar a r r a y
|
||
|
||
declare +m scalar
|
||
0:declare previously lacked -m/+m options
|
||
>scalar
|
||
|
||
scope10
|
||
print $outer
|
||
0:Global export
|
||
>outer
|
||
>outer
|
||
|
||
scope11
|
||
print $outer
|
||
0:Equivalence of export and typeset -x
|
||
>outer
|
||
>outer
|
||
|
||
scope12
|
||
print $outer
|
||
0:Local export
|
||
>inner
|
||
>outer
|
||
|
||
float f=3.14159
|
||
typeset +m f
|
||
float -E3 f
|
||
print $f
|
||
float -F f
|
||
print $f
|
||
0:Floating point, adding a precision, and fixed point
|
||
>float local f
|
||
>3.14e+00
|
||
>3.142
|
||
|
||
integer i=3.141
|
||
typeset +m i
|
||
integer -i2 i
|
||
print $i
|
||
0:Integer and changing the base
|
||
>integer local i
|
||
>2#11
|
||
|
||
float -E3 f=3.141
|
||
typeset +m f
|
||
integer -i2 f
|
||
typeset +m f
|
||
print $f
|
||
0:Conversion of floating point to integer
|
||
>float local f
|
||
>integer 2 local f
|
||
>2#11
|
||
|
||
typeset -f
|
||
0q:Equivalence of functions and typeset -f
|
||
>$(functions)
|
||
|
||
readonly r=success
|
||
print $r
|
||
r=failure
|
||
1:Readonly declaration
|
||
>success
|
||
?(eval):3: read-only variable: r
|
||
|
||
typeset r=success
|
||
readonly r
|
||
print $r
|
||
r=failure
|
||
1:Convert to readonly
|
||
>success
|
||
?(eval):4: read-only variable: r
|
||
|
||
typeset -gU array
|
||
print $array
|
||
0:Uniquified arrays and non-local scope
|
||
>a r y
|
||
|
||
typeset -T SCALAR=l:o:c:a:l array
|
||
print $array
|
||
typeset -U SCALAR
|
||
print $SCALAR $array
|
||
0:Tied parameters and uniquified colon-arrays
|
||
>l o c a l
|
||
>l:o:c:a l o c a
|
||
|
||
typeset -T SCALAR=$'l\x83o\x83c\x83a\x83l' array $'\x83'
|
||
print $array
|
||
typeset -U SCALAR
|
||
print $SCALAR $array
|
||
0:Tied parameters and uniquified arrays with meta-character as separator
|
||
>l o c a l
|
||
>l<>o<EFBFBD>c<EFBFBD>a l o c a
|
||
|
||
typeset -T SCALAR=$'l\000o\000c\000a\000l' array $'\000'
|
||
typeset -U SCALAR
|
||
print $array
|
||
[[ $SCALAR == $'l\000o\000c\000a' ]]
|
||
0:Tied parameters and uniquified arrays with NUL-character as separator
|
||
>l o c a
|
||
|
||
typeset -T SCALAR array
|
||
typeset +T SCALAR
|
||
1:Untying is prohibited
|
||
?(eval):typeset:2: use unset to remove tied variables
|
||
|
||
OUTER=outer
|
||
scope13
|
||
print $OUTER
|
||
0:Export of tied parameters
|
||
>i:n:n:e:r
|
||
>outer
|
||
|
||
typeset -TU MORESTUFF=here-we-go-go-again morestuff '-'
|
||
print -l $morestuff
|
||
0:Tied arrays with separator specified
|
||
>here
|
||
>we
|
||
>go
|
||
>again
|
||
|
||
typeset -T THIS will not work
|
||
1:Tied array syntax
|
||
?(eval):typeset:1: -T requires names of scalar and array
|
||
|
||
local array[2]=x
|
||
1:Illegal local array element assignment
|
||
?(eval):local:1: array[2]: can't create local array elements
|
||
|
||
local -a array
|
||
typeset array[1]=a array[2]=b array[3]=c
|
||
print $array
|
||
0:Legal local array element assignment
|
||
>a b c
|
||
|
||
local -A assoc
|
||
local b=1 ;: to stomp assoc[1] if assoc[b] is broken
|
||
typeset assoc[1]=a assoc[b]=2 assoc[3]=c
|
||
print $assoc[1] $assoc[b] $assoc[3]
|
||
0:Legal local associative array element assignment
|
||
>a 2 c
|
||
|
||
local scalar scalar[1]=a scalar[2]=b scalar[3]=c
|
||
print $scalar
|
||
0:Local scalar subscript assignment
|
||
>abc
|
||
|
||
typeset -L 10 fools
|
||
for fools in " once" "twice" " thrice" " oops too long here"; do
|
||
print "'$fools'"
|
||
done
|
||
0:Left justification of scalars
|
||
>'once '
|
||
>'twice '
|
||
>'thrice '
|
||
>'oops too l'
|
||
|
||
typeset -L 10 -F 3 foolf
|
||
for foolf in 1.3 4.6 -2.987 -4.91031; do
|
||
print "'$foolf'"
|
||
done
|
||
0:Left justification of floating point
|
||
>'1.300 '
|
||
>'4.600 '
|
||
>'-2.987 '
|
||
>'-4.910 '
|
||
|
||
typeset -L 10 -Z foolzs
|
||
for foolzs in 001.3 04.6 -2.987 -04.91231; do
|
||
print "'$foolzs'"
|
||
done
|
||
0:Left justification of scalars with zero suppression
|
||
>'1.3 '
|
||
>'4.6 '
|
||
>'-2.987 '
|
||
>'-04.91231 '
|
||
|
||
typeset -R 10 foors
|
||
for foors in short longer even-longer; do
|
||
print "'$foors'"
|
||
done
|
||
0:Right justification of scalars
|
||
>' short'
|
||
>' longer'
|
||
>'ven-longer'
|
||
|
||
typeset -Z 10 foozs
|
||
for foozs in 42 -42 " 43" " -43"; do
|
||
print "'$foozs'"
|
||
done
|
||
0:Right justification of scalars with zeroes
|
||
>'0000000042'
|
||
>' -42'
|
||
>' 000000043'
|
||
>' -43'
|
||
|
||
integer -Z 10 foozi
|
||
for foozi in 42 -42 " 43" " -43"; do
|
||
print "'$foozi'"
|
||
done
|
||
0:Right justification of integers with zero, no initial base
|
||
>'0000000042'
|
||
>'-000000042'
|
||
>'0000000043'
|
||
>'-000000043'
|
||
# In case you hadn't twigged, the spaces are absorbed in the initial
|
||
# math evaluation, so don't get through.
|
||
|
||
unsetopt cbases
|
||
integer -Z 10 -i 16 foozi16
|
||
for foozi16 in 42 -42 " 43" " -43"; do
|
||
print "'$foozi16'"
|
||
done
|
||
0:Right justification of integers with zero, base 16, C_BASES off
|
||
>'16#000002A'
|
||
>'-16#00002A'
|
||
>'16#000002B'
|
||
>'-16#00002B'
|
||
|
||
setopt cbases
|
||
integer -Z 10 -i 16 foozi16c
|
||
for foozi16c in 42 -42 " 43" " -43"; do
|
||
print "'$foozi16c'"
|
||
done
|
||
0:Right justification of integers with zero, base 16, C_BASES on
|
||
>'0x0000002A'
|
||
>'-0x000002A'
|
||
>'0x0000002B'
|
||
>'-0x000002B'
|
||
|
||
typeset -F 3 -Z 10 foozf
|
||
for foozf in 3.14159 -3.14159 4 -4; do
|
||
print "'$foozf'"
|
||
done
|
||
0:Right justification of fixed point numbers with zero
|
||
>'000003.142'
|
||
>'-00003.142'
|
||
>'000004.000'
|
||
>'-00004.000'
|
||
|
||
stress00
|
||
print $scalar $array
|
||
0q:Stress test: all parameters are local and unset, using -m
|
||
>scalar a r y
|
||
|
||
local parentenv=preserved
|
||
fn() {
|
||
# The first declare works around the "not an identifier" bug with -h
|
||
declare \! \# \$ \* - \? @ 0
|
||
typeset -h +g -m \*
|
||
unset -m \*
|
||
integer i=9
|
||
float -H f=9
|
||
declare -t scalar
|
||
declare -H -a array
|
||
typeset
|
||
typeset +
|
||
}
|
||
fn
|
||
echo $parentenv
|
||
0:Parameter hiding and tagging, printing types and values
|
||
>array local array
|
||
>float local f
|
||
>integer local i=9
|
||
>local tagged scalar=''
|
||
>array local array
|
||
>float local f
|
||
>integer local i
|
||
>local tagged scalar
|
||
>preserved
|