-- 
cgit v0.12

From 7141714e0b598c51f7bda601937fb5e1160e9332 Mon Sep 17 00:00:00 2001
From: kjnash <k.j.nash@usa.net>
Date: Mon, 13 Jul 2020 17:36:16 +0000
Subject: safe.test - use opt instead of http for tests with stock packages;
 tests work whether and how opt is installed; add tests 9.10opt, 9.12opt

---
 tests/safe.test | 169 ++++++++++++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 151 insertions(+), 18 deletions(-)

diff --git a/tests/safe.test b/tests/safe.test
index be52ff4..e99e3f7 100644
--- a/tests/safe.test
+++ b/tests/safe.test
@@ -24,6 +24,58 @@ foreach i [interp slaves] {
 set saveAutoPath $::auto_path
 set ::auto_path [info library]
 
+# The defunct package http 1.0 was convenient for testing package loading.
+# - Replaced here with tests using example packages provided in subdirectory
+#   auto0 of the tests directory, which are independent of any changes
+#   made to the packages provided with Tcl.
+#   - These are tests 7.1 7.2 7.4 9.10 9.12
+#   - Tests 7.0[a-f] test the example packages themselves before they
+#     are used to test Safe Base interpreters.
+# - Alternatively use packages opt and (from cookiejar) tcl::idna.
+#   - These alternative tests have suffix "opt".
+#   - These are 7.[124]opt, 9.1[02]opt
+#   - Tests 7.[124]opt, 9.1[02]opt use "package require opt".
+#   - Tests 9.1[02]opt also use "package require tcl::idna".
+#
+# When using package opt for testing positive/negative package search:
+# - The directory location and the error message depend on whether
+#   and how the package is installed.
+
+# Error message for tests 7.2opt for "package require opt".
+if {[string match *zipfs:/* [info library]]} {
+    # pkgIndex.tcl is in [info library]
+    # file to be sourced is in [info library]/opt*
+    set pkgOptErrMsg {permission denied}
+} else {
+    # pkgIndex.tcl and file to be sourced are
+    # both in [info library]/opt*
+    set pkgOptErrMsg {can't find package opt}
+}
+
+# Directory of opt for tests 7.4opt, 9.10opt, 9.12opt
+# for "package require opt".
+if {[file exists [file join [info library] opt0.4]]} {
+    # Installed files in lib8.7/opt0.4
+    set pkgOptDir opt0.4
+} elseif {[file exists [file join [info library] opt]]} {
+    # Installed files in zipfs, or source files used by "make test"
+    set pkgOptDir opt
+} else {
+    error {cannot find opt library}
+}
+
+# Directory of cookiejar for tests 9.10opt, 9.12opt
+# for "package require tcl::idna".
+if {[file exists [file join [info library] cookiejar0.2]]} {
+    # Installed files in lib8.7/cookiejar0.2
+    set pkgJarDir cookiejar0.2
+} elseif {[file exists [file join [info library] cookiejar]]} {
+    # Installed files in zipfs, or source files used by "make test"
+    set pkgJarDir cookiejar
+} else {
+    error {cannot find cookiejar library}
+}
+
 set TestsDir [file normalize [file dirname [info script]]]
 
 # Force actual loading of the safe package because we use un exported (and
@@ -320,17 +372,19 @@ test safe-7.1 {tests that everything works at high level} -setup {
     safe::interpDelete $i
 } -match glob -result 1.2.3
 # high level general test
-test safe-7.1http {tests that everything works at high level, uses http 2} -body {
+test safe-7.1opt {tests that everything works at high level, uses pkg opt} -setup {
     set i [safe::interpCreate]
+} -body {
     # no error shall occur:
     # (because the default access_path shall include 1st level sub dirs so
     #  package require in a slave works like in the master)
-    set v [interp eval $i {package require http 2}]
+    set v [interp eval $i {package require opt}]
     # no error shall occur:
-    interp eval $i {http::config}
-    safe::interpDelete $i
+    interp eval $i {::tcl::Lempty {a list}}
     set v
-} -match glob -result 2.*
+} -cleanup {
+    safe::interpDelete $i
+} -match glob -result 0.4.*
 test safe-7.2 {tests specific path and interpFind/AddToAccessPath} -setup {
 } -body {
     set i [safe::interpCreate -nostat -nested 1 -accessPath [list [info library]]]
@@ -351,19 +405,23 @@ test safe-7.2 {tests specific path and interpFind/AddToAccessPath} -setup {
         {can't find package SafeTestPackage1}\
         {-accessPath {[list $tcl_library */dummy/unixlike/test/path $TestsDir/auto0]}\
         -statics 0 -nested 1 -deleteHook {}} {}"
-test safe-7.2http {tests specific path and interpFind/AddToAccessPath, uses http1.0} -body {
+test safe-7.2opt {tests specific path and interpFind/AddToAccessPath, uses pkg opt} -setup {
+} -body {
     set i [safe::interpCreate -nostat -nested 1 -accessPath [list [info library]]]
     # should not add anything (p0)
     set token1 [safe::interpAddToAccessPath $i [info library]]
-    # should add as p1
+    # should add as p* (not p1 if master has a module path)
     set token2 [safe::interpAddToAccessPath $i "/dummy/unixlike/test/path"]
-    # an error shall occur (http is not anymore in the secure 0-level
+    # an error shall occur (opt is not anymore in the secure 0-level
     # provided deep path)
     list $token1 $token2 \
-	    [catch {interp eval $i {package require http 1}} msg] $msg \
+	    [catch {interp eval $i {package require opt}} msg] $msg \
 	    [safe::interpConfigure $i]\
 	    [safe::interpDelete $i]
-} -match glob -result "{\$p(:0:)} {\$p(:*:)} 1 {can't find package http 1} {-accessPath {[list $tcl_library */dummy/unixlike/test/path]} -statics 0 -nested 1 -deleteHook {}} {}"
+} -cleanup {
+} -match glob -result "{\$p(:0:)} {\$p(:*:)} 1 {$pkgOptErrMsg}\
+        {-accessPath {[list $tcl_library */dummy/unixlike/test/path]}\
+        -statics 0 -nested 1 -deleteHook {}} {}"
 test safe-7.3 {check that safe subinterpreters work} {
     set i [safe::interpCreate]
     set j [safe::interpCreate [list $i x]]
@@ -387,18 +445,24 @@ test safe-7.4 {tests specific path and positive search} -setup {
 } -match glob -result "{\$p(:0:)} {\$p(:*:)} 0 1.2.3\
         {-accessPath {[list $tcl_library * $TestsDir/auto0/auto1]}\
         -statics 0 -nested 1 -deleteHook {}} {}"
-test safe-7.4http {tests specific path and positive search, uses http1.0} -constraints needs_http1.0 -body {
+test safe-7.4opt {tests specific path and positive search, uses pkg opt} -setup {
+} -body {
     set i [safe::interpCreate -nostat -nested 1 -accessPath [list [info library]]]
     # should not add anything (p0)
     set token1 [safe::interpAddToAccessPath $i [info library]]
-    # should add as p1
-    set token2 [safe::interpAddToAccessPath $i [file join [info library] http1.0]]
-    # this time, unlike test safe-7.2, http should be found
+    # should add as p* (not p1 if master has a module path)
+    set token2 [safe::interpAddToAccessPath $i [file join [info library] $pkgOptDir]]
+    # this time, unlike test safe-7.2opt, opt should be found
     list $token1 $token2 \
-	    [catch {interp eval $i {package require http 1}} msg] $msg \
+	    [catch {interp eval $i {package require opt}} msg] $msg \
 	    [safe::interpConfigure $i]\
 	    [safe::interpDelete $i]
-} -match glob -result "{\$p(:0:)} {\$p(:*:)} 0 1.0 {-accessPath {[list $tcl_library *$tcl_library/http1.0]} -statics 0 -nested 1 -deleteHook {}} {}"
+    # Note that the glob match elides directories (those from the module path)
+    # other than the first and last in the access path.
+} -cleanup {
+} -match glob -result "{\$p(:0:)} {\$p(:*:)} 0 0.4.*\
+        {-accessPath {[list $tcl_library *$tcl_library/$pkgOptDir]}\
+        -statics 0 -nested 1 -deleteHook {}} {}"
 
 # test source control on file name
 set i "a"
@@ -748,7 +812,45 @@ test safe-9.10 {interpConfigure change the access path; pkgIndex.tcl packages un
         {-accessPath {[list $tcl_library $TestsDir/auto0 $TestsDir/auto0/auto2 $TestsDir/auto0/auto1]*}\
         -statics 1 -nested 0 -deleteHook {}}\
         0 OK1 0 OK2"
+test safe-9.10opt {interpConfigure change the access path; pkgIndex.tcl packages unaffected by token rearrangement, uses pkg opt and tcl::idna} -setup {
+} -body {
+    set i [safe::interpCreate -accessPath [list $tcl_library \
+                                            [file join $tcl_library $pkgOptDir] \
+                                            [file join $tcl_library $pkgJarDir]]]
+
+    # Inspect.
+    set confA [safe::interpConfigure $i]
+    set path1 [::safe::interpFindInAccessPath $i [file join $tcl_library $pkgOptDir]]
+    set path2 [::safe::interpFindInAccessPath $i [file join $tcl_library $pkgJarDir]]
+
+    # Load pkgIndex.tcl data.
+    catch {interp eval $i {package require NOEXIST}}
+
+    # Rearrange access path.  Swap tokens {$p(:1:)} and {$p(:2:)}.
+    # This has no effect because the records in Pkg of these directories were from access as children of {$p(:0:)}.
+    safe::interpConfigure $i -accessPath [list $tcl_library \
+                                           [file join $tcl_library $pkgJarDir] \
+                                           [file join $tcl_library $pkgOptDir]]
+
+    # Inspect.
+    set confB [safe::interpConfigure $i]
+    set path3 [::safe::interpFindInAccessPath $i [file join $tcl_library $pkgOptDir]]
+    set path4 [::safe::interpFindInAccessPath $i [file join $tcl_library $pkgJarDir]]
 
+    # Try to load the packages and run a command from each one.
+    set code3 [catch {interp eval $i {package require tcl::idna}} msg3]
+    set code4 [catch {interp eval $i {package require opt}} msg4]
+    set code5 [catch {interp eval $i {::tcl::Lempty {a list}}} msg5]
+    set code6 [catch {interp eval $i {::tcl::idna::IDNAencode example.com}} msg6]
+
+    list $path1 $path2 $path3 $path4 $code3 $msg3 $code4 $msg4 \
+         $confA $confB $code5 $msg5 $code6 $msg6
+} -cleanup {
+} -match glob -result "{\$p(:1:)} {\$p(:2:)} {\$p(:2:)} {\$p(:1:)} 0 1.* 0 0.4.*\
+        {-accessPath {[list $tcl_library $tcl_library/$pkgOptDir $tcl_library/$pkgJarDir]*}\
+        -statics 1 -nested 0 -deleteHook {}}\
+        {-accessPath {[list $tcl_library $tcl_library/$pkgJarDir $tcl_library/$pkgOptDir]*}\
+        -statics 1 -nested 0 -deleteHook {}} 0 0 0 example.com"
 test safe-9.11 {interpConfigure change the access path; pkgIndex.tcl packages unaffected by token rearrangement, 9.10 without path auto0} -setup {
 } -body {
     set i [safe::interpCreate -accessPath [list $tcl_library \
@@ -789,7 +891,6 @@ test safe-9.11 {interpConfigure change the access path; pkgIndex.tcl packages un
         {-accessPath {[list $tcl_library $TestsDir/auto0/auto2 $TestsDir/auto0/auto1]*}\
         -statics 1 -nested 0 -deleteHook {}}\
         0 OK1 0 OK2"
-
 test safe-9.12 {interpConfigure change the access path; pkgIndex.tcl packages fail if directory de-listed} -setup {
 } -body {
     set i [safe::interpCreate -accessPath [list $tcl_library \
@@ -824,7 +925,39 @@ test safe-9.12 {interpConfigure change the access path; pkgIndex.tcl packages fa
         {-accessPath {[list $tcl_library $TestsDir/auto0/auto1 $TestsDir/auto0/auto2]*}\
         -statics 1 -nested 0 -deleteHook {}}\
         {-accessPath {[list $tcl_library]*} -statics 1 -nested 0 -deleteHook {}}"
+test safe-9.12opt {interpConfigure change the access path; pkgIndex.tcl packages fail if directory de-listed, uses pkg opt and tcl::idna} -setup {
+} -body {
+    set i [safe::interpCreate -accessPath [list $tcl_library \
+                                            [file join $tcl_library $pkgOptDir] \
+                                            [file join $tcl_library $pkgJarDir]]]
+
+    # Inspect.
+    set confA [safe::interpConfigure $i]
+    set path1 [::safe::interpFindInAccessPath $i [file join $tcl_library $pkgOptDir]]
+    set path2 [::safe::interpFindInAccessPath $i [file join $tcl_library $pkgJarDir]]
 
+    # Load pkgIndex.tcl data.
+    catch {interp eval $i {package require NOEXIST}}
+
+    # Limit access path.  Remove tokens {$p(:1:)} and {$p(:2:)}.
+    safe::interpConfigure $i -accessPath [list $tcl_library]
+
+    # Inspect.
+    set confB [safe::interpConfigure $i]
+    set code4 [catch {::safe::interpFindInAccessPath $i [file join $tcl_library $pkgOptDir]} path4]
+    set code5 [catch {::safe::interpFindInAccessPath $i [file join $tcl_library $pkgJarDir]} path5]
+
+    # Try to load the packages.
+    set code3 [catch {interp eval $i {package require opt}} msg3]
+    set code6 [catch {interp eval $i {package require tcl::idna}} msg6]
+
+    list $path1 $path2 $code4 $path4 $code5 $path5 $code3 $msg3 $code6 $msg6 $confA $confB
+} -cleanup {
+} -match glob -result "{\$p(:1:)} {\$p(:2:)} 1 {* not found in access path}\
+        1 {* not found in access path} 1 {*} 1 {*}\
+        {-accessPath {[list $tcl_library $tcl_library/$pkgOptDir $tcl_library/$pkgJarDir]*}\
+        -statics 1 -nested 0 -deleteHook {}}\
+        {-accessPath {[list $tcl_library]*} -statics 1 -nested 0 -deleteHook {}}"
 test safe-9.20 {check module loading} -setup {
     set oldTm [tcl::tm::path list]
     foreach path $oldTm {
@@ -1563,7 +1696,7 @@ test safe-16.4 {Bug 3529949: defang ~user in globs} -setup {
 } -result {}
 
 set ::auto_path $saveAutoPath
-unset saveAutoPath TestsDir
+unset pkgOptErrMsg pkgOptDir pkgJarDir saveAutoPath TestsDir
 # cleanup
 ::tcltest::cleanupTests
 return
-- 
cgit v0.12


From 7e2905fd746b15cae860819c4b882f30b6d1c659 Mon Sep 17 00:00:00 2001
From: kjnash <k.j.nash@usa.net>
Date: Mon, 13 Jul 2020 18:14:33 +0000
Subject: safe.test - add zipfile and tests of loading files from zipfs

---
 tests/auto-files.zip | Bin 0 -> 4447 bytes
 tests/safe.test      | 696 ++++++++++++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 684 insertions(+), 12 deletions(-)
 create mode 100644 tests/auto-files.zip

diff --git a/tests/auto-files.zip b/tests/auto-files.zip
new file mode 100644
index 0000000..b8bdf88
Binary files /dev/null and b/tests/auto-files.zip differ
diff --git a/tests/safe.test b/tests/safe.test
index e99e3f7..98584fd 100644
--- a/tests/safe.test
+++ b/tests/safe.test
@@ -77,6 +77,8 @@ if {[file exists [file join [info library] cookiejar0.2]]} {
 }
 
 set TestsDir [file normalize [file dirname [info script]]]
+set ZipMountPoint [zipfs root]auto-files
+zipfs mount $ZipMountPoint [file join $TestsDir auto-files.zip]
 
 # Force actual loading of the safe package because we use un exported (and
 # thus un-autoindexed) APIs in this test result arguments:
@@ -249,7 +251,20 @@ test safe-7.0a {example tclIndex commands, test in master interpreter} -setup {
     set ::auto_path $tmpAutoPath
     auto_reset
 } -match glob -result {0 ok1 0 ok2}
-
+test safe-7.0az {example tclIndex commands, test in master interpreter; zipfs} -setup {
+    set tmpAutoPath $::auto_path
+    lappend ::auto_path [file join $ZipMountPoint auto0 auto1] [file join $ZipMountPoint auto0 auto2]
+} -body {
+    # Try to load the commands.
+    set code3 [catch report1 msg3]
+    set code4 [catch report2 msg4]
+    list $code3 $msg3 $code4 $msg4
+} -cleanup {
+    catch {rename report1 {}}
+    catch {rename report2 {}}
+    set ::auto_path $tmpAutoPath
+    auto_reset
+} -match glob -result {0 ok1 0 ok2}
 test safe-7.0b {example tclIndex commands, negative test in master interpreter} -setup {
     set tmpAutoPath $::auto_path
     lappend ::auto_path [file join $TestsDir auto0]
@@ -264,7 +279,20 @@ test safe-7.0b {example tclIndex commands, negative test in master interpreter}
     set ::auto_path $tmpAutoPath
     auto_reset
 } -match glob -result {1 {invalid command name "report1"} 1 {invalid command name "report2"}}
-
+test safe-7.0bz {example tclIndex commands, negative test in master interpreter; zipfs} -setup {
+    set tmpAutoPath $::auto_path
+    lappend ::auto_path [file join $ZipMountPoint auto0]
+} -body {
+    # Try to load the commands.
+    set code3 [catch report1 msg3]
+    set code4 [catch report2 msg4]
+    list $code3 $msg3 $code4 $msg4
+} -cleanup {
+    catch {rename report1 {}}
+    catch {rename report2 {}}
+    set ::auto_path $tmpAutoPath
+    auto_reset
+} -match glob -result {1 {invalid command name "report1"} 1 {invalid command name "report2"}}
 test safe-7.0c {example pkgIndex.tcl packages, test in master interpreter, child directories} -setup {
     set tmpAutoPath $::auto_path
     lappend ::auto_path [file join $TestsDir auto0]
@@ -283,7 +311,24 @@ test safe-7.0c {example pkgIndex.tcl packages, test in master interpreter, child
     catch {rename HeresPackage1 {}}
     catch {rename HeresPackage2 {}}
 } -match glob -result {0 1.2.3 0 2.3.4 0 OK1 0 OK2}
+test safe-7.0cz {example pkgIndex.tcl packages, test in master interpreter, child directories; zipfs} -setup {
+    set tmpAutoPath $::auto_path
+    lappend ::auto_path [file join $ZipMountPoint auto0]
+} -body {
+    # Try to load the packages and run a command from each one.
+    set code3 [catch {package require SafeTestPackage1} msg3]
+    set code4 [catch {package require SafeTestPackage2} msg4]
+    set code5 [catch HeresPackage1 msg5]
+    set code6 [catch HeresPackage2 msg6]
 
+    list $code3 $msg3 $code4 $msg4 $code5 $msg5 $code6 $msg6
+} -cleanup {
+    set ::auto_path $tmpAutoPath
+    catch {package forget SafeTestPackage1}
+    catch {package forget SafeTestPackage2}
+    catch {rename HeresPackage1 {}}
+    catch {rename HeresPackage2 {}}
+} -match glob -result {0 1.2.3 0 2.3.4 0 OK1 0 OK2}
 test safe-7.0d {example pkgIndex.tcl packages, test in master interpreter, main directories} -setup {
     set tmpAutoPath $::auto_path
     lappend ::auto_path [file join $TestsDir auto0 auto1] \
@@ -303,7 +348,25 @@ test safe-7.0d {example pkgIndex.tcl packages, test in master interpreter, main
     catch {rename HeresPackage1 {}}
     catch {rename HeresPackage2 {}}
 } -match glob -result {0 1.2.3 0 2.3.4 0 OK1 0 OK2}
+test safe-7.0dz {example pkgIndex.tcl packages, test in master interpreter, main directories; zipfs} -setup {
+    set tmpAutoPath $::auto_path
+    lappend ::auto_path [file join $ZipMountPoint auto0 auto1] \
+                        [file join $ZipMountPoint auto0 auto2]
+} -body {
+    # Try to load the packages and run a command from each one.
+    set code3 [catch {package require SafeTestPackage1} msg3]
+    set code4 [catch {package require SafeTestPackage2} msg4]
+    set code5 [catch HeresPackage1 msg5]
+    set code6 [catch HeresPackage2 msg6]
 
+    list $code3 $msg3 $code4 $msg4 $code5 $msg5 $code6 $msg6
+} -cleanup {
+    set ::auto_path $tmpAutoPath
+    catch {package forget SafeTestPackage1}
+    catch {package forget SafeTestPackage2}
+    catch {rename HeresPackage1 {}}
+    catch {rename HeresPackage2 {}}
+} -match glob -result {0 1.2.3 0 2.3.4 0 OK1 0 OK2}
 test safe-7.0e {example modules packages, test in master interpreter, replace path} -setup {
     set oldTm [tcl::tm::path list]
     foreach path $oldTm {
@@ -331,7 +394,33 @@ test safe-7.0e {example modules packages, test in master interpreter, replace pa
     catch {namespace delete ::test0}
     catch {namespace delete ::mod1}
 } -match glob -result {0 0.5 0 1.0 0 2.0 -- res0 res1 res2}
+test safe-7.0ez {example modules packages, test in master interpreter, replace path; zipfs} -setup {
+    set oldTm [tcl::tm::path list]
+    foreach path $oldTm {
+        tcl::tm::path remove $path
+    }
+    tcl::tm::path add [file join $ZipMountPoint auto0 modules]
+} -body {
+    # Try to load the modules and run a command from each one.
+    set code0 [catch {package require test0} msg0]
+    set code1 [catch {package require mod1::test1} msg1]
+    set code2 [catch {package require mod2::test2} msg2]
+    set out0  [test0::try0]
+    set out1  [mod1::test1::try1]
+    set out2  [mod2::test2::try2]
 
+    list $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $out0 $out1 $out2
+} -cleanup {
+    tcl::tm::path remove [file join $ZipMountPoint auto0 modules]
+    foreach path [lreverse $oldTm] {
+        tcl::tm::path add $path
+    }
+    catch {package forget test0}
+    catch {package forget mod1::test1}
+    catch {package forget mod2::test2}
+    catch {namespace delete ::test0}
+    catch {namespace delete ::mod1}
+} -match glob -result {0 0.5 0 1.0 0 2.0 -- res0 res1 res2}
 test safe-7.0f {example modules packages, test in master interpreter, append to path} -setup {
     tcl::tm::path add [file join $TestsDir auto0 modules]
 } -body {
@@ -352,6 +441,26 @@ test safe-7.0f {example modules packages, test in master interpreter, append to
     catch {namespace delete ::test0}
     catch {namespace delete ::mod1}
 } -match glob -result {0 0.5 0 1.0 0 2.0 -- res0 res1 res2}
+test safe-7.0fz {example modules packages, test in master interpreter, append to path; zipfs} -setup {
+    tcl::tm::path add [file join $ZipMountPoint auto0 modules]
+} -body {
+    # Try to load the modules and run a command from each one.
+    set code0 [catch {package require test0} msg0]
+    set code1 [catch {package require mod1::test1} msg1]
+    set code2 [catch {package require mod2::test2} msg2]
+    set out0  [test0::try0]
+    set out1  [mod1::test1::try1]
+    set out2  [mod2::test2::try2]
+
+    list $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $out0 $out1 $out2
+} -cleanup {
+    tcl::tm::path remove [file join $ZipMountPoint auto0 modules]
+    catch {package forget test0}
+    catch {package forget mod1::test1}
+    catch {package forget mod2::test2}
+    catch {namespace delete ::test0}
+    catch {namespace delete ::mod1}
+} -match glob -result {0 0.5 0 1.0 0 2.0 -- res0 res1 res2}
 
 # high level general test
 # Use example packages not http1.0
@@ -372,6 +481,24 @@ test safe-7.1 {tests that everything works at high level} -setup {
     safe::interpDelete $i
 } -match glob -result 1.2.3
 # high level general test
+# Use zipped example packages not tcl8.x/opt
+test safe-7.1z {tests that everything works at high level; zipfs} -setup {
+    set tmpAutoPath $::auto_path
+    lappend ::auto_path [file join $TestsDir auto0]
+    set i [safe::interpCreate]
+    set ::auto_path $tmpAutoPath
+} -body {
+    # no error shall occur:
+    # (because the default access_path shall include 1st level sub dirs so
+    #  package require in a slave works like in the master)
+    set v [interp eval $i {package require SafeTestPackage1}]
+    # no error shall occur:
+    interp eval $i {HeresPackage1}
+    set v
+} -cleanup {
+    safe::interpDelete $i
+} -match glob -result 1.2.3
+# high level general test
 test safe-7.1opt {tests that everything works at high level, uses pkg opt} -setup {
     set i [safe::interpCreate]
 } -body {
@@ -405,6 +532,26 @@ test safe-7.2 {tests specific path and interpFind/AddToAccessPath} -setup {
         {can't find package SafeTestPackage1}\
         {-accessPath {[list $tcl_library */dummy/unixlike/test/path $TestsDir/auto0]}\
         -statics 0 -nested 1 -deleteHook {}} {}"
+test safe-7.2z {tests specific path and interpFind/AddToAccessPath; zipfs} -setup {
+} -body {
+    set i [safe::interpCreate -nostat -nested 1 -accessPath [list [info library]]]
+    # should not add anything (p0)
+    set token1 [safe::interpAddToAccessPath $i [info library]]
+    # should add as p* (not p1 if master has a module path)
+    set token2 [safe::interpAddToAccessPath $i "/dummy/unixlike/test/path"]
+    # should add as p* (not p2 if master has a module path)
+    set token3 [safe::interpAddToAccessPath $i [file join $TestsDir auto0]]
+    # an error shall occur (SafeTestPackage1 is not anymore in the secure 0-level
+    # provided deep path)
+    list $token1 $token2 $token3 \
+	    [catch {interp eval $i {package require SafeTestPackage1}} msg] $msg \
+	    [safe::interpConfigure $i]\
+	    [safe::interpDelete $i]
+} -cleanup {
+} -match glob -result "{\$p(:0:)} {\$p(:*:)} {\$p(:*:)} 1\
+        {can't find package SafeTestPackage1}\
+        {-accessPath {[list $tcl_library */dummy/unixlike/test/path $TestsDir/auto0]}\
+        -statics 0 -nested 1 -deleteHook {}} {}"
 test safe-7.2opt {tests specific path and interpFind/AddToAccessPath, uses pkg opt} -setup {
 } -body {
     set i [safe::interpCreate -nostat -nested 1 -accessPath [list [info library]]]
@@ -445,6 +592,24 @@ test safe-7.4 {tests specific path and positive search} -setup {
 } -match glob -result "{\$p(:0:)} {\$p(:*:)} 0 1.2.3\
         {-accessPath {[list $tcl_library * $TestsDir/auto0/auto1]}\
         -statics 0 -nested 1 -deleteHook {}} {}"
+test safe-7.4z {tests specific path and positive search; zipfs} -setup {
+} -body {
+    set i [safe::interpCreate -nostat -nested 1 -accessPath [list [info library]]]
+    # should not add anything (p0)
+    set token1 [safe::interpAddToAccessPath $i [info library]]
+    # should add as p* (not p1 if master has a module path)
+    set token2 [safe::interpAddToAccessPath $i [file join $TestsDir auto0 auto1]]
+    # this time, unlike test safe-7.2z, SafeTestPackage1 should be found
+    list $token1 $token2 \
+	    [catch {interp eval $i {package require SafeTestPackage1}} msg] $msg \
+	    [safe::interpConfigure $i]\
+	    [safe::interpDelete $i]
+    # Note that the glob match elides directories (those from the module path)
+    # other than the first and last in the access path.
+} -cleanup {
+} -match glob -result "{\$p(:0:)} {\$p(:*:)} 0 1.2.3\
+        {-accessPath {[list $tcl_library * $TestsDir/auto0/auto1]}\
+        -statics 0 -nested 1 -deleteHook {}} {}"
 test safe-7.4opt {tests specific path and positive search, uses pkg opt} -setup {
 } -body {
     set i [safe::interpCreate -nostat -nested 1 -accessPath [list [info library]]]
@@ -724,7 +889,47 @@ test safe-9.8 {interpConfigure change the access path; tclIndex commands unaffec
         -statics 1 -nested 0 -deleteHook {}}\
         {-accessPath {[list $tcl_library $TestsDir/auto0/auto2 $TestsDir/auto0/auto1]*}\
         -statics 1 -nested 0 -deleteHook {}}"
+test safe-9.8z {interpConfigure change the access path; tclIndex commands unaffected by token rearrangement (dummy test of doreset); zipfs} -setup {
+} -body {
+    set i [safe::interpCreate -accessPath [list $tcl_library \
+                                            [file join $ZipMountPoint auto0 auto1] \
+                                            [file join $ZipMountPoint auto0 auto2]]]
+
+    # Inspect.
+    set confA [safe::interpConfigure $i]
+    set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
+    set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
+
+    # Load auto_load data.
+    interp eval $i {catch nonExistentCommand}
 
+    # Load and run the commands.
+    # This guarantees the test will pass even if the tokens are swapped.
+    set code1 [catch {interp eval $i {report1}} msg1]
+    set code2 [catch {interp eval $i {report2}} msg2]
+
+    # Rearrange access path.  Swap tokens {$p(:1:)} and {$p(:2:)}.
+    safe::interpConfigure $i -accessPath [list $tcl_library \
+                                           [file join $ZipMountPoint auto0 auto2] \
+                                           [file join $ZipMountPoint auto0 auto1]]
+
+    # Inspect.
+    set confB [safe::interpConfigure $i]
+    set path3 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
+    set path4 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
+
+    # Run the commands.
+    set code3 [catch {interp eval $i {report1}} msg3]
+    set code4 [catch {interp eval $i {report2}} msg4]
+
+    list $path1 $path2 $path3 $path4 $code3 $msg3 $code4 $msg4 $confA $confB
+} -cleanup {
+    safe::interpDelete $i
+} -match glob -result "{\$p(:1:)} {\$p(:2:)} {\$p(:2:)} {\$p(:1:)} 0 ok1 0 ok2\
+        {-accessPath {[list $tcl_library $ZipMountPoint/auto0/auto1 $ZipMountPoint/auto0/auto2]*}\
+        -statics 1 -nested 0 -deleteHook {}}\
+        {-accessPath {[list $tcl_library $ZipMountPoint/auto0/auto2 $ZipMountPoint/auto0/auto1]*}\
+        -statics 1 -nested 0 -deleteHook {}}"
 test safe-9.9 {interpConfigure change the access path; tclIndex commands unaffected by token rearrangement (actual test of doreset)} -setup {
 } -body {
     set i [safe::interpCreate -accessPath [list $tcl_library \
@@ -764,7 +969,45 @@ test safe-9.9 {interpConfigure change the access path; tclIndex commands unaffec
         -statics 1 -nested 0 -deleteHook {}}\
         {-accessPath {[list $tcl_library $TestsDir/auto0/auto2 $TestsDir/auto0/auto1]*}\
         -statics 1 -nested 0 -deleteHook {}}"
+test safe-9.9z {interpConfigure change the access path; tclIndex commands unaffected by token rearrangement (actual test of doreset); zipfs} -setup {
+} -body {
+    set i [safe::interpCreate -accessPath [list $tcl_library \
+                                            [file join $ZipMountPoint auto0 auto1] \
+                                            [file join $ZipMountPoint auto0 auto2]]]
+
+    # Inspect.
+    set confA [safe::interpConfigure $i]
+    set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
+    set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
+
+    # Load auto_load data.
+    interp eval $i {catch nonExistentCommand}
+
+    # Do not load the commands.  With the tokens swapped, the test
+    # will pass only if the Safe Base has called auto_reset.
+
+    # Rearrange access path.  Swap tokens {$p(:1:)} and {$p(:2:)}.
+    safe::interpConfigure $i -accessPath [list $tcl_library \
+                                           [file join $ZipMountPoint auto0 auto2] \
+                                           [file join $ZipMountPoint auto0 auto1]]
 
+    # Inspect.
+    set confB [safe::interpConfigure $i]
+    set path3 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
+    set path4 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
+
+    # Load and run the commands.
+    set code3 [catch {interp eval $i {report1}} msg3]
+    set code4 [catch {interp eval $i {report2}} msg4]
+
+    list $path1 $path2 $path3 $path4 $code3 $msg3 $code4 $msg4 $confA $confB
+} -cleanup {
+    safe::interpDelete $i
+} -match glob -result "{\$p(:1:)} {\$p(:2:)} {\$p(:2:)} {\$p(:1:)} 0 ok1 0 ok2\
+        {-accessPath {[list $tcl_library $ZipMountPoint/auto0/auto1 $ZipMountPoint/auto0/auto2]*}\
+        -statics 1 -nested 0 -deleteHook {}}\
+        {-accessPath {[list $tcl_library $ZipMountPoint/auto0/auto2 $ZipMountPoint/auto0/auto1]*}\
+        -statics 1 -nested 0 -deleteHook {}}"
 test safe-9.10 {interpConfigure change the access path; pkgIndex.tcl packages unaffected by token rearrangement} -setup {
 } -body {
     # For complete correspondence to safe-9.10opt, include auto0 in access path.
@@ -812,6 +1055,53 @@ test safe-9.10 {interpConfigure change the access path; pkgIndex.tcl packages un
         {-accessPath {[list $tcl_library $TestsDir/auto0 $TestsDir/auto0/auto2 $TestsDir/auto0/auto1]*}\
         -statics 1 -nested 0 -deleteHook {}}\
         0 OK1 0 OK2"
+test safe-9.10z {interpConfigure change the access path; pkgIndex.tcl packages unaffected by token rearrangement; zipfs} -setup {
+} -body {
+    # For complete correspondence to safe-9.10opt, include auto0 in access path.
+    set i [safe::interpCreate -accessPath [list $tcl_library \
+                                            [file join $ZipMountPoint auto0] \
+                                            [file join $ZipMountPoint auto0 auto1] \
+                                            [file join $ZipMountPoint auto0 auto2]]]
+
+    # Inspect.
+    set confA [safe::interpConfigure $i]
+    set path0 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0]]
+    set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
+    set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
+
+    # Load pkgIndex.tcl data.
+    catch {interp eval $i {package require NOEXIST}}
+
+    # Rearrange access path.  Swap tokens {$p(:2:)} and {$p(:3:)}.
+    # This would have no effect because the records in Pkg of these directories
+    # were from access as children of {$p(:1:)}.
+    safe::interpConfigure $i -accessPath [list $tcl_library \
+                                           [file join $ZipMountPoint auto0] \
+                                           [file join $ZipMountPoint auto0 auto2] \
+                                           [file join $ZipMountPoint auto0 auto1]]
+
+    # Inspect.
+    set confB [safe::interpConfigure $i]
+    set path3 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
+    set path4 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
+
+    # Try to load the packages and run a command from each one.
+    set code3 [catch {interp eval $i {package require SafeTestPackage1}} msg3 opts3]
+    set code4 [catch {interp eval $i {package require SafeTestPackage2}} msg4 opts4]
+    set code5 [catch {interp eval $i {HeresPackage1}} msg5 opts5]
+    set code6 [catch {interp eval $i {HeresPackage2}} msg6 opts6]
+
+    list $path1 $path2 $path3 $path4 $code3 $msg3 $code4 $msg4 $confA $confB \
+         $code5 $msg5 $code6 $msg6
+
+} -cleanup {
+    safe::interpDelete $i
+} -match glob -result "{\$p(:2:)} {\$p(:3:)} {\$p(:3:)} {\$p(:2:)} 0 1.2.3 0 2.3.4\
+        {-accessPath {[list $tcl_library $ZipMountPoint/auto0 $ZipMountPoint/auto0/auto1 $ZipMountPoint/auto0/auto2]*}\
+        -statics 1 -nested 0 -deleteHook {}}\
+        {-accessPath {[list $tcl_library $ZipMountPoint/auto0 $ZipMountPoint/auto0/auto2 $ZipMountPoint/auto0/auto1]*}\
+        -statics 1 -nested 0 -deleteHook {}}\
+        0 OK1 0 OK2"
 test safe-9.10opt {interpConfigure change the access path; pkgIndex.tcl packages unaffected by token rearrangement, uses pkg opt and tcl::idna} -setup {
 } -body {
     set i [safe::interpCreate -accessPath [list $tcl_library \
@@ -846,6 +1136,7 @@ test safe-9.10opt {interpConfigure change the access path; pkgIndex.tcl packages
     list $path1 $path2 $path3 $path4 $code3 $msg3 $code4 $msg4 \
          $confA $confB $code5 $msg5 $code6 $msg6
 } -cleanup {
+    safe::interpDelete $i
 } -match glob -result "{\$p(:1:)} {\$p(:2:)} {\$p(:2:)} {\$p(:1:)} 0 1.* 0 0.4.*\
         {-accessPath {[list $tcl_library $tcl_library/$pkgOptDir $tcl_library/$pkgJarDir]*}\
         -statics 1 -nested 0 -deleteHook {}}\
@@ -859,21 +1150,61 @@ test safe-9.11 {interpConfigure change the access path; pkgIndex.tcl packages un
 
     # Inspect.
     set confA [safe::interpConfigure $i]
-    set path1 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 auto1]]
-    set path2 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 auto2]]
+    set path1 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 auto1]]
+    set path2 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 auto2]]
+
+    # Load pkgIndex.tcl data.
+    catch {interp eval $i {package require NOEXIST}}
+
+    # Rearrange access path.  Swap tokens {$p(:1:)} and {$p(:2:)}.
+    safe::interpConfigure $i -accessPath [list $tcl_library \
+                                           [file join $TestsDir auto0 auto2] \
+                                           [file join $TestsDir auto0 auto1]]
+
+    # Inspect.
+    set confB [safe::interpConfigure $i]
+    set path3 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 auto1]]
+    set path4 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 auto2]]
+
+    # Try to load the packages and run a command from each one.
+    set code3 [catch {interp eval $i {package require SafeTestPackage1}} msg3 opts3]
+    set code4 [catch {interp eval $i {package require SafeTestPackage2}} msg4 opts4]
+    set code5 [catch {interp eval $i {HeresPackage1}} msg5 opts5]
+    set code6 [catch {interp eval $i {HeresPackage2}} msg6 opts6]
+
+    list $path1 $path2 $path3 $path4 $code3 $msg3 $code4 $msg4 $confA $confB \
+         $code5 $msg5 $code6 $msg6
+} -cleanup {
+    safe::interpDelete $i
+} -match glob -result "{\$p(:1:)} {\$p(:2:)} {\$p(:2:)} {\$p(:1:)} 0 1.2.3 0 2.3.4\
+        {-accessPath {[list $tcl_library $TestsDir/auto0/auto1 $TestsDir/auto0/auto2]*}\
+        -statics 1 -nested 0 -deleteHook {}}\
+        {-accessPath {[list $tcl_library $TestsDir/auto0/auto2 $TestsDir/auto0/auto1]*}\
+        -statics 1 -nested 0 -deleteHook {}}\
+        0 OK1 0 OK2"
+test safe-9.11z {interpConfigure change the access path; pkgIndex.tcl packages unaffected by token rearrangement, 9.10 without path auto0; zipfs} -setup {
+} -body {
+    set i [safe::interpCreate -accessPath [list $tcl_library \
+                                            [file join $ZipMountPoint auto0 auto1] \
+                                            [file join $ZipMountPoint auto0 auto2]]]
+
+    # Inspect.
+    set confA [safe::interpConfigure $i]
+    set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
+    set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
 
     # Load pkgIndex.tcl data.
     catch {interp eval $i {package require NOEXIST}}
 
     # Rearrange access path.  Swap tokens {$p(:1:)} and {$p(:2:)}.
     safe::interpConfigure $i -accessPath [list $tcl_library \
-                                           [file join $TestsDir auto0 auto2] \
-                                           [file join $TestsDir auto0 auto1]]
+                                           [file join $ZipMountPoint auto0 auto2] \
+                                           [file join $ZipMountPoint auto0 auto1]]
 
     # Inspect.
     set confB [safe::interpConfigure $i]
-    set path3 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 auto1]]
-    set path4 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 auto2]]
+    set path3 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
+    set path4 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
 
     # Try to load the packages and run a command from each one.
     set code3 [catch {interp eval $i {package require SafeTestPackage1}} msg3 opts3]
@@ -886,9 +1217,9 @@ test safe-9.11 {interpConfigure change the access path; pkgIndex.tcl packages un
 } -cleanup {
     safe::interpDelete $i
 } -match glob -result "{\$p(:1:)} {\$p(:2:)} {\$p(:2:)} {\$p(:1:)} 0 1.2.3 0 2.3.4\
-        {-accessPath {[list $tcl_library $TestsDir/auto0/auto1 $TestsDir/auto0/auto2]*}\
+        {-accessPath {[list $tcl_library $ZipMountPoint/auto0/auto1 $ZipMountPoint/auto0/auto2]*}\
         -statics 1 -nested 0 -deleteHook {}}\
-        {-accessPath {[list $tcl_library $TestsDir/auto0/auto2 $TestsDir/auto0/auto1]*}\
+        {-accessPath {[list $tcl_library $ZipMountPoint/auto0/auto2 $ZipMountPoint/auto0/auto1]*}\
         -statics 1 -nested 0 -deleteHook {}}\
         0 OK1 0 OK2"
 test safe-9.12 {interpConfigure change the access path; pkgIndex.tcl packages fail if directory de-listed} -setup {
@@ -925,6 +1256,40 @@ test safe-9.12 {interpConfigure change the access path; pkgIndex.tcl packages fa
         {-accessPath {[list $tcl_library $TestsDir/auto0/auto1 $TestsDir/auto0/auto2]*}\
         -statics 1 -nested 0 -deleteHook {}}\
         {-accessPath {[list $tcl_library]*} -statics 1 -nested 0 -deleteHook {}}"
+test safe-9.12z {interpConfigure change the access path; pkgIndex.tcl packages fail if directory de-listed; zipfs} -setup {
+} -body {
+    set i [safe::interpCreate -accessPath [list $tcl_library \
+                                            [file join $ZipMountPoint auto0 auto1] \
+                                            [file join $ZipMountPoint auto0 auto2]]]
+
+    # Inspect.
+    set confA [safe::interpConfigure $i]
+    set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
+    set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
+
+    # Load pkgIndex.tcl data.
+    catch {interp eval $i {package require NOEXIST}}
+
+    # Limit access path.  Remove tokens {$p(:1:)} and {$p(:2:)}.
+    safe::interpConfigure $i -accessPath [list $tcl_library]
+
+    # Inspect.
+    set confB [safe::interpConfigure $i]
+    set code4 [catch {::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]} path4]
+    set code5 [catch {::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]} path5]
+
+    # Try to load the packages.
+    set code3 [catch {interp eval $i {package require SafeTestPackage1}} msg3]
+    set code6 [catch {interp eval $i {package require SafeTestPackage2}} msg6]
+
+    list $path1 $path2 $code4 $path4 $code5 $path5 $code3 $msg3 $code6 $msg6 $confA $confB
+} -cleanup {
+    safe::interpDelete $i
+} -match glob -result "{\$p(:1:)} {\$p(:2:)} 1 {* not found in access path}\
+        1 {* not found in access path} 1 {*} 1 {*}\
+        {-accessPath {[list $tcl_library $ZipMountPoint/auto0/auto1 $ZipMountPoint/auto0/auto2]*}\
+        -statics 1 -nested 0 -deleteHook {}}\
+        {-accessPath {[list $tcl_library]*} -statics 1 -nested 0 -deleteHook {}}"
 test safe-9.12opt {interpConfigure change the access path; pkgIndex.tcl packages fail if directory de-listed, uses pkg opt and tcl::idna} -setup {
 } -body {
     set i [safe::interpCreate -accessPath [list $tcl_library \
@@ -953,6 +1318,7 @@ test safe-9.12opt {interpConfigure change the access path; pkgIndex.tcl packages
 
     list $path1 $path2 $code4 $path4 $code5 $path5 $code3 $msg3 $code6 $msg6 $confA $confB
 } -cleanup {
+    safe::interpDelete $i
 } -match glob -result "{\$p(:1:)} {\$p(:2:)} 1 {* not found in access path}\
         1 {* not found in access path} 1 {*} 1 {*}\
         {-accessPath {[list $tcl_library $tcl_library/$pkgOptDir $tcl_library/$pkgJarDir]*}\
@@ -997,7 +1363,45 @@ test safe-9.20 {check module loading} -setup {
                         $TestsDir/auto0/modules/mod2]*}\
         -statics 1 -nested 0 -deleteHook {}} --\
         res0 res1 res2"
+test safe-9.20z {check module loading; zipfs} -setup {
+    set oldTm [tcl::tm::path list]
+    foreach path $oldTm {
+        tcl::tm::path remove $path
+    }
+    tcl::tm::path add [file join $ZipMountPoint auto0 modules]
+} -body {
+    set i [safe::interpCreate -accessPath [list $tcl_library]]
+
+    # Inspect.
+    set confA [safe::interpConfigure $i]
+    set modsA [interp eval $i {tcl::tm::path list}]
+    set path0 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
+    set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
+    set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod2]]
+
+    # Try to load the packages and run a command from each one.
+    set code0 [catch {interp eval $i {package require test0}} msg0]
+    set code1 [catch {interp eval $i {package require mod1::test1}} msg1]
+    set code2 [catch {interp eval $i {package require mod2::test2}} msg2]
+    set out0  [interp eval $i {test0::try0}]
+    set out1  [interp eval $i {mod1::test1::try1}]
+    set out2  [interp eval $i {mod2::test2::try2}]
 
+    list $path0 $path1 $path2 -- $modsA -- \
+         $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $confA -- $out0 $out1 $out2
+} -cleanup {
+    tcl::tm::path remove [file join $ZipMountPoint auto0 modules]
+    foreach path [lreverse $oldTm] {
+        tcl::tm::path add $path
+    }
+    safe::interpDelete $i
+} -match glob -result "{\$p(:1:)} {\$p(:2:)} {\$p(:3:)} -- {{\$p(:1:)}} --\
+        0 0.5 0 1.0 0 2.0 --\
+        {-accessPath {[list $tcl_library $ZipMountPoint/auto0/modules \
+                        $ZipMountPoint/auto0/modules/mod1 \
+                        $ZipMountPoint/auto0/modules/mod2]*}\
+        -statics 1 -nested 0 -deleteHook {}} --\
+        res0 res1 res2"
 test safe-9.21 {interpConfigure change the access path; check module loading; stale data case 1} -setup {
     set oldTm [tcl::tm::path list]
     foreach path $oldTm {
@@ -1065,7 +1469,73 @@ test safe-9.21 {interpConfigure change the access path; check module loading; st
                         $TestsDir/auto0/modules/mod2]}\
         -statics 1 -nested 0 -deleteHook {}} --\
         res0 res1 res2"
+test safe-9.21z {interpConfigure change the access path; check module loading; stale data case 1; zipfs} -setup {
+    set oldTm [tcl::tm::path list]
+    foreach path $oldTm {
+        tcl::tm::path remove $path
+    }
+    tcl::tm::path add [file join $ZipMountPoint auto0 modules]
+} -body {
+    set i [safe::interpCreate -accessPath [list $tcl_library]]
+
+    # Inspect.
+    set confA [safe::interpConfigure $i]
+    set modsA [interp eval $i {tcl::tm::path list}]
+    set path0 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
+    set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
+    set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod2]]
+
+    # Add to access path.
+    # This injects more tokens, pushing modules to higher token numbers.
+    safe::interpConfigure $i -accessPath [list $tcl_library \
+                                           [file join $ZipMountPoint auto0 auto1] \
+                                           [file join $ZipMountPoint auto0 auto2]]
+
+    # Inspect.
+    set confB [safe::interpConfigure $i]
+    set modsB [interp eval $i {tcl::tm::path list}]
+    set path3 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
+    set path4 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
+    set path5 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod2]]
+
+    # Load pkg data.
+    catch {interp eval $i {package require NOEXIST}}
+    catch {interp eval $i {package require mod1::NOEXIST}}
+    catch {interp eval $i {package require mod2::NOEXIST}}
+
+    # Try to load the packages and run a command from each one.
+    set code0 [catch {interp eval $i {package require test0}} msg0]
+    set code1 [catch {interp eval $i {package require mod1::test1}} msg1]
+    set code2 [catch {interp eval $i {package require mod2::test2}} msg2]
+    set out0  [interp eval $i {test0::try0}]
+    set out1  [interp eval $i {mod1::test1::try1}]
+    set out2  [interp eval $i {mod2::test2::try2}]
 
+    list $path0 $path1 $path2 -- $modsA -- $path3 $path4 $path5 -- $modsB -- \
+         $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $confA -- $confB -- \
+         $out0 $out1 $out2
+} -cleanup {
+    tcl::tm::path remove [file join $ZipMountPoint auto0 modules]
+    foreach path [lreverse $oldTm] {
+        tcl::tm::path add $path
+    }
+    safe::interpDelete $i
+} -match glob -result "{\$p(:1:)} {\$p(:2:)} {\$p(:3:)} -- {{\$p(:1:)}} --\
+        {\$p(:3:)} {\$p(:4:)} {\$p(:5:)} -- {{\$p(:3:)}} --\
+        0 0.5 0 1.0 0 2.0 --\
+        {-accessPath {[list $tcl_library \
+                        $ZipMountPoint/auto0/modules \
+                        $ZipMountPoint/auto0/modules/mod1 \
+                        $ZipMountPoint/auto0/modules/mod2]}\
+        -statics 1 -nested 0 -deleteHook {}} --\
+        {-accessPath {[list $tcl_library \
+                        $ZipMountPoint/auto0/auto1 \
+                        $ZipMountPoint/auto0/auto2 \
+                        $ZipMountPoint/auto0/modules \
+                        $ZipMountPoint/auto0/modules/mod1 \
+                        $ZipMountPoint/auto0/modules/mod2]}\
+        -statics 1 -nested 0 -deleteHook {}} --\
+        res0 res1 res2"
 test safe-9.22 {interpConfigure change the access path; check module loading; stale data case 0} -setup {
     set oldTm [tcl::tm::path list]
     foreach path $oldTm {
@@ -1128,7 +1598,68 @@ test safe-9.22 {interpConfigure change the access path; check module loading; st
                             $TestsDir/auto0/modules/mod2]}\
         -statics 1 -nested 0 -deleteHook {}} --\
         res0 res1 res2"
+test safe-9.22z {interpConfigure change the access path; check module loading; stale data case 0; zipfs} -setup {
+    set oldTm [tcl::tm::path list]
+    foreach path $oldTm {
+        tcl::tm::path remove $path
+    }
+    tcl::tm::path add [file join $ZipMountPoint auto0 modules]
+} -body {
+    set i [safe::interpCreate -accessPath [list $tcl_library]]
+
+    # Inspect.
+    set confA [safe::interpConfigure $i]
+    set modsA [interp eval $i {tcl::tm::path list}]
+    set path0 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
+    set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
+    set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod2]]
+
+    # Add to access path.
+    # This injects more tokens, pushing modules to higher token numbers.
+    safe::interpConfigure $i -accessPath [list $tcl_library \
+                                          [file join $ZipMountPoint auto0 auto1] \
+                                          [file join $ZipMountPoint auto0 auto2]]
+
+    # Inspect.
+    set confB [safe::interpConfigure $i]
+    set modsB [interp eval $i {tcl::tm::path list}]
+    set path3 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
+    set path4 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
+    set path5 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod2]]
+
+    # Try to load the packages and run a command from each one.
+    set code0 [catch {interp eval $i {package require test0}} msg0]
+    set code1 [catch {interp eval $i {package require mod1::test1}} msg1]
+    set code2 [catch {interp eval $i {package require mod2::test2}} msg2]
+    set out0  [interp eval $i {test0::try0}]
+    set out1  [interp eval $i {mod1::test1::try1}]
+    set out2  [interp eval $i {mod2::test2::try2}]
 
+    list $path0 $path1 $path2 -- $modsA -- $path3 $path4 $path5 -- $modsB -- \
+         $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $confA -- $confB -- \
+         $out0 $out1 $out2
+} -cleanup {
+    tcl::tm::path remove [file join $ZipMountPoint auto0 modules]
+    foreach path [lreverse $oldTm] {
+        tcl::tm::path add $path
+    }
+    safe::interpDelete $i
+} -match glob -result "{\$p(:1:)} {\$p(:2:)} {\$p(:3:)} -- {{\$p(:1:)}} --\
+        {\$p(:3:)} {\$p(:4:)} {\$p(:5:)} -- {{\$p(:3:)}} --\
+        0 0.5 0 1.0 0 2.0 --\
+        {-accessPath {[list $tcl_library \
+                            $ZipMountPoint/auto0/modules \
+                            $ZipMountPoint/auto0/modules/mod1 \
+                            $ZipMountPoint/auto0/modules/mod2]}\
+        -statics 1 -nested 0 -deleteHook {}} --\
+        {-accessPath {[list $tcl_library \
+                            $ZipMountPoint/auto0/auto1 \
+                            $ZipMountPoint/auto0/auto2 \
+                            $ZipMountPoint/auto0/modules \
+                            $ZipMountPoint/auto0/modules/mod1 \
+                            $ZipMountPoint/auto0/modules/mod2]}\
+        -statics 1 -nested 0 -deleteHook {}} --\
+        res0 res1 res2"
 test safe-9.23 {interpConfigure change the access path; check module loading; stale data case 3} -setup {
     set oldTm [tcl::tm::path list]
     foreach path $oldTm {
@@ -1202,7 +1733,79 @@ test safe-9.23 {interpConfigure change the access path; check module loading; st
                             $TestsDir/auto0/modules/mod2]}\
         -statics 1 -nested 0 -deleteHook {}} --\
         res0 res1 res2"
+test safe-9.23z {interpConfigure change the access path; check module loading; stale data case 3; zipfs} -setup {
+    set oldTm [tcl::tm::path list]
+    foreach path $oldTm {
+        tcl::tm::path remove $path
+    }
+    tcl::tm::path add [file join $ZipMountPoint auto0 modules]
+} -body {
+    set i [safe::interpCreate -accessPath [list $tcl_library]]
+
+    # Inspect.
+    set confA [safe::interpConfigure $i]
+    set modsA [interp eval $i {tcl::tm::path list}]
+    set path0 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
+    set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
+    set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod2]]
+
+    # Force the interpreter to acquire pkg data which will soon become stale.
+    catch {interp eval $i {package require NOEXIST}}
+    catch {interp eval $i {package require mod1::NOEXIST}}
+    catch {interp eval $i {package require mod2::NOEXIST}}
+
+    # Add to access path.
+    # This injects more tokens, pushing modules to higher token numbers.
+    safe::interpConfigure $i -accessPath [list $tcl_library \
+                                           [file join $ZipMountPoint auto0 auto1] \
+                                           [file join $ZipMountPoint auto0 auto2]]
+
+    # Inspect.
+    set confB [safe::interpConfigure $i]
+    set modsB [interp eval $i {tcl::tm::path list}]
+    set path3 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
+    set path4 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
+    set path5 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod2]]
+
+    # Refresh stale pkg data.
+    catch {interp eval $i {package require NOEXIST}}
+    catch {interp eval $i {package require mod1::NOEXIST}}
+    catch {interp eval $i {package require mod2::NOEXIST}}
+
+    # Try to load the packages and run a command from each one.
+    set code0 [catch {interp eval $i {package require test0}} msg0]
+    set code1 [catch {interp eval $i {package require mod1::test1}} msg1]
+    set code2 [catch {interp eval $i {package require mod2::test2}} msg2]
+    set out0  [interp eval $i {test0::try0}]
+    set out1  [interp eval $i {mod1::test1::try1}]
+    set out2  [interp eval $i {mod2::test2::try2}]
+
+    list $path0 $path1 $path2 -- $modsA -- $path3 $path4 $path5 -- $modsB -- \
+         $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $confA -- $confB -- \
+         $out0 $out1 $out2
 
