dwww Home | Manual pages | Find package

TRIAL(1)                                                              TRIAL(1)

NAME
       trial - run unit tests

SYNOPSIS
       trial  [  options ] [ file | package | module | TestCase | testmethod ]
       ...

       trial --help | -h

DESCRIPTION
       trial loads and executes a suite of unit tests, obtained from  modules,
       packages and files listed on the command line.

       trial will take either filenames or fully qualified Python names as ar-
       guments.  Thus  `trial  myproject/foo.py',  `trial  myproject.foo'  and
       `trial  myproject.foo.SomeTestCase.test_method'  are  all valid ways to
       invoke trial. Multiple such arguments are also accepted, and their  or-
       der will determine the order in which the corresponding tests are run.

       After  running the given test suite, the default test reporter prints a
       summary of the test run. This consists of the  word  "PASSED"  (if  all
       tests  ran  as expected) or "FAILED" (if any test behaved unexpectedly)
       followed by a count of the different kinds of test results encountered.
       The possible kinds of test results includes:

       successes
              Tests that passed all their assertions and completed without er-
              ror.  These are marked "PASSED" in the normal test output.

       failures
              Tests that failed an assertion, called self.fail() or explicitly
              raised  self.failureException  for some reason. These are marked
              "FAILED" in the normal test output.

       errors Tests that raised an unexpected exception (including  Assertion-
              Error),  tests that caused the tearDown() method to raise an ex-
              ception, tests that run for longer than  the  timeout  interval,
              tests  that  caused  something  to call twisted.python.log.err()
              without  subsequently  calling  self.flushLoggedErrors(),  tests
              that  leave  the  reactor  in  an  unclean state, etc. These are
              marked "ERROR" in the normal test output.

              Note that because errors can be caused  after  the  actual  test
              method  returns, it is possible for a single test to be reported
              as both an error and a failure, and hence the  total  number  of
              test  results can be greater than the total number of tests exe-
              cuted.

       skips  Tests that were skipped, usually because  of  missing  dependen-
              cies. These are marked "SKIPPED" in the normal test output.

       expectedFailures
              Tests  that  failed,  but were expected to fail, usually because
              the test is for a feature  that  hasn't  been  implemented  yet.
              These are marked "TODO" in the normal test output.

       unexpectedSuccesses
              Tests  that  should have been listed under expectedFailures, ex-
              cept that for some reason the test succeeded. These  are  marked
              "SUCCESS!?!" in the normal test output.

OPTIONS
       -j, --jobs number
              Set  the number of process workers to run. It conflicts with the
              debug, exitfirst and profile options.

       -b, --debug
              Run the tests in a debugger. If that debugger is 'pdb' (which is
              the  default if unspecified), a `.pdbrc' will be loaded from the
              current directory if it exists. Also does post-mortem  debugging
              on exceptions.

       -B, --debug-stacktraces
              Report Deferred creation and callback stack traces.

       --coverage
              Generate  coverage information in the `coverage' subdirectory of
              the trial temp directory (`_trial_temp' by  default).  For  each
              Python  module  touched  by  the execution of the given tests, a
              file will be created in the coverage  directory  named  for  the
              module's fully-qualified name with the suffix `.cover'.  For ex-
              ample, because the trial test runner is written in  Python,  the
              coverage  directory  will  almost  always  contain  a file named
              `twisted.trial.runner.cover'.

              Each `.cover' file contains a copy of the Python source  of  the
              module  in question, with a prefix at the beginning of each line
              containing coverage information.  For lines that  are  not  exe-
              cutable (blank lines, comments, etc.)  the prefix is blank.  For
              executable lines that were run in the course of the test  suite,
              the  prefix is a number indicating the number of times that line
              was executed.  The string  `>>>>>>'  prefixes  executable  lines
              that were not executed in the course of the test suite.

              Note  that this functionality uses Python's sys.settrace() func-
              tion, so tests that call sys.settrace() themselves are likely to
              break trial's coverage functionality.

       --debugger
              Specifies the debugger to use when the --debug option is passed.
              The argument should be the fully qualified  name  of  an  object
              that  implements  the  same  interface as the standard library's
              `pdb'.

       --disablegc
              Disable the garbage collector for the duration of the test  run.
              As  each  test is run, trial saves the TestResult objects, which
              means that Python's garbage collector has more  non-garbage  ob-
              jects  to  wade  through,  making  each  garbage-collection  run
              slightly slower. Disabling garbage collection entirely will make
              some  test  suites complete faster (contrast --force-gc, below),
              at the cost of increasing (possibly greatly) memory consumption.
              This  option also makes tests slightly more deterministic, which
              might help debugging in extreme circumstances.

       -e, --rterrors
              Print tracebacks to standard output as soon as they occur.

       --force-gc
              Run gc.collect() before and after each test case.  This  can  be
              used  to  isolate  errors that occur when objects get collected.
              This option would be the default,  except  it  makes  tests  run
              about ten times slower.

       -h, --help
              Print a usage message to standard output, then exit.

       --help-order
              Print  a  list of possible orders that TestCase test methods can
              be run in, then exit. The orders can be used  with  the  --order
              option described below.

       --help-reporters
              Print  a  list of valid reporters to standard output, then exit.
              Reporters can be selected with the --reporter  option  described
              below.

       --help-reactors
              Print a list of possible reactors to standard output, then exit.
              Not all listed reactors are available on every  platform.  Reac-
              tors can be selected with the --reactor option described below.

       -l, --logfile logfile
              Direct  the  log  to  a  different  file.  The  default  file is
              `test.log'.  logfile is relative to _trial_temp.

       -n, --dry-run
              Go through all the tests and make them pass without running.

       -N, --no-recurse
              By default, trial recurses through packages to find every module
              inside  every subpackage.  Unless, that is, you specify this op-
              tion.

       --nopm Don't automatically jump into debugger for post-mortem  analysis
              of exceptions.  Only usable in conjunction with --debug.

       --order order
              Specify what order to run the individual test methods within the
              given TestCases. By default, they are  run  alphabetically.  See
              --help-order for a list of other valid values.

       --profile
              Run tests under the Python profiler.

       -r, --reactor reactor
              Choose which reactor to use.  See --help-reactors for a list.

       --recursionlimit limit
              Set Python's recursion limit. See sys.setrecursionlimit().

       --reporter reporter
              Select  the reporter to use for trial's output.  Use the --help-
              reporters option to see a list of valid reporters.

       -x, --exitfirst
              Stop the test run after the first test which does  not  succeed.
              This  includes  failures, errors, or unexpected successes. Won't
              work with the --jobs option currently.

       --spew Print an insanely verbose log of everything that happens. Useful
              when debugging freezes or locks in complex code.

       --tbformat format
              Format  to  display  tracebacks with. Acceptable values are `de-
              fault', `brief' and `verbose'. `brief' produces tracebacks  that
              play nicely with Emacs' GUD.

       --temp-directory directory
              WARNING: Do not use this option unless you know what you are do-
              ing.  By default, trial creates a directory  called  _trial_temp
              under  the current working directory.  When trial runs, it first
              deletes this directory, then creates it, then changes  into  the
              directory  to run the tests. The log file and any coverage files
              are stored here. Use this option if you wish to have  trial  run
              in  a  directory  other  than _trial_temp. Be warned, trial will
              delete the directory before re-creating it.

       --testmodule filename
              Ask trial to look into filename and run any tests specified  us-
              ing the Emacs-style buffer variable `test-case-name'.

       --unclean-warnings
              As  of Twisted 8.0, trial will report an error if the reactor is
              left unclean at the end of the test. This option is provided  to
              assist  in  migrating from Twisted 2.5 to Twisted 8.0 and later.
              Enabling this option will turn the errors into warnings.

       -u, --until-failure
              Keep looping the tests until one of them raises an  error  or  a
              failure.   This is particularly useful for reproducing intermit-
              tent failures.

       --version
              Prints the Twisted version number and exit.

       --without-module modulenames
              Simulate the lack of the specified comma-separated list of  mod-
              ules. This makes it look like the modules are not present in the
              system, causing tests to check the behavior for that  configura-
              tion.

       -z, --random seed
              Run  the  tests  in random order using the specified seed. Don't
              pass this option if you also are passing --order.

SEE ALSO
       The  latest  version  of  the  trial  documentation  can  be  found  at
       http://twistedmatrix.com/documents/current/core/howto/testing.html

AUTHOR
       Written by Jonathan M. Lange

REPORTING BUGS
       To report a bug, visit http://twistedmatrix.com/trac/newticket

COPYRIGHT
       Copyright © 2003-2013 Twisted Matrix Laboratories
       This is free software; see the source for copying conditions.  There is
       NO warranty; not even for MERCHANTABILITY or FITNESS FOR  A  PARTICULAR
       PURPOSE.

                                   Jun 2013                           TRIAL(1)

Generated by dwww version 1.14 on Fri Jan 24 06:12:48 CET 2025.