-í ç ¶), 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=1" to testmod, or prohibit it by passing "verbose=0". In either of those cases, sys.argv is not examined by testmod. In any case, testmod returns a 2-tuple of ints (f, t), where f is the number of docstring examples that failed and t is the total number of docstring examples attempted. WHICH DOCSTRINGS ARE EXAMINED? + M.__doc__. + f.__doc__ for all functions f in M.__dict__.values(), except those with private names and those defined in other modules. + C.__doc__ for all classes C in M.__dict__.values(), except those with private names and those defined in other modules. + If M.__test__ exists and "is true", it must be a dict, and each entry maps a (string) name to a function object, class object, or string. Function and class object docstrings found from M.__test__ are searched even if the name is private, and strings are searched directly as if they were docstrings. In output, a key K in M.__test__ appears with name .__test__.K Any classes found are recursively searched similarly, to test docstrings in their contained methods and nested classes. Private names reached from M's globals are skipped, but all names reached from M.__test__ are searched. By default, a name is considered to be private if it begins with an underscore (like "_my_func") but doesn't both begin and end with (at least) two underscores (like "__init__"). You can change the default by passing your own "isprivate" function to testmod. If you want to test docstrings in objects with private names too, stuff them into an M.__test__ dict, or see ADVANCED USAGE below (e.g., pass your own isprivate function to Tester's constructor, or call the rundoc method of a Tester instance). WHAT'S THE EXECUTION CONTEXT? By default, each time testmod finds a docstring to test, it uses a *copy* of M's globals (so that running tests on a module doesn't change the module's real globals, and so that one test in M can't leave behind crumbs that accidentally allow another test to work). This means examples can freely use any names defined at top-level in M. It also means that sloppy imports (see above) can cause examples in external docstrings to use globals inappropriate for them. You can force use of your own dict as the execution context by passing "globs=your_dict" to testmod instead. Presumably this would be a copy of M.__dict__ merged with the globals from other imported modules. WHAT IF I WANT TO TEST A WHOLE PACKAGE? Piece o' cake, provided the modules do their testing from docstrings. Here's the test.py I use for the world's most elaborate Rational/ floating-base-conversion pkg (which I'll distribute some day): from Rational import Cvt from Rational import Format from Rational import machprec from Rational import Rat from Rational import Round from Rational import utils modules = (Cvt, Format, machprec, Rat, Round, utils) def _test(): import doctest import sys verbose = "-v" in sys.argv for mod in modules: doctest.testmod(mod, verbose=verbose, report=0) doctest.master.summarize() if __name__ == "__main__": _test() IOW, it just runs testmod on all the pkg modules. testmod remembers the names and outcomes (# of failures, # of tries) for each item it's seen, and passing "report=0" prevents it from printing a summary in verbose mode. Instead, the summary is delayed until all modules have been tested, and then "doctest.master.summarize()" forces the summary at the end. So this is very nice in practice: each module can be tested individually with almost no work beyond writing up docstring examples, and collections of modules can be tested too as a unit with no more work than the above. WHAT ABOUT EXCEPTIONS? No problem, as long as the only output generated by the example is the traceback itself. For example: >>> [1, 2, 3].remove(42) Traceback (most recent call last): File "", line 1, in ? ValueError: list.remove(x): x not in list >>> Note that only the exception type and value are compared (specifically, only the last line in the traceback). ADVANCED USAGE doctest.testmod() captures the testing policy I find most useful most often. You may want other policies. testmod() actually creates a local instance of class doctest.Tester, runs appropriate methods of that class, and merges the results into global Tester instance doctest.master. You can create your own instances of doctest.Tester, and so build your own policies, or even run methods of doctest.master directly. See doctest.Tester.__doc__ for details. SO WHAT DOES A DOCSTRING EXAMPLE LOOK LIKE ALREADY!? Oh ya. It's easy! In most cases a copy-and-paste of an interactive console session works fine -- just make sure the leading whitespace is rigidly consistent (you can mix tabs and spaces if you're too lazy to do it right, but doctest is not in the business of guessing what you think a tab means). >>> # comments are ignored >>> x = 12 >>> x 12 >>> if x == 13: ... print "yes" ... else: ... print "no" ... print "NO" ... print "NO!!!" ... no NO NO!!! >>> Any expected output must immediately follow the final ">>>" or "..." line containing the code, and the expected output (if any) extends to the next ">>>" or all-whitespace line. That's it. Bummers: + Expected output cannot contain an all-whitespace line, since such a line is taken to signal the end of expected output. + Output to stdout is captured, but not output to stderr (exception tracebacks are captured via a different means). + If you continue a line via backslashing in an interactive session, or for any other reason use a backslash, you need to double the backslash in the docstring version. This is simply because you're in a string, and so the backslash must be escaped for it to survive intact. Like: >>> if "yes" == \ ... "y" + \ ... "es": # in the source code you'll see the doubled backslashes ... print 'yes' yes The starting column doesn't matter: >>> assert "Easy!" >>> import math >>> math.floor(1.9) 1.0 and as many leading whitespace characters are stripped from the expected output as appeared in the initial ">>>" line that triggered it. If you execute this very file, the examples above will be found and executed, leading to this output in verbose mode: Running doctest.__doc__ Trying: [1, 2, 3].remove(42) Expecting: Traceback (most recent call last): File "", line 1, in ? ValueError: list.remove(x): x not in list ok Trying: x = 12 Expecting: nothing ok Trying: x Expecting: 12 ok Trying: if x == 13: print "yes" else: print "no" print "NO" print "NO!!!" Expecting: no NO NO!!! ok ... and a bunch more like that, with this summary at the end: 5 items had no tests: doctest.Tester.__init__ doctest.Tester.run__test__ doctest.Tester.summarize doctest.run_docstring_examples doctest.testmod 12 items passed all tests: 8 tests in doctest 6 tests in doctest.Tester 10 tests in doctest.Tester.merge 14 tests in doctest.Tester.rundict 3 tests in doctest.Tester.rundoc 3 tests in doctest.Tester.runstring 2 tests in doctest.__test__._TestClass 2 tests in doctest.__test__._TestClass.__init__ 2 tests in doctest.__test__._TestClass.get 1 tests in doctest.__test__._TestClass.square 2 tests in doctest.__test__.string 7 tests in doctest.is_private 60 tests in 17 items. 60 passed and 0 failed. Test passed. stestmodsrun_docstring_exampless is_privatesTesterNs>>>s...s(\s*)s\s*$s\s*#(s StringTypes(sisclass(s isfunction(sismodule(sclassify_class_attrscsættf\}}ttf\} }g}|i dƒ}dt |ƒf\}} xŠ|| jo|||}|d}||ƒ} | tjoqTn| idƒ} | || ƒp ||| ƒoqTn|d}|| djo%td| dtd|ƒ‚n| d} | idƒ}t |ƒ}g} x|dot| i|| ƒ||}||ƒ} | oA| idƒ|jotd| d |ƒ‚n|d}nPq9Wt | ƒdjo| d} n0| d d jo | d =ndi| ƒd} ||ƒp | |ƒo d }n›g}x~dov|| |jotd| d |ƒ‚n|i||ƒ|d}||}||ƒp | |ƒoPnq2Wdi|ƒd}|i| ||fƒqTW|SdS( Ns iis sline s of docstring lacks blank after s: s(inconsistent leading whitespace in line s of docstring: iÿÿÿÿs(s_isPS1s_isPS2sisPS1sisPS2s_isEmptys _isCommentsisEmptys isCommentsexamplesssssplitslinesslensisnslinesmsNonesendsjslinenos ValueErrorsPS1sgroupsblankssnblanksssourcesappendsjoinsexpect(sssblankss isCommentslinessexpectsisPS1sisPS2slinesisjsmsnssourcesisEmptyslinenosnblankssexamples((s/usr/lib/python2.2/doctest.pys_extract_examples3sh       %         s _SpoofOutcs5tZd„Zd„Zd„Zd„Zd„ZRS(Ncs|iƒdS(N(sselfsclear(sself((s/usr/lib/python2.2/doctest.pys__init__sscs|ii|ƒdS(N(sselfsbufsappendss(sselfss((s/usr/lib/python2.2/doctest.pyswriteuscsZdi|iƒ}|o|idƒ o|d}nt|dƒo |`n|SdS(Nss s softspace(sjoinsselfsbufsgutssendswithshasattrs softspace(sselfsguts((s/usr/lib/python2.2/doctest.pysgetws  cs'g|_t|dƒo |`ndS(Ns softspace(sselfsbufshasattrs softspace(sself((s/usr/lib/python2.2/doctest.pysclearƒs csdS(N((sself((s/usr/lib/python2.2/doctest.pysflush‡s(s__name__s __module__s__init__swritesgetsclearsflush(((s/usr/lib/python2.2/doctest.pys _SpoofOutrs    cs¼xµ|D]­\}}||dƒ|ddj}|o|idƒt|ƒdj}t|ƒt|ƒdjo| o|dƒn |dƒ||ƒ| o|dƒnqWdS(Ns:iÿÿÿÿs iiLs (s tag_msg_pairsstagsmsgsprinters msg_has_nlsfindslensmsg_has_two_nl(sprinters tag_msg_pairssmsg_has_two_nlsmsgstags msg_has_nl((s/usr/lib/python2.2/doctest.pys_tag_outŽs &%  csLdk}dk}edƒ\} }} d}eƒ}d}xù|D]ñ\}} }|o'e|d|fd| p|fƒn|iƒy0e|dd|dƒ|U|iƒ} | }Wn | id ƒdjp| id ƒdjoM| id ƒd d } |iƒd \} }|i| |ƒd} | }n!|iƒ|id|ƒ|}nX|| jo3| | jo|o|dƒnqCn| }n|d}|ddd ƒe|d|fƒ|d| d|d ƒ|| jo'e|d| p|fd| fƒne|d|iƒfƒqCW|e!|ƒfSdS(NisnothingisTryings ExpectingsssingleisTraceback (innermost last): s#Traceback (most recent call last): s iþÿÿÿiiÿÿÿÿsfilesok s*iAsFailure in examples from line #s of sExpectedsGotsException raised("ssyss tracebacksrangesOKsBOOMsFAILsNADAs _SpoofOutsstderrsfailuressexamplesssourceswantslinenosverboses_tag_outsoutsfakeoutsclearscompiles compileflagssglobssgetsgotsstatesfindssplitsexc_infosexc_typesexc_valsformat_exception_onlys print_excsnameslen(soutsfakeoutsexamplessglobssverbosesnames compileflagssNADAssysswantsgotsFAILsexc_typesOKs tracebacksstatessourceslinenosstderrsfailuressexc_valsBOOM((s/usr/lib/python2.2/doctest.pys_run_examples_inner sR     ,        'cs[d}xJtiD]?}|i|tƒ}|tt|ƒjo||i O}nqW|SdS(Ni( sflagss __future__sall_feature_namessfnamesglobssgetsNonesfeaturesgetattrs compiler_flag(sglobssflagssfnamesfeature((s/usr/lib/python2.2/doctest.pys_extract_future_flagsØs c srdk}|i}|iƒ}z5tƒ|_}t|i||||||ƒ}Wd||_|iƒX|SdS(N(ssyssstdoutssaveoutsglobsscopys _SpoofOutsfakeouts_run_examples_innerswritesexamplessverbosesnames compileflagssxsclear( sexamplessglobssverbosesnames compileflagsssyssfakeoutsxssaveout((s/usr/lib/python2.2/doctest.pys _run_examplesãs    isNoNamecsœy/|i}| oddfSnt|ƒ}WnddfSnXt|ƒ}| oddfSn|tjot|ƒ}nt |||||ƒSdS(s'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. iN( sfs__doc__sdocsstrs_extract_examplesses compileflagssNones_extract_future_flagssglobss _run_examplessverbosesname(sfsglobssverbosesnames compileflagssesdoc((s/usr/lib/python2.2/doctest.pysrun_docstring_examplesøs    cs9|d djo$|d djo|djn SdS(sÅ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 is_is__iþÿÿÿN(sbase(sprefixsbase((s/usr/lib/python2.2/doctest.pys is_privatescsRt|ƒo|i|ijSnt|ƒo|i|ijSntdƒ‚dS(Ns"object must be a class or function( s _isfunctionsobjectsmodules__dict__s func_globalss_isclasss__name__s __module__s ValueError(smodulesobject((s/usr/lib/python2.2/doctest.pys _from_module3s   csttZdZeeeed„Zd„Zed„Zed„Zd„Zed„Z d„Z d„Z d „Z RS( s@Class Tester -- runs docstring examples and accumulates stats. In normal use, function doctest.testmod() hides all this from you, so use that if you can. Create your own instances of Tester to do fancier things. Methods: runstring(s, name) Search string s for examples to run; use name for logging. Return (#failures, #tries). rundoc(object, name=None) Search object.__doc__ for examples to run; use name (or object.__name__) for logging. Return (#failures, #tries). rundict(d, name, module=None) Search for examples in docstrings in all of d.values(); use name for logging. Exclude functions and classes not defined in module if specified. Return (#failures, #tries). run__test__(d, name) Treat dict d like module.__test__. Return (#failures, #tries). summarize(verbose=None) Display summary of testing results, to stdout. Return (#failures, #tries). merge(other) Merge in the test results from Tester instance "other". >>> from doctest import Tester >>> t = Tester(globs={'x': 42}, verbose=0) >>> t.runstring(r''' ... >>> x = x * 2 ... >>> print x ... 42 ... ''', 'XYZ') ***************************************************************** Failure in example: print x from line #2 of XYZ Expected: 42 Got: 84 (1, 2) >>> t.runstring(">>> x = x * 2\n>>> print x\n84\n", 'example2') (0, 2) >>> t.summarize() ***************************************************************** 1 items had failures: 1 of 2 in XYZ ***Test Failed*** 1 failures. (1, 4) >>> t.summarize(verbose=1) 1 items passed all tests: 2 tests in example2 ***************************************************************** 1 items had failures: 1 of 2 in XYZ 4 tests in 2 items. 3 passed and 1 failed. ***Test Failed*** 1 failures. (1, 4) >>> csë|tjo |tjotdƒ‚n|tj o t|ƒ otd| ƒ‚n|tjo |i}n||_|tjodk}d|i j}n||_|tjo t }n||_ h|_ t |ƒ|_dS(sçmod=None, globs=None, verbose=None, isprivate=None See doctest.__doc__ for an overview. Optional keyword arg "mod" is a module, whose globals are used for executing examples. If not specified, globs must be specified. Optional keyword arg "globs" gives a dict to be used as the globals when executing examples; if not specified, use the globals from module mod. In either case, a copy of the dict is used for each docstring examined. 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 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. s*Tester.__init__: must specify mod or globss'Tester.__init__: mod must be a module; Ns-v(smodsNonesglobss TypeErrors _ismodules__dict__sselfsverbosessyssargvs isprivates is_privatesname2fts_extract_future_flagss compileflags(sselfsmodsglobssverboses isprivatessys((s/usr/lib/python2.2/doctest.pys__init__{s"          cs£|io dG|GHnd}}t|ƒ}|o+t||i |i||i ƒ\}}n|io|GdG|GdG|GHn|i |||ƒ||fSdS(si s, name -> search string s for examples to run, logging as name. Use string name as the key for logging the outcome. Return (#failures, #examples). >>> t = Tester(globs={}, verbose=1) >>> test = r''' ... # just an example ... >>> x = 1 + 2 ... >>> x ... 3 ... ''' >>> t.runstring(test, "Example") Running string Example Trying: x = 1 + 2 Expecting: nothing ok Trying: x Expecting: 3 ok 0 of 2 examples failed in string Example (0, 2) sRunning stringisofsexamples failed in stringN( sselfsverbosesnamesfsts_extract_examplesssses _run_examplessglobss compileflagss_Tester__record_outcome(sselfsssnamesestsf((s/usr/lib/python2.2/doctest.pys runstring©s     c s=|tjo8y |i}Wn$tj otd| ƒ‚nXn|iodG|dGHnt||i |i||i ƒ\}} |io|GdG| GdG|dGHn|i ||| ƒt|ƒoah}x(t|ƒD]\} }}}||j oqánõ|i|| ƒoqánÛ|djo||| search object.__doc__ for examples to run. Use optional string name as the key for logging the outcome; by default use object.__name__. Return (#failures, #examples). If object is a class object, search recursively for method docstrings too. object.__doc__ is examined regardless of name, but if object is a class, whether private names reached from object are searched depends on the constructor's "isprivate" argument. >>> t = Tester(globs={}, verbose=0) >>> def _f(): ... '''Trivial docstring example. ... >>> assert 2 == 2 ... ''' ... return 32 ... >>> t.rundoc(_f) # expect 0 failures in 1 example (0, 1) sFTester.rundoc: name must be given when object.__name__ doesn't exist; sRunnings.__doc__sofsexamples failed insmethods static methods class methodspropertysdatasteach doctest about %rN(snamesNonesobjects__name__sAttributeErrors ValueErrorsselfsverbosesrun_docstring_examplessglobss compileflagssfsts_Tester__record_outcomes_isclasssds_classify_class_attrsstagskindshomeclssvalues isprivatesgetattrsim_funcs__doc__sstrs run__test__sf2st2( sselfsobjectsnameshomeclssdsfst2skindsvaluesf2stagst((s/usr/lib/python2.2/doctest.pysrundocÏsL              c sàt|dƒ otd| ƒ‚nd}}|iƒ} | iƒx‰| D]} || }t |ƒp t |ƒoW|ot ||ƒ oqMn|i||d| ƒ\}}||}||}nqMW||fSdS(sò d, name, module=None -> search for docstring examples in d.values(). For k, v in d.items() such that v is a function or class, do self.rundoc(v, name + "." + k). Whether this includes objects with private names depends on the constructor's "isprivate" argument. If module is specified, functions and classes that are not defined in module are excluded. Return aggregate (#failures, #examples). Build and populate two modules with sample functions to test that exclusion of external functions and classes works. >>> import new >>> m1 = new.module('_m1') >>> m2 = new.module('_m2') >>> test_data = """ ... def _f(): ... '''>>> assert 1 == 1 ... ''' ... def g(): ... '''>>> assert 2 != 1 ... ''' ... class H: ... '''>>> assert 2 > 1 ... ''' ... def bar(self): ... '''>>> assert 1 < 2 ... ''' ... """ >>> exec test_data in m1.__dict__ >>> exec test_data in m2.__dict__ >>> m1.__dict__.update({"f2": m2._f, "g2": m2.g, "h2": m2.H}) Tests that objects outside m1 are excluded: >>> t = Tester(globs={}, verbose=0) >>> t.rundict(m1.__dict__, "rundict_test", m1) # _f, f2 and g2 and h2 skipped (0, 3) Again, but with a custom isprivate function allowing _f: >>> t = Tester(globs={}, verbose=0, isprivate=lambda x,y: 0) >>> t.rundict(m1.__dict__, "rundict_test_pvt", m1) # Only f2, g2 and h2 skipped (0, 4) And once more, not excluding stuff outside m1: >>> t = Tester(globs={}, verbose=0, isprivate=lambda x,y: 0) >>> t.rundict(m1.__dict__, "rundict_test_pvt") # None are skipped. (0, 8) The exclusion of objects from outside the designated module is meant to be invoked automagically by testmod. >>> testmod(m1) (0, 3) sitemss)Tester.rundict: d must support .items(); is.N(shasattrsds TypeErrorsfstskeyssnamesssortsthisnamesvalues _isfunctions_isclasssmodules _from_modulesselfs_Tester__runonesnamesf2st2( sselfsdsnamesmodulesf2sfst2svalueststhisnamesnames((s/usr/lib/python2.2/doctest.pysrundict$s ;      c s d} }|d}|i}zÕd„|_|iƒ}|i ƒx¬|D]¤} || } || } t | ƒtjo|i| | ƒ\}}nHt| ƒp t| ƒo|i| | ƒ\}}ntd| ƒ‚| |} ||}qIWWd||_X| |fSdS(s„d, name -> Treat dict d like module.__test__. Return (#failures, #tries). See testmod.__doc__ for details. is.csdS(Ni((sargs((s/usr/lib/python2.2/doctest.pys~ssJTester.run__test__: values in dict must be strings, functions or classes; N(sfailuresstriessnamesprefixsselfs isprivatessavepvtsdskeysssortsksvsthisnamestypes _StringTypess runstringsfsts _isfunctions_isclasssrundocs TypeError( sselfsdsnamessavepvtskeyssfsprefixstriesstsvsfailuressthisnamesk((s/usr/lib/python2.2/doctest.pys run__test__ss,          c s$|tjo |i}ng} g}g}d}} xŒ|ii ƒD]{} | \} \}}||}| |} |djo| i| ƒn2|djo|i| |fƒn|i| ƒqFW|oŒ| o7t| ƒGdGH| iƒx| D]}dG|GHqóWn|oCt|ƒGdGH|iƒx#|D]\}}d||fGHq1Wnn|oUddGHt|ƒGdGH|iƒx,|D]$\}\}}d |||fGHqˆWn|o3|Gd Gt|iƒGd GH|| Gd G| Gd GHn| odG| GdGHn|o dGHn| |fSdS(s verbose=None -> summarize results, return (#failures, #tests). Print summary of test results to stdout. Optional arg 'verbose' controls how wordy this is. By default, use the verbose setting established by the constructor. isitems had no tests:s sitems passed all tests:s %3d tests in %ss*iAsitems had failures:s %3d of %3d in %sstests insitems.s passed andsfailed.s***Test Failed***s failures.s Test passed.N(sverbosesNonesselfsnotestsspassedsfailedstotaltstotalfsname2ftsitemssxsnamesfstsappendslenssortsthingscount( sselfsverbosesthingscountsfstotaltsfailedstspassedsxstotalfsnotestssname((s/usr/lib/python2.2/doctest.pys summarize”s\             csˆ|i}xx|iiƒD]g\}\}}|i|ƒo5d|dGH||\}}||}||}n||f|| merge in test results from the other Tester instance. If self and other both have a test result for something with the same name, the (#failures, #tests) results are summed, and a warning is printed to stdout. >>> from doctest import Tester >>> t1 = Tester(globs={}, verbose=0) >>> t1.runstring(''' ... >>> x = 12 ... >>> print x ... 12 ... ''', "t1example") (0, 2) >>> >>> t2 = Tester(globs={}, verbose=0) >>> t2.runstring(''' ... >>> x = 13 ... >>> print x ... 13 ... ''', "t2example") (0, 2) >>> common = ">>> assert 1 + 2 == 3\n" >>> t1.runstring(common, "common") (0, 1) >>> t2.runstring(common, "common") (0, 1) >>> t1.merge(t2) *** Tester.merge: 'common' in both testers; summing outcomes. >>> t1.summarize(1) 3 items passed all tests: 2 tests in common 2 tests in t1example 2 tests in t2example 6 tests in 3 items. 6 passed and 0 failed. Test passed. (0, 6) >>> s*** Tester.merge: 's$' in both testers; summing outcomes.N( sselfsname2ftsdsothersitemssnamesfstshas_keysf2st2(sselfsothersf2stsnamesfst2sd((s/usr/lib/python2.2/doctest.pysmergeÉs)   csf|ii|ƒo<d|dGdGH|i|\}}||}||}n||f|i|>> _TestClass(13).get() + _TestClass(-12).get() 1 >>> hex(_TestClass(13).square().get()) '0xa9' cs ||_dS(sƒval -> _TestClass object with associated value val. >>> t = _TestClass(123) >>> print t.get() 123 N(svalsself(sselfsval((s/usr/lib/python2.2/doctest.pys__init__iscs|id|_|SdS(sosquare() -> square TestClass's associated value >>> _TestClass(13).square().get() 169 iN(sselfsval(sself((s/usr/lib/python2.2/doctest.pyssquaresscs |iSdS(s}get() -> return TestClass's associated value. >>> x = _TestClass(-42) >>> print x.get() -42 N(sselfsval(sself((s/usr/lib/python2.2/doctest.pysget}s(s__name__s __module__s__doc__s__init__ssquaresget(((s/usr/lib/python2.2/doctest.pys _TestClass[s  sÄ Example of a string object, searched as-is. >>> x = 1; y = 2 >>> x + y, x * y (3, 2) sstringcsdk}|i|ƒSdS(N(sdocteststestmod(sdoctest((s/usr/lib/python2.2/doctest.pys_tests s__main__(*s__doc__s__all__s __future__sresPS1sPS2scompilesescapesmatchs_isPS1s_isPS2s_isEmptys _isCommentstypess StringTypess _StringTypessinspectsisclasss_isclasss isfunctions _isfunctionsismodules _ismodulesclassify_class_attrss_classify_class_attrss_extract_exampless _SpoofOuts_tag_outs_run_examples_inners_extract_future_flagss _run_examplessNonesrun_docstring_exampless is_privates _from_modulesTestersmasterstestmods _TestClasss__test__s_tests__name__(s_run_examples_inners __future__s _StringTypess_tag_outsrun_docstring_exampless_tests _SpoofOutstestmodsPS2s__test__s_extract_future_flagss _isComments_isEmptysPS1s _from_modules _ismodules _isfunctions _TestClasss_isclasss__all__sresTesters _run_exampless is_privates_extract_exampless_isPS2s_isPS1s_classify_class_attrs((s/usr/lib/python2.2/doctest.pys?sB       ?  8   ÿØH,