Attachment "make_test.log" to
ticket [748804ffff]
added by
nobody
2003-06-04 18:31:43.
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
