zsh/Test/C01arith.ztst

# Tests corresponding to the texinfo node `Arithmetic Evaluation'

%test

  integer light there
  (( light = 42 )) &&
  let 'there = light' &&
  print $(( there ))
0:basic integer arithmetic
>42

  float light there
  integer rnd
  (( light = 3.1415 )) &&
  let 'there = light' &&
  print -- $(( rnd = there * 10000 ))
# save rounding problems by converting to integer
0:basic floating point arithmetic
>31415

  integer rnd
  (( rnd = ((29.1 % 13.0 * 10) + 0.5) ))
  print $rnd
0:Test floating point modulo function
>31

  print $(( 0x10 + 0X01 + 2#1010 ))
0:base input
>27

  float light
  (( light = 4 ))
  print $light
  typeset -F light
  print $light
0:conversion to float
>4.000000000e+00
>4.0000000000

  integer i
  (( i = 32.5 ))
  print $i
0:conversion to int
>32

  integer i
  (( i = 4 - - 3 * 7 << 1 & 7 ^ 1 | 16 ** 2 ))
  print $i
0:precedence (arithmetic)
>1591

  fn() {
    setopt localoptions c_precedences
    integer i
    (( i = 4 - - 3 * 7 << 1 & 7 ^ 1 | 16 ** 2 ))
    print $i
  }
  fn
0:precedence (arithmetic, with C_PRECEDENCES)
>259

  print $(( 1 < 2 || 2 < 2 && 3 > 4 ))
0:precedence (logical)
>1

  print $(( 1 + 4 ? 3 + 2 ? 4 + 3 ? 5 + 6 ? 4 * 8 : 0 : 0 : 0 : 0 ))
0:precedence (ternary)
>32

  print $(( 3 ? 2 ))
1:parsing ternary (1)
?(eval):1: bad math expression: ':' expected

  print $(( 3 ? 2 : 1 : 4 ))
1:parsing ternary (2)
?(eval):1: bad math expression: ':' without '?'

  print $(( 0, 4 ? 3 : 1, 5 ))
0:comma operator
>5

  foo=000
  print $(( ##A + ##\C-a + #foo + $#foo ))
0:#, ## and $#
>117

  print $((##))
1:## without following character
?(eval):1: bad math expression: character missing after ##

  print $((## ))
0:## followed by a space
>32

  integer i
  (( i = 3 + 5 * 1.75 ))
  print $i
0:promotion to float
>11

  typeset x      &&
  (( x = 3.5 ))  &&
  print $x       &&
  (( x = 4 ))    &&
  print $x
0:use of scalars to store integers and floats
>3.5
>4

  (( newarray[unsetvar] = 1 ))
2:error using unset variable as index
?(eval):1: newarray: assignment to invalid subscript range

  integer setvar=1
  (( newarray[setvar]++ ))
  (( newarray[setvar]++ ))
  print ${(t)newarray} ${#newarray} ${newarray[1]}
0:setting array elements in math context
>array 1 2

  xarr=()
  (( xarr = 3 ))
  print ${(t)xarr} $xarr
0:converting type from array
>integer 3

  print $(( 13 = 42 ))
1:bad lvalue
?(eval):1: bad math expression: lvalue required

  x=/bar
  (( x = 32 ))
  print $x
0:assigning to scalar which contains non-math string
>32

  print $(( ))
0:empty math parse e.g. $(( )) acts like a zero
>0

  print $(( a = ))
1:empty assignment
?(eval):1: bad math expression: operand expected at end of string

  print $(( 3, ))
1:empty right hand of comma
?(eval):1: bad math expression: operand expected at end of string

  print $(( 3,,4 ))
1:empty middle of comma
?(eval):1: bad math expression: operand expected at `,4 '

  print $(( (3 + 7, 4), 5 ))
0:commas and parentheses, part 1
>5

  print $(( 5, (3 + 7, 4) ))
0:commas and parentheses, part 1
>4

  print $(( 07.5 ))
  (setopt octalzeroes; print $(( 09.5 )))
0:leading zero doesn't affect floating point
>7.5
>9.5

  (setopt octalzeroes; print $(( 09 )))
1:octalzeroes rejects invalid constants
?(eval):1: bad math expression: operator expected at `9 '

  (setopt octalzeroes; print $(( 08#77 )))
0:octalzeroes doesn't affect bases
>63

  print $(( 36#z ))
0:bases up to 36 work
>35

  print $(( 37#z ))
1:bases beyond 36 don't work
?(eval):1: invalid base (must be 2 to 36 inclusive): 37

  fail=39
  print $(( 3 + "fail" ))
0:Double quotes are not treated specially in arithmetic
>42

  alias 3=echo
  print $(( 3 + "OK"); echo "Worked")
0:not a parse failure because not arithmetic
>+ OK Worked

  fn() {
    emulate -L zsh
    print $(( [#16] 255 ))
    print $(( [##16] 255 ))
    setopt cbases
    print $(( [#16] 255 ))
    print $(( [##16] 255 ))
  }
  fn
0:doubled # in base removes radix
>16#FF
>FF
>0xFF
>FF

  array=(1)
  x=0
  (( array[++x]++ ))
  print $x
  print $#array
  print $array
0:no double increment for subscript
>1
>1
>2

  # This is a bit naughty...  the value of array
  # isn't well defined since there's no sequence point
  # between the increments of x, however we just want
  # to be sure that in this case, unlike the above,
  # x does get incremented twice.
  x=0
  array=(1 2)
  (( array[++x] = array[++x] + 1 ))
  print $x
0:double increment for repeated expression
>2

  # Floating point.  Default precision should take care of rounding errors.
  print $(( 1_0.000_000e0_1 ))
  # Integer.
  print $(( 0x_ff_ff_ ))
  # _ are parts of variable names that don't start with a digit
  __myvar__=42
  print $(( __myvar__ + $__myvar__ ))
  # _ is not part of variable name that does start with a digit
  # (which are substituted before math eval)
  set -- 6
  print $(( $1_000_000 ))
  # Underscores in expressions with no whitespace
  print $(( 3_000_+4_000_/2 ))
  # Underscores may appear in the base descriptor, for what it's worth...
  print $(( 1_6_#f_f_ ))
0:underscores in math constants
>100.
>65535
>84
>6000000
>5000
>255

 set -- {101..120}
 _10=42
 echo $_10 : $1_0
 echo $(( _10 )) : $(( 1_0 ))
0:underscores in front of a numeric identifier is not a math constant
>42 : 101_0
>42 : 10

  # Force floating point.
  for expr in "3/4" "0x100/0x200" "0x30/0x10"; do
    print $(( $expr ))
    setopt force_float
    print $(( $expr ))
    unsetopt force_float
  done
0:Forcing floating point constant evaluation, or not.
>0
>0.75
>0
>0.5
>3
>3.

  print $(( 0x30 + 0.5 ))
  print $(( 077 + 0.5 ))
  (setopt octalzeroes; print $(( 077 + 0.5 )) )
0:Mixed float and non-decimal integer constants
>48.5
>77.5
>63.5

  underscore_integer() {
    setopt cbases localoptions
    print $(( [#_] 1000000 ))
    print $(( [#16_] 65536 ))
    print $(( [#16_4] 65536 * 32768 ))
  }
  underscore_integer
0:Grouping output with underscores: integers
>1_000_000
>0x10_000
>0x8000_0000

  print $(( [#_] (5. ** 10) / 16. ))
0:Grouping output with underscores: floating point
>610_351.562_5

  env SHLVL=1+RANDOM $ZTST_testdir/../Src/zsh -f -c 'print $SHLVL'
0:Imported integer functions are not evaluated
>2

  print $(( 0b0 + 0b1 + 0b11 + 0b110 ))
0:Binary input
>10

  print $(( 0b2 ))
1:Binary numbers don't tend to have 2's in
?(eval):1: bad math expression: operator expected at `2 '
# ` for emacs shell mode

  in=1 info=2 Infinity=3 Inf=4
  print $(( in )) $(( info )) $(( Infinity )) $(( $Inf )) $(( inf )) $(( INF )) $(( Inf )) $(( iNF ))
0:Infinity parsing
>1 2 3 4 Inf Inf Inf Inf

  integer Inf
  print $(( Inf[0] ))
1:Refer to Inf with an array subscript
?(eval):2: bad base syntax

  (( NaN = 1 ))
2:Assign to NaN
?(eval):1: bad math expression: lvalue required

  a='Inf'
  (( b = 1e500 ))
  print $((1e500)) $(($((1e500)))) $(( a )) $b $(( b )) $(( 3.0 / 0 ))
0:Overflow to infinity
>Inf Inf Inf Inf Inf Inf

  print $((1e500))
  print $(( $((1e500)) ))
0:Reinput infinity value into math context
>Inf
>Inf

  print $((1e500/1e500)) $((-1e500/1e500)) $(( 24. % 0 ))
0:NaN results
>NaN NaN NaN

  (( 3 / 0 ))
2:Integer division by zero
?(eval):1: division by zero

  integer varassi
  print $(( varassi = 5.5 / 2.0 ))
  print $varassi
0:Integer variable assignment converts result to integer
>2
>2
# It's hard to test for integer to float.

  integer ff1=3 ff2=4
  print $(( ff1/ff2 ))
  setopt force_float
  print $(( ff1/ff2 ))
  unsetopt force_float
0:Variables are forced to floating point where necessary
# 0.75 is exactly representable, don't expect rounding error.
>0
>0.75

  # The following tests for a bug that only happens when
  # backing up over input read a line at a time, so we'll
  # read the input from stdin.
  $ZTST_testdir/../Src/zsh -f <<<'
  print $((echo first command
  ); echo second command)
  print third command
  '
0:Backing up a line of input when finding out it's not arithmetic
>first command second command
>third command

  $ZTST_testdir/../Src/zsh -f <<<'
  print $((3 +
  4))
  print next line
  '
0:Not needing to back up a line when reading multiline arithmetic
>7
>next line

  $ZTST_testdir/../Src/zsh -f <<<'
  print $((case foo in
  bar)
  echo not this no, no
  ;;
  foo)
  echo yes, this one
  ;;
  esac)
  print after case in subshell)
  '
0:Non-arithmetic subst with command substitution parse from hell
>yes, this one after case in subshell

  print "a$((echo one subst)
  (echo two subst))b"
0:Another tricky case that is actually a command substitution
>aone subst
>two substb

  print "x$((echo one frob); (echo two frob))y"
0:Same on a single line
>xone frob
>two froby

  # This case actually only works by accident: if it wasn't for the
  # unbalanced parenthesis this would be a valid math substitution.
  # Hence it's definitely not recommended code.  However, it does give
  # the algorithm an extra check.
  print $((case foo in
  foo)
  print Worked OK
  ;;
  esac))
0:Would-be math expansion with extra parenthesis making it a cmd subst
>Worked OK

  (setopt extendedglob
  set -- 32.463
  print ${$(( $1 * 100 ))%%.[0-9]#})
0:Arithmetic substitution nested in parameter substitution
>3246

  print $((`:`))
0:Null string in arithmetic evaluation after command substitution
>0

  print $(( 1 + $(( 2 + 3 )) ))
  print $(($((3+4))))
  print $((1*$((2*$((3))*4))*5))
0:Nested math substitutions.  Yes, I know, very useful.
>6
>7
>120

  foo="(1)"
  print $((foo))
  print $(($foo))
  print $(((2)))
  foo="3)"
  (print $((foo))) 2>&1
  (print $(($foo))) 2>&1
1: Good and bad trailing parentheses
>1
>1
>2
>(eval):6: bad math expression: unexpected ')'
>(eval):7: bad math expression: unexpected ')'

  unset number
  (( number = 3 ))
  print ${(t)number}
  unset number
  (setopt posix_identifiers
  (( number = 3 ))
  print ${(t)number})
0:type of variable when created in arithmetic context
>integer
>scalar

  integer a=1
  print $(( ++a * 2 ))
  print $(( ++a ))
  print $(( a++ * 2 ))
  print $(( a ))
  print $(( ++a++ * 2 ))
1: Allow rvalue but not lvalue operations with result of increment
>4
>3
>6
>4
?(eval):6: bad math expression: lvalue required

  print $(( -2#101-16#f ))
0: Unary minus doesn't apply to base but to number as a whole.
>-20

  ( set -o nounset
  true $(( noexist + 1 ))
  echo 'should never get here' )
1:Arithmetic, NO_UNSET part 1
?(eval):2: noexist: parameter not set

  ( setopt nounset
  (( noexist++ )) )
2:Arithmetic, NO_UNSET part 2
?(eval):2: noexist: parameter not set

  ( unsetopt unset
  let noexist==0 )
1:Arithmetic, NO_UNSET part 3
?(eval):2: noexist: parameter not set

  print $(( "6+2" / "1+3" ))
0:Double quotes are not treated specially in arithmetic (POSIX)
# and do not do grouping!  this is 6 + (2/1) + 3
>11