开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
expr-old.test
资源名称：ns-allinone-2.33.tar.gz　[点击查看]
上传用户：rrhhcc
上传日期：2015-12-11
资源大小：54129k
文件大小：41k
源码类别：

通讯编程

开发平台：

Visual C++

expr-old.test：源码内容
  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