| #!/usr/bin/env python3 |
| # |
| # 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. |
| |
| """Functional test for aidegen project files.""" |
| |
| from __future__ import absolute_import |
| from __future__ import print_function |
| |
| import argparse |
| import functools |
| import itertools |
| import json |
| import logging |
| import os |
| import subprocess |
| import sys |
| import xml.etree.ElementTree |
| import xml.parsers.expat |
| |
| from aidegen import aidegen_main |
| from aidegen import constant |
| from aidegen.lib import clion_project_file_gen |
| # pylint: disable=no-name-in-module |
| from aidegen.lib import common_util |
| from aidegen.lib import errors |
| from aidegen.lib import module_info_util |
| from aidegen.lib import project_config |
| from aidegen.lib import project_file_gen |
| |
| from atest import module_info |
| |
| _PRODUCT_DIR = '$PROJECT_DIR$' |
| _ROOT_DIR = os.path.join(common_util.get_android_root_dir(), |
| 'tools/asuite/aidegen_functional_test') |
| _TEST_DATA_PATH = os.path.join(_ROOT_DIR, 'test_data') |
| _VERIFY_COMMANDS_JSON = os.path.join(_TEST_DATA_PATH, 'verify_commands.json') |
| _GOLDEN_SAMPLES_JSON = os.path.join(_TEST_DATA_PATH, 'golden_samples.json') |
| _VERIFY_BINARY_JSON = os.path.join(_TEST_DATA_PATH, 'verify_binary_upload.json') |
| _VERIFY_PRESUBMIT_JSON = os.path.join(_TEST_DATA_PATH, 'verify_presubmit.json') |
| _ANDROID_COMMON = 'android_common' |
| _LINUX_GLIBC_COMMON = 'linux_glibc_common' |
| _SRCS = 'srcs' |
| _JARS = 'jars' |
| _URL = 'url' |
| _TEST_ERROR = 'AIDEGen functional test error: {}-{} is different.' |
| _MSG_NOT_IN_PROJECT_FILE = ('{} is expected, but not found in the created ' |
| 'project file: {}') |
| _MSG_NOT_IN_SAMPLE_DATA = ('{} is unexpected, but found in the created project ' |
| 'file: {}') |
| _ALL_PASS = 'All tests passed!' |
| _GIT_COMMIT_ID_JSON = os.path.join( |
| _TEST_DATA_PATH, 'baseline_code_commit_id.json') |
| _GIT = 'git' |
| _CHECKOUT = 'checkout' |
| _BRANCH = 'branch' |
| _COMMIT = 'commit' |
| _LOG = 'log' |
| _ALL = '--all' |
| _COMMIT_ID_NOT_EXIST_ERROR = ('Commit ID: {} does not exist in path: {}. ' |
| 'Please use "git log" command to check if it ' |
| 'exists. If it does not, try to update your ' |
| 'source files to the latest version or do not ' |
| 'use "repo init --depth=1" command.') |
| _GIT_LOG_ERROR = 'Command "git log -n 1" failed.' |
| _BE_REPLACED = '${config.X86_64GccRoot}' |
| _TO_REPLACE = 'prebuilts/gcc/linux-x86/x86/x86_64-linux-android-4.9' |
| |
| |
| def _parse_args(args): |
| """Parse command line arguments. |
| |
| Args: |
| args: A list of arguments. |
| |
| Returns: |
| An argparse.Namespace object holding parsed args. |
| """ |
| parser = argparse.ArgumentParser( |
| description=__doc__, |
| formatter_class=argparse.RawDescriptionHelpFormatter, |
| usage='aidegen_functional_test [-c | -u | -b | -a] -v -r') |
| group = parser.add_mutually_exclusive_group() |
| parser.required = False |
| parser.add_argument( |
| 'targets', |
| type=str, |
| nargs='*', |
| default=[''], |
| help='Android module name or path.e.g. frameworks/base') |
| group.add_argument( |
| '-c', |
| '--create-sample', |
| action='store_true', |
| dest='create_sample', |
| help=('Create aidegen project files and write data to sample json file ' |
| 'for aidegen_functional_test to compare.')) |
| parser.add_argument( |
| '-v', |
| '--verbose', |
| action='store_true', |
| help='Show DEBUG level logging.') |
| parser.add_argument( |
| '-r', |
| '--remove_bp_json', |
| action='store_true', |
| help='Remove module_bp_java_deps.json for each use case test.') |
| parser.add_argument( |
| '-m', |
| '--make_clean', |
| action='store_true', |
| help=('Make clean before testing to create a clean environment, the ' |
| 'aidegen_functional_test can run only once if users command it.')) |
| group.add_argument( |
| '-u', |
| '--use_cases', |
| action='store_true', |
| dest='use_cases_verified', |
| help='Verify various use cases of executing aidegen.') |
| group.add_argument( |
| '-b', |
| action='store_true', |
| dest='binary_upload_verified', |
| help=('Verify aidegen\'s use cases by executing different aidegen ' |
| 'commands.')) |
| group.add_argument( |
| '-p', |
| action='store_true', |
| dest='binary_presubmit_verified', |
| help=('Verify aidegen\'s tool in presubmit test by executing' |
| 'different aidegen commands.')) |
| group.add_argument( |
| '-a', |
| '--test-all', |
| action='store_true', |
| dest='test_all_samples', |
| help='Test all modules listed in module-info.json.') |
| group.add_argument( |
| '-n', |
| '--compare-sample-native', |
| action='store_true', |
| dest='compare_sample_native', |
| help=('Compare if sample native project file is the same as generated ' |
| 'by the build system.')) |
| return parser.parse_args(args) |
| |
| |
| def _import_project_file_xml_etree(filename): |
| """Import iml project file and load its data into a dictionary. |
| |
| Args: |
| filename: The input project file name. |
| |
| Returns: |
| A dictionary contains dependent files' data of project file's contents. |
| The samples are like: |
| "srcs": [ |
| ... |
| "file://$PROJECT_DIR$/frameworks/base/cmds/am/src", |
| "file://$PROJECT_DIR$/frameworks/base/cmds/appwidget/src", |
| ... |
| ] |
| "jars": [ |
| ... |
| "jar://$PROJECT_DIR$/out/host/common/obj/**/classes-header.jar!/" |
| ... |
| ] |
| |
| Raises: |
| EnvironmentError and xml parsing or format errors. |
| """ |
| data = {} |
| try: |
| tree = xml.etree.ElementTree.parse(filename) |
| data[_SRCS] = [] |
| root = tree.getroot() |
| for element in root.iter('sourceFolder'): |
| src = element.get(_URL).replace(common_util.get_android_root_dir(), |
| _PRODUCT_DIR) |
| data[_SRCS].append(src) |
| data[_JARS] = [] |
| for element in root.iter('root'): |
| jar = element.get(_URL).replace(common_util.get_android_root_dir(), |
| _PRODUCT_DIR) |
| data[_JARS].append(jar) |
| except (EnvironmentError, ValueError, LookupError, |
| xml.parsers.expat.ExpatError) as err: |
| print("{0}: import error: {1}".format(os.path.basename(filename), err)) |
| raise |
| return data |
| |
| |
| def _get_project_file_names(abs_path): |
| """Get project file name and depenencies name by relative path. |
| |
| Args: |
| abs_path: an absolute module's path. |
| |
| Returns: |
| file_name: a string of the project file name. |
| dep_name: a string of the merged project and dependencies file's name, |
| e.g., frameworks-dependencies.iml. |
| """ |
| # pylint: disable=maybe-no-member |
| code_name = project_file_gen.ProjectFileGenerator.get_unique_iml_name( |
| abs_path) |
| file_name = ''.join([code_name, '.iml']) |
| dep_name = ''.join([constant.KEY_DEPENDENCIES, '.iml']) |
| return file_name, dep_name |
| |
| |
| def _get_unique_module_name(rel_path, filename): |
| """Get a unique project file name or dependencies name by relative path. |
| |
| Args: |
| rel_path: a relative module's path to aosp root path. |
| filename: the file name to be generated in module_in type file name. |
| |
| Returns: |
| A string, the unique file name for the whole module-info.json. |
| """ |
| code_names = rel_path.split(os.sep) |
| code_names[-1] = filename |
| return '-'.join(code_names) |
| |
| |
| def _get_git_current_commit_id(abs_path): |
| """Get target's git checkout command list. |
| |
| When we run command 'git log -n 1' and get the top first git log record, the |
| commit id is next to the specific word 'commit'. |
| |
| Args: |
| abs_path: a string of the absolute path of the target branch. |
| |
| Return: |
| The current git commit id. |
| |
| Raises: |
| Call subprocess.check_output cause subprocess.CalledProcessError. |
| """ |
| cwd = os.getcwd() |
| os.chdir(abs_path) |
| git_log_cmds = [_GIT, _LOG, '-n', '1'] |
| try: |
| out_put = subprocess.check_output(git_log_cmds).decode("utf-8") |
| except subprocess.CalledProcessError: |
| logging.error(_GIT_LOG_ERROR) |
| raise |
| finally: |
| os.chdir(cwd) |
| com_list = out_put.split() |
| return com_list[com_list.index(_COMMIT) + 1] |
| |
| |
| def _get_commit_id_dictionary(): |
| """Get commit id from dictionary of key, value 'module': 'commit id'.""" |
| data_id_dict = {} |
| with open(_GIT_COMMIT_ID_JSON, 'r') as jsfile: |
| data_id_dict = json.load(jsfile) |
| return data_id_dict |
| |
| |
| def _git_checkout_commit_id(abs_path, commit_id): |
| """Command to checkout specific commit id. |
| |
| Change directory to the module's absolute path which users want to get its |
| specific commit id. |
| |
| Args: |
| abs_path: the absolute path of the target branch. E.g., abs_path/.git |
| commit_id: the commit id users want to checkout. |
| |
| Raises: |
| Call git checkout commit id failed, raise errors.CommitIDNotExistError. |
| """ |
| git_chekout_cmds = [_GIT, _CHECKOUT, commit_id] |
| cwd = os.getcwd() |
| try: |
| os.chdir(abs_path) |
| subprocess.check_output(git_chekout_cmds) |
| except subprocess.CalledProcessError: |
| err = _COMMIT_ID_NOT_EXIST_ERROR.format(commit_id, abs_path) |
| logging.error(err) |
| raise errors.CommitIDNotExistError(err) |
| finally: |
| os.chdir(cwd) |
| |
| |
| def _git_checkout_target_commit_id(target, commit_id): |
| """Command to checkout target commit id. |
| |
| Switch code base to specific commit id which is kept in data_id_dict with |
| target: commit_id as key: value. If the data is missing in data_id_dict, the |
| target isn't a selected golden sample raise error for it. |
| |
| Args: |
| target: the string of target's module name or module path to checkout |
| the relevant git to its specific commit id. |
| commit_id: a string represent target's specific commit id. |
| |
| Returns: |
| current_commit_id: the current commit id of the target which should be |
| switched back to. |
| """ |
| atest_module_info = module_info.ModuleInfo() |
| _, abs_path = common_util.get_related_paths(atest_module_info, target) |
| current_commit_id = _get_git_current_commit_id(abs_path) |
| _git_checkout_commit_id(abs_path, commit_id) |
| return current_commit_id |
| |
| |
| def _checkout_baseline_code_to_spec_commit_id(): |
| """Get a dict of target, commit id listed in baseline_code_commit_id.json. |
| |
| To make sure all samples run on the same environment, we need to keep all |
| the baseline code in a specific commit id. For example, all samples should |
| be created in the same specific commit id of the baseline code |
| 'frameworks/base' for comparison except 'frameworks/base' itself. |
| |
| Returns: |
| A dictionary contains target, specific and current commit id. |
| """ |
| spec_and_cur_commit_id_dict = {} |
| data_id_dict = _get_commit_id_dictionary() |
| for target in data_id_dict: |
| commit_id = data_id_dict.get(target, '') |
| current_commit_id = _git_checkout_target_commit_id(target, commit_id) |
| spec_and_cur_commit_id_dict[target] = {} |
| spec_and_cur_commit_id_dict[target]['current'] = current_commit_id |
| return spec_and_cur_commit_id_dict |
| |
| |
| def _generate_target_real_iml_data(target): |
| """Generate single target's real iml file content's data. |
| |
| Args: |
| target: Android module name or path to be create iml data. |
| |
| Returns: |
| data: A dictionary contains key: unique file name and value: iml |
| content. |
| """ |
| data = {} |
| try: |
| aidegen_main.main([target, '-s', '-n', '-v']) |
| except (errors.FakeModuleError, |
| errors.ProjectOutsideAndroidRootError, |
| errors.ProjectPathNotExistError, |
| errors.NoModuleDefinedInModuleInfoError) as err: |
| logging.error(str(err)) |
| return data |
| |
| atest_module_info = module_info.ModuleInfo() |
| rel_path, abs_path = common_util.get_related_paths(atest_module_info, |
| target) |
| for filename in iter(_get_project_file_names(abs_path)): |
| real_iml_file = os.path.join(abs_path, filename) |
| item_name = _get_unique_module_name(rel_path, filename) |
| data[item_name] = _import_project_file_xml_etree(real_iml_file) |
| return data |
| |
| |
| def _generate_sample_json(test_list): |
| """Generate sample iml data. |
| |
| We use all baseline code samples on the version of their own specific commit |
| id which is kept in _GIT_COMMIT_ID_JSON file. We need to switch back to |
| their current commit ids after generating golden samples' data. |
| |
| Args: |
| test_list: a list of module name and module path. |
| |
| Returns: |
| data: a dictionary contains dependent files' data of project file's |
| contents. |
| The sample is like: |
| "frameworks-base.iml": { |
| "srcs": [ |
| .... |
| "file://$PROJECT_DIR$/frameworks/base/cmds/am/src", |
| "file://$PROJECT_DIR$/frameworks/base/cmds/appwidget/src", |
| .... |
| ], |
| "jars": [ |
| .... |
| "jar://$PROJECT_DIR$/out/target/common/**/aapt2.srcjar!/", |
| .... |
| ] |
| } |
| """ |
| data = {} |
| spec_and_cur_commit_id_dict = _checkout_baseline_code_to_spec_commit_id() |
| for target in test_list: |
| data.update(_generate_target_real_iml_data(target)) |
| atest_module_info = module_info.ModuleInfo() |
| for target in spec_and_cur_commit_id_dict: |
| _, abs_path = common_util.get_related_paths(atest_module_info, target) |
| _git_checkout_commit_id( |
| abs_path, spec_and_cur_commit_id_dict[target]['current']) |
| return data |
| |
| |
| def _create_some_sample_json_file(targets): |
| """Write some samples' iml data into a json file. |
| |
| Args: |
| targets: Android module name or path to be create iml data. |
| |
| linked_function: _generate_sample_json() |
| """ |
| data = _generate_sample_json(targets) |
| data_sample = {} |
| with open(_GOLDEN_SAMPLES_JSON, 'r') as infile: |
| try: |
| data_sample = json.load(infile) |
| # pylint: disable=maybe-no-member |
| except json.JSONDecodeError as err: |
| print("Json decode error: {}".format(err)) |
| data_sample = {} |
| data_sample.update(data) |
| with open(_GOLDEN_SAMPLES_JSON, 'w') as outfile: |
| json.dump(data_sample, outfile, indent=4, sort_keys=False) |
| |
| |
| def test_samples(func): |
| """Decorate a function to deal with preparing and verifying staffs of it. |
| |
| Args: |
| func: a function is to be compared its iml data with the json file's |
| data. |
| |
| Returns: |
| The wrapper function. |
| """ |
| |
| @functools.wraps(func) |
| def wrapper(*args, **kwargs): |
| """A wrapper function.""" |
| |
| test_successful = True |
| with open(_GOLDEN_SAMPLES_JSON, 'r') as outfile: |
| data_sample = json.load(outfile) |
| |
| data_real = func(*args, **kwargs) |
| |
| for name in data_real: |
| for item in [_SRCS, _JARS]: |
| s_items = data_sample[name][item] |
| r_items = data_real[name][item] |
| if set(s_items) != set(r_items): |
| diff_iter = _compare_content(name, item, s_items, r_items) |
| if diff_iter: |
| print('\n{} {}'.format( |
| common_util.COLORED_INFO('Test error:'), |
| _TEST_ERROR.format(name, item))) |
| print('{} {} contents are different:'.format( |
| name, item)) |
| for diff in diff_iter: |
| print(diff) |
| test_successful = False |
| if test_successful: |
| print(common_util.COLORED_PASS(_ALL_PASS)) |
| return test_successful |
| |
| return wrapper |
| |
| |
| @test_samples |
| def _test_some_sample_iml(targets=None): |
| """Compare with sample iml's data to assure the project's contents is right. |
| |
| Args: |
| targets: Android module name or path to be create iml data. |
| """ |
| if targets: |
| return _generate_sample_json(targets) |
| return _generate_sample_json(_get_commit_id_dictionary().keys()) |
| |
| |
| @test_samples |
| def _test_all_samples_iml(): |
| """Compare all imls' data with all samples' data. |
| |
| It's to make sure each iml's contents is right. The function is implemented |
| but hasn't been used yet. |
| """ |
| all_module_list = module_info.ModuleInfo().name_to_module_info.keys() |
| return _generate_sample_json(all_module_list) |
| |
| |
| def _compare_content(module_name, item_type, s_items, r_items): |
| """Compare src or jar files' data of two dictionaries. |
| |
| Args: |
| module_name: the test module name. |
| item_type: the type is src or jar. |
| s_items: sample jars' items. |
| r_items: real jars' items. |
| |
| Returns: |
| An iterator of not equal sentences after comparison. |
| """ |
| if item_type == _SRCS: |
| cmp_iter1 = _compare_srcs_content(module_name, s_items, r_items, |
| _MSG_NOT_IN_PROJECT_FILE) |
| cmp_iter2 = _compare_srcs_content(module_name, r_items, s_items, |
| _MSG_NOT_IN_SAMPLE_DATA) |
| else: |
| cmp_iter1 = _compare_jars_content(module_name, s_items, r_items, |
| _MSG_NOT_IN_PROJECT_FILE) |
| cmp_iter2 = _compare_jars_content(module_name, r_items, s_items, |
| _MSG_NOT_IN_SAMPLE_DATA) |
| return itertools.chain(cmp_iter1, cmp_iter2) |
| |
| |
| def _compare_srcs_content(module_name, s_items, r_items, msg): |
| """Compare src or jar files' data of two dictionaries. |
| |
| Args: |
| module_name: the test module name. |
| s_items: sample jars' items. |
| r_items: real jars' items. |
| msg: the message will be written into log file. |
| |
| Returns: |
| An iterator of not equal sentences after comparison. |
| """ |
| for sample in s_items: |
| if sample not in r_items: |
| yield msg.format(sample, module_name) |
| |
| |
| def _compare_jars_content(module_name, s_items, r_items, msg): |
| """Compare src or jar files' data of two dictionaries. |
| |
| AIDEGen treats the jars in folder names 'linux_glib_common' and |
| 'android_common' as the same content. If the paths are different only |
| because of these two names, we ignore it. |
| |
| Args: |
| module_name: the test module name. |
| s_items: sample jars' items. |
| r_items: real jars' items. |
| msg: the message will be written into log file. |
| |
| Returns: |
| An iterator of not equal sentences after comparison. |
| """ |
| for sample in s_items: |
| if sample not in r_items: |
| lnew = sample |
| if constant.LINUX_GLIBC_COMMON in sample: |
| lnew = sample.replace(constant.LINUX_GLIBC_COMMON, |
| constant.ANDROID_COMMON) |
| else: |
| lnew = sample.replace(constant.ANDROID_COMMON, |
| constant.LINUX_GLIBC_COMMON) |
| if not lnew in r_items: |
| yield msg.format(sample, module_name) |
| |
| |
| # pylint: disable=broad-except |
| # pylint: disable=eval-used |
| @common_util.back_to_cwd |
| @common_util.time_logged |
| def _verify_aidegen(verified_file_path, forced_remove_bp_json, |
| is_presubmit=False): |
| """Verify various use cases of executing aidegen. |
| |
| There are two types of running commands: |
| 1. Use 'eval' to run the commands for present codes in aidegen_main.py, |
| such as: |
| aidegen_main.main(['tradefed', '-n', '-v']) |
| 2. Use 'subprocess.check_call' to run the commands for the binary codes of |
| aidegen such as: |
| aidegen tradefed -n -v |
| |
| Remove module_bp_java_deps.json in the beginning of running use cases. If |
| users need to remove module_bp_java_deps.json between each use case they |
| can set forced_remove_bp_json true. |
| |
| Args: |
| verified_file_path: The json file path to be verified. |
| forced_remove_bp_json: Remove module_bp_java_deps.json for each use case |
| test. |
| |
| Raises: |
| There are two type of exceptions: |
| 1. aidegen.lib.errors for projects' or modules' issues such as, |
| ProjectPathNotExistError. |
| 2. Any exceptions other than aidegen.lib.errors such as, |
| subprocess.CalledProcessError. |
| """ |
| bp_json_path = common_util.get_blueprint_json_path( |
| constant.BLUEPRINT_JAVA_JSONFILE_NAME) |
| use_eval = (verified_file_path == _VERIFY_COMMANDS_JSON) |
| try: |
| with open(verified_file_path, 'r') as jsfile: |
| data = json.load(jsfile) |
| except IOError as err: |
| raise errors.JsonFileNotExistError( |
| '%s does not exist, error: %s.' % (verified_file_path, err)) |
| |
| if not is_presubmit: |
| _compare_sample_native_content() |
| |
| os.chdir(common_util.get_android_root_dir()) |
| for use_case in data: |
| print('Use case "{}" is running.'.format(use_case)) |
| if forced_remove_bp_json and os.path.exists(bp_json_path): |
| os.remove(bp_json_path) |
| for cmd in data[use_case]: |
| print('Command "{}" is running.'.format(cmd)) |
| try: |
| if use_eval: |
| eval(cmd) |
| else: |
| subprocess.check_call(cmd, shell=True) |
| except (errors.ProjectOutsideAndroidRootError, |
| errors.ProjectPathNotExistError, |
| errors.NoModuleDefinedInModuleInfoError, |
| errors.IDENotExistError) as err: |
| print('"{}" raises error: {}.'.format(use_case, err)) |
| continue |
| except BaseException: |
| exc_type, _, _ = sys.exc_info() |
| print('"{}.{}" command {}.'.format( |
| use_case, cmd, common_util.COLORED_FAIL('executes failed'))) |
| raise BaseException( |
| 'Unexpected command "{}" exception: {}.'.format( |
| use_case, exc_type)) |
| print('"{}" command {}!'.format( |
| use_case, common_util.COLORED_PASS('test passed'))) |
| print(common_util.COLORED_PASS(_ALL_PASS)) |
| |
| |
| @common_util.back_to_cwd |
| def _make_clean(): |
| """Make a command to clean out folder for a pure environment to test. |
| |
| Raises: |
| Call subprocess.check_call to execute |
| 'build/soong/soong_ui.bash --make-mode clean' and cause |
| subprocess.CalledProcessError. |
| """ |
| try: |
| os.chdir(common_util.get_android_root_dir()) |
| subprocess.check_call( |
| ['build/soong/soong_ui.bash --make-mode clean', '-j'], |
| shell=True) |
| except subprocess.CalledProcessError: |
| print('"build/soong/soong_ui.bash --make-mode clean" command failed.') |
| raise |
| |
| |
| def _read_file_content(path): |
| """Read file's content. |
| |
| Args: |
| path: Path of input file. |
| |
| Returns: |
| A list of content strings. |
| """ |
| with open(path, encoding='utf8') as template: |
| contents = [] |
| for cnt in template: |
| if cnt.startswith('#'): |
| continue |
| contents.append(cnt.rstrip()) |
| return contents |
| |
| |
| # pylint: disable=protected-access |
| def _compare_sample_native_content(): |
| """Compares 'libui' sample module's project file. |
| |
| Compares 'libui' sample module's project file generated by AIDEGen with that |
| generated by the soong build system. Check if their contents are the same. |
| There should be only one different: |
| ${config.X86_64GccRoot} # in the soong build sytem |
| becomes |
| prebuilts/gcc/linux-x86/x86/x86_64-linux-android-4.9 # in AIDEGen |
| """ |
| target_arch_variant = 'x86_64' |
| env_on = { |
| 'TARGET_PRODUCT': 'aosp_x86_64', |
| 'TARGET_BUILD_VARIANT': 'eng', |
| 'TARGET_ARCH_VARIANT': target_arch_variant, |
| 'SOONG_COLLECT_JAVA_DEPS': 'true', |
| 'SOONG_GEN_CMAKEFILES': '1', |
| 'SOONG_COLLECT_CC_DEPS': '1' |
| } |
| |
| try: |
| project_config.ProjectConfig( |
| aidegen_main._parse_args(['-n', '-v'])).init_environment() |
| module_info_util.generate_merged_module_info(env_on) |
| cc_path = os.path.join(common_util.get_soong_out_path(), |
| constant.BLUEPRINT_CC_JSONFILE_NAME) |
| mod_name = 'libui' |
| mod_info = common_util.get_json_dict(cc_path)['modules'][mod_name] |
| if mod_info: |
| clion_project_file_gen.CLionProjectFileGenerator( |
| mod_info).generate_cmakelists_file() |
| out_dir = os.path.join(common_util.get_android_root_dir(), |
| common_util.get_android_out_dir(), |
| constant.RELATIVE_NATIVE_PATH, |
| mod_info['path'][0]) |
| content1 = _read_file_content(os.path.join( |
| out_dir, mod_name, constant.CLION_PROJECT_FILE_NAME)) |
| cc_file_name = ''.join( |
| [mod_name, '-', target_arch_variant, '-android']) |
| cc_file_path = os.path.join( |
| out_dir, cc_file_name, constant.CLION_PROJECT_FILE_NAME) |
| content2 = _read_file_content(cc_file_path) |
| same = True |
| for lino, (cnt1, cnt2) in enumerate( |
| zip(content1, content2), start=1): |
| if _BE_REPLACED in cnt2: |
| cnt2 = cnt2.replace(_BE_REPLACED, _TO_REPLACE) |
| if cnt1 != cnt2: |
| print('Contents {} and {} are different in line:{}.'.format( |
| cnt1, cnt2, lino)) |
| same = False |
| if same: |
| print('Files {} and {} are the same.'.format( |
| mod_name, cc_file_name)) |
| except errors.BuildFailureError: |
| print('Compare native content failed.') |
| |
| |
| def main(argv): |
| """Main entry. |
| |
| 1. Create the iml file data of each module in module-info.json and write it |
| into single_module.json. |
| 2. Verify every use case of AIDEGen. |
| 3. Compare all or some iml project files' data to the data recorded in |
| single_module.json. |
| |
| Args: |
| argv: A list of system arguments. |
| """ |
| args = _parse_args(argv) |
| common_util.configure_logging(args.verbose) |
| os.environ[constant.AIDEGEN_TEST_MODE] = 'true' |
| |
| if args.make_clean: |
| _make_clean() |
| |
| if args.create_sample: |
| _create_some_sample_json_file(args.targets) |
| elif args.use_cases_verified: |
| _verify_aidegen(_VERIFY_COMMANDS_JSON, args.remove_bp_json) |
| elif args.binary_upload_verified: |
| _verify_aidegen(_VERIFY_BINARY_JSON, args.remove_bp_json) |
| elif args.binary_presubmit_verified: |
| _verify_aidegen(_VERIFY_PRESUBMIT_JSON, args.remove_bp_json, True) |
| elif args.test_all_samples: |
| _test_all_samples_iml() |
| elif args.compare_sample_native: |
| _compare_sample_native_content() |
| else: |
| if not args.targets[0]: |
| _test_some_sample_iml() |
| else: |
| _test_some_sample_iml(args.targets) |
| |
| del os.environ[constant.AIDEGEN_TEST_MODE] |
| |
| |
| if __name__ == '__main__': |
| main(sys.argv[1:]) |
