aidegen_functional_test/aidegen_functional_test_main.py

#!/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:])