NAME

       Tcltest - Test harness support code and utilities


SYNOPSIS

       package require tcltest ?1.0?

       ::tcltest::test  name desc ?constraint? script expectedAn­
       swer

       ::tcltest::cleanupTests ?runningMultipleTests?

       ::tcltest::getMatchingTestFiles

       ::tcltest::loadTestedCommands

       ::tcltest::makeFile contents name

       ::tcltest::removeFile name

       ::tcltest::makeDirectory name

       ::tcltest::removeDirectory name

       ::tcltest::viewFile name

       ::tcltest::normalizeMsg msg

       ::tcltest::bytestring string

       ::tcltest::saveState

       ::tcltest::restoreState

       ::tcltest::threadReap
_________________________________________________________________


DESCRIPTION

       The tcltest package provides the user with  utility  tools
       for  writing  and running tests in the Tcl test suite.  It
       can also be used to create a customized test  harness  for
       an extension.

       The  Tcl test suite consists of multiple .test files, each
       of which contains multiple test  cases.   Each  test  case
       consists  of  a  call to the test command, which specifies
       the name of  test, a short  description,  any  constraints
       that  apply  to  the  test case, the script to be run, and
       expected results.  See the sections  "Tests,"  "Test  Con­
       straints,"  and  "Test Files and How to Run Them" for more
       details.

       It is also possible to add to this test harness to  create

       defails, see the section "How to Customize the  Test  Har­
       ness".

       This approach to testing was designed and initially imple­
       mented by Mary Ann May-Pumphrey of Sun Microsystems in the
       early  1990's.   Many  thanks to her for donating her work
       back to the public Tcl release.


COMMANDS

       ::tcltest::test name desc ?constraints? script expectedAn­
              swer
              The ::tcltest::test command runsscript and compares
              its result to expectedAnswer. It  prints  an  error
              message    if   the   two   do   not   match.    If
              ::tcltest::verbose contains "p"  or  "s",  it  also
              prints  out  a  message  if  the test passed or was
              skipped.  The test will be skipped  if  it  doesn't
              match  the ::tcltest::match variable, if it matches
              an element in ::tcltest::skip, or  if  one  of  the
              elements  of  constraint  turns out not to be true.
              The ::tcltest::test command has no  defined  return
              values.   See  the "Writing a new test" section for
              more details on this command.

       ::tcltest::cleanupTests ?runningMultipleTests?
              This command should be called at the end of a  test
              file.  It prints statistics about the tests run and
              removes    files    that    were     created     by
              ::tcltest::makeDirectory  and  ::tcltest::makeFile.
              Names of files and directories created  outside  of
              ::tcltest::makeFile   and  ::tcltest::makeDirectory
              and never deleted are  printed  to  ::tcltest::out­
              putChannel.   This command also restores the origi­
              nal shell environment, as described  by  the  ::env
              array.   calledFromAll  should  be  specified  when
              ::tcltest::cleanupTests is called from an "all.tcl"
              file.   Tcl  files  files are generally used to run
              multiple tests.  For more details  on  how  to  run
              multiple  tests,  please  see  the section "Running
              test files".   This  proc  has  no  defined  return
              value.

       ::tcltest::getMatchingTestFiles
              This  command is used when you want to run multiple
              test files.  It returns  the  list  of  tests  that
              should  be  sourced  in an 'all.tcl' file.  See the
              section "Running test files" for more  information.

       ::tcltest::loadTestedCommands
              This  command  uses  the  script  specified via the
              -load or -loadfile to load the commands checked  by
              the test suite.  Allowed to be empty, as the tested
              commands  could  have  been   compiled   into   the


       ::tcltest::makeFile contents name
              Create a file that will be automatically be removed
              by ::tcltest::cleanupTests at the  end  of  a  test
              file.  This proc has no defined return value.

       ::tcltest::removeFile name
              Force  the  file  referenced by name to be removed.
              This   file   name   should    be    relative    to
              ::tcltest::temporaryDirectory.   This  proc  has no
              defined return values.

       ::tcltest::makeDirectory name
              Create a directory named name that  will  automati­
              cally  be removed by ::tcltest::cleanupTests at the
              end of a test  file.   This  proc  has  no  defined
              return value.

       ::tcltest::removeDirectory name
              Force  the  directory  referenced  by  name  to  be
              removed. This proc has no defined return value.

       ::tcltest::viewFile file
              Returns the contents of file.

       ::tcltest::normalizeMsg msg
              Remove extra newlines from msg.

       ::tcltest::bytestring string
              Construct a string that consists of  the  requested
              sequence  of bytes, as opposed to a string of prop­
              erly formed UTF-8 characters using the  value  sup­
              plied  in string.  This allows the tester to create
              denormalized or improperly formed strings  to  pass
              to C procedures that are supposed to accept strings
              with embedded NULL types and confirm that a  string
              result has a certain pattern of bytes.

       ::tcltest::saveState
              ::tcltest::restoreState Save and restore the proce­
              dure and global variable names.  A test file  might
              contain    calls    to   ::tcltest::saveState   and
              ::tcltest:restoreState if  it  creates  or  deletes
              global variables or procs.

       ::tcltest::threadReap
              ::tcltest::threadReap  only  works if testthread is
              defined, generally by compiling tcltest.  If  test­
              thread  is defined, ::tcltest::threadReap kills all
              threads except for the main thread.  It gets the ID
              of the main thread by calling testthread names dur­
              ing  initialization.   This  value  is  stored   in
              ::tcltest::mainThread.        ::tcltest::threadReap

              tion.


