Vega strike Python Modules doc: doctest Namespace Reference

All Data Structures Namespaces Files Functions Variables

Data Structures
class	_SpoofOut

class	Tester

class	_TestClass

Functions
def	run_docstring_examples

def	is_private

def	testmod

Variables
list	__all__

string	PS1 = ">>>"

string	PS2 = "..."

tuple	_isPS1 = re.compile(r"(\s*)" + re.escape(PS1))

tuple	_isPS2 = re.compile(r"(\s*)" + re.escape(PS2))

tuple	_isEmpty = re.compile(r"\s*$")

tuple	_isComment = re.compile(r"\s*#")

	master = None

dictionary	__test__

Function Documentation

def doctest.is_private	(	prefix,
		base
	)

prefix, base -> true iff name prefix + "." + base is "private".

Prefix may be an empty string, and base does not contain a period.
Prefix is ignored (although functions you write conforming to this
protocol may make use of it).
Return true iff base begins with an (at least one) underscore, but
does not both begin and end with (at least) two underscores.

>>> is_private("a.b", "my_func")
0
>>> is_private("____", "_my_func")
1
>>> is_private("someclass", "__init__")
0
>>> is_private("sometypo", "__init_")
1
>>> is_private("x.y.z", "_")
1
>>> is_private("_x.y.z", "__")
0
>>> is_private("", "")  # senseless but consistent
0

Definition at line 534 of file doctest.py.

 
 def is_private(prefix, base):
     """prefix, base -> true iff name prefix + "." + base is "private".
 
     Prefix may be an empty string, and base does not contain a period.
     Prefix is ignored (although functions you write conforming to this
     protocol may make use of it).
     Return true iff base begins with an (at least one) underscore, but
     does not both begin and end with (at least) two underscores.
 
     >>> is_private("a.b", "my_func")
     0
     >>> is_private("____", "_my_func")
     1
     >>> is_private("someclass", "__init__")
     0
     >>> is_private("sometypo", "__init_")
     1
     >>> is_private("x.y.z", "_")
     1
     >>> is_private("_x.y.z", "__")
     0
     >>> is_private("", "")  # senseless but consistent
     0
     """
 
     return base[:1] == "_" and not base[:2] == "__" == base[-2:]
 
 # Determine if a class of function was defined in the given module.

def doctest.run_docstring_examples	(	f,
		globs,
		verbose = `0`,
		name = `"NoName"`,
		compileflags = `None`
	)

f, globs, verbose=0, name="NoName" -> run examples from f.__doc__.

Use (a shallow copy of) dict globs as the globals for execution.
Return (#failures, #tries).

If optional arg verbose is true, print stuff even if there are no
failures.
Use string name in failure msgs.

Definition at line 505 of file doctest.py.

References locale.str().

 
                            compileflags=None):
     """f, globs, verbose=0, name="NoName" -> run examples from f.__doc__.
 
     Use (a shallow copy of) dict globs as the globals for execution.
     Return (#failures, #tries).
 
     If optional arg verbose is true, print stuff even if there are no
     failures.
     Use string name in failure msgs.
     """
 
     try:
         doc = f.__doc__
         if not doc:
             # docstring empty or None
             return 0, 0
         # just in case CT invents a doc object that has to be forced
         # to look like a string <0.9 wink>
         doc = str(doc)
     except:
         return 0, 0
 
     e = _extract_examples(doc)
     if not e:
         return 0, 0
     if compileflags is None:
         compileflags = _extract_future_flags(globs)
     return _run_examples(e, globs, verbose, name, compileflags)

def doctest.testmod	(	m,
		name = `None`,
		globs = `None`,
		verbose = `None`,
		isprivate = `None`,
		report = `1`
	)

m, name=None, globs=None, verbose=None, isprivate=None, report=1

Test examples in docstrings in functions and classes reachable from
module m, starting with m.__doc__.  Private names are skipped.

