def test_something(self):
# Use the assert* functions to determine the outcome of a test.
unittest.assertEqual(1,1)
unittest.assertNotEqual(1,0)
unittest.assertTrue(1 == 1)
unittest.assertFalse(1 == 0)
unittest.assertIs(a, b)
unittest.assertIsNot(a, c)
unittest.assertIsNone(None)
unittest.assertIsNotNone(a)
unittest.assertIn(1, a)
unittest.assertNotIn(4, b)
unittest.assertIsInstance(c, list)
unittest.assertNotIsInstance(d, list)
unittest.assertRaises()
unittest.assertRaisesRegex()
unittest.assertWarns()
unittest.assertWarnsRegex()
unittest.assertLogs()
unittest.assertAlmostEqual()
unittest.assertNotAlmostEqual()
unittest.assertGreater()
unittest.assertGreaterEqual()
unittest.assertLess()
unittest.assertLessEqual()
unittest.assertRegex()
unittest.assertNotRegex()
unittest.assertCountEqual()
def setUp_bucket(self, unittest):
self.log = logger.Logger.get_logger()
self.input = TestInputSingleton.input
unittest.assertTrue(self.input, msg="input parameters missing...")
self.test = unittest
self.master = self.input.servers[0]
rest = RestConnection(self.master)
rest.init_cluster(username=self.master.rest_username, password=self.master.rest_password)
rest.init_cluster_memoryQuota(memoryQuota=rest.get_nodes_self().mcdMemoryReserved)
ClusterOperationHelper.cleanup_cluster([self.master])
BucketOperationHelper.delete_all_buckets_or_assert([self.master], self.test)
serverInfo = self.master
rest = RestConnection(serverInfo)
info = rest.get_nodes_self()
rest.init_cluster(username=serverInfo.rest_username,
password=serverInfo.rest_password)
rest.init_cluster_memoryQuota(memoryQuota=info.memoryQuota)
# Add built-in user
testuser = [{'id': 'cbadminbucket', 'name': 'cbadminbucket', 'password': '******'}]
RbacBase().create_user_source(testuser, 'builtin', self.master)
# Assign user to role
role_list = [{'id': 'cbadminbucket', 'name': 'cbadminbucket', 'roles': 'admin'}]
RbacBase().add_user_role(role_list, RestConnection(self.master), 'builtin')
def test_initial_state( unittest, node ):
matrix = matrix44.identity()
#
# Axis
#
test_axis( unittest, node.transform.object, matrix )
test_axis( unittest, node.transform.inertial, matrix )
test_axis( unittest, node.world_transform.object, matrix )
test_axis( unittest, node.world_transform.inertial, matrix )
#
# Quaternion
#
quat = quaternion.identity()
unittest.assertTrue(
numpy.allclose( node.transform.orientation, quat ),
"Object quaternion incorrect"
)
unittest.assertTrue(
numpy.allclose( node.world_transform.orientation, quat ),
"World quaternion incorrect"
)
#
# Scale
#
test_scale( unittest, node.transform, [1.0, 1.0, 1.0] )
test_scale( unittest, node.world_transform, [1.0, 1.0, 1.0] )
#
# Translation
#
test_translation( unittest, node.transform, [0.0, 0.0, 0.0] )
test_translation( unittest, node.world_transform, [0.0, 0.0, 0.0] )
def setUp_bucket(self, unittest):
self.log = logger.Logger.get_logger()
self.input = TestInputSingleton.input
unittest.assertTrue(self.input, msg="input parameters missing...")
self.test = unittest
self.master = self.input.servers[0]
rest = RestConnection(self.master)
rest.init_cluster(username=self.master.rest_username, password=self.master.rest_password)
rest.init_cluster_memoryQuota(memoryQuota=rest.get_nodes_self().mcdMemoryReserved)
ClusterOperationHelper.cleanup_cluster([self.master])
BucketOperationHelper.delete_all_buckets_or_assert([self.master], self.test)
serverInfo = self.master
rest = RestConnection(serverInfo)
info = rest.get_nodes_self()
rest.init_cluster(username=serverInfo.rest_username,
password=serverInfo.rest_password)
rest.init_cluster_memoryQuota(memoryQuota=info.memoryQuota)
# Add built-in user
testuser = [{'id': 'cbadminbucket', 'name': 'cbadminbucket', 'password': '******'}]
RbacBase().create_user_source(testuser, 'builtin', self.master)
time.sleep(10)
# Assign user to role
role_list = [{'id': 'cbadminbucket', 'name': 'cbadminbucket', 'roles': 'admin'}]
RbacBase().add_user_role(role_list, RestConnection(self.master), 'builtin')
time.sleep(10)
def main():
'''
takes from the command line the directory
where the input and expected output files are
then it runs the test on the files and returns
a goodness-of-fit measurement.
'''
parser = argparse.ArgumentParser (description="Develops Training Data for Object Recognition")
parser.add_argument("--inputs",
"-i",
dest="inputs",
required=True, nargs="+",
help="list of input images")
parser.add_argument("--background",
"-b",
dest="background",
required=True, nargs="1",
help="background image")
parser.add_argument("--foreground",
"-f",
dest="foreground",
required=True, nargs="1",
help="foreground image")
parser.add_argument("--modality",
"-m",
dest="modality",
required=True, nargs="1",
help="image modality")
parser.add_argument("--target",
"-t",
dest="target",
required=False, nargs="?",
help="Previous Target Training Data")
parser.add_argument("--expected",
"-e",
dest="expected",
required=True, nargs="1",
help="Expected Outcome")
args = parser.parse_args()
inputs = args.inputs
foreground = args.foreground
background = args.background
modality = args.modality
target = args.target
boundary = args.boundary
expected = args.expected
epsilon = args.epsilon
if (epsilon !=None):
EPSILON=epsilon
assertTrue( run_test(inputs, background, foreground, modality, target, expected) <= EPSILON)
def TPlayer_to_player_Transaction(self):
P1 = Player()
P2 = Player()
initMoneyP1 = P1.money
initMoneyP2 = P2.money
Bank.Player_to_player_Transaction(P1, P2, 100)
unittest.assertTrue(P1.money == initMoneyP1 - 100
and P2.money == initMoneyP2 + 100)
def validate_nweights(self, unittest, expected_result, msg_base = ''):
"""Compares the nweights hold by the graph with the once provided (as a dict)."""
unittest.assertTrue(len(self.__nweights) == len(expected_result), '{}: Expected {} edges, but {} were added.'.format(msg_base, len(expected_result), len(self.__nweights)))
node_id_set = set()
for key in self.__nweights.keys():
node_id_set.add(key[0])
node_id_set.add(key[1])
unittest.assertTrue(len(node_id_set) == self.__nodes), '{}: Not all {} node-ids appeared in the edges, but only {}. Missing are {}.'.format(msg_base, self.__nodes, len(node_id_set), set(range(0, self.__nodes)) - node_id_set)
self.__compare_dictionaries(unittest, self.__nweights, expected_result, msg_base)
def validate_nweights(self, unittest, expected_result, msg_base = ''):
"""Compares the nweights hold by the graph with the once provided (as a dict)."""
unittest.assertTrue(len(self.__nweights) == self.__edges, '{}: Expected {} edges, but {} were added.'.format(msg_base, self.__edges, len(self.__nweights)))
node_id_set = set()
for key in self.__nweights.iterkeys():
node_id_set.add(key[0])
node_id_set.add(key[1])
unittest.assertTrue(len(node_id_set) == self.__nodes), '{}: Not all {} node-ids appeared in the edges, but only {}. Missing are {}.'.format(msg_base, self.__nodes, len(node_id_set), set(range(0, self.__nodes)) - node_id_set)
self.__compare_dictionaries(unittest, self.__nweights, expected_result, msg_base)
def setUp_bucket(self, bucket_name, port, bucket_type, unittest):
self.log = logger.Logger.get_logger()
self.input = TestInputSingleton.input
unittest.assertTrue(self.input, msg="input parameters missing...")
self.test = unittest
self.master = self.input.servers[0]
self.bucket_port = port
self.bucket_name = bucket_name
ClusterOperationHelper.cleanup_cluster([self.master])
BucketOperationHelper.delete_all_buckets_or_assert([self.master], self.test)
self._create_default_bucket(unittest)
def __compare_dictionaries(self, unittest, result, expected_result, msg_base = ''):
"""Evaluates the returned results."""
unittest.assertEqual(len(expected_result), len(result), '{}: The expected result dict contains {} entries (for 4-connectedness), instead found {}.'.format(msg_base, len(expected_result), len(result)))
for key, value in result.items():
unittest.assertTrue(key in expected_result, '{}: Region border {} unexpectedly found in expected results.'.format(msg_base, key))
if key in expected_result:
unittest.assertAlmostEqual(value[0], expected_result[key][0], msg='{}: Weight for region border {} is {}. Expected {}.'.format(msg_base, key, value, expected_result[key]), delta=sys.float_info.epsilon)
unittest.assertAlmostEqual(value[1], expected_result[key][1], msg='{}: Weight for region border {} is {}. Expected {}.'.format(msg_base, key, value, expected_result[key]), delta=sys.float_info.epsilon)
unittest.assertGreater(value[0], 0.0, '{}: Encountered a weight {} <= 0.0 for key {}.'.format(msg_base, value, key))
unittest.assertGreater(value[1], 0.0, '{}: Encountered a weight {} <= 0.0 for key {}.'.format(msg_base, value, key))
for key, value in expected_result.items():
unittest.assertTrue(key in result, '{}: Region border {} expectedly but not found in results.'.format(msg_base, key))
def test_scale( unittest, transform, scale ):
eye = numpy.empty( 4 )
eye[ 0:3 ] = scale
eye[ 3 ] = 1.0
unittest.assertTrue(
numpy.allclose( transform.scale, scale ),
"Scale incorrect"
)
unittest.assertTrue(
numpy.allclose( numpy.diag(transform.matrix), eye ),
"Matrix scale incorrect"
)
def test_translation( unittest, transform, vector ):
# Object space
unittest.assertTrue(
numpy.allclose( transform.translation, vector ),
"Translation Vector incorrect"
)
# check the matrix translation matches the transform
matrix_trans = vector3.create_from_matrix44_translation( transform.matrix )
unittest.assertTrue(
numpy.allclose( matrix_trans, vector ),
"Translation Matrix incorrect"
)
def __compare_dictionaries(self, unittest, result, expected_result, msg_base = ''):
"""Evaluates the returned results."""
unittest.assertEqual(len(expected_result), len(result), '{}: The expected result dict contains {} entries (for 4-connectedness), instead found {}.'.format(msg_base, len(expected_result), len(result)))
for key, value in result.iteritems():
unittest.assertTrue(key in expected_result, '{}: Region border {} unexpectedly found in results.'.format(msg_base, key))
if key in expected_result:
unittest.assertAlmostEqual(value[0], expected_result[key][0], msg='{}: Weight for region border {} is {}. Expected {}.'.format(msg_base, key, value, expected_result[key]), delta=sys.float_info.epsilon)
unittest.assertAlmostEqual(value[1], expected_result[key][1], msg='{}: Weight for region border {} is {}. Expected {}.'.format(msg_base, key, value, expected_result[key]), delta=sys.float_info.epsilon)
unittest.assertGreater(value[0], 0.0, '{}: Encountered a weight {} <= 0.0 for key {}.'.format(msg_base, value, key))
unittest.assertGreater(value[1], 0.0, '{}: Encountered a weight {} <= 0.0 for key {}.'.format(msg_base, value, key))
unittest.assertLessEqual(value[0], 1.0, '{}: Encountered a weight {} > 1.0 for key {}.'.format(msg_base, value, key))
unittest.assertLessEqual(value[1], 1.0, '{}: Encountered a weight {} > 1.0 for key {}.'.format(msg_base, value, key))
for key, value in expected_result.iteritems():
unittest.assertTrue(key in result, '{}: Region border {} expectedly but not found in results.'.format(msg_base, key))
def test_request(self):
algo = HIT_MARKING(5)
faults = 0
faults += algo.request(0)
faults += algo.request(1)
faults += algo.request(2)
faults += algo.request(3)
faults += algo.request(4)
faults += algo.request(5)
print 'faults = ', faults
unittest.assertTrue(faults == 6)
def _create_default_bucket(self, unittest):
name = "default"
master = self.master
rest = RestConnection(master)
helper = RestHelper(RestConnection(master))
if not helper.bucket_exists(name):
node_ram_ratio = BucketOperationHelper.base_bucket_ratio(TestInputSingleton.input.servers)
info = rest.get_nodes_self()
available_ram = info.memoryQuota * node_ram_ratio
rest.create_bucket(bucket=name, ramQuotaMB=int(available_ram))
ready = BucketOperationHelper.wait_for_memcached(master, name)
BucketOperationHelper.wait_for_vbuckets_ready_state(master, name)
unittest.assertTrue(ready, msg="wait_for_memcached failed")
unittest.assertTrue(helper.bucket_exists(name),
msg="unable to create {0} bucket".format(name))
def setUp_bucket(self, unittest):
self.log = logger.Logger.get_logger()
self.input = TestInputSingleton.input
unittest.assertTrue(self.input, msg="input parameters missing...")
self.test = unittest
self.master = self.input.servers[0]
rest = RestConnection(self.master)
rest.init_cluster(username=self.master.rest_username, password=self.master.rest_password)
rest.init_cluster_memoryQuota(memoryQuota=rest.get_nodes_self().mcdMemoryReserved)
ClusterOperationHelper.cleanup_cluster([self.master])
BucketOperationHelper.delete_all_buckets_or_assert([self.master], self.test)
serverInfo = self.master
rest = RestConnection(serverInfo)
info = rest.get_nodes_self()
rest.init_cluster(username=serverInfo.rest_username, password=serverInfo.rest_password)
rest.init_cluster_memoryQuota(memoryQuota=info.memoryQuota)
def test_Upload_Success(self):
req = Request
req.method = 'POST'
req.files = MultiDict([('file',
FileStorage(filename=u'img.png',
content_type='image/jpeg'))])
# bp = Blueprint('testBP', __name__)
upload(req)
fileLoc = os.path.join(dirname(dirname(dirname(__file__))),
UPLOAD_FOLDER, req.files['file'].filename)
try:
unittest.assertTrue(os.path.exists(fileLoc))
except:
pass
finally:
if os.path.exists(fileLoc):
os.remove(fileLoc)
def setUp_bucket(self, unittest):
self.log = logger.Logger.get_logger()
self.input = TestInputSingleton.input
unittest.assertTrue(self.input, msg="input parameters missing...")
self.test = unittest
self.master = self.input.servers[0]
rest = RestConnection(self.master)
rest.init_cluster(username=self.master.rest_username,
password=self.master.rest_password)
rest.init_cluster_memoryQuota(
memoryQuota=rest.get_nodes_self().mcdMemoryReserved)
ClusterOperationHelper.cleanup_cluster([self.master])
BucketOperationHelper.delete_all_buckets_or_assert([self.master],
self.test)
serverInfo = self.master
rest = RestConnection(serverInfo)
info = rest.get_nodes_self()
rest.init_cluster(username=serverInfo.rest_username,
password=serverInfo.rest_password)
rest.init_cluster_memoryQuota(memoryQuota=info.memoryQuota)
def test_axis( unittest, transform_space, matrix ):
x_axis = matrix44.apply_to_vector( matrix, [1.0, 0.0, 0.0] )
y_axis = matrix44.apply_to_vector( matrix, [0.0, 1.0, 0.0] )
z_axis = matrix44.apply_to_vector( matrix, [0.0, 0.0, 1.0] )
# Object space
unittest.assertTrue(
numpy.allclose( transform_space.x, x_axis ),
"X axis incorrect"
)
unittest.assertTrue(
numpy.allclose( transform_space.y, y_axis ),
"Y axis incorrect"
)
unittest.assertTrue(
numpy.allclose( transform_space.z, z_axis ),
"Z axis incorrect"
)
def Test_Create_Chance(self):
chance = Square(7)
unittest.assertTrue(chance.Event == 'Carte Chance')
def Test_Create_Commu(self):
commu = Square(2)
unittest.assertTrue(commu.Event == 'Caisse de Communauté')
def Test_Create_tax(self):
tax = Square(4)
unittest.assertTrue(tax.Tax == 200)
def TBuy_Lot(self):
L = Lot()
P = Player()
Bank.Buy_Lot(L, P)
unittest.assertTrue(L.Owner == P)
def Test_Create_Lot(self):
lot = Square(1)
unittest.assertTrue(type(lot.Lot) == Lot)
def Test__init__(self):
b = Board()
unittest.assertTrue(len(b.Squares) == 40)
def test_add(self):
expected = Quaternion(0.0, 1.0, 1.0, 0.0)
actual = Quaternion.QI + Quaternion.QJ
unittest.assertTrue(are_equal(expected, actual))
def TGet_from_player(self):
Player1 = Player()
Player1.money = 1000
Bank.Get_from_player(Player1, 100)
unittest.assertTrue(Player1.money == 900)
def field(self, unittest, locator, key_data):
unittest.assertTrue(locator.is_displayed() and locator.is_enabled())
locator.send_keys(key_data)
def is_element_enable(self, unittest, locator):
unittest.assertTrue(locator.is_displayed() and locator.is_enabled())
def Test_Create_Prison(self):
prison = Square(30)
unittest.assertTrue(prison.Prison == True)
def TPay_to_player(self):
Player1 = Player()
Player1.money = 1000
Bank.Pay_to_player(Player1, 100)
unittest.assertTrue(Player1.money == 1100)
