def test_testMethodPrefix__default_value(self): loader = unittest2.TestLoader() self.assertTrue(loader.testMethodPrefix == 'test')
self.assertIsNotNone(self.server) stats = self.mc.get_stats('settings') self.assertEqual(1.0, float(stats[0][1]['stats_agg_intvl'])) def test_slabsize(self): '''Choose a different slab/max-item size, -I''' # jumbo slabs args = Args(command='SLAB_SIZE = 1024 * 1024 * 4') slabsize = 1024 * 1024 * 4 self.server = startServer(args) self.assertIsNotNone(self.server) # here we use a different memcache client to set value length differently mc = memcache.Client(["%s:%s" % (SERVER, PORT)], debug=0, server_max_value_length=slabsize) mc.set("lval", 'a' * (slabsize - 512)) self.assertEqual(slabsize - 512, len(mc.get("lval"))) def test_slabfile(self): '''Initalize slab classes with a size profile, -z''' # create a slab profile first args = Args(command='SLAB_PROFILE = "64,128,256"') self.server = startServer(args) self.assertIsNotNone(self.server) if __name__ == '__main__': functional_startup = unittest.TestLoader().loadTestsFromTestCase( FunctionalStartup) unittest.TextTestRunner(verbosity=2).run(functional_startup)
expected = 20 self.assertEqual(expected, actual) def test_maps_debug(self): """Logleveler maps debug""" actual = logleveler('debug') expected = 10 self.assertEqual(expected, actual) def test_maps_warn(self): """Logleveler maps warn""" actual = logleveler('warn') expected = 30 self.assertEqual(expected, actual) def test_maps_warning(self): """Logleveler maps warning""" actual = logleveler('warning') expected = 30 self.assertEqual(expected, actual) def test_maps_error(self): """Logleveler maps error""" actual = logleveler('error') expected = 40 self.assertEqual(expected, actual) def test_maps_notset(self): """Logleveler maps notset""" actual = logleveler('notset') expected = 0 self.assertEqual(expected, actual) suite = unittest.TestLoader().loadTestsFromTestCase(ValidateUtilities) unittest.TextTestRunner(verbosity=2).run(suite)
def test_find_tests_with_package(self): loader = unittest2.TestLoader() original_listdir = os.listdir def restore_listdir(): os.listdir = original_listdir original_isfile = os.path.isfile def restore_isfile(): os.path.isfile = original_isfile original_isdir = os.path.isdir def restore_isdir(): os.path.isdir = original_isdir directories = ['a_directory', 'test_directory', 'test_directory2'] path_lists = [directories, [], [], []] os.listdir = lambda path: path_lists.pop(0) self.addCleanup(restore_listdir) os.path.isdir = lambda path: True self.addCleanup(restore_isdir) os.path.isfile = lambda path: os.path.basename(path) not in directories self.addCleanup(restore_isfile) class Module(object): paths = [] load_tests_args = [] def __init__(self, path): self.path = path self.paths.append(path) if os.path.basename(path) == 'test_directory': def load_tests(loader, tests, pattern): self.load_tests_args.append((loader, tests, pattern)) return 'load_tests' self.load_tests = load_tests def __eq__(self, other): return self.path == other.path # Silence py3k warning __hash__ = None loader._get_module_from_name = lambda name: Module(name) def loadTestsFromModule(module, use_load_tests): if use_load_tests: raise self.failureException( 'use_load_tests should be False for packages') return module.path + ' module tests' loader.loadTestsFromModule = loadTestsFromModule loader._top_level_dir = '/foo' # this time no '.py' on the pattern so that it can match # a test package suite = list(loader._find_tests('/foo', 'test*')) # We should have loaded tests from the test_directory package by calling load_tests # and directly from the test_directory2 package self.assertEqual(suite, ['load_tests', 'test_directory2' + ' module tests']) self.assertEqual(Module.paths, ['test_directory', 'test_directory2']) # load_tests should have been called once with loader, tests and # pattern self.assertEqual( Module.load_tests_args, [(loader, 'test_directory' + ' module tests', 'test*')])
import unittest2 as unittest import numpy as np from vsm.model.lsa import Lsa class TestLsa(unittest.TestCase): def setUp(self): self.tfidf_mat = np.array(\ [[2.0794415, 1.3862944, 0], [0.86304623, 0.28768209, 0.28768209], [np.inf, np.inf, np.inf], [0, 0, 0]]) self.eigenvalues = np.array(\ [ 0.35270742, 2.65176495]) self.doc_matrix = np.array([0.314334, 0.023485]) #TODO: Write some actual unit tests for this module #Define and run test suite suite = unittest.TestLoader().loadTestsFromTestCase(TestLsa) unittest.TextTestRunner(verbosity=2).run(suite)
def run(name='__main__'): result = runsuite(unittest.TestLoader().loadTestsFromName(name), False) sys.exit(0 if result.wasSuccessful() else 1)
self.assertEqual(0, _pt.len) with open(self.tempf, "wt") as f: f.write("a b") self.assertRaises(ValueError, ParameterTable, self.tempf) def test_current_parameter(self): _pt = self.obj self.assertRaises(IndexError, _pt.current_parameter) _pt.paraLines.append("0 1\n") self.assertEqual(1.0, _pt.current_parameter()[1]) def test_update_table(self): _pt = self.obj self.assertRaises(ValueError, _pt.update_table, [0.0, 1.0, 2.0]) self.assertIsNone(_pt.update_table([0.0, 1.0])) def test_write_line(self): pass @classmethod def tearDownClass(cls): os.remove(cls.tempf) sys.stdout = cls.stdout if __name__ == "__main__": suite = unittest.TestLoader().loadTestsFromTestCase(TestParameterTable) unittest.TextTestRunner(verbosity=2).run(suite)
def run(self): suite = unittest.TestLoader().loadTestsFromNames( ['tests.__main__.suite']) unittest.TextTestRunner(verbosity=2).run(suite)
import unittest2 import HTMLTestRunner import os import sys, re, traceback class TestSeqFunc(unittest2.TestCase): def test1(self): click("Field.png") assert True def test2(self): click("Field.png") assert False suite = unittest2.TestLoader().loadTestsFromTestCase(TestSeqFunc) #CreateFile = os.path.expanduser("~/Desktop/Report.html") #outfile = open(CreateFile, "w") #runner = HTMLTestRunner.HTMLTestRunner(stream=outfile, title="Test Report", description="Test1") runner.run(suite)
cm = BeagleContextSeq(cc, ec, e.matrix) cm.train() om = BeagleOrderSeq(ec, e.matrix) om.train() m = BeagleComposite(cc, cm.matrix, ec, om.matrix) m.train() self.venv = BeagleViewer(ec, e) self.vctx = BeagleViewer(cc, cm) self.vord = BeagleViewer(ec, om) self.vcom = BeagleViewer(cc, m) def test_BeagleViewer(self): sww = self.venv.dist_word_word('1') sww1 = self.vord.dist_word_word('0') self.assertTrue(type(sww) == LabeledColumn) self.assertTrue(type(sww1) == LabeledColumn) smw = self.vcom.dismat_word(['1']) smw1 = self.vctx.dismat_word(['1']) self.assertTrue(type(smw) == IndexedSymmArray) self.assertTrue(type(smw1) == IndexedSymmArray) #Define and run test suite suite = unittest.TestLoader().loadTestsFromTestCase(TestBeagleViewer) unittest.TextTestRunner(verbosity=2).run(suite)
# # This file is part of pyasn1 software. # # Copyright (c) 2005-2017, Ilya Etingof <*****@*****.**> # License: http://snmplabs.com/pyasn1/license.html # try: import unittest2 as unittest except ImportError: import unittest suite = unittest.TestLoader().loadTestsFromNames([ 'tests.codec.cer.test_encoder.suite', 'tests.codec.cer.test_decoder.suite' ]) if __name__ == '__main__': unittest.TextTestRunner(verbosity=2).run(suite)
def test_loadTestsFromNames__relative_empty_name_list(self): loader = unittest2.TestLoader() suite = loader.loadTestsFromNames([], unittest2) self.assertIsInstance(suite, loader.suiteClass) self.assertEqual(list(suite), [])
def test_suiteClass__default_value(self): loader = unittest2.TestLoader() self.assertTrue(loader.suiteClass is unittest2.TestSuite)
def test_sortTestMethodsUsing__default_value(self): loader = unittest2.TestLoader() self.assertTrue(loader.sortTestMethodsUsing is cmp)
def test_avgdistance(self): avg = self.database.do(read.get_avg_distance) self.assertEqual(correct_avgdistance, avg) def test_bigcity(self): city = self.database.do(read.get_largest_city)['code'] self.assertEqual(correct_bigcity, city) def test_smallcity(self): city = self.database.do(read.get_smallest_city)['code'] self.assertEqual(correct_smallcity, city) def test_avgpop(self): avg = self.database.do(read.get_average_pop) self.assertEqual(correct_avgpop, avg) def test_hubs(self): hubs, maximum = self.database.do(read.get_hubs) self.assertItemsEqual(correct_hubs, hubs) self.assertEqual(correct_hubcount, maximum) def test_continents(self): self.assertItemsEqual(correct_continents, self.database.do(read.get_continents)) if __name__ == '__main__': # Run the test cases with a bit of fancy formatting. suite = unittest2.TestLoader().loadTestsFromTestCase(TestMapDatabase) unittest2.TextTestRunner(verbosity=2).run(suite)
def suite(): """The test suite for this writer's tests.""" loader = unittest.TestLoader() mysuite = unittest.TestSuite() mysuite.addTest(loader.loadTestsFromTestCase(TestGeoTIFFWriter)) return mysuite
def run_tests_from_names(names, buffer_test_output, xml_output, skipUntil): loader = unittest.TestLoader() suites = [] for name in names: full_name = add_class_path_prefix(name) try: suite = loader.loadTestsFromName(full_name) suites.append(suite) except AttributeError as e: raise ImportError( "Could not load '" + full_name + "'. Please ensure the file exists and all imports (including imports in imported files) are valid." ) if skipUntil == None: markers = [["", ""]] else: markers = map(lambda x: map(lambda y: y.strip(), x.split("-")), skipUntil.split(",")) for marker in markers: for i in range(0, len(marker)): if marker[i] != "": marker[i] = add_class_path_prefix(marker[i]) if skipUntil != None: for marker in markers: if len(marker) == 1: print(marker[0]) else: print(marker[0], "-", marker[1]) # simulate nonlocal in python 2.x filtered_markers = [m for m in markers if m[0] == ""] suitelist = [] def filter_testcase(suite, marker): return fnmatch.fnmatch(suite.id(), marker) def filter_testsuite(suite, filtered_markers): if isinstance(suite, unittest.TestCase): if len(filtered_markers) == 0: filtered_markers = [ m for m in markers if filter_testcase(suite, m[0]) ] if len(filtered_markers) != 0: suitelist.append(suite) filtered_markers = [ m for m in filtered_markers if m[-1] == "" or not filter_testcase(suite, m[-1]) ] else: for subsuite in suite: filter_testsuite(subsuite, filtered_markers) filter_testsuite(suites, filtered_markers) super_suite = unittest.TestSuite(suitelist) if xml_output: import xmlrunner runner = xmlrunner.XMLTestRunner(output='test-reports', verbosity=2) else: runner = unittest.TextTestRunner(verbosity=2, failfast=True, buffer=buffer_test_output, resultclass=RegisteredTestResult) results = runner.run(super_suite) return results
def testFixLength(self): testdata.useFixedLength = True self.testNormalize() self.testMerge() self.testAddField() self.testSVM() #self.testSVM2() # why does this work, we shouldn't be able to apply a transfo on an already transformed dataset... self.testRCA() self.testCenter() def testEnumerate(self): testdata.useEnumerate = True self.testNormalize() self.testMerge() self.testAddField() #self.testSVM2() self.testCenter() self.testRCA() def testEnumerateFixLength(self): testdata.useEnumerate = True self.testFixLength() suite = unittest2.TestLoader().loadTestsFromTestCase(TestAlgorithms) if __name__ == '__main__': unittest2.TextTestRunner(verbosity=2).run(suite)
self.assertEqual(o_date.to_date().time().second, 0) def test_o_date_epoch(self): epoch = 8546400 o_date = ODate(epoch=epoch) days = 99 o_date_clone = ODate(days_since_epoch=days) self.assertTrue(o_date.__eq__(o_date_clone)) self.assertEqual(o_date.__cmp__(o_date_clone), 0) self.assertEqual(o_date.__hash__(), o_date_clone.__hash__()) self.assertEqual(o_date.get_year(), o_date_clone.get_year()) self.assertEqual(o_date.get_month(), o_date_clone.get_month()) self.assertEqual(o_date.get_day_of_month(), o_date_clone.get_day_of_month()) def test_o_date_datetime(self): import datetime date = datetime.datetime(year=1970, month=4, day=10, hour=5, minute=15, second=55) o_date = ODate(date=date) self.assertEqual(o_date.days_since_epoch, 99) self.assertEqual(o_date.get_year(), 1970) self.assertEqual(o_date.get_month(), 4) self.assertEqual(o_date.get_day_of_month(), 10) self.assertEqual(o_date.to_date().time().hour, 0) self.assertEqual(o_date.to_date().time().minute, 0) self.assertEqual(o_date.to_date().time().second, 0) if __name__ == '__main__': suite = unittest.TestLoader().loadTestsFromTestCase(ODateTest) unittest.TextTestRunner(verbosity=2).run(suite)
zypper_enabled = True except ImportError: zypper_enabled = False if zypper_enabled: modules.append('zypper_plugins.test_enabled_repos_upload') modules.append('zypper_plugins.test_package_upload') modules.append('zypper_plugins.test_tracer_upload') else: modules.append('test_yum_plugins.test_enabled_repos_upload') if sys.version_info[1] > 6: modules.append('test_katello.test_plugin') modules.append('test_katello.test_agent.test_pulp.test_handler') modules.append('test_katello.test_agent.test_pulp.test_libyum') else: # this test file doesn't start with test_ to avoid py3 unittest discovery modules.append('test_katello.legacy_plugin_test') map(__import__, modules) suite = unittest.TestSuite() for module in [sys.modules[modname] for modname in modules]: suite.addTest(unittest.TestLoader().loadTestsFromModule(module)) else: suite = unittest.defaultTestLoader.discover('test') result = unittest.TextTestRunner(verbosity=2).run(suite) sys.exit(not result.wasSuccessful())
def run(self): tests = unittest.TestLoader().discover('.') runner = unittest.TextTestRunner() results = runner.run(tests) sys.exit(not results.wasSuccessful())
def alltests(): makeTests() ret = unittest.TestLoader().discover('test/haystack/') return ret
def test_reachability_node4(self): dtl = DeterLabTesting.DeterLabTesting() rc, msg, loss = dtl.ping("node-4") if rc != 0 or loss > 0: self.fail(msg) pass def test_reachability_outside(self): dtl = DeterLabTesting.DeterLabTesting() rc, msg, loss = dtl.ping("128.9.128.127") if re.search("Destination Host Unreachable|Network is unreachable", msg, re.MULTILINE) is None: self.fail(msg) pass def test_bw_node0_to_node1_100mb(self): dtl = DeterLabTesting.DeterLabTesting() rc, msg, dtl.bw_mb = dtl.bw("node-1") if rc != 0 or dtl.bw_mb < 80 or dtl.bw_mb > 105: self.fail(msg) pass # allow the test to be run by hand for development if __name__ == '__main__': logging.basicConfig(stream=sys.stderr) logging.getLogger(__name__).setLevel(logging.DEBUG) suite = unittest.TestLoader().loadTestsFromTestCase(Test003Containers) unittest.TextTestRunner(verbosity=2).run(suite)
def suite(): return unittest.TestLoader().loadTestsFromTestCase(TestUtil)
def runAll(): """ Unittest runner """ suite = unittest.TestSuite() suite.addTest(unittest.TestLoader().loadTestsFromTestCase(BasicTestCase)) unittest.TextTestRunner(verbosity=2).run(suite)
import os import sys if sys.version.startswith('2.6') or sys.version.startswith('3.1'): import unittest2 as unittest else: import unittest suite = unittest.TestLoader().discover('PyMca5', pattern='*Test.py') unittest.TextTestRunner(verbosity=1).run(suite)
def suite(): """The test suite for test_sar_c_safe.""" loader = unittest.TestLoader() mysuite = unittest.TestSuite() mysuite.addTest(loader.loadTestsFromTestCase(TestSAFEGRD)) return mysuite
else: theTests = [el.lower().strip() for el in args.tests.strip().split(',')] print("Limiting testing to tests {}".format(theTests)) goodClasses = { 'Cals'.lower(): TestCalendars, 'CAF'.lower(): TestComboAggregateFactory, 'DBTU'.lower(): TestDBTimeUtils, 'Plot'.lower(): TestPlot, 'FigW'.lower(): TestFigureWrapper, 'TTools'.lower(): TestTableTools, 'TConv'.lower(): TestTableDataframeConversion, 'TMT'.lower(): TestTableManagementTools, } suite = [] if theTests is None: for cls in goodClasses.values(): tests = unittest.TestLoader().loadTestsFromTestCase(cls) suite.append(tests) else: for testName in theTests: cls = goodClasses.get(testName, None) if cls is None: print("Found no tests for name = {}".format(testName)) else: suite.append(unittest.TestLoader().loadTestsFromTestCase(cls)) # Now, run the tests runner.run(unittest.TestSuite(suite))
assert len(s) == 0 s = self.s1.clone(cloneValueFlag=1) assert len(s) == 1 assert s.getComponentByPosition(0) == self.s1.getComponentByPosition(0) def testSetToDefault(self): s = self.s1.clone() s.setComponentByName('sex', univ.noValue) assert s['sex'] is not univ.noValue def testStaticDef(self): class InnerChoice(univ.Choice): componentType = namedtype.NamedTypes( namedtype.NamedType('count', univ.Integer()), namedtype.NamedType('flag', univ.Boolean())) class OuterChoice(univ.Choice): componentType = namedtype.NamedTypes( namedtype.NamedType('name', univ.OctetString()), namedtype.NamedType('sex', InnerChoice())) c = OuterChoice() c.setComponentByType(univ.OctetString.tagSet, 'abc') assert c.getName() == 'name' suite = unittest.TestLoader().loadTestsFromModule(sys.modules[__name__]) if __name__ == '__main__': unittest.TextTestRunner(verbosity=2).run(suite)
p.join() def test_LdaCgsMulti_remove_Seq_props(self): t = MPTester() p = Process(target=t.test_LdaCgsMulti_remove_Seq_props, args=()) p.start() p.join() def test_LdaCgsMulti_continue_training(self): t = MPTester() p = Process(target=t.test_LdaCgsMulti_continue_training, args=()) p.start() p.join() def test_LdaCgsMulti_eq_LdaCgsSeq(self): t = MPTester() p = Process(target=t.test_LdaCgsMulti_eq_LdaCgsSeq, args=()) p.start() p.join() def test_LdaCgsMulti_eq_LdaCgsSeq_multi(self): t = MPTester() p = Process(target=t.test_LdaCgsMulti_eq_LdaCgsSeq_multi, args=()) p.start() p.join() if __name__ == '__main__': suite = unittest.TestLoader().loadTestsFromTestCase(TestLdaCgsMulti) unittest.TextTestRunner(verbosity=2).run(suite)