Пример #1
0
def load_tests(loader, tests, ignore):
    tests.addTests(doctest.DocTestSuite(ngsutils.support.stats))
    return tests
Пример #2
0
def load_tests(loader, tests, ignore):
    tests.addTests(doctest.DocTestSuite())
    return tests
Пример #3
0
def get_suite():
    """Get unittest suite for this module"""
    import doctest, sys
    return doctest.DocTestSuite(sys.modules[__name__])
Пример #4
0
def load_tests(loader, tests, pattern):
    tests.addTest(doctest.DocTestSuite())
    return tests
Пример #5
0
def test_suite():
    return unittest.TestSuite((doctest.DocTestSuite(setUp=setUp,
                                                    tearDown=tearDown), ))
Пример #6
0
def suite():
    suite = unittest.TestSuite()
    suite.addTest(doctest.DocTestSuite(TemplateLoader.__module__))
    suite.addTest(unittest.makeSuite(TemplateLoaderTestCase, 'test'))
    return suite
Пример #7
0
def load_tests(loader, tests, ignore):
    tests.addTests(doctest.DocTestSuite(ObjectFactoryMixin))
    return tests
Пример #8
0
def test_suite():
    optionflags = (doctest.ELLIPSIS | doctest.REPORT_NDIFF
                   | doctest.NORMALIZE_WHITESPACE)
    return unittest.TestSuite([
        doctest.DocTestSuite(optionflags=optionflags, checker=checker),
    ])
Пример #9
0
def load_tests(loader, tests, ignore):
    tests.addTests(doctest.DocTestSuite(rdSubstructLibrary))
    return tests
Пример #10
0
def test_suite():
    optionflags = (doctest.ELLIPSIS |
                   doctest.NORMALIZE_WHITESPACE |
                   doctest.REPORT_ONLY_FIRST_FAILURE)
    return doctest.DocTestSuite(setUp=setUp, tearDown=tearDown,
                                optionflags=optionflags)
Пример #11
0
def doctests():
    # type: () -> unittest.TestSuite
    import doctest

    return doctest.DocTestSuite()
