OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [tcl/] [tests/] [expr-old.test] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 578 markom 
# 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 is in the file "expr.test". Sourcing this file
6 
# into Tcl runs the tests and generates output for errors.
7 
# 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 
#
12 
# See the file "license.terms" for information on usage and redistribution
13 
# of this file, and for a DISCLAIMER OF ALL WARRANTIES.
14 
#
15 
# RCS: @(#) $Id: expr-old.test,v 1.1.1.1 2002-01-16 10:25:35 markom Exp $
16 
 
17 
if {[string compare test [info procs test]] == 1} then {source defs}
18 
 
19 
if {([catch {expr T1()} msg] == 1) && ($msg == {unknown math function "T1"})} {
20 
    set gotT1 0
21 
    puts "This application hasn't been compiled with the \"T1\" and"
22 
    puts "\"T2\" math functions, so I'll skip some of the expr tests."
23 
} else {
24 
    set gotT1 1
25 
}
26 
 
27 
# First, test all of the integer operators individually.
28 
 
29 
test expr-old-1.1 {integer operators} {expr -4} -4
30 
test expr-old-1.2 {integer operators} {expr -(1+4)} -5
31 
test expr-old-1.3 {integer operators} {expr ~3} -4
32 
test expr-old-1.4 {integer operators} {expr !2} 0
33 
test expr-old-1.5 {integer operators} {expr !0} 1
34 
test expr-old-1.6 {integer operators} {expr 4*6} 24
35 
test expr-old-1.7 {integer operators} {expr 36/12} 3
36 
test expr-old-1.8 {integer operators} {expr 27/4} 6
37 
test expr-old-1.9 {integer operators} {expr 27%4} 3
38 
test expr-old-1.10 {integer operators} {expr 2+2} 4
39 
test expr-old-1.11 {integer operators} {expr 2-6} -4
40 
test expr-old-1.12 {integer operators} {expr 1<<3} 8
41 
test expr-old-1.13 {integer operators} {expr 0xff>>2} 63
42 
test expr-old-1.14 {integer operators} {expr -1>>2} -1
43 
test expr-old-1.15 {integer operators} {expr 3>2} 1
44 
test expr-old-1.16 {integer operators} {expr 2>2} 0
45 
test expr-old-1.17 {integer operators} {expr 1>2} 0
46 
test expr-old-1.18 {integer operators} {expr 3<2} 0
47 
test expr-old-1.19 {integer operators} {expr 2<2} 0
48 
test expr-old-1.20 {integer operators} {expr 1<2} 1
49 
test expr-old-1.21 {integer operators} {expr 3>=2} 1
50 
test expr-old-1.22 {integer operators} {expr 2>=2} 1
51 
test expr-old-1.23 {integer operators} {expr 1>=2} 0
52 
test expr-old-1.24 {integer operators} {expr 3<=2} 0
53 
test expr-old-1.25 {integer operators} {expr 2<=2} 1
54 
test expr-old-1.26 {integer operators} {expr 1<=2} 1
55 
test expr-old-1.27 {integer operators} {expr 3==2} 0
56 
test expr-old-1.28 {integer operators} {expr 2==2} 1
57 
test expr-old-1.29 {integer operators} {expr 3!=2} 1
58 
test expr-old-1.30 {integer operators} {expr 2!=2} 0
59 
test expr-old-1.31 {integer operators} {expr 7&0x13} 3
60 
test expr-old-1.32 {integer operators} {expr 7^0x13} 20
61 
test expr-old-1.33 {integer operators} {expr 7|0x13} 23
62 
test expr-old-1.34 {integer operators} {expr 0&&1} 0
63 
test expr-old-1.35 {integer operators} {expr 0&&0} 0
64 
test expr-old-1.36 {integer operators} {expr 1&&3} 1
65 
test expr-old-1.37 {integer operators} {expr 0||1} 1
66 
test expr-old-1.38 {integer operators} {expr 3||0} 1
67 
test expr-old-1.39 {integer operators} {expr 0||0} 0
68 
test expr-old-1.40 {integer operators} {expr 3>2?44:66} 44
69 
test expr-old-1.41 {integer operators} {expr 2>3?44:66} 66
70 
test expr-old-1.42 {integer operators} {expr 36/5} 7
71 
test expr-old-1.43 {integer operators} {expr 36%5} 1
72 
test expr-old-1.44 {integer operators} {expr -36/5} -8
73 
test expr-old-1.45 {integer operators} {expr -36%5} 4
74 
test expr-old-1.46 {integer operators} {expr 36/-5} -8
75 
test expr-old-1.47 {integer operators} {expr 36%-5} -4
76 
test expr-old-1.48 {integer operators} {expr -36/-5} 7
77 
test expr-old-1.49 {integer operators} {expr -36%-5} -1
78 
test expr-old-1.50 {integer operators} {expr +36} 36
79 
test expr-old-1.51 {integer operators} {expr +--++36} 36
80 
test expr-old-1.52 {integer operators} {expr +36%+5} 1
81 
test expr-old-1.53 {integer operators} {
82 
    catch {unset x}
83 
    set x yes
84 
    list [expr {1 && $x}] [expr {$x && 1}] \
85 
         [expr {0 || $x}] [expr {$x || 0}]
86 
} {1 1 1 1}
87 
 
88 
# Check the floating-point operators individually, along with
89 
# automatic conversion to integers where needed.
90 
 
