1089 lines
33 KiB
Plaintext
1089 lines
33 KiB
Plaintext
# This file contains tests for the tclExecute.c source file. Tests appear in
|
||
# the same order as the C code that they test. The set of tests is currently
|
||
# incomplete since it currently includes only new tests for code changed for
|
||
# the addition of Tcl namespaces. Other execution-related tests appear in
|
||
# several other test files including namespace.test, basic.test, eval.test,
|
||
# for.test, etc.
|
||
#
|
||
# Sourcing this file into Tcl runs the tests and generates output for errors.
|
||
# No output means no errors were found.
|
||
#
|
||
# Copyright (c) 1997 Sun Microsystems, Inc.
|
||
# Copyright (c) 1998-1999 by Scriptics Corporation.
|
||
#
|
||
# See the file "license.terms" for information on usage and redistribution of
|
||
# this file, and for a DISCLAIMER OF ALL WARRANTIES.
|
||
|
||
if {"::tcltest" ni [namespace children]} {
|
||
package require tcltest 2
|
||
namespace import -force ::tcltest::*
|
||
}
|
||
|
||
::tcltest::loadTestedCommands
|
||
catch [list package require -exact Tcltest [info patchlevel]]
|
||
|
||
catch {namespace delete {*}[namespace children :: test_ns_*]}
|
||
catch {rename foo ""}
|
||
catch {unset x}
|
||
catch {unset y}
|
||
catch {unset msg}
|
||
|
||
testConstraint testobj [expr {
|
||
[llength [info commands testobj]]
|
||
&& [llength [info commands testdoubleobj]]
|
||
&& [llength [info commands teststringobj]]
|
||
}]
|
||
|
||
testConstraint longIs32bit [expr {int(0x80000000) < 0}]
|
||
testConstraint testexprlongobj [llength [info commands testexprlongobj]]
|
||
|
||
# Tests for the omnibus TclExecuteByteCode function:
|
||
|
||
# INST_DONE not tested
|
||
# INST_PUSH1 not tested
|
||
# INST_PUSH4 not tested
|
||
# INST_POP not tested
|
||
# INST_DUP not tested
|
||
# INST_INVOKE_STK4 not tested
|
||
# INST_INVOKE_STK1 not tested
|
||
# INST_EVAL_STK not tested
|
||
# INST_EXPR_STK not tested
|
||
|
||
# INST_LOAD_SCALAR1
|
||
test execute-1.1 {TclExecuteByteCode, INST_LOAD_SCALAR1, small opnd} {
|
||
proc foo {} {
|
||
set x 1
|
||
return $x
|
||
}
|
||
foo
|
||
} 1
|
||
test execute-1.2 {TclExecuteByteCode, INST_LOAD_SCALAR1, large opnd} {
|
||
# Bug: 2243
|
||
set body {}
|
||
for {set i 0} {$i < 129} {incr i} {
|
||
append body "set x$i x\n"
|
||
}
|
||
append body {
|
||
set y 1
|
||
return $y
|
||
}
|
||
proc foo {} $body
|
||
foo
|
||
} 1
|
||
test execute-1.3 {TclExecuteByteCode, INST_LOAD_SCALAR1, error} {
|
||
proc foo {} {
|
||
set x 1
|
||
unset x
|
||
return $x
|
||
}
|
||
list [catch {foo} msg] $msg
|
||
} {1 {can't read "x": no such variable}}
|
||
|
||
# INST_LOAD_SCALAR4
|
||
test execute-2.1 {TclExecuteByteCode, INST_LOAD_SCALAR4, simple case} {
|
||
set body {}
|
||
for {set i 0} {$i < 256} {incr i} {
|
||
append body "set x$i x\n"
|
||
}
|
||
append body {
|
||
set y 1
|
||
return $y
|
||
}
|
||
proc foo {} $body
|
||
foo
|
||
} 1
|
||
test execute-2.2 {TclExecuteByteCode, INST_LOAD_SCALAR4, error} {
|
||
set body {}
|
||
for {set i 0} {$i < 256} {incr i} {
|
||
append body "set x$i x\n"
|
||
}
|
||
append body {
|
||
set y 1
|
||
unset y
|
||
return $y
|
||
}
|
||
proc foo {} $body
|
||
list [catch {foo} msg] $msg
|
||
} {1 {can't read "y": no such variable}}
|
||
|
||
# INST_LOAD_SCALAR_STK not tested
|
||
# INST_LOAD_ARRAY4 not tested
|
||
# INST_LOAD_ARRAY1 not tested
|
||
# INST_LOAD_ARRAY_STK not tested
|
||
# INST_LOAD_STK not tested
|
||
# INST_STORE_SCALAR4 not tested
|
||
# INST_STORE_SCALAR1 not tested
|
||
# INST_STORE_SCALAR_STK not tested
|
||
# INST_STORE_ARRAY4 not tested
|
||
# INST_STORE_ARRAY1 not tested
|
||
# INST_STORE_ARRAY_STK not tested
|
||
# INST_STORE_STK not tested
|
||
# INST_INCR_SCALAR1 not tested
|
||
# INST_INCR_SCALAR_STK not tested
|
||
# INST_INCR_STK not tested
|
||
# INST_INCR_ARRAY1 not tested
|
||
# INST_INCR_ARRAY_STK not tested
|
||
# INST_INCR_SCALAR1_IMM not tested
|
||
# INST_INCR_SCALAR_STK_IMM not tested
|
||
# INST_INCR_STK_IMM not tested
|
||
# INST_INCR_ARRAY1_IMM not tested
|
||
# INST_INCR_ARRAY_STK_IMM not tested
|
||
# INST_JUMP1 not tested
|
||
# INST_JUMP4 not tested
|
||
# INST_JUMP_TRUE4 not tested
|
||
# INST_JUMP_TRUE1 not tested
|
||
# INST_JUMP_FALSE4 not tested
|
||
# INST_JUMP_FALSE1 not tested
|
||
# INST_LOR not tested
|
||
# INST_LAND not tested
|
||
# INST_EQ not tested
|
||
# INST_NEQ not tested
|
||
# INST_LT not tested
|
||
# INST_GT not tested
|
||
# INST_LE not tested
|
||
# INST_GE not tested
|
||
# INST_MOD not tested
|
||
# INST_LSHIFT not tested
|
||
# INST_RSHIFT not tested
|
||
# INST_BITOR not tested
|
||
# INST_BITXOR not tested
|
||
# INST_BITAND not tested
|
||
|
||
# INST_ADD is partially tested:
|
||
test execute-3.1 {TclExecuteByteCode, INST_ADD, op1 is int} {testobj} {
|
||
set x [testintobj set 0 1]
|
||
expr {$x + 1}
|
||
} 2
|
||
test execute-3.2 {TclExecuteByteCode, INST_ADD, op1 is double} {testobj} {
|
||
set x [testdoubleobj set 0 1]
|
||
expr {$x + 1}
|
||
} 2.0
|
||
test execute-3.3 {TclExecuteByteCode, INST_ADD, op1 is double with string} {testobj} {
|
||
set x [testintobj set 0 1]
|
||
testobj convert 0 double
|
||
expr {$x + 1}
|
||
} 2
|
||
test execute-3.4 {TclExecuteByteCode, INST_ADD, op1 is string int} {testobj} {
|
||
set x [teststringobj set 0 1]
|
||
expr {$x + 1}
|
||
} 2
|
||
test execute-3.5 {TclExecuteByteCode, INST_ADD, op1 is string double} {testobj} {
|
||
set x [teststringobj set 0 1.0]
|
||
expr {$x + 1}
|
||
} 2.0
|
||
test execute-3.6 {TclExecuteByteCode, INST_ADD, op1 is non-numeric} {testobj} {
|
||
set x [teststringobj set 0 foo]
|
||
list [catch {expr {$x + 1}} msg] $msg
|
||
} {1 {can't use non-numeric string as operand of "+"}}
|
||
test execute-3.7 {TclExecuteByteCode, INST_ADD, op2 is int} {testobj} {
|
||
set x [testintobj set 0 1]
|
||
expr {1 + $x}
|
||
} 2
|
||
test execute-3.8 {TclExecuteByteCode, INST_ADD, op2 is double} {testobj} {
|
||
set x [testdoubleobj set 0 1]
|
||
expr {1 + $x}
|
||
} 2.0
|
||
test execute-3.9 {TclExecuteByteCode, INST_ADD, op2 is double with string} {testobj} {
|
||
set x [testintobj set 0 1]
|
||
testobj convert 0 double
|
||
expr {1 + $x}
|
||
} 2
|
||
test execute-3.10 {TclExecuteByteCode, INST_ADD, op2 is string int} {testobj} {
|
||
set x [teststringobj set 0 1]
|
||
expr {1 + $x}
|
||
} 2
|
||
test execute-3.11 {TclExecuteByteCode, INST_ADD, op2 is string double} {testobj} {
|
||
set x [teststringobj set 0 1.0]
|
||
expr {1 + $x}
|
||
} 2.0
|
||
test execute-3.12 {TclExecuteByteCode, INST_ADD, op2 is non-numeric} {testobj} {
|
||
set x [teststringobj set 0 foo]
|
||
list [catch {expr {1 + $x}} msg] $msg
|
||
} {1 {can't use non-numeric string as operand of "+"}}
|
||
|
||
# INST_SUB is partially tested:
|
||
test execute-3.13 {TclExecuteByteCode, INST_SUB, op1 is int} {testobj} {
|
||
set x [testintobj set 0 1]
|
||
expr {$x - 1}
|
||
} 0
|
||
test execute-3.14 {TclExecuteByteCode, INST_SUB, op1 is double} {testobj} {
|
||
set x [testdoubleobj set 0 1]
|
||
expr {$x - 1}
|
||
} 0.0
|
||
test execute-3.15 {TclExecuteByteCode, INST_SUB, op1 is double with string} {testobj} {
|
||
set x [testintobj set 0 1]
|
||
testobj convert 0 double
|
||
expr {$x - 1}
|
||
} 0
|
||
test execute-3.16 {TclExecuteByteCode, INST_SUB, op1 is string int} {testobj} {
|
||
set x [teststringobj set 0 1]
|
||
expr {$x - 1}
|
||
} 0
|
||
test execute-3.17 {TclExecuteByteCode, INST_SUB, op1 is string double} {testobj} {
|
||
set x [teststringobj set 0 1.0]
|
||
expr {$x - 1}
|
||
} 0.0
|
||
test execute-3.18 {TclExecuteByteCode, INST_SUB, op1 is non-numeric} {testobj} {
|
||
set x [teststringobj set 0 foo]
|
||
list [catch {expr {$x - 1}} msg] $msg
|
||
} {1 {can't use non-numeric string as operand of "-"}}
|
||
test execute-3.19 {TclExecuteByteCode, INST_SUB, op2 is int} {testobj} {
|
||
set x [testintobj set 0 1]
|
||
expr {1 - $x}
|
||
} 0
|
||
test execute-3.20 {TclExecuteByteCode, INST_SUB, op2 is double} {testobj} {
|
||
set x [testdoubleobj set 0 1]
|
||
expr {1 - $x}
|
||
} 0.0
|
||
test execute-3.21 {TclExecuteByteCode, INST_SUB, op2 is double with string} {testobj} {
|
||
set x [testintobj set 0 1]
|
||
testobj convert 0 double
|
||
expr {1 - $x}
|
||
} 0
|
||
test execute-3.22 {TclExecuteByteCode, INST_SUB, op2 is string int} {testobj} {
|
||
set x [teststringobj set 0 1]
|
||
expr {1 - $x}
|
||
} 0
|
||
test execute-3.23 {TclExecuteByteCode, INST_SUB, op2 is string double} {testobj} {
|
||
set x [teststringobj set 0 1.0]
|
||
expr {1 - $x}
|
||
} 0.0
|
||
test execute-3.24 {TclExecuteByteCode, INST_SUB, op2 is non-numeric} {testobj} {
|
||
set x [teststringobj set 0 foo]
|
||
list [catch {expr {1 - $x}} msg] $msg
|
||
} {1 {can't use non-numeric string as operand of "-"}}
|
||
|
||
# INST_MULT is partially tested:
|
||
test execute-3.25 {TclExecuteByteCode, INST_MULT, op1 is int} {testobj} {
|
||
set x [testintobj set 1 1]
|
||
expr {$x * 1}
|
||
} 1
|
||
test execute-3.26 {TclExecuteByteCode, INST_MULT, op1 is double} {testobj} {
|
||
set x [testdoubleobj set 1 2.0]
|
||
expr {$x * 1}
|
||
} 2.0
|
||
test execute-3.27 {TclExecuteByteCode, INST_MULT, op1 is double with string} {testobj} {
|
||
set x [testintobj set 1 2]
|
||
testobj convert 1 double
|
||
expr {$x * 1}
|
||
} 2
|
||
test execute-3.28 {TclExecuteByteCode, INST_MULT, op1 is string int} {testobj} {
|
||
set x [teststringobj set 1 1]
|
||
expr {$x * 1}
|
||
} 1
|
||
test execute-3.29 {TclExecuteByteCode, INST_MULT, op1 is string double} {testobj} {
|
||
set x [teststringobj set 1 1.0]
|
||
expr {$x * 1}
|
||
} 1.0
|
||
test execute-3.30 {TclExecuteByteCode, INST_MULT, op1 is non-numeric} {testobj} {
|
||
set x [teststringobj set 1 foo]
|
||
list [catch {expr {$x * 1}} msg] $msg
|
||
} {1 {can't use non-numeric string as operand of "*"}}
|
||
test execute-3.31 {TclExecuteByteCode, INST_MULT, op2 is int} {testobj} {
|
||
set x [testintobj set 1 1]
|
||
expr {1 * $x}
|
||
} 1
|
||
test execute-3.32 {TclExecuteByteCode, INST_MULT, op2 is double} {testobj} {
|
||
set x [testdoubleobj set 1 2.0]
|
||
expr {1 * $x}
|
||
} 2.0
|
||
test execute-3.33 {TclExecuteByteCode, INST_MULT, op2 is double with string} {testobj} {
|
||
set x [testintobj set 1 2]
|
||
testobj convert 1 double
|
||
expr {1 * $x}
|
||
} 2
|
||
test execute-3.34 {TclExecuteByteCode, INST_MULT, op2 is string int} {testobj} {
|
||
set x [teststringobj set 1 1]
|
||
expr {1 * $x}
|
||
} 1
|
||
test execute-3.35 {TclExecuteByteCode, INST_MULT, op2 is string double} {testobj} {
|
||
set x [teststringobj set 1 1.0]
|
||
expr {1 * $x}
|
||
} 1.0
|
||
test execute-3.36 {TclExecuteByteCode, INST_MULT, op2 is non-numeric} {testobj} {
|
||
set x [teststringobj set 1 foo]
|
||
list [catch {expr {1 * $x}} msg] $msg
|
||
} {1 {can't use non-numeric string as operand of "*"}}
|
||
|
||
# INST_DIV is partially tested:
|
||
test execute-3.37 {TclExecuteByteCode, INST_DIV, op1 is int} {testobj} {
|
||
set x [testintobj set 1 1]
|
||
expr {$x / 1}
|
||
} 1
|
||
test execute-3.38 {TclExecuteByteCode, INST_DIV, op1 is double} {testobj} {
|
||
set x [testdoubleobj set 1 2.0]
|
||
expr {$x / 1}
|
||
} 2.0
|
||
test execute-3.39 {TclExecuteByteCode, INST_DIV, op1 is double with string} {testobj} {
|
||
set x [testintobj set 1 2]
|
||
testobj convert 1 double
|
||
expr {$x / 1}
|
||
} 2
|
||
test execute-3.40 {TclExecuteByteCode, INST_DIV, op1 is string int} {testobj} {
|
||
set x [teststringobj set 1 1]
|
||
expr {$x / 1}
|
||
} 1
|
||
test execute-3.41 {TclExecuteByteCode, INST_DIV, op1 is string double} {testobj} {
|
||
set x [teststringobj set 1 1.0]
|
||
expr {$x / 1}
|
||
} 1.0
|
||
test execute-3.42 {TclExecuteByteCode, INST_DIV, op1 is non-numeric} {testobj} {
|
||
set x [teststringobj set 1 foo]
|
||
list [catch {expr {$x / 1}} msg] $msg
|
||
} {1 {can't use non-numeric string as operand of "/"}}
|
||
test execute-3.43 {TclExecuteByteCode, INST_DIV, op2 is int} {testobj} {
|
||
set x [testintobj set 1 1]
|
||
expr {2 / $x}
|
||
} 2
|
||
test execute-3.44 {TclExecuteByteCode, INST_DIV, op2 is double} {testobj} {
|
||
set x [testdoubleobj set 1 1.0]
|
||
expr {2 / $x}
|
||
} 2.0
|
||
test execute-3.45 {TclExecuteByteCode, INST_DIV, op2 is double with string} {testobj} {
|
||
set x [testintobj set 1 1]
|
||
testobj convert 1 double
|
||
expr {2 / $x}
|
||
} 2
|
||
test execute-3.46 {TclExecuteByteCode, INST_DIV, op2 is string int} {testobj} {
|
||
set x [teststringobj set 1 1]
|
||
expr {2 / $x}
|
||
} 2
|
||
test execute-3.47 {TclExecuteByteCode, INST_DIV, op2 is string double} {testobj} {
|
||
set x [teststringobj set 1 1.0]
|
||
expr {2 / $x}
|
||
} 2.0
|
||
test execute-3.48 {TclExecuteByteCode, INST_DIV, op2 is non-numeric} {testobj} {
|
||
set x [teststringobj set 1 foo]
|
||
list [catch {expr {1 / $x}} msg] $msg
|
||
} {1 {can't use non-numeric string as operand of "/"}}
|
||
|
||
# INST_UPLUS is partially tested:
|
||
test execute-3.49 {TclExecuteByteCode, INST_UPLUS, op is int} {testobj} {
|
||
set x [testintobj set 1 1]
|
||
expr {+ $x}
|
||
} 1
|
||
test execute-3.50 {TclExecuteByteCode, INST_UPLUS, op is double} {testobj} {
|
||
set x [testdoubleobj set 1 1.0]
|
||
expr {+ $x}
|
||
} 1.0
|
||
test execute-3.51 {TclExecuteByteCode, INST_UPLUS, op is double with string} {testobj} {
|
||
set x [testintobj set 1 1]
|
||
testobj convert 1 double
|
||
expr {+ $x}
|
||
} 1
|
||
test execute-3.52 {TclExecuteByteCode, INST_UPLUS, op is string int} {testobj} {
|
||
set x [teststringobj set 1 1]
|
||
expr {+ $x}
|
||
} 1
|
||
test execute-3.53 {TclExecuteByteCode, INST_UPLUS, op is string double} {testobj} {
|
||
set x [teststringobj set 1 1.0]
|
||
expr {+ $x}
|
||
} 1.0
|
||
test execute-3.54 {TclExecuteByteCode, INST_UPLUS, op is non-numeric} {testobj} {
|
||
set x [teststringobj set 1 foo]
|
||
list [catch {expr {+ $x}} msg] $msg
|
||
} {1 {can't use non-numeric string as operand of "+"}}
|
||
|
||
# INST_UMINUS is partially tested:
|
||
test execute-3.55 {TclExecuteByteCode, INST_UMINUS, op is int} {testobj} {
|
||
set x [testintobj set 1 1]
|
||
expr {- $x}
|
||
} -1
|
||
test execute-3.56 {TclExecuteByteCode, INST_UMINUS, op is double} {testobj} {
|
||
set x [testdoubleobj set 1 1.0]
|
||
expr {- $x}
|
||
} -1.0
|
||
test execute-3.57 {TclExecuteByteCode, INST_UMINUS, op is double with string} {testobj} {
|
||
set x [testintobj set 1 1]
|
||
testobj convert 1 double
|
||
expr {- $x}
|
||
} -1
|
||
test execute-3.58 {TclExecuteByteCode, INST_UMINUS, op is string int} {testobj} {
|
||
set x [teststringobj set 1 1]
|
||
expr {- $x}
|
||
} -1
|
||
test execute-3.59 {TclExecuteByteCode, INST_UMINUS, op is string double} {testobj} {
|
||
set x [teststringobj set 1 1.0]
|
||
expr {- $x}
|
||
} -1.0
|
||
test execute-3.60 {TclExecuteByteCode, INST_UMINUS, op is non-numeric} {testobj} {
|
||
set x [teststringobj set 1 foo]
|
||
list [catch {expr {- $x}} msg] $msg
|
||
} {1 {can't use non-numeric string as operand of "-"}}
|
||
|
||
# INST_LNOT is partially tested:
|
||
test execute-3.61 {TclExecuteByteCode, INST_LNOT, op is int} {testobj} {
|
||
set x [testintobj set 1 2]
|
||
expr {! $x}
|
||
} 0
|
||
test execute-3.62 {TclExecuteByteCode, INST_LNOT, op is int} {testobj} {
|
||
set x [testintobj set 1 0]
|
||
expr {! $x}
|
||
} 1
|
||
test execute-3.63 {TclExecuteByteCode, INST_LNOT, op is double} {testobj} {
|
||
set x [testdoubleobj set 1 1.0]
|
||
expr {! $x}
|
||
} 0
|
||
test execute-3.64 {TclExecuteByteCode, INST_LNOT, op is double} {testobj} {
|
||
set x [testdoubleobj set 1 0.0]
|
||
expr {! $x}
|
||
} 1
|
||
test execute-3.65 {TclExecuteByteCode, INST_LNOT, op is double with string} {testobj} {
|
||
set x [testintobj set 1 1]
|
||
testobj convert 1 double
|
||
expr {! $x}
|
||
} 0
|
||
test execute-3.66 {TclExecuteByteCode, INST_LNOT, op is double with string} {testobj} {
|
||
set x [testintobj set 1 0]
|
||
testobj convert 1 double
|
||
expr {! $x}
|
||
} 1
|
||
test execute-3.67 {TclExecuteByteCode, INST_LNOT, op is string int} {testobj} {
|
||
set x [teststringobj set 1 1]
|
||
expr {! $x}
|
||
} 0
|
||
test execute-3.68 {TclExecuteByteCode, INST_LNOT, op is string int} {testobj} {
|
||
set x [teststringobj set 1 0]
|
||
expr {! $x}
|
||
} 1
|
||
test execute-3.69 {TclExecuteByteCode, INST_LNOT, op is string double} {testobj} {
|
||
set x [teststringobj set 1 1.0]
|
||
expr {! $x}
|
||
} 0
|
||
test execute-3.70 {TclExecuteByteCode, INST_LNOT, op is string double} {testobj} {
|
||
set x [teststringobj set 1 0.0]
|
||
expr {! $x}
|
||
} 1
|
||
test execute-3.71 {TclExecuteByteCode, INST_LNOT, op is non-numeric} {testobj} {
|
||
set x [teststringobj set 1 foo]
|
||
list [catch {expr {! $x}} msg] $msg
|
||
} {1 {can't use non-numeric string as operand of "!"}}
|
||
|
||
# INST_BITNOT not tested
|
||
# INST_CALL_BUILTIN_FUNC1 not tested
|
||
# INST_CALL_FUNC1 not tested
|
||
|
||
# INST_TRY_CVT_TO_NUMERIC is partially tested:
|
||
test execute-3.72 {TclExecuteByteCode, INST_TRY_CVT_TO_NUMERIC, op is int} {testobj} {
|
||
set x [testintobj set 1 1]
|
||
expr {$x}
|
||
} 1
|
||
test execute-3.73 {TclExecuteByteCode, INST_TRY_CVT_TO_NUMERIC, op is double} {testobj} {
|
||
set x [testdoubleobj set 1 1.0]
|
||
expr {$x}
|
||
} 1.0
|
||
test execute-3.74 {TclExecuteByteCode, INST_TRY_CVT_TO_NUMERIC, op is double with string} {testobj} {
|
||
set x [testintobj set 1 1]
|
||
testobj convert 1 double
|
||
expr {$x}
|
||
} 1
|
||
test execute-3.75 {TclExecuteByteCode, INST_TRY_CVT_TO_NUMERIC, op is string int} {testobj} {
|
||
set x [teststringobj set 1 1]
|
||
expr {$x}
|
||
} 1
|
||
test execute-3.76 {TclExecuteByteCode, INST_TRY_CVT_TO_NUMERIC, op is string double} {testobj} {
|
||
set x [teststringobj set 1 1.0]
|
||
expr {$x}
|
||
} 1.0
|
||
test execute-3.77 {TclExecuteByteCode, INST_TRY_CVT_TO_NUMERIC, op is non-numeric} {testobj} {
|
||
set x [teststringobj set 1 foo]
|
||
expr {$x}
|
||
} foo
|
||
|
||
# INST_BREAK not tested
|
||
# INST_CONTINUE not tested
|
||
# INST_FOREACH_START4 not tested
|
||
# INST_FOREACH_STEP4 not tested
|
||
# INST_BEGIN_CATCH4 not tested
|
||
# INST_END_CATCH not tested
|
||
# INST_PUSH_RESULT not tested
|
||
# INST_PUSH_RETURN_CODE not tested
|
||
|
||
test execute-4.1 {Tcl_GetCommandFromObj, convert to tclCmdNameType} -setup {
|
||
catch {namespace delete {*}[namespace children :: test_ns_*]}
|
||
unset -nocomplain x
|
||
unset -nocomplain y
|
||
} -body {
|
||
namespace eval test_ns_1 {
|
||
namespace export cmd1
|
||
proc cmd1 {args} {return "cmd1: $args"}
|
||
proc cmd2 {args} {return "cmd2: $args"}
|
||
}
|
||
namespace eval test_ns_1::test_ns_2 {
|
||
namespace import ::test_ns_1::*
|
||
}
|
||
set x "test_ns_1::"
|
||
set y "test_ns_2::"
|
||
list [namespace which -command ${x}${y}cmd1] \
|
||
[catch {namespace which -command ${x}${y}cmd2} msg] $msg \
|
||
[catch {namespace which -command ${x}${y}:cmd2} msg] $msg
|
||
} -result {::test_ns_1::test_ns_2::cmd1 0 {} 0 {}}
|
||
test execute-4.2 {Tcl_GetCommandFromObj, check if cached tclCmdNameType is invalid} -setup {
|
||
catch {namespace delete {*}[namespace children :: test_ns_*]}
|
||
catch {rename foo ""}
|
||
unset -nocomplain l
|
||
} -body {
|
||
proc foo {} {
|
||
return "global foo"
|
||
}
|
||
namespace eval test_ns_1 {
|
||
proc whichFoo {} {
|
||
return [namespace which -command foo]
|
||
}
|
||
}
|
||
set l ""
|
||
lappend l [test_ns_1::whichFoo]
|
||
namespace eval test_ns_1 {
|
||
proc foo {} {
|
||
return "namespace foo"
|
||
}
|
||
}
|
||
lappend l [test_ns_1::whichFoo]
|
||
} -result {::foo ::test_ns_1::foo}
|
||
test execute-4.3 {Tcl_GetCommandFromObj, command never found} -setup {
|
||
catch {namespace delete {*}[namespace children :: test_ns_*]}
|
||
catch {rename foo ""}
|
||
} -body {
|
||
namespace eval test_ns_1 {
|
||
proc foo {} {
|
||
return "namespace foo"
|
||
}
|
||
}
|
||
namespace eval test_ns_1 {
|
||
proc foo {} {
|
||
return "namespace foo"
|
||
}
|
||
}
|
||
list [namespace eval test_ns_1 {namespace which -command foo}] \
|
||
[rename test_ns_1::foo ""] \
|
||
[catch {namespace eval test_ns_1 {namespace which -command foo}} msg] $msg
|
||
} -result {::test_ns_1::foo {} 0 {}}
|
||
|
||
test execute-5.1 {SetCmdNameFromAny, set cmd name to empty heap string if NULL} -setup {
|
||
catch {namespace delete {*}[namespace children :: test_ns_*]}
|
||
unset -nocomplain l
|
||
} -body {
|
||
proc {} {} {return {}}
|
||
{}
|
||
set l {}
|
||
lindex {} 0
|
||
{}
|
||
} -result {}
|
||
|
||
test execute-6.1 {UpdateStringOfCmdName: called for duplicate of empty cmdName object} {
|
||
proc {} {} {}
|
||
proc { } {} {}
|
||
proc p {} {
|
||
set x {}
|
||
$x
|
||
append x { }
|
||
$x
|
||
}
|
||
p
|
||
} {}
|
||
test execute-6.2 {Evaluate an expression in a variable; compile the first time, do not the second} {
|
||
set w {3*5}
|
||
proc a {obj} {expr $obj}
|
||
set res "[a $w]:[a $w]"
|
||
} {15:15}
|
||
test execute-6.3 {Tcl_ExprObj: don't use cached script bytecode [Bug 1899164]} -setup {
|
||
proc 0+0 {} {return SCRIPT}
|
||
} -body {
|
||
set e { 0+0 }
|
||
if 1 $e
|
||
if 1 {expr $e}
|
||
} -cleanup {
|
||
rename 0+0 {}
|
||
} -result 0
|
||
test execute-6.4 {TclCompEvalObj: don't use cached expr bytecode [Bug 1899164]} -setup {
|
||
proc 0+0 {} {return SCRIPT}
|
||
} -body {
|
||
set e { 0+0 }
|
||
if 1 {expr $e}
|
||
if 1 $e
|
||
} -cleanup {
|
||
rename 0+0 {}
|
||
} -result SCRIPT
|
||
test execute-6.5 {TclCompEvalObj: bytecode epoch validation} -body {
|
||
set script { llength {} }
|
||
set result {}
|
||
lappend result [if 1 $script]
|
||
set origName [namespace which llength]
|
||
rename $origName llength.orig
|
||
proc $origName {args} {return AHA!}
|
||
lappend result [if 1 $script]
|
||
} -cleanup {
|
||
rename $origName {}
|
||
rename llength.orig $origName
|
||
} -result {0 AHA!}
|
||
test execute-6.6 {TclCompEvalObj: proc-body bytecode invalid for script} -body {
|
||
proc foo {} {set a 1}
|
||
set a untouched
|
||
set result {}
|
||
lappend result [foo] $a
|
||
lappend result [if 1 [info body foo]] $a
|
||
} -cleanup {
|
||
rename foo {}
|
||
} -result {1 untouched 1 1}
|
||
test execute-6.7 {TclCompEvalObj: bytecode context validation} -setup {
|
||
namespace eval foo {}
|
||
} -body {
|
||
set script { llength {} }
|
||
namespace eval foo {
|
||
proc llength {args} {return AHA!}
|
||
}
|
||
set result {}
|
||
lappend result [if 1 $script]
|
||
lappend result [namespace eval foo $script]
|
||
} -cleanup {
|
||
namespace delete foo
|
||
} -result {0 AHA!}
|
||
test execute-6.8 {TclCompEvalObj: bytecode name resolution epoch validation} -setup {
|
||
namespace eval foo {}
|
||
} -body {
|
||
set script { llength {} }
|
||
set result {}
|
||
lappend result [namespace eval foo $script]
|
||
namespace eval foo {
|
||
proc llength {args} {return AHA!}
|
||
}
|
||
lappend result [namespace eval foo $script]
|
||
} -cleanup {
|
||
namespace delete foo
|
||
} -result {0 AHA!}
|
||
test execute-6.9 {TclCompEvalObj: bytecode interp validation} -setup {
|
||
interp create slave
|
||
} -body {
|
||
set script { llength {} }
|
||
slave eval {proc llength args {return AHA!}}
|
||
set result {}
|
||
lappend result [if 1 $script]
|
||
lappend result [slave eval $script]
|
||
} -cleanup {
|
||
interp delete slave
|
||
} -result {0 AHA!}
|
||
test execute-6.10 {TclCompEvalObj: bytecode interp validation} -body {
|
||
set script { llength {} }
|
||
interp create slave
|
||
set result {}
|
||
lappend result [slave eval $script]
|
||
interp delete slave
|
||
interp create slave
|
||
lappend result [slave eval $script]
|
||
} -cleanup {
|
||
catch {interp delete slave}
|
||
} -result {0 0}
|
||
test execute-6.11 {Tcl_ExprObj: exprcode interp validation} -setup {
|
||
interp create slave
|
||
} -constraints testexprlongobj -body {
|
||
set e { [llength {}]+1 }
|
||
set result {}
|
||
load {} Tcltest slave
|
||
interp alias {} e slave testexprlongobj
|
||
lappend result [e $e]
|
||
interp delete slave
|
||
interp create slave
|
||
load {} Tcltest slave
|
||
interp alias {} e slave testexprlongobj
|
||
lappend result [e $e]
|
||
} -cleanup {
|
||
interp delete slave
|
||
} -result {{This is a result: 1} {This is a result: 1}}
|
||
test execute-6.12 {Tcl_ExprObj: exprcode interp validation} -setup {
|
||
interp create slave
|
||
} -body {
|
||
set e { [llength {}]+1 }
|
||
set result {}
|
||
interp alias {} e slave expr
|
||
lappend result [e $e]
|
||
interp delete slave
|
||
interp create slave
|
||
interp alias {} e slave expr
|
||
lappend result [e $e]
|
||
} -cleanup {
|
||
interp delete slave
|
||
} -result {1 1}
|
||
test execute-6.13 {Tcl_ExprObj: exprcode epoch validation} -body {
|
||
set e { [llength {}]+1 }
|
||
set result {}
|
||
lappend result [expr $e]
|
||
set origName [namespace which llength]
|
||
rename $origName llength.orig
|
||
proc $origName {args} {return 1}
|
||
lappend result [expr $e]
|
||
} -cleanup {
|
||
rename $origName {}
|
||
rename llength.orig $origName
|
||
} -result {1 2}
|
||
test execute-6.14 {Tcl_ExprObj: exprcode context validation} -setup {
|
||
namespace eval foo {}
|
||
} -body {
|
||
set e { [llength {}]+1 }
|
||
namespace eval foo {
|
||
proc llength {args} {return 1}
|
||
}
|
||
set result {}
|
||
lappend result [expr $e]
|
||
lappend result [namespace eval foo [list expr $e]]
|
||
} -cleanup {
|
||
namespace delete foo
|
||
} -result {1 2}
|
||
test execute-6.15 {Tcl_ExprObj: exprcode name resolution epoch validation} -setup {
|
||
namespace eval foo {}
|
||
} -body {
|
||
set e { [llength {}]+1 }
|
||
set result {}
|
||
lappend result [namespace eval foo [list expr $e]]
|
||
namespace eval foo {
|
||
proc llength {args} {return 1}
|
||
}
|
||
lappend result [namespace eval foo [list expr $e]]
|
||
} -cleanup {
|
||
namespace delete foo
|
||
} -result {1 2}
|
||
test execute-6.16 {Tcl_ExprObj: exprcode interp validation} -setup {
|
||
interp create slave
|
||
} -body {
|
||
set e { [llength {}]+1 }
|
||
interp alias {} e slave expr
|
||
slave eval {proc llength args {return 1}}
|
||
set result {}
|
||
lappend result [expr $e]
|
||
lappend result [e $e]
|
||
} -cleanup {
|
||
interp delete slave
|
||
} -result {1 2}
|
||
test execute-6.17 {Tcl_ExprObj: exprcode context validation} -body {
|
||
proc foo e {set v 0; expr $e}
|
||
proc bar e {set v 1; expr $e}
|
||
set e { $v }
|
||
set result {}
|
||
lappend result [foo $e]
|
||
lappend result [bar $e]
|
||
} -cleanup {
|
||
rename foo {}
|
||
rename bar {}
|
||
} -result {0 1}
|
||
test execute-6.18 {Tcl_ExprObj: exprcode context validation} -body {
|
||
proc foo e {set v {}; expr $e}
|
||
proc bar e {set v v; expr $e}
|
||
set e { [llength $v] }
|
||
set result {}
|
||
lappend result [foo $e]
|
||
lappend result [bar $e]
|
||
} -cleanup {
|
||
rename foo {}
|
||
rename bar {}
|
||
} -result {0 1}
|
||
|
||
test execute-7.0 {Wide int handling in INST_JUMP_FALSE/LAND} {
|
||
set x 0x100000000
|
||
expr {$x && 1}
|
||
} 1
|
||
test execute-7.1 {Wide int handling in INST_JUMP_FALSE/LAND} {
|
||
expr {0x100000000 && 1}
|
||
} 1
|
||
test execute-7.2 {Wide int handling in INST_JUMP_FALSE/LAND} {
|
||
expr {1 && 0x100000000}
|
||
} 1
|
||
test execute-7.3 {Wide int handling in INST_JUMP_FALSE/LAND} {
|
||
expr {wide(0x100000000) && 1}
|
||
} 1
|
||
test execute-7.4 {Wide int handling in INST_JUMP_FALSE/LAND} {
|
||
expr {1 && wide(0x100000000)}
|
||
} 1
|
||
test execute-7.5 {Wide int handling in INST_EQ} {
|
||
expr {4 == (wide(1)+wide(3))}
|
||
} 1
|
||
test execute-7.6 {Wide int handling in INST_EQ and [incr]} {
|
||
set x 399999999999
|
||
expr {400000000000 == [incr x]}
|
||
} 1
|
||
# wide ints have more bits of precision than doubles, but we convert anyway
|
||
test execute-7.7 {Wide int handling in INST_EQ and [incr]} {
|
||
set x [expr {wide(1)<<62}]
|
||
set y [expr {$x+1}]
|
||
expr {double($x) == double($y)}
|
||
} 1
|
||
test execute-7.8 {Wide int conversions can change sign} longIs32bit {
|
||
set x 0x80000000
|
||
expr {int($x) < wide($x)}
|
||
} 1
|
||
test execute-7.9 {Wide int handling in INST_MOD} {
|
||
expr {(wide(1)<<60) % ((wide(47)<<45)-1)}
|
||
} 316659348800185
|
||
test execute-7.10 {Wide int handling in INST_MOD} {
|
||
expr {((wide(1)<<60)-1) % 0x400000000}
|
||
} 17179869183
|
||
test execute-7.11 {Wide int handling in INST_LSHIFT} {
|
||
expr wide(42)<<30
|
||
} 45097156608
|
||
test execute-7.12 {Wide int handling in INST_LSHIFT} {
|
||
expr 12345678901<<3
|
||
} 98765431208
|
||
test execute-7.13 {Wide int handling in INST_RSHIFT} {
|
||
expr 0x543210febcda9876>>7
|
||
} 47397893236700464
|
||
test execute-7.14 {Wide int handling in INST_RSHIFT} {
|
||
expr wide(0x9876543210febcda)>>7
|
||
} -58286587177206407
|
||
test execute-7.15 {Wide int handling in INST_BITOR} {
|
||
expr wide(0x9876543210febcda) | 0x543210febcda9876
|
||
} -2560765885044310786
|
||
test execute-7.16 {Wide int handling in INST_BITXOR} {
|
||
expr wide(0x9876543210febcda) ^ 0x543210febcda9876
|
||
} -3727778945703861076
|
||
test execute-7.17 {Wide int handling in INST_BITAND} {
|
||
expr wide(0x9876543210febcda) & 0x543210febcda9876
|
||
} 1167013060659550290
|
||
test execute-7.18 {Wide int handling in INST_ADD} {
|
||
expr wide(0x7fffffff)+wide(0x7fffffff)
|
||
} 4294967294
|
||
test execute-7.19 {Wide int handling in INST_ADD} {
|
||
expr 0x7fffffff+wide(0x7fffffff)
|
||
} 4294967294
|
||
test execute-7.20 {Wide int handling in INST_ADD} {
|
||
expr wide(0x7fffffff)+0x7fffffff
|
||
} 4294967294
|
||
test execute-7.21 {Wide int handling in INST_ADD} {
|
||
expr double(0x7fffffff)+wide(0x7fffffff)
|
||
} 4294967294.0
|
||
test execute-7.22 {Wide int handling in INST_ADD} {
|
||
expr wide(0x7fffffff)+double(0x7fffffff)
|
||
} 4294967294.0
|
||
test execute-7.23 {Wide int handling in INST_SUB} {
|
||
expr 0x123456789a-0x20406080a
|
||
} 69530054800
|
||
test execute-7.24 {Wide int handling in INST_MULT} {
|
||
expr 0x123456789a*193
|
||
} 15090186251290
|
||
test execute-7.25 {Wide int handling in INST_DIV} {
|
||
expr 0x123456789a/193
|
||
} 405116546
|
||
test execute-7.26 {Wide int handling in INST_UPLUS} {
|
||
set x 0x123456871234568
|
||
expr {+ $x}
|
||
} 81985533099853160
|
||
test execute-7.27 {Wide int handling in INST_UMINUS} {
|
||
set x 0x123456871234568
|
||
expr {- $x}
|
||
} -81985533099853160
|
||
test execute-7.28 {Wide int handling in INST_LNOT} {
|
||
set x 0x123456871234568
|
||
expr {! $x}
|
||
} 0
|
||
test execute-7.29 {Wide int handling in INST_BITNOT} {
|
||
set x 0x123456871234568
|
||
expr {~ $x}
|
||
} -81985533099853161
|
||
test execute-7.30 {Wide int handling in function call} {
|
||
set x 0x12345687123456
|
||
incr x
|
||
expr {log($x) == log(double($x))}
|
||
} 1
|
||
test execute-7.31 {Wide int handling in abs()} {
|
||
set x 0xa23456871234568
|
||
incr x
|
||
set y 0x123456871234568
|
||
concat [expr {abs($x)}] [expr {abs($y)}]
|
||
} {730503879441204585 81985533099853160}
|
||
test execute-7.32 {Wide int handling} longIs32bit {
|
||
expr {int(1024 * 1024 * 1024 * 1024)}
|
||
} 0
|
||
test execute-7.33 {Wide int handling} longIs32bit {
|
||
expr {int(0x1 * 1024 * 1024 * 1024 * 1024)}
|
||
} 0
|
||
test execute-7.34 {Wide int handling} {
|
||
expr {wide(0x1) * 1024 * 1024 * 1024 * 1024}
|
||
} 1099511627776
|
||
|
||
test execute-8.1 {Stack protection} -setup {
|
||
# If [Bug #804681] has not been properly taken care of, this should
|
||
# segfault
|
||
proc whatever args {llength $args}
|
||
trace add variable ::errorInfo {write unset} whatever
|
||
} -body {
|
||
expr {1+9/0}
|
||
} -cleanup {
|
||
trace remove variable ::errorInfo {write unset} whatever
|
||
rename whatever {}
|
||
} -returnCodes error -match glob -result *
|
||
test execute-8.2 {Stack restoration} -setup {
|
||
# Avoid crashes when system stack size is limited (thread-enabled!)
|
||
set limit [interp recursionlimit {}]
|
||
interp recursionlimit {} 100
|
||
} -body {
|
||
# Test for [Bug #816641], correct restoration of the stack top after the
|
||
# stack is grown
|
||
proc f {args} { f bee bop }
|
||
catch f msg
|
||
set msg
|
||
} -cleanup {
|
||
interp recursionlimit {} $limit
|
||
} -result {too many nested evaluations (infinite loop?)}
|
||
test execute-8.3 {Stack restoration} -setup {
|
||
# Avoid crashes when system stack size is limited (thread-enabled!)
|
||
set limit [interp recursionlimit {}]
|
||
interp recursionlimit {} 100
|
||
} -body {
|
||
# Test for [Bug #1055676], correct restoration of the stack top after the
|
||
# epoch is bumped and the stack is grown in a call from a nested
|
||
# evaluation
|
||
set arglst [string repeat "a " 1000]
|
||
proc f {args} "f $arglst"
|
||
proc run {} {
|
||
# bump the interp's epoch
|
||
rename ::set ::dummy
|
||
rename ::dummy ::set
|
||
catch f msg
|
||
set msg
|
||
}
|
||
run
|
||
} -cleanup {
|
||
interp recursionlimit {} $limit
|
||
} -result {too many nested evaluations (infinite loop?)}
|
||
test execute-8.4 {Compile epoch bump effect on stack trace} -setup {
|
||
proc foo {} {
|
||
error bar
|
||
}
|
||
proc FOO {} {
|
||
catch {error bar} m o
|
||
rename ::set ::dummy
|
||
rename ::dummy ::set
|
||
return -options $o $m
|
||
}
|
||
} -body {
|
||
catch foo m o
|
||
set stack1 [dict get $o -errorinfo]
|
||
catch FOO m o
|
||
set stack2 [string map {FOO foo} [dict get $o -errorinfo]]
|
||
expr {$stack1 eq $stack2 ? {} : "These differ:\n$stack1\n$stack2"}
|
||
} -cleanup {
|
||
rename foo {}
|
||
rename FOO {}
|
||
unset -nocomplain m o stack1 stack2
|
||
} -result {}
|
||
test execute-8.5 {Bug 2038069} -setup {
|
||
proc demo {} {
|
||
catch [list error FOO] m o
|
||
return $o
|
||
}
|
||
} -body {
|
||
demo
|
||
} -cleanup {
|
||
rename demo {}
|
||
} -match glob -result {-code 1 -level 0 -errorstack * -errorcode NONE -errorinfo {FOO
|
||
while executing
|
||
"error FOO"
|
||
invoked from within
|
||
"catch \[list error FOO\] m o"} -errorline 2}
|
||
|
||
test execute-9.1 {Interp result resetting [Bug 1522803]} {
|
||
set c 0
|
||
catch {
|
||
catch {set foo}
|
||
expr {1/$c}
|
||
}
|
||
if {[string match *foo* $::errorInfo]} {
|
||
set result "Bad errorInfo: $::errorInfo"
|
||
} else {
|
||
set result SUCCESS
|
||
}
|
||
set result
|
||
} SUCCESS
|
||
|
||
test execute-10.1 {TclExecuteByteCode, INST_CONCAT1, bytearrays} {
|
||
apply {s {binary scan $s c x; list $x [scan $s$s %c%c]}} \u0130
|
||
} {48 {304 304}}
|
||
test execute-10.2 {Bug 2802881} -setup {
|
||
interp create slave
|
||
} -body {
|
||
# If [Bug 2802881] is not fixed, this will segfault
|
||
slave eval {
|
||
trace add variable ::errorInfo write {expr {$foo} ;#}
|
||
proc demo {} {a {}{}}
|
||
demo
|
||
}
|
||
} -cleanup {
|
||
interp delete slave
|
||
} -returnCodes error -match glob -result *
|
||
test execute-10.3 {Bug 3072640} -setup {
|
||
proc generate {n} {
|
||
for {set i 0} {$i < $n} {incr i} {
|
||
yield $i
|
||
}
|
||
}
|
||
proc t {args} {
|
||
incr ::foo
|
||
}
|
||
trace add execution ::generate enterstep ::t
|
||
} -body {
|
||
coroutine coro generate 5
|
||
trace remove execution ::generate enterstep ::t
|
||
set ::foo
|
||
} -cleanup {
|
||
unset ::foo
|
||
rename generate {}
|
||
rename t {}
|
||
rename coro {}
|
||
} -result 4
|
||
|
||
test execute-11.1 {Bug 3142026: GrowEvaluationStack off-by-one} -setup {
|
||
interp create slave
|
||
} -body {
|
||
slave eval {
|
||
set x [lrepeat 1320 199]
|
||
for {set i 0} {$i < 20} {incr i} {
|
||
lappend x $i
|
||
lsort -integer $x
|
||
}
|
||
# Crashes on failure
|
||
return ok
|
||
}
|
||
} -cleanup {
|
||
interp delete slave
|
||
} -result ok
|
||
|
||
test execute-11.2 {Bug 268b23df11} -setup {
|
||
proc zero {} {return 0}
|
||
proc crash {} {expr {abs([zero])}}
|
||
proc noop args {}
|
||
trace add execution crash enterstep noop
|
||
} -body {
|
||
crash
|
||
} -cleanup {
|
||
trace remove execution crash enterstep noop
|
||
rename noop {}
|
||
rename crash {}
|
||
rename zero {}
|
||
} -result 0
|
||
test execute-11.3 {Bug a0ece9d6d4} -setup {
|
||
proc crash {} {expr {rand()}}
|
||
trace add execution crash enterstep {apply {args {info frame -2}}}
|
||
} -body {
|
||
string is double [crash]
|
||
} -cleanup {
|
||
trace remove execution crash enterstep {apply {args {info frame -2}}}
|
||
rename crash {}
|
||
} -result 1
|
||
|
||
# cleanup
|
||
if {[info commands testobj] != {}} {
|
||
testobj freeallvars
|
||
}
|
||
catch {namespace delete {*}[namespace children :: test_ns_*]}
|
||
catch {rename foo ""}
|
||
catch {rename p ""}
|
||
catch {rename {} ""}
|
||
catch {rename { } ""}
|
||
catch {unset x}
|
||
catch {unset y}
|
||
catch {unset msg}
|
||
::tcltest::cleanupTests
|
||
return
|
||
|
||
# Local Variables:
|
||
# mode: tcl
|
||
# fill-column: 78
|
||
# End:
|