| # Copyright 2018, The Android Open Source Project |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| |
| """ |
| Module Finder class. |
| """ |
| |
| # pylint: disable=line-too-long |
| |
| import logging |
| import os |
| import time |
| |
| import atest_configs |
| import atest_error |
| import atest_utils |
| import constants |
| |
| from metrics import metrics |
| from test_finders import test_info |
| from test_finders import test_finder_base |
| from test_finders import test_finder_utils |
| from test_runners import atest_tf_test_runner |
| from test_runners import robolectric_test_runner |
| from test_runners import vts_tf_test_runner |
| |
| _ANDROID_MK = 'Android.mk' |
| |
| # These are suites in LOCAL_COMPATIBILITY_SUITE that aren't really suites so |
| # we can ignore them. |
| _SUITES_TO_IGNORE = frozenset({'general-tests', 'device-tests', 'tests'}) |
| |
| class ModuleFinder(test_finder_base.TestFinderBase): |
| """Module finder class.""" |
| NAME = 'MODULE' |
| _TEST_RUNNER = atest_tf_test_runner.AtestTradefedTestRunner.NAME |
| _ROBOLECTRIC_RUNNER = robolectric_test_runner.RobolectricTestRunner.NAME |
| _VTS_TEST_RUNNER = vts_tf_test_runner.VtsTradefedTestRunner.NAME |
| |
| def __init__(self, module_info=None): |
| super().__init__() |
| self.root_dir = os.environ.get(constants.ANDROID_BUILD_TOP) |
| self.module_info = module_info |
| |
| def _determine_testable_module(self, path, file_path=None): |
| """Determine which module the user is trying to test. |
| |
| Returns the module to test. If there are multiple possibilities, will |
| ask the user. Otherwise will return the only module found. |
| |
| Args: |
| path: String path of module to look for. |
| file_path: String path of input file. |
| |
| Returns: |
| A list of the module names. |
| """ |
| testable_modules = [] |
| # A list to save those testable modules but srcs information is empty. |
| testable_modules_no_srcs = [] |
| for mod in self.module_info.get_module_names(path): |
| mod_info = self.module_info.get_module_info(mod) |
| # Robolectric tests always exist in pairs of 2, one module to build |
| # the test and another to run it. For now, we are assuming they are |
| # isolated in their own folders and will return if we find one. |
| if self.module_info.is_robolectric_test(mod): |
| # return a list with one module name if it is robolectric. |
| return [mod] |
| if self.module_info.is_testable_module(mod_info): |
| # If test module defined srcs, input file_path should be defined |
| # in the src list of module. |
| module_srcs = mod_info.get(constants.MODULE_SRCS, []) |
| if file_path and os.path.relpath( |
| file_path, self.root_dir) not in module_srcs: |
| logging.debug('Skip module: %s for %s', mod, file_path) |
| # Collect those modules if they don't have srcs information |
| # in module-info, use this list if there's no other matched |
| # module with src information. |
| if not module_srcs: |
| testable_modules_no_srcs.append( |
| mod_info.get(constants.MODULE_NAME)) |
| continue |
| testable_modules.append(mod_info.get(constants.MODULE_NAME)) |
| if not testable_modules: |
| testable_modules.extend(testable_modules_no_srcs) |
| return test_finder_utils.extract_test_from_tests(testable_modules) |
| |
| def _is_vts_module(self, module_name): |
| """Returns True if the module is a vts10 module, else False.""" |
| mod_info = self.module_info.get_module_info(module_name) |
| suites = [] |
| if mod_info: |
| suites = mod_info.get('compatibility_suites', []) |
| # Pull out all *ts (cts, tvts, etc) suites. |
| suites = [suite for suite in suites if suite not in _SUITES_TO_IGNORE] |
| return len(suites) == 1 and 'vts10' in suites |
| |
| def _update_to_vts_test_info(self, test): |
| """Fill in the fields with vts10 specific info. |
| |
| We need to update the runner to use the vts10 runner and also find the |
| test specific dependencies. |
| |
| Args: |
| test: TestInfo to update with vts10 specific details. |
| |
| Return: |
| TestInfo that is ready for the vts10 test runner. |
| """ |
| test.test_runner = self._VTS_TEST_RUNNER |
| config_file = os.path.join(self.root_dir, |
| test.data[constants.TI_REL_CONFIG]) |
| # Need to get out dir (special logic is to account for custom out dirs). |
| # The out dir is used to construct the build targets for the test deps. |
| out_dir = os.environ.get(constants.ANDROID_HOST_OUT) |
| custom_out_dir = os.environ.get(constants.ANDROID_OUT_DIR) |
| # If we're not an absolute custom out dir, get no-absolute out dir path. |
| if custom_out_dir is None or not os.path.isabs(custom_out_dir): |
| out_dir = os.path.relpath(out_dir, self.root_dir) |
| vts_out_dir = os.path.join(out_dir, 'vts10', 'android-vts10', 'testcases') |
| # Parse dependency of default staging plans. |
| xml_paths = test_finder_utils.search_integration_dirs( |
| constants.VTS_STAGING_PLAN, |
| self.module_info.get_paths(constants.VTS_TF_MODULE)) |
| vts_xmls = set() |
| vts_xmls.add(config_file) |
| for xml_path in xml_paths: |
| vts_xmls |= test_finder_utils.get_plans_from_vts_xml(xml_path) |
| for config_file in vts_xmls: |
| # Add in vts10 test build targets. |
| test.build_targets |= test_finder_utils.get_targets_from_vts_xml( |
| config_file, vts_out_dir, self.module_info) |
| test.build_targets.add('vts-test-core') |
| test.build_targets.add(test.test_name) |
| return test |
| |
| def _update_legacy_robolectric_test_info(self, test): |
| """Update the fields for a legacy robolectric test. |
| |
| This method is updating test_name when the given is a legacy robolectric |
| test, and assigning Robolectric Runner for it. |
| |
| e.g. WallPaperPicker2RoboTests is a legacy robotest, and the test_name |
| will become RunWallPaperPicker2RoboTests and run it with Robolectric |
| Runner. |
| |
| Args: |
| test: TestInfo to be updated with robolectric fields. |
| |
| Returns: |
| TestInfo with updated robolectric fields. |
| """ |
| test.test_runner = self._ROBOLECTRIC_RUNNER |
| test.test_name = self.module_info.get_robolectric_test_name(test.test_name) |
| return test |
| |
| def _process_test_info(self, test): |
| """Process the test info and return some fields updated/changed. |
| |
| We need to check if the test found is a special module (like vts10) and |
| update the test_info fields (like test_runner) appropriately. |
| |
| Args: |
| test: TestInfo that has been filled out by a find method. |
| |
| Return: |
| TestInfo that has been modified as needed and return None if |
| this module can't be found in the module_info. |
| """ |
| module_name = test.test_name |
| mod_info = self.module_info.get_module_info(module_name) |
| if not mod_info: |
| return None |
| test.module_class = mod_info['class'] |
| test.install_locations = test_finder_utils.get_install_locations( |
| mod_info['installed']) |
| # Check if this is only a vts10 module. |
| if self._is_vts_module(test.test_name): |
| return self._update_to_vts_test_info(test) |
| test.robo_type = self.module_info.get_robolectric_type(test.test_name) |
| if test.robo_type: |
| test.install_locations = {constants.DEVICELESS_TEST} |
| if test.robo_type == constants.ROBOTYPE_MODERN: |
| test.build_targets.add(test.test_name) |
| return test |
| if test.robo_type == constants.ROBOTYPE_LEGACY: |
| return self._update_legacy_robolectric_test_info(test) |
| rel_config = test.data[constants.TI_REL_CONFIG] |
| test.build_targets = self._get_build_targets(module_name, rel_config) |
| # For device side java test, it will use |
| # com.android.compatibility.testtype.DalvikTest as test runner in |
| # cts-dalvik-device-test-runner.jar |
| if self.module_info.is_auto_gen_test_config(module_name): |
| if constants.MODULE_CLASS_JAVA_LIBRARIES in test.module_class: |
| for dalvik_dep in test_finder_utils.DALVIK_TEST_DEPS: |
| if self.module_info.is_module(dalvik_dep): |
| test.build_targets.add(dalvik_dep) |
| # Update test name if the test belong to extra config which means it's |
| # test config name is not the same as module name. For extra config, it |
| # index will be greater or equal to 1. |
| try: |
| if (mod_info.get(constants.MODULE_TEST_CONFIG, []).index(rel_config) |
| > 0): |
| config_test_name = os.path.splitext(os.path.basename( |
| rel_config))[0] |
| logging.debug('Replace test_info.name(%s) to %s', |
| test.test_name, config_test_name) |
| test.test_name = config_test_name |
| except ValueError: |
| pass |
| return test |
| |
| def _get_build_targets(self, module_name, rel_config): |
| """Get the test deps. |
| |
| Args: |
| module_name: name of the test. |
| rel_config: XML for the given test. |
| |
| Returns: |
| Set of build targets. |
| """ |
| targets = set() |
| if not self.module_info.is_auto_gen_test_config(module_name): |
| config_file = os.path.join(self.root_dir, rel_config) |
| targets = test_finder_utils.get_targets_from_xml(config_file, |
| self.module_info) |
| if constants.VTS_CORE_SUITE in self.module_info.get_module_info( |
| module_name).get(constants.MODULE_COMPATIBILITY_SUITES, []): |
| targets.add(constants.VTS_CORE_TF_MODULE) |
| for suite in self.module_info.get_module_info( |
| module_name).get(constants.MODULE_COMPATIBILITY_SUITES, []): |
| targets.update(constants.SUITE_DEPS.get(suite, [])) |
| for module_path in self.module_info.get_paths(module_name): |
| mod_dir = module_path.replace('/', '-') |
| targets.add(constants.MODULES_IN + mod_dir) |
| # (b/156457698) Force add vts_kernel_tests as build target if our test |
| # belong to REQUIRED_KERNEL_TEST_MODULES due to required_module option |
| # not working for sh_test in soong. |
| if module_name in constants.REQUIRED_KERNEL_TEST_MODULES: |
| targets.add('vts_kernel_tests') |
| # (b/184567849) Force adding module_name as a build_target. This will |
| # allow excluding MODULES-IN-* and prevent from missing build targets. |
| if module_name and self.module_info.is_module(module_name): |
| targets.add(module_name) |
| # If it's a MTS test, add cts-tradefed as test dependency. |
| if constants.MTS_SUITE in self.module_info.get_module_info( |
| module_name).get(constants.MODULE_COMPATIBILITY_SUITES, []): |
| if self.module_info.is_module(constants.CTS_JAR): |
| targets.add(constants.CTS_JAR) |
| return targets |
| |
| def _get_module_test_config(self, module_name, rel_config=None): |
| """Get the value of test_config in module_info. |
| |
| Get the value of 'test_config' in module_info if its |
| auto_test_config is not true. |
| In this case, the test_config is specified by user. |
| If not, return rel_config. |
| |
| Args: |
| module_name: A string of the test's module name. |
| rel_config: XML for the given test. |
| |
| Returns: |
| A list of string of test_config path if found, else return rel_config. |
| """ |
| default_all_config = not (atest_configs.GLOBAL_ARGS and |
| atest_configs.GLOBAL_ARGS.test_config_select) |
| mod_info = self.module_info.get_module_info(module_name) |
| if mod_info: |
| test_configs = [] |
| test_config_list = mod_info.get(constants.MODULE_TEST_CONFIG, []) |
| if test_config_list: |
| # multiple test configs |
| if len(test_config_list) > 1: |
| test_configs = test_finder_utils.extract_test_from_tests( |
| test_config_list, default_all=default_all_config) |
| else: |
| test_configs = test_config_list |
| if test_configs: |
| return test_configs |
| # Double check if below section is needed. |
| if (not self.module_info.is_auto_gen_test_config(module_name) |
| and len(test_configs) > 0): |
| return test_configs |
| return [rel_config] if rel_config else [] |
| |
| # pylint: disable=too-many-branches |
| # pylint: disable=too-many-locals |
| def _get_test_info_filter(self, path, methods, **kwargs): |
| """Get test info filter. |
| |
| Args: |
| path: A string of the test's path. |
| methods: A set of method name strings. |
| rel_module_dir: Optional. A string of the module dir no-absolute to |
| root. |
| class_name: Optional. A string of the class name. |
| is_native_test: Optional. A boolean variable of whether to search |
| for a native test or not. |
| |
| Returns: |
| A set of test info filter. |
| """ |
| _, file_name = test_finder_utils.get_dir_path_and_filename(path) |
| ti_filter = frozenset() |
| if os.path.isfile(path) and kwargs.get('is_native_test', None): |
| class_info = test_finder_utils.get_cc_class_info(path) |
| ti_filter = frozenset([test_info.TestFilter( |
| test_finder_utils.get_cc_filter( |
| class_info, kwargs.get('class_name', '*'), methods), |
| frozenset())]) |
| # Path to java file. |
| elif file_name and constants.JAVA_EXT_RE.match(file_name): |
| full_class_name = test_finder_utils.get_fully_qualified_class_name( |
| path) |
| # If input class is parameterized java class, adding * to the end of |
| # method filter string to make sure the generated method name could |
| # be run. |
| if test_finder_utils.is_parameterized_java_class(path): |
| update_methods = [] |
| for method in methods: |
| update_methods.append(method + '*') |
| methods = frozenset(update_methods) |
| ti_filter = frozenset( |
| [test_info.TestFilter(full_class_name, methods)]) |
| # Path to cc file. |
| elif file_name and constants.CC_EXT_RE.match(file_name): |
| # TODO (b/173019813) Should setup correct filter for an input file. |
| if not test_finder_utils.has_cc_class(path): |
| raise atest_error.MissingCCTestCaseError( |
| "Can't find CC class in %s" % path) |
| class_info = test_finder_utils.get_cc_class_info(path) |
| cc_filters = [] |
| for classname, _ in class_info.items(): |
| cc_filters.append( |
| test_info.TestFilter( |
| test_finder_utils.get_cc_filter(class_info, classname, methods), |
| frozenset())) |
| ti_filter = frozenset(cc_filters) |
| # If input path is a folder and have class_name information. |
| elif (not file_name and kwargs.get('class_name', None)): |
| ti_filter = frozenset( |
| [test_info.TestFilter(kwargs.get('class_name', None), methods)]) |
| # Path to non-module dir, treat as package. |
| elif (not file_name |
| and kwargs.get('rel_module_dir', None) != |
| os.path.relpath(path, self.root_dir)): |
| dir_items = [os.path.join(path, f) for f in os.listdir(path)] |
| for dir_item in dir_items: |
| if constants.JAVA_EXT_RE.match(dir_item): |
| package_name = test_finder_utils.get_package_name(dir_item) |
| if package_name: |
| # methods should be empty frozenset for package. |
| if methods: |
| raise atest_error.MethodWithoutClassError( |
| '%s: Method filtering requires class' |
| % str(methods)) |
| ti_filter = frozenset( |
| [test_info.TestFilter(package_name, methods)]) |
| break |
| logging.debug('_get_test_info_filter() ti_filter: %s', ti_filter) |
| return ti_filter |
| |
| def _get_rel_config(self, test_path): |
| """Get config file's no-absolute path. |
| |
| Args: |
| test_path: A string of the test absolute path. |
| |
| Returns: |
| A string of config's no-absolute path, else None. |
| """ |
| test_dir = os.path.dirname(test_path) |
| rel_module_dir = test_finder_utils.find_parent_module_dir( |
| self.root_dir, test_dir, self.module_info) |
| if rel_module_dir: |
| return os.path.join(rel_module_dir, constants.MODULE_CONFIG) |
| return None |
| |
| def _get_test_infos(self, test_path, rel_config, module_name, test_filter): |
| """Get test_info for test_path. |
| |
| Args: |
| test_path: A string of the test path. |
| rel_config: A string of rel path of config. |
| module_name: A string of the module name to use. |
| test_filter: A test info filter. |
| |
| Returns: |
| A list of TestInfo namedtuple if found, else None. |
| """ |
| if not rel_config: |
| rel_config = self._get_rel_config(test_path) |
| if not rel_config: |
| return None |
| if module_name: |
| module_names = [module_name] |
| else: |
| module_names = self._determine_testable_module( |
| os.path.dirname(rel_config), |
| test_path if self._is_comparted_src(test_path) else None) |
| test_infos = [] |
| if module_names: |
| for mname in module_names: |
| # The real test config might be record in module-info. |
| rel_configs = self._get_module_test_config( |
| mname, rel_config=rel_config) |
| for rel_cfg in rel_configs: |
| mod_info = self.module_info.get_module_info(mname) |
| tinfo = self._process_test_info(test_info.TestInfo( |
| test_name=mname, |
| test_runner=self._TEST_RUNNER, |
| build_targets=set(), |
| data={constants.TI_FILTER: test_filter, |
| constants.TI_REL_CONFIG: rel_cfg}, |
| compatibility_suites=mod_info.get( |
| constants.MODULE_COMPATIBILITY_SUITES, []))) |
| if tinfo: |
| test_infos.append(tinfo) |
| return test_infos |
| |
| def find_test_by_module_name(self, module_name): |
| """Find test for the given module name. |
| |
| Args: |
| module_name: A string of the test's module name. |
| |
| Returns: |
| A list that includes only 1 populated TestInfo namedtuple |
| if found, otherwise None. |
| """ |
| tinfos = [] |
| mod_info = self.module_info.get_module_info(module_name) |
| if self.module_info.is_testable_module(mod_info): |
| # path is a list with only 1 element. |
| rel_config = os.path.join(mod_info['path'][0], |
| constants.MODULE_CONFIG) |
| rel_configs = self._get_module_test_config(module_name, |
| rel_config=rel_config) |
| for rel_config in rel_configs: |
| tinfo = self._process_test_info(test_info.TestInfo( |
| test_name=module_name, |
| test_runner=self._TEST_RUNNER, |
| build_targets=set(), |
| data={constants.TI_REL_CONFIG: rel_config, |
| constants.TI_FILTER: frozenset()}, |
| compatibility_suites=mod_info.get( |
| constants.MODULE_COMPATIBILITY_SUITES, []))) |
| if tinfo: |
| tinfos.append(tinfo) |
| if tinfos: |
| return tinfos |
| return None |
| |
| def find_test_by_kernel_class_name(self, module_name, class_name): |
| """Find kernel test for the given class name. |
| |
| Args: |
| module_name: A string of the module name to use. |
| class_name: A string of the test's class name. |
| |
| Returns: |
| A list of populated TestInfo namedtuple if test found, else None. |
| """ |
| |
| class_name, methods = test_finder_utils.split_methods(class_name) |
| test_configs = self._get_module_test_config(module_name) |
| if not test_configs: |
| return None |
| tinfos = [] |
| for test_config in test_configs: |
| test_config_path = os.path.join(self.root_dir, test_config) |
| mod_info = self.module_info.get_module_info(module_name) |
| ti_filter = frozenset( |
| [test_info.TestFilter(class_name, methods)]) |
| if test_finder_utils.is_test_from_kernel_xml(test_config_path, class_name): |
| tinfo = self._process_test_info(test_info.TestInfo( |
| test_name=module_name, |
| test_runner=self._TEST_RUNNER, |
| build_targets=set(), |
| data={constants.TI_REL_CONFIG: test_config, |
| constants.TI_FILTER: ti_filter}, |
| compatibility_suites=mod_info.get( |
| constants.MODULE_COMPATIBILITY_SUITES, []))) |
| if tinfo: |
| tinfos.append(tinfo) |
| if tinfos: |
| return tinfos |
| return None |
| |
| def find_test_by_class_name(self, class_name, module_name=None, |
| rel_config=None, is_native_test=False): |
| """Find test files given a class name. |
| |
| If module_name and rel_config not given it will calculate it determine |
| it by looking up the tree from the class file. |
| |
| Args: |
| class_name: A string of the test's class name. |
| module_name: Optional. A string of the module name to use. |
| rel_config: Optional. A string of module dir no-absolute to repo root. |
| is_native_test: A boolean variable of whether to search for a |
| native test or not. |
| |
| Returns: |
| A list of populated TestInfo namedtuple if test found, else None. |
| """ |
| class_name, methods = test_finder_utils.split_methods(class_name) |
| search_class_name = class_name |
| # For parameterized gtest, test class will be automerged to |
| # $(class_prefix)/$(base_class) name. Using $(base_class) for searching |
| # matched TEST_P to make sure test class is matched. |
| if '/' in search_class_name: |
| search_class_name = str(search_class_name).split('/')[-1] |
| if rel_config: |
| search_dir = os.path.join(self.root_dir, |
| os.path.dirname(rel_config)) |
| else: |
| search_dir = self.root_dir |
| test_paths = test_finder_utils.find_class_file(search_dir, search_class_name, |
| is_native_test, methods) |
| if not test_paths and rel_config: |
| logging.info('Did not find class (%s) under module path (%s), ' |
| 'researching from repo root.', class_name, rel_config) |
| test_paths = test_finder_utils.find_class_file(self.root_dir, |
| search_class_name, |
| is_native_test, |
| methods) |
| test_paths = test_paths if test_paths is not None else [] |
| # If we already have module name, use path in module-info as test_path. |
| if not test_paths: |
| if not module_name: |
| return None |
| # Use the module path as test_path. |
| module_paths = self.module_info.get_paths(module_name) |
| test_paths = [] |
| for rel_module_path in module_paths: |
| test_paths.append(os.path.join(self.root_dir, rel_module_path)) |
| tinfos = [] |
| for test_path in test_paths: |
| test_filter = self._get_test_info_filter( |
| test_path, methods, class_name=class_name, |
| is_native_test=is_native_test) |
| test_infos = self._get_test_infos( |
| test_path, rel_config, module_name, test_filter) |
| # If input include methods, check if tinfo match. |
| if test_infos and len(test_infos) > 1 and methods: |
| test_infos = self._get_matched_test_infos(test_infos, methods) |
| if test_infos: |
| tinfos.extend(test_infos) |
| return tinfos if tinfos else None |
| |
| def _get_matched_test_infos(self, test_infos, methods): |
| """Get the test_infos matched the given methods. |
| |
| Args: |
| test_infos: A list of TestInfo obj. |
| methods: A set of method name strings. |
| |
| Returns: |
| A list of matched TestInfo namedtuple, else None. |
| """ |
| matched_test_infos = set() |
| for tinfo in test_infos: |
| test_config, test_srcs = test_finder_utils.get_test_config_and_srcs( |
| tinfo, self.module_info) |
| if test_config: |
| filter_dict = atest_utils.get_android_junit_config_filters( |
| test_config) |
| # Always treat the test_info is matched if no filters found. |
| if not filter_dict.keys(): |
| matched_test_infos.add(tinfo) |
| continue |
| for method in methods: |
| if self._is_srcs_match_method_annotation(method, test_srcs, |
| filter_dict): |
| logging.debug('For method:%s Test:%s matched ' |
| 'filter_dict: %s', method, |
| tinfo.test_name, filter_dict) |
| matched_test_infos.add(tinfo) |
| return list(matched_test_infos) |
| |
| def _is_srcs_match_method_annotation(self, method, srcs, annotation_dict): |
| """Check if input srcs matched annotation. |
| |
| Args: |
| method: A string of test method name. |
| srcs: A list of source file of test. |
| annotation_dict: A dictionary record the include and exclude |
| annotations. |
| |
| Returns: |
| True if input method matched the annotation of input srcs, else |
| None. |
| """ |
| include_annotations = annotation_dict.get( |
| constants.INCLUDE_ANNOTATION, []) |
| exclude_annotations = annotation_dict.get( |
| constants.EXCLUDE_ANNOTATION, []) |
| for src in srcs: |
| include_methods = set() |
| src_path = os.path.join(self.root_dir, src) |
| # Add methods matched include_annotations. |
| for annotation in include_annotations: |
| include_methods.update( |
| test_finder_utils.get_annotated_methods( |
| annotation, src_path)) |
| if exclude_annotations: |
| # For exclude annotation, get all the method in the input srcs, |
| # and filter out the matched annotation. |
| exclude_methods = set() |
| all_methods = test_finder_utils.get_java_methods(src_path) |
| for annotation in exclude_annotations: |
| exclude_methods.update( |
| test_finder_utils.get_annotated_methods( |
| annotation, src_path)) |
| include_methods = all_methods - exclude_methods |
| if method in include_methods: |
| return True |
| return False |
| |
| def find_test_by_module_and_class(self, module_class): |
| """Find the test info given a MODULE:CLASS string. |
| |
| Args: |
| module_class: A string of form MODULE:CLASS or MODULE:CLASS#METHOD. |
| |
| Returns: |
| A list of populated TestInfo namedtuple if found, else None. |
| """ |
| if ':' not in module_class: |
| return None |
| module_name, class_name = module_class.split(':') |
| # module_infos is a list with at most 1 element. |
| module_infos = self.find_test_by_module_name(module_name) |
| module_info = module_infos[0] if module_infos else None |
| if not module_info: |
| return None |
| find_result = None |
| # If the target module is NATIVE_TEST, search CC classes only. |
| if not self.module_info.is_native_test(module_name): |
| # Find by java class. |
| find_result = self.find_test_by_class_name( |
| class_name, module_info.test_name, |
| module_info.data.get(constants.TI_REL_CONFIG)) |
| # kernel target test is also define as NATIVE_TEST in build system. |
| # TODO (b/157210083) Update find_test_by_kernel_class_name method to |
| # support gen_rule use case. |
| if not find_result: |
| find_result = self.find_test_by_kernel_class_name( |
| module_name, class_name) |
| # Find by cc class. |
| if not find_result: |
| find_result = self.find_test_by_cc_class_name( |
| class_name, module_info.test_name, |
| module_info.data.get(constants.TI_REL_CONFIG)) |
| return find_result |
| |
| def find_test_by_package_name(self, package, module_name=None, |
| rel_config=None): |
| """Find the test info given a PACKAGE string. |
| |
| Args: |
| package: A string of the package name. |
| module_name: Optional. A string of the module name. |
| ref_config: Optional. A string of rel path of config. |
| |
| Returns: |
| A list of populated TestInfo namedtuple if found, else None. |
| """ |
| _, methods = test_finder_utils.split_methods(package) |
| if methods: |
| raise atest_error.MethodWithoutClassError('%s: Method filtering ' |
| 'requires class' % ( |
| methods)) |
| # Confirm that packages exists and get user input for multiples. |
| if rel_config: |
| search_dir = os.path.join(self.root_dir, |
| os.path.dirname(rel_config)) |
| else: |
| search_dir = self.root_dir |
| package_paths = test_finder_utils.run_find_cmd( |
| test_finder_utils.FIND_REFERENCE_TYPE.PACKAGE, search_dir, package) |
| package_paths = package_paths if package_paths is not None else [] |
| # Package path will be the full path to the dir represented by package. |
| if not package_paths: |
| if not module_name: |
| return None |
| module_paths = self.module_info.get_paths(module_name) |
| for rel_module_path in module_paths: |
| package_paths.append(os.path.join(self.root_dir, rel_module_path)) |
| test_filter = frozenset([test_info.TestFilter(package, frozenset())]) |
| test_infos = [] |
| for package_path in package_paths: |
| tinfo = self._get_test_infos(package_path, rel_config, |
| module_name, test_filter) |
| if tinfo: |
| test_infos.extend(tinfo) |
| return test_infos if test_infos else None |
| |
| def find_test_by_module_and_package(self, module_package): |
| """Find the test info given a MODULE:PACKAGE string. |
| |
| Args: |
| module_package: A string of form MODULE:PACKAGE |
| |
| Returns: |
| A list of populated TestInfo namedtuple if found, else None. |
| """ |
| module_name, package = module_package.split(':') |
| # module_infos is a list with at most 1 element. |
| module_infos = self.find_test_by_module_name(module_name) |
| module_info = module_infos[0] if module_infos else None |
| if not module_info: |
| return None |
| return self.find_test_by_package_name( |
| package, module_info.test_name, |
| module_info.data.get(constants.TI_REL_CONFIG)) |
| |
| def find_test_by_path(self, rel_path): |
| """Find the first test info matching the given path. |
| |
| Strategy: |
| path_to_java_file --> Resolve to CLASS |
| path_to_cc_file --> Resolve to CC CLASS |
| path_to_module_file -> Resolve to MODULE |
| path_to_module_dir -> Resolve to MODULE |
| path_to_dir_with_class_files--> Resolve to PACKAGE |
| path_to_any_other_dir --> Resolve as MODULE |
| |
| Args: |
| rel_path: A string of the relative path to $BUILD_TOP. |
| |
| Returns: |
| A list of populated TestInfo namedtuple if test found, else None |
| """ |
| logging.debug('Finding test by path: %s', rel_path) |
| path, methods = test_finder_utils.split_methods(rel_path) |
| # TODO: See if this can be generalized and shared with methods above |
| # create absolute path from cwd and remove symbolic links |
| path = os.path.realpath(path) |
| if not os.path.exists(path): |
| return None |
| if (methods and |
| not test_finder_utils.has_method_in_file(path, methods)): |
| return None |
| dir_path, _ = test_finder_utils.get_dir_path_and_filename(path) |
| # Module/Class |
| rel_module_dir = test_finder_utils.find_parent_module_dir( |
| self.root_dir, dir_path, self.module_info) |
| if not rel_module_dir: |
| # Try to find unit-test for input path. |
| path = os.path.relpath( |
| os.path.realpath(rel_path), |
| os.environ.get(constants.ANDROID_BUILD_TOP, '')) |
| unit_tests = test_finder_utils.find_host_unit_tests( |
| self.module_info, path) |
| if unit_tests: |
| tinfos = [] |
| for unit_test in unit_tests: |
| tinfo = self._get_test_infos(path, constants.MODULE_CONFIG, |
| unit_test, frozenset()) |
| if tinfo: |
| tinfos.extend(tinfo) |
| return tinfos |
| return None |
| rel_config = os.path.join(rel_module_dir, constants.MODULE_CONFIG) |
| test_filter = self._get_test_info_filter(path, methods, |
| rel_module_dir=rel_module_dir) |
| return self._get_test_infos(path, rel_config, None, test_filter) |
| |
| def find_test_by_cc_class_name(self, class_name, module_name=None, |
| rel_config=None): |
| """Find test files given a cc class name. |
| |
| If module_name and rel_config not given, test will be determined |
| by looking up the tree for files which has input class. |
| |
| Args: |
| class_name: A string of the test's class name. |
| module_name: Optional. A string of the module name to use. |
| rel_config: Optional. A string of module dir no-absolute to repo root. |
| |
| Returns: |
| A list of populated TestInfo namedtuple if test found, else None. |
| """ |
| # Check if class_name is prepended with file name. If so, trim the |
| # prefix and keep only the class_name. |
| if '.' in class_name: |
| # (b/202764540) Strip prefixes of a cc class. |
| # Assume the class name has a format of file_name.class_name |
| class_name = class_name[class_name.rindex('.')+1:] |
| logging.info('Search with updated class name: %s', class_name) |
| return self.find_test_by_class_name( |
| class_name, module_name, rel_config, is_native_test=True) |
| |
| def get_testable_modules_with_ld(self, user_input, ld_range=0): |
| """Calculate the edit distances of the input and testable modules. |
| |
| The user input will be calculated across all testable modules and |
| results in integers generated by Levenshtein Distance algorithm. |
| To increase the speed of the calculation, a bound can be applied to |
| this method to prevent from calculating every testable modules. |
| |
| Guessing from typos, e.g. atest atest_unitests, implies a tangible range |
| of length that Atest only needs to search within it, and the default of |
| the bound is 2. |
| |
| Guessing from keywords however, e.g. atest --search Camera, means that |
| the uncertainty of the module name is way higher, and Atest should walk |
| through all testable modules and return the highest possibilities. |
| |
| Args: |
| user_input: A string of the user input. |
| ld_range: An integer that range the searching scope. If the length |
| of user_input is 10, then Atest will calculate modules of |
| which length is between 8 and 12. 0 is equivalent to |
| unlimited. |
| |
| Returns: |
| A List of LDs and possible module names. If the user_input is "fax", |
| the output will be like: |
| [[2, "fog"], [2, "Fix"], [4, "duck"], [7, "Duckies"]] |
| |
| Which means the most lilely names of "fax" are fog and Fix(LD=2), |
| while Dickies is the most unlikely one(LD=7). |
| """ |
| atest_utils.colorful_print('\nSearching for similar module names using ' |
| 'fuzzy search...', constants.CYAN) |
| search_start = time.time() |
| testable_modules = sorted(self.module_info.get_testable_modules(), |
| key=len) |
| lower_bound = len(user_input) - ld_range |
| upper_bound = len(user_input) + ld_range |
| testable_modules_with_ld = [] |
| for module_name in testable_modules: |
| # Dispose those too short or too lengthy. |
| if ld_range != 0: |
| if len(module_name) < lower_bound: |
| continue |
| if len(module_name) > upper_bound: |
| break |
| testable_modules_with_ld.append( |
| [test_finder_utils.get_levenshtein_distance( |
| user_input, module_name), module_name]) |
| search_duration = time.time() - search_start |
| logging.debug('Fuzzy search took %ss', search_duration) |
| metrics.LocalDetectEvent( |
| detect_type=constants.DETECT_TYPE_FUZZY_SEARCH_TIME, |
| result=round(search_duration)) |
| return testable_modules_with_ld |
| |
| def get_fuzzy_searching_results(self, user_input): |
| """Give results which have no more than allowance of edit distances. |
| |
| Args: |
| user_input: the target module name for fuzzy searching. |
| |
| Return: |
| A list of guessed modules. |
| """ |
| modules_with_ld = self.get_testable_modules_with_ld( |
| user_input, ld_range=constants.LD_RANGE) |
| guessed_modules = [] |
| for _distance, _module in modules_with_ld: |
| if _distance <= abs(constants.LD_RANGE): |
| guessed_modules.append(_module) |
| return guessed_modules |
| |
| def find_test_by_config_name(self, config_name): |
| """Find test for the given config name. |
| |
| Args: |
| config_name: A string of the test's config name. |
| |
| Returns: |
| A list that includes only 1 populated TestInfo namedtuple |
| if found, otherwise None. |
| """ |
| for module_name, mod_info in self.module_info.name_to_module_info.items(): |
| test_configs = mod_info.get(constants.MODULE_TEST_CONFIG, []) |
| for test_config in test_configs: |
| test_config_name = os.path.splitext( |
| os.path.basename(test_config))[0] |
| if test_config_name == config_name: |
| tinfo = test_info.TestInfo( |
| test_name=test_config_name, |
| test_runner=self._TEST_RUNNER, |
| build_targets=self._get_build_targets(module_name, |
| test_config), |
| data={constants.TI_REL_CONFIG: test_config, |
| constants.TI_FILTER: frozenset()}, |
| compatibility_suites=mod_info.get( |
| constants.MODULE_COMPATIBILITY_SUITES, [])) |
| test_config_path = os.path.join(self.root_dir, test_config) |
| if test_finder_utils.need_aggregate_metrics_result(test_config_path): |
| tinfo.aggregate_metrics_result = True |
| if tinfo: |
| # There should have only one test_config with the same |
| # name in source tree. |
| return [tinfo] |
| return None |
| |
| def _is_comparted_src(self, path): |
| """Check if the input path need to match srcs information in module. |
| |
| If path is a folder or android build file, we don't need to compart |
| with module's srcs. |
| |
| Args: |
| path: A string of the test's path. |
| |
| Returns: |
| True if input path need to match with module's src info, else False. |
| """ |
| if os.path.isdir(path): |
| return False |
| if atest_utils.is_build_file(path): |
| return False |
| return True |
| |
| class MainlineModuleFinder(ModuleFinder): |
| """Mainline Module finder class.""" |
| NAME = 'MAINLINE_MODULE' |
| |
| def __init__(self, module_info=None): |
| super().__init__() |
