* Implementation of TIP 101. Adds and exports a [configure] command

        from tcltest.

1 files changed, 713 insertions, 819 deletions

diff --git a/library/tcltest/tcltest.tcl b/library/tcltest/tcltest.tcl
index b2b020b..095a40f 100644
--- a/library/tcltest/tcltest.tcl
+++ b/library/tcltest/tcltest.tcl
@@ -13,36 +13,146 @@
 # Copyright (c) 1994-1997 Sun Microsystems, Inc.
 # Copyright (c) 1998-1999 by Scriptics Corporation.
 # Copyright (c) 2000 by Ajuba Solutions
+# Contributions from Don Porter, NIST, 2002.  (not subject to US copyright)
 # All rights reserved.
 #
-# RCS: @(#) $Id: tcltest.tcl,v 1.55 2002/06/22 04:19:46 dgp Exp $
-
-# create the "tcltest" namespace for all testing variables and
-# procedures
-
-package require Tcl 8.3
+# RCS: @(#) $Id: tcltest.tcl,v 1.56 2002/06/25 01:13:38 dgp Exp $
 
+package require Tcl 8.3		;# uses [glob -directory]
 namespace eval tcltest {
+    variable Version 2.1
+
+    # Compatibility support for dumb variables defined in tcltest 1
+    # Do not use these.  Call [package provide Tcl] and [info patchlevel]
+    # yourself.  You don't need tcltest to wrap it for you.
+    variable version [package provide Tcl]
+    variable patchLevel [info patchlevel]
 
-    # Export the public tcltest procs
-    namespace export bytestring cleanupTests customMatch debug errorChannel \
-	    errorFile interpreter limitConstraints loadFile loadScript \
-	    loadTestedCommands makeDirectory makeFile match \
-	    matchDirectories matchFiles normalizeMsg normalizePath \
-	    outputChannel outputFile preserveCore removeDirectory \
-	    removeFile runAllTests singleProcess skip skipDirectories \
-	    skipFiles temporaryDirectory test testConstraint \
-	    testsDirectory verbose viewFile workingDirectory
-    # Export the tcltest 1 compatibility procs
+##### Export the public tcltest procs; several categories
+    #
+    # Export the main functional commands that do useful things
+    namespace export cleanupTests loadTestedCommands makeDirectory \
+	makeFile removeDirectory removeFile runAllTests test
+
+    # Export configuration commands that control the functional commands
+    namespace export configure customMatch errorChannel interpreter \
+	    outputChannel testConstraint
+
+    # Export commands that are duplication (candidates for deprecation)
+    namespace export bytestring		;# dups [encoding convertfrom identity]
+    namespace export debug		;#	[configure -debug]
+    namespace export errorFile		;#	[configure -errfile]
+    namespace export limitConstraints	;#	[configure -limitconstraints]
+    namespace export loadFile		;#	[configure -loadfile]
+    namespace export loadScript		;#	[configure -load]
+    namespace export match		;#	[configure -match]
+    namespace export matchFiles		;#	[configure -file]
+    namespace export matchDirectories	;#	[configure -relateddir]
+    namespace export normalizeMsg	;#	application of [customMatch]
+    namespace export normalizePath	;#	[file normalize] (8.4)
+    namespace export outputFile		;#	[configure -outfile]
+    namespace export preserveCore	;#	[configure -preservecore]
+    namespace export singleProcess	;#	[configure -singleproc]
+    namespace export skip		;#	[configure -skip]
+    namespace export skipFiles		;#	[configure -notfile]
+    namespace export skipDirectories	;#	[configure -asidefromdir]
+    namespace export temporaryDirectory	;#	[configure -tmpdir]
+    namespace export testsDirectory	;#	[configure -testdir]
+    namespace export verbose		;#	[configure -verbose]
+    namespace export viewFile		;#	bizarre [read]-ish thing
+    namespace export workingDirectory	;#	[cd] [pwd]
+
+    # Export deprecated commands for tcltest 1 compatibility
     namespace export getMatchingFiles mainThread restoreState saveState \
 	    threadReap
 
-    proc Default {varName value} {
-	variable $varName
-	if {![info exists $varName]} {
-	    variable $varName $value
+    # tcltest::normalizePath --
+    #
+    #     This procedure resolves any symlinks in the path thus creating
+    #     a path without internal redirection. It assumes that the
+    #     incoming path is absolute.
+    #
+    # Arguments
+    #     pathVar - name of variable containing path to modify.
+    #
+    # Results
+    #     The path is modified in place.
+    #
+    # Side Effects:
+    #     None.
+    #
+    proc normalizePath {pathVar} {
+	upvar $pathVar path
+	set oldpwd [pwd]
+	catch {cd $path}
+	set path [pwd]
+	cd $oldpwd
+	return $path
+    }
+
+##### Verification commands used to test values of variables and options
+    #
+    # Verification command that accepts everything
+    proc AcceptAll {value} {
+	return $value
+    }
+
+    # Verification command that accepts valid Tcl lists
+    proc AcceptList { list } {
+	return [lrange $list 0 end]
+    }
+
+    # Verification command that accepts a glob pattern
+    proc AcceptPattern { pattern } {
+	return [AcceptAll $pattern]
+    }
+
+    # Verification command that accepts integers
+    proc AcceptInteger { level } {
+	return [incr level 0]
+    }
+
+    # Verification command that accepts boolean values
+    proc AcceptBoolean { boolean } {
+	return [expr {$boolean && $boolean}]
+    }
+
+    # Verification command that accepts (syntactically) valid Tcl scripts
+    proc AcceptScript { script } {
+	if {![info complete $script]} {
+	    return -code error "invalid Tcl script: $script"
+	}
+	return $script
+    }
+
+    # Verification command that accepts (converts to) absolute pathnames
+    proc AcceptAbsolutePath { path } {
+	return [file join [pwd] $path]
+    }
+
+    # Verification command that accepts existing readable directories
+    proc AcceptReadable { path } {
+	if {![file readable $path]} {
+	    return -code error "\"$path\" is not readable"
 	}
+	return $path
     }
+    proc AcceptDirectory { directory } {
+	set directory [AcceptAbsolutePath $directory]
+	if {![file exists $directory]} {
+	    return -code error "\"$directory\" does not exist"
+	}
+	if {![file isdir $directory]} {
+	    return -code error "\"$directory\" is not a directory"
+	}
+	return [AcceptReadable $directory]
+    }
+
+##### Initialize internal arrays of tcltest, but only if the caller
+    # has not already pre-initialized them.  This is done to support
+    # compatibility with older tests that directly access internals
+    # rather than go through command interfaces.
+    #
     proc ArrayDefault {varName value} {
 	variable $varName
 	if {[array exists $varName]} {
@@ -55,41 +165,48 @@ namespace eval tcltest {
 	array set $varName $value
     }
 
-    # verbose defaults to {body}
-    Default verbose body
+    # save the original environment so that it can be restored later
+    ArrayDefault originalEnv [array get ::env]
 
-    # Match and skip patterns default to the empty list, except for
-    # matchFiles, which defaults to all .test files in the
-    # testsDirectory and matchDirectories, which defaults to all
-    # directories.
-    Default match {}
-    Default skip {}
-    Default matchFiles {*.test}
-    Default skipFiles {}
-    Default matchDirectories {*}
-    Default skipDirectories {}
+    # initialize numTests array to keep track fo the number of tests
+    # that pass, fail, and are skipped.
+    ArrayDefault numTests [list Total 0 Passed 0 Skipped 0 Failed 0]
 
-    # By default, don't save core files
-    Default preserveCore 0
+    # numTests will store test files as indices and the list of files
+    # (that should not have been) left behind by the test files.
+    ArrayDefault createdNewFiles {}
 
-    # output goes to stdout by default
-    Default outputChannel stdout
-    Default outputFile stdout
+    # initialize skippedBecause array to keep track of constraints that
+    # kept tests from running; a constraint name of "userSpecifiedSkip"
+    # means that the test appeared on the list of tests that matched the
+    # -skip value given to the flag; "userSpecifiedNonMatch" means that
+    # the test didn't match the argument given to the -match flag; both
+    # of these constraints are counted only if tcltest::debug is set to
+    # true.
+    ArrayDefault skippedBecause {}
 
-    # errors go to stderr by default
-    Default errorChannel stderr
-    Default errorFile stderr
+    # initialize the testConstraints array to keep track of valid
+    # predefined constraints (see the explanation for the
+    # InitConstraints proc for more details).
+    ArrayDefault testConstraints {}
 
-    # debug output doesn't get printed by default; debug level 1 spits
-    # up only the tests that were skipped because they didn't match or
-    # were specifically skipped.  A debug level of 2 would spit up the
-    # tcltest variables and flags provided; a debug level of 3 causes
-    # some additional output regarding operations of the test harness.
-    # The tcltest package currently implements only up to debug level 3.
-    Default debug 0
+##### Initialize internal variables of tcltest, but only if the caller
+    # has not already pre-initialized them.  This is done to support
+    # compatibility with older tests that directly access internals
+    # rather than go through command interfaces.
+    #
+    proc Default {varName value {verify AcceptAll}} {
+	variable $varName
+	if {![info exists $varName]} {
+	    variable $varName [$verify $value]
+	} else {
+	    variable $varName [$verify [set $varName]]
+	}
+    }
 
     # Save any arguments that we might want to pass through to other
     # programs.  This is used by the -args flag.
+    # FINDUSER
     Default parameters {}
 
     # Count the number of files tested (0 if runAllTests wasn't called).
@@ -98,57 +215,36 @@ namespace eval tcltest {
     # The currentFailure var stores the boolean value of whether the
     # current test file has had any failures.  The failFiles list
     # stores the names of test files that had failures.
-    Default numTestFiles 0
-    Default testSingleFile true
-    Default currentFailure false
-    Default failFiles {}
+    Default numTestFiles 0 AcceptInteger
+    Default testSingleFile true AcceptBoolean
+    Default currentFailure false AcceptBoolean
+    Default failFiles {} AcceptList
 
     # Tests should remove all files they create.  The test suite will
     # check the current working dir for files created by the tests.
     # filesMade keeps track of such files created using the makeFile and
     # makeDirectory procedures.  filesExisted stores the names of
     # pre-existing files.
-    Default filesMade {}
-    Default filesExisted {}
-
-    # numTests will store test files as indices and the list of files
-    # (that should not have been) left behind by the test files.
-    ArrayDefault createdNewFiles {}
-
-    # initialize numTests array to keep track fo the number of tests
-    # that pass, fail, and are skipped.
-    ArrayDefault numTests [list Total 0 Passed 0 Skipped 0 Failed 0]
-
-    # initialize skippedBecause array to keep track of constraints that
-    # kept tests from running; a constraint name of "userSpecifiedSkip"
-    # means that the test appeared on the list of tests that matched the
-    # -skip value given to the flag; "userSpecifiedNonMatch" means that
-    # the test didn't match the argument given to the -match flag; both
-    # of these constraints are counted only if tcltest::debug is set to
-    # true.
-    ArrayDefault skippedBecause {}
+    Default filesMade {} AcceptList
+    Default filesExisted {} AcceptList
+    variable FilesExistedFilled 0
+    proc FillFilesExisted {} {
+	variable FilesExistedFilled
+	if {$FilesExistedFilled} {return}
+	variable filesExisted
 
-    # initialize the testConstraints array to keep track of valid
-    # predefined constraints (see the explanation for the
-    # InitConstraints proc for more details).
-    ArrayDefault testConstraints {}
-    Default ConstraintsSpecifiedByCommandLineArgument {}
+	# Save the names of files that already exist in the scratch directory.
+	foreach file [glob -nocomplain -directory [temporaryDirectory] *] {
+	    lappend filesExisted [file tail $file]
+	}
+	set FilesExistedFilled 1
+    }
 
     # Kept only for compatibility
-    Default constraintsSpecified {}
+    Default constraintsSpecified {} AcceptList
     trace variable constraintsSpecified r {set ::tcltest::constraintsSpecified \
 		[array names ::tcltest::testConstraints] ;# }
 
-    # Don't run only the "-constraint" specified tests by default
-    Default limitConstraints false
-
-    # A test application has to know how to load the tested commands
-    # into the interpreter.
-    Default loadScript {}
-
-    # and the filename of the script file, if it exists
-    Default loadFile {}
-
     # tests that use threads need to know which is the main thread
     Default mainThread 1
     variable mainThread
@@ -158,49 +254,40 @@ namespace eval tcltest {
 	set mainThread [testthread id]
     }
 
-    # save the original environment so that it can be restored later
-    ArrayDefault originalEnv [array get ::env]
-
     # Set workingDirectory to [pwd]. The default output directory for
-    # Tcl tests is the working directory.
-    Default workingDirectory [pwd]
-    Default temporaryDirectory $workingDirectory
+    # Tcl tests is the working directory.  Whenever this value changes
+    # change to that directory.
+    variable workingDirectory
+    trace variable workingDirectory w \
+	    [namespace code {cd $workingDirectory ;#}]
 
-    # tcltest::normalizePath --
-    #
-    #     This procedure resolves any symlinks in the path thus creating
-    #     a path without internal redirection. It assumes that the
-    #     incoming path is absolute.
-    #
-    # Arguments
-    #     pathVar contains the name of the variable containing the path
-    #     to modify.
-    #
-    # Results
-    #     The path is modified in place.
-    #
-    # Side Effects:
-    #     None.
-    #
-    proc normalizePath {pathVar} {
-	upvar $pathVar path
-	set oldpwd [pwd]
-	catch {cd $path}
-	set path [pwd]
-	cd $oldpwd
-	return $path
+    Default workingDirectory [pwd] AcceptAbsolutePath
+    proc workingDirectory { {dir ""} } {
+	variable workingDirectory
+	if {[llength [info level 0]] == 1} {
+	    return $workingDirectory
+	}
+	set workingDirectory [AcceptAbsolutePath $dir]
     }
 
-    # Tests should not rely on the current working directory.
-    # Files that are part of the test suite should be accessed relative
-    # to tcltest::testsDirectory.
-    Default testsDirectory [file join \
-	    [file dirname [info script]] .. .. tests]
-    variable testsDirectory
-    normalizePath testsDirectory
+    # Set the location of the execuatble
+    Default tcltest [info nameofexecutable]
 
-    # Default is to run each test file in a separate process
-    Default singleProcess 0
+    # save the platform information so it can be restored later
+    Default originalTclPlatform [array get tcl_platform]
+
+    # If a core file exists, save its modification time.
+    if {[file exists [file join [workingDirectory] core]]} {
+	Default coreModTime \
+		[file mtime [file join [workingDirectory] core]]
+    }
+
+    # stdout and stderr buffers for use when we want to store them
+    Default outData {}
+    Default errData {}
+
+    # keep track of test level for nested test commands
+    variable testLevel 0
 
     # the variables and procs that existed when saveState was called are
     # stored in a variable of the same name
@@ -243,25 +330,377 @@ namespace eval tcltest {
 	}
     }
 
-    # Set the location of the execuatble
-    Default tcltest [info nameofexecutable]
+    # output goes to stdout by default
+    Default outputChannel stdout
+    proc outputChannel { {filename ""} } {
+	variable outputChannel
+
+	# Trigger auto-configuration of -outfile option, if needed.
+	# This is tricky because we have to trigger a trace on $debug
+	# so that traces attached to $outputFile are not disabled.
+	# We need them enabled to reflect changes back to outputChannel
+	set dummy [debug]
+
+	if {[llength [info level 0]] == 1} {
+	    return $outputChannel
+	}
+	switch -exact -- $filename {
+	    stderr -
+	    stdout {
+		set outputChannel $filename
+	    }
+	    default {
+		set outputChannel [open $filename a]
+	    }
+	}
+	return $outputChannel
+    }
 
-    # save the platform information so it can be restored later
-    Default originalTclPlatform [array get tcl_platform]
+    # errors go to stderr by default
+    Default errorChannel stderr
+    proc errorChannel { {filename ""} } {
+	variable errorChannel
+
+	# Trigger auto-configuration of -errfile option, if needed.
+	# This is tricky because we have to trigger a trace on $debug
+	# so that traces attached to $outputFile are not disabled.
+	# We need them enabled to reflect changes back to outputChannel
+	set dummy [debug]
+
+	if {[llength [info level 0]] == 1} {
+	    return $errorChannel
+	}
+	switch -exact -- $filename {
+	    stderr -
+	    stdout {
+		set errorChannel $filename
+	    }
+	    default {
+		set errorChannel [open $filename a]
+	    }
+	}
+	return $errorChannel
+    }
 
-    # If a core file exists, save its modification time.
-    variable workingDirectory
-    if {[file exists [file join $workingDirectory core]]} {
-	Default coreModTime \
-		[file mtime [file join $workingDirectory core]]
+##### Set up the configurable options
+    #
+    # The configurable options of the package
+    variable Option; array set Option {}
+
+    # Usage strings for those options
+    variable Usage; array set Usage {}
+
+    # Verification commands for those options
+    variable Verify; array set Verify {}
+
+    # Initialize the default values of the configurable options that are
+    # historically associated with an exported variable.  If that variable
+    # is already set, support compatibility by accepting its pre-set value.
+    # Use [trace] to establish ongoing connection between the deprecated
+    # exported variable and the modern option kept as a true internal var.
+    # Also set up usage string and value testing for the option.
+    proc Option {option value usage {verify AcceptAll} {varName {}}} {
+	variable Option
+	variable Verify
+	variable Usage
+	variable OptionControlledVariables
+	set Usage($option) $usage
+	set Verify($option) $verify
+	set Option($option) [$verify $value]
+	if {[string length $varName]} {
+	    variable $varName
+	    if {[info exists $varName]} {
+		set Option($option) [$verify [set $varName]]
+		unset $varName
+	    }
+	    namespace eval [namespace current] \
+	    	    [list upvar 0 Option($option) $varName]
+	    # Workaround for Bug 572889.  Grrrr....
+	    # Track all the variables tied to options
+	    lappend OptionControlledVariables $varName
+	    # Later, set auto-configure read traces on all
+	    # of them, since a single trace on Option does not work.
+	    proc $varName {{value {}}} [subst -nocommands {
+		if {[llength [info level 0]] == 2} {
+		    Configure $option [set value]
+		}
+		return [Configure $option]
+	    }]
+	}
     }
 
-    # stdout and stderr buffers for use when we want to store them
-    Default outData {}
-    Default errData {}
+    proc MatchingOption {option} {
+	variable Option
+	set match [array names Option $option*]
+	switch -- [llength $match] {
+	    0 {
+		set sorted [lsort [array names Option]]
+		set values [join [lrange $sorted 0 end-1] ", "]
+		append values ", or [lindex $sorted end]"
+		return -code error "unknown option $option: should be\
+			one of $values"
+	    }
+	    1 {
+		return [lindex $match 0]
+	    }
+	    default {
+		# Exact match trumps ambiguity
+		if {[lsearch -exact $match $option] >= 0} {
+		    return $option
+		}
+		set values [join [lrange $match 0 end-1] ", "]
+		append values ", or [lindex $match end]"
+		return -code error "ambiguous option $option:\
+			could match $values"
+	    }
+	}
+    }
+
+    proc EstablishAutoConfigureTraces {} {
+	variable OptionControlledVariables
+	foreach varName [concat $OptionControlledVariables Option] {
+	    variable $varName
+	    trace variable $varName r [namespace code {ProcessCmdLineArgs ;#}]
+	}
+    }
+
+    proc RemoveAutoConfigureTraces {} {
+	variable OptionControlledVariables
+	foreach varName [concat $OptionControlledVariables Option] {
+	    variable $varName
+	    foreach pair [trace vinfo $varName] {
+		foreach {op cmd} $pair break
+		if {[string equal r $op]
+			&& [string match *ProcessCmdLineArgs* $cmd]} {
+		    trace vdelete $varName $op $cmd
+		}
+	    }
+	}
+	# One the traces are removed, this can become a no-op
+	proc RemoveAutoConfigureTraces {} {}
+    }
+
+    proc Configure args {
+	variable Option
+	variable Verify
+	set n [llength $args]
+	if {$n == 0} {
+	    return [lsort [array names Option]]
+	}
+	if {$n == 1} {
+	    if {[catch {MatchingOption [lindex $args 0]} option]} {
+		return -code error $option
+	    }
+	    return $Option($option)
+	}
+	while {[llength $args] > 1} {
+	    if {[catch {MatchingOption [lindex $args 0]} option]} {
+		return -code error $option
+	    }
+	    if {[catch {$Verify($option) [lindex $args 1]} value]} {
+		return -code error "invalid $option\
+			value \"[lindex $args 1]\": $value"
+	    }
+	    set Option($option) $value
+	    set args [lrange $args 2 end]
+	}
+	if {[llength $args]} {
+	    if {[catch {MatchingOption [lindex $args 0]} option]} {
+		return -code error $option
+	    }
+	    return -code error "missing value for option $option"
+	}
+    }
+    proc configure args {
+	RemoveAutoConfigureTraces
+	set code [catch {eval Configure $args} msg]
+	return -code $code $msg
+    }
+    
+    proc AcceptVerbose { level } {
+	set level [AcceptList $level]
+	if {[llength $level] == 1} {
+	    if {![regexp {^(pass|body|skip|start|error)$} $level]} {
+		# translate single characters abbreviations to expanded list
+		set level [string map {p pass b body s skip t start e error} \
+			[split $level {}]]
+	    }
+	}
+	set valid [list]
+	foreach v $level {
+	    if {[regexp {^(pass|body|skip|start|error)$} $v]} {
+		lappend valid $v
+	    }
+	}
+	return $valid
+    }
+
+    proc IsVerbose {level} {
+	variable Option
+	return [expr {[lsearch -exact $Option(-verbose) $level] != -1}]
+    }
+
+    # Default verbosity is to show bodies of failed tests
+    Option -verbose body {
+	Takes any combination of the values 'p', 's', 'b', 't' and 'e'.
+	Test suite will display all passed tests if 'p' is specified, all
+	skipped tests if 's' is specified, the bodies of failed tests if
+	'b' is specified, and when tests start if 't' is specified.
+	ErrorInfo is displayed if 'e' is specified.
+    } AcceptVerbose verbose
+
+    # Match and skip patterns default to the empty list, except for
+    # matchFiles, which defaults to all .test files in the
+    # testsDirectory and matchDirectories, which defaults to all
+    # directories.
+    Option -match {} {
+	Run all tests within the specified files that match one of the
+	list of glob patterns given.
+    } AcceptList match
+
+    Option -skip {} {
+	Skip all tests within the specified tests (via -match) and files
+	that match one of the list of glob patterns given.
+    } AcceptList skip
+
+    Option -file *.test {
+	Run tests in all test files that match the glob pattern given.
+    } AcceptPattern matchFiles
+
+    Option -notfile {} {
+	Skip all test files that match the glob pattern given.
+    } AcceptPattern skipFiles
+
+    Option -relateddir * {
+	Run tests in directories that match the glob pattern given.
+    } AcceptPattern matchDirectories
+
+    Option -asidefromdir {} {
+	Skip tests in directories that match the glob pattern given.
+    } AcceptPattern skipDirectories
+
+    # By default, don't save core files
+    Option -preservecore 0 {
+	If 2, save any core files produced during testing in the directory
+	specified by -tmpdir. If 1, notify the user if core files are
+	created.
+    } AcceptInteger preserveCore
+
+    # debug output doesn't get printed by default; debug level 1 spits
+    # up only the tests that were skipped because they didn't match or
+    # were specifically skipped.  A debug level of 2 would spit up the
+    # tcltest variables and flags provided; a debug level of 3 causes
+    # some additional output regarding operations of the test harness.
+    # The tcltest package currently implements only up to debug level 3.
+    Option -debug 0 {
+	Internal debug level 
+    } AcceptInteger debug
+
+    proc SetSelectedConstraints args {
+	variable Option
+	foreach c $Option(-constraints) {
+	    testConstraint $c 1
+	}
+    }
+    Option -constraints {} {
+	Do not skip the listed constraints listed in -constraints.
+    } AcceptList
+    trace variable Option(-constraints) w \
+	    [namespace code {SetSelectedConstraints ;#}]
+
+    # Don't run only the "-constraint" specified tests by default
+    proc ClearUnselectedConstraints args {
+	variable Option
+	variable testConstraints
+	if {!$Option(-limitconstraints)} {return}
+	foreach c [array names testConstraints] {
+	    if {[lsearch -exact $Option(-constraints) $c] == -1} {
+		testConstraint $elt 0
+	    }
+	}
+    }
+    Option -limitconstraints false {
+	whether to run only tests with the constraints
+    } AcceptBoolean limitConstraints 
+    trace variable Option(-limitconstraints) w \
+	    [namespace code {ClearUnselectedConstraints ;#}]
+
+    # A test application has to know how to load the tested commands
+    # into the interpreter.
+    Option -load {} {
+	Specifies the script to load the tested commands.
+    } AcceptScript loadScript
+
+    # Default is to run each test file in a separate process
+    Option -singleproc 0 {
+	whether to run all tests in one process
+    } AcceptBoolean singleProcess 
+
+    proc AcceptTemporaryDirectory { directory } {
+	set directory [AcceptAbsolutePath $directory]
+	if {![file exists $directory]} {
+	    file mkdir $directory
+	}
+	set directory [AcceptDirectory $directory]
+	if {![file writable $directory]} {
+	    return -code error "\"$directory\" is not writeable"
+	}
+	return $directory
+    }
+
+    # Directory where files should be created
+    Option -tmpdir [workingDirectory] {
+	Save temporary files in the specified directory.
+    } AcceptTemporaryDirectory temporaryDirectory
+    trace variable Option(-tmpdir) w \
+	    [namespace code {normalizePath Option(-tmpdir) ;#}]
+
+    # Tests should not rely on the current working directory.
+    # Files that are part of the test suite should be accessed relative
+    # to [testsDirectory]
+    Option -testdir [file join [file dirname [info script]] .. ..  tests] {
+	Search tests in the specified directory.
+    } AcceptDirectory testsDirectory
+    trace variable Option(-testdir) w \
+	    [namespace code {normalizePath Option(-testdir) ;#}]
+
+    proc AcceptLoadFile { file } {
+	if {[string equal "" $file]} {return $file}
+	set file [file join [temporaryDirectory] $file]
+	return [AcceptReadable $file]
+    }
+    proc ReadLoadScript {args} {
+	variable Option
+	if {[string equal "" $Option(-loadfile)]} {return}
+	set tmp [open $Option(-loadfile) r]
+	loadScript [read $tmp]
+	close $tmp
+    }
+    Option -loadfile {} {
+	Read the script to load the tested commands from the specified file.
+    } AcceptLoadFile loadFile
+    trace variable Option(-loadfile) w [namespace code ReadLoadScript]
+
+    proc AcceptOutFile { file } {
+	if {[string equal stderr $file]} {return $file}
+	if {[string equal stdout $file]} {return $file}
+	return [file join [temporaryDirectory] $file]
+    }
+
+    # output goes to stdout by default
+    Option -outfile stdout {
+	Send output from test runs to the specified file.
+    } AcceptOutFile outputFile
+    trace variable Option(-outfile) w \
+	    [namespace code {outputChannel $Option(-outfile) ;#}]
+
+    # errors go to stderr by default
+    Option -errfile stderr {
+	Send errors from test runs to the specified file.
+    } AcceptOutFile errorFile
+    trace variable Option(-errfile) w \
+	    [namespace code {errorChannel $Option(-errfile) ;#}]
 
-    # keep track of test level for nested test commands
-    variable testLevel 0
 }
 
 #####################################################################
@@ -357,305 +796,16 @@ proc tcltest::DebugDo {level script} {
 
 #####################################################################
 
-# tcltest::CheckDirectory --
-#
-#     This procedure checks whether the specified path is a readable
-#     and/or writable directory. If one of the conditions is not
-#     satisfied an error is printed and the application aborted. The
-#     procedure assumes that the caller already checked the existence
-#     of the path.
-#
-# Arguments
-#     rw      Information what attributes to check. Allowed values:
-#             r, w, rw, wr. If 'r' is part of the value the directory
-#             must be readable. 'w' associates to 'writable'.
-#     dir     The directory to check.
-#     errMsg  The string to prepend to the actual error message before
-#             printing it.
-#
-# Results
-#     none
-#
-# Side Effects:
-#     None.
-#
-
-proc tcltest::CheckDirectory {rw dir errMsg} {
-    # Allowed values for 'rw': r, w, rw, wr
-
-    if {![file isdir $dir]} {
-	return -code error "$errMsg \"$dir\" is not a directory"
-    } elseif {([string first w $rw] >= 0) && ![file writable $dir]} {
-	return -code error "$errMsg \"$dir\" is not writeable"
-    } elseif {([string first r $rw] >= 0) && ![file readable $dir]} {
-	return -code error "$errMsg \"$dir\" is not readable"
-    }
-    return
-}
-
-# tcltest::MakeAbsolutePath --
-#
-#     This procedure checks whether the incoming path is absolute or
-#     not.  Makes it absolute if it was not.
-#
-# Arguments
-#     pathVar contains the name of the variable containing the path to
-#             modify.
-#     prefix  is optional, contains the path to use to make the other an
-#             absolute one. The current working directory is used if it
-#             was not specified.
-#
-# Results
-#     The path is modified in place.
-#
-# Side Effects:
-#     None.
-#
-
-proc tcltest::MakeAbsolutePath {pathVar {prefix {}}} {
-    upvar $pathVar path
-
-    if {![string equal [file pathtype $path] "absolute"]} {
-	if {[string equal {} $prefix]} {
-	    set prefix [pwd]
-	}
-
-	set path [file join $prefix $path]
-    }
-    return $path
-}
-
-#####################################################################
-
-# tcltest::<variableName>
-#
-#     Accessor functions for tcltest variables that can be modified
-#     externally.  These are vars that could otherwise be modified
-#     using command line arguments to tcltest.
-
-#     Many of them are all the same boilerplate:
-
-namespace eval tcltest {
-    variable var
-    foreach var {
-	    match skip matchFiles skipFiles matchDirectories
-	    skipDirectories preserveCore debug loadScript singleProcess
-	    mainThread ConstraintsSpecifiedByCommandLineArgument
-    } {
-	proc $var { {new ""} } [subst -nocommands {
-	    variable $var
-	    if {[llength [info level 0]] == 1} {
-		return [set $var]
-	    }
-	    set $var \$new
-	}]
-    }
-    unset var
-}
-
-#     The rest have something special to deal with:
-
-# tcltest::verbose --
+# tcltest::mainThread
 #
-#	Set or return the verbosity level (tcltest::verbose) for tests.
-#       This determines what gets printed to the screen and when, with
-#       regard to the running of the tests.  The proc does not check for
-#       invalid values.  It assumes that a string that doesn't match its
-#       predefined keywords is a string containing letter-specified
-#       verbosity levels.
-#
-# Arguments:
-#	A string containing any combination of 'pbste' or a list of
-#       keywords (listed in parens)
-#          p = print output whenever a test passes (pass)
-#          b = print the body of the test when it fails (body)
-#          s = print when a test is skipped (skip)
-#          t = print when a test starts (start)
-#          e = print errorInfo and errorCode when a test encounters an
-#              error (error)
+#     Accessor command for tcltest variable mainThread.
 #
-# Results:
-#	content of tcltest::verbose
-#
-# Side effects:
-#	None.
-
-proc tcltest::verbose { {level ""} } {
-    variable verbose
-    if {[llength [info level 0]] == 1} {
-	return $verbose
-    }
-    if {[llength $level] > 1} {
-  	set verbose $level
-    } else {
-	if {[regexp {pass|body|skip|start|error} $level]} {
-	    set verbose $level
-	} else {
-	    set levelList [split $level {}]
-	    set verbose [string map \
-		    {p pass b body s skip t start e error} $levelList]
-	}
-    }
-    return $verbose
-}
-
-# tcltest::IsVerbose --
-#
-#	Returns true if argument is one of the verbosity levels
-#       currently being used; returns false otherwise.
-#
-# Arguments:
-#	level
-#
-# Results:
-#	boolean 1 (true) or 0 (false), depending on whether or not the
-#       level provided is one of the ones stored in tcltest::verbose.
-#
-# Side effects:
-#	None.
-
-proc tcltest::IsVerbose {level} {
-    if {[lsearch -exact [verbose] $level] == -1} {
-	return 0
-    }
-    return 1
-}
-
-# tcltest::outputChannel --
-#
-#	set or return the output file descriptor based on the supplied
-#       file name (where tcltest puts all of its output)
-#
-# Arguments:
-#	output file descriptor
-#
-# Results:
-#	file descriptor corresponding to supplied file name (or
-#       currently set file descriptor, if no new filename was supplied)
-#       - this is the content of tcltest::outputChannel
-#
-# Side effects:
-#	None.
-
-proc tcltest::outputChannel { {filename ""} } {
-    variable outputChannel
-    if {[llength [info level 0]] == 1} {
-	return $outputChannel
-    }
-    switch -exact -- $filename {
-	stderr -
-	stdout {
-	    set outputChannel $filename
-	}
-	default {
-	    set outputChannel [open $filename w]
-	}
-    }
-    return $outputChannel
-}
-
-# tcltest::outputFile --
-#
-#	set or return the output file name (where tcltest puts all of
-#       its output); calls [outputChannel] to set the corresponding
-#       file descriptor
-#
-# Arguments:
-#	output file name
-#
-# Results:
-#       file name corresponding to supplied file name (or currently set
-#       file name, if no new filename was supplied) - this is the
-#       content of tcltest::outputFile
-#
-# Side effects:
-#	if the file name supplied is relative, it will be made absolute
-#       with respect to the predefined temporaryDirectory
-
-proc tcltest::outputFile { {filename ""} } {
-    variable outputFile
-    if {[llength [info level 0]] == 1} {
-	return $outputFile
-    }
-    switch -exact -- $filename {
-	stderr -
-	stdout {
-	    # do nothing
-	}
-	default {
-	    MakeAbsolutePath filename [temporaryDirectory]
-	}
-    }
-    outputChannel $filename
-    set outputFile $filename
-}
-
-# tcltest::errorChannel --
-#
-#	set or return the error file descriptor based on the supplied
-#       file name (where tcltest sends all its errors)
-#
-# Arguments:
-#	error file name
-#
-# Results:
-#	file descriptor corresponding to the supplied file name (or
-#       currently set file descriptor, if no new filename was supplied)
-#       - this is the content of tcltest::errorChannel
-#
-# Side effects:
-#	opens the descriptor in w mode unless the filename is set to
-#       stderr or stdout
-
-proc tcltest::errorChannel { {filename ""} } {
-    variable errorChannel
-    if {[llength [info level 0]] == 1} {
-	return $errorChannel
-    }
-    switch -exact -- $filename {
-	stderr -
-	stdout {
-	    set errorChannel $filename
-	}
-	default {
-	    set errorChannel [open $filename w]
-	}
-    }
-    return $errorChannel
-}
-
-# tcltest::errorFile --
-#
-#	set or return the error file name; calls [errorChannel] to set
-#       the corresponding file descriptor
-#
-# Arguments:
-#	error file name
-#
-# Results:
-#	content of tcltest::errorFile
-#
-# Side effects:
-#	if the file name supplied is relative, it will be made absolute
-#       with respect to the predefined temporaryDirectory
-
-proc tcltest::errorFile { {filename ""} } {
-    variable errorFile
+proc tcltest::mainThread { {new ""} } {
+    variable mainThread
     if {[llength [info level 0]] == 1} {
-	return $errorFile
-    }
-    switch -exact -- $filename {
-	stderr -
-	stdout {
-	    # do nothing
-	}
-	default {
-	    MakeAbsolutePath filename [temporaryDirectory]
-	}
+	return $mainThread
     }
-    set errorFile $filename
-    errorChannel $errorFile
-    return $errorFile
+    set mainThread $new
 }
 
 # tcltest::testConstraint --
@@ -691,168 +841,6 @@ proc tcltest::testConstraint {constraint {value ""}} {
     set testConstraints($constraint) $value
 }
 
-# tcltest::limitConstraints --
-#
-#	sets/gets flag indicating whether tests run are limited only
-#	to those matching constraints specified by the -constraints
-#	command line option.
-#
-# Arguments:
-#	new boolean value for the flag
-#
-# Results:
-#	content of tcltest::limitConstraints
-#
-# Side effects:
-#	None.
-
-proc tcltest::limitConstraints { {value ""} } {
-    variable testConstraints
-    variable limitConstraints
-    DebugPuts 3 "entering limitConstraints $value"
-    if {[llength [info level 0]] == 1} {
-	return $limitConstraints
-    }
-    # Check for boolean values
-    if {[catch {expr {$value && $value}} msg]} {
-	return -code error $msg
-    }
-    set limitConstraints $value
-    if {!$limitConstraints} {return $limitConstraints}
-    foreach elt [array names testConstraints] {
-	if {[lsearch -exact [ConstraintsSpecifiedByCommandLineArgument] $elt] 
-		== -1} {
-	    testConstraint $elt 0
-	}
-    }
-    return $limitConstraints
-}
-
-# tcltest::loadFile --
-#
-#	set the load file (containing the load script);
-#       put the content of the load file into loadScript
-#
-# Arguments:
-#	script's file name
-#
-# Results:
-#	content of tcltest::loadFile
-#
-# Side effects:
-#	None.
-
-proc tcltest::loadFile { {scriptFile ""} } {
-    variable loadFile
-    if {[llength [info level 0]] == 1} {
-	return $loadFile
-    }
-    MakeAbsolutePath scriptFile [temporaryDirectory]
-    set tmp [open $scriptFile r]
-    loadScript [read $tmp]
-    close $tmp
-    set loadFile $scriptFile
-}
-
-# tcltest::workingDirectory --
-#
-#	set workingDirectory to the given path.  If the path is
-#       relative, make it absolute.  Change directory to the stated
-#       working directory, if resetting the value
-#
-# Arguments:
-#	directory name
-#
-# Results:
-#	content of tcltest::workingDirectory
-#
-# Side effects:
-#	None.
-
-proc tcltest::workingDirectory { {dir ""} } {
-    variable workingDirectory
-    if {[llength [info level 0]] == 1} {
-	return $workingDirectory
-    }
-    set workingDirectory $dir
-    MakeAbsolutePath workingDirectory
-    cd $workingDirectory
-    return $workingDirectory
-}
-
-# tcltest::temporaryDirectory --
-#
-#     Set temporaryDirectory to the given path.  If the path is
-#     relative, make it absolute.  If the file exists but is not a dir,
-#     then return an error.
-#
-#     If temporaryDirectory does not already exist, create it.  If you
-#     cannot create it, then return an error (the file mkdir isn't
-#     caught and will propagate).
-#
-# Arguments:
-#	directory name
-#
-# Results:
-#	content of tcltest::temporaryDirectory
-#
-# Side effects:
-#	None.
-
-proc tcltest::temporaryDirectory { {dir ""} } {
-    variable temporaryDirectory
-    if {[llength [info level 0]] == 1} {
-	return $temporaryDirectory
-    }
-    set temporaryDirectory $dir
-    MakeAbsolutePath temporaryDirectory
-
-    if {[file exists $temporaryDirectory]} {
-	CheckDirectory rw $temporaryDirectory \
-		{bad argument for temporary directory: }
-    } else {
-	file mkdir $temporaryDirectory
-    }
-
-    normalizePath temporaryDirectory
-}
-
-# tcltest::testsDirectory --
-#
-#     Set testsDirectory to the given path.  If the path is relative,
-#     make it absolute.  If the file exists but is not a dir, then
-#     return an error.
-#
-#     If testsDirectory does not already exist, return an error.
-#
-# Arguments:
-#	directory name
-#
-# Results:
-#	content of tcltest::testsDirectory
-#
-# Side effects:
-#	None.
-
-proc tcltest::testsDirectory { {dir ""} } {
-    variable testsDirectory
-    if {[llength [info level 0]] == 1} {
-	return $testsDirectory
-    }
-
-    set testsDirectory $dir
-    MakeAbsolutePath testsDirectory
-    set testDirError "bad argument for tests directory: "
-    if {[file exists $testsDirectory]} {
-	CheckDirectory r $testsDirectory $testDirError
-    } else {
-	return -code error \
-		"$testDirError \"$testsDirectory\" does not exist"
-    }
-
-    normalizePath testsDirectory
-}
-
 # tcltest::interpreter --
 #
 #	the interpreter name stored in tcltest::tcltest
@@ -1242,15 +1230,6 @@ proc tcltest::DefineConstraintInitializers {} {
 # Handle command line arguments (from argv) and default arg settings
 # (in TCLTEST_OPTIONS).
 
-# tcltest::PrintUsageInfoHook
-#
-#       Hook used for customization of display of usage information.
-#
-
-if {[llength [info commands tcltest::PrintUsageInfoHook]] == 0} {
-    proc tcltest::PrintUsageInfoHook {} {}
-}
-
 # tcltest::PrintUsageInfo
 #
 #	Prints out the usage information for package tcltest.  This can
@@ -1265,93 +1244,54 @@ if {[llength [info commands tcltest::PrintUsageInfoHook]] == 0} {
 # Side Effects:
 #       none
 proc tcltest::PrintUsageInfo {} {
-    puts "Usage: [file tail [info nameofexecutable]]\
-	script ?-help? ?flag value? ... \n\
-	Available flags (and valid input values) are:\n\
-	-help          		 Display this usage information.\n\
-	-verbose level 		 Takes any combination of the values\n\
-	\t                 'p', 's', 'b', 't' and 'e'. \
-			   Test suite will\n\
-	\t                 display all passed tests if 'p' is\n\
-	\t                 specified, all skipped tests if 's'\n\
-	\t                 is specified, the bodies of\n\
-	\t                 failed tests if 'b' is specified,\n\
-	\t                 and when tests start if 't' is specified.\n\
-	\t                 ErrorInfo is displayed\
-			   if 'e' is specified.\n\
-	\t                 The default value is 'b'.\n\
-	-constraints list	 Do not skip the listed constraints\n\
-	-limitconstraints bool	 Only run tests with the constraints\n\
-	\t                 listed in -constraints.\n\
-	-match pattern 		 Run all tests within the specified\n\
-	\t                 files that match the glob pattern\n\
-	\t                 given.\n\
-	-skip pattern  		 Skip all tests within the set of\n\
-	\t                 specified tests (via -match) and\n\
-	\t                 files that match the glob pattern\n\
-	\t                 given.\n\
-	-file pattern  		 Run tests in all test files that\n\
-	\t                 match the glob pattern given.\n\
-	-notfile pattern	 Skip all test files that match the\n\
-	\t                 glob pattern given.\n\
-	-relateddir pattern	 Run tests in directories that match\n\
-	\t                 the glob pattern given.\n\
-	-asidefromdir pattern	 Skip tests in directories that match\n\
-	\t                 the glob pattern given.\n\
-	-preservecore level 	 If 2, save any core files produced\n\
-	\t                 during testing in the directory\n\
-	\t                 specified by -tmpdir. If 1, notify the\n\
-	\t                 user if core files are created. \
-			   The default\n\
-	\t                 is [preserveCore].\n\
-	-tmpdir directory	 Save temporary files\
-			   in the specified\n\
-	\t                 directory.  The default value is\n\
-	\t                 [temporaryDirectory]\n\
-	-testdir directories	 Search tests in the specified\n\
-	\t                 directories.  The default value is\n\
-	\t                 [testsDirectory].\n\
-	-outfile file    	 Send output from test runs to the\n\
-	\t                 specified file.  The default is\n\
-	\t                 stdout.\n\
-	-errfile file    	 Send errors from test runs to the\n\
-	\t                 specified file.  The default is\n\
-	\t                 stderr.\n\
-	-loadfile file   	 Read the script to load the tested\n\
-	\t                 commands from the specified file.\n\
-	-load script     	 Specifies the script\
-			   to load the tested\n\
-	\t                 commands.\n\
-	-debug level     	 Internal debug flag."
+    puts [Usage]
     PrintUsageInfoHook
-    return
 }
 
-# tcltest::processCmdLineArgsFlagsHook --
-#
-#	This hook is used to add to the list of command line arguments
-#	that are processed by tcltest::ProcessFlags.   It is called at
-#	the beginning of ProcessFlags.
-#
-
-if {[llength [info commands \
-	tcltest::processCmdLineArgsAddFlagsHook]] == 0} {
-    proc tcltest::processCmdLineArgsAddFlagsHook {} {}
+proc tcltest::Usage { {option ""} } {
+    variable Usage
+    variable Verify
+    if {[llength [info level 0]] == 1} {
+	set msg "Usage: [file tail [info nameofexecutable]] script "
+	append msg "?-help? ?flag value? ... \n"
+	append msg "Available flags (and valid input values) are:"
+
+	set max 0
+	set allOpts [concat -help [Configure]]
+	foreach opt $allOpts {
+	    set foo [Usage $opt]
+	    foreach [list x type($opt) usage($opt)] $foo break
+	    set line($opt) "  $opt $type($opt)  "
+	    set length($opt) [string length $line($opt)]
+	    if {$length($opt) > $max} {set max $length($opt)}
+	}
+	set rest [expr {72 - $max}]
+	foreach opt $allOpts {
+	    append msg \n$line($opt)
+	    append msg [string repeat " " [expr {$max - $length($opt)}]]
+	    set u [string trim $usage($opt)]
+	    catch {append u "  (default: \[[Configure $opt]])"}
+	    regsub -all {\s*\n\s*} $u " " u
+	    while {[string length $u] > $rest} {
+		set break [string wordstart $u $rest]
+		if {$break == 0} {
+		    set break [string wordend $u 0]
+		}
+		append msg [string range $u 0 [expr {$break - 1}]]
+		set u [string trim [string range $u $break end]]
+		append msg \n[string repeat " " $max]
+	    }
+	    append msg $u
+	}
+	return $msg\n
+    } elseif {[string equal -help $option]} {
+	return [list -help "" "Display this usage information."]
+    } else {
+	set type [lindex [info args $Verify($option)] 0]
+	return [list $option $type $Usage($option)]
+    }
 }
 
-# tcltest::processCmdLineArgsHook --
-#
-#	This hook is used to actually process the flags added by
-#       tcltest::processCmdLineArgsAddFlagsHook.  It is called at the
-#	end of ProcessFlags.
-#
-# Arguments:
-#	flags      The flags that have been pulled out of argv
-#
-
-if {[llength [info commands tcltest::processCmdLineArgsHook]] == 0} {
-    proc tcltest::processCmdLineArgsHook {flag} {}
-}
 
 # tcltest::ProcessFlags --
 #
@@ -1376,125 +1316,39 @@ proc tcltest::ProcessFlags {flagArray} {
 	exit 1
     }
 
-    catch {array set flag $flagArray}
-
-    # -help is not listed since it has already been processed
-    lappend defaultFlags -verbose -match -skip -constraints \
-	    -outfile -errfile -debug -tmpdir -file -notfile \
-	    -preservecore -limitconstraints -testdir \
-	    -load -loadfile -asidefromdir \
-	    -relateddir -singleproc
-    set defaultFlags \
-	    [concat $defaultFlags [processCmdLineArgsAddFlagsHook]]
-
-    # Set verbose to the arg of the -verbose flag, if given
-    if {[info exists flag(-verbose)]} {
-	verbose $flag(-verbose)
-    }
-
-    # Set match to the arg of the -match flag, if given.
-    if {[info exists flag(-match)]} {
-	match $flag(-match)
-    }
-
-    # Set skip to the arg of the -skip flag, if given
-    if {[info exists flag(-skip)]} {
-	skip $flag(-skip)
-    }
-
-    # Handle the -file and -notfile flags
-    if {[info exists flag(-file)]} {
-	matchFiles $flag(-file)
-    }
-    if {[info exists flag(-notfile)]} {
-	skipFiles $flag(-notfile)
-    }
-
-    # Handle -relateddir and -asidefromdir flags
-    if {[info exists flag(-relateddir)]} {
-	matchDirectories $flag(-relateddir)
-    }
-    if {[info exists flag(-asidefromdir)]} {
-	skipDirectories $flag(-asidefromdir)
-    }
-
-    # Use the -constraints flag, if given, to turn on constraints that
-    # are turned off by default: userInteractive knownBug nonPortable.
-
-    if {[info exists flag(-constraints)]} {
-	foreach elt $flag(-constraints) {
-	    testConstraint $elt 1
-	}
-	ConstraintsSpecifiedByCommandLineArgument $flag(-constraints)
-    }
+    if {[llength $flagArray] == 0} {
+	RemoveAutoConfigureTraces
+    } else {
+	set args $flagArray
+	while {[llength $args] && [catch {eval configure $args} msg]} {
+
+	    # Something went wrong parsing $args for tcltest options
+	    # Check whether the problem is "unknown option"
+	    if {[regexp {^unknown option (\S+):} $msg -> option]} {
+		# Could be this is an option the Hook knows about
+		if {[lsearch -exact \
+			[processCmdLineArgsAddFlagHook] $option] == -1} {
+		    # Nope.  Report the error, but keep going
+		    puts [errorChannel] "WARNING: $msg"
+		}
+	    } else {
+		# error is something other than "unknown option"
+		# notify user of the error; and exit
+		puts [errorChannel] $msg
+		exit 1
+	    }
 
-    # Use the -limitconstraints flag, if given, to tell the harness to
-    # limit tests run to those that were specified using the
-    # -constraints flag.  If the -constraints flag was not specified,
-    # print out an error and exit.
-    if {[info exists flag(-limitconstraints)]} {
-	if {![info exists flag(-constraints)]} {
-	    error "-limitconstraints flag can only\
-		    be used with -constraints"
+	    # To recover, find that unknown option and remove up to it.
+	    # then retry
+	    while {![string equal [lindex $args 0] $option]} {
+		set args [lrange $args 2 end]
+	    }
+	    set args [lrange $args 2 end]
 	}
-	limitConstraints $flag(-limitconstraints)
-    }
-
-    # Set the temporaryDirectory to the arg of -tmpdir, if given.
-
-    if {[info exists flag(-tmpdir)]} {
-	temporaryDirectory $flag(-tmpdir)
-    }
-
-    # Set the testsDirectory to the arg of -testdir, if given.
-
-    if {[info exists flag(-testdir)]} {
-	testsDirectory $flag(-testdir)
-    }
-
-    # If an alternate error or output files are specified, change the
-    # default channels.
-
-    if {[info exists flag(-outfile)]} {
-	outputFile $flag(-outfile)
-    }
-
-    if {[info exists flag(-errfile)]} {
-	errorFile $flag(-errfile)
-    }
-
-    # If a load script was specified, either directly or through
-    # a file, remember it for later usage.
-
-    if {[info exists flag(-load)] &&  \
-	    ([lsearch -exact $flagArray -load] > \
-		[lsearch -exact $flagArray -loadfile])} {
-	loadScript $flag(-load)
-    }
-
-    if {[info exists flag(-loadfile)] && \
-	    ([lsearch -exact $flagArray -loadfile] > \
-		[lsearch -exact $flagArray -load]) } {
-	loadFile $flag(-loadfile)
-    }
-
-    # If the user specifies debug testing, print out extra information
-    # during the run.
-    if {[info exists flag(-debug)]} {
-	debug $flag(-debug)
-    }
-
-    # Handle -preservecore
-    if {[info exists flag(-preservecore)]} {
-	preserveCore $flag(-preservecore)
-    }
-
-    # Handle -singleproc flag
-    if {[info exists flag(-singleproc)]} {
-	singleProcess $flag(-singleproc)
     }
 
     # Call the hook
+    array set flag $flagArray
     processCmdLineArgsHook [array get flag]
     return
 }
@@ -1898,6 +1752,7 @@ proc tcltest::test {name description args} {
     variable testLevel
     DebugPuts 3 "test $name $args"
 
+    FillFilesExisted
     incr testLevel
 
     # Pre-define everything to null except output and errorOutput.  We
@@ -2239,8 +2094,6 @@ proc tcltest::RunTest {
 } {
     variable testLevel
     variable numTests
-    variable skip
-    variable match
     variable testConstraints
     variable originalTclPlatform
     variable coreModTime
@@ -2250,7 +2103,7 @@ proc tcltest::RunTest {
     }
 
     # skip the test if it's name matches an element of skip
-    foreach pattern $skip {
+    foreach pattern [skip] {
 	if {[string match $pattern $name]} {
 	    if {$testLevel == 1} {
 		incr numTests(Skipped)
@@ -2261,9 +2114,9 @@ proc tcltest::RunTest {
     }
 
     # skip the test if it's name doesn't match any element of match
-    if {[llength $match] > 0} {
+    if {[llength [match]] > 0} {
 	set ok 0
-	foreach pattern $match {
+	foreach pattern [match] {
 	    if {[string match $pattern $name]} {
 		set ok 1
 		break
@@ -2417,6 +2270,7 @@ proc tcltest::cleanupTests {{calledFromAllFile 0}} {
     variable originalTclPlatform
     variable coreModTime
 
+    FillFilesExisted
     set testFileName [file tail [info script]]
 
     # Call the cleanup hook
@@ -2651,7 +2505,7 @@ proc tcltest::GetMatchingFiles { {searchDirectory ""} } {
 	    set matchFileList [concat $matchFileList \
 		    [glob -directory $directory -nocomplain -- $match]]
 	}
-	if {[string compare {} $tcltest::skipFiles]} {
+	if {[string compare {} [skipFiles]]} {
 	    set skipFileList {}
 	    foreach skip [skipFiles] {
 		set skipFileList [concat $skipFileList \
@@ -2749,12 +2603,12 @@ proc tcltest::GetMatchingDirectories {rootdir} {
 #	None.
 
 proc tcltest::runAllTests { {shell ""} } {
-    global argv
     variable testSingleFile
     variable numTestFiles
     variable numTests
     variable failFiles
 
+    FillFilesExisted
     if {[llength [info level 0]] == 1} {
 	set shell [interpreter]
     }
@@ -2807,12 +2661,21 @@ proc tcltest::runAllTests { {shell ""} } {
     foreach file [lsort [GetMatchingFiles]] {
 	set tail [file tail $file]
 	puts [outputChannel] $tail
+	flush [outputChannel]
 
 	if {[singleProcess]} {
 	    incr numTestFiles
 	    uplevel 1 [list ::source $file]
 	} else {
-	    set cmd [linsert $argv 0 | $shell $file]
+	    # Pass along our configuration to the child processes.
+	    # EXCEPT for the -outfile, because the parent process
+	    # needs to read and process output of children.
+	    set childargv [list]
+	    foreach opt [Configure] {
+		if {[string equal $opt -outfile]} {continue}
+		lappend childargv $opt [Configure $opt]
+	    }
+	    set cmd [linsert $childargv 0 | $shell $file]
 	    if {[catch {
 		incr numTestFiles
 		set pipeFd [open $cmd "r"]
@@ -3007,6 +2870,7 @@ proc tcltest::normalizeMsg {msg} {
 proc tcltest::makeFile {contents name {directory ""}} {
     global tcl_platform
     variable filesMade
+    FillFilesExisted
 
     if {[llength [info level 0]] == 3} {
 	set directory [temporaryDirectory]
@@ -3049,6 +2913,7 @@ proc tcltest::makeFile {contents name {directory ""}} {
 #	None.
 
 proc tcltest::removeFile {name {directory ""}} {
+    FillFilesExisted
     if {[llength [info level 0]] == 2} {
 	set directory [temporaryDirectory]
     }
@@ -3077,6 +2942,7 @@ proc tcltest::removeFile {name {directory ""}} {
 
 proc tcltest::makeDirectory {name {directory ""}} {
     variable filesMade
+    FillFilesExisted
     if {[llength [info level 0]] == 2} {
 	set directory [temporaryDirectory]
     }
@@ -3104,6 +2970,7 @@ proc tcltest::makeDirectory {name {directory ""}} {
 #	None
 
 proc tcltest::removeDirectory {name {directory ""}} {
+    FillFilesExisted
     if {[llength [info level 0]] == 2} {
 	set directory [temporaryDirectory]
     }
@@ -3128,6 +2995,7 @@ proc tcltest::removeDirectory {name {directory ""}} {
 
 proc tcltest::viewFile {name {directory ""}} {
     global tcl_platform
+    FillFilesExisted
     if {[llength [info level 0]] == 2} {
 	set directory [temporaryDirectory]
     }
@@ -3348,21 +3216,47 @@ namespace eval tcltest {
     } else {
 	proc initConstraintsHook {} {}
     }
-    ProcessCmdLineArgs
-
-    # Save the names of files that already exist in
-    # the output directory.
-    variable file {}
-    foreach file [glob -nocomplain -directory [temporaryDirectory] *] {
-	lappend filesExisted [file tail $file]
-    }
 
     # Define the standard match commands
     customMatch exact	[list string equal]
     customMatch glob	[list string match]
     customMatch regexp	[list regexp --]
-    unset file
-}
 
-package provide tcltest 2.1
+    proc LoadTimeConfigurationRequired {} {
+	set required false
+	if {[info exists ::env(TCLTEST_OPTIONS)]} {
+	    # Respect the environment variable at package load time,
+	    # so that it effectively establishes new defaults.
+	    set required true
+	}
+	if {[info exists ::argv] && [lsearch -exact $::argv -help]} {
+	    # The command line asks for -help, so give it (and exit)
+	    # right now.  ([configure] does not process -help)
+	    set required true
+	}
+	foreach hook { PrintUsageInfoHook processCmdLineArgsHook
+			processCmdLineArgsAddFlagHook } {
+	    if {[string equal [namespace current] [namespace qualifiers \
+		    [namespace which $hook]]]} {
+		set required true
+	    } else {
+		proc $hook args {}
+	    }
+	}
+	return $required
+    }
 
+    # Only initialize configurable options from the command line arguments
+    # at package load time if necessary for backward compatibility.  This
+    # lets the tcltest user call [configure] for themselves if they wish.
+    # Traves are established for auto-configuration from the command line
+    # if any configurable options are accessed before the user calls
+    # [configure].
+    if {[LoadTimeConfigurationRequired]} {
+	ProcessCmdLineArgs
+    } else {
+	EstablishAutoConfigureTraces
+    }
+
+    package provide [namespace tail [namespace current]] $Version
+}