"moduleclass = 'tools' ", # trailing whitespace '', ] line_numbers = range(1, len(lines) + 1) state = {} test_cases = [ None, (17, "W299 trailing whitespace"), (0, "W293 blank line contains whitespace"), None, None, None, (21, "W299 trailing whitespace"), ] for (line, line_number, expected_result) in zip(lines, line_numbers, test_cases): result = _eb_check_trailing_whitespace(line, lines, line_number, state) self.assertEqual(result, expected_result) def suite(): """Return all style tests for easyconfigs.""" return TestLoaderFiltered().loadTestsFromTestCase(StyleTest, sys.argv[1:]) if __name__ == '__main__': res = TextTestRunner(verbosity=1).run(suite()) sys.exit(len(res.failures))
def run_docstring_tests(module): runner = TextTestRunner() s = runner.run(doctest.DocTestSuite(module)) assert 0 == len(s.failures)
""" Runs all tests in this directory Note: Only test file with names: test*.py are executed Version: 2018-09-19 DWW """ import os from unittest import TestLoader, TextTestRunner start = os.getcwd() suite = TestLoader().discover(start) result = TextTestRunner().run(suite)
def main(): option_parser, opts, args = parse_command_line_parameters(**script_info) if opts.haiku: print "QIIME provides insight\nmicrobial in nature\nto ecology" exit(0) qiime_config = load_qiime_config() test = opts.test qiime_base_install = opts.qiime_base_install rdp_jarpath = get_rdp_jarpath() if rdp_jarpath is None: rdp_version = "Not installed." else: rdp_version = split(rdp_jarpath)[1] java_version = get_java_version() if java_version is None: java_version = "Not installed." system_info = [("Platform", platform), ("Python version", python_version.replace('\n', ' ')), ("Python executable", executable)] max_len = max([len(e[0]) for e in system_info]) print "\nSystem information" print "==================" for v in system_info: print "%*s:\t%s" % (max_len, v[0], v[1]) version_info = [("NumPy version", numpy_lib_version), ("SciPy version", scipy_lib_version), ("matplotlib version", matplotlib_lib_version), ("biom-format version", biom_lib_version), ("qcli version", qcli_lib_version), ("pyqi version", pyqi_lib_version), ("scikit-bio version", skbio_lib_version), ("QIIME library version", get_qiime_library_version()), ("QIIME script version", __version__), ("PyNAST version (if installed)", pynast_lib_version), ("Emperor version", emperor_lib_version)] if not qiime_base_install: version_info += [("RDP Classifier version (if installed)", rdp_version), ("Java version (if installed)", java_version)] max_len = max([len(e[0]) for e in version_info]) print "\nDependency versions" print "===================" for v in version_info: print "%*s:\t%s" % (max_len, v[0], v[1]) print "\nQIIME config values" print "===================" max_len = max([len(key) for key in qiime_config]) for key, value in qiime_config.items(): print "%*s:\t%s" % (max_len, key, value) if test: if qiime_base_install: suite = TestLoader().loadTestsFromTestCase(QIIMEDependencyBase) else: suite = TestLoader().loadTestsFromTestCase(QIIMEDependencyFull) if opts.verbose: verbosity = 2 else: verbosity = 1 TextTestRunner(stream=stdout, verbosity=verbosity).run(suite)
"""Implement test runner.""" import sys from unittest import TextTestRunner from tests import suite runner = TextTestRunner(verbosity=2) ret = not runner.run(suite).wasSuccessful() sys.exit(ret)
def __init__(self): self.runner = TextTestRunner(verbosity=2)
def run_test(test): suite = TestSuite() suite.addTest(test) TextTestRunner().run(suite)
def main(): logging.basicConfig(level=logging.ERROR) suite = full_suite() TextTestRunner().run(suite) return
if __name__ == '__main__': usage = '%prog [OPTIONS]' description = 'Run ikaaro tests' parser = OptionParser(usage, description=description) parser.add_option('-m', '--mode', default='standard', help='tests mode') options, args = parser.parse_args() # Remove old test database if exists path = 'demo.hforge.org' if lfs.exists(path): lfs.remove(path) # Create test server create_server(path, '*****@*****.**', 'password', 'ikaaro', website_languages=['en', 'fr']) # Launch test suite = TestSuite() for module in test_modules: suite.addTest(loader.loadTestsFromModule(module)) if options.mode == 'standard': ret = TextTestRunner(verbosity=1).run(suite) elif options.mode == 'junitxml': path = get_abspath('./junit.xml') print('Result is here: %s' % path) f = file(path, 'wb') result = JUnitXmlResult(f) result.startTestRun() ret = suite.run(result) result.stopTestRun() exit_code = not ret.wasSuccessful() exit(exit_code)
def setUp(self): self.conman = ContractsManager(self.contracts) self.results = TextTestRunner()._makeResult() self.results.stream = None
def test_all(): TextTestRunner(verbosity=2).run(suite)
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 = TestSuite([TestLoader().loadTestsFromModule(m) for m in modules]) # Add doctests from the unittest modules to the suite optionflags = doctest.ELLIPSIS | doctest.NORMALIZE_WHITESPACE for mod in modules: try: suite.addTest(doctest.DocTestSuite(mod, optionflags=optionflags)) except ValueError: # No tests found. pass return suite if __name__ == '__main__': setUpLogging() runner = TextTestRunner() runner.run(make_test_suite())
"""Main entry point for all unit tests """ import sys from pathlib import Path from unittest import TestLoader, TestSuite, TextTestRunner sys.path.append(Path(__file__).absolute().parents[1].as_posix()) try: from parsers_test.test_sdl_rpc_v2 import TestSDLRPCV2Parser from test_model import TestInterfaceModel from test_code_format_and_quality import CodeFormatAndQuality except ModuleNotFoundError as error: print('{}.\nProbably you did not initialize submodule'.format(error)) sys.exit(1) if __name__ == '__main__': SUITE = TestSuite() SUITE.addTests(TestLoader().loadTestsFromTestCase(TestSDLRPCV2Parser)) SUITE.addTests(TestLoader().loadTestsFromTestCase(TestInterfaceModel)) SUITE.addTests(TestLoader().loadTestsFromTestCase(CodeFormatAndQuality)) RUNNER = TextTestRunner(verbosity=2) TEST_RESULT = RUNNER.run(SUITE) print(TEST_RESULT)
self.sim.doRun(self.sim.getCurrentTime() + 100000) # +100µs self.assertPin("B3", self._state_1) self.assertPin("B4", self._state_0) t = self.assertPinChange("B3", "B4") self.sim.doRun(self.sim.getCurrentTime() + 30000) # +30µs self.assertWordValue("timer_ticks_overflow", 1) self.assertWordValue("timer_ticks_compare_b", 0) # next compare event, 64µs later t = self.assertPinChange("B3", "B4", 64000 - (self.sim.getCurrentTime() - t)) self.sim.doRun(self.sim.getCurrentTime() + 30000) # +30µs self.assertWordValue("timer_ticks_overflow", 1) self.assertWordValue("timer_ticks_compare_b", 1) # next overflow event, 64µs later t = self.assertPinChange("B3", "B4", 64000 - (self.sim.getCurrentTime() - t)) self.sim.doRun(self.sim.getCurrentTime() + 30000) # +30µs self.assertWordValue("timer_ticks_overflow", 2) self.assertWordValue("timer_ticks_compare_b", 1) # next compare event, 64µs later t = self.assertPinChange("B3", "B4", 64000 - (self.sim.getCurrentTime() - t)) self.sim.doRun(self.sim.getCurrentTime() + 30000) # +30µs self.assertWordValue("timer_ticks_overflow", 2) self.assertWordValue("timer_ticks_compare_b", 2) if __name__ == '__main__': from unittest import TextTestRunner tests = SimTestLoader("timer_tX5_8bit_pwm_attiny25.elf").loadTestsFromTestCase(TestCase) TextTestRunner(verbosity = 2).run(tests) # EOF
from airflow.models import DagBag from unittest import TestCase, TestLoader, TextTestRunner # write tests for the dag here class TestDagIntegrity(TestCase): def setUp(self): self.dagbag = DagBag() def test_import_dags(self): '''smoketest for the dagbag''' self.assertFalse( len(self.dagbag.import_errors), 'DAG import failed. Errors: {}'.format(self.dagbag.import_errors)) if __name__ == "__main__": suite = TestLoader().loadTestsFromTestCase(TestDagIntegrity) TextTestRunner(verbosity=2).run(suite)
def test(verbosity=1): suite =TestSuite() for module in modules: suite.addTests(TestLoader().loadTestsFromModule(module)) return TextTestRunner(verbosity=verbosity).run(suite)