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)