TESTS

       The  test procedure runs a test script and prints an error
       message if the script's result does not match the expected
       result.  The following is the spec for the test command:

              test <name> <description> ?<constraint>? <script> <expectedAnswer>

       The <name> argument should follow the pattern:

              <target>-<majorNum>.<minorNum>

       For white-box (regression) tests, the target should be the
       name of the C function or Tcl procedure being tested.  For
       black-box tests, the target should be the name of the fea­
       ture being tested.  Related tests  should  share  a  major
       number.

       The  <description> argument is a short textual description
       of the test, to help humans understand what it tests.  The
       name  of  a  Tcl  or  C  function  being  tested should be
       included for regression tests.  If the test case exists to
       reproduce a bug, include the bug ID in the description.

       The  optional <constraints> argument can be list of one or
       more keywords or  an  expression.   If  the  <constraints>
       argument consists of keywords, each of these keywords must
       be the name of an element in the array ::tcltest::testCon­
       straints.   If  any of these elements is false or does not
       exist, the test is skipped.  If the <constraints> argument
       consists  of  an expression, that expression is evaluated.
       If the expression evaluates to true, then the test is run.

       Add  appropriate constraints (e.g., unixOnly) to any tests
       that should not always be run.  For example, a  test  that
       should only be run on Unix should look like the following:

              test getAttribute-1.1 {testing file permissions} {unixOnly} {
                  lindex [file attributes foo.tcl] 5
              } {00644}

       An example of a test that contains an expression:

              test unixNotfy-1.1 {Tcl_DeleteFileHandler} {unixOnly && !testthread} {
                  catch {vwait x}
                  set f [open foo w]
                  fileevent $f writable {set x 1}
                  vwait x
                  close $f

              } {1 {can't wait for variable "x":  would wait forever}}

       See the "Test Constraints" section for a list of  built-in
       constraints  and  information  on how to add your own con­
       straints.

       The <script> argument contains the script to run to  carry
       out the test.  It must return a result that can be checked
       for correctness.  If your script requires that a  file  be
       created  on  the  fly,  please use the ::tcltest::makeFile
       procedure.  If your test requires that a small  file  (<50
       lines) be checked in, please consider creating the file on
       the fly using the  ::tcltest::makeFile  procedure.   Files
       created by the ::tcltest::makeFile procedure will automat­
       ically be removed by the ::tcltest::cleanupTests  call  at
       the end of each test file.

       The <expectedAnswer> argument will be compared against the
       result of  evaluating  the  <script>  argument.   If  they
       match, the test passes, otherwise the test fails.


TCLTEST NAMEPSACE VARIABLES

       The  following  variables  are also defined in the tcltest
       namespace and can be used by tests:

       ::tcltest::outputChannel
              output file ID - defaults  to  stdout  and  can  be
              specified  using -outfile on the command line.  Any
              test that prints test related  output  should  send
              that output to ::tcltest::outputChannel rather than
              letting that output default to stdout.

       ::tcltest::errorChannel
              error file ID - defaults to stderr and can be spec­
              ified using -errfile on the command line.  Any test
              that prints error messages should send that  output
              to  ::tcltest::errorChannel  rather  than  printing
              directly to stderr.

       ::tcltest::mainThread
              main thread ID - defaults to 1.  This is  the  only
              thread  that is not killed by ::tcltest::threadReap
              and is set according to the return value  of  test­
              thread names at initialization.

       ::tcltest::originalEnv
              copy  of the global "env" array at the beginning of
              the test run.  This array is used  to  restore  the
              "env"    array   to   its   original   state   when
              ::tcltest::cleanupTests is called.

              the directory in which the test suite was launched.

       ::tcltest::temporaryDirectory
              the output directory - defaults to ::tcltest::work­
              ingDirectory and can be specified using -tmpdir  on
              the command line.

       ::tcltest::testsDirectory
              where    the    tests    reside   -   defaults   to
              ::tcltest::workingDirectory if  the  script  cannot
              determine  where the tests directory is located. It
              is possible to change  the  default  by  specifying
              -testdir  on  the commandline. This variable should
              be explicitly set if tests are being  run  from  an
              all.tcl file.

       ::tcltest::tcltest
              the  name of the executable used to invoke the test
              suite.

       ::tcltest::loadScript
              The script executed  loadTestedCommands.  Specified
              either by -load or -loadfile.


TEST CONSTRAINTS

       Constraints are used to determine whether a test should be
       skipped.  Each constraint is stored as  an  index  in  the
       array   ::tcltest::testConstraints.    For   example,  the
       unixOnly constraint is defined as the following:

              set ::tcltest::testConstraints(unixOnly) \
                  [string equal $tcl_platform(platform) "unix"]

       If a test is constrained by "unixOnly", then it will  only
       be    run    if    the    value   of   ::tcltest::testCon­
       straints(unixOnly)  is  true.   Several  constraints   are
       defined in the tcltest package.  To add file- or test-spe­
       cific constraints, you can set the desired  index  of  the
       ::tcltest::testsConstraints array in your own test file.

       The  following  is  a  list  of constraints defined in the
       tcltest package:

       unix   test can only be run on any UNIX platform

       pc     test can only be run on any Windows platform

       nt     test can only be run on any Windows NT platform

       95     test can only be run on any Windows 95 platform

       98     test can only be run on any Windows 98 platform


       unixOrPc
              test can only be run on a UNIX or PC platform

       macOrPc
              test can only be run on a Mac or PC platform

       macOrUnix
              test can only be run on a Mac or UNIX platform

       tempNotPc
              test can not be run on Windows.  This flag is  used
              to temporarily disable a test.

       tempNotMac
              test can not be run on a Mac.  This flag is used to
              temporarily disable a test.

       unixCrash
              test crashes if it's run on  UNIX.   This  flag  is
              used to temporarily disable a test.

       pcCrash
              test  crashes if it's run on Windows.  This flag is
              used to temporarily disable a test.

       macCrash
              test crashes if it's run on a Mac.   This  flag  is
              used to temporarily disable a test.

       emptyTest
              test  is  empty,  and  so not worth running, but it
              remains as a place-holder for a test to be  written
              in the future.  This constraint always causes tests
              to be skipped.

       knownBug
              test is known to fail and the bug is not yet fixed.
              This  constraint  always causes tests to be skipped
              unless  the  user  specifies  otherwise.   See  the
              "Introduction" section for more details.

       nonPortable
              test  can only be run in the master Tcl/Tk develop­
              ment environment.  Some tests are  inherently  non-
              portable  because  they  depend on things like word
              length, file system configuration, window  manager,
              etc.   These  tests  are  only  run in the main Tcl
              development directory where  the  configuration  is
              well known.  This constraint always causes tests to
              be skipped unless the user specifies otherwise.

              test requires interaction from the user.  This con­
              straint  always  causes  tests to be skipped unless
              the user specifies otherwise.

       interactive
              test can only be run in if the  interpreter  is  in
              interactive  mode,  that is the global tcl_interac­
              tive variable is set to 1.

       nonBlockFiles
              test can only be run if platform  supports  setting
              files into nonblocking mode

       asyncPipeClose
              test  can  only  be  run if platform supports async
              flush and async close on a pipe

       unixExecs
              test can only be run if this machine  has  commands
              such as 'cat', 'echo', etc. available.

       hasIsoLocale
              test can only be run if can switch to an ISO locale

       root   test can only run if Unix user is root

       notRoot
              test can only run if Unix user is not root

       eformat
              test can only run if app has a working  version  of
              sprintf with respect to the "e" format of floating-
              point numbers.

       stdio  test can only be run if  the  current  app  can  be
              spawned via a pipe


RUNNING TEST FILES

       Use  the  following  command  to run a test file that uses
       package tcltest:

              <shell> <testFile> ?<option> ?<value>?? ...

       Command line options include (tcltest namespace  variables
       that correspond to each flag are listed at the end of each
       flag description in parenthesis):

              -help  display usage information.

              -verbose <level>
                     set the level of verbosity to a substring of
                     "bps".  See the "Test output" section for an
                     explanation      of       this       option.


              -match <matchList>
                     only run tests that match one or more of the
                     glob      patterns      in      <matchList>.
                     (::tcltest::match)

              -skip <skipList>
                     do  not  run tests that match one or more of
                     the    glob    patterns    in    <skipList>.
                     (::tcltest::skip)

              -file <globPatternList>
                     only source test files that match any of the
                     items  in  <globPatternList>   relative   to
                     ::tcltest::testsDirectory.  This option only
                     makes sense if you are running  tests  using
                     "all.tcl"  as the <testFile> instead of run­
                     ning    single    test    files    directly.
                     (::tcltest::matchFiles)

              -notfile <globPatternList>
                     source files except for those that match any
                     of the items in  <globPatternList>  relative
                     to  ::tcltest::testsDirectory.   This option
                     only makes sense if you  are  running  tests
                     using "all.tcl" as the <testFile> instead of
                     running   single   test   files    directly.
                     (::tcltest::skipFiles)

              -constraints <list>
                     tests  with  any  constraints in <list> will
                     not  be  skipped.   Note  that  elements  of
                     <list>  must exactly match the existing con­
                     straints.  This is useful  if  you  want  to
                     make  sure that tests with a particular con­
                     straint are run (for example, if the  tester
                     wants  to  run  all  tests with the knownBug
                     constraint).            (::tcltest::testCon­
                     straints(constraintName))

              -limitconstraints <bool>
                     If  the argument to this flag is 1, the test
                     harness limits test runs to those tests that
                     match  the  constraints  listed by the -con­
                     straints flag. Use of this flag requires use
                     of the -constraints flag.  The default value
                     for this flag is 0 (false).  This is  useful
                     if  you  want  to  run only those tests that
                     match the constraints listed using the -con­
                     straints  option.  A tester might want to do
                     this if he were interested in  running  only
                     those  tests  that  are  constrained  to  be
                     unixOnly     and     no     other     tests.


              -load <script>
                     will  use  the  specified script to load the
                     commands under test  (::tcltest::loadTested­
                     Commands).  The default is the empty script.
                     See -loadfile below  too.  (::tcltest::load­
                     Script)

              -loadfile <scriptfile>
                     will  use  the contents of the named file to
                     load     the     commands     under     test
                     (::tcltest::loadTestedCommands).  See  -load
                     above too. The default is the empty  script.
                     (::tcltest::loadScript)

              -tmpdir <directoryName>
                     put   any   temporary  files  (created  with
                     ::tcltest::makeFile  and  ::tcltest::makeDi­
                     rectory)  into  the  named  directory.   The
                     default location is ::tcltest::workingDirec­
                     tory.  (::tcltest::temporaryDirectory)

              -testdir <directoryName>
                     search  the  test  suite  to  execute in the
                     named directory.  The  default  location  is
                     ::tcltest::workingDirectory.
                     (::tcltest::testsDirectory)

              -preservecore <level>
                     check for core files.  This flag is used  to
                     determine  how  much checking should be done
                     for core files.  The default value for level
                     is 0.  Levels are defined as:

                      0      No  checking - do not check for core
                             files at the end of each  test  com­
                             mand, but do check for them whenever
                             ::tcltest::cleanupTests  is   called
                             from an all.tcl file.

                      1      Check  for  core files at the end of
                             each  test  command   and   whenever
                             ::tcltest::cleanupTests   is  called
                             from all.tcl.

                      2      Check for core files at the  end  of
                             all   test   commands  and  whenever
                             ::tcltest::cleanupTests  is   called
                             from  all.tcl.   Save any core files
                             produced in  ::tcltest::temporaryDi­
                             rectory.

              (::tcltest::preserveCore)

                     print  debug information to stdout.  This is
                     used to debug code in the test harness.  The
                     default   debug  level  is  0.   Levels  are
                     defined as:

                      0      Do not display  any  debug  informa­
                             tion.

                      1      Display     information    regarding
                             whether a test is skipped because it
                             doesn't  match any of the tests that
                             were  specified  using   -match   or
                             ::tcltest::match  (userSpecifiedNon­
                             Match) or matches any of  the  tests
                             specified      by      -skip      or
                             ::tcltest::skip (userSpecifiedSkip).

                      2      Display the flag array parsed by the
                             command line processor, the contents
                             of  the  ::env  array, and all user-
                             defined variables that exist in  the
                             current  namespace as they are used.

                      3      Display information  regarding  what
                             individual procs in the test harness
                             are doing.

              (::tcltest::debug)

              -outfile <filename>
                     print output generated by the tcltest  pack­
                     age  to  the  named  file.  This defaults to
                     stdout.  Note that debug output always  goes
                     to  stdout,  regardless  of this flag's set­
                     ting.  (::tcltest::outputChannel)

              -errfile <filename>
                     print errors generated by the tcltest  pack­
                     age  to  the  named  file.  This defaults to
                     stderr.  (::tcltest::errorChannel)

       A second way to run tets is to start up a shell, load  the
       tcltest  package, and then source an appropriate test file
       or use the test command.  To use the options  in  interac­
       tive mode, set their corresponding tcltest namespace vari­
       ables after loading the package.

       See "Test Constraints" for all built-in  constraint  names
       that  can be used in the ::tcltest::testConstraints array.
       See "Tcltest namespace variables"  for  details  on  other
       variables defined in the tcltest namespace.

       A  final  way  to run tests would be to specify which test

       This  is  the  approach  used by the Tcl test suite.  This
       file loads the tcltest package, sets the location  of  the
       test   directory  (::tcltest::testsDirectory),  determines
       which test files to run,  sources  each  of  these  files,
       calls ::tcltest::cleanupTests and then exits.

       A more elaborate all.tcl file might do some pre- and post-
       processing before sourcing each .test file,  use  separate
       interpreters  for  each  file, or handle complex directory
       structures.  For an example of an all.tcl file, please see
       the "Examples" section of this document.


TEST OUTPUT

       After  all  specified  test  files  are run, the number of
       tests  passed,  skipped,  and   failed   is   printed   to
       ::tcltest::outputChannel.   Aside  from  this  statistical
       information, output can be controlled on a per-test  basis
       by the ::tcltest::verbose variable.

       ::tcltest::verbose can be set to any substring or permuta­
       tion of "bps". In the string "bps", the 'b' stands  for  a
       test's  "body", the 'p' stands for "passed" tests, and the
       's' stands for  "skipped"  tests.  The  default  value  of
       ::tcltest::verbose  is  "b".   If 'b' is present, then the
       entire body of the test is printed for each  failed  test,
       otherwise only the test's name, desired output, and actual
       output, are printed for each failed test.  If 'p' is  pre­
       sent,  then a line is printed for each passed test, other­
       wise no line is printed for passed tests.  If 's' is  pre­
       sent,  then  a  line (containing the consraints that cause
       the test to be skipped) is printed for each skipped  test,
       otherwise no line is printed for skipped tests.

       You can set ::tcltest::verbose either interactively (after
       the tcltest package has been loaded) or by using the  com­
       mand line argument -verbose, for example:

              tclsh socket.test -verbose bps


CONTENTS OF A TEST FILE

       Test files should begin by loading the tcltest package:

              if {[lsearch [namespace children] ::tcltest] == -1} {
                  package require tcltest
                  namespace import ::tcltest::*
              }

       Test  files should end by cleaning up after themselves and
       calling           ::tcltest::cleanupTests.             The
       ::tcltest::cleanupTests  procedure prints statistics about
       the number of tests that passed, skipped, and failed,  and
       removes   all   files   that   were   created   using  the

       dures.

              # Remove files created by these tests
              # Change to original working directory
              # Unset global arrays
              ::tcltest::cleanupTests
              return

       When naming test files, file names should end with a .test
       extension.  The names of test files that  contain  regres­
       sion  (or glass-box) tests should correspond to the Tcl or
       C code file that they are testing.  For example, the  test
       file  for  the  C file "tclCmdAH.c" is "cmdAH.test".  Test
       files that contain black-box tests should match  the  pat­
       tern "*_bb.test".


SELECTING TESTS FOR EXECUTION WITHIN A FILE

       Normally,  all  the  tests  in a file are run whenever the
       file is sourced.  An individual test will  be  skipped  if
       one of the following conditions is met:

       [1]    the  name  of  the tests does not match (using glob
              style  matching)  one  or  more  elements  in   the
              ::tcltest::match variable

       [2]    the  name  of  the  tests matches (using glob style
              matching)   one   or   more   elements    in    the
              ::tcltest::skip variable

       [3]    the  constraints  argument  to  the ::tcltest::test
              call, if given, contains one  or  more  false  ele­
              ments.

       You can set ::tcltest::match and/or ::tcltest::skip either
       interactively  (after  the  tcltest   package   has   been
       sourced),  or  by  using the command line arguments -match
       and -skip, for example:

              tclsh info.test -match '*-5.* *-7.*' -skip '*-7.1*'

       Be sure to use the proper quoting convention so that  your
       shell  does not perform the glob substitution on the match
       or skip patterns you specify.

       Predefined constraints (e.g. knownBug and nonPortable) can
       be  overridden  either  interactively  (after  the tcltest
       package  has  been  sourced)   by   setting   the   proper
       ::tcltest::testConstraints(constraint)   variable   or  by
       using the -constraints command line option with  the  name
       of  the constraint in the argument.  The following example
       shows how to run tests that are constrained by the  known­
       Bug and nonPortable restrictions:


       See  the "Constraints" package for information about using
       built-in constraints and adding new ones.


HOW TO CUSTOMIZE THE TEST HARNESS

       To create your own custom test harness, create a .tcl file
       that  contains  your namespace.  Within this file, require
       package tcltest.  Commands that can be redefined  to  cus­
       tomize the test harness include:

       ::tcltest::PrintUsageInfoHook
              print additional usage information specific to your
              situation.

       ::tcltest::processCmdLineArgsFlagHook
              tell the test harness about additional  flags  that
              you want it to understand.

       ::tcltest::processCmdLineArgsHook flags
              process the additional flags that you told the har­
              ness   about   in    ::tcltest::processCmdLineArgs­
              FlagHook.

       ::tcltest::initConstraintsHook
              used  to  add  additional  built-in  constraints to
              those already defined by tcltest.

       ::tcltest::cleanupTestsHook
              do additional cleanup

       To add new flags to your customized test harness, redefine
       ::tcltest::processCmdLineArgsAddFlagHook  to  define addi­
       tional flags to be  parsed  and  ::tcltest::processCmdLin­
       eArgsHook to actually process them.  For example:

              proc ::tcltest::processCmdLineArgsAddFlagHook {} {
                  return [list -flag1 -flag2]
              }

              proc ::tcltest::processCmdLineArgsHook {flagArray} {
                  array set flag $flagArray

                  if {[info exists flag(-flag1)]} {
                      # Handle flag1
                  }

                  if {[info exists flag(-flag2)]} {
                      # Handle flag2
                  }

                  return
              }

       flags.  This information would be displayed  whenever  the
       user specifies -help.  To define additional usage informa­
       tion, define your own ::tcltest::PrintUsageInfoHook  proc.
       Within  this  proc,  you should print out additional usage
       information for any flags that you've implemented.

       To add new  built-in  constraints  to  the  test  harness,
       define your own version of ::tcltest::initConstraintsHook.
       Within your proc, you can add to  the  ::tcltest::testCon­
       straints array.  For example:

              proc ::tcltest::initConstraintsHook {} {
                  set ::tcltest::testConstraints(win95Or98) \
                          [expr {$::tcltest::testConstraints(95) || \
                          $::tcltest::testConstraints(98)}]
              }

       Finally,  if  you  want  to add additional cleanup code to
       your    harness    you     can     define     your     own
       ::tcltest::cleanupTestsHook.  For example:

              proc ::tcltest::cleanupTestsHook {} {
                  # Add your cleanup code here
              }


EXAMPLES

       [1]    A simple test file (foo.test)

              if {[lsearch [namespace children] ::tcltest] == -1} {
                  package require tcltest
                  namespace import ::tcltest::*
              }

              test foo-1.1 {save 1 in variable name foo} {} {
                  set foo 1
              } {1}

              ::tcltest::cleanupTests
              return

       [2]    A simple all.tcl

              if {[lsearch [namespace children] ::tcltest] == -1} {
                  package require tcltest
                  namespace import ::tcltest::*
              }

              set ::tcltest::testSingleFile false
              set ::tcltest::testsDirectory [file dir [info script]]

                  if {[catch {source $file} msg]} {
                      puts stdout $msg
                  }
              }

              ::tclttest::cleanupTests 1
              return

       [3]    Running a single test

              tclsh foo.test

       [4]    Running multiple tests

              tclsh all.tcl -file 'foo*.test' -notfile 'foo2.test'


KEYWORDS

       test, test harness, test suite


Man(1) output converted with man2html