def main(): try: doctest.register_optionflag except: print( "\n" "The regression test suite requires a more recent version of\n" "doctest (e.g., the version that ships with Python 2.4 or 2.5).\n" "Please place a new version of doctest on your path before \n" "running the test suite.\n") return PY24 = doctest.register_optionflag('PYTHON2.4') """Flag indicating that a doctest example requires Python 2.4+""" PY25 = doctest.register_optionflag('PYTHON2.5') """Flag indicating that a doctest example requires Python 2.5+""" class DocTestParser(doctest.DocTestParser): """ Custom doctest parser that adds support for two new flags +PYTHON2.4 and +PYTHON2.5. """ def parse(self, string, name='<string>'): pieces = doctest.DocTestParser.parse(self, string, name) for i, val in enumerate(pieces): if (isinstance(val, doctest.Example) and ((val.options.get(PY24, False) and sys.version[:2] < (2, 4)) or (val.options.get(PY25, False) and sys.version[:2] < (2, 5)))): pieces[i] = doctest.Example('1', '1') return pieces # Turn on debugging. epydoc.DEBUG = True # Options for doctest: options = doctest.ELLIPSIS doctest.set_unittest_reportflags(doctest.REPORT_UDIFF) # Use a custom parser parser = DocTestParser() # Find all test cases. tests = [] testdir = os.path.join(os.path.split(__file__)[0]) if testdir == '': testdir = '.' for filename in os.listdir(testdir): if (filename.endswith('.doctest') and check_requirements(os.path.join(testdir, filename))): tests.append( doctest.DocFileSuite(filename, optionflags=options, parser=parser)) # Run all test cases. unittest.TextTestRunner(verbosity=2).run(unittest.TestSuite(tests))
def main(): try: doctest.register_optionflag except: print ("\n" "The regression test suite requires a more recent version of\n" "doctest (e.g., the version that ships with Python 2.4 or 2.5).\n" "Please place a new version of doctest on your path before \n" "running the test suite.\n") return PY24 = doctest.register_optionflag('PYTHON2.4') """Flag indicating that a doctest example requires Python 2.4+""" PY25 = doctest.register_optionflag('PYTHON2.5') """Flag indicating that a doctest example requires Python 2.5+""" class DocTestParser(doctest.DocTestParser): """ Custom doctest parser that adds support for two new flags +PYTHON2.4 and +PYTHON2.5. """ def parse(self, string, name='<string>'): pieces = doctest.DocTestParser.parse(self, string, name) for i, val in enumerate(pieces): if (isinstance(val, doctest.Example) and ((val.options.get(PY24, False) and sys.version[:2] < (2,4)) or (val.options.get(PY25, False) and sys.version[:2] < (2,5)))): pieces[i] = doctest.Example('1', '1') return pieces # Turn on debugging. epydoc.DEBUG = True # Options for doctest: options = doctest.ELLIPSIS doctest.set_unittest_reportflags(doctest.REPORT_UDIFF) # Use a custom parser parser = DocTestParser() # Find all test cases. tests = [] testdir = os.path.join(os.path.split(__file__)[0]) if testdir == '': testdir = '.' for filename in os.listdir(testdir): if (filename.endswith('.doctest') and check_requirements(os.path.join(testdir, filename))): tests.append(doctest.DocFileSuite(filename, optionflags=options, parser=parser)) # Run all test cases. unittest.TextTestRunner(verbosity=2).run(unittest.TestSuite(tests))
def _get_allow_unicode_flag(): """ Registers and returns the ALLOW_UNICODE flag. """ import doctest return doctest.register_optionflag("ALLOW_UNICODE")
def _get_allow_unicode_flag() -> int: """ Registers and returns the ALLOW_UNICODE flag. """ import doctest return doctest.register_optionflag("ALLOW_UNICODE")
def _get_allow_bytes_flag() -> int: """ Registers and returns the ALLOW_BYTES flag. """ import doctest return doctest.register_optionflag("ALLOW_BYTES")
def _get_number_flag() -> int: """ Registers and returns the NUMBER flag. """ import doctest return doctest.register_optionflag("NUMBER")
def _get_allow_bytes_flag(): """ Registers and returns the ALLOW_BYTES flag. """ import doctest return doctest.register_optionflag("ALLOW_BYTES")
def check_multi_rank_docstr(module): # supply customized flag ONLY_CHECK_RANK_{x} for docstr check_flags = [ doctest.register_optionflag(f"ONLY_CHECK_RANK_{i}") for i in range(oneflow.env.get_world_size()) ] finder = doctest.DocTestFinder() runner = doctest.DebugRunner(CondSkipChecker(check_flags)) for test in finder.find(module, module.__name__): runner.run(test)
def run(testObject, name_space=None): """ Runs this doc test executor with the given test object in the given namespace. @param testObject: object to test. If this is a string, it is run as is; otherwise, its C{__doc__} attribute is used @type testObject: string or an arbitrary object with a C{__doc__} attribute @param name_space: namespace to execute the test in (defaults to the C{__main__} module) @type name_space: dictionary mapping names (strings) to arbitrary objects @note: when passing in a custom L{name_space} argument, beware that the doctest runner also inserts the C{__builtin__} module into your namespace """ # Register our special IGNORE_TRAILING_WHITESPACE option. flag = doctest.register_optionflag('IGNORE_TRAILING_WHITESPACE') # Set up a doc tester with our special dict. custom_name_space = _DocTestExecutor._NonCopyableNonClearableDict() finder = doctest.DocTestFinder() if isinstance(testObject, basestring): name = 'doctest' else: name = testObject.__name__ tests = finder.find(testObject, name=name, globs=custom_name_space) checker = \ _DocTestExecutor._TrailingWhitespaceInsensitiveOutputChecker(flag) tester = doctest.DocTestRunner(checker=checker, verbose=False) for test in tests: # Run the doc test(s). tester.run(test) # Now, update our name space with our newly created variables for # further interactive use (but *only* with those to avoid overwriting # things, e.g. default instances!). if name_space is None: name_space = sys.modules['__main__'].__dict__ for key, value in custom_name_space.items(): if not key in name_space: name_space[key] = value
def init_precisions(precisions): """ Register flags for given precisions with doctest module. Unfortunately, doctest doesn't seem to support a more generic mechanism such as "# doctest: +NUMERIC: 6" to specify the precision and we need to unroll each precision we want to its own flag. """ global NUMERIC_LIST global NUMERIC_DICT global ALL_NUMERIC for precision in precisions: # Check key such that clients having demand for different # precisions could register them. if precision not in NUMERIC_DICT: flag = doctest.register_optionflag('NUMERIC%d' % precision) NUMERIC_LIST.append((precision, flag)) NUMERIC_DICT[precision] = flag ALL_NUMERIC |= flag
def setup(app): """Add an "IGNORE_RESULT" doctest optionflag to sphinx.ext.doctest Any output following the flag will be ignored. This can be used when the result of a method call is not relevant to the doctest or code example:: >>> p = pathlib.Path('somefile.txt') >>> # `write_text` returns the number of bytes written, but we don't care >>> p.write_text('foo') 3 >>> # Ignore it to make the code example cleaner >>> p.write_text('foo') #doctest: +IGNORE_RESULT """ app.setup_extension('sphinx.ext.doctest') import doctest from sphinx.ext import doctest as sphinx_doctest _SphinxDocTestRunner_orig = sphinx_doctest.SphinxDocTestRunner sphinx_doctest._SphinxDocTestRunner_orig = _SphinxDocTestRunner_orig IGNORE_RESULT = doctest.register_optionflag('IGNORE_RESULT') class IgnoreOutputChecker(doctest.OutputChecker): def check_output(self, want, got, optionflags): if optionflags & IGNORE_RESULT: return True return super().check_output(want, got, optionflags) class MyRunner(_SphinxDocTestRunner_orig): def __init__(self, checker=None, verbose=None, optionflags=0): checker = IgnoreOutputChecker() super().__init__(checker, verbose, optionflags) sphinx_doctest.SphinxDocTestRunner = MyRunner return { 'version': '0.1', 'parallel_read_safe': True, 'parallel_write_safe': True, }
def register_skipper(flag, test, why, skipWarning=True): """Create a new doctest option flag for skipping tests Parameters ---------- flag : str Name of the option flag test : function A function which should return `True` if the test should be run why : str Explanation for why the test was skipped (to be used in a string "``Skipped %%(count)d doctest examples because %%(why)s``") skipWarning : bool Whether or not to report on tests skipped by this flag (default `True`) """ global _doctestSkippers skipper = _DoctestSkipper(flag=doctest.register_optionflag(flag), test=test, why=why, skipWarning=skipWarning) _doctestSkippers.append(skipper)
Implements a replacement for `doctest.OutputChecker` that handles certain normalizations of Python expression output. See the docstring on `AstropyOutputChecker` for more details. """ from __future__ import (absolute_import, division, print_function, unicode_literals) import doctest import re # Much of this code, particularly the parts of floating point handling, is # borrowed from the SymPy project with permission. See licenses/SYMPY.rst # for the full SymPy license. FIX = doctest.register_optionflag('FIX') FLOAT_CMP = doctest.register_optionflag('FLOAT_CMP') class AstropyOutputChecker(doctest.OutputChecker): """ - Removes u'' prefixes on string literals - Ignores the 'L' suffix on long integers - In Numpy dtype strings, removes the leading pipe, i.e. '|S9' -> 'S9'. Numpy 1.7 no longer includes it in display. - Supports the FLOAT_CMP flag, which parses floating point values out of the output and compares their numerical values rather than their string representation. This naturally supports complex numbers as well (simply by comparing their real and imaginary parts separately). """
a space character, then raise ValueError. Note: IPython-modified version which takes the input prompt length as a parameter, so that prompts of variable length can be dealt with. """ space_idx = indent+ps1_len min_len = space_idx+1 for i, line in enumerate(lines): if len(line) >= min_len and line[space_idx] != ' ': raise ValueError('line %r of the docstring for %s ' 'lacks blank after %s: %r' % (lineno+i+1, name, line[indent:space_idx], line)) SKIP = doctest.register_optionflag('SKIP') class IPDocTestRunner(doctest.DocTestRunner,object): """Test runner that synchronizes the IPython namespace with test globals. """ def run(self, test, compileflags=None, out=None, clear_globs=True): # Hack: ipython needs access to the execution context of the example, # so that it can propagate user variables loaded by %run into # test.globs. We put them here into our modified %run as a function # attribute. Our new %run will then only make the namespace update # when called (rather than unconconditionally updating test.globs here # for all examples, most of which won't be calling %run anyway). #_ip._ipdoctest_test_globs = test.globs
""" normalised_text = text normalise_map = { re.compile(r"\(\s+(\S)"): r"(\1", re.compile(r"(\S)\s+\)"): r"\1)", re.compile(r",\s*(\S)"): r", \1", } for search_pattern, replace_pattern in normalise_map.items(): normalised_text = re.sub( search_pattern, replace_pattern, normalised_text) return normalised_text doctest.NORMALIZE_FUNCTION_PARAMETERS = ( doctest.register_optionflag('NORMALIZE_FUNCTION_PARAMETERS')) class MinimockOutputChecker(doctest.OutputChecker, object): """ Class for matching output of MiniMock objects against expectations """ def check_output(self, want, got, optionflags): if (optionflags & doctest.NORMALIZE_FUNCTION_PARAMETERS): want = normalise_function_parameters(want) got = normalise_function_parameters(got) output_match = super(MinimockOutputChecker, self).check_output( want, got, optionflags) return output_match check_output.__doc__ = doctest.OutputChecker.check_output.__doc__ class TestCase(unittest.TestCase):
# TODO: # - optional round-trip check (global setting) # - "inject" pandoc.read errors in the doctest so that we can catch them. # Mmmm we probably can't do it, unless we do some fugly stack patching. # So what ? pandoc.read on any output JSON generated by pandoc is not # supposed to fail ... Implement a "safe" read on top of it ? # Return a reference error message ? (maybe the full traceback?) # And make sure that after that, it is properly handled? # ------------------------------------------------------------------------------ # Global Variables check_round_trip = True # New Doctest Directive: PANDOC PANDOC = doctest.register_optionflag("PANDOC") doctest.PANDOC = PANDOC doctest.__all__.append("PANDOC") doctest.COMPARISON_FLAGS = doctest.COMPARISON_FLAGS | PANDOC # Helpers from subprocess import Popen, PIPE import json def to_json(txt): p = Popen(["pandoc", "-tjson"], stdout=PIPE, stdin=PIPE, stderr=PIPE) json_string = p.communicate(input=txt.encode("utf-8"))[0].decode("utf-8") json_doc = json.loads(json_string) return json_doc def linebreak(text, length=80):
from __future__ import (absolute_import, division, print_function, unicode_literals) import doctest import re import numpy as np from ..extern import six from ..extern.six.moves import zip # Much of this code, particularly the parts of floating point handling, is # borrowed from the SymPy project with permission. See licenses/SYMPY.rst # for the full SymPy license. FIX = doctest.register_optionflag('FIX') FLOAT_CMP = doctest.register_optionflag('FLOAT_CMP') IGNORE_OUTPUT = doctest.register_optionflag('IGNORE_OUTPUT') IGNORE_OUTPUT_2 = doctest.register_optionflag('IGNORE_OUTPUT_2') IGNORE_OUTPUT_3 = doctest.register_optionflag('IGNORE_OUTPUT_3') class AstropyOutputChecker(doctest.OutputChecker): """ - Removes u'' prefixes on string literals - Ignores the 'L' suffix on long integers - In Numpy dtype strings, removes the leading pipe, i.e. '|S9' -> 'S9'. Numpy 1.7 no longer includes it in display. - Supports the FLOAT_CMP flag, which parses floating point values out of the output and compares their numerical values rather than their string representation. This naturally supports complex numbers as well
# Can't use super here because doctest.OutputChecker is not a # new-style class. return self._original_output_checker.check_output(self, want, got, flags) def output_difference(self, want, got, flags): if flags & FIX: want, got = self.do_fixes(want, got) # Can't use super here because doctest.OutputChecker is not a # new-style class. return self._original_output_checker.output_difference(self, want, got, flags) # We monkey-patch in our replacement doctest OutputChecker. Not # great, but there isn't really an API to replace the checker when # using doctest.testfile, unfortunately. FIX = doctest.register_optionflag("FIX") doctest.OutputChecker = OutputCheckerFix REMOTE_DATA = doctest.register_optionflag("REMOTE_DATA") def pytest_configure(config): treat_deprecations_as_exceptions() # Monkeypatch to deny access to remote resources unless explicitly told # otherwise if not config.getoption("remote_data"): turn_off_internet(verbose=config.option.verbose) doctest_plugin = config.pluginmanager.getplugin("doctest")
from zope.security.interfaces import IInteraction from zope.security.interfaces import ISecurityPolicy import z3c.form from z3c.form import browser, button, converter, datamanager, error, field from z3c.form import form, interfaces, term, validator, widget from z3c.form import contentprovider from z3c.form import outputchecker from z3c.form import tests from z3c.form.browser import radio, select, text, textarea import lxml.html import lxml.doctestcompare # register lxml doctest option flags lxml.doctestcompare.NOPARSE_MARKUP = register_optionflag('NOPARSE_MARKUP') outputChecker = outputchecker.OutputChecker( patterns =( # Py3 compatibility. (re.compile("u('.*?')"), r"\1"), (re.compile("b('.*?')"), r"\1"), (re.compile("__builtin__"), r"builtins"), (re.compile("<type"), r"<class"), (re.compile("set\(\[(.*?)\]\)"), r"{\1}"), ) ) class TestingFileUploadDataConverter(converter.FileUploadDataConverter): """A special file upload data converter that works with testing.""" zope.component.adapts(
def setup(): global session, engine, metadata, trans session, engine, metadata = setup_database() user = setup_records(session) #this may be needed if we end up testing the provider with doctests #session.commit() def check_output_xml(want, got, optionsflags): return eq_xml(want, got) from doctest import OutputChecker original_check_output = OutputChecker.check_output import doctest XML_OUTPUT = doctest.register_optionflag("XML") class MyOutputChecker(doctest.OutputChecker): def check_output(self, want, got, optionflags): if optionflags & XML_OUTPUT: return check_output_xml(want, got, optionflags) return original_check_output(self, want, got, optionflags) doctest.OutputChecker = MyOutputChecker def teardown(): session.rollback() def test_doctests(): global session, metadata import unittest
for file in p.rglob("*.py"): # Construct path as string for import, for instance "internals.frame" # The -3 drops the ".py" file_name_import = ".".join(file.relative_to(p).parts)[:-3] temp_module = importlib.import_module(p.name + "." + file_name_import) yield temp_module if __name__ == "__main__": # set to True to just run the code, and do not check any output. Will still report errors if the code is invalid IGNORE_RESULT_ALL = True # Below the implementation if the IGNORE_RESULT directive # You can ignore the result of a doctest by adding "doctest: +IGNORE_RESULT" into the code block # The difference with SKIP is that if the code errors on running, that will still be reported. IGNORE_RESULT = doctest.register_optionflag("IGNORE_RESULT") OutputChecker = doctest.OutputChecker class CustomOutputChecker(OutputChecker): def check_output(self, want: str, got: str, optionflags: Any) -> bool: if IGNORE_RESULT_ALL: return True if IGNORE_RESULT & optionflags: return True else: return OutputChecker.check_output(self, want, got, optionflags) doctest.OutputChecker = CustomOutputChecker # type: ignore # We want to be relaxed about whitespace, but strict on True vs 1
""" Implements a replacement for `doctest.OutputChecker` that handles certain normalizations of Python expression output. See the docstring on `AstropyOutputChecker` for more details. """ import doctest import re import numpy as np # Much of this code, particularly the parts of floating point handling, is # borrowed from the SymPy project with permission. See licenses/SYMPY.rst # for the full SymPy license. FIX = doctest.register_optionflag('FIX') FLOAT_CMP = doctest.register_optionflag('FLOAT_CMP') IGNORE_OUTPUT = doctest.register_optionflag('IGNORE_OUTPUT') IGNORE_OUTPUT_2 = doctest.register_optionflag('IGNORE_OUTPUT_2') IGNORE_OUTPUT_3 = doctest.register_optionflag('IGNORE_OUTPUT_3') class AstropyOutputChecker(doctest.OutputChecker): """ - Removes u'' prefixes on string literals - Ignores the 'L' suffix on long integers - In Numpy dtype strings, removes the leading pipe, i.e. '|S9' -> 'S9'. Numpy 1.7 no longer includes it in display. - Supports the FLOAT_CMP flag, which parses floating point values out of the output and compares their numerical values rather than their string representation. This naturally supports complex numbers as well
min_versions = {} for line in metadata.requires('astropy'): req = Requirement(line.split(';')[0]) min_versions[req.name.lower()] = str(req.specifier) # This is added to the end of RST files - a good place to put substitutions to # be used globally. with open("common_links.txt", "r") as cl: rst_epilog += cl.read().format(minimum_python=__minimum_python_version__, **min_versions) # Manually register doctest options since matplotlib 3.5 messed up allowing them # from pytest-doctestplus IGNORE_OUTPUT = doctest.register_optionflag('IGNORE_OUTPUT') REMOTE_DATA = doctest.register_optionflag('REMOTE_DATA') FLOAT_CMP = doctest.register_optionflag('FLOAT_CMP') # Whether to create cross-references for the parameter types in the # Parameters, Other Parameters, Returns and Yields sections of the docstring. numpydoc_xref_param_type = True # Words not to cross-reference. Most likely, these are common words used in # parameter type descriptions that may be confused for classes of the same # name. The base set comes from sphinx-astropy. We add more here. numpydoc_xref_ignore.update({ "mixin", "Any", # aka something that would be annotated with `typing.Any` # needed in subclassing numpy # TODO! revisit "Arguments", "Path",
key = ''.join(chr(i) for i in range(16)).encode('utf-8') plaintext = ''.join(chr(i) for i in range(64)).encode('utf-8') for i in range(64): assert SipHash_2_4(key, plaintext[:i]).hexdigest() == vectors[i], \ 'failed on test no %i' % i # Internal doctests # # To maintain compatibility with both python 2.x and 3.x in tests # we need to do a trick. Python 2.x doesn't like b'' notation, # Python 3.x doesn't have 2222L long integers notation. To # overcome that we'll pipe both results as well as the intended # doctest output through an `eval` function before comparison. To # do it we need to monkeypatch the OutputChecker: import doctest EVAL_FLAG = doctest.register_optionflag("EVAL") OrigOutputChecker = doctest.OutputChecker def relaxed_eval(s): if s.strip(): return eval(s) else: return None class MyOutputChecker: def __init__(self): self.orig = OrigOutputChecker() def check_output(self, want, got, optionflags): if optionflags & EVAL_FLAG: return relaxed_eval(got) == relaxed_eval(want)
""" testing.buildoutSetUp(test) import tempfile target_dir = tempfile.mkdtemp('.z3c.autoinclude.test-installs') install_projects(test_packages, target_dir) def testTearDown(test): from testdirective.zcml import clear_test_log clear_test_log() testing.buildoutTearDown(test) IGNORECASE = doctest.register_optionflag('IGNORECASE') class IgnoreCaseChecker(doctest.OutputChecker): def check_output(self, want, got, optionflags): if optionflags & IGNORECASE: want, got = want.lower(), got.lower() #print repr(want), repr(got), optionflags, IGNORECASE return doctest.OutputChecker.check_output(self, want, got, optionflags) def test_suite(): from pprint import pprint suite = doctest.DocFileSuite('../utils.txt', '../dependency.txt', '../plugin.txt', setUp=testSetUp,
# Copyright (c) 2004 Zope Foundation and Contributors. # All Rights Reserved. # # This software is subject to the provisions of the Zope Public License, # Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution. # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS # FOR A PARTICULAR PURPOSE. # ############################################################################## import sys import doctest IGNORE_EXCEPTION_MODULE_IN_PYTHON2 = doctest.register_optionflag( 'IGNORE_EXCEPTION_MODULE_IN_PYTHON2') IGNORE_EXCEPTION_MODULE_IN_PYTHON2_HINT = """\ =============================================================== HINT: The optionflag IGNORE_EXCEPTION_MODULE_IN_PYTHON2 is set. You seem to test traceback output. If you are indeed, make sure to use the full dotted name of the exception class like Python 3 displays, even though you are running the tests in Python 2. The exception message needs to be last line (and thus not split over multiple lines). ===============================================================""" class OutputChecker(doctest.OutputChecker): """Pattern-normalizing outout checker
s = s.strip() if s and s[0] in ("'", '"') and s[-1] in ("'", '"'): s = s[1:-1] return s want = clean_string(want) got = clean_string(got) if not want or not got: return False, "something is missing" want = etree.fromstring(want) got = etree.fromstring(got) return _assertXMLElementEqual(want, got, optionflags) XMLDATA = doctest.register_optionflag("XMLDATA") XMLDATA_IGNOREORDER = doctest.register_optionflag("XMLDATA_IGNOREORDER") XMLDATA_IGNOREMISSINGATTRIBUTES = doctest.register_optionflag( "XMLDATA_IGNOREMISSINGATTRIBUTES") XMLDATA_IGNOREEXTRAATTRIBUTES = doctest.register_optionflag( "XMLDATA_IGNOREEXTRAATTRIBUTES") class XMLOutputChecker(doctest.OutputChecker): def check_output(self, want, got, optionflags): if optionflags & XMLDATA or optionflags & XMLDATA_IGNOREORDER: if want and got: # it only makes sense to compare actual data. result, msg = _assertXMLElement(want, got, optionflags)
flags = doctest.ELLIPSIS timeout = 600 filenames = sys.argv[1:] if os.name == 'nt': notinwindows = set([ 'src/cysignals/pysignals.pyx', 'src/cysignals/alarm.pyx', 'src/cysignals/pselect.pyx' ]) filenames = [f for f in filenames if f not in notinwindows] # Add an option to flag doctests which should be skipped depending on # the platform SKIP_WINDOWS = doctest.register_optionflag("SKIP_WINDOWS") SKIP_CYGWIN = doctest.register_optionflag("SKIP_CYGWIN") SKIP_POSIX = doctest.register_optionflag("SKIP_POSIX") skipflags = set() if os.name == 'posix': skipflags.add(SKIP_POSIX) elif os.name == 'nt': skipflags.add(SKIP_WINDOWS) if sys.platform == 'cygwin': skipflags.add(SKIP_CYGWIN) class CysignalsDocTestParser(DocTestParser): def parse(self, *args, **kwargs):
try: from html import escape as html_escape except ImportError: from cgi import escape as html_escape __all__ = ['PARSE_HTML', 'PARSE_XML', 'NOPARSE_MARKUP', 'LXMLOutputChecker', 'LHTMLOutputChecker', 'install', 'temp_install'] try: _basestring = basestring except NameError: _basestring = (str, bytes) _IS_PYTHON_3 = sys.version_info[0] >= 3 PARSE_HTML = doctest.register_optionflag('PARSE_HTML') PARSE_XML = doctest.register_optionflag('PARSE_XML') NOPARSE_MARKUP = doctest.register_optionflag('NOPARSE_MARKUP') OutputChecker = doctest.OutputChecker def strip(v): if v is None: return None else: return v.strip() def norm_whitespace(v): return _norm_whitespace_re.sub(' ', v) _html_parser = etree.HTMLParser(recover=False, remove_blank_text=True)
import doctest import numpy as np import pkg_resources # import all packages from . import audio, evaluation, features, io, ml, models, processors, utils # define a version variable __version__ = pkg_resources.get_distribution("madmom").version # Create a doctest output checker that optionally ignores the unicode string # literal. # declare the new doctest directives _IGNORE_UNICODE = doctest.register_optionflag("IGNORE_UNICODE") doctest.IGNORE_UNICODE = _IGNORE_UNICODE doctest.__all__.append("IGNORE_UNICODE") doctest.COMPARISON_FLAGS = doctest.COMPARISON_FLAGS | _IGNORE_UNICODE _NORMALIZE_ARRAYS = doctest.register_optionflag("NORMALIZE_ARRAYS") doctest.NORMALIZE_ARRAYS = _NORMALIZE_ARRAYS doctest.__all__.append("NORMALIZE_ARRAYS") doctest.COMPARISON_FLAGS = doctest.COMPARISON_FLAGS | _NORMALIZE_ARRAYS _doctest_OutputChecker = doctest.OutputChecker class _OutputChecker(_doctest_OutputChecker): """ Output checker which enhances `doctest.OutputChecker` to compare doctests
import docutils.core from argparse import ArgumentParser from contextlib import contextmanager, redirect_stderr from doctest import NORMALIZE_WHITESPACE, ELLIPSIS, IGNORE_EXCEPTION_DETAIL from docutils.parsers.rst import directives from pkg_resources import parse_version import sphinx import numpy as np sys.path.insert( 0, os.path.join(os.path.dirname(__file__), '..', 'doc', 'sphinxext')) from numpydoc.docscrape_sphinx import get_doc_object SKIPBLOCK = doctest.register_optionflag('SKIPBLOCK') if parse_version(sphinx.__version__) >= parse_version('1.5'): # Enable specific Sphinx directives from sphinx.directives.other import SeeAlso, Only directives.register_directive('seealso', SeeAlso) directives.register_directive('only', Only) else: # Remove sphinx directives that don't run without Sphinx environment. # Sphinx < 1.5 installs all directives on import... directives._directives.pop('versionadded', None) directives._directives.pop('versionchanged', None) directives._directives.pop('moduleauthor', None) directives._directives.pop('sectionauthor', None) directives._directives.pop('codeauthor', None) directives._directives.pop('toctree', None)
try: from epydoc.cli import TerminalController except ImportError: class TerminalController: def __getattr__(self, attr): return '' term = TerminalController() ###################################################################### # Code ###################################################################### # If we're using py24, then ignore the +SKIP directive. if sys.version_info[:2] < (2, 5): register_optionflag('SKIP') def strip_quotes(s): s = s.strip() while (s and (s[0] in "ur") and (s[-1] in "'\"")): s = s[1:] while (s and (s[0] in "'\"" and (s[0] == s[-1]))): s = s[1:-1] s = s.strip() return s def find_class(s, index): lines = s[:index].split('\n') while lines:
import doctest import sys SKIP_ON_PY2 = doctest.register_optionflag('SKIP_ON_PY2') SKIP_ON_PY3 = doctest.register_optionflag('SKIP_ON_PY3') _skip = None if sys.version_info.major == 2: _skip = SKIP_ON_PY2 elif sys.version_info.major == 3: _skip = SKIP_ON_PY3 def PyVersionAwareDocTestSuite(*args, **kwargs): """A specialism of doctest.DocTestSuite providing the ability to SKIP doctests based on the Python major version. Two new doctest option flags are made available: SKIP_ON_PY2 and SKIP_ON_PY3. These cause the SKIP option flag to be set if the Python version matches. >>> print("Never") # doctest: +SKIP Never >>> print("Not Py2") # doctest: +SKIP_ON_PY2 Not Py2 >>> print("Not Py3") # doctest: +SKIP_ON_PY3 Not Py3
import sys import re import doctest import cgi __all__ = ['PARSE_HTML', 'PARSE_XML', 'NOPARSE_MARKUP', 'LXMLOutputChecker', 'LHTMLOutputChecker', 'install', 'temp_install'] try: _basestring = basestring except NameError: _basestring = (str, bytes) _IS_PYTHON_3 = sys.version_info[0] >= 3 PARSE_HTML = doctest.register_optionflag('PARSE_HTML') PARSE_XML = doctest.register_optionflag('PARSE_XML') NOPARSE_MARKUP = doctest.register_optionflag('NOPARSE_MARKUP') OutputChecker = doctest.OutputChecker def strip(v): if v is None: return None else: return v.strip() def norm_whitespace(v): return _norm_whitespace_re.sub(' ', v) _html_parser = etree.HTMLParser(recover=False, remove_blank_text=True)
#!/usr/bin/python import doctest import gc import glob import os import re import sys import shutil import tempfile import unittest NODES_VARY = doctest.register_optionflag('NODES_VARY') RANDOM_OUTPUT = doctest.register_optionflag('RANDOM_OUTPUT') class RandomOutputChecker(doctest.OutputChecker): def check_output(self, want, got, optionflags): if optionflags & RANDOM_OUTPUT: return True return doctest.OutputChecker.check_output(self, want, got, optionflags) class IgnoreNodeCountChecker(RandomOutputChecker): _r = re.compile('\(\d+ nodes\)$', re.MULTILINE) def check_output(self, want, got, optionflags): if optionflags & NODES_VARY: want = self._r.sub('(X nodes)', want) got = self._r.sub('(X nodes)', got)
import doctest, re, sys, subprocess, time, socket, traceback GLOBAL_FLAGS = 0 LOG_TEST = False PASS = doctest.register_optionflag("PASS") old_OutputChecker_check_output = doctest.OutputChecker.check_output def _custom_check_output(self, want, got, optionflags): if optionflags & PASS: return True return old_OutputChecker_check_output(self, want, got, optionflags) doctest.OutputChecker.check_output = _custom_check_output JS_SESSION_ADDRESS = ('', 5001) class DocTestJSParser(doctest.DocTestParser): '''This is an adaptation of the original parser. Instead of be using '>>>' for the interactive session and '#' for commenting a line, they are replaced by 'js>' and '//' respectively, so they can be used with a javascript session.''' _EXAMPLE_RE = re.compile(r''' # Source consists of a PS1 line followed by zero or more PS2 lines. (?P<source> (?:^(?P<indent> [ ]*) js> .*) # 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 (?![ ]*js>) # Not a line starting with PS1
# -*- coding: utf-8 -*- from __future__ import print_function from nose.suite import ContextList import re import sys import os import codecs import doctest from nose.plugins.base import Plugin from nose.util import tolist, anyp from nose.plugins.doctests import Doctest, log, DocFileCase ALLOW_UNICODE = doctest.register_optionflag('ALLOW_UNICODE') class _UnicodeOutputChecker(doctest.OutputChecker): _literal_re = re.compile(r"(\W|^)[uU]([rR]?[\'\"])", re.UNICODE) def _remove_u_prefixes(self, txt): return re.sub(self._literal_re, r'\1\2', txt) def check_output(self, want, got, optionflags): res = doctest.OutputChecker.check_output(self, want, got, optionflags) if res: return True if not (optionflags & ALLOW_UNICODE): return False # ALLOW_UNICODE is active and want != got cleaned_want = self._remove_u_prefixes(want) cleaned_got = self._remove_u_prefixes(got) res = doctest.OutputChecker.check_output(self, cleaned_want, cleaned_got, optionflags)
from __future__ import absolute_import import re import os from doctest import register_optionflag import numpy as np # Import for testing structured array reprs from numpy import array # noqa from nipy.utils import _NoValue from ..fixes.numpy.testing.noseclasses import (NumpyDoctest, NumpyOutputChecker) IGNORE_OUTPUT = register_optionflag('IGNORE_OUTPUT') SYMPY_EQUAL = register_optionflag('SYMPY_EQUAL') STRUCTARR_EQUAL = register_optionflag('STRUCTARR_EQUAL') STRIP_ARRAY_REPR = register_optionflag('STRIP_ARRAY_REPR') IGNORE_DTYPE = register_optionflag('IGNORE_DTYPE') NOT_EQUAL = register_optionflag('NOT_EQUAL') FP_4DP = register_optionflag('FP_4DP') FP_6DP = register_optionflag('FP_6DP') FP_REG = re.compile(r'(?<![0-9a-zA-Z_.])' r'(\d+\.\d+)' r'(e[+-]?\d+)?' r'(?![0-9a-zA-Z_.])') def round_numbers(in_str, precision): """ Replace fp numbers in `in_str` with numbers rounded to `precision`
from guild import _api as gapi from guild import cli from guild import config as configlib from guild import guildfile from guild import index2 as indexlib from guild import init from guild import op_util from guild import run as runlib from guild import util PLATFORM = platform.system() TEST_NAME_WIDTH = 27 NORMALIZE_PATHS = doctest.register_optionflag("NORMALIZE_PATHS") STRIP_U = doctest.register_optionflag("STRIP_U") STRIP_L = doctest.register_optionflag("STRIP_L") WINDOWS = doctest.register_optionflag("WINDOWS") WINDOWS_ONLY = doctest.register_optionflag("WINDOWS_ONLY") STRIP_ANSI_FMT = doctest.register_optionflag("STRIP_ANSI_FMT") PY2 = doctest.register_optionflag("PY2") PY3 = doctest.register_optionflag("PY3") def run_all(skip=None): return run(all_tests(), skip) def all_tests(): test_pattern = os.path.join(tests_dir(), "*.md")
import guild from guild import _api as gapi from guild import cli from guild import config as configlib from guild import guildfile from guild import index2 from guild import init from guild import run_util from guild import util PLATFORM = platform.system() TEST_NAME_WIDTH = 27 DONT_NORMALIZE_PATH = doctest.register_optionflag("DONT_NORMALIZE_PATH") SKIP_WINDOWS = doctest.register_optionflag("SKIP_WINDOWS") def run_all(skip=None): return run(all_tests(), skip) def all_tests(): test_pattern = os.path.join(tests_dir(), "*.md") return sorted( [_test_name_from_path(path) for path in glob.glob(test_pattern)]) def tests_dir(): return os.path.join(os.path.dirname(__file__), "tests")
# http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. import doctest from unittest import mock from lxml import doctestcompare import six CHECKER = doctestcompare.LXMLOutputChecker() PARSE_XML = doctest.register_optionflag('PARSE_XML') class RequestSideEffect(object): def __init__(self): self.actions = [] self.started = False def append(self, resp=None, ex=None): if not self.started: self.actions.append((resp, ex)) def __call__(self, *args, **kwargs): if not self.started: self.started = True self.actions.reverse()
#!/usr/bin/env python import sys import doctest # handle platform specific issues WINDOWS = doctest.register_optionflag("WINDOWS") LINUX = doctest.register_optionflag("LINUX") SKIP = doctest.register_optionflag("SKIP") # handle size specific issues import ctypes c_int_name = ctypes.c_int.__name__ base = doctest.DocTestRunner class MyDocTestRunner(base): def run(self, test, compileflags=None, out=None, clear_globs=True): examples = test.examples[:] for ex in test.examples: if WINDOWS in ex.options and sys.platform != "win32": examples.remove(ex) elif LINUX in ex.options and not sys.platform.startswith("linux"): examples.remove(ex) elif SKIP in ex.options: examples.remove(ex) ## elif "printf(" in ex.source: ## # handle that doctest doesn't catch printf's output ## lines = ex.want.splitlines() ## try: ## int(lines[-1]) ## except ValueError: ## pass
# -*- coding: utf-8 -*- from __future__ import print_function import re import sys import os import codecs import doctest from nose.util import tolist, anyp from nose.plugins.base import Plugin from nose.suite import ContextList from nose.plugins.doctests import Doctest, log, DocFileCase ALLOW_UNICODE = doctest.register_optionflag('ALLOW_UNICODE') class _UnicodeOutputChecker(doctest.OutputChecker): _literal_re = re.compile(r"(\W|^)[uU]([rR]?[\'\"])", re.UNICODE) def _remove_u_prefixes(self, txt): return re.sub(self._literal_re, r'\1\2', txt) def check_output(self, want, got, optionflags): res = doctest.OutputChecker.check_output(self, want, got, optionflags) if res: return True if not (optionflags & ALLOW_UNICODE): return False # ALLOW_UNICODE is active and want != got cleaned_want = self._remove_u_prefixes(want) cleaned_got = self._remove_u_prefixes(got)
#!/usr/bin/env python3 # flake8: noqa """Run the tests with https://pytest.org.""" import doctest as doctest from unittest import mock import platform import sys NO_EXE = doctest.register_optionflag('NO_EXE') ARGS = [#'--skip-exe', #'--only-exe', #'--collect-only', #'--verbose', #'--pdb', #'--exitfirst', # a.k.a. -x #'-W', 'error', #'--doctest-report none', #'--cov-append', ] class NoExeChecker(doctest.OutputChecker): def check_output(self, want, got, optionflags, *args, **kwargs) -> bool: if optionflags & NO_EXE: return True return super().check_output(want, got, optionflags, *args, **kwargs)
deprecated_methods = defaultdict(set) try: from epydoc.cli import TerminalController except ImportError: class TerminalController: def __getattr__(self, attr): return '' term = TerminalController() ###################################################################### # Code ###################################################################### # If we're using py24, then ignore the +SKIP directive. if sys.version_info[:2] < (2,5): register_optionflag('SKIP') def strip_quotes(s): s = s.strip() while (s and (s[0] in "ur") and (s[-1] in "'\"")): s = s[1:] while (s and (s[0] in "'\"" and (s[0] == s[-1]))): s = s[1:-1] s = s.strip() return s def find_class(s, index): lines = s[:index].split('\n') while lines: m = CLASS_DEF_RE.match(lines[-1]) if m: return m.group(1)+'.'
class SageNotAvailable(Exception): pass if _within_sage: def sage_method(function): function._sage_method = True return function else: def _sage_method(function, *args, **kw): raise SageNotAvailable('Sorry, this feature requires using SnapPy inside Sage.') def sage_method(function): return decorator.decorator(_sage_method, function) SNAPPY_FLAG = doctest.register_optionflag('SNAPPY') def filter_out_snappy(pieces): ans = [] for piece in pieces: if _have_snappy or not isinstance(piece, doctest.Example): ans.append(piece) elif not piece.options.get(SNAPPY_FLAG, False): ans.append(piece) return ans if _within_sage: class DocTestParser(doctest.DocTestParser): def parse(self, string, name='<string>'): string = re.subn('([\n\A]\s*)sage:', '\g<1>>>>', string)[0]
from plone.testing import layered from plone.testing.zca import UNIT_TESTING import doctest import re import sys import unittest DOCFILES = [ 'message.txt', 'fields.txt', 'supermodel.txt', ] SKIP_PYTHON_2 = doctest.register_optionflag('SKIP_PYTHON_2') SKIP_PYTHON_3 = doctest.register_optionflag('SKIP_PYTHON_3') IGNORE_U = doctest.register_optionflag('IGNORE_U') IGNORE_B = doctest.register_optionflag('IGNORE_B') class PolyglotOutputChecker(doctest.OutputChecker): def check_output(self, want, got, optionflags): if optionflags & SKIP_PYTHON_3 and sys.version_info >= (3,): return True elif optionflags & SKIP_PYTHON_2: return True if hasattr(self, '_toAscii'): got = self._toAscii(got) want = self._toAscii(want)
""" testing.buildoutSetUp(test) import tempfile target_dir = tempfile.mkdtemp('.z3c.autoinclude.test-installs') install_projects(test_packages, target_dir) def testTearDown(test): from testdirective.zcml import clear_test_log clear_test_log() testing.buildoutTearDown(test) IGNORECASE = doctest.register_optionflag('IGNORECASE') class IgnoreCaseChecker(renormalizing.RENormalizing, object): def __init__(self): super(IgnoreCaseChecker, self).__init__([ # Python 3 drops the u'' prefix on unicode strings (re.compile(r"u('[^']*')"), r"\1"), # Python 3 adds module name to exceptions (re.compile("pkg_resources.DistributionNotFound"), r"DistributionNotFound"), ]) def check_output(self, want, got, optionflags): if optionflags & IGNORECASE: want, got = want.lower(), got.lower()
import doctest import os import numpy as np import pytest import hail as hl SKIP_OUTPUT_CHECK = doctest.register_optionflag('SKIP_OUTPUT_CHECK') @pytest.fixture(autouse=True) def patch_doctest_check_output(monkeypatch): # FIXME: remove once test output matches docs base_check_output = doctest.OutputChecker.check_output def patched_check_output(self, want, got, optionflags): return ((not want) or (want.strip() == 'None') or (SKIP_OUTPUT_CHECK & optionflags) or base_check_output( self, want, got, optionflags | doctest.NORMALIZE_WHITESPACE)) monkeypatch.setattr('doctest.OutputChecker.check_output', patched_check_output) yield monkeypatch.undo() @pytest.fixture(scope="session", autouse=True) def init(doctest_namespace): # This gets run once per process -- must avoid race conditions
""" Custom doctester based on Numpy doctester """ import re from doctest import register_optionflag import numpy as np from ..fixes.numpy.testing.noseclasses import NumpyDoctest, NumpyOutputChecker IGNORE_OUTPUT = register_optionflag('IGNORE_OUTPUT') SYMPY_EQUAL = register_optionflag('SYMPY_EQUAL') STRIP_ARRAY_REPR = register_optionflag('STRIP_ARRAY_REPR') NOT_EQUAL = register_optionflag('NOT_EQUAL') FP_4DP = register_optionflag('FP_4DP') FP_6DP = register_optionflag('FP_6DP') FP_REG = re.compile(r'(?<![0-9a-zA-Z_.])' r'(\d+\.\d+)' r'(e[+-]?\d+)?' r'(?![0-9a-zA-Z_.])') def round_numbers(in_str, precision): """ Replace fp numbers in `in_str` with numbers rounded to `precision` Parameters ---------- in_str : str string possibly containing floating point numbers precision : int number of decimal places to round to
# pylint: disable=missing-docstring # sets up the environment for doctests (when run through nose) np.set_printoptions(precision=5, edgeitems=2, suppress=True) def teardown(): # pylint: disable=missing-docstring # restore the environment after doctests (when run through nose) np.set_printoptions(**_NP_PRINT_OPTIONS) # Create a doctest output checker that optionally ignores the unicode string # literal. # declare the new doctest directives IGNORE_UNICODE = doctest.register_optionflag("IGNORE_UNICODE") doctest.IGNORE_UNICODE = IGNORE_UNICODE doctest.__all__.append("IGNORE_UNICODE") doctest.COMPARISON_FLAGS = doctest.COMPARISON_FLAGS | IGNORE_UNICODE NORMALIZE_ARRAYS = doctest.register_optionflag("NORMALIZE_ARRAYS") doctest.NORMALIZE_ARRAYS = NORMALIZE_ARRAYS doctest.__all__.append("NORMALIZE_ARRAYS") doctest.COMPARISON_FLAGS = doctest.COMPARISON_FLAGS | NORMALIZE_ARRAYS _doctest_OutputChecker = doctest.OutputChecker class MadmomOutputChecker(_doctest_OutputChecker): """ Output checker which enhances `doctest.OutputChecker` to compare doctests
# If the repeat option is set, we add a fixture for the repeat count and # parametrize the tests over the repeats. Solution adapted from: # http://stackoverflow.com/q/21764473/180783 if metafunc.config.option.repeat is not None: count = int(metafunc.config.option.repeat) metafunc.fixturenames.append('tmp_ct') metafunc.parametrize('tmp_ct', range(count)) # We monkey-patch in our replacement doctest OutputChecker. Not # great, but there isn't really an API to replace the checker when # using doctest.testfile, unfortunately. doctest.OutputChecker = AstropyOutputChecker REMOTE_DATA = doctest.register_optionflag('REMOTE_DATA') def pytest_configure(config): treat_deprecations_as_exceptions() config.getini('markers').append( 'remote_data: Run tests that require data from remote servers') # Monkeypatch to deny access to remote resources unless explicitly told # otherwise if not config.getoption('remote_data'): turn_off_internet(verbose=config.option.verbose) doctest_plugin = config.pluginmanager.getplugin('doctest') if (doctest_plugin is None or config.option.doctestmodules or
# under the License. from __future__ import unicode_literals import doctest import logging import mock import six from lxml import doctestcompare __author__ = 'Jay Xu' log = logging.getLogger(__name__) CHECKER = doctestcompare.LXMLOutputChecker() PARSE_XML = doctest.register_optionflag('PARSE_XML') class RequestSideEffect(object): def __init__(self): self.actions = [] self.started = False def append(self, resp=None, ex=None): if not self.started: self.actions.append((resp, ex)) def __call__(self, *args, **kwargs): if not self.started: self.started = True self.actions.reverse()
return self._original_output_checker.check_output( self, want, got, flags) def output_difference(self, want, got, flags): if flags & FIX: want, got = self.do_fixes(want, got) # Can't use super here because doctest.OutputChecker is not a # new-style class. return self._original_output_checker.output_difference( self, want, got, flags) # We monkey-patch in our replacement doctest OutputChecker. Not # great, but there isn't really an API to replace the checker when # using doctest.testfile, unfortunately. FIX = doctest.register_optionflag('FIX') doctest.OutputChecker = OutputCheckerFix REMOTE_DATA = doctest.register_optionflag('REMOTE_DATA') def pytest_configure(config): treat_deprecations_as_exceptions() # Monkeypatch to deny access to remote resources unless explicitly told # otherwise if not config.getoption('remote_data'): turn_off_internet(verbose=config.option.verbose) doctest_plugin = config.pluginmanager.getplugin('doctest')
a space character, then raise ValueError. Note: IPython-modified version which takes the input prompt length as a parameter, so that prompts of variable length can be dealt with. """ space_idx = indent + ps1_len min_len = space_idx + 1 for i, line in enumerate(lines): if len(line) >= min_len and line[space_idx] != ' ': raise ValueError( 'line %r of the docstring for %s ' 'lacks blank after %s: %r' % (lineno + i + 1, name, line[indent:space_idx], line)) SKIP = doctest.register_optionflag('SKIP') class IPDocTestRunner(doctest.DocTestRunner, object): """Test runner that synchronizes the IPython namespace with test globals. """ def run(self, test, compileflags=None, out=None, clear_globs=True): # Hack: ipython needs access to the execution context of the example, # so that it can propagate user variables loaded by %run into # test.globs. We put them here into our modified %run as a function # attribute. Our new %run will then only make the namespace update # when called (rather than unconditionally updating test.globs here # for all examples, most of which won't be calling %run anyway). #_ip._ipdoctest_test_globs = test.globs #_ip._ipdoctest_test_filename = test.filename
a space character, then raise ValueError. Note: IPython-modified version which takes the input prompt length as a parameter, so that prompts of variable length can be dealt with. """ space_idx = indent + ps1_len min_len = space_idx + 1 for i, line in enumerate(lines): if len(line) >= min_len and line[space_idx] != " ": raise ValueError( "line %r of the docstring for %s " "lacks blank after %s: %r" % (lineno + i + 1, name, line[indent:space_idx], line) ) SKIP = doctest.register_optionflag("SKIP") class IPDocTestRunner(doctest.DocTestRunner, object): """Test runner that synchronizes the IPython namespace with test globals. """ def run(self, test, compileflags=None, out=None, clear_globs=True): # Hack: ipython needs access to the execution context of the example, # so that it can propagate user variables loaded by %run into # test.globs. We put them here into our modified %run as a function # attribute. Our new %run will then only make the namespace update # when called (rather than unconconditionally updating test.globs here # for all examples, most of which won't be calling %run anyway). # _ip._ipdoctest_test_globs = test.globs