tcl8.7a5/tests/compile.test

# This file contains tests for the files tclCompile.c, tclCompCmds.c and
# tclLiteral.c
#
# This file contains a collection of tests for one or more of the Tcl built-in
# commands. Sourcing this file into Tcl runs the tests and generates output
# for errors. No output means no errors were found.
#
# Copyright © 1997 Sun Microsystems, Inc.
# Copyright © 1998-1999 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.5
    namespace import -force ::tcltest::*
}


::tcltest::loadTestedCommands
catch [list package require -exact tcl::test [info patchlevel]]

testConstraint exec       [llength [info commands exec]]
testConstraint memory     [llength [info commands memory]]
testConstraint testevalex [llength [info commands testevalex]]

# The following tests are very incomplete, although the rest of the
# test suite covers this file fairly well.

catch {rename p ""}
catch {namespace delete test_ns_compile}
catch {unset x}
catch {unset y}
catch {unset a}

test compile-1.1 {TclCompileString: look up cmds in proc ns, not current ns} -setup {
    catch {namespace delete test_ns_compile}
    catch {unset x}
} -body {
    set x 123
    namespace eval test_ns_compile {
        proc set {args} {
            global x
            lappend x test_ns_compile::set
        }
        proc p {} {
            set 0
        }
    }
    list [test_ns_compile::p] [set x]
} -result {{123 test_ns_compile::set} {123 test_ns_compile::set}}
test compile-1.2 {TclCompileString, error result is reset if TclGetLong determines word isn't an integer} {
    proc p {x} {info commands 3m}
    list [catch {p} msg] $msg
} {1 {wrong # args: should be "p x"}}

test compile-2.1 {TclCompileDollarVar: global scalar name with ::s} -setup {
    catch {unset x}
} -body {
    set x 123
    list $::x [expr {"x" in [info globals]}]
} -result {123 1}
test compile-2.2 {TclCompileDollarVar: global scalar name with ::s} -setup {
    catch {unset y}
} -body {
    proc p {} {
        set ::y 789
        return $::y
    }
    list [p] $::y [expr {"y" in [info globals]}]
} -result {789 789 1}
test compile-2.3 {TclCompileDollarVar: global array name with ::s} -setup {
    catch {unset a}
} -body {
    set ::a(1) 2
    list $::a(1) [set ::a($::a(1)) 3] $::a(2) [expr {"a" in [info globals]}]
} -result {2 3 3 1}
test compile-2.4 {TclCompileDollarVar: global scalar name with ::s} -setup {
    catch {unset a}
} -body {
    proc p {} {
        set ::a(1) 1
        return $::a($::a(1))
    }
    list [p] $::a(1) [expr {"a" in [info globals]}]
} -result {1 1 1}
test compile-2.5 {TclCompileDollarVar: global array, called as ${arrName(0)}} -setup {
    catch {unset a}
} -body {
    proc p {} {
	global a
        set a(1) 1
        return ${a(1)}$::a(1)$a(1)
    }
    list [p] $::a(1) [expr {"a" in [info globals]}]
} -result {111 1 1}

test compile-3.1 {TclCompileCatchCmd: only catch cmds with scalar vars are compiled inline} -setup {
    catch {unset a}
} -body {
    set a(1) xyzzyx
    proc p {} {
        global a
        catch {set x 123} a(1)
    }
    list [p] $a(1)
} -result {0 123}
test compile-3.2 {TclCompileCatchCmd: non-local variables} {
    set ::foo 1
    proc catch-test {} {
	catch {set x 3} ::foo
    }
    catch-test
    return $::foo
} 3
test compile-3.3 {TclCompileCatchCmd: overagressive compiling [bug 219184]} {
    proc catch-test {str} {
	catch [eval $str GOOD]
	error BAD
    }
    catch {catch-test error} ::foo
    return $::foo
} {GOOD}
test compile-3.4 {TclCompileCatchCmd: bcc'ed [return] is caught} {
    proc foo {} {
	set fail [catch {
	    return 1
	}] ; # {}
	return 2
    }
    foo
} {2}
test compile-3.5 {TclCompileCatchCmd: recover from error, [Bug 705406]} {
    proc foo {} {
	catch {
	    if {[a]} {
		if b {}
	    }
	}
    }
    list [catch foo msg] $msg
} {0 1}
test compile-3.6 {TclCompileCatchCmd: error in storing result [Bug 3098302]} {*}{
     -setup {
	 namespace eval catchtest {
	     variable result1 {}
	 }
	 trace add variable catchtest::result1 write catchtest::failtrace
	 proc catchtest::failtrace {n1 n2 op} {
	     return -code error "trace on $n1 fails by request"
	 }
     }
    -body {
	proc catchtest::x {} {
	    variable result1
	    set count 0
	    for {set i 0} {$i < 10} {incr i} {
		set status2 [catch {
		    set status1 [catch {
			return -code error -level 0 "original failure"
		    } result1 options1]
		} result2 options2]
		incr count
	    }
	    list $count $result2
	}
	catchtest::x
    }
    -result {10 {can't set "result1": trace on result1 fails by request}}
    -cleanup {namespace delete catchtest}
}

test compile-3.7 {TclCompileCatchCmd: error in storing options [Bug 3098302]} {*}{
     -setup {
	 namespace eval catchtest {
	     variable options1 {}
	 }
	 trace add variable catchtest::options1 write catchtest::failtrace
	 proc catchtest::failtrace {n1 n2 op} {
	     return -code error "trace on $n1 fails by request"
	 }
     }
    -body {
	proc catchtest::x {} {
	    variable options1
	    set count 0
	    for {set i 0} {$i < 10} {incr i} {
		set status2 [catch {
		    set status1 [catch {
			return -code error -level 0 "original failure"
		    } result1 options1]
		} result2 options2]
		incr count
	    }
	    list $count $result2
	}
	catchtest::x
    }
    -result {10 {can't set "options1": trace on options1 fails by request}}
    -cleanup {namespace delete catchtest}
}

test compile-4.1 {TclCompileForCmd: command substituted test expression} {
    set i 0
    set j 0
    # Should be "forever"
    for {} [expr {$i < 3}] {} {
	set j [incr i]
	if {$j > 3} break
    }
    set j
} {4}

test compile-5.1 {TclCompileForeachCmd: exception stack} {
    proc foreach-exception-test {} {
	foreach array(index) [list 1 2 3] break
	foreach array(index) [list 1 2 3] break
	foreach scalar [list 1 2 3] break
    }
    list [catch foreach-exception-test result] $result
} {0 {}}
test compile-5.2 {TclCompileForeachCmd: non-local variables} {
    set ::foo 1
    proc foreach-test {} {
	foreach ::foo {1 2 3} {}
    }
    foreach-test
    set ::foo
} 3
test compile-5.3 {TclCompileForeachCmd: [Bug b9b2079e6d]} -setup {
    proc demo {} {
	foreach x y {
	    if 1 break else
	}
    }
} -body {
    demo
} -cleanup {
    rename demo {}
} -returnCodes error -result {wrong # args: no script following "else" argument}

test compile-6.1 {TclCompileSetCmd: global scalar names with ::s} -setup {
    catch {unset x}
    catch {unset y}
} -body {
    set x 123
    proc p {} {
        set ::y 789
        return $::y
    }
    list $::x [expr {"x" in [info globals]}] \
         [p] $::y [expr {"y" in [info globals]}]
} -result {123 1 789 789 1}
test compile-6.2 {TclCompileSetCmd: global array names with ::s} -setup {
    catch {unset a}
} -body {
    set ::a(1) 2
    proc p {} {
        set ::a(1) 1
        return $::a($::a(1))
    }
    list $::a(1) [p] [set ::a($::a(1)) 3] $::a(1) [expr {"a" in [info globals]}]
} -result {2 1 3 3 1}
test compile-6.3 {TclCompileSetCmd: namespace var names with ::s} -setup {
    catch {namespace delete test_ns_compile}
    catch {unset x}
} -body {
    namespace eval test_ns_compile {
        variable v hello
        variable arr
        set ::x $::test_ns_compile::v
	set ::test_ns_compile::arr(1) 123
    }
    list $::x $::test_ns_compile::arr(1)
} -result {hello 123}

test compile-7.1 {TclCompileWhileCmd: command substituted test expression} {
    set i 0
    set j 0
    # Should be "forever"
    while [expr {$i < 3}] {
	set j [incr i]
	if {$j > 3} break
    }
    set j
} {4}

test compile-8.1 {CollectArgInfo: binary data} {
    list [catch "string length \x00foo" msg] $msg
} {0 4}
test compile-8.2 {CollectArgInfo: binary data} {
    list [catch "string length foo\x00" msg] $msg
} {0 4}
test compile-8.3 {CollectArgInfo: handle "]" at end of command properly} {
    set x ]
} {]}

test compile-9.1 {UpdateStringOfByteCode: called for duplicate of compiled empty object} {
    proc p {} {
        set x {}
        eval $x
        append x { }
        eval $x
    }
    p
} {}

test compile-10.1 {BLACKBOX: exception stack overflow} {
    set x {{0}}
    set y 0
    while {$y < 100} {
	if !$x {incr y}
    }
} {}

test compile-11.1 {Tcl_Append*: ensure Tcl_ResetResult is used properly} -body {
    apply {{} {
	# shared object - Interp result && Var 'r'
	set r [list foobar]
	# command that will add error to result
	lindex a bogus
    }}
} -returnCodes error -result {bad index "bogus": must be integer?[+-]integer? or end?[+-]integer?}
test compile-11.2 {Tcl_Append*: ensure Tcl_ResetResult is used properly} -body {
    apply {{} { set r [list foobar] ; string index a bogus }}
} -returnCodes error -result {bad index "bogus": must be integer?[+-]integer? or end?[+-]integer?}
test compile-11.3 {Tcl_Append*: ensure Tcl_ResetResult is used properly} -body {
    apply {{} { set r [list foobar] ; string index a 0o9 }}
} -returnCodes error -match glob -result {*invalid octal number*}
test compile-11.4 {Tcl_Append*: ensure Tcl_ResetResult is used properly} -body {
    apply {{} { set r [list foobar] ; array set var {one two many} }}
} -returnCodes error -result {list must have an even number of elements}
test compile-11.5 {Tcl_Append*: ensure Tcl_ResetResult is used properly} -body {
    apply {{} { set r [list foobar] ; incr foo bar baz}}
} -returnCodes error -result {wrong # args: should be "incr varName ?increment?"}
test compile-11.6 {Tcl_Append*: ensure Tcl_ResetResult is used properly} -body {
    apply {{} { set r [list foobar] ; incr}}
} -returnCodes error -result {wrong # args: should be "incr varName ?increment?"}
test compile-11.7 {Tcl_Append*: ensure Tcl_ResetResult is used properly} -body {
    apply {{} { set r [list foobar] ; expr [concat !a] }}
} -returnCodes error -match glob -result *
test compile-11.8 {Tcl_Append*: ensure Tcl_ResetResult is used properly} -body {
    apply {{} { set r [list foobar] ; expr {!a} }}
} -returnCodes error -match glob -result *
test compile-11.9 {Tcl_Append*: ensure Tcl_ResetResult is used properly} -body {
    apply {{} { set r [list foobar] ; llength "\{" }}
    list [catch {p} msg] $msg
} -returnCodes error -result {unmatched open brace in list}

#
# Special section for tests of tclLiteral.c
# The following tests check for incorrect memory handling in
# TclReleaseLiteral. They are only effective when tcl is compiled with
# TCL_MEM_DEBUG
#
# Special test for leak on interp delete [Bug 467523].
test compile-12.1 {testing literal leak on interp delete} -setup {
    proc getbytes {} {
	set lines [split [memory info] "\n"]
	lindex $lines 3 3
    }
} -constraints memory -body {
    set end [getbytes]
    for {set i 0} {$i < 5} {incr i} {
	interp create foo
	foo eval {
	    namespace eval bar {}
	}
	interp delete foo
	set tmp $end
	set end [getbytes]
    }
    set leakedBytes [expr {$end - $tmp}]
} -cleanup {
    rename getbytes {}
    unset -nocomplain end i tmp leakedBytes
} -result 0
# Special test for a memory error in a preliminary fix of [Bug 467523].  It
# requires executing a helpfile.  Presumably the child process is used because
# when this test fails, it crashes.
test compile-12.2 {testing error on literal deletion} -constraints {memory exec} -body {
    set sourceFile [makeFile {
	for {set i 0} {$i < 5} {incr i} {
	    namespace eval bar {}
	    namespace delete bar
	}
	puts 0
    } source.file]
    exec [interpreter] $sourceFile
} -cleanup {
    catch {removeFile $sourceFile}
} -result 0
# Test to catch buffer overrun in TclCompileTokens from buf 530320
test compile-12.3 {check for a buffer overrun} -body {
    proc crash {} {
	puts $array([expr {a+2}])
    }
    crash
} -returnCodes error -cleanup {
    rename crash {}
} -match glob -result *
test compile-12.4 {TclCleanupLiteralTable segfault} -body {
    # Tcl Bug 1001997
    # Here, we're trying to test a case that causes a crash in
    # TclCleanupLiteralTable.  The conditions that we're trying to establish
    # are:
    # - TclCleanupLiteralTable is attempting to clean up a bytecode object in
    #   the literal table.
    # - The bytecode object in question contains the only reference to another
    #   literal.
    # - The literal in question is in the same hash bucket as the bytecode
    #   object, and immediately follows it in the chain.
    # Since newly registered literals are added at the FRONT of the bucket
    # chains, and since the bytecode object is registered before its literals,
    # this is difficult to achieve.  What we do is:
    #  (a) do a [namespace eval] of a string that's calculated to hash into
    #      the same bucket as a literal that it contains.  In this case, the
    #      script and the variable 'bugbug' land in the same bucket.
    #  (b) do a [namespace eval] of a string that contains enough literals to
    #      force TclRegisterLiteral to rebuild the global literal table.  The
    #      newly created hash buckets will contain the literals, IN REVERSE
    #      ORDER, thus putting the bytecode immediately ahead of 'bugbug' and
    #      'bug4345bug'.  The bytecode object will contain the only references
    #      to those two literals.
    #  (c) Delete the interpreter to invoke TclCleanupLiteralTable and tickle
    #      the bug.
    proc foo {} {
	set i [interp create]
	$i eval {
	    namespace eval ::w {concat 4649; variable bugbug}
	    namespace eval ::w {
		concat x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 \
		    x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 \
		    x21 x22 x23 x24 x25 x26 x27 x28 x29 x30 \
		    x31 x32 X33 X34 X35 X36 X37 X38 X39 X40 \
		    x41 x42 x43 x44 x45 x46 x47 x48 x49 x50 \
		    x51 x52 x53 x54 x55 x56 x57 x58 x59 x60 \
		    x61 x62 x63 x64
		concat y1 y2 y3 y4 y5 y6 y7 y8 y9 y10 \
		    y11 y12 y13 y14 y15 y16 y17 y18 y19 y20 \
		    y21 y22 y23 y24 y25 y26 y27 y28 y29 y30 \
		    y31 y32 Y33 Y34 Y35 Y36 Y37 Y38 Y39 Y40 \
		    y41 y42 y43 y44 y45 y46 y47 y48 y49 y50 \
		    y51 y52 y53 y54 y55 y56 y57 y58 y59 y60 \
		    y61 y62 y63 y64
		concat z1 z2 z3 z4 z5 z6 z7 z8 z9 z10 \
		    z11 z12 z13 z14 z15 z16 z17 z18 z19 z20 \
		    z21 z22 z23 z24 z25 z26 z27 z28 z29 z30 \
		    z31 z32
	    }
	}
	interp delete $i; # must not crash
	return ok
    }
    foo
} -cleanup {
    rename foo {}
} -result ok

# Special test for underestimating the maxStackSize required for a compiled
# command. A failure will cause a segfault in the child process.
test compile-13.1 {testing underestimate of maxStackSize in list cmd} {exec} {
    set body {set x [list}
    for {set i 0} {$i < 3000} {incr i} {
	append body " $i"
    }
    append body {]; puts OK}
    regsub BODY {proc crash {} {BODY}; crash} $body script
    list [catch {exec [interpreter] << $script} msg] $msg
} {0 OK}

# Tests of nested compile (body in body compilation), should not generate stack overflow
# (with abnormal program termination), bug [fec0c17d39]:
proc _ti_gencode {} {
    # creates test interpreter on demand with [gencode] generator:
    if {[interp exists ti]} {
	return
    }
    interp create ti
    ti eval {proc gencode {nr {cmd eval} {nl 0}} {
	set code ""
	set e ""; if {$nl} {set e "\n"}
	for {set i 0} {$i < $nr} {incr i} {
	    append code "$cmd \{$e"
	}
	append code "lappend result 1$e"
	for {set i 0} {$i < $nr} {incr i} {
	    append code "\}$e"
	}
	#puts [format "%% %.40s ... %d bytes" $code [string length $code]]
	return $code
    }}
}
test compile-13.2 {TclCompileScript: testing expected nested scripts compilation} -setup {
    _ti_gencode
    interp recursionlimit ti [expr {10000+50}]
    ti eval {set result {}}
} -body {
    # Test different compilation variants (instructions evalStk, invokeStk, etc),
    # with 1500 (1000 in debug) nested scripts (bodies). If you get SO/SF exceptions on some low-stack
    # boxes or systems, please don't decrease it (either provide a constraint)
    ti eval {foreach cmd {eval "if 1" try catch} {
	set c [gencode [expr {![::tcl::pkgconfig get debug] ? 1500 : 1000}] $cmd]
	if 1 $c
    }}
    ti eval {set result}
} -result {1 1 1 1}
test compile-13.3 {TclCompileScript: testing check of max depth by nested scripts compilation} -setup {
    _ti_gencode
    interp recursionlimit ti 100
    ti eval {set result {}}
} -body {
    # Test different compilation variants (instructions evalStk, invokeStk, etc),
    # with 500 nested scripts (bodies). It must generate "too many nested compilations"
    # error for any variant we're testing here:
    ti eval {foreach cmd {eval "if 1" try catch} {
	set c [gencode 500 $cmd]
	lappend errors [catch $c e] $e
    }}
    #puts $errors
    # all of nested calls exceed the limit, so must end with "too many nested compilations"
    # (or evaluations, depending on compile method/instruction and "mixed" compile within
    # evaliation), so no one succeeds, the result must be empty:
    ti eval {set result}
} -result {}
#
# clean up:
if {[interp exists ti]} {
    interp delete ti
}
rename _ti_gencode {}

# Tests compile-14.* for [Bug 599788] [Bug 0c043a175a47da8c2342]
test compile-14.1 {testing errors in element name; segfault?} {} {
     catch {set a([error])} msg1
     catch {set bubba([join $abba $jubba]) $vol} msg2
     list $msg1 $msg2
} {{wrong # args: should be "error message ?errorInfo? ?errorCode?"} {can't read "abba": no such variable}}

test compile-14.2 {testing element name "$"} -body {
    unset -nocomplain a
    set a() 1
    set a(1) 2
    set a($) 3
    list [set a()] [set a(1)] [set a($)] [unset a() a(1); lindex [array names a] 0]
} -cleanup {unset a} -result [list 1 2 3 {$}]


# Tests compile-15.* cover Tcl Bug 633204
test compile-15.1 {proper TCL_RETURN code from [return]} {
    apply {{} {catch return}}
} 2
test compile-15.2 {proper TCL_RETURN code from [return]} {
    apply {{} {catch {return foo}}}
} 2
test compile-15.3 {proper TCL_RETURN code from [return]} {
    apply {{} {catch {return $::tcl_library}}}
} 2
test compile-15.4 {proper TCL_RETURN code from [return]} {
    apply {{} {catch {return [info library]}}}
} 2
test compile-15.5 {proper TCL_RETURN code from [return]} {
    apply {{} {catch {set a 1}; return}}
} ""

# Do all tests once byte compiled and once with direct string evaluation
foreach noComp {0 1} {

if {$noComp} {
    interp alias {} run {} testevalex
    set constraints testevalex
} else {
    interp alias {} run {} if 1
    set constraints {}
}

test compile-16.1.$noComp {TclCompileScript: word expansion} $constraints {
    run "list [string repeat {{*}a } 255]"
} [lrepeat 255 a]
test compile-16.2.$noComp {TclCompileScript: word expansion} $constraints {
    run "list [string repeat {{*}a } 256]"
} [lrepeat 256 a]
test compile-16.3.$noComp {TclCompileScript: word expansion} $constraints {
    run "list [string repeat {{*}a } 257]"
} [lrepeat 257 a]
test compile-16.4.$noComp {TclCompileScript: word expansion} $constraints {
    run {{*}list}
} {}
test compile-16.5.$noComp {TclCompileScript: word expansion} $constraints {
    run {{*}list {*}{x y z}}
} {x y z}
test compile-16.6.$noComp {TclCompileScript: word expansion} $constraints {
    run {{*}list {*}[list x y z]}
} {x y z}
test compile-16.7.$noComp {TclCompileScript: word expansion} $constraints {
    run {{*}list {*}[list x y z][list x y z]}
} {x y zx y z}
test compile-16.8.$noComp {TclCompileScript: word expansion} -body {
    set l {x y z}
    run {{*}list {*}$l}
} -constraints $constraints -cleanup {
    unset l
} -result {x y z}
test compile-16.9.$noComp {TclCompileScript: word expansion} -body {
    set l {x y z}
    run {{*}list {*}$l$l}
} -constraints $constraints -cleanup {
    unset l
} -result {x y zx y z}
test compile-16.10.$noComp {TclCompileScript: word expansion} -body {
    run {{*}\{}
} -constraints $constraints -returnCodes error \
-result {unmatched open brace in list}
test compile-16.11.$noComp {TclCompileScript: word expansion} -body {
    proc badList {} {return \{}
    run {{*}[badList]}
} -constraints $constraints -cleanup {
    rename badList {}
} -returnCodes error  -result {unmatched open brace in list}
test compile-16.12.$noComp {TclCompileScript: word expansion} $constraints {
    run {{*}list x y z}
} {x y z}
test compile-16.13.$noComp {TclCompileScript: word expansion} $constraints {
    run {{*}list x y {*}z}
} {x y z}
test compile-16.14.$noComp {TclCompileScript: word expansion} $constraints {
    run {{*}list x {*}y z}
} {x y z}
test compile-16.15.$noComp {TclCompileScript: word expansion} $constraints {
    run {list x y {*}z}
} {x y z}
test compile-16.16.$noComp {TclCompileScript: word expansion} $constraints {
    run {list x {*}y z}
} {x y z}
test compile-16.17.$noComp {TclCompileScript: word expansion} $constraints {
    run {list {*}x y z}
} {x y z}

# These tests note that expansion can in theory cause the number of arguments
# to a command to exceed INT_MAX, which is as big as objc is allowed to get.
#
# In practice, it seems we will run out of memory before we confront this
# issue. Note that compiled operations run out of memory at smaller objc
# values than direct string evaluation.
#
# These tests are constrained as knownBug because they are likely to cause
# memory allocation panics somewhere, and we don't want panics in the test
# suite.
#
test compile-16.18.$noComp {TclCompileScript: word expansion} -body {
    proc LongList {} {return [lrepeat [expr {1<<10}] x]}
    llength [run "list [string repeat {{*}[LongList] } [expr {1<<10}]]"]
} -constraints [linsert $constraints 0 knownBug] -cleanup {
    rename LongList {}
} -returnCodes ok  -result [expr {1<<20}]
test compile-16.19.$noComp {TclCompileScript: word expansion} -body {
    proc LongList {} {return [lrepeat [expr {1<<11}] x]}
    llength [run "list [string repeat {{*}[LongList] } [expr {1<<11}]]"]
} -constraints [linsert $constraints 0 knownBug] -cleanup {
    rename LongList {}
} -returnCodes ok  -result [expr {1<<22}]
test compile-16.20.$noComp {TclCompileScript: word expansion} -body {
    proc LongList {} {return [lrepeat [expr {1<<12}] x]}
    llength [run "list [string repeat {{*}[LongList] } [expr {1<<12}]]"]
} -constraints [linsert $constraints 0 knownBug] -cleanup {
    rename LongList {}
} -returnCodes ok  -result [expr {1<<24}]
# This is the one that should cause overflow
test compile-16.21.$noComp {TclCompileScript: word expansion} -body {
    proc LongList {} {return [lrepeat [expr {1<<16}] x]}
    llength [run "list [string repeat {{*}[LongList] } [expr {1<<16}]]"]
} -constraints [linsert $constraints 0 knownBug] -cleanup {
    rename LongList {}
} -returnCodes ok  -result [expr {wide(1)<<32}]
test compile-16.22.$noComp {
    Bug 845412: TclCompileScript: word expansion not mandatory
} -body {
    # This test may crash and will fail unless Bug 845412 is fixed.
    proc ReturnResults args {return $args}
    run "ReturnResults [string repeat {x } 260]"
} -constraints $constraints -cleanup {
    rename ReturnResults {}
} -returnCodes ok -result [string trim [string repeat {x } 260]]
test compile-16.23.$noComp {
    Bug 1032805: defer parse error until run time
} -constraints $constraints -body {
    namespace eval x {
	run {
	    proc if {a b} {uplevel 1 [list set $a $b]}
	    if 1 {syntax {}{}}
	}
    }
} -cleanup {
    namespace delete x
} -returnCodes ok -result {syntax {}{}}
test compile-16.24.$noComp {
    Bug 1638414: bad list constant as first expanded term
} -constraints $constraints -body {
    run "{*}\"\{foo bar\""
} -returnCodes error -result {unmatched open brace in list}
test compile-16.25.$noComp {TclCompileScript: word expansion, naked backslashes} $constraints {
    run {list {*}{a \n b}}
} {a {
} b}
test compile-16.26.$noComp {TclCompileScript: word expansion, protected backslashes} $constraints {
    run {list {*}{a {\n} b}}
} {a {\n} b}
}	;# End of noComp loop

# These tests are messy because it wrecks the interpreter it runs in!  They
# demonstrate issues arising from [FRQ 1101710]
test compile-17.1 {Command interpretation binding for compiled code} -constraints knownBug -setup {
    set i [interp create]
} -body {
    $i eval {
	if 1 {
	    expr [
		proc expr args {return substituted}
		format {[subst compiled]}
	    ]
	}
    }
} -cleanup {
    interp delete $i
} -result substituted
test compile-17.2 {Command interpretation binding for non-compiled code} -setup {
    set i [interp create]
} -body {
    $i eval {
	if 1 {
	    [subst expr] [
		proc expr args {return substituted}
		format {[subst compiled]}
	    ]
	}
    }
} -cleanup {
    interp delete $i
} -result substituted

# This tests the supported parts of the unsupported [disassemble] command. It
# does not check the format of disassembled bytecode though; that's liable to
# change without warning.

set disassemblables [linsert [join {
    constructor destructor lambda method objmethod proc script
} ", "] end-1 or]
test compile-18.1 {disassembler - basics} -returnCodes error -body {
    tcl::unsupported::disassemble
} -match glob -result {wrong # args: should be "*"}
test compile-18.2 {disassembler - basics} -returnCodes error -body {
    tcl::unsupported::disassemble ?
} -result "bad type \"?\": must be $disassemblables"
test compile-18.3 {disassembler - basics} -returnCodes error -body {
    tcl::unsupported::disassemble lambda
} -match glob -result {wrong # args: should be "* lambda lambdaTerm"}
test compile-18.4 {disassembler - basics} -returnCodes error -body {
    tcl::unsupported::disassemble lambda \{
} -result "can't interpret \"\{\" as a lambda expression"
test compile-18.5 {disassembler - basics} -body {
    # Allow any string: the result format is not defined anywhere!
    tcl::unsupported::disassemble lambda {{} {}}
} -match glob -result *
test compile-18.6 {disassembler - basics} -returnCodes error -body {
    tcl::unsupported::disassemble proc
} -match glob -result {wrong # args: should be "* proc procName"}
test compile-18.7 {disassembler - basics} -returnCodes error -body {
    tcl::unsupported::disassemble proc nosuchproc
} -result {"nosuchproc" isn't a procedure}
test compile-18.8 {disassembler - basics} -setup {
    proc chewonthis {} {}
} -body {
    # Allow any string: the result format is not defined anywhere!
    tcl::unsupported::disassemble proc chewonthis
} -cleanup {
    rename chewonthis {}
} -match glob -result *
test compile-18.9 {disassembler - basics} -returnCodes error -body {
    tcl::unsupported::disassemble script
} -match glob -result {wrong # args: should be "* script script"}
test compile-18.10 {disassembler - basics} -body {
    # Allow any string: the result format is not defined anywhere!
    tcl::unsupported::disassemble script {}
} -match glob -result *
test compile-18.11 {disassembler - basics} -returnCodes error -body {
    tcl::unsupported::disassemble method
} -match glob -result {wrong # args: should be "* method className methodName"}
test compile-18.12 {disassembler - basics} -returnCodes error -body {
    tcl::unsupported::disassemble method nosuchclass foo
} -result {nosuchclass does not refer to an object}
test compile-18.13 {disassembler - basics} -returnCodes error -setup {
    oo::object create justanobject
} -body {
    tcl::unsupported::disassemble method justanobject foo
} -cleanup {
    justanobject destroy
} -result {"justanobject" is not a class}
test compile-18.14 {disassembler - basics} -returnCodes error -body {
    tcl::unsupported::disassemble method oo::object nosuchmethod
} -result {unknown method "nosuchmethod"}
test compile-18.15 {disassembler - basics} -setup {
    oo::class create foo {method bar {} {}}
} -body {
    # Allow any string: the result format is not defined anywhere!
    tcl::unsupported::disassemble method foo bar
} -cleanup {
    foo destroy
} -match glob -result *
test compile-18.16 {disassembler - basics} -returnCodes error -body {
    tcl::unsupported::disassemble objmethod
} -match glob -result {wrong # args: should be "* objmethod objectName methodName"}
test compile-18.17 {disassembler - basics} -returnCodes error -body {
    tcl::unsupported::disassemble objmethod nosuchobject foo
} -result {nosuchobject does not refer to an object}
test compile-18.18 {disassembler - basics} -returnCodes error -body {
    tcl::unsupported::disassemble objmethod oo::object nosuchmethod
} -result {unknown method "nosuchmethod"}
test compile-18.19 {disassembler - basics} -setup {
    oo::object create foo
    oo::objdefine foo {method bar {} {}}
} -body {
    # Allow any string: the result format is not defined anywhere!
    tcl::unsupported::disassemble objmethod foo bar
} -cleanup {
    foo destroy
} -match glob -result *
# There never was a compile-18.20.
# The keys of the dictionary produced by [getbytecode] are defined.
set bytecodekeys {literals variables exception instructions auxiliary commands script namespace stackdepth exceptdepth}
test compile-18.21 {disassembler - basics} -returnCodes error -body {
    tcl::unsupported::getbytecode
} -match glob -result {wrong # args: should be "*"}
test compile-18.22 {disassembler - basics} -returnCodes error -body {
    tcl::unsupported::getbytecode ?
} -result "bad type \"?\": must be $disassemblables"
test compile-18.23 {disassembler - basics} -returnCodes error -body {
    tcl::unsupported::getbytecode lambda
} -match glob -result {wrong # args: should be "* lambda lambdaTerm"}
test compile-18.24 {disassembler - basics} -returnCodes error -body {
    tcl::unsupported::getbytecode lambda \{
} -result "can't interpret \"\{\" as a lambda expression"
test compile-18.25 {disassembler - basics} -body {
    dict keys [tcl::unsupported::getbytecode lambda {{} {}}]
} -result "$bytecodekeys initiallinenumber sourcefile"
test compile-18.26 {disassembler - basics} -returnCodes error -body {
    tcl::unsupported::getbytecode proc
} -match glob -result {wrong # args: should be "* proc procName"}
test compile-18.27 {disassembler - basics} -returnCodes error -body {
    tcl::unsupported::getbytecode proc nosuchproc
} -result {"nosuchproc" isn't a procedure}
test compile-18.28 {disassembler - basics} -setup {
    proc chewonthis {} {}
} -body {
    dict keys [tcl::unsupported::getbytecode proc chewonthis]
} -cleanup {
    rename chewonthis {}
} -result "$bytecodekeys initiallinenumber sourcefile"
test compile-18.28.1 {disassembler - tricky bit} -setup {
    eval [list proc chewonthis {} {}]
} -body {
    dict keys [tcl::unsupported::getbytecode proc chewonthis]
} -cleanup {
    rename chewonthis {}
} -result $bytecodekeys
test compile-18.28.2 {disassembler - tricky bit} -setup {
    eval {proc chewonthis {} {}}
} -body {
    dict keys [tcl::unsupported::getbytecode proc chewonthis]
} -cleanup {
    rename chewonthis {}
} -result "$bytecodekeys initiallinenumber sourcefile"
test compile-18.28.3 {disassembler - tricky bit} -setup {
    proc Proc {n a b} {
	proc $n $a $b
    }
    Proc chewonthis {} {}
} -body {
    dict keys [tcl::unsupported::getbytecode proc chewonthis]
} -cleanup {
    rename Proc {}
    rename chewonthis {}
} -result $bytecodekeys
test compile-18.28.4 {disassembler - tricky bit} -setup {
    proc Proc {n a b} {
	tailcall proc $n $a $b
    }
    Proc chewonthis {} {}
} -body {
    dict keys [tcl::unsupported::getbytecode proc chewonthis]
} -cleanup {
    rename Proc {}
    rename chewonthis {}
} -result "$bytecodekeys initiallinenumber sourcefile"
test compile-18.29 {disassembler - basics} -returnCodes error -body {
    tcl::unsupported::getbytecode script
} -match glob -result {wrong # args: should be "* script script"}
test compile-18.30 {disassembler - basics} -body {
    dict keys [tcl::unsupported::getbytecode script {}]
} -result $bytecodekeys
test compile-18.31 {disassembler - basics} -returnCodes error -body {
    tcl::unsupported::getbytecode method
} -match glob -result {wrong # args: should be "* method className methodName"}
test compile-18.32 {disassembler - basics} -returnCodes error -body {
    tcl::unsupported::getbytecode method nosuchclass foo
} -result {nosuchclass does not refer to an object}
test compile-18.33 {disassembler - basics} -returnCodes error -setup {
    oo::object create justanobject
} -body {
    tcl::unsupported::getbytecode method justanobject foo
} -cleanup {
    justanobject destroy
} -result {"justanobject" is not a class}
test compile-18.34 {disassembler - basics} -returnCodes error -body {
    tcl::unsupported::getbytecode method oo::object nosuchmethod
} -result {unknown method "nosuchmethod"}
test compile-18.35 {disassembler - basics} -setup {
    oo::class create foo {method bar {} {}}
} -body {
    dict keys [tcl::unsupported::getbytecode method foo bar]
} -cleanup {
    foo destroy
} -result "$bytecodekeys initiallinenumber sourcefile"
test compile-18.36 {disassembler - basics} -returnCodes error -body {
    tcl::unsupported::getbytecode objmethod
} -match glob -result {wrong # args: should be "* objmethod objectName methodName"}
test compile-18.37 {disassembler - basics} -returnCodes error -body {
    tcl::unsupported::getbytecode objmethod nosuchobject foo
} -result {nosuchobject does not refer to an object}
test compile-18.38 {disassembler - basics} -returnCodes error -body {
    tcl::unsupported::getbytecode objmethod oo::object nosuchmethod
} -result {unknown method "nosuchmethod"}
test compile-18.39 {disassembler - basics} -setup {
    oo::object create foo
    oo::objdefine foo {method bar {} {}}
} -body {
    dict keys [tcl::unsupported::getbytecode objmethod foo bar]
} -cleanup {
    foo destroy
} -result "$bytecodekeys initiallinenumber sourcefile"
test compile-18.40 {disassembler - basics} -returnCodes error -body {
    tcl::unsupported::disassemble constructor
} -match glob -result {wrong # args: should be "* constructor className"}
test compile-18.41 {disassembler - basics} -returnCodes error -body {
    tcl::unsupported::disassemble constructor nosuchclass
} -result {nosuchclass does not refer to an object}
test compile-18.42 {disassembler - basics} -returnCodes error -setup {
    oo::object create justanobject
} -body {
    tcl::unsupported::disassemble constructor justanobject
} -cleanup {
    justanobject destroy
} -result {"justanobject" is not a class}
test compile-18.43 {disassembler - basics} -returnCodes error -setup {
    oo::class create constructorless
} -body {
    tcl::unsupported::disassemble constructor constructorless
} -cleanup {
    constructorless destroy
} -result {"constructorless" has no defined constructor}
test compile-18.44 {disassembler - basics} -setup {
    oo::class create foo {constructor {} {set x 1}}
} -body {
    # Allow any string: the result format is not defined anywhere!
    tcl::unsupported::disassemble constructor foo
} -cleanup {
    foo destroy
} -match glob -result *
test compile-18.45 {disassembler - basics} -returnCodes error -body {
    tcl::unsupported::getbytecode constructor
} -match glob -result {wrong # args: should be "* constructor className"}
test compile-18.46 {disassembler - basics} -returnCodes error -body {
    tcl::unsupported::getbytecode constructor nosuchobject
} -result {nosuchobject does not refer to an object}
test compile-18.47 {disassembler - basics} -returnCodes error -setup {
    oo::class create constructorless
} -body {
    tcl::unsupported::getbytecode constructor constructorless
} -cleanup {
    constructorless destroy
} -result {"constructorless" has no defined constructor}
test compile-18.48 {disassembler - basics} -setup {
    oo::class create foo {constructor {} {set x 1}}
} -body {
    dict keys [tcl::unsupported::getbytecode constructor foo]
} -cleanup {
    foo destroy
} -result "$bytecodekeys"
# There is no compile-18.49
test compile-18.50 {disassembler - basics} -returnCodes error -body {
    tcl::unsupported::disassemble destructor
} -match glob -result {wrong # args: should be "* destructor className"}
test compile-18.51 {disassembler - basics} -returnCodes error -body {
    tcl::unsupported::disassemble destructor nosuchclass
} -result {nosuchclass does not refer to an object}
test compile-18.52 {disassembler - basics} -returnCodes error -setup {
    oo::object create justanobject
} -body {
    tcl::unsupported::disassemble destructor justanobject
} -cleanup {
    justanobject destroy
} -result {"justanobject" is not a class}
test compile-18.53 {disassembler - basics} -returnCodes error -setup {
    oo::class create constructorless
} -body {
    tcl::unsupported::disassemble destructor constructorless
} -cleanup {
    constructorless destroy
} -result {"constructorless" has no defined destructor}
test compile-18.54 {disassembler - basics} -setup {
    oo::class create foo {destructor {set x 1}}
} -body {
    # Allow any string: the result format is not defined anywhere!
    tcl::unsupported::disassemble destructor foo
} -cleanup {
    foo destroy
} -match glob -result *
test compile-18.55 {disassembler - basics} -returnCodes error -body {
    tcl::unsupported::getbytecode destructor
} -match glob -result {wrong # args: should be "* destructor className"}
test compile-18.56 {disassembler - basics} -returnCodes error -body {
    tcl::unsupported::getbytecode destructor nosuchobject
} -result {nosuchobject does not refer to an object}
test compile-18.57 {disassembler - basics} -returnCodes error -setup {
    oo::class create constructorless
} -body {
    tcl::unsupported::getbytecode destructor constructorless
} -cleanup {
    constructorless destroy
} -result {"constructorless" has no defined destructor}
test compile-18.58 {disassembler - basics} -setup {
    oo::class create foo {destructor {set x 1}}
} -body {
    dict keys [tcl::unsupported::getbytecode destructor foo]
} -cleanup {
    foo destroy
} -result "$bytecodekeys"

test compile-19.0 {Bug 3614102: reset stack housekeeping} -body {
    # This will panic in a --enable-symbols=compile build, unless bug is fixed.
    apply {{} {list [if 1]}}
} -returnCodes error -match glob -result *

test compile-20.1 {ensure there are no infinite loops in optimizing} {
    tcl::unsupported::disassemble script {
	while 1 {
	    return -code continue -level 0
	}
    }
    return
} {}
test compile-20.2 {ensure there are no infinite loops in optimizing} {
    tcl::unsupported::disassemble script {
	while 1 {
	    while 1 {
		return -code break -level 0
	    }
	}
    }
    return
} {}

test compile-21.1 {stack balance management} {
    apply {{} {
	set result {}
	while 1 {
	    lappend result a
	    lappend result [list b [break]]
	    lappend result c
	}
	return $result
    }}
} a
test compile-21.2 {stack balance management} {
    apply {{} {
	set result {}
	while {[incr i] <= 10} {
	    lappend result $i
	    lappend result [list b [continue] c]
	    lappend result c
	}
	return $result
    }}
} {1 2 3 4 5 6 7 8 9 10}
test compile-21.3 {stack balance management} {
    apply {args {
	set result {}
	while 1 {
	    lappend result a
	    lappend result [concat {*}$args [break]]
	    lappend result c
	}
	return $result
    }} P Q R S T
} a
test compile-21.4 {stack balance management} {
    apply {args {
	set result {}
	while {[incr i] <= 10} {
	    lappend result $i
	    lappend result [concat {*}$args [continue] c]
	    lappend result c
	}
	return $result
    }} P Q R S T
} {1 2 3 4 5 6 7 8 9 10}

# TODO sometime - check that bytecode from tbcload is *not* disassembled.

# cleanup
catch {rename p ""}
catch {namespace delete test_ns_compile}
catch {unset x}
catch {unset y}
catch {unset a}
::tcltest::cleanupTests
return

# Local Variables:
# mode: tcl
# fill-column: 78
# End: