LD_LIBRARY_PATH=`pwd`:/software/@sys/usr/lib:/usr/local/lib:/usr/local/openssl/lib:/usr/lib:/usr/share/lib:/usr/shlib:; export LD_LIBRARY_PATH; \
TCL_LIBRARY="/afs/gsf.de/sources/ev56/tcl8.4.3/library"; export TCL_LIBRARY; \
./tcltest ./../tests/all.tcl  
Tests running in interp:  /afs/gsf.de/sources/ev56/tcl8.4.3/unix/tcltest
Tests located in:  /afs/gsf.de/sources/ev56/tcl8.4.3/tests
Tests running in:  /afs/gsf.de/sources/ev56/tcl8.4.3/unix
Temporary files stored in /afs/gsf.de/sources/ev56/tcl8.4.3/unix
Test files run in separate interpreters
Running tests that match:  *
Skipping test files that match:  l.*.test
Only running test files that match:  *.test
Tests began at Wed Jun 04 13:26:18 MEST 2003
append.test
appendComp.test
assocd.test
async.test
autoMkindex.test
basic.test
binary.test
case.test
clock.test

==== clock-3.2 clock format tests FAILED
==== Contents of test case:

    # TCL_USE_TIMEZONE_VAR

    catch {set oldtz $env(TZ)}
    set env(TZ) PST
    set x {}
    append x [clock format 863800000 -format %Z -gmt 1]
    append x [set env(TZ)]
    catch {unset env(TZ); set env(TZ) $oldtz}
    set x

---- Result was:
METPST
---- Result should have been (exact matching):
GMTPST
==== clock-3.2 FAILED


==== clock-3.4 clock format tests FAILED
==== Contents of test case:

    # tzset() under Borland doesn't seem to set up tzname[] for gmt timezone.
    # tzset() under MSVC has the following weird observed behavior:
    #	 First time we call "clock format [clock seconds] -format %Z -gmt 1"
    #	 we get "GMT", but on all subsequent calls we get the current time 
    #	 zone string, even though env(TZ) is GMT and the variable _timezone 
    #    is 0.

    set x {}
    append x [clock format 863800000 -format %Z -gmt 1]
    append x [clock format 863800000 -format %Z -gmt 1]

---- Result was:
METMET
---- Result should have been (exact matching):
GMTGMT
==== clock-3.4 FAILED

cmdAH.test

==== cmdAH-20.5 Tcl_FileObjCmd: atime touch FAILED
==== Contents of test case:

    if {[string equal $tcl_platform(platform) "windows"]} {
	set old [pwd]
	cd $::tcltest::temporaryDirectory
	if {![string equal "NTFS" [testvolumetype]]} {
	    # Windows FAT doesn't understand atime, but NTFS does
	    # May also fail for Windows on NFS mounted disks
	    cd $old
	    return 1
	}
	cd $old
    }
    set atime [file atime $file]
    after 1100; # pause a sec to notice change in atime
    set newatime [clock seconds]
    set modatime [file atime $file $newatime]
    expr {$newatime == $modatime ? 1 : "$newatime != $modatime"}

---- Result was:
1054725988 != 1054725987
---- Result should have been (exact matching):
1
==== cmdAH-20.5 FAILED


==== cmdAH-25.2 Tcl_FileObjCmd: owned FAILED
==== Contents of test case:

    file owned $gorpfile

---- Result was:
0
---- Result should have been (exact matching):
1
==== cmdAH-25.2 FAILED

cmdIL.test
cmdInfo.test
cmdMZ.test

==== cmdMZ-1.4 Tcl_PwdObjCmd: failure FAILED
==== Contents of test case:

    # We don't want this test to run on Linux because they do a
    # permissions caching trick which causes this to fail.  The
    # caching is incorrect, but we have no control over that.
    set foodir [file join [temporaryDirectory] foo]
    file delete -force $foodir
    file mkdir $foodir
    set cwd [pwd]
    cd $foodir
    file attr . -permissions 000
    set result [list [catch {pwd} msg] $msg]
    cd $cwd
    file delete -force $foodir
    set result

---- Result was:
0 /afs/gsf.de/sources/ev56/tcl8.4.3/unix/foo
---- Result should have been (exact matching):
1 {error getting working directory name: permission denied}
==== cmdMZ-1.4 FAILED

