Provided by: python3-nose_1.3.7-4_all bug


       nosetests - Nicer testing for Python


          nosetests [options] [names]

       nose collects tests automatically from python source files, directories and packages found
       in its working directory (which defaults to the current  working  directory).  Any  python
       source  file,  directory  or  package  that  matches  the testMatch regular expression (by
       default: (?:^|[b_.-])[Tt]est) will be collected as a test (or  source  for  collection  of
       tests).  In  addition,  all other packages found in the working directory will be examined
       for python source files or directories that match testMatch.  Package  discovery  descends
       all    the   way   down   the   tree,   so   package.tests   and   package.sub.tests   and
       package.sub.sub2.tests will all be collected.

       Within a test directory or package, any python source  file  matching  testMatch  will  be
       examined  for  test  cases.  Within a test module, functions and classes whose names match
       testMatch and TestCase subclasses with any name will be  loaded  and  executed  as  tests.
       Tests  may  use  the  assert  keyword  or  raise AssertionErrors to indicate test failure.
       TestCase subclasses may do the same or use the various TestCase methods available.

       It is important to note that the default behavior of nose is to  not  include  tests  from
       files which are executable.  To include tests from such files, remove their executable bit
       or use the --exe flag (see 'Options' section below).

   Selecting Tests
       To specify which tests to run, pass test names on the command line:


       Test names specified may be file or module names, and may  optionally  indicate  the  test
       case  to  run  by separating the module or file name from the test case name with a colon.
       Filenames may be relative or absolute. Examples:

          nosetests test.module
          nosetests another.test:TestCase.test_method
          nosetests a.test:TestCase
          nosetests /path/to/test/

       You may also change the working directory where nose looks  for  tests  by  using  the  -w

          nosetests -w /path/to/tests

       Note,  however,  that  support  for  multiple  -w  arguments is now deprecated and will be
       removed in a future release. As of nose 0.10, you can get the same behavior by  specifying
       the target directories without the -w switch:

          nosetests /path/to/tests /another/path/to/tests

       Further  customization  of  test  selection  and  loading  is  possible through the use of

       Test result output is identical to that of unittest, except for  the  additional  features
       (error   classes,   and  plugin-supplied  features  such  as  output  capture  and  assert
       introspection) detailed in the options below.

       In addition to passing command-line options, you may also  put  configuration  options  in
       your  project's  setup.cfg  file, or a .noserc or nose.cfg file in your home directory. In
       any of these standard ini-style config files, you put your nosetests  configuration  in  a
       [nosetests]  section.  Options  are  the  same  as on the command line, with the -- prefix
       removed. For options that are simple switches, you must supply a value:


       All configuration files that are found will be loaded and their options combined. You  can
       override the standard config file loading with the -c option.

   Using Plugins
       There are numerous nose plugins available via easy_install and elsewhere. To use a plugin,
       just install it. The plugin will add command line options to nosetests. To verify that the
       plugin is installed, run:

          nosetests --plugins

       You can add -v or -vv to that command to show more information about each plugin.

       If  you  are  running  nose.main()  or from a script, you can specify a list of
       plugins to use by passing a list of plugins with the plugins keyword argument.

   0.9 plugins
       nose 1.0 can use SOME plugins that were written for nose 0.9. The default  plugin  manager
       inserts  a  compatibility  wrapper  around  0.9 plugins that adapts the changed plugin api
       calls. However, plugins that access nose internals are likely to fail, especially if  they
       attempt  to  access  test  case  or  test  suite classes. For example, plugins that try to
       determine if a test passed to startTest is an individual test or a suite will fail, partly
       because  suites  are no longer passed to startTest and partly because it's likely that the
       plugin is trying to find out if the test is an instance of a class that no longer exists.

   0.10 and 0.11 plugins
       All plugins written for nose 0.10 and 0.11 should work with nose 1.0.

       -V, --version
              Output nose version and exit

       -p, --plugins
              Output list of available plugins  and  exit.  Combine  with  higher  verbosity  for
              greater detail

       -v=DEFAULT, --verbose=DEFAULT
              Be more verbose. [NOSE_VERBOSE]

              Set verbosity; --verbosity=2 is the same as -v

       -q=DEFAULT, --quiet=DEFAULT
              Be less verbose

       -c=FILES, --config=FILES
              Load  configuration  from  config file(s). May be specified multiple times; in that
              case, all config files will be loaded and combined

       -w=WHERE, --where=WHERE
              Look for tests in this directory.  May  be  specified  multiple  times.  The  first
              directory  passed  will  be  used as the working directory, in place of the current
              working directory, which is the default. Others will be added to the list of  tests
              to execute. [NOSE_WHERE]

              Look  for  tests in this directory under Python 3.x. Functions the same as 'where',
              but only applies if running under Python 3.x or above.  Note that, if present under
              3.x, this option completely replaces any directories specified with 'where', so the
              'where' option becomes ineffective. [NOSE_PY3WHERE]

       -m=REGEX, --match=REGEX, --testmatch=REGEX
              Files, directories, function  names,  and  class  names  that  match  this  regular
              expression are considered tests.  Default: (?:^|[b_./-])[Tt]est [NOSE_TESTMATCH]

              Run  these  tests  (comma-separated  list).  This  argument  is  useful mainly from
              configuration files; on the command line, just pass the tests to run as  additional
              arguments with no switch.

       -l=DEFAULT, --debug=DEFAULT
              Activate  debug  logging  for  one  or more systems. Available debug loggers: nose,
              nose.importer,  nose.inspector,  nose.plugins,   nose.result   and   nose.selector.
              Separate multiple names with a comma.

              Log debug messages to this file (default: sys.stderr)

       --logging-config=FILE, --log-config=FILE
              Load logging config from this file -- bypasses all other logging config settings.

       -I=REGEX, --ignore-files=REGEX
              Completely  ignore  any file that matches this regular expression. Takes precedence
              over any other settings or plugins. Specifying this option will replace the default
              setting.  Specify  this  option  multiple  times  to  add  more regular expressions

       -e=REGEX, --exclude=REGEX
              Don't run tests that match regular expression [NOSE_EXCLUDE]

       -i=REGEX, --include=REGEX
              This regular expression will be applied to files, directories, function names,  and
              class  names  for a chance to include additional tests that do not match TESTMATCH.
              Specify this option multiple times to add more regular expressions [NOSE_INCLUDE]

       -x, --stop
              Stop running tests after the first error or failure

       -P, --no-path-adjustment
              Don't make any changes to sys.path when loading tests [NOSE_NOPATH]

       --exe  Look for tests in python modules that are executable. Normal behavior is to exclude
              executable modules, since they may not be import-safe [NOSE_INCLUDE_EXE]

              DO  NOT  look  for tests in python modules that are executable. (The default on the
              windows platform is to do so.)

              Traverse through all path entries of a namespace package

       --first-package-wins, --first-pkg-wins, --1st-pkg-wins
              nose's importer will normally evict a package from sys.modules if it sees a package
              with  the  same  name  in  a  different  location.  Set this option to disable that

              Prevent nose from byte-compiling the source into .pyc files while nose is  scanning
              for and running tests.

       -a=ATTR, --attr=ATTR
              Run only tests that have attributes specified by ATTR [NOSE_ATTR]

       -A=EXPR, --eval-attr=EXPR
              Run  only  tests  for whose attributes the Python expression EXPR evaluates to True

       -s, --nocapture
              Don't  capture  stdout  (any   stdout   output   will   be   printed   immediately)

              Disable  logging  capture  plugin.  Logging  configuration  will  be  left  intact.

              Specify custom format to print statements. Uses the same format as used by standard
              logging handlers. [NOSE_LOGFORMAT]

              Specify  custom  date/time format to print statements. Uses the same format as used
              by standard logging handlers. [NOSE_LOGDATEFMT]

              Specify which statements to filter in/out. By default, everything is  captured.  If
              the output is too verbose, use this option to filter out needless output.  Example:
              filter=foo will capture statements issued ONLY to
               foo or foo.what.ever.sub but not foobar or other logger.  Specify multiple loggers
              with  comma:  filter=foo,bar,baz.   If any logger name is prefixed with a minus, eg
              filter=-foo, it will be excluded rather than  included.  Default:  exclude  logging
              messages from nose itself (-nose). [NOSE_LOGFILTER]

              Clear all other logging handlers

              Set the log level to capture

              Enable  plugin Coverage: Activate a coverage report using Ned Batchelder's coverage

              Restrict coverage output to selected packages [NOSE_COVER_PACKAGE]

              Erase previously collected coverage statistics before run

              Include test modules in coverage report [NOSE_COVER_TESTS]

              Minimum percentage of coverage for tests to pass [NOSE_COVER_MIN_PERCENTAGE]

              Include all python files under working directory in coverage  report.   Useful  for
              discovering holes in test coverage if not all files are imported by the test suite.

              Produce HTML coverage information

              Produce HTML coverage information in dir

              Include branch coverage in coverage report [NOSE_COVER_BRANCHES]

              Produce XML coverage information

              Produce XML coverage information in file

       --pdb  Drop into debugger on failures or errors

              Drop into debugger on failures

              Drop into debugger on errors

              Disable special handling of DeprecatedTest exceptions.

              Enable plugin Doctest: Activate doctest plugin to find and run doctests in non-test

              Also  look  for  doctests in test modules. Note that classes, methods and functions
              should have either doctests or non-doctest tests, not both. [NOSE_DOCTEST_TESTS]

              Also look for doctests in files with this extension [NOSE_DOCTEST_EXTENSION]

              Change the variable name set to the result of the last interpreter command from the
              default  '_'.  Can  be  used to avoid conflicts with the _() function used for text
              translation. [NOSE_DOCTEST_RESULT_VAR]

              Find fixtures for a doctest file in module with this name appended to the base name
              of the doctest file

              Specify options to pass to doctest. Eg. '+ELLIPSIS,+NORMALIZE_WHITESPACE'

              Enable  plugin IsolationPlugin: Activate the isolation plugin to isolate changes to
              external modules to a single test module or package. The  isolation  plugin  resets
              the  contents  of  sys.modules  after each test module or package runs to its state
              before the test. PLEASE NOTE that this plugin should not be used with the  coverage
              plugin,  or  in  any  other  case  where  module  reloading may produce undesirable

       -d, --detailed-errors, --failure-detail
              Add  detail  to  error  output   by   attempting   to   evaluate   failed   asserts

              Enable plugin Profile: Use this plugin to run tests using the hotshot profiler.

              Set sort order for profiler output

              Profiler stats file; default is a new temp file on each run

              Restrict profiler output. See help for pstats.Stats for details

              Disable special handling of SkipTest exceptions.

              Enable plugin TestId: Activate to add a test id (like #1) to each test name output.
              Activate with --failed to rerun failing tests only.

              Store test ids found in test runs in this file. Default is the file .noseids in the
              working directory.

              Run the tests that failed in the last test run.

              Spread  test  run  among  this  many processes. Set a number equal to the number of
              processors or cores in your machine for best results. Pass  a  negative  number  to
              have  the  number  of processes automatically set to the number of cores. Passing 0
              means to disable parallel testing. Default  is  0  unless  NOSE_PROCESSES  is  set.

              Set  timeout  for  return  of results from each test runner process. Default is 10.

              If set, will restart each worker process once their  tests  are  done,  this  helps
              control memory leaks from killing the system. [NOSE_PROCESS_RESTARTWORKER]

              Enable  plugin  Xunit:  This plugin provides test results in the standard XUnit XML
              format. [NOSE_WITH_XUNIT]

              Path to xml file to store the xunit report in.  Default  is  nosetests.xml  in  the
              working directory [NOSE_XUNIT_FILE]

              Name  of  the  testsuite  in the xunit xml, generated by plugin. Default test suite
              name is nosetests.

              Enable plugin AllModules: Collect tests from all python modules.

              Enable collect-only: Collect and output test names only, don't run any tests.


       Nose developers


       2009, Jason Pellerin