+} -cleanup {
+    tcl::tm::path remove [file join $ZipMountPoint auto0 modules]
+    foreach path [lreverse $oldTm] {
+        tcl::tm::path add $path
+    }
+    safe::interpDelete $i
+} -match glob -result "{\$p(:1:)} {\$p(:2:)} {\$p(:3:)} -- {{\$p(:1:)}} --\
+        {\$p(:3:)} {\$p(:4:)} {\$p(:5:)} -- {{\$p(:3:)}} --\
+        0 0.5 0 1.0 0 2.0 --\
+        {-accessPath {[list $tcl_library \
+                            $ZipMountPoint/auto0/modules \
+                            $ZipMountPoint/auto0/modules/mod1 \
+                            $ZipMountPoint/auto0/modules/mod2]}\
+        -statics 1 -nested 0 -deleteHook {}} --\
+        {-accessPath {[list $tcl_library \
+                            $ZipMountPoint/auto0/auto1 \
+                            $ZipMountPoint/auto0/auto2 \
+                            $ZipMountPoint/auto0/modules \
+                            $ZipMountPoint/auto0/modules/mod1 \
+                            $ZipMountPoint/auto0/modules/mod2]}\
+        -statics 1 -nested 0 -deleteHook {}} --\
+        res0 res1 res2"
 test safe-9.24 {interpConfigure change the access path; check module loading; stale data case 2 (worst case)} -setup {
     set oldTm [tcl::tm::path list]
     foreach path $oldTm {
@@ -1270,7 +1873,73 @@ test safe-9.24 {interpConfigure change the access path; check module loading; st
 			    $TestsDir/auto0/modules/mod2]}\
         -statics 1 -nested 0 -deleteHook {}} --\
         res0 res1 res2"
+test safe-9.24z {interpConfigure change the access path; check module loading; stale data case 2 (worst case); zipfs} -setup {
+    set oldTm [tcl::tm::path list]
+    foreach path $oldTm {
+        tcl::tm::path remove $path
+    }
+    tcl::tm::path add [file join $ZipMountPoint auto0 modules]
+} -body {
+    set i [safe::interpCreate -accessPath [list $tcl_library]]
+
+    # Inspect.
+    set confA [safe::interpConfigure $i]
+    set modsA [interp eval $i {tcl::tm::path list}]
+    set path0 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
+    set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
+    set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod2]]
+
+    # Force the interpreter to acquire pkg data which will soon become stale.
+    catch {interp eval $i {package require NOEXIST}}
+    catch {interp eval $i {package require mod1::NOEXIST}}
+    catch {interp eval $i {package require mod2::NOEXIST}}
+
+    # Add to access path.
+    # This injects more tokens, pushing modules to higher token numbers.
+    safe::interpConfigure $i -accessPath [list $tcl_library \
+                                           [file join $ZipMountPoint auto0 auto1] \
+                                           [file join $ZipMountPoint auto0 auto2]]
+
+    # Inspect.
+    set confB [safe::interpConfigure $i]
+    set modsB [interp eval $i {tcl::tm::path list}]
+    set path3 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
+    set path4 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
+    set path5 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod2]]
+
+    # Try to load the packages and run a command from each one.
+    set code0 [catch {interp eval $i {package require test0}} msg0]
+    set code1 [catch {interp eval $i {package require mod1::test1}} msg1]
+    set code2 [catch {interp eval $i {package require mod2::test2}} msg2]
+    set out0  [interp eval $i {test0::try0}]
+    set out1  [interp eval $i {mod1::test1::try1}]
+    set out2  [interp eval $i {mod2::test2::try2}]
 
+    list $path0 $path1 $path2 -- $modsA -- $path3 $path4 $path5 -- $modsB -- \
+         $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $confA -- $confB -- \
+         $out0 $out1 $out2
+} -cleanup {
+    tcl::tm::path remove [file join $ZipMountPoint auto0 modules]
+    foreach path [lreverse $oldTm] {
+        tcl::tm::path add $path
+    }
+    safe::interpDelete $i
+} -match glob -result "{\$p(:1:)} {\$p(:2:)} {\$p(:3:)} -- {{\$p(:1:)}} --\
+        {\$p(:3:)} {\$p(:4:)} {\$p(:5:)} -- {{\$p(:3:)}} --\
+        0 0.5 0 1.0 0 2.0 --\
+        {-accessPath {[list $tcl_library \
+                            $ZipMountPoint/auto0/modules \
+                            $ZipMountPoint/auto0/modules/mod1 \
+                            $ZipMountPoint/auto0/modules/mod2]}\
+        -statics 1 -nested 0 -deleteHook {}} --\
+        {-accessPath {[list $tcl_library \
+			    $ZipMountPoint/auto0/auto1 \
+			    $ZipMountPoint/auto0/auto2 \
+			    $ZipMountPoint/auto0/modules \
+			    $ZipMountPoint/auto0/modules/mod1 \
+			    $ZipMountPoint/auto0/modules/mod2]}\
+        -statics 1 -nested 0 -deleteHook {}} --\
+        res0 res1 res2"
 
 catch {teststaticpkg Safepkg1 0 0}
 test safe-10.1 {testing statics loading} -constraints TcltestPackage -setup {
@@ -1694,9 +2363,12 @@ test safe-16.4 {Bug 3529949: defang ~user in globs} -setup {
 } -cleanup {
     safe::interpDelete $i
 } -result {}
-
+
+puts stderr [interp slaves]
+
 set ::auto_path $saveAutoPath
-unset pkgOptErrMsg pkgOptDir pkgJarDir saveAutoPath TestsDir
+zipfs unmount ${ZipMountPoint}
+unset pkgOptErrMsg pkgOptDir pkgJarDir saveAutoPath TestsDir ZipMountPoint
 # cleanup
 ::tcltest::cleanupTests
 return
-- 
cgit v0.12


From 5e45a1d39a08b7172d872e54720fa033bafc4dd9 Mon Sep 17 00:00:00 2001
From: kjnash <k.j.nash@usa.net>
Date: Tue, 14 Jul 2020 15:45:31 +0000
Subject: Remove diagnostic puts

---
 tests/safe.test | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/tests/safe.test b/tests/safe.test
index 98584fd..6838201 100644
--- a/tests/safe.test
+++ b/tests/safe.test
@@ -2363,9 +2363,7 @@ test safe-16.4 {Bug 3529949: defang ~user in globs} -setup {
 } -cleanup {
     safe::interpDelete $i
 } -result {}
-
-puts stderr [interp slaves]
-
+
 set ::auto_path $saveAutoPath
 zipfs unmount ${ZipMountPoint}
 unset pkgOptErrMsg pkgOptDir pkgJarDir saveAutoPath TestsDir ZipMountPoint
-- 
cgit v0.12


From d44da35f2c661a2a7ae6bfd016778f34d65162b0 Mon Sep 17 00:00:00 2001
From: kjnash <k.j.nash@usa.net>
Date: Thu, 16 Jul 2020 12:17:59 +0000
Subject: Remove diagnostic spaces

---
 tests/safe.test | 34 +++++++++++++++++-----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/tests/safe.test b/tests/safe.test
index 6cbcdf8..56cf013 100644
--- a/tests/safe.test
+++ b/tests/safe.test
@@ -530,7 +530,7 @@ test safe-7.1opt {tests that everything works at high level, uses pkg opt} -setu
 } -cleanup {
     safe::interpDelete $i
 } -match glob -result 0.4.*