compExpr-old.test
compExpr.test
compile.test
concat.test
dcall.test
dstring.test
encoding.test
env.test
error.test
eval.test
event.test

==== event-11.5 Tcl_VwaitCmd procedure: round robin scheduling, 2 sources FAILED
==== Contents of test case:

    set test1file [makeFile "" test1]
    set f1 [open $test1file w]
    proc accept {s args} {
	puts $s foobar
	close $s
    }
    catch {set s1 [socket -server accept 0]}
    after 1000
    catch {set s2 [socket 127.0.0.1 [lindex [fconfigure $s1 -sockname] 2]]}
    close $s1
    set x 0
    set y 0
    set z 0
    fileevent $s2 readable {incr z}
    vwait z
    fileevent $f1 writable {incr x; if {$y == 3} {set z done}}
    fileevent $s2 readable {incr y; if {$x == 3} {set z done}}
    vwait z
    close $f1
    close $s2
    removeFile $test1file
    list $x $y $z

---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
==== event-11.5 FAILED

exec.test
execute.test
expr-old.test
expr.test
fCmd.test
fileName.test
fileSystem.test
for-old.test
for.test
foreach.test
format.test
get.test

==== get-1.10 Tcl_GetInt procedure FAILED
==== Contents of test case:

	set x 0
	list [catch {incr x -18446744073709551614} msg] $msg
    
---- Result was:
1 {integer value too large to represent}
---- Result should have been (exact matching):
0 2
==== get-1.10 FAILED

history.test
http.test

==== http-3.11 http::geturl querychannel with -command FAILED
==== Contents of test case:

    set query foo=bar
    set sep ""
    set i 0
    # Create about 120K of query data
    while {$i < 14} {
	incr i
	append query $sep$query
	set sep &
    }
    set file [makeFile $query outdata]
    set fp [open $file]

    proc asyncCB {token} {
	global postResult
	lappend postResult [http::data $token]
    }
    set postResult [list ]
    set t [http::geturl $posturl -querychannel $fp]
    http::wait $t
    set testRes [list [http::status $t] [string length $query] [http::data $t]]

    # Now do async
    http::cleanup $t
    close $fp
    set fp [open $file]
    set t [http::geturl $posturl -querychannel $fp -command asyncCB]
    set postResult [list PostStart]
    http::wait $t
    close $fp

    lappend testRes [http::status $t] $postResult
    removeFile outdata
    set testRes

---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
==== http-3.11 FAILED


==== http-3.13 http::geturl socket leak test FAILED
==== Contents of test case:

    set chanCount [llength [file channels]]
    for {set i 0} {$i < 3} {incr i} {
	catch {http::geturl $badurl -timeout 5000} 
    }

    # No extra channels should be taken
    expr {[llength [file channels]] == $chanCount}

---- Result was:
0
---- Result should have been (exact matching):
1
==== http-3.13 FAILED

httpold.test
if-old.test
if.test
incr-old.test
incr.test
indexObj.test
info.test
init.test
interp.test
io.test

==== io-14.9 reuse of stdio special channels FAILED
==== Contents of test case:

    removeFile script
    removeFile test1
    set f [open $path(script) w]
    puts $f {
        array set path [lindex $argv 0]
	set f [open $path(test1) w]
	puts $f hello
	close $f
	close stderr
	set f [open "|[list [info nameofexecutable] $path(cat) $path(test1)]" r]
	puts [gets $f]
    }
    close $f
    set f [open "|[list [interpreter] $path(script) [array get path]]" r]
    set c [gets $f]
    close $f
    set c

---- Result was:

---- Result should have been (exact matching):
hello
==== io-14.9 FAILED


==== io-32.7 Tcl_Read, nonblocking, file FAILED
==== Contents of test case:

    set f1 [open $path(longfile) r]
    fconfigure $f1 -blocking off
    set z [read $f1 20]
    close $f1
    set l [string length $z]
    set x ok
    if {$l != 20} {
	set x broken
    }
    set x

---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
==== io-32.7 FAILED


