xref: /aosp_15_r20/tools/asuite/aidegen/lib/ide_util_unittest.py (revision c2e18aaa1096c836b086f94603d04f4eb9cf37f5)

#!/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.


"""Unittests for ide_util."""

import os
import shutil
import subprocess
import tempfile
import unittest

from unittest import mock
from xml.etree import ElementTree

from aidegen import aidegen_main
from aidegen import unittest_constants
from aidegen.lib import android_dev_os
from aidegen.lib import common_util
from aidegen.lib import config
from aidegen.lib import errors
from aidegen.lib import ide_common_util
from aidegen.lib import ide_util
from aidegen.lib import project_config
from aidegen.lib import project_file_gen
from aidegen.sdk import jdk_table


# pylint: disable=protected-access
# pylint: disable-msg=too-many-arguments
# pylint: disable-msg=unused-argument
class IdeUtilUnittests(unittest.TestCase):
    """Unit tests for ide_util.py."""

    _TEST_PRJ_PATH1 = ''
    _TEST_PRJ_PATH2 = ''
    _TEST_PRJ_PATH3 = ''
    _TEST_PRJ_PATH4 = ''
    _MODULE_XML_SAMPLE = ''
    _TEST_DIR = None
    _TEST_XML_CONTENT = """\
<application>
  <component name="FileTypeManager" version="17">
    <extensionMap>
      <mapping ext="pi" type="Python"/>
    </extensionMap>
  </component>
</application>"""
    _TEST_XML_CONTENT_2 = """\
<application>
  <component name="FileTypeManager" version="17">
    <extensionMap>
      <mapping ext="pi" type="Python"/>
      <mapping pattern="test" type="a"/>
      <mapping pattern="TEST_MAPPING" type="a"/>
    </extensionMap>
  </component>
</application>"""

    def setUp(self):
        """Prepare the testdata related path."""
        IdeUtilUnittests._TEST_PRJ_PATH1 = os.path.join(
            unittest_constants.TEST_DATA_PATH, 'android_facet.iml')
        IdeUtilUnittests._TEST_PRJ_PATH2 = os.path.join(
            unittest_constants.TEST_DATA_PATH, 'project/test.java')
        IdeUtilUnittests._TEST_PRJ_PATH3 = unittest_constants.TEST_DATA_PATH
        IdeUtilUnittests._TEST_PRJ_PATH4 = os.path.join(
            unittest_constants.TEST_DATA_PATH, '.idea')
        IdeUtilUnittests._MODULE_XML_SAMPLE = os.path.join(
            unittest_constants.TEST_DATA_PATH, 'modules.xml')
        IdeUtilUnittests._TEST_DIR = tempfile.mkdtemp()

    def tearDown(self):
        """Clear the testdata related path."""
        IdeUtilUnittests._TEST_PRJ_PATH1 = ''
        IdeUtilUnittests._TEST_PRJ_PATH2 = ''
        IdeUtilUnittests._TEST_PRJ_PATH3 = ''
        IdeUtilUnittests._TEST_PRJ_PATH4 = ''
        shutil.rmtree(IdeUtilUnittests._TEST_DIR)

    @unittest.skip('Skip to use real command to launch IDEA.')
    def test_run_intellij_sh_in_linux(self):
        """Follow the target behavior, with sh to show UI, else raise err."""
        sh_path = ide_util.IdeLinuxIntelliJ()._get_script_from_system()
        if sh_path:
            ide_util_obj = ide_util.IdeUtil()
            ide_util_obj.config_ide(IdeUtilUnittests._TEST_PRJ_PATH1)
            ide_util_obj.launch_ide()
        else:
            self.assertRaises(subprocess.CalledProcessError)

    @mock.patch.object(ide_util, '_get_linux_ide')
    @mock.patch.object(ide_util, '_get_mac_ide')
    def test_get_ide(self, mock_mac, mock_linux):
        """Test if _get_ide calls the correct respective functions."""
        ide_util._get_ide(None, 'j', False, is_mac=True)
        self.assertTrue(mock_mac.called)
        ide_util._get_ide(None, 'j', False, is_mac=False)
        self.assertTrue(mock_linux.called)

    @mock.patch.object(ide_util.IdeBase, '_get_user_preference')
    @mock.patch.object(config.AidegenConfig, 'set_preferred_version')
    @mock.patch.object(ide_util.IdeEclipse, '_get_script_from_system')
    @mock.patch.object(ide_util.IdeIntelliJ, '_get_preferred_version')
    def test_get_mac_and_linux_ide(self, mock_preference, mock_path, mock_cfg,
                                   mock_version):
        """Test if _get_mac_ide and _get_linux_ide return correct IDE class."""
        mock_preference.return_value = None
        mock_path.return_value = 'path'
        mock_cfg.return_value = None
        mock_version.return_value = 'default'
        self.assertIsInstance(ide_util._get_mac_ide(), ide_util.IdeMacIntelliJ)
        self.assertIsInstance(ide_util._get_mac_ide(None, 's'),
                              ide_util.IdeMacStudio)
        self.assertIsInstance(ide_util._get_mac_ide(None, 'e'),
                              ide_util.IdeMacEclipse)

        self.assertIsInstance(ide_util._get_mac_ide(None, 'c'),
                              ide_util.IdeMacCLion)
        self.assertIsInstance(ide_util._get_linux_ide(),
                              ide_util.IdeLinuxIntelliJ)
        self.assertIsInstance(
            ide_util._get_linux_ide(None, 's'), ide_util.IdeLinuxStudio)
        self.assertIsInstance(
            ide_util._get_linux_ide(None, 'e'), ide_util.IdeLinuxEclipse)
        self.assertIsInstance(
            ide_util._get_linux_ide(None, 'c'), ide_util.IdeLinuxCLion)

    @mock.patch.object(ide_util.IdeIntelliJ, '_set_installed_path')
    @mock.patch.object(ide_common_util, 'get_script_from_input_path')
    @mock.patch.object(ide_util.IdeIntelliJ, '_get_script_from_system')
    def test_init_ideintellij(self, mock_sys, mock_input, mock_set):
        """Test IdeIntelliJ's __init__ method."""
        ide_util.IdeLinuxIntelliJ()
        self.assertTrue(mock_sys.called)
        ide_util.IdeMacIntelliJ()
        self.assertTrue(mock_sys.called)
        ide_util.IdeLinuxIntelliJ('some_path')
        self.assertTrue(mock_input.called)
        self.assertTrue(mock_set.called)
        ide_util.IdeMacIntelliJ('some_path')
        self.assertTrue(mock_input.called)
        self.assertTrue(mock_set.called)

    @mock.patch.object(ide_util.IdeIntelliJ, '_get_preferred_version')
    @mock.patch.object(ide_util.IdeIntelliJ, '_get_config_root_paths')
    @mock.patch.object(ide_util.IdeBase, 'apply_optional_config')
    def test_config_ide(self, mock_config, mock_paths, mock_preference):
        """Test IDEA, IdeUtil.config_ide won't call base none implement api."""
        # Mock SDkConfig flow to not generate real jdk config file.
        mock_preference.return_value = None
        module_path = os.path.join(self._TEST_DIR, 'test')
        idea_path = os.path.join(module_path, '.idea')
        os.makedirs(idea_path)
        shutil.copy(IdeUtilUnittests._MODULE_XML_SAMPLE, idea_path)
        util_obj = ide_util.IdeUtil()
        util_obj.config_ide(module_path)
        self.assertFalse(mock_config.called)
        self.assertFalse(mock_paths.called)

    @mock.patch.object(ide_util.IdeIntelliJ, '_setup_ide')
    @mock.patch.object(config.AidegenConfig, 'set_preferred_version')
    @mock.patch.object(os.path, 'isfile')
    @mock.patch.object(os.path, 'realpath')
    @mock.patch.object(ide_common_util, 'get_script_from_input_path')
    @mock.patch.object(ide_common_util, 'get_script_from_internal_path')
    def test_get_linux_config_1(self, mock_path, mock_path2, mock_path3,
                                mock_is_file, mock_cfg, mock_setup_ide):
        """Test to get unique config path for linux IDEA case."""
        if (not android_dev_os.AndroidDevOS.MAC ==
                android_dev_os.AndroidDevOS.get_os_type()):
            mock_path.return_value = ['/opt/intellij-ce-2018.3/bin/idea.sh']
            mock_path2.return_value = ['/opt/intellij-ce-2018.3/bin/idea.sh']
            mock_path3.return_value = '/opt/intellij-ce-2018.3/bin/idea.sh'
            mock_is_file.return_value = True
            mock_cfg.return_value = None
            mock_setup_ide.return_value = None
            ide_obj = ide_util.IdeLinuxIntelliJ('default_path')
            self.assertEqual(1, len(ide_obj._get_config_root_paths()))
        else:
            self.assertTrue((android_dev_os.AndroidDevOS.MAC ==
                             android_dev_os.AndroidDevOS.get_os_type()))

    @mock.patch.object(config.AidegenConfig, 'set_preferred_version')
    @mock.patch('glob.glob')
    @mock.patch.object(ide_common_util, 'get_script_from_input_path')
    @mock.patch.object(ide_common_util, 'get_script_from_internal_path')
    def test_get_linux_config_2(self, mock_path, mock_path_2, mock_filter,
                                mock_cfg):
        """Test to get unique config path for linux IDEA case."""
        if (not android_dev_os.AndroidDevOS.MAC ==
                android_dev_os.AndroidDevOS.get_os_type()):
            mock_path.return_value = ['/opt/intelliJ-ce-2018.3/bin/idea.sh']
            mock_path_2.return_value = ['/opt/intelliJ-ce-2018.3/bin/idea.sh']
            mock_cfg.return_value = None
            ide_obj = ide_util.IdeLinuxIntelliJ()
            mock_filter.called = False
            ide_obj._get_config_root_paths()
            self.assertFalse(mock_filter.called)
        else:
            self.assertTrue((android_dev_os.AndroidDevOS.MAC ==
                             android_dev_os.AndroidDevOS.get_os_type()))

    def test_get_mac_config_root_paths(self):
        """Return None if there's no install path."""
        if (android_dev_os.AndroidDevOS.MAC ==
                android_dev_os.AndroidDevOS.get_os_type()):
            mac_ide = ide_util.IdeMacIntelliJ()
            mac_ide._installed_path = None
            self.assertIsNone(mac_ide._get_config_root_paths())
        else:
            self.assertFalse((android_dev_os.AndroidDevOS.MAC ==
                              android_dev_os.AndroidDevOS.get_os_type()))

    @mock.patch.object(config.AidegenConfig, 'set_preferred_version')
    @mock.patch('glob.glob')
    @mock.patch.object(ide_common_util, 'get_script_from_input_path')
    @mock.patch.object(ide_common_util, 'get_script_from_internal_path')
    def test_get_linux_config_root(self, mock_path_1, mock_path_2, mock_filter,
                                   mock_cfg):
        """Test to go filter logic for self download case."""
        mock_path_1.return_value = ['/usr/tester/IDEA/IC2018.3.3/bin']
        mock_path_2.return_value = ['/usr/tester/IDEA/IC2018.3.3/bin']
        mock_cfg.return_value = None
        ide_obj = ide_util.IdeLinuxIntelliJ()
        mock_filter.reset()
        ide_obj._get_config_root_paths()
        self.assertTrue(mock_filter.called)

    @mock.patch.object(ide_util.IdeBase, '_add_test_mapping_file_type')
    @mock.patch.object(config.IdeaProperties, 'set_max_file_size')
    @mock.patch.object(project_file_gen, 'gen_enable_debugger_module')
    @mock.patch.object(jdk_table.JDKTableXML, 'config_jdk_table_xml')
    @mock.patch.object(ide_util.IdeBase, '_get_config_root_paths')
    def test_apply_optional_config(self, mock_path, mock_config_xml,
                                   mock_gen_debugger, mock_set_size,
                                   mock_test_mapping):
        """Test basic logic of apply_optional_config."""
        ide = ide_util.IdeBase()
        ide._installed_path = None
        ide.apply_optional_config()
        self.assertFalse(mock_path.called)
        ide._installed_path = 'default_path'
        ide.apply_optional_config()
        self.assertTrue(mock_path.called)
        mock_path.return_value = []
        ide.apply_optional_config()
        self.assertFalse(mock_config_xml.called)
        mock_path.return_value = ['a']
        mock_config_xml.return_value = False
        ide.apply_optional_config()
        self.assertFalse(mock_gen_debugger.called)
        self.assertTrue(mock_set_size.called)
        mock_config_xml.return_value = True
        ide.apply_optional_config()
        self.assertEqual(ide.config_folders, ['a'])
        self.assertTrue(mock_gen_debugger.called)
        self.assertTrue(mock_set_size.called)

    @mock.patch('os.path.isfile')
    @mock.patch.object(ElementTree.ElementTree, 'write')
    @mock.patch.object(common_util, 'to_pretty_xml')
    @mock.patch.object(common_util, 'file_generate')
    @mock.patch.object(ElementTree, 'parse')
    @mock.patch.object(ElementTree.ElementTree, 'getroot')
    def test_add_test_mapping_file_type(self, mock_root, mock_parse,
                                        mock_file_gen, mock_pretty_xml,
                                        mock_write, mock_isfile):
        """Test basic logic of _add_test_mapping_file_type."""
        mock_isfile.return_value = False
        self.assertFalse(mock_file_gen.called)

        mock_isfile.return_value = True
        mock_parse.return_value = None
        self.assertFalse(mock_file_gen.called)

        mock_parse.return_value = ElementTree.ElementTree()
        mock_root.return_value = ElementTree.fromstring(
            self._TEST_XML_CONTENT_2)
        ide_obj = ide_util.IdeBase()
        ide_obj._add_test_mapping_file_type('')
        self.assertFalse(mock_file_gen.called)
        mock_root.return_value = ElementTree.fromstring(self._TEST_XML_CONTENT)
        ide_obj._add_test_mapping_file_type('')
        self.assertTrue(mock_pretty_xml.called)
        self.assertTrue(mock_file_gen.called)

    @mock.patch('os.path.realpath')
    @mock.patch('os.path.isfile')
    def test_merge_symbolic_version(self, mock_isfile, mock_realpath):
        """Test _merge_symbolic_version and _get_real_path."""
        symbolic_path = ide_util.IdeLinuxIntelliJ._SYMBOLIC_VERSIONS[0]
        original_path = 'intellij-ce-2019.1/bin/idea.sh'
        mock_isfile.return_value = True
        mock_realpath.return_value = original_path
        ide_obj = ide_util.IdeLinuxIntelliJ('default_path')
        merged_version = ide_obj._merge_symbolic_version(
            [symbolic_path, original_path])
        self.assertEqual(
            merged_version[0], symbolic_path + ' -> ' + original_path)
        self.assertEqual(
            ide_obj._get_real_path(merged_version[0]), symbolic_path)

    @mock.patch.object(config.AidegenConfig, 'set_preferred_version')
    @mock.patch('os.path.isfile')
    def test_get_application_path(self, mock_isfile, mock_cfg):
        """Test _get_application_path."""
        mock_cfg.return_value = None
        ide_obj = ide_util.IdeLinuxIntelliJ('default_path')
        mock_isfile.return_value = True
        test_path = None
        self.assertEqual(None, ide_obj._get_application_path(test_path))

        test_path = 'a/b/c/d-e/f-gh/foo'
        self.assertEqual(None, ide_obj._get_application_path(test_path))

        test_path = 'a/b/c/d/intellij/foo'
        self.assertEqual(None, ide_obj._get_application_path(test_path))

        test_path = 'a/b/c/d/intellij-efg/foo'
        self.assertEqual(None, ide_obj._get_application_path(test_path))

        test_path = 'a/b/c/d/intellij-efg-hi/foo'
        self.assertEqual(None, ide_obj._get_application_path(test_path))

        test_path = 'a/b/c/d/intellij-ce-303/foo'
        self.assertEqual('.IdeaIC303', ide_obj._get_application_path(test_path))

        test_path = 'a/b/c/d/intellij-ue-303/foo'
        self.assertEqual('.IntelliJIdea303', ide_obj._get_application_path(
            test_path))

    def test_get_ide_util_instance_with_no_launch(self):
        """Test _get_ide_util_instance with no launch IDE."""
        args = aidegen_main._parse_args(['tradefed', '-n'])
        project_config.ProjectConfig(args)
        self.assertEqual(ide_util.get_ide_util_instance(args), None)

    @mock.patch.object(config.AidegenConfig, 'set_preferred_version')
    @mock.patch.object(ide_util.IdeIntelliJ, '_get_preferred_version')
    def test_get_ide_util_instance_with_success(self, mock_preference,
                                                mock_cfg_write):
        """Test _get_ide_util_instance with success."""
        args = aidegen_main._parse_args(['tradefed'])
        project_config.ProjectConfig(args)
        mock_cfg_write.return_value = None
        mock_preference.return_value = '1'
        self.assertIsInstance(
            ide_util.get_ide_util_instance(), ide_util.IdeUtil)

    @mock.patch.object(config.AidegenConfig, 'set_preferred_version')
    @mock.patch.object(ide_util.IdeIntelliJ, '_get_preferred_version')
    @mock.patch.object(ide_util.IdeUtil, 'is_ide_installed')
    def test_get_ide_util_instance_with_failure(
            self, mock_installed, mock_preference, mock_cfg_write):
        """Test _get_ide_util_instance with failure."""
        args = aidegen_main._parse_args(['tradefed'])
        project_config.ProjectConfig(args)
        mock_installed.return_value = False
        mock_cfg_write.return_value = None
        mock_preference.return_value = '1'
        with self.assertRaises(errors.IDENotExistError):
            ide_util.get_ide_util_instance()

    @mock.patch.object(ide_common_util, 'get_scripts_from_dir_path')
    @mock.patch.object(ide_common_util, '_run_ide_sh')
    @mock.patch('logging.info')
    def test_ide_base(self, mock_log, mock_run_ide, mock_run_path):
        """Test ide_base class."""
        # Test raise NotImplementedError.
        ide_base = ide_util.IdeBase()
        with self.assertRaises(NotImplementedError):
            ide_base._get_config_root_paths()

        # Test ide_name.
        ide_base._ide_name = 'a'
        self.assertEqual(ide_base.ide_name, 'a')

        # Test _get_ide_cmd.
        ide_base._installed_path = '/a/b'
        ide_base.project_abspath = '/x/y'
        expected_result = 'nohup /a/b /x/y 2>/dev/null >&2 &'
        self.assertEqual(ide_base._get_ide_cmd(), expected_result)

        # Test launch_ide.
        mock_run_ide.return_value = True
        ide_base.launch_ide()
        self.assertTrue(mock_log.called)

        # Test _get_ide_from_environment_paths.
        mock_run_path.return_value = '/a/b/idea.sh'
        ide_base._bin_file_name = 'idea.sh'
        expected_path = '/a/b/idea.sh'
        ide_path = ide_base._get_ide_from_environment_paths()
        self.assertEqual(ide_path, expected_path)

    def test_ide_intellij(self):
        """Test IdeIntelliJ class."""
        # Test raise NotImplementedError.
        ide_intellij = ide_util.IdeIntelliJ()
        with self.assertRaises(NotImplementedError):
            ide_intellij._get_config_root_paths()

    @mock.patch.object(config.AidegenConfig, 'set_preferred_version')
    @mock.patch.object(config.AidegenConfig, 'preferred_version')
    @mock.patch.object(ide_common_util, 'ask_preference')
    @mock.patch.object(config.AidegenConfig, 'deprecated_intellij_version')
    @mock.patch.object(ide_util.IdeIntelliJ, '_get_all_versions')
    def test_intellij_get_preferred_version(self,
                                            mock_all_versions,
                                            mock_deprecated_version,
                                            mock_ask_preference,
                                            mock_preference,
                                            mock_write_cfg):
        """Test _get_preferred_version for IdeIntelliJ class."""
        mock_write_cfg.return_value = None
        ide_intellij = ide_util.IdeIntelliJ()

        # No IntelliJ version is installed.
        mock_all_versions.return_value = ['/a/b', '/a/c']
        mock_deprecated_version.return_value = True
        version = ide_intellij._get_preferred_version()
        self.assertEqual(version, None)

        # Load default preferred version.
        mock_all_versions.return_value = ['/a/b', '/a/c']
        mock_deprecated_version.return_value = False
        ide_intellij._config_reset = False
        expected_result = '/a/b'
        mock_preference.return_value = '/a/b'
        version = ide_intellij._get_preferred_version()
        self.assertEqual(version, expected_result)

        # Asking user the preferred version.
        mock_preference.reset()
        mock_all_versions.return_value = ['/a/b', '/a/c']
        mock_deprecated_version.return_value = False
        ide_intellij._config_reset = True
        mock_ask_preference.return_value = '/a/b'
        version = ide_intellij._get_preferred_version()
        expected_result = '/a/b'
        self.assertEqual(version, expected_result)

        mock_all_versions.return_value = ['/a/b', '/a/c']
        mock_ask_preference.return_value = None
        expected_result = '/a/b'
        mock_preference.return_value = '/a/b'
        version = ide_intellij._get_preferred_version()
        self.assertEqual(version, expected_result)

        # The all_versions list has only one version.
        mock_all_versions.return_value = ['/a/b']
        mock_deprecated_version.return_value = False
        version = ide_intellij._get_preferred_version()
        self.assertEqual(version, '/a/b')

    @mock.patch.object(ide_util.IdeBase, '_add_test_mapping_file_type')
    @mock.patch.object(ide_common_util, 'ask_preference')
    @mock.patch.object(config.IdeaProperties, 'set_max_file_size')
    @mock.patch.object(project_file_gen, 'gen_enable_debugger_module')
    @mock.patch.object(ide_util.IdeStudio, '_get_config_root_paths')
    def test_android_studio_class(self, mock_get_config_paths,
                                  mock_gen_debugger, mock_set_size, mock_ask,
                                  mock_add_file_type):
        """Test IdeStudio."""
        mock_get_config_paths.return_value = ['path1', 'path2']
        mock_gen_debugger.return_value = True
        mock_set_size.return_value = True
        mock_ask.return_value = None
        obj = ide_util.IdeStudio()
        obj._installed_path = False
        # Test the native IDE case.
        obj.project_abspath = os.path.realpath(__file__)
        obj.apply_optional_config()
        self.assertEqual(obj.config_folders, [])

        # Test the java IDE case.
        obj.project_abspath = IdeUtilUnittests._TEST_DIR
        obj.apply_optional_config()
        self.assertEqual(obj.config_folders, [])

        mock_get_config_paths.return_value = []
        self.assertIsNone(obj.apply_optional_config())

    @mock.patch.object(ide_common_util, 'ask_preference')
    def test_studio_get_config_root_paths(self, mock_ask):
        """Test the method _get_config_root_paths of IdeStudio."""
        mock_ask.return_value = None
        obj = ide_util.IdeStudio()
        with self.assertRaises(NotImplementedError):
            obj._get_config_root_paths()

    @mock.patch.object(ide_util.IdeBase, 'apply_optional_config')
    @mock.patch.object(os.path, 'isdir')
    @mock.patch.object(os.path, 'isfile')
    def test_studio_optional_config_apply(self, mock_isfile, mock_isdir,
                                          mock_base_implement):
        """Test IdeStudio.apply_optional_config."""
        obj = ide_util.IdeStudio()
        obj.project_abspath = None
        # Test no project path case.
        obj.apply_optional_config()
        self.assertFalse(mock_isfile.called)
        self.assertFalse(mock_isdir.called)
        self.assertFalse(mock_base_implement.called)
        # Test the native IDE case.
        obj.project_abspath = '/'
        mock_isfile.reset_mock()
        mock_isdir.reset_mock()
        mock_base_implement.reset_mock()
        mock_isfile.return_value = True
        obj.apply_optional_config()
        self.assertTrue(mock_isfile.called)
        self.assertFalse(mock_isdir.called)
        self.assertFalse(mock_base_implement.called)
        # Test the java IDE case.
        mock_isfile.reset_mock()
        mock_isdir.reset_mock()
        mock_base_implement.reset_mock()
        mock_isfile.return_value = False
        mock_isdir.return_value = True
        obj.apply_optional_config()
        self.assertTrue(mock_base_implement.called)
        # Test neither case.
        mock_isfile.reset_mock()
        mock_isdir.reset_mock()
        mock_base_implement.reset_mock()
        mock_isfile.return_value = False
        mock_isdir.return_value = False
        obj.apply_optional_config()
        self.assertFalse(mock_base_implement.called)

    @mock.patch.object(ide_common_util, 'ask_preference')
    @mock.patch('os.getenv')
    def test_linux_android_studio_class(self, mock_get_home, mock_ask):
        """Test the method _get_config_root_paths of IdeLinuxStudio."""
        mock_get_home.return_value = self._TEST_DIR
        studio_config_dir1 = os.path.join(self._TEST_DIR, '.AndroidStudio3.0')
        studio_config_dir2 = os.path.join(self._TEST_DIR, '.AndroidStudio3.1')
        os.makedirs(studio_config_dir1)
        os.makedirs(studio_config_dir2)
        expected_result = [studio_config_dir1, studio_config_dir2]
        mock_ask.return_value = None
        obj = ide_util.IdeLinuxStudio()
        config_paths = obj._get_config_root_paths()
        self.assertEqual(sorted(config_paths), sorted(expected_result))

    @mock.patch('os.getenv')
    def test_mac_android_studio_class(self, mock_get_home):
        """Test the method _get_config_root_paths of IdeMacStudio."""
        mock_get_home.return_value = self._TEST_DIR
        studio_config_dir1 = os.path.join(self._TEST_DIR, 'Library',
                                          'Preferences', 'AndroidStudio3.0')
        studio_config_dir2 = os.path.join(self._TEST_DIR, 'Library',
                                          'Preferences', 'AndroidStudio3.1')
        os.makedirs(studio_config_dir1)
        os.makedirs(studio_config_dir2)
        expected_result = [studio_config_dir1, studio_config_dir2]

        obj = ide_util.IdeMacStudio()
        config_paths = obj._get_config_root_paths()
        self.assertEqual(sorted(config_paths), sorted(expected_result))

    @mock.patch('os.access')
    @mock.patch('glob.glob')
    def test_eclipse_get_script_from_system(self, mock_glob, mock_file_access):
        """Test IdeEclipse _get_script_from_system method."""
        eclipse = ide_util.IdeEclipse()

        # Test no binary path in _get_script_from_system.
        eclipse._bin_paths = []
        expected_result = None
        test_result = eclipse._get_script_from_system()
        self.assertEqual(test_result, expected_result)

        # Test get the matched binary from _get_script_from_system.
        mock_glob.return_value = ['/a/b/eclipse']
        mock_file_access.return_value = True
        eclipse._bin_paths = ['/a/b/eclipse']
        expected_result = '/a/b/eclipse'
        test_result = eclipse._get_script_from_system()
        self.assertEqual(test_result, expected_result)

        # Test no matched binary from _get_script_from_system.
        mock_glob.return_value = []
        eclipse._bin_paths = ['/a/b/eclipse']
        expected_result = None
        test_result = eclipse._get_script_from_system()
        self.assertEqual(test_result, expected_result)

        # Test the matched binary cannot be executed.
        mock_glob.return_value = ['/a/b/eclipse']
        mock_file_access.return_value = False
        eclipse._bin_paths = ['/a/b/eclipse']
        expected_result = None
        test_result = eclipse._get_script_from_system()
        self.assertEqual(test_result, expected_result)

    @mock.patch('builtins.input')
    @mock.patch('os.path.exists')
    def test_eclipse_get_ide_cmd(self, mock_exists, mock_input):
        """Test IdeEclipse _get_ide_cmd method."""
        # Test open the IDE with the default Eclipse workspace.
        eclipse = ide_util.IdeEclipse()
        eclipse.cmd = ['eclipse']
        mock_exists.return_value = True
        expected_result = ('eclipse -data '
                           '~/Documents/AIDEGen_Eclipse_workspace '
                           '2>/dev/null >&2 &')
        test_result = eclipse._get_ide_cmd()
        self.assertEqual(test_result, expected_result)

        # Test running command without the default workspace.
        eclipse.cmd = ['eclipse']
        mock_exists.return_value = False
        mock_input.return_value = 'n'
        expected_result = 'eclipse 2>/dev/null >&2 &'
        test_result = eclipse._get_ide_cmd()
        self.assertEqual(test_result, expected_result)

    @mock.patch.object(ide_util.IdeUtil, 'is_ide_installed')
    @mock.patch.object(project_config.ProjectConfig, 'get_instance')
    def test_get_ide_util_instance(self, mock_config, mock_ide_installed):
        """Test get_ide_util_instance."""
        # Test is_launch_ide conditions.
        mock_instance = mock_config.return_value
        mock_instance.is_launch_ide = False
        ide_util.get_ide_util_instance()
        self.assertFalse(mock_ide_installed.called)
        mock_instance.is_launch_ide = True
        ide_util.get_ide_util_instance()
        self.assertTrue(mock_ide_installed.called)

        # Test ide is not installed.
        mock_ide_installed.return_value = False
        with self.assertRaises(errors.IDENotExistError):
            ide_util.get_ide_util_instance()

    @mock.patch.object(ide_util.IdeLinuxVSCode, '_init_installed_path')
    @mock.patch.object(ide_util.IdeLinuxVSCode, '_get_possible_bin_paths')
    def test_ide_linux_vscode(self, mock_get_pos, mock_init_inst):
        """Test IdeLinuxVSCode class."""
        ide_util.IdeLinuxVSCode()
        self.assertTrue(mock_get_pos.called)
        self.assertTrue(mock_init_inst.called)

    @mock.patch.object(ide_util.IdeMacVSCode, '_init_installed_path')
    @mock.patch.object(ide_util.IdeMacVSCode, '_get_possible_bin_paths')
    def test_ide_mac_vscode(self, mock_get_pos, mock_init_inst):
        """Test IdeMacVSCode class."""
        ide_util.IdeMacVSCode()
        self.assertTrue(mock_get_pos.called)
        self.assertTrue(mock_init_inst.called)

    def test_get_all_versions(self):
        """Test _get_all_versions."""
        ide = ide_util.IdeIntelliJ()
        test_result = ide._get_all_versions('a', 'b')
        self.assertEqual(test_result, ['a', 'b'])

    @mock.patch('logging.warning')
    def test_get_ide_version(self, mock_warn):
        """Test _get_ide_version with conditions."""
        self.assertEqual(
            None, ide_util.IdeIntelliJ._get_ide_version('intellij-efg-hi'))
        self.assertTrue(mock_warn.called)
        mock_warn.reset_mock()
        self.assertEqual(
            '2020.1',
            ide_util.IdeIntelliJ._get_ide_version('intellij-ue-2020.1'))
        self.assertFalse(mock_warn.called)
        mock_warn.reset_mock()
        self.assertEqual(
            '303', ide_util.IdeIntelliJ._get_ide_version('intellij-ue-303'))
        self.assertFalse(mock_warn.called)

    @mock.patch('os.path.join')
    def test_get_config_dir(self, mock_join):
        """Test _get_config_dir with conditions."""
        config_folder_name = 'IntelliJ2020.1'
        ide_version = '2020.1'
        ide_util.IdeIntelliJ._get_config_dir(ide_version, config_folder_name)
        self.assertTrue(
            mock_join.called_with(
                os.getenv('HOME'), '.config', 'JetBrains', config_folder_name))
        mock_join.reset_mock()
        config_folder_name = 'IntelliJ2019.3'
        ide_version = '2019.3'
        self.assertTrue(
            mock_join.called_with(
                os.getenv('HOME'), config_folder_name, 'config'))
        mock_join.reset_mock()
        self.assertEqual(None, ide_util.IdeIntelliJ._get_config_dir(
            'Not-a-float', config_folder_name))
        self.assertFalse(mock_join.called)

    def test_get_config_folder_name(self):
        """Test _get_config_folder_name with conditions."""
        config_folder_name = 'intellij-ce-2019.3'
        pre_folder = '.IdeaIC'
        ide_version = '2019.3'
        expected = ''.join([pre_folder, ide_version])
        self.assertEqual(expected, ide_util.IdeIntelliJ._get_config_folder_name(
            config_folder_name))
        config_folder_name = 'intellij-ue-2019.3'
        pre_folder = '.IntelliJIdea'
        expected = ''.join([pre_folder, ide_version])
        self.assertEqual(expected, ide_util.IdeIntelliJ._get_config_folder_name(
            config_folder_name))
        config_folder_name = 'intellij-ce-2020.1'
        pre_folder = 'IdeaIC'
        ide_version = '2020.1'
        expected = ''.join([pre_folder, ide_version])
        self.assertEqual(expected, ide_util.IdeIntelliJ._get_config_folder_name(
            config_folder_name))
        config_folder_name = 'intellij-ue-2020.1'
        pre_folder = 'IntelliJIdea'
        expected = ''.join([pre_folder, ide_version])
        self.assertEqual(expected, ide_util.IdeIntelliJ._get_config_folder_name(
            config_folder_name))
        config_folder_name = 'intellij-ue-2020.1.4'
        self.assertEqual(expected, ide_util.IdeIntelliJ._get_config_folder_name(
            config_folder_name))
        config_folder_name = 'intellij-unknown'
        expected = None
        self.assertEqual(expected, ide_util.IdeIntelliJ._get_config_folder_name(
            config_folder_name))
        config_folder_name = 'intellij-ue-NotAFloat'
        self.assertEqual(expected, ide_util.IdeIntelliJ._get_config_folder_name(
            config_folder_name))


if __name__ == '__main__':
    unittest.main()