"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)
