#2234 sparc solaris 8 test suite failure

[Larry W. Virden]

Taking the tcl CVS head snapshot from activestate ftp
site on March 13, 2003, and configure/build it on SPARC
Solaris 8 using Sun's C compiler with these flags:

./configure --prefix=/volws/lwv26/ldatae/tcl85
--enable-threads --enable-shared --enable-64bit
--enable-symbols

Result is a makefile.

make all results in a tclsh.
make test results in these errors:

http.test
Test file error: invalid thread id
while executing
"testthread send $httpthread [list set port $port]"
invoked from within
"if {[info commands testthread] == "testthread" &&
[file exists $httpdFile]} {
set httpthread [testthread create "
source [list $httpdFile]
testt..."
(file "/vol/tclsrcsol/tcl85/tcl/tests/http.test"
line 59)

socket.test

==== socket-2.3 tcp connection with client interface
specified FAILED
==== Contents of test case:

removeFile script
set f [open $path(script) w]
puts $f {
set timer [after 2000 "set x done"]
set f [socket -server accept 2830]
proc accept {file addr port} {
global x
puts "[gets $file] $addr"
close $file
set x done
}
puts ready
vwait x
after cancel $timer
close $f
}
close $f
set f [open "|[list [interpreter] $path(script)]" r]
gets $f x
if {[catch {socket -myaddr 127.0.0.1 127.0.0.1
2830} sock]} {
set x $sock
} else {
puts $sock hello
flush $sock
lappend x [gets $f]
close $sock
}
close $f
set x

---- Result was:
ready {hello 0.0.0.0}
---- Result should have been (exact matching):
ready {hello 127.0.0.1}
==== socket-2.3 FAILED

==== socket-7.1 testing socket specific options FAILED
==== Contents of test case:

removeFile script
set f [open $path(script) w]
puts $f {
set ss [socket -server accept 0]
proc accept args {
global x
set x done
}
puts ready
puts [lindex [fconfigure $ss -sockname] 2]
set timer [after 10000 "set x timed_out"]
vwait x
after cancel $timer
}
close $f
set f [open "|[list [interpreter] $path(script)]" r]
gets $f
gets $f listen
set s [socket 127.0.0.1 $listen]
set p [fconfigure $s -peername]
close $s
close $f
set l ""
lappend l [string compare [lindex $p 0] 127.0.0.1]
lappend l [string compare [lindex $p 2] $listen]
lappend l [llength $p]

---- Result was:
-1 0 3
---- Result should have been (exact matching):
0 0 3
==== socket-7.1 FAILED

==== socket-7.5 testing socket specific options FAILED
==== Contents of test case:

set s [socket -server accept 0]
proc accept {s a p} {
global x
set x [fconfigure $s -sockname]
close $s
}
set listen [lindex [fconfigure $s -sockname] 2]
set s1 [socket 127.0.0.1 $listen]
set timer [after 10000 "set x timed_out"]
vwait x
after cancel $timer
close $s
close $s1
set l ""
lappend l [lindex $x 0] [expr {[lindex $x 2] ==
$listen}] [llength $x]

---- Result was:
0.0.0.0 1 3
---- Result should have been (exact matching):
127.0.0.1 1 3
==== socket-7.5 FAILED

==== socket-13.1 Testing use of shared socket between
two threads FAILED
==== Contents of test case:

removeFile script
threadReap

makeFile {
set f [socket -server accept 0]
set listen [lindex [fconfigure $f -sockname] 2]
proc accept {s a p} {
fileevent $s readable [list echo $s]
fconfigure $s -buffering line
}
proc echo {s} {
global i
set l [gets $s]
if {[eof $s]} {
global x
close $s
set x done
} else {
incr i
puts $s $l
}
}
set i 0
vwait x
close $f

# thread cleans itself up.
testthread exit
} script

# create a thread
set serverthread [testthread create { source script } ]
update
set port [testthread send $serverthread {set listen}]
update

after 1000
set s [socket 127.0.0.1 $port]
fconfigure $s -buffering line

catch {
puts $s "hello"
gets $s result
}
close $s
update

after 2000
lappend result [threadReap]

set result

---- Result was:
invalid thread id
---- Result should have been (exact matching):
hello 1
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
==== socket-13.1 FAILED

thread.test

==== thread-1.13 Tcl_ThreadObjCmd: send args FAILED
==== Contents of test case:

threadReap
set serverthread [testthread create]
set five [testthread send $serverthread {set x 5}]
threadReap
set five

---- Result was:
invalid thread id
---- Result should have been (exact matching):
5
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
==== thread-1.13 FAILED

==== thread-1.15 Tcl_ThreadObjCmd: wait FAILED
==== Contents of test case:

threadReap
set serverthread [testthread create {set z 5 ;
testthread wait}]
set five [testthread send $serverthread {set z}]
threadReap
set five

---- Result was:
invalid thread id
---- Result should have been (exact matching):
5
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
==== thread-1.15 FAILED

==== thread-3.1 TclThreadList FAILED
==== Contents of test case:

threadReap
catch {unset tid}
set len [llength [testthread names]]
set l1 {}
foreach t {0 1 2} {
lappend l1 [testthread create]
}
set l2 [testthread names]
list $l1 $l2
set c [string compare [lsort -integer [concat
$::tcltest::mainThread $l1]]
[lsort -integer $l2]]
threadReap
list $len $c

---- Result was:
1 1
---- Result should have been (exact matching):
1 0
==== thread-3.1 FAILED

==== thread-4.2 TclThreadSend -async FAILED
==== Contents of test case:

threadReap
set len [llength [testthread names]]
set serverthread [testthread create]
testthread send -async $serverthread {
after 1000
testthread exit
}
set two [llength [testthread names]]
after 1500 {set done 1}
vwait done
threadReap
list $len [llength [testthread names]] $two

---- Result was:
invalid thread id
---- Result should have been (exact matching):
1 1 2
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
==== thread-4.2 FAILED

==== thread-4.3 TclThreadSend preserve errorInfo FAILED
==== Contents of test case:

threadReap
set len [llength [testthread names]]
set serverthread [testthread create]
set x [catch {testthread send $serverthread {set
undef}} msg]
threadReap
list $len $x $msg $errorInfo

---- Result was:
1 1 {invalid thread id} {invalid thread id
while executing
"testthread send $serverthread {set undef}"}
---- Result should have been (exact matching):
1 1 {can't read "undef": no such variable} {can't read
"undef": no such variable
while executing
"set undef"
invoked from within
"testthread send $serverthread {set undef}"}
==== thread-4.3 FAILED

==== thread-4.4 TclThreadSend preserve code FAILED
==== Contents of test case:

threadReap
set len [llength [testthread names]]
set serverthread [testthread create]
set x [catch {testthread send $serverthread
{break}} msg]
threadReap
list $len $x $msg $errorInfo

---- Result was:
1 1 {invalid thread id} {invalid thread id
while executing
"testthread send $serverthread {break}"}
---- Result should have been (exact matching):
1 3 {} {}
==== thread-4.4 FAILED

==== thread-4.5 TclThreadSend preserve errorCode FAILED
==== Contents of test case:

threadReap
set ::tcltest::mainThread [testthread names]
set serverthread [testthread create]
set x [catch {testthread send $serverthread {error
ERR INFO CODE}} msg]
threadReap
list $x $msg $errorCode

---- Result was:
1 {invalid thread id} NONE
---- Result should have been (exact matching):
1 ERR CODE
==== thread-4.5 FAILED

==== thread-5.0 Joining threads FAILED
==== Contents of test case:

threadReap
set serverthread [testthread create -joinable]
testthread send -async $serverthread {after 1000 ;
testthread exit}
set res [testthread join $serverthread]
threadReap
set res

---- Result was:
invalid thread id
---- Result should have been (exact matching):
0
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
==== thread-5.0 FAILED

==== thread-5.1 Joining threads after the fact FAILED
==== Contents of test case:

threadReap
set serverthread [testthread create -joinable]
testthread send -async $serverthread {testthread exit}
after 2000
set res [testthread join $serverthread]
threadReap
set res

---- Result was:
invalid thread id
---- Result should have been (exact matching):
0
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
==== thread-5.1 FAILED

==== thread-5.2 Try to join a detached thread FAILED
==== Contents of test case:

threadReap
set serverthread [testthread create]
testthread send -async $serverthread {after 1000 ;
testthread exit}
catch {set res [testthread join $serverthread]} msg
threadReap
lrange $msg 0 2

---- Result was:
invalid thread id
---- Result should have been (exact matching):
cannot join thread
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
==== thread-5.2 FAILED

timer.test
trace.test
unixFCmd.test
unixFile.test
unixInit.test

==== unixInit-1.2 initialisation: standard channel type
deduction FAILED
==== Contents of test case:

# pipe1 is a connection to a server that reports
what port it
# starts on, and delivers a constant string to the
first client to
# connect to that port before exiting.
set pipe1 [open "|[list [interpreter]]" r+]
puts $pipe1 {
proc accept {channel host port} {
puts $channel {puts [fconfigure stdin
-peername]; exit}
close $channel
exit
}
puts [fconfigure [socket -server accept 0]
-sockname]
vwait forever }
# Note the backslash above; this is important to
make sure that the
# whole string is read before an [exit] can happen...
flush $pipe1
set port [lindex [gets $pipe1] 2]
set sock [socket localhost $port]
# pipe2 is a connection to a Tcl interpreter that
takes its orders
# from the socket we hand it (i.e. the server we
create above.)
# These orders will tell it to print out the
details about the
# socket it is taking instructions from, hopefully
identifying it
# as a socket. Which is what this test is all about.
set pipe2 [open "|[list [interpreter] <@$sock]" r]
set result [gets $pipe2]

# Clear any pending data; stops certain kinds of
(non-important) errors
fconfigure $pipe1 -blocking 0; gets $pipe1
fconfigure $pipe2 -blocking 0; gets $pipe2

# Close the pipes and the socket.
close $pipe2
close $pipe1
catch {close $sock}

# Can't use normal comparison, as hostname varies
due to some
# installations having a messed up /etc/hosts file.
if {
[string equal 127.0.0.1 [lindex $result 0]] &&
[string equal $port [lindex $result 2]]
} then {
subst "OK"
} else {
subst "Expected: `[list 127.0.0.1 localhost
$port]', Got `$result'"
}