91 
test expr-old-2.1 {floating-point operators} {expr -4.2} -4.2
92 
test expr-old-2.2 {floating-point operators} {expr -(1.1+4.2)} -5.3
93 
test expr-old-2.3 {floating-point operators} {expr +5.7} 5.7
94 
test expr-old-2.4 {floating-point operators} {expr +--+-62.0} -62.0
95 
test expr-old-2.5 {floating-point operators} {expr !2.1} 0
96 
test expr-old-2.6 {floating-point operators} {expr !0.0} 1
97 
test expr-old-2.7 {floating-point operators} {expr 4.2*6.3} 26.46
98 
test expr-old-2.8 {floating-point operators} {expr 36.0/12.0} 3.0
99 
test expr-old-2.9 {floating-point operators} {expr 27/4.0} 6.75
100 
test expr-old-2.10 {floating-point operators} {expr 2.3+2.1} 4.4
101 
test expr-old-2.11 {floating-point operators} {expr 2.3-6.5} -4.2
102 
test expr-old-2.12 {floating-point operators} {expr 3.1>2.1} 1
103 
test expr-old-2.13 {floating-point operators} {expr {2.1 > 2.1}} 0
104 
test expr-old-2.14 {floating-point operators} {expr 1.23>2.34e+1} 0
105 
test expr-old-2.15 {floating-point operators} {expr 3.45<2.34} 0
106 
test expr-old-2.16 {floating-point operators} {expr 0.002e3<--200e-2} 0
107 
test expr-old-2.17 {floating-point operators} {expr 1.1<2.1} 1
108 
test expr-old-2.18 {floating-point operators} {expr 3.1>=2.2} 1
109 
test expr-old-2.19 {floating-point operators} {expr 2.345>=2.345} 1
110 
test expr-old-2.20 {floating-point operators} {expr 1.1>=2.2} 0
111 
test expr-old-2.21 {floating-point operators} {expr 3.0<=2.0} 0
112 
test expr-old-2.22 {floating-point operators} {expr 2.2<=2.2} 1
113 
test expr-old-2.23 {floating-point operators} {expr 2.2<=2.2001} 1
114 
test expr-old-2.24 {floating-point operators} {expr 3.2==2.2} 0
115 
test expr-old-2.25 {floating-point operators} {expr 2.2==2.2} 1
116 
test expr-old-2.26 {floating-point operators} {expr 3.2!=2.2} 1
117 
test expr-old-2.27 {floating-point operators} {expr 2.2!=2.2} 0
118 
test expr-old-2.28 {floating-point operators} {expr 0.0&&0.0} 0
119 
test expr-old-2.29 {floating-point operators} {expr 0.0&&1.3} 0
120 
test expr-old-2.30 {floating-point operators} {expr 1.3&&0.0} 0
121 
test expr-old-2.31 {floating-point operators} {expr 1.3&&3.3} 1
122 
test expr-old-2.32 {floating-point operators} {expr 0.0||0.0} 0
123 
test expr-old-2.33 {floating-point operators} {expr 0.0||1.3} 1
124 
test expr-old-2.34 {floating-point operators} {expr 1.3||0.0} 1
125 
test expr-old-2.35 {floating-point operators} {expr 3.3||0.0} 1
126 
test expr-old-2.36 {floating-point operators} {expr 3.3>2.3?44.3:66.3} 44.3
127 
test expr-old-2.37 {floating-point operators} {expr 2.3>3.3?44.3:66.3} 66.3
128 
test expr-old-2.38 {floating-point operators} {
129 
    list [catch {expr 028.1 + 09.2} msg] $msg
130 
} {0 37.3}
131 
 
132 
# Operators that aren't legal on floating-point numbers
133 
 
