def _TestNotInVndkDirecotory(self, vndk_dir, vndk_list_names, except_libs): """Verifies that VNDK directory doesn't contain specific files. Args: vndk_dir, The path to the VNDK directory on device. vndk_list_names: A list of strings, the categories of the VNDK libraries that should not be in the directory. except_libs: A set of strings, the file names of the libraries that are exceptions to this test. """ vndk_lists = vndk_data.LoadVndkLibraryLists(self.data_file_path, self._vndk_version, *vndk_list_names) asserts.assertTrue(vndk_lists, "Cannot load VNDK library lists.") vndk_set = set() for vndk_list in vndk_lists: vndk_set.update(path_utils.TargetBaseName(x) for x in vndk_list) vndk_set.difference_update(except_libs) logging.debug("vndk set: %s", vndk_set) unexpected = [ x for x in self._ListFiles(vndk_dir) if path_utils.TargetBaseName(x) in vndk_set ] if unexpected: logging.error("Unexpected files:\n%s", "\n".join(unexpected)) asserts.fail("Total number of errors: %d" % len(unexpected))
def output_file_path(self, output_file_path): """Set output_file_path. Lengths of both file name and path will be checked. If longer than maximum allowance, file name will be set to a random name, and directory will be set to relative directory. Args: output_file_path: string, intended path of output xml file """ output_file_path = path_utils.TargetNormPath(output_file_path.strip()) output_base_name = path_utils.TargetBaseName(output_file_path) output_dir_name = path_utils.TargetDirName(output_file_path) if len(output_base_name) > utils.MAX_FILENAME_LEN: logging.warn( 'File name of output file "{}" is longer than {}.'.format( output_file_path, utils.MAX_FILENAME_LEN)) output_base_name = '{}.xml'.format(uuid.uuid4()) output_file_path = path_utils.JoinTargetPath( output_dir_name, output_base_name) logging.debug('Output file path is set as "%s".', output_file_path) if len(output_file_path) > utils.MAX_PATH_LEN: logging.warn( 'File path of output file "{}" is longer than {}.'.format( output_file_path, utils.MAX_PATH_LEN)) output_file_path = output_base_name logging.debug('Output file path is set as "%s".', output_file_path) self._output_file_path = output_file_path
def CreateTestCase(self, path, tag=''): '''Create a list of TestCase objects from a binary path. Args: path: string, absolute path of a binary on device tag: string, a tag that will be appended to the end of test name Returns: A list of BinaryTestCase objects ''' working_directory = self.working_directory[ tag] if tag in self.working_directory else None envp = self.envp[tag] if tag in self.envp else '' args = self.args[tag] if tag in self.args else '' ld_library_path = self.ld_library_path[ tag] if tag in self.ld_library_path else None profiling_library_path = self.profiling_library_path[ tag] if tag in self.profiling_library_path else None return binary_test_case.BinaryTestCase('', path_utils.TargetBaseName(path), path, tag, self.PutTag, working_directory, ld_library_path, profiling_library_path, envp=envp, args=args)
def setUpClass(self): """Initializes device, temporary directory, and VNDK lists.""" required_params = [keys.ConfigKeys.IKEY_DATA_FILE_PATH] self.getUserParams(required_params) self._dut = self.android_devices[0] self._temp_dir = tempfile.mkdtemp() for target_dir in (self._TARGET_ODM_DIR, self._TARGET_VENDOR_DIR): if target_file_utils.IsDirectory(target_dir, self._dut.shell): logging.info("adb pull %s %s", target_dir, self._temp_dir) self._dut.adb.pull(target_dir, self._temp_dir) else: logging.info("Skip adb pull %s", target_dir) vndk_lists = vndk_data.LoadVndkLibraryLists( self.data_file_path, self._dut.vndk_version, vndk_data.SP_HAL, vndk_data.LL_NDK, vndk_data.VNDK, vndk_data.VNDK_SP) asserts.assertTrue(vndk_lists, "Cannot load VNDK library lists.") sp_hal_strings = vndk_lists[0] self._sp_hal = [re.compile(x) for x in sp_hal_strings] (self._ll_ndk, self._vndk, self._vndk_sp) = (set( path_utils.TargetBaseName(path) for path in vndk_list) for vndk_list in vndk_lists[1:]) logging.debug("LL_NDK: %s", self._ll_ndk) logging.debug("SP_HAL: %s", sp_hal_strings) logging.debug("VNDK: %s", self._vndk) logging.debug("VNDK_SP: %s", self._vndk_sp)
def _testSpHalDependency(self, bitness, objs): """Scans same-process HAL dependency on vendor partition. Returns: List of tuples (path, dependency_names). The library with disallowed dependencies and list of the dependencies. """ vndk_sp_dir = self._getTargetVndkSpDir(bitness) vndk_sp_paths = file_utils.FindFiles(self._shell, vndk_sp_dir, "*.so") vndk_sp_names = set( path_utils.TargetBaseName(x) for x in vndk_sp_paths) logging.info("%s libraries: %s" % (vndk_sp_dir, ", ".join(vndk_sp_names))) # map file names to libraries which can be linked to same-process HAL linkable_libs = dict() for obj in [ x for x in objs if x.bitness == bitness and self._isInSpHalLinkPaths(x) ]: if obj.name not in linkable_libs: linkable_libs[obj.name] = obj else: linkable_libs[obj.name] = min(linkable_libs[obj.name], obj, key=self._spHalLinkOrder) # find same-process HAL and dependencies sp_hal_libs = set() for file_name, obj in linkable_libs.iteritems(): if any([x.match(file_name) for x in self._SAME_PROCESS_HAL]): self._dfsDependencies(obj, sp_hal_libs, linkable_libs) logging.info("%d-bit SP HAL libraries: %s" % (bitness, ", ".join([x.name for x in sp_hal_libs]))) # check disallowed dependencies dep_errors = [] for obj in sp_hal_libs: disallowed_libs = [ x for x in obj.deps if not self._isAllowedSpHalDependency( x, vndk_sp_names, linkable_libs) ] if disallowed_libs: dep_errors.append((obj.target_path, disallowed_libs)) return dep_errors
def __init__(self, target_path, bitness, deps): self.target_path = target_path self.name = path_utils.TargetBaseName(target_path) self.target_dir = path_utils.TargetDirName(target_path) self.bitness = bitness self.deps = deps