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)