==== io-32.8 Tcl_Read, nonblocking, file FAILED
==== Contents of test case:

    set f1 [open $path(longfile) r]
    fconfigure $f1 -blocking off
    set z [read $f1 1000000]
    close $f1
    set x ok
    set l [string length $z]
    set z [file size $path(longfile)]
    if {$z != $l} {
	set x broken
    }
    set x

---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
==== io-32.8 FAILED


==== io-35.4 Tcl_Eof, eof detection on nonblocking file FAILED
==== Contents of test case:

    removeFile test1
    set f [open $path(test1) w]
    close $f
    set f [open $path(test1) r]
    fconfigure $f -blocking off
    set l ""
    lappend l [gets $f]
    lappend l [eof $f]
    close $f
    set l

---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
==== io-35.4 FAILED


==== io-36.5 Tcl_InputBlocked vs files, short read, nonblocking FAILED
==== Contents of test case:

    removeFile test1
    set f [open $path(test1) w]
    puts $f abcdefghijklmnop
    close $f
    set f [open $path(test1) r]
    fconfigure $f -blocking off
    set l ""
    lappend l [fblocked $f]
    lappend l [read $f 3]
    lappend l [fblocked $f]
    lappend l [read -nonewline $f]
    lappend l [fblocked $f]
    lappend l [eof $f]
    close $f
    set l

---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
==== io-36.5 FAILED


==== io-36.6 Tcl_InputBlocked vs files, event driven read FAILED
==== Contents of test case:

    proc in {f} {
        variable l
        variable x
	lappend l [read $f 3]
	if {[eof $f]} {lappend l eof; close $f; set x done}
    }
    removeFile test1
    set f [open $path(test1) w]
    puts $f abcdefghijklmnop
    close $f
    set f [open $path(test1) r]
    fconfigure $f -blocking off
    set l ""
    fileevent $f readable [namespace code [list in $f]]
    variable x
    vwait [namespace which -variable x]
    set l

---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
==== io-36.6 FAILED


==== io-39.9 Tcl_SetChannelOption, blocking mode FAILED
==== Contents of test case:

    removeFile test1
    set f1 [open $path(test1) w]
    close $f1
    set f1 [open $path(test1) r]
    set x ""
    lappend x [fconfigure $f1 -blocking]
    fconfigure $f1 -blocking off
    lappend x [fconfigure $f1 -blocking]
    lappend x [gets $f1]
    lappend x [read $f1 1000]
    lappend x [fblocked $f1]
    lappend x [eof $f1]
    close $f1
    set x

---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
==== io-39.9 FAILED


==== io-48.2 testing readability conditions FAILED
==== Contents of test case:

    set f [open $path(bar) w]
    puts $f abcdefg
    puts $f abcdefg
    puts $f abcdefg
    puts $f abcdefg
    puts $f abcdefg
    close $f
    set f [open $path(bar) r]
    fileevent $f readable [namespace code [list consume $f]]
    fconfigure $f -blocking off
    proc consume {f} {
	variable x
	variable l
	lappend l called
	if {[eof $f]} {
	    close $f
	    set x done
	} else {
	    gets $f
	}
    }
    set l ""
    variable x not_done
    vwait [namespace which -variable x]
    list $x $l

---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
==== io-48.2 FAILED


==== io-48.3 testing readability conditions FAILED
==== Contents of test case:

    set f [open $path(bar) w]
    puts $f abcdefg
    puts $f abcdefg
    puts $f abcdefg
    puts $f abcdefg
    puts $f abcdefg
    close $f
    set f [open $path(my_script) w]
    puts $f {
	proc copy_slowly {f} {
	    while {![eof $f]} {
		puts [gets $f]
		after 200
	    }
	    close $f
	}
    }
    close $f
    set f [open "|[list [interpreter]]" r+]
    fileevent  $f readable [namespace code [list consume $f]]
    fconfigure $f -buffering line
    fconfigure $f -blocking off
    proc consume {f} {
	variable l
	variable x
	if {[eof $f]} {
	    set x done
	} else {
	    gets $f
	    lappend l [fblocked $f]
	    gets $f
	    lappend l [fblocked $f]
	}
    }
    set l ""
    variable x not_done
    puts $f [format {source {%s}}         $path(my_script)]
    puts $f [format {set f [open {%s} r]} $path(bar)]
    puts $f {copy_slowly $f}
    puts $f {exit}
    vwait [namespace which -variable x]
    close $f
    list $x $l