Also test examples reachable from dict m.__test__ if it exists and is
not None.  m.__dict__ maps names to functions, classes and strings;
function and class docstrings are tested even if the name is private;
strings are tested directly, as if they were docstrings.

Return (#failures, #tests).

See doctest.__doc__ for an overview.

Optional keyword arg "name" gives the name of the module; by default
use m.__name__.

Optional keyword arg "globs" gives a dict to be used as the globals
when executing examples; by default, use m.__dict__.  A copy of this
dict is actually used for each docstring, so that each docstring's
examples start with a clean slate.

Optional keyword arg "verbose" prints lots of stuff if true, prints
only failures if false; by default, it's true iff "-v" is in sys.argv.

Optional keyword arg "isprivate" specifies a function used to
determine whether a name is private.  The default function is
doctest.is_private; see its docs for details.

Optional keyword arg "report" prints a summary at the end when true,
else prints nothing at the end.  In verbose mode, the summary is
detailed, else very brief (in fact, empty if all tests passed).

Advanced tomfoolery:  testmod runs methods of a local instance of
class doctest.Tester, then merges the results into (or creates)
global Tester instance doctest.master.  Methods of doctest.master
can be called directly too, if you want to do something unusual.
Passing report=0 to testmod is especially useful then, to delay
displaying a summary.  Invoke doctest.master.summarize(verbose)
when you're done fiddling.

Definition at line 1044 of file doctest.py.

 
                report=1):
     """m, name=None, globs=None, verbose=None, isprivate=None, report=1
 
     Test examples in docstrings in functions and classes reachable from
     module m, starting with m.__doc__.  Private names are skipped.
 
     Also test examples reachable from dict m.__test__ if it exists and is
     not None.  m.__dict__ maps names to functions, classes and strings;
     function and class docstrings are tested even if the name is private;
     strings are tested directly, as if they were docstrings.
 
     Return (#failures, #tests).
 
     See doctest.__doc__ for an overview.
 
     Optional keyword arg "name" gives the name of the module; by default
     use m.__name__.
 
     Optional keyword arg "globs" gives a dict to be used as the globals
     when executing examples; by default, use m.__dict__.  A copy of this
     dict is actually used for each docstring, so that each docstring's
     examples start with a clean slate.
 
     Optional keyword arg "verbose" prints lots of stuff if true, prints
     only failures if false; by default, it's true iff "-v" is in sys.argv.
 
     Optional keyword arg "isprivate" specifies a function used to
     determine whether a name is private.  The default function is
     doctest.is_private; see its docs for details.
 
     Optional keyword arg "report" prints a summary at the end when true,
     else prints nothing at the end.  In verbose mode, the summary is
     detailed, else very brief (in fact, empty if all tests passed).
 
     Advanced tomfoolery:  testmod runs methods of a local instance of
     class doctest.Tester, then merges the results into (or creates)
     global Tester instance doctest.master.  Methods of doctest.master
     can be called directly too, if you want to do something unusual.
     Passing report=0 to testmod is especially useful then, to delay
     displaying a summary.  Invoke doctest.master.summarize(verbose)
     when you're done fiddling.
     """
 
     global master
 
     if not _ismodule(m):
         raise TypeError("testmod: module required; " + `m`)
     if name is None:
         name = m.__name__
     tester = Tester(m, globs=globs, verbose=verbose, isprivate=isprivate)
     failures, tries = tester.rundoc(m, name)
     f, t = tester.rundict(m.__dict__, name, m)
     failures = failures + f
     tries = tries + t
     if hasattr(m, "__test__"):
         testdict = m.__test__
         if testdict:
             if not hasattr(testdict, "items"):
                 raise TypeError("testmod: module.__test__ must support "
                                 ".items(); " + `testdict`)
             f, t = tester.run__test__(testdict, name + ".__test__")
             failures = failures + f
             tries = tries + t
     if report:
         tester.summarize()
     if master is None:
         master = tester
     else:
         master.merge(tester)
     return failures, tries

Data Structures

Functions

Variables

Function Documentation

Variable Documentation