| #!/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 source_locator.""" |
| |
| import os |
| import shutil |
| import tempfile |
| import unittest |
| from unittest import mock |
| |
| from aidegen import constant |
| from aidegen import unittest_constants |
| from aidegen.lib import source_locator |
| |
| _MODULE_NAME = 'test' |
| _MODULE_PATH = 'packages/apps/test' |
| _MODULE_INFO = { |
| 'path': [_MODULE_PATH], |
| 'srcs': [ |
| 'packages/apps/test/src/main/java/com/android/java.java', |
| 'packages/apps/test/tests/com/android/test.java', |
| 'packages/apps/test/tests/test.srcjar' |
| ], |
| 'dependencies': [], |
| 'installed': [] |
| } |
| _MODULE_DEPTH = 0 |
| |
| |
| # pylint: disable=protected-access |
| # pylint: disable=invalid-name |
| class SourceLocatorUnittests(unittest.TestCase): |
| """Unit tests for source_locator.py""" |
| |
| @mock.patch('aidegen.lib.common_util.get_android_root_dir') |
| def test_collect_srcs_paths(self, mock_android_root_dir): |
| """Test _collect_srcs_paths create the source path list.""" |
| result_source = set(['packages/apps/test/src/main/java']) |
| result_test = set(['packages/apps/test/tests']) |
| mock_android_root_dir.return_value = unittest_constants.TEST_DATA_PATH |
| module_data = source_locator.ModuleData(_MODULE_NAME, _MODULE_INFO, |
| _MODULE_DEPTH) |
| module_data._collect_srcs_paths() |
| self.assertEqual(module_data.src_dirs, result_source) |
| self.assertEqual(module_data.test_dirs, result_test) |
| |
| def test_get_package_name(self): |
| """test get the package name from a java file.""" |
| result_package_name = 'com.android' |
| test_java = os.path.join(unittest_constants.TEST_DATA_PATH, |
| _MODULE_PATH, |
| 'src/main/java/com/android/java.java') |
| package_name = source_locator.ModuleData._get_package_name(test_java) |
| self.assertEqual(package_name, result_package_name) |
| |
| # Test on java file with no package name. |
| result_package_name = None |
| test_java = os.path.join(unittest_constants.TEST_DATA_PATH, |
| _MODULE_PATH, |
| 'src/main/java/com/android/no_package.java') |
| package_name = source_locator.ModuleData._get_package_name(test_java) |
| self.assertEqual(package_name, result_package_name) |
| |
| @mock.patch('aidegen.lib.common_util.get_android_root_dir') |
| def test_get_source_folder(self, mock_android_root_dir): |
| """Test _get_source_folder process.""" |
| # Test for getting the source path by parse package name from a java. |
| test_java = 'packages/apps/test/src/main/java/com/android/java.java' |
| result_source = 'packages/apps/test/src/main/java' |
| mock_android_root_dir.return_value = unittest_constants.TEST_DATA_PATH |
| module_data = source_locator.ModuleData(_MODULE_NAME, _MODULE_INFO, |
| _MODULE_DEPTH) |
| src_path = module_data._get_source_folder(test_java) |
| self.assertEqual(src_path, result_source) |
| |
| # Return path is None if the java file doesn't exist. |
| test_java = 'file_not_exist.java' |
| src_path = module_data._get_source_folder(test_java) |
| self.assertEqual(src_path, None) |
| |
| # Return path is None on the java file without package name. |
| test_java = ('packages/apps/test/src/main/java/com/android/' |
| 'no_package.java') |
| src_path = module_data._get_source_folder(test_java) |
| self.assertEqual(src_path, None) |
| |
| def test_get_r_dir(self): |
| """Test get_r_dir.""" |
| module_data = source_locator.ModuleData(_MODULE_NAME, _MODULE_INFO, |
| _MODULE_DEPTH) |
| # Test for aapt2.srcjar |
| test_aapt2_srcjar = 'a/aapt2.srcjar' |
| expect_result = 'a/aapt2' |
| r_dir = module_data._get_r_dir(test_aapt2_srcjar) |
| self.assertEqual(r_dir, expect_result) |
| |
| # Test for R.jar |
| test_r_jar = 'b/R.jar' |
| expect_result = 'b/aapt2/R' |
| r_dir = module_data._get_r_dir(test_r_jar) |
| self.assertEqual(r_dir, expect_result) |
| |
| # Test for the target file is not aapt2.srcjar or R.jar |
| test_unknown_target = 'c/proto.srcjar' |
| expect_result = None |
| r_dir = module_data._get_r_dir(test_unknown_target) |
| self.assertEqual(r_dir, expect_result) |
| |
| @mock.patch('aidegen.lib.common_util.get_android_root_dir') |
| def test_collect_r_src_path(self, mock_android_root_dir): |
| """Test collect_r_src_path.""" |
| # Test on target srcjar exists in srcjars. |
| test_module = dict(_MODULE_INFO) |
| test_module['srcs'] = [] |
| mock_android_root_dir.return_value = unittest_constants.TEST_DATA_PATH |
| module_data = source_locator.ModuleData(_MODULE_NAME, test_module, |
| _MODULE_DEPTH) |
| # Test the module is not APPS. |
| module_data._collect_r_srcs_paths() |
| expect_result = set() |
| self.assertEqual(module_data.r_java_paths, expect_result) |
| |
| # Test the module is not a target module. |
| test_module['depth'] = 1 |
| module_data = source_locator.ModuleData(_MODULE_NAME, test_module, 1) |
| module_data._collect_r_srcs_paths() |
| expect_result = set() |
| self.assertEqual(module_data.r_java_paths, expect_result) |
| |
| # Test the srcjar target doesn't exist. |
| test_module['class'] = ['APPS'] |
| test_module['srcjars'] = [] |
| module_data = source_locator.ModuleData(_MODULE_NAME, test_module, |
| _MODULE_DEPTH) |
| module_data._collect_r_srcs_paths() |
| expect_result = set() |
| self.assertEqual(module_data.r_java_paths, expect_result) |
| |
| # Test the srcjar target exists. |
| test_module['srcjars'] = [('out/soong/.intermediates/packages/apps/' |
| 'test_aapt2/aapt2.srcjar')] |
| module_data = source_locator.ModuleData(_MODULE_NAME, test_module, |
| _MODULE_DEPTH) |
| module_data._collect_r_srcs_paths() |
| expect_result = { |
| 'out/soong/.intermediates/packages/apps/test_aapt2/aapt2' |
| } |
| self.assertEqual(module_data.r_java_paths, expect_result) |
| |
| def test_parse_source_path(self): |
| """Test _parse_source_path.""" |
| # The package name of e.java is c.d. |
| test_java = 'a/b/c/d/e.java' |
| package_name = 'c.d' |
| expect_result = 'a/b' |
| src_path = source_locator.ModuleData._parse_source_path(test_java, |
| package_name) |
| self.assertEqual(src_path, expect_result) |
| |
| # The package name of e.java is c.d. |
| test_java = 'a/b/c.d/e.java' |
| package_name = 'c.d' |
| expect_result = 'a/b' |
| src_path = source_locator.ModuleData._parse_source_path(test_java, |
| package_name) |
| self.assertEqual(src_path, expect_result) |
| |
| # The package name of e.java is x.y. |
| test_java = 'a/b/c/d/e.java' |
| package_name = 'x.y' |
| expect_result = 'a/b/c/d' |
| src_path = source_locator.ModuleData._parse_source_path(test_java, |
| package_name) |
| self.assertEqual(src_path, expect_result) |
| |
| # The package name of f.java is c.d. |
| test_java = 'a/b/c.d/e/c/d/f.java' |
| package_name = 'c.d' |
| expect_result = 'a/b/c.d/e' |
| src_path = source_locator.ModuleData._parse_source_path(test_java, |
| package_name) |
| self.assertEqual(src_path, expect_result) |
| |
| # The package name of f.java is c.d.e. |
| test_java = 'a/b/c.d/e/c.d/e/f.java' |
| package_name = 'c.d.e' |
| expect_result = 'a/b/c.d/e' |
| src_path = source_locator.ModuleData._parse_source_path(test_java, |
| package_name) |
| self.assertEqual(src_path, expect_result) |
| |
| @mock.patch('aidegen.lib.common_util.get_android_root_dir') |
| def test_append_jar_file(self, mock_android_root_dir): |
| """Test _append_jar_file process.""" |
| # Append an existing jar file path to module_data.jar_files. |
| test_jar_file = os.path.join(_MODULE_PATH, 'test.jar') |
| result_jar_list = set([test_jar_file]) |
| mock_android_root_dir.return_value = unittest_constants.TEST_DATA_PATH |
| module_data = source_locator.ModuleData(_MODULE_NAME, _MODULE_INFO, |
| _MODULE_DEPTH) |
| module_data._append_jar_file(test_jar_file) |
| self.assertEqual(module_data.jar_files, result_jar_list) |
| |
| # Skip if the jar file doesn't exist. |
| test_jar_file = os.path.join(_MODULE_PATH, 'jar_not_exist.jar') |
| module_data.jar_files = set() |
| module_data._append_jar_file(test_jar_file) |
| self.assertEqual(module_data.jar_files, set()) |
| |
| # Skip if it's not a jar file. |
| test_jar_file = os.path.join(_MODULE_PATH, 'test.java') |
| module_data.jar_files = set() |
| module_data._append_jar_file(test_jar_file) |
| self.assertEqual(module_data.jar_files, set()) |
| |
| @mock.patch('aidegen.lib.common_util.get_android_root_dir') |
| def test_append_jar_from_installed(self, mock_android_root_dir): |
| """Test _append_jar_from_installed handling.""" |
| # Test appends the first jar file of 'installed'. |
| module_info = dict(_MODULE_INFO) |
| module_info['installed'] = [ |
| os.path.join(_MODULE_PATH, 'test.aar'), |
| os.path.join(_MODULE_PATH, 'test.jar'), |
| os.path.join(_MODULE_PATH, 'tests/test_second.jar') |
| ] |
| result_jar_list = set([os.path.join(_MODULE_PATH, 'test.jar')]) |
| mock_android_root_dir.return_value = unittest_constants.TEST_DATA_PATH |
| module_data = source_locator.ModuleData(_MODULE_NAME, module_info, |
| _MODULE_DEPTH) |
| module_data._append_jar_from_installed() |
| self.assertEqual(module_data.jar_files, result_jar_list) |
| |
| # Test on the jar file path matches the path prefix. |
| module_data.jar_files = set() |
| result_jar_list = set( |
| [os.path.join(_MODULE_PATH, 'tests/test_second.jar')]) |
| module_data._append_jar_from_installed( |
| os.path.join(_MODULE_PATH, 'tests/')) |
| self.assertEqual(module_data.jar_files, result_jar_list) |
| |
| @mock.patch('aidegen.lib.common_util.get_android_root_dir') |
| def test_set_jars_jarfile(self, mock_android_root_dir): |
| """Test _set_jars_jarfile handling.""" |
| # Combine the module path with jar file name in 'jars' and then append |
| # it to module_data.jar_files. |
| module_info = dict(_MODULE_INFO) |
| module_info['jars'] = [ |
| 'test.jar', |
| 'src/test.jar', # This jar file doesn't exist. |
| 'tests/test_second.jar' |
| ] |
| result_jar_list = set([ |
| os.path.join(_MODULE_PATH, 'test.jar'), |
| os.path.join(_MODULE_PATH, 'tests/test_second.jar') |
| ]) |
| mock_android_root_dir.return_value = unittest_constants.TEST_DATA_PATH |
| module_data = source_locator.ModuleData(_MODULE_NAME, module_info, |
| _MODULE_DEPTH) |
| module_data._set_jars_jarfile() |
| self.assertEqual(module_data.jar_files, result_jar_list) |
| |
| @mock.patch('aidegen.lib.common_util.get_android_root_dir') |
| def test_locate_sources_path(self, mock_android_root_dir): |
| """Test locate_sources_path handling.""" |
| # Test collect source path. |
| module_info = dict(_MODULE_INFO) |
| result_src_list = set(['packages/apps/test/src/main/java']) |
| result_test_list = set(['packages/apps/test/tests']) |
| result_jar_list = set() |
| result_r_path = set() |
| mock_android_root_dir.return_value = unittest_constants.TEST_DATA_PATH |
| module_data = source_locator.ModuleData(_MODULE_NAME, module_info, |
| _MODULE_DEPTH) |
| module_data.locate_sources_path() |
| self.assertEqual(module_data.src_dirs, result_src_list) |
| self.assertEqual(module_data.test_dirs, result_test_list) |
| self.assertEqual(module_data.jar_files, result_jar_list) |
| self.assertEqual(module_data.r_java_paths, result_r_path) |
| |
| # Test find jar files. |
| jar_file = ('out/soong/.intermediates/packages/apps/test/test/' |
| 'android_common/test.jar') |
| module_info['jarjar_rules'] = ['jarjar-rules.txt'] |
| module_info['installed'] = [jar_file] |
| result_jar_list = set([jar_file]) |
| module_data = source_locator.ModuleData(_MODULE_NAME, module_info, |
| _MODULE_DEPTH) |
| module_data.locate_sources_path() |
| self.assertEqual(module_data.jar_files, result_jar_list) |
| |
| # Test find jar by srcjar. |
| module_info = dict(_MODULE_INFO) |
| module_info['srcs'].extend( |
| [('out/soong/.intermediates/packages/apps/test/test/android_common/' |
| 'gen/test.srcjar')]) |
| module_info['installed'] = [ |
| ('out/soong/.intermediates/packages/apps/test/test/android_common/' |
| 'test.jar') |
| ] |
| result_jar_list = set([ |
| jar_file, |
| ('out/soong/.intermediates/packages/apps/test/test/' |
| 'android_common/test.jar') |
| ]) |
| module_data = source_locator.ModuleData(_MODULE_NAME, module_info, |
| _MODULE_DEPTH) |
| module_data.locate_sources_path() |
| self.assertEqual(module_data.jar_files, result_jar_list) |
| |
| @mock.patch('aidegen.lib.common_util.get_android_root_dir') |
| def test_collect_jar_by_depth_value(self, mock_android_root_dir): |
| """Test parameter --depth handling.""" |
| # Test find jar by module's depth greater than the --depth value from |
| # command line. |
| depth_by_source = 2 |
| module_info = dict(_MODULE_INFO) |
| module_info['depth'] = 3 |
| module_info['installed'] = [ |
| ('out/soong/.intermediates/packages/apps/test/test/android_common/' |
| 'test.jar') |
| ] |
| result_src_list = set() |
| result_jar_list = set( |
| [('out/soong/.intermediates/packages/apps/test/test/' |
| 'android_common/test.jar')]) |
| mock_android_root_dir.return_value = unittest_constants.TEST_DATA_PATH |
| module_data = source_locator.ModuleData(_MODULE_NAME, module_info, |
| depth_by_source) |
| module_data.locate_sources_path() |
| self.assertEqual(module_data.src_dirs, result_src_list) |
| self.assertEqual(module_data.jar_files, result_jar_list) |
| |
| # Test find source folder when module's depth equal to the --depth value |
| # from command line. |
| depth_by_source = 2 |
| module_info = dict(_MODULE_INFO) |
| module_info['depth'] = 2 |
| result_src_list = set(['packages/apps/test/src/main/java']) |
| result_test_list = set(['packages/apps/test/tests']) |
| result_jar_list = set() |
| result_r_path = set() |
| module_data = source_locator.ModuleData(_MODULE_NAME, module_info, |
| depth_by_source) |
| module_data.locate_sources_path() |
| self.assertEqual(module_data.src_dirs, result_src_list) |
| self.assertEqual(module_data.test_dirs, result_test_list) |
| self.assertEqual(module_data.jar_files, result_jar_list) |
| self.assertEqual(module_data.r_java_paths, result_r_path) |
| |
| # Test find source folder when module's depth smaller than the --depth |
| # value from command line. |
| depth_by_source = 3 |
| module_info = dict(_MODULE_INFO) |
| module_info['depth'] = 2 |
| result_src_list = set(['packages/apps/test/src/main/java']) |
| result_test_list = set(['packages/apps/test/tests']) |
| result_jar_list = set() |
| result_r_path = set() |
| module_data = source_locator.ModuleData(_MODULE_NAME, module_info, |
| depth_by_source) |
| module_data.locate_sources_path() |
| self.assertEqual(module_data.src_dirs, result_src_list) |
| self.assertEqual(module_data.test_dirs, result_test_list) |
| self.assertEqual(module_data.jar_files, result_jar_list) |
| self.assertEqual(module_data.r_java_paths, result_r_path) |
| |
| @mock.patch('aidegen.lib.common_util.get_android_root_dir') |
| @mock.patch('aidegen.lib.project_info.ProjectInfo') |
| @mock.patch('atest.atest_utils.build') |
| def test_locate_source(self, mock_atest_utils_build, mock_project_info, |
| mock_android_root_dir): |
| """Test locate_source handling.""" |
| mock_atest_utils_build.build.return_value = True |
| test_root_path = os.path.join(tempfile.mkdtemp(), 'test') |
| shutil.copytree(unittest_constants.TEST_DATA_PATH, test_root_path) |
| mock_android_root_dir.return_value = test_root_path |
| generated_jar = ('out/soong/.intermediates/packages/apps/test/test/' |
| 'android_common/generated.jar') |
| module_info = dict(_MODULE_INFO) |
| module_info['srcs'].extend( |
| [('out/soong/.intermediates/packages/apps/test/test/android_common/' |
| 'gen/test.srcjar')]) |
| module_info['installed'] = [generated_jar] |
| mock_project_info.dep_modules = {'test': module_info} |
| mock_project_info.source_path = { |
| 'source_folder_path': set(), |
| 'test_folder_path': set(), |
| 'jar_path': set(), |
| 'jar_module_path': dict(), |
| 'srcjar_path': set(), |
| 'r_java_path': set(), |
| } |
| # Show warning when the jar not exists after build the module. |
| result_jar = set() |
| source_locator.locate_source(mock_project_info, False, 0, |
| constant.IDE_INTELLIJ, True) |
| self.assertEqual(mock_project_info.source_path['jar_path'], result_jar) |
| |
| # Test on jar exists. |
| jar_abspath = os.path.join(test_root_path, generated_jar) |
| result_jar = set([generated_jar]) |
| result_jar_module_path = dict({generated_jar: module_info['path'][0]}) |
| try: |
| open(jar_abspath, 'w').close() |
| source_locator.locate_source(mock_project_info, False, 0, |
| constant.IDE_INTELLIJ, False) |
| self.assertEqual(mock_project_info.source_path['jar_path'], |
| result_jar) |
| self.assertEqual(mock_project_info.source_path['jar_module_path'], |
| result_jar_module_path) |
| finally: |
| shutil.rmtree(test_root_path) |
| |
| # Test collects source and test folders. |
| result_source = set(['packages/apps/test/src/main/java']) |
| result_test = set(['packages/apps/test/tests']) |
| result_r_path = set() |
| self.assertEqual(mock_project_info.source_path['source_folder_path'], |
| result_source) |
| self.assertEqual(mock_project_info.source_path['test_folder_path'], |
| result_test) |
| self.assertEqual(mock_project_info.source_path['r_java_path'], |
| result_r_path) |
| |
| # Test loading jar from dependencies parameter. |
| default_jar = os.path.join(_MODULE_PATH, 'test.jar') |
| module_info['dependencies'] = [default_jar] |
| result_jar = set([generated_jar, default_jar]) |
| source_locator.locate_source(mock_project_info, False, 0, |
| constant.IDE_INTELLIJ, False) |
| self.assertEqual(mock_project_info.source_path['jar_path'], result_jar) |
| |
| def test_separate_build_target(self): |
| """Test separate_build_target.""" |
| test_list = ['1', '22', '333', '4444', '55555', '1', '7777777'] |
| target = [] |
| sample = [['1', '22', '333'], ['4444'], ['55555', '1'], ['7777777']] |
| for start, end in iter( |
| source_locator._separate_build_targets(test_list, 9)): |
| target.append(test_list[start: end]) |
| self.assertEqual(target, sample) |
| |
| def test_collect_srcjar_path(self): |
| """Test collect srcjar path.""" |
| srcjar_path = 'a/b/aapt2.srcjar' |
| test_module = dict(_MODULE_INFO) |
| test_module['srcjars'] = [srcjar_path] |
| expacted_result = set(['%s!/' % srcjar_path]) |
| module_data = source_locator.ModuleData(_MODULE_NAME, test_module, |
| _MODULE_DEPTH) |
| module_data._collect_srcjar_path(srcjar_path) |
| self.assertEqual(module_data.srcjar_paths, expacted_result) |
| |
| |
| if __name__ == '__main__': |
| unittest.main() |