---- Result was:
done {0 0 0 0 0 0}
---- Result should have been (exact matching):
done {0 1 0 1 0 1 0 1 0 1 0 1 0 0}
==== io-48.3 FAILED


==== io-48.4 lf write, testing readability, ^Z termination, auto read mode FAILED
==== Contents of test case:

    removeFile test1
    set f [open $path(test1) w]
    fconfigure $f -translation lf
    set c [format "abc\ndef\n%c" 26]
    puts -nonewline $f $c
    close $f
    proc consume {f} {
	variable l
	variable c
	variable x
	if {[eof $f]} {
	   set x done
	   close $f
	} else {
	   lappend l [gets $f]
	   incr c
	}
    }
    set c 0
    set l ""
    set f [open $path(test1) r]
    fconfigure $f -translation auto -eofchar \x1a
    fileevent $f readable [namespace code [list consume $f]]
    variable x
    vwait [namespace which -variable x]
    list $c $l

---- Result was:
1 abc
---- Result should have been (exact matching):
3 {abc def {}}
==== io-48.4 FAILED


==== io-48.5 lf write, testing readability, ^Z in middle, auto read mode FAILED
==== Contents of test case:

    removeFile test1
    set f [open $path(test1) w]
    fconfigure $f -translation lf
    set c [format "abc\ndef\n%cfoo\nbar\n" 26]
    puts -nonewline $f $c
    close $f
    proc consume {f} {
	variable l
	variable x
	variable c
	if {[eof $f]} {
	   set x done
	   close $f
	} else {
	   lappend l [gets $f]
	   incr c
	}
    }
    set c 0
    set l ""
    set f [open $path(test1) r]
    fconfigure $f -eofchar \x1a -translation auto
    fileevent $f readable [namespace code [list consume $f]]
    variable x
    vwait [namespace which -variable x]
    list $c $l

---- Result was:
5 {abc def def {} {}}
---- Result should have been (exact matching):
3 {abc def {}}
==== io-48.5 FAILED