---- Result was:
Expected: `127.0.0.1 localhost 46144', Got `0.0.0.0
localhost 46144'
---- Result should have been (exact matching):
OK
==== unixInit-1.2 FAILED

[Larry W. Virden]

Logged In: YES
user_id=15949

I next did a fresh build of tcl tcl 8.5 head using
./configure --prefix=/volws/lwv26/ldatae/tcl85
--enable-threads --enable-shared --enable-symbols

(ie only threads - no 64 bit support specified).

With this configuration, I got the following test suite errors:

io.test

==== io-8.4 PeekAhead: cached data available in this buffer
FAILED
==== Contents of test case:

# not (bytesLeft == 0)

set f [open $path(test1) w+]
fconfigure $f -translation binary
puts $f "${a}\r\nabcdef"
close $f
set f [open $path(test1)]
fconfigure $f -encoding binary -translation auto

# "${a}\r" was converted in one operation (because
ENCODING_LINESIZE
# is 30). To check if "\n" follows, calls PeekAhead and
determines
# that cached data is available in buffer w/o having to
call driver.

set x [gets $f]
close $f
set x

---- Result was:
12345678901234567890123456789012345678901234567890123456789012345678901234567890
12345678901^@
---- Result should have been (exact matching):
12345678901234567890123456789012345678901234567890123456789012345678901234567890
12345678901
==== io-8.4 FAILED

