| # 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. |
| |
| """ |
| Test Finder Handler module. |
| """ |
| |
| import logging |
| |
| import atest_enum |
| from test_finders import cache_finder |
| from test_finders import test_finder_base |
| from test_finders import suite_plan_finder |
| from test_finders import tf_integration_finder |
| from test_finders import module_finder |
| |
| # List of default test finder classes. |
| _TEST_FINDERS = { |
| suite_plan_finder.SuitePlanFinder, |
| tf_integration_finder.TFIntegrationFinder, |
| module_finder.ModuleFinder, |
| cache_finder.CacheFinder, |
| } |
| |
| # Explanation of REFERENCE_TYPEs: |
| # ---------------------------------- |
| # 0. MODULE: LOCAL_MODULE or LOCAL_PACKAGE_NAME value in Android.mk/Android.bp. |
| # 1. CLASS: Names which the same with a ClassName.java/kt file. |
| # 2. QUALIFIED_CLASS: String like "a.b.c.ClassName". |
| # 3. MODULE_CLASS: Combo of MODULE and CLASS as "module:class". |
| # 4. PACKAGE: Package in java file. Same as file path to java file. |
| # 5. MODULE_PACKAGE: Combo of MODULE and PACKAGE as "module:package". |
| # 6. MODULE_FILE_PATH: File path to dir of tests or test itself. |
| # 7. INTEGRATION_FILE_PATH: File path to config xml in one of the 4 integration |
| # config directories. |
| # 8. INTEGRATION: xml file name in one of the 4 integration config directories. |
| # 9. SUITE: Value of the "run-suite-tag" in xml config file in 4 config dirs. |
| # Same as value of "test-suite-tag" in AndroidTest.xml files. |
| # 10. CC_CLASS: Test case in cc file. |
| # 11. SUITE_PLAN: Suite name such as cts. |
| # 12. SUITE_PLAN_FILE_PATH: File path to config xml in the suite config directories. |
| # 13. CACHE: A pseudo type that runs cache_finder without finding test in real. |
| _REFERENCE_TYPE = atest_enum.AtestEnum(['MODULE', 'CLASS', 'QUALIFIED_CLASS', |
| 'MODULE_CLASS', 'PACKAGE', |
| 'MODULE_PACKAGE', 'MODULE_FILE_PATH', |
| 'INTEGRATION_FILE_PATH', 'INTEGRATION', |
| 'SUITE', 'CC_CLASS', 'SUITE_PLAN', |
| 'SUITE_PLAN_FILE_PATH', 'CACHE']) |
| |
| _REF_TYPE_TO_FUNC_MAP = { |
| _REFERENCE_TYPE.MODULE: module_finder.ModuleFinder.find_test_by_module_name, |
| _REFERENCE_TYPE.CLASS: module_finder.ModuleFinder.find_test_by_class_name, |
| _REFERENCE_TYPE.MODULE_CLASS: module_finder.ModuleFinder.find_test_by_module_and_class, |
| _REFERENCE_TYPE.QUALIFIED_CLASS: module_finder.ModuleFinder.find_test_by_class_name, |
| _REFERENCE_TYPE.PACKAGE: module_finder.ModuleFinder.find_test_by_package_name, |
| _REFERENCE_TYPE.MODULE_PACKAGE: module_finder.ModuleFinder.find_test_by_module_and_package, |
| _REFERENCE_TYPE.MODULE_FILE_PATH: module_finder.ModuleFinder.find_test_by_path, |
| _REFERENCE_TYPE.INTEGRATION_FILE_PATH: |
| tf_integration_finder.TFIntegrationFinder.find_int_test_by_path, |
| _REFERENCE_TYPE.INTEGRATION: |
| tf_integration_finder.TFIntegrationFinder.find_test_by_integration_name, |
| _REFERENCE_TYPE.CC_CLASS: |
| module_finder.ModuleFinder.find_test_by_cc_class_name, |
| _REFERENCE_TYPE.SUITE_PLAN:suite_plan_finder.SuitePlanFinder.find_test_by_suite_name, |
| _REFERENCE_TYPE.SUITE_PLAN_FILE_PATH: |
| suite_plan_finder.SuitePlanFinder.find_test_by_suite_path, |
| _REFERENCE_TYPE.CACHE: cache_finder.CacheFinder.find_test_by_cache, |
| } |
| |
| |
| def _get_finder_instance_dict(module_info): |
| """Return dict of finder instances. |
| |
| Args: |
| module_info: ModuleInfo for finder classes to use. |
| |
| Returns: |
| Dict of finder instances keyed by their name. |
| """ |
| instance_dict = {} |
| for finder in _get_test_finders(): |
| instance_dict[finder.NAME] = finder(module_info=module_info) |
| return instance_dict |
| |
| |
| def _get_test_finders(): |
| """Returns the test finders. |
| |
| If external test types are defined outside atest, they can be try-except |
| imported into here. |
| |
| Returns: |
| Set of test finder classes. |
| """ |
| test_finders_list = _TEST_FINDERS |
| # Example import of external test finder: |
| try: |
| from test_finders import example_finder |
| test_finders_list.add(example_finder.ExampleFinder) |
| except ImportError: |
| pass |
| return test_finders_list |
| |
| # pylint: disable=too-many-return-statements |
| def _get_test_reference_types(ref): |
| """Determine type of test reference based on the content of string. |
| |
| Examples: |
| The string 'SequentialRWTest' could be a reference to |
| a Module or a Class name. |
| |
| The string 'cts/tests/filesystem' could be a Path, Integration |
| or Suite reference. |
| |
| Args: |
| ref: A string referencing a test. |
| |
| Returns: |
| A list of possible REFERENCE_TYPEs (ints) for reference string. |
| """ |
| if ref.startswith('.') or '..' in ref: |
| return [_REFERENCE_TYPE.CACHE, |
| _REFERENCE_TYPE.INTEGRATION_FILE_PATH, |
| _REFERENCE_TYPE.MODULE_FILE_PATH, |
| _REFERENCE_TYPE.SUITE_PLAN_FILE_PATH] |
| if '/' in ref: |
| if ref.startswith('/'): |
| return [_REFERENCE_TYPE.CACHE, |
| _REFERENCE_TYPE.INTEGRATION_FILE_PATH, |
| _REFERENCE_TYPE.MODULE_FILE_PATH, |
| _REFERENCE_TYPE.SUITE_PLAN_FILE_PATH] |
| return [_REFERENCE_TYPE.CACHE, |
| _REFERENCE_TYPE.INTEGRATION_FILE_PATH, |
| _REFERENCE_TYPE.MODULE_FILE_PATH, |
| _REFERENCE_TYPE.INTEGRATION, |
| _REFERENCE_TYPE.SUITE_PLAN_FILE_PATH, |
| # TODO: Uncomment in SUITE when it's supported |
| # _REFERENCE_TYPE.SUITE |
| ] |
| if '.' in ref: |
| ref_end = ref.rsplit('.', 1)[-1] |
| ref_end_is_upper = ref_end[0].isupper() |
| if ':' in ref: |
| if '.' in ref: |
| if ref_end_is_upper: |
| # Module:fully.qualified.Class or Integration:fully.q.Class |
| return [_REFERENCE_TYPE.CACHE, |
| _REFERENCE_TYPE.INTEGRATION, |
| _REFERENCE_TYPE.MODULE_CLASS] |
| # Module:some.package |
| return [_REFERENCE_TYPE.CACHE, _REFERENCE_TYPE.MODULE_PACKAGE, |
| _REFERENCE_TYPE.MODULE_CLASS] |
| # Module:Class or IntegrationName:Class |
| return [_REFERENCE_TYPE.CACHE, |
| _REFERENCE_TYPE.INTEGRATION, |
| _REFERENCE_TYPE.MODULE_CLASS] |
| if '.' in ref: |
| # The string of ref_end possibly includes specific mathods, e.g. |
| # foo.java#method, so let ref_end be the first part of splitting '#'. |
| if "#" in ref_end: |
| ref_end = ref_end.split('#')[0] |
| if ref_end in ('java', 'kt', 'bp', 'mk', 'cc', 'cpp'): |
| return [_REFERENCE_TYPE.CACHE, _REFERENCE_TYPE.MODULE_FILE_PATH] |
| if ref_end == 'xml': |
| return [_REFERENCE_TYPE.CACHE, |
| _REFERENCE_TYPE.INTEGRATION_FILE_PATH, |
| _REFERENCE_TYPE.SUITE_PLAN_FILE_PATH] |
| if ref_end_is_upper: |
| return [_REFERENCE_TYPE.CACHE, _REFERENCE_TYPE.QUALIFIED_CLASS] |
| return [_REFERENCE_TYPE.CACHE, |
| _REFERENCE_TYPE.MODULE, |
| _REFERENCE_TYPE.PACKAGE] |
| # Note: We assume that if you're referencing a file in your cwd, |
| # that file must have a '.' in its name, i.e. foo.java, foo.xml. |
| # If this ever becomes not the case, then we need to include path below. |
| return [_REFERENCE_TYPE.CACHE, |
| _REFERENCE_TYPE.INTEGRATION, |
| # TODO: Uncomment in SUITE when it's supported |
| # _REFERENCE_TYPE.SUITE, |
| _REFERENCE_TYPE.MODULE, |
| _REFERENCE_TYPE.SUITE_PLAN, |
| _REFERENCE_TYPE.CLASS, |
| _REFERENCE_TYPE.CC_CLASS] |
| |
| |
| def _get_registered_find_methods(module_info): |
| """Return list of registered find methods. |
| |
| This is used to return find methods that were not listed in the |
| default find methods but just registered in the finder classes. These |
| find methods will run before the default find methods. |
| |
| Args: |
| module_info: ModuleInfo for finder classes to instantiate with. |
| |
| Returns: |
| List of registered find methods. |
| """ |
| find_methods = [] |
| finder_instance_dict = _get_finder_instance_dict(module_info) |
| for finder in _get_test_finders(): |
| finder_instance = finder_instance_dict[finder.NAME] |
| for find_method_info in finder_instance.get_all_find_methods(): |
| find_methods.append(test_finder_base.Finder( |
| finder_instance, find_method_info.find_method, finder.NAME)) |
| return find_methods |
| |
| |
| def _get_default_find_methods(module_info, test): |
| """Default find methods to be used based on the given test name. |
| |
| Args: |
| module_info: ModuleInfo for finder instances to use. |
| test: String of test name to help determine which find methods |
| to utilize. |
| |
| Returns: |
| List of find methods to use. |
| """ |
| find_methods = [] |
| finder_instance_dict = _get_finder_instance_dict(module_info) |
| test_ref_types = _get_test_reference_types(test) |
| logging.debug('Resolved input to possible references: %s', [ |
| _REFERENCE_TYPE[t] for t in test_ref_types]) |
| for test_ref_type in test_ref_types: |
| find_method = _REF_TYPE_TO_FUNC_MAP[test_ref_type] |
| finder_instance = finder_instance_dict[find_method.im_class.NAME] |
| finder_info = _REFERENCE_TYPE[test_ref_type] |
| find_methods.append(test_finder_base.Finder(finder_instance, |
| find_method, |
| finder_info)) |
| return find_methods |
| |
| |
| def get_find_methods_for_test(module_info, test): |
| """Return a list of ordered find methods. |
| |
| Args: |
| test: String of test name to get find methods for. |
| |
| Returns: |
| List of ordered find methods. |
| """ |
| registered_find_methods = _get_registered_find_methods(module_info) |
| default_find_methods = _get_default_find_methods(module_info, test) |
| return registered_find_methods + default_find_methods |