==== io-52.1 TclCopyChannel FAILED
==== Contents of test case:

    removeFile test1
    set f1 [open $thisScript]
    set f2 [open $path(test1) w]
    fcopy $f1 $f2 -command { # }
    catch { fcopy $f1 $f2 } msg
    close $f1
    close $f2
    string compare $msg "channel \"$f1\" is busy"

---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
==== io-52.1 FAILED


==== io-52.2 TclCopyChannel FAILED
==== Contents of test case:

    removeFile test1
    set f1 [open $thisScript]
    set f2 [open $path(test1) w]
    set f3 [open $thisScript]
    fcopy $f1 $f2 -command { # }
    catch { fcopy $f3 $f2 } msg
    close $f1
    close $f2
    close $f3
    string compare $msg "channel \"$f2\" is busy"

---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
==== io-52.2 FAILED


==== io-52.3 TclCopyChannel FAILED
==== Contents of test case:

    removeFile test1
    set f1 [open $thisScript]
    set f2 [open $path(test1) w]
    fconfigure $f1 -translation lf -blocking 0
    fconfigure $f2 -translation cr -blocking 0
    set s0 [fcopy $f1 $f2]
    set result [list [fconfigure $f1 -blocking] [fconfigure $f2 -blocking]]
    close $f1
    close $f2
    set s1 [file size $thisScript]
    set s2 [file size $path(test1)]
    if {("$s1" == "$s2") && ($s0 == $s1)} {
        lappend result ok
    }
    set result

---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
==== io-52.3 FAILED


==== io-52.4 TclCopyChannel FAILED
==== Contents of test case:

    removeFile test1
    set f1 [open $thisScript]
    set f2 [open $path(test1) w]
    fconfigure $f1 -translation lf -blocking 0
    fconfigure $f2 -translation cr -blocking 0
    fcopy $f1 $f2 -size 40
    set result [list [fconfigure $f1 -blocking] [fconfigure $f2 -blocking]]
    close $f1
    close $f2
    lappend result [file size $path(test1)]

---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
==== io-52.4 FAILED


==== io-52.5 TclCopyChannel FAILED
==== Contents of test case:

    removeFile test1
    set f1 [open $thisScript]
    set f2 [open $path(test1) w]
    fconfigure $f1 -translation lf -blocking 0
    fconfigure $f2 -translation lf -blocking 0
    fcopy $f1 $f2 -size -1
    set result [list [fconfigure $f1 -blocking] [fconfigure $f2 -blocking]]
    close $f1
    close $f2
    set s1 [file size $thisScript]
    set s2 [file size $path(test1)]
    if {"$s1" == "$s2"} {
        lappend result ok
    }
    set result

---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
==== io-52.5 FAILED


==== io-52.6 TclCopyChannel FAILED
==== Contents of test case:

    removeFile test1
    set f1 [open $thisScript]
    set f2 [open $path(test1) w]
    fconfigure $f1 -translation lf -blocking 0
    fconfigure $f2 -translation lf -blocking 0
    set s0 [fcopy $f1 $f2 -size [expr [file size $thisScript] + 5]]
    set result [list [fconfigure $f1 -blocking] [fconfigure $f2 -blocking]]
    close $f1
    close $f2
    set s1 [file size $thisScript]
    set s2 [file size $path(test1)]
    if {("$s1" == "$s2") && ($s0 == $s1)} {
        lappend result ok
    }
    set result

---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
==== io-52.6 FAILED


==== io-52.7 TclCopyChannel FAILED
==== Contents of test case:

    removeFile test1
    set f1 [open $thisScript]
    set f2 [open $path(test1) w]
    fconfigure $f1 -translation lf -blocking 0
    fconfigure $f2 -translation lf -blocking 0
    fcopy $f1 $f2
    set result [list [fconfigure $f1 -blocking] [fconfigure $f2 -blocking]]
    set s1 [file size $thisScript]
    set s2 [file size $path(test1)]
    close $f1
    close $f2
    if {"$s1" == "$s2"} {
        lappend result ok
    }
    set result

---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
==== io-52.7 FAILED


==== io-53.1 CopyData FAILED
==== Contents of test case:

    removeFile test1
    set f1 [open $thisScript]
    set f2 [open $path(test1) w]
    fconfigure $f1 -translation lf -blocking 0
    fconfigure $f2 -translation cr -blocking 0
    fcopy $f1 $f2 -size 0
    set result [list [fconfigure $f1 -blocking] [fconfigure $f2 -blocking]]
    close $f1
    close $f2
    lappend result [file size $path(test1)]

---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
==== io-53.1 FAILED


==== io-53.2 CopyData FAILED
==== Contents of test case:

    removeFile test1
    set f1 [open $thisScript]
    set f2 [open $path(test1) w]
    fconfigure $f1 -translation lf -blocking 0
    fconfigure $f2 -translation cr -blocking 0
    fcopy $f1 $f2 -command [namespace code {set s0}]
    set result [list [fconfigure $f1 -blocking] [fconfigure $f2 -blocking]]
    variable s0
    vwait [namespace which -variable s0]
    close $f1
    close $f2
    set s1 [file size $thisScript]
    set s2 [file size $path(test1)]
    if {("$s1" == "$s2") && ($s0 == $s1)} {
        lappend result ok
    }
    set result

---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
==== io-53.2 FAILED


==== io-53.5 CopyData: error during fcopy FAILED
==== Contents of test case:

    variable fcopyTestDone
    set listen [socket -server [namespace code FcopyTestAccept] 0]
    set in [open $thisScript]	;# 126 K
    set out [socket 127.0.0.1 [lindex [fconfigure $listen -sockname] 2]]
    catch {unset fcopyTestDone}
    close $listen	;# This means the socket open never really succeeds
    fcopy $in $out -command [namespace code FcopyTestDone]
    variable fcopyTestDone
    if ![info exists fcopyTestDone] {
	vwait [namespace which -variable fcopyTestDone]		;# The error occurs here in the b.g.
    }
    close $in
    close $out
    set fcopyTestDone	;# 1 for error condition

---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
==== io-53.5 FAILED


==== io-53.6 CopyData: error during fcopy FAILED
==== Contents of test case:

    variable fcopyTestDone
    removeFile pipe
    removeFile test1
    catch {unset fcopyTestDone}
    set f1 [open $path(pipe) w]
    puts $f1 "exit 1"
    close $f1
    set in [open "|[list [interpreter] $path(pipe)]" r+]
    set out [open $path(test1) w]
    fcopy $in $out -command [namespace code FcopyTestDone]
    variable fcopyTestDone
    if ![info exists fcopyTestDone] {
	vwait [namespace which -variable fcopyTestDone]
    }
    catch {close $in}
    close $out
    set fcopyTestDone	;# 0 for plain end of file

---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
==== io-53.6 FAILED


==== io-53.7 CopyData: Flooding fcopy from pipe FAILED
==== Contents of test case:

    variable fcopyTestDone
    removeFile pipe
    removeFile test1
    catch {unset fcopyTestDone}
    set fcopyTestCount 0
    set f1 [open $path(pipe) w]
    puts $f1 {
	# Write  10 bytes / 10 msec
	proc Write {count} {
	    puts -nonewline "1234567890"
	    if {[incr count -1]} {
	        after 10 [list Write $count]
	    } else {
	        set ::ready 1
	    }
	}
	fconfigure stdout -buffering none
	Write 345 ;# 3450 bytes ~3.45 sec
	vwait ready
	exit 0
    }
    close $f1
    set in [open "|[list [interpreter] $path(pipe) &]" r+]
    set out [open $path(test1) w]
    doFcopy $in $out
    variable fcopyTestDone
    if ![info exists fcopyTestDone] {
	vwait [namespace which -variable fcopyTestDone]
    }
    catch {close $in}
    close $out
    # -1=error 0=script error N=number of bytes
    expr ($fcopyTestDone == 0) ? $fcopyTestCount : -1

---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
==== io-53.7 FAILED

ioCmd.test
ioUtil.test
iogt.test
join.test
lindex.test
link.test
linsert.test
list.test
listObj.test
llength.test
load.test
lrange.test
lreplace.test
lsearch.test
lset.test
lsetComp.test
macFCmd.test
main.test
misc.test
msgcat.test
namespace-old.test
namespace.test
notify.test
obj.test
opt.test
osa.test
package.test
parse.test
parseExpr.test

==== parseExpr-16.11 GetLexeme procedure, bad double lexeme too big FAILED
==== Contents of test case:

    list [catch {testexprparser {123.e+99999999999999} -1} msg] $msg

---- Result was:
1 {syntax error in expression "123.e+99999999999999": character not legal in expressions}
---- Result should have been (exact matching):
1 {floating-point value too large to represent}
==== parseExpr-16.11 FAILED

parseOld.test
pid.test
pkg.test
pkgMkIndex.test
platform.test
proc-old.test
proc.test
pwd.test
reg.test
regexp.test
regexpComp.test
registry.test
rename.test
resource.test
result.test
safe.test
scan.test
security.test
set-old.test
set.test
socket.test
source.test
split.test
stack.test
string.test
stringComp.test
stringObj.test
subst.test
switch.test
tcltest.test
thread.test
timer.test
trace.test
unixFCmd.test
unixFile.test
unixInit.test
unixNotfy.test
unknown.test
uplevel.test
upvar.test
utf.test
util.test
var.test
while-old.test
while.test
winConsole.test
winDde.test
winFCmd.test
winFile.test
winNotify.test
winPipe.test
winTime.test

Tests ended at Wed Jun 04 13:30:10 MEST 2003
all.tcl:	Total	10480	Passed	9341	Skipped	1106	Failed	33
Sourced 129 Test Files.
Files with failing tests: clock.test cmdAH.test cmdMZ.test event.test get.test http.test io.test parseExpr.test
Number of tests skipped for each constraint:
	1	dontCopyLinks
	47	emptyTest
	2	hasIsoLocale
	13	knownBug
	1	largefileSupport
	25	localeRegexp
	35	longIs32bit
	126	macOnly
	1	macOrWin
	2	memDebug
	1	needPST
	139	nonPortable
	3	nonRoot
	252	notRoot
	372	pcOnly
	1	singleTestInterp
	28	testthread
	1	testwinclock
	21	testwordend
	1	umask2
	2	unixOnly && testthread
	3	unknownFailure
	2	wideIntExpressions
	22	wideIntegerUnparsed
	1	win
	4	winOnly
