From 41a61597547eca28506fbb85f2737413dc8f2162 Mon Sep 17 00:00:00 2001
From: pooryorick <com.digitalsmarties@pooryorick.com>
Date: Sat, 16 Jun 2018 17:55:31 +0000
Subject: new package    tcltests exclude some exec.test tests when running
 under valgrind

---
 tests/all.tcl      |  9 +++++++++
 tests/exec.test    | 25 +++++++++++++++----------
 tests/ioCmd.test   |  1 -
 tests/pkgIndex.tcl |  6 ++++++
 4 files changed, 30 insertions(+), 11 deletions(-)
 create mode 100644 tests/pkgIndex.tcl

diff --git a/tests/all.tcl b/tests/all.tcl
index 69a16ba..ad372db 100644
--- a/tests/all.tcl
+++ b/tests/all.tcl
@@ -18,5 +18,14 @@ configure {*}$argv -testdir [file dir [info script]]
 if {[singleProcess]} {
     interp debug {} -frame 1
 }
+
+set testsdir [file dirname [file dirname [file normalize [info script]/...]]]
+lappend auto_path $testsdir {*}[apply {{testsdir args} {
+    lmap x $args {
+	if {$x eq $testsdir} continue
+	lindex $x
+    }
+}} $testsdir {*}$auto_path]
+
 runAllTests
 proc exit args {}
diff --git a/tests/exec.test b/tests/exec.test
index 5542f3d..6570e57 100644
--- a/tests/exec.test
+++ b/tests/exec.test
@@ -11,9 +11,14 @@
 # See the file "license.terms" for information on usage and redistribution of
 # this file, and for a DISCLAIMER OF ALL WARRANTIES.
 
+# There is no point in running Valgrind on cases where [exec] forks but then
+# fails and the child process doesn't go through full cleanup.
+
 package require tcltest 2
 namespace import -force ::tcltest::*
 
+package require tcltests
+
 # All tests require the "exec" command.
 # Skip them if exec is not defined.
 testConstraint exec [llength [info commands exec]]
