def load_tests():
test_suite = TestSuite()
this_dir = os.path.dirname(__file__)
loader = TestLoader()
package_tests = loader.discover(start_dir=this_dir)
test_suite.addTests(package_tests)
return test_suite
def all():
'''
This runs all tests and examples. It is something of a compromise - seems
to be the best solution that's independent of other libraries, doesn't
use the file system (since code may be in a zip file), and keeps the
number of required imports to a minimum.
'''
basicConfig(level=ERROR)
log = getLogger('lepl._test.all.all')
suite = TestSuite()
loader = TestLoader()
runner = TextTestRunner(verbosity=4)
for module in ls_modules(lepl, MODULES):
log.debug(module.__name__)
suite.addTest(loader.loadTestsFromModule(module))
result = runner.run(suite)
print('\n\n\n----------------------------------------------------------'
'------------\n')
if version[0] == '2':
print('Expect 2-5 failures + 2 errors in Python 2: {0:d}, {1:d} '
.format(len(result.failures), len(result.errors)))
assert 2 <= len(result.failures) <= 5, len(result.failures)
assert 1 <= len(result.errors) <= 2, len(result.errors)
target = TOTAL - NOT_DISTRIBUTED - NOT_3
else:
print('Expect at most 1 failure + 0 errors in Python 3: {0:d}, {1:d} '
.format(len(result.failures), len(result.errors)))
assert 0 <= len(result.failures) <= 1, len(result.failures)
assert 0 <= len(result.errors) <= 0, len(result.errors)
target = TOTAL - NOT_DISTRIBUTED
print('Expect {0:d} tests total: {1:d}'.format(target, result.testsRun))
assert result.testsRun == target, result.testsRun
print('\nLooks OK to me!\n\n')
def loadTestCases(self):
loader = TestLoader()
selector = QTestLoader()
if selector.exec_():
self.cases[:] = []
for case in selector.selected:
self.cases.extend(loader.loadTestsFromTestCase(case))
def discover(root_dir):
if not os.path.exists(root_dir):
return []
loader = TestLoader()
prev_dir = os.curdir
os.chdir(root_dir)
tests = loader.discover(root_dir, top_level_dir=root_dir)
os.chdir(prev_dir)
ret = []
for suite in tests:
for suite2 in suite:
if suite2.__class__.__name__ == 'ModuleImportFailure':
continue
for test in suite2:
name = ".".join((test.__class__.__name__, test._testMethodName))
module = test.__module__
ret.append([symbol(":name"), name,
symbol(":module"), module,
symbol(":root"), root_dir])
modkey = lambda x: x[3]
ret.sort(key=modkey)
return [[k, list(g)] for k,g in groupby(ret, key=modkey)] # Converting to a list of lists
def test_suite():
loader = TestLoader()
tests = loader.loadTestsFromTestCase(PrincipalAnnotationTests)
import zope.app.principalannotation
tests.addTest(doctest.DocTestSuite(zope.app.principalannotation))
return tests
def collect(self):
from unittest import TestLoader
cls = self.obj
if not getattr(cls, "__test__", True):
return
skipped = getattr(cls, "__unittest_skip__", False)
if not skipped:
self._inject_setup_teardown_fixtures(cls)
self._inject_setup_class_fixture()
self.session._fixturemanager.parsefactories(self, unittest=True)
loader = TestLoader()
foundsomething = False
for name in loader.getTestCaseNames(self.obj):
x = getattr(self.obj, name)
if not getattr(x, "__test__", True):
continue
funcobj = getimfunc(x)
yield TestCaseFunction(name, parent=self, callobj=funcobj)
foundsomething = True
if not foundsomething:
runtest = getattr(self.obj, "runTest", None)
if runtest is not None:
ut = sys.modules.get("twisted.trial.unittest", None)
if ut is None or runtest != ut.TestCase.runTest:
yield TestCaseFunction("runTest", parent=self)
def test_all():
loader = TestLoader()
suite = TestSuite()
suite.addTests(loader.loadTestsFromTestCase(TestLocale))
suite.addTests(loader.loadTestsFromTestCase(TestExtract))
suite.addTests(loader.loadTestsFromTestCase(TestMerge))
return suite
class TestGroup(object):
def __init__(self, name, classnames=None, groupSetUp=lambda:None, groupTearDown=lambda:None):
self.name = name
self._classes = {}
for classname in (classnames or []):
self._loadClass(classname)
self._loader = TestLoader()
self.setUp = groupSetUp
self.tearDown = groupTearDown
def _loadClass(self, classname):
moduleName, className = classname.rsplit('.', 1)
cls = getattr(__import__(moduleName, globals(), locals(), [className]), className)
self._classes[className] = cls
def createSuite(self, testnames=None):
if not testnames:
testnames = sorted(self._classes.keys())
suite = TestSuite()
for testname in testnames:
testcase = testname.split('.')
testclass = self._classes.get(testcase[0], None)
if not testclass:
continue
if len(testcase) == 1:
suite.addTest(self._loader.loadTestsFromTestCase(testclass))
else:
suite.addTest(self._loader.loadTestsFromName(testcase[1], testclass))
return suite
def search(path, prefix=''):
loader = TestLoader()
for _, name, is_pkg in iter_modules(path):
full_name = '{}.{}'.format(prefix, name)
module_path = os.path.join(path[0], name)
if is_pkg:
search([module_path], full_name)
if not is_pkg and name.startswith('test'):
test_module = import_module(full_name)
for suite in loader.loadTestsFromModule(test_module):
for test in suite._tests:
path = '{}.{}.{}'.format(full_name, test.__class__.__name__, test._testMethodName)
rec = {
'ver': '1.0',
'execution': {
'command': 'python -m unittest {}'.format(path),
'recording': find_recording_file(path)
},
'classifier': {
'identifier': path,
'type': get_test_type(test),
}
}
RECORDS.append(rec)
def all_tests():
suite = TestSuite()
loader = TestLoader()
suite.addTests(loader.loadTestsFromTestCase(RewriterTest))
return suite
def suite():
"""Suite of TestCases for Django"""
suite = TestSuite()
loader = TestLoader()
test_cases = (ManagersTestCase, EntryTestCase,
EntryGetBaseModelTestCase, SignalsTestCase,
EntryHtmlContentTestCase, CategoryTestCase,
ZinniaViewsTestCase, ZinniaFeedsTestCase,
ZinniaSitemapsTestCase, ComparisonTestCase,
DirectoryPingerTestCase, ExternalUrlsPingerTestCase,
TemplateTagsTestCase, QuickEntryTestCase,
URLShortenerTestCase, EntryCommentModeratorTestCase,
ZinniaCustomDetailViews, SpamCheckerTestCase,
EntryAdminTestCase, CategoryAdminTestCase,
MixinTestCase, LongEnoughTestCase,
AuthorTestCase)
if 'django_xmlrpc' in settings.INSTALLED_APPS:
test_cases += (PingBackTestCase, MetaWeblogTestCase)
for test_class in test_cases:
tests = loader.loadTestsFromTestCase(test_class)
suite.addTests(tests)
return suite
class TestHTMLTestRunner(TestCase):
def setUp(self):
self.suite = TestSuite()
self.loader = TestLoader()
self.suite.addTests(self.loader.loadTestsFromModule(tests.SampleTestPass))
self.suite.addTests(self.loader.loadTestsFromModule(tests.SampleTestFail))
self.suite.addTests(self.loader.loadTestsFromModule(tests.SampleTestBasic))
self.results_output_buffer = StringIO()
HTMLTestRunner(stream=self.results_output_buffer).run(self.suite)
self.byte_output = self.results_output_buffer.getvalue()
def test_SampleTestPass(self):
output1="".join(self.byte_output.split())
output2="".join(SampleTestPass.EXPECTED_RESULT.split())
self.assertGreater(output1.find(output2),0)
@skip("Test Skipping")
def test_SampleTestSkip(self):
self.fail("This error should never be displayed")
def test_SampleTestFail(self):
output1="".join(self.byte_output.split())
output2="".join(SampleTestFail.EXPECTED_RESULT.split())
self.assertGreater(output1.find(output2),0)
def test_SampleTestBasic(self):
output1="".join(self.byte_output.split())
output2="".join(SampleTestBasic.EXPECTED_RESULT.split())
self.assertGreater(output1.find(output2),0)
def run(self, ):
loader = TestLoader()
tests = loader.discover('.', 'test_*.py')
t = XMLTestRunner(verbosity=1, output=self.TEST_RESULTS)
res = t.run(tests)
if not res.wasSuccessful():
raise FailTestException()
def main():
modules = ['test_360', 'test_dependencies', 'test_optional_dependencies', 'test_simple']
simple_suite = TestSuite()
loader = TestLoader()
result = TestResult()
for module in modules:
suite = loader.loadTestsFromName(module)
simple_suite.addTest(suite)
print
print 'Running simple test suite...'
print
simple_suite.run(result)
print
print 'Ran {0} tests.'.format(result.testsRun)
print
if len(result.errors) > 0:
print '#########################################################'
print 'There are {0} errors. See below for tracebacks:'.format(len(result.errors))
print '#########################################################'
print
for error in result.errors:
print error[1]
print
print '#########################################################'
print 'There are {0} errors. See above for tracebacks.'.format(len(result.errors))
print '#########################################################'
else:
print 'All tests passed.'
print
def suite():
"""Suite of TestCases for Django"""
suite = TestSuite()
loader = TestLoader()
test_cases = (ManagersTestCase, EntryTestCase,
LoadModelClassTestCase, SignalsTestCase,
EntryHtmlContentTestCase, CategoryTestCase,
ZinniaViewsTestCase, ZinniaFeedsTestCase,
ZinniaSitemapsTestCase, ComparisonTestCase,
DirectoryPingerTestCase, ExternalUrlsPingerTestCase,
TemplateTagsTestCase, QuickEntryTestCase,
URLShortenerTestCase, EntryCommentModeratorTestCase,
ZinniaCustomDetailViews, SpamCheckerTestCase,
EntryAdminTestCase, CategoryAdminTestCase,
MixinTestCase, LongEnoughTestCase,
AuthorTestCase, FlagsTestCase,
AuthorListFilterTestCase, CategoryListFilterTestCase,
TranslatedURLsTestCase, EntryAbsoluteUrlTestCase,
MarkupsTestCase, FailImportMarkupTestCase,
PingBackTestCase, MetaWeblogTestCase,
HTMLPreviewTestCase,
EntryAdminFormTestCase, CategoryAdminFormTestCase,
MPTTModelChoiceIteratorTestCase,
MPTTModelMultipleChoiceFieldTestCase,
MPTTFilteredSelectMultipleTestCase
)
for test_class in test_cases:
tests = loader.loadTestsFromTestCase(test_class)
suite.addTests(tests)
return suite
def build_suite(self, test_labels, extra_tests=None, **kwargs):
'''
Override the base class method to return a suite consisting of all
TestCase subclasses throughought the whole project.
'''
if test_labels:
suite = TestSuite()
else:
suite = DjangoTestSuiteRunner.build_suite(
self, test_labels, extra_tests, **kwargs
)
added_test_classes = set(t.__class__ for t in suite)
loader = TestLoader()
for fname in _get_module_names(os.getcwd()):
module = _import(_to_importable_name(fname))
for test_class in _get_testcases(module):
if test_class in added_test_classes:
continue
for method_name in loader.getTestCaseNames(test_class):
testname = '.'.join([
module.__name__, test_class.__name__, method_name
])
if self._test_matches(testname, test_labels):
suite.addTest(loader.loadTestsFromName(testname))
added_test_classes.add(test_class)
return reorder_suite(suite, (TestCase,))
def run(self):
# Do not include current directory, validate using installed pythran
current_dir = _exclude_current_dir_from_import()
os.chdir("pythran/tests")
where = os.path.join(current_dir, 'pythran')
from pythran import test_compile
test_compile()
try:
import py
import xdist
args = ["-n", str(self.num_threads), where, '--pep8']
if self.failfast:
args.insert(0, '-x')
if self.cov:
try:
import pytest_cov
args = ["--cov-report", "html",
"--cov-report", "annotate",
"--cov", "pythran"] + args
except ImportError:
print ("W: Skipping coverage analysis, pytest_cov"
"not found")
if py.test.cmdline.main(args) == 0:
print "\\_o<"
except ImportError:
print ("W: Using only one thread, "
"try to install pytest-xdist package")
loader = TestLoader()
t = TextTestRunner(failfast=self.failfast)
t.run(loader.discover(where))
if t.wasSuccessful():
print "\\_o<"
def discover(directory):
directory = os.path.expanduser(directory) # The tilde does not work with os.chdir
os.chdir(directory)
# Discovering tests using unittest framework
loader = TestLoader()
tests = loader.discover(directory, top_level_dir=directory)
result = EmacsTestResult()
# Create a buffer (if it not exists) and put the formatted results
# inside it
let = Let()
lisp.get_buffer_create("unittest")
let.push_excursion()
lisp.set_buffer("unittest")
lisp.erase_buffer()
tests.run(result)
lisp.insert("\n")
lisp.insert("Errors:\n")
for test, traceback in result.errors:
lisp.insert(str(test))
lisp.insert(traceback)
let.pop_excursion()
lisp.pop_to_buffer("unittest")
lisp.compilation_mode()
lisp.beginning_of_buffer()
def run(self):
"""
Finds and executes unit tests in the 'tests' subdir.
Because TestLoader imports the tests as a module this method
automatically creates/updates the 'tests/__init__.py' to
import all python scripts in the 'tests' subdir.
"""
self.run_command('build')
sys.path.insert(0,os.path.join(os.getcwd(),"build","lib"))
self.tests = []
# make sure the 'tests' subdir actually exists.
if not os.path.isdir(self.tests_dir):
print "ExecuteTests: <Error> 'tests' subdir not found!"
else:
self.find_tests()
self.gen_tests_init()
# create a test suite.
tests = TestLoader().loadTestsFromNames([t[0] for t in self.tests])
if not self.filter is None:
tests = self.filter_tests(tests)
# run the test suite if it actually contains test cases.
run_verbosity = 2
if self.verbose == 0:
run_verbosity = 0
if tests.countTestCases() > 0:
runner = TextTestRunner(verbosity=run_verbosity)
runner.run(tests)
else:
print "ExecuteTests: <Warning> No test cases found!"
sys.path.pop(0)
def run(self):
where = os.path.join('pythran', 'tests')
try:
import py
import xdist
import multiprocessing
cpu_count = multiprocessing.cpu_count()
args = ["-n", str(cpu_count), where]
if self.failfast:
args.insert(0, '-x')
if self.cov:
try:
import pytest_cov
args = ["--cov-report", "html",
"--cov-report", "annotate",
"--cov", "pythran"] + args
except ImportError:
print ("W: Skipping coverage analysis, pytest_cov"
"not found")
py.test.cmdline.main(args)
except ImportError:
print ("W: Using only one thread, "
"try to install pytest-xdist package")
loader = TestLoader()
t = TextTestRunner(failfast=self.failfast)
t.run(loader.discover(where))
def collect(self):
from unittest import TestLoader
cls = self.obj
if not getattr(cls, "__test__", True):
return
self.session._fixturemanager.parsefactories(self, unittest=True)
loader = TestLoader()
module = self.getparent(Module).obj
foundsomething = False
for name in loader.getTestCaseNames(self.obj):
x = getattr(self.obj, name)
if not getattr(x, "__test__", True):
continue
funcobj = getattr(x, "im_func", x)
transfer_markers(funcobj, cls, module)
yield TestCaseFunction(name, parent=self, callobj=funcobj)
foundsomething = True
if not foundsomething:
runtest = getattr(self.obj, "runTest", None)
if runtest is not None:
ut = sys.modules.get("twisted.trial.unittest", None)
if ut is None or runtest != ut.TestCase.runTest:
yield TestCaseFunction("runTest", parent=self)
def load_tests():
loader = TestLoader()
loader.suiteClass = OptionAwareTestLoader
for package in test_packages:
# forcing the improt now gives us better error messages sometimes
__import__(package)
tests = loader.loadTestsFromNames(test_packages)
return tests
def run():
loader = TestLoader()
suite = TestSuite((
loader.loadTestsFromTestCase(UtilsTests),
loader.loadTestsFromTestCase(Tests)
))
runner = TextTestRunner(verbosity = 2)
runner.run(suite)
def run_suite(verbose=False):
loader = TestLoader()
runner = TextTestRunner(verbosity=2 if verbose else 1)
suite = TestSuite()
for mod in get_modules():
suite.addTest(loader.loadTestsFromModule(mod))
runner.run(suite)
return 0
def run_daemon(testpath, testname, amqp):
module = load_source(testname, testpath)
loader = TestLoader()
suite = loader.loadTestsFromModule(module)
result = CanopsisTestResult(module.__name__, amqp)
suite.run(result)
result.report()
def run(self):
import os
from unittest import TestLoader, TextTestRunner
cur_dir = os.path.dirname(os.path.abspath(__file__))
loader = TestLoader()
test_suite = loader.discover(cur_dir)
runner = TextTestRunner(verbosity=2)
runner.run(test_suite)
def run(self):
address = self.address or 'localhost:10190'
os.environ.setdefault('URLFETCH_ADDR', address)
import pyurlfetch.tests
loader = TestLoader()
t = TextTestRunner()
t.run(loader.loadTestsFromModule(pyurlfetch.tests))
def build_suite(self, test_labels, extra_tests=None, **kwargs):
suite = TestSuite()
loader = TestLoader()
for fname in _get_module_names('.'):
module = _import(_to_importable_name(fname))
for test_case in _get_module_testcases(module):
suite.addTests(loader.loadTestsFromTestCase(test_case))
return reorder_suite(suite, (TestCase,))
def create_test_suite():
"""create a unittest.TestSuite with available tests"""
from unittest import TestLoader, TestSuite
loader = TestLoader()
suite = TestSuite()
for test_name in available_tests:
exec("from . import " + test_name)
suite.addTests(loader.loadTestsFromModule(eval(test_name)))
return suite
def test_suite():
names = [
'utils',
]
module_names = ['wafsamba.tests.test_' + name for name in names]
loader = TestLoader()
result = loader.suiteClass()
suite = loader.loadTestsFromNames(module_names)
result.addTests(suite)
return result
def tests():
app.testing = True
loader = TestLoader()
tests = loader.discover('source/tests/')
testRunner = runner.TextTestRunner()
testRunner.run(tests)
savedata=False,
run=FB.FBFMEB))
fbfm.summary()
def test_periodic(self):
print()
t, sd, Us, Ud = 1.0, 1.4, 0.1, 0.1
S2x = Square('S2x')('1P-1O', nneighbour=2)
fbfm = self.fbfmconstruct(
t, sd, Us, Ud,
FB.FBFMBasis(BZ=FBZ(S2x.reciprocals, nks=(60, )),
polarization='up'), S2x)
fbfm.register(
FB.EB(name='EB1',
path='L:G1-G2',
ne=4,
savedata=False,
run=FB.FBFMEB))
fbfm.register(
BP(name='BP',
path='L:G1-G2',
ns=(0, 1),
savedata=False,
run=FB.FBFMBP))
fbfm.summary()
fbfm = TestSuite([
TestLoader().loadTestsFromTestCase(TestFBFM),
])
sectors=[basis],
lattice=lattice,
config=config,
terms=[Hopping('t1', t1), Hubbard('U', U)],
dtype=np.complex128)
eigvals0 = eigh(ed.matrix(basis.rep).todense(), eigvals_only=True)
basis = TrBasis(FBasis(m * 2, m, 0.0), dk=2, nk=m)
ed = TrFED(name='OneD_%s_%s' % (lattice.name, basis.rep),
basis=basis,
lattice=lattice,
config=config,
terms=[Hopping('t1', t1),
Hubbard('U', U)],
dtype=np.complex128)
eigvals1 = []
for k in xrange(m):
eigvals1.append(
eigh(ed.matrix(sector=k).todense(), eigvals_only=True))
eigvals1 = sorted(np.concatenate(eigvals1))
self.assertAlmostEqual(norm(eigvals0 - eigvals1), 0.0)
trfed = TestSuite([
TestLoader().loadTestsFromTestCase(TestTrFBasis),
TestLoader().loadTestsFromTestCase(TestTrFED),
])
if __name__ == '__main__':
from unittest import main
main(verbosity=2)
def get_test_suite():
test_loader = TestLoader()
return test_loader.discover('test', pattern='*_test.py')
__author__ = 'Gourika Maaknuru'
from unittest import TestLoader, TestSuite, TextTestRunner
from Test.Scripts.test_Oyeroomie_HomePage import Oyeroomie_HomePage
from Test.Scripts.test_Oyeroomie_PostAdPage import Oyeroomie_PostAdPage
import testtools as testtools
import HtmlTestRunner
if __name__ == '__main__':
loader = TestLoader()
suite = TestSuite((
loader.loadTestsFromTestCase(Oyeroomie_HomePage),
loader.loadTestsFromTestCase(Oyeroomie_PostAdPage)
))
# Run Tests Sequentially #
#runner = TextTestRunner(verbosity=2)
#runner.run(suite)
#run test parallel using concurrent_suite, but output result data gets overlapped
concurrent_suite = testtools.ConcurrentStreamTestSuite(lambda: ((case, None) for case in suite))
concurrent_suite.run(testtools.StreamResult())
def suite():
""" return all the tests in this file """
return TestLoader().loadTestsFromTestCase(TweakTest)
def suite():
""" returns all the testcases in this module """
suite = TestSuite()
suite.addTests(TestLoader().loadTestsFromTestCase(TclModuleGeneratorTest))
suite.addTests(TestLoader().loadTestsFromTestCase(LuaModuleGeneratorTest))
return suite
except AssertionError as e:
result = '用例不通过'
raise e
else:
result = '用例通过'
finally:
print(result)
def test_error(self):
""" 账号或者密码输入错误 """
expected = '{"code":0,"mes":"账号或者密码不正确"}'
res = login_check(username='******', password='******')
self.assertEqual(expected, res)
try:
self.assertEqual(expected, res)
except AssertionError as e:
result = '用例不通过'
raise e
else:
result = '用例通过'
finally:
print(result)
if __name__ == '__main__':
suit = TestCase()
loader = TestLoader()
suit.addTest(loader.loadTestsFromModule(MyTestCase, TestLogin))
runner = TextTestRunner()
runner.run(suit)
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 = [("PyCogent version", pycogent_lib_version),
("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)
import os
from unittest import TestLoader, TextTestRunner
if __name__ == '__main__':
loader = TestLoader()
tests_dir = os.path.join(os.path.dirname(__file__), 'tests')
tests = loader.discover(tests_dir, pattern='*.py')
runner = TextTestRunner()
result = runner.run(tests)
if result.failures or result.errors:
raise SystemExit(f'{len(result.failures) + len(result.errors)} tests failed.')
language = sys.argv[1]
try:
trad = gettext.GNUTranslations(
open("../../course/common/student/$i18n/" + language + ".mo", "rb"))
except FileNotFoundError:
trad = gettext.NullTranslations()
trad.install()
test_names = [
file[:file.rfind('.')] for file in os.listdir('.')
if file.startswith("Test")
]
suite = TestSuite()
for test in test_names:
tests = TestLoader().loadTestsFromName(test)
suite.addTests(tests)
runner = TextTestRunner()
try:
result = runner.run(suite)
except AttributeError:
pass
except TimeoutError:
pass
for f in result.failures:
print(f[1], file=sys.stderr)
if result.wasSuccessful():
sys.exit(127)
def test_suite():
from unittest import TestLoader
return TestLoader().loadTestsFromName(__name__)
def test_suite():
return TestLoader().discover(".")
def suite():
return TestLoader().loadTestsFromTestCase(T800WinThreadTest)
def suite(self):
"""Return all the testcases in this module."""
return TestLoader().loadTestsFromTestCase(ConfigTest)
def myReportStart():
runner = HtmlTestRunner.HTMLTestRunner(output='My_dir',
report_title='MyTests')
runner.run(TestSuite((TestLoader().loadTestsFromTestCase(MyTestCase1))))
from unittest import TestLoader, TestSuite from HtmlTestRunner import HTMLTestRunner import POM.Tests.login example_tests = TestLoader().loadTestsFromTestCase(POM.Tests.login.LoginTest) suite = TestSuite([example_tests]) runner = HTMLTestRunner(output='C:/Users/Karan Singh Bais/PycharmProjects/YourLogo/Reports/ExecutionReport.html') runner.run(suite)
def get_test_suite():
return TestLoader().loadTestsFromTestCase(TestBayesRMerge)
def run(self):
'''Run test suite in parse_rest.tests'''
tests = TestLoader().loadTestsFromNames(['parse_client.tests'])
t = TextTestRunner(verbosity=1)
t.run(tests)
def _test_suite() -> TestSuite:
test_suite: TestSuite = TestSuite()
for test_case in TestFilterOddNumbers, TestFilterEvenNumbers:
tests: TestLoader = TestLoader().loadTestsFromTestCase(test_case)
test_suite.addTests(tests)
return test_suite
def suite():
"""Return all easyblock --module-only tests."""
def make_inner_test(easyblock, **kwargs):
def innertest(self):
template_module_only_test(self, easyblock, **kwargs)
return innertest
# initialize configuration (required for e.g. default modules_tool setting)
cleanup()
eb_go = eboptions.parse_options(args=['--prefix=%s' % TMPDIR])
config.init(eb_go.options, eb_go.get_options_by_section('config'))
build_options = {
'external_modules_metadata': {},
# enable --force --module-only
'force': True,
'module_only': True,
'silent': True,
'suffix_modules_path': GENERAL_CLASS,
'valid_module_classes': config.module_classes(),
'valid_stops': [x[0] for x in EasyBlock.get_steps()],
}
config.init_build_options(build_options=build_options)
set_tmpdir()
# dynamically generate a separate test for each of the available easyblocks
easyblocks_path = get_paths_for("easyblocks")[0]
all_pys = glob.glob('%s/*/*.py' % easyblocks_path)
easyblocks = [
eb for eb in all_pys
if os.path.basename(eb) != '__init__.py' and '/test/' not in eb
]
# filter out no longer supported easyblocks, or easyblocks that are tested in a different way
excluded_easyblocks = ['versionindependendpythonpackage.py']
easyblocks = [
e for e in easyblocks if os.path.basename(e) not in excluded_easyblocks
]
# add dummy PrgEnv-* modules, required for testing CrayToolchain easyblock
for prgenv in ['PrgEnv-cray', 'PrgEnv-gnu', 'PrgEnv-intel', 'PrgEnv-pgi']:
write_file(os.path.join(TMPDIR, 'modules', 'all', prgenv, '1.2.3'),
"#%Module")
# add foo/1.3.2.1.1 module, required for testing ModuleAlias easyblock
write_file(os.path.join(TMPDIR, 'modules', 'all', 'foo', '1.2.3.4.5'),
"#%Module")
for easyblock in easyblocks:
eb_fn = os.path.basename(easyblock)
# dynamically define new inner functions that can be added as class methods to ModuleOnlyTest
if eb_fn == 'systemcompiler.py':
# use GCC as name when testing SystemCompiler easyblock
innertest = make_inner_test(easyblock,
name='GCC',
version='system')
elif eb_fn == 'systemmpi.py':
# use OpenMPI as name when testing SystemMPI easyblock
innertest = make_inner_test(easyblock,
name='OpenMPI',
version='system')
elif eb_fn == 'craytoolchain.py':
# make sure that a (known) PrgEnv is included as a dependency
extra_txt = 'dependencies = [("PrgEnv-gnu/1.2.3", EXTERNAL_MODULE)]'
innertest = make_inner_test(easyblock,
name='CrayCC',
extra_txt=extra_txt)
elif eb_fn == 'modulerc.py':
# exactly one dependency is included with ModuleRC generic easyblock (and name must match)
extra_txt = 'dependencies = [("foo", "1.2.3.4.5")]'
innertest = make_inner_test(easyblock,
name='foo',
version='1.2.3.4',
extra_txt=extra_txt)
elif eb_fn == 'intel_compilers.py':
# custom easyblock for intel-compilers (oneAPI) requires v2021.x or newer
innertest = make_inner_test(easyblock,
name='intel-compilers',
version='2021.1')
elif eb_fn == 'openssl_wrapper.py':
# easyblock to create OpenSSL wrapper expects an OpenSSL version
innertest = make_inner_test(easyblock,
name='OpenSSL-wrapper',
version='1.1')
elif eb_fn == 'ucx_plugins.py':
# install fake ucx_info command (used in make_module_extra)
tmpdir = tempfile.mkdtemp()
install_fake_command('ucx_info', FAKE_UCX_INFO, tmpdir)
innertest = make_inner_test(easyblock,
name='UCX-CUDA',
tmpdir=tmpdir)
else:
# Make up some unique name
innertest = make_inner_test(easyblock,
name=eb_fn.replace('.', '-') + '-sw')
innertest.__doc__ = "Test for using --module-only with easyblock %s" % easyblock
innertest.__name__ = "test_easyblock_%s" % '_'.join(
easyblock.replace('.py', '').split('/'))
setattr(ModuleOnlyTest, innertest.__name__, innertest)
return TestLoader().loadTestsFromTestCase(ModuleOnlyTest)
#!/usr/bin/env python
import os
import sys
from unittest import TestLoader, TestSuite
import xmlrunner
"""
NOTE: "If a test package name (directory with __init__.py) matches the pattern
then the package will be checked for a load_tests function. If this
exists then it will be called with loader, tests, pattern."
"""
"""
Load all tests in the current directory and run them
"""
if __name__ == "__main__":
# must set the path for the imported tests
sys.path.insert(0, os.path.abspath('../..'))
loader = TestLoader()
suite = TestSuite(
loader.discover(start_dir='.', pattern='*_test.py', top_level_dir="."))
result = xmlrunner.XMLTestRunner(verbosity=2,
output='test-reports').run(suite)
if result.wasSuccessful():
sys.exit(0)
sys.exit(1)
#通过文件路径及py的文件名过滤，并返回TestSuite
def getTestSuite_by_dicover(filename=None, keys='*.py'):
try:
# suite=TestLoader().discover(filename,keys)
# print suite
suit = TestLoader().discover(filename, keys)
logging.info("Found testcase in %s" % filename)
return suit
except:
logging.info("Did not found %s in %s" % keys % filename)
def getTestSuite_by_CaseClass(testCaseClasses):
case = []
suite = TestLoader().loadTestsFromTestCase(testCaseClasses)
# for i in range(0, len(testCaseClasses)):
# #cls=re.findall(r"'([^']+)'",testCaseClasses[i])
# #cls=testCaseClasses[i].split('\'')
# #m = re.findall('"([^"]+)"', str1)
# #print cls[0]
# cls=testCaseClasses[i]
# # print cls,type(cls)
# suite=TestLoader().loadTestsFromTestCase(cls)
# case.append(suite)
# # try:
# # suit.append(TestLoader.loadTestsFromTestCase(testCaseClasses[i]))
# # logging.info("Found testcaseclass throud %s" % testCaseClasses[i])
# # except:
# # logging.info("Not found testcaseclass throud %s" %testCaseClasses[i])
# # continue
import sys
sys.dont_write_bytecode = True
from unittest import TestLoader, TestSuite, TextTestRunner
from photographer.test_photographer import TestPhotographer
from segmenter.test_segmenter import TestSegmenter
from classifier.test_classifier import TestClassifier
if __name__ == "__main__":
loader = TestLoader()
suite = TestSuite((
loader.loadTestsFromTestCase(TestPhotographer),
loader.loadTestsFromTestCase(TestSegmenter),
loader.loadTestsFromTestCase(TestClassifier),
))
runner = TextTestRunner(verbosity=2)
runner.run(suite)
def test():
"""Run unit tests from command line"""
from unittest import TestLoader, TextTestRunner
suite = TestLoader().discover('tests')
TextTestRunner(verbosity=2, buffer=False).run(suite)
def suite():
""" returns all the testcases in this module """
return TestLoader().loadTestsFromTestCase(ScriptsTest)
from unittest import TestLoader, TestSuite, TextTestRunner
from UnitTest_customerregister import waves_Test1
from UnitTest_customerlogin import waves_Test2
from UnitTest_enrollevent import waves_Test3
from UnitTest_enrolledevents import waves_Test4
from UnitTest_alreadyenrolled import waves_Test5
from UnitTest_logout import waves_Test6
from UnitTest_employeeregister import waves_Test7
from UnitTest_employeelogin import waves_Test8
from UnitTest_addevent import waves_Test9
from UnitTest_updateevent import waves_Test10
from UnitTest_enrollmentlist import waves_Test11
if __name__ == "__main__":
loader = TestLoader()
suite = TestSuite((
loader.loadTestsFromTestCase(waves_Test1),
loader.loadTestsFromTestCase(waves_Test2),
loader.loadTestsFromTestCase(waves_Test3),
loader.loadTestsFromTestCase(waves_Test4),
loader.loadTestsFromTestCase(waves_Test5),
loader.loadTestsFromTestCase(waves_Test6),
loader.loadTestsFromTestCase(waves_Test7),
loader.loadTestsFromTestCase(waves_Test8),
loader.loadTestsFromTestCase(waves_Test9),
loader.loadTestsFromTestCase(waves_Test10),
loader.loadTestsFromTestCase(waves_Test11),
))
runner = TextTestRunner(verbosity=2)
runner.run(suite)
print(
'No url specified in your config file for submitting test results. Please do so.'
)
except configparser.Error as e:
print("Something went wrong while parsing the configuration file:\n{}".
format(e))
data = {'test_runs': [], 'grouped_tests': []}
log = open(log_dir + "endpoint_hits.log", "w")
log.write("\"time\",\"endpoint\"\n")
log.close()
log = open(log_dir + "test_runs.log", "w")
log.write("\"start_time\",\"stop_time\",\"test_name\"\n")
if test_dir:
suites = TestLoader().discover(test_dir, pattern="*test*.py")
for i in range(n):
for suite in suites:
for case in suite:
for test in case:
result = None
t1 = str(datetime.datetime.now())
time1 = time.time()
result = test.run(result)
time2 = time.time()
t2 = str(datetime.datetime.now())
log.write("\"{}\",\"{}\",\"{}\"\n".format(
t1, t2, str(test)))
t = (time2 - time1) * 1000
data['test_runs'].append({
'name':
from unittest import TestLoader, TextTestRunner, TestSuite from .api_tests import TypeformTestCase from .distil_tests import TestDistil if __name__ == '__main__': loader = TestLoader() suite = TestSuite(( loader.loadTestsFromTestCase(TypeformTestCase), loader.loadTestsFromTestCase(TestDistil) )) runner = TextTestRunner(verbosity = 2) runner.run(suite)
conn.create_topic(Name="dummy-topic")
response = conn.list_topics()
topic_arn = response["Topics"][0]['TopicArn']
message = {
'key_string1': '2017-7-6',
'key_string2': '12345',
'decimal': Decimal('1')
}
response = self.notify.customer(topic_arn, message)
self.assertTrue(response['ResponseMetadata']['HTTPStatusCode'] == 200)
def test_backend_metrics(self):
uuid = str(uuid4())
solution_id = 'SO_unit_test'
customer_uuid = uuid
logger.info("UUID: " + customer_uuid)
data = {
'key_string1': '2017-7-6',
'key_string2': '12345',
'decimal': Decimal('1')
}
url = 'https://oszclq8tyh.execute-api.us-east-1.amazonaws.com/prod/generic'
response = self.notify.metrics(solution_id, customer_uuid, data, url)
self.assertTrue(response == 200)
if __name__ == '__main__' and __package__ is None:
suite = TestLoader().loadTestsFromTestCase(NotifyTest)
TextTestRunner(verbosity=2).run(suite)
