def ic_testmod(m,
name=None,
globs=None,
verbose=None,
report=True,
optionflags=0,
extraglobs=None,
raise_on_error=False,
exclude_empty=False):
"""See original code in doctest.testmod."""
if name is None:
name = m.__name__
finder = DocTestFinder(exclude_empty=exclude_empty)
if raise_on_error:
runner = DebugRunner(checker=Py23DocChecker(),
verbose=verbose,
optionflags=optionflags)
else:
runner = DocTestRunner(checker=Py23DocChecker(),
verbose=verbose,
optionflags=optionflags)
for test in finder.find(m, name, globs=globs, extraglobs=extraglobs):
runner.run(test)
if report:
runner.summarize()
return doctest.TestResults(runner.failures, runner.tries)
def get_doc_test_cases_from_module(self, name):
mod = self.import_dotted_name(name)
finder = DocTestFinder()
tests = finder.find(mod)
doc_test_cases = []
for test in tests:
doc_test_cases.append(self.make_doc_test_case(test))
return doc_test_cases
def discover(module='__main__',
suite=None,
*,
doctest=doctest,
unittest=unittest,
loader=loader):
from doctest import DocTestCase, DocTestFinder
if isinstance(module, str):
module = __import__('importlib').import_module(module)
if suite is None:
return Sweet(module=module,
doctest=doctest,
unittest=unittest,
loader=loader)
for name, object in vars(module).items():
if getmodule(object) == module or module.__name__ == 'interactive':
if unittest:
if isinstance(object, type) and issubclass(object, TestCase):
suite.addTests(loader.loadTestsFromTestCase(object)._tests)
if callable(object) and not isinstance(object,
(partial, type)):
function_test_case = infer(object)
if function_test_case:
suite.addTest(function_test_case)
if doctest and hasattr(object, '__name__'):
suite.addTests(map(DocTestCase, DocTestFinder().find(object)))
return suite
def test_testil():
# nose test generator
import testil
from doctest import DocTestFinder, DocTestRunner
def run(test):
result = runner.run(test)
assert not result.failed, (
"%s of %s examples failed while testing %s"
% (result.failed, len(test.examples), test.name))
# Find, parse, and run all tests in this module.
finder = DocTestFinder()
runner = DocTestRunner()
for test in finder.find(testil, "testil"):
yield run, test
def tester(modules, runner, f=None):
'''Runs tests for each module.'''
results = []
for module in modules:
tests = DocTestFinder().find(module)
tests.sort(key=lambda test: test.name)
for test in tests:
if test.examples == []: # Skip empty tests
pass
else:
if f:
f.write('\n'.join(('-' * 80, test.name, '-' * 80, '\n')))
results.append(runner.run(test, out=f.write))
else:
print('\n'.join(('-' * 80, test.name, '-' * 80)))
results.append(runner.run(test))
return results
def make_full_suite():
from doctest import DocTestFinder, DocTestSuite
suite = unittest.TestSuite()
loader = unittest.TestLoader()
finder = DocTestFinder()
for modname in (__name__, "pylibmc", "_pylibmc"):
ss = (DocTestSuite(sys.modules[modname], test_finder=finder),
loader.loadTestsFromName(modname))
for subsuite in ss:
map(suite.addTest, subsuite._tests)
return suite
def __init__(self, verbose=False):
"""New decorator.
Parameters
----------
verbose : boolean, optional (False)
Passed to the doctest finder and runner to control verbosity.
"""
self.verbose = verbose
# We can reuse the same finder for all instances
self.finder = DocTestFinder(verbose=verbose, recurse=False)
def check_doctest(func_name, module, run=True):
"""Check that MODULE.FUNC_NAME doctest passes."""
func = getattr(module, func_name)
tests = DocTestFinder().find(func)
if not tests:
print("No doctests found for " + func_name)
return True
fn = lambda: DocTestRunner().run(tests[0])
result = test_eval(fn, tuple())
if result.failed != 0:
print("A doctest example failed for " + func_name + ".")
return True
return False
def check_doctest(func_name, module, run=True): # func_name是函数的名字，module是模块的名字
"""Check that MODULE.FUNC_NAME doctest passes."""
func = getattr(module, func_name) # 好吧，终于看到了这个玩意了。Java的反射机制是吧！
tests = DocTestFinder().find(func)
if not tests:
print("No doctests found for " + func_name)
return True
fn = lambda: DocTestRunner().run(tests[0]) # 一个匿名函数
result = test_eval(fn, tuple()) #
if result.failed != 0:
print("A doctest example failed for " + func_name + ".")
return True
return False
def tester(modules, runner):
"""Runs tests for each module."""
results = []
for module in modules:
try:
tests = DocTestFinder().find(module)
tests.sort(key=lambda test: test.name)
except ValueError:
tests = []
for test in tests:
if mock:
results.append(None)
elif test.examples == []: # Skip empty tests
pass
elif log != False:
f = log.handlers[0].stream
f.write('\n'.join(('-' * 80, test.name, '-' * 80, '\n')))
results.append(runner.run(test, out=f))
else:
print('\n'.join(('-' * 80, test.name, '-' * 80)))
results.append(runner.run(test))
return results
def __init__(cls, name, bases, dct):
super(DocMetaTestCase, cls).__init__(name, bases, dct)
module = dct['module']
globs = dct.get('globs', None)
extraglobs = dct.get('extraglobs', None)
if isinstance(module, basestring):
# transform a module name into a module
module = sys.modules[module]
for doctest in DocTestFinder(recurse=True).find(module,
name='test_doc',
globs=globs,
extraglobs=extraglobs):
cls.add_test(doctest)
def __init__(cls, name, bases, dct):
super(DocMetaTestCase, cls).__init__(name, bases, dct)
try:
module = dct['module']
except KeyError:
if dct.get('__test__', True) == False:
# This is some kind of abstract class. Do nothing.
return
else:
raise ValueError('No module was given for doctest search!')
globs = dct.get('globs', None)
extraglobs = dct.get('extraglobs', None)
if isinstance(module, basestring):
# transform a module name into a module
module = sys.modules[module]
for doctest in DocTestFinder(recurse=True).find(module, name='test_doc', globs=globs, extraglobs=extraglobs):
cls.add_test(doctest)
def check_doctests(modules=None, respect_skips=True, verbose=True):
"""Check whether doctests can be run as-is without errors.
Parameters
----------
modules : dict, optional
(module name -> module) mapping of submodules defined in a
package as returned by ``discover_modules()``. If omitted,
``discover_modules()`` will be called for ``pyvista``.
respect_skips : bool, optional
Whether to ignore doctest examples that contain a DOCTEST:+SKIP
directive.
verbose : bool, optional
Whether to print passes/failures as the testing progresses.
Failures are printed at the end in every case.
Returns
-------
failures : dict of (Exception, str) tuples
An (object name -> (exception raised, failing code)) mapping
of failed doctests under the specified modules.
"""
skip_pattern = re.compile('doctest: *\+SKIP')
if modules is None:
modules = discover_modules()
# find and parse all docstrings; this will also remove any duplicates
doctests = {
dt.name: dt
for module_name, module in modules.items()
for dt in DocTestFinder(recurse=True).find(module, globs={})
}
# loop over doctests in alphabetical order for sanity
sorted_names = sorted(doctests)
failures = {}
for dt_name in sorted_names:
dt = doctests[dt_name]
if not dt.examples:
continue
# mock print to suppress output from a few talkative tests
globs = {'print': (lambda *args, **kwargs:...)}
for iline, example in enumerate(dt.examples, start=1):
if (not example.source.strip() or
(respect_skips and skip_pattern.search(example.source))):
continue
try:
exec(example.source, globs)
except Exception as exc:
if verbose:
print(f'FAILED: {dt.name} -- {repr(exc)}')
erroring_code = ''.join(
[example.source for example in dt.examples[:iline]])
failures[dt_name] = exc, erroring_code
break
else:
if verbose:
print(f'PASSED: {dt.name}')
total = len(doctests)
fails = len(failures)
passes = total - fails
print(f'\n{passes} passes and {fails} failures '
f'out of {total} total doctests.\n')
if not fails:
return failures
print('List of failures:')
for name, (exc, erroring_code) in failures.items():
print('-' * 60)
print(f'{name}:')
print(indent(erroring_code, ' '))
print(repr(exc))
print('-' * 60)
return failures
else:
return want, got
def check_output(self, want, got, optionflags):
want, got = self.remove_u(want, got)
return super(Py23DocChecker, self).check_output(
want, got, optionflags)
def output_difference(self, example, got, optionflags):
example.want, got = self.remove_u(example.want, got)
return super(Py23DocChecker, self).output_difference(
example, got, optionflags)
global master
m = sys.modules.get('__main__')
finder = DocTestFinder()
runner = DocTestRunner(checker=Py23DocChecker())
for test in finder.find(m, m.__name__):
runner.run(test)
runner.summarize()
import sys
sys.exit()
# yapf: disable
class Cache(object):
def __init__(self):
self.cache = {}
def set(self, k, v, ttl):
self.cache[k] = v
else:
last_line_was_a_doc_test = True
def call_and_return_none_on_exception(func, *args, **kwargs):
try:
return func(*args, **kwargs)
except Exception:
return None
import inspect
from doctest import DocTestFinder
from inspect import signature, getfile, getcomments, getsource, getsourcelines, getdoc
doctest_finder = DocTestFinder(recurse=False)
def argnames(func):
return ' '.join(inspect.signature(func).parameters)
def tokenize_for_code(string):
camelcase_and_underscore_tokenizer(string)
_func_info_funcs = {
'func_name': lambda f: f.__qualname__,
'arg_names': argnames,
'comments': getcomments,
'doc': lambda f: '\n'.join(non_doctest_lines(getdoc(f))),