@@ -325,11 +330,11 @@ test exec-8.2 {long input and output} {exec} {
 
 # Commands that return errors.
 
-test exec-9.1 {commands returning errors} {exec} {
+test exec-9.1 {commands returning errors} {exec notValgrind} {
     set x [catch {exec gorp456} msg]
     list $x [string tolower $msg] [string tolower $errorCode]
 } {1 {couldn't execute "gorp456": no such file or directory} {posix enoent {no such file or directory}}}
-test exec-9.2 {commands returning errors} {exec} {
+test exec-9.2 {commands returning errors} {exec notValgrind} {
     string tolower [list [catch {exec [interpreter] echo foo | foo123} msg] $msg $errorCode]
 } {1 {couldn't execute "foo123": no such file or directory} {posix enoent {no such file or directory}}}
 test exec-9.3 {commands returning errors} -constraints {exec stdio} -body {
@@ -339,7 +344,7 @@ test exec-9.4 {commands returning errors} -constraints {exec stdio} -body {
     exec [interpreter] $path(exit) 43 | [interpreter] $path(echo) "foo bar"
 } -returnCodes error -result {foo bar
 child process exited abnormally}
-test exec-9.5 {commands returning errors} -constraints {exec stdio} -body {
+test exec-9.5 {commands returning errors} -constraints {exec stdio notValgrind} -body {
     exec gorp456 | [interpreter] echo a b c
 } -returnCodes error -result {couldn't execute "gorp456": no such file or directory}
 test exec-9.6 {commands returning errors} -constraints {exec} -body {
@@ -428,13 +433,13 @@ test exec-10.19 {errors in exec invocation} -constraints {exec} -body {
     exec cat >@ $f
 } -returnCodes error -result "channel \"$f\" wasn't opened for writing"
 close $f
-test exec-10.20 {errors in exec invocation} -constraints {exec} -body {
+test exec-10.20 {errors in exec invocation} -constraints {exec notValgrind} -body {
     exec ~non_existent_user/foo/bar
 } -returnCodes error -result {user "non_existent_user" doesn't exist}
-test exec-10.21 {errors in exec invocation} -constraints {exec} -body {
+test exec-10.21 {errors in exec invocation} -constraints {exec notValgrind} -body {
     exec [interpreter] true | ~xyzzy_bad_user/x | false
 } -returnCodes error -result {user "xyzzy_bad_user" doesn't exist}
-test exec-10.22 {errors in exec invocation} -constraints exec -body {
+test exec-10.22 {errors in exec invocation} -constraints {exec notValgrind} -body {
     exec echo test > ~non_existent_user/foo/bar
 } -returnCodes error -result {user "non_existent_user" doesn't exist}
 # Commands in background.
@@ -510,7 +515,7 @@ test exec-13.1 {setting errorCode variable} {exec} {
 test exec-13.2 {setting errorCode variable} {exec} {
     list [catch {exec [interpreter] $path(cat) > a/b/c} msg] [string tolower $errorCode]
 } {1 {posix enoent {no such file or directory}}}
-test exec-13.3 {setting errorCode variable} {exec} {
+test exec-13.3 {setting errorCode variable} {exec notValgrind} {
     set x [catch {exec _weird_cmd_} msg]
     list $x [string tolower $msg] [lindex $errorCode 0] \
 	    [string tolower [lrange $errorCode 2 end]]
@@ -548,7 +553,7 @@ test exec-14.2 {-keepnewline switch} -constraints {exec} -body {
 test exec-14.3 {unknown switch} -constraints {exec} -body {
     exec -gorp
 } -returnCodes error -result {bad option "-gorp": must be -ignorestderr, -keepnewline, or --}
-test exec-14.4 {-- switch} -constraints {exec} -body {
+test exec-14.4 {-- switch} -constraints {exec notValgrind} -body {
     exec -- -gorp
 } -returnCodes error -result {couldn't execute "-gorp": no such file or directory}
 test exec-14.5 {-ignorestderr switch} {exec} {
@@ -662,7 +667,7 @@ test exec-18.2 {exec cat deals with weird file names} -body {
 # Note that this test cannot be adapted to work on Windows; that platform has
 # no kernel support for an analog of O_APPEND. OTOH, that means we can assume
 # that there is a POSIX shell...
-test exec-19.1 {exec >> uses O_APPEND} -constraints {exec unix} -setup {
+test exec-19.1 {exec >> uses O_APPEND} -constraints {exec unix notValgrind} -setup {
     set tmpfile [makeFile {0} tmpfile.exec-19.1]
 } -body {
     # Note that we have to allow for the current contents of the temporary
@@ -675,7 +680,7 @@ test exec-19.1 {exec >> uses O_APPEND} -constraints {exec unix} -setup {
 	    {for a in a b c; do sleep 1; echo $a; done} >>$tmpfile &
     exec /bin/sh -c \
 	    {for a in d e f; do sleep 1; echo $a >&2; done} 2>>$tmpfile &
-    # The above four shell invokations take about 3 seconds to finish, so allow
+    # The above four shell invocations take about 3 seconds to finish, so allow
     # 5s (in case the machine is busy)
     after 5000
     # Check that no bytes have got lost through mixups with overlapping
diff --git a/tests/ioCmd.test b/tests/ioCmd.test
index cab4e97..ae58025 100644
--- a/tests/ioCmd.test
+++ b/tests/ioCmd.test
@@ -3781,7 +3781,6 @@ test iocmd.tf-32.0 {origin thread of moved channel gone} -match glob -body {
 # Use constraints to skip this test while valgrinding so this expected leak
 # doesn't prevent a finding of "leak-free".
 #
-testConstraint notValgrind [expr {![testConstraint valgrind]}]
 test iocmd.tf-32.1 {origin thread of moved channel destroyed during access} -match glob -body {
 
     #puts <<$tcltest::mainThread>>main
diff --git a/tests/pkgIndex.tcl b/tests/pkgIndex.tcl
new file mode 100644
index 0000000..48ab71b
--- /dev/null
+++ b/tests/pkgIndex.tcl
@@ -0,0 +1,6 @@
+#! /usr/bin/env tclsh
+
+package ifneeded tcltests 0.1 {
+	source [file dirname [file dirname [file normalize [info script]/...]]]/tcltests.tcl
+	package provide tcltests 0.1
+}
-- 
cgit v0.12


From 7bf68c2335062edb662417df9048b2c56244479f Mon Sep 17 00:00:00 2001
From: dkf <donal.k.fellows@manchester.ac.uk>
Date: Sat, 16 Jun 2018 18:07:30 +0000
Subject: Add in basic github meta-files to reduce problems with issues being
 filed where we don't see them.

---
 .github/ISSUE_TEMPLATE.md        | 3 +++
 .github/PULL_REQUEST_TEMPLATE.md | 3 +++
 2 files changed, 6 insertions(+)
 create mode 100644 .github/ISSUE_TEMPLATE.md
 create mode 100644 .github/PULL_REQUEST_TEMPLATE.md

diff --git a/.github/ISSUE_TEMPLATE.md b/.github/ISSUE_TEMPLATE.md
new file mode 100644
index 0000000..22d3860
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE.md
@@ -0,0 +1,3 @@
+Important Note
+==========
+Please do not file issues with Tcl on Github. They are unlikely to be noticed in a timely fashion. Tcl issues are hosted in the [tcl fossil repository on core.tcl.tk](https://core.tcl.tk/tcl/tktnew); please post them there.
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
new file mode 100644
index 0000000..da07cd2
--- /dev/null
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -0,0 +1,3 @@
+Important Note
+==========
+Please do not file pull requests with Tcl on Github. They are unlikely to be noticed in a timely fashion. Tcl issues (including patches) are hosted in the [tcl fossil repository on core.tcl.tk](https://core.tcl.tk/tcl/tktnew); please post them there.
-- 
cgit v0.12


From 983854ad7b59ba90d6686bdd6f6f0fd3014a6912 Mon Sep 17 00:00:00 2001
From: pooryorick <com.digitalsmarties@pooryorick.com>
Date: Sat, 16 Jun 2018 22:56:07 +0000
Subject: Add tests/tcltests.tcl as a place to store common code for tests.

---
 tests/tcltests.tcl | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 tests/tcltests.tcl

diff --git a/tests/tcltests.tcl b/tests/tcltests.tcl
new file mode 100644
index 0000000..f7597b5
--- /dev/null
+++ b/tests/tcltests.tcl
@@ -0,0 +1,3 @@
+#! /usr/bin/env tclsh
+
+testConstraint notValgrind [expr {![testConstraint valgrind]}]
-- 
cgit v0.12


From dd713ee96ec9cda48ba5f801193a70b6eb49d4a1 Mon Sep 17 00:00:00 2001
From: pooryorick <com.digitalsmarties@pooryorick.com>
Date: Sat, 16 Jun 2018 22:57:36 +0000
Subject: Add tests/tcltests.tcl as a place to store common code for tests.

---
 tests/tcltests.tcl | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 tests/tcltests.tcl

diff --git a/tests/tcltests.tcl b/tests/tcltests.tcl
new file mode 100644
index 0000000..f7597b5
--- /dev/null
+++ b/tests/tcltests.tcl
@@ -0,0 +1,3 @@
+#! /usr/bin/env tclsh
+
+testConstraint notValgrind [expr {![testConstraint valgrind]}]
-- 
cgit v0.12


From 2b739c838a2b0f6dc7e64fad24eeb661d1a437ba Mon Sep 17 00:00:00 2001
From: pooryorick <com.digitalsmarties@pooryorick.com>
Date: Sun, 17 Jun 2018 08:47:29 +0000
Subject: Remove dependencies between tests in env.test.

---
 tests/env.test     | 399 +++++++++++++++++++++++++++++++----------------------
 tests/tcltests.tcl |   4 +
 2 files changed, 236 insertions(+), 167 deletions(-)

diff --git a/tests/env.test b/tests/env.test
index 0dd4f98..2c077b1 100644
--- a/tests/env.test
+++ b/tests/env.test
@@ -16,49 +16,96 @@ if {[lsearch [namespace children] ::tcltest] == -1} {
     namespace import -force ::tcltest::*
 }
 
-# Some tests require the "exec" command.
-# Skip them if exec is not defined.
-testConstraint exec [llength [info commands exec]]
+package require tcltests
+
+# [exec] is required here to see the actual environment received by child
+# processes.
+proc getenv {} {
+    global printenvScript
+    catch {exec [interpreter] $printenvScript} out
+    if {$out eq "child process exited abnormally"} {
+	set out {}
+    }
+    return $out
+}
+
+
+proc envrestore {} {
+    # Restore the environment variables at the end of the test.
+    global env
+    variable env2
+
+    foreach name [array names env] {
+	unset env($name)
+    }
+    array set env $env2
+    return
+}
+
+
+proc envprep {} {
+    # Save the current environment variables at the start of the test.
+    global env
+    variable keep
+    variable env2
+
+    set env2 [array get env]
+    foreach name [array names env] {
+	# Keep some environment variables that support operation of the tcltest
+	# package.
+	if {[string toupper $name] ni $keep} {
+	    unset env($name)
+	}
+    }
+    return
+}
+
+
+proc encodingrestore {} {
+    variable sysenc
+    encoding system $sysenc
+    return
+}
+
+
+proc encodingswitch encoding {
+    variable sysenc
+    # Need to run [getenv] in known encoding, so save the current one here...
+    set sysenc [encoding system]
+    encoding system $encoding
+    return
+}
+
+
+proc setup1 {} {
+    global env
+    envprep
+    encodingswitch iso8859-1
+}
+
+proc setup2 {} {
+    global env
+    setup1
+    set env(NAME1) {test string}
+    set env(NAME2) {new value}
+    set env(XYZZY) {garbage}
+}
+
+
+proc cleanup1 {} {
+    encodingrestore
+    envrestore
+}
 
-#
-# These tests will run on any platform (and indeed crashed on the Mac). So put
-# them before you test for the existance of exec.
-#
-test env-1.1 {propagation of env values to child interpreters} -setup {
-    catch {interp delete child}
-    catch {unset env(test)}
-} -body {
-    interp create child
-    set env(test) garbage
-    child eval {set env(test)}
-} -cleanup {
-    interp delete child
-    unset env(test)
-} -result {garbage}
-#
-# This one crashed on Solaris under Tcl8.0, so we only want to make sure it
-# runs.
-#
-test env-1.2 {lappend to env value} -setup {
-    catch {unset env(test)}
-} -body {
-    set env(test) aaaaaaaaaaaaaaaa
-    append env(test) bbbbbbbbbbbbbb
-    unset env(test)
+variable keep {
+    TCL_LIBRARY PATH LD_LIBRARY_PATH LIBPATH DISPLAY SHLIB_PATH
+    SYSTEMDRIVE SYSTEMROOT DYLD_LIBRARY_PATH DYLD_FRAMEWORK_PATH
+    DYLD_NEW_LOCAL_SHARED_REGIONS DYLD_NO_FIX_PREBINDING
+    SECURITYSESSIONID LANG WINDIR TERM
+    CONNOMPROGRAMFILES PROGRAMFILES COMMONPROGRAMW6432 PROGRAMW6432
 }
-test env-1.3 {reflection of env by "array names"} -setup {
-    catch {interp delete child}
-    catch {unset env(test)}
-} -body {
-    interp create child
-    child eval {set env(test) garbage}
-    expr {"test" in [array names env]}
-} -cleanup {
-    interp delete child
-    catch {unset env(test)}
-} -result {1}
 
-set printenvScript [makeFile {
+variable printenvScript [makeFile [string map [list @keep@ [list $keep]] {
     encoding system iso8859-1
     proc lrem {listname name} {
 	upvar $listname list
@@ -70,7 +117,7 @@ set printenvScript [makeFile {
     }
     proc mangle s {
 	regsub -all {\[|\\|\]} $s {\\&} s
-	regsub -all "\[\u0000-\u001f\u007f-\uffff\]" $s {[manglechar &]} s
+	regsub -all "\[\u0000-\u001f\u007f-\uffff\]" $s {[manglechar {&}]} s
 	return [subst -novariables $s]
     }
     proc manglechar c {
@@ -84,161 +131,154 @@ set printenvScript [makeFile {
 	lrem names ComSpec
 	lrem names ""
     }
-    foreach name {
-	TCL_LIBRARY PATH LD_LIBRARY_PATH LIBPATH PURE_PROG_NAME DISPLAY
-	SHLIB_PATH SYSTEMDRIVE SYSTEMROOT DYLD_LIBRARY_PATH DYLD_FRAMEWORK_PATH
-	DYLD_NEW_LOCAL_SHARED_REGIONS DYLD_NO_FIX_PREBINDING
-	__CF_USER_TEXT_ENCODING SECURITYSESSIONID LANG WINDIR TERM
-	CommonProgramFiles ProgramFiles CommonProgramW6432 ProgramW6432
-    } {
+    foreach name @keep@ {
 	lrem names $name
     }
     foreach p $names {
-	puts "[mangle $p]=[mangle $env($p)]"
+	puts [mangle $p]=[mangle $env($p)]
     }
     exit
-} printenv]
+}] printenv]
 
-# [exec] is required here to see the actual environment received by child
-# processes.
-proc getenv {} {
-    global printenvScript tcltest
-    catch {exec [interpreter] $printenvScript} out
-    if {$out eq "child process exited abnormally"} {
-	set out {}
-    }
-    return $out
-}
 
-# Save the current environment variables at the start of the test.
-
-set env2 [array get env]
-foreach name [array names env] {
-    # Keep some environment variables that support operation of the tcltest
-    # package.
-    if {[string toupper $name] ni {
-	TCL_LIBRARY PATH LD_LIBRARY_PATH LIBPATH DISPLAY SHLIB_PATH
-	SYSTEMDRIVE SYSTEMROOT DYLD_LIBRARY_PATH DYLD_FRAMEWORK_PATH
-	DYLD_NEW_LOCAL_SHARED_REGIONS DYLD_NO_FIX_PREBINDING
-	SECURITYSESSIONID LANG WINDIR TERM
-	CONNOMPROGRAMFILES PROGRAMFILES COMMONPROGRAMW6432 PROGRAMW6432
-    }} {
-	unset env($name)
-    }
+test env-1.1 {propagation of env values to child interpreters} -setup {
+    catch {interp delete child}
+    catch {unset env(test)}
+} -body {
+    interp create child
+    set env(test) garbage
+    child eval {set env(test)}
+} -cleanup {
+    interp delete child
+    unset env(test)
+} -result {garbage}
+
+
+# This one crashed on Solaris under Tcl8.0, so we only want to make sure it
+# runs.
+test env-1.2 {lappend to env value} -setup {
+    catch {unset env(test)}
+} -body {
+    set env(test) aaaaaaaaaaaaaaaa
+    append env(test) bbbbbbbbbbbbbb
+    unset env(test)
 }
 
-# Need to run 'getenv' in known encoding, so save the current one here...
-set sysenc [encoding system]
 
-test env-2.1 {adding environment variables} -setup {
-    encoding system iso8859-1
-} -constraints {exec} -body {
-    getenv
+test env-1.3 {reflection of env by "array names"} -setup {
+    catch {interp delete child}
+    catch {unset env(test)}
+} -body {
+    interp create child
+    child eval {set env(test) garbage}
+    expr {"test" in [array names env]}
 } -cleanup {
-    encoding system $sysenc
-} -result {}
-test env-2.2 {adding environment variables} -setup {
-    encoding system iso8859-1
-} -constraints {exec} -body {
+    interp delete child
+    catch {unset env(test)}
+} -result 1
+
+
+test env-2.1 {
+    adding environment variables
+} -constraints exec -setup setup1 -body {
+    getenv
+} -cleanup cleanup1 -result {}
+
+
+test env-2.2 {
+    adding environment variables
+} -constraints exec -setup setup1 -body {
     set env(NAME1) "test string"
     getenv
-} -cleanup {
-    encoding system $sysenc
-} -result {NAME1=test string}
-test env-2.3 {adding environment variables} -setup {
-    encoding system iso8859-1
+} -cleanup cleanup1 -result {NAME1=test string}
+
+
+test env-2.3 {adding environment variables} -constraints exec -setup {
+    setup1
     set env(NAME1) "test string"
-} -constraints {exec} -body {
+} -body {
     set env(NAME2) "more"
     getenv
-} -cleanup {
-    encoding system $sysenc
-} -result {NAME1=test string
+} -cleanup cleanup1 -result {NAME1=test string
 NAME2=more}
-test env-2.4 {adding environment variables} -setup {
-    encoding system iso8859-1
+
+
+test env-2.4 {
+    adding environment variables
+} -constraints exec -setup {
+    setup1
     set env(NAME1) "test string"
     set env(NAME2) "more"
-} -constraints {exec} -body {
+} -body {
     set env(XYZZY) "garbage"
     getenv
-} -cleanup {
-    encoding system $sysenc
+} -cleanup { cleanup1
 } -result {NAME1=test string
 NAME2=more
 XYZZY=garbage}
 
-set env(NAME1) "test string"
-set env(NAME2) "new value"
-set env(XYZZY) "garbage"
-test env-3.1 {changing environment variables} -setup {
-    encoding system iso8859-1
-} -constraints {exec} -body {
+
+test env-3.1 {
+    changing environment variables
+} -constraints exec -setup setup2 -body {
     set result [getenv]
     unset env(NAME2)
     set result
 } -cleanup {
-    encoding system $sysenc
+    cleanup1
 } -result {NAME1=test string
 NAME2=new value
 XYZZY=garbage}
-unset -nocomplain env(NAME2)
 
-test env-4.1 {unsetting environment variables: default} -setup {
-    encoding system iso8859-1
-} -constraints {exec} -body {
+
+test env-4.1 {
+    unsetting environment variables
+} -constraints exec -setup setup2 -body {
+    unset -nocomplain env(NAME2)
     getenv
-} -cleanup {
-    encoding system $sysenc
-} -result {NAME1=test string
+} -cleanup cleanup1 -result {NAME1=test string
 XYZZY=garbage}
-test env-4.2 {unsetting environment variables} -setup {
-    encoding system iso8859-1
-} -constraints {exec} -body {
-    unset env(NAME1)
-    getenv
-} -cleanup {
-    unset env(XYZZY)
-    encoding system $sysenc
-} -result {XYZZY=garbage}
-unset -nocomplain env(NAME1) env(XYZZY)
-test env-4.3 {setting international environment variables} -setup {
-    encoding system iso8859-1
-} -constraints {exec} -body {
+
+# env-4.2 is deleted
+
+test env-4.3 {
+    setting international environment variables
+} -constraints exec -setup setup1 -body {
     set env(\ua7) \ub6
     getenv
-} -cleanup {
-    encoding system $sysenc
-} -result {\u00a7=\u00b6}
-test env-4.4 {changing international environment variables} -setup {
-    encoding system iso8859-1
-} -constraints {exec} -body {
+} -cleanup cleanup1 -result {\u00a7=\u00b6}
+
+
+test env-4.4 {
+    changing international environment variables
+} -constraints exec -setup setup1 -body {
     set env(\ua7) \ua7
     getenv
-} -cleanup {
-    encoding system $sysenc
-} -result {\u00a7=\u00a7}
-test env-4.5 {unsetting international environment variables} -setup {
-    encoding system iso8859-1
+} -cleanup cleanup1 -result {\u00a7=\u00a7}
+
+
+test env-4.5 {
+    unsetting international environment variables
+} -constraints exec -setup {
+    setup1
     set env(\ua7) \ua7
 } -body {
     set env(\ub6) \ua7
     unset env(\ua7)
     getenv
-} -constraints {exec} -cleanup {
-    unset env(\ub6)
-    encoding system $sysenc
-} -result {\u00b6=\u00a7}
+} -cleanup cleanup1 -result {\u00b6=\u00a7}
 
-test env-5.0 {corner cases - set a value, it should exist} -body {
+test env-5.0 {
+    corner cases - set a value, it should exist
+} -setup setup1 -body {
     set env(temp) a
     set env(temp)
-} -cleanup {
-    unset env(temp)
-} -result {a}
-test env-5.1 {corner cases - remove one elem at a time} -setup {
-    set x [array get env]
-} -body {
+} -cleanup cleanup1 -result a
+
+
+test env-5.1 {
+    corner cases - remove one elem at a time
+} -setup setup1 -body {
     # When no environment variables exist, the env var will contain no
     # entries. The "array names" call synchs up the C-level environ array with
     # the Tcl level env array. Make sure an empty Tcl array is created.
@@ -246,9 +286,9 @@ test env-5.1 {corner cases - remove one elem at a time} -setup {
 	unset env($e)
     }
     array size env
-} -cleanup {
-    array set env $x
-} -result {0}
+} -cleanup cleanup1 -result 0
+
+
 test env-5.2 {corner cases - unset the env array} -setup {
     interp create i
 } -body {
@@ -262,42 +302,54 @@ test env-5.2 {corner cases - unset the env array} -setup {
 } -cleanup {
     interp delete i
 } -result {0}
+
+
 test env-5.3 {corner cases: unset the env in master should unset child} -setup {
+    setup1
     interp create i
 } -body {
     # Variables deleted in a master interp should be deleted in child interp
     # too.
-    i eval { set env(THIS_SHOULD_EXIST) a}
+    i eval {set env(THIS_SHOULD_EXIST) a}
     set result [set env(THIS_SHOULD_EXIST)]
     unset env(THIS_SHOULD_EXIST)
     lappend result [i eval {catch {set env(THIS_SHOULD_EXIST)}}]
 } -cleanup {
+    cleanup1
     interp delete i
 } -result {a 1}
+
+
 test env-5.4 {corner cases - unset the env array} -setup {
+    setup1
     interp create i
 } -body {
     # The info exists command should be in synch with the env array.
     # Know Bug: 1737
-    i eval { set env(THIS_SHOULD_EXIST) a}
+    i eval {set env(THIS_SHOULD_EXIST) a}
     set     result [info exists env(THIS_SHOULD_EXIST)]
     lappend result [set env(THIS_SHOULD_EXIST)]
     lappend result [info exists env(THIS_SHOULD_EXIST)]
 } -cleanup {
+    cleanup1
     interp delete i
 } -result {1 a 1}
-test env-5.5 {corner cases - cannot have null entries on Windows} -constraints win -body {
+
+
+test env-5.5 {
+    corner cases - cannot have null entries on Windows
+} -constraints win -body {
     set env() a
     catch {set env()}
-} -result 1
+} -cleanup cleanup1 -result 1
 
-test env-6.1 {corner cases - add lots of env variables} -body {
+test env-6.1 {corner cases - add lots of env variables} -setup setup1 -body {
     set size [array size env]
     for {set i 0} {$i < 100} {incr i} {
 	set env(BOGUS$i) $i
     }
     expr {[array size env] - $size}
-} -result 100
+} -cleanup cleanup1 -result 100
 
 test env-7.1 {[219226]: whole env array should not be unset by read} -body {
     set n [array size env]
@@ -310,16 +362,20 @@ test env-7.1 {[219226]: whole env array should not be unset by read} -body {
     return $n
 } -result 0
 
-test env-7.2 {[219226]: links to env elements should not be removed by read} -body {
+test env-7.2 {
+    [219226]: links to env elements should not be removed by read
+} -setup setup1 -body {
     apply {{} {
 	set ::env(test7_2) ok
 	upvar env(test7_2) elem
 	set ::env(PATH)
 	return $elem
     }}
-} -result ok
+} -cleanup cleanup1 -result ok
 
-test env-7.3 {[9b4702]: testing existence of env(some_thing) should not destroy trace} -body {
+test env-7.3 {
+    [9b4702]: testing existence of env(some_thing) should not destroy trace
+} -setup setup1 -body {
     apply {{} {
       catch {unset ::env(test7_3)}
       proc foo args {
@@ -330,16 +386,25 @@ test env-7.3 {[9b4702]: testing existence of env(some_thing) should not destroy
       set ::env(not_yet_existent) "Now I'm here";
       return [info exists ::env(test7_3)]
     }}
-} -result 1
+} -cleanup cleanup1 -result 1
 
-# Restore the environment variables at the end of the test.
+test env-8.0 {
+    memory usage - valgrind does not report reachable memory
+} -body {
+    set res [set env(__DUMMY__) {i'm with dummy}]
+    unset env(__DUMMY__)
+    return $res
+} -result {i'm with dummy}
+
 
-foreach name [array names env] {
-    unset env($name)
-}
-array set env $env2
 
 # cleanup
+rename getenv {} 
+rename envrestore {} 
+rename envprep {}
+rename encodingrestore {}
+rename encodingswitch {}
+
 removeFile $printenvScript
 ::tcltest::cleanupTests
 return
diff --git a/tests/tcltests.tcl b/tests/tcltests.tcl
index f7597b5..8d42b70 100644
--- a/tests/tcltests.tcl
+++ b/tests/tcltests.tcl
@@ -1,3 +1,7 @@
 #! /usr/bin/env tclsh
 
+# Some tests require the "exec" command.
+# Skip them if exec is not defined.
+testConstraint exec [llength [info commands exec]]
+
 testConstraint notValgrind [expr {![testConstraint valgrind]}]
-- 
cgit v0.12


From 8047a470ef35faeafe18de166f773a78097b3fc2 Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Sun, 17 Jun 2018 16:07:09 +0000
Subject: Fix [53cad613d8a4de166e680f09a6c6399ebddbc17c|53cad613d8]: TIP 389
 implementation makes Tk tests font-4.12 and font-4.15 fail. (Fix it in 8.6
 too, for benefit of androwish)

---
 generic/tclParse.c | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/generic/tclParse.c b/generic/tclParse.c
index f2cf322..fc7f77b 100644
--- a/generic/tclParse.c
+++ b/generic/tclParse.c
@@ -991,6 +991,14 @@ TclParseBackslash(
     if (readPtr != NULL) {
 	*readPtr = count;
     }
+#if TCL_UTF_MAX >= 4
+    if ((result & 0xFC00) == 0xD800) {
+	dst[2] = (char) ((result | 0x80) & 0xBF);
+	dst[1] = (char) (((result >> 6) | 0x80) & 0xBF);
+	dst[0] = (char) ((result >> 12) | 0xE0);
+	return 3;
+    }
+#endif
     return Tcl_UniCharToUtf(result, dst);
 }
 
-- 
cgit v0.12


From e9c0ec1219e3c42df67c414bfda0bb5aab9a5bbb Mon Sep 17 00:00:00 2001
From: pooryorick <com.digitalsmarties@pooryorick.com>
Date: Mon, 18 Jun 2018 05:59:22 +0000
Subject: Plug leak in TclSetEnv.

---
 generic/tclEnv.c   | 4 ++++
 tests/pkgIndex.tcl | 8 ++++----
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/generic/tclEnv.c b/generic/tclEnv.c
index 8cc4b74..c559c69 100644
--- a/generic/tclEnv.c
+++ b/generic/tclEnv.c
@@ -730,6 +730,10 @@ TclFinalizeEnvironment(void)
 	ckfree(env.cache);
 	env.cache = NULL;
 	env.cacheSize = 0;
+	if ((env.ourEnviron != NULL)) {
+	    ckfree(env.ourEnviron);
+	    env.ourEnviron = NULL;
+	}
 #ifndef USE_PUTENV
 	env.ourEnvironSize = 0;
 #endif
diff --git a/tests/pkgIndex.tcl b/tests/pkgIndex.tcl
index 48ab71b..0feb0eb 100644
--- a/tests/pkgIndex.tcl
+++ b/tests/pkgIndex.tcl
@@ -1,6 +1,6 @@
 #! /usr/bin/env tclsh
 
-package ifneeded tcltests 0.1 {
-	source [file dirname [file dirname [file normalize [info script]/...]]]/tcltests.tcl
-	package provide tcltests 0.1
-}
+package ifneeded tcltests 0.1 "
+    source [list $dir]/tcltests.tcl
+    package provide tcltests 0.1
+"
-- 
cgit v0.12


From 625aca976acac85e85a36f68a3727d2eec785922 Mon Sep 17 00:00:00 2001
From: pooryorick <com.digitalsmarties@pooryorick.com>
Date: Mon, 18 Jun 2018 07:06:04 +0000
Subject: Full cleanup of env cache when in a PURIFY build.

---
 generic/tclEnv.c | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/generic/tclEnv.c b/generic/tclEnv.c
index c559c69..4a48f65 100644
--- a/generic/tclEnv.c
+++ b/generic/tclEnv.c
@@ -723,10 +723,18 @@ TclFinalizeEnvironment(void)
      * strings. This may leak more memory that strictly necessary, since some
      * of the strings may no longer be in the environment. However,
      * determining which ones are ok to delete is n-squared, and is pretty
-     * unlikely, so we don't bother.
+     * unlikely, so we don't bother.  However, in the case of DPURIFY, just
+     * free all strings in the cache.
      */
 
+    size_t i;
+
     if (env.cache) {
+#ifdef PURIFY
+	for (i = 0; i < env.cacheSize; i++) {
+	    ckfree(env.cache[i]);
+	}
+#endif
 	ckfree(env.cache);
 	env.cache = NULL;
 	env.cacheSize = 0;
-- 
cgit v0.12


From 155e8a1ad56291fb61f3578f3c7cda632556d1da Mon Sep 17 00:00:00 2001
From: pooryorick <com.digitalsmarties@pooryorick.com>
Date: Mon, 18 Jun 2018 08:09:32 +0000
Subject: Avoid valgrind "still reachable" reports stemming from early
 termination of threads.

---
 tests/async.test | 40 +++++++++++++++++++++++++++++-----------
 1 file changed, 29 insertions(+), 11 deletions(-)

diff --git a/tests/async.test b/tests/async.test
index cb67cc2..e7fc45a 100644
--- a/tests/async.test
+++ b/tests/async.test
@@ -157,17 +157,24 @@ test async-4.1 {async interrupting bytecode sequence} -constraints {
     }
 } -body {
     apply {{handle} {
-	global aresult
-	set aresult {Async event not delivered}
-	testasync marklater $handle
-	for {set i 0} {
-	    $i < 2500000  &&  $aresult eq "Async event not delivered"
-	} {incr i} {
-	    nothing
-	}
+    global aresult
+    set aresult {Async event not delivered}
+    testasync marklater $handle
+    # allow plenty of time to pass in case valgrind is running
+    set start [clock seconds]
+    while {
+	[clock seconds] - $start < 180 && $aresult eq "Async event not delivered"
+    } {
+	# be less busy
+	after 100
+	nothing
+    }
 	return $aresult
     }} $hm
 } -result {test pattern} -cleanup {
+    # give other threads some time to go way so that valgrind doesn't pick up
+    # "still reachable" cases from early thread termination
+    after 100
     testasync delete $hm
 }
 test async-4.2 {async interrupting straight bytecode sequence} -constraints {
@@ -179,12 +186,20 @@ test async-4.2 {async interrupting straight bytecode sequence} -constraints {
 	global aresult
 	set aresult {Async event not delivered}
 	testasync marklater $handle
-	for {set i 0} {
-	    $i < 2500000  &&  $aresult eq "Async event not delivered"
-	} {incr i} {}
+	# allow plenty of time to pass in case valgrind is running
+	set start [clock seconds]
+	while {
+		[clock seconds] - $start < 180 && $aresult eq "Async event not delivered"
+	} {
+		# be less busy
+	    after 100
+	}
 	return $aresult
     }} $hm
 } -result {test pattern} -cleanup {
+    # give other threads some time to go way so that valgrind doesn't pick up
+    # "still reachable" cases from early thread termination
+    after 100
     testasync delete $hm
 }
 test async-4.3 {async interrupting loop-less bytecode sequence} -constraints {
@@ -201,6 +216,9 @@ test async-4.3 {async interrupting loop-less bytecode sequence} -constraints {
 	return $aresult
     }]] $hm
 } -result {test pattern} -cleanup {
+    # give other threads some time to go way so that valgrind doesn't pick up
+    # "still reachable" cases from early thread termination
+    after 100
     testasync delete $hm
 }
 
-- 
cgit v0.12


From 04004f3abcabe486568af1e7b026d03670b48ca8 Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Mon, 18 Jun 2018 15:51:43 +0000
Subject: Unbreak build on Windows (and - most likely - some other platforms
 too)

---
 generic/tclEnv.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/generic/tclEnv.c b/generic/tclEnv.c
index 4a48f65..40ced17 100644
--- a/generic/tclEnv.c
+++ b/generic/tclEnv.c
@@ -727,10 +727,9 @@ TclFinalizeEnvironment(void)
      * free all strings in the cache.
      */
 
-    size_t i;
-
     if (env.cache) {
 #ifdef PURIFY
+	int i;
 	for (i = 0; i < env.cacheSize; i++) {
 	    ckfree(env.cache[i]);
 	}
@@ -738,11 +737,11 @@ TclFinalizeEnvironment(void)
 	ckfree(env.cache);
 	env.cache = NULL;
 	env.cacheSize = 0;
+#ifndef USE_PUTENV
 	if ((env.ourEnviron != NULL)) {
 	    ckfree(env.ourEnviron);
 	    env.ourEnviron = NULL;
 	}
-#ifndef USE_PUTENV
 	env.ourEnvironSize = 0;
 #endif
     }
-- 
cgit v0.12


From 3c57d80efed172427e5aafa447365cb61439613c Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Mon, 18 Jun 2018 15:54:38 +0000
Subject: Fix [53cad613d8]: TIP 389 implementation makes Tk tests font-4.12 and
 font-4.15 fail. One more situation in which high surrogate causes problem

---
 generic/tclParse.c     | 12 +++++-------
 generic/tclStringObj.c |  6 ++++++
 generic/tclUtf.c       |  7 +++++++
 3 files changed, 18 insertions(+), 7 deletions(-)

diff --git a/generic/tclParse.c b/generic/tclParse.c
index fc7f77b..f26f933 100644
--- a/generic/tclParse.c
+++ b/generic/tclParse.c
@@ -991,15 +991,13 @@ TclParseBackslash(
     if (readPtr != NULL) {
 	*readPtr = count;
     }
-#if TCL_UTF_MAX >= 4
-    if ((result & 0xFC00) == 0xD800) {
-	dst[2] = (char) ((result | 0x80) & 0xBF);
-	dst[1] = (char) (((result >> 6) | 0x80) & 0xBF);
-	dst[0] = (char) ((result >> 12) | 0xE0);
-	return 3;
+    count = Tcl_UniCharToUtf(result, dst);
+#if TCL_UTF_MAX > 3
+    if (!count) {
+	count = Tcl_UniCharToUtf(-1, dst);
     }
 #endif
-    return Tcl_UniCharToUtf(result, dst);
+    return count;
 }
 
 /*
diff --git a/generic/tclStringObj.c b/generic/tclStringObj.c
index a503392..1795d0c 100644
--- a/generic/tclStringObj.c
+++ b/generic/tclStringObj.c
@@ -1996,6 +1996,12 @@ Tcl_AppendFormatToObj(
 		goto error;
 	    }
 	    length = Tcl_UniCharToUtf(code, buf);
+#if TCL_UTF_MAX > 3
+	    if (!length) {
+		/* Special case for handling upper surrogates. */
+		length = Tcl_UniCharToUtf(-1, buf);
+	    }
+#endif
 	    segment = Tcl_NewStringObj(buf, length);
 	    Tcl_IncrRefCount(segment);
 	    allocSegment = 1;
diff --git a/generic/tclUtf.c b/generic/tclUtf.c
index 46ce4ef..c2963bf 100644
--- a/generic/tclUtf.c
+++ b/generic/tclUtf.c
@@ -189,6 +189,13 @@ Tcl_UniCharToUtf(
 	    buf[0] = (char) ((ch >> 18) | 0xF0);
 	    return 4;
 	}
+    } else if (ch == -1) {
+	if (((buf[0] & 0xF8) == 0xF0) && ((buf[1] & 0xC0) == 0x80)
+		&& ((buf[2] & 0xCF) == 0)) {
+	    ch = 0xD7C0 + ((buf[0] & 0x07) << 8) + ((buf[1] & 0x3F) << 2)
+		    + ((buf[2] & 0x30) >> 4);
+	    goto three;
+	}
 #endif
     }
 
-- 
cgit v0.12


From 03a3c09b1fc4fc80caec28b88b0fe09d612835b8 Mon Sep 17 00:00:00 2001
From: pooryorick <com.digitalsmarties@pooryorick.com>
Date: Tue, 19 Jun 2018 11:47:08 +0000
Subject: new file: tools/valgrind_suppress.  num-callers bumped from 8 to 24. 
 Valgrind now issues no "still reachable" reports for cmdAH.test.

---
 tests/all.tcl           | 23 ++++++++++++++---------
 tests/pkgIndex.tcl      |  2 +-
 tools/valgrind_suppress | 33 +++++++++++++++++++++++++++++++++
 unix/Makefile.in        |  4 +++-
 4 files changed, 51 insertions(+), 11 deletions(-)
 create mode 100644 tools/valgrind_suppress

diff --git a/tests/all.tcl b/tests/all.tcl
index ad372db..d6434fb 100644
--- a/tests/all.tcl
+++ b/tests/all.tcl
@@ -14,18 +14,23 @@ package prefer latest
 package require Tcl 8.5-
 package require tcltest 2.2
 namespace import tcltest::*
-configure {*}$argv -testdir [file dir [info script]]
-if {[singleProcess]} {
-    interp debug {} -frame 1
-}
 
-set testsdir [file dirname [file dirname [file normalize [info script]/...]]]
-lappend auto_path $testsdir {*}[apply {{testsdir args} {
-    lmap x $args {
+apply {args {
+    global auto_path
+    set testsdir [file dirname [file dirname [file normalize [
+	info script]/...]]]
+
+    configure {*}$args -testdir $testsdir
+
+    if {[singleProcess]} {
+	interp debug {} -frame 1
+    }
+
+    set auto_path [lmap x $auto_path[set auto_path {}] {
 	if {$x eq $testsdir} continue
 	lindex $x
-    }
-}} $testsdir {*}$auto_path]
+    }]
+}} {*}$argv
 
 runAllTests
 proc exit args {}
diff --git a/tests/pkgIndex.tcl b/tests/pkgIndex.tcl
index 0feb0eb..854b943 100644
--- a/tests/pkgIndex.tcl
+++ b/tests/pkgIndex.tcl
@@ -1,6 +1,6 @@
 #! /usr/bin/env tclsh
 
 package ifneeded tcltests 0.1 "
-    source [list $dir]/tcltests.tcl
+    source [list $dir/tcltests.tcl]
     package provide tcltests 0.1
 "
diff --git a/tools/valgrind_suppress b/tools/valgrind_suppress
new file mode 100644
index 0000000..e8f0204
--- /dev/null
+++ b/tools/valgrind_suppress
@@ -0,0 +1,33 @@
+{
+   TclpGetPwNam/getpwname_r/__nss_next2/calloc
+   Memcheck:Leak
+   match-leak-kinds: reachable
+   fun:calloc
+   ...
+   fun:__nss_next2
+   ...
+   fun:TclpGetPwNam
+}
+
+{
+   TclpGetPwNam/getpwname_r/__nss_next2/malloc
+   Memcheck:Leak
+   match-leak-kinds: reachable
+   fun:malloc
+   ...
+   fun:__nss_next2
+   ...
+   fun:TclpGetPwNam
+}
+
+{
+   TclpGetPwNam/getpwname_r/_nss_systemd_getpwnam_r/malloc
+   Memcheck:Leak
+   match-leak-kinds: reachable
+   fun:malloc
+   ...
+   fun:_nss_systemd_getpwnam_r
+   ...
+   fun:TclpGetPwNam
+}
+
diff --git a/unix/Makefile.in b/unix/Makefile.in
index 4277fad..060148f 100644
--- a/unix/Makefile.in
+++ b/unix/Makefile.in
@@ -262,7 +262,9 @@ GDB			= gdb
 TRACE			= strace
 TRACE_OPTS		=
 VALGRIND		= valgrind
-VALGRINDARGS		= --tool=memcheck --num-callers=8 --leak-resolution=high --leak-check=yes --show-reachable=yes -v
+VALGRINDARGS		= --tool=memcheck --num-callers=24 \
+    --leak-resolution=high --leak-check=yes --show-reachable=yes -v \
+    --suppressions=$(TOOL_DIR)/valgrind_suppress
 
 #--------------------------------------------------------------------------
 # The information below should be usable as is. The configure script won't
-- 
cgit v0.12


From 645241afc13d0aa6272925a04c3afa93ca93ef19 Mon Sep 17 00:00:00 2001
From: pooryorick <com.digitalsmarties@pooryorick.com>
Date: Wed, 20 Jun 2018 08:03:22 +0000
Subject: Remove recent auto_path modification in tests/all.tcl and suppress
 more valgrind reports.

---
 tests/all.tcl           | 20 +++++---------------
 tools/valgrind_suppress | 20 ++++++++++++++++++++
 2 files changed, 25 insertions(+), 15 deletions(-)

diff --git a/tests/all.tcl b/tests/all.tcl
index d6434fb..250163b 100644
--- a/tests/all.tcl
+++ b/tests/all.tcl
@@ -15,22 +15,12 @@ package require Tcl 8.5-
 package require tcltest 2.2
 namespace import tcltest::*
 
-apply {args {
-    global auto_path
-    set testsdir [file dirname [file dirname [file normalize [
-	info script]/...]]]
+configure {*}$argv -testdir [file dirname [file dirname [file normalize [
+    info script]/...]]]
 
-    configure {*}$args -testdir $testsdir
-
-    if {[singleProcess]} {
-	interp debug {} -frame 1
-    }
-
-    set auto_path [lmap x $auto_path[set auto_path {}] {
-	if {$x eq $testsdir} continue
-	lindex $x
-    }]
-}} {*}$argv
+if {[singleProcess]} {
+    interp debug {} -frame 1
+}
 
 runAllTests
 proc exit args {}
diff --git a/tools/valgrind_suppress b/tools/valgrind_suppress
index e8f0204..84ed4cd 100644
--- a/tools/valgrind_suppress
+++ b/tools/valgrind_suppress
@@ -31,3 +31,23 @@
    fun:TclpGetPwNam
 }
 
+{
+   TclCreatesocketAddress/getaddrinfo/calloc
+   Memcheck:Leak
+   match-leak-kinds: reachable
+   fun:calloc
+   ...
+   fun:getaddrinfo
+   fun:TclCreateSocketAddress
+}
+
+{
+   TclCreatesocketAddress/getaddrinfo/malloc
+   Memcheck:Leak
+   match-leak-kinds: reachable
+   fun:malloc
+   ...
+   fun:getaddrinfo
+   fun:TclCreateSocketAddress
+}
+
-- 
cgit v0.12


From c911dc937fb03f387cc7ecd74b04a2e60ddb53b5 Mon Sep 17 00:00:00 2001
From: pooryorick <com.digitalsmarties@pooryorick.com>
Date: Wed, 20 Jun 2018 19:06:40 +0000
Subject: Add valgrind suppression for dlopen and ensure that processes are
 reaped in http11.test.

---
 tests/http11.test       |  7 +++++++
 tools/valgrind_suppress | 10 ++++++++++
 2 files changed, 17 insertions(+)

diff --git a/tests/http11.test b/tests/http11.test
index c9ded0b..2e50837 100644
--- a/tests/http11.test
+++ b/tests/http11.test
@@ -666,6 +666,13 @@ test http11-4.3 "normal post request, check channel query length" -setup {
 
 # -------------------------------------------------------------------------
 
+# Eliminate valgrind "still reachable" reports on outstanding "Detached"
+# structures in the detached list which stem from PipeClose2Proc not waiting
+# around for background processes to complete, meaning that previous calls to
+# Tcl_ReapDetachedProcs might not have had a chance to reap all processes.
+after 10
+exec [info nameofexecutable] << {}
+
 foreach p {create_httpd httpd_read halt_httpd meta check_crc} {
     if {[llength [info proc $p]]} {rename $p {}}
 }
diff --git a/tools/valgrind_suppress b/tools/valgrind_suppress
index 84ed4cd..3c733c2 100644
--- a/tools/valgrind_suppress
+++ b/tools/valgrind_suppress
@@ -51,3 +51,13 @@
    fun:TclCreateSocketAddress
 }
 
+{
+   TclpDlopen/load
+   Memcheck:Leak
+   match-leak-kinds: reachable
+   fun:calloc
+   ...
+   fun:dlopen
+   fun:TclpDlopen
+}
+
-- 
cgit v0.12


From 107fb1eb331d7f346dfbdf5e7655a28f4643899c Mon Sep 17 00:00:00 2001
From: pooryorick <com.digitalsmarties@pooryorick.com>
Date: Thu, 21 Jun 2018 22:16:29 +0000
Subject: Suppress more valgrind "still reachable" reports and ensure that
 threads are fully finalized in thread tests.

---
 tests/thread.test       | 56 +++++++++++++++++++------------
 tools/valgrind_suppress | 87 +++++++++++++++++++++++++++++++++++++++----------
 2 files changed, 106 insertions(+), 37 deletions(-)

diff --git a/tests/thread.test b/tests/thread.test
index cc4c871..a23670a 100644
--- a/tests/thread.test
+++ b/tests/thread.test
@@ -11,17 +11,22 @@
 # See the file "license.terms" for information on usage and redistribution
 # of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 
+
+#  when thread::release is used, -wait is passed in order allow the thread to
+#  be fully finalized, which avoids valgrind "still reachable" reports.
 if {[lsearch [namespace children] ::tcltest] == -1} {
     package require tcltest 2.2
     namespace import -force ::tcltest::*
 }
 
+package require tcltests
+
 ::tcltest::loadTestedCommands
 catch [list package require -exact Tcltest [info patchlevel]]
 
 # Some tests require the testthread command
 
-testConstraint testthread [expr {[info commands testthread] != {}}]
+testConstraint testthread [expr {[info commands testthread] ne {}}]
 
 # Some tests require the Thread package
 
@@ -72,6 +77,17 @@ proc ThreadError {id info} {
     set threadSawError($id) true; # signal main thread to exit [vwait].
 }
 
+proc threadSuperKill id {
+    variable threadSuperKillScript
+    try {
+	thread::send $id $::threadSuperKillScript
+    } on error {tres topts} {
+	if {$tres ne {target thread died}} {
+	    return -options $topts $tres
+	}
+    }
+}
+
 if {[testConstraint thread]} {
     thread::errorproc ThreadError
 }
@@ -96,22 +112,22 @@ test thread-1.3 {Tcl_ThreadObjCmd: initial thread list} {thread} {
 test thread-1.4 {Tcl_ThreadObjCmd: thread create } {thread} {
     set serverthread [thread::create -preserved]
     set numthreads [llength [thread::names]]
-    thread::release $serverthread
+    thread::release -wait $serverthread
     set numthreads
-} {2}
+} 2
 test thread-1.5 {Tcl_ThreadObjCmd: thread create one shot} {thread} {
     thread::create {set x 5}
     foreach try {0 1 2 4 5 6} {
-	# Try various ways to yield
-	update
-	after 10
-	set l [llength [thread::names]]
-	if {$l == 1} {
-	    break
-	}
+        # Try various ways to yield
+        update
+        after 10
+        set l [llength [thread::names]]
+        if {$l == 1} {
+            break
+        }
     }
     set l
-} {1}
+} 1
 test thread-1.6 {Tcl_ThreadObjCmd: thread exit} {thread} {
     thread::create {{*}{}}
     update
@@ -121,13 +137,13 @@ test thread-1.6 {Tcl_ThreadObjCmd: thread exit} {thread} {
 test thread-1.13 {Tcl_ThreadObjCmd: send args} {thread} {
     set serverthread [thread::create -preserved]
     set five [thread::send $serverthread {set x 5}]
-    thread::release $serverthread
+    thread::release -wait $serverthread
     set five
 } 5
 test thread-1.15 {Tcl_ThreadObjCmd: wait} {thread} {
     set serverthread [thread::create -preserved {set z 5 ; thread::wait}]
     set five [thread::send $serverthread {set z}]
-    thread::release $serverthread
+    thread::release -wait $serverthread
     set five
 } 5
 
@@ -159,7 +175,7 @@ test thread-3.1 {TclThreadList} {thread} {
     set l2 [thread::names]
     set c [string compare [lsort [concat [thread::id] $l1]] [lsort $l2]]
     foreach t $l1 {
-	thread::release $t
+	thread::release -wait $t
     }
     list $len $c
 } {1 0}
@@ -887,7 +903,7 @@ test thread-7.24 {cancel: nested catch inside pure bytecode loop} {thread drainE
     # wait for other thread to signal "ready to cancel"
     vwait ::threadIdStarted; after 1000
     set res [thread::cancel $serverthread]
-    thread::send $serverthread $::threadSuperKillScript
+    threadSuperKill $serverthread
     vwait ::threadSawError($serverthread)
     thread::join $serverthread; drainEventQueue
     list $res [expr {[info exists ::threadIdStarted] ? \
@@ -929,7 +945,7 @@ test thread-7.25 {cancel: nested catch inside pure inside-command loop} {thread
     # wait for other thread to signal "ready to cancel"
     vwait ::threadIdStarted; after 1000
     set res [thread::cancel $serverthread]
-    thread::send $serverthread $::threadSuperKillScript
+    threadSuperKill $serverthread
     vwait ::threadSawError($serverthread)
     thread::join $serverthread; drainEventQueue
     list $res [expr {[info exists ::threadIdStarted] ? \
@@ -1029,7 +1045,7 @@ test thread-7.28 {cancel: send async cancel nested catch inside pure bytecode lo
     # wait for other thread to signal "ready to cancel"
     vwait ::threadIdStarted; after 1000
     set res [thread::send -async $serverthread {interp cancel}]
-    thread::send $serverthread $::threadSuperKillScript
+    threadSuperKill $serverthread
     vwait ::threadSawError($serverthread)
     thread::join $serverthread; drainEventQueue
     list $res [expr {[info exists ::threadIdStarted] ? \
@@ -1071,7 +1087,7 @@ test thread-7.29 {cancel: send async cancel nested catch pure inside-command loo
     # wait for other thread to signal "ready to cancel"
     vwait ::threadIdStarted; after 1000
     set res [thread::send -async $serverthread {interp cancel}]
-    thread::send $serverthread $::threadSuperKillScript
+    threadSuperKill $serverthread
     vwait ::threadSawError($serverthread)
     thread::join $serverthread; drainEventQueue
     list $res [expr {[info exists ::threadIdStarted] ? \
@@ -1111,7 +1127,7 @@ test thread-7.30 {cancel: send async thread cancel nested catch inside pure byte
     # wait for other thread to signal "ready to cancel"
     vwait ::threadIdStarted; after 1000
     set res [thread::send -async $serverthread {thread::cancel [thread::id]}]
-    thread::send $serverthread $::threadSuperKillScript
+    threadSuperKill $serverthread
     vwait ::threadSawError($serverthread)
     thread::join $serverthread; drainEventQueue
     list $res [expr {[info exists ::threadIdStarted] ? \
@@ -1153,7 +1169,7 @@ test thread-7.31 {cancel: send async thread cancel nested catch pure inside-comm
     # wait for other thread to signal "ready to cancel"
     vwait ::threadIdStarted; after 1000
     set res [thread::send -async $serverthread {thread::cancel [thread::id]}]
-    thread::send $serverthread $::threadSuperKillScript
+    threadSuperKill $serverthread
     vwait ::threadSawError($serverthread)
     thread::join $serverthread; drainEventQueue
     list $res [expr {[info exists ::threadIdStarted] ? \
diff --git a/tools/valgrind_suppress b/tools/valgrind_suppress
index 3c733c2..ede584a 100644
--- a/tools/valgrind_suppress
+++ b/tools/valgrind_suppress
@@ -1,63 +1,116 @@
 {
-   TclpGetPwNam/getpwname_r/__nss_next2/calloc
+   TclCreatesocketAddress/getaddrinfo/calloc
+   Memcheck:Leak
+   match-leak-kinds: reachable
+   fun:calloc
+   ...
+   fun:getaddrinfo
+   fun:TclCreateSocketAddress
+}
+
+{
+   TclCreatesocketAddress/getaddrinfo/malloc
+   Memcheck:Leak
+   match-leak-kinds: reachable
+   fun:malloc
+   ...
+   fun:getaddrinfo
+   fun:TclCreateSocketAddress
+}
+
+{
+   TclpDlopen/load
+   Memcheck:Leak
+   match-leak-kinds: reachable
+   fun:calloc
+   ...
+   fun:dlopen
+   fun:TclpDlopen
+}
+
+{
+   TclpGetGrNam/__nss_next2/calloc
    Memcheck:Leak
    match-leak-kinds: reachable
    fun:calloc
    ...
    fun:__nss_next2
    ...
-   fun:TclpGetPwNam
+   fun:TclpGetGrNam
 }
 
 {
-   TclpGetPwNam/getpwname_r/__nss_next2/malloc
+   TclpGetGrNam/__nss_next2/malloc
    Memcheck:Leak
    match-leak-kinds: reachable
    fun:malloc
    ...
    fun:__nss_next2
    ...
-   fun:TclpGetPwNam
+   fun:TclpGetGrNam
 }
 
 {
-   TclpGetPwNam/getpwname_r/_nss_systemd_getpwnam_r/malloc
+   TclpGetGrNam/__nss_systemd_getfrname_r/malloc
    Memcheck:Leak
    match-leak-kinds: reachable
    fun:malloc
    ...
-   fun:_nss_systemd_getpwnam_r
+   fun:_nss_systemd_getgrnam_r
    ...
-   fun:TclpGetPwNam
+   fun:TclpGetGrNam
 }
 
 {
-   TclCreatesocketAddress/getaddrinfo/calloc
+   TclpGetPwNam/getpwname_r/__nss_next2/calloc
    Memcheck:Leak
    match-leak-kinds: reachable
    fun:calloc
    ...
-   fun:getaddrinfo
-   fun:TclCreateSocketAddress
+   fun:__nss_next2
+   ...
+   fun:TclpGetPwNam
 }
 
 {
-   TclCreatesocketAddress/getaddrinfo/malloc
+   TclpGetPwNam/getpwname_r/__nss_next2/malloc
    Memcheck:Leak
    match-leak-kinds: reachable
    fun:malloc
    ...
-   fun:getaddrinfo
-   fun:TclCreateSocketAddress
+   fun:__nss_next2
+   ...
+   fun:TclpGetPwNam
 }
 
 {
-   TclpDlopen/load
+   TclpGetPwNam/getpwname_r/_nss_systemd_getpwnam_r/malloc
    Memcheck:Leak
    match-leak-kinds: reachable
-   fun:calloc
+   fun:malloc
    ...
-   fun:dlopen
-   fun:TclpDlopen
+   fun:_nss_systemd_getpwnam_r
+   ...
+   fun:TclpGetPwNam
+}
+
+{
+	TclpThreadExit/pthread_exit/calloc
+    Memcheck:Leak
+    match-leak-kinds: reachable
+	fun:calloc
+	...
+	fun:pthread_exit
+	fun:TclpThreadExit
+}
+
+{
+	TclpThreadExit/pthread_exit/malloc
+    Memcheck:Leak
+    match-leak-kinds: reachable
+	fun:malloc
+	...
+	fun:pthread_exit
+	fun:TclpThreadExit
 }
 
-- 
cgit v0.12


From 56ca35e8a95b8cfaac73104d3699c2b901298a2d Mon Sep 17 00:00:00 2001
From: pooryorick <com.digitalsmarties@pooryorick.com>
Date: Thu, 21 Jun 2018 22:21:31 +0000
Subject: Add custom exit procedure for tcltests executable.

---
 generic/tclInt.h        |  1 +
 generic/tclTest.c       | 16 ++++++++++++++++
 generic/tclThreadTest.c |  7 +++++++
 3 files changed, 24 insertions(+)

diff --git a/generic/tclInt.h b/generic/tclInt.h
index 0a3285f..6fc2e85 100644
--- a/generic/tclInt.h
+++ b/generic/tclInt.h
@@ -4532,6 +4532,7 @@ MODULE_SCOPE Tcl_PackageInitProc TclObjTest_Init;
 MODULE_SCOPE Tcl_PackageInitProc TclThread_Init;
 MODULE_SCOPE Tcl_PackageInitProc Procbodytest_Init;
 MODULE_SCOPE Tcl_PackageInitProc Procbodytest_SafeInit;
+MODULE_SCOPE void *TclThreadTestFinalize();
 
 /*
  *----------------------------------------------------------------
diff --git a/generic/tclTest.c b/generic/tclTest.c
index 45cca5a..952f384 100644
--- a/generic/tclTest.c
+++ b/generic/tclTest.c
@@ -52,6 +52,7 @@
 #define TCL_STORAGE_CLASS DLLEXPORT
 EXTERN int		Tcltest_Init(Tcl_Interp *interp);
 EXTERN int		Tcltest_SafeInit(Tcl_Interp *interp);
+EXTERN TCL_NORETURN void	Tcltest_Exit(ClientData clientData);
 
 /*
  * Dynamic string shared by TestdcallCmd and DelCallbackProc; used to collect
@@ -563,6 +564,10 @@ Tcltest_Init(
 	return TCL_ERROR;
     }
 
+
+    /* Finalizer */
+    Tcl_SetExitProc(Tcltest_Exit);
+
     /*
      * Create additional commands and math functions for testing Tcl.
      */
@@ -790,6 +795,17 @@ Tcltest_SafeInit(
     return Procbodytest_SafeInit(interp);
 }
 
+TCL_NORETURN void Tcltest_Exit(
+    ClientData clientData
+) {
+    int status = PTR2INT(clientData);
+    Tcl_Finalize();
+    TclThreadTestFinalize();
+    TclpExit(status);
+    Tcl_Panic("OS exit failed!");
+}
+	
+
 /*
  *----------------------------------------------------------------------
  *
diff --git a/generic/tclThreadTest.c b/generic/tclThreadTest.c
index 6fc0e52..3d63964 100644
--- a/generic/tclThreadTest.c
+++ b/generic/tclThreadTest.c
@@ -176,6 +176,13 @@ TclThread_Init(
 }
 
 
+void * TclThreadTestFinalize() {
+    if (errorProcString != NULL) {
+	ckfree(errorProcString);
+	errorProcString= NULL;
+    }
+}
+
 /*
  *----------------------------------------------------------------------
  *
-- 
cgit v0.12


From 563bd6e4ddc1fab518dc16ebd1d39d05feffa6b0 Mon Sep 17 00:00:00 2001
From: pooryorick <com.digitalsmarties@pooryorick.com>
Date: Thu, 21 Jun 2018 22:43:18 +0000
Subject: Fix function signature of TclThreadTestFinalize.

---
 generic/tclInt.h        | 2 +-
 generic/tclThreadTest.c | 3 ++-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/generic/tclInt.h b/generic/tclInt.h
index 6fc2e85..64004d8 100644
--- a/generic/tclInt.h
+++ b/generic/tclInt.h
@@ -4532,7 +4532,7 @@ MODULE_SCOPE Tcl_PackageInitProc TclObjTest_Init;
 MODULE_SCOPE Tcl_PackageInitProc TclThread_Init;
 MODULE_SCOPE Tcl_PackageInitProc Procbodytest_Init;
 MODULE_SCOPE Tcl_PackageInitProc Procbodytest_SafeInit;
-MODULE_SCOPE void *TclThreadTestFinalize();
+MODULE_SCOPE void TclThreadTestFinalize();
 
 /*
  *----------------------------------------------------------------
diff --git a/generic/tclThreadTest.c b/generic/tclThreadTest.c
index 3d63964..92cfa13 100644
--- a/generic/tclThreadTest.c
+++ b/generic/tclThreadTest.c
@@ -176,11 +176,12 @@ TclThread_Init(
 }
 
 
-void * TclThreadTestFinalize() {
+void TclThreadTestFinalize() {
     if (errorProcString != NULL) {
 	ckfree(errorProcString);
 	errorProcString= NULL;
     }
+    return;
 }
 
 /*
-- 
cgit v0.12


From 94ec3d943104b645666e3f71feb61ac260a43fcf Mon Sep 17 00:00:00 2001
From: pooryorick <com.digitalsmarties@pooryorick.com>
Date: Fri, 22 Jun 2018 15:10:04 +0000
Subject: Add another suppress rule for valgrind, factor test code into
 tests/tcltests.tcl, and constrained a some tests in the valgrind case.

---
 tests/all.tcl           |  2 +-
 tests/chanio.test       |  4 ----
 tests/io.test           |  4 ----
 tests/ioCmd.test        | 16 +++++++++++++---
 tests/platform.test     |  6 +++++-
 tests/tcltest.test      |  7 +++++++
 tests/tcltests.tcl      | 12 ++++++++----
 tests/thread.test       | 11 -----------
 tools/valgrind_suppress | 10 ++++++++++
 9 files changed, 44 insertions(+), 28 deletions(-)

diff --git a/tests/all.tcl b/tests/all.tcl
index 250163b..4fce323 100644
--- a/tests/all.tcl
+++ b/tests/all.tcl
@@ -13,7 +13,7 @@
 package prefer latest
 package require Tcl 8.5-
 package require tcltest 2.2
-namespace import tcltest::*
+namespace import -force ::tcltest::*
 
 configure {*}$argv -testdir [file dirname [file dirname [file normalize [
     info script]/...]]]
diff --git a/tests/chanio.test b/tests/chanio.test
index 86c1485..492c11e 100644
--- a/tests/chanio.test
+++ b/tests/chanio.test
@@ -39,14 +39,10 @@ namespace eval ::tcl::test::io {
     catch [list package require -exact Tcltest [info patchlevel]]
     
     testConstraint testchannel      [llength [info commands testchannel]]
-    testConstraint exec             [llength [info commands exec]]
     testConstraint openpipe         1
-    testConstraint fileevent        [llength [info commands fileevent]]
-    testConstraint fcopy            [llength [info commands fcopy]]
     testConstraint testfevent       [llength [info commands testfevent]]
     testConstraint testchannelevent [llength [info commands testchannelevent]]
     testConstraint testmainthread   [llength [info commands testmainthread]]
-    testConstraint thread [expr {0 == [catch {package require Thread 2.7-}]}]
 
     # You need a *very* special environment to do some tests.  In particular,
     # many file systems do not support large-files...
diff --git a/tests/io.test b/tests/io.test
index cdecb7b..cc1d986 100644
--- a/tests/io.test
+++ b/tests/io.test
@@ -36,14 +36,10 @@ namespace eval ::tcl::test::io {
     variable expected
 
 testConstraint testchannel      [llength [info commands testchannel]]
-testConstraint exec             [llength [info commands exec]]
 testConstraint openpipe         1
-testConstraint fileevent        [llength [info commands fileevent]]
-testConstraint fcopy            [llength [info commands fcopy]]
 testConstraint testfevent       [llength [info commands testfevent]]
 testConstraint testchannelevent [llength [info commands testchannelevent]]
 testConstraint testmainthread   [llength [info commands testmainthread]]
-testConstraint thread [expr {0 == [catch {package require Thread 2.7-}]}]
 testConstraint testobj		[llength [info commands testobj]]
 
 # You need a *very* special environment to do some tests.  In
diff --git a/tests/ioCmd.test b/tests/ioCmd.test
index ae58025..948671e 100644
--- a/tests/ioCmd.test
+++ b/tests/ioCmd.test
@@ -21,10 +21,10 @@ if {[lsearch [namespace children] ::tcltest] == -1} {
 ::tcltest::loadTestedCommands
 catch [list package require -exact Tcltest [info patchlevel]]
 
+package require tcltests
+
 # Custom constraints used in this file
-testConstraint fcopy		[llength [info commands fcopy]]
 testConstraint testchannel	[llength [info commands testchannel]]
-testConstraint thread [expr {0 == [catch {package require Thread 2.7-}]}]
 
 #----------------------------------------------------------------------
 
@@ -395,7 +395,7 @@ test iocmd-11.2 {I/O to command pipelines} {unixOrPc unixExecs} {
 test iocmd-11.3 {I/O to command pipelines} {unixOrPc unixExecs} {
     list [catch {open "| echo > \"$path(test5)\"" r+} msg] $msg $::errorCode
 } {1 {can't read output from command: standard output was redirected} {TCL OPERATION EXEC BADREDIRECT}}
-test iocmd-11.4 {I/O to command pipelines} unixOrPc {
+test iocmd-11.4 {I/O to command pipelines} {notValgrind unixOrPc} {
     list [catch {open "| no_such_command_exists" rb} msg] $msg $::errorCode
 } {1 {couldn't execute "no_such_command_exists": no such file or directory} {POSIX ENOENT {no such file or directory}}}
 
@@ -3833,6 +3833,16 @@ test iocmd.tf-32.1 {origin thread of moved channel destroyed during access} -mat
 
 rename track {}
 # cleanup
+
+
+# Eliminate valgrind "still reachable" reports on outstanding "Detached"
+# structures in the detached list which stem from PipeClose2Proc not waiting
+# around for background processes to complete, meaning that previous calls to
+# Tcl_ReapDetachedProcs might not have had a chance to reap all processes.
+after 10
+exec [info nameofexecutable] << {}
+
+
 foreach file [list test1 test2 test3 test4] {
     removeFile $file
 }
diff --git a/tests/platform.test b/tests/platform.test
index 8ee0ec7..e5a4c90 100644
--- a/tests/platform.test
+++ b/tests/platform.test
@@ -10,6 +10,7 @@
 # of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 
 package require tcltest 2
+package require tcltests
 
 namespace eval ::tcl::test::platform {
     namespace import ::tcltest::testConstraint
@@ -67,7 +68,10 @@ test platform-3.1 {CPU ID on Windows/UNIX} \
 # format of string it produces consists of two non-empty words separated by a
 # hyphen.
 package require platform
-test platform-4.1 {format of platform::identify result} -match regexp -body {
+test platform-4.1 {format of platform::identify result} -constraints notValgrind -match regexp -body {
+    # [identify] may attempt to [exec] dpkg-architecture, which may not exist,
+    # in which case fork will not be followed by exec, and valgrind will issue
+    # "still reachable" reports.
     platform::identify
 } -result {^([^-]+-)+[^-]+$}
 test platform-4.2 {format of platform::generic result} -match regexp -body {
diff --git a/tests/tcltest.test b/tests/tcltest.test
index 17fa926..0bcf342 100644
--- a/tests/tcltest.test
+++ b/tests/tcltest.test
@@ -908,7 +908,9 @@ removeFile load.tcl
 
 # [interpreter]
 test tcltest-13.1 {interpreter} {
+    -constraints notValgrind 
     -setup {
+	#to do:  Why is $::tcltest::tcltest being saved and restored here?
 	set old $::tcltest::tcltest
 	set ::tcltest::tcltest tcltest
     }
@@ -920,6 +922,11 @@ test tcltest-13.1 {interpreter} {
     }
     -result {tcltest tclsh tclsh}
     -cleanup {
+	# writing ::tcltest::tcltest triggers a trace that sets up the stdio
+	# constraint, which involves a call to [exec] that might fail after
+	# "fork" and before "exec", in which case the forked process will not
+	# have a chance to clean itself up before exiting, which causes
+	# valgrind to issue numerous "still reachable" reports. 
 	set ::tcltest::tcltest $old
     }
 }
diff --git a/tests/tcltests.tcl b/tests/tcltests.tcl
index 8d42b70..2105279 100644
--- a/tests/tcltests.tcl
+++ b/tests/tcltests.tcl
@@ -1,7 +1,11 @@
 #! /usr/bin/env tclsh
 
-# Some tests require the "exec" command.
-# Skip them if exec is not defined.
-testConstraint exec [llength [info commands exec]]
+package require tcltest 2.2
+namespace import -force ::tcltest::*
 
-testConstraint notValgrind [expr {![testConstraint valgrind]}]
+testConstraint exec          [llength [info commands exec]]
+testConstraint fcopy         [llength [info commands fcopy]]
+testConstraint fileevent     [llength [info commands fileevent]]
+testConstraint thread        [
+    expr {0 == [catch {package require Thread 2.7-}]}]
+testConstraint notValgrind   [expr {![testConstraint valgrind]}]
diff --git a/tests/thread.test b/tests/thread.test
index a23670a..eaaaa41 100644
--- a/tests/thread.test
+++ b/tests/thread.test
@@ -14,10 +14,6 @@
 
 #  when thread::release is used, -wait is passed in order allow the thread to
 #  be fully finalized, which avoids valgrind "still reachable" reports.
-if {[lsearch [namespace children] ::tcltest] == -1} {
-    package require tcltest 2.2
-    namespace import -force ::tcltest::*
-}
 
 package require tcltests
 
@@ -28,13 +24,6 @@ catch [list package require -exact Tcltest [info patchlevel]]
 
 testConstraint testthread [expr {[info commands testthread] ne {}}]
 
-# Some tests require the Thread package
-
-testConstraint thread [expr {0 == [catch {package require Thread 2.7-}]}]
-
-# Some tests may not work under valgrind
-
-testConstraint notValgrind [expr {![testConstraint valgrind]}]
 
 set threadSuperKillScript {
     rename catch ""
diff --git a/tools/valgrind_suppress b/tools/valgrind_suppress
index ede584a..fb7f173 100644
--- a/tools/valgrind_suppress
+++ b/tools/valgrind_suppress
@@ -29,6 +29,16 @@
 }
 
 {
+   TclpDlopen/load
+   Memcheck:Leak
+   match-leak-kinds: reachable
+   fun:malloc
+   ...
+   fun:dlopen
+   fun:TclpDlopen
+}
+
+{
    TclpGetGrNam/__nss_next2/calloc
    Memcheck:Leak
    match-leak-kinds: reachable
-- 
cgit v0.12


From 6cbfdcc4a338d5b7348ee7e65a7710d13f9bc27e Mon Sep 17 00:00:00 2001
From: pooryorick <com.digitalsmarties@pooryorick.com>
Date: Sat, 23 Jun 2018 14:18:06 +0000
Subject: Add a test for no generation of a string representation when
 comparing with the empty string.

---
 tests/expr.test | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/tests/expr.test b/tests/expr.test
index fd11870..a265ac6 100644
--- a/tests/expr.test
+++ b/tests/expr.test
@@ -7196,6 +7196,15 @@ test expr-51.1 {test round-to-even on input} {
     expr 6.9294956446009195e15
 } 6929495644600920.0
 
+test expr-52.1 {
+	comparison with empty string does not generate string representation
+} {
+	set a [list one two three]
+	list [expr {$a eq {}}] [expr {$a < {}}] [expr {$a > {}}] [
+		string match {*no string representation*} [
+		::tcl::unsupported::representation $a]]
+} {0 0 1 1} 
+
 
 
 # cleanup
-- 
cgit v0.12


From e2a79c2604e79b36ec065a7bb44ec57eaca5ed8a Mon Sep 17 00:00:00 2001
From: pooryorick <com.digitalsmarties@pooryorick.com>
Date: Sun, 24 Jun 2018 07:17:46 +0000
Subject: Fix for [3592747]:  Let TclNRTailcallEval handle namespace problems.

---
 generic/tclBasic.c  |  8 +-------
 tests/tailcall.test | 20 ++++++++++++++++++++
 2 files changed, 21 insertions(+), 7 deletions(-)

diff --git a/generic/tclBasic.c b/generic/tclBasic.c
index 3ac3ffd..07f7e5c 100644
--- a/generic/tclBasic.c
+++ b/generic/tclBasic.c
@@ -8402,18 +8402,12 @@ TclNRTailcallObjCmd(
     if (objc > 1) {
         Tcl_Obj *listPtr, *nsObjPtr;
         Tcl_Namespace *nsPtr = (Tcl_Namespace *) iPtr->varFramePtr->nsPtr;
-        Tcl_Namespace *ns1Ptr;
 
         /* The tailcall data is in a Tcl list: the first element is the
          * namespace, the rest the command to be tailcalled. */
 
-        listPtr = Tcl_NewListObj(objc, objv);
-
         nsObjPtr = Tcl_NewStringObj(nsPtr->fullName, -1);
-        if ((TCL_OK != TclGetNamespaceFromObj(interp, nsObjPtr, &ns1Ptr))
-                || (nsPtr != ns1Ptr)) {
-            Tcl_Panic("Tailcall failed to find the proper namespace");
-        }
+        listPtr = Tcl_NewListObj(objc, objv);
  	TclListObjSetElement(interp, listPtr, 0, nsObjPtr);
 
         iPtr->varFramePtr->tailcallPtr = listPtr;
diff --git a/tests/tailcall.test b/tests/tailcall.test
index 26f3cbf..3751c35 100644
--- a/tests/tailcall.test
+++ b/tests/tailcall.test
@@ -688,6 +688,26 @@ if {[testConstraint testnrelevels]} {
     namespace delete testnre
 }
 
+test tailcall-14.1 {in a deleted namespace} -body {
+    namespace eval ns {
+	proc p args {
+	    tailcall [namespace current] $args
+	}
+	namespace delete [namespace current]
+	p
+    }
+} -returnCodes 1 -result {namespace "::ns" not found}
+
+test tailcall-14.1-bc {{in a deleted namespace} {byte compiled}} -body {
+    namespace eval ns {
+	proc p args {
+	    tailcall [namespace current] {*}$args
+	}
+	namespace delete [namespace current]
+	p
+    }
+} -returnCodes 1 -result {namespace "::ns" not found}
+
 # cleanup
 ::tcltest::cleanupTests
 
-- 
cgit v0.12


From 94f9cf81ed3e156bd372a3cac249974d1acb4e1d Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Sun, 24 Jun 2018 20:26:27 +0000
Subject: Fix "string tolower" and friends for handling unpaired surrogates
 correctly. Also add test-cases for those situations. Various typo's in
 comments.

---
 doc/Utf.3                |  5 ++++-
 generic/tclCmdMZ.c       |  3 +++
 generic/tclDisassemble.c |  2 +-
 generic/tclExecute.c     | 14 ++++++++++----
 generic/tclParse.c       |  1 +
 generic/tclUtf.c         | 21 +++++++++++++++------
 tests/utf.test           | 15 +++++++++++++++
 7 files changed, 49 insertions(+), 12 deletions(-)

diff --git a/doc/Utf.3 b/doc/Utf.3
index 160575b..922fd81 100644
--- a/doc/Utf.3
+++ b/doc/Utf.3
@@ -132,7 +132,10 @@ represent one Unicode character in the UTF-8 representation.
 .PP
 \fBTcl_UniCharToUtf\fR stores the character \fIch\fR as a UTF-8 string
 in starting at \fIbuf\fR.  The return value is the number of bytes stored
-in \fIbuf\fR.
+in \fIbuf\fR. If ch is an upper surrogate (range U+D800 - U+DBFF), then
+the return value will be 0 and nothing will be stored. If you still
+want to produce UTF-8 output for it (even though knowing it's an illegal
+code-point on its own), just call \fBTcl_UniCharToUtf\fR again using ch = -1.
 .PP
 \fBTcl_UtfToUniChar\fR reads one UTF-8 character starting at \fIsrc\fR
 and stores it as a Tcl_UniChar in \fI*chPtr\fR.  The return value is the
diff --git a/generic/tclCmdMZ.c b/generic/tclCmdMZ.c
index d64299e..0bd6cb4 100644
--- a/generic/tclCmdMZ.c
+++ b/generic/tclCmdMZ.c
@@ -1447,6 +1447,9 @@ StringIndexCmd(
 	    char buf[4];
 
 	    length = Tcl_UniCharToUtf(ch, buf);
+	    if (!length) {
+		length = Tcl_UniCharToUtf(-1, buf);
+	    }
 	    Tcl_SetObjResult(interp, Tcl_NewStringObj(buf, length));
 	}
     }
diff --git a/generic/tclDisassemble.c b/generic/tclDisassemble.c
index e9aaec4..a0d1258 100644
--- a/generic/tclDisassemble.c
+++ b/generic/tclDisassemble.c
@@ -894,7 +894,7 @@ PrintSourceToObj(
 		Tcl_AppendPrintfToObj(appendObj, "\\U%08x", ch);
 		i += 10;
 	    } else
-#elif TCL_UTF_MAX > 3
+#else
 	    /* If len == 0, this means we have a char > 0xffff, resulting in
 	     * TclUtfToUniChar producing a surrogate pair. We want to output
 	     * this pair as a single Unicode character.
diff --git a/generic/tclExecute.c b/generic/tclExecute.c
index fda50b2..82de752 100644
--- a/generic/tclExecute.c
+++ b/generic/tclExecute.c
@@ -4964,7 +4964,7 @@ TEBCresume(
 
 	/* Decode index value operands. */
 
-	/* 
+	/*
 	assert ( toIdx != TCL_INDEX_AFTER);
 	 *
 	 * Extra safety for legacy bytecodes:
@@ -5223,9 +5223,15 @@ TEBCresume(
 	     * but creating the object as a string seems to be faster in
 	     * practical use.
 	     */
-
-	    length = (ch != -1) ? Tcl_UniCharToUtf(ch, buf) : 0;
-	    objResultPtr = Tcl_NewStringObj(buf, length);
+	    if (ch == -1) {
+		objResultPtr = Tcl_NewObj();
+	    } else {
+		length = Tcl_UniCharToUtf(ch, buf);
+		if (!length) {
+		    length = Tcl_UniCharToUtf(-1, buf);
+		}
+		objResultPtr = Tcl_NewStringObj(buf, length);
+	    }
 	}
 
 	TRACE_APPEND(("\"%s\"\n", O2S(objResultPtr)));
diff --git a/generic/tclParse.c b/generic/tclParse.c
index 581270c..00b83a1 100644
--- a/generic/tclParse.c
+++ b/generic/tclParse.c
@@ -981,6 +981,7 @@ TclParseBackslash(
     }
     count = Tcl_UniCharToUtf(result, dst);
     if (!count) {
+	/* Special case for handling upper surrogates. */
 	count = Tcl_UniCharToUtf(-1, dst);
     }
     return count;
diff --git a/generic/tclUtf.c b/generic/tclUtf.c
index ed10ab2..c8292a2 100644
--- a/generic/tclUtf.c
+++ b/generic/tclUtf.c
@@ -218,7 +218,7 @@ Tcl_UniCharToUtfDString(
 {
     const Tcl_UniChar *w, *wEnd;
     char *p, *string;
-    int oldLength;
+    int oldLength, len = 1;
 
     /*
      * UTF-8 string length in bytes will be <= Unicode string length * 4.
@@ -231,9 +231,18 @@ Tcl_UniCharToUtfDString(
     p = string;
     wEnd = uniStr + uniLength;
     for (w = uniStr; w < wEnd; ) {
-	p += Tcl_UniCharToUtf(*w, p);
+	if (!len && ((*w & 0xFC00) != 0xDC00)) {
+	    /* Special case for handling upper surrogates. */
+	    p += Tcl_UniCharToUtf(-1, p);
+	}
+	len = Tcl_UniCharToUtf(*w, p);
+	p += len;
 	w++;
     }
+    if (!len) {
+	/* Special case for handling upper surrogates. */
+	p += Tcl_UniCharToUtf(-1, p);
+    }
     Tcl_DStringSetLength(dsPtr, oldLength + (p - string));
 
     return string;
@@ -899,7 +908,7 @@ Tcl_UtfToUpper(
 	 * char to dst if its size is <= the original char.
 	 */
 
-	if (bytes < TclUtfCount(upChar)) {
+	if ((bytes < TclUtfCount(upChar)) || ((upChar & 0xF800) == 0xD800)) {
 	    memcpy(dst, src, (size_t) bytes);
 	    dst += bytes;
 	} else {
@@ -962,7 +971,7 @@ Tcl_UtfToLower(
 	 * char to dst if its size is <= the original char.
 	 */
 
-	if (bytes < TclUtfCount(lowChar)) {
+	if ((bytes < TclUtfCount(lowChar)) || ((lowChar & 0xF800) == 0xD800)) {
 	    memcpy(dst, src, (size_t) bytes);
 	    dst += bytes;
 	} else {
@@ -1022,7 +1031,7 @@ Tcl_UtfToTitle(
 #endif
 	titleChar = Tcl_UniCharToTitle(titleChar);
 
-	if (bytes < TclUtfCount(titleChar)) {
+	if ((bytes < TclUtfCount(titleChar)) || ((titleChar & 0xF800) == 0xD800)) {
 	    memcpy(dst, src, (size_t) bytes);
 	    dst += bytes;
 	} else {
@@ -1046,7 +1055,7 @@ Tcl_UtfToTitle(
 	    lowChar = Tcl_UniCharToLower(lowChar);
 	}
 
-	if (bytes < TclUtfCount(lowChar)) {
+	if ((bytes < TclUtfCount(lowChar)) || ((lowChar & 0xF800) == 0xD800)) {
 	    memcpy(dst, src, (size_t) bytes);
 	    dst += bytes;
 	} else {
diff --git a/tests/utf.test b/tests/utf.test
index 67a6778..e820359 100644
--- a/tests/utf.test
+++ b/tests/utf.test
@@ -158,6 +158,12 @@ test utf-8.3 {Tcl_UniCharAtIndex: index > 0} {
 test utf-8.4 {Tcl_UniCharAtIndex: index > 0} {
     string index \u4e4e\u25a\xff\u543 2
 } "\uff"
+test utf-8.5 {Tcl_UniCharAtIndex: upper surrogate} {
+    string index \ud842 0
+} "\ud842"
+test utf-8.5 {Tcl_UniCharAtIndex: lower surrogate} {
+    string index \udc42 0
+} "\udc42"
 
 test utf-9.1 {Tcl_UtfAtIndex: index = 0} {
     string range abcd 0 2
@@ -263,6 +269,9 @@ test utf-11.4 {Tcl_UtfToUpper} {
 test utf-11.5 {Tcl_UtfToUpper Georgian (new in Unicode 11)} {
     string toupper \u10d0\u1c90
 } \u1c90\u1c90
+test utf-11.6 {Tcl_UtfToUpper low/high surrogate)} {
+    string toupper \udc24\ud824
+} \udc24\ud824
 
 test utf-12.1 {Tcl_UtfToLower} {
     string tolower {}
@@ -279,6 +288,9 @@ test utf-12.4 {Tcl_UtfToLower} {
 test utf-12.5 {Tcl_UtfToLower Georgian (new in Unicode 11)} {
     string tolower \u10d0\u1c90
 } \u10d0\u10d0
+test utf-12.6 {Tcl_UtfToUpper low/high surrogate)} {
+    string tolower \udc24\ud824
+} \udc24\ud824
 
 test utf-13.1 {Tcl_UtfToTitle} {
     string totitle {}
@@ -298,6 +310,9 @@ test utf-13.5 {Tcl_UtfToTitle Georgian (new in Unicode 11)} {
 test utf-13.6 {Tcl_UtfToTitle Georgian (new in Unicode 11)} {
     string totitle \u1c90\u10d0
 } \u1c90\u10d0
+test utf-13.7 {Tcl_UtfToTitle low/high surrogate)} {
+    string totitle \udc24\ud824
+} \udc24\ud824
 
 test utf-14.1 {Tcl_UtfNcasecmp} {
     string compare -nocase a b
-- 
cgit v0.12


From 0839047d8bed631eeb82c7c3e26b0f13461717e6 Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Mon, 25 Jun 2018 07:22:19 +0000
Subject: Simplify ToUtf(), expecially for TCL_UTF_MAX>3 (with correct
 surrogate handling). Fix various typo's

---
 tests/iogt.test    |  2 +-
 unix/tclUnixSock.c |  6 +++---
 unix/tclUnixThrd.c |  6 +++---
 win/tclWinInit.c   | 19 +++++++++++--------
 win/tclWinSock.c   | 16 ++++++++--------
 win/tclWinThrd.c   |  8 ++++----
 6 files changed, 30 insertions(+), 27 deletions(-)

diff --git a/tests/iogt.test b/tests/iogt.test
index 1ed89f7..269a0ba 100644
--- a/tests/iogt.test
+++ b/tests/iogt.test
@@ -608,7 +608,7 @@ test iogt-3.0 {Tcl_Channel valid after stack/unstack, fevent handling} -setup {
 	variable copy 1
     }
 } -constraints {testchannel knownBug} -body {
-    # This test to check the validity of aquired Tcl_Channel references is not
+    # This test to check the validity of acquired Tcl_Channel references is not
     # possible because even a backgrounded fcopy will immediately start to
     # copy data, without waiting for the event loop. This is done only in case
     # of an underflow on the read size!. So stacking transforms after the
diff --git a/unix/tclUnixSock.c b/unix/tclUnixSock.c
index e418ff0..90c72c0 100644
--- a/unix/tclUnixSock.c
+++ b/unix/tclUnixSock.c
@@ -1099,7 +1099,7 @@ TcpGetHandleProc(
  * TcpAsyncCallback --
  *
  *	Called by the event handler that TcpConnect sets up internally for
- *	[socket -async] to get notified when the asyncronous connection
+ *	[socket -async] to get notified when the asynchronous connection
  *	attempt has succeeded or failed.
  *
  * ----------------------------------------------------------------------
@@ -1132,7 +1132,7 @@ TcpAsyncCallback(
  *
  * Remarks:
  *	A single host name may resolve to more than one IP address, e.g. for
- *	an IPv4/IPv6 dual stack host. For handling asyncronously connecting
+ *	an IPv4/IPv6 dual stack host. For handling asynchronously connecting
  *	sockets in the background for such hosts, this function can act as a
  *	coroutine. On the first call, it sets up the control variables for the
  *	two nested loops over the local and remote addresses. Once the first
@@ -1140,7 +1140,7 @@ TcpAsyncCallback(
  *	event handler for that socket, and returns. When the callback occurs,
  *	control is transferred to the "reenter" label, right after the initial
  *	return and the loops resume as if they had never been interrupted.
- *	For syncronously connecting sockets, the loops work the usual way.
+ *	For synchronously connecting sockets, the loops work the usual way.
  *
  * ----------------------------------------------------------------------
  */
diff --git a/unix/tclUnixThrd.c b/unix/tclUnixThrd.c
index 0476d85..0609230 100644
--- a/unix/tclUnixThrd.c
+++ b/unix/tclUnixThrd.c
@@ -316,7 +316,7 @@ TclpInitUnlock(void)
  *	in finalization; it is hidden during creation of the objects.
  *
  *	This lock must be different than the initLock because the initLock is
- *	held during creation of syncronization objects.
+ *	held during creation of synchronization objects.
  *
  * Results:
  *	None.
@@ -407,7 +407,7 @@ Tcl_GetAllocMutex(void)
  *	None.
  *
  * Side effects:
- *	May block the current thread. The mutex is aquired when this returns.
+ *	May block the current thread. The mutex is acquired when this returns.
  *	Will allocate memory for a pthread_mutex_t and initialize this the
  *	first time this Tcl_Mutex is used.
  *
@@ -511,7 +511,7 @@ TclpFinalizeMutex(
  *	None.
  *
  * Side effects:
- *	May block the current thread. The mutex is aquired when this returns.
+ *	May block the current thread. The mutex is acquired when this returns.
  *	Will allocate memory for a pthread_mutex_t and initialize this the
  *	first time this Tcl_Mutex is used.
  *
diff --git a/win/tclWinInit.c b/win/tclWinInit.c
index 8e567e3..ff5327d 100644
--- a/win/tclWinInit.c
+++ b/win/tclWinInit.c
@@ -112,7 +112,12 @@ static ProcessGlobalValue sourceLibraryDir =
 	{0, 0, NULL, NULL, InitializeSourceLibraryDir, NULL, NULL};
 
 static void		AppendEnvironment(Tcl_Obj *listPtr, const char *lib);
-static int		ToUtf(const WCHAR *wSrc, char *dst);
+
+#if TCL_UTF_MAX < 4
+static void		ToUtf(const WCHAR *wSrc, char *dst);
+#else
+#define ToUtf(wSrc, dst) WideCharToMultiByte(CP_UTF8, 0, wSrc, -1, dst, MAX_PATH * TCL_UTF_MAX, NULL, NULL)
+#endif
 
 /*
  *---------------------------------------------------------------------------
@@ -435,7 +440,7 @@ InitializeSourceLibraryDir(
  *
  * ToUtf --
  *
- *	Convert a char string to a UTF string.
+ *	Convert a wchar string to a UTF string.
  *
  * Results:
  *	None.
@@ -446,21 +451,19 @@ InitializeSourceLibraryDir(
  *---------------------------------------------------------------------------
  */
 
-static int
+#if TCL_UTF_MAX < 4
+static void
 ToUtf(
     const WCHAR *wSrc,
     char *dst)
 {
-    char *start;
-
-    start = dst;
     while (*wSrc != '\0') {
 	dst += Tcl_UniCharToUtf(*wSrc, dst);
 	wSrc++;
     }
     *dst = '\0';
-    return (int) (dst - start);
 }
+#endif
 
 /*
  *---------------------------------------------------------------------------
@@ -660,7 +663,7 @@ TclpSetVariables(
  * TclpFindVariable --
  *
  *	Locate the entry in environ for a given name. On Unix this routine is
- *	case sensitive, on Windows this matches mioxed case.
+ *	case sensitive, on Windows this matches mixed case.
  *
  * Results:
  *	The return value is the index in environ of an entry with the name
diff --git a/win/tclWinSock.c b/win/tclWinSock.c
index da2e60a..e2479e81 100644
--- a/win/tclWinSock.c
+++ b/win/tclWinSock.c
@@ -686,7 +686,7 @@ WaitForConnect(
 	}
 
 	/*
-	 * A non blocking socket waiting for an asyncronous connect
+	 * A non blocking socket waiting for an asynchronous connect
 	 * returns directly the error EWOULDBLOCK
 	 */
 
@@ -1606,9 +1606,9 @@ TcpGetHandleProc(
  *
  *	This might be called in 3 circumstances:
  *	-   By a regular socket command
- *	-   By the event handler to continue an asynchroneous connect
+ *	-   By the event handler to continue an asynchronously connect
  *	-   By a blocking socket function (gets/puts) to terminate the
- *	    connect synchroneously
+ *	    connect synchronously
  *
  * Results:
  *      TCL_OK, if the socket was successfully connected or an asynchronous
@@ -1620,7 +1620,7 @@ TcpGetHandleProc(
  *
  * Remarks:
  *	A single host name may resolve to more than one IP address, e.g. for
- *	an IPv4/IPv6 dual stack host. For handling asyncronously connecting
+ *	an IPv4/IPv6 dual stack host. For handling asynchronously connecting
  *	sockets in the background for such hosts, this function can act as a
  *	coroutine. On the first call, it sets up the control variables for the
  *	two nested loops over the local and remote addresses. Once the first
@@ -1628,7 +1628,7 @@ TcpGetHandleProc(
  *	event handler for that socket, and returns. When the callback occurs,
  *	control is transferred to the "reenter" label, right after the initial
  *	return and the loops resume as if they had never been interrupted.
- *	For syncronously connecting sockets, the loops work the usual way.
+ *	For synchronously connecting sockets, the loops work the usual way.
  *
  *----------------------------------------------------------------------
  */
@@ -1718,7 +1718,7 @@ TcpConnect(
 		continue;
 	    }
 	    /*
-	     * For asyncroneous connect set the socket in nonblocking mode
+	     * For asynchroneous connect set the socket in nonblocking mode
 	     * and activate connect notification
 	     */
 	    if (async_connect) {
@@ -1806,7 +1806,7 @@ TcpConnect(
 
 	    /*
 	     * Clear the tsd socket list pointer if we did not wait for
-	     * the FD_CONNECT asyncroneously
+	     * the FD_CONNECT asynchroneously
 	     */
 	    tsdPtr->pendingTcpState = NULL;
 
@@ -1868,7 +1868,7 @@ out:
 	    SetEvent(tsdPtr->socketListLock);
 	}
 	/*
-	 * Error message on syncroneous connect
+	 * Error message on synchroneous connect
 	 */
 	if (interp != NULL) {
 	    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
diff --git a/win/tclWinThrd.c b/win/tclWinThrd.c
index 8f3ddb9..0f83526 100644
--- a/win/tclWinThrd.c
+++ b/win/tclWinThrd.c
@@ -247,7 +247,7 @@ TclpThreadCreate(
 
 	/*
 	 * The only purpose of this is to decrement the reference count so the
-	 * OS resources will be reaquired when the thread closes.
+	 * OS resources will be reacquired when the thread closes.
 	 */
 
 	CloseHandle(tHandle);
@@ -405,7 +405,7 @@ TclpInitUnlock(void)
  *	mutexes, condition variables, and thread local storage keys.
  *
  *	This lock must be different than the initLock because the initLock is
- *	held during creation of syncronization objects.
+ *	held during creation of synchronization objects.
  *
  * Results:
  *	None.
@@ -555,7 +555,7 @@ static void		FinalizeConditionEvent(ClientData data);
  *	None.
  *
  * Side effects:
- *	May block the current thread. The mutex is aquired when this returns.
+ *	May block the current thread. The mutex is acquired when this returns.
  *
  *----------------------------------------------------------------------
  */
@@ -655,7 +655,7 @@ TclpFinalizeMutex(
  *	None.
  *
  * Side effects:
- *	May block the current thread. The mutex is aquired when this returns.
+ *	May block the current thread. The mutex is acquired when this returns.
  *	Will allocate memory for a HANDLE and initialize this the first time
  *	this Tcl_Condition is used.
  *
-- 
cgit v0.12


From ed5ed756bc5993edb110e13b90028646b413e92d Mon Sep 17 00:00:00 2001
From: dgp <dgp@users.sourceforge.net>
Date: Tue, 26 Jun 2018 14:22:08 +0000
Subject: Restore lost tests.

---
 tests/all.tcl      |  2 +-
 tests/chanio.test  | 11 ++++-------
 tests/io.test      | 11 +++++------
 tests/tcltests.tcl |  2 +-
 4 files changed, 11 insertions(+), 15 deletions(-)

diff --git a/tests/all.tcl b/tests/all.tcl
index 4fce323..e14bd9c 100644
--- a/tests/all.tcl
+++ b/tests/all.tcl
@@ -13,7 +13,7 @@
 package prefer latest
 package require Tcl 8.5-
 package require tcltest 2.2
-namespace import -force ::tcltest::*
+namespace import ::tcltest::*
 
 configure {*}$argv -testdir [file dirname [file dirname [file normalize [
     info script]/...]]]
diff --git a/tests/chanio.test b/tests/chanio.test
index 492c11e..6408f50 100644
--- a/tests/chanio.test
+++ b/tests/chanio.test
@@ -13,16 +13,11 @@
 # See the file "license.terms" for information on usage and redistribution of
 # this file, and for a DISCLAIMER OF ALL WARRANTIES.
 
+# TODO: This test is likely worthless. Confirm and remove
 if {[lsearch [namespace children] ::tcltest] == -1} {
     package require tcltest 2
-    namespace import -force ::tcltest::*
 }
 
-::tcltest::loadTestedCommands
-catch [list package require -exact Tcltest [info patchlevel]]
-
-testConstraint testbytestring [llength [info commands testbytestring]]
-
 namespace eval ::tcl::test::io {
     namespace import ::tcltest::*
 
@@ -35,9 +30,11 @@ namespace eval ::tcl::test::io {
     variable msg
     variable expected
 
-    ::tcltest::loadTestedCommands
+    loadTestedCommands
     catch [list package require -exact Tcltest [info patchlevel]]
+    package require tcltests
     
+    testConstraint testbytestring   [llength [info commands testbytestring]]
     testConstraint testchannel      [llength [info commands testchannel]]
     testConstraint openpipe         1
     testConstraint testfevent       [llength [info commands testfevent]]
diff --git a/tests/io.test b/tests/io.test
index cc1d986..996e125 100644
--- a/tests/io.test
+++ b/tests/io.test
@@ -15,14 +15,8 @@
 
 if {[lsearch [namespace children] ::tcltest] == -1} {
     package require tcltest 2
-    namespace import -force ::tcltest::*
 }
 
-::tcltest::loadTestedCommands
-catch [list package require -exact Tcltest [info patchlevel]]
-
-testConstraint testbytestring [llength [info commands testbytestring]]
-
 namespace eval ::tcl::test::io {
     namespace import ::tcltest::*
 
@@ -35,6 +29,11 @@ namespace eval ::tcl::test::io {
     variable msg
     variable expected
 
+    loadTestedCommands
+    catch [list package require -exact Tcltest [info patchlevel]]
+    package require tcltests
+
+testConstraint testbytestring [llength [info commands testbytestring]]
 testConstraint testchannel      [llength [info commands testchannel]]
 testConstraint openpipe         1
 testConstraint testfevent       [llength [info commands testfevent]]
diff --git a/tests/tcltests.tcl b/tests/tcltests.tcl
index 2105279..74d1b40 100644
--- a/tests/tcltests.tcl
+++ b/tests/tcltests.tcl
@@ -1,7 +1,7 @@
 #! /usr/bin/env tclsh
 
 package require tcltest 2.2
-namespace import -force ::tcltest::*
+namespace import ::tcltest::*
 
 testConstraint exec          [llength [info commands exec]]
 testConstraint fcopy         [llength [info commands fcopy]]
-- 
cgit v0.12


From 9da2aebeaebd1ccbfa806b0c3550774abc7ad778 Mon Sep 17 00:00:00 2001
From: dgp <dgp@users.sourceforge.net>
Date: Tue, 26 Jun 2018 17:00:29 +0000
Subject: Use a thread exit handler, and not a custom exit proc for package
 cleanup.

---
 generic/tclInt.h        |  1 -
 generic/tclTest.c       | 16 ----------------
 generic/tclThreadTest.c | 17 ++++++++---------
 3 files changed, 8 insertions(+), 26 deletions(-)

diff --git a/generic/tclInt.h b/generic/tclInt.h
index 64004d8..0a3285f 100644
--- a/generic/tclInt.h
+++ b/generic/tclInt.h
@@ -4532,7 +4532,6 @@ MODULE_SCOPE Tcl_PackageInitProc TclObjTest_Init;
 MODULE_SCOPE Tcl_PackageInitProc TclThread_Init;
 MODULE_SCOPE Tcl_PackageInitProc Procbodytest_Init;
 MODULE_SCOPE Tcl_PackageInitProc Procbodytest_SafeInit;
-MODULE_SCOPE void TclThreadTestFinalize();
 
 /*
  *----------------------------------------------------------------
diff --git a/generic/tclTest.c b/generic/tclTest.c
index 952f384..45cca5a 100644
--- a/generic/tclTest.c
+++ b/generic/tclTest.c
@@ -52,7 +52,6 @@
 #define TCL_STORAGE_CLASS DLLEXPORT
 EXTERN int		Tcltest_Init(Tcl_Interp *interp);
 EXTERN int		Tcltest_SafeInit(Tcl_Interp *interp);
-EXTERN TCL_NORETURN void	Tcltest_Exit(ClientData clientData);
 
 /*
  * Dynamic string shared by TestdcallCmd and DelCallbackProc; used to collect
@@ -564,10 +563,6 @@ Tcltest_Init(
 	return TCL_ERROR;
     }
 
-
-    /* Finalizer */
-    Tcl_SetExitProc(Tcltest_Exit);
-
     /*
      * Create additional commands and math functions for testing Tcl.
      */
@@ -795,17 +790,6 @@ Tcltest_SafeInit(
     return Procbodytest_SafeInit(interp);
 }
 
-TCL_NORETURN void Tcltest_Exit(
-    ClientData clientData
-) {
-    int status = PTR2INT(clientData);
-    Tcl_Finalize();
-    TclThreadTestFinalize();
-    TclpExit(status);
-    Tcl_Panic("OS exit failed!");
-}
-	
-
 /*
  *----------------------------------------------------------------------
  *
diff --git a/generic/tclThreadTest.c b/generic/tclThreadTest.c
index 92cfa13..35b3fc3 100644
--- a/generic/tclThreadTest.c
+++ b/generic/tclThreadTest.c
@@ -174,15 +174,6 @@ TclThread_Init(
     Tcl_CreateObjCommand(interp, "testthread", ThreadObjCmd, NULL, NULL);
     return TCL_OK;
 }
-
-
-void TclThreadTestFinalize() {
-    if (errorProcString != NULL) {
-	ckfree(errorProcString);
-	errorProcString= NULL;
-    }
-    return;
-}
 
 /*
  *----------------------------------------------------------------------
@@ -1166,6 +1157,14 @@ ThreadExitProc(
 
     Tcl_MutexLock(&threadMutex);
 
+    if (self == errorThreadId) {
+	if (errorProcString) {	/* Extra safety */
+	    ckfree(errorProcString);
+	    errorProcString = NULL;
+	}
+	errorThreadId = 0;
+    }
+
     if (threadEvalScript) {
 	ckfree(threadEvalScript);
 	threadEvalScript = NULL;
-- 
cgit v0.12


From 7a9d97826e2df30fcf48191281dede724a99ff43 Mon Sep 17 00:00:00 2001
From: "jan.nijtmans" <nijtmans@users.sourceforge.net>
Date: Tue, 26 Jun 2018 19:45:22 +0000
Subject: Since Tcl is always compiled with -DUNICODE -D_UNICODE (on Windows)
 and we know TCL_UTF_MAX>=4, we can simplify things. No change in
 functionality.

---
 generic/tclIOSock.c |  2 +-
 win/tclWinConsole.c |  4 ----
 win/tclWinDde.c     | 31 --------------------------
 win/tclWinError.c   |  2 +-
 win/tclWinFile.c    | 18 ++-------------
 win/tclWinInit.c    | 64 ++++++++---------------------------------------------
 win/tclWinPanic.c   |  2 +-
 win/tclWinPipe.c    |  2 +-
 win/tclWinReg.c     |  7 ------
 9 files changed, 15 insertions(+), 117 deletions(-)

diff --git a/generic/tclIOSock.c b/generic/tclIOSock.c
index 6abfa60..12e2900 100644
--- a/generic/tclIOSock.c
+++ b/generic/tclIOSock.c
@@ -11,7 +11,7 @@
 
 #include "tclInt.h"
 
-#if defined(_WIN32) && defined(UNICODE)
+#if defined(_WIN32)
 /*
  * On Windows, we need to do proper Unicode->UTF-8 conversion.
  */
diff --git a/win/tclWinConsole.c b/win/tclWinConsole.c
index 92643cf..f8b67a3 100644
--- a/win/tclWinConsole.c
+++ b/win/tclWinConsole.c
@@ -1360,11 +1360,7 @@ TclWinOpenConsoleChannel(
 
     Tcl_SetChannelOption(NULL, infoPtr->channel, "-translation", "auto");
     Tcl_SetChannelOption(NULL, infoPtr->channel, "-eofchar", "\032 {}");
-#ifdef UNICODE
     Tcl_SetChannelOption(NULL, infoPtr->channel, "-encoding", "unicode");
-#else
-    Tcl_SetChannelOption(NULL, infoPtr->channel, "-encoding", encoding);
-#endif
     return infoPtr->channel;
 }
 
diff --git a/win/tclWinDde.c b/win/tclWinDde.c
index 381db65..52bcd42 100644
--- a/win/tclWinDde.c
+++ b/win/tclWinDde.c
@@ -18,15 +18,6 @@
 #include <dde.h>
 #include <ddeml.h>
 
-#ifndef UNICODE
-#   undef CP_WINUNICODE
-#   define CP_WINUNICODE CP_WINANSI
-#   undef Tcl_WinTCharToUtf
-#   define Tcl_WinTCharToUtf(a,b,c) Tcl_ExternalToUtfDString(NULL,a,b,c)
-#   undef Tcl_WinUtfToTChar
-#   define Tcl_WinUtfToTChar(a,b,c) Tcl_UtfToExternalDString(NULL,a,b,c)
-#endif
-
 #if !defined(NDEBUG)
     /* test POKE server Implemented for debug mode only */
 #   undef CBF_FAIL_POKES
@@ -1432,11 +1423,7 @@ DdeObjCmd(
     Initialize();
 
     if (firstArg != 1) {
-#ifdef UNICODE
 	serviceName = Tcl_GetUnicodeFromObj(objv[firstArg], &length);
-#else
-	serviceName = Tcl_GetStringFromObj(objv[firstArg], &length);
-#endif
     } else {
 	length = 0;
     }
@@ -1449,11 +1436,7 @@ DdeObjCmd(
     }
 
     if ((index != DDE_SERVERNAME) && (index != DDE_EVAL)) {
-#ifdef UNICODE
 	topicName = (TCHAR *) Tcl_GetUnicodeFromObj(objv[firstArg + 1], &length);
-#else
-	topicName = Tcl_GetStringFromObj(objv[firstArg + 1], &length);
-#endif
 	if (length == 0) {
 	    topicName = NULL;
 	} else {
@@ -1467,11 +1450,7 @@ DdeObjCmd(
 	serviceName = DdeSetServerName(interp, serviceName, flags,
 		handlerPtr);
 	if (serviceName != NULL) {
-#ifdef UNICODE
 	    Tcl_SetObjResult(interp, Tcl_NewUnicodeObj((Tcl_UniChar *) serviceName, -1));
-#else
-	    Tcl_SetObjResult(interp, Tcl_NewStringObj(serviceName, -1));
-#endif
 	} else {
 	    Tcl_ResetResult(interp);
 	}
@@ -1530,13 +1509,8 @@ DdeObjCmd(
 	break;
     }
     case DDE_REQUEST: {
-#ifdef UNICODE
 	const TCHAR *itemString = (TCHAR *) Tcl_GetUnicodeFromObj(objv[firstArg + 2],
 		&length);
-#else
-	const TCHAR *itemString = Tcl_GetStringFromObj(objv[firstArg + 2],
-		&length);
-#endif
 
 	if (length == 0) {
 	    Tcl_SetObjResult(interp,
@@ -1590,13 +1564,8 @@ DdeObjCmd(
 	break;
     }
     case DDE_POKE: {
-#ifdef UNICODE
 	const TCHAR *itemString = (TCHAR *) Tcl_GetUnicodeFromObj(objv[firstArg + 2],
 		&length);
-#else
-	const TCHAR *itemString = Tcl_GetStringFromObj(objv[firstArg + 2],
-		&length);
-#endif
 	BYTE *dataString;
 
 	if (length == 0) {
diff --git a/win/tclWinError.c b/win/tclWinError.c
index 5d4423b..bce81fa 100644
--- a/win/tclWinError.c
+++ b/win/tclWinError.c
@@ -391,7 +391,7 @@ tclWinDebugPanic(
 
     if (IsDebuggerPresent()) {
 	WCHAR msgString[TCL_MAX_WARN_LEN];
-	char buf[TCL_MAX_WARN_LEN * TCL_UTF_MAX];
+	char buf[TCL_MAX_WARN_LEN * 3];
 
 	vsnprintf(buf, sizeof(buf), format, argList);
 	msgString[TCL_MAX_WARN_LEN-1] = L'\0';
diff --git a/win/tclWinFile.c b/win/tclWinFile.c
index 0595e6c..f1e4cc9 100644
--- a/win/tclWinFile.c
+++ b/win/tclWinFile.c
@@ -567,7 +567,6 @@ WinReadLinkDirectory(
 	 */
 
 	offset = 0;
-#ifdef UNICODE
 	if (reparseBuffer->MountPointReparseBuffer.PathBuffer[0] == L'\\') {
 	    /*
 	     * Check whether this is a mounted volume.
@@ -629,7 +628,6 @@ WinReadLinkDirectory(
 		offset = 4;
 	    }
 	}
-#endif /* UNICODE */
 
 	Tcl_WinTCharToUtf((const TCHAR *)
 		reparseBuffer->MountPointReparseBuffer.PathBuffer,
@@ -800,7 +798,7 @@ tclWinDebugPanic(
 {
 #define TCL_MAX_WARN_LEN 1024
     va_list argList;
-    char buf[TCL_MAX_WARN_LEN * TCL_UTF_MAX];
+    char buf[TCL_MAX_WARN_LEN * 3];
     WCHAR msgString[TCL_MAX_WARN_LEN];
 
     va_start(argList, format);
@@ -859,7 +857,7 @@ TclpFindExecutable(
 				 * ignore. */
 {
     WCHAR wName[MAX_PATH];
-    char name[MAX_PATH * TCL_UTF_MAX];
+    char name[MAX_PATH * 3];
 
     /*
      * Under Windows we ignore argv0, and return the path for the file used to
@@ -871,17 +869,7 @@ TclpFindExecutable(
 	Tcl_SetPanicProc(tclWinDebugPanic);
     }
 
-#ifdef UNICODE
     GetModuleFileNameW(NULL, wName, MAX_PATH);
-#else
-    GetModuleFileNameA(NULL, name, sizeof(name));
-
-    /*
-     * Convert to WCHAR to get out of ANSI codepage
-     */
-
-    MultiByteToWideChar(CP_ACP, 0, name, -1, wName, MAX_PATH);
-#endif
     WideCharToMultiByte(CP_UTF8, 0, wName, -1, name, sizeof(name), NULL, NULL);
     TclWinNoBackslash(name);
     TclSetObjNameOfExecutable(Tcl_NewStringObj(name, -1), NULL);
@@ -1646,7 +1634,6 @@ NativeAccess(
      * what permissions the OS has set for a file.
      */
 
-#ifdef UNICODE
     {
 	SECURITY_DESCRIPTOR *sdPtr = NULL;
 	unsigned long size;
@@ -1809,7 +1796,6 @@ NativeAccess(
 	}
 
     }
-#endif /* !UNICODE */
     return 0;
 }
 
diff --git a/win/tclWinInit.c b/win/tclWinInit.c
index f04069b..2ce19ce 100644
--- a/win/tclWinInit.c
+++ b/win/tclWinInit.c
@@ -107,12 +107,6 @@ static ProcessGlobalValue sourceLibraryDir =
 	{0, 0, NULL, NULL, InitializeSourceLibraryDir, NULL, NULL};
 
 static void		AppendEnvironment(Tcl_Obj *listPtr, const char *lib);
-
-#if TCL_UTF_MAX < 4
-static void		ToUtf(const WCHAR *wSrc, char *dst);
-#else
-#define ToUtf(wSrc, dst) WideCharToMultiByte(CP_UTF8, 0, wSrc, -1, dst, MAX_PATH * TCL_UTF_MAX, NULL, NULL)
-#endif
 
 /*
  *---------------------------------------------------------------------------
@@ -262,7 +256,7 @@ AppendEnvironment(
 {
     int pathc;
     WCHAR wBuf[MAX_PATH];
-    char buf[MAX_PATH * TCL_UTF_MAX];
+    char buf[MAX_PATH * 3];
     Tcl_Obj *objPtr;
     Tcl_DString ds;
     const char **pathv;
@@ -291,12 +285,8 @@ AppendEnvironment(
      * this is a unicode string.
      */
 
-    if (GetEnvironmentVariableW(L"TCL_LIBRARY", wBuf, MAX_PATH) == 0) {
-	buf[0] = '\0';
-	GetEnvironmentVariableA("TCL_LIBRARY", buf, MAX_PATH);
-    } else {
-	ToUtf(wBuf, buf);
-    }
+    GetEnvironmentVariableW(L"TCL_LIBRARY", wBuf, MAX_PATH);
+    WideCharToMultiByte(CP_UTF8, 0, wBuf, -1, buf, MAX_PATH * 3, NULL, NULL);
 
     if (buf[0] != '\0') {
 	objPtr = Tcl_NewStringObj(buf, -1);
@@ -355,14 +345,11 @@ InitializeDefaultLibraryDir(
 {
     HMODULE hModule = TclWinGetTclInstance();
     WCHAR wName[MAX_PATH + LIBRARY_SIZE];
-    char name[(MAX_PATH + LIBRARY_SIZE) * TCL_UTF_MAX];
+    char name[(MAX_PATH + LIBRARY_SIZE) * 3];
     char *end, *p;
 
-    if (GetModuleFileNameW(hModule, wName, MAX_PATH) == 0) {
-	GetModuleFileNameA(hModule, name, MAX_PATH);
-    } else {
-	ToUtf(wName, name);
-    }
+    GetModuleFileNameW(hModule, wName, MAX_PATH);
+    WideCharToMultiByte(CP_UTF8, 0, wName, -1, name, MAX_PATH * 3, NULL, NULL);
 
     end = strrchr(name, '\\');
     *end = '\0';
@@ -406,14 +393,11 @@ InitializeSourceLibraryDir(
 {
     HMODULE hModule = TclWinGetTclInstance();
     WCHAR wName[MAX_PATH + LIBRARY_SIZE];
-    char name[(MAX_PATH + LIBRARY_SIZE) * TCL_UTF_MAX];
+    char name[(MAX_PATH + LIBRARY_SIZE) * 3];
     char *end, *p;
 
-    if (GetModuleFileNameW(hModule, wName, MAX_PATH) == 0) {
-	GetModuleFileNameA(hModule, name, MAX_PATH);
-    } else {
-	ToUtf(wName, name);
-    }
+    GetModuleFileNameW(hModule, wName, MAX_PATH);
+    WideCharToMultiByte(CP_UTF8, 0, wName, -1, name, MAX_PATH * 3, NULL, NULL);
 
     end = strrchr(name, '\\');
     *end = '\0';
@@ -434,36 +418,6 @@ InitializeSourceLibraryDir(
 /*
  *---------------------------------------------------------------------------
  *
- * ToUtf --
- *
- *	Convert a wchar string to a UTF string.
- *
- * Results:
- *	None.
- *
- * Side effects:
- *	None.
- *
- *---------------------------------------------------------------------------
- */
-
-#if TCL_UTF_MAX < 4
-static void
-ToUtf(
-    const WCHAR *wSrc,
-    char *dst)
-{
-    while (*wSrc != '\0') {
-	dst += Tcl_UniCharToUtf(*wSrc, dst);
-	wSrc++;
-    }
-    *dst = '\0';
-}
-#endif
-
-/*
- *---------------------------------------------------------------------------
- *
  * TclpSetInitialEncodings --
  *
  *	Based on the locale, determine the encoding of the operating system
diff --git a/win/tclWinPanic.c b/win/tclWinPanic.c
index d23ffcd..a71f506 100644
--- a/win/tclWinPanic.c
+++ b/win/tclWinPanic.c
@@ -35,7 +35,7 @@ Tcl_ConsolePanic(
 #define TCL_MAX_WARN_LEN 26000
     va_list argList;
     WCHAR msgString[TCL_MAX_WARN_LEN];
-    char buf[TCL_MAX_WARN_LEN * TCL_UTF_MAX];
+    char buf[TCL_MAX_WARN_LEN * 3];
     HANDLE handle = GetStdHandle(STD_ERROR_HANDLE);
     DWORD dummy;
 
diff --git a/win/tclWinPipe.c b/win/tclWinPipe.c
index a357412..2155a8d 100644
--- a/win/tclWinPipe.c
+++ b/win/tclWinPipe.c
@@ -941,7 +941,7 @@ TclpCreateProcess(
     PROCESS_INFORMATION procInfo;
     SECURITY_ATTRIBUTES secAtts;
     HANDLE hProcess, h, inputHandle, outputHandle, errorHandle;
-    char execPath[MAX_PATH * TCL_UTF_MAX];
+    char execPath[MAX_PATH * 3];
     WinFile *filePtr;
 
     PipeInit();
diff --git a/win/tclWinReg.c b/win/tclWinReg.c
index de48b9b..95ab499 100644
--- a/win/tclWinReg.c
+++ b/win/tclWinReg.c
@@ -22,13 +22,6 @@
 #endif
 #include <stdlib.h>
 
-#ifndef UNICODE
-#   undef Tcl_WinTCharToUtf
-#   define Tcl_WinTCharToUtf(a,b,c)	Tcl_ExternalToUtfDString(NULL,a,b,c)
-#   undef Tcl_WinUtfToTChar
-#   define Tcl_WinUtfToTChar(a,b,c)	Tcl_UtfToExternalDString(NULL,a,b,c)
-#endif /* !UNICODE */
-
 /*
  * Ensure that we can say which registry is being accessed.
  */
-- 
cgit v0.12