Symaptic: os/persistentdata/persistentstorage/sqlite3api/TEST/TCL/tcldistribution/tests/expr-old.test@bde4ae8d615e

     1 # Commands covered: expr

2 #

     3 # This file contains the original set of tests for Tcl's expr command.

     4 # Since the expr command is now compiled, a new set of tests covering

     5 # the new implementation are in the files "parseExpr.test" and

     6 # "compExpr.test". Sourcing this file into Tcl runs the tests and generates

     7 # output for errors. No output means no errors were found.

8 #

     9 # Copyright (c) 1991-1994 The Regents of the University of California.

    10 # Copyright (c) 1994-1997 Sun Microsystems, Inc.

    11 # Copyright (c) 1998-2000 by Scriptics Corporation.

    12 #

    13 # See the file "license.terms" for information on usage and redistribution

    14 # of this file, and for a DISCLAIMER OF ALL WARRANTIES.

    15 #

    16 # RCS: @(#) $Id: expr-old.test,v 1.16.2.5 2006/05/04 12:34:39 dgp Exp $

    18 if {[lsearch [namespace children] ::tcltest] == -1} {

    19     package require tcltest 2.1

    20     namespace import -force ::tcltest::*

    21 }

    23 if {([catch {expr T1()} msg] == 1) && ($msg == {unknown math function "T1"})} {

    24     set gotT1 0

    25     puts "This application hasn't been compiled with the \"T1\" and"

    26     puts "\"T2\" math functions, so I'll skip some of the expr tests."

    27 } else {

    28     set gotT1 1

    29 }

    31 # First, test all of the integer operators individually.

    33 test expr-old-1.1 {integer operators} {expr -4} -4

    34 test expr-old-1.2 {integer operators} {expr -(1+4)} -5

    35 test expr-old-1.3 {integer operators} {expr ~3} -4

    36 test expr-old-1.4 {integer operators} {expr !2} 0

    37 test expr-old-1.5 {integer operators} {expr !0} 1

    38 test expr-old-1.6 {integer operators} {expr 4*6} 24

    39 test expr-old-1.7 {integer operators} {expr 36/12} 3

    40 test expr-old-1.8 {integer operators} {expr 27/4} 6

    41 test expr-old-1.9 {integer operators} {expr 27%4} 3

    42 test expr-old-1.10 {integer operators} {expr 2+2} 4

    43 test expr-old-1.11 {integer operators} {expr 2-6} -4

    44 test expr-old-1.12 {integer operators} {expr 1<<3} 8

    45 test expr-old-1.13 {integer operators} {expr 0xff>>2} 63

    46 test expr-old-1.14 {integer operators} {expr -1>>2} -1

    47 test expr-old-1.15 {integer operators} {expr 3>2} 1

    48 test expr-old-1.16 {integer operators} {expr 2>2} 0

    49 test expr-old-1.17 {integer operators} {expr 1>2} 0

    50 test expr-old-1.18 {integer operators} {expr 3<2} 0

    51 test expr-old-1.19 {integer operators} {expr 2<2} 0

    52 test expr-old-1.20 {integer operators} {expr 1<2} 1

    53 test expr-old-1.21 {integer operators} {expr 3>=2} 1

    54 test expr-old-1.22 {integer operators} {expr 2>=2} 1

    55 test expr-old-1.23 {integer operators} {expr 1>=2} 0

    56 test expr-old-1.24 {integer operators} {expr 3<=2} 0

    57 test expr-old-1.25 {integer operators} {expr 2<=2} 1

    58 test expr-old-1.26 {integer operators} {expr 1<=2} 1

    59 test expr-old-1.27 {integer operators} {expr 3==2} 0

    60 test expr-old-1.28 {integer operators} {expr 2==2} 1

    61 test expr-old-1.29 {integer operators} {expr 3!=2} 1

    62 test expr-old-1.30 {integer operators} {expr 2!=2} 0

    63 test expr-old-1.31 {integer operators} {expr 7&0x13} 3

    64 test expr-old-1.32 {integer operators} {expr 7^0x13} 20

    65 test expr-old-1.33 {integer operators} {expr 7|0x13} 23

    66 test expr-old-1.34 {integer operators} {expr 0&&1} 0

    67 test expr-old-1.35 {integer operators} {expr 0&&0} 0

    68 test expr-old-1.36 {integer operators} {expr 1&&3} 1

    69 test expr-old-1.37 {integer operators} {expr 0||1} 1

    70 test expr-old-1.38 {integer operators} {expr 3||0} 1

    71 test expr-old-1.39 {integer operators} {expr 0||0} 0

    72 test expr-old-1.40 {integer operators} {expr 3>2?44:66} 44

    73 test expr-old-1.41 {integer operators} {expr 2>3?44:66} 66

    74 test expr-old-1.42 {integer operators} {expr 36/5} 7

    75 test expr-old-1.43 {integer operators} {expr 36%5} 1

    76 test expr-old-1.44 {integer operators} {expr -36/5} -8

    77 test expr-old-1.45 {integer operators} {expr -36%5} 4

    78 test expr-old-1.46 {integer operators} {expr 36/-5} -8

    79 test expr-old-1.47 {integer operators} {expr 36%-5} -4

    80 test expr-old-1.48 {integer operators} {expr -36/-5} 7

    81 test expr-old-1.49 {integer operators} {expr -36%-5} -1

    82 test expr-old-1.50 {integer operators} {expr +36} 36

    83 test expr-old-1.51 {integer operators} {expr +--++36} 36

    84 test expr-old-1.52 {integer operators} {expr +36%+5} 1

    85 test expr-old-1.53 {integer operators} {

    86     catch {unset x}

    87     set x yes

    88     list [expr {1 && $x}] [expr {$x && 1}] \

    89          [expr {0 || $x}] [expr {$x || 0}]

    90 } {1 1 1 1}

    92 # Check the floating-point operators individually, along with

    93 # automatic conversion to integers where needed.

    95 test expr-old-2.1 {floating-point operators} {expr -4.2} -4.2

    96 test expr-old-2.2 {floating-point operators} {expr -(1.1+4.2)} -5.3

    97 test expr-old-2.3 {floating-point operators} {expr +5.7} 5.7

    98 test expr-old-2.4 {floating-point operators} {expr +--+-62.0} -62.0

    99 test expr-old-2.5 {floating-point operators} {expr !2.1} 0

   100 test expr-old-2.6 {floating-point operators} {expr !0.0} 1

   101 test expr-old-2.7 {floating-point operators} {expr 4.2*6.3} 26.46

   102 test expr-old-2.8 {floating-point operators} {expr 36.0/12.0} 3.0

   103 test expr-old-2.9 {floating-point operators} {expr 27/4.0} 6.75

   104 test expr-old-2.10 {floating-point operators} {expr 2.3+2.1} 4.4

   105 test expr-old-2.11 {floating-point operators} {expr 2.3-6.5} -4.2

   106 test expr-old-2.12 {floating-point operators} {expr 3.1>2.1} 1

   107 test expr-old-2.13 {floating-point operators} {expr {2.1 > 2.1}} 0

   108 test expr-old-2.14 {floating-point operators} {expr 1.23>2.34e+1} 0

   109 test expr-old-2.15 {floating-point operators} {expr 3.45<2.34} 0

   110 test expr-old-2.16 {floating-point operators} {expr 0.002e3<--200e-2} 0

   111 test expr-old-2.17 {floating-point operators} {expr 1.1<2.1} 1

   112 test expr-old-2.18 {floating-point operators} {expr 3.1>=2.2} 1

   113 test expr-old-2.19 {floating-point operators} {expr 2.345>=2.345} 1

   114 test expr-old-2.20 {floating-point operators} {expr 1.1>=2.2} 0

   115 test expr-old-2.21 {floating-point operators} {expr 3.0<=2.0} 0

   116 test expr-old-2.22 {floating-point operators} {expr 2.2<=2.2} 1

   117 test expr-old-2.23 {floating-point operators} {expr 2.2<=2.2001} 1

   118 test expr-old-2.24 {floating-point operators} {expr 3.2==2.2} 0

   119 test expr-old-2.25 {floating-point operators} {expr 2.2==2.2} 1

   120 test expr-old-2.26 {floating-point operators} {expr 3.2!=2.2} 1

   121 test expr-old-2.27 {floating-point operators} {expr 2.2!=2.2} 0

   122 test expr-old-2.28 {floating-point operators} {expr 0.0&&0.0} 0

   123 test expr-old-2.29 {floating-point operators} {expr 0.0&&1.3} 0

   124 test expr-old-2.30 {floating-point operators} {expr 1.3&&0.0} 0

   125 test expr-old-2.31 {floating-point operators} {expr 1.3&&3.3} 1

   126 test expr-old-2.32 {floating-point operators} {expr 0.0||0.0} 0

   127 test expr-old-2.33 {floating-point operators} {expr 0.0||1.3} 1

   128 test expr-old-2.34 {floating-point operators} {expr 1.3||0.0} 1

   129 test expr-old-2.35 {floating-point operators} {expr 3.3||0.0} 1

   130 test expr-old-2.36 {floating-point operators} {expr 3.3>2.3?44.3:66.3} 44.3

   131 test expr-old-2.37 {floating-point operators} {expr 2.3>3.3?44.3:66.3} 66.3

   132 test expr-old-2.38 {floating-point operators} {

   133     list [catch {expr 028.1 + 09.2} msg] $msg

   134 } {0 37.3}

   136 # Operators that aren't legal on floating-point numbers

   138 test expr-old-3.1 {illegal floating-point operations} {

   139     list [catch {expr ~4.0} msg] $msg

   140 } {1 {can't use floating-point value as operand of "~"}}

   141 test expr-old-3.2 {illegal floating-point operations} {

   142     list [catch {expr 27%4.0} msg] $msg

   143 } {1 {can't use floating-point value as operand of "%"}}

   144 test expr-old-3.3 {illegal floating-point operations} {

   145     list [catch {expr 27.0%4} msg] $msg

   146 } {1 {can't use floating-point value as operand of "%"}}

   147 test expr-old-3.4 {illegal floating-point operations} {

   148     list [catch {expr 1.0<<3} msg] $msg

   149 } {1 {can't use floating-point value as operand of "<<"}}

   150 test expr-old-3.5 {illegal floating-point operations} {

   151     list [catch {expr 3<<1.0} msg] $msg

   152 } {1 {can't use floating-point value as operand of "<<"}}

   153 test expr-old-3.6 {illegal floating-point operations} {

   154     list [catch {expr 24.0>>3} msg] $msg

   155 } {1 {can't use floating-point value as operand of ">>"}}

   156 test expr-old-3.7 {illegal floating-point operations} {

   157     list [catch {expr 24>>3.0} msg] $msg

   158 } {1 {can't use floating-point value as operand of ">>"}}

   159 test expr-old-3.8 {illegal floating-point operations} {

   160     list [catch {expr 24&3.0} msg] $msg

   161 } {1 {can't use floating-point value as operand of "&"}}

   162 test expr-old-3.9 {illegal floating-point operations} {

   163     list [catch {expr 24.0|3} msg] $msg

   164 } {1 {can't use floating-point value as operand of "|"}}

   165 test expr-old-3.10 {illegal floating-point operations} {

   166     list [catch {expr 24.0^3} msg] $msg

   167 } {1 {can't use floating-point value as operand of "^"}}

   169 # Check the string operators individually.

   171 test expr-old-4.1 {string operators} {expr {"abc" > "def"}} 0

   172 test expr-old-4.2 {string operators} {expr {"def" > "def"}} 0

   173 test expr-old-4.3 {string operators} {expr {"g" > "def"}} 1

   174 test expr-old-4.4 {string operators} {expr {"abc" < "abd"}} 1

   175 test expr-old-4.5 {string operators} {expr {"abd" < "abd"}} 0

   176 test expr-old-4.6 {string operators} {expr {"abe" < "abd"}} 0

   177 test expr-old-4.7 {string operators} {expr {"abc" >= "def"}} 0

   178 test expr-old-4.8 {string operators} {expr {"def" >= "def"}} 1

   179 test expr-old-4.9 {string operators} {expr {"g" >= "def"}} 1

   180 test expr-old-4.10 {string operators} {expr {"abc" <= "abd"}} 1

   181 test expr-old-4.11 {string operators} {expr {"abd" <= "abd"}} 1

   182 test expr-old-4.12 {string operators} {expr {"abe" <= "abd"}} 0

   183 test expr-old-4.13 {string operators} {expr {"abc" == "abd"}} 0

   184 test expr-old-4.14 {string operators} {expr {"abd" == "abd"}} 1

   185 test expr-old-4.15 {string operators} {expr {"abc" != "abd"}} 1

   186 test expr-old-4.16 {string operators} {expr {"abd" != "abd"}} 0

   187 test expr-old-4.17 {string operators} {expr {"0y" < "0x12"}} 0

   188 test expr-old-4.18 {string operators} {expr {"." < " "}} 0

   189 test expr-old-4.19 {string operators} {expr {"abc" eq "abd"}} 0

   190 test expr-old-4.20 {string operators} {expr {"abd" eq "abd"}} 1

   191 test expr-old-4.21 {string operators} {expr {"abc" ne "abd"}} 1

   192 test expr-old-4.22 {string operators} {expr {"abd" ne "abd"}} 0

   193 test expr-old-4.23 {string operators} {expr {"" eq "abd"}} 0

   194 test expr-old-4.24 {string operators} {expr {"" eq ""}} 1

   195 test expr-old-4.25 {string operators} {expr {"abd" ne ""}} 1

   196 test expr-old-4.26 {string operators} {expr {"" ne ""}} 0

   197 test expr-old-4.27 {string operators} {expr {"longerstring" eq "shorter"}} 0

   198 test expr-old-4.28 {string operators} {expr {"longerstring" ne "shorter"}} 1

   200 # The following tests are non-portable because on some systems "+"

   201 # and "-" can be parsed as numbers.

   203 test expr-old-4.29 {string operators} {nonPortable} {expr {"0" == "+"}} 0

   204 test expr-old-4.30 {string operators} {nonPortable} {expr {"0" == "-"}} 0

   205 test expr-old-4.31 {string operators} {expr {1?"foo":"bar"}} foo

   206 test expr-old-4.32 {string operators} {expr {0?"foo":"bar"}} bar

   208 # Operators that aren't legal on string operands.

   210 test expr-old-5.1 {illegal string operations} {

   211     list [catch {expr {-"a"}} msg] $msg

   212 } {1 {can't use non-numeric string as operand of "-"}}

   213 test expr-old-5.2 {illegal string operations} {

   214     list [catch {expr {+"a"}} msg] $msg

   215 } {1 {can't use non-numeric string as operand of "+"}}

   216 test expr-old-5.3 {illegal string operations} {

   217     list [catch {expr {~"a"}} msg] $msg

   218 } {1 {can't use non-numeric string as operand of "~"}}

   219 test expr-old-5.4 {illegal string operations} {

   220     list [catch {expr {!"a"}} msg] $msg

   221 } {1 {can't use non-numeric string as operand of "!"}}

   222 test expr-old-5.5 {illegal string operations} {

   223     list [catch {expr {"a"*"b"}} msg] $msg

   224 } {1 {can't use non-numeric string as operand of "*"}}

   225 test expr-old-5.6 {illegal string operations} {

   226     list [catch {expr {"a"/"b"}} msg] $msg

   227 } {1 {can't use non-numeric string as operand of "/"}}

   228 test expr-old-5.7 {illegal string operations} {

   229     list [catch {expr {"a"%"b"}} msg] $msg

   230 } {1 {can't use non-numeric string as operand of "%"}}

   231 test expr-old-5.8 {illegal string operations} {

   232     list [catch {expr {"a"+"b"}} msg] $msg

   233 } {1 {can't use non-numeric string as operand of "+"}}

   234 test expr-old-5.9 {illegal string operations} {

   235     list [catch {expr {"a"-"b"}} msg] $msg

   236 } {1 {can't use non-numeric string as operand of "-"}}

   237 test expr-old-5.10 {illegal string operations} {

   238     list [catch {expr {"a"<<"b"}} msg] $msg

   239 } {1 {can't use non-numeric string as operand of "<<"}}

   240 test expr-old-5.11 {illegal string operations} {

   241     list [catch {expr {"a">>"b"}} msg] $msg

   242 } {1 {can't use non-numeric string as operand of ">>"}}

   243 test expr-old-5.12 {illegal string operations} {

   244     list [catch {expr {"a"&"b"}} msg] $msg

   245 } {1 {can't use non-numeric string as operand of "&"}}

   246 test expr-old-5.13 {illegal string operations} {

   247     list [catch {expr {"a"^"b"}} msg] $msg

   248 } {1 {can't use non-numeric string as operand of "^"}}

   249 test expr-old-5.14 {illegal string operations} {

   250     list [catch {expr {"a"|"b"}} msg] $msg

   251 } {1 {can't use non-numeric string as operand of "|"}}

   252 test expr-old-5.15 {illegal string operations} {

   253     list [catch {expr {"a"&&"b"}} msg] $msg

   254 } {1 {expected boolean value but got "a"}}

   255 test expr-old-5.16 {illegal string operations} {

   256     list [catch {expr {"a"||"b"}} msg] $msg

   257 } {1 {expected boolean value but got "a"}}

   258 test expr-old-5.17 {illegal string operations} {

   259     list [catch {expr {"a"?4:2}} msg] $msg

   260 } {1 {expected boolean value but got "a"}}

   262 # Check precedence pairwise.

   264 test expr-old-6.1 {precedence checks} {expr -~3} 4

   265 test expr-old-6.2 {precedence checks} {expr -!3} 0

   266 test expr-old-6.3 {precedence checks} {expr -~0} 1

   268 test expr-old-7.1 {precedence checks} {expr 2*4/6} 1

   269 test expr-old-7.2 {precedence checks} {expr 24/6*3} 12

   270 test expr-old-7.3 {precedence checks} {expr 24/6/2} 2

   272 test expr-old-8.1 {precedence checks} {expr -2+4} 2

   273 test expr-old-8.2 {precedence checks} {expr -2-4} -6

   274 test expr-old-8.3 {precedence checks} {expr +2-4} -2

   276 test expr-old-9.1 {precedence checks} {expr 2*3+4} 10

   277 test expr-old-9.2 {precedence checks} {expr 8/2+4} 8

   278 test expr-old-9.3 {precedence checks} {expr 8%3+4} 6

   279 test expr-old-9.4 {precedence checks} {expr 2*3-1} 5

   280 test expr-old-9.5 {precedence checks} {expr 8/2-1} 3

   281 test expr-old-9.6 {precedence checks} {expr 8%3-1} 1

   283 test expr-old-10.1 {precedence checks} {expr 6-3-2} 1

   285 test expr-old-11.1 {precedence checks} {expr 7+1>>2} 2

   286 test expr-old-11.2 {precedence checks} {expr 7+1<<2} 32

   287 test expr-old-11.3 {precedence checks} {expr 7>>3-2} 3

   288 test expr-old-11.4 {precedence checks} {expr 7<<3-2} 14

   290 test expr-old-12.1 {precedence checks} {expr 6>>1>4} 0

   291 test expr-old-12.2 {precedence checks} {expr 6>>1<2} 0

   292 test expr-old-12.3 {precedence checks} {expr 6>>1>=3} 1

   293 test expr-old-12.4 {precedence checks} {expr 6>>1<=2} 0

   294 test expr-old-12.5 {precedence checks} {expr 6<<1>5} 1

   295 test expr-old-12.6 {precedence checks} {expr 6<<1<5} 0

   296 test expr-old-12.7 {precedence checks} {expr 5<=6<<1} 1

   297 test expr-old-12.8 {precedence checks} {expr 5>=6<<1} 0

   299 test expr-old-13.1 {precedence checks} {expr 2<3<4} 1

   300 test expr-old-13.2 {precedence checks} {expr 0<4>2} 0

   301 test expr-old-13.3 {precedence checks} {expr 4>2<1} 0

   302 test expr-old-13.4 {precedence checks} {expr 4>3>2} 0

   303 test expr-old-13.5 {precedence checks} {expr 4>3>=2} 0

   304 test expr-old-13.6 {precedence checks} {expr 4>=3>2} 0

   305 test expr-old-13.7 {precedence checks} {expr 4>=3>=2} 0

   306 test expr-old-13.8 {precedence checks} {expr 0<=4>=2} 0

   307 test expr-old-13.9 {precedence checks} {expr 4>=2<=0} 0

   308 test expr-old-13.10 {precedence checks} {expr 2<=3<=4} 1

   310 test expr-old-14.1 {precedence checks} {expr 1==4>3} 1

   311 test expr-old-14.2 {precedence checks} {expr 0!=4>3} 1

   312 test expr-old-14.3 {precedence checks} {expr 1==3<4} 1

   313 test expr-old-14.4 {precedence checks} {expr 0!=3<4} 1

   314 test expr-old-14.5 {precedence checks} {expr 1==4>=3} 1

   315 test expr-old-14.6 {precedence checks} {expr 0!=4>=3} 1

   316 test expr-old-14.7 {precedence checks} {expr 1==3<=4} 1

   317 test expr-old-14.8 {precedence checks} {expr 0!=3<=4} 1

   318 test expr-old-14.9 {precedence checks} {expr 1eq4>3} 1

   319 test expr-old-14.10 {precedence checks} {expr 0ne4>3} 1

   320 test expr-old-14.11 {precedence checks} {expr 1eq3<4} 1

   321 test expr-old-14.12 {precedence checks} {expr 0ne3<4} 1

   322 test expr-old-14.13 {precedence checks} {expr 1eq4>=3} 1

   323 test expr-old-14.14 {precedence checks} {expr 0ne4>=3} 1

   324 test expr-old-14.15 {precedence checks} {expr 1eq3<=4} 1

   325 test expr-old-14.16 {precedence checks} {expr 0ne3<=4} 1

   327 test expr-old-15.1 {precedence checks} {expr 1==3==3} 0

   328 test expr-old-15.2 {precedence checks} {expr 3==3!=2} 1

   329 test expr-old-15.3 {precedence checks} {expr 2!=3==3} 0

   330 test expr-old-15.4 {precedence checks} {expr 2!=1!=1} 0

   331 test expr-old-15.5 {precedence checks} {expr 1eq3eq3} 0

   332 test expr-old-15.6 {precedence checks} {expr 3eq3ne2} 1

   333 test expr-old-15.7 {precedence checks} {expr 2ne3eq3} 0

   334 test expr-old-15.8 {precedence checks} {expr 2ne1ne1} 0

   336 test expr-old-16.1 {precedence checks} {expr 2&3eq2} 0

   337 test expr-old-16.2 {precedence checks} {expr 1&3ne3} 0

   338 test expr-old-16.3 {precedence checks} {expr 2&3eq2} 0

   339 test expr-old-16.4 {precedence checks} {expr 1&3ne3} 0

   341 test expr-old-17.1 {precedence checks} {expr 7&3^0x10} 19

   342 test expr-old-17.2 {precedence checks} {expr 7^0x10&3} 7

   344 test expr-old-18.1 {precedence checks} {expr 7^0x10|3} 23

   345 test expr-old-18.2 {precedence checks} {expr 7|0x10^3} 23

   347 test expr-old-19.1 {precedence checks} {expr 7|3&&1} 1

   348 test expr-old-19.2 {precedence checks} {expr 1&&3|7} 1

   349 test expr-old-19.3 {precedence checks} {expr 0&&1||1} 1

   350 test expr-old-19.4 {precedence checks} {expr 1||1&&0} 1

   352 test expr-old-20.1 {precedence checks} {expr 1||0?3:4} 3

   353 test expr-old-20.2 {precedence checks} {expr 1?0:4||1} 0

   354 test expr-old-20.3 {precedence checks} {expr 1?2:0?3:4} 2

   355 test expr-old-20.4 {precedence checks} {expr 0?2:0?3:4} 4

   356 test expr-old-20.5 {precedence checks} {expr 1?2?3:4:0} 3

   357 test expr-old-20.6 {precedence checks} {expr 0?2?3:4:0} 0

   359 # Parentheses.

   361 test expr-old-21.1 {parenthesization} {expr (2+4)*6} 36

   362 test expr-old-21.2 {parenthesization} {expr (1?0:4)||1} 1

   363 test expr-old-21.3 {parenthesization} {expr +(3-4)} -1

   365 # Embedded commands and variable names.

   367 set a 16

   368 test expr-old-22.1 {embedded variables} {expr {2*$a}} 32

   369 test expr-old-22.2 {embedded variables} {

   370     set x -5

   371     set y 10

   372     expr {$x + $y}

   373 } {5}

   374 test expr-old-22.3 {embedded variables} {

   375     set x "  -5"

   376     set y "  +10"

   377     expr {$x + $y}

   378 } {5}

   379 test expr-old-22.4 {embedded commands and variables} {expr {[set a] - 14}} 2

   380 test expr-old-22.5 {embedded commands and variables} {

   381     list [catch {expr {12 - [bad_command_name]}} msg] $msg

   382 } {1 {invalid command name "bad_command_name"}}

   384 # Double-quotes and things inside them.

   386 test expr-old-23.1 {double quotes} {expr {"abc"}} abc

   387 test expr-old-23.2 {double quotes} {

   388     set a 189

   389     expr {"$a.bc"}

   390 } 189.bc

   391 test expr-old-23.3 {double quotes} {

   392     set b2 xyx

   393     expr {"$b2$b2$b2.[set b2].[set b2]"}

   394 } xyxxyxxyx.xyx.xyx

   395 test expr-old-23.4 {double quotes} {expr {"11\}\}22"}} 11}}22

   396 test expr-old-23.5 {double quotes} {expr {"\*bc"}} {*bc}

   397 test expr-old-23.6 {double quotes} {

   398     catch {unset bogus__}

   399     list [catch {expr {"$bogus__"}} msg] $msg

   400 } {1 {can't read "bogus__": no such variable}}

   401 test expr-old-23.7 {double quotes} {

   402     list [catch {expr {"a[error Testing]bc"}} msg] $msg

   403 } {1 Testing}

   404 test expr-old-23.8 {double quotes} {

   405     list [catch {expr {"12398712938788234-1298379" != ""}} msg] $msg

   406 } {0 1}

   408 # Numbers in various bases.

   410 test expr-old-24.1 {numbers in different bases} {expr 0x20} 32

   411 test expr-old-24.2 {numbers in different bases} {expr 015} 13

   413 # Conversions between various data types.

   415 test expr-old-25.1 {type conversions} {expr 2+2.5} 4.5

   416 test expr-old-25.2 {type conversions} {expr 2.5+2} 4.5

   417 test expr-old-25.3 {type conversions} {expr 2-2.5} -0.5

   418 test expr-old-25.4 {type conversions} {expr 2/2.5} 0.8

   419 test expr-old-25.5 {type conversions} {expr 2>2.5} 0

   420 test expr-old-25.6 {type conversions} {expr 2.5>2} 1

   421 test expr-old-25.7 {type conversions} {expr 2<2.5} 1

   422 test expr-old-25.8 {type conversions} {expr 2>=2.5} 0

   423 test expr-old-25.9 {type conversions} {expr 2<=2.5} 1

   424 test expr-old-25.10 {type conversions} {expr 2==2.5} 0

   425 test expr-old-25.11 {type conversions} {expr 2!=2.5} 1

   426 test expr-old-25.12 {type conversions} {expr 2>"ab"} 0

   427 test expr-old-25.13 {type conversions} {expr {2>" "}} 1

   428 test expr-old-25.14 {type conversions} {expr {"24.1a" > 24.1}} 1

   429 test expr-old-25.15 {type conversions} {expr {24.1 > "24.1a"}} 0

   430 test expr-old-25.16 {type conversions} {expr 2+2.5} 4.5

   431 test expr-old-25.17 {type conversions} {expr 2+2.5} 4.5

   432 test expr-old-25.18 {type conversions} {expr 2.0e2} 200.0

   433 test expr-old-25.19 {type conversions} {eformat} {expr 2.0e15} 2e+15

   434 test expr-old-25.20 {type conversions} {expr 10.0} 10.0

   436 # Various error conditions.

   438 test expr-old-26.1 {error conditions} {

   439     list [catch {expr 2+"a"} msg] $msg

   440 } {1 {can't use non-numeric string as operand of "+"}}

   441 test expr-old-26.2 {error conditions} {

   442     list [catch {expr 2+4*} msg] $msg

   443 } {1 {syntax error in expression "2+4*": premature end of expression}}

   444 test expr-old-26.3 {error conditions} {

   445     list [catch {expr 2+4*(} msg] $msg

   446 } {1 {syntax error in expression "2+4*(": premature end of expression}}

   447 catch {unset _non_existent_}

   448 test expr-old-26.4 {error conditions} {

   449     list [catch {expr 2+$_non_existent_} msg] $msg

   450 } {1 {can't read "_non_existent_": no such variable}}

   451 set a xx

   452 test expr-old-26.5 {error conditions} {

   453     list [catch {expr {2+$a}} msg] $msg

   454 } {1 {can't use non-numeric string as operand of "+"}}

   455 test expr-old-26.6 {error conditions} {

   456     list [catch {expr {2+[set a]}} msg] $msg

   457 } {1 {can't use non-numeric string as operand of "+"}}

   458 test expr-old-26.7 {error conditions} {

   459     list [catch {expr {2+(4}} msg] $msg

   460 } {1 {syntax error in expression "2+(4": looking for close parenthesis}}

   461 test expr-old-26.8 {error conditions} {

   462     list [catch {expr 2/0} msg] $msg $errorCode

   463 } {1 {divide by zero} {ARITH DIVZERO {divide by zero}}}

   464 test expr-old-26.9 {error conditions} {

   465     list [catch {expr 2%0} msg] $msg $errorCode

   466 } {1 {divide by zero} {ARITH DIVZERO {divide by zero}}}

   467 test expr-old-26.10 {error conditions} {

   468     list [catch {expr 2.0/0.0} msg] $msg $errorCode

   469 } {1 {divide by zero} {ARITH DIVZERO {divide by zero}}}

   470 test expr-old-26.11 {error conditions} {

   471     list [catch {expr 2#} msg] $msg

   472 } {1 {syntax error in expression "2#": extra tokens at end of expression}}

   473 test expr-old-26.12 {error conditions} {

   474     list [catch {expr a.b} msg] $msg

   475 } {1 {syntax error in expression "a.b": variable references require preceding $}}

   476 test expr-old-26.13 {error conditions} {

   477     list [catch {expr {"a"/"b"}} msg] $msg

   478 } {1 {can't use non-numeric string as operand of "/"}}

   479 test expr-old-26.14 {error conditions} {

   480     list [catch {expr 2:3} msg] $msg

   481 } {1 {syntax error in expression "2:3": extra tokens at end of expression}}

   482 test expr-old-26.15 {error conditions} {

   483     list [catch {expr a@b} msg] $msg

   484 } {1 {syntax error in expression "a@b": variable references require preceding $}}

   485 test expr-old-26.16 {error conditions} {

   486     list [catch {expr a[b} msg] $msg

   487 } {1 {missing close-bracket}}

   488 test expr-old-26.17 {error conditions} {

   489     list [catch {expr a`b} msg] $msg

   490 } {1 {syntax error in expression "a`b": variable references require preceding $}}

   491 test expr-old-26.18 {error conditions} {

   492     list [catch {expr \"a\"\{b} msg] $msg

   493 } {1 syntax\ error\ in\ expression\ \"\"a\"\{b\":\ extra\ tokens\ at\ end\ of\ expression}

   494 test expr-old-26.19 {error conditions} {

   495     list [catch {expr a} msg] $msg

   496 } {1 {syntax error in expression "a": variable references require preceding $}}

   497 test expr-old-26.20 {error conditions} {

   498     list [catch expr msg] $msg

   499 } {1 {wrong # args: should be "expr arg ?arg ...?"}}

   501 # Cancelled evaluation.

   503 test expr-old-27.1 {cancelled evaluation} {

   504     set a 1

   505     expr {0&&[set a 2]}

   506     set a

   507 } 1

   508 test expr-old-27.2 {cancelled evaluation} {

   509     set a 1

   510     expr {1||[set a 2]}

   511     set a

   512 } 1

   513 test expr-old-27.3 {cancelled evaluation} {

   514     set a 1

   515     expr {0?[set a 2]:1}

   516     set a

   517 } 1

   518 test expr-old-27.4 {cancelled evaluation} {

   519     set a 1

   520     expr {1?2:[set a 2]}

   521     set a

   522 } 1

   523 catch {unset x}

   524 test expr-old-27.5 {cancelled evaluation} {

   525     list [catch {expr {[info exists x] && $x}} msg] $msg

   526 } {0 0}

   527 test expr-old-27.6 {cancelled evaluation} {

   528     list [catch {expr {0 && [concat $x]}} msg] $msg

   529 } {0 0}

   530 test expr-old-27.7 {cancelled evaluation} {

   531     set one 1

   532     list [catch {expr {1 || 1/$one}} msg] $msg

   533 } {0 1}

   534 test expr-old-27.8 {cancelled evaluation} {

   535     list [catch {expr {1 || -"string"}} msg] $msg

   536 } {0 1}

   537 test expr-old-27.9 {cancelled evaluation} {

   538     list [catch {expr {1 || ("string" * ("x" && "y"))}} msg] $msg

   539 } {0 1}

   540 test expr-old-27.10 {cancelled evaluation} {

   541     set x -1.0

   542     list [catch {expr {($x > 0) ? round(log($x)) : 0}} msg] $msg

   543 } {0 0}

   544 test expr-old-27.11 {cancelled evaluation} {

   545     list [catch {expr {0 && foo}} msg] $msg

   546 } {1 {syntax error in expression "0 && foo": variable references require preceding $}}

   547 test expr-old-27.12 {cancelled evaluation} {

   548     list [catch {expr {0 ? 1 : foo}} msg] $msg

   549 } {1 {syntax error in expression "0 ? 1 : foo": variable references require preceding $}}

   551 # Tcl_ExprBool as used in "if" statements

   553 test expr-old-28.1 {Tcl_ExprBoolean usage} {

   554     set a 1

   555     if {2} {set a 2}

   556     set a

   557 } 2

   558 test expr-old-28.2 {Tcl_ExprBoolean usage} {

   559     set a 1

   560     if {0} {set a 2}

   561     set a

   562 } 1

   563 test expr-old-28.3 {Tcl_ExprBoolean usage} {

   564     set a 1

   565     if {1.2} {set a 2}

   566     set a

   567 } 2

   568 test expr-old-28.4 {Tcl_ExprBoolean usage} {

   569     set a 1

   570     if {-1.1} {set a 2}

   571     set a

   572 } 2

   573 test expr-old-28.5 {Tcl_ExprBoolean usage} {

   574     set a 1

   575     if {0.0} {set a 2}

   576     set a

   577 } 1

   578 test expr-old-28.6 {Tcl_ExprBoolean usage} {

   579     set a 1

   580     if {"YES"} {set a 2}

   581     set a

   582 } 2

   583 test expr-old-28.7 {Tcl_ExprBoolean usage} {

   584     set a 1

   585     if {"no"} {set a 2}

   586     set a

   587 } 1

   588 test expr-old-28.8 {Tcl_ExprBoolean usage} {

   589     set a 1

   590     if {"true"} {set a 2}

   591     set a

   592 } 2

   593 test expr-old-28.9 {Tcl_ExprBoolean usage} {

   594     set a 1

   595     if {"fAlse"} {set a 2}

   596     set a

   597 } 1

   598 test expr-old-28.10 {Tcl_ExprBoolean usage} {

   599     set a 1

   600     if {"on"} {set a 2}

   601     set a

   602 } 2

   603 test expr-old-28.11 {Tcl_ExprBoolean usage} {

   604     set a 1

   605     if {"Off"} {set a 2}

   606     set a

   607 } 1

   608 test expr-old-28.12 {Tcl_ExprBool usage} {

   609     list [catch {if {"abc"} {}} msg] $msg

   610 } {1 {expected boolean value but got "abc"}}

   611 test expr-old-28.13 {Tcl_ExprBool usage} {

   612     list [catch {if {"ogle"} {}} msg] $msg

   613 } {1 {expected boolean value but got "ogle"}}

   614 test expr-old-28.14 {Tcl_ExprBool usage} {

   615     list [catch {if {"o"} {}} msg] $msg

   616 } {1 {expected boolean value but got "o"}}

   618 # Operands enclosed in braces

   620 test expr-old-29.1 {braces} {expr {{abc}}} abc

   621 test expr-old-29.2 {braces} {expr {{00010}}} 8

   622 test expr-old-29.3 {braces} {expr {{3.1200000}}} 3.12

   623 test expr-old-29.4 {braces} {expr {{a{b}{1 {2 3}}c}}} "a{b}{1 {2 3}}c"

   624 test expr-old-29.5 {braces} {

   625     list [catch {expr "\{abc"} msg] $msg

   626 } {1 {missing close-brace}}

   628 # Very long values

   630 test expr-old-30.1 {long values} {

   631     set a "0000 1111 2222 3333 4444"

   632     set a "$a | $a | $a | $a | $a"

   633     set a "$a || $a || $a || $a || $a"

   634     expr {$a}

   635 } {0000 1111 2222 3333 4444 | 0000 1111 2222 3333 4444 | 0000 1111 2222 3333 4444 | 0000 1111 2222 3333 4444 | 0000 1111 2222 3333 4444 || 0000 1111 2222 3333 4444 | 0000 1111 2222 3333 4444 | 0000 1111 2222 3333 4444 | 0000 1111 2222 3333 4444 | 0000 1111 2222 3333 4444 || 0000 1111 2222 3333 4444 | 0000 1111 2222 3333 4444 | 0000 1111 2222 3333 4444 | 0000 1111 2222 3333 4444 | 0000 1111 2222 3333 4444 || 0000 1111 2222 3333 4444 | 0000 1111 2222 3333 4444 | 0000 1111 2222 3333 4444 | 0000 1111 2222 3333 4444 | 0000 1111 2222 3333 4444 || 0000 1111 2222 3333 4444 | 0000 1111 2222 3333 4444 | 0000 1111 2222 3333 4444 | 0000 1111 2222 3333 4444 | 0000 1111 2222 3333 4444}

   636 test expr-old-30.2 {long values} {

   637     set a "000000000000000000000000000000"

   638     set a "$a$a$a$a$a$a$a$a$a$a$a$a$a$a$a$a${a}5"

   639     expr $a

   640 } 5

   642 # Expressions spanning multiple arguments

   644 test expr-old-31.1 {multiple arguments to expr command} {

   645     expr 4 + ( 6 *12) -3

   646 } 73

   647 test expr-old-31.2 {multiple arguments to expr command} {

   648     list [catch {expr 2 + (3 + 4} msg] $msg

   649 } {1 {syntax error in expression "2 + (3 + 4": looking for close parenthesis}}

   650 test expr-old-31.3 {multiple arguments to expr command} {

   651     list [catch {expr 2 + 3 +} msg] $msg

   652 } {1 {syntax error in expression "2 + 3 +": premature end of expression}}

   653 test expr-old-31.4 {multiple arguments to expr command} {

   654     list [catch {expr 2 + 3 )} msg] $msg

   655 } {1 {syntax error in expression "2 + 3 )": extra tokens at end of expression}}

   657 # Math functions

   659 test expr-old-32.1 {math functions in expressions} {

   660     format %.6g [expr acos(0.5)]

   661 } {1.0472}

   662 test expr-old-32.2 {math functions in expressions} {

   663     format %.6g [expr asin(0.5)]

   664 } {0.523599}

   665 test expr-old-32.3 {math functions in expressions} {

   666     format %.6g [expr atan(1.0)]

   667 } {0.785398}

   668 test expr-old-32.4 {math functions in expressions} {

   669     format %.6g [expr atan2(2.0, 2.0)]

   670 } {0.785398}

   671 test expr-old-32.5 {math functions in expressions} {

   672     format %.6g [expr ceil(1.999)]

   673 } {2}

   674 test expr-old-32.6 {math functions in expressions} {

   675     format %.6g [expr cos(.1)]

   676 } {0.995004}

   677 test expr-old-32.7 {math functions in expressions} {

   678     format %.6g [expr cosh(.1)]

   679 } {1.005}

   680 test expr-old-32.8 {math functions in expressions} {

   681     format %.6g [expr exp(1.0)]

   682 } {2.71828}

   683 test expr-old-32.9 {math functions in expressions} {

   684     format %.6g [expr floor(2.000)]

   685 } {2}

   686 test expr-old-32.10 {math functions in expressions} {

   687     format %.6g [expr floor(2.001)]

   688 } {2}

   689 test expr-old-32.11 {math functions in expressions} {

   690     format %.6g [expr fmod(7.3, 3.2)]

   691 } {0.9}

   692 test expr-old-32.12 {math functions in expressions} {

   693     format %.6g [expr hypot(3.0, 4.0)]

   694 } {5}

   695 test expr-old-32.13 {math functions in expressions} {

   696     format %.6g [expr log(2.8)]

   697 } {1.02962}

   698 test expr-old-32.14 {math functions in expressions} {

   699     format %.6g [expr log10(2.8)]

   700 } {0.447158}

   701 test expr-old-32.15 {math functions in expressions} {

   702     format %.6g [expr pow(2.1, 3.1)]

   703 } {9.97424}

   704 test expr-old-32.16 {math functions in expressions} {

   705     format %.6g [expr sin(.1)]

   706 } {0.0998334}

   707 test expr-old-32.17 {math functions in expressions} {

   708     format %.6g [expr sinh(.1)]

   709 } {0.100167}

   710 test expr-old-32.18 {math functions in expressions} {

   711     format %.6g [expr sqrt(2.0)]

   712 } {1.41421}

   713 test expr-old-32.19 {math functions in expressions} {

   714     format %.6g [expr tan(0.8)]

   715 } {1.02964}

   716 test expr-old-32.20 {math functions in expressions} {

   717     format %.6g [expr tanh(0.8)]

   718 } {0.664037}

   719 test expr-old-32.21 {math functions in expressions} {

   720     format %.6g [expr abs(-1.8)]

   721 } {1.8}

   722 test expr-old-32.22 {math functions in expressions} {

   723     expr abs(10.0)

   724 } {10.0}

   725 test expr-old-32.23 {math functions in expressions} {

   726     format %.6g [expr abs(-4)]

   727 } {4}

   728 test expr-old-32.24 {math functions in expressions} {

   729     format %.6g [expr abs(66)]

   730 } {66}

   732 # The following test is different for 32-bit versus 64-bit architectures.

   734 if {0x80000000 > 0} {

   735     test expr-old-32.25 {math functions in expressions} {nonPortable} {

   736 	list [catch {expr abs(0x8000000000000000)} msg] $msg

   737     } {1 {integer value too large to represent}}

   738 } else {

   739     test expr-old-32.25 {math functions in expressions} {nonPortable} {

   740 	list [catch {expr abs(0x80000000)} msg] $msg

   741     } {1 {integer value too large to represent}}

   742 }

   744 test expr-old-32.26 {math functions in expressions} {

   745     expr double(1)

   746 } {1.0}

   747 test expr-old-32.27 {math functions in expressions} {

   748     expr double(1.1)

   749 } {1.1}

   750 test expr-old-32.28 {math functions in expressions} {

   751     expr int(1)

   752 } {1}

   753 test expr-old-32.29 {math functions in expressions} {

   754     expr int(1.4)

   755 } {1}

   756 test expr-old-32.30 {math functions in expressions} {

   757     expr int(1.6)

   758 } {1}

   759 test expr-old-32.31 {math functions in expressions} {

   760     expr int(-1.4)

   761 } {-1}

   762 test expr-old-32.32 {math functions in expressions} {

   763     expr int(-1.6)

   764 } {-1}

   765 test expr-old-32.33 {math functions in expressions} {

   766     list [catch {expr int(1e60)} msg] $msg

   767 } {1 {integer value too large to represent}}

   768 test expr-old-32.34 {math functions in expressions} {

   769     list [catch {expr int(-1e60)} msg] $msg

   770 } {1 {integer value too large to represent}}

   771 test expr-old-32.35 {math functions in expressions} {

   772     expr round(1.49)

   773 } {1}

   774 test expr-old-32.36 {math functions in expressions} {

   775     expr round(1.51)

   776 } {2}

   777 test expr-old-32.37 {math functions in expressions} {

   778     expr round(-1.49)

   779 } {-1}

   780 test expr-old-32.38 {math functions in expressions} {

   781     expr round(-1.51)

   782 } {-2}

   783 test expr-old-32.39 {math functions in expressions} {

   784     list [catch {expr round(1e60)} msg] $msg

   785 } {1 {integer value too large to represent}}

   786 test expr-old-32.40 {math functions in expressions} {

   787     list [catch {expr round(-1e60)} msg] $msg

   788 } {1 {integer value too large to represent}}

   789 test expr-old-32.41 {math functions in expressions} {

   790     list [catch {expr pow(1.0 + 3.0 - 2, .8 * 5)} msg] $msg

   791 } {0 16.0}

   792 test expr-old-32.42 {math functions in expressions} {

   793     list [catch {expr hypot(5*.8,3)} msg] $msg

   794 } {0 5.0}

   795 if $gotT1 {

   796     test expr-old-32.43 {math functions in expressions} {

   797 	expr 2*T1()

   798     } 246

   799     test expr-old-32.44 {math functions in expressions} {

   800 	expr T2()*3

   801     } 1035

   802 }

   803 test expr-old-32.45 {math functions in expressions} {

   804     expr (0 <= rand()) && (rand() < 1)

   805 } {1}

   806 test expr-old-32.46 {math functions in expressions} {

   807     list [catch {expr rand(24)} msg] $msg

   808 } {1 {too many arguments for math function}}

   809 test expr-old-32.47 {math functions in expressions} {

   810     list [catch {expr srand()} msg] $msg

   811 } {1 {too few arguments for math function}}

   812 test expr-old-32.48 {math functions in expressions} {

   813     list [catch {expr srand(3.79)} msg] $msg

   814 } {1 {expected integer but got "3.79"}}

   815 test expr-old-32.49 {math functions in expressions} {

   816     list [catch {expr srand("")} msg] $msg

   817 } {1 {argument to math function didn't have numeric value}}

   818 test expr-old-32.50 {math functions in expressions} {

   819     set result [expr round(srand(12345) * 1000)]

   820     for {set i 0} {$i < 10} {incr i} {

   821 	lappend result [expr round(rand() * 1000)]

   822     }

   823     set result

   824 } {97 834 948 36 12 51 766 585 914 784 333}

   825 test expr-old-32.51 {math functions in expressions} {

   826     list [catch {expr {srand([lindex "6ty" 0])}} msg] $msg

   827 } {1 {argument to math function didn't have numeric value}}

   828 test expr-old-32.52 {math functions in expressions} {

   829     expr {srand(int(1<<37)) < 1}

   830 } {1}

   831 test expr-old-32.53 {math functions in expressions} {

   832     expr {srand((1<<31) - 1) > 0}

   833 } {1}

   835 test expr-old-33.1 {conversions and fancy args to math functions} {

   836     expr hypot ( 3 , 4 )

   837 } 5.0

   838 test expr-old-33.2 {conversions and fancy args to math functions} {

   839     expr hypot ( (2.0+1.0) , 4 )

   840 } 5.0

   841 test expr-old-33.3 {conversions and fancy args to math functions} {

   842     expr hypot ( 3 , (3.0 + 1.0) )

   843 } 5.0

   844 test expr-old-33.4 {conversions and fancy args to math functions} {

   845     format %.6g [expr cos(acos(0.1))]

   846 } 0.1

   848 test expr-old-34.1 {errors in math functions} {

   849     list [catch {expr func_2(1.0)} msg] $msg

   850 } {1 {unknown math function "func_2"}}

   851 test expr-old-34.2 {errors in math functions} {

   852     list [catch {expr func|(1.0)} msg] $msg

   853 } {1 {syntax error in expression "func|(1.0)": variable references require preceding $}}

   854 test expr-old-34.3 {errors in math functions} {

   855     list [catch {expr {hypot("a b", 2.0)}} msg] $msg

   856 } {1 {argument to math function didn't have numeric value}}

   857 test expr-old-34.4 {errors in math functions} {

   858     list [catch {expr hypot(1.0 2.0)} msg] $msg

   859 } {1 {syntax error in expression "hypot(1.0 2.0)": missing close parenthesis at end of function call}}

   860 test expr-old-34.5 {errors in math functions} {

   861     list [catch {expr hypot(1.0, 2.0} msg] $msg

   862 } {1 {syntax error in expression "hypot(1.0, 2.0": missing close parenthesis at end of function call}}

   863 test expr-old-34.6 {errors in math functions} {

   864     list [catch {expr hypot(1.0 ,} msg] $msg

   865 } {1 {syntax error in expression "hypot(1.0 ,": premature end of expression}}

   866 test expr-old-34.7 {errors in math functions} {

   867     list [catch {expr hypot(1.0)} msg] $msg

   868 } {1 {too few arguments for math function}}

   869 test expr-old-34.8 {errors in math functions} {

   870     list [catch {expr hypot(1.0, 2.0, 3.0)} msg] $msg

   871 } {1 {too many arguments for math function}}

   872 test expr-old-34.9 {errors in math functions} {

   873     list [catch {expr acos(-2.0)} msg] $msg $errorCode

   874 } {1 {domain error: argument not in valid range} {ARITH DOMAIN {domain error: argument not in valid range}}}

   875 test expr-old-34.10 {errors in math functions} {nonPortable} {

   876     list [catch {expr pow(-3, 1000001)} msg] $msg $errorCode

   877 } {1 {floating-point value too large to represent} {ARITH OVERFLOW {floating-point value too large to represent}}}

   878 test expr-old-34.11 {errors in math functions} {

   879     list [catch {expr pow(3, 1000001)} msg] $msg $errorCode

   880 } {1 {floating-point value too large to represent} {ARITH OVERFLOW {floating-point value too large to represent}}}

   881 test expr-old-34.12 {errors in math functions} {

   882     list [catch {expr -14.0*exp(100000)} msg] $msg $errorCode

   883 } {1 {floating-point value too large to represent} {ARITH OVERFLOW {floating-point value too large to represent}}}

   884 test expr-old-34.13 {errors in math functions} {

   885     list [catch {expr int(1.0e30)} msg] $msg $errorCode

   886 } {1 {integer value too large to represent} {ARITH IOVERFLOW {integer value too large to represent}}}

   887 test expr-old-34.14 {errors in math functions} {

   888     list [catch {expr int(-1.0e30)} msg] $msg $errorCode

   889 } {1 {integer value too large to represent} {ARITH IOVERFLOW {integer value too large to represent}}}

   890 test expr-old-34.15 {errors in math functions} {

   891     list [catch {expr round(1.0e30)} msg] $msg $errorCode

   892 } {1 {integer value too large to represent} {ARITH IOVERFLOW {integer value too large to represent}}}

   893 test expr-old-34.16 {errors in math functions} {

   894     list [catch {expr round(-1.0e30)} msg] $msg $errorCode

   895 } {1 {integer value too large to represent} {ARITH IOVERFLOW {integer value too large to represent}}}

   896 if $gotT1 {

   897     test expr-old-34.17 {errors in math functions} {

   898 	list [catch {expr T1(4)} msg] $msg

   899     } {1 {too many arguments for math function}}

   900 }

   902 test expr-old-36.1 {ExprLooksLikeInt procedure} -body {

   903     expr 0289

   904 } -returnCodes error -match glob -result {*invalid octal number*}

   905 test expr-old-36.2 {ExprLooksLikeInt procedure} {

   906     set x 0289

   907     list [catch {expr {$x+1}} msg] $msg

   908 } {1 {can't use invalid octal number as operand of "+"}}

   909 test expr-old-36.3 {ExprLooksLikeInt procedure} {

   910     list [catch {expr 0289.1} msg] $msg

   911 } {0 289.1}

   912 test expr-old-36.4 {ExprLooksLikeInt procedure} {

   913     set x 0289.1

   914     list [catch {expr {$x+1}} msg] $msg

   915 } {0 290.1}

   916 test expr-old-36.5 {ExprLooksLikeInt procedure} {

   917     set x {  +22}

   918     list [catch {expr {$x+1}} msg] $msg

   919 } {0 23}

   920 test expr-old-36.6 {ExprLooksLikeInt procedure} {

   921     set x {	-22}

   922     list [catch {expr {$x+1}} msg] $msg

   923 } {0 -21}

   924 test expr-old-36.7 {ExprLooksLikeInt procedure} {nonPortable unixOnly} {

   925     list [catch {expr nan} msg] $msg

   926 } {1 {domain error: argument not in valid range}}

   927 test expr-old-36.8 {ExprLooksLikeInt procedure} {

   928     list [catch {expr 78e1} msg] $msg

   929 } {0 780.0}

   930 test expr-old-36.9 {ExprLooksLikeInt procedure} {

   931     list [catch {expr 24E1} msg] $msg

   932 } {0 240.0}

   933 test expr-old-36.10 {ExprLooksLikeInt procedure} {nonPortable unixOnly} {

   934     list [catch {expr 78e} msg] $msg

   935 } {1 {syntax error in expression "78e"}}

   937 # test for [Bug #542588]

   938 test expr-old-36.11 {ExprLooksLikeInt procedure} {

   939     # define a "too large integer"; this one works also for 64bit arith

   940     set x 665802003400000000000000

   941     list [catch {expr {$x+1}} msg] $msg

   942 } {1 {can't use integer value too large to represent as operand of "+"}}

   944 # tests for [Bug #587140]

   945 test expr-old-36.12 {ExprLooksLikeInt procedure} {

   946     set x "10;"

   947     list [catch {expr {$x+1}} msg] $msg

   948 } {1 {can't use non-numeric string as operand of "+"}}

   949 test expr-old-36.13 {ExprLooksLikeInt procedure} {

   950     set x " +"

   951     list [catch {expr {$x+1}} msg] $msg

   952 } {1 {can't use non-numeric string as operand of "+"}}

   953 test expr-old-36.14 {ExprLooksLikeInt procedure} {

   954     set x "123456789012345678901234567890 "

   955     list [catch {expr {$x+1}} msg] $msg

   956 } {1 {can't use integer value too large to represent as operand of "+"}}

   957 test expr-old-36.15 {ExprLooksLikeInt procedure} {

   958     set x "099 "

   959     list [catch {expr {$x+1}} msg] $msg

   960 } {1 {can't use invalid octal number as operand of "+"}}

   961 test expr-old-36.16 {ExprLooksLikeInt procedure} {

   962     set x " 0xffffffffffffffffffffffffffffffffffffff  "

   963     list [catch {expr {$x+1}} msg] $msg

   964 } {1 {can't use integer value too large to represent as operand of "+"}}

   966 if {[info commands testexprlong] == {}} {

   967     puts "This application hasn't been compiled with the \"testexprlong\""

   968     puts "command, so I can't test Tcl_ExprLong etc."

   969 } else {

   970 test expr-old-37.1 {Check that Tcl_ExprLong doesn't modify interpreter result if no error} {

   971     testexprlong

   972 } {This is a result: 5}

   973 }

   975 if {[info commands testexprstring] == {}} {

   976     puts "This application hasn't been compiled with the \"testexprstring\""

   977     puts "command, so I can't test Tcl_ExprString etc."

   978 } else {

   979 test expr-old-38.1 {Verify Tcl_ExprString's basic operation} {

   980     list [testexprstring "1+4"] [testexprstring "2*3+4.2"] \

   981         [catch {testexprstring "1+"} msg] $msg

   982 } {5 10.2 1 {syntax error in expression "1+": premature end of expression}}

   983 }

   985 #

   986 # Test for bug #908375: rounding numbers that do not fit in a

   987 # long but do fit in a wide

   988 #

   990 test expr-old-39.1 {Rounding with wide result} {

   991     set x 1.0e10

   992     set y [expr $x + 0.1]

   993     catch {

   994 	set x [list [expr {$x == round($y)}] [expr $x == -round(-$y)]]

   995     }

   996     set x

   997 } {1 1}

   998 unset -nocomplain x y

  1000 # Special test for Pentium arithmetic bug of 1994:

  1002 if {(4195835.0 - (4195835.0/3145727.0)*3145727.0) == 256.0} {

  1003     puts "Warning: this machine contains a defective Pentium processor"

  1004     puts "that performs arithmetic incorrectly.  I recommend that you"

  1005     puts "call Intel customer service immediately at 1-800-628-8686"

  1006     puts "to request a replacement processor."

  1007 }

  1009 # cleanup

  1010 ::tcltest::cleanupTests

  1011 return

author	sl@SLION-WIN7.fritz.box
	Fri, 15 Jun 2012 03:10:57 +0200
changeset 0	bde4ae8d615e
permissions	-rw-r--r--