path: root/Test/B02typeset.ztst

# 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 -xg
#  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:
#  Assorted illegal flag combinations

# For a few tests, we include a
#    typeset -p param
#    typeset -m param
#    typeset +m param
# to test the proper output of typeset for a number of different types
# of variables. Note that we can't use a dedicated function to factorize
# that code, as that would affect the scoping.

%prep
  ## Do not remove the next line, it's used by V10private.ztst
  # test_zsh_param_private

  mkdir typeset.tmp && cd typeset.tmp

  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
    typeset -p scalar array
    typeset -m scalar array
    typeset +m scalar array
  }
  scope01() {
    local scalar
    scalar=local
    local -a array
    array=(l o c a l)
    print $scalar $array
    typeset -p scalar array
    typeset -m scalar array
    typeset +m scalar array
  }
  scope02() {
    declare scalar
    scalar=local
    declare -a array
    array=(l o c a l)
    print $scalar $array
    typeset -p scalar array
    typeset -m scalar array
    typeset +m scalar array
  }
  scope10() {
    export outer=outer
    /bin/sh -fc 'echo $outer'
    typeset -p outer
    typeset -m outer
    typeset +m 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'
    typeset -p OUTER outer
    typeset -m OUTER outer
    typeset +m OUTER outer
  }

  # Bug?  `typeset -h' complains that ! # $ * - ? @ are not identifiers.
  stress00() {
    typeset -h +g -m [[:alpha:]_]*
    unset -m [[:alpha:]_]*
    typeset +m [[:alpha:]_]*
  }

%test

 typeset -p scalar array
 typeset -m scalar array
 typeset +m scalar array
0:Report types for global variables
>typeset -g scalar=scalar
>typeset -g -a array=( a r r a y )
>scalar=scalar
>array=( a r r a y )
>scalar
>array array

 scope00
 print $scalar $array
0:Simple local declarations
>local l o c a l
>typeset scalar=local
>typeset -a array=( l o c a l )
>scalar=local
>array=( l o c a l )
>local scalar
>array local array
>scalar a r r a y

 scope01
 print $scalar $array
0:Equivalence of local and typeset in functions
>local l o c a l
>typeset scalar=local
>typeset -a array=( l o c a l )
>scalar=local
>array=( l o c a l )
>local scalar
>array local array
>scalar a r r a y

 scope02
 print $scalar $array
0:Basic equivalence of declare and typeset
>local l o c a l
>typeset scalar=local
>typeset -a array=( l o c a l )
>scalar=local
>array=( l o c a l )
>local scalar
>array local array
>scalar a r r a y

 declare +m scalar
0:declare previously lacked -m/+m options
>scalar

 scope10
 print $outer
0:Global export
>outer
>export outer=outer
>outer=outer
>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
 typeset -p f
 typeset -m f
 typeset +m f
0:Floating point, adding a precision, and fixed point
>float local f
>3.14e+00
>3.142
>typeset -F f=3.142
>f=3.142
>float local f

 integer i=3.141
 typeset +m i
 integer -i2 i
 print $i
 typeset -p i
 typeset -m i
 typeset +m i
0:Integer and changing the base
>integer local i
>2#11
>typeset -i2 i=3
>i=3
>integer 2 local i

 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
 typeset -p array
 typeset -m array
 typeset +m array
0:Uniquified arrays and non-local scope
>a r y
>typeset -g -aU array=( a r y )
>array=( a r y )
>array unique array

 typeset -T SCALAR=l:o:c:a:l array
 print $array
 typeset -U SCALAR
 print $SCALAR $array
 typeset -p SCALAR array
 typeset -m SCALAR array
 typeset +m SCALAR array
 print ${(t)SCALAR} ${(t)array}
