def suite():
suite = TestSuite()
suite.addTest(TestLoader().loadTestsFromTestCase(TestScript))
suite.addTest(TestLoader().loadTestsFromTestCase(TestCountry))
suite.addTest(TestLoader().loadTestsFromTestCase(TestLanguage))
return suite
from unit_tests.test_linear_regression import TestLinearRegression
from unit_tests.test_ridge_regression import TestRidgeRegression
from unittest import TestLoader, TextTestRunner, TestSuite
# Uses a testLoader to run multiple tests from different python unit tests file
if __name__ == "__main__":
loader = TestLoader()
suite = TestSuite((loader.loadTestsFromTestCase(TestLinearRegression),
loader.loadTestsFromTestCase(TestRidgeRegression)))
runner = TextTestRunner()
runner.run(suite)
from unittest import TestLoader, TestSuite
from pyunitreport import HTMLTestRunner
from assertions import AssertionTest
from searchtest import SearchTest
assertion_test = TestLoader().loadTestsFromTestCase(AssertionTest)
search_test = TestLoader().loadTestsFromTestCase(SearchTest)
smoke_test = TestSuite([search_test, assertion_test])
kwargs = {"output": 'smoke-report'}
runner = HTMLTestRunner(**kwargs)
runner.run(smoke_test)
def test_suite():
suite = TestLoader().loadTestsFromName(__name__)
suite.addTest(DocTestSuite(lp.soyuz.scripts.gina.handlers))
return suite
def __init__(self, test_case_class): my_load = TestLoader() self.methods = my_load.getTestCaseNames(test_case_class)
def run(self):
loader = TestLoader()
tests = loader.discover(start_dir='tests')
runner = TextTestRunner(verbosity=2)
runner.run(tests)
def run_tests(self):
from unittest import TestLoader, TextTestRunner
tests_dir = pjoin(dirname(__file__), 'tests')
suite = TestLoader().discover(tests_dir)
result = TextTestRunner().run(suite)
sys.exit(0 if result.wasSuccessful() else -1)
def test_1_gradient(self):
img = im_data.imread('image.jpg')
img = im_color.rgb2gray(img)
gd = two_neighbors_gradient(img)
blurred = blur(img, (9, 9))
gd2 = two_neighbors_gradient(blurred)
sh1 = mean(gd) * 256
sh2 = mean(gd2) * 256
self.assertGreater(sh1, sh2, 'Original sharpness should be bigger!')
def test_2_shb(self):
img = im_data.imread('image.jpg')
img = im_color.rgb2gray(img)
img = resize(img, None, fx=0.5, fy=0.5)
features = sharpness_behavior(img)
self.assertEqual(len(features), 5,
'The features returned should have 5'
' values')
if __name__ == '__main__':
# loads and runs the Unit Tests
suite = TestLoader().loadTestsFromTestCase(SHBTests)
TextTestRunner(verbosity=2, ).run(suite)
def suite():
""" returns all the testcases in this module """
return TestLoader().loadTestsFromTestCase(EasyConfigVersion)
return
self.fail(u"Expected exception")
def testLocalFilesAreNotRead(self):
try:
getHtmlSafely("/etc/passwd")
except HttpException, e:
return
self.fail(u"Expected exception")
def testFtpIsNotAllowed(self):
try:
getHtmlSafely("ftp:localhost")
except HttpException, e:
return
self.fail(u"Expected exception")
def testFtpIsNotAllowedWithProtocolAutoDetect(self):
try:
getHtmlSafely("ftp.funet.fi")
except HttpException, e:
self.failUnless(ERR_FORBIDDEN_SCHEME in e.parameter)
return
self.fail(u"Expected exception")
if __name__ == "__main__":
suite = TestLoader().loadTestsFromTestCase(VoikkoHtmlTest)
#suite = TestLoader().loadTestsFromName("voikkohtmlTest.VoikkoHtmlTest.testCorrectCommentParsing")
TextTestRunner(verbosity=1).run(suite)
def make_test_suite():
"""Load unittests placed in pybrain/tests/unittests, then return a
TestSuite object of those."""
# [...]/pybrain/pybrain [cut] /tests/runtests.py
path = os.path.abspath(__file__).rsplit(os.sep + 'tests', 1)[0]
sys.path.append(path.rstrip('pybrain'))
top_testdir = os.path.join(path, 'tests', 'unittests')
testdirs = getSubDirectories(top_testdir)
# Initialize the testsuite to add to
suite = TestSuite()
optionflags = doctest.ELLIPSIS | doctest.NORMALIZE_WHITESPACE | doctest.IGNORE_EXCEPTION_DETAIL
for testdir in testdirs:
# All unittest modules have to start with 'test_' and have to be, of
# course, python files
module_names = [
f[:-3] for f in os.listdir(testdir)
if f.startswith('test_') and f.endswith('.py')
]
if not module_names:
logging.info('No tests found in %s' % testdir)
continue
# "Magically" import the tests package and its test-modules that we've
# found
test_package_path = 'pybrain.tests.unittests'
sub_path = os.path.relpath(testdir, top_testdir).split(os.sep)
test_package_path = '.'.join([test_package_path] + sub_path)
test_package = __import__(test_package_path, fromlist=module_names)
# Put the test modules in a list that can be passed to the testsuite
modules = (getattr(test_package, n) for n in module_names)
modules = [(m, missingDependencies(m)) for m in modules]
untests = [(m, md) for m, md in modules if md]
modules = [m for m, md in modules if not md]
# print(out modules that are missing dependencies)
for module, miss_dep in untests: # Mr Dep is not around, though
logging.warning('Module %s is missing dependencies: %s' %
(module.__name__, ', '.join(miss_dep)))
# print(out a list of tests that are found)
for m in modules:
logging.info('Tests found: %s' % m.__name__)
# Build up the testsuite
suite.addTests([TestLoader().loadTestsFromModule(m) for m in modules])
# Add doctests from the unittest modules to the suite
for mod in modules:
try:
suite.addTest(
doctest.DocTestSuite(mod, optionflags=optionflags))
except ValueError:
# No tests found.
pass
return suite
# -----
if arguments.get("console", False):
for item in LOGGERS:
with suppress(KeyError):
config["loggers"][item]["handlers"] = ["file", "console"]
with suppress(KeyError):
config["handlers"]["console"]["level"] = "DEBUG"
config["handlers"]["console"]["func"] = partial(cf, attrgetter_("funcName")(partial(operator.contains, arguments.get("console", []))))
# -----
logging.config.dictConfig(config)
logger = logging.getLogger("MyPythonProject.{0}".format(os.path.splitext(os.path.basename(os.path.abspath(__file__)))[0]))
# ================
# Run main script.
# ================
verbosity = arguments.get("verbosity", 1)
if verbosity > 2:
verbosity = 2
suite, loader, runner = TestSuite(), TestLoader(), TextTestRunner(verbosity=verbosity)
suite.addTests(loader.loadTestsFromModule(module1))
suite.addTests(loader.loadTestsFromModule(module2))
suite.addTests(loader.loadTestsFromModule(module3))
suite.addTests(loader.loadTestsFromModule(module4))
suite.addTests(loader.loadTestsFromModule(module5))
if Path("F:/").exists():
from Applications.Unittests import module6
suite.addTests(loader.loadTestsFromModule(module6))
result = runner.run(suite)
sys.exit(EXIT[result.wasSuccessful()])
def add_tests_to_suite(suite, test_modules):
suite.addTests([
TestLoader().loadTestsFromModule(test_module)
for test_module in test_modules
])
tls.reportTCResult(None, 2, None, 'b', 'skip', guess=True,
testcaseexternalid='11-2',
platformname='NewPlatform',
execduration=1.9, timestamp='2018-06-04 23:00',
steps=[{'step_number': 1, 'result': "fail", 'notes': 'skip'}])
if __name__ == '__main__':
# redirector default output of unittest to /dev/null
with open(os.devnull, 'w') as null_stream:
# new a runner and overwrite resultclass of runner
runner = TextTestRunner(stream=null_stream)
runner.resultclass = JsonTestResult
# create a testsuite
suite = TestLoader().loadTestsFromTestCase(TestSimple)
# run the testsuite
result = runner.run(suite)
# print json output
print("\nresult.jsonify()")
pprint(result.jsonify())
TESTLINK_API_PYTHON_SERVER_URL = "http://192.168.1.161/lib/api/xmlrpc/v1/xmlrpc.php"
TESTLINK_API_PYTHON_DEVKEY = "0dc10c05acc7320bb5a0a793b6b08c97"
# tls = testlink.TestLinkHelper( TESTLINK_API_PYTHON_SERVER_URL, TESTLINK_API_PYTHON_DEVKEY).connect(testlink.TestlinkAPIClient)
tlh = testlink.TestLinkHelper(TESTLINK_API_PYTHON_SERVER_URL, TESTLINK_API_PYTHON_DEVKEY)
tls = testlink.TestlinkAPIClient(tlh._server_url, tlh._devkey, verbose=True)
def suite():
suite = TestSuite()
suite.addTest(TestLoader().loadTestsFromTestCase(PackagesTestCase))
return suite
def run(self):
test_suite = TestLoader().discover('./tests', pattern='*_test.py')
test_results = TextTestRunner(verbosity=2).run(test_suite)
def main():
tl = TestLoader()
suite = tl.loadTestsFromTestCase(ChipHardwareTest)
# This runs the whole suite of tests. For now, using TextTestRunner
result = TextTestRunner(verbosity=2, failfast=True).run(suite)
print result
def allTests(testClass):
return TestLoader().loadTestsFromTestCase(testClass)
def suite(self):
"""Return all the testcases in this module."""
return TestLoader().loadTestsFromTestCase(PanHandlerTest)
self.assertRaises(Exception,
solventlibrary.load_entry,
index=4,
label='benzene',
solvent=None,
molecule='ring')
# Case 5: when the solventDatabase contains data for co-solvents.
solventlibrary.load_entry(index=5,
label='methanol_50_water_50',
solvent=None,
molecule=['CO', 'O'])
solvent_species_list = [
Species().from_smiles('CO'),
Species().from_smiles('O')
]
self.assertEqual(
len(solventlibrary.entries['methanol_50_water_50'].item), 2)
for spc1 in solventlibrary.entries['methanol_50_water_50'].item:
self.assertTrue(
any([
spc1.is_isomorphic(spc2) for spc2 in solvent_species_list
]))
#####################################################
if __name__ == '__main__':
suite = TestLoader().loadTestsFromTestCase(TestSoluteDatabase)
TextTestRunner(verbosity=2).run(suite)
def test_learner_kwargs(self):
"""
Returns:
"""
my_learner = baseline_learner.BaselineLearner
data_arff = arff.Arff(self.arff_path, label_count=1)
session = manager.ToolkitSession(arff=self.arff_path, learner=my_learner, data=data_arff, example_hyperparameter=.5, label_count=1)
self.assertEqual(session.learner.data_shape,(690,16))
self.assertEqual(session.learner.example_hyperparameter, .5)
def test_confusion_matrix(self):
my_learner = baseline_learner.BaselineLearner
data_arff = arff.Arff(self.arff_path, label_count=1)
session = manager.ToolkitSession(arff=self.arff_path, learner=my_learner, data=data_arff, example_hyperparameter=.5, label_count=1)
session.train()
cm = session.learner.get_confusion_matrix(data_arff.get_features(), data_arff.get_labels())
self.assertEqual('383',cm[-1,-1])
def test_multidimensional_label(self):
pass
if __name__=="__main__":
print("here")
suite = TestLoader().loadTestsFromTestCase(TestManager)
TextTestRunner(verbosity=2).run(suite)
quantum_pauli_y_transform_20_qubits_array_expected_amplitudes,
rtol=1e-7, atol=1e-7)
"""
Perform the Assertion of all close values in the values of the quantum_regime state,
represented by its state vector describing the given qubit,
after be applied the Qiskrypt's Quantum Pauli-Y Transform.
"""
"""
Dummy Assert Equal for the Unittest.
"""
self.assertEqual(True, True)
if __name__ == "__main__":
"""
The Main Method for the Unitary Test.
"""
qiskrypt_quantum_pauli_y_transform_test_cases = \
TestLoader().loadTestsFromTestCase(QiskryptQuantumPauliYTransformTests)
"""
Load the Test Cases from the Unitary Tests for the Qiskrypt's Quantum Pauli-Y Transform.
"""
qiskrypt_quantum_pauli_y_transform_test_suite = \
TestSuite([qiskrypt_quantum_pauli_y_transform_test_cases])
"""
Load the Test Suite with all the Test Cases for the Qiskrypt's Quantum Pauli-Y Transform.
"""
def suite():
""" returns all the testcases in this module """
return TestLoader().loadTestsFromTestCase(ScriptsTest)
# -*- coding: utf-8 -*-
from unittest import TestLoader, TextTestRunner
try:
import pymongo
except ImportError:
print('Pymongo module is required')
try:
import gst
except ImportError:
print('Gst python binding is required')
if __name__ == "__main__":
test_loader = TestLoader()
suit = test_loader.discover('tests/', pattern='test*.py')
res = TextTestRunner(verbosity=1).run(suit)
raise SystemExit(not res.wasSuccessful())
def suite():
""" return all the tests in this file """
return TestLoader().loadTestsFromTestCase(ToyBuildTest)
#!/usr/bin/env python3 import sys from getopt import getopt from os.path import dirname from unittest import TestLoader, TextTestRunner def createTestRunner(): opts, _ = getopt(sys.argv[1:], '', ['xml=']) for o, v in opts: if o == '--xml': from xmlrunner import XMLTestRunner return XMLTestRunner(output=open(v, 'wb')) return TextTestRunner() if __name__ == '__main__': cwd = dirname(sys.argv[0]) suite = TestLoader().discover(cwd + '/test') runner = createTestRunner() result = runner.run(suite) sys.exit(not result.wasSuccessful())
def test_suite():
from unittest import TestLoader
return TestLoader().loadTestsFromName(__name__)
def test_suite():
from unittest import TestLoader, TestSuite
return TestSuite(
[TestLoader().loadTestsFromName(__name__),
make_integration_tests()])
def get_test_suite():
test_loader = TestLoader()
return test_loader.discover('test', pattern='*_test.py')
def suite():
""" return all the tests"""
return TestLoader().loadTestsFromTestCase(TestTesting)