- test safe-7.2 {tests specific path and interpFind/AddToAccessPath} -setup {
+test safe-7.2 {tests specific path and interpFind/AddToAccessPath} -setup {
 } -body {
     set i [safe::interpCreate -nostat -nested 1 -accessPath [list [info library]]]
     # should not add anything (p0)
@@ -587,7 +587,7 @@ test safe-7.2opt {tests specific path and interpFind/AddToAccessPath, uses pkg o
 } -cleanup {
 } -match glob -result {{$p(:0:)} {$p(:*:)} -- 1 {can't find package opt} --\
         {TCLLIB */dummy/unixlike/test/path} -- {}}
- test safe-7.3 {check that safe subinterpreters work} {
+test safe-7.3 {check that safe subinterpreters work} {
     set g [interp slaves]
     if {$g ne {}} {
         append g { -- residue of an earlier test}
@@ -600,7 +600,7 @@ test safe-7.2opt {tests specific path and interpFind/AddToAccessPath, uses pkg o
     set j [safe::interpCreate [list $i x]]
     list $g $h [interp eval $j {join {o k} ""}] [safe::interpDelete $i] [interp exists $j] [info vars ::safe::S*]
 } {{} {} ok {} 0 {}}
- test safe-7.4 {tests specific path and positive search} -setup {
+test safe-7.4 {tests specific path and positive search} -setup {
 } -body {
     set i [safe::interpCreate -nostat -nested 1 -accessPath [list [info library]]]
     # should not add anything (p0)
@@ -831,7 +831,7 @@ test safe-9.4 {dual specification of statics} {
 test safe-9.5 {dual specification of nested} -returnCodes error -body {
     safe::interpCreate -nested 0 -nestedload
 } -result {conflicting values given for -nested and -nestedLoadOk}
- test safe-9.6 {interpConfigure widget like behaviour} -body {
+test safe-9.6 {interpConfigure widget like behaviour} -body {
    # this test shall work, don't try to "fix it" unless you *really* know what
    # you are doing (ie you are me :p) -- dl
    list [set i [safe::interpCreate \
@@ -850,7 +850,7 @@ test safe-9.5 {dual specification of nested} -returnCodes error -body {
 	 safe::interpConfigure $i]
 } -match glob -result {{-accessPath * -statics 0 -nested 1 -deleteHook {foo bar}} {-accessPath *} {-nested 1} {-statics 0} {-deleteHook {foo bar}} {-accessPath * -statics 1 -nested 1 -deleteHook {foo bar}} {-accessPath * -statics 0 -nested 0 -deleteHook toto}}
 
- test safe-9.7 {interpConfigure widget like behaviour (demystified)} -body {
+test safe-9.7 {interpConfigure widget like behaviour (demystified)} -body {
    # this test shall work, believed equivalent to 9.6
     set i [safe::interpCreate \
 	    -noStatics \
@@ -874,7 +874,7 @@ test safe-9.5 {dual specification of nested} -returnCodes error -body {
     safe::interpDelete $i
 } -match glob -result {{-accessPath * -statics 0 -nested 1 -deleteHook {foo bar}} {-accessPath *} {-nested 1} {-statics 0} {-deleteHook {foo bar}} {-accessPath * -statics 1 -nested 1 -deleteHook {foo bar}} {-accessPath * -statics 0 -nested 0 -deleteHook toto}}
 
- test safe-9.8 {interpConfigure change the access path; tclIndex commands unaffected by token rearrangement (dummy test of doreset)} -setup {
+test safe-9.8 {interpConfigure change the access path; tclIndex commands unaffected by token rearrangement (dummy test of doreset)} -setup {
 } -body {
     set i [safe::interpCreate -accessPath [list $tcl_library \
                                             [file join $TestsDir auto0 auto1] \
@@ -956,7 +956,7 @@ test safe-9.8z {interpConfigure change the access path; tclIndex commands unaffe
         -statics 1 -nested 0 -deleteHook {}}\
         {-accessPath {[list $tcl_library $ZipMountPoint/auto0/auto2 $ZipMountPoint/auto0/auto1]*}\
         -statics 1 -nested 0 -deleteHook {}}"
- test safe-9.9 {interpConfigure change the access path; tclIndex commands unaffected by token rearrangement (actual test of doreset)} -setup {
+test safe-9.9 {interpConfigure change the access path; tclIndex commands unaffected by token rearrangement (actual test of doreset)} -setup {
 } -body {
     set i [safe::interpCreate -accessPath [list $tcl_library \
                                             [file join $TestsDir auto0 auto1] \
@@ -1035,7 +1035,7 @@ test safe-9.9z {interpConfigure change the access path; tclIndex commands unaffe
         -statics 1 -nested 0 -deleteHook {}}\
         {-accessPath {[list $tcl_library $ZipMountPoint/auto0/auto2 $ZipMountPoint/auto0/auto1]*}\
         -statics 1 -nested 0 -deleteHook {}}"
- test safe-9.10 {interpConfigure change the access path; pkgIndex.tcl packages unaffected by token rearrangement} -setup {
+test safe-9.10 {interpConfigure change the access path; pkgIndex.tcl packages unaffected by token rearrangement} -setup {
 } -body {
     # For complete correspondence to safe-9.10opt, include auto0 in access path.
     set i [safe::interpCreate -accessPath [list $tcl_library \
@@ -1169,7 +1169,7 @@ test safe-9.10opt {interpConfigure change the access path; pkgIndex.tcl packages
         -statics 1 -nested 0 -deleteHook {}}\
         {-accessPath {[list $tcl_library $tcl_library/$pkgJarDir $tcl_library/$pkgOptDir]*}\
         -statics 1 -nested 0 -deleteHook {}} 0 0 0 example.com"
- test safe-9.11 {interpConfigure change the access path; pkgIndex.tcl packages unaffected by token rearrangement, 9.10 without path auto0} -setup {
+test safe-9.11 {interpConfigure change the access path; pkgIndex.tcl packages unaffected by token rearrangement, 9.10 without path auto0} -setup {
 } -body {
     set i [safe::interpCreate -accessPath [list $tcl_library \
                                             [file join $TestsDir auto0 auto1] \
@@ -1250,7 +1250,7 @@ test safe-9.11z {interpConfigure change the access path; pkgIndex.tcl packages u
         {-accessPath {[list $tcl_library $ZipMountPoint/auto0/auto2 $ZipMountPoint/auto0/auto1]*}\
         -statics 1 -nested 0 -deleteHook {}}\
         0 OK1 0 OK2"
- test safe-9.12 {interpConfigure change the access path; pkgIndex.tcl packages fail if directory de-listed} -setup {
+test safe-9.12 {interpConfigure change the access path; pkgIndex.tcl packages fail if directory de-listed} -setup {
 } -body {
     set i [safe::interpCreate -accessPath [list $tcl_library \
                                             [file join $TestsDir auto0 auto1] \
@@ -1351,7 +1351,7 @@ test safe-9.12opt {interpConfigure change the access path; pkgIndex.tcl packages
         {-accessPath {[list $tcl_library $tcl_library/$pkgOptDir $tcl_library/$pkgJarDir]*}\
         -statics 1 -nested 0 -deleteHook {}}\
         {-accessPath {[list $tcl_library]*} -statics 1 -nested 0 -deleteHook {}}"
- test safe-9.20 {check module loading} -setup {
+test safe-9.20 {check module loading} -setup {
     set oldTm [tcl::tm::path list]
     foreach path $oldTm {
         tcl::tm::path remove $path
@@ -1436,7 +1436,7 @@ test safe-9.20z {check module loading; zipfs} -setup {
                         $ZipMountPoint/auto0/modules/mod2]*}\
         -statics 1 -nested 0 -deleteHook {}} --\
         res0 res1 res2"
- test safe-9.21 {interpConfigure change the access path; check module loading; stale data case 1} -setup {
+test safe-9.21 {interpConfigure change the access path; check module loading; stale data case 1} -setup {
     set oldTm [tcl::tm::path list]
     foreach path $oldTm {
         tcl::tm::path remove $path
@@ -1565,7 +1565,7 @@ test safe-9.21z {interpConfigure change the access path; check module loading; s
                         $ZipMountPoint/auto0/modules/mod2]}\
         -statics 1 -nested 0 -deleteHook {}} --\
         res0 res1 res2"
- test safe-9.22 {interpConfigure change the access path; check module loading; stale data case 0} -setup {
+test safe-9.22 {interpConfigure change the access path; check module loading; stale data case 0} -setup {
     set oldTm [tcl::tm::path list]
     foreach path $oldTm {
         tcl::tm::path remove $path
@@ -1684,7 +1684,7 @@ test safe-9.22z {interpConfigure change the access path; check module loading; s
                             $ZipMountPoint/auto0/modules/mod2]}\
         -statics 1 -nested 0 -deleteHook {}} --\
         res0 res1 res2"
- test safe-9.23 {interpConfigure change the access path; check module loading; stale data case 3} -setup {
+test safe-9.23 {interpConfigure change the access path; check module loading; stale data case 3} -setup {
     set oldTm [tcl::tm::path list]
     foreach path $oldTm {
         tcl::tm::path remove $path
@@ -1825,7 +1825,7 @@ test safe-9.23z {interpConfigure change the access path; check module loading; s
                             $ZipMountPoint/auto0/modules/mod2]}\
         -statics 1 -nested 0 -deleteHook {}} --\
         res0 res1 res2"
- test safe-9.24 {interpConfigure change the access path; check module loading; stale data case 2 (worst case)} -setup {
+test safe-9.24 {interpConfigure change the access path; check module loading; stale data case 2 (worst case)} -setup {
     set oldTm [tcl::tm::path list]
     foreach path $oldTm {
         tcl::tm::path remove $path
@@ -2239,7 +2239,7 @@ test safe-13.6 {as 13.4 but test silent failure when result is outside access_pa
     safe::interpDelete $i
     removeDirectory $testdir
 } -result {}
- test safe-13.7 {mimic the glob call by tclPkgUnknown in a safe interpreter [Bug 2964715]} -setup {
+test safe-13.7 {mimic the glob call by tclPkgUnknown in a safe interpreter [Bug 2964715]} -setup {
     set i [safe::interpCreate]
     buildEnvironment pkgIndex.tcl
 } -body {
@@ -2251,7 +2251,7 @@ test safe-13.6 {as 13.4 but test silent failure when result is outside access_pa
     safe::interpDelete $i
     removeDirectory $testdir
 } -result {EXPECTED/deletemetoo/pkgIndex.tcl}
- test safe-13.7a {mimic the glob call by tclPkgUnknown in a safe interpreter with multiple subdirectories} -setup {
+test safe-13.7a {mimic the glob call by tclPkgUnknown in a safe interpreter with multiple subdirectories} -setup {
     set i [safe::interpCreate]
     buildEnvironment2 pkgIndex.tcl
 } -body {
-- 
cgit v0.12


From 18560d970e2d150d0082bd99455bae5c8caa238a Mon Sep 17 00:00:00 2001
From: kjnash <k.j.nash@usa.net>
Date: Thu, 16 Jul 2020 15:47:39 +0000
Subject: Bugfix tests/safe.test (as in safe-bugfixes-8-6).  Harden tests
 safe-9.20z to safe-9.24z against indeterminate order of glob matches.  Audit
 use of glob and tcl::tm in modified tests for cases with multiple matches. 
 Simplify test comparison patterns.

---
 tests/safe.test | 322 +++++++++++++++++++++++++-------------------------------
 1 file changed, 145 insertions(+), 177 deletions(-)

diff --git a/tests/safe.test b/tests/safe.test
index 56cf013..4195ebb 100644
--- a/tests/safe.test
+++ b/tests/safe.test
@@ -80,8 +80,10 @@ set TestsDir [file normalize [file dirname [info script]]]
 set ZipMountPoint [zipfs root]auto-files
 zipfs mount $ZipMountPoint [file join $TestsDir auto-files.zip]
 
-set TestsDir [file normalize [file dirname [info script]]]
-set PathMapp [list $tcl_library TCLLIB $TestsDir TESTSDIR]
+set PathMapp {}
+lappend PathMapp [file join [info library] $pkgOptDir] TCLLIB/OPTDIR
+lappend PathMapp [file join [info library] $pkgJarDir] TCLLIB/JARDIR
+lappend PathMapp $tcl_library TCLLIB $TestsDir TESTSDIR $ZipMountPoint ZIPDIR
 
 proc mapList {map listIn} {
     set listOut {}
@@ -338,7 +340,6 @@ test safe-7.0cz {example pkgIndex.tcl packages, test in master interpreter, chil
     set code4 [catch {package require SafeTestPackage2} msg4]
     set code5 [catch HeresPackage1 msg5]
     set code6 [catch HeresPackage2 msg6]
-
     list $code3 $msg3 $code4 $msg4 $code5 $msg5 $code6 $msg6
 } -cleanup {
     set ::auto_path $tmpAutoPath
@@ -376,7 +377,6 @@ test safe-7.0dz {example pkgIndex.tcl packages, test in master interpreter, main
     set code4 [catch {package require SafeTestPackage2} msg4]
     set code5 [catch HeresPackage1 msg5]
     set code6 [catch HeresPackage2 msg6]
-
     list $code3 $msg3 $code4 $msg4 $code5 $msg5 $code6 $msg6
 } -cleanup {
     set ::auto_path $tmpAutoPath
@@ -426,7 +426,6 @@ test safe-7.0ez {example modules packages, test in master interpreter, replace p
     set out0  [test0::try0]
     set out1  [mod1::test1::try1]
     set out2  [mod2::test2::try2]
-
     list $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $out0 $out1 $out2
 } -cleanup {
     tcl::tm::path remove [file join $ZipMountPoint auto0 modules]
@@ -469,7 +468,6 @@ test safe-7.0fz {example modules packages, test in master interpreter, append to
     set out0  [test0::try0]
     set out1  [mod1::test1::try1]
     set out2  [mod2::test2::try2]
-
     list $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $out0 $out1 $out2
 } -cleanup {
     tcl::tm::path remove [file join $ZipMountPoint auto0 modules]
@@ -559,17 +557,17 @@ test safe-7.2z {tests specific path and interpFind/AddToAccessPath; zipfs} -setu
     set token2 [safe::interpAddToAccessPath $i "/dummy/unixlike/test/path"]
     # should add as p* (not p2 if master has a module path)
     set token3 [safe::interpAddToAccessPath $i [file join $TestsDir auto0]]
+    set confA [safe::interpConfigure $i]
+    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
     # an error shall occur (SafeTestPackage1 is not anymore in the secure 0-level
     # provided deep path)
-    list $token1 $token2 $token3 \
-	    [catch {interp eval $i {package require SafeTestPackage1}} msg] $msg \
-	    [safe::interpConfigure $i]\
-	    [safe::interpDelete $i]
-} -cleanup {
-} -match glob -result "{\$p(:0:)} {\$p(:*:)} {\$p(:*:)} 1\
-        {can't find package SafeTestPackage1}\
-        {-accessPath {[list $tcl_library */dummy/unixlike/test/path $TestsDir/auto0]}\
-        -statics 0 -nested 1 -deleteHook {}} {}"
+    list $token1 $token2 $token3 -- \
+            [catch {interp eval $i {package require SafeTestPackage1}} msg] $msg -- \
+            $mappA -- [safe::interpDelete $i]
+} -cleanup {
+} -match glob -result {{$p(:0:)} {$p(:*:)} {$p(:*:)} --\
+        1 {can't find package SafeTestPackage1} --\
+        {TCLLIB */dummy/unixlike/test/path TESTSDIR/auto0} -- {}}
 test safe-7.2opt {tests specific path and interpFind/AddToAccessPath, uses pkg opt} -setup {
 } -body {
     set i [safe::interpCreate -nostat -nested 1 -accessPath [list [info library]]]
@@ -625,17 +623,17 @@ test safe-7.4z {tests specific path and positive search; zipfs} -setup {
     set token1 [safe::interpAddToAccessPath $i [info library]]
     # should add as p* (not p1 if master has a module path)
     set token2 [safe::interpAddToAccessPath $i [file join $TestsDir auto0 auto1]]
-    # this time, unlike test safe-7.2z, SafeTestPackage1 should be found
-    list $token1 $token2 \
-	    [catch {interp eval $i {package require SafeTestPackage1}} msg] $msg \
-	    [safe::interpConfigure $i]\
-	    [safe::interpDelete $i]
+    set confA [safe::interpConfigure $i]
+    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
+    # this time, unlike test safe-7.2, SafeTestPackage1 should be found
+    list $token1 $token2 -- \
+	    [catch {interp eval $i {package require SafeTestPackage1}} msg] $msg -- \
+	    $mappA -- [safe::interpDelete $i]
     # Note that the glob match elides directories (those from the module path)
     # other than the first and last in the access path.
 } -cleanup {
-} -match glob -result "{\$p(:0:)} {\$p(:*:)} 0 1.2.3\
-        {-accessPath {[list $tcl_library * $TestsDir/auto0/auto1]}\
-        -statics 0 -nested 1 -deleteHook {}} {}"
+} -match glob -result {{$p(:0:)} {$p(:*:)} -- 0 1.2.3 --\
+        {TCLLIB * TESTSDIR/auto0/auto1} -- {}}
 test safe-7.4opt {tests specific path and positive search, uses pkg opt} -setup {
 } -body {
     set i [safe::interpCreate -nostat -nested 1 -accessPath [list [info library]]]
@@ -643,17 +641,17 @@ test safe-7.4opt {tests specific path and positive search, uses pkg opt} -setup
     set token1 [safe::interpAddToAccessPath $i [info library]]
     # should add as p* (not p1 if master has a module path)
     set token2 [safe::interpAddToAccessPath $i [file join [info library] $pkgOptDir]]
+    set confA [safe::interpConfigure $i]
+    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
     # this time, unlike test safe-7.2opt, opt should be found
-    list $token1 $token2 \
-	    [catch {interp eval $i {package require opt}} msg] $msg \
-	    [safe::interpConfigure $i]\
-	    [safe::interpDelete $i]
+    list $token1 $token2 -- \
+            [catch {interp eval $i {package require opt}} msg] $msg -- \
+            $mappA -- [safe::interpDelete $i]
     # Note that the glob match elides directories (those from the module path)
     # other than the first and last in the access path.
 } -cleanup {
-} -match glob -result "{\$p(:0:)} {\$p(:*:)} 0 0.4.*\
-        {-accessPath {[list $tcl_library *$tcl_library/$pkgOptDir]}\
-        -statics 0 -nested 1 -deleteHook {}} {}"
+} -match glob -result {{$p(:0:)} {$p(:*:)} -- 0 0.4.* --\
+        {TCLLIB * TCLLIB/OPTDIR} -- {}}
 
 # test source control on file name
 set i "a"
@@ -920,9 +918,9 @@ test safe-9.8z {interpConfigure change the access path; tclIndex commands unaffe
     set i [safe::interpCreate -accessPath [list $tcl_library \
                                             [file join $ZipMountPoint auto0 auto1] \
                                             [file join $ZipMountPoint auto0 auto2]]]
-
     # Inspect.
     set confA [safe::interpConfigure $i]
+    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
     set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
     set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
 
@@ -938,9 +936,9 @@ test safe-9.8z {interpConfigure change the access path; tclIndex commands unaffe
     safe::interpConfigure $i -accessPath [list $tcl_library \
                                            [file join $ZipMountPoint auto0 auto2] \
                                            [file join $ZipMountPoint auto0 auto1]]
-
     # Inspect.
     set confB [safe::interpConfigure $i]
+    set mappB [mapList $PathMapp [dict get $confB -accessPath]]
     set path3 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
     set path4 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
 
@@ -948,14 +946,13 @@ test safe-9.8z {interpConfigure change the access path; tclIndex commands unaffe
     set code3 [catch {interp eval $i {report1}} msg3]
     set code4 [catch {interp eval $i {report2}} msg4]
 
-    list $path1 $path2 $path3 $path4 $code3 $msg3 $code4 $msg4 $confA $confB
+    list $path1 $path2 -- $path3 $path4 -- $code3 $msg3 $code4 $msg4 -- $mappA -- $mappB
 } -cleanup {
     safe::interpDelete $i
-} -match glob -result "{\$p(:1:)} {\$p(:2:)} {\$p(:2:)} {\$p(:1:)} 0 ok1 0 ok2\
-        {-accessPath {[list $tcl_library $ZipMountPoint/auto0/auto1 $ZipMountPoint/auto0/auto2]*}\
-        -statics 1 -nested 0 -deleteHook {}}\
-        {-accessPath {[list $tcl_library $ZipMountPoint/auto0/auto2 $ZipMountPoint/auto0/auto1]*}\
-        -statics 1 -nested 0 -deleteHook {}}"
+} -match glob -result {{$p(:1:)} {$p(:2:)} -- {$p(:2:)} {$p(:1:)} -- 0 ok1 0 ok2 --\
+        {TCLLIB ZIPDIR/auto0/auto1 ZIPDIR/auto0/auto2*} --\
+        {TCLLIB ZIPDIR/auto0/auto2 ZIPDIR/auto0/auto1*}}
+
 test safe-9.9 {interpConfigure change the access path; tclIndex commands unaffected by token rearrangement (actual test of doreset)} -setup {
 } -body {
     set i [safe::interpCreate -accessPath [list $tcl_library \
@@ -1001,9 +998,9 @@ test safe-9.9z {interpConfigure change the access path; tclIndex commands unaffe
     set i [safe::interpCreate -accessPath [list $tcl_library \
                                             [file join $ZipMountPoint auto0 auto1] \
                                             [file join $ZipMountPoint auto0 auto2]]]
-
     # Inspect.
     set confA [safe::interpConfigure $i]
+    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
     set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
     set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
 
@@ -1017,9 +1014,9 @@ test safe-9.9z {interpConfigure change the access path; tclIndex commands unaffe
     safe::interpConfigure $i -accessPath [list $tcl_library \
                                            [file join $ZipMountPoint auto0 auto2] \
                                            [file join $ZipMountPoint auto0 auto1]]
-
     # Inspect.
     set confB [safe::interpConfigure $i]
+    set mappB [mapList $PathMapp [dict get $confB -accessPath]]
     set path3 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
     set path4 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
 
@@ -1027,14 +1024,13 @@ test safe-9.9z {interpConfigure change the access path; tclIndex commands unaffe
     set code3 [catch {interp eval $i {report1}} msg3]
     set code4 [catch {interp eval $i {report2}} msg4]
 
-    list $path1 $path2 $path3 $path4 $code3 $msg3 $code4 $msg4 $confA $confB
+    list $path1 $path2 -- $path3 $path4 -- $code3 $msg3 $code4 $msg4 -- $mappA -- $mappB
 } -cleanup {
     safe::interpDelete $i
-} -match glob -result "{\$p(:1:)} {\$p(:2:)} {\$p(:2:)} {\$p(:1:)} 0 ok1 0 ok2\
-        {-accessPath {[list $tcl_library $ZipMountPoint/auto0/auto1 $ZipMountPoint/auto0/auto2]*}\
-        -statics 1 -nested 0 -deleteHook {}}\
-        {-accessPath {[list $tcl_library $ZipMountPoint/auto0/auto2 $ZipMountPoint/auto0/auto1]*}\
-        -statics 1 -nested 0 -deleteHook {}}"
+} -match glob -result {{$p(:1:)} {$p(:2:)} -- {$p(:2:)} {$p(:1:)} --\
+        0 ok1 0 ok2 --\
+        {TCLLIB ZIPDIR/auto0/auto1 ZIPDIR/auto0/auto2*} --\
+        {TCLLIB ZIPDIR/auto0/auto2 ZIPDIR/auto0/auto1*}}
 test safe-9.10 {interpConfigure change the access path; pkgIndex.tcl packages unaffected by token rearrangement} -setup {
 } -body {
     # For complete correspondence to safe-9.10opt, include auto0 in access path.
@@ -1081,7 +1077,6 @@ test safe-9.10 {interpConfigure change the access path; pkgIndex.tcl packages un
         {TCLLIB TESTSDIR/auto0 TESTSDIR/auto0/auto1 TESTSDIR/auto0/auto2*} --\
         {TCLLIB TESTSDIR/auto0 TESTSDIR/auto0/auto2 TESTSDIR/auto0/auto1*} --\
         0 OK1 0 OK2}
-
 test safe-9.10z {interpConfigure change the access path; pkgIndex.tcl packages unaffected by token rearrangement; zipfs} -setup {
 } -body {
     # For complete correspondence to safe-9.10opt, include auto0 in access path.
@@ -1089,9 +1084,9 @@ test safe-9.10z {interpConfigure change the access path; pkgIndex.tcl packages u
                                             [file join $ZipMountPoint auto0] \
                                             [file join $ZipMountPoint auto0 auto1] \
                                             [file join $ZipMountPoint auto0 auto2]]]
-
     # Inspect.
     set confA [safe::interpConfigure $i]
+    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
     set path0 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0]]
     set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
     set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
@@ -1106,9 +1101,9 @@ test safe-9.10z {interpConfigure change the access path; pkgIndex.tcl packages u
                                            [file join $ZipMountPoint auto0] \
                                            [file join $ZipMountPoint auto0 auto2] \
                                            [file join $ZipMountPoint auto0 auto1]]
-
     # Inspect.
     set confB [safe::interpConfigure $i]
+    set mappB [mapList $PathMapp [dict get $confB -accessPath]]
     set path3 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
     set path4 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
 
@@ -1118,25 +1113,22 @@ test safe-9.10z {interpConfigure change the access path; pkgIndex.tcl packages u
     set code5 [catch {interp eval $i {HeresPackage1}} msg5 opts5]
     set code6 [catch {interp eval $i {HeresPackage2}} msg6 opts6]
 
-    list $path1 $path2 $path3 $path4 $code3 $msg3 $code4 $msg4 $confA $confB \
-         $code5 $msg5 $code6 $msg6
-
+    list $path1 $path2 -- $path3 $path4 -- $code3 $msg3 $code4 $msg4 -- \
+         $mappA -- $mappB -- $code5 $msg5 $code6 $msg6
 } -cleanup {
     safe::interpDelete $i
-} -match glob -result "{\$p(:2:)} {\$p(:3:)} {\$p(:3:)} {\$p(:2:)} 0 1.2.3 0 2.3.4\
-        {-accessPath {[list $tcl_library $ZipMountPoint/auto0 $ZipMountPoint/auto0/auto1 $ZipMountPoint/auto0/auto2]*}\
-        -statics 1 -nested 0 -deleteHook {}}\
-        {-accessPath {[list $tcl_library $ZipMountPoint/auto0 $ZipMountPoint/auto0/auto2 $ZipMountPoint/auto0/auto1]*}\
-        -statics 1 -nested 0 -deleteHook {}}\
-        0 OK1 0 OK2"
+} -match glob -result {{$p(:2:)} {$p(:3:)} -- {$p(:3:)} {$p(:2:)} -- 0 1.2.3 0 2.3.4 --\
+        {TCLLIB ZIPDIR/auto0 ZIPDIR/auto0/auto1 ZIPDIR/auto0/auto2*} --\
+        {TCLLIB ZIPDIR/auto0 ZIPDIR/auto0/auto2 ZIPDIR/auto0/auto1*} --\
+        0 OK1 0 OK2}
 test safe-9.10opt {interpConfigure change the access path; pkgIndex.tcl packages unaffected by token rearrangement, uses pkg opt and tcl::idna} -setup {
 } -body {
     set i [safe::interpCreate -accessPath [list $tcl_library \
                                             [file join $tcl_library $pkgOptDir] \
                                             [file join $tcl_library $pkgJarDir]]]
-
     # Inspect.
     set confA [safe::interpConfigure $i]
+    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
     set path1 [::safe::interpFindInAccessPath $i [file join $tcl_library $pkgOptDir]]
     set path2 [::safe::interpFindInAccessPath $i [file join $tcl_library $pkgJarDir]]
 
@@ -1148,9 +1140,9 @@ test safe-9.10opt {interpConfigure change the access path; pkgIndex.tcl packages
     safe::interpConfigure $i -accessPath [list $tcl_library \
                                            [file join $tcl_library $pkgJarDir] \
                                            [file join $tcl_library $pkgOptDir]]
-
     # Inspect.
     set confB [safe::interpConfigure $i]
+    set mappB [mapList $PathMapp [dict get $confB -accessPath]]
     set path3 [::safe::interpFindInAccessPath $i [file join $tcl_library $pkgOptDir]]
     set path4 [::safe::interpFindInAccessPath $i [file join $tcl_library $pkgJarDir]]
 
@@ -1160,15 +1152,14 @@ test safe-9.10opt {interpConfigure change the access path; pkgIndex.tcl packages
     set code5 [catch {interp eval $i {::tcl::Lempty {a list}}} msg5]
     set code6 [catch {interp eval $i {::tcl::idna::IDNAencode example.com}} msg6]
 
-    list $path1 $path2 $path3 $path4 $code3 $msg3 $code4 $msg4 \
-         $confA $confB $code5 $msg5 $code6 $msg6
+    list $path1 $path2 -- $path3 $path4 -- $code3 $msg3 $code4 $msg4 -- \
+         $mappA -- $mappB -- $code5 $msg5 $code6 $msg6
 } -cleanup {
     safe::interpDelete $i
-} -match glob -result "{\$p(:1:)} {\$p(:2:)} {\$p(:2:)} {\$p(:1:)} 0 1.* 0 0.4.*\
-        {-accessPath {[list $tcl_library $tcl_library/$pkgOptDir $tcl_library/$pkgJarDir]*}\
-        -statics 1 -nested 0 -deleteHook {}}\
-        {-accessPath {[list $tcl_library $tcl_library/$pkgJarDir $tcl_library/$pkgOptDir]*}\
-        -statics 1 -nested 0 -deleteHook {}} 0 0 0 example.com"
+} -match glob -result {{$p(:1:)} {$p(:2:)} -- {$p(:2:)} {$p(:1:)} -- 0 1.* 0 0.4.* --\
+        {TCLLIB TCLLIB/OPTDIR TCLLIB/JARDIR*} --\
+        {TCLLIB TCLLIB/JARDIR TCLLIB/OPTDIR*} --\
+        0 0 0 example.com}
 test safe-9.11 {interpConfigure change the access path; pkgIndex.tcl packages unaffected by token rearrangement, 9.10 without path auto0} -setup {
 } -body {
     set i [safe::interpCreate -accessPath [list $tcl_library \
@@ -1215,9 +1206,9 @@ test safe-9.11z {interpConfigure change the access path; pkgIndex.tcl packages u
     set i [safe::interpCreate -accessPath [list $tcl_library \
                                             [file join $ZipMountPoint auto0 auto1] \
                                             [file join $ZipMountPoint auto0 auto2]]]
-
     # Inspect.
     set confA [safe::interpConfigure $i]
+    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
     set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
     set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
 
@@ -1228,9 +1219,9 @@ test safe-9.11z {interpConfigure change the access path; pkgIndex.tcl packages u
     safe::interpConfigure $i -accessPath [list $tcl_library \
                                            [file join $ZipMountPoint auto0 auto2] \
                                            [file join $ZipMountPoint auto0 auto1]]
-
     # Inspect.
     set confB [safe::interpConfigure $i]
+    set mappB [mapList $PathMapp [dict get $confB -accessPath]]
     set path3 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
     set path4 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
 
@@ -1240,16 +1231,15 @@ test safe-9.11z {interpConfigure change the access path; pkgIndex.tcl packages u
     set code5 [catch {interp eval $i {HeresPackage1}} msg5 opts5]
     set code6 [catch {interp eval $i {HeresPackage2}} msg6 opts6]
 
-    list $path1 $path2 $path3 $path4 $code3 $msg3 $code4 $msg4 $confA $confB \
-         $code5 $msg5 $code6 $msg6
+    list $path1 $path2 -- $path3 $path4 -- $code3 $msg3 $code4 $msg4 -- \
+            $mappA -- $mappB -- $code5 $msg5 $code6 $msg6
 } -cleanup {
     safe::interpDelete $i
-} -match glob -result "{\$p(:1:)} {\$p(:2:)} {\$p(:2:)} {\$p(:1:)} 0 1.2.3 0 2.3.4\
-        {-accessPath {[list $tcl_library $ZipMountPoint/auto0/auto1 $ZipMountPoint/auto0/auto2]*}\
-        -statics 1 -nested 0 -deleteHook {}}\
-        {-accessPath {[list $tcl_library $ZipMountPoint/auto0/auto2 $ZipMountPoint/auto0/auto1]*}\
-        -statics 1 -nested 0 -deleteHook {}}\
-        0 OK1 0 OK2"
+} -match glob -result {{$p(:1:)} {$p(:2:)} -- {$p(:2:)} {$p(:1:)} --\
+        0 1.2.3 0 2.3.4 --\
+        {TCLLIB ZIPDIR/auto0/auto1 ZIPDIR/auto0/auto2*} --\
+        {TCLLIB ZIPDIR/auto0/auto2 ZIPDIR/auto0/auto1*} --\
+        0 OK1 0 OK2}
 test safe-9.12 {interpConfigure change the access path; pkgIndex.tcl packages fail if directory de-listed} -setup {
 } -body {
     set i [safe::interpCreate -accessPath [list $tcl_library \
@@ -1288,9 +1278,9 @@ test safe-9.12z {interpConfigure change the access path; pkgIndex.tcl packages f
     set i [safe::interpCreate -accessPath [list $tcl_library \
                                             [file join $ZipMountPoint auto0 auto1] \
                                             [file join $ZipMountPoint auto0 auto2]]]
-
     # Inspect.
     set confA [safe::interpConfigure $i]
+    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
     set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
     set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
 
@@ -1302,6 +1292,7 @@ test safe-9.12z {interpConfigure change the access path; pkgIndex.tcl packages f
 
     # Inspect.
     set confB [safe::interpConfigure $i]
+    set mappB [mapList $PathMapp [dict get $confB -accessPath]]
     set code4 [catch {::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]} path4]
     set code5 [catch {::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]} path5]
 
@@ -1309,22 +1300,21 @@ test safe-9.12z {interpConfigure change the access path; pkgIndex.tcl packages f
     set code3 [catch {interp eval $i {package require SafeTestPackage1}} msg3]
     set code6 [catch {interp eval $i {package require SafeTestPackage2}} msg6]
 
-    list $path1 $path2 $code4 $path4 $code5 $path5 $code3 $msg3 $code6 $msg6 $confA $confB
+    list $path1 $path2 -- $code4 $path4 -- $code5 $path5 -- $code3 $code6 -- \
+            $mappA -- $mappB
 } -cleanup {
     safe::interpDelete $i
-} -match glob -result "{\$p(:1:)} {\$p(:2:)} 1 {* not found in access path}\
-        1 {* not found in access path} 1 {*} 1 {*}\
-        {-accessPath {[list $tcl_library $ZipMountPoint/auto0/auto1 $ZipMountPoint/auto0/auto2]*}\
-        -statics 1 -nested 0 -deleteHook {}}\
-        {-accessPath {[list $tcl_library]*} -statics 1 -nested 0 -deleteHook {}}"
+} -match glob -result {{$p(:1:)} {$p(:2:)} -- 1 {* not found in access path} --\
+        1 {* not found in access path} -- 1 1 --\
+        {TCLLIB ZIPDIR/auto0/auto1 ZIPDIR/auto0/auto2*} -- {TCLLIB*}}
 test safe-9.12opt {interpConfigure change the access path; pkgIndex.tcl packages fail if directory de-listed, uses pkg opt and tcl::idna} -setup {
 } -body {
     set i [safe::interpCreate -accessPath [list $tcl_library \
                                             [file join $tcl_library $pkgOptDir] \
                                             [file join $tcl_library $pkgJarDir]]]
-
     # Inspect.
     set confA [safe::interpConfigure $i]
+    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
     set path1 [::safe::interpFindInAccessPath $i [file join $tcl_library $pkgOptDir]]
     set path2 [::safe::interpFindInAccessPath $i [file join $tcl_library $pkgJarDir]]
 
@@ -1336,6 +1326,7 @@ test safe-9.12opt {interpConfigure change the access path; pkgIndex.tcl packages
 
     # Inspect.
     set confB [safe::interpConfigure $i]
+    set mappB [mapList $PathMapp [dict get $confB -accessPath]]
     set code4 [catch {::safe::interpFindInAccessPath $i [file join $tcl_library $pkgOptDir]} path4]
     set code5 [catch {::safe::interpFindInAccessPath $i [file join $tcl_library $pkgJarDir]} path5]
 
@@ -1343,14 +1334,13 @@ test safe-9.12opt {interpConfigure change the access path; pkgIndex.tcl packages
     set code3 [catch {interp eval $i {package require opt}} msg3]
     set code6 [catch {interp eval $i {package require tcl::idna}} msg6]
 
-    list $path1 $path2 $code4 $path4 $code5 $path5 $code3 $msg3 $code6 $msg6 $confA $confB
+    list $path1 $path2 -- $code4 $path4 -- $code5 $path5 -- $code3 $code6 -- \
+            $mappA -- $mappB
 } -cleanup {
     safe::interpDelete $i
-} -match glob -result "{\$p(:1:)} {\$p(:2:)} 1 {* not found in access path}\
-        1 {* not found in access path} 1 {*} 1 {*}\
-        {-accessPath {[list $tcl_library $tcl_library/$pkgOptDir $tcl_library/$pkgJarDir]*}\
-        -statics 1 -nested 0 -deleteHook {}}\
-        {-accessPath {[list $tcl_library]*} -statics 1 -nested 0 -deleteHook {}}"
+} -match glob -result {{$p(:1:)} {$p(:2:)} -- 1 {* not found in access path} --\
+        1 {* not found in access path} -- 1 1 --\
+        {TCLLIB TCLLIB/OPTDIR TCLLIB/JARDIR*} -- {TCLLIB*}}
 test safe-9.20 {check module loading} -setup {
     set oldTm [tcl::tm::path list]
     foreach path $oldTm {
@@ -1408,6 +1398,7 @@ test safe-9.20z {check module loading; zipfs} -setup {
 
     # Inspect.
     set confA [safe::interpConfigure $i]
+    set sortA [mapAndSortList $PathMapp [dict get $confA -accessPath]]
     set modsA [interp eval $i {tcl::tm::path list}]
     set path0 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
     set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
@@ -1421,21 +1412,19 @@ test safe-9.20z {check module loading; zipfs} -setup {
     set out1  [interp eval $i {mod1::test1::try1}]
     set out2  [interp eval $i {mod2::test2::try2}]
 
-    list $path0 $path1 $path2 -- $modsA -- \
-         $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $confA -- $out0 $out1 $out2
+    list [lsort [list $path0 $path1 $path2]] -- $modsA -- \
+            $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $sortA -- $out0 $out1 $out2
 } -cleanup {
     tcl::tm::path remove [file join $ZipMountPoint auto0 modules]
     foreach path [lreverse $oldTm] {
         tcl::tm::path add $path
     }
     safe::interpDelete $i
-} -match glob -result "{\$p(:1:)} {\$p(:2:)} {\$p(:3:)} -- {{\$p(:1:)}} --\
+} -match glob -result {{{$p(:1:)} {$p(:2:)} {$p(:3:)}} -- {{$p(:1:)}} --\
         0 0.5 0 1.0 0 2.0 --\
-        {-accessPath {[list $tcl_library $ZipMountPoint/auto0/modules \
-                        $ZipMountPoint/auto0/modules/mod1 \
-                        $ZipMountPoint/auto0/modules/mod2]*}\
-        -statics 1 -nested 0 -deleteHook {}} --\
-        res0 res1 res2"
+        {TCLLIB ZIPDIR/auto0/modules ZIPDIR/auto0/modules/mod1\
+         ZIPDIR/auto0/modules/mod2} -- res0 res1 res2}
+# See comments on lsort after test safe-9.20.
 test safe-9.21 {interpConfigure change the access path; check module loading; stale data case 1} -setup {
     set oldTm [tcl::tm::path list]
     foreach path $oldTm {
@@ -1509,6 +1498,7 @@ test safe-9.21z {interpConfigure change the access path; check module loading; s
 
     # Inspect.
     set confA [safe::interpConfigure $i]
+    set sortA [mapAndSortList $PathMapp [dict get $confA -accessPath]]
     set modsA [interp eval $i {tcl::tm::path list}]
     set path0 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
     set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
@@ -1519,9 +1509,9 @@ test safe-9.21z {interpConfigure change the access path; check module loading; s
     safe::interpConfigure $i -accessPath [list $tcl_library \
                                            [file join $ZipMountPoint auto0 auto1] \
                                            [file join $ZipMountPoint auto0 auto2]]
-
     # Inspect.
     set confB [safe::interpConfigure $i]
+    set sortB [mapAndSortList $PathMapp [dict get $confB -accessPath]]
     set modsB [interp eval $i {tcl::tm::path list}]
     set path3 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
     set path4 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
@@ -1540,31 +1530,25 @@ test safe-9.21z {interpConfigure change the access path; check module loading; s
     set out1  [interp eval $i {mod1::test1::try1}]
     set out2  [interp eval $i {mod2::test2::try2}]
 
-    list $path0 $path1 $path2 -- $modsA -- $path3 $path4 $path5 -- $modsB -- \
-         $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $confA -- $confB -- \
-         $out0 $out1 $out2
+    list [lsort [list $path0 $path1 $path2]] -- $modsA -- \
+            [lsort [list $path3 $path4 $path5]] -- $modsB -- \
+            $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $sortA -- $sortB -- \
+            $out0 $out1 $out2
 } -cleanup {
     tcl::tm::path remove [file join $ZipMountPoint auto0 modules]
     foreach path [lreverse $oldTm] {
         tcl::tm::path add $path
     }
     safe::interpDelete $i
-} -match glob -result "{\$p(:1:)} {\$p(:2:)} {\$p(:3:)} -- {{\$p(:1:)}} --\
-        {\$p(:3:)} {\$p(:4:)} {\$p(:5:)} -- {{\$p(:3:)}} --\
+} -match glob -result {{{$p(:1:)} {$p(:2:)} {$p(:3:)}} -- {{$p(:1:)}} --\
+        {{$p(:3:)} {$p(:4:)} {$p(:5:)}} -- {{$p(:3:)}} --\
         0 0.5 0 1.0 0 2.0 --\
-        {-accessPath {[list $tcl_library \
-                        $ZipMountPoint/auto0/modules \
-                        $ZipMountPoint/auto0/modules/mod1 \
-                        $ZipMountPoint/auto0/modules/mod2]}\
-        -statics 1 -nested 0 -deleteHook {}} --\
-        {-accessPath {[list $tcl_library \
-                        $ZipMountPoint/auto0/auto1 \
-                        $ZipMountPoint/auto0/auto2 \
-                        $ZipMountPoint/auto0/modules \
-                        $ZipMountPoint/auto0/modules/mod1 \
-                        $ZipMountPoint/auto0/modules/mod2]}\
-        -statics 1 -nested 0 -deleteHook {}} --\
-        res0 res1 res2"
+        {TCLLIB ZIPDIR/auto0/modules ZIPDIR/auto0/modules/mod1\
+         ZIPDIR/auto0/modules/mod2} --\
+        {TCLLIB ZIPDIR/auto0/auto1 ZIPDIR/auto0/auto2 ZIPDIR/auto0/modules\
+         ZIPDIR/auto0/modules/mod1 ZIPDIR/auto0/modules/mod2} --\
+        res0 res1 res2}
+# See comments on lsort after test safe-9.20.
 test safe-9.22 {interpConfigure change the access path; check module loading; stale data case 0} -setup {
     set oldTm [tcl::tm::path list]
     foreach path $oldTm {
@@ -1633,6 +1617,7 @@ test safe-9.22z {interpConfigure change the access path; check module loading; s
 
     # Inspect.
     set confA [safe::interpConfigure $i]
+    set sortA [mapAndSortList $PathMapp [dict get $confA -accessPath]]
     set modsA [interp eval $i {tcl::tm::path list}]
     set path0 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
     set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
@@ -1643,9 +1628,9 @@ test safe-9.22z {interpConfigure change the access path; check module loading; s
     safe::interpConfigure $i -accessPath [list $tcl_library \
                                           [file join $ZipMountPoint auto0 auto1] \
                                           [file join $ZipMountPoint auto0 auto2]]
-
     # Inspect.
     set confB [safe::interpConfigure $i]
+    set sortB [mapAndSortList $PathMapp [dict get $confB -accessPath]]
     set modsB [interp eval $i {tcl::tm::path list}]
     set path3 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
     set path4 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
@@ -1659,31 +1644,25 @@ test safe-9.22z {interpConfigure change the access path; check module loading; s
     set out1  [interp eval $i {mod1::test1::try1}]
     set out2  [interp eval $i {mod2::test2::try2}]
 
-    list $path0 $path1 $path2 -- $modsA -- $path3 $path4 $path5 -- $modsB -- \
-         $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $confA -- $confB -- \
-         $out0 $out1 $out2
+    list [lsort [list $path0 $path1 $path2]] -- $modsA -- \
+            [lsort [list $path3 $path4 $path5]] -- $modsB -- \
+            $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $sortA -- $sortB -- \
+            $out0 $out1 $out2
 } -cleanup {
     tcl::tm::path remove [file join $ZipMountPoint auto0 modules]
     foreach path [lreverse $oldTm] {
         tcl::tm::path add $path
     }
     safe::interpDelete $i
-} -match glob -result "{\$p(:1:)} {\$p(:2:)} {\$p(:3:)} -- {{\$p(:1:)}} --\
-        {\$p(:3:)} {\$p(:4:)} {\$p(:5:)} -- {{\$p(:3:)}} --\
+} -match glob -result {{{$p(:1:)} {$p(:2:)} {$p(:3:)}} -- {{$p(:1:)}} --\
+        {{$p(:3:)} {$p(:4:)} {$p(:5:)}} -- {{$p(:3:)}} --\
         0 0.5 0 1.0 0 2.0 --\
-        {-accessPath {[list $tcl_library \
-                            $ZipMountPoint/auto0/modules \
-                            $ZipMountPoint/auto0/modules/mod1 \
-                            $ZipMountPoint/auto0/modules/mod2]}\
-        -statics 1 -nested 0 -deleteHook {}} --\
-        {-accessPath {[list $tcl_library \
-                            $ZipMountPoint/auto0/auto1 \
-                            $ZipMountPoint/auto0/auto2 \
-                            $ZipMountPoint/auto0/modules \
-                            $ZipMountPoint/auto0/modules/mod1 \
-                            $ZipMountPoint/auto0/modules/mod2]}\
-        -statics 1 -nested 0 -deleteHook {}} --\
-        res0 res1 res2"
+        {TCLLIB ZIPDIR/auto0/modules ZIPDIR/auto0/modules/mod1\
+         ZIPDIR/auto0/modules/mod2} --\
+        {TCLLIB ZIPDIR/auto0/auto1 ZIPDIR/auto0/auto2 ZIPDIR/auto0/modules\
+         ZIPDIR/auto0/modules/mod1 ZIPDIR/auto0/modules/mod2} --\
+        res0 res1 res2}
+# See comments on lsort after test safe-9.20.
 test safe-9.23 {interpConfigure change the access path; check module loading; stale data case 3} -setup {
     set oldTm [tcl::tm::path list]
     foreach path $oldTm {
@@ -1763,6 +1742,7 @@ test safe-9.23z {interpConfigure change the access path; check module loading; s
 
     # Inspect.
     set confA [safe::interpConfigure $i]
+    set sortA [mapAndSortList $PathMapp [dict get $confA -accessPath]]
     set modsA [interp eval $i {tcl::tm::path list}]
     set path0 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
     set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
@@ -1778,9 +1758,9 @@ test safe-9.23z {interpConfigure change the access path; check module loading; s
     safe::interpConfigure $i -accessPath [list $tcl_library \
                                            [file join $ZipMountPoint auto0 auto1] \
                                            [file join $ZipMountPoint auto0 auto2]]
-
     # Inspect.
     set confB [safe::interpConfigure $i]
+    set sortB [mapAndSortList $PathMapp [dict get $confB -accessPath]]
     set modsB [interp eval $i {tcl::tm::path list}]
     set path3 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
     set path4 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
@@ -1799,32 +1779,25 @@ test safe-9.23z {interpConfigure change the access path; check module loading; s
     set out1  [interp eval $i {mod1::test1::try1}]
     set out2  [interp eval $i {mod2::test2::try2}]
 
-    list $path0 $path1 $path2 -- $modsA -- $path3 $path4 $path5 -- $modsB -- \
-         $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $confA -- $confB -- \
-         $out0 $out1 $out2
-
+    list [lsort [list $path0 $path1 $path2]] -- $modsA -- \
+            [lsort [list $path3 $path4 $path5]] -- $modsB -- \
+            $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $sortA -- $sortB -- \
+            $out0 $out1 $out2
 } -cleanup {
     tcl::tm::path remove [file join $ZipMountPoint auto0 modules]
     foreach path [lreverse $oldTm] {
         tcl::tm::path add $path
     }
     safe::interpDelete $i
-} -match glob -result "{\$p(:1:)} {\$p(:2:)} {\$p(:3:)} -- {{\$p(:1:)}} --\
-        {\$p(:3:)} {\$p(:4:)} {\$p(:5:)} -- {{\$p(:3:)}} --\
+} -match glob -result {{{$p(:1:)} {$p(:2:)} {$p(:3:)}} -- {{$p(:1:)}} --\
+        {{$p(:3:)} {$p(:4:)} {$p(:5:)}} -- {{$p(:3:)}} --\
         0 0.5 0 1.0 0 2.0 --\
-        {-accessPath {[list $tcl_library \
-                            $ZipMountPoint/auto0/modules \
-                            $ZipMountPoint/auto0/modules/mod1 \
-                            $ZipMountPoint/auto0/modules/mod2]}\
-        -statics 1 -nested 0 -deleteHook {}} --\
-        {-accessPath {[list $tcl_library \
-                            $ZipMountPoint/auto0/auto1 \
-                            $ZipMountPoint/auto0/auto2 \
-                            $ZipMountPoint/auto0/modules \
-                            $ZipMountPoint/auto0/modules/mod1 \
-                            $ZipMountPoint/auto0/modules/mod2]}\
-        -statics 1 -nested 0 -deleteHook {}} --\
-        res0 res1 res2"
+        {TCLLIB ZIPDIR/auto0/modules ZIPDIR/auto0/modules/mod1\
+         ZIPDIR/auto0/modules/mod2} --\
+        {TCLLIB ZIPDIR/auto0/auto1 ZIPDIR/auto0/auto2 ZIPDIR/auto0/modules\
+         ZIPDIR/auto0/modules/mod1 ZIPDIR/auto0/modules/mod2} --\
+        res0 res1 res2}
+# See comments on lsort after test safe-9.20.
 test safe-9.24 {interpConfigure change the access path; check module loading; stale data case 2 (worst case)} -setup {
     set oldTm [tcl::tm::path list]
     foreach path $oldTm {
@@ -1887,7 +1860,6 @@ test safe-9.24 {interpConfigure change the access path; check module loading; st
          TESTSDIR/auto0/modules/mod1 TESTSDIR/auto0/modules/mod2} --\
         res0 res1 res2}
 # See comments on lsort after test safe-9.20.
-
 test safe-9.24z {interpConfigure change the access path; check module loading; stale data case 2 (worst case); zipfs} -setup {
     set oldTm [tcl::tm::path list]
     foreach path $oldTm {
@@ -1899,6 +1871,7 @@ test safe-9.24z {interpConfigure change the access path; check module loading; s
 
     # Inspect.
     set confA [safe::interpConfigure $i]
+    set sortA [mapAndSortList $PathMapp [dict get $confA -accessPath]]
     set modsA [interp eval $i {tcl::tm::path list}]
     set path0 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
     set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
@@ -1914,9 +1887,9 @@ test safe-9.24z {interpConfigure change the access path; check module loading; s
     safe::interpConfigure $i -accessPath [list $tcl_library \
                                            [file join $ZipMountPoint auto0 auto1] \
                                            [file join $ZipMountPoint auto0 auto2]]
-
     # Inspect.
     set confB [safe::interpConfigure $i]
+    set sortB [mapAndSortList $PathMapp [dict get $confB -accessPath]]
     set modsB [interp eval $i {tcl::tm::path list}]
     set path3 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
     set path4 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
@@ -1930,31 +1903,25 @@ test safe-9.24z {interpConfigure change the access path; check module loading; s
     set out1  [interp eval $i {mod1::test1::try1}]
     set out2  [interp eval $i {mod2::test2::try2}]
 
-    list $path0 $path1 $path2 -- $modsA -- $path3 $path4 $path5 -- $modsB -- \
-         $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $confA -- $confB -- \
-         $out0 $out1 $out2
+    list [lsort [list $path0 $path1 $path2]] -- $modsA -- \
+            [lsort [list $path3 $path4 $path5]] -- $modsB -- \
+            $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $sortA -- $sortB -- \
+            $out0 $out1 $out2
 } -cleanup {
     tcl::tm::path remove [file join $ZipMountPoint auto0 modules]
     foreach path [lreverse $oldTm] {
         tcl::tm::path add $path
     }
     safe::interpDelete $i
-} -match glob -result "{\$p(:1:)} {\$p(:2:)} {\$p(:3:)} -- {{\$p(:1:)}} --\
-        {\$p(:3:)} {\$p(:4:)} {\$p(:5:)} -- {{\$p(:3:)}} --\
+} -match glob -result {{{$p(:1:)} {$p(:2:)} {$p(:3:)}} -- {{$p(:1:)}} --\
+        {{$p(:3:)} {$p(:4:)} {$p(:5:)}} -- {{$p(:3:)}} --\
         0 0.5 0 1.0 0 2.0 --\
-        {-accessPath {[list $tcl_library \
-                            $ZipMountPoint/auto0/modules \
-                            $ZipMountPoint/auto0/modules/mod1 \
-                            $ZipMountPoint/auto0/modules/mod2]}\
-        -statics 1 -nested 0 -deleteHook {}} --\
-        {-accessPath {[list $tcl_library \
-			    $ZipMountPoint/auto0/auto1 \
-			    $ZipMountPoint/auto0/auto2 \
-			    $ZipMountPoint/auto0/modules \
-			    $ZipMountPoint/auto0/modules/mod1 \
-			    $ZipMountPoint/auto0/modules/mod2]}\
-        -statics 1 -nested 0 -deleteHook {}} --\
-        res0 res1 res2"
+        {TCLLIB ZIPDIR/auto0/modules ZIPDIR/auto0/modules/mod1\
+         ZIPDIR/auto0/modules/mod2} --\
+        {TCLLIB ZIPDIR/auto0/auto1 ZIPDIR/auto0/auto2 ZIPDIR/auto0/modules\
+         ZIPDIR/auto0/modules/mod1 ZIPDIR/auto0/modules/mod2} --\
+        res0 res1 res2}
+# See comments on lsort after test safe-9.20.
 
 catch {teststaticpkg Safepkg1 0 0}
 test safe-10.1 {testing statics loading} -constraints TcltestPackage -setup {
@@ -2264,6 +2231,7 @@ test safe-13.7a {mimic the glob call by tclPkgUnknown in a safe interpreter with
     safe::interpDelete $i
     removeDirectory $testdir
 } -result {EXPECTED/deleteme/pkgIndex.tcl EXPECTED/deletemetoo/pkgIndex.tcl}
+# See comments on lsort after test safe-9.20.
 test safe-13.8 {mimic the glob call by tclPkgUnknown without the special treatment that is specific to pkgIndex.tcl [Bug 2964715]} -setup {
     set i [safe::interpCreate]
     buildEnvironment notIndex.tcl
-- 
cgit v0.12


From 7d6a2292b530eb21168b734c6dcf292c9927ad08 Mon Sep 17 00:00:00 2001
From: kjnash <k.j.nash@usa.net>
Date: Thu, 16 Jul 2020 15:55:19 +0000
Subject: Amend tests safe-7.[124]z so they look for packages in the mounted
 zipfile

---
 tests/safe.test | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/tests/safe.test b/tests/safe.test
index 4195ebb..b71a720 100644
--- a/tests/safe.test
+++ b/tests/safe.test
@@ -500,7 +500,7 @@ test safe-7.1 {tests that everything works at high level} -setup {
 # Use zipped example packages not tcl8.x/opt
 test safe-7.1z {tests that everything works at high level; zipfs} -setup {
     set tmpAutoPath $::auto_path
-    lappend ::auto_path [file join $TestsDir auto0]
+    lappend ::auto_path [file join $ZipMountPoint auto0]
     set i [safe::interpCreate]
     set ::auto_path $tmpAutoPath
 } -body {
@@ -556,7 +556,7 @@ test safe-7.2z {tests specific path and interpFind/AddToAccessPath; zipfs} -setu
     # should add as p* (not p1 if master has a module path)
     set token2 [safe::interpAddToAccessPath $i "/dummy/unixlike/test/path"]
     # should add as p* (not p2 if master has a module path)
-    set token3 [safe::interpAddToAccessPath $i [file join $TestsDir auto0]]
+    set token3 [safe::interpAddToAccessPath $i [file join $ZipMountPoint auto0]]
     set confA [safe::interpConfigure $i]
     set mappA [mapList $PathMapp [dict get $confA -accessPath]]
     # an error shall occur (SafeTestPackage1 is not anymore in the secure 0-level
@@ -567,7 +567,7 @@ test safe-7.2z {tests specific path and interpFind/AddToAccessPath; zipfs} -setu
 } -cleanup {
 } -match glob -result {{$p(:0:)} {$p(:*:)} {$p(:*:)} --\
         1 {can't find package SafeTestPackage1} --\
-        {TCLLIB */dummy/unixlike/test/path TESTSDIR/auto0} -- {}}
+        {TCLLIB */dummy/unixlike/test/path ZIPDIR/auto0} -- {}}
 test safe-7.2opt {tests specific path and interpFind/AddToAccessPath, uses pkg opt} -setup {
 } -body {
     set i [safe::interpCreate -nostat -nested 1 -accessPath [list [info library]]]
@@ -622,7 +622,7 @@ test safe-7.4z {tests specific path and positive search; zipfs} -setup {
     # should not add anything (p0)
     set token1 [safe::interpAddToAccessPath $i [info library]]
     # should add as p* (not p1 if master has a module path)
-    set token2 [safe::interpAddToAccessPath $i [file join $TestsDir auto0 auto1]]
+    set token2 [safe::interpAddToAccessPath $i [file join $ZipMountPoint auto0 auto1]]
     set confA [safe::interpConfigure $i]
     set mappA [mapList $PathMapp [dict get $confA -accessPath]]
     # this time, unlike test safe-7.2, SafeTestPackage1 should be found
@@ -633,7 +633,7 @@ test safe-7.4z {tests specific path and positive search; zipfs} -setup {
     # other than the first and last in the access path.
 } -cleanup {
 } -match glob -result {{$p(:0:)} {$p(:*:)} -- 0 1.2.3 --\
-        {TCLLIB * TESTSDIR/auto0/auto1} -- {}}
+        {TCLLIB * ZIPDIR/auto0/auto1} -- {}}
 test safe-7.4opt {tests specific path and positive search, uses pkg opt} -setup {
 } -body {
     set i [safe::interpCreate -nostat -nested 1 -accessPath [list [info library]]]
-- 
cgit v0.12


From 85bdb7cb8e43af0938b1c7f5013daa6b170bd5d4 Mon Sep 17 00:00:00 2001
From: kjnash <k.j.nash@usa.net>
Date: Thu, 16 Jul 2020 17:29:04 +0000
Subject: Fix error in merging safe.test with safe-bugfixes-8-6 commit
 d065e8c73d

---
 tests/safe.test | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/safe.test b/tests/safe.test
index b71a720..e9ec7df 100644
--- a/tests/safe.test
+++ b/tests/safe.test
@@ -583,8 +583,8 @@ test safe-7.2opt {tests specific path and interpFind/AddToAccessPath, uses pkg o
 	    [catch {interp eval $i {package require opt}} msg] $msg -- \
 	    $mappA -- [safe::interpDelete $i]
 } -cleanup {
-} -match glob -result {{$p(:0:)} {$p(:*:)} -- 1 {can't find package opt} --\
-        {TCLLIB */dummy/unixlike/test/path} -- {}}
+} -match glob -result "{\$p(:0:)} {\$p(:*:)} -- 1 {$pkgOptErrMsg} --\
+        {TCLLIB */dummy/unixlike/test/path} -- {}"
 test safe-7.3 {check that safe subinterpreters work} {
     set g [interp slaves]
     if {$g ne {}} {
-- 
cgit v0.12


From 51449d078f688627b42b0c8ced040cc8b5197ca2 Mon Sep 17 00:00:00 2001
From: kjnash <k.j.nash@usa.net>
Date: Mon, 20 Jul 2020 22:57:42 +0000
Subject: File tests/safe.test - rearrange tests - move tests of
 command/package loading that use Tcl files to new file
 tests/safe-stock87.test; move tests of zipfs compatibility to new file
 tests/safe-zipfs.test; renumber tests 9.8+ and add test 9.8 to replace old
 5.1; move tests 7.0* to 5.*; reverse merge error (duplicate code).

---
 tests/safe-stock87.test |  255 ++++++++
 tests/safe-zipfs.test   |  729 +++++++++++++++++++++++
 tests/safe.test         | 1487 +++--------------------------------------------
 3 files changed, 1063 insertions(+), 1408 deletions(-)
 create mode 100644 tests/safe-stock87.test
 create mode 100644 tests/safe-zipfs.test

diff --git a/tests/safe-stock87.test b/tests/safe-stock87.test
new file mode 100644
index 0000000..3ba1558
--- /dev/null
+++ b/tests/safe-stock87.test
@@ -0,0 +1,255 @@
+# safe-stock87.test --
+#
+# This file contains tests for safe Tcl that were previously in the file
+# safe.test, and use files and packages of stock Tcl 8.7 to perform the tests.
+# These files may be changed or disappear in future revisions of Tcl, for
+# example package opt will eventually be removed.
+#
+# The tests are replaced in safe.tcl with tests that use files provided in the
+# tests directory.  Test numbering is for comparison with similar tests in
+# safe.test.
+#
+# Sourcing this file into tcl runs the tests and generates output for errors.
+# No output means no errors were found.
+#
+# The defunct package http 1.0 was convenient for testing package loading.
+# - This file, safe-stock87.test, uses packages opt and (from cookiejar)
+#   tcl::idna to provide alternative tests based on stock Tcl packages.
+#   - These are tests 7.1 7.2 7.4 9.11 9.13
+#   - Tests 7.[124], 9.1[13] use "package require opt".
+#   - Tests 9.1[13] also use "package require tcl::idna".
+# - The corresponding tests in safe.test use example packages provided in
+#   subdirectory auto0 of the tests directory, which are independent of any
+#   changes made to the packages provided with Tcl.
+#
+# Copyright (c) 1995-1996 Sun Microsystems, Inc.
+# Copyright (c) 1998-1999 by Scriptics Corporation.
+#
+# See the file "license.terms" for information on usage and redistribution of
+# this file, and for a DISCLAIMER OF ALL WARRANTIES.
+
+package require Tcl 8.5-
+
+if {"::tcltest" ni [namespace children]} {
+    package require tcltest 2
+    namespace import -force ::tcltest::*
+}
+
+foreach i [interp slaves] {
+    interp delete $i
+}
+
+# When using package opt for testing positive/negative package search:
+# - The directory location and the error message depend on whether
+#   and how the package is installed.
+
+# Error message for test 7.2 for "package require opt".
+if {[string match *zipfs:/* [info library]]} {
+    # pkgIndex.tcl is in [info library]
+    # file to be sourced is in [info library]/opt*
+    set pkgOptErrMsg {permission denied}
+} else {
+    # pkgIndex.tcl and file to be sourced are
+    # both in [info library]/opt*
+    set pkgOptErrMsg {can't find package opt}
+}
+
+# Directory of opt for tests 7.4, 9.10, 9.12 for "package require opt".
+if {[file exists [file join [info library] opt0.4]]} {
+    # Installed files in lib8.7/opt0.4
+    set pkgOptDir opt0.4
+} elseif {[file exists [file join [info library] opt]]} {
+    # Installed files in zipfs, or source files used by "make test"
+    set pkgOptDir opt
+} else {
+    error {cannot find opt library}
+}
+
+# Directory of cookiejar for tests 9.10, 9.12 for "package require tcl::idna".
+if {[file exists [file join [info library] cookiejar0.2]]} {
+    # Installed files in lib8.7/cookiejar0.2
+    set pkgJarDir cookiejar0.2
+} elseif {[file exists [file join [info library] cookiejar]]} {
+    # Installed files in zipfs, or source files used by "make test"
+    set pkgJarDir cookiejar
+} else {
+    error {cannot find cookiejar library}
+}
+
+set SaveAutoPath $::auto_path
+set ::auto_path [info library]
+set TestsDir [file normalize [file dirname [info script]]]
+set PathMapp {}
+lappend PathMapp [file join [info library] $pkgOptDir] TCLLIB/OPTDIR
+lappend PathMapp [file join [info library] $pkgJarDir] TCLLIB/JARDIR
+lappend PathMapp $tcl_library TCLLIB $TestsDir TESTSDIR
+
+proc mapList {map listIn} {
+    set listOut {}
+    foreach element $listIn {
+        lappend listOut [string map $map $element]
+    }
+    return $listOut
+}
+proc mapAndSortList {map listIn} {
+    set listOut {}
+    foreach element $listIn {
+        lappend listOut [string map $map $element]
+    }
+    lsort $listOut
+}
+
+# Force actual loading of the safe package because we use un-exported (and
+# thus un-autoindexed) APIs in this test result arguments:
+catch {safe::interpConfigure}
+
+# testing that nested and statics do what is advertised (we use a static
+# package - Tcltest - but it might be absent if we're in standard tclsh)
+
+testConstraint TcltestPackage [expr {![catch {package require Tcltest}]}]
+
+# high level general test
+test safe-stock87-7.1 {tests that everything works at high level, uses pkg opt} -setup {
+    set i [safe::interpCreate]
+} -body {
+    # no error shall occur:
+    # (because the default access_path shall include 1st level sub dirs so
+    #  package require in a slave works like in the master)
+    set v [interp eval $i {package require opt}]
+    # no error shall occur:
+    interp eval $i {::tcl::Lempty {a list}}
+    set v
+} -cleanup {
+    safe::interpDelete $i
+} -match glob -result 0.4.*
+test safe-stock87-7.2 {tests specific path and interpFind/AddToAccessPath, uses pkg opt} -setup {
+} -body {
+    set i [safe::interpCreate -nostat -nested 1 -accessPath [list [info library]]]
+    # should not add anything (p0)
+    set token1 [safe::interpAddToAccessPath $i [info library]]
+    # should add as p* (not p1 if master has a module path)
+    set token2 [safe::interpAddToAccessPath $i "/dummy/unixlike/test/path"]
+    # an error shall occur (opt is not anymore in the secure 0-level
+    # provided deep path)
+    set confA [safe::interpConfigure $i]
+    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
+    list $token1 $token2 -- \
+	    [catch {interp eval $i {package require opt}} msg] $msg -- \
+	    $mappA -- [safe::interpDelete $i]
+} -cleanup {
+} -match glob -result "{\$p(:0:)} {\$p(:*:)} -- 1 {$pkgOptErrMsg} --\
+        {TCLLIB */dummy/unixlike/test/path} -- {}"
+test safe-stock87-7.4 {tests specific path and positive search, uses pkg opt} -setup {
+} -body {
+    set i [safe::interpCreate -nostat -nested 1 -accessPath [list [info library]]]
+    # should not add anything (p0)
+    set token1 [safe::interpAddToAccessPath $i [info library]]
+    # should add as p* (not p1 if master has a module path)
+    set token2 [safe::interpAddToAccessPath $i [file join [info library] $pkgOptDir]]
+    set confA [safe::interpConfigure $i]
+    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
+    # this time, unlike test safe-stock87-7.2, opt should be found
+    list $token1 $token2 -- \
+            [catch {interp eval $i {package require opt}} msg] $msg -- \
+            $mappA -- [safe::interpDelete $i]
+    # Note that the glob match elides directories (those from the module path)
+    # other than the first and last in the access path.
+} -cleanup {
+} -match glob -result {{$p(:0:)} {$p(:*:)} -- 0 0.4.* --\
+        {TCLLIB * TCLLIB/OPTDIR} -- {}}
+
+# The following test checks whether the definition of tcl_endOfWord can be
+# obtained from auto_loading.  It was previously test "safe-5.1".
+test safe-stock87-9.8 {test auto-loading in safe interpreters, was safe-5.1} -setup {
+    catch {safe::interpDelete a}
+    safe::interpCreate a
+} -body {
+    interp eval a {tcl_endOfWord "" 0}
+} -cleanup {
+    safe::interpDelete a
+} -result -1
+test safe-stock87-9.11 {interpConfigure change the access path; pkgIndex.tcl packages unaffected by token rearrangement, uses pkg opt and tcl::idna} -setup {
+} -body {
+    set i [safe::interpCreate -accessPath [list $tcl_library \
+                                            [file join $tcl_library $pkgOptDir] \
+                                            [file join $tcl_library $pkgJarDir]]]
+    # Inspect.
+    set confA [safe::interpConfigure $i]
+    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
+    set path1 [::safe::interpFindInAccessPath $i [file join $tcl_library $pkgOptDir]]
+    set path2 [::safe::interpFindInAccessPath $i [file join $tcl_library $pkgJarDir]]
+
+    # Load pkgIndex.tcl data.
+    catch {interp eval $i {package require NOEXIST}}
+
+    # Rearrange access path.  Swap tokens {$p(:1:)} and {$p(:2:)}.
+    # This has no effect because the records in Pkg of these directories were from access as children of {$p(:0:)}.
+    safe::interpConfigure $i -accessPath [list $tcl_library \
+                                           [file join $tcl_library $pkgJarDir] \
+                                           [file join $tcl_library $pkgOptDir]]
+    # Inspect.
+    set confB [safe::interpConfigure $i]
+    set mappB [mapList $PathMapp [dict get $confB -accessPath]]
+    set path3 [::safe::interpFindInAccessPath $i [file join $tcl_library $pkgOptDir]]
+    set path4 [::safe::interpFindInAccessPath $i [file join $tcl_library $pkgJarDir]]
+
+    # Try to load the packages and run a command from each one.
+    set code3 [catch {interp eval $i {package require tcl::idna}} msg3]
+    set code4 [catch {interp eval $i {package require opt}} msg4]
+    set code5 [catch {interp eval $i {::tcl::Lempty {a list}}} msg5]
+    set code6 [catch {interp eval $i {::tcl::idna::IDNAencode example.com}} msg6]
+
+    list $path1 $path2 -- $path3 $path4 -- $code3 $msg3 $code4 $msg4 -- \
+         $mappA -- $mappB -- $code5 $msg5 $code6 $msg6
+} -cleanup {
+    safe::interpDelete $i
+} -match glob -result {{$p(:1:)} {$p(:2:)} -- {$p(:2:)} {$p(:1:)} -- 0 1.* 0 0.4.* --\
+        {TCLLIB TCLLIB/OPTDIR TCLLIB/JARDIR*} --\
+        {TCLLIB TCLLIB/JARDIR TCLLIB/OPTDIR*} --\
+        0 0 0 example.com}
+test safe-stock87-9.13 {interpConfigure change the access path; pkgIndex.tcl packages fail if directory de-listed, uses pkg opt and tcl::idna} -setup {
+} -body {
+    set i [safe::interpCreate -accessPath [list $tcl_library \
+                                            [file join $tcl_library $pkgOptDir] \
+                                            [file join $tcl_library $pkgJarDir]]]
+    # Inspect.
+    set confA [safe::interpConfigure $i]
+    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
+    set path1 [::safe::interpFindInAccessPath $i [file join $tcl_library $pkgOptDir]]
+    set path2 [::safe::interpFindInAccessPath $i [file join $tcl_library $pkgJarDir]]
+
+    # Load pkgIndex.tcl data.
+    catch {interp eval $i {package require NOEXIST}}
+
+    # Limit access path.  Remove tokens {$p(:1:)} and {$p(:2:)}.
+    safe::interpConfigure $i -accessPath [list $tcl_library]
+
+    # Inspect.
+    set confB [safe::interpConfigure $i]
+    set mappB [mapList $PathMapp [dict get $confB -accessPath]]
+    set code4 [catch {::safe::interpFindInAccessPath $i [file join $tcl_library $pkgOptDir]} path4]
+    set code5 [catch {::safe::interpFindInAccessPath $i [file join $tcl_library $pkgJarDir]} path5]
+
+    # Try to load the packages.
+    set code3 [catch {interp eval $i {package require opt}} msg3]
+    set code6 [catch {interp eval $i {package require tcl::idna}} msg6]
+
+    list $path1 $path2 -- $code4 $path4 -- $code5 $path5 -- $code3 $code6 -- \
+            $mappA -- $mappB
+} -cleanup {
+    safe::interpDelete $i
+} -match glob -result {{$p(:1:)} {$p(:2:)} -- 1 {* not found in access path} --\
+        1 {* not found in access path} -- 1 1 --\
+        {TCLLIB TCLLIB/OPTDIR TCLLIB/JARDIR*} -- {TCLLIB*}}
+
+set ::auto_path $SaveAutoPath
+unset pkgOptErrMsg pkgOptDir pkgJarDir SaveAutoPath TestsDir PathMapp
+rename mapList {}
+rename mapAndSortList {}
+# cleanup
+::tcltest::cleanupTests
+return
+
+# Local Variables:
+# mode: tcl
+# End:
diff --git a/tests/safe-zipfs.test b/tests/safe-zipfs.test
new file mode 100644
index 0000000..1f110d1
--- /dev/null
+++ b/tests/safe-zipfs.test
@@ -0,0 +1,729 @@
+# safe-zipfs.test --
+#
+# This file contains tests for safe Tcl that test its compatibility with the
+# zipfs facilities introduced in Tcl 8.7.  Test numbering is for comparison
+# with similar tests in safe.test that do not use the zipfs file system.
+#
+# Sourcing this file into tcl runs the tests and generates output for errors.
+# No output means no errors were found.
+#
+# Copyright (c) 1995-1996 Sun Microsystems, Inc.
+# Copyright (c) 1998-1999 by Scriptics Corporation.
+#
+# See the file "license.terms" for information on usage and redistribution of
+# this file, and for a DISCLAIMER OF ALL WARRANTIES.
+
+package require Tcl 8.5-
+
+if {"::tcltest" ni [namespace children]} {
+    package require tcltest 2
+    namespace import -force ::tcltest::*
+}
+
+foreach i [interp slaves] {
+    interp delete $i
+}
+
+set SaveAutoPath $::auto_path
+set ::auto_path [info library]
+set TestsDir [file normalize [file dirname [info script]]]
+
+set ZipMountPoint [zipfs root]auto-files
+zipfs mount $ZipMountPoint [file join $TestsDir auto-files.zip]
+
+set PathMapp {}
+lappend PathMapp $tcl_library TCLLIB $TestsDir TESTSDIR $ZipMountPoint ZIPDIR
+
+proc mapList {map listIn} {
+    set listOut {}
+    foreach element $listIn {
+        lappend listOut [string map $map $element]
+    }
+    return $listOut
+}
+proc mapAndSortList {map listIn} {
+    set listOut {}
+    foreach element $listIn {
+        lappend listOut [string map $map $element]
+    }
+    lsort $listOut
+}
+
+# Force actual loading of the safe package because we use un-exported (and
+# thus un-autoindexed) APIs in this test result arguments:
+catch {safe::interpConfigure}
+
+# testing that nested and statics do what is advertised (we use a static
+# package - Tcltest - but it might be absent if we're in standard tclsh)
+
+testConstraint TcltestPackage [expr {![catch {package require Tcltest}]}]
+
+# Tests 5.* test the example files before using them to test safe interpreters.
+
+test safe-zipfs-5.1 {example tclIndex commands, test in master interpreter; zipfs} -setup {
+    set tmpAutoPath $::auto_path
+    lappend ::auto_path [file join $ZipMountPoint auto0 auto1] [file join $ZipMountPoint auto0 auto2]
+} -body {
+    # Try to load the commands.
+    set code3 [catch report1 msg3]
+    set code4 [catch report2 msg4]
+    list $code3 $msg3 $code4 $msg4
+} -cleanup {
+    catch {rename report1 {}}
+    catch {rename report2 {}}
+    set ::auto_path $tmpAutoPath
+    auto_reset
+} -match glob -result {0 ok1 0 ok2}
+test safe-zipfs-5.2 {example tclIndex commands, negative test in master interpreter; zipfs} -setup {
+    set tmpAutoPath $::auto_path
+    lappend ::auto_path [file join $ZipMountPoint auto0]
+} -body {
+    # Try to load the commands.
+    set code3 [catch report1 msg3]
+    set code4 [catch report2 msg4]
+    list $code3 $msg3 $code4 $msg4
+} -cleanup {
+    catch {rename report1 {}}
+    catch {rename report2 {}}
+    set ::auto_path $tmpAutoPath
+    auto_reset
+} -match glob -result {1 {invalid command name "report1"} 1 {invalid command name "report2"}}
+test safe-zipfs-5.3 {example pkgIndex.tcl packages, test in master interpreter, child directories; zipfs} -setup {
+    set tmpAutoPath $::auto_path
+    lappend ::auto_path [file join $ZipMountPoint auto0]
+} -body {
+    # Try to load the packages and run a command from each one.
+    set code3 [catch {package require SafeTestPackage1} msg3]
+    set code4 [catch {package require SafeTestPackage2} msg4]
+    set code5 [catch HeresPackage1 msg5]
+    set code6 [catch HeresPackage2 msg6]
+    list $code3 $msg3 $code4 $msg4 $code5 $msg5 $code6 $msg6
+} -cleanup {
+    set ::auto_path $tmpAutoPath
+    catch {package forget SafeTestPackage1}
+    catch {package forget SafeTestPackage2}
+    catch {rename HeresPackage1 {}}
+    catch {rename HeresPackage2 {}}
+} -match glob -result {0 1.2.3 0 2.3.4 0 OK1 0 OK2}
+test safe-zipfs-5.4 {example pkgIndex.tcl packages, test in master interpreter, main directories; zipfs} -setup {
+    set tmpAutoPath $::auto_path
+    lappend ::auto_path [file join $ZipMountPoint auto0 auto1] \
+                        [file join $ZipMountPoint auto0 auto2]
+} -body {
+    # Try to load the packages and run a command from each one.
+    set code3 [catch {package require SafeTestPackage1} msg3]
+    set code4 [catch {package require SafeTestPackage2} msg4]
+    set code5 [catch HeresPackage1 msg5]
+    set code6 [catch HeresPackage2 msg6]
+    list $code3 $msg3 $code4 $msg4 $code5 $msg5 $code6 $msg6
+} -cleanup {
+    set ::auto_path $tmpAutoPath
+    catch {package forget SafeTestPackage1}
+    catch {package forget SafeTestPackage2}
+    catch {rename HeresPackage1 {}}
+    catch {rename HeresPackage2 {}}
+} -match glob -result {0 1.2.3 0 2.3.4 0 OK1 0 OK2}
+test safe-zipfs-5.5 {example modules packages, test in master interpreter, replace path; zipfs} -setup {
+    set oldTm [tcl::tm::path list]
+    foreach path $oldTm {
+        tcl::tm::path remove $path
+    }
+    tcl::tm::path add [file join $ZipMountPoint auto0 modules]
+} -body {
+    # Try to load the modules and run a command from each one.
+    set code0 [catch {package require test0} msg0]
+    set code1 [catch {package require mod1::test1} msg1]
+    set code2 [catch {package require mod2::test2} msg2]
+    set out0  [test0::try0]
+    set out1  [mod1::test1::try1]
+    set out2  [mod2::test2::try2]
+    list $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $out0 $out1 $out2
+} -cleanup {
+    tcl::tm::path remove [file join $ZipMountPoint auto0 modules]
+    foreach path [lreverse $oldTm] {
+        tcl::tm::path add $path
+    }
+    catch {package forget test0}
+    catch {package forget mod1::test1}
+    catch {package forget mod2::test2}
+    catch {namespace delete ::test0}
+    catch {namespace delete ::mod1}
+} -match glob -result {0 0.5 0 1.0 0 2.0 -- res0 res1 res2}
+test safe-zipfs-5.6 {example modules packages, test in master interpreter, append to path; zipfs} -setup {
+    tcl::tm::path add [file join $ZipMountPoint auto0 modules]
+} -body {
+    # Try to load the modules and run a command from each one.
+    set code0 [catch {package require test0} msg0]
+    set code1 [catch {package require mod1::test1} msg1]
+    set code2 [catch {package require mod2::test2} msg2]
+    set out0  [test0::try0]
+    set out1  [mod1::test1::try1]
+    set out2  [mod2::test2::try2]
+    list $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $out0 $out1 $out2
+} -cleanup {
+    tcl::tm::path remove [file join $ZipMountPoint auto0 modules]
+    catch {package forget test0}
+    catch {package forget mod1::test1}
+    catch {package forget mod2::test2}
+    catch {namespace delete ::test0}
+    catch {namespace delete ::mod1}
+} -match glob -result {0 0.5 0 1.0 0 2.0 -- res0 res1 res2}
+
+# high level general test
+# Use zipped example packages not tcl8.x/opt
+test safe-zipfs-7.1 {tests that everything works at high level; zipfs} -setup {
+    set tmpAutoPath $::auto_path
+    lappend ::auto_path [file join $ZipMountPoint auto0]
+    set i [safe::interpCreate]
+    set ::auto_path $tmpAutoPath
+} -body {
+    # no error shall occur:
+    # (because the default access_path shall include 1st level sub dirs so
+    #  package require in a slave works like in the master)
+    set v [interp eval $i {package require SafeTestPackage1}]
+    # no error shall occur:
+    interp eval $i {HeresPackage1}
+    set v
+} -cleanup {
+    safe::interpDelete $i
+} -match glob -result 1.2.3
+test safe-zipfs-7.2 {tests specific path and interpFind/AddToAccessPath; zipfs} -setup {
+} -body {
+    set i [safe::interpCreate -nostat -nested 1 -accessPath [list [info library]]]
+    # should not add anything (p0)
+    set token1 [safe::interpAddToAccessPath $i [info library]]
+    # should add as p* (not p1 if master has a module path)
+    set token2 [safe::interpAddToAccessPath $i "/dummy/unixlike/test/path"]
+    # should add as p* (not p2 if master has a module path)
+    set token3 [safe::interpAddToAccessPath $i [file join $ZipMountPoint auto0]]
+    set confA [safe::interpConfigure $i]
+    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
+    # an error shall occur (SafeTestPackage1 is not anymore in the secure 0-level
+    # provided deep path)
+    list $token1 $token2 $token3 -- \
+            [catch {interp eval $i {package require SafeTestPackage1}} msg] $msg -- \
+            $mappA -- [safe::interpDelete $i]
+} -cleanup {
+} -match glob -result {{$p(:0:)} {$p(:*:)} {$p(:*:)} --\
+        1 {can't find package SafeTestPackage1} --\
+        {TCLLIB */dummy/unixlike/test/path ZIPDIR/auto0} -- {}}
+test safe-zipfs-7.4 {tests specific path and positive search; zipfs} -setup {
+} -body {
+    set i [safe::interpCreate -nostat -nested 1 -accessPath [list [info library]]]
+    # should not add anything (p0)
+    set token1 [safe::interpAddToAccessPath $i [info library]]
+    # should add as p* (not p1 if master has a module path)
+    set token2 [safe::interpAddToAccessPath $i [file join $ZipMountPoint auto0 auto1]]
+    set confA [safe::interpConfigure $i]
+    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
+    # this time, unlike test safe-zipfs-7.2, SafeTestPackage1 should be found
+    list $token1 $token2 -- \
+	    [catch {interp eval $i {package require SafeTestPackage1}} msg] $msg -- \
+	    $mappA -- [safe::interpDelete $i]
+    # Note that the glob match elides directories (those from the module path)
+    # other than the first and last in the access path.
+} -cleanup {
+} -match glob -result {{$p(:0:)} {$p(:*:)} -- 0 1.2.3 --\
+        {TCLLIB * ZIPDIR/auto0/auto1} -- {}}
+
+test safe-zipfs-9.9 {interpConfigure change the access path; tclIndex commands unaffected by token rearrangement (dummy test of doreset); zipfs} -setup {
+} -body {
+    set i [safe::interpCreate -accessPath [list $tcl_library \
+                                            [file join $ZipMountPoint auto0 auto1] \
+                                            [file join $ZipMountPoint auto0 auto2]]]
+    # Inspect.
+    set confA [safe::interpConfigure $i]
+    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
+    set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
+    set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
+
+    # Load auto_load data.
+    interp eval $i {catch nonExistentCommand}
+
+    # Load and run the commands.
+    # This guarantees the test will pass even if the tokens are swapped.
+    set code1 [catch {interp eval $i {report1}} msg1]
+    set code2 [catch {interp eval $i {report2}} msg2]
+
+    # Rearrange access path.  Swap tokens {$p(:1:)} and {$p(:2:)}.
+    safe::interpConfigure $i -accessPath [list $tcl_library \
+                                           [file join $ZipMountPoint auto0 auto2] \
+                                           [file join $ZipMountPoint auto0 auto1]]
+    # Inspect.
+    set confB [safe::interpConfigure $i]
+    set mappB [mapList $PathMapp [dict get $confB -accessPath]]
+    set path3 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
+    set path4 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
+
+    # Run the commands.
+    set code3 [catch {interp eval $i {report1}} msg3]
+    set code4 [catch {interp eval $i {report2}} msg4]
+
+    list $path1 $path2 -- $path3 $path4 -- $code3 $msg3 $code4 $msg4 -- $mappA -- $mappB
+} -cleanup {
+    safe::interpDelete $i
+} -match glob -result {{$p(:1:)} {$p(:2:)} -- {$p(:2:)} {$p(:1:)} -- 0 ok1 0 ok2 --\
+        {TCLLIB ZIPDIR/auto0/auto1 ZIPDIR/auto0/auto2*} --\
+        {TCLLIB ZIPDIR/auto0/auto2 ZIPDIR/auto0/auto1*}}
+test safe-zipfs-9.10 {interpConfigure change the access path; tclIndex commands unaffected by token rearrangement (actual test of doreset); zipfs} -setup {
+} -body {
+    set i [safe::interpCreate -accessPath [list $tcl_library \
+                                            [file join $ZipMountPoint auto0 auto1] \
+                                            [file join $ZipMountPoint auto0 auto2]]]
+    # Inspect.
+    set confA [safe::interpConfigure $i]
+    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
+    set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
+    set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
+
+    # Load auto_load data.
+    interp eval $i {catch nonExistentCommand}
+
+    # Do not load the commands.  With the tokens swapped, the test
+    # will pass only if the Safe Base has called auto_reset.
+
+    # Rearrange access path.  Swap tokens {$p(:1:)} and {$p(:2:)}.
+    safe::interpConfigure $i -accessPath [list $tcl_library \
+                                           [file join $ZipMountPoint auto0 auto2] \
+                                           [file join $ZipMountPoint auto0 auto1]]
+    # Inspect.
+    set confB [safe::interpConfigure $i]
+    set mappB [mapList $PathMapp [dict get $confB -accessPath]]
+    set path3 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
+    set path4 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
+
+    # Load and run the commands.
+    set code3 [catch {interp eval $i {report1}} msg3]
+    set code4 [catch {interp eval $i {report2}} msg4]
+
+    list $path1 $path2 -- $path3 $path4 -- $code3 $msg3 $code4 $msg4 -- $mappA -- $mappB
+} -cleanup {
+    safe::interpDelete $i
+} -match glob -result {{$p(:1:)} {$p(:2:)} -- {$p(:2:)} {$p(:1:)} --\
+        0 ok1 0 ok2 --\
+        {TCLLIB ZIPDIR/auto0/auto1 ZIPDIR/auto0/auto2*} --\
+        {TCLLIB ZIPDIR/auto0/auto2 ZIPDIR/auto0/auto1*}}
+test safe-zipfs-9.11 {interpConfigure change the access path; pkgIndex.tcl packages unaffected by token rearrangement; zipfs} -setup {
+} -body {
+    # For complete correspondence to safe-stock87-9.11, include auto0 in access path.
+    set i [safe::interpCreate -accessPath [list $tcl_library \
+                                            [file join $ZipMountPoint auto0] \
+                                            [file join $ZipMountPoint auto0 auto1] \
+                                            [file join $ZipMountPoint auto0 auto2]]]
+    # Inspect.
+    set confA [safe::interpConfigure $i]
+    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
+    set path0 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0]]
+    set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
+    set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
+
+    # Load pkgIndex.tcl data.
+    catch {interp eval $i {package require NOEXIST}}
+
+    # Rearrange access path.  Swap tokens {$p(:2:)} and {$p(:3:)}.
+    # This would have no effect because the records in Pkg of these directories
+    # were from access as children of {$p(:1:)}.
+    safe::interpConfigure $i -accessPath [list $tcl_library \
+                                           [file join $ZipMountPoint auto0] \
+                                           [file join $ZipMountPoint auto0 auto2] \
+                                           [file join $ZipMountPoint auto0 auto1]]
+    # Inspect.
+    set confB [safe::interpConfigure $i]
+    set mappB [mapList $PathMapp [dict get $confB -accessPath]]
+    set path3 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
+    set path4 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
+
+    # Try to load the packages and run a command from each one.
+    set code3 [catch {interp eval $i {package require SafeTestPackage1}} msg3 opts3]
+    set code4 [catch {interp eval $i {package require SafeTestPackage2}} msg4 opts4]
+    set code5 [catch {interp eval $i {HeresPackage1}} msg5 opts5]
+    set code6 [catch {interp eval $i {HeresPackage2}} msg6 opts6]
+
+    list $path1 $path2 -- $path3 $path4 -- $code3 $msg3 $code4 $msg4 -- \
+         $mappA -- $mappB -- $code5 $msg5 $code6 $msg6
+} -cleanup {
+    safe::interpDelete $i
+} -match glob -result {{$p(:2:)} {$p(:3:)} -- {$p(:3:)} {$p(:2:)} -- 0 1.2.3 0 2.3.4 --\
+        {TCLLIB ZIPDIR/auto0 ZIPDIR/auto0/auto1 ZIPDIR/auto0/auto2*} --\
+        {TCLLIB ZIPDIR/auto0 ZIPDIR/auto0/auto2 ZIPDIR/auto0/auto1*} --\
+        0 OK1 0 OK2}
+test safe-zipfs-9.12 {interpConfigure change the access path; pkgIndex.tcl packages unaffected by token rearrangement, 9.10 without path auto0; zipfs} -setup {
+} -body {
+    set i [safe::interpCreate -accessPath [list $tcl_library \
+                                            [file join $ZipMountPoint auto0 auto1] \
+                                            [file join $ZipMountPoint auto0 auto2]]]
+    # Inspect.
+    set confA [safe::interpConfigure $i]
+    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
+    set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
+    set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
+
+    # Load pkgIndex.tcl data.
+    catch {interp eval $i {package require NOEXIST}}
+
+    # Rearrange access path.  Swap tokens {$p(:1:)} and {$p(:2:)}.
+    safe::interpConfigure $i -accessPath [list $tcl_library \
+                                           [file join $ZipMountPoint auto0 auto2] \
+                                           [file join $ZipMountPoint auto0 auto1]]
+    # Inspect.
+    set confB [safe::interpConfigure $i]
+    set mappB [mapList $PathMapp [dict get $confB -accessPath]]
+    set path3 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
+    set path4 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
+
+    # Try to load the packages and run a command from each one.
+    set code3 [catch {interp eval $i {package require SafeTestPackage1}} msg3 opts3]
+    set code4 [catch {interp eval $i {package require SafeTestPackage2}} msg4 opts4]
+    set code5 [catch {interp eval $i {HeresPackage1}} msg5 opts5]
+    set code6 [catch {interp eval $i {HeresPackage2}} msg6 opts6]
+
+    list $path1 $path2 -- $path3 $path4 -- $code3 $msg3 $code4 $msg4 -- \
+            $mappA -- $mappB -- $code5 $msg5 $code6 $msg6
+} -cleanup {
+    safe::interpDelete $i
+} -match glob -result {{$p(:1:)} {$p(:2:)} -- {$p(:2:)} {$p(:1:)} --\
+        0 1.2.3 0 2.3.4 --\
+        {TCLLIB ZIPDIR/auto0/auto1 ZIPDIR/auto0/auto2*} --\
+        {TCLLIB ZIPDIR/auto0/auto2 ZIPDIR/auto0/auto1*} --\
+        0 OK1 0 OK2}
+test safe-zipfs-9.13 {interpConfigure change the access path; pkgIndex.tcl packages fail if directory de-listed; zipfs} -setup {
+} -body {
+    set i [safe::interpCreate -accessPath [list $tcl_library \
+                                            [file join $ZipMountPoint auto0 auto1] \
+                                            [file join $ZipMountPoint auto0 auto2]]]
+    # Inspect.
+    set confA [safe::interpConfigure $i]
+    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
+    set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
+    set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
+
+    # Load pkgIndex.tcl data.
+    catch {interp eval $i {package require NOEXIST}}
+
+    # Limit access path.  Remove tokens {$p(:1:)} and {$p(:2:)}.
+    safe::interpConfigure $i -accessPath [list $tcl_library]
+
+    # Inspect.
+    set confB [safe::interpConfigure $i]
+    set mappB [mapList $PathMapp [dict get $confB -accessPath]]
+    set code4 [catch {::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]} path4]
+    set code5 [catch {::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]} path5]
+
+    # Try to load the packages.
+    set code3 [catch {interp eval $i {package require SafeTestPackage1}} msg3]
+    set code6 [catch {interp eval $i {package require SafeTestPackage2}} msg6]
+
+    list $path1 $path2 -- $code4 $path4 -- $code5 $path5 -- $code3 $code6 -- \
+            $mappA -- $mappB
+} -cleanup {
+    safe::interpDelete $i
+} -match glob -result {{$p(:1:)} {$p(:2:)} -- 1 {* not found in access path} --\
+        1 {* not found in access path} -- 1 1 --\
+        {TCLLIB ZIPDIR/auto0/auto1 ZIPDIR/auto0/auto2*} -- {TCLLIB*}}
+test safe-zipfs-9.20 {check module loading; zipfs} -setup {
+    set oldTm [tcl::tm::path list]
+    foreach path $oldTm {
+        tcl::tm::path remove $path
+    }
+    tcl::tm::path add [file join $ZipMountPoint auto0 modules]
+} -body {
+    set i [safe::interpCreate -accessPath [list $tcl_library]]
+
+    # Inspect.
+    set confA [safe::interpConfigure $i]
+    set sortA [mapAndSortList $PathMapp [dict get $confA -accessPath]]
+    set modsA [interp eval $i {tcl::tm::path list}]
+    set path0 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
+    set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
+    set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod2]]
+
+    # Try to load the packages and run a command from each one.
+    set code0 [catch {interp eval $i {package require test0}} msg0]
+    set code1 [catch {interp eval $i {package require mod1::test1}} msg1]
+    set code2 [catch {interp eval $i {package require mod2::test2}} msg2]
+    set out0  [interp eval $i {test0::try0}]
+    set out1  [interp eval $i {mod1::test1::try1}]
+    set out2  [interp eval $i {mod2::test2::try2}]
+
+    list [lsort [list $path0 $path1 $path2]] -- $modsA -- \
+            $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $sortA -- $out0 $out1 $out2
+} -cleanup {
+    tcl::tm::path remove [file join $ZipMountPoint auto0 modules]
+    foreach path [lreverse $oldTm] {
+        tcl::tm::path add $path
+    }
+    safe::interpDelete $i
+} -match glob -result {{{$p(:1:)} {$p(:2:)} {$p(:3:)}} -- {{$p(:1:)}} --\
+        0 0.5 0 1.0 0 2.0 --\
+        {TCLLIB ZIPDIR/auto0/modules ZIPDIR/auto0/modules/mod1\
+         ZIPDIR/auto0/modules/mod2} -- res0 res1 res2}
+# - The command safe::InterpSetConfig adds the master's [tcl::tm::list] in
+#   tokenized form to the slave's access path, and then adds all the
+#   descendants, discovered recursively by using glob.
+# - The order of the directories in the list returned by glob is system-dependent,
+#   and therefore this is true also for (a) the order of token assignment to
+#   descendants of the [tcl::tm::list] roots; and (b) the order of those same
+#   directories in the access path.  Both those things must be sorted before
+#   comparing with expected results.  The test is therefore not totally strict,
+#   but will notice missing or surplus directories.
+test safe-zipfs-9.21 {interpConfigure change the access path; check module loading; stale data case 1; zipfs} -setup {
+    set oldTm [tcl::tm::path list]
+    foreach path $oldTm {
+        tcl::tm::path remove $path
+    }
+    tcl::tm::path add [file join $ZipMountPoint auto0 modules]
+} -body {
+    set i [safe::interpCreate -accessPath [list $tcl_library]]
+
+    # Inspect.
+    set confA [safe::interpConfigure $i]
+    set sortA [mapAndSortList $PathMapp [dict get $confA -accessPath]]
+    set modsA [interp eval $i {tcl::tm::path list}]
+    set path0 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
+    set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
+    set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod2]]
+
+    # Add to access path.
+    # This injects more tokens, pushing modules to higher token numbers.
+    safe::interpConfigure $i -accessPath [list $tcl_library \
+                                           [file join $ZipMountPoint auto0 auto1] \
+                                           [file join $ZipMountPoint auto0 auto2]]
+    # Inspect.
+    set confB [safe::interpConfigure $i]
+    set sortB [mapAndSortList $PathMapp [dict get $confB -accessPath]]
+    set modsB [interp eval $i {tcl::tm::path list}]
+    set path3 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
+    set path4 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
+    set path5 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod2]]
+
+    # Load pkg data.
+    catch {interp eval $i {package require NOEXIST}}
+    catch {interp eval $i {package require mod1::NOEXIST}}
+    catch {interp eval $i {package require mod2::NOEXIST}}
+
+    # Try to load the packages and run a command from each one.
+    set code0 [catch {interp eval $i {package require test0}} msg0]
+    set code1 [catch {interp eval $i {package require mod1::test1}} msg1]
+    set code2 [catch {interp eval $i {package require mod2::test2}} msg2]
+    set out0  [interp eval $i {test0::try0}]
+    set out1  [interp eval $i {mod1::test1::try1}]
+    set out2  [interp eval $i {mod2::test2::try2}]
+
+    list [lsort [list $path0 $path1 $path2]] -- $modsA -- \
+            [lsort [list $path3 $path4 $path5]] -- $modsB -- \
+            $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $sortA -- $sortB -- \
+            $out0 $out1 $out2
+} -cleanup {
+    tcl::tm::path remove [file join $ZipMountPoint auto0 modules]
+    foreach path [lreverse $oldTm] {
+        tcl::tm::path add $path
+    }
+    safe::interpDelete $i
+} -match glob -result {{{$p(:1:)} {$p(:2:)} {$p(:3:)}} -- {{$p(:1:)}} --\
+        {{$p(:3:)} {$p(:4:)} {$p(:5:)}} -- {{$p(:3:)}} --\
+        0 0.5 0 1.0 0 2.0 --\
+        {TCLLIB ZIPDIR/auto0/modules ZIPDIR/auto0/modules/mod1\
+         ZIPDIR/auto0/modules/mod2} --\
+        {TCLLIB ZIPDIR/auto0/auto1 ZIPDIR/auto0/auto2 ZIPDIR/auto0/modules\
+         ZIPDIR/auto0/modules/mod1 ZIPDIR/auto0/modules/mod2} --\
+        res0 res1 res2}
+# See comments on lsort after test safe-zipfs-9.20.
+test safe-zipfs-9.22 {interpConfigure change the access path; check module loading; stale data case 0; zipfs} -setup {
+    set oldTm [tcl::tm::path list]
+    foreach path $oldTm {
+        tcl::tm::path remove $path
+    }
+    tcl::tm::path add [file join $ZipMountPoint auto0 modules]
+} -body {
+    set i [safe::interpCreate -accessPath [list $tcl_library]]
+
+    # Inspect.
+    set confA [safe::interpConfigure $i]
+    set sortA [mapAndSortList $PathMapp [dict get $confA -accessPath]]
+    set modsA [interp eval $i {tcl::tm::path list}]
+    set path0 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
+    set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
+    set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod2]]
+
+    # Add to access path.
+    # This injects more tokens, pushing modules to higher token numbers.
+    safe::interpConfigure $i -accessPath [list $tcl_library \
+                                          [file join $ZipMountPoint auto0 auto1] \
+                                          [file join $ZipMountPoint auto0 auto2]]
+    # Inspect.
+    set confB [safe::interpConfigure $i]
+    set sortB [mapAndSortList $PathMapp [dict get $confB -accessPath]]
+    set modsB [interp eval $i {tcl::tm::path list}]
+    set path3 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
+    set path4 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
+    set path5 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod2]]
+
+    # Try to load the packages and run a command from each one.
+    set code0 [catch {interp eval $i {package require test0}} msg0]
+    set code1 [catch {interp eval $i {package require mod1::test1}} msg1]
+    set code2 [catch {interp eval $i {package require mod2::test2}} msg2]
+    set out0  [interp eval $i {test0::try0}]
+    set out1  [interp eval $i {mod1::test1::try1}]
+    set out2  [interp eval $i {mod2::test2::try2}]
+
+    list [lsort [list $path0 $path1 $path2]] -- $modsA -- \
+            [lsort [list $path3 $path4 $path5]] -- $modsB -- \
+            $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $sortA -- $sortB -- \
+            $out0 $out1 $out2
+} -cleanup {
+    tcl::tm::path remove [file join $ZipMountPoint auto0 modules]
+    foreach path [lreverse $oldTm] {
+        tcl::tm::path add $path
+    }
+    safe::interpDelete $i
+} -match glob -result {{{$p(:1:)} {$p(:2:)} {$p(:3:)}} -- {{$p(:1:)}} --\
+        {{$p(:3:)} {$p(:4:)} {$p(:5:)}} -- {{$p(:3:)}} --\
+        0 0.5 0 1.0 0 2.0 --\
+        {TCLLIB ZIPDIR/auto0/modules ZIPDIR/auto0/modules/mod1\
+         ZIPDIR/auto0/modules/mod2} --\
+        {TCLLIB ZIPDIR/auto0/auto1 ZIPDIR/auto0/auto2 ZIPDIR/auto0/modules\
+         ZIPDIR/auto0/modules/mod1 ZIPDIR/auto0/modules/mod2} --\
+        res0 res1 res2}
+# See comments on lsort after test safe-zipfs-9.20.
+test safe-zipfs-9.23 {interpConfigure change the access path; check module loading; stale data case 3; zipfs} -setup {
+    set oldTm [tcl::tm::path list]
+    foreach path $oldTm {
+        tcl::tm::path remove $path
+    }
+    tcl::tm::path add [file join $ZipMountPoint auto0 modules]
+} -body {
+    set i [safe::interpCreate -accessPath [list $tcl_library]]
+
+    # Inspect.
+    set confA [safe::interpConfigure $i]
+    set sortA [mapAndSortList $PathMapp [dict get $confA -accessPath]]
+    set modsA [interp eval $i {tcl::tm::path list}]
+    set path0 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
+    set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
+    set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod2]]
+
+    # Force the interpreter to acquire pkg data which will soon become stale.
+    catch {interp eval $i {package require NOEXIST}}
+    catch {interp eval $i {package require mod1::NOEXIST}}
+    catch {interp eval $i {package require mod2::NOEXIST}}
+
+    # Add to access path.
+    # This injects more tokens, pushing modules to higher token numbers.
+    safe::interpConfigure $i -accessPath [list $tcl_library \
+                                           [file join $ZipMountPoint auto0 auto1] \
+                                           [file join $ZipMountPoint auto0 auto2]]
+    # Inspect.
+    set confB [safe::interpConfigure $i]
+    set sortB [mapAndSortList $PathMapp [dict get $confB -accessPath]]
+    set modsB [interp eval $i {tcl::tm::path list}]
+    set path3 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
+    set path4 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
+    set path5 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod2]]
+
+    # Refresh stale pkg data.
+    catch {interp eval $i {package require NOEXIST}}
+    catch {interp eval $i {package require mod1::NOEXIST}}
+    catch {interp eval $i {package require mod2::NOEXIST}}
+
+    # Try to load the packages and run a command from each one.
+    set code0 [catch {interp eval $i {package require test0}} msg0]
+    set code1 [catch {interp eval $i {package require mod1::test1}} msg1]
+    set code2 [catch {interp eval $i {package require mod2::test2}} msg2]
+    set out0  [interp eval $i {test0::try0}]
+    set out1  [interp eval $i {mod1::test1::try1}]
+    set out2  [interp eval $i {mod2::test2::try2}]
+
+    list [lsort [list $path0 $path1 $path2]] -- $modsA -- \
+            [lsort [list $path3 $path4 $path5]] -- $modsB -- \
+            $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $sortA -- $sortB -- \
+            $out0 $out1 $out2
+} -cleanup {
+    tcl::tm::path remove [file join $ZipMountPoint auto0 modules]
+    foreach path [lreverse $oldTm] {
+        tcl::tm::path add $path
+    }
+    safe::interpDelete $i
+} -match glob -result {{{$p(:1:)} {$p(:2:)} {$p(:3:)}} -- {{$p(:1:)}} --\
+        {{$p(:3:)} {$p(:4:)} {$p(:5:)}} -- {{$p(:3:)}} --\
+        0 0.5 0 1.0 0 2.0 --\
+        {TCLLIB ZIPDIR/auto0/modules ZIPDIR/auto0/modules/mod1\
+         ZIPDIR/auto0/modules/mod2} --\
+        {TCLLIB ZIPDIR/auto0/auto1 ZIPDIR/auto0/auto2 ZIPDIR/auto0/modules\
+         ZIPDIR/auto0/modules/mod1 ZIPDIR/auto0/modules/mod2} --\
+        res0 res1 res2}
+# See comments on lsort after test safe-zipfs-9.20.
+test safe-zipfs-9.24 {interpConfigure change the access path; check module loading; stale data case 2 (worst case); zipfs} -setup {
+    set oldTm [tcl::tm::path list]
+    foreach path $oldTm {
+        tcl::tm::path remove $path
+    }
+    tcl::tm::path add [file join $ZipMountPoint auto0 modules]
+} -body {
+    set i [safe::interpCreate -accessPath [list $tcl_library]]
+
+    # Inspect.
+    set confA [safe::interpConfigure $i]
+    set sortA [mapAndSortList $PathMapp [dict get $confA -accessPath]]
+    set modsA [interp eval $i {tcl::tm::path list}]
+    set path0 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
+    set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
+    set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod2]]
+
+    # Force the interpreter to acquire pkg data which will soon become stale.
+    catch {interp eval $i {package require NOEXIST}}
+    catch {interp eval $i {package require mod1::NOEXIST}}
+    catch {interp eval $i {package require mod2::NOEXIST}}
+
+    # Add to access path.
+    # This injects more tokens, pushing modules to higher token numbers.
+    safe::interpConfigure $i -accessPath [list $tcl_library \
+                                           [file join $ZipMountPoint auto0 auto1] \
+                                           [file join $ZipMountPoint auto0 auto2]]
+    # Inspect.
+    set confB [safe::interpConfigure $i]
+    set sortB [mapAndSortList $PathMapp [dict get $confB -accessPath]]
+    set modsB [interp eval $i {tcl::tm::path list}]
+    set path3 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
+    set path4 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
+    set path5 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod2]]
+
+    # Try to load the packages and run a command from each one.
+    set code0 [catch {interp eval $i {package require test0}} msg0]
+    set code1 [catch {interp eval $i {package require mod1::test1}} msg1]
+    set code2 [catch {interp eval $i {package require mod2::test2}} msg2]
+    set out0  [interp eval $i {test0::try0}]
+    set out1  [interp eval $i {mod1::test1::try1}]
+    set out2  [interp eval $i {mod2::test2::try2}]
+
+    list [lsort [list $path0 $path1 $path2]] -- $modsA -- \
+            [lsort [list $path3 $path4 $path5]] -- $modsB -- \
+            $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $sortA -- $sortB -- \
+            $out0 $out1 $out2
+} -cleanup {
+    tcl::tm::path remove [file join $ZipMountPoint auto0 modules]
+    foreach path [lreverse $oldTm] {
+        tcl::tm::path add $path
+    }
+    safe::interpDelete $i
+} -match glob -result {{{$p(:1:)} {$p(:2:)} {$p(:3:)}} -- {{$p(:1:)}} --\
+        {{$p(:3:)} {$p(:4:)} {$p(:5:)}} -- {{$p(:3:)}} --\
+        0 0.5 0 1.0 0 2.0 --\
+        {TCLLIB ZIPDIR/auto0/modules ZIPDIR/auto0/modules/mod1\
+         ZIPDIR/auto0/modules/mod2} --\
+        {TCLLIB ZIPDIR/auto0/auto1 ZIPDIR/auto0/auto2 ZIPDIR/auto0/modules\
+         ZIPDIR/auto0/modules/mod1 ZIPDIR/auto0/modules/mod2} --\
+        res0 res1 res2}
+# See comments on lsort after test safe-zipfs-9.20.
+
+set ::auto_path $SaveAutoPath
+zipfs unmount ${ZipMountPoint}
+unset SaveAutoPath TestsDir ZipMountPoint PathMapp
+rename mapList {}
+rename mapAndSortList {}
+# cleanup
+::tcltest::cleanupTests
+return
+
+# Local Variables:
+# mode: tcl
+# End:
diff --git a/tests/safe.test b/tests/safe.test
index be29a8d..4157596 100644
--- a/tests/safe.test
+++ b/tests/safe.test
@@ -4,6 +4,16 @@
 # using safe interpreters. Sourcing this file into tcl runs the tests and
 # generates output for errors. No output means no errors were found.
 #
+# The defunct package http 1.0 was convenient for testing package loading.
+# - Tests that used http are replaced here with tests that use example packages
+#   provided in subdirectory auto0 of the tests directory, which are independent
+#   of any changes made to the packages provided with Tcl itself.
+#   - These are tests 7.1 7.2 7.4 9.11 9.13
+#   - Tests 5.* test the example packages themselves before they
+#     are used to test Safe Base interpreters.
+# - Alternative tests using stock packages of Tcl 8.7 are in file
+#   safe-stock87.test.
+#
 # Copyright (c) 1995-1996 Sun Microsystems, Inc.
 # Copyright (c) 1998-1999 by Scriptics Corporation.
 #
@@ -26,67 +36,6 @@ set ::auto_path [info library]
 set TestsDir [file normalize [file dirname [info script]]]
 set PathMapp [list $tcl_library TCLLIB $TestsDir TESTSDIR]
 
-# The defunct package http 1.0 was convenient for testing package loading.
-# - Replaced here with tests using example packages provided in subdirectory
-#   auto0 of the tests directory, which are independent of any changes
-#   made to the packages provided with Tcl.
-#   - These are tests 7.1 7.2 7.4 9.10 9.12
-#   - Tests 7.0[a-f] test the example packages themselves before they
-#     are used to test Safe Base interpreters.
-# - Alternatively use packages opt and (from cookiejar) tcl::idna.
-#   - These alternative tests have suffix "opt".
-#   - These are 7.[124]opt, 9.1[02]opt
-#   - Tests 7.[124]opt, 9.1[02]opt use "package require opt".
-#   - Tests 9.1[02]opt also use "package require tcl::idna".
-#
-# When using package opt for testing positive/negative package search:
-# - The directory location and the error message depend on whether
-#   and how the package is installed.
-
-# Error message for tests 7.2opt for "package require opt".
-if {[string match *zipfs:/* [info library]]} {
-    # pkgIndex.tcl is in [info library]
-    # file to be sourced is in [info library]/opt*
-    set pkgOptErrMsg {permission denied}
-} else {
-    # pkgIndex.tcl and file to be sourced are
-    # both in [info library]/opt*
-    set pkgOptErrMsg {can't find package opt}
-}
-
-# Directory of opt for tests 7.4opt, 9.10opt, 9.12opt
-# for "package require opt".
-if {[file exists [file join [info library] opt0.4]]} {
-    # Installed files in lib8.7/opt0.4
-    set pkgOptDir opt0.4
-} elseif {[file exists [file join [info library] opt]]} {
-    # Installed files in zipfs, or source files used by "make test"
-    set pkgOptDir opt
-} else {
-    error {cannot find opt library}
-}
-
-# Directory of cookiejar for tests 9.10opt, 9.12opt
-# for "package require tcl::idna".
-if {[file exists [file join [info library] cookiejar0.2]]} {
-    # Installed files in lib8.7/cookiejar0.2
-    set pkgJarDir cookiejar0.2
-} elseif {[file exists [file join [info library] cookiejar]]} {
-    # Installed files in zipfs, or source files used by "make test"
-    set pkgJarDir cookiejar
-} else {
-    error {cannot find cookiejar library}
-}
-
-set TestsDir [file normalize [file dirname [info script]]]
-set ZipMountPoint [zipfs root]auto-files
-zipfs mount $ZipMountPoint [file join $TestsDir auto-files.zip]
-
-set PathMapp {}
-lappend PathMapp [file join [info library] $pkgOptDir] TCLLIB/OPTDIR
-lappend PathMapp [file join [info library] $pkgJarDir] TCLLIB/JARDIR
-lappend PathMapp $tcl_library TCLLIB $TestsDir TESTSDIR $ZipMountPoint ZIPDIR
-
 proc mapList {map listIn} {
     set listOut {}
     foreach element $listIn {
@@ -216,51 +165,11 @@ test safe-4.6 {safe::interpDelete, indirectly} -setup {
     a eval exit
 } -result ""
 
-# The following test checks whether the definition of tcl_endOfWord can be
-# obtained from auto_loading.
-
-test safe-5.1 {test auto-loading in safe interpreters} -setup {
-    catch {safe::interpDelete a}
-    safe::interpCreate a
-} -body {
-    interp eval a {tcl_endOfWord "" 0}
-} -cleanup {
-    safe::interpDelete a
-} -result -1
-
-# test safe interps 'information leak'
-proc SafeEval {script} {
-    # Helper procedure that ensures the safe interp is cleaned up even if
-    # there is a failure in the script.
-    set SafeInterp [interp create -safe]
-    catch {$SafeInterp eval $script} msg opts
-    interp delete $SafeInterp
-    return -options $opts $msg
-}
-
-test safe-6.1 {test safe interpreters knowledge of the world} {
-    lsort [SafeEval {info globals}]
-} {tcl_interactive tcl_patchLevel tcl_platform tcl_version}
-test safe-6.2 {test safe interpreters knowledge of the world} {
-    SafeEval {info script}
-} {}
-test safe-6.3 {test safe interpreters knowledge of the world} {
-    set r [SafeEval {array names tcl_platform}]
-    # If running a windows-debug shell, remove the "debug" element from r.
-    if {[testConstraint win]} {
-	set r [lsearch -all -inline -not -exact $r "debug"]
-    }
-    set r [lsearch -all -inline -not -exact $r "threaded"]
-    lsort $r
-} {byteOrder engine pathSeparator platform pointerSize wordSize}
-
-rename SafeEval {}
-# More test should be added to check that hostname, nameofexecutable, aren't
-# leaking infos, but they still do...
-
-# Tests 7.0* test the example files before using them to test safe interpreters.
+# The old test "safe-5.1" has been moved to "safe-stock87-9.8".
+# A replacement test using example files is "safe-9.8".
+# Tests 5.* test the example files before using them to test safe interpreters.
 
-test safe-7.0a {example tclIndex commands, test in master interpreter} -setup {
+test safe-5.1 {example tclIndex commands, test in master interpreter} -setup {
     set tmpAutoPath $::auto_path
     lappend ::auto_path [file join $TestsDir auto0 auto1] [file join $TestsDir auto0 auto2]
 } -body {
@@ -274,21 +183,7 @@ test safe-7.0a {example tclIndex commands, test in master interpreter} -setup {
     set ::auto_path $tmpAutoPath
     auto_reset
 } -match glob -result {0 ok1 0 ok2}
-test safe-7.0az {example tclIndex commands, test in master interpreter; zipfs} -setup {
-    set tmpAutoPath $::auto_path
-    lappend ::auto_path [file join $ZipMountPoint auto0 auto1] [file join $ZipMountPoint auto0 auto2]
-} -body {
-    # Try to load the commands.
-    set code3 [catch report1 msg3]
-    set code4 [catch report2 msg4]
-    list $code3 $msg3 $code4 $msg4
-} -cleanup {
-    catch {rename report1 {}}
-    catch {rename report2 {}}
-    set ::auto_path $tmpAutoPath
-    auto_reset
-} -match glob -result {0 ok1 0 ok2}
-test safe-7.0b {example tclIndex commands, negative test in master interpreter} -setup {
+test safe-5.2 {example tclIndex commands, negative test in master interpreter} -setup {
     set tmpAutoPath $::auto_path
     lappend ::auto_path [file join $TestsDir auto0]
 } -body {
@@ -302,21 +197,7 @@ test safe-7.0b {example tclIndex commands, negative test in master interpreter}
     set ::auto_path $tmpAutoPath
     auto_reset
 } -match glob -result {1 {invalid command name "report1"} 1 {invalid command name "report2"}}
-test safe-7.0bz {example tclIndex commands, negative test in master interpreter; zipfs} -setup {
-    set tmpAutoPath $::auto_path
-    lappend ::auto_path [file join $ZipMountPoint auto0]
-} -body {
-    # Try to load the commands.
-    set code3 [catch report1 msg3]
-    set code4 [catch report2 msg4]
-    list $code3 $msg3 $code4 $msg4
-} -cleanup {
-    catch {rename report1 {}}
-    catch {rename report2 {}}
-    set ::auto_path $tmpAutoPath
-    auto_reset
-} -match glob -result {1 {invalid command name "report1"} 1 {invalid command name "report2"}}
-test safe-7.0c {example pkgIndex.tcl packages, test in master interpreter, child directories} -setup {
+test safe-5.3 {example pkgIndex.tcl packages, test in master interpreter, child directories} -setup {
     set tmpAutoPath $::auto_path
     lappend ::auto_path [file join $TestsDir auto0]
 } -body {
@@ -333,24 +214,7 @@ test safe-7.0c {example pkgIndex.tcl packages, test in master interpreter, child
     catch {rename HeresPackage1 {}}
     catch {rename HeresPackage2 {}}
 } -match glob -result {0 1.2.3 0 2.3.4 0 OK1 0 OK2}
-test safe-7.0cz {example pkgIndex.tcl packages, test in master interpreter, child directories; zipfs} -setup {
-    set tmpAutoPath $::auto_path
-    lappend ::auto_path [file join $ZipMountPoint auto0]
-} -body {
-    # Try to load the packages and run a command from each one.
-    set code3 [catch {package require SafeTestPackage1} msg3]
-    set code4 [catch {package require SafeTestPackage2} msg4]
-    set code5 [catch HeresPackage1 msg5]
-    set code6 [catch HeresPackage2 msg6]
-    list $code3 $msg3 $code4 $msg4 $code5 $msg5 $code6 $msg6
-} -cleanup {
-    set ::auto_path $tmpAutoPath
-    catch {package forget SafeTestPackage1}
-    catch {package forget SafeTestPackage2}
-    catch {rename HeresPackage1 {}}
-    catch {rename HeresPackage2 {}}
-} -match glob -result {0 1.2.3 0 2.3.4 0 OK1 0 OK2}
-test safe-7.0d {example pkgIndex.tcl packages, test in master interpreter, main directories} -setup {
+test safe-5.4 {example pkgIndex.tcl packages, test in master interpreter, main directories} -setup {
     set tmpAutoPath $::auto_path
     lappend ::auto_path [file join $TestsDir auto0 auto1] \
                         [file join $TestsDir auto0 auto2]
@@ -368,25 +232,7 @@ test safe-7.0d {example pkgIndex.tcl packages, test in master interpreter, main
     catch {rename HeresPackage1 {}}
     catch {rename HeresPackage2 {}}
 } -match glob -result {0 1.2.3 0 2.3.4 0 OK1 0 OK2}
-test safe-7.0dz {example pkgIndex.tcl packages, test in master interpreter, main directories; zipfs} -setup {
-    set tmpAutoPath $::auto_path
-    lappend ::auto_path [file join $ZipMountPoint auto0 auto1] \
-                        [file join $ZipMountPoint auto0 auto2]
-} -body {
-    # Try to load the packages and run a command from each one.
-    set code3 [catch {package require SafeTestPackage1} msg3]
-    set code4 [catch {package require SafeTestPackage2} msg4]
-    set code5 [catch HeresPackage1 msg5]
-    set code6 [catch HeresPackage2 msg6]
-    list $code3 $msg3 $code4 $msg4 $code5 $msg5 $code6 $msg6
-} -cleanup {
-    set ::auto_path $tmpAutoPath
-    catch {package forget SafeTestPackage1}
-    catch {package forget SafeTestPackage2}
-    catch {rename HeresPackage1 {}}
-    catch {rename HeresPackage2 {}}
-} -match glob -result {0 1.2.3 0 2.3.4 0 OK1 0 OK2}
-test safe-7.0e {example modules packages, test in master interpreter, replace path} -setup {
+test safe-5.5 {example modules packages, test in master interpreter, replace path} -setup {
     set oldTm [tcl::tm::path list]
     foreach path $oldTm {
         tcl::tm::path remove $path
@@ -412,33 +258,7 @@ test safe-7.0e {example modules packages, test in master interpreter, replace pa
     catch {namespace delete ::test0}
     catch {namespace delete ::mod1}
 } -match glob -result {0 0.5 0 1.0 0 2.0 -- res0 res1 res2}
-test safe-7.0ez {example modules packages, test in master interpreter, replace path; zipfs} -setup {
-    set oldTm [tcl::tm::path list]
-    foreach path $oldTm {
-        tcl::tm::path remove $path
-    }
-    tcl::tm::path add [file join $ZipMountPoint auto0 modules]
-} -body {
-    # Try to load the modules and run a command from each one.
-    set code0 [catch {package require test0} msg0]
-    set code1 [catch {package require mod1::test1} msg1]
-    set code2 [catch {package require mod2::test2} msg2]
-    set out0  [test0::try0]
-    set out1  [mod1::test1::try1]
-    set out2  [mod2::test2::try2]
-    list $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $out0 $out1 $out2
-} -cleanup {
-    tcl::tm::path remove [file join $ZipMountPoint auto0 modules]
-    foreach path [lreverse $oldTm] {
-        tcl::tm::path add $path
-    }
-    catch {package forget test0}
-    catch {package forget mod1::test1}
-    catch {package forget mod2::test2}
-    catch {namespace delete ::test0}
-    catch {namespace delete ::mod1}
-} -match glob -result {0 0.5 0 1.0 0 2.0 -- res0 res1 res2}
-test safe-7.0f {example modules packages, test in master interpreter, append to path} -setup {
+test safe-5.6 {example modules packages, test in master interpreter, append to path} -setup {
     tcl::tm::path add [file join $TestsDir auto0 modules]
 } -body {
     # Try to load the modules and run a command from each one.
@@ -457,25 +277,37 @@ test safe-7.0f {example modules packages, test in master interpreter, append to
     catch {namespace delete ::test0}
     catch {namespace delete ::mod1}
 } -match glob -result {0 0.5 0 1.0 0 2.0 -- res0 res1 res2}
-test safe-7.0fz {example modules packages, test in master interpreter, append to path; zipfs} -setup {
-    tcl::tm::path add [file join $ZipMountPoint auto0 modules]
-} -body {
-    # Try to load the modules and run a command from each one.
-    set code0 [catch {package require test0} msg0]
-    set code1 [catch {package require mod1::test1} msg1]
-    set code2 [catch {package require mod2::test2} msg2]
-    set out0  [test0::try0]
-    set out1  [mod1::test1::try1]
-    set out2  [mod2::test2::try2]
-    list $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $out0 $out1 $out2
-} -cleanup {
-    tcl::tm::path remove [file join $ZipMountPoint auto0 modules]
-    catch {package forget test0}
-    catch {package forget mod1::test1}
-    catch {package forget mod2::test2}
-    catch {namespace delete ::test0}
-    catch {namespace delete ::mod1}
-} -match glob -result {0 0.5 0 1.0 0 2.0 -- res0 res1 res2}
+
+
+# test safe interps 'information leak'
+proc SafeEval {script} {
+    # Helper procedure that ensures the safe interp is cleaned up even if
+    # there is a failure in the script.
+    set SafeInterp [interp create -safe]
+    catch {$SafeInterp eval $script} msg opts
+    interp delete $SafeInterp
+    return -options $opts $msg
+}
+
+test safe-6.1 {test safe interpreters knowledge of the world} {
+    lsort [SafeEval {info globals}]
+} {tcl_interactive tcl_patchLevel tcl_platform tcl_version}
+test safe-6.2 {test safe interpreters knowledge of the world} {
+    SafeEval {info script}
+} {}
+test safe-6.3 {test safe interpreters knowledge of the world} {
+    set r [SafeEval {array names tcl_platform}]
+    # If running a windows-debug shell, remove the "debug" element from r.
+    if {[testConstraint win]} {
+	set r [lsearch -all -inline -not -exact $r "debug"]
+    }
+    set r [lsearch -all -inline -not -exact $r "threaded"]
+    lsort $r
+} {byteOrder engine pathSeparator platform pointerSize wordSize}
+
+rename SafeEval {}
+# More test should be added to check that hostname, nameofexecutable, aren't
+# leaking infos, but they still do...
 
 # high level general test
 # Use example packages not http1.0
@@ -495,38 +327,6 @@ test safe-7.1 {tests that everything works at high level} -setup {
 } -cleanup {
     safe::interpDelete $i
 } -match glob -result 1.2.3
-# high level general test
-# Use zipped example packages not tcl8.x/opt
-test safe-7.1z {tests that everything works at high level; zipfs} -setup {
-    set tmpAutoPath $::auto_path
-    lappend ::auto_path [file join $ZipMountPoint auto0]
-    set i [safe::interpCreate]
-    set ::auto_path $tmpAutoPath
-} -body {
-    # no error shall occur:
-    # (because the default access_path shall include 1st level sub dirs so
-    #  package require in a slave works like in the master)
-    set v [interp eval $i {package require SafeTestPackage1}]
-    # no error shall occur:
-    interp eval $i {HeresPackage1}
-    set v
-} -cleanup {
-    safe::interpDelete $i
-} -match glob -result 1.2.3
-# high level general test
-test safe-7.1opt {tests that everything works at high level, uses pkg opt} -setup {
-    set i [safe::interpCreate]
-} -body {
-    # no error shall occur:
-    # (because the default access_path shall include 1st level sub dirs so
-    #  package require in a slave works like in the master)
-    set v [interp eval $i {package require opt}]
-    # no error shall occur:
-    interp eval $i {::tcl::Lempty {a list}}
-    set v
-} -cleanup {
-    safe::interpDelete $i
-} -match glob -result 0.4.*
 test safe-7.2 {tests specific path and interpFind/AddToAccessPath} -setup {
 } -body {
     set i [safe::interpCreate -nostat -nested 1 -accessPath [list [info library]]]
@@ -547,43 +347,6 @@ test safe-7.2 {tests specific path and interpFind/AddToAccessPath} -setup {
 } -match glob -result {{$p(:0:)} {$p(:*:)} {$p(:*:)} --\
         1 {can't find package SafeTestPackage1} --\
         {TCLLIB */dummy/unixlike/test/path TESTSDIR/auto0} -- {}}
-test safe-7.2z {tests specific path and interpFind/AddToAccessPath; zipfs} -setup {
-} -body {
-    set i [safe::interpCreate -nostat -nested 1 -accessPath [list [info library]]]
-    # should not add anything (p0)
-    set token1 [safe::interpAddToAccessPath $i [info library]]
-    # should add as p* (not p1 if master has a module path)
-    set token2 [safe::interpAddToAccessPath $i "/dummy/unixlike/test/path"]
-    # should add as p* (not p2 if master has a module path)
-    set token3 [safe::interpAddToAccessPath $i [file join $ZipMountPoint auto0]]
-    set confA [safe::interpConfigure $i]
-    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
-    # an error shall occur (SafeTestPackage1 is not anymore in the secure 0-level
-    # provided deep path)
-    list $token1 $token2 $token3 -- \
-            [catch {interp eval $i {package require SafeTestPackage1}} msg] $msg -- \
-            $mappA -- [safe::interpDelete $i]
-} -cleanup {
-} -match glob -result {{$p(:0:)} {$p(:*:)} {$p(:*:)} --\
-        1 {can't find package SafeTestPackage1} --\
-        {TCLLIB */dummy/unixlike/test/path ZIPDIR/auto0} -- {}}
-test safe-7.2opt {tests specific path and interpFind/AddToAccessPath, uses pkg opt} -setup {
-} -body {
-    set i [safe::interpCreate -nostat -nested 1 -accessPath [list [info library]]]
-    # should not add anything (p0)
-    set token1 [safe::interpAddToAccessPath $i [info library]]
-    # should add as p* (not p1 if master has a module path)
-    set token2 [safe::interpAddToAccessPath $i "/dummy/unixlike/test/path"]
-    # an error shall occur (opt is not anymore in the secure 0-level
-    # provided deep path)
-    set confA [safe::interpConfigure $i]
-    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
-    list $token1 $token2 -- \
-	    [catch {interp eval $i {package require opt}} msg] $msg -- \
-	    $mappA -- [safe::interpDelete $i]
-} -cleanup {
-} -match glob -result "{\$p(:0:)} {\$p(:*:)} -- 1 {$pkgOptErrMsg} --\
-        {TCLLIB */dummy/unixlike/test/path} -- {}"
 test safe-7.3 {check that safe subinterpreters work} {
     set g [interp slaves]
     if {$g ne {}} {
@@ -616,42 +379,6 @@ test safe-7.4 {tests specific path and positive search} -setup {
 } -cleanup {
 } -match glob -result {{$p(:0:)} {$p(:*:)} -- 0 1.2.3 --\
         {TCLLIB * TESTSDIR/auto0/auto1} -- {}}
-test safe-7.4z {tests specific path and positive search; zipfs} -setup {
-} -body {
-    set i [safe::interpCreate -nostat -nested 1 -accessPath [list [info library]]]
-    # should not add anything (p0)
-    set token1 [safe::interpAddToAccessPath $i [info library]]
-    # should add as p* (not p1 if master has a module path)
-    set token2 [safe::interpAddToAccessPath $i [file join $ZipMountPoint auto0 auto1]]
-    set confA [safe::interpConfigure $i]
-    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
-    # this time, unlike test safe-7.2, SafeTestPackage1 should be found
-    list $token1 $token2 -- \
-	    [catch {interp eval $i {package require SafeTestPackage1}} msg] $msg -- \
-	    $mappA -- [safe::interpDelete $i]
-    # Note that the glob match elides directories (those from the module path)
-    # other than the first and last in the access path.
-} -cleanup {
-} -match glob -result {{$p(:0:)} {$p(:*:)} -- 0 1.2.3 --\
-        {TCLLIB * ZIPDIR/auto0/auto1} -- {}}
-test safe-7.4opt {tests specific path and positive search, uses pkg opt} -setup {
-} -body {
-    set i [safe::interpCreate -nostat -nested 1 -accessPath [list [info library]]]
-    # should not add anything (p0)
-    set token1 [safe::interpAddToAccessPath $i [info library]]
-    # should add as p* (not p1 if master has a module path)
-    set token2 [safe::interpAddToAccessPath $i [file join [info library] $pkgOptDir]]
-    set confA [safe::interpConfigure $i]
-    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
-    # this time, unlike test safe-7.2opt, opt should be found
-    list $token1 $token2 -- \
-            [catch {interp eval $i {package require opt}} msg] $msg -- \
-            $mappA -- [safe::interpDelete $i]
-    # Note that the glob match elides directories (those from the module path)
-    # other than the first and last in the access path.
-} -cleanup {
-} -match glob -result {{$p(:0:)} {$p(:*:)} -- 0 0.4.* --\
-        {TCLLIB * TCLLIB/OPTDIR} -- {}}
 
 # test source control on file name
 test safe-8.1 {safe source control on file} -setup {
@@ -900,7 +627,7 @@ test safe-9.7 {interpConfigure widget like behaviour (demystified)} -body {
         {-accessPath *} {-nested 1} {-statics 0} {-deleteHook {foo bar}}\
         {-accessPath * -statics 1 -nested 1 -deleteHook {foo bar}}\
         {-accessPath * -statics 0 -nested 0 -deleteHook toto}}
-test safe-9.8 {interpConfigure change the access path; tclIndex commands unaffected by token rearrangement (dummy test of doreset)} -setup {
+test safe-9.8 {test autoloading commands indexed in tclIndex files} -setup {
 } -body {
     set i [safe::interpCreate -accessPath [list $tcl_library \
                                             [file join $TestsDir auto0 auto1] \
@@ -911,8 +638,28 @@ test safe-9.8 {interpConfigure change the access path; tclIndex commands unaffec
     set path1 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 auto1]]
     set path2 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 auto2]]
 
-    # Load auto_load data.
-    interp eval $i {catch nonExistentCommand}
+    # Load and run the commands.
+    set code1 [catch {interp eval $i {report1}} msg1]
+    set code2 [catch {interp eval $i {report2}} msg2]
+
+    list $path1 $path2 -- $code1 $msg1 $code2 $msg2 -- $mappA
+} -cleanup {
+    safe::interpDelete $i
+} -match glob -result {{$p(:1:)} {$p(:2:)} -- 0 ok1 0 ok2 --\
+        {TCLLIB TESTSDIR/auto0/auto1 TESTSDIR/auto0/auto2*}}
+test safe-9.9 {interpConfigure change the access path; tclIndex commands unaffected by token rearrangement (dummy test of doreset)} -setup {
+} -body {
+    set i [safe::interpCreate -accessPath [list $tcl_library \
+                                            [file join $TestsDir auto0 auto1] \
+                                            [file join $TestsDir auto0 auto2]]]
+    # Inspect.
+    set confA [safe::interpConfigure $i]
+    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
+    set path1 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 auto1]]
+    set path2 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 auto2]]
+
+    # Load auto_load data.
+    interp eval $i {catch nonExistentCommand}
 
     # Load and run the commands.
     # This guarantees the test will pass even if the tokens are swapped.
@@ -939,7 +686,7 @@ test safe-9.8 {interpConfigure change the access path; tclIndex commands unaffec
 } -match glob -result {{$p(:1:)} {$p(:2:)} -- {$p(:2:)} {$p(:1:)} -- 0 ok1 0 ok2 --\
         {TCLLIB TESTSDIR/auto0/auto1 TESTSDIR/auto0/auto2*} --\
         {TCLLIB TESTSDIR/auto0/auto2 TESTSDIR/auto0/auto1*}}
-test safe-9.9 {interpConfigure change the access path; tclIndex commands unaffected by token rearrangement (actual test of doreset)} -setup {
+test safe-9.10 {interpConfigure change the access path; tclIndex commands unaffected by token rearrangement (actual test of doreset)} -setup {
 } -body {
     set i [safe::interpCreate -accessPath [list $tcl_library \
                                             [file join $TestsDir auto0 auto1] \
@@ -977,7 +724,7 @@ test safe-9.9 {interpConfigure change the access path; tclIndex commands unaffec
         0 ok1 0 ok2 --\
         {TCLLIB TESTSDIR/auto0/auto1 TESTSDIR/auto0/auto2*} --\
         {TCLLIB TESTSDIR/auto0/auto2 TESTSDIR/auto0/auto1*}}
-test safe-9.10 {interpConfigure change the access path; pkgIndex.tcl packages unaffected by token rearrangement} -setup {
+test safe-9.11 {interpConfigure change the access path; pkgIndex.tcl packages unaffected by token rearrangement} -setup {
 } -body {
     # For complete correspondence to safe-9.10opt, include auto0 in access path.
     set i [safe::interpCreate -accessPath [list $tcl_library \
@@ -1021,7 +768,7 @@ test safe-9.10 {interpConfigure change the access path; pkgIndex.tcl packages un
         {TCLLIB TESTSDIR/auto0 TESTSDIR/auto0/auto1 TESTSDIR/auto0/auto2*} --\
         {TCLLIB TESTSDIR/auto0 TESTSDIR/auto0/auto2 TESTSDIR/auto0/auto1*} --\
         0 OK1 0 OK2}
-test safe-9.11 {interpConfigure change the access path; pkgIndex.tcl packages unaffected by token rearrangement, 9.10 without path auto0} -setup {
+test safe-9.12 {interpConfigure change the access path; pkgIndex.tcl packages unaffected by token rearrangement, 9.10 without path auto0} -setup {
 } -body {
     set i [safe::interpCreate -accessPath [list $tcl_library \
                                             [file join $TestsDir auto0 auto1] \
@@ -1061,7 +808,7 @@ test safe-9.11 {interpConfigure change the access path; pkgIndex.tcl packages un
         {TCLLIB TESTSDIR/auto0/auto1 TESTSDIR/auto0/auto2*} --\
         {TCLLIB TESTSDIR/auto0/auto2 TESTSDIR/auto0/auto1*} --\
         0 OK1 0 OK2}
-test safe-9.12 {interpConfigure change the access path; pkgIndex.tcl packages fail if directory de-listed} -setup {
+test safe-9.13 {interpConfigure change the access path; pkgIndex.tcl packages fail if directory de-listed} -setup {
 } -body {
     set i [safe::interpCreate -accessPath [list $tcl_library \
                                             [file join $TestsDir auto0 auto1] \
@@ -1390,1081 +1137,6 @@ test safe-9.24 {interpConfigure change the access path; check module loading; st
         res0 res1 res2}
 # See comments on lsort after test safe-9.20.
 
-test safe-9.7 {interpConfigure widget like behaviour (demystified)} -body {
-   # this test shall work, believed equivalent to 9.6
-    set i [safe::interpCreate \
-	    -noStatics \
-	    -nestedLoadOk \
-	    -deleteHook {foo bar} \
-    ]
-
-	   safe::interpConfigure $i -accessPath /foo/bar
-    set a [safe::interpConfigure $i]
-    set b [safe::interpConfigure $i -aCCess]
-    set c [safe::interpConfigure $i -nested]
-    set d [safe::interpConfigure $i -statics]
-    set e [safe::interpConfigure $i -DEL]
-	   safe::interpConfigure $i -accessPath /blah -statics 1
-    set f [safe::interpConfigure $i]
-	   safe::interpConfigure $i -deleteHook toto -nosta -nested 0
-    set g [safe::interpConfigure $i]
-
-    list $a $b $c $d $e $f $g
-} -cleanup {
-    safe::interpDelete $i
-} -match glob -result {{-accessPath * -statics 0 -nested 1 -deleteHook {foo bar}} {-accessPath *} {-nested 1} {-statics 0} {-deleteHook {foo bar}} {-accessPath * -statics 1 -nested 1 -deleteHook {foo bar}} {-accessPath * -statics 0 -nested 0 -deleteHook toto}}
-
-test safe-9.8 {interpConfigure change the access path; tclIndex commands unaffected by token rearrangement (dummy test of doreset)} -setup {
-} -body {
-    set i [safe::interpCreate -accessPath [list $tcl_library \
-                                            [file join $TestsDir auto0 auto1] \
-                                            [file join $TestsDir auto0 auto2]]]
-    # Inspect.
-    set confA [safe::interpConfigure $i]
-    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
-    set path1 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 auto1]]
-    set path2 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 auto2]]
-
-    # Load auto_load data.
-    interp eval $i {catch nonExistentCommand}
-
-    # Load and run the commands.
-    # This guarantees the test will pass even if the tokens are swapped.
-    set code1 [catch {interp eval $i {report1}} msg1]
-    set code2 [catch {interp eval $i {report2}} msg2]
-
-    # Rearrange access path.  Swap tokens {$p(:1:)} and {$p(:2:)}.
-    safe::interpConfigure $i -accessPath [list $tcl_library \
-                                           [file join $TestsDir auto0 auto2] \
-                                           [file join $TestsDir auto0 auto1]]
-
-    # Inspect.
-    set confB [safe::interpConfigure $i]
-    set mappB [mapList $PathMapp [dict get $confB -accessPath]]
-    set path3 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 auto1]]
-    set path4 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 auto2]]
-
-    # Run the commands.
-    set code3 [catch {interp eval $i {report1}} msg3]
-    set code4 [catch {interp eval $i {report2}} msg4]
-
-    list $path1 $path2 -- $path3 $path4 -- $code3 $msg3 $code4 $msg4 -- $mappA -- $mappB
-} -cleanup {
-    safe::interpDelete $i
-} -match glob -result {{$p(:1:)} {$p(:2:)} -- {$p(:2:)} {$p(:1:)} -- 0 ok1 0 ok2 --\
-        {TCLLIB TESTSDIR/auto0/auto1 TESTSDIR/auto0/auto2*} --\
-        {TCLLIB TESTSDIR/auto0/auto2 TESTSDIR/auto0/auto1*}}
-
-test safe-9.8z {interpConfigure change the access path; tclIndex commands unaffected by token rearrangement (dummy test of doreset); zipfs} -setup {
-} -body {
-    set i [safe::interpCreate -accessPath [list $tcl_library \
-                                            [file join $ZipMountPoint auto0 auto1] \
-                                            [file join $ZipMountPoint auto0 auto2]]]
-    # Inspect.
-    set confA [safe::interpConfigure $i]
-    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
-    set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
-    set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
-
-    # Load auto_load data.
-    interp eval $i {catch nonExistentCommand}
-
-    # Load and run the commands.
-    # This guarantees the test will pass even if the tokens are swapped.
-    set code1 [catch {interp eval $i {report1}} msg1]
-    set code2 [catch {interp eval $i {report2}} msg2]
-
-    # Rearrange access path.  Swap tokens {$p(:1:)} and {$p(:2:)}.
-    safe::interpConfigure $i -accessPath [list $tcl_library \
-                                           [file join $ZipMountPoint auto0 auto2] \
-                                           [file join $ZipMountPoint auto0 auto1]]
-    # Inspect.
-    set confB [safe::interpConfigure $i]
-    set mappB [mapList $PathMapp [dict get $confB -accessPath]]
-    set path3 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
-    set path4 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
-
-    # Run the commands.
-    set code3 [catch {interp eval $i {report1}} msg3]
-    set code4 [catch {interp eval $i {report2}} msg4]
-
-    list $path1 $path2 -- $path3 $path4 -- $code3 $msg3 $code4 $msg4 -- $mappA -- $mappB
-} -cleanup {
-    safe::interpDelete $i
-} -match glob -result {{$p(:1:)} {$p(:2:)} -- {$p(:2:)} {$p(:1:)} -- 0 ok1 0 ok2 --\
-        {TCLLIB ZIPDIR/auto0/auto1 ZIPDIR/auto0/auto2*} --\
-        {TCLLIB ZIPDIR/auto0/auto2 ZIPDIR/auto0/auto1*}}
-
-test safe-9.9 {interpConfigure change the access path; tclIndex commands unaffected by token rearrangement (actual test of doreset)} -setup {
-} -body {
-    set i [safe::interpCreate -accessPath [list $tcl_library \
-                                            [file join $TestsDir auto0 auto1] \
-                                            [file join $TestsDir auto0 auto2]]]
-    # Inspect.
-    set confA [safe::interpConfigure $i]
-    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
-    set path1 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 auto1]]
-    set path2 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 auto2]]
-
-    # Load auto_load data.
-    interp eval $i {catch nonExistentCommand}
-
-    # Do not load the commands.  With the tokens swapped, the test
-    # will pass only if the Safe Base has called auto_reset.
-
-    # Rearrange access path.  Swap tokens {$p(:1:)} and {$p(:2:)}.
-    safe::interpConfigure $i -accessPath [list $tcl_library \
-                                           [file join $TestsDir auto0 auto2] \
-                                           [file join $TestsDir auto0 auto1]]
-
-    # Inspect.
-    set confB [safe::interpConfigure $i]
-    set mappB [mapList $PathMapp [dict get $confB -accessPath]]
-    set path3 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 auto1]]
-    set path4 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 auto2]]
-
-    # Load and run the commands.
-    set code3 [catch {interp eval $i {report1}} msg3]
-    set code4 [catch {interp eval $i {report2}} msg4]
-
-    list $path1 $path2 -- $path3 $path4 -- $code3 $msg3 $code4 $msg4 -- $mappA -- $mappB
-} -cleanup {
-    safe::interpDelete $i
-} -match glob -result {{$p(:1:)} {$p(:2:)} -- {$p(:2:)} {$p(:1:)} --\
-        0 ok1 0 ok2 --\
-        {TCLLIB TESTSDIR/auto0/auto1 TESTSDIR/auto0/auto2*} --\
-        {TCLLIB TESTSDIR/auto0/auto2 TESTSDIR/auto0/auto1*}}
-
-test safe-9.9z {interpConfigure change the access path; tclIndex commands unaffected by token rearrangement (actual test of doreset); zipfs} -setup {
-} -body {
-    set i [safe::interpCreate -accessPath [list $tcl_library \
-                                            [file join $ZipMountPoint auto0 auto1] \
-                                            [file join $ZipMountPoint auto0 auto2]]]
-    # Inspect.
-    set confA [safe::interpConfigure $i]
-    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
-    set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
-    set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
-
-    # Load auto_load data.
-    interp eval $i {catch nonExistentCommand}
-
-    # Do not load the commands.  With the tokens swapped, the test
-    # will pass only if the Safe Base has called auto_reset.
-
-    # Rearrange access path.  Swap tokens {$p(:1:)} and {$p(:2:)}.
-    safe::interpConfigure $i -accessPath [list $tcl_library \
-                                           [file join $ZipMountPoint auto0 auto2] \
-                                           [file join $ZipMountPoint auto0 auto1]]
-    # Inspect.
-    set confB [safe::interpConfigure $i]
-    set mappB [mapList $PathMapp [dict get $confB -accessPath]]
-    set path3 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
-    set path4 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
-
-    # Load and run the commands.
-    set code3 [catch {interp eval $i {report1}} msg3]
-    set code4 [catch {interp eval $i {report2}} msg4]
-
-    list $path1 $path2 -- $path3 $path4 -- $code3 $msg3 $code4 $msg4 -- $mappA -- $mappB
-} -cleanup {
-    safe::interpDelete $i
-} -match glob -result {{$p(:1:)} {$p(:2:)} -- {$p(:2:)} {$p(:1:)} --\
-        0 ok1 0 ok2 --\
-        {TCLLIB ZIPDIR/auto0/auto1 ZIPDIR/auto0/auto2*} --\
-        {TCLLIB ZIPDIR/auto0/auto2 ZIPDIR/auto0/auto1*}}
-test safe-9.10 {interpConfigure change the access path; pkgIndex.tcl packages unaffected by token rearrangement} -setup {
-} -body {
-    # For complete correspondence to safe-9.10opt, include auto0 in access path.
-    set i [safe::interpCreate -accessPath [list $tcl_library \
-                                            [file join $TestsDir auto0] \
-                                            [file join $TestsDir auto0 auto1] \
-                                            [file join $TestsDir auto0 auto2]]]
-
-    # Inspect.
-    set confA [safe::interpConfigure $i]
-    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
-    set path0 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0]]
-    set path1 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 auto1]]
-    set path2 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 auto2]]
-
-    # Load pkgIndex.tcl data.
-    catch {interp eval $i {package require NOEXIST}}
-
-    # Rearrange access path.  Swap tokens {$p(:2:)} and {$p(:3:)}.
-    # This would have no effect because the records in Pkg of these directories
-    # were from access as children of {$p(:1:)}.
-    safe::interpConfigure $i -accessPath [list $tcl_library \
-                                           [file join $TestsDir auto0] \
-                                           [file join $TestsDir auto0 auto2] \
-                                           [file join $TestsDir auto0 auto1]]
-
-    # Inspect.
-    set confB [safe::interpConfigure $i]
-    set mappB [mapList $PathMapp [dict get $confB -accessPath]]
-    set path3 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 auto1]]
-    set path4 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 auto2]]
-
-    # Try to load the packages and run a command from each one.
-    set code3 [catch {interp eval $i {package require SafeTestPackage1}} msg3 opts3]
-    set code4 [catch {interp eval $i {package require SafeTestPackage2}} msg4 opts4]
-    set code5 [catch {interp eval $i {HeresPackage1}} msg5 opts5]
-    set code6 [catch {interp eval $i {HeresPackage2}} msg6 opts6]
-
-    list $path1 $path2 -- $path3 $path4 -- $code3 $msg3 $code4 $msg4 -- \
-         $mappA -- $mappB -- $code5 $msg5 $code6 $msg6
-} -cleanup {
-    safe::interpDelete $i
-} -match glob -result {{$p(:2:)} {$p(:3:)} -- {$p(:3:)} {$p(:2:)} -- 0 1.2.3 0 2.3.4 --\
-        {TCLLIB TESTSDIR/auto0 TESTSDIR/auto0/auto1 TESTSDIR/auto0/auto2*} --\
-        {TCLLIB TESTSDIR/auto0 TESTSDIR/auto0/auto2 TESTSDIR/auto0/auto1*} --\
-        0 OK1 0 OK2}
-test safe-9.10z {interpConfigure change the access path; pkgIndex.tcl packages unaffected by token rearrangement; zipfs} -setup {
-} -body {
-    # For complete correspondence to safe-9.10opt, include auto0 in access path.
-    set i [safe::interpCreate -accessPath [list $tcl_library \
-                                            [file join $ZipMountPoint auto0] \
-                                            [file join $ZipMountPoint auto0 auto1] \
-                                            [file join $ZipMountPoint auto0 auto2]]]
-    # Inspect.
-    set confA [safe::interpConfigure $i]
-    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
-    set path0 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0]]
-    set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
-    set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
-
-    # Load pkgIndex.tcl data.
-    catch {interp eval $i {package require NOEXIST}}
-
-    # Rearrange access path.  Swap tokens {$p(:2:)} and {$p(:3:)}.
-    # This would have no effect because the records in Pkg of these directories
-    # were from access as children of {$p(:1:)}.
-    safe::interpConfigure $i -accessPath [list $tcl_library \
-                                           [file join $ZipMountPoint auto0] \
-                                           [file join $ZipMountPoint auto0 auto2] \
-                                           [file join $ZipMountPoint auto0 auto1]]
-    # Inspect.
-    set confB [safe::interpConfigure $i]
-    set mappB [mapList $PathMapp [dict get $confB -accessPath]]
-    set path3 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
-    set path4 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
-
-    # Try to load the packages and run a command from each one.
-    set code3 [catch {interp eval $i {package require SafeTestPackage1}} msg3 opts3]
-    set code4 [catch {interp eval $i {package require SafeTestPackage2}} msg4 opts4]
-    set code5 [catch {interp eval $i {HeresPackage1}} msg5 opts5]
-    set code6 [catch {interp eval $i {HeresPackage2}} msg6 opts6]
-
-    list $path1 $path2 -- $path3 $path4 -- $code3 $msg3 $code4 $msg4 -- \
-         $mappA -- $mappB -- $code5 $msg5 $code6 $msg6
-} -cleanup {
-    safe::interpDelete $i
-} -match glob -result {{$p(:2:)} {$p(:3:)} -- {$p(:3:)} {$p(:2:)} -- 0 1.2.3 0 2.3.4 --\
-        {TCLLIB ZIPDIR/auto0 ZIPDIR/auto0/auto1 ZIPDIR/auto0/auto2*} --\
-        {TCLLIB ZIPDIR/auto0 ZIPDIR/auto0/auto2 ZIPDIR/auto0/auto1*} --\
-        0 OK1 0 OK2}
-test safe-9.10opt {interpConfigure change the access path; pkgIndex.tcl packages unaffected by token rearrangement, uses pkg opt and tcl::idna} -setup {
-} -body {
-    set i [safe::interpCreate -accessPath [list $tcl_library \
-                                            [file join $tcl_library $pkgOptDir] \
-                                            [file join $tcl_library $pkgJarDir]]]
-    # Inspect.
-    set confA [safe::interpConfigure $i]
-    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
-    set path1 [::safe::interpFindInAccessPath $i [file join $tcl_library $pkgOptDir]]
-    set path2 [::safe::interpFindInAccessPath $i [file join $tcl_library $pkgJarDir]]
-
-    # Load pkgIndex.tcl data.
-    catch {interp eval $i {package require NOEXIST}}
-
-    # Rearrange access path.  Swap tokens {$p(:1:)} and {$p(:2:)}.
-    # This has no effect because the records in Pkg of these directories were from access as children of {$p(:0:)}.
-    safe::interpConfigure $i -accessPath [list $tcl_library \
-                                           [file join $tcl_library $pkgJarDir] \
-                                           [file join $tcl_library $pkgOptDir]]
-    # Inspect.
-    set confB [safe::interpConfigure $i]
-    set mappB [mapList $PathMapp [dict get $confB -accessPath]]
-    set path3 [::safe::interpFindInAccessPath $i [file join $tcl_library $pkgOptDir]]
-    set path4 [::safe::interpFindInAccessPath $i [file join $tcl_library $pkgJarDir]]
-
-    # Try to load the packages and run a command from each one.
-    set code3 [catch {interp eval $i {package require tcl::idna}} msg3]
-    set code4 [catch {interp eval $i {package require opt}} msg4]
-    set code5 [catch {interp eval $i {::tcl::Lempty {a list}}} msg5]
-    set code6 [catch {interp eval $i {::tcl::idna::IDNAencode example.com}} msg6]
-
-    list $path1 $path2 -- $path3 $path4 -- $code3 $msg3 $code4 $msg4 -- \
-         $mappA -- $mappB -- $code5 $msg5 $code6 $msg6
-} -cleanup {
-    safe::interpDelete $i
-} -match glob -result {{$p(:1:)} {$p(:2:)} -- {$p(:2:)} {$p(:1:)} -- 0 1.* 0 0.4.* --\
-        {TCLLIB TCLLIB/OPTDIR TCLLIB/JARDIR*} --\
-        {TCLLIB TCLLIB/JARDIR TCLLIB/OPTDIR*} --\
-        0 0 0 example.com}
-test safe-9.11 {interpConfigure change the access path; pkgIndex.tcl packages unaffected by token rearrangement, 9.10 without path auto0} -setup {
-} -body {
-    set i [safe::interpCreate -accessPath [list $tcl_library \
-                                            [file join $TestsDir auto0 auto1] \
-                                            [file join $TestsDir auto0 auto2]]]
-
-    # Inspect.
-    set confA [safe::interpConfigure $i]
-    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
-    set path1 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 auto1]]
-    set path2 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 auto2]]
-
-    # Load pkgIndex.tcl data.
-    catch {interp eval $i {package require NOEXIST}}
-
-    # Rearrange access path.  Swap tokens {$p(:1:)} and {$p(:2:)}.
-    safe::interpConfigure $i -accessPath [list $tcl_library \
-                                           [file join $TestsDir auto0 auto2] \
-                                           [file join $TestsDir auto0 auto1]]
-
-    # Inspect.
-    set confB [safe::interpConfigure $i]
-    set mappB [mapList $PathMapp [dict get $confB -accessPath]]
-    set path3 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 auto1]]
-    set path4 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 auto2]]
-
-    # Try to load the packages and run a command from each one.
-    set code3 [catch {interp eval $i {package require SafeTestPackage1}} msg3 opts3]
-    set code4 [catch {interp eval $i {package require SafeTestPackage2}} msg4 opts4]
-    set code5 [catch {interp eval $i {HeresPackage1}} msg5 opts5]
-    set code6 [catch {interp eval $i {HeresPackage2}} msg6 opts6]
-
-    list $path1 $path2 -- $path3 $path4 -- $code3 $msg3 $code4 $msg4 -- $mappA -- $mappB -- \
-         $code5 $msg5 $code6 $msg6
-} -cleanup {
-    safe::interpDelete $i
-} -match glob -result {{$p(:1:)} {$p(:2:)} -- {$p(:2:)} {$p(:1:)} --\
-        0 1.2.3 0 2.3.4 --\
-        {TCLLIB TESTSDIR/auto0/auto1 TESTSDIR/auto0/auto2*} --\
-        {TCLLIB TESTSDIR/auto0/auto2 TESTSDIR/auto0/auto1*} --\
-        0 OK1 0 OK2}
-test safe-9.11z {interpConfigure change the access path; pkgIndex.tcl packages unaffected by token rearrangement, 9.10 without path auto0; zipfs} -setup {
-} -body {
-    set i [safe::interpCreate -accessPath [list $tcl_library \
-                                            [file join $ZipMountPoint auto0 auto1] \
-                                            [file join $ZipMountPoint auto0 auto2]]]
-    # Inspect.
-    set confA [safe::interpConfigure $i]
-    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
-    set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
-    set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
-
-    # Load pkgIndex.tcl data.
-    catch {interp eval $i {package require NOEXIST}}
-
-    # Rearrange access path.  Swap tokens {$p(:1:)} and {$p(:2:)}.
-    safe::interpConfigure $i -accessPath [list $tcl_library \
-                                           [file join $ZipMountPoint auto0 auto2] \
-                                           [file join $ZipMountPoint auto0 auto1]]
-    # Inspect.
-    set confB [safe::interpConfigure $i]
-    set mappB [mapList $PathMapp [dict get $confB -accessPath]]
-    set path3 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
-    set path4 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
-
-    # Try to load the packages and run a command from each one.
-    set code3 [catch {interp eval $i {package require SafeTestPackage1}} msg3 opts3]
-    set code4 [catch {interp eval $i {package require SafeTestPackage2}} msg4 opts4]
-    set code5 [catch {interp eval $i {HeresPackage1}} msg5 opts5]
-    set code6 [catch {interp eval $i {HeresPackage2}} msg6 opts6]
-
-    list $path1 $path2 -- $path3 $path4 -- $code3 $msg3 $code4 $msg4 -- \
-            $mappA -- $mappB -- $code5 $msg5 $code6 $msg6
-} -cleanup {
-    safe::interpDelete $i
-} -match glob -result {{$p(:1:)} {$p(:2:)} -- {$p(:2:)} {$p(:1:)} --\
-        0 1.2.3 0 2.3.4 --\
-        {TCLLIB ZIPDIR/auto0/auto1 ZIPDIR/auto0/auto2*} --\
-        {TCLLIB ZIPDIR/auto0/auto2 ZIPDIR/auto0/auto1*} --\
-        0 OK1 0 OK2}
-test safe-9.12 {interpConfigure change the access path; pkgIndex.tcl packages fail if directory de-listed} -setup {
-} -body {
-    set i [safe::interpCreate -accessPath [list $tcl_library \
-                                            [file join $TestsDir auto0 auto1] \
-                                            [file join $TestsDir auto0 auto2]]]
-    # Inspect.
-    set confA [safe::interpConfigure $i]
-    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
-    set path1 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 auto1]]
-    set path2 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 auto2]]
-
-    # Load pkgIndex.tcl data.
-    catch {interp eval $i {package require NOEXIST}}
-
-    # Limit access path.  Remove tokens {$p(:1:)} and {$p(:2:)}.
-    safe::interpConfigure $i -accessPath [list $tcl_library]
-
-    # Inspect.
-    set confB [safe::interpConfigure $i]
-    set mappB [mapList $PathMapp [dict get $confB -accessPath]]
-    set code4 [catch {::safe::interpFindInAccessPath $i [file join $TestsDir auto0 auto1]} path4]
-    set code5 [catch {::safe::interpFindInAccessPath $i [file join $TestsDir auto0 auto2]} path5]
-
-    # Try to load the packages.
-    set code3 [catch {interp eval $i {package require SafeTestPackage1}} msg3]
-    set code6 [catch {interp eval $i {package require SafeTestPackage2}} msg6]
-
-    list $path1 $path2 -- $code4 $path4 -- $code5 $path5 -- $code3 $code6 -- $mappA -- $mappB
-} -cleanup {
-    safe::interpDelete $i
-} -match glob -result {{$p(:1:)} {$p(:2:)} -- 1 {* not found in access path} --\
-        1 {* not found in access path} -- 1 1 --\
-        {TCLLIB TESTSDIR/auto0/auto1 TESTSDIR/auto0/auto2*} -- {TCLLIB*}}
-test safe-9.12z {interpConfigure change the access path; pkgIndex.tcl packages fail if directory de-listed; zipfs} -setup {
-} -body {
-    set i [safe::interpCreate -accessPath [list $tcl_library \
-                                            [file join $ZipMountPoint auto0 auto1] \
-                                            [file join $ZipMountPoint auto0 auto2]]]
-    # Inspect.
-    set confA [safe::interpConfigure $i]
-    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
-    set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]]
-    set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]]
-
-    # Load pkgIndex.tcl data.
-    catch {interp eval $i {package require NOEXIST}}
-
-    # Limit access path.  Remove tokens {$p(:1:)} and {$p(:2:)}.
-    safe::interpConfigure $i -accessPath [list $tcl_library]
-
-    # Inspect.
-    set confB [safe::interpConfigure $i]
-    set mappB [mapList $PathMapp [dict get $confB -accessPath]]
-    set code4 [catch {::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto1]} path4]
-    set code5 [catch {::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 auto2]} path5]
-
-    # Try to load the packages.
-    set code3 [catch {interp eval $i {package require SafeTestPackage1}} msg3]
-    set code6 [catch {interp eval $i {package require SafeTestPackage2}} msg6]
-
-    list $path1 $path2 -- $code4 $path4 -- $code5 $path5 -- $code3 $code6 -- \
-            $mappA -- $mappB
-} -cleanup {
-    safe::interpDelete $i
-} -match glob -result {{$p(:1:)} {$p(:2:)} -- 1 {* not found in access path} --\
-        1 {* not found in access path} -- 1 1 --\
-        {TCLLIB ZIPDIR/auto0/auto1 ZIPDIR/auto0/auto2*} -- {TCLLIB*}}
-test safe-9.12opt {interpConfigure change the access path; pkgIndex.tcl packages fail if directory de-listed, uses pkg opt and tcl::idna} -setup {
-} -body {
-    set i [safe::interpCreate -accessPath [list $tcl_library \
-                                            [file join $tcl_library $pkgOptDir] \
-                                            [file join $tcl_library $pkgJarDir]]]
-    # Inspect.
-    set confA [safe::interpConfigure $i]
-    set mappA [mapList $PathMapp [dict get $confA -accessPath]]
-    set path1 [::safe::interpFindInAccessPath $i [file join $tcl_library $pkgOptDir]]
-    set path2 [::safe::interpFindInAccessPath $i [file join $tcl_library $pkgJarDir]]
-
-    # Load pkgIndex.tcl data.
-    catch {interp eval $i {package require NOEXIST}}
-
-    # Limit access path.  Remove tokens {$p(:1:)} and {$p(:2:)}.
-    safe::interpConfigure $i -accessPath [list $tcl_library]
-
-    # Inspect.
-    set confB [safe::interpConfigure $i]
-    set mappB [mapList $PathMapp [dict get $confB -accessPath]]
-    set code4 [catch {::safe::interpFindInAccessPath $i [file join $tcl_library $pkgOptDir]} path4]
-    set code5 [catch {::safe::interpFindInAccessPath $i [file join $tcl_library $pkgJarDir]} path5]
-
-    # Try to load the packages.
-    set code3 [catch {interp eval $i {package require opt}} msg3]
-    set code6 [catch {interp eval $i {package require tcl::idna}} msg6]
-
-    list $path1 $path2 -- $code4 $path4 -- $code5 $path5 -- $code3 $code6 -- \
-            $mappA -- $mappB
-} -cleanup {
-    safe::interpDelete $i
-} -match glob -result {{$p(:1:)} {$p(:2:)} -- 1 {* not found in access path} --\
-        1 {* not found in access path} -- 1 1 --\
-        {TCLLIB TCLLIB/OPTDIR TCLLIB/JARDIR*} -- {TCLLIB*}}
-test safe-9.20 {check module loading} -setup {
-    set oldTm [tcl::tm::path list]
-    foreach path $oldTm {
-        tcl::tm::path remove $path
-    }
-    tcl::tm::path add [file join $TestsDir auto0 modules]
-} -body {
-    set i [safe::interpCreate -accessPath [list $tcl_library]]
-
-    # Inspect.
-    set confA [safe::interpConfigure $i]
-    set sortA [mapAndSortList $PathMapp [dict get $confA -accessPath]]
-    set modsA [interp eval $i {tcl::tm::path list}]
-    set path0 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 modules]]
-    set path1 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 modules mod1]]
-    set path2 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 modules mod2]]
-
-    # Try to load the packages and run a command from each one.
-    set code0 [catch {interp eval $i {package require test0}} msg0]
-    set code1 [catch {interp eval $i {package require mod1::test1}} msg1]
-    set code2 [catch {interp eval $i {package require mod2::test2}} msg2]
-    set out0  [interp eval $i {test0::try0}]
-    set out1  [interp eval $i {mod1::test1::try1}]
-    set out2  [interp eval $i {mod2::test2::try2}]
-
-    list [lsort [list $path0 $path1 $path2]] -- $modsA -- \
-            $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $sortA -- $out0 $out1 $out2
-} -cleanup {
-    tcl::tm::path remove [file join $TestsDir auto0 modules]
-    foreach path [lreverse $oldTm] {
-        tcl::tm::path add $path
-    }
-    safe::interpDelete $i
-} -match glob -result {{{$p(:1:)} {$p(:2:)} {$p(:3:)}} -- {{$p(:1:)}} --\
-        0 0.5 0 1.0 0 2.0 --\
-        {TCLLIB TESTSDIR/auto0/modules TESTSDIR/auto0/modules/mod1\
-         TESTSDIR/auto0/modules/mod2} -- res0 res1 res2}
-# - The command safe::InterpSetConfig adds the master's [tcl::tm::list] in
-#   tokenized form to the slave's access path, and then adds all the
-#   descendants, discovered recursively by using glob.
-# - The order of the directories in the list returned by glob is system-dependent,
-#   and therefore this is true also for (a) the order of token assignment to
-#   descendants of the [tcl::tm::list] roots; and (b) the order of those same
-#   directories in the access path.  Both those things must be sorted before
-#   comparing with expected results.  The test is therefore not totally strict,
-#   but will notice missing or surplus directories.
-test safe-9.20z {check module loading; zipfs} -setup {
-    set oldTm [tcl::tm::path list]
-    foreach path $oldTm {
-        tcl::tm::path remove $path
-    }
-    tcl::tm::path add [file join $ZipMountPoint auto0 modules]
-} -body {
-    set i [safe::interpCreate -accessPath [list $tcl_library]]
-
-    # Inspect.
-    set confA [safe::interpConfigure $i]
-    set sortA [mapAndSortList $PathMapp [dict get $confA -accessPath]]
-    set modsA [interp eval $i {tcl::tm::path list}]
-    set path0 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
-    set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
-    set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod2]]
-
-    # Try to load the packages and run a command from each one.
-    set code0 [catch {interp eval $i {package require test0}} msg0]
-    set code1 [catch {interp eval $i {package require mod1::test1}} msg1]
-    set code2 [catch {interp eval $i {package require mod2::test2}} msg2]
-    set out0  [interp eval $i {test0::try0}]
-    set out1  [interp eval $i {mod1::test1::try1}]
-    set out2  [interp eval $i {mod2::test2::try2}]
-
-    list [lsort [list $path0 $path1 $path2]] -- $modsA -- \
-            $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $sortA -- $out0 $out1 $out2
-} -cleanup {
-    tcl::tm::path remove [file join $ZipMountPoint auto0 modules]
-    foreach path [lreverse $oldTm] {
-        tcl::tm::path add $path
-    }
-    safe::interpDelete $i
-} -match glob -result {{{$p(:1:)} {$p(:2:)} {$p(:3:)}} -- {{$p(:1:)}} --\
-        0 0.5 0 1.0 0 2.0 --\
-        {TCLLIB ZIPDIR/auto0/modules ZIPDIR/auto0/modules/mod1\
-         ZIPDIR/auto0/modules/mod2} -- res0 res1 res2}
-# See comments on lsort after test safe-9.20.
-test safe-9.21 {interpConfigure change the access path; check module loading; stale data case 1} -setup {
-    set oldTm [tcl::tm::path list]
-    foreach path $oldTm {
-        tcl::tm::path remove $path
-    }
-    tcl::tm::path add [file join $TestsDir auto0 modules]
-} -body {
-    set i [safe::interpCreate -accessPath [list $tcl_library]]
-
-    # Inspect.
-    set confA [safe::interpConfigure $i]
-    set sortA [mapAndSortList $PathMapp [dict get $confA -accessPath]]
-    set modsA [interp eval $i {tcl::tm::path list}]
-    set path0 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 modules]]
-    set path1 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 modules mod1]]
-    set path2 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 modules mod2]]
-
-    # Add to access path.
-    # This injects more tokens, pushing modules to higher token numbers.
-    safe::interpConfigure $i -accessPath [list $tcl_library \
-                                           [file join $TestsDir auto0 auto1] \
-                                           [file join $TestsDir auto0 auto2]]
-
-    # Inspect.
-    set confB [safe::interpConfigure $i]
-    set sortB [mapAndSortList $PathMapp [dict get $confB -accessPath]]
-    set modsB [interp eval $i {tcl::tm::path list}]
-    set path3 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 modules]]
-    set path4 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 modules mod1]]
-    set path5 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 modules mod2]]
-
-    # Load pkg data.
-    catch {interp eval $i {package require NOEXIST}}
-    catch {interp eval $i {package require mod1::NOEXIST}}
-    catch {interp eval $i {package require mod2::NOEXIST}}
-
-    # Try to load the packages and run a command from each one.
-    set code0 [catch {interp eval $i {package require test0}} msg0]
-    set code1 [catch {interp eval $i {package require mod1::test1}} msg1]
-    set code2 [catch {interp eval $i {package require mod2::test2}} msg2]
-    set out0  [interp eval $i {test0::try0}]
-    set out1  [interp eval $i {mod1::test1::try1}]
-    set out2  [interp eval $i {mod2::test2::try2}]
-
-    list [lsort [list $path0 $path1 $path2]] -- $modsA -- [lsort [list $path3 $path4 $path5]] -- $modsB -- \
-         $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $sortA -- $sortB -- \
-         $out0 $out1 $out2
-} -cleanup {
-    tcl::tm::path remove [file join $TestsDir auto0 modules]
-    foreach path [lreverse $oldTm] {
-        tcl::tm::path add $path
-    }
-    safe::interpDelete $i
-} -match glob -result {{{$p(:1:)} {$p(:2:)} {$p(:3:)}} -- {{$p(:1:)}} --\
-        {{$p(:3:)} {$p(:4:)} {$p(:5:)}} -- {{$p(:3:)}} --\
-        0 0.5 0 1.0 0 2.0 --\
-        {TCLLIB TESTSDIR/auto0/modules TESTSDIR/auto0/modules/mod1\
-         TESTSDIR/auto0/modules/mod2} --\
-        {TCLLIB TESTSDIR/auto0/auto1 TESTSDIR/auto0/auto2 TESTSDIR/auto0/modules\
-         TESTSDIR/auto0/modules/mod1 TESTSDIR/auto0/modules/mod2} --\
-        res0 res1 res2}
-# See comments on lsort after test safe-9.20.
-test safe-9.21z {interpConfigure change the access path; check module loading; stale data case 1; zipfs} -setup {
-    set oldTm [tcl::tm::path list]
-    foreach path $oldTm {
-        tcl::tm::path remove $path
-    }
-    tcl::tm::path add [file join $ZipMountPoint auto0 modules]
-} -body {
-    set i [safe::interpCreate -accessPath [list $tcl_library]]
-
-    # Inspect.
-    set confA [safe::interpConfigure $i]
-    set sortA [mapAndSortList $PathMapp [dict get $confA -accessPath]]
-    set modsA [interp eval $i {tcl::tm::path list}]
-    set path0 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
-    set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
-    set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod2]]
-
-    # Add to access path.
-    # This injects more tokens, pushing modules to higher token numbers.
-    safe::interpConfigure $i -accessPath [list $tcl_library \
-                                           [file join $ZipMountPoint auto0 auto1] \
-                                           [file join $ZipMountPoint auto0 auto2]]
-    # Inspect.
-    set confB [safe::interpConfigure $i]
-    set sortB [mapAndSortList $PathMapp [dict get $confB -accessPath]]
-    set modsB [interp eval $i {tcl::tm::path list}]
-    set path3 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
-    set path4 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
-    set path5 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod2]]
-
-    # Load pkg data.
-    catch {interp eval $i {package require NOEXIST}}
-    catch {interp eval $i {package require mod1::NOEXIST}}
-    catch {interp eval $i {package require mod2::NOEXIST}}
-
-    # Try to load the packages and run a command from each one.
-    set code0 [catch {interp eval $i {package require test0}} msg0]
-    set code1 [catch {interp eval $i {package require mod1::test1}} msg1]
-    set code2 [catch {interp eval $i {package require mod2::test2}} msg2]
-    set out0  [interp eval $i {test0::try0}]
-    set out1  [interp eval $i {mod1::test1::try1}]
-    set out2  [interp eval $i {mod2::test2::try2}]
-
-    list [lsort [list $path0 $path1 $path2]] -- $modsA -- \
-            [lsort [list $path3 $path4 $path5]] -- $modsB -- \
-            $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $sortA -- $sortB -- \
-            $out0 $out1 $out2
-} -cleanup {
-    tcl::tm::path remove [file join $ZipMountPoint auto0 modules]
-    foreach path [lreverse $oldTm] {
-        tcl::tm::path add $path
-    }
-    safe::interpDelete $i
-} -match glob -result {{{$p(:1:)} {$p(:2:)} {$p(:3:)}} -- {{$p(:1:)}} --\
-        {{$p(:3:)} {$p(:4:)} {$p(:5:)}} -- {{$p(:3:)}} --\
-        0 0.5 0 1.0 0 2.0 --\
-        {TCLLIB ZIPDIR/auto0/modules ZIPDIR/auto0/modules/mod1\
-         ZIPDIR/auto0/modules/mod2} --\
-        {TCLLIB ZIPDIR/auto0/auto1 ZIPDIR/auto0/auto2 ZIPDIR/auto0/modules\
-         ZIPDIR/auto0/modules/mod1 ZIPDIR/auto0/modules/mod2} --\
-        res0 res1 res2}
-# See comments on lsort after test safe-9.20.
-test safe-9.22 {interpConfigure change the access path; check module loading; stale data case 0} -setup {
-    set oldTm [tcl::tm::path list]
-    foreach path $oldTm {
-        tcl::tm::path remove $path
-    }
-    tcl::tm::path add [file join $TestsDir auto0 modules]
-} -body {
-    set i [safe::interpCreate -accessPath [list $tcl_library]]
-
-    # Inspect.
-    set confA [safe::interpConfigure $i]
-    set sortA [mapAndSortList $PathMapp [dict get $confA -accessPath]]
-    set modsA [interp eval $i {tcl::tm::path list}]
-    set path0 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 modules]]
-    set path1 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 modules mod1]]
-    set path2 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 modules mod2]]
-
-    # Add to access path.
-    # This injects more tokens, pushing modules to higher token numbers.
-    safe::interpConfigure $i -accessPath [list $tcl_library \
-                                          [file join $TestsDir auto0 auto1] \
-                                          [file join $TestsDir auto0 auto2]]
-
-    # Inspect.
-    set confB [safe::interpConfigure $i]
-    set sortB [mapAndSortList $PathMapp [dict get $confB -accessPath]]
-    set modsB [interp eval $i {tcl::tm::path list}]
-    set path3 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 modules]]
-    set path4 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 modules mod1]]
-    set path5 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 modules mod2]]
-
-    # Try to load the packages and run a command from each one.
-    set code0 [catch {interp eval $i {package require test0}} msg0]
-    set code1 [catch {interp eval $i {package require mod1::test1}} msg1]
-    set code2 [catch {interp eval $i {package require mod2::test2}} msg2]
-    set out0  [interp eval $i {test0::try0}]
-    set out1  [interp eval $i {mod1::test1::try1}]
-    set out2  [interp eval $i {mod2::test2::try2}]
-
-    list [lsort [list $path0 $path1 $path2]] -- $modsA -- [lsort [list $path3 $path4 $path5]] -- $modsB -- \
-         $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $sortA -- $sortB -- \
-         $out0 $out1 $out2
-} -cleanup {
-    tcl::tm::path remove [file join $TestsDir auto0 modules]
-    foreach path [lreverse $oldTm] {
-        tcl::tm::path add $path
-    }
-    safe::interpDelete $i
-} -match glob -result {{{$p(:1:)} {$p(:2:)} {$p(:3:)}} -- {{$p(:1:)}} --\
-        {{$p(:3:)} {$p(:4:)} {$p(:5:)}} -- {{$p(:3:)}} --\
-        0 0.5 0 1.0 0 2.0 --\
-        {TCLLIB TESTSDIR/auto0/modules TESTSDIR/auto0/modules/mod1\
-         TESTSDIR/auto0/modules/mod2} --\
-        {TCLLIB TESTSDIR/auto0/auto1 TESTSDIR/auto0/auto2 TESTSDIR/auto0/modules\
-         TESTSDIR/auto0/modules/mod1 TESTSDIR/auto0/modules/mod2} --\
-        res0 res1 res2}
-# See comments on lsort after test safe-9.20.
-test safe-9.22z {interpConfigure change the access path; check module loading; stale data case 0; zipfs} -setup {
-    set oldTm [tcl::tm::path list]
-    foreach path $oldTm {
-        tcl::tm::path remove $path
-    }
-    tcl::tm::path add [file join $ZipMountPoint auto0 modules]
-} -body {
-    set i [safe::interpCreate -accessPath [list $tcl_library]]
-
-    # Inspect.
-    set confA [safe::interpConfigure $i]
-    set sortA [mapAndSortList $PathMapp [dict get $confA -accessPath]]
-    set modsA [interp eval $i {tcl::tm::path list}]
-    set path0 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
-    set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
-    set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod2]]
-
-    # Add to access path.
-    # This injects more tokens, pushing modules to higher token numbers.
-    safe::interpConfigure $i -accessPath [list $tcl_library \
-                                          [file join $ZipMountPoint auto0 auto1] \
-                                          [file join $ZipMountPoint auto0 auto2]]
-    # Inspect.
-    set confB [safe::interpConfigure $i]
-    set sortB [mapAndSortList $PathMapp [dict get $confB -accessPath]]
-    set modsB [interp eval $i {tcl::tm::path list}]
-    set path3 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
-    set path4 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
-    set path5 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod2]]
-
-    # Try to load the packages and run a command from each one.
-    set code0 [catch {interp eval $i {package require test0}} msg0]
-    set code1 [catch {interp eval $i {package require mod1::test1}} msg1]
-    set code2 [catch {interp eval $i {package require mod2::test2}} msg2]
-    set out0  [interp eval $i {test0::try0}]
-    set out1  [interp eval $i {mod1::test1::try1}]
-    set out2  [interp eval $i {mod2::test2::try2}]
-
-    list [lsort [list $path0 $path1 $path2]] -- $modsA -- \
-            [lsort [list $path3 $path4 $path5]] -- $modsB -- \
-            $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $sortA -- $sortB -- \
-            $out0 $out1 $out2
-} -cleanup {
-    tcl::tm::path remove [file join $ZipMountPoint auto0 modules]
-    foreach path [lreverse $oldTm] {
-        tcl::tm::path add $path
-    }
-    safe::interpDelete $i
-} -match glob -result {{{$p(:1:)} {$p(:2:)} {$p(:3:)}} -- {{$p(:1:)}} --\
-        {{$p(:3:)} {$p(:4:)} {$p(:5:)}} -- {{$p(:3:)}} --\
-        0 0.5 0 1.0 0 2.0 --\
-        {TCLLIB ZIPDIR/auto0/modules ZIPDIR/auto0/modules/mod1\
-         ZIPDIR/auto0/modules/mod2} --\
-        {TCLLIB ZIPDIR/auto0/auto1 ZIPDIR/auto0/auto2 ZIPDIR/auto0/modules\
-         ZIPDIR/auto0/modules/mod1 ZIPDIR/auto0/modules/mod2} --\
-        res0 res1 res2}
-# See comments on lsort after test safe-9.20.
-test safe-9.23 {interpConfigure change the access path; check module loading; stale data case 3} -setup {
-    set oldTm [tcl::tm::path list]
-    foreach path $oldTm {
-        tcl::tm::path remove $path
-    }
-    tcl::tm::path add [file join $TestsDir auto0 modules]
-} -body {
-    set i [safe::interpCreate -accessPath [list $tcl_library]]
-
-    # Inspect.
-    set confA [safe::interpConfigure $i]
-    set sortA [mapAndSortList $PathMapp [dict get $confA -accessPath]]
-    set modsA [interp eval $i {tcl::tm::path list}]
-    set path0 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 modules]]
-    set path1 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 modules mod1]]
-    set path2 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 modules mod2]]
-
-    # Force the interpreter to acquire pkg data which will soon become stale.
-    catch {interp eval $i {package require NOEXIST}}
-    catch {interp eval $i {package require mod1::NOEXIST}}
-    catch {interp eval $i {package require mod2::NOEXIST}}
-
-    # Add to access path.
-    # This injects more tokens, pushing modules to higher token numbers.
-    safe::interpConfigure $i -accessPath [list $tcl_library \
-                                           [file join $TestsDir auto0 auto1] \
-                                           [file join $TestsDir auto0 auto2]]
-
-    # Inspect.
-    set confB [safe::interpConfigure $i]
-    set sortB [mapAndSortList $PathMapp [dict get $confB -accessPath]]
-    set modsB [interp eval $i {tcl::tm::path list}]
-    set path3 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 modules]]
-    set path4 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 modules mod1]]
-    set path5 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 modules mod2]]
-
-    # Refresh stale pkg data.
-    catch {interp eval $i {package require NOEXIST}}
-    catch {interp eval $i {package require mod1::NOEXIST}}
-    catch {interp eval $i {package require mod2::NOEXIST}}
-
-    # Try to load the packages and run a command from each one.
-    set code0 [catch {interp eval $i {package require test0}} msg0]
-    set code1 [catch {interp eval $i {package require mod1::test1}} msg1]
-    set code2 [catch {interp eval $i {package require mod2::test2}} msg2]
-    set out0  [interp eval $i {test0::try0}]
-    set out1  [interp eval $i {mod1::test1::try1}]
-    set out2  [interp eval $i {mod2::test2::try2}]
-
-    list [lsort [list $path0 $path1 $path2]] -- $modsA -- [lsort [list $path3 $path4 $path5]] -- $modsB -- \
-         $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $sortA -- $sortB -- \
-         $out0 $out1 $out2
-
-} -cleanup {
-    tcl::tm::path remove [file join $TestsDir auto0 modules]
-    foreach path [lreverse $oldTm] {
-        tcl::tm::path add $path
-    }
-    safe::interpDelete $i
-} -match glob -result {{{$p(:1:)} {$p(:2:)} {$p(:3:)}} -- {{$p(:1:)}} --\
-        {{$p(:3:)} {$p(:4:)} {$p(:5:)}} -- {{$p(:3:)}} --\
-        0 0.5 0 1.0 0 2.0 --\
-        {TCLLIB TESTSDIR/auto0/modules TESTSDIR/auto0/modules/mod1\
-         TESTSDIR/auto0/modules/mod2} --\
-        {TCLLIB TESTSDIR/auto0/auto1 TESTSDIR/auto0/auto2 TESTSDIR/auto0/modules\
-         TESTSDIR/auto0/modules/mod1 TESTSDIR/auto0/modules/mod2} --\
-        res0 res1 res2}
-# See comments on lsort after test safe-9.20.
-test safe-9.23z {interpConfigure change the access path; check module loading; stale data case 3; zipfs} -setup {
-    set oldTm [tcl::tm::path list]
-    foreach path $oldTm {
-        tcl::tm::path remove $path
-    }
-    tcl::tm::path add [file join $ZipMountPoint auto0 modules]
-} -body {
-    set i [safe::interpCreate -accessPath [list $tcl_library]]
-
-    # Inspect.
-    set confA [safe::interpConfigure $i]
-    set sortA [mapAndSortList $PathMapp [dict get $confA -accessPath]]
-    set modsA [interp eval $i {tcl::tm::path list}]
-    set path0 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
-    set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
-    set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod2]]
-
-    # Force the interpreter to acquire pkg data which will soon become stale.
-    catch {interp eval $i {package require NOEXIST}}
-    catch {interp eval $i {package require mod1::NOEXIST}}
-    catch {interp eval $i {package require mod2::NOEXIST}}
-
-    # Add to access path.
-    # This injects more tokens, pushing modules to higher token numbers.
-    safe::interpConfigure $i -accessPath [list $tcl_library \
-                                           [file join $ZipMountPoint auto0 auto1] \
-                                           [file join $ZipMountPoint auto0 auto2]]
-    # Inspect.
-    set confB [safe::interpConfigure $i]
-    set sortB [mapAndSortList $PathMapp [dict get $confB -accessPath]]
-    set modsB [interp eval $i {tcl::tm::path list}]
-    set path3 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
-    set path4 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
-    set path5 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod2]]
-
-    # Refresh stale pkg data.
-    catch {interp eval $i {package require NOEXIST}}
-    catch {interp eval $i {package require mod1::NOEXIST}}
-    catch {interp eval $i {package require mod2::NOEXIST}}
-
-    # Try to load the packages and run a command from each one.
-    set code0 [catch {interp eval $i {package require test0}} msg0]
-    set code1 [catch {interp eval $i {package require mod1::test1}} msg1]
-    set code2 [catch {interp eval $i {package require mod2::test2}} msg2]
-    set out0  [interp eval $i {test0::try0}]
-    set out1  [interp eval $i {mod1::test1::try1}]
-    set out2  [interp eval $i {mod2::test2::try2}]
-
-    list [lsort [list $path0 $path1 $path2]] -- $modsA -- \
-            [lsort [list $path3 $path4 $path5]] -- $modsB -- \
-            $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $sortA -- $sortB -- \
-            $out0 $out1 $out2
-} -cleanup {
-    tcl::tm::path remove [file join $ZipMountPoint auto0 modules]
-    foreach path [lreverse $oldTm] {
-        tcl::tm::path add $path
-    }
-    safe::interpDelete $i
-} -match glob -result {{{$p(:1:)} {$p(:2:)} {$p(:3:)}} -- {{$p(:1:)}} --\
-        {{$p(:3:)} {$p(:4:)} {$p(:5:)}} -- {{$p(:3:)}} --\
-        0 0.5 0 1.0 0 2.0 --\
-        {TCLLIB ZIPDIR/auto0/modules ZIPDIR/auto0/modules/mod1\
-         ZIPDIR/auto0/modules/mod2} --\
-        {TCLLIB ZIPDIR/auto0/auto1 ZIPDIR/auto0/auto2 ZIPDIR/auto0/modules\
-         ZIPDIR/auto0/modules/mod1 ZIPDIR/auto0/modules/mod2} --\
-        res0 res1 res2}
-# See comments on lsort after test safe-9.20.
-test safe-9.24 {interpConfigure change the access path; check module loading; stale data case 2 (worst case)} -setup {
-    set oldTm [tcl::tm::path list]
-    foreach path $oldTm {
-        tcl::tm::path remove $path
-    }
-    tcl::tm::path add [file join $TestsDir auto0 modules]
-} -body {
-    set i [safe::interpCreate -accessPath [list $tcl_library]]
-
-    # Inspect.
-    set confA [safe::interpConfigure $i]
-    set sortA [mapAndSortList $PathMapp [dict get $confA -accessPath]]
-    set modsA [interp eval $i {tcl::tm::path list}]
-    set path0 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 modules]]
-    set path1 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 modules mod1]]
-    set path2 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 modules mod2]]
-
-    # Force the interpreter to acquire pkg data which will soon become stale.
-    catch {interp eval $i {package require NOEXIST}}
-    catch {interp eval $i {package require mod1::NOEXIST}}
-    catch {interp eval $i {package require mod2::NOEXIST}}
-
-    # Add to access path.
-    # This injects more tokens, pushing modules to higher token numbers.
-    safe::interpConfigure $i -accessPath [list $tcl_library \
-                                           [file join $TestsDir auto0 auto1] \
-                                           [file join $TestsDir auto0 auto2]]
-
-    # Inspect.
-    set confB [safe::interpConfigure $i]
-    set sortB [mapAndSortList $PathMapp [dict get $confB -accessPath]]
-    set modsB [interp eval $i {tcl::tm::path list}]
-    set path3 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 modules]]
-    set path4 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 modules mod1]]
-    set path5 [::safe::interpFindInAccessPath $i [file join $TestsDir auto0 modules mod2]]
-
-    # Try to load the packages and run a command from each one.
-    set code0 [catch {interp eval $i {package require test0}} msg0]
-    set code1 [catch {interp eval $i {package require mod1::test1}} msg1]
-    set code2 [catch {interp eval $i {package require mod2::test2}} msg2]
-    set out0  [interp eval $i {test0::try0}]
-    set out1  [interp eval $i {mod1::test1::try1}]
-    set out2  [interp eval $i {mod2::test2::try2}]
-
-    list [lsort [list $path0 $path1 $path2]] -- $modsA -- [lsort [list $path3 $path4 $path5]] -- $modsB -- \
-         $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $sortA -- $sortB -- \
-         $out0 $out1 $out2
-} -cleanup {
-    tcl::tm::path remove [file join $TestsDir auto0 modules]
-    foreach path [lreverse $oldTm] {
-        tcl::tm::path add $path
-    }
-    safe::interpDelete $i
-} -match glob -result {{{$p(:1:)} {$p(:2:)} {$p(:3:)}} -- {{$p(:1:)}} --\
-        {{$p(:3:)} {$p(:4:)} {$p(:5:)}} -- {{$p(:3:)}} --\
-        0 0.5 0 1.0 0 2.0 --\
-        {TCLLIB TESTSDIR/auto0/modules TESTSDIR/auto0/modules/mod1\
-         TESTSDIR/auto0/modules/mod2} --\
-        {TCLLIB TESTSDIR/auto0/auto1 TESTSDIR/auto0/auto2 TESTSDIR/auto0/modules\
-         TESTSDIR/auto0/modules/mod1 TESTSDIR/auto0/modules/mod2} --\
-        res0 res1 res2}
-# See comments on lsort after test safe-9.20.
-test safe-9.24z {interpConfigure change the access path; check module loading; stale data case 2 (worst case); zipfs} -setup {
-    set oldTm [tcl::tm::path list]
-    foreach path $oldTm {
-        tcl::tm::path remove $path
-    }
-    tcl::tm::path add [file join $ZipMountPoint auto0 modules]
-} -body {
-    set i [safe::interpCreate -accessPath [list $tcl_library]]
-
-    # Inspect.
-    set confA [safe::interpConfigure $i]
-    set sortA [mapAndSortList $PathMapp [dict get $confA -accessPath]]
-    set modsA [interp eval $i {tcl::tm::path list}]
-    set path0 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
-    set path1 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
-    set path2 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod2]]
-
-    # Force the interpreter to acquire pkg data which will soon become stale.
-    catch {interp eval $i {package require NOEXIST}}
-    catch {interp eval $i {package require mod1::NOEXIST}}
-    catch {interp eval $i {package require mod2::NOEXIST}}
-
-    # Add to access path.
-    # This injects more tokens, pushing modules to higher token numbers.
-    safe::interpConfigure $i -accessPath [list $tcl_library \
-                                           [file join $ZipMountPoint auto0 auto1] \
-                                           [file join $ZipMountPoint auto0 auto2]]
-    # Inspect.
-    set confB [safe::interpConfigure $i]
-    set sortB [mapAndSortList $PathMapp [dict get $confB -accessPath]]
-    set modsB [interp eval $i {tcl::tm::path list}]
-    set path3 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules]]
-    set path4 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod1]]
-    set path5 [::safe::interpFindInAccessPath $i [file join $ZipMountPoint auto0 modules mod2]]
-
-    # Try to load the packages and run a command from each one.
-    set code0 [catch {interp eval $i {package require test0}} msg0]
-    set code1 [catch {interp eval $i {package require mod1::test1}} msg1]
-    set code2 [catch {interp eval $i {package require mod2::test2}} msg2]
-    set out0  [interp eval $i {test0::try0}]
-    set out1  [interp eval $i {mod1::test1::try1}]
-    set out2  [interp eval $i {mod2::test2::try2}]
-
-    list [lsort [list $path0 $path1 $path2]] -- $modsA -- \
-            [lsort [list $path3 $path4 $path5]] -- $modsB -- \
-            $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $sortA -- $sortB -- \
-            $out0 $out1 $out2
-} -cleanup {
-    tcl::tm::path remove [file join $ZipMountPoint auto0 modules]
-    foreach path [lreverse $oldTm] {
-        tcl::tm::path add $path
-    }
-    safe::interpDelete $i
-} -match glob -result {{{$p(:1:)} {$p(:2:)} {$p(:3:)}} -- {{$p(:1:)}} --\
-        {{$p(:3:)} {$p(:4:)} {$p(:5:)}} -- {{$p(:3:)}} --\
-        0 0.5 0 1.0 0 2.0 --\
-        {TCLLIB ZIPDIR/auto0/modules ZIPDIR/auto0/modules/mod1\
-         ZIPDIR/auto0/modules/mod2} --\
-        {TCLLIB ZIPDIR/auto0/auto1 ZIPDIR/auto0/auto2 ZIPDIR/auto0/modules\
-         ZIPDIR/auto0/modules/mod1 ZIPDIR/auto0/modules/mod2} --\
-        res0 res1 res2}
-# See comments on lsort after test safe-9.20.
-
 catch {teststaticpkg Safepkg1 0 0}
 test safe-10.1 {testing statics loading} -constraints TcltestPackage -setup {
     set i [safe::interpCreate]
@@ -2760,7 +1432,7 @@ test safe-13.7 {mimic the glob call by tclPkgUnknown in a safe interpreter [Bug
     safe::interpDelete $i
     removeDirectory $testdir
 } -result {EXPECTED/deletemetoo/pkgIndex.tcl}
-test safe-13.7a {mimic the glob call by tclPkgUnknown in a safe interpreter with multiple subdirectories} -setup {
+test safe-13.7.1 {mimic the glob call by tclPkgUnknown in a safe interpreter with multiple subdirectories} -setup {
     set i [safe::interpCreate]
     buildEnvironment2 pkgIndex.tcl
 } -body {
@@ -2960,8 +1632,7 @@ test safe-16.8 {Bug 3529949: defang ~user in paths used by AliasGlob (2)} -setup
 } -result {~USER}
 
 set ::auto_path $SaveAutoPath
-zipfs unmount ${ZipMountPoint}
-unset pkgOptErrMsg pkgOptDir pkgJarDir SaveAutoPath TestsDir ZipMountPoint PathMapp
+unset SaveAutoPath TestsDir PathMapp
 rename mapList {}
 rename mapAndSortList {}
 # cleanup
-- 
cgit v0.12


From 9684712f82b11fe000a70daea51504e068baba80 Mon Sep 17 00:00:00 2001
From: kjnash <k.j.nash@usa.net>
Date: Wed, 22 Jul 2020 19:26:32 +0000
Subject: Whitespace and comment changes only.

---
 tests/safe-zipfs.test | 4 ++--
 tests/safe.test       | 9 ++++-----
 2 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/tests/safe-zipfs.test b/tests/safe-zipfs.test
index 1f110d1..ed473ca 100644
--- a/tests/safe-zipfs.test
+++ b/tests/safe-zipfs.test
@@ -170,7 +170,7 @@ test safe-zipfs-5.6 {example modules packages, test in master interpreter, appen
 } -match glob -result {0 0.5 0 1.0 0 2.0 -- res0 res1 res2}
 
 # high level general test
-# Use zipped example packages not tcl8.x/opt
+# Use zipped example packages not http1.0 etc
 test safe-zipfs-7.1 {tests that everything works at high level; zipfs} -setup {
     set tmpAutoPath $::auto_path
     lappend ::auto_path [file join $ZipMountPoint auto0]
@@ -715,12 +715,12 @@ test safe-zipfs-9.24 {interpConfigure change the access path; check module loadi
         res0 res1 res2}
 # See comments on lsort after test safe-zipfs-9.20.
 
+# cleanup
 set ::auto_path $SaveAutoPath
 zipfs unmount ${ZipMountPoint}
 unset SaveAutoPath TestsDir ZipMountPoint PathMapp
 rename mapList {}
 rename mapAndSortList {}
-# cleanup
 ::tcltest::cleanupTests
 return
 
diff --git a/tests/safe.test b/tests/safe.test
index f196d97..3dd965e 100644
--- a/tests/safe.test
+++ b/tests/safe.test
@@ -284,7 +284,6 @@ test safe-5.6 {example modules packages, test in master interpreter, append to p
     catch {namespace delete ::mod1}
 } -match glob -result {0 0.5 0 1.0 0 2.0 -- res0 res1 res2}
 
-
 # test safe interps 'information leak'
 proc SafeEval {script} {
     # Helper procedure that ensures the safe interp is cleaned up even if
@@ -316,7 +315,7 @@ rename SafeEval {}
 # leaking infos, but they still do...
 
 # high level general test
-# Use example packages not http1.0
+# Use example packages not http1.0 etc
 test safe-7.1 {tests that everything works at high level} -setup {
     set tmpAutoPath $::auto_path
     lappend ::auto_path [file join $TestsDir auto0]
@@ -1011,7 +1010,7 @@ test safe-9.22 {interpConfigure change the access path; check module loading; st
     set out1  [interp eval $i {mod1::test1::try1}]
     set out2  [interp eval $i {mod2::test2::try2}]
 
-    list [lsort [list $path0 $path1 $path2]] -- $modsA --\
+    list [lsort [list $path0 $path1 $path2]] -- $modsA -- \
             [lsort [list $path3 $path4 $path5]] -- $modsB -- \
             $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $sortA -- $sortB -- \
             $out0 $out1 $out2
@@ -1078,7 +1077,7 @@ test safe-9.23 {interpConfigure change the access path; check module loading; st
     set out1  [interp eval $i {mod1::test1::try1}]
     set out2  [interp eval $i {mod2::test2::try2}]
 
-    list [lsort [list $path0 $path1 $path2]] -- $modsA --\
+    list [lsort [list $path0 $path1 $path2]] -- $modsA -- \
             [lsort [list $path3 $path4 $path5]] -- $modsB -- \
             $code0 $msg0 $code1 $msg1 $code2 $msg2 -- $sortA -- $sortB -- \
             $out0 $out1 $out2
@@ -1654,11 +1653,11 @@ test safe-16.8 {Bug 3529949: defang ~user in paths used by AliasGlob (2)} -setup
     unset user
 } -result {~USER}
 
+# cleanup
 set ::auto_path $SaveAutoPath
 unset SaveAutoPath TestsDir PathMapp
 rename mapList {}
 rename mapAndSortList {}
-# cleanup
 ::tcltest::cleanupTests
 return
 
-- 
cgit v0.12