def _check_table(test: unittest.TestCase, table: pd.DataFrame, colnames): test.assertIsInstance(table, pd.DataFrame) test.assertGreater(len(table), 0) test.assertTrue(table.shape[1], 2) test.assertTrue(table.notnull().values.any()) test.assertTrue((table.iloc[:, 0] != 0).any()) test.assertEqual(tuple(table.columns), colnames)
def test_tmx_stackCollisionEvents(self): walls = self.game.tilemap.layers['walls'] destination = walls.cells[walls.cells.keys()[0]] (dx, dy) = self.__calcule_delta(self.game.perso, destination) self.game.perso.move(dx, dy) TestCase.assertEqual(self, len(self.game.tmxEvents), 0) self.game.tmx_stackCollisionEvents(self.game.perso, self.game.tmxEvents) TestCase.assertGreater(self, len(self.game.tmxEvents), 0)
def test_player_stackEvents(self): destination = self.game.tilemap.layers['pnjs'].find('monstre')[0] (dx, dy) = self.__calcule_delta(self.game.perso, destination) self.game.perso.move(dx, dy) self.game.player_stackEvents(self.game.perso, self.game.monster_layer, self.game.playerEvents) TestCase.assertGreater(self, len(self.game.playerEvents), 0) TestCase.assertIsInstance(self, self.game.playerEvents[0], Monster)
def _apply(self, put: unittest.TestCase, value: Sequence[T], message_builder: MessageBuilder): put.assertGreater(len(value), self.index, message_builder.apply('number of elements')) idx = self.index element_message_builder = sub_component_builder(_element_at_index(idx), message_builder, component_separator='') self.element_assertion.apply(put, value[idx], element_message_builder)
def assert_file_does_not_contain(filename: str, search_string: str, test_case: unittest.TestCase): with open(filename, 'r') as file: current_line = "\n" num_lines = 0 while current_line: current_line = file.readline() num_lines += 1 test_case.assertNotIn(search_string, current_line) test_case.assertGreater(num_lines, 1)
def assert_files_equal(filename_a: str, filename_b: str, test_case: unittest.TestCase): with open(filename_a, 'r') as file_a, open(filename_b, 'r') as file_b: a_curr = "\n" b_curr = a_curr num_lines = 0 while a_curr and b_curr: a_curr = file_a.readline() b_curr = file_b.readline() num_lines += 1 test_case.assertEqual(a_curr, b_curr) test_case.assertGreater(num_lines, 1)
def run_single_assertions(cls, test: unittest.TestCase, retriever: Retriever): data = retriever.retrieve() expected_locations = ("0214655255", "0214657975") unique_loaded_locations = data.observation_location.unique() for location in expected_locations: test.assertIn(location, unique_loaded_locations) earliest_possible_date = datetime(year=2015, month=12, day=1, tzinfo=timezone.utc) latest_possible_date = datetime(year=2016, month=1, day=2, tzinfo=timezone.utc) earliest_date = data.value_date.min() latest_date = data.value_date.max() test.assertGreater(earliest_date, earliest_possible_date) test.assertLess(latest_date, latest_possible_date) for location_name, subset in data.groupby(by="observation_location"): test.assertGreater(subset.value_date.min(), earliest_possible_date) test.assertLess(subset.value_date.max(), latest_possible_date) current_date = earliest_date.date() present_days = subset.value_date.apply(lambda d: d.date()).unique() missing_days = list() while current_date <= latest_date: if current_date not in present_days: missing_days.append(current_date) else: missing_days.clear() test.assertLess(len(missing_days), 5) current_date += timedelta(days=1)
def doframe(t: unittest.TestCase, curr: sllib.Frame, prev: sllib.Frame): """Validate some basic data for the frame""" t.assertGreaterEqual(curr.course, 0) t.assertLessEqual(curr.course, 6.28) t.assertLess(curr.gps_speed, 15) t.assertLess(curr.altitude, 500) t.assertLess(curr.temperature, 22) t.assertGreater(curr.temperature, 10) t.assertGreater(curr.framesize, curr.packetsize) t.assertGreater(curr.framesize, 1900) t.assertLessEqual(len(curr.packet), curr.packetsize) if prev is not None: t.assertGreater(curr.offset, prev.offset) t.assertGreaterEqual(curr.time1, prev.time1)
def run_acceptance_test(test_case: unittest.TestCase, model_id: str, props_to_test: list = None) -> bool: """ Runs the acceptance test for the given model id. :param test_case: The unittest case. :param model_id: The model ID to run the test for. :return: True if successful, false or exception if not. """ npy_test_file = os.path.join(UCVM_MODELS_DIRECTORY, model_id, "test_" + model_id + ".npy") ucvm_model_file = os.path.join(UCVM_MODELS_DIRECTORY, model_id, "ucvm_model.xml") spacing = 0.05 depth = 5000 bottom_corner = {"e": 0, "n": 0} if not os.path.exists(npy_test_file) or not os.path.exists( ucvm_model_file): return False with open(ucvm_model_file, "r") as fd: ucvm_model = xmltodict.parse(fd.read()) bottom_corner["e"] = \ float(ucvm_model["root"]["information"]["coverage"]["bottom-left"]["e"]) bottom_corner["n"] = \ float(ucvm_model["root"]["information"]["coverage"]["bottom-left"]["n"]) model_type = ucvm_model["root"]["information"]["type"] arr = np.load(npy_test_file) nums = {"x": len(arr), "y": len(arr[0]), "z": len(arr[0][0])} sd_array = [ SeismicData() for _ in range(nums["x"] * nums["y"] * nums["z"]) ] counter = 0 for z in range(nums["z"]): for y in range(nums["y"]): for x in range(nums["x"]): sd_array[counter].original_point = Point( bottom_corner["e"] + spacing * x, bottom_corner["n"] + spacing * y, 0 + depth * z) counter += 1 UCVM.query(sd_array, model_id, [model_type]) if props_to_test is None or len(props_to_test) == 0: props_to_test = ["vp", "vs", "density"] counter = 0 epsilon = 0.006 for z in range(nums["z"]): for y in range(nums["y"]): for x in range(nums["x"]): if arr[x][y][z][0] <= 0 and sd_array[counter].velocity_properties.vp is None or \ arr[x][y][z][1] <= 0 and sd_array[counter].velocity_properties.vs is None or \ arr[x][y][z][2] <= 0 and sd_array[counter].velocity_properties.density is None: counter += 1 continue # This is to account for a floating point rounding issue in the CVM-S4.26 test which has the new UCVM # thinking that the corner is in bounds and the old version thinking it's out of bounds. This version # thinks the point is 1534.999999999 where as the old version thinks it's exactly 1535. This also fixes # a difference whereby the old CVM-S5 extended below 50000km but the new one does not. if (sd_array[counter].original_point.x_value == -116 and sd_array[counter].original_point.y_value == 30.45 and model_id == "cvms426") or \ (sd_array[counter].original_point.z_value == 50000 and model_id == "cvms426"): counter += 1 continue if "vp" in props_to_test: test_case.assertGreater( sd_array[counter].velocity_properties.vp / arr[x][y][z][0], 1 - epsilon) test_case.assertLess( sd_array[counter].velocity_properties.vp / arr[x][y][z][0], 1 + epsilon) if "vs" in props_to_test: test_case.assertGreater( sd_array[counter].velocity_properties.vs / arr[x][y][z][1], 1 - epsilon) test_case.assertLess( sd_array[counter].velocity_properties.vs / arr[x][y][z][1], 1 + epsilon) if "density" in props_to_test: test_case.assertGreater( sd_array[counter].velocity_properties.density / arr[x][y][z][2], 1 - epsilon) test_case.assertLess( sd_array[counter].velocity_properties.density / arr[x][y][z][2], 1 + epsilon) counter += 1 return True
def run_acceptance_test(test_case: unittest.TestCase, model_id: str, props_to_test: list=None) -> bool: """ Runs the acceptance test for the given model id. :param test_case: The unittest case. :param model_id: The model ID to run the test for. :return: True if successful, false or exception if not. """ npy_test_file = os.path.join(UCVM_MODELS_DIRECTORY, model_id, "test_" + model_id + ".npy") ucvm_model_file = os.path.join(UCVM_MODELS_DIRECTORY, model_id, "ucvm_model.xml") spacing = 0.05 depth = 5000 bottom_corner = { "e": 0, "n": 0 } if not os.path.exists(npy_test_file) or not os.path.exists(ucvm_model_file): return False with open(ucvm_model_file, "r") as fd: ucvm_model = xmltodict.parse(fd.read()) bottom_corner["e"] = \ float(ucvm_model["root"]["information"]["coverage"]["bottom-left"]["e"]) bottom_corner["n"] = \ float(ucvm_model["root"]["information"]["coverage"]["bottom-left"]["n"]) model_type = ucvm_model["root"]["information"]["type"] arr = np.load(npy_test_file) nums = { "x": len(arr), "y": len(arr[0]), "z": len(arr[0][0]) } sd_array = [SeismicData() for _ in range(nums["x"] * nums["y"] * nums["z"])] counter = 0 for z in range(nums["z"]): for y in range(nums["y"]): for x in range(nums["x"]): sd_array[counter].original_point = Point(bottom_corner["e"] + spacing * x, bottom_corner["n"] + spacing * y, 0 + depth * z) counter += 1 UCVM.query(sd_array, model_id, [model_type]) if props_to_test is None or len(props_to_test) == 0: props_to_test = ["vp", "vs", "density"] counter = 0 epsilon = 0.006 for z in range(nums["z"]): for y in range(nums["y"]): for x in range(nums["x"]): if arr[x][y][z][0] <= 0 and sd_array[counter].velocity_properties.vp is None or \ arr[x][y][z][1] <= 0 and sd_array[counter].velocity_properties.vs is None or \ arr[x][y][z][2] <= 0 and sd_array[counter].velocity_properties.density is None: counter += 1 continue # This is to account for a floating point rounding issue in the CVM-S4.26 test which has the new UCVM # thinking that the corner is in bounds and the old version thinking it's out of bounds. This version # thinks the point is 1534.999999999 where as the old version thinks it's exactly 1535. This also fixes # a difference whereby the old CVM-S5 extended below 50000km but the new one does not. if (sd_array[counter].original_point.x_value == -116 and sd_array[counter].original_point.y_value == 30.45 and model_id == "cvms426") or \ (sd_array[counter].original_point.z_value == 50000 and model_id == "cvms426"): counter += 1 continue if "vp" in props_to_test: test_case.assertGreater(sd_array[counter].velocity_properties.vp / arr[x][y][z][0], 1 - epsilon) test_case.assertLess(sd_array[counter].velocity_properties.vp / arr[x][y][z][0], 1 + epsilon) if "vs" in props_to_test: test_case.assertGreater(sd_array[counter].velocity_properties.vs / arr[x][y][z][1], 1 - epsilon) test_case.assertLess(sd_array[counter].velocity_properties.vs / arr[x][y][z][1], 1 + epsilon) if "density" in props_to_test: test_case.assertGreater(sd_array[counter].velocity_properties.density / arr[x][y][z][2], 1 - epsilon) test_case.assertLess(sd_array[counter].velocity_properties.density / arr[x][y][z][2], 1 + epsilon) counter += 1 return True
def _apply(self, put: unittest.TestCase, value: T, message_builder: MessageBuilder): put.assertGreater(value, self.limit, message_builder.apply(self.message))