134 
test expr-old-3.1 {illegal floating-point operations} {
135 
    list [catch {expr ~4.0} msg] $msg
136 
} {1 {can't use floating-point value as operand of "~"}}
137 
test expr-old-3.2 {illegal floating-point operations} {
138 
    list [catch {expr 27%4.0} msg] $msg
139 
} {1 {can't use floating-point value as operand of "%"}}
140 
test expr-old-3.3 {illegal floating-point operations} {
141 
    list [catch {expr 27.0%4} msg] $msg
142 
} {1 {can't use floating-point value as operand of "%"}}
143 
test expr-old-3.4 {illegal floating-point operations} {
144 
    list [catch {expr 1.0<<3} msg] $msg
145 
} {1 {can't use floating-point value as operand of "<<"}}
146 
test expr-old-3.5 {illegal floating-point operations} {
147 
    list [catch {expr 3<<1.0} msg] $msg
148 
} {1 {can't use floating-point value as operand of "<<"}}
149 
test expr-old-3.6 {illegal floating-point operations} {
150 
    list [catch {expr 24.0>>3} msg] $msg
151 
} {1 {can't use floating-point value as operand of ">>"}}
152 
test expr-old-3.7 {illegal floating-point operations} {
153 
    list [catch {expr 24>>3.0} msg] $msg
154 
} {1 {can't use floating-point value as operand of ">>"}}
155 
test expr-old-3.8 {illegal floating-point operations} {
156 
    list [catch {expr 24&3.0} msg] $msg
157 
} {1 {can't use floating-point value as operand of "&"}}
158 
test expr-old-3.9 {illegal floating-point operations} {
159 
    list [catch {expr 24.0|3} msg] $msg
160 
} {1 {can't use floating-point value as operand of "|"}}
161 
test expr-old-3.10 {illegal floating-point operations} {
162 
    list [catch {expr 24.0^3} msg] $msg
163 
} {1 {can't use floating-point value as operand of "^"}}
164 
 
165 
# Check the string operators individually.
166 
 
167 
test expr-old-4.1 {string operators} {expr {"abc" > "def"}} 0
168 
test expr-old-4.2 {string operators} {expr {"def" > "def"}} 0
169 
test expr-old-4.3 {string operators} {expr {"g" > "def"}} 1
170 
test expr-old-4.4 {string operators} {expr {"abc" < "abd"}} 1
171 
test expr-old-4.5 {string operators} {expr {"abd" < "abd"}} 0
172 
test expr-old-4.6 {string operators} {expr {"abe" < "abd"}} 0
173 
test expr-old-4.7 {string operators} {expr {"abc" >= "def"}} 0
174 
test expr-old-4.8 {string operators} {expr {"def" >= "def"}} 1
175 
test expr-old-4.9 {string operators} {expr {"g" >= "def"}} 1
176 
test expr-old-4.10 {string operators} {expr {"abc" <= "abd"}} 1
177 
test expr-old-4.11 {string operators} {expr {"abd" <= "abd"}} 1
178 
test expr-old-4.12 {string operators} {expr {"abe" <= "abd"}} 0
179 
test expr-old-4.13 {string operators} {expr {"abc" == "abd"}} 0
180 
test expr-old-4.14 {string operators} {expr {"abd" == "abd"}} 1
181 
test expr-old-4.15 {string operators} {expr {"abc" != "abd"}} 1
182 
test expr-old-4.16 {string operators} {expr {"abd" != "abd"}} 0
183 
test expr-old-4.17 {string operators} {expr {"0y" < "0x12"}} 0
184 
test expr-old-4.18 {string operators} {expr {"." < " "}} 0
185 
 
186 
# The following tests are non-portable because on some systems "+"
187 
# and "-" can be parsed as numbers.
188 
 
189 
test expr-old-4.19 {string operators} {nonPortable} {expr {"0" == "+"}} 0
190 
test expr-old-4.20 {string operators} {nonPortable} {expr {"0" == "-"}} 0
191 
test expr-old-4.21 {string operators} {expr {1?"foo":"bar"}} foo
192 
test expr-old-4.22 {string operators} {expr {0?"foo":"bar"}} bar
193 
 
194 
# Operators that aren't legal on string operands.
195 
 
196 
test expr-old-5.1 {illegal string operations} {
197 
    list [catch {expr {-"a"}} msg] $msg
198 
} {1 {can't use non-numeric string as operand of "-"}}
199 
test expr-old-5.2 {illegal string operations} {
200 
    list [catch {expr {+"a"}} msg] $msg
201 
} {1 {can't use non-numeric string as operand of "+"}}
202 
test expr-old-5.3 {illegal string operations} {
203 
    list [catch {expr {~"a"}} msg] $msg
204 
} {1 {can't use non-numeric string as operand of "~"}}
205 
test expr-old-5.4 {illegal string operations} {
206 
    list [catch {expr {!"a"}} msg] $msg
207 
} {1 {can't use non-numeric string as operand of "!"}}
208 
test expr-old-5.5 {illegal string operations} {
209 
    list [catch {expr {"a"*"b"}} msg] $msg
210 
} {1 {can't use non-numeric string as operand of "*"}}
211 
test expr-old-5.6 {illegal string operations} {
212 
    list [catch {expr {"a"/"b"}} msg] $msg
213 
} {1 {can't use non-numeric string as operand of "/"}}
214 
test expr-old-5.7 {illegal string operations} {
215 
    list [catch {expr {"a"%"b"}} msg] $msg
216 
} {1 {can't use non-numeric string as operand of "%"}}
217 
test expr-old-5.8 {illegal string operations} {
218 
    list [catch {expr {"a"+"b"}} msg] $msg
219 
} {1 {can't use non-numeric string as operand of "+"}}
220 
test expr-old-5.9 {illegal string operations} {
221 
    list [catch {expr {"a"-"b"}} msg] $msg
222 
} {1 {can't use non-numeric string as operand of "-"}}
223 
test expr-old-5.10 {illegal string operations} {
224 
    list [catch {expr {"a"<<"b"}} msg] $msg
225 
} {1 {can't use non-numeric string as operand of "<<"}}
226 
test expr-old-5.11 {illegal string operations} {
227 
    list [catch {expr {"a">>"b"}} msg] $msg
228 
} {1 {can't use non-numeric string as operand of ">>"}}
229 
test expr-old-5.12 {illegal string operations} {
230 
    list [catch {expr {"a"&"b"}} msg] $msg
231 
} {1 {can't use non-numeric string as operand of "&"}}
232 
test expr-old-5.13 {illegal string operations} {
233 
    list [catch {expr {"a"^"b"}} msg] $msg
234 
} {1 {can't use non-numeric string as operand of "^"}}
235 
test expr-old-5.14 {illegal string operations} {
236 
    list [catch {expr {"a"|"b"}} msg] $msg
237 
} {1 {can't use non-numeric string as operand of "|"}}
238 
test expr-old-5.15 {illegal string operations} {
239 
    list [catch {expr {"a"&&"b"}} msg] $msg
240 
} {1 {expected boolean value but got "a"}}
241 
test expr-old-5.16 {illegal string operations} {
242 
    list [catch {expr {"a"||"b"}} msg] $msg
243 
} {1 {expected boolean value but got "a"}}
244 
test expr-old-5.17 {illegal string operations} {
245 
    list [catch {expr {"a"?4:2}} msg] $msg
246 
} {1 {expected boolean value but got "a"}}
247 
 
248 
# Check precedence pairwise.
249 
 
250 
test expr-old-6.1 {precedence checks} {expr -~3} 4
251 
test expr-old-6.2 {precedence checks} {expr -!3} 0
252 
test expr-old-6.3 {precedence checks} {expr -~0} 1
253 
 
254 
test expr-old-7.1 {precedence checks} {expr 2*4/6} 1
255 
test expr-old-7.2 {precedence checks} {expr 24/6*3} 12
256 
test expr-old-7.3 {precedence checks} {expr 24/6/2} 2
257 
 
258 
test expr-old-8.1 {precedence checks} {expr -2+4} 2
259 
test expr-old-8.2 {precedence checks} {expr -2-4} -6
260 
test expr-old-8.3 {precedence checks} {expr +2-4} -2
261 
 
262 
test expr-old-9.1 {precedence checks} {expr 2*3+4} 10
263 
test expr-old-9.2 {precedence checks} {expr 8/2+4} 8
264 
test expr-old-9.3 {precedence checks} {expr 8%3+4} 6
265 
test expr-old-9.4 {precedence checks} {expr 2*3-1} 5
266 
test expr-old-9.5 {precedence checks} {expr 8/2-1} 3
267 
test expr-old-9.6 {precedence checks} {expr 8%3-1} 1
268 
 
269 
test expr-old-10.1 {precedence checks} {expr 6-3-2} 1
270 
 
271 
test expr-old-11.1 {precedence checks} {expr 7+1>>2} 2
272 
test expr-old-11.2 {precedence checks} {expr 7+1<<2} 32
273 
test expr-old-11.3 {precedence checks} {expr 7>>3-2} 3
274 
test expr-old-11.4 {precedence checks} {expr 7<<3-2} 14
275 
 
276 
test expr-old-12.1 {precedence checks} {expr 6>>1>4} 0
277 
test expr-old-12.2 {precedence checks} {expr 6>>1<2} 0
278 
test expr-old-12.3 {precedence checks} {expr 6>>1>=3} 1
279 
test expr-old-12.4 {precedence checks} {expr 6>>1<=2} 0
280 
test expr-old-12.5 {precedence checks} {expr 6<<1>5} 1
281 
test expr-old-12.6 {precedence checks} {expr 6<<1<5} 0
282 
test expr-old-12.7 {precedence checks} {expr 5<=6<<1} 1
283 
test expr-old-12.8 {precedence checks} {expr 5>=6<<1} 0
284 
 
285 
test expr-old-13.1 {precedence checks} {expr 2<3<4} 1
286 
test expr-old-13.2 {precedence checks} {expr 0<4>2} 0
287 
test expr-old-13.3 {precedence checks} {expr 4>2<1} 0
288 
test expr-old-13.4 {precedence checks} {expr 4>3>2} 0
289 
test expr-old-13.5 {precedence checks} {expr 4>3>=2} 0
290 
test expr-old-13.6 {precedence checks} {expr 4>=3>2} 0
291 
test expr-old-13.7 {precedence checks} {expr 4>=3>=2} 0
292 
test expr-old-13.8 {precedence checks} {expr 0<=4>=2} 0
293 
test expr-old-13.9 {precedence checks} {expr 4>=2<=0} 0
294 
test expr-old-13.10 {precedence checks} {expr 2<=3<=4} 1
295 
 
296 
test expr-old-14.1 {precedence checks} {expr 1==4>3} 1
297 
test expr-old-14.2 {precedence checks} {expr 0!=4>3} 1
298 
test expr-old-14.3 {precedence checks} {expr 1==3<4} 1
299 
test expr-old-14.4 {precedence checks} {expr 0!=3<4} 1
300 
test expr-old-14.5 {precedence checks} {expr 1==4>=3} 1
301 
test expr-old-14.6 {precedence checks} {expr 0!=4>=3} 1
302 
test expr-old-14.7 {precedence checks} {expr 1==3<=4} 1
303 
test expr-old-14.8 {precedence checks} {expr 0!=3<=4} 1
304 
 
305 
test expr-old-15.1 {precedence checks} {expr 1==3==3} 0
306 
test expr-old-15.2 {precedence checks} {expr 3==3!=2} 1
307 
test expr-old-15.3 {precedence checks} {expr 2!=3==3} 0
308 
test expr-old-15.4 {precedence checks} {expr 2!=1!=1} 0
309 
 
310 
test expr-old-16.1 {precedence checks} {expr 2&3==2} 0
311 
test expr-old-16.2 {precedence checks} {expr 1&3!=3} 0
312 
 
313 
test expr-old-17.1 {precedence checks} {expr 7&3^0x10} 19
314 
test expr-old-17.2 {precedence checks} {expr 7^0x10&3} 7
315 
 
316 
test expr-old-18.1 {precedence checks} {expr 7^0x10|3} 23
317 
test expr-old-18.2 {precedence checks} {expr 7|0x10^3} 23
318 
 
319 
test expr-old-19.1 {precedence checks} {expr 7|3&&1} 1
320 
test expr-old-19.2 {precedence checks} {expr 1&&3|7} 1
321 
test expr-old-19.3 {precedence checks} {expr 0&&1||1} 1
322 
test expr-old-19.4 {precedence checks} {expr 1||1&&0} 1
323 
 
324 
test expr-old-20.1 {precedence checks} {expr 1||0?3:4} 3
325 
test expr-old-20.2 {precedence checks} {expr 1?0:4||1} 0
326 
test expr-old-20.3 {precedence checks} {expr 1?2:0?3:4} 2
327 
test expr-old-20.4 {precedence checks} {expr 0?2:0?3:4} 4
328 
test expr-old-20.5 {precedence checks} {expr 1?2?3:4:0} 3
329 
test expr-old-20.6 {precedence checks} {expr 0?2?3:4:0} 0
330 
 
331 
# Parentheses.
332 
 
333 
test expr-old-21.1 {parenthesization} {expr (2+4)*6} 36
334 
test expr-old-21.2 {parenthesization} {expr (1?0:4)||1} 1
335 
test expr-old-21.3 {parenthesization} {expr +(3-4)} -1
336 
 
337 
# Embedded commands and variable names.
338 
 
339 
set a 16
340 
test expr-old-22.1 {embedded variables} {expr {2*$a}} 32
341 
test expr-old-22.2 {embedded variables} {
342 
    set x -5
343 
    set y 10
344 
    expr {$x + $y}
345 
} {5}
346 
test expr-old-22.3 {embedded variables} {
347 
    set x "  -5"
348 
    set y "  +10"
349 
    expr {$x + $y}
350 
} {5}
351 
test expr-old-22.4 {embedded commands and variables} {expr {[set a] - 14}} 2
352 
test expr-old-22.5 {embedded commands and variables} {
353 
    list [catch {expr {12 - [bad_command_name]}} msg] $msg
354 
} {1 {invalid command name "bad_command_name"}}
355 
 
356 
# Double-quotes and things inside them.
357 
 
358 
test expr-old-23.1 {double quotes} {expr {"abc"}} abc
359 
test expr-old-23.2 {double quotes} {
360 
    set a 189
361 
    expr {"$a.bc"}
362 
} 189.bc
363 
test expr-old-23.3 {double quotes} {
364 
    set b2 xyx
365 
    expr {"$b2$b2$b2.[set b2].[set b2]"}
366 
} xyxxyxxyx.xyx.xyx
367 
test expr-old-23.4 {double quotes} {expr {"11\}\}22"}} 11}}22
368 
test expr-old-23.5 {double quotes} {expr {"\*bc"}} {*bc}
369 
test expr-old-23.6 {double quotes} {
370 
    catch {unset bogus__}
371 
    list [catch {expr {"$bogus__"}} msg] $msg
372 
} {1 {can't read "bogus__": no such variable}}
373 
test expr-old-23.7 {double quotes} {
374 
    list [catch {expr {"a[error Testing]bc"}} msg] $msg
375 
} {1 Testing}
376 
test expr-old-23.8 {double quotes} {
377 
    list [catch {expr {"12398712938788234-1298379" != ""}} msg] $msg
378 
} {0 1}
379 
 
380 
# Numbers in various bases.
381 
 
382 
test expr-old-24.1 {numbers in different bases} {expr 0x20} 32
383 
test expr-old-24.2 {numbers in different bases} {expr 015} 13
384 
 
385 
# Conversions between various data types.
386 
 
387 
test expr-old-25.1 {type conversions} {expr 2+2.5} 4.5
388 
test expr-old-25.2 {type conversions} {expr 2.5+2} 4.5
389 
test expr-old-25.3 {type conversions} {expr 2-2.5} -0.5
390 
test expr-old-25.4 {type conversions} {expr 2/2.5} 0.8
391 
test expr-old-25.5 {type conversions} {expr 2>2.5} 0
392 
test expr-old-25.6 {type conversions} {expr 2.5>2} 1
393 
test expr-old-25.7 {type conversions} {expr 2<2.5} 1
394 
test expr-old-25.8 {type conversions} {expr 2>=2.5} 0
395 
test expr-old-25.9 {type conversions} {expr 2<=2.5} 1
396 
test expr-old-25.10 {type conversions} {expr 2==2.5} 0
397 
test expr-old-25.11 {type conversions} {expr 2!=2.5} 1
398 
test expr-old-25.12 {type conversions} {expr 2>"ab"} 0
399 
test expr-old-25.13 {type conversions} {expr {2>" "}} 1
400 
test expr-old-25.14 {type conversions} {expr {"24.1a" > 24.1}} 1
401 
test expr-old-25.15 {type conversions} {expr {24.1 > "24.1a"}} 0
402 
test expr-old-25.16 {type conversions} {expr 2+2.5} 4.5
403 
test expr-old-25.17 {type conversions} {expr 2+2.5} 4.5
404 
test expr-old-25.18 {type conversions} {expr 2.0e2} 200.0
405 
test expr-old-25.19 {type conversions} {eformat} {expr 2.0e15} 2e+15
406 
test expr-old-25.20 {type conversions} {expr 10.0} 10.0
407 
 
408 
# Various error conditions.
409 
 
410 
test expr-old-26.1 {error conditions} {
411 
    list [catch {expr 2+"a"} msg] $msg
412 
} {1 {can't use non-numeric string as operand of "+"}}
413 
test expr-old-26.2 {error conditions} {
414 
    list [catch {expr 2+4*} msg] $msg
415 
} {1 {syntax error in expression "2+4*"}}
416 
test expr-old-26.3 {error conditions} {
417 
    list [catch {expr 2+4*(} msg] $msg
418 
} {1 {syntax error in expression "2+4*("}}
419 
catch {unset _non_existent_}
420 
test expr-old-26.4 {error conditions} {
421 
    list [catch {expr 2+$_non_existent_} msg] $msg
422 
} {1 {can't read "_non_existent_": no such variable}}
423 
set a xx
424 
test expr-old-26.5 {error conditions} {
425 
    list [catch {expr {2+$a}} msg] $msg
426 
} {1 {can't use non-numeric string as operand of "+"}}
427 
test expr-old-26.6 {error conditions} {
428 
    list [catch {expr {2+[set a]}} msg] $msg
429 
} {1 {can't use non-numeric string as operand of "+"}}
430 
test expr-old-26.7 {error conditions} {
431 
    list [catch {expr {2+(4}} msg] $msg
432 
} {1 {syntax error in expression "2+(4"}}
433 
test expr-old-26.8 {error conditions} {
434 
    list [catch {expr 2/0} msg] $msg $errorCode
435 
} {1 {divide by zero} {ARITH DIVZERO {divide by zero}}}
436 
test expr-old-26.9 {error conditions} {
437 
    list [catch {expr 2%0} msg] $msg $errorCode
438 
} {1 {divide by zero} {ARITH DIVZERO {divide by zero}}}
439 
test expr-old-26.10 {error conditions} {
440 
    list [catch {expr 2.0/0.0} msg] $msg $errorCode
441 
} {1 {divide by zero} {ARITH DIVZERO {divide by zero}}}
442 
test expr-old-26.11 {error conditions} {
443 
    list [catch {expr 2#} msg] $msg
444 
} {1 {syntax error in expression "2#"}}
445 
test expr-old-26.12 {error conditions} {
446 
    list [catch {expr a.b} msg] $msg
447 
} {1 {syntax error in expression "a.b"}}
448 
test expr-old-26.13 {error conditions} {
449 
    list [catch {expr {"a"/"b"}} msg] $msg
450 
} {1 {can't use non-numeric string as operand of "/"}}
451 
test expr-old-26.14 {error conditions} {
452 
    list [catch {expr 2:3} msg] $msg
453 
} {1 {syntax error in expression "2:3"}}
454 
test expr-old-26.15 {error conditions} {
455 
    list [catch {expr a@b} msg] $msg
456 
} {1 {syntax error in expression "a@b"}}
457 
test expr-old-26.16 {error conditions} {
458 
    list [catch {expr a[b} msg] $msg
459 
} {1 {missing close-bracket or close-brace}}
460 
test expr-old-26.17 {error conditions} {
461 
    list [catch {expr a`b} msg] $msg
462 
} {1 {syntax error in expression "a`b"}}
463 
test expr-old-26.18 {error conditions} {
464 
    list [catch {expr \"a\"\{b} msg] $msg
465 
} {1 {missing close-brace}}
466 
test expr-old-26.19 {error conditions} {
467 
    list [catch {expr a} msg] $msg
468 
} {1 {syntax error in expression "a"}}
469 
test expr-old-26.20 {error conditions} {
470 
    list [catch expr msg] $msg
471 
} {1 {wrong # args: should be "expr arg ?arg ...?"}}
472 
 
473 
# Cancelled evaluation.
474 
 
475 
test expr-old-27.1 {cancelled evaluation} {
476 
    set a 1
477 
    expr {0&&[set a 2]}
478 
    set a
479 
} 1
480 
test expr-old-27.2 {cancelled evaluation} {
481 
    set a 1
482 
    expr {1||[set a 2]}
483 
    set a
484 
} 1
485 
test expr-old-27.3 {cancelled evaluation} {
486 
    set a 1
487 
    expr {0?[set a 2]:1}
488 
    set a
489 
} 1
490 
test expr-old-27.4 {cancelled evaluation} {
491 
    set a 1
492 
    expr {1?2:[set a 2]}
493 
    set a
494 
} 1
495 
catch {unset x}
496 
test expr-old-27.5 {cancelled evaluation} {
497 
    list [catch {expr {[info exists x] && $x}} msg] $msg
498 
} {0 0}
499 
test expr-old-27.6 {cancelled evaluation} {
500 
    list [catch {expr {0 && [concat $x]}} msg] $msg
501 
} {0 0}
502 
test expr-old-27.7 {cancelled evaluation} {
503 
    set one 1
504 
    list [catch {expr {1 || 1/$one}} msg] $msg
505 
} {0 1}
506 
test expr-old-27.8 {cancelled evaluation} {
507 
    list [catch {expr {1 || -"string"}} msg] $msg
508 
} {0 1}
509 
test expr-old-27.9 {cancelled evaluation} {
510 
    list [catch {expr {1 || ("string" * ("x" && "y"))}} msg] $msg
511 
} {0 1}
512 
test expr-old-27.10 {cancelled evaluation} {
513 
    set x -1.0
514 
    list [catch {expr {($x > 0) ? round(log($x)) : 0}} msg] $msg
515 
} {0 0}
516 
test expr-old-27.11 {cancelled evaluation} {
517 
    list [catch {expr {0 && foo}} msg] $msg
518 
} {1 {syntax error in expression "0 && foo"}}
519 
test expr-old-27.12 {cancelled evaluation} {
520 
    list [catch {expr {0 ? 1 : foo}} msg] $msg
521 
} {1 {syntax error in expression "0 ? 1 : foo"}}
522 
 
523 
# Tcl_ExprBool as used in "if" statements
524 
 
525 
test expr-old-28.1 {Tcl_ExprBoolean usage} {
526 
    set a 1
527 
    if {2} {set a 2}
528 
    set a
529 
} 2
530 
test expr-old-28.2 {Tcl_ExprBoolean usage} {
531 
    set a 1
532 
    if {0} {set a 2}
533 
    set a
534 
} 1
535 
test expr-old-28.3 {Tcl_ExprBoolean usage} {
536 
    set a 1
537 
    if {1.2} {set a 2}
538 
    set a
539 
} 2
540 
test expr-old-28.4 {Tcl_ExprBoolean usage} {
541 
    set a 1
542 
    if {-1.1} {set a 2}
543 
    set a
544 
} 2
545 
test expr-old-28.5 {Tcl_ExprBoolean usage} {
546 
    set a 1
547 
    if {0.0} {set a 2}
548 
    set a
549 
} 1
550 
test expr-old-28.6 {Tcl_ExprBoolean usage} {
551 
    set a 1
552 
    if {"YES"} {set a 2}
553 
    set a
554 
} 2
555 
test expr-old-28.7 {Tcl_ExprBoolean usage} {
556 
    set a 1
557 
    if {"no"} {set a 2}
558 
    set a
559 
} 1
560 
test expr-old-28.8 {Tcl_ExprBoolean usage} {
561 
    set a 1
562 
    if {"true"} {set a 2}
563 
    set a
564 
} 2
565 
test expr-old-28.9 {Tcl_ExprBoolean usage} {
566 
    set a 1
567 
    if {"fAlse"} {set a 2}
568 
    set a
569 
} 1
570 
test expr-old-28.10 {Tcl_ExprBoolean usage} {
571 
    set a 1
572 
    if {"on"} {set a 2}
573 
    set a
574 
} 2
575 
test expr-old-28.11 {Tcl_ExprBoolean usage} {
576 
    set a 1
577 
    if {"Off"} {set a 2}
578 
    set a
579 
} 1
580 
test expr-old-28.12 {Tcl_ExprBool usage} {
581 
    list [catch {if {"abc"} {}} msg] $msg
582 
} {1 {expected boolean value but got "abc"}}
583 
test expr-old-28.13 {Tcl_ExprBool usage} {
584 
    list [catch {if {"ogle"} {}} msg] $msg
585 
} {1 {expected boolean value but got "ogle"}}
586 
test expr-old-28.14 {Tcl_ExprBool usage} {
587 
    list [catch {if {"o"} {}} msg] $msg
588 
} {1 {expected boolean value but got "o"}}
589 
 
590 
# Operands enclosed in braces
591 
 
592 
test expr-old-29.1 {braces} {expr {{abc}}} abc
593 
test expr-old-29.2 {braces} {expr {{00010}}} 8
594 
test expr-old-29.3 {braces} {expr {{3.1200000}}} 3.12
595 
test expr-old-29.4 {braces} {expr {{a{b}{1 {2 3}}c}}} "a{b}{1 {2 3}}c"
596 
test expr-old-29.5 {braces} {
597 
    list [catch {expr "\{abc"} msg] $msg
598 
} {1 {missing close-brace}}
599 
 
600 
# Very long values
601 
 
602 
test expr-old-30.1 {long values} {
603 
    set a "0000 1111 2222 3333 4444"
604 
    set a "$a | $a | $a | $a | $a"
605 
    set a "$a || $a || $a || $a || $a"
606 
    expr {$a}
607 
} {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}
608 
test expr-old-30.2 {long values} {
609 
    set a "000000000000000000000000000000"
610 
    set a "$a$a$a$a$a$a$a$a$a$a$a$a$a$a$a$a${a}5"
611 
    expr $a
612 
} 5
613 
 
614 
# Expressions spanning multiple arguments
615 
 
616 
test expr-old-31.1 {multiple arguments to expr command} {
617 
    expr 4 + ( 6 *12) -3
618 
} 73
619 
test expr-old-31.2 {multiple arguments to expr command} {
620 
    list [catch {expr 2 + (3 + 4} msg] $msg
621 
} {1 {syntax error in expression "2 + (3 + 4"}}
622 
test expr-old-31.3 {multiple arguments to expr command} {
623 
    list [catch {expr 2 + 3 +} msg] $msg
624 
} {1 {syntax error in expression "2 + 3 +"}}
625 
test expr-old-31.4 {multiple arguments to expr command} {
626 
    list [catch {expr 2 + 3 )} msg] $msg
627 
} {1 {syntax error in expression "2 + 3 )"}}
628 
 
629 
# Math functions
630 
 
631 
test expr-old-32.1 {math functions in expressions} {
632 
    format %.6g [expr acos(0.5)]
633 
} {1.0472}
634 
test expr-old-32.2 {math functions in expressions} {
635 
    format %.6g [expr asin(0.5)]
636 
} {0.523599}
637 
test expr-old-32.3 {math functions in expressions} {
638 
    format %.6g [expr atan(1.0)]
639 
} {0.785398}
640 
test expr-old-32.4 {math functions in expressions} {
641 
    format %.6g [expr atan2(2.0, 2.0)]
642 
} {0.785398}
643 
test expr-old-32.5 {math functions in expressions} {
644 
    format %.6g [expr ceil(1.999)]
645 
} {2}
646 
test expr-old-32.6 {math functions in expressions} {
647 
    format %.6g [expr cos(.1)]
648 
} {0.995004}
649 
test expr-old-32.7 {math functions in expressions} {
650 
    format %.6g [expr cosh(.1)]
651 
} {1.005}
652 
test expr-old-32.8 {math functions in expressions} {
653 
    format %.6g [expr exp(1.0)]
654 
} {2.71828}
655 
test expr-old-32.9 {math functions in expressions} {
656 
    format %.6g [expr floor(2.000)]
657 
} {2}
658 
test expr-old-32.10 {math functions in expressions} {
659 
    format %.6g [expr floor(2.001)]
660 
} {2}
661 
test expr-old-32.11 {math functions in expressions} {
662 
    format %.6g [expr fmod(7.3, 3.2)]
663 
} {0.9}
664 
test expr-old-32.12 {math functions in expressions} {
665 
    format %.6g [expr hypot(3.0, 4.0)]
666 
} {5}
667 
test expr-old-32.13 {math functions in expressions} {
668 
    format %.6g [expr log(2.8)]
669 
} {1.02962}
670 
test expr-old-32.14 {math functions in expressions} {
671 
    format %.6g [expr log10(2.8)]
672 
} {0.447158}
673 
test expr-old-32.15 {math functions in expressions} {
674 
    format %.6g [expr pow(2.1, 3.1)]
675 
} {9.97424}
676 
test expr-old-32.16 {math functions in expressions} {
677 
    format %.6g [expr sin(.1)]
678 
} {0.0998334}
679 
test expr-old-32.17 {math functions in expressions} {
680 
    format %.6g [expr sinh(.1)]
681 
} {0.100167}
682 
test expr-old-32.18 {math functions in expressions} {
683 
    format %.6g [expr sqrt(2.0)]
684 
} {1.41421}
685 
test expr-old-32.19 {math functions in expressions} {
686 
    format %.6g [expr tan(0.8)]
687 
} {1.02964}
688 
test expr-old-32.20 {math functions in expressions} {
689 
    format %.6g [expr tanh(0.8)]
690 
} {0.664037}
691 
test expr-old-32.21 {math functions in expressions} {
692 
    format %.6g [expr abs(-1.8)]
693 
} {1.8}
694 
test expr-old-32.22 {math functions in expressions} {
695 
    expr abs(10.0)
696 
} {10.0}
697 
test expr-old-32.23 {math functions in expressions} {
698 
    format %.6g [expr abs(-4)]
699 
} {4}
700 
test expr-old-32.24 {math functions in expressions} {
701 
    format %.6g [expr abs(66)]
702 
} {66}
703 
 
704 
# The following test is different for 32-bit versus 64-bit architectures.
705 
 
706 
if {0x80000000 > 0} {
707 
    test expr-old-32.25 {math functions in expressions} {nonPortable} {
708 
        list [catch {expr abs(0x8000000000000000)} msg] $msg
709 
    } {1 {integer value too large to represent}}
710 
} else {
711 
    test expr-old-32.25 {math functions in expressions} {nonPortable} {
712 
        list [catch {expr abs(0x80000000)} msg] $msg
713 
    } {1 {integer value too large to represent}}
714 
}
715 
 
716 
test expr-old-32.26 {math functions in expressions} {
717 
    expr double(1)
718 
} {1.0}
719 
test expr-old-32.27 {math functions in expressions} {
720 
    expr double(1.1)
721 
} {1.1}
722 
test expr-old-32.28 {math functions in expressions} {
723 
    expr int(1)
724 
} {1}
725 
test expr-old-32.29 {math functions in expressions} {
726 
    expr int(1.4)
727 
} {1}
728 
test expr-old-32.30 {math functions in expressions} {
729 
    expr int(1.6)
730 
} {1}
731 
test expr-old-32.31 {math functions in expressions} {
732 
    expr int(-1.4)
733 
} {-1}
734 
test expr-old-32.32 {math functions in expressions} {
735 
    expr int(-1.6)
736 
} {-1}
737 
test expr-old-32.33 {math functions in expressions} {
738 
    list [catch {expr int(1e60)} msg] $msg
739 
} {1 {integer value too large to represent}}
740 
test expr-old-32.34 {math functions in expressions} {
741 
    list [catch {expr int(-1e60)} msg] $msg
742 
} {1 {integer value too large to represent}}
743 
test expr-old-32.35 {math functions in expressions} {
744 
    expr round(1.49)
745 
} {1}
746 
test expr-old-32.36 {math functions in expressions} {
747 
    expr round(1.51)
748 
} {2}
749 
test expr-old-32.37 {math functions in expressions} {
750 
    expr round(-1.49)
751 
} {-1}
752 
test expr-old-32.38 {math functions in expressions} {
753 
    expr round(-1.51)
754 
} {-2}
755 
test expr-old-32.39 {math functions in expressions} {
756 
    list [catch {expr round(1e60)} msg] $msg
757 
} {1 {integer value too large to represent}}
758 
test expr-old-32.40 {math functions in expressions} {
759 
    list [catch {expr round(-1e60)} msg] $msg
760 
} {1 {integer value too large to represent}}
761 
test expr-old-32.41 {math functions in expressions} {
762 
    list [catch {expr pow(1.0 + 3.0 - 2, .8 * 5)} msg] $msg
763 
} {0 16.0}
764 
test expr-old-32.42 {math functions in expressions} {
765 
    list [catch {expr hypot(5*.8,3)} msg] $msg
766 
} {0 5.0}
767 
if $gotT1 {
768 
    test expr-old-32.43 {math functions in expressions} {
769 
        expr 2*T1()
770 
    } 246
771 
    test expr-old-32.44 {math functions in expressions} {
772 
        expr T2()*3
773 
    } 1035
774 
}
775 
test expr-old-32.45 {math functions in expressions} {
776 
    expr (0 <= rand()) && (rand() < 1)
777 
} {1}
778 
test expr-old-32.46 {math functions in expressions} {
779 
    list [catch {expr rand(24)} msg] $msg
780 
} {1 {syntax error in expression "rand(24)"}}
781 
test expr-old-32.47 {math functions in expressions} {
782 
    list [catch {expr srand()} msg] $msg
783 
} {1 {syntax error in expression "srand()"}}
784 
test expr-old-32.48 {math functions in expressions} {
785 
    list [catch {expr srand(3.79)} msg] $msg
786 
} {1 {can't use floating-point value as argument to srand}}
787 
test expr-old-32.49 {math functions in expressions} {
788 
    list [catch {expr srand("")} msg] $msg
789 
} {1 {can't use non-numeric string as argument to srand}}
790 
test expr-old-32.50 {math functions in expressions} {
791 
    set result [expr round(srand(12345) * 1000)]
792 
    for {set i 0} {$i < 10} {incr i} {
793 
        lappend result [expr round(rand() * 1000)]
794 
    }
795 
    set result
796 
} {97 834 948 36 12 51 766 585 914 784 333}
797 
test expr-old-32.51 {math functions in expressions} {
798 
    list [catch {expr {srand([lindex "6ty" 0])}} msg] $msg
799 
} {1 {can't use non-numeric string as argument to srand}}
800 
 
801 
test expr-old-33.1 {conversions and fancy args to math functions} {
802 
    expr hypot ( 3 , 4 )
803 
} 5.0
804 
test expr-old-33.2 {conversions and fancy args to math functions} {
805 
    expr hypot ( (2.0+1.0) , 4 )
806 
} 5.0
807 
test expr-old-33.3 {conversions and fancy args to math functions} {
808 
    expr hypot ( 3 , (3.0 + 1.0) )
809 
} 5.0
810 
test expr-old-33.4 {conversions and fancy args to math functions} {
811 
    format %.6g [expr cos(acos(0.1))]
812 
} 0.1
813 
 
814 
test expr-old-34.1 {errors in math functions} {
815 
    list [catch {expr func_2(1.0)} msg] $msg
816 
} {1 {unknown math function "func_2"}}
817 
test expr-old-34.2 {errors in math functions} {
818 
    list [catch {expr func|(1.0)} msg] $msg
819 
} {1 {syntax error in expression "func|(1.0)"}}
820 
test expr-old-34.3 {errors in math functions} {
821 
    list [catch {expr {hypot("a b", 2.0)}} msg] $msg
822 
} {1 {argument to math function didn't have numeric value}}
823 
test expr-old-34.4 {errors in math functions} {
824 
    list [catch {expr hypot(1.0 2.0)} msg] $msg
825 
} {1 {syntax error in expression "hypot(1.0 2.0)"}}
826 
test expr-old-34.5 {errors in math functions} {
827 
    list [catch {expr hypot(1.0, 2.0} msg] $msg
828 
} {1 {syntax error in expression "hypot(1.0, 2.0"}}
829 
test expr-old-34.6 {errors in math functions} {
830 
    list [catch {expr hypot(1.0 ,} msg] $msg
831 
} {1 {syntax error in expression "hypot(1.0 ,"}}
832 
test expr-old-34.7 {errors in math functions} {
833 
    list [catch {expr hypot(1.0)} msg] $msg
834 
} {1 {too few arguments for math function}}
835 
test expr-old-34.8 {errors in math functions} {
836 
    list [catch {expr hypot(1.0, 2.0, 3.0)} msg] $msg
837 
} {1 {too many arguments for math function}}
838 
test expr-old-34.9 {errors in math functions} {
839 
    list [catch {expr acos(-2.0)} msg] $msg $errorCode
840 
} {1 {domain error: argument not in valid range} {ARITH DOMAIN {domain error: argument not in valid range}}}
841 
test expr-old-34.10 {errors in math functions} {nonPortable} {
842 
    list [catch {expr pow(-3, 1000001)} msg] $msg $errorCode
843 
} {1 {floating-point value too large to represent} {ARITH OVERFLOW {floating-point value too large to represent}}}
844 
test expr-old-34.11 {errors in math functions} {
845 
    list [catch {expr pow(3, 1000001)} msg] $msg $errorCode
846 
} {1 {floating-point value too large to represent} {ARITH OVERFLOW {floating-point value too large to represent}}}
847 
test expr-old-34.12 {errors in math functions} {
848 
    list [catch {expr -14.0*exp(100000)} msg] $msg $errorCode
849 
} {1 {floating-point value too large to represent} {ARITH OVERFLOW {floating-point value too large to represent}}}
850 
test expr-old-34.13 {errors in math functions} {
851 
    list [catch {expr int(1.0e30)} msg] $msg $errorCode
852 
} {1 {integer value too large to represent} {ARITH IOVERFLOW {integer value too large to represent}}}
853 
test expr-old-34.14 {errors in math functions} {
854 
    list [catch {expr int(-1.0e30)} msg] $msg $errorCode
855 
} {1 {integer value too large to represent} {ARITH IOVERFLOW {integer value too large to represent}}}
856 
test expr-old-34.15 {errors in math functions} {
857 
    list [catch {expr round(1.0e30)} msg] $msg $errorCode
858 
} {1 {integer value too large to represent} {ARITH IOVERFLOW {integer value too large to represent}}}
859 
test expr-old-34.16 {errors in math functions} {
860 
    list [catch {expr round(-1.0e30)} msg] $msg $errorCode
861 
} {1 {integer value too large to represent} {ARITH IOVERFLOW {integer value too large to represent}}}
862 
if $gotT1 {
863 
    test expr-old-34.17 {errors in math functions} {
864 
        list [catch {expr T1(4)} msg] $msg
865 
    } {1 {syntax error in expression "T1(4)"}}
866 
}
867 
 
868 
test expr-old-36.1 {ExprLooksLikeInt procedure} {
869 
    list [catch {expr 0289} msg] $msg
870 
} {1 {syntax error in expression "0289"}}
871 
test expr-old-36.2 {ExprLooksLikeInt procedure} {
872 
    set x 0289
873 
    list [catch {expr {$x+1}} msg] $msg
874 
} {1 {can't use non-numeric string as operand of "+"}}
875 
test expr-old-36.3 {ExprLooksLikeInt procedure} {
876 
    list [catch {expr 0289.1} msg] $msg
877 
} {0 289.1}
878 
test expr-old-36.4 {ExprLooksLikeInt procedure} {
879 
    set x 0289.1
880 
    list [catch {expr {$x+1}} msg] $msg
881 
} {0 290.1}
882 
test expr-old-36.5 {ExprLooksLikeInt procedure} {
883 
    set x {  +22}
884 
    list [catch {expr {$x+1}} msg] $msg
885 
} {0 23}
886 
test expr-old-36.6 {ExprLooksLikeInt procedure} {
887 
    set x {     -22}
888 
    list [catch {expr {$x+1}} msg] $msg
889 
} {0 -21}
890 
test expr-old-36.7 {ExprLooksLikeInt procedure} {nonPortable unixOnly} {
891 
    list [catch {expr nan} msg] $msg
892 
} {1 {domain error: argument not in valid range}}
893 
test expr-old-36.8 {ExprLooksLikeInt procedure} {
894 
    list [catch {expr 78e1} msg] $msg
895 
} {0 780.0}
896 
test expr-old-36.9 {ExprLooksLikeInt procedure} {
897 
    list [catch {expr 24E1} msg] $msg
898 
} {0 240.0}
899 
test expr-old-36.10 {ExprLooksLikeInt procedure} {nonPortable unixOnly} {
900 
    list [catch {expr 78e} msg] $msg
901 
} {1 {syntax error in expression "78e"}}
902 
 
903 
if {[info commands testexprlong] == {}} {
904 
    puts "This application hasn't been compiled with the \"testexprlong\""
905 
    puts "command, so I can't test Tcl_ExprLong etc."
906 
} else {
907 
test expr-old-37.1 {Check that Tcl_ExprLong doesn't modify interpreter result if no error} {
908 
    testexprlong
909 
} {This is a result: 5}
910 
}
911 
 
912 
if {[info commands testexprstring] == {}} {
913 
    puts "This application hasn't been compiled with the \"testexprstring\""
914 
    puts "command, so I can't test Tcl_ExprString etc."
915 
} else {
916 
test expr-old-38.1 {Verify Tcl_ExprString's basic operation} {
917 
    list [testexprstring "1+4"] [testexprstring "2*3+4.2"] \
918 
        [catch {testexprstring "1+"} msg] $msg
919 
} {5 10.2 1 {syntax error in expression "1+"}}
920 
}
921 
 
922 
# Special test for Pentium arithmetic bug of 1994:
923 
 
924 
if {(4195835.0 - (4195835.0/3145727.0)*3145727.0) == 256.0} {
925 
    puts "Warning: this machine contains a defective Pentium processor"
926 
    puts "that performs arithmetic incorrectly.  I recommend that you"
927 
    puts "call Intel customer service immediately at 1-800-628-8686"
928 
    puts "to request a replacement processor."
929 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.