def test_all():
loader = TestLoader()
suite = TestSuite()
suite.addTests(loader.loadTestsFromTestCase(TestLocale))
suite.addTests(loader.loadTestsFromTestCase(TestExtract))
suite.addTests(loader.loadTestsFromTestCase(TestMerge))
return suite
def run():
loader = TestLoader()
suite = TestSuite((
loader.loadTestsFromTestCase(UtilsTests),
loader.loadTestsFromTestCase(Tests)
))
runner = TextTestRunner(verbosity = 2)
runner.run(suite)
def loadTestCases(self):
loader = TestLoader()
selector = QTestLoader()
if selector.exec_():
self.cases[:] = []
for case in selector.selected:
self.cases.extend(loader.loadTestsFromTestCase(case))
def test_suite():
loader = TestLoader()
tests = loader.loadTestsFromTestCase(PrincipalAnnotationTests)
import zope.app.principalannotation
tests.addTest(doctest.DocTestSuite(zope.app.principalannotation))
return tests
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
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 all_tests():
suite = TestSuite()
loader = TestLoader()
suite.addTests(loader.loadTestsFromTestCase(RewriterTest))
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 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 test_data_cleaned_up(self):
user_collection.remove()
company_collection.remove()
loader = TestLoader()
suite = loader.loadTestsFromTestCase(TestUnittestSupport.TestTestCase)
result = TestResult()
suite.run(result)
self.assertTrue(result.wasSuccessful(), result)
self.assertEquals(user_collection.count(), 0)
self.assertEquals(company_collection.count(), 0)
def testSuiteFromTCs(*tcs):
loader = TestLoader()
for tc in tcs:
# skip AxiLiteEndpointTC because we need one to test original methods
# from SimTestCase
if issubclass(tc, SimTestCase) and tc is not AxiLiteEndpointTC:
tc.runSim = runSimWithoutLog
tc._multiprocess_can_split_ = True
loadedTcs = [loader.loadTestsFromTestCase(tc) for tc in tcs]
suite = TestSuite(loadedTcs)
return suite
def suite():
unit_test_cases = ()
integration_test_cases = (
URLSmokeTest,
AuthMiddleWareTest,
RequestCreateTest, RequestDetailsTest, ProfileDetailsTest, RequestListTest,
TestAuthentication
)
all_test_cases = unit_test_cases + integration_test_cases
test_loader = TestLoader()
tests = [test_loader.loadTestsFromTestCase(case) for case in all_test_cases]
return TestSuite(tests)
def creat():
loadcase=TestLoader()
testsuite=[]
suite1=TestSuite()
suite2=TestSuite()
caseclass_dict={}
def backcount(d):
n=0
for i in d.values():
n+=i
return n
def caseclass_count(caselist):
print 'dir caselist',caselist
for casename in caselist:
module=loadcase._get_module_from_name(casename)
for name in dir(module):
obj = getattr(module,name)
if isinstance(obj, type) and issubclass(obj, case.TestCase):
modeltestcases_list=getTestCaseNames(obj,'test')
caseclass_dict[obj]=len(modeltestcases_list)
return caseclass_dict
classcase_dict=caseclass_count(backcaselist(dirs+'/bank_case'))
case_and_count_list=back_list(classcase_dict)
sort_case=SelectSort(case_and_count_list)
print sort_case
for i in range(len(sort_case)):
if i%2==0:
suite1.addTest(loadcase.loadTestsFromTestCase([x for x in sort_case[i].keys()][0]))
[x for x in sort_case[i].keys()][0].remoteip='http://172.17.2.136:3344/wd/hub'
else:
suite2.addTest(loadcase.loadTestsFromTestCase([x for x in sort_case[i].keys()][0]))
[x for x in sort_case[i].keys()][0].remoteip='http://172.17.2.57:3344/wd/hub'
print 'suite1',suite1
print 'suite2',suite2
testsuite.append(suite1)
testsuite.append(suite2)
return testsuite
def combine(*args):
"combine given TestCase classes and suite objects into a new suite"
loader = TestLoader()
suites = []
for arg in args:
if isinstance(arg, TestSuite):
suites.append(arg)
elif issubclass(arg, RealTestCase):
suites.append(loader.loadTestsFromTestCase(arg))
else:
msg = "combine: bad arg type: %s <%s>" % (arg, type(arg))
raise AssertionError(msg)
return TestSuite(suites)
def test_all():
loader = TestLoader()
suites = [
loader.loadTestsFromTestCase(TestRole),
loader.loadTestsFromTestCase(TestIP),
loader.loadTestsFromTestCase(TestHost),
loader.loadTestsFromTestCase(TestRoleMap),
loader.loadTestsFromTestCase(TestApi),
loader.loadTestsFromTestCase(TestHostsOutput),
loader.loadTestsFromTestCase(TestValidator),
]
testsuites = TestSuite(suites)
runner = TextTestRunner()
runner.run(testsuites)
def suite():
suite = TestSuite()
loader = TestLoader()
test_cases = [
EsViewTestCase,
EsQuerysetTestCase,
EsIndexableTestCase,
EsRestFrameworkTestCase]
if not TestModel.es.check_cluster():
print "Test skipped. Could not connect to elasticsearch."
else:
for test_case in test_cases:
tests = loader.loadTestsFromTestCase(test_case)
suite.addTests(tests)
return suite
def suite():
"""Suite of TestCases for Django"""
suite = TestSuite()
loader = TestLoader()
test_cases = (ManagersTestCase, EntryTestCase, CategoryTestCase,
ZinniaViewsTestCase, ZinniaFeedsTestCase,
ZinniaSitemapsTestCase, ComparisonTestCase,
ExternalUrlsPingerTestCase, TemplateTagsTestCase,
QuickEntryTestCase, EntryCommentModeratorTestCase)
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
def suite():
suite = TestSuite()
loader = TestLoader()
test_cases = [
BaseResourceTest,
JsonResourceTest,
DateRangeResourceTest,
InstanceResourceTest,
ExternalIdInstanceResourceTest,
RestApiTest,
ModelSyncTest,
SalesForceApiTest,
]
for test_case in test_cases:
tests = loader.loadTestsFromTestCase(test_case)
suite.addTests(tests)
return suite
def getSuites():
suites = [doctestSuite]
loader = TestLoader()
for startDir in searchDirs:
for testFile in findTests(startDir, skipFiles):
modBase = os.path.splitext(testFile)[0]
name = modBase.replace(os.path.sep, '.')
# import the testFile as a module
mod = importModule(name)
# iterate through module objects, checking for TestCases
for objName in dir(mod):
if not objName.endswith('TestCase'):
continue
obj = getattr(mod, objName)
if not issubclass(obj, TestCase):
continue
# create a suite from any test cases
suite = loader.loadTestsFromTestCase(obj)
# append to suites list
suites.append(suite)
return suites
def main():
cov = Coverage(
omit=[
"*passlib*",
"*test*",
"*tornado*",
"*backports_abc*",
"*singledispatch*",
"*six*",
"*certifi*",
"*daemon*",
"*funcsigs*",
"*mock*",
"*pbr*",
"*pkg_resources*",
"*tablib*",
]
)
cov.start()
from app_test import ApplicationTest
from database_test import DatabaseTest
from http_test import HTTPTestCase
from procinfo_test import ProcInfoTest
from user_test import UserTest
from token_test import TokenTest
from ws_test import WebSocketTestCase
from unittest import TestLoader, TextTestRunner, TestSuite
loader = TestLoader()
suite = TestSuite(
(
loader.loadTestsFromTestCase(ProcInfoTest),
loader.loadTestsFromTestCase(DatabaseTest),
loader.loadTestsFromTestCase(UserTest),
loader.loadTestsFromTestCase(TokenTest),
loader.loadTestsFromTestCase(HTTPTestCase),
loader.loadTestsFromTestCase(WebSocketTestCase),
loader.loadTestsFromTestCase(ApplicationTest),
)
)
runner = TextTestRunner(verbosity=2)
runner.run(suite)
cov.stop()
cov.save()
def suite():
"""Suite of TestCases for Django"""
suite = TestSuite()
loader = TestLoader()
test_cases = (ManagersTestCase, GbobjectTestCase,
GbobjectGetBaseModelTestCase, SignalsTestCase,
GbobjectHtmlContentTestCase, ObjecttypeTestCase,
ObjectappViewsTestCase, ObjectappFeedsTestCase,
ObjectappSitemapsTestCase, ComparisonTestCase,
DirectoryPingerTestCase, ExternalUrlsPingerTestCase,
TemplateTagsTestCase, QuickGbobjectTestCase,
URLShortenerTestCase, GbobjectCommentModeratorTestCase,
ObjectappCustomDetailViews, SpamCheckerTestCase,
GbobjectAdminTestCase, ObjecttypeAdminTestCase)
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
from unittest import TestLoader, TestSuite, TextTestRunner
from Test.TestScripts.test_Home_Page import TestHomePage
from Test.TestScripts.test_Search_Page import TestSearchPage
from Test.TestScripts.test_Registration_Page import TestRegistration
from Test.TestScripts.test_Login_Page import TestLoginPage
# import testtools as testtools
if __name__ == "__main__":
loader = TestLoader()
suite = TestSuite((
loader.loadTestsFromTestCase(TestHomePage),
loader.loadTestsFromTestCase(TestSearchPage),
loader.loadTestsFromTestCase(TestRegistration),
loader.loadTestsFromTestCase(TestLoginPage)
))
#run test sequentially using simple TextTestRunner
runner = TextTestRunner(verbosity=2)
runner.run(suite)
# #run test parallel using concurrent_suite
# concurrent_suite = testtools.ConcurrentStreamTestSuite(lambda: ((case, None) for case in suite))
# concurrent_suite.run(testtools.StreamResult())
from unittest import TestLoader, TextTestRunner, TestSuite
from api_test import APITestCase
from software_test import SoftwareTestCase
from database_test import DatabaseTestCase
from host_test import HostTestCase
if __name__ == '__main__':
TEST_CLASSES_TO_RUN = [
APITestCase, SoftwareTestCase, DatabaseTestCase, HostTestCase
]
LOADER = TestLoader()
SUITES_LIST = [
LOADER.loadTestsFromTestCase(test_class)
for test_class in TEST_CLASSES_TO_RUN
]
BIG_SUITE = TestSuite(SUITES_LIST)
exit(TextTestRunner(verbosity=2).run(BIG_SUITE).wasSuccessful())
print("Test Distributivity Mul over Sum: {0}".format(ringname))
permut3 = permutations(Ring.generateSET(), 3)
for x, y, z in permut3:
self.assertEqual(x * (y + z), (x * y) + (x * z))
for x, y, z in permut3:
self.assertEqual((y + z) * x, (y * x) + (z * x))
return TestRing
ringZ = genRing(Z, lambda x, y: Z(x.value+y.value), lambda x, y: Z(x.value*y.value), Z(1), Z(0))
testZ = generateTestCase(ringZ, "ring Z + x i=1 z=0")
ringZn = genRing(Zn, lambda x, y: Zn(x.value*y.value), lambda x, y: Zn(x.value+y.value), Zn(0), Zn(1))
testZn = generateTestCase(ringZn, "ring Zn x + i=0 z=1")
ringZ4 = genRing(Z4, lambda x, y: Z4((x.value+y.value) % 4), lambda x, y: Z4((x.value*y.value) % 4), Z4(1), Z4(0))
testZ4 = generateTestCase(ringZ4, "ring Z4 + x i=1 z=0")
ringBool = genRing(Bool, lambda x, y: Bool(x.value or y.value), lambda x, y: Bool(x.value and y.value), Bool(True), Bool(False))
testBool = generateTestCase(ringBool, "ring Bool or and i=True z=False")
tests = [testZ, testZn, testZ4, testBool]
if __name__ == '__main__':
suite = TestSuite()
testLoader = TestLoader()
for test in tests:
suite.addTest(testLoader.loadTestsFromTestCase(test))
runner = TextTestRunner(verbosity=2)
runner.run(suite)
def test_suite(): suite = TestSuite() loader = TestLoader() suite.addTests(loader.loadTestsFromTestCase(TVComTest)) return suite
languages = list(LANGUAGE_MAPPING.keys()) + list(AVAILABLE_LANGUAGES)
sample = random.sample(languages, len(languages))
for language in sample:
stop_words = safe_get_stop_words(language)
self.assertTrue(
len(stop_words) > 0,
'Cannot load stopwords for {0} language'.format(language)
)
def test_filters(self):
language = 'en'
before = get_stop_words(language, False)
letter = random.choice(random.choice(before))
def remove_letter(stopwords, language):
return [word for word in stopwords if letter not in word]
stop_words.add_filter(remove_letter)
after = get_stop_words(language, False)
for stopword in after:
self.assertFalse(letter in stopword)
self.assertTrue(stop_words.remove_filter(remove_letter))
loader = TestLoader()
test_suite = TestSuite(
[
loader.loadTestsFromTestCase(StopWordsTestCase),
]
)
"""
storage = StringIO.StringIO()
c = pycurl.Curl()
c.setopt(c.URL, 'http://127.0.0.1:8090/-/')
c.setopt(c.HTTPHEADER, ['Content-Type: application/occi+json', 'Accept: application/occi+json'])
c.setopt(c.CUSTOMREQUEST, 'PUT')
c.setopt(c.POSTFIELDS, f_categories.action)
c.setopt(c.WRITEFUNCTION, storage.write)
c.perform()
content = storage.getvalue()
print " ===== Body content =====\n " + content + " ==========\n"
if __name__ == '__main__':
#Create the testing tools
loader = TestLoader()
runner = TextTestRunner(verbosity=2)
#Create the testing suites
get_suite = loader.loadTestsFromTestCase(test_get)
delete_suite = loader.loadTestsFromTestCase(test_delete)
post_suite = loader.loadTestsFromTestCase(test_post)
put_suite = loader.loadTestsFromTestCase(test_put)
#Run tests
runner.run(put_suite)
import os
import sys
import logging
from unittest import TestLoader, TextTestRunner, TestSuite
from backup_scenario import BackupScenarioFS
SWIFT_CONF = 'swiftrc'
def load_swift_env(fname):
file_lines = open(fname, 'r').readlines()
for line in file_lines:
if ' ' not in line.strip():
continue
(cmd, line) = line.split()
if cmd.strip().lower() == 'unset':
os.environ.pop(line, None)
elif '=' in line.strip():
(key, val) = line.split('=')
os.environ[key.strip()] = val.strip()
if __name__ == "__main__":
load_swift_env(SWIFT_CONF)
logging.disable(logging.CRITICAL)
os.system('./vagrant-scripts/create-lvm.sh 1')
loader = TestLoader()
suite = TestSuite(loader.loadTestsFromTestCase(BackupScenarioFS), )
runner = TextTestRunner(verbosity=2)
runner.run(suite)
def test_random_language_stop_words_load(self):
languages = list(LANGUAGE_MAPPING.keys()) + list(AVAILABLE_LANGUAGES)
sample = random.sample(languages, len(languages))
for language in sample:
stop_words = safe_get_stop_words(language)
self.assertTrue(
len(stop_words) > 0,
'Cannot load stopwords for {0} language'.format(language))
def test_filters(self):
language = 'en'
before = get_stop_words(language, False)
letter = random.choice(random.choice(before))
def remove_letter(stopwords, language):
return [word for word in stopwords if letter not in word]
stop_words.add_filter(remove_letter)
after = get_stop_words(language, False)
for stopword in after:
self.assertFalse(letter in stopword)
self.assertTrue(stop_words.remove_filter(remove_letter))
loader = TestLoader()
test_suite = TestSuite([
loader.loadTestsFromTestCase(StopWordsTestCase),
])
# Copyright (c) 2004-present Facebook All rights reserved.
# Use of this source code is governed by a BSD-style
# license that can be found in the LICENSE file.
from unittest import TestLoader, TestSuite, TextTestRunner
from test_equipment import TestEquipment
from test_link import TestLink
from test_location import TestLocation
from test_service import TestService
from test_site_survey import TestSiteSurvey
from utils.constant import XML_OUTPUT_DIRECTORY
from xmlrunner import XMLTestRunner
TEST_CASES = [
TestLocation, TestEquipment, TestLink, TestService, TestSiteSurvey
]
if __name__ == "__main__":
suite = TestSuite()
loader = TestLoader()
for test_class in TEST_CASES:
tests = loader.loadTestsFromTestCase(test_class)
suite.addTests(tests)
if XML_OUTPUT_DIRECTORY:
runner = XMLTestRunner(output=XML_OUTPUT_DIRECTORY, verbosity=2)
else:
runner = TextTestRunner(verbosity=2)
runner.run(suite)
from unittest import TestLoader, TestSuite, TextTestRunner
from admintest import admintest
from staffTest import staffTest
from residentTest import residentTest
from ResetPassword import ResetPassword
from signupFeature import signupFeature
from categoryFeature import categoryFeature
if __name__ == "__main__":
loader = TestLoader()
suite = TestSuite((
loader.loadTestsFromTestCase(categoryFeature),
loader.loadTestsFromTestCase(signupFeature),
loader.loadTestsFromTestCase(ResetPassword),
loader.loadTestsFromTestCase(residentTest),
loader.loadTestsFromTestCase(staffTest),
loader.loadTestsFromTestCase(admintest),
))
runner = TextTestRunner(verbosity=2)
runner.run(suite)
from unittest import TestLoader, TestSuite, TextTestRunner
from Tests.Login import LoginTest
from Tests.Dashboard import DashboardTest
if __name__ == "__main__":
loader = TestLoader()
suite = TestSuite((
loader.loadTestsFromTestCase(LoginTest),
loader.loadTestsFromTestCase(DashboardTest),
))
runner = TextTestRunner(verbosity=2)
runner.run(suite)
from unittest import TestLoader, TestSuite, TextTestRunner
import testtools as testtools
if __name__ == "__main__":
loader = TestLoader()
suite = TestSuite(
(loader.loadTestsFromTestCase(MercuryTours_HomePage),
loader.loadTestsFromTestCase(MercuryTours_SignOn),
loader.loadTestsFromTestCase(MercuryTours_Registration)))
#run test sequentially using simple TextTestRunner
runner = TextTestRunner(verbosity=2)
runner.run(suite)
# #run test parallel using concurrent_suite
concurrent_suite = testtools.ConcurrentStreamTestSuite(
lambda: ((case, None) for case in suite))
concurrent_suite.run(testtools.StreamResult())
from unittest import TestLoader, TextTestRunner, TestSuite
from unit_tests.docker_command_tests import Test_APIs
# Uses a testLoader to run multiple tests from different python unit tests file
if __name__ == "__main__":
loader = TestLoader()
suite = TestSuite((
loader.loadTestsFromTestCase(Test_APIs),
))
runner = TextTestRunner()
runner.run(suite)
def test_delete_on_path(self):
"""
get resources & links
"""
storage = StringIO.StringIO()
c = pycurl.Curl()
c.setopt(pycurl.URL, "http://127.0.0.1:8090/compute/bilel/")
c.setopt(pycurl.HTTPHEADER, ["Accept: application/occi+json", "Content-Type: application/occi+json"])
c.setopt(pycurl.CUSTOMREQUEST, "DELETE")
c.setopt(c.WRITEFUNCTION, storage.write)
c.perform()
content = storage.getvalue()
print " ===== Body content =====\n " + content + " ==========\n"
if __name__ == "__main__":
# Create the testing tools
loader = TestLoader()
runner = TextTestRunner(verbosity=2)
# Create the testing suites
get_suite = loader.loadTestsFromTestCase(test_get)
delete_suite = loader.loadTestsFromTestCase(test_delete)
# Run tests
runner.run(delete_suite)
from unittest import TestLoader, TextTestRunner, TestSuite
from testfilelister import TestFileLister
from testfilemover import TestFileMover
from testrequester import TestRequester
from testdropboxaccess import TestDropboxAccess
from testtransferfiles import TestTransferFiles
from testconfigmanager import TestConfigManager
if __name__ == "__main__":
'''
This test suite runs on Android in Pydroid, but fails in QPython !
'''
loader = TestLoader()
suite = TestSuite((loader.loadTestsFromTestCase(TestFileLister),
loader.loadTestsFromTestCase(TestFileMover),
loader.loadTestsFromTestCase(TestRequester),
loader.loadTestsFromTestCase(TestDropboxAccess),
loader.loadTestsFromTestCase(TestTransferFiles),
loader.loadTestsFromTestCase(TestConfigManager)))
runner = TextTestRunner(verbosity=2)
runner.run(suite)
def test_suite():
suite = TestSuite()
loader = TestLoader()
suite.addTest(loader.loadTestsFromTestCase(TranslationFormatInvalidInputErrorTest))
suite.addTest(loader.loadTestsFromTestCase(TranslationFormatSyntaxErrorTest))
return suite
# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
from unittest import (TestSuite, TestLoader, TextTestRunner)
from AlgFactory_test import TestAlgFactory
from jetDefAlgToString_test import TestJetDefAlgToString
from Sequence_test import TestSequence
from JetSequencesBuilder_test import TestJetSequencesBuilder
from JetDef_test import TestJetDef
from JetDef_test2 import TestJetDef2
from InstantiatorFactory_test import TestInstantiatorFactory
from hypo_factory_test import Test_hypo_factory
from jetDefInstantiator_test import Test_jetDefInstantiator
from fexparams_factory_test import Test_fexparams_factory
from ChainConfigMaker_test import Test_ChainConfigMaker
test_cases = (TestAlgFactory, TestJetDefAlgToString, TestSequence,
TestJetSequencesBuilder, TestJetDef, TestJetDef2,
TestInstantiatorFactory, Test_hypo_factory,
Test_jetDefInstantiator, Test_fexparams_factory,
Test_ChainConfigMaker)
loader = TestLoader()
suite = TestSuite([loader.loadTestsFromTestCase(tc) for tc in test_cases])
runner = TextTestRunner(verbosity=2)
runner.run(suite)
from unittest import TestLoader, TestSuite, TextTestRunner
from netCDF4_weld.tests import VariableTests, DatasetTests, UtilsTests
if __name__ == '__main__':
loader = TestLoader()
suite = TestSuite((loader.loadTestsFromTestCase(VariableTests),
loader.loadTestsFromTestCase(DatasetTests),
loader.loadTestsFromTestCase(UtilsTests)))
runner = TextTestRunner(verbosity=2)
runner.run(suite)
class Kissenium:
"""Kissenium is a free software to run selenium tests
To define new scenarios, please check the examples given in ``./scenarios`` folder.
First run:
You will need to create a new class file and add it to ``__init__.py``. Then,
you can declare your new scenario like the following::
def __init__(self):
...
self.test_classes_to_run = [scenarios.TestDemo, scenarios.ParallelDemo]
...
Then you can run your tests:
From your virtual environment::
$(Kissenium) ./kissenium.py
Note:
Don't forget to check the `kissenium.ini`` file. Here you will be able to activate
or deactivate the main functionalities.
Developers:
Here are the commands that you will need:
* Pylint::
$(Kissenium) pylint kissenium.py base/
* Documentation::
$(Kissenium) make clean && make html
"""
def __init__(self):
"""Init Kissenium Runner class
"""
self.start = datetime.datetime.now()
self.prepare_for_run()
self.config = Config()
self.logger = Log4Kissenium().setup("Kissenium", "Kissenium")
self.logger.info("Logger created.")
self.loader = TestLoader()
self.suites = []
@staticmethod
def clean_reports_folder():
"""Clean reports folder on every run
:return:
"""
reports_list = glob.glob("reports/*")
globs = [reports_list]
for g in globs:
SmallTools.delete_from_glob(g)
def prepare_for_run(self):
"""Prepare the report folders for Kissenium execution
:return:
"""
self.clean_reports_folder()
SmallTools.check_path("reports/tmp")
def execution(self):
"""Execute Kissenium with a single test runner
:return:
"""
results = {}
for test_class in scenarios.__actives__:
suite = self.loader.loadTestsFromTestCase(test_class)
self.suites.append(suite)
suite = TestSuite(self.suites)
test_runner = HTMLTestRunner(
output='html',
template='resources/html/kissenium-template.html',
report_title='Test report')
results['single_runner'] = test_runner.run(suite)
return (results['single_runner'].wasSuccessful()), results
def parallel_execution(self):
"""Execute kissenium with parallels tests runners
You can disable (or enable) the parallels runners, and modify the max number of threads in
``kissenium.ini``::
RunParallel = True
MaxParallel = 5
Solution for parrallel execution finded here:
https://stackoverflow.com/questions/38189461/how-can-i-execute-in-parallel-selenium-python-tests-with-unittest
:return:
"""
suite = TestSuite()
results = {}
for test in scenarios.__actives__:
suite.addTest(TestLoader().loadTestsFromTestCase(test))
with ThreadPoolExecutor(
max_workers=int(self.config.get_max_parallel())) as executor:
list_of_suites = list(suite)
for test in list_of_suites:
results[str(test)] = executor.submit(
HTMLTestRunner(
output='html',
template='resources/html/kissenium-template.html',
report_title=str(test)).run, test)
executor.shutdown(wait=True)
for key, future in results.items():
result = future.result()
self.logger.debug('[%s] Result is : %s', key,
result.wasSuccessful())
if not result.wasSuccessful():
return False, results
return True, results
def run(self):
"""Run Kissenium tests
:return:
"""
self.logger.info('Launching tests ...')
if self.config.get_run_parallel() == 'True':
self.logger.info("Test are parallel")
status, results = self.parallel_execution()
else:
self.logger.info("Test are not parallel")
status, results = self.execution()
self.logger.info(
"All tests have been executed. Kissenium will stop now.")
HtmlRender(results, self.start).create_index()
JunitResults(results, self.start).generate()
sys.exit(not status)
def get_suite():
loader = TestLoader()
suite = TestSuite()
suite.addTest(loader.loadTestsFromTestCase(HighlanderTestCase))
return suite
from unittest import TestLoader, TextTestRunner, TestSuite
import vectorFunctionsTest
import skeletonFunctionsTest
if __name__ == "__main__":
loader = TestLoader()
suite = TestSuite((
loader.loadTestsFromTestCase(vectorFunctionsTest.TestVectorFunctions),
loader.loadTestsFromTestCase(skeletonFunctionsTest.TestSkeletonFunctions),
))
runner = TextTestRunner(verbosity = 2)
runner.run(suite)
if __name__ == "__main__":
loader = TestLoader()
suite = TestSuite((
# --------------- Rapt UI Screens and Negative casses------------
#loader.loadTestsFromTestCase(Rapt_Ui_Registration),
#loader.loadTestsFromTestCase(Rapt_Ui_Registration_Screens),
#loader.loadTestsFromTestCase(Rapt_Ui_Login_Screens),
#loader.loadTestsFromTestCase(Rapt_Ui_AdminLogin),
#loader.loadTestsFromTestCase(Rapt_Ui_DatasetTab),
#loader.loadTestsFromTestCase(Rapt_Ui_ComputeTab),
# Single user single gpu
# ---------------------- local ---------------------------------
loader.loadTestsFromTestCase(Kubernetes_Ui_Mnist_Auto),
#loader.loadTestsFromTestCase(Kubernetes_Ui_Mnist_Manual),
'''
#loader.loadTestsFromTestCase(Kubernetes_Ui_Pgan_Auto),
#loader.loadTestsFromTestCase(Kubernetes_Ui_Pgan_Manual),
loader.loadTestsFromTestCase(Kubernetes_Ui_Image_Auto),
loader.loadTestsFromTestCase(Kubernetes_Ui_Image_Manual),
# --------------------- nfs --------------------------------------
loader.loadTestsFromTestCase(Kubernetes_Ui_Nfs_Mnist_Auto),
loader.loadTestsFromTestCase(Kubernetes_Ui_Nfs_Mnist_Manual),
loader.loadTestsFromTestCase(Kubernetes_Ui_Nfs_Pgan_Auto),
loader.loadTestsFromTestCase(Kubernetes_Ui_Nfs_Pgan_Manual),
def test_suite():
suite = TestSuite()
loader = TestLoader()
suite.addTests(loader.loadTestsFromTestCase(SourcesTest))
return suite
from unittest import (TestSuite,
TestLoader,
TextTestRunner)
from algFactories_test import TestAlgFactories
from jetDefAlgToString_test import TestJetDefAlgToString
from Sequence_test import TestSequence
from JetSequenceRouter_test import TestJetSequenceRouter
from JetDef_test import TestJetDef
from InstantiatorFactory_test import TestInstantiatorFactory
from hypo_factory_test import Test_hypo_factory
from jetDefInstantiator_test import Test_jetDefInstantiator
test_cases = (TestAlgFactories,
TestJetDefAlgToString,
TestSequence,
TestJetSequenceRouter,
TestJetDef,
TestInstantiatorFactory,
Test_hypo_factory,
Test_jetDefInstantiator)
loader = TestLoader()
suite = TestSuite([loader.loadTestsFromTestCase(tc) for tc in test_cases])
runner = TextTestRunner(verbosity=2)
runner.run(suite)
from unittest import TestLoader, TestSuite, TextTestRunner
from .chessboard import TestChessboard
from .do_continue import TestDoContinue
from .envelopes_analysis import TestEnvelopeEntry
from .fibonacci_range import TestFibonacci
from .fibonacci_range import TestFibonacciGeneration
from .triangles_sorting import TestAreaCalculation
from .triangles_sorting import TestSorting
from .triangles_sorting import TestValidation
if __name__ == '__main__':
loader = TestLoader()
suit = TestSuite((
loader.loadTestsFromTestCase(TestChessboard),
loader.loadTestsFromTestCase(TestDoContinue),
loader.loadTestsFromTestCase(TestEnvelopeEntry),
loader.loadTestsFromTestCase(TestFibonacci),
loader.loadTestsFromTestCase(TestFibonacciGeneration),
loader.loadTestsFromTestCase(TestAreaCalculation),
loader.loadTestsFromTestCase(TestSorting),
loader.loadTestsFromTestCase(TestValidation),
))
runner = TextTestRunner(verbosity=2)
runner.run(suit)
from unittest import TestLoader, TestSuite, TextTestRunner
from Login_test import LoginTest
from stock_edit import StockEditTest
from Stock_add import StockAddTest
from stock_delete import StockDeleteTest
from investment_add import InvestmentAddTest
from investment_edit import InvestmentEditTest
from investment_delete import InvestmentDeleteTest
from cust_edit import CustEditTest
from cust_delete import CustDeleteTest
from cust_summary import CustSummaryTest
if __name__ == "__main__":
loader = TestLoader()
suite = TestSuite((
loader.loadTestsFromTestCase(LoginTest),
loader.loadTestsFromTestCase(StockAddTest),
loader.loadTestsFromTestCase(StockEditTest),
loader.loadTestsFromTestCase(StockDeleteTest),
loader.loadTestsFromTestCase(InvestmentAddTest),
loader.loadTestsFromTestCase(InvestmentEditTest),
loader.loadTestsFromTestCase(InvestmentDeleteTest),
loader.loadTestsFromTestCase(CustEditTest),
loader.loadTestsFromTestCase(CustDeleteTest),
loader.loadTestsFromTestCase(CustSummaryTest),
))
runner = TextTestRunner(verbosity=2)
runner.run(suite)
def run_tests_from_classes(*test_classes):
loader = TestLoader()
suite = TestSuite(
(loader.loadTestsFromTestCase(tc) for tc in test_classes))
TextTestRunner(verbosity=2).run(suite)
from g2p.tests.test_network import NetworkTest
from g2p.tests.test_studio import StudioTest
from g2p.tests.test_tokenize_and_map import TokenizeAndMapTest
from g2p.tests.test_tokenizer import TokenizerTest
from g2p.tests.test_transducer import TransducerTest
from g2p.tests.test_unidecode_transducer import UnidecodeTransducerTest
from g2p.tests.test_utils import UtilsTest
from g2p.tests.test_z_local_config import LocalConfigTest
# Deliberately left out:
# from g2p.tests.test_doctor_expensive import ExpensiveDoctorTest
LOADER = TestLoader()
TRANSDUCER_TESTS = [
LOADER.loadTestsFromTestCase(test)
for test in [
IndicesTest,
TransducerTest,
UnidecodeTransducerTest,
]
]
MAPPINGS_TESTS = [
LOADER.loadTestsFromTestCase(test)
for test in [
FallbackTest,
MappingCreationTest,
MappingTest,
NetworkTest,
UtilsTest,
from unittest import TestLoader, TestSuite, TextTestRunner
import test_demo
from test_demo import MyTest
loader = TestLoader()
suite = TestSuite(
[loader.loadTestsFromModule(test_demo),
loader.loadTestsFromTestCase(MyTest)]
)
runner = TextTestRunner(verbosity=2)
runner.run(suite)
