def test():
# Run a Single Test Case
suite = unittest.TestSuite()
suite.addTests(unittest.TestLoader().loadTestsFromName(
"test_Grover.Test_Grover.test_grover2"))
runner = TextTestRunner(verbosity=2)
runner.run(suite)
def test():
# Run all test cases
case_dir = ".\\"
discover = unittest.defaultTestLoader.discover(case_dir,
pattern="test_*.py",
top_level_dir=None)
runner = TextTestRunner(verbosity=2)
runner.run(discover)
def main() -> None:
args = parse_args()
suite = defaultTestLoader.discover(_tests_,
top_level_dir=_parent_,
pattern=args.pattern)
runner = TextTestRunner(
verbosity=args.verbosity,
failfast=args.fail,
buffer=args.buffer,
)
installHandler()
runner.run(suite)
def run(self):
global THIS_PATH, PKG_DIR, TEST_DIR
sys.path.insert(0, PKG_DIR)
suite = TestSuite()
loaded = unittest.defaultTestLoader.discover(TEST_DIR, pattern='*Test.py')
for all_test_suite in loaded:
for test_suite in all_test_suite:
suite.addTests(test_suite)
runner = TextTestRunner(verbosity = 2)
runner.run(suite)
def run_test_suite(test_suite, title=u'测试', description='', export_file=None):
'''
运行test suite
@param export_file: if export_file is not None, then run the html test runner to dump test report
@return: text test result
'''
if export_file is None:
runner = TextTestRunner()
return runner.run(suite)
else:
fp = file(export_file, "wb")
runner = HTMLTestRunner.HTMLTestRunner(stream=fp, title=title, description=description)
text_result = runner.run(suite)
return text_result
def run_tests(self):
# If we perform this input at the top of the file, we get an
# import error because we need to load this file to discover
# dependenices.
tests = TestLoader().discover("tests", pattern="test_*.py")
runner = TextTestRunner()
result = runner.run(tests)
exit(0 if result.wasSuccessful() else 1)
def invoked(self, ns):
# Load tests selected on command line
tests = ns.suite_loader()
# Use standard unittest runner, it has somewhat annoying way of
# displaying test progress but is well-known and will do for now.
runner = TextTestRunner(verbosity=ns.verbosity, failfast=ns.fail_fast)
result = runner.run(tests)
# Forward the successfulness of the test suite as the exit code
return 0 if result.wasSuccessful() else 1
def invoked(self, ns):
# Load tests selected on command line
tests = ns.suite_loader()
# Use standard unittest runner, it has somewhat annoying way of
# displaying test progress but is well-known and will do for now.
runner = TextTestRunner(verbosity=ns.verbosity, failfast=ns.fail_fast)
result = runner.run(tests)
# Forward the successfulness of the test suite as the exit code
return 0 if result.wasSuccessful() else 1
def invoked(self, ns):
# Use standard unittest runner, it has somewhat annoying way of
# displaying test progress but is well-known and will do for now.
runner = TextTestRunner(verbosity=ns.verbosity, failfast=ns.fail_fast)
loader = TestLoader()
# Discover all integration tests
tests = loader.discover(get_plainbox_dir(), pattern="integration_*.py")
result = runner.run(tests)
# Forward the successfulness of the test suite as the exit code
return 0 if result.wasSuccessful() else 1
def run(self, test):
result_test = TextTestRunner.run(self, test)
try:
if self.extension["requested"]:
self.result["stop_test"] = datetime.now()
self.result["tests"] = result_test.result
use_readable_format(self.result)
self.ext_class.generate_document(self.config_file, self.result, result_test, **self.kwdict)
except Exception, e:
print_exception()
print "Problem to execute the extension [%s]" % e
def run_tests():
out_stream = StringIO()
runner = TextTestRunner(resultclass=TestResultWithSuccess,
stream=out_stream)
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(DatabaseIntegrityTests))
suite.addTest(unittest.makeSuite(ModelTests))
suite.addTest(unittest.makeSuite(RouteTests))
suite.addTest(unittest.makeSuite(RouteUtilityTests))
suite.addTest(unittest.makeSuite(SearchTests))
suite.addTest(unittest.makeSuite(SearchResultClassTests))
result = runner.run(suite)
return (result, out_stream)
def run(self, ns):
# If asked to, re-execute without locale
if ns.reexec and sys.platform != 'win32':
self._reexec_without_locale()
if isinstance(self.loader, str):
suite = defaultTestLoader.loadTestsFromName(self.loader)
else:
suite = self.loader()
# Use standard unittest runner, it has somewhat annoying way of
# displaying test progress but is well-known and will do for now.
runner = TextTestRunner(verbosity=ns.verbosity, failfast=ns.fail_fast)
result = runner.run(suite)
# Forward the successfulness of the test suite as the exit code
return 0 if result.wasSuccessful() else 1
def main() -> int:
args = _parse_args()
suite = defaultTestLoader.discover(
str(_TESTS), top_level_dir=str(_TOP_LV.parent), pattern=args.pattern
)
runner = TextTestRunner(
verbosity=args.verbosity,
failfast=args.fail,
buffer=args.buffer,
)
installHandler()
r = runner.run(suite)
return not r.wasSuccessful()
def runtests(failfast, quiet, verbose, buffer, integration_config,
integration_git_server, integration_git_staging, tests):
verbosity = 1
if quiet:
verbosity = 0
if verbose:
verbosity = 2
if integration_config is not None:
config = ConfigParser()
config.readfp(integration_config)
else:
config = None
runner = TextTestRunner(verbosity=verbosity,
failfast=failfast,
buffer=buffer)
ran = False
if tests in ("all", "all_unit"):
ran = True
runner.run(all_unittests)
if tests in unit_tests:
ran = True
runner.run(unit_tests[tests])
if tests in integration_tests:
ran = True
test_class = integration_tests[tests]
suite = unittest.TestSuite()
for name in unittest.TestLoader().getTestCaseNames(test_class):
test = test_class(name)
configure_integration_test(test, config, integration_git_server,
integration_git_staging)
suite.addTest(test)
runner.run(suite)
if not ran:
# TODO: Try to instantiate specific test
try:
suite = unittest.TestLoader().loadTestsFromName(tests)
runner.run(suite)
except AttributeError, ae:
print "Unknown test: %s" % tests
def runtests(failfast, quiet, verbose, buffer,
integration_config, integration_git_server, integration_git_staging,
tests):
verbosity = 1
if quiet:
verbosity = 0
if verbose:
verbosity = 2
if integration_config is not None:
config = ConfigParser()
config.readfp(integration_config)
else:
config = None
runner = TextTestRunner(verbosity=verbosity, failfast=failfast, buffer=buffer)
ran = False
if tests in ("all", "all_unit"):
ran = True
runner.run(all_unittests)
if tests in unit_tests:
ran = True
runner.run(unit_tests[tests])
if tests in integration_tests:
ran = True
test_class = integration_tests[tests]
suite = unittest.TestSuite()
for name in unittest.TestLoader().getTestCaseNames(test_class):
test = test_class(name)
configure_integration_test(test, config, integration_git_server, integration_git_staging)
suite.addTest(test)
runner.run(suite)
if not ran:
# TODO: Try to instantiate specific test
try:
suite = unittest.TestLoader().loadTestsFromName(tests)
runner.run(suite)
except AttributeError, ae:
print "Unknown test: %s" % tests
def main() -> int:
args = _parse_args()
suite = defaultTestLoader.discover(normcase(_TESTS),
top_level_dir=normcase(_ROOT),
pattern="*.py")
names = {*_names(args.paths)}
tests = (test for test in _tests(suite)
if not names or test.__module__ in names)
runner = TextTestRunner(
verbosity=args.verbosity,
failfast=args.fail,
buffer=args.buffer,
)
installHandler()
r = runner.run(TestSuite(tests))
return not r.wasSuccessful()
self.logInfo("Step 4 - Click on 'Log in' button")
self.login(self.browser, self.username, self.password)
self.logInfo("Step 5 - Select Content > Article Manager")
self.navigateMenu(self.browser, "Content>Article Manager")
self.logInfo("Step 6 - Click on 'New' icon of the top right toolbar ")
self.logInfo("Step 7 - Enter a title on 'Title' text field ")
self.logInfo("Step 8 - Select an item from the 'Category' dropdown list ")
self.logInfo("Step 9 - Enter value on 'Article Text' text area ")
self.logInfo("Step 10 - Select 'Public' item from the 'Access' dropdown list ")
self.logInfo("Step 11 - Click on 'Save & Close' icon of the top right toolbar ")
self.createNewArticleByButton(self.browser, self.title, self.category, self.text, self.option, self.status, self.insert, self.access)
self.logInfo("Step 12 - Verify the article is saved successfully")
#VP: 1. "Article successfully saved" message is displayed
self.checkMessageDisplay(self.browser, "Article successfully saved")
#VP: 2. Created article is displayed on the articles table
self.checkArticleCreated(self.browser, self.title)
#VP: 3. The Access Level of the article is displayed as 'Public'
self.checkAccessLevelValue(self.browser, self.title, "Access", "Public")
#VP: 4. Created article's information is displayed correctly
self.checkArticleInformation(self.browser, self.title, self.title, self.category, self.text, self.access)
if __name__ == '__main__':
tests = ["test_TC07ArticleChangeStatus", "test_TC08ArticleChangeFeature", "test_TC09ArticleCreateWithAccessLevel"]
suite = unittest.TestSuite(map(Ex05Article, tests))
runner = TextTestRunner()
runner.run(suite)
def __init__(self, discovery_dir='.', discovery_pattern='test*.py', output_file='test_results.html', silent=False, verbosity=2):
test_groups = {}
loader = TestLoader()
groups_data = {}
summary_data = {
'discovery_dir' : discovery_dir,
'discovery_pattern' : discovery_pattern,
'num_groups' : 0,
'num_groups_fail' : 0,
'num_groups_pass' : 0,
'num_tests' : 0,
'num_tests_fail' : 0,
'num_tests_pass' : 0,
'num_tests_skip' : 0,
'raw_log' : ''
}
# Discovery tests from specified directory
tests = loader.discover(discovery_dir, discovery_pattern)
# Group tests by file
for group in tests:
group_name = None
for suite in group:
# Determine group name
if hasattr(suite, '_testMethodName'):
test_groups[suite._testMethodName] = group
else:
for test in suite:
test_groups[inspect.getmodule(test).__name__] = group
break
# Run tests for each group
for group_name, tests in test_groups.items():
raw_log = StringIO()
runner = TextTestRunner(stream=TestRunner.StreamRouter(raw_log, silent), verbosity=verbosity)
result = runner.run(tests)
# Index errors by test class
errors = {}
for error in result.errors:
errors['{0}.{1}'.format(error[0].__class__.__name__, error[0]._testMethodName)] = error[1]
# Marshall/record data
group_data = {
'tests' : []
}
group_data['tests_errored'] = len(result.errors)
group_data['tests_passed'] = result.testsRun - group_data['tests_errored']
group_data['tests_skipped'] = len(result.skipped)
group_data['tests_run'] = result.testsRun
summary_data['num_groups'] += 1
summary_data['num_tests'] += group_data['tests_run'] + group_data['tests_skipped']
summary_data['num_tests_fail'] += group_data['tests_errored']
summary_data['num_tests_pass'] += group_data['tests_passed']
summary_data['num_tests_skip'] += group_data['tests_skipped']
summary_data['raw_log'] += raw_log.getvalue()
if group_data['tests_errored'] > 0:
summary_data['num_groups_fail'] += 1
else:
summary_data['num_groups_pass'] += 1
# Detailed test data
for suite in tests:
cls_name = suite.__class__.__name__
if cls_name == 'ModuleImportFailure' or cls_name == 'LoadTestsFailure':
# Record loader failure
group_data['tests'].append({
'name' : suite._testMethodName,
'status' : 'fail',
'description' : errors['{0}.{1}'.format(suite.__class__.__name__, suite._testMethodName)]
})
else:
for t in suite:
signature = '{0}.{1}'.format(t.__class__.__name__, t._testMethodName)
test_data = {'name' : '{0}.{1}'.format(group_name, signature)}
if signature in errors:
test_data['status'] = 'fail'
test_data['description'] = errors[signature]
else:
test_data['description'] = '';
test_data['status'] = 'pass'
group_data['tests'].append(test_data)
groups_data[group_name] = group_data
# Write results
if summary_data['num_tests'] > 0:
results.PageBuilder(groups_data, summary_data).generate_html(output_file)
print 'Results available at {0}'.format(os.path.realpath(output_file))
else:
print 'No tests run; no results to publish.'
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import unittest
from unittest.runner import TextTestRunner
from tests.fromJsonToHdl_test import FromJsonToHdlTC
def main_test_suite():
suite = unittest.TestSuite()
tcs = [
FromJsonToHdlTC,
]
for tc in tcs:
suite.addTest(unittest.makeSuite(tc))
return suite
suite = main_test_suite()
if __name__ == "__main__":
runner = TextTestRunner(verbosity=3)
runner.run(suite)
#!/usr/bin/env python3
from unittest.loader import TestLoader
from unittest.runner import TextTestRunner
if __name__ == '__main__':
loader = TestLoader()
runner = TextTestRunner()
suites = loader.discover("nrf5_cmake", "*.py", ".")
runner.run(suites)
#! /usr/bin/python
# -*- coding: utf-8 -*-
"""Discover all tests (except the ones inside test_fa.py) and run them."""
from unittest import defaultTestLoader
from unittest.runner import TextTestRunner
import config
if __name__ == '__main__':
config.LANG = 'en'
tests = defaultTestLoader.discover('.', '*_test.py')
runner = TextTestRunner()
runner.run(tests)
def run_tests(self):
tests = TestLoader().discover("tests", pattern="test_*.py")
runner = TextTestRunner()
result = runner.run(tests)
exit(0 if result.wasSuccessful() else 1)
#! /usr/bin/python
# -*- coding: utf-8 -*-
"""Discover all tests (except the ones inside test_fa.py) and run them."""
from unittest import defaultTestLoader
from unittest.runner import TextTestRunner
import config
if __name__ == '__main__':
config.LANG = 'en'
tests = defaultTestLoader.discover('.', '*_test.py')
runner = TextTestRunner()
runner.run(tests)
from unittest import TestLoader
from unittest.runner import TextTestRunner
test_loader = TestLoader()
tests = test_loader.discover('src/mousetrap')
test_runner = TextTestRunner()
test_runner.run(tests)
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
test_loader = TestLoader()
test_runner = TextTestRunner()
os.environ['CELERY_CONFIG_MODULE'] = 'pmworker.config.test'
setup_logging()
parser = argparse.ArgumentParser()
parser.add_argument('-p',
'--pattern',
default='test*py',
help='Test files pattern.')
args = parser.parse_args()
if args.pattern.endswith('py'):
discovery_pattern = args.pattern
else:
discovery_pattern = args.pattern + "*"
tests = test_loader.discover(start_dir=BASE_DIR, pattern=discovery_pattern)
result = test_runner.run(tests)
if not result.wasSuccessful():
sys.exit(1)
def run(self, test):
"""Stores the total count of test cases, then calls super impl"""
self.total_test_cases = test.countTestCases()
return TextTestRunner.run(self, test)