Пример #12
0
def load_tests(*args):
    from test import test_pdb
    suites = [unittest.makeSuite(PdbTestCase), doctest.DocTestSuite(test_pdb)]
    return unittest.TestSuite(suites)
      The config file's encoding, defaults to :data:`default_encoding`.

    Examples
    --------

    >>> get_val("junk") is None
    True
    >>> set_val("junk", "random")
    >>> get_val("junk")
    u'random'
    >>> set_val("junk", None)
    >>> get_val("junk") is None
    True
    """
    if os.path.exists(path()):
        if encoding == None:
            encoding = default_encoding
        config = ConfigParser.ConfigParser()
        f = codecs.open(path(), 'r', encoding)
        config.readfp(f, path())
        f.close()
        try:
            return config.get(section, name)
        except ConfigParser.NoOptionError:
            return default
    else:
        return default

if libbe.TESTING == True:
    suite = doctest.DocTestSuite()
Пример #14
0
def run_docstring_tests(module):
    runner = TextTestRunner()
    s = runner.run(doctest.DocTestSuite(module))
    assert 0 == len(s.failures)
Пример #15
0
        for path, module in walk_modules():
            add_module(module, path)
        add_module('setup', 'setup.py')

        if not modules:
            sys.exit('No modules found matching %s' %
                     ' '.join(allowed_modules))

        suite = unittest.TestSuite()
        tests_count = 0
        modules_count = 0
        for m, path in sorted(modules):
            with open(path, 'r') as f:
                contents = f.read()
            if re.search(r'^\s*>>> ', contents, re.M):
                try:
                    s = doctest.DocTestSuite(m, extraglobs=globs)
                    test_count = len(s._tests)  # pylint: disable=W0212
                    print('%s (from %s): %s tests' % (m, path, test_count))
                    suite.addTest(s)
                    modules_count += 1
                    tests_count += test_count
                except Exception:
                    traceback.print_exc()
                    sys.stderr.write('Failed to process %s\n\n' % path)
        print('Total: %s tests in %s modules' % (tests_count, modules_count))
        runner = unittest.TextTestRunner(verbosity=2)
        runner.run(suite)
    finally:
        os.chdir(cwd)
Пример #16
0
def load_tests(loader, tests, ignore):
    tests.addTests(doctest.DocTestSuite(encrypt))
    tests.addTests(doctest.DocTestSuite(game))
    return tests
def test_suite():
    suite = unittest.TestSuite()
    suite.addTest(
        doctest.DocTestSuite('Products.eXtremeManagement.browser.gantt',
                             optionflags=OPTIONFLAGS))
    return suite
Пример #18
0
import doctest
import unittest
import os
import vcf2hl7v2
from os.path import join, dirname
import shutil
import logging
import filecmp

suite = doctest.DocTestSuite(vcf2hl7v2)


class TestTemporary(unittest.TestCase):
    @classmethod
    def setUpClass(self):
        self.TEST_RESULT_DIR = os.path.join(
            os.path.dirname(__file__), 'output')
        if os.path.exists(self.TEST_RESULT_DIR):
            shutil.rmtree(self.TEST_RESULT_DIR)
        os.mkdir(self.TEST_RESULT_DIR)

    @classmethod
    def tearDownClass(self):
        shutil.rmtree(self.TEST_RESULT_DIR)

    def test_NB6TK328(self):
        o_vcf_2_hl7v2 = vcf2hl7v2.Converter(
                vcf_filename=os.path.join(
                                        os.path.dirname(__file__),
                                        'NB6TK328_filtered.vcf'
                                    ),
Пример #19
0
        if os.path.exists(self.rustc_stamp_path):
            os.unlink(self.rustc_stamp_path)
        self.assertTrue(self.build.program_out_of_date(self.rustc_stamp_path))

    def test_dates_are_different(self):
        """Return True when the dates are different"""
        with open(self.rustc_stamp_path, "w") as rustc_stamp:
            rustc_stamp.write("2017-06-14")
        self.assertTrue(self.build.program_out_of_date(self.rustc_stamp_path))

    def test_same_dates(self):
        """Return False both dates match"""
        with open(self.rustc_stamp_path, "w") as rustc_stamp:
            rustc_stamp.write("2017-06-15")
        self.assertFalse(self.build.program_out_of_date(self.rustc_stamp_path))


if __name__ == '__main__':
    SUITE = unittest.TestSuite()
    TEST_LOADER = unittest.TestLoader()
    SUITE.addTest(doctest.DocTestSuite(bootstrap))
    SUITE.addTests([
        TEST_LOADER.loadTestsFromTestCase(Stage0DataTestCase),
        TEST_LOADER.loadTestsFromTestCase(VerifyTestCase),
        TEST_LOADER.loadTestsFromTestCase(ProgramOutOfDate)
    ])

    RUNNER = unittest.TextTestRunner(stream=sys.stdout, verbosity=2)
    result = RUNNER.run(SUITE)
    sys.exit(0 if result.wasSuccessful() else 1)
Пример #20
0
def load_tests(loader, tests, ignore):
    tests.addTests(
        doctest.DocTestSuite('plainbox.impl.xparsers',
                             optionflags=doctest.REPORT_NDIFF))
    return tests
Пример #21
0
def load_tests(loader, tests, ignore):
    tests.addTests(doctest.DocTestSuite(representation))
    return tests
Пример #22
0
def load_tests(loader, tests, ignore):
    tests.addTests(doctest.DocTestSuite(preprocessing))
    return tests
Пример #23
0
def test_suite():
    return unittest.TestSuite(
        [doctest.DocTestSuite(module=module) for module in modules])
Пример #24
0
def suite():
    suite = unittest.TestSuite()
    suite.addTest(doctest.DocTestSuite(mofile, optionflags=doctest.ELLIPSIS))
    suite.addTest(unittest.makeSuite(ReadMoTestCase))
    suite.addTest(unittest.makeSuite(WriteMoTestCase))
    return suite
Пример #25
0
def suitefn():
    suite = unittest.TestSuite()
    suite.addTests(doctest.DocTestSuite(diskarray))
    suite.addTests(doctest.DocTestSuite(vararray))
    return suite
Пример #26
0
def load_tests(loader, tests, ignore):
    tests.addTests(doctest.DocTestSuite(solists.move_to_front_list))
    return tests
Пример #27
0
def make_test_suite():
    """Load unittests placed in here and below, then return a
    TestSuite object of those."""
    path = os.path.abspath(__file__).rsplit(os.sep + 'tests', 1)[0]

    # path to actual code that we want to test
    sys.path.append('../')
    sys.path.append('../../')

    top_testdir = os.path.join(path, 'tests')  # 'tests', 'unittests'
    testdirs = getSubDirectories(top_testdir)
    # testdirs.append('./')
    print "scan directories: ", testdirs

    # Initialize the testsuite to add to
    suite = TestSuite()
    optionflags = doctest.ELLIPSIS | doctest.NORMALIZE_WHITESPACE

    for testdir in testdirs:
        # All unittest modules have to start with 'test_' and have to be, of
        # course, python files
        module_names = [
            f[:-3] for f in os.listdir(testdir)
            if f.startswith('test_') and f.endswith('.py')
        ]

        if not module_names:
            logging.info('No tests found in %s' % testdir)
            continue

        # "Magically" import the tests package and its test-modules that we've
        # found
        sub_path = os.path.relpath(testdir, top_testdir).split(os.sep)
        test_package_path = '.'.join(sub_path)
        test_package = __import__(test_package_path, fromlist=module_names)

        # Put the test modules in a list that can be passed to the testsuite
        modules = (getattr(test_package, n) for n in module_names)
        modules = [(m, missingDependencies(m)) for m in modules]
        untests = [(m, md) for m, md in modules if md]
        modules = [m for m, md in modules if not md]

        # Print out modules that are missing dependencies
        for module, miss_dep in untests:  # Mr Dep is not around, though
            logging.warning('Module %s is missing dependencies: %s' %
                            (module.__name__, ', '.join(miss_dep)))

        # Print out a list of tests that are found
        for m in modules:
            logging.info('Tests found: %s' % m.__name__)

        # Build up the testsuite
        suite.addTests([TestLoader().loadTestsFromModule(m) for m in modules])

        # Add doctests from the unittest modules to the suite
        for mod in modules:
            try:
                suite.addTest(
                    doctest.DocTestSuite(mod, optionflags=optionflags))
            except ValueError:
                # No tests found.
                pass

    return suite
Пример #28
0
 def runTest(self, name):
     from Bio import MissingExternalDependencyError
     result = self._makeResult()
     output = StringIO()
     # Restore the language and thus default encoding (in case a prior
     # test changed this, e.g. to help with detecting command line tools)
     global SYSTEM_LANG
     os.environ['LANG'] = SYSTEM_LANG
     # Always run tests from the Tests/ folder where run_tests.py
     # should be located (as we assume this with relative paths etc)
     os.chdir(self.testdir)
     try:
         stdout = sys.stdout
         sys.stdout = output
         if name.startswith("test_"):
             sys.stderr.write("%s ... " % name)
             # It's either a unittest or a print-and-compare test
             loader = unittest.TestLoader()
             suite = loader.loadTestsFromName(name)
             if hasattr(loader, "errors") and loader.errors:
                 # New in Python 3.5, don't always get an exception anymore
                 # Instead this is a list of error messages as strings
                 for msg in loader.errors:
                     if "Bio.MissingExternalDependencyError: " in msg or \
                             "Bio.MissingPythonDependencyError: " in msg:
                         # Remove the traceback etc
                         msg = msg[msg.find("Bio.Missing"):]
                         msg = msg[msg.find("Error: "):]
                         sys.stderr.write("skipping. %s\n" % msg)
                         return True
                 # Looks like a real failure
                 sys.stderr.write("loading tests failed:\n")
                 for msg in loader.errors:
                     sys.stderr.write("%s\n" % msg)
                 return False
             if suite.countTestCases() == 0:
                 # This is a print-and-compare test instead of a
                 # unittest-type test.
                 test = ComparisonTestCase(name, output)
                 suite = unittest.TestSuite([test])
         else:
             # It's a doc test
             sys.stderr.write("%s docstring test ... " % name)
             module = __import__(name, fromlist=name.split("."))
             suite = doctest.DocTestSuite(module,
                                          optionflags=doctest.ELLIPSIS)
             del module
         suite.run(result)
         if self.testdir != os.path.abspath("."):
             sys.stderr.write("FAIL\n")
             result.stream.write(result.separator1 + "\n")
             result.stream.write("ERROR: %s\n" % name)
             result.stream.write(result.separator2 + "\n")
             result.stream.write("Current directory changed\n")
             result.stream.write("Was: %s\n" % self.testdir)
             result.stream.write("Now: %s\n" % os.path.abspath("."))
             os.chdir(self.testdir)
             if not result.wasSuccessful():
                 result.printErrors()
             return False
         elif result.wasSuccessful():
             sys.stderr.write("ok\n")
             return True
         else:
             sys.stderr.write("FAIL\n")
             result.printErrors()
         return False
     except MissingExternalDependencyError as msg:
         # Seems this isn't always triggered on Python 3.5,
         # exception messages can be in loader.errors instead.
         sys.stderr.write("skipping. %s\n" % msg)
         return True
     except Exception as msg:
         # This happened during the import
         sys.stderr.write("ERROR\n")
         result.stream.write(result.separator1 + "\n")
         result.stream.write("ERROR: %s\n" % name)
         result.stream.write(result.separator2 + "\n")
         result.stream.write(traceback.format_exc())
         return False
     except KeyboardInterrupt as err:
         # Want to allow this, and abort the test
         # (see below for special case)
         raise err
     except:
         # This happens in Jython with java.lang.ClassFormatError:
         # Invalid method Code length ...
         sys.stderr.write("ERROR\n")
         result.stream.write(result.separator1 + "\n")
         result.stream.write("ERROR: %s\n" % name)
         result.stream.write(result.separator2 + "\n")
         result.stream.write(traceback.format_exc())
         return False
     finally:
         sys.stdout = stdout
         # Running under PyPy we were leaking file handles...
         gc.collect()
Пример #29
0
def doctests():
    import doctest
    return doctest.DocTestSuite()
Пример #30
0
def mainTest(*testClasses, **kwargs):
    '''
    Takes as its arguments modules (or a string 'noDocTest' or 'verbose')
    and runs all of these modules through a unittest suite

    Unless 'noDocTest' is passed as a module, a docTest
    is also performed on `__main__`, hence the name "mainTest".

    If 'moduleRelative' (a string) is passed as a module, then
    global variables are preserved.

    Run example (put at end of your modules):

    ::

        import unittest
        class Test(unittest.TestCase):
            def testHello(self):
                hello = "Hello"
                self.assertEqual("Hello", hello)

        import music21
        if __name__ == '__main__':
            music21.mainTest(Test)


    This module tries to fix up some differences between python2 and python3 so
    that the same doctests can work.
    '''

    runAllTests = True

    # default -- is fail fast.
    failFast = bool(kwargs.get('failFast', True))
    if failFast:
        optionflags = (doctest.ELLIPSIS | doctest.NORMALIZE_WHITESPACE
                       | doctest.REPORT_ONLY_FIRST_FAILURE)
    else:
        optionflags = (doctest.ELLIPSIS | doctest.NORMALIZE_WHITESPACE)

    globs = None
    if ('noDocTest' in testClasses or 'noDocTest' in sys.argv
            or 'nodoctest' in sys.argv
            or bool(kwargs.get('noDocTest', False))):
        skipDoctest = True
    else:
        skipDoctest = False

    # start with doc tests, then add unit tests
    if skipDoctest:
        # create a test suite for storage
        s1 = unittest.TestSuite()
    else:
        # create test suite derived from doc tests
        # here we use '__main__' instead of a module
        if ('moduleRelative' in testClasses or 'moduleRelative' in sys.argv
                or bool(kwargs.get('moduleRelative', False))):
            pass
        else:
            for di in defaultImports:
                globs = __import__(di).__dict__.copy()
            if ('importPlusRelative' in testClasses
                    or 'importPlusRelative' in sys.argv
                    or bool(kwargs.get('importPlusRelative', False))):
                globs.update(globals())

        try:
            s1 = doctest.DocTestSuite(
                '__main__',
                globs=globs,
                optionflags=optionflags,
            )
        except ValueError as ve:  # no docstrings
            print("Problem in docstrings [usually a missing r value before " +
                  "the quotes:] {0}".format(str(ve)))
            s1 = unittest.TestSuite()

    verbosity = 1
    if ('verbose' in testClasses or 'verbose' in sys.argv
            or bool(kwargs.get('verbose', False))):
        verbosity = 2  # this seems to hide most display

    displayNames = False
    if ('list' in sys.argv or 'display' in sys.argv
            or bool(kwargs.get('display', False))
            or bool(kwargs.get('list', False))):
        displayNames = True
        runAllTests = False

    runThisTest = None
    if len(sys.argv) == 2:
        arg = sys.argv[1].lower()
        if arg not in ('list', 'display', 'verbose', 'nodoctest'):
            # run a test directly named in this module
            runThisTest = sys.argv[1]
    if bool(kwargs.get('runTest', False)):
        runThisTest = kwargs.get('runTest', False)

    # -f, --failfast
    if ('onlyDocTest' in sys.argv or 'onlyDocTest' in testClasses
            or bool(kwargs.get('onlyDocTest', False))):
        testClasses = []  # remove cases
    for t in testClasses:
        if not isinstance(t, str):
            if displayNames is True:
                for tName in unittest.defaultTestLoader.getTestCaseNames(t):
                    print('Unit Test Method: %s' % tName)
            if runThisTest is not None:
                tObj = t()  # call class
                # search all names for case-insensitive match
                for name in dir(tObj):
                    if (name.lower() == runThisTest.lower()
                            or name.lower() == ('test' + runThisTest.lower())
                            or name.lower()
                            == ('xtest' + runThisTest.lower())):
                        runThisTest = name
                        break
                if hasattr(tObj, runThisTest):
                    print('Running Named Test Method: %s' % runThisTest)
                    tObj.setUp()
                    getattr(tObj, runThisTest)()
                    runAllTests = False
                    break
                else:
                    print(
                        'Could not find named test method: %s, running all tests'
                        % runThisTest)

            # normally operation collects all tests
            s2 = unittest.defaultTestLoader.loadTestsFromTestCase(t)
            s1.addTests(s2)

    ### Add _DOC_ATTR tests...
    if not skipDoctest:
        stacks = inspect.stack()
        if len(stacks) > 1:
            outerFrameTuple = stacks[1]
        else:
            outerFrameTuple = stacks[0]
        outerFrame = outerFrameTuple[0]
        outerFilename = outerFrameTuple[1]
        localVariables = list(outerFrame.f_locals.values())
        addDocAttrTestsToSuite(s1, localVariables, outerFilename, globs,
                               optionflags)

    if runAllTests is True:
        fixDoctests(s1)

        runner = unittest.TextTestRunner()
        runner.verbosity = verbosity
        unused_testResult = runner.run(s1)