ioCmd.test

==== iocmd-12.6 POSIX open access modes: errors FAILED
==== Contents of test case:

concat [catch {open $path(test3) "FOO \{BAR BAZ"} msg]
$msg\n$errorInfo
---- Result was:
1 unmatched open brace in list^@unmatched open brace in list
while processing open access modes "FOO {BAR BAZ"
invoked from within
"open $path(test3) "FOO \{BAR BAZ""
---- Result should have been (exact matching):
1 unmatched open brace in list
unmatched open brace in list
while processing open access modes "FOO {BAR BAZ"
invoked from within
"open $path(test3) "FOO \{BAR BAZ""
==== iocmd-12.6 FAILED

ioUtil.test
iogt.test

==== iogt-2.1 basic I/O, operation trail FAILED
==== Contents of test case:

set fin [open $path(dummy) r]
set fout [open $path(dummyout) w]

set ain [list] ; set aout [list]
audit_ops ain -attach $fin
audit_ops aout -attach $fout

fconfigure $fin -buffersize 10
fconfigure $fout -buffersize 5

fcopy $fin $fout

close $fin
close $fout

set res "[join $ain \n]\n--------\n[join $aout \n]"
---- Result was:
create/read
query/maxRead
read
query/maxRead
read
query/maxRead
read
query/maxRead
read
query/maxRead
read
query/maxRead
read
query/maxRead
read
query/maxRead
read
query/maxRead
flush/read
delete/read^@--------
create/write
write
write
write
write
write
write
write
write
flush/write
delete/write
---- Result should have been (exact matching):
create/read
query/maxRead
read
query/maxRead
read
query/maxRead
read
query/maxRead
read
query/maxRead
read
query/maxRead
read
query/maxRead
read
query/maxRead
read
query/maxRead
flush/read
delete/read
--------
create/write
write
write
write
write
write
write
write
write
flush/write
delete/write
==== iogt-2.1 FAILED
==== iogt-2.2 basic I/O, data trail FAILED
==== Contents of test case:

set fin [open $path(dummy) r]
set fout [open $path(dummyout) w]

set ain [list] ; set aout [list]
audit_flow ain -attach $fin
audit_flow aout -attach $fout

fconfigure $fin -buffersize 10
fconfigure $fout -buffersize 5

fcopy $fin $fout

close $fin
close $fout

set res "[join $ain \n]\n--------\n[join $aout \n]"

---- Result was:
create/read {} *ignored*
query/maxRead {} -1
read abcdefghij abcdefghij
query/maxRead {} -1
read klmnopqrst klmnopqrst
query/maxRead {} -1
read uvwxyz0123 uvwxyz0123
query/maxRead {} -1
read 456789,./? 456789,./?
query/maxRead {} -1
read {><;'\|":[]} {><;'\|":[]}
query/maxRead {} -1
read {\}\{`~!@#$} {\}\{`~!@#$}
query/maxRead {} -1
read %^&*()_+-= %^&*()_+-=
query/maxRead {} -1
read {
} {
}
query/maxRead {} -1
flush/read {} {}
delete/read {} *ignored*^@--------
create/write {} *ignored*
write abcdefghij abcdefghij
write klmnopqrst klmnopqrst
write uvwxyz0123 uvwxyz0123
write 456789,./? 456789,./?
write {><;'\|":[]} {><;'\|":[]}
write {\}\{`~!@#$} {\}\{`~!@#$}
write %^&*()_+-= %^&*()_+-=
write {
} {
}
flush/write {} {}
delete/write {} *ignored*
---- Result should have been (exact matching):
create/read {} *ignored*
query/maxRead {} -1
read abcdefghij abcdefghij
query/maxRead {} -1
read klmnopqrst klmnopqrst
query/maxRead {} -1
read uvwxyz0123 uvwxyz0123
query/maxRead {} -1
read 456789,./? 456789,./?
query/maxRead {} -1
read {><;'\|":[]} {><;'\|":[]}
query/maxRead {} -1
read {\}\{`~!@#$} {\}\{`~!@#$}
query/maxRead {} -1
read %^&*()_+-= %^&*()_+-=
query/maxRead {} -1
read {
} {
}
query/maxRead {} -1
flush/read {} {}
delete/read {} *ignored*
--------
create/write {} *ignored*
write abcdefghij abcdefghij
write klmnopqrst klmnopqrst
write uvwxyz0123 uvwxyz0123
write 456789,./? 456789,./?
write {><;'\|":[]} {><;'\|":[]}
write {\}\{`~!@#$} {\}\{`~!@#$}
write %^&*()_+-= %^&*()_+-=
write {
} {
}
flush/write {} {}
delete/write {} *ignored*
==== iogt-2.2 FAILED

parseOld.test

==== parseOld-5.9 array variable substitution FAILED
==== Contents of test case:

catch {unset a}; catch {unset qqq}
set "a(x y z)" qqq
set $a([format x]\ y [format z]) foo
set qqq

---- Result was:
can't read "a(x)": no such element in array
---- Result should have been (exact matching):
foo
---- Test generated error; Return code was: 1
---- Return code should have been one of: 0 2
==== parseOld-5.9 FAILED

pid.test
pkg.test
pkgMkIndex.test

==== pkgMkIndex-4.2 split package - direct loading FAILED
==== Contents of test case:

pkgtest::runIndex -direct $fullPkgPath pkg2_a.tcl pkg2_b.tcl

---- Result was:
0 {{pkg2:1.0 {source
/vol/tclsrcsol/tcl85/tcl/unix/pkg/pkg2_a.tcl^@source /vol/t
clsrcsol/tcl85/tcl/unix/pkg/pkg2_b.tcl}}}
---- Result should have been (exact matching):
0 {{pkg2:1.0 {source
/vol/tclsrcsol/tcl85/tcl/unix/pkg/pkg2_a.tcl
source /vol/tclsrcsol/tcl85/tcl/unix/pkg/pkg2_b.tcl}}}
==== pkgMkIndex-4.2 FAILED

==== pkgMkIndex-8.2 pkg5 uses pkg2 - use -direct FAILED
==== Contents of test case:

pkgtest::runIndex -direct $fullPkgPath pkg5.tcl
pkg2_a.tcl pkg2_b.tcl

---- Result was:
0 {{pkg2:1.0 {source
/vol/tclsrcsol/tcl85/tcl/unix/pkg/pkg2_a.tcl^@source /vol/t
clsrcsol/tcl85/tcl/unix/pkg/pkg2_b.tcl}} {pkg5:1.0 {source
/vol/tclsrcsol/tcl85/
tcl/unix/pkg/pkg5.tcl}}}
---- Result should have been (exact matching):
0 {{pkg2:1.0 {source
/vol/tclsrcsol/tcl85/tcl/unix/pkg/pkg2_a.tcl
source /vol/tclsrcsol/tcl85/tcl/unix/pkg/pkg2_b.tcl}}
{pkg5:1.0 {source /vol/tcl
srcsol/tcl85/tcl/unix/pkg/pkg5.tcl}}}
==== pkgMkIndex-8.2 FAILED

==== pkgMkIndex-10.2 package in DLL hidden by -load FAILED
==== Contents of test case:

# Do all [load]ing of shared libraries in another
process, so
# we can delete the file and not get stuck because we're
holding
# a reference to it.
#
# This test depends on context from prior test, so
repeat it.
set script "[list pkg_mkIndex -lazy $fullPkgPath [file
tail $x] pkga.tcl]\n"
append script "[list pkg_mkIndex -lazy -load Pkg*
$fullPkgPath [file tail $
x]]"
exec [interpreter] << $script
pkgtest::runCreatedIndex {0 {}} -lazy -load Pkg* --
$fullPkgPath pkga[info s
haredlibextension]

---- Result was:
0 {{Pkga:1.0 {tclPkgSetup {pkga.so load {pkga_eq
pkga_quote}} {pkga.tcl source p
kga_neq}}}}
---- Result should have been (exact matching):
0 {}
==== pkgMkIndex-10.2 FAILED

tcltest.test

==== tcltest-12.4 loadFile FAILED
==== Contents of test case:
set f1 [loadScript]
set f2 [loadFile]
set f3 [loadFile $loadfile]
set f4 [loadScript]
set f5 [loadFile]
list $f1 $f2 $f3 $f4 $f5
---- Result was:
{} {} /vol/tclsrcsol/tcl85/tcl/unix/load.tcl {
package require tcltest
namespace import tcltest::*
puts [outputChannel] $::tcltest::loadScript
exit
} /vol/tclsrcsol/tcl85/tcl/unix/load.tcl
---- Result should have been (exact matching):
{} {} /vol/tclsrcsol/tcl85/tcl/unix/load.tcl {
package require tcltest
namespace import tcltest::*
puts [outputChannel] $::tcltest::loadScript
exit
} /vol/tclsrcsol/tcl85/tcl/unix/load.tcl^@
==== tcltest-12.4 FAILED

[Larry W. Virden]

Logged In: YES
user_id=15949

I find if I configure Tcl 8.5 cvs head with only the 64 bit
support, and no threads, then I see only one occasional
problem in the event test suite.

[Don Porter]

Logged In: YES
user_id=80530

I believe this is fixed now.
Please test, confirm, and close.

[Don Porter]

Logged In: YES
user_id=80530

seems the failures reported in comments
below are fixed (from dup report 713754),
but the original failures reported are still seen.

[Don Porter]

Logged In: YES
user_id=80530

OK, so new report 714784 covers this now.
CLosing this one.