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 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 test_unittest(capsys):
runner = TextTestRunner(verbosity=2, stream=sys.stdout)
path = join(example_dir, 'example_unittest')
main = unittest_main(exit=False,
module=None,
testRunner=runner,
argv=['x', 'discover', '-s', path, '-t', path])
assert main.result.testsRun == 3
assert len(main.result.failures) == 0
assert len(main.result.errors) == 0
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 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 main():
dt_suite = doctest.DocTestSuite(test_finder=doctest.DocTestFinder(
recurse=True))
dt_suite.countTestCases()
dt_suite.debug()
if pytest is None:
suite = TestSuite()
all_test_suites = unittest.defaultTestLoader.discover(start_dir="test")
suite.addTests(tests=[all_test_suites, dt_suite])
logging.debug(vars(suite))
successful = TextTestRunner().run(suite).wasSuccessful()
return 0 if successful else 1
else:
pytest.main(plugins=[])
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 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 test_unittest(capsys):
runner = TextTestRunner(verbosity=2, stream=sys.stdout)
path = join(functional_test_dir, 'functional_unittest')
main = unittest_main(exit=False,
module=None,
testRunner=runner,
argv=['x', 'discover', '-v', '-t', path, '-s', path])
out, err = capsys.readouterr()
assert err == ''
out = Finder(out)
common_checks(out)
out.then_find('Ran 8 tests')
assert main.result.testsRun == 8
assert len(main.result.failures) == 1
assert len(main.result.errors) == 1
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()
def test_package(*package_names):
tests = []
test_loader = TestLoader()
for module_name, module in sys.modules.items():
for package_name in package_names:
if module_name.startswith('{}.'.format(package_name)):
module_tests = test_loader.loadTestsFromModule(module)
module_tests = [
t for t in module_tests if is_test_suite_loaded(t)
]
tests.extend(module_tests)
break
test_result = TextTestRunner(failfast=True,
resultclass=TimedTextTestResult).run(
TestSuite(tests))
if not test_result.wasSuccessful():
raise Exception('test failed')
def __init__(self):
'''
Constructor
'''
parser = ArgumentParser(epilog = 'ACTC Test Runner')
parser.add_argument('-c', '--coverage',
action = 'store_true',
help = 'activate code coverage measurement')
args = parser.parse_args()
if (args.coverage):
from coverage import coverage
cov = coverage(include = 'src/*',
omit = '*/test/*.py')
# actc.cli
cov.exclude('Exception')
cov.exclude('parser.error')
# actc.dodo
cov.exclude('NotImplementedError')
cov.start()
# end if
TextTestRunner(verbosity = 2).run(TestLoader().discover('src'))
if (args.coverage):
cov.stop()
cov.html_report(directory = 'coverage',
title = 'ACTC code coverage')
print('See coverage/index.html report')
assert (self.device.GetPin(self.LED2).toChar() == "H")
self.doRun(2500000) # 25ms
assert (self.device.GetPin(self.LED1).toChar() == "H")
assert (self.device.GetPin(self.LED2).toChar() == "H")
self.doRun(2500000) # 25ms
assert (self.device.GetPin(self.LED1).toChar() == "H")
assert (self.device.GetPin(self.LED2).toChar() == "H")
# Deuxieme seconde
self.doRun(2500000) # 25ms
assert (self.device.GetPin(self.LED1).toChar() == "L")
assert (self.device.GetPin(self.LED2).toChar() == "H")
self.doRun(2500000) # 25ms
assert (self.device.GetPin(self.LED1).toChar() == "L")
assert (self.device.GetPin(self.LED2).toChar() == "H")
self.doRun(2500000) # 25ms
assert (self.device.GetPin(self.LED1).toChar() == "L")
assert (self.device.GetPin(self.LED2).toChar() == "H")
self.doRun(2500000) # 25ms
assert (self.device.GetPin(self.LED1).toChar() == "L")
assert (self.device.GetPin(self.LED2).toChar() == "H")
self.doRun(2500000) # 25ms
assert (self.device.GetPin(self.LED1).toChar() == "L")
assert (self.device.GetPin(self.LED2).toChar() == "L")
if __name__ == "__main__":
allTestsFrom = defaultTestLoader.loadTestsFromTestCase
suite = TestSuite()
suite.addTests(allTestsFrom(TestEx1Semaine2))
TextTestRunner(verbosity=2).run(suite)
#!/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)
# -*- coding: utf-8 -*-
from sys import exit
from unittest.loader import defaultTestLoader
from unittest.runner import TextTestRunner
from unittest.suite import TestSuite
if __name__ == '__main__':
中研院服務試驗包 = TestSuite()
中研院服務試驗包.addTest(defaultTestLoader.discover('.',
pattern='Test中研院*整合試驗.py'))
試驗結果 = TextTestRunner().run(中研院服務試驗包)
if len(試驗結果.errors) > 0 or len(試驗結果.failures) > 0:
exit(1)
def __call__(self, *args, **kwargs):
kwargs['resultclass'] = TextTestResult
return TextTestRunner(buffer=self.buffer, *args, **kwargs)
def run_tests(self):
tests = TestLoader().discover("tests", pattern="test_*.py")
runner = TextTestRunner()
result = runner.run(tests)
exit(0 if result.wasSuccessful() else 1)
# np.testing.assert_allclose(qx2,qxnum2,rtol=1e-5,atol=1e-8)
# np.testing.assert_allclose(qy2,qynum2,rtol=1e-5,atol=1e-8)
#def test_ellip_inhom_with_well(self):
# ml = ModelMaq(kaq=[4,5],z=[4,2,1,0],c=[100],Saq=[1e-3,1e-4],Sll=[1e-6],tmin=1,tmax=10,M=20)
# w = DischargeWell(ml,xw=.5,yw=0,rw=.1,tsandQ=[0,5.0],layers=1)
# e1a = EllipseInhomDataMaq(ml,0,0,along=2.0,bshort=1.0,angle=0.0,kaq=[10,2],z=[4,2,1,0],c=[200],Saq=[2e-3,2e-4],Sll=[1e-5])
# e1 = EllipseInhom(ml,0,0,along=2.0,bshort=1.0,angle=0.0,order=5)
# ml.solve()
# h1,h2 = np.zeros((2,e1.Ncp)), np.zeros((2,e1.Ncp))
# qn1,qn2 = np.zeros((2,e1.Ncp)), np.zeros((2,e1.Ncp))
# for i in range(e1.Ncp):
# h1[:,i] = ml.head(e1.xc[i],e1.yc[i],2,aq=e1.aqin)[:,0]
# h2[:,i] = ml.head(e1.xc[i],e1.yc[i],2,aq=e1.aqout)[:,0]
# qx1,qy1 = ml.discharge(e1.xc[i],e1.yc[i],2,aq=e1.aqin)
# qx2,qy2 = ml.discharge(e1.xc[i],e1.yc[i],2,aq=e1.aqout)
# a = e1a.outwardnormalangle(e1.xc[i],e1.yc[i])
# qn1[:,i] = qx1[:,0]*np.cos(a) + qy1[:,0]*np.sin(a)
# qn2[:,i] = qx2[:,0]*np.cos(a) + qy2[:,0]*np.sin(a)
# np.testing.assert_allclose(h1,h2,rtol=1e-4,atol=1e-8)
# np.testing.assert_allclose(qn1,qn2,rtol=1e-3,atol=1e-8)
#
#if __name__ == '__main__':
# unittest.main(verbosity=2)
if __name__ == '__main__':
import sys
from unittest.runner import TextTestRunner
unittest.main(testRunner=TextTestRunner(stream=sys.stderr))
def all_tests_pass(tests):
return TextTestRunner().run(tests).wasSuccessful()
import os
import sys
import argparse
from unittest.loader import TestLoader
from unittest.runner import TextTestRunner
from pmworker import setup_logging
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 + "*"
return tempfile.mkdtemp(dir="/run/user/{}".format(os.geteuid()))
except OSError:
return tempfile.mkdtemp()
def _init_X_y(size, random=True):
'''@return (X, y) of given size'''
X = [(1, 0)] * size
X.extend([(0, 1)] * size)
if random:
X = np.array(X).astype('float64')
X += np.random.random_sample(X.shape) * 0.8 - 0.4
y = [1] * size
y.extend([-1] * size)
return (X, y)
def _is_online():
socket.setdefaulttimeout(1)
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(("8.8.8.8", 53))
return True
except socket.timeout:
return False
if __name__ == '__main__':
test_runner = TextTestRunner(resultclass=TimeLoggingTestResult)
unittest.main(testRunner=test_runner)
