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)