def runTests(self):
# Setup some globals to pass to the TestCase
global SOFT_PKG
global IMPL_ID
SOFT_PKG = self.spd_file
spd = SPDParser.parse(self.spd_file)
if self.testRunner is None:
try:
import xmlrunner
self.testRunner = xmlrunner.XMLTestRunner(verbosity=self.verbosity)
except ImportError:
self.testRunner = unittest.TextTestRunner(verbosity=self.verbosity)
for implementation in spd.get_implementation():
IMPL_ID = implementation.get_id()
if IMPL_ID == self.impl or self.impl is None:
result = self.testRunner.run(self.test)
self.results.append(result)
#sys.exit(not result.wasSuccessful())
python类TextTestRunner()的实例源码
def cov():
"""Runs the unit tests with coverage."""
tests = unittest.TestLoader().discover('project/tests')
result = unittest.TextTestRunner(verbosity=2).run(tests)
if result.wasSuccessful():
COV.stop()
COV.save()
print('Coverage Summary:')
COV.report()
basedir = os.path.abspath(os.path.dirname(__file__))
covdir = os.path.join(basedir, 'tmp/coverage')
COV.html_report(directory=covdir)
print('HTML version: file://%s/index.html' % covdir)
COV.erase()
return 0
return 1
def _run_suite(suite):
"""Run tests from a unittest.TestSuite-derived class."""
if verbose:
runner = unittest.TextTestRunner(sys.stdout, verbosity=2,
failfast=failfast)
else:
runner = BasicTestRunner()
result = runner.run(suite)
if not result.wasSuccessful():
if len(result.errors) == 1 and not result.failures:
err = result.errors[0][1]
elif len(result.failures) == 1 and not result.errors:
err = result.failures[0][1]
else:
err = "multiple errors occurred"
if not verbose: err += "; run in verbose mode for details"
raise TestFailed(err)
def main(sdk_path, test_path, test_pattern):
# If the SDK path points to a Google Cloud SDK installation
# then we should alter it to point to the GAE platform location.
if os.path.exists(os.path.join(sdk_path, 'platform/google_appengine')):
sdk_path = os.path.join(sdk_path, 'platform/google_appengine')
# Make sure google.appengine.* modules are importable.
fixup_paths(sdk_path)
# Make sure all bundled third-party packages are available.
import dev_appserver
dev_appserver.fix_sys_path()
# Loading appengine_config from the current project ensures that any
# changes to configuration there are available to all tests (e.g.
# sys.path modifications, namespaces, etc.)
try:
import appengine_config
(appengine_config)
except ImportError:
print('Note: unable to import appengine_config.')
# Discover and run tests.
suite = unittest.loader.TestLoader().discover(test_path, test_pattern)
return unittest.TextTestRunner(verbosity=2).run(suite)
def testRunnerRegistersResult(self):
class Test(unittest.TestCase):
def testFoo(self):
pass
originalRegisterResult = unittest.runner.registerResult
def cleanup():
unittest.runner.registerResult = originalRegisterResult
self.addCleanup(cleanup)
result = unittest.TestResult()
runner = unittest.TextTestRunner(stream=StringIO())
# Use our result object
runner._makeResult = lambda: result
self.wasRegistered = 0
def fakeRegisterResult(thisResult):
self.wasRegistered += 1
self.assertEqual(thisResult, result)
unittest.runner.registerResult = fakeRegisterResult
runner.run(unittest.TestSuite())
self.assertEqual(self.wasRegistered, 1)
def test_startTestRun_stopTestRun_called(self):
class LoggingTextResult(LoggingResult):
separator2 = ''
def printErrors(self):
pass
class LoggingRunner(unittest.TextTestRunner):
def __init__(self, events):
super(LoggingRunner, self).__init__(StringIO())
self._events = events
def _makeResult(self):
return LoggingTextResult(self._events)
events = []
runner = LoggingRunner(events)
runner.run(unittest.TestSuite())
expected = ['startTestRun', 'stopTestRun']
self.assertEqual(events, expected)
def _run_suite(suite):
"""Run tests from a unittest.TestSuite-derived class."""
if verbose:
runner = unittest.TextTestRunner(sys.stdout, verbosity=2)
else:
runner = BasicTestRunner()
result = runner.run(suite)
if not result.wasSuccessful():
if len(result.errors) == 1 and not result.failures:
err = result.errors[0][1]
elif len(result.failures) == 1 and not result.errors:
err = result.failures[0][1]
else:
err = "multiple errors occurred"
if not verbose:
err += "; run in verbose mode for details"
raise TestFailed(err)
def __init__(self, stream=sys.stderr, descriptions=True, verbosity=1,
failfast=False, buffer=False, resultclass=None,
tb_locals=False):
"""Construct a TextTestRunner.
Subclasses should accept **kwargs to ensure compatibility as the
interface changes.
"""
self.stream = _WritelnDecorator(stream)
self.descriptions = descriptions
self.verbosity = verbosity
self.failfast = failfast
self.buffer = buffer
self.tb_locals = tb_locals
if resultclass is not None:
self.resultclass = resultclass
def handle(self, *args, **options):
loader = unittest.TestLoader()
tests = loader.discover(
'./acceptancetests/tests',
pattern="acc_test_*.py"
)
runner = unittest.TextTestRunner(verbosity=2)
test_result = runner.run(tests)
if test_result.wasSuccessful():
sys.exit()
else:
number_failed = len(test_result.failures) + len(test_result.errors)
sys.exit(number_failed)
def run_tests(self, stream, test_suite):
"""Runs the given TestSuite.
@param stream: A stream object with write functionality to capture the test output.
@param test_suite: The TestSuite to run.
"""
runner = unittest.TextTestRunner(stream=stream, verbosity=2, resultclass=mayaunittest.TestResult)
runner.failfast = False
runner.buffer = mayaunittest.Settings.buffer_output
result = runner.run(test_suite)
self._set_test_result_data(result.failures, TestStatus.fail)
self._set_test_result_data(result.errors, TestStatus.error)
self._set_test_result_data(result.skipped, TestStatus.skipped)
for test in result.successes:
node = self.node_lookup[str(test)]
index = self.get_index_of_node(node)
self.setData(index, 'Test Passed', QtCore.Qt.ToolTipRole)
self.setData(index, TestStatus.success, QtCore.Qt.DecorationRole)
def main(sdk_path, test_path, test_pattern):
# If the SDK path points to a Google Cloud SDK installation
# then we should alter it to point to the GAE platform location.
if os.path.exists(os.path.join(sdk_path, 'platform/google_appengine')):
sdk_path = os.path.join(sdk_path, 'platform/google_appengine')
# Make sure google.appengine.* modules are importable.
fixup_paths(sdk_path)
# Make sure all bundled third-party packages are available.
import dev_appserver
dev_appserver.fix_sys_path()
# Loading appengine_config from the current project ensures that any
# changes to configuration there are available to all tests (e.g.
# sys.path modifications, namespaces, etc.)
try:
import appengine_config
(appengine_config)
except ImportError:
print('Note: unable to import appengine_config.')
# Discover and run tests.
suite = unittest.loader.TestLoader().discover(test_path, test_pattern)
return unittest.TextTestRunner(verbosity=2).run(suite)
def main():
"""Runs the unit tests"""
suite = unittest.TestSuite()
suite.addTests(unittest.makeSuite(TestFunctions))
suite.addTests(unittest.makeSuite(TestPointCharge))
suite.addTests(unittest.makeSuite(TestLineCharge))
suite.addTests(unittest.makeSuite(TestElectricField))
suite.addTests(unittest.makeSuite(TestGaussianCircle))
result = unittest.TextTestRunner(verbosity=1).run(suite)
n_errors = len(result.errors)
n_failures = len(result.failures)
if n_errors or n_failures:
print('\n\nSummary: %d errors and %d failures reported\n'%\
(n_errors, n_failures))
print()
sys.exit(n_errors+n_failures)
def test():
'''Run the face test suite.'''
pv.disableCommercialUseWarnings()
normalize_suite = unittest.TestLoader().loadTestsFromTestCase(_TestNormalize)
surf_suite = unittest.TestLoader().loadTestsFromTestCase(_TestSURF)
dist_suite = unittest.TestLoader().loadTestsFromTestCase(_TestDistance)
test_suites = [
normalize_suite,
surf_suite,
dist_suite
]
pyvision_suite = unittest.TestSuite(test_suites)
unittest.TextTestRunner(verbosity=2).run(pyvision_suite)
def test():
import QuantLib
print('testing QuantLib ' + QuantLib.__version__)
suite = unittest.TestSuite()
suite.addTest(DateTest())
suite.addTest(DayCountersTest())
suite.addTest(unittest.makeSuite(InstrumentTest,'test'))
suite.addTest(unittest.makeSuite(MarketElementTest,'test'))
suite.addTest(unittest.makeSuite(IntegralTest,'test'))
suite.addTest(Solver1DTest())
suite.addTest(unittest.makeSuite(TermStructureTest,'test'))
suite.addTest(unittest.makeSuite(FixedRateBondTest, 'test'))
suite.addTest(unittest.makeSuite(FixedRateBondHelperTest, 'test'))
suite.addTest(unittest.makeSuite(CmsTest, 'test'))
suite.addTest(unittest.makeSuite(AssetSwapTest, 'test'))
suite.addTest(unittest.makeSuite(CapFloorTest, 'test'))
result = unittest.TextTestRunner(verbosity=2).run(suite)
if not result.wasSuccessful:
sys.exit(1)
def test(coverage=False):
"""Run the unit tests."""
if coverage and not os.environ.get('FLASK_COVERAGE'):
import sys
os.environ['FLASK_COVERAGE'] = '1'
os.execvp(sys.executable, [sys.executable] + sys.argv)
import unittest
tests = unittest.TestLoader().discover('tests')
unittest.TextTestRunner(verbosity=2).run(tests)
if COV:
COV.stop()
COV.save()
print('Coverage Summary:')
COV.report()
basedir = os.path.abspath(os.path.dirname(__file__))
covdir = os.path.join(basedir, 'tmp/coverage')
COV.html_report(directory=covdir)
print('HTML version: file://%s/index.html' % covdir)
COV.erase()
def run_transcript_tests(self, callargs):
"""Runs transcript tests for provided file(s).
This is called when either -t is provided on the command line or the transcript_files argument is provided
during construction of the cmd2.Cmd instance.
:param callargs: List[str] - list of transcript test file names
"""
class TestMyAppCase(Cmd2TestCase):
cmdapp = self
self.__class__.testfiles = callargs
sys.argv = [sys.argv[0]] # the --test argument upsets unittest.main()
testcase = TestMyAppCase()
runner = unittest.TextTestRunner()
runner.run(testcase)
def test(coverage=False):
"""
??
:param coverage ????????
:return:
"""
if coverage and not os.environ.get('PG_COVERAGE'):
import sys
os.environ['PG_COVERAGE'] = '1'
os.execvp(sys.executable, [sys.executable] + sys.argv)
import unittest
tests = unittest.TestLoader().discover('tests')
unittest.TextTestRunner(verbosity=2).run(tests)
if COV:
COV.stop()
COV.save()
print('Coverage Summary:')
COV.report()
basedir = os.path.abspath(os.path.dirname(__file__))
covdir = os.path.join(basedir, 'tests/coverage')
COV.html_report(directory=covdir)
print('HTML version: file://%s/index.html' % covdir)
COV.erase()
def run_availability_tests(test_suite):
__import__(test_suite)
suite = unittest.TestLoader().loadTestsFromName(test_suite)
runner = TextTestRunner(verbosity=4)
result = runner.run(suite)
return result
def unittest_main(*args, **kwargs):
if 'testRunner' in kwargs and kwargs['testRunner'] is None:
kwargs['testRunner'] = unittest.TextTestRunner
return unittest.main(*args, **kwargs)
def run_tests(self):
"""
Loads the test suite and hook the callback for reporting progress.
"""
Controller.patch_keystore_path()
test_suite = suite()
self.stream_property = ""
stream = StringIOCBWrite(callback_write=self.callback_write)
verbosity = 2
unittest.TextTestRunner(
stream=stream, verbosity=verbosity).run(test_suite)
def unittest_main(*args, **kwargs):
if 'testRunner' in kwargs and kwargs['testRunner'] is None:
kwargs['testRunner'] = unittest.TextTestRunner
return unittest.main(*args, **kwargs)
def runTests(self):
if self.testRunner is None:
try:
import xmlrunner
self.testRunner = xmlrunner.XMLTestRunner(verbosity=self.verbosity)
except ImportError:
self.testRunner = unittest.TextTestRunner(verbosity=self.verbosity)
unittest.TestProgram.runTests(self)
def test():
"""Run the unit tests."""
import unittest
tests = unittest.TestLoader().discover('tests')
unittest.TextTestRunner(verbosity=2).run(tests)
def runtests(debug=False):
enableLogging(debug)
test_suite = unittest.TestLoader().discover('tests/')
result = unittest.TextTestRunner().run(test_suite)
sys.exit(0 if result.wasSuccessful() else 1)
def test():
print("=" * len(__TITLE__))
print(__TITLE__)
print("=" * len(__TITLE__))
suite = unittest.TestLoader().loadTestsFromTestCase(TestPJFEncoder)
unittest.TextTestRunner(verbosity=2).run(suite)
def test():
print("=" * len(__TITLE__))
print(__TITLE__)
print("=" * len(__TITLE__))
suite = unittest.TestLoader().loadTestsFromTestCase(TestPJFServer)
unittest.TextTestRunner(verbosity=2).run(suite)
def test():
print("=" * len(__TITLE__))
print(__TITLE__)
print("=" * len(__TITLE__))
suite = unittest.TestLoader().loadTestsFromTestCase(TestPJFMutation)
unittest.TextTestRunner(verbosity=2).run(suite)
def test():
print("=" * len(__TITLE__))
print(__TITLE__)
print("=" * len(__TITLE__))
suite = unittest.TestLoader().loadTestsFromTestCase(TestPJFFactory)
unittest.TextTestRunner(verbosity=2).run(suite)
def test():
print("=" * len(__TITLE__))
print(__TITLE__)
print("=" * len(__TITLE__))
suite = unittest.TestLoader().loadTestsFromTestCase(TestPJFConfiguration)
unittest.TextTestRunner(verbosity=2).run(suite)
def test():
print("=" * len(__TITLE__))
print(__TITLE__)
print("=" * len(__TITLE__))
suite = unittest.TestLoader().loadTestsFromTestCase(TestPJFExternalFuzzer)
unittest.TextTestRunner(verbosity=2).run(suite)
