ó
|
L\¬Qc ! @ sö d Z d Z d d d d d d d d d
|
d d d d d d d d d d d d d d d d d d d d d d d! d" g! Z d# d$ l Z d# d$ l Z d# d$ l Z d# d$ l Z d# d$ l Z d# d$ l Z d# d$ l Z d# d$ l
|
Z
|
d# d$ l Z d# d$ l Z d# d$ l Z d# d$ l Z d# d% l m Z d# d& l m Z e d' d( Z i Z d) Z e d Z e d Z e d Z e d Z e d Z e d Z e e Be Be Be Be BZ e d
|
Z e d Z e d Z e d Z e e Be Be BZ d* Z! d+ Z" d, Z# d- d. Z$ d/ Z% e& e j' d0 e( p)d1 Z) d2 d3 Z* d4 Z+ d5 e f d6 YZ, d7 Z- d8 Z. d9 e j/ f d: YZ0 d; Z1 d f d< YZ2 d f d= YZ3 d f d> YZ4 d f d? YZ5 d f d@ YZ6 d f dA YZ7 d e8 f dB YZ9 d e8 f dC YZ: d e6 f dD YZ; e( a< e( e( e( e( e= dE e( e> e> dF Z? e= e( e( e( e( e= dE e( e> e4 e( dG Z@ e> dH e( dE dI ZA d f dJ YZB dE aC dK ZD dL e
|
jE f dM YZF dN eF f dO YZG e( e( e( e( dP ZH dQ eF f dR YZI e= e( e( e4 e( dS ZJ dT ZK dU ZL dV ZM e> e( dW ZN e> e( dX ZO e> dY ZP dZ f d[ YZQ i eQ dZ 6d\ d] 6d^ d_ 6d` da 6db dc 6dd de 6ZR df ZS eT dg k ròe jU eS n d$ S(h sÅ Module doctest -- a framework for running examples in docstrings.
|
|
In simplest use, end each module M to be tested with:
|
|
def _test():
|
import doctest
|
doctest.testmod()
|
|
if __name__ == "__main__":
|
_test()
|
|
Then running the module as a script will cause the examples in the
|
docstrings to get executed and verified:
|
|
python M.py
|
|
This won't display anything unless an example fails, in which case the
|
failing example(s) and the cause(s) of the failure(s) are printed to stdout
|
(why not stderr? because stderr is a lame hack <0.2 wink>), and the final
|
line of output is "Test failed.".
|
|
Run it with the -v switch instead:
|
|
python M.py -v
|
|
and a detailed report of all examples tried is printed to stdout, along
|
with assorted summaries at the end.
|
|
You can force verbose mode by passing "verbose=True" to testmod, or prohibit
|
it by passing "verbose=False". In either of those cases, sys.argv is not
|
examined by testmod.
|
|
There are a variety of other ways to run doctests, including integration
|
with the unittest framework, and support for running non-Python text
|
files containing doctests. There are also many ways to override parts
|
of doctest's default behaviors. See the Library Reference Manual for
|
details.
|
s reStructuredText ent register_optionflagt DONT_ACCEPT_TRUE_FOR_1t DONT_ACCEPT_BLANKLINEt NORMALIZE_WHITESPACEt ELLIPSISt SKIPt IGNORE_EXCEPTION_DETAILt COMPARISON_FLAGSt REPORT_UDIFFt REPORT_CDIFFt REPORT_NDIFFt REPORT_ONLY_FIRST_FAILUREt REPORTING_FLAGSt Examplet DocTestt DocTestParsert DocTestFindert DocTestRunnert OutputCheckert DocTestFailuret UnexpectedExceptiont DebugRunnert testmodt testfilet run_docstring_examplest Testert DocTestSuitet DocFileSuitet set_unittest_reportflagst script_from_examplest
|
testsourcet debug_srct debugiÿÿÿÿN( t StringIO( t
|
namedtuplet TestResultss failed attemptedc C s t j | d t t > S( Ni ( t OPTIONFLAGS_BY_NAMEt
|
setdefaultt len( t name( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR s s <BLANKLINE>s ...c C sU d } xH t j D]= } | j | d } | t t | k r | | j O} q q W| S( s
|
Return the compiler-flags associated with the future features that
|
have been imported into the given namespace (globs).
|
i N( t
|
__future__t all_feature_namest gett Nonet getattrt compiler_flag( t globst flagst fnamet feature( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt _extract_future_flags² s i c C s{ t j | r | St | t t f rD t | t t d g S| d k rk t j
|
t j | j d St d d S( s
|
Return the module specified by `module`. In particular:
|
- If `module` is a module, then return module.
|
- If `module` is a string, then import and return the
|
module with that name.
|
- If `module` is None, then return the calling module.
|
The calling module is assumed to be the module of
|
the stack frame at the given depth in the call stack.
|
t *t __name__s" Expected a module, string, or NoneN( t inspectt ismodulet
|
isinstancet strt unicodet
|
__import__t globalst localsR+ t syst modulest _getframet f_globalst TypeError( t modulet depth( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt _normalize_module¾ s
|
c C s | rv t | d } t | | } t | d rv t | j d rs | j j | } | j t j d | f Sqv n t | } | j | f SWd QXd S( Ni t
|
__loader__t get_datas
|
(
|
RD t _module_relative_patht hasattrRE RF t replacet ost linesept opent read( t filenamet packaget module_relativet file_contentst f( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt _load_testfileÑ s t encodings utf-8i c C s; t | t r$ | j t d } n t j d | d | S( sö
|
Add the given number of space characters to the beginning of
|
every non-blank line in `s`, and return the result.
|
If the string `s` is Unicode, it is encoded using the stdout
|
encoding and the `backslashreplace` error handler.
|
t backslashreplaces
|
(?m)^(?!$)t ( R7 R9 t encodet _encodingt ret sub( t st indent( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt _indentá s c C s; t } | \ } } } t j | | | d | | j S( sz
|
Return a string containing a traceback message for the given
|
exc_info tuple (as returned by sys.exc_info()).
|
t file( R! t tracebackt print_exceptiont getvalue( t exc_infot excoutt exc_typet exc_valt exc_tb( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt _exception_tracebackí s t _SpoofOutc B s e Z d Z d d Z RS( c C sN t j | } | r2 | j d r2 | d 7} n t | d rJ | ` n | S( Ns
|
t softspace( R! Ra t endswithRH Ri ( t selft result( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyRa ú s c C sA t j | | t | d r( | ` n | j s= d | _ n d S( NRi t ( R! t truncateRH Ri t buf( Rk t size( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyRn s
|
N( R4 t
|
__module__Ra R+ Rn ( ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyRh ù s c C s& t | k r | | k S| j t } t | d k s= t d t | } } | d } | r | j | r
t | } | d =q t Sn | d } | rÌ | j | rÅ | t | 8} | d =qÌ t Sn | | k rÜ t SxC | D]; } | j | | | } | d k rt S| t | 7} qã Wt S( s_
|
Essentially the only subtle case:
|
>>> _ellipsis_match('aa...aa', 'aaa')
|
False
|
i i iÿÿÿÿ( t ELLIPSIS_MARKERt splitR& t AssertionErrort
|
startswitht FalseRj t findt True( t wantt gott wst startpost endpost w( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt _ellipsis_match s2
|
|
|
|
|
c C s" | j } | r d | Sd Sd S( s) Return a commented form of the given lines # t #N( t rstrip( t line( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt _comment_lineA s t _OutputRedirectingPdbc B s5 e Z d Z d Z d d Z d Z d Z RS( sÀ
|
A specialized version of the python debugger that redirects stdout
|
to a given stream when interacting with the user. Stdout is *not*
|
redirected when traced code is executed.
|
c C s5 | | _ t | _ t j j | d | d | _ d S( Nt stdouti ( t _OutputRedirectingPdb__outRv t$ _OutputRedirectingPdb__debugger_usedt pdbt Pdbt __init__t use_rawinput( Rk t out( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR O s c C s> t | _ | d k r' t j j } n t j j | | d S( N( Rx R R+ R= R? t f_backR R t set_trace( Rk t frame( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR V s c C s | j r t j j | n d S( N( R R R t set_continue( Rk ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR \ s c G s= t j } | j t _ z t j j | | SWd | t _ Xd S( N( R= R
R R R t trace_dispatch( Rk t argst save_stdout( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR b s
|
N( R4 Rq t __doc__R R+ R R R ( ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR I s
|
c C sø t j | s t d | n | j d r: t d n t | d re t j j | j d } nw | j
|
d k rÈ t t j d k r¼ t j d d k r¼ t j j t j d d } qÜ t j } n t d | d t j j | | j d S(
|
Ns Expected a module: %rt /s1 Module-relative files may not have absolute pathst __file__i t __main__Rm s+ Can't resolve paths relative to the module s (it has no __file__)( R5 R6 RA Ru t
|
ValueErrorRH RJ t pathRs R R4 R& R= t argvt curdirt join( RB R t basedir( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyRG m s ( c B s> e Z d Z d d d d d Z d Z d Z d Z RS( sn
|
A single doctest example, consisting of source code and expected
|
output. `Example` defines the following attributes:
|
|
- source: A single Python statement, always ending with a newline.
|
The constructor adds a newline if needed.
|
|
- want: The expected output from running the source code (either
|
from stdout, or a traceback in case of exception). `want` ends
|
with a newline unless it's empty, in which case it's an empty
|
string. The constructor adds a newline if needed.
|
|
- exc_msg: The exception message generated by the example, if
|
the example is expected to generate an exception; or `None` if
|
it is not expected to generate an exception. This exception
|
message is compared against the return value of
|
`traceback.format_exception_only()`. `exc_msg` ends with a
|
newline unless it's `None`. The constructor adds a newline
|
if needed.
|
|
- lineno: The line number within the DocTest string containing
|
this Example where the Example begins. This line number is
|
zero-based, with respect to the beginning of the DocTest.
|
|
- indent: The example's indentation in the DocTest string.
|
I.e., the number of space characters that preceed the
|
example's first prompt.
|
|
- options: A dictionary mapping from option flags to True or
|
False, which is used to override default options for this
|
example. Any option flags not contained in this dictionary
|
are left at their default value (as specified by the
|
DocTestRunner's optionflags). By default, no options are set.
|
i c C s· | j d s | d 7} n | r? | j d r? | d 7} n | d k rh | j d rh | d 7} n | | _ | | _ | | _ | | _ | d k r¡ i } n | | _ | | _ d S( Ns
|
( Rj R+ t sourceRy t linenoR\ t optionst exc_msg( Rk R Ry R¡ R R\ R ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR ´ s c C s t | t | k r t S| j | j k o
| j | j k o
| j | j k o
| j | j k o
| j | j k o
| j | j k S( N( t typet NotImplementedR Ry R R\ R R¡ ( Rk t other( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt __eq__Æ s c C s | | k S( N( ( Rk R¤ ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt __ne__Ñ s c C s( t | j | j | j | j | j f S( N( t hashR Ry R R\ R¡ ( Rk ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt __hash__Ô s N( R4 Rq R R+ R R¥ R¦ R¨ ( ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR s " c B sD e Z d Z d Z d Z d Z d Z d Z d Z RS( se
|
A collection of doctest examples that should be run in a single
|
namespace. Each `DocTest` defines the following attributes:
|
|
- examples: the list of examples.
|
|
- globs: The namespace (aka globals) that the examples should
|
be run in.
|
|
- name: A name identifying the DocTest (typically, the name of
|
the object whose docstring this DocTest was extracted from).
|
|
- filename: The name of the file that this DocTest was extracted
|
from, or `None` if the filename is unknown.
|
|
- lineno: The line number within filename where this DocTest
|
begins, or `None` if the line number is unavailable. This
|
line number is zero-based, with respect to the beginning of
|
the file.
|
|
- docstring: The string that the examples were extracted from,
|
or `None` if the string is unavailable.
|
c C s\ t | t s t d | | _ | | _ | j | _ | | _ | | _ | | _ d S( s
|
Create a new DocTest containing the given examples. The
|
DocTest's globals are initialized with a copy of `globs`.
|
s8 DocTest no longer accepts str; use DocTestParser insteadN(
|
R7 t
|
basestringRt t examplest docstringt copyR. R' RN R ( Rk Rª R. R' RN R R« ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR ñ s c C sl t | j d k r d } n1 t | j d k r< d } n d t | j } d | j | j | j | f S( Ni s no examplesi s 1 examples %d exampless <DocTest %s from %s:%s (%s)>( R& Rª R' RN R ( Rk Rª ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt __repr__ÿ s c C s t | t | k r t S| j | j k o
| j | j k o
| j | j k o
| j | j k o
| j | j k o
| j | j k S( N( R¢ R£ Rª R« R. R' RN R ( Rk R¤ ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR¥ s c C s | | k S( N( ( Rk R¤ ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR¦ s c C s" t | j | j | j | j f S( N( R§ R« R' RN R ( Rk ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR¨ s c C sV t | t s d St | j | j | j t | f | j | j | j t | f S( Niÿÿÿÿ( R7 R t cmpR' RN R t id( Rk R¤ ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt __cmp__ s !( R4 Rq R R R R¥ R¦ R¨ R° ( ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR Ù s
|
c B s× e Z d Z e j d e j e j B Z e j d e j e j Be j B Z e j d j
|
Z d d Z d Z d d Z d Z e j d e j Z d
|
Z e j d e j Z d Z d Z d Z RS( sD
|
A class used to parse strings containing doctest examples.
|
sú
|
# Source consists of a PS1 line followed by zero or more PS2 lines.
|
(?P<source>
|
(?:^(?P<indent> [ ]*) >>> .*) # PS1 line
|
(?:\n [ ]* \.\.\. .*)*) # PS2 lines
|
\n?
|
# Want consists of any non-blank lines that do not start with PS1.
|
(?P<want> (?:(?![ ]*$) # Not a blank line
|
(?![ ]*>>>) # Not a line starting with PS1
|
.*$\n? # But any other line
|
)*)
|
sß
|
# Grab the traceback header. Different versions of Python have
|
# said different things on the first traceback line.
|
^(?P<hdr> Traceback\ \(
|
(?: most\ recent\ call\ last
|
| innermost\ last
|
) \) :
|
)
|
\s* $ # toss trailing whitespace on the header.
|
(?P<stack> .*?) # don't blink: absorb stuff until...
|
^ (?P<msg> \w+ .*) # a line *starts* with alphanum.
|
s ^[ ]*(#.*)?$s <string>c C sx | j } | j | } | d k rY d j g | j d D] } | | ^ q= } n g } d \ } } xõ | j j | D]á } | j | | | j ! | | j d | | j 7} | j | | | \ } }
|
} } | j
|
| s.| j t | | | d | d | t | j d d |
|
n | | j d | j | j 7} | j } q~ W| j | | | S( s=
|
Divide the given string into examples and intervening text,
|
and return them as a list of alternating Examples and strings.
|
Line numbers for the Examples are 0-based. The optional
|
argument `name` is a name identifying this string, and is only
|
used for error messages.
|
i s
|
R R\ R ( i i ( t
|
expandtabst _min_indentR Rs t _EXAMPLE_REt finditert appendt startt countt _parse_examplet _IS_BLANK_OR_COMMENTR R& t groupt end( Rk t stringR' t
|
min_indentt lt outputt charnoR t mR R Ry R¡ ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt parseU s& 2 ! %c C s% t | j | | | | | | | S( s"
|
Extract all doctest examples from the given string, and
|
collect them into a `DocTest` object.
|
|
`globs`, `name`, `filename`, and `lineno` are attributes for
|
the new `DocTest` object. See the documentation for `DocTest`
|
for more information.
|
( R t get_examples( Rk R¼ R. R' RN R ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt get_doctest| s c C s2 g | j | | D] } t | t r | ^ q S( sÑ
|
Extract all doctest examples from the given string, and return
|
them as a list of `Example` objects. Line numbers are
|
0-based, because it's most common in doctests that nothing
|
interesting appears on the same line as opening triple-quote,
|
and so the first interesting line is called "line 1" then.
|
|
The optional argument `name` is a name identifying this
|
string, and is only used for error messages.
|
( RÂ R7 R ( Rk R¼ R' t x( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyRÃ s c C s~ t | j d } | j d j d } | j | | | | | j | d d | d | | d j g | D] } | | d ^ qr } | j d } | j d } t | d k rß t j d | d
|
rß | d
|
=n | j | d | | | t | d j g | D] }
|
|
|
| ^ q } | j j | } | rS| j d } n d } | j
|
| | | } | | | | f S( s¼
|
Given a regular expression match from `_EXAMPLE_RE` (`m`),
|
return a pair `(source, want)`, where `source` is the matched
|
example's source code (with prompts and indentation stripped);
|
and `want` is the example's expected output (with indentation
|
stripped).
|
|
`name` is the string's name, and `lineno` is the line number
|
where the example starts; both are used for error messages.
|
R\ R s
|
i RV t .i Ry s *$iÿÿÿÿt msgN( R& Rº Rs t _check_prompt_blankt _check_prefixR RY t matcht _EXCEPTION_RER+ t _find_options( Rk RÁ R' R R\ t source_linest slR Ry t
|
want_linest wlR¡ R ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR¸ s$ "*(
|
&s #\s*doctest:\s*([^\n\'"]*)$c C sì i } x® | j j | D] } | j d j d d j } xp | D]h } | d d k sm | d t k r t d | d | | f n t | d } | d d k | | <qG Wq W| rè | j | rè t d | | | f n | S( s
|
Return a dictionary containing option overrides extracted from
|
option directives in the given source string.
|
|
`name` is the string's name, and `lineno` is the line number
|
where the example starts; both are used for error messages.
|
i t ,RV i s +-s7 line %r of the doctest for %s has an invalid option: %rt +sS line %r of the doctest for %s has an option directive on a line with no example: %r( t _OPTION_DIRECTIVE_RER´ Rº RI Rs R$ R R¹ ( Rk R R' R R RÁ t option_stringst optiont flag( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyRÌ Ì s ! s ^([ ]*)(?=\S)c C sO g | j j | D] } t | ^ q } t | d k rG t | Sd Sd S( s; Return the minimum indentation of any non-blank line in `s`i N( t
|
_INDENT_REt findallR& t min( Rk R[ R\ t indents( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR² ê s +
|
c
|
C s} xv t | D]h \ } } t | | d k r | | d d k r t d | | d | | | | d !| f q q Wd S( s
|
|
Given the lines of a source string (including prompts and
|
leading indentation), check to make sure that every prompt is
|
followed by a space character. If any line is not followed by
|
a space character, then raise ValueError.
|
i i RV s8 line %r of the docstring for %s lacks blank after %s: %ri N( t enumerateR& R ( Rk t linesR\ R' R t iR ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyRÈ ò s
|
*c C s[ xT t | D]F \ } } | r | j | r t d | | d | | f q q Wd S( s
|
Check that every line in the given list starts with the given
|
prefix; if any line does not, then raise a ValueError.
|
sG line %r of the docstring for %s has inconsistent leading whitespace: %ri N( RÛ Ru R ( Rk RÜ t prefixR' R RÝ R ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyRÉ s ( R4 Rq R RY t compilet MULTILINEt VERBOSER³ t DOTALLRË RÊ R¹ RÂ RÄ RÃ R¸ RÓ RÌ R× R² RÈ RÉ ( ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR % s" ' 3 c B s_ e Z d Z e e e e d Z d d d d d Z d Z d Z
|
d Z d Z RS( s<
|
A class used to extract the DocTests that are relevant to a given
|
object, from its docstring and the docstrings of its contained
|
objects. Doctests can currently be extracted from the following
|
object types: modules, functions, classes, methods, staticmethods,
|
classmethods, and properties.
|
c C s( | | _ | | _ | | _ | | _ d S( st
|
Create a new doctest finder.
|
|
The optional argument `parser` specifies a class or
|
function that should be used to create new DocTest objects (or
|
objects that implement the same interface as DocTest). The
|
signature for this factory function should match the signature
|
of the DocTest constructor.
|
|
If the optional argument `recurse` is false, then `find` will
|
only examine the given object, and not any contained objects.
|
|
If the optional argument `exclude_empty` is false, then `find`
|
will include tests for objects with empty docstrings.
|
N( t _parsert _verboset _recurset _exclude_empty( Rk t verboset parsert recurset exclude_empty( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR s c C s¡ | d k rI t | d d } | d k rI t d t | f qI n | t k r^ d } n | d k r| t j | } n yd t j | p t j | } | d k rÁ t j
|
| | j } n t j
|
| } | sß d } n Wn t k
|
rù d } n X| d k r-| d k ri } q9| j j } n | j } | d k rU| j | n d | k rnd | d <n g } | j | | | | | | i | j | S( sj
|
Return a list of the DocTests that are defined by the given
|
object's docstring, or by any of its contained objects'
|
docstrings.
|
|
The optional parameter `module` is the module that contains
|
the given object. If the module is not specified or is None, then
|
the test finder will attempt to automatically determine the
|
correct module. The object's module is used:
|
|
- As a default namespace, if `globs` is not specified.
|
- To prevent the DocTestFinder from extracting DocTests
|
from objects that are imported from other modules.
|
- To find the name of the file containing the object.
|
- To help find the line number of the object within its
|
file.
|
|
Contained objects whose module does not match `module` are ignored.
|
|
If `module` is False, no attempt to find the module will be made.
|
This is obscure, of use mostly in tests: if `module` is False, or
|
is None but cannot be found automatically, then all objects are
|
considered to belong to the (non-existent) module, so all contained
|
objects will (recursively) be searched for doctests.
|
|
The globals for each DocTest is formed by combining `globs`
|
and `extraglobs` (bindings in `extraglobs` override bindings
|
in `globs`). A new copy of the globals dictionary is created
|
for each DocTest. If `globs` is not specified, then it
|
defaults to the module's `__dict__`, if specified, or {}
|
otherwise. If `extraglobs` is not specified, then it defaults
|
to {}.
|
|
R4 sJ DocTestFinder.find: name must be given when obj.__name__ doesn't exist: %rR N( R+ R, R R¢ Rv R5 t getmodulet getsourcefilet getfilet linecachet getlinest __dict__RA R¬ t updatet _findt sort( Rk t objR' RB R. t
|
extraglobsR^ RÍ t tests( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyRw / s> $
|
|
c C s¸ | d k r t St j | d k r8 | t j | k St j | rW | j | j k St j | rv | j | j k St
|
| d r | j | j k St | t r¨ t St d d S( sY
|
Return true if the given object is defined in the given
|
module.
|
Rq s" object must be a class or functionN( R+ Rx R5 Rë t
|
isfunctionRð t func_globalst isclassR4 Rq RH R7 t propertyR ( Rk RB t object( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt _from_module s c C s | j r d | GHn t | | k r+ d Sd | t | <| j | | | | | } | d k rr | j | n t j | r| j rx | j j D]n \ } }
|
d | | f } t j
|
|
|
sÔ t j |
|
r | j | |
|
r | j | |
|
| | | | | q q Wn t j | r| j rxê t | d i j D]Í \ } }
|
t | t swt d t | f n t j
|
|
|
p¿t j |
|
p¿t j |
|
p¿t j |
|
p¿t |
|
t sÞt d t |
|
f n d | | f } | j | |
|
| | | | | q@Wn t j | r| j rxÖ | j j D]Â \ } }
|
t |
|
t rit | | }
|
n t |
|
t rt | | j }
|
n t j
|
|
|
sºt j |
|
sºt |
|
t r<| j | |
|
r<d | | f } | j | |
|
| | | | | q<q<Wn d S( sm
|
Find tests for the given object and any contained objects, and
|
add them to `tests`.
|
s Finding tests in %sNi s %s.%st __test__s5 DocTestFinder.find: __test__ keys must be strings: %rs` DocTestFinder.find: __test__ values must be strings, functions, methods, classes, or modules: %rs %s.__test__.%s( Rä R¯ t _get_testR+ Rµ R5 R6 Rå Rð t itemsR÷ Rù Rü Rò R, R7 R© R R¢ t ismethodt staticmethodt classmethodt im_funcRú ( Rk Rö Rô R' RB RÍ R. t seent testt valnamet val( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyRò sP % c C s t | t r | } nc yC | j d k r3 d } n' | j } t | t sZ t | } n Wn t t f k
|
rz d } n X| j | | } | j r¡ | r¡ d S| d k r¶ d } n2 t | d | j
|
} | d d k rè | d } n | j j | | | | | S( ss
|
Return a DocTest for the given object, if it defines a docstring;
|
otherwise, return None.
|
Rm R iüÿÿÿs .pycs .pyoiÿÿÿÿN( s .pycs .pyo( R7 R© R R+ R8 RA t AttributeErrort _find_linenoRæ R, R4 Rã RÄ ( Rk Rô R' RB R. RÍ R« R RN ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyRþ ß s(
|
c C s d } t j | r d } n t j | r | d k r= d St j d t | d d } x6 t | D]% \ } } | j | ri | } Pqi qi Wn t j | r° | j
|
} n t j | rË | j } n t j | ræ | j } n t j | r| j } n t j | r)t | d d d } n | d k r| d k rI| d St j d } x7 t | t | D] } | j | | rn| SqnWn d S( s
|
Return a line number of the given object's docstring. Note:
|
this method assumes that the object has a docstring.
|
i s ^\s*class\s*%s\bR4 t -t co_firstlinenoi s (^|.*:)\s*\w*("|')N( R+ R5 R6 Rù RY Rß R, RÛ RÊ R R R÷ t func_codet istracebackt tb_framet isframet f_codet iscodet rangeR& ( Rk Rô RÍ R t patRÝ R ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR s< N( R4 Rq R Rv R Rx R R+ Rw Rü Rò Rþ R ( ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR s ] ? %c B s« e Z d Z d d Z d d d d Z d Z d Z d Z d Z d Z
|
d
|
Z d Z e j d Z d d Z d d e d Z d d Z d Z RS( s2
|
A class used to run DocTest test cases, and accumulate statistics.
|
The `run` method is used to process a single DocTest case. It
|
returns a tuple `(f, t)`, where `t` is the number of test cases
|
tried, and `f` is the number of test cases that failed.
|
|
>>> tests = DocTestFinder().find(_TestClass)
|
>>> runner = DocTestRunner(verbose=False)
|
>>> tests.sort(key = lambda test: test.name)
|
>>> for test in tests:
|
... print test.name, '->', runner.run(test)
|
_TestClass -> TestResults(failed=0, attempted=2)
|
_TestClass.__init__ -> TestResults(failed=0, attempted=2)
|
_TestClass.get -> TestResults(failed=0, attempted=2)
|
_TestClass.square -> TestResults(failed=0, attempted=1)
|
|
The `summarize` method prints a summary of all the test cases that
|
have been run by the runner, and returns an aggregated `(f, t)`
|
tuple:
|
|
>>> runner.summarize(verbose=1)
|
4 items passed all tests:
|
2 tests in _TestClass
|
2 tests in _TestClass.__init__
|
2 tests in _TestClass.get
|
1 tests in _TestClass.square
|
7 tests in 4 items.
|
7 passed and 0 failed.
|
Test passed.
|
TestResults(failed=0, attempted=7)
|
|
The aggregated number of tried examples and failed examples is
|
also available via the `tries` and `failures` attributes:
|
|
>>> runner.tries
|
7
|
>>> runner.failures
|
0
|
|
The comparison between expected outputs and actual outputs is done
|
by an `OutputChecker`. This comparison may be customized with a
|
number of option flags; see the documentation for `testmod` for
|
more information. If the option flags are insufficient, then the
|
comparison may also be customized by passing a subclass of
|
`OutputChecker` to the constructor.
|
|
The test runner's display output can be controlled in two ways.
|
First, an output function (`out) can be passed to
|
`TestRunner.run`; this function will be called with strings that
|
should be displayed. It defaults to `sys.stdout.write`. If
|
capturing the output is not sufficient, then the display output
|
can be also customized by subclassing DocTestRunner, and
|
overriding the methods `report_start`, `report_success`,
|
`report_unexpected_exception`, and `report_failure`.
|
R3 iF i c C sv | p t | _ | d k r0 d t j k } n | | _ | | _ | | _ d | _ d | _ i | _
|
t | _ d S( sc
|
Create a new test runner.
|
|
Optional keyword arg `checker` is the `OutputChecker` that
|
should be used to compare the expected outputs and actual
|
outputs of doctest examples.
|
|
Optional keyword arg 'verbose' prints lots of stuff if true,
|
only failures if false; by default, it's true iff '-v' is in
|
sys.argv.
|
|
Optional argument `optionflags` can be used to control how the
|
test runner compares expected output to actual output, and how
|
it displays failures. See the documentation for `testmod` for
|
more information.
|
s -vi N( R t _checkerR+ R= R Rä t optionflagst original_optionflagst triest failurest _name2ftRh t _fakeout( Rk t checkerRç R ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR t s c C s_ | j r[ | j r= | d t | j d t | j q[ | d t | j d n d S( s
|
Report that the test runner is about to process the given
|
example. (Only displays a message if verbose=True)
|
s Trying:
|
s Expecting:
|
s Expecting nothing
|
N( Rä Ry R] R ( Rk R R t example( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt report_start s (c C s | j r | d n d S( st
|
Report that the given example ran successfully. (Only
|
displays a message if verbose=True)
|
s ok
|
N( Rä ( Rk R R R Rz ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt report_success¥ s c C s3 | | j | | | j j | | | j d S( s7
|
Report that the given example failed.
|
N( t _failure_headerR t output_differenceR ( Rk R R R Rz ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt report_failure s c C s. | | j | | d t t | d S( sO
|
Report that the given example raised an unexpected exception.
|
s Exception raised:
|
N( R R] Rg ( Rk R R R Rb ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt report_unexpected_exception´ s c C sÊ | j g } | j rs | j d k rJ | j d k rJ | j | j d } n d } | j d | j | | j f n! | j d | j d | j f | j d | j } | j t | d j | S( Ni t ?s File "%s", line %s, in %ss Line %s, in %ss Failed example:s
|
( t DIVIDERRN R R+ Rµ R' R R] R ( Rk R R R R R ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR » s ! c B s d } } | j } e d \ } } } | j j }
|
x?e | j D].\ } } | j e @of | d k } | | _ | j rÆ xH | j j D]4 \ } } | r¯ | j | O_ q | j | M_ q Wn | j e @rÙ qD n | d 7} | sÿ | j
|
| | | n d | j | f } y7 e | j | d | d | j U| j j d
|
} Wn3 e k
|
r_ n e j } | j j n X| j j } | j j d | } | d
|
k rÔ|
|
| j | | j r¼| } q¼nè e j } e j | d d } | s| e | 7} n | j d
|
k r(| } n |
|
| j | | j rI| } ns | j e @r¼e j d | j } e j d | } | r¼| r¼|
|
| j d | j d | j r¼| } q¼n | | k rê| sr| j! | | | | qrqD | | k r"| s| j" | | | | n | d 7} qD | | k rZ| sM| j# | | | | n | d 7} qD e$ sD t% d | f qD W| | _ | j& | | | e' | | S( sÒ
|
Run the examples in `test`. Write the outcome of each example
|
with one of the `DocTestRunner.report_*` methods, using the
|
writer function `out`. `compileflags` is the set of compiler
|
flags that should be used to execute examples. Return a tuple
|
`(f, t)`, where `t` is the number of examples tried, and `f`
|
is the number of examples that failed. The examples are run
|
in the namespace `test.globs`.
|
i i i s <doctest %s[%d]>t singlei iÿÿÿÿs (?:[^:]*\.)?([^:]*:)s unknown outcomeN(( R R R t check_outputRÛ Rª R R Rÿ R R R' Rß R R. t debuggerR R+ t KeyboardInterruptR= Rb R Ra Rn Ry R_ t format_exception_onlyRg R¡ R RY RÊ Rº R R! R" Rv Rt t _DocTestRunner__record_outcomeR# ( Rk R t compileflagsR R R R t SUCCESSt FAILUREt BOOMt checkt
|
examplenumR t quiett
|
optionflagR RN t exceptionRz t outcomeRb R¡ t m1t m2( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt __runÏ s
|
|
|
'
|
c C s^ | j j | j d \ } } | | | | f | j | j <| j | 7_ | j | 7_ d S( s{
|
Record the fact that the given DocTest (`test`) generated `f`
|
failures out of `t` tried examples.
|
i N( i i ( R R* R' R R ( Rk R RR t tt f2t t2( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt __record_outcomeK s s. <doctest (?P<name>.+)\[(?P<examplenum>\d+)\]>$c C s | j j | } | r | j d | j j k r | j j t | j d } | j } t | t r | j
|
d d } n | j t S| j | | Sd S( NR' R0 t asciiRU ( t% _DocTestRunner__LINECACHE_FILENAME_RERÊ Rº R R' Rª t intR R7 R9 RW t
|
splitlinesRx t save_linecache_getlines( Rk RN t module_globalsRÁ R R ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt __patched_linecache_getlinesX s ! c C s | | _ | d k r' t | j } n t j } | d k rH | j } n | j t _ t j } t
|
| | _ | j j | j j t _ t j | _ | j t _ t j } t j t _ z | j | | | SWd | t _ | t _ | j t _ | t _ | r | j j n Xd S( sJ
|
Run the examples in `test`, and display the results using the
|
writer function `out`.
|
|
The examples are run in the namespace `test.globs`. If
|
`clear_globs` is true (the default), then this namespace will
|
be cleared after the test runs, to help with garbage
|
collection. If you would like to examine the namespace after
|
the test completes, then use `clear_globs=False`.
|
|
`compileflags` gives the set of flags that should be used by
|
the Python compiler when running the examples. If not
|
specified, then it will default to the set of future-import
|
flags that apply to `globs`.
|
|
The output of each example is checked using
|
`DocTestRunner.check_output`, and the results are formatted by
|
the `DocTestRunner.report_*` methods.
|
N( R R+ R2 R. R= R
t writeR R R R R' t resetRî Rï R@ t* _DocTestRunner__patched_linecache_getlinest displayhookt __displayhook__t _DocTestRunner__runt clear( Rk R R+ R t clear_globsR t save_set_tracet save_displayhook( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt runc s. c C s | d k r | j } n g } g } g } d } } x | j j D] } | \ } \ } }
|
| |
|
k sn t | |
|
7} | | 7} |
|
d k r | j | qD | d k rÀ | j | |
|
f qD | j | qD W| r^| rt | Gd GH| j x | D] } d G| GHqý Wn | r^t | Gd GH| j x& | D] \ } } d | | f GHq9Wq^n | r·| j GHt | Gd GH| j x/ | D]$ \ } \ } }
|
d | |
|
| f GHqWn | rï| Gd Gt | j Gd GH| | Gd
|
G| Gd GHn | rd G| Gd GHn | rd GHn t | | S( s¦
|
Print a summary of all the test cases that have been run by
|
this DocTestRunner, and return a tuple `(f, t)`, where `f` is
|
the total number of failed examples, and `t` is the total
|
number of tried examples.
|
|
The optional `verbose` argument controls how detailed the
|
summary is. If the verbosity is not specified, then the
|
DocTestRunner's verbosity is used.
|
i s items had no tests:s s items passed all tests:s %3d tests in %ss items had failures:s %3d of %3d in %ss tests ins items.s
|
passed ands failed.s ***Test Failed***s failures.s Test passed.N(
|
R+ Rä R Rÿ Rt Rµ R& Ró R$ R# ( Rk Rç t notestst passedt failedt totaltt totalfRÅ R' RR R8 t thingR· ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt summarize¡ sR
|
|
|
|
|
|
c C sv | j } xf | j j D]U \ } \ } } | | k r^ | | \ } } | | } | | } n | | f | | <q Wd S( N( R Rÿ ( Rk R¤ t dR' RR R8 R9 R: ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt mergeÚ s "
|
N( R4 Rq R R$ R+ R R R R! R" R RH R* RY Rß R= RE Rx RM RT RV ( ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR 8 s 7
|
$ |
|
> 9c B s) e Z d Z d Z d Z d Z RS( s_
|
A class used to check the whether the actual output from a doctest
|
example matches the expected output. `OutputChecker` defines two
|
methods: `check_output`, which compares a given pair of outputs,
|
and returns true if they match; and `output_difference`, which
|
returns a string describing the differences between two outputs.
|
c C s | | k r t S| t @sI | | f d k r0 t S| | f d
|
k rI t Sn | t @s t j d t j t d | } t j d d | } | | k r t Sn | t @rä d j | j } d j | j } | | k rä t Sn | t
|
@rt | | rt Sn t S( s¥
|
Return True iff the actual output from an example (`got`)
|
matches the expected output (`want`). These strings are
|
always considered to match if they are identical; but
|
depending on what option flags the test runner is using,
|
several non-exact match types are also possible. See the
|
documentation for `TestRunner` for more information about
|
option flags.
|
s True
|
s 1
|
s False
|
s 0
|
s (?m)^%s\s*?$Rm s
|
(?m)^\s*?$RV ( s True
|
s 1
|
( s False
|
s 0
|
( Rx R R RY RZ t escapet BLANKLINE_MARKERR R Rs R R Rv ( Rk Ry Rz R ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR& ï s,
|
|
|
|
c C sL | t t Bt B@s t S| t @r$ t S| j d d k oK | j d d k S( Ns
|
i ( R R R
|
Rv Rx R· ( Rk Ry Rz R ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt _do_a_fancy_diff% s
|
c C sº | j } | t @s+ t j d t | } n | j | | | rd| j t } | j t } | t @r t j
|
| | d d } t | d } d } n | t @rÔ t j | | d d } t | d } d } nR | t @rt j d t j } t | j | | } d } n d s&t d g | D] }
|
|
|
j d
|
^ q-} d | t d j | S| r| rd t | t | f S| rd t | S| r²d t | Sd Sd S( sû
|
Return a string describing the differences between the
|
expected output for a given example (`example`) and the actual
|
output (`got`). `optionflags` is the set of option flags used
|
to compare `want` and `got`.
|
s (?m)^[ ]*(?=
|
)t ni s# unified diff with -expected +actuals- context diff with expected followed by actualt charjunks ndiff with -expected +actuali s Bad diff options
|
s Differences (%s):
|
Rm s Expected:
|
%sGot:
|
%ss Expected:
|
%sGot nothing
|
s Expected nothing
|
Got:
|
%ss Expected nothing
|
Got nothing
|
N( Ry R RY RZ RX RY R? Rx R t difflibt unified_difft listR t context_diffR
|
t Differt IS_CHARACTER_JUNKt compareRt R R] R ( Rk R Rz R Ry RÏ t got_linest difft kindt engineR ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR < s8
|
|
|
|
# ( R4 Rq R R& RY R ( ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR ç s 6 c B s e Z d Z d Z d Z RS( sÖ A DocTest example has failed in debugging mode.
|
|
The exception instance has variables:
|
|
- test: the DocTest object being run
|
|
- example: the Example object that failed
|
|
- got: the actual output
|
c C s | | _ | | _ | | _ d S( N( R R Rz ( Rk R R Rz ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR w s c C s t | j S( N( R8 R ( Rk ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt __str__| s ( R4 Rq R R Rg ( ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR l s
|
c B s e Z d Z d Z d Z RS( sæ A DocTest example has encountered an unexpected exception
|
|
The exception instance has variables:
|
|
- test: the DocTest object being run
|
|
- example: the Example object that failed
|
|
- exc_info: the exception info
|
c C s | | _ | | _ | | _ d S( N( R R Rb ( Rk R R Rb ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR s c C s t | j S( N( R8 R ( Rk ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyRg s ( R4 Rq R R Rg ( ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR s
|
c B s2 e Z d Z d d e d Z d Z d Z RS( s{ Run doc tests but raise an exception as soon as there is a failure.
|
|
If an unexpected exception occurs, an UnexpectedException is raised.
|
It contains the test, the example, and the original exception:
|
|
>>> runner = DebugRunner(verbose=False)
|
>>> test = DocTestParser().get_doctest('>>> raise KeyError\n42',
|
... {}, 'foo', 'foo.py', 0)
|
>>> try:
|
... runner.run(test)
|
... except UnexpectedException, failure:
|
... pass
|
|
>>> failure.test is test
|
True
|
|
>>> failure.example.want
|
'42\n'
|
|
>>> exc_info = failure.exc_info
|
>>> raise exc_info[0], exc_info[1], exc_info[2]
|
Traceback (most recent call last):
|
...
|
KeyError
|
|
We wrap the original exception to give the calling application
|
access to the test and example information.
|
|
If the output doesn't match, then a DocTestFailure is raised:
|
|
>>> test = DocTestParser().get_doctest('''
|
... >>> x = 1
|
... >>> x
|
... 2
|
... ''', {}, 'foo', 'foo.py', 0)
|
|
>>> try:
|
... runner.run(test)
|
... except DocTestFailure, failure:
|
... pass
|
|
DocTestFailure objects provide access to the test:
|
|
>>> failure.test is test
|
True
|
|
As well as to the example:
|
|
>>> failure.example.want
|
'2\n'
|
|
and the actual output:
|
|
>>> failure.got
|
'1\n'
|
|
If a failure or error occurs, the globals are left intact:
|
|
>>> del test.globs['__builtins__']
|
>>> test.globs
|
{'x': 1}
|
|
>>> test = DocTestParser().get_doctest('''
|
... >>> x = 2
|
... >>> raise KeyError
|
... ''', {}, 'foo', 'foo.py', 0)
|
|
>>> runner.run(test)
|
Traceback (most recent call last):
|
...
|
UnexpectedException: <DocTest foo from foo.py:0 (2 examples)>
|
|
>>> del test.globs['__builtins__']
|
>>> test.globs
|
{'x': 2}
|
|
But the globals are cleared if there is no error:
|
|
>>> test = DocTestParser().get_doctest('''
|
... >>> x = 2
|
... ''', {}, 'foo', 'foo.py', 0)
|
|
>>> runner.run(test)
|
TestResults(failed=0, attempted=1)
|
|
>>> test.globs
|
{}
|
|
c C s5 t j | | | | t } | r1 | j j n | S( N( R RM Rv R. RI ( Rk R R+ R RJ t r( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyRM í s c C s t | | | d S( N( R ( Rk R R R Rb ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR" ó s c C s t | | | d S( N( R ( Rk R R R Rz ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR! ö s N( R4 Rq R R+ Rx RM R" R! ( ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR s Y i c C s | d k r! t j j d } n t j | sF t d | f n | d k r^ | j } n t d | } | r t d | d | }
|
n t
|
d | d | }
|
x3 | j | | d | d | D] } |
|
j | q¿ W| ré |
|
j n t d k rþ |
|
a n t j |
|
t |
|
j |
|
j S( s*
|
m=None, name=None, globs=None, verbose=None, report=True,
|
optionflags=0, extraglobs=None, raise_on_error=False,
|
exclude_empty=False
|
|
Test examples in docstrings in functions and classes reachable
|
from module m (or the current module if m is not supplied), starting
|
with m.__doc__.
|
|
Also test examples reachable from dict m.__test__ if it exists and is
|
not None. m.__test__ 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 help(doctest) 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 "extraglobs" gives a dictionary that should be
|
merged into the globals that are used to execute examples. By
|
default, no extra globals are used. This is new in 2.4.
|
|
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 "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).
|
|
Optional keyword arg "optionflags" or's together module constants,
|
and defaults to 0. This is new in 2.3. Possible values (see the
|
docs for details):
|
|
DONT_ACCEPT_TRUE_FOR_1
|
DONT_ACCEPT_BLANKLINE
|
NORMALIZE_WHITESPACE
|
ELLIPSIS
|
SKIP
|
IGNORE_EXCEPTION_DETAIL
|
REPORT_UDIFF
|
REPORT_CDIFF
|
REPORT_NDIFF
|
REPORT_ONLY_FIRST_FAILURE
|
|
Optional keyword arg "raise_on_error" raises an exception on the
|
first unexpected exception or failure. This allows failures to be
|
post-mortem debugged.
|
|
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.
|
R s testmod: module required; %rRê Rç R R. Rõ N( R+ R= R> R* R5 R6 RA R4 R R R Rw RM RT t masterRV R# R R ( RÁ R' R. Rç t reportR Rõ t raise_on_errorRê t findert runnerR ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR s$ E % c C sl | r | r t d n t | | | \ } } | d k rU t j j | } n | d k rj i } n | j } | d k r | j | n d | k r« d | d <n | rÉ t d | d | } n t d | d | } | d k rü | j
|
| } n |
|
j | | | | d } | j | | r7| j n t d k rL| a n t j | t | j | j S( s
|
Test examples in the given file. Return (#failures, #tests).
|
|
Optional keyword arg "module_relative" specifies how filenames
|
should be interpreted:
|
|
- If "module_relative" is True (the default), then "filename"
|
specifies a module-relative path. By default, this path is
|
relative to the calling module's directory; but if the
|
"package" argument is specified, then it is relative to that
|
package. To ensure os-independence, "filename" should use
|
"/" characters to separate path segments, and should not
|
be an absolute path (i.e., it may not begin with "/").
|
|
- If "module_relative" is False, then "filename" specifies an
|
os-specific path. The path may be absolute or relative (to
|
the current working directory).
|
|
Optional keyword arg "name" gives the name of the test; by default
|
use the file's basename.
|
|
Optional keyword argument "package" is a Python package or the
|
name of a Python package whose directory should be used as the
|
base directory for a module relative filename. If no package is
|
specified, then the calling module's directory is used as the base
|
directory for module relative filenames. It is an error to
|
specify "package" if "module_relative" is False.
|
|
Optional keyword arg "globs" gives a dict to be used as the globals
|
when executing examples; by default, use {}. 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 "extraglobs" gives a dictionary that should be
|
merged into the globals that are used to execute examples. By
|
default, no extra globals are used.
|
|
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 "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).
|
|
Optional keyword arg "optionflags" or's together module constants,
|
and defaults to 0. Possible values (see the docs for details):
|
|
DONT_ACCEPT_TRUE_FOR_1
|
DONT_ACCEPT_BLANKLINE
|
NORMALIZE_WHITESPACE
|
ELLIPSIS
|
SKIP
|
IGNORE_EXCEPTION_DETAIL
|
REPORT_UDIFF
|
REPORT_CDIFF
|
REPORT_NDIFF
|
REPORT_ONLY_FIRST_FAILURE
|
|
Optional keyword arg "raise_on_error" raises an exception on the
|
first unexpected exception or failure. This allows failures to be
|
post-mortem debugged.
|
|
Optional keyword arg "parser" specifies a DocTestParser (or
|
subclass) that should be used to extract tests from the files.
|
|
Optional keyword arg "encoding" specifies an encoding that should
|
be used to convert the file to unicode.
|
|
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.
|
s8 Package may only be specified for module-relative paths.R4 R Rç R i N( R RS R+ RJ R t basenameR¬ Rñ R R t decodeRÄ RM RT Ri RV R# R R ( RN RP R' RO R. Rç Rj R Rõ Rk Rè RT t textRm R ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR j s2 R t NoNamec C sd t d | d t } t d | d | } x3 | j | | d | D] } | j | d | qC Wd S( sr
|
Test examples in the given object's docstring (`f`), using `globs`
|
as globals. Optional argument `name` is used in failure messages.
|
If the optional argument `verbose` is true, then generate output
|
even if there are no failures.
|
|
`compileflags` gives the set of flags that should be used by the
|
Python compiler when running the examples. If not specified, then
|
it will default to the set of future-import flags that apply to
|
`globs`.
|
|
Optional keyword arg `optionflags` specifies options for the
|
testing and output. See the documentation for `testmod` for more
|
information.
|
Rç Ré R R. R+ N( R Rv R Rw RM ( RR R. Rç R' R+ R Rl Rm R ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR ç s c B s_ e Z d d d d d Z d Z d d d Z d d Z d Z d d Z d Z RS( i c C sÊ t j d t d d | d k r= | d k r= t d n | d k ro t j | ro t d | f n | d k r | j } n | | _ | | _ | | _
|
t | _ t d | d | | _ d S( NsC class Tester is deprecated; use class doctest.DocTestRunner insteadt
|
stackleveli s* Tester.__init__: must specify mod or globss) Tester.__init__: mod must be a module; %rRç R ( t warningst warnt DeprecationWarningR+ RA R5 R6 Rð R. Rç R R t
|
testfinderR t
|
testrunner( Rk t modR. Rç R ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR s c C s| t j | | j | d d } | j r6 d G| GHn | j j | \ } } | j ro | Gd G| Gd G| GHn t | | S( Ns Running stringt ofs examples failed in string( R RÄ R. R+ Rç Rw RM R# ( Rk R[ R' R RR R8 ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt runstring s ! c
|
C sy d } } | j j | | d | d | j } x; | D]3 } | j j | \ } } | | | | } } q5 Wt | | S( Ni RB R. ( Rv Rw R. Rw RM R# (
|
Rk Rû R' RB RR R8 Rö R R9 R: ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt rundoc" s
|
c C sS d d l } | j | } | j j | | d k r@ t } n | j | | | S( Niÿÿÿÿ( t typest
|
ModuleTypeRð Rñ R+ Rv R{ ( Rk RU R' RB R| RÁ ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt rundict+ s c C s4 d d l } | j | } | | _ | j | | S( Niÿÿÿÿ( R| R} Rý R{ ( Rk RU R' R| RÁ ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt run__test__3 s c C s | j j | S( N( Rw RT ( Rk Rç ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyRT 9 s c C s | j j | j d S( N( Rw RV ( Rk R¤ ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyRV < s N(
|
R4 Rq R+ R Rz R{ R~ R RT RV ( ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR s c C s2 | t @| k r" t d | n t } | a | S( s? Sets the unittest option flags.
|
|
The old flag is returned so that a runner could restore the old
|
value if it wished to:
|
|
>>> import doctest
|
>>> old = doctest._unittest_reportflags
|
>>> doctest.set_unittest_reportflags(REPORT_NDIFF |
|
... REPORT_ONLY_FIRST_FAILURE) == old
|
True
|
|
>>> doctest._unittest_reportflags == (REPORT_NDIFF |
|
... REPORT_ONLY_FIRST_FAILURE)
|
True
|
|
Only reporting flags can be set:
|
|
>>> doctest.set_unittest_reportflags(ELLIPSIS)
|
Traceback (most recent call last):
|
...
|
ValueError: ('Only reporting flags allowed', 8)
|
|
>>> doctest.set_unittest_reportflags(old) == (REPORT_NDIFF |
|
... REPORT_ONLY_FIRST_FAILURE)
|
True
|
s Only reporting flags allowed( R R t _unittest_reportflags( R/ t old( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR E s
|
t DocTestCasec B s e Z d d d d d Z d Z d Z d Z d Z d Z d Z d Z
|
d Z d
|
Z d Z e Z d Z RS( i c C sA t j j | | | _ | | _ | | _ | | _ | | _ d S( N( t unittestt TestCaseR t _dt_optionflagst _dt_checkert _dt_testt _dt_setUpt _dt_tearDown( Rk R R t setUpt tearDownR ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR k s c C s, | j } | j d k r( | j | n d S( N( R R R+ ( Rk R ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR u s c C s9 | j } | j d k r( | j | n | j j d S( N( R R R+ R. RI ( Rk R ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR { s c C sÆ | j } t j } t } | j } | t @s; | t O} n t d | d | j d t } z5 d d | _
|
| j | d | j d t \ } } Wd | t _ X| r | j | j | j n d S( NR R Rç R
|
iF R RJ ( R R= R
R! R
R R R R Rv R$ RM RC t failureExceptiont format_failureRa ( Rk R R t newR Rm R R ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt runTest s
|
"
|
c C sj | j } | j d k r! d } n d | j } d j | j j d d } d | j | j | | | f S( Ns unknown line numbers %sRÆ iÿÿÿÿs: Failed doctest test for %s
|
File "%s", line %s, in %s
|
|
%s( R R R+ R R' Rs RN ( Rk t errR R t lname( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR s c C sO | j t d | j d | j d t } | j | j d t | j d S( sÊ Run the test case without results and without catching exceptions
|
|
The unit test framework includes a debug method on test cases
|
and test suites to support post-mortem debugging. The test code
|
is run in such a way that errors are not caught. This way a
|
caller can catch the errors and initiate post-mortem debugging.
|
|
The DocTestCase provides a debug method that raises
|
UnexpectedException errors if there is an unexpected
|
exception:
|
|
>>> test = DocTestParser().get_doctest('>>> raise KeyError\n42',
|
... {}, 'foo', 'foo.py', 0)
|
>>> case = DocTestCase(test)
|
>>> try:
|
... case.debug()
|
... except UnexpectedException, failure:
|
... pass
|
|
The UnexpectedException contains the test, the example, and
|
the original exception:
|
|
>>> failure.test is test
|
True
|
|
>>> failure.example.want
|
'42\n'
|
|
>>> exc_info = failure.exc_info
|
>>> raise exc_info[0], exc_info[1], exc_info[2]
|
Traceback (most recent call last):
|
...
|
KeyError
|
|
If the output doesn't match, then a DocTestFailure is raised:
|
|
>>> test = DocTestParser().get_doctest('''
|
... >>> x = 1
|
... >>> x
|
... 2
|
... ''', {}, 'foo', 'foo.py', 0)
|
>>> case = DocTestCase(test)
|
|
>>> try:
|
... case.debug()
|
... except DocTestFailure, failure:
|
... pass
|
|
DocTestFailure objects provide access to the test:
|
|
>>> failure.test is test
|
True
|
|
As well as to the example:
|
|
>>> failure.example.want
|
'2\n'
|
|
and the actual output:
|
|
>>> failure.got
|
'1\n'
|
|
R R Rç RJ N( R R R
R Rv RM R R ( Rk Rm ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR § s
|
B
|
c C s
|
| j j S( N( R R' ( Rk ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR¯ ï s c C st t | t | k r t S| j | j k os | j | j k os | j | j k os | j | j k os | j | j k S( N( R¢ R£ R R
R R R ( Rk R¤ ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR¥ ò s c C s | | k S( N( ( Rk R¤ ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR¦ ü s c C s" t | j | j | j | j f S( N( R§ R
R R R ( Rk ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR¨ ÿ s c C s4 | j j j d } d | d d j | d f S( NRÆ s %s (%s)iÿÿÿÿ( R R' Rs R ( Rk R' ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR s c C s d | j j S( Ns Doctest: ( R R' ( Rk ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt shortDescription s N( R4 Rq R+ R R R R R R R¯ R¥ R¦ R¨ R Rg R ( ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR i s H
|
t SkipDocTestCasec B s2 e Z d Z d Z d Z d Z e Z RS( c C s | | _ t j | d d S( N( RB R R R+ ( Rk RB ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR s c C s | j d d S( Ns- DocTestSuite will not work with -O2 and above( t skipTest( Rk ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR s c C s d S( N( ( Rk ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt test_skip s c C s d | j j S( Ns Skipping tests from %s( RB R4 ( Rk ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR s ( R4 Rq R R R R Rg ( ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR s
|
c K s* | d
|
k r t } n t | } | j | d | d | } | r{ t j j d k r{ t j } | j t
|
| | S| s t | d n | j t j } xz | D]r } t | j d k rÑ q° n | j s | j } | d d k r | d } n | | _ n | j t | | q° W| S( s
|
Convert doctest tests for a module to a unittest test suite.
|
|
This converts each documentation string in a module that
|
contains doctest tests to a unittest test case. If any of the
|
tests in a doc string fail, then the test case fails. An exception
|
is raised showing the name of the file containing the test and a
|
(sometimes approximate) line number.
|
|
The `module` argument provides the module to be tested. The argument
|
can be either a module or a module name.
|
|
If no argument is given, the calling module is used.
|
|
A number of options may be provided as keyword arguments:
|
|
setUp
|
A set-up function. This is called before running the
|
tests in each file. The setUp function will be passed a DocTest
|
object. The setUp function can access the test globals as the
|
globs attribute of the test passed.
|
|
tearDown
|
A tear-down function. This is called after running the
|
tests in each file. The tearDown function will be passed a DocTest
|
object. The tearDown function can access the test globals as the
|
globs attribute of the test passed.
|
|
globs
|
A dictionary containing initial global variables for the tests.
|
|
optionflags
|
A set of doctest option flags expressed as an integer.
|
R. Rõ i s has no docstringsi iüÿÿÿs .pycs .pyoiÿÿÿÿN( s .pycs .pyo( R+ R RD Rw R= R/ t optimizeR t TestSuitet addTestR R Ró R& Rª RN R R ( RB R. Rõ t test_finderR Rö t suiteR RN ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR s, %
|
t DocFileCasec B s) e Z d Z d Z e Z d Z RS( c C s d j | j j j d S( Nt _RÆ ( R R R' Rs ( Rk ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR¯ h s c C s
|
| j j S( N( R RN ( Rk ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR k s c C s d | j j | j j | f S( Ns2 Failed doctest test for %s
|
File "%s", line 0
|
|
%s( R R' RN ( Rk R ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR o s ( R4 Rq R¯ R Rg R ( ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR f s c
|
K sÆ | d k r i } n | j } | r= | r= t d n t | | | \ } } d | k rn | | d <n t j j | } | d k r | j | } n | j | | | | d } t | | S( Ns8 Package may only be specified for module-relative paths.R i (
|
R+ R¬ R RS RJ R Rn Ro RÄ R (
|
R RP RO R. Rè RT R t docR' R ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt DocFileTestt s c O se t j } | j d t r: t | j d | d <n x$ | D] } | j t | | qA W| S( s A unittest suite for one or more doctest files.
|
|
The path to each doctest file is given as a string; the
|
interpretation of that string depends on the keyword argument
|
"module_relative".
|
|
A number of options may be provided as keyword arguments:
|
|
module_relative
|
If "module_relative" is True, then the given file paths are
|
interpreted as os-independent module-relative paths. By
|
default, these paths are relative to the calling module's
|
directory; but if the "package" argument is specified, then
|
they are relative to that package. To ensure os-independence,
|
"filename" should use "/" characters to separate path
|
segments, and may not be an absolute path (i.e., it may not
|
begin with "/").
|
|
If "module_relative" is False, then the given file paths are
|
interpreted as os-specific paths. These paths may be absolute
|
or relative (to the current working directory).
|
|
package
|
A Python package or the name of a Python package whose directory
|
should be used as the base directory for module relative paths.
|
If "package" is not specified, then the calling module's
|
directory is used as the base directory for module relative
|
filenames. It is an error to specify "package" if
|
"module_relative" is False.
|
|
setUp
|
A set-up function. This is called before running the
|
tests in each file. The setUp function will be passed a DocTest
|
object. The setUp function can access the test globals as the
|
globs attribute of the test passed.
|
|
tearDown
|
A tear-down function. This is called after running the
|
tests in each file. The tearDown function will be passed a DocTest
|
object. The tearDown function can access the test globals as the
|
globs attribute of the test passed.
|
|
globs
|
A dictionary containing initial global variables for the tests.
|
|
optionflags
|
A set of doctest option flags expressed as an integer.
|
|
parser
|
A DocTestParser (or subclass) that should be used to extract
|
tests from the files.
|
|
encoding
|
An encoding that will be used to convert the files to unicode.
|
RP RO ( R R R* Rx RD R R ( t pathst kwR R ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR s 8 c C s( g } x½ t j | D]© } t | t r | j | j d | j } | r | j d | g | j d d D] } d | ^ qu 7} q q | g | j d d D] } t | ^ q© 7} q Wx$ | rì | d d k rì | j qÉ Wx' | r| d d k r| j d qð Wd j
|
| d S( sv Extract script from text with examples.
|
|
Converts text with examples to a Python script. Example input is
|
converted to regular code. Example output and all other words
|
are converted to comments:
|
|
>>> text = '''
|
... Here are examples of simple math.
|
...
|
... Python has super accurate integer addition
|
...
|
... >>> 2 + 2
|
... 5
|
...
|
... And very friendly error messages:
|
...
|
... >>> 1/0
|
... To Infinity
|
... And
|
... Beyond
|
...
|
... You can use logic if you want:
|
...
|
... >>> if 0:
|
... ... blah
|
... ... blah
|
... ...
|
...
|
... Ho hum
|
... '''
|
|
>>> print script_from_examples(text)
|
# Here are examples of simple math.
|
#
|
# Python has super accurate integer addition
|
#
|
2 + 2
|
# Expected:
|
## 5
|
#
|
# And very friendly error messages:
|
#
|
1/0
|
# Expected:
|
## To Infinity
|
## And
|
## Beyond
|
#
|
# You can use logic if you want:
|
#
|
if 0:
|
blah
|
blah
|
#
|
# Ho hum
|
<BLANKLINE>
|
iÿÿÿÿs # Expected:s
|
s ## R i ( R RÂ R7 R Rµ R Ry Rs R t popR ( R[ R¿ t pieceRy R¾ ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR Ú s : 4.c C s{ t | } t j | } g | D] } | j | k r% | ^ q% } | s^ t | d n | d } t | j } | S( s Extract the test sources from a doctest docstring as a script.
|
|
Provide the module (or dotted name of the module) containing the
|
test to be debugged and the name (within the module) of the object
|
with the doc string with tests to be debugged.
|
s not found in testsi ( RD R Rw R' R R R« ( RB R' Rö R8 R t testsrc( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR ,
|
s (
|
c C s t | } t | | | d S( s4 Debug a single doctest docstring, in argument `src`'N( R t debug_script( t srct pmR. R£ ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR <
|
s c C sÜ d d l } t j d d } t | d } | j | | j z | r\ | j } n i } | r¯ y t | | | WqÆ t j d GH| j
|
t j d qÆ Xn | j d | | | Wd t j | Xd S( s7 Debug a test script. `src` is the script, as a string.iÿÿÿÿNs .pyt doctestdebugR~ i i s execfile(%r)( R t tempfilet mktempRL RC t closeR¬ t execfileR= Rb t post_mortemRM RJ t remove( R¥ R¦ R. R t srcfilenameRR ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR¤ A
|
s"
|
c C s2 t | } t | | } t | | | j d S( så Debug a single doctest docstring.
|
|
Provide the module (or dotted name of the module) containing the
|
test to be debugged and the name (within the module) of the object
|
with the docstring with tests to be debugged.
|
N( RD R R¤ Rð ( RB R' R¦ R£ ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR a
|
s t
|
_TestClassc B s) e Z d Z d Z d Z d Z RS( så
|
A pointless class, for sanity-checking of docstring testing.
|
|
Methods:
|
square()
|
get()
|
|
>>> _TestClass(13).get() + _TestClass(-12).get()
|
1
|
>>> hex(_TestClass(13).square().get())
|
'0xa9'
|
c C s | | _ d S( s val -> _TestClass object with associated value val.
|
|
>>> t = _TestClass(123)
|
>>> print t.get()
|
123
|
N( R ( Rk R ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR }
|
s c C s | j d | _ | S( so square() -> square TestClass's associated value
|
|
>>> _TestClass(13).square().get()
|
169
|
i ( R ( Rk ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt square
|
s c C s | j S( s} get() -> return TestClass's associated value.
|
|
>>> x = _TestClass(-42)
|
>>> print x.get()
|
-42
|
( R ( Rk ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR*
|
s ( R4 Rq R R R° R* ( ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyR¯ o
|
s
|
|
sÄ
|
Example of a string object, searched as-is.
|
>>> x = 1; y = 2
|
>>> x + y, x * y
|
(3, 2)
|
R¼ sÜ
|
In 2.2, boolean expressions displayed
|
0 or 1. By default, we still accept
|
them. This can be disabled by passing
|
DONT_ACCEPT_TRUE_FOR_1 to the new
|
optionflags argument.
|
>>> 4 == 4
|
1
|
>>> 4 == 4
|
True
|
>>> 4 > 4
|
0
|
>>> 4 > 4
|
False
|
s bool-int equivalencesæ
|
Blank lines can be marked with <BLANKLINE>:
|
>>> print 'foo\n\nbar\n'
|
foo
|
<BLANKLINE>
|
bar
|
<BLANKLINE>
|
s blank linessó
|
If the ellipsis flag is used, then '...' can be used to
|
elide substrings in the desired output:
|
>>> print range(1000) #doctest: +ELLIPSIS
|
[0, 1, 2, ..., 999]
|
t ellipsiss|
|
If the whitespace normalization flag is used, then
|
differences in whitespace are ignored.
|
>>> print range(30) #doctest: +NORMALIZE_WHITESPACE
|
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
|
15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
|
27, 28, 29]
|
s whitespace normalizationc C s1 g t j d D]" } | r | d d k r | ^ q } | s t j j t j d } d t k r t j j | \ } } n d j | GHd Sx | D] } | j d rt j j | \ } } t j j
|
d | t | d } t j d =t | \ } } n t | d t \ } } | r d Sq Wd S(
|
Ni i R
|
RE s usage: {0} [-v] file ...i s .pyiýÿÿÿRP ( R= R RJ R Rn R; t splitextt formatRj Rs t insertR: R R Rv ( t argt testfilesR' R RN t dirnameRÁ R ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt _testÎ
|
s$ 6
|
R (V R t __docformat__t __all__R( R= R_ R5 Rî RJ RY R R\ R R¨ Rs R! t collectionsR" R# R$ R R R R R R R R R R R
|
R R RX Rr R2 RD RS R, t
|
__stdout__R+ RX R] Rg Rh R R R R RG R R R R R R t ExceptionR R R Ri Rx Rv R R R R R R R R R R R R R R R R R¤ R R¯ Rý R¸ R4 t exit( ( ( sO /tmp/ndk-User/buildhost/install/prebuilt/darwin-x86_64/lib/python2.7/doctest.pyt <module>. sê H0 1 $ $HLëÿ )ÿ °
n f z ? $£I I R ,
|
|
|