0:Tied parameters and uniquified colon-arrays
>l o c a l
>l:o:c:a l o c a
>typeset -UT SCALAR array=( l o c a )
>typeset -aT SCALAR array=( l o c a )
>SCALAR=l:o:c:a
>array=( l o c a )
>local unique tied array SCALAR
>array local tied SCALAR array
>scalar-local-tied-unique array-local-tied

 (setopt NO_multibyte cbases
 LC_ALL=C 2>/dev/null
 typeset -T SCALAR=$'l\x83o\x83c\x83a\x83l' array $'\x83'
 print $array
 typeset -U SCALAR
 for (( i = 1; i <= ${#SCALAR}; i++ )); do
   char=$SCALAR[i]
   print $(( [#16] #char ))
 done
 print $array)
0:Tied parameters and uniquified arrays with meta-character as separator
>l o c a l
>0x6C
>0x83
>0x6F
>0x83
>0x63
>0x83
>0x61
>l o c a

 typeset -T SCALAR=$'l\000o\000c\000a\000l' array $'\000'
 typeset -U SCALAR
 print $array
 typeset -p SCALAR array
 typeset -m SCALAR array
 typeset +m SCALAR array
 [[ $SCALAR == $'l\000o\000c\000a' ]]
0:Tied parameters and uniquified arrays with NUL-character as separator
>l o c a
>typeset -UT SCALAR array=( l o c a ) ''
>typeset -aT SCALAR array=( l o c a ) ''
>SCALAR=$'l\C-@o\C-@c\C-@a'
>array=( l o c a )
>local unique tied array SCALAR
>array local tied SCALAR array

 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
>typeset -xT OUTER outer=( i n n e r )
>typeset -aT OUTER outer=( i n n e r )
>OUTER=i:n:n:e:r
>outer=( i n n e r )
>local exported tied outer OUTER
>array local tied OUTER outer
>outer

 typeset -TU MORESTUFF=here-we-go-go-again morestuff '-'
 print -l $morestuff
 typeset -p MORESTUFF morestuff
 typeset -m MORESTUFF morestuff
 typeset +m MORESTUFF morestuff
0:Tied arrays with separator specified
>here
>we
>go
>again
>typeset -UT MORESTUFF morestuff=( here we go again ) -
>typeset -aUT MORESTUFF morestuff=( here we go again ) -
>MORESTUFF=here-we-go-again
>morestuff=( here we go again )
>local unique tied morestuff MORESTUFF
>array local unique tied MORESTUFF morestuff

 typeset -T THIS will not work
1:Tied array syntax
?(eval):typeset:1: too many arguments for -T

 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]
 typeset -p assoc
 typeset -m assoc
 typeset +m assoc
0:Legal local associative array element assignment
>a 2 c
>typeset -A assoc=( [1]=a [3]=c [b]=2 )
>assoc=( [1]=a [3]=c [b]=2 )
>association local assoc

 local scalar scalar[1]=a scalar[2]=b scalar[3]=c
 print $scalar
 typeset -p scalar
 typeset -m scalar
 typeset +m scalar
0:Local scalar subscript assignment
>abc
>typeset scalar=abc
>scalar=abc
>local scalar

 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
 typeset -p foolf
 typeset -m foolf
 typeset +m foolf
0:Left justification of floating point
>'1.300     '
>'4.600     '
>'-2.987    '
>'-4.910    '
>typeset -FL10 foolf=-4.910
>foolf=-4.910
>float local left justified 10 foolf

 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
 typeset -p foors
 typeset -m foors
 typeset +m foors
0:Right justification of scalars
>'     short'
>'    longer'
>'ven-longer'
>typeset -R10 foors=even-longer
>foors=even-longer
>local right justified 10 foors

 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'

 setopt cbases
 integer -Z 10 -i 16 foozi16c
 for foozi16c in 0x1234 -0x1234; do
   for (( i = 1; i <= 5; i++ )); do
       print "'${foozi16c[i,11-i]}'"
   done
   print "'${foozi16c[-2]}'"
 done
0:Extracting substrings from padded integers
>'0x00001234'
>'x0000123'
>'000012'
>'0001'
>'00'
>'3'
>'-0x0001234'
>'0x000123'
>'x00012'
>'0001'
>'00'
>'3'

 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() {
  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

 export ENVFOO=bar
 print ENVFOO in environment
 env | grep '^ENVFOO'
 print Changing ENVFOO
 ENVFOO="not bar any more"
 env | grep '^ENVFOO'
 unset ENVFOO
 print ENVFOO no longer in environment
 env | grep '^ENVFOO'
1:Adding and removing values to and from the environment
>ENVFOO in environment
>ENVFOO=bar
>Changing ENVFOO
>ENVFOO=not bar any more
>ENVFOO no longer in environment

 (export FOOENV=BAR
 env | grep '^FOOENV'
 print Exec
 exec $ZTST_testdir/../Src/zsh -fc '
 print Unset
 unset FOOENV
 env | grep "^FOOENV"')
1:Can unset environment variables after exec
>FOOENV=BAR
>Exec
>Unset

 local case1=upper
 typeset -u case1
 print $case1
 upper="VALUE OF \$UPPER"
 print ${(P)case1}
 typeset -p case1
 typeset -m case1
 typeset +m case1
0:Upper case conversion, does not apply to values used internally
>UPPER
>VALUE OF $UPPER
>typeset -u case1=upper
>case1=upper
>local uppercase case1

 local case2=LOWER
 typeset -l case2
 print $case2
 LOWER="value of \$lower"
 print ${(P)case2}
 typeset -p case2
 typeset -m case2
 typeset +m case2
0:Lower case conversion, does not apply to values used internally
>lower
>value of $lower
>typeset -l case2=LOWER
>case2=LOWER
>local lowercase case2

 typeset -a array
 array=(foo bar)
 fn() { typeset -p array nonexistent; }
 fn
1:typeset -p shouldn't create scoped values
>typeset -g -a array=( foo bar )
?fn:typeset: no such variable: nonexistent

 unsetopt typesetsilent
 silent1(){ typeset -g silence; }
 silent2(){ local silence; silent1; }
 silent2
0:typeset -g should be silent even without TYPESET_SILENT

 typeset -T TIED_SCALAR tied_array
 TIED_SCALAR=foo:bar
 print $tied_array
 typeset -T TIED_SCALAR=goo:car tied_array
 print $tied_array
 typeset -T TIED_SCALAR tied_array=(poo par)
 print $TIED_SCALAR
0:retying arrays to same array works
>foo bar
>goo car
>poo:par

 (
   setopt POSIXBUILTINS
   readonly pbro
   print ${+pbro} >&2
   (typeset -g pbro=3)
   (pbro=4)
   readonly -p pbro >&2   # shows up as "readonly" although unset
   typeset -gr pbro       # idempotent (no error)...
   print ${+pbro} >&2     # ...so still readonly...
   typeset -g +r pbro     # ...can't turn it off
 )
1:readonly with POSIX_BUILTINS
?0
?(eval):5: read-only variable: pbro
?(eval):6: read-only variable: pbro
?readonly pbro
?0
?(eval):10: read-only variable: pbro

  readonly foo=bar novalue
  readonly -p
0:readonly -p output (no readonly specials)
>typeset -r foo=bar
>typeset -r novalue=''

  local -a a1 a2
  local -r r1=yes r2=no
  a1=(one two) a2=(three four)
  readonly a1
  typeset -pm 'a[12]'
  typeset -pm 'r[12]'
0:readonly -p output
>typeset -ar a1=( one two )
>typeset -a a2=( three four )
>typeset -r r1=yes
>typeset -r r2=no

  one=hidden two=hidden three=hidden four=hidden five=hidden
  fn() {
     local bleugh="four=vier"
     typeset -R10 one=eins two=(zwei dio) three $bleugh five=(cinq cinque)
     three=drei
     print -l $one $two $three $four $five
  }
  fn
  print -l $one $two $three $four $five
0:typeset reserved word interface: basic
>      eins
>zwei
>dio
>      drei
>      vier
>cinq
>cinque
>hidden
>hidden
>hidden
>hidden
>hidden

  (
  setopt glob
  mkdir -p arrayglob
  touch arrayglob/{one,two,three,four,five,six,seven}
  fn() {
    typeset array=(arrayglob/[tf]*)
    print -l ${array:t}
    #
    typeset {first,second,third}=the_same_value array=(
    extends
    over
    multiple
    lines
    )
    print -l $first $second $third "$array"
    #
    integer i=$(echo 1 + 2 + 3 + 4)
    print $i
    #
    # only noted by accident this was broken..
    # we need to turn off special recognition
    # of assignments within assignments...
    typeset careful=( i=1 j=2 k=3 )
    print -l $careful
  }
  fn
  )
0:typeset reserved word, more complicated cases
>five
>four
>three
>two
>the_same_value
>the_same_value
>the_same_value
>extends over multiple lines
>10
>i=1
>j=2
>k=3

  (
     # reserved word is recognised at parsing.
     # yes, this is documented.
     # anyway, that means we need to
     # re-eval the function...
     fn='
     fn() {
        typeset foo=`echo one word=two`
        print $foo
        print $word
     }
     '
     print reserved
     eval $fn; fn
     print builtin
     disable -r typeset
     eval $fn; fn
     enable -r typeset
     disable typeset
     print reserved
     eval $fn; fn
  )
0:reserved word and builtin interfaces
>reserved
>one word=two
>
>builtin
>one
>two
>reserved
>one word=two
>

  fn() {
    emulate -L zsh
    setopt typeset_silent
    local k
    typeset -A hash=(k1 v1 k2 v2)
    typeset foo=word array=(more than one word)
    for k in ${(ko)hash}; do
      print $k $hash[$k]
    done
    print -l $foo $array
    typeset -A hash
    typeset foo array
    for k in ${(ko)hash}; do
      print $k $hash[$k]
    done
    print -l $foo $array
    typeset hash=(k3 v3 k4 v4) array=(odd number here)
    for k in ${(ko)hash}; do
      print $k $hash[$k]
    done
    print -l $array
  }
  fn
0:typeset preserves existing variable types
>k1 v1
>k2 v2
>word
>more
>than
>one
>word
>k1 v1
>k2 v2
>word
>more
>than
>one
>word
>k3 v3
>k4 v4
>odd
>number
>here

  fn() { typeset foo bar thing=this stuff=(that other) more=woevva; }
  which -x2 fn
  fn2() { typeset assignfirst=(why not); }
  which -x2 fn2
0:text output from typeset
>fn () {
>  typeset foo bar thing=this stuff=(that other) more=woevva 
>}
>fn2 () {
>  typeset assignfirst=(why not) 
>}

  fn() {
    typeset array=()
    print ${(t)array} ${#array}
    typeset gnothergarray=() gnothergarray[1]=yes gnothergarray[2]=no
    print -l ${(t)gnothergarray} $gnothergarray
  }
  fn
0:can set empty array
>array-local 0
>array-local
>yes
>no

  array=(nothing to see here)
  fn() {
    typeset array=(one two three four five)
    typeset array[2,4]=(umm er)
    print ${#array} $array
    typeset array[2,3]=()
    print ${#array} $array
  }
  fn
  print ${#array} $array
0:can update array slices in typeset
>4 one umm er five
>2 one five
>4 nothing to see here

  array=(no really nothing here)
  fn() {
    typeset array=() array[2]=two array[4]=four
    typeset -p array
    typeset array=() array[3]=three array[1]=one
    typeset -p array
  }
  fn
  print $array
0:setting empty array in typeset
>typeset -a array=( '' two '' four )
>typeset -a array=( one '' three )
>no really nothing here

  readonly isreadonly=yes
  typeset isreadonly=still
1:typeset returns status 1 if setting readonly variable
?(eval):2: read-only variable: isreadonly

  if (( UID )); then
    UID=$((UID+1)) date; echo "Status is printed, $?"
  else
    ZTST_skip="cannot test setuid error when tests run as superuser"
  fi
0:when cannot change UID, the command isn't run
# 'date' did not run.
>Status is printed, 1
*?*: failed to change user ID: *

 typeset -A keyvalhash=([one]=eins [two]=zwei)
 keyvalhash+=([three]=drei)
 for key in ${(ok)keyvalhash}; do
   print $key $keyvalhash[$key]
 done
0:[key]=val for hashes
>one eins
>three drei
>two zwei

  local keyvalarray=([1]=one [3]=three)
  print -l "${keyvalarray[@]}"
  keyvalarray+=([2]=two)
  print -l "${keyvalarray[@]}"
  local keyvalarray=([1]=one [3]=three)
  print -l "${keyvalarray[@]}"
0:[key]=val for normal arrays
>one
>
>three
>one
>two
>three
>one
>
>three

 touch foo Xnot_globbedX
 inkey="another key" val="another value"
 typeset -A keyvalhash=([$(echo the key)]=$(echo the value)
                        [$inkey]=$val
	                [*]=?not_globbed?)
 for key in ${(ok)keyvalhash}; do
   print -l $key $keyvalhash[$key]
 done
 typeset -A keyvalhash=([$(echo the key)]=$(echo the value)
                        [$inkey]=$val
	                [*]=?not_globbed?)
 for key in ${(ok)keyvalhash}; do
   print -l $key $keyvalhash[$key]
 done
 typeset -p keyvalhash
0:Substitution in [key]=val syntax
>*
>?not_globbed?
>another key
>another value
>the key
>the value
>*
>?not_globbed?
>another key
>another value
>the key
>the value
>typeset -A keyvalhash=( ['*']='?not_globbed?' ['another key']='another value' ['the key']='the value' )

  local keyvalarray=(first [2]=second third [6]=sixth seventh [5]=fifth new_sixth)
  print -l "${keyvalarray[@]}"
0:mixed syntax [key]=val with normal arrays
>first
>second
>third
>
>fifth
>new_sixth
>seventh

  local -A keyvalhash=(1 one [2]=two 3 three)
1:Mixed syntax with [key]=val not allowed for hash.
?(eval):1: bad [key]=value syntax for associative array

  local -a myarray
  typeset -p1 myarray
  myarray=("&" sand '""' "" plugh)
  typeset -p1 myarray
0:typeset -p1 output for array
>typeset -a myarray=()
>typeset -a myarray=(
>  '&'
>  sand
>  '""'
>  ''
>  plugh
>)

  local -A myhash
  typeset -p1 myhash
  myhash=([one]=two [three]= [four]="[]")
  typeset -p1 myhash
0:typeset -p1 output for associative array
>typeset -A myhash=()
>typeset -A myhash=(
>  [four]='[]'
>  [one]=two
>  [three]=''
>)

 (export PATH MANPATH
 path=(/bin)
 MANPATH=/
 # read-only special params like zsh_eval_context are not output by typeset -p
 specials=(path PATH manpath MANPATH zsh_eval_context ZSH_EVAL_CONTEXT)
 typeset -p $specials
 typeset -m $specials
 typeset +m $specials
 for var ($specials) print $var: ${(Pt)var}
 )
0:typeset output for some special tied parameters
>typeset -g -aT PATH path=( /bin )
>export -T PATH path=( /bin )
>typeset -g -aT MANPATH manpath=( / )
>export -T MANPATH manpath=( / )
>path=( /bin )
>PATH=/bin
>manpath=( / )
>MANPATH=/
>zsh_eval_context=( toplevel shfunc shfunc shfunc eval )
>ZSH_EVAL_CONTEXT=toplevel:shfunc:shfunc:shfunc:eval
>array tied PATH path
>tied path PATH
>array tied MANPATH manpath
>tied manpath MANPATH
>array readonly tied ZSH_EVAL_CONTEXT zsh_eval_context
>readonly tied zsh_eval_context ZSH_EVAL_CONTEXT
>path: array-tied-special
>PATH: scalar-tied-export-special
>manpath: array-tied-special
>MANPATH: scalar-tied-export-special
>zsh_eval_context: array-readonly-tied-special
>ZSH_EVAL_CONTEXT: scalar-readonly-tied-special

 typeset -T VAR var=(a b a b)
 typeset -UuT VAR var +
 print $VAR
0:redeclare a tied variable with different attributes
>A+B

 typeset -T VAR=a+b var
 typeset -T VAR var +
 print $var
0:colonarray re-split when changing the join character
>a b

 readonly -T VAR var=(a b)
 readonly -T VAR var +
1:cannot change the join character on a readonly tied variable
?(eval):1: read-only variable: var

 typeset -T FOO manpath
1:Can't tie a special tied array to a different variable
?(eval):typeset:1: manpath special parameter can only be tied to special parameter MANPATH

 typeset -T MANPATH foo
1:Can't tie a special tied scalar to a different variable
?(eval):typeset:1: MANPATH special parameter can only be tied to special parameter manpath

 typeset -T MANPATH manpath +
1:Can't change the join character of a special tied variable
?(eval):typeset:1: cannot change the join character of special tied parameters

 (){
   typeset -h path
   typeset -T PATH path=(x)
 }
 (){
   typeset -h PATH
   typeset -T PATH path=(x)
 }
1:reject attempt to tie special to downgraded peer
?(anon):typeset:2: PATH special parameter can only be tied to special parameter path
?(anon):typeset:2: path special parameter can only be tied to special parameter PATH

 typeset MANPATH
 manpath=(/ /)
 typeset -UT MANPATH manpath
 print $manpath
0:OK to run typeset -T on tied specials as long as peer and joinchar are unchanged
>/

 typeset FOO=a:b
 export FOO
 typeset +x -T FOO foo
 typeset -p FOO
0:Make sure +x is honoured when tying a parameter
>typeset -T FOO foo=( a b )

 $ZTST_testdir/../Src/zsh --emulate sh -f -c '
 PATH=/bin; export PATH; readonly PATH
 export -p PATH
 typeset -p PATH
 readonly -p'
0: readonly/export output for exported+readonly+special when started as sh
>export PATH=/bin
>export -r PATH=/bin
>readonly PATH=/bin

 function {
 emulate -L sh
 MANPATH=/bin; export MANPATH; readonly MANPATH
 export -p MANPATH
 typeset -p MANPATH
 readonly -p
 }
0: readonly/export output for exported+readonly+tied+special after switching to sh emulation
>export MANPATH=/bin
>export -rT MANPATH manpath=( /bin )
>readonly MANPATH=/bin

 function {
   local -rax zsh_exported_readonly_array=(2)
   local -rAx zsh_exported_readonly_hash=(3 3)
   local -rx zsh_exported_readonly_scalar=1
   print zsh:
   export -p | grep zsh_exported_readonly
   readonly -p | grep zsh_exported_readonly
   print sh:
   emulate -L sh
   export -p | grep zsh_exported_readonly
   readonly -p | grep zsh_exported_readonly
   print still asking for arrays:
   export -ap | grep zsh_exported_readonly
   readonly -ap | grep zsh_exported_readonly
 }
0: no array/hash in POSIX export/readonly -p
>zsh:
>typeset -arx zsh_exported_readonly_array=( 2 )
>typeset -Arx zsh_exported_readonly_hash=( [3]=3 )
>typeset -rx zsh_exported_readonly_scalar=1
>typeset -arx zsh_exported_readonly_array=( 2 )
>typeset -Arx zsh_exported_readonly_hash=( [3]=3 )
>typeset -rx zsh_exported_readonly_scalar=1
>sh:
>export zsh_exported_readonly_scalar=1
>readonly zsh_exported_readonly_scalar=1
>still asking for arrays:
>export zsh_exported_readonly_array=( 2 )
>export zsh_exported_readonly_scalar=1
>readonly zsh_exported_readonly_array=( 2 )
>readonly zsh_exported_readonly_scalar=1

  # The second case was buggy as it needs special handling in postassigns
  (typeset {X})
  (typeset Q= {X})
1:Regression test for {...} parsing in typeset
?(eval):typeset:2: not valid in this context: {X}
?(eval):typeset:3: not valid in this context: {X}