| # SPDX-License-Identifier: Apache-2.0 |
| # Copyright 2024 Meson project contributors |
| |
| from mesonbuild.options import * |
| from mesonbuild.envconfig import MachineInfo |
| |
| import os |
| import unittest |
| |
| |
| def make_machine(system: str) -> MachineInfo: |
| return MachineInfo(system, 'x86_64', 'x86_64', 'little', None, None) |
| |
| |
| def num_options(store: OptionStore) -> int: |
| return len(store.options) |
| |
| |
| class OptionTests(unittest.TestCase): |
| |
| def test_basic(self): |
| optstore = OptionStore(False) |
| name = 'someoption' |
| default_value = 'somevalue' |
| new_value = 'new_value' |
| vo = UserStringOption(name, 'An option of some sort', default_value) |
| optstore.add_system_option(name, vo) |
| self.assertEqual(optstore.get_value_for(name), default_value) |
| optstore.set_option(OptionKey.from_string(name), new_value) |
| self.assertEqual(optstore.get_value_for(name), new_value) |
| |
| def test_toplevel_project(self): |
| optstore = OptionStore(False) |
| name = 'someoption' |
| default_value = 'somevalue' |
| new_value = 'new_value' |
| k = OptionKey(name) |
| vo = UserStringOption(k.name, 'An option of some sort', default_value) |
| optstore.add_system_option(k.name, vo) |
| self.assertEqual(optstore.get_value_for(k), default_value) |
| optstore.initialize_from_top_level_project_call({OptionKey('someoption'): new_value}, {}, {}) |
| self.assertEqual(optstore.get_value_for(k), new_value) |
| |
| def test_machine_vs_project(self): |
| optstore = OptionStore(False) |
| name = 'backend' |
| default_value = 'ninja' |
| proj_value = 'xcode' |
| mfile_value = 'vs2010' |
| k = OptionKey(name) |
| prefix = UserStringOption('prefix', 'This is needed by OptionStore', '/usr') |
| optstore.add_system_option('prefix', prefix) |
| vo = UserStringOption(k.name, 'You know what this is', default_value) |
| optstore.add_system_option(k.name, vo) |
| self.assertEqual(optstore.get_value_for(k), default_value) |
| optstore.initialize_from_top_level_project_call({OptionKey(name): proj_value}, {}, |
| {OptionKey(name): mfile_value}) |
| self.assertEqual(optstore.get_value_for(k), mfile_value) |
| |
| def test_subproject_system_option(self): |
| """Test that subproject system options get their default value from the global |
| option (e.g. "sub:b_lto" can be initialized from "b_lto").""" |
| optstore = OptionStore(False) |
| name = 'b_lto' |
| default_value = 'false' |
| new_value = 'true' |
| k = OptionKey(name) |
| subk = k.evolve(subproject='sub') |
| optstore.initialize_from_top_level_project_call({}, {}, {OptionKey(name): new_value}) |
| vo = UserStringOption(k.name, 'An option of some sort', default_value) |
| optstore.add_system_option(subk, vo) |
| self.assertEqual(optstore.get_value_for(subk), new_value) |
| |
| def test_parsing(self): |
| with self.subTest('subproject'): |
| s1 = OptionKey.from_string('sub:optname') |
| s1_expected = OptionKey('optname', 'sub', MachineChoice.HOST) |
| self.assertEqual(s1, s1_expected) |
| self.assertEqual(str(s1), 'sub:optname') |
| |
| with self.subTest('plain name'): |
| s2 = OptionKey.from_string('optname') |
| s2_expected = OptionKey('optname', None, MachineChoice.HOST) |
| self.assertEqual(s2, s2_expected) |
| self.assertEqual(str(s2), 'optname') |
| |
| with self.subTest('root project'): |
| s3 = OptionKey.from_string(':optname') |
| s3_expected = OptionKey('optname', '', MachineChoice.HOST) |
| self.assertEqual(s3, s3_expected) |
| self.assertEqual(str(s3), ':optname') |
| |
| def test_subproject_for_system(self): |
| optstore = OptionStore(False) |
| name = 'someoption' |
| default_value = 'somevalue' |
| vo = UserStringOption(name, 'An option of some sort', default_value) |
| optstore.add_system_option(name, vo) |
| self.assertEqual(optstore.get_value_for(name, 'somesubproject'), default_value) |
| |
| def test_reset(self): |
| optstore = OptionStore(False) |
| name = 'someoption' |
| original_value = 'original' |
| reset_value = 'reset' |
| vo = UserStringOption(name, 'An option set twice', original_value) |
| optstore.add_system_option(name, vo) |
| self.assertEqual(optstore.get_value_for(name), original_value) |
| self.assertEqual(num_options(optstore), 1) |
| vo2 = UserStringOption(name, 'An option set twice', reset_value) |
| optstore.add_system_option(name, vo2) |
| self.assertEqual(optstore.get_value_for(name), original_value) |
| self.assertEqual(num_options(optstore), 1) |
| |
| def test_project_nonyielding(self): |
| optstore = OptionStore(False) |
| name = 'someoption' |
| top_value = 'top' |
| sub_value = 'sub' |
| vo = UserStringOption(name, 'A top level option', top_value, False) |
| optstore.add_project_option(OptionKey(name, ''), vo) |
| self.assertEqual(optstore.get_value_for(name, ''), top_value, False) |
| self.assertEqual(num_options(optstore), 1) |
| vo2 = UserStringOption(name, 'A subproject option', sub_value) |
| optstore.add_project_option(OptionKey(name, 'sub'), vo2) |
| self.assertEqual(optstore.get_value_for(name, ''), top_value) |
| self.assertEqual(optstore.get_value_for(name, 'sub'), sub_value) |
| self.assertEqual(num_options(optstore), 2) |
| |
| def test_toplevel_project_yielding(self): |
| optstore = OptionStore(False) |
| name = 'someoption' |
| top_value = 'top' |
| vo = UserStringOption(name, 'A top level option', top_value, True) |
| optstore.add_project_option(OptionKey(name, ''), vo) |
| self.assertEqual(optstore.get_value_for(name, ''), top_value) |
| |
| def test_project_yielding(self): |
| optstore = OptionStore(False) |
| name = 'someoption' |
| top_value = 'top' |
| sub_value = 'sub' |
| vo = UserStringOption(name, 'A top level option', top_value) |
| optstore.add_project_option(OptionKey(name, ''), vo) |
| self.assertEqual(optstore.get_value_for(name, ''), top_value) |
| self.assertEqual(num_options(optstore), 1) |
| vo2 = UserStringOption(name, 'A subproject option', sub_value, True) |
| optstore.add_project_option(OptionKey(name, 'sub'), vo2) |
| self.assertEqual(optstore.get_value_for(name, ''), top_value) |
| self.assertEqual(optstore.get_value_for(name, 'sub'), top_value) |
| self.assertEqual(num_options(optstore), 2) |
| |
| def test_project_yielding_not_defined_in_top_project(self): |
| optstore = OptionStore(False) |
| top_name = 'a_name' |
| top_value = 'top' |
| sub_name = 'different_name' |
| sub_value = 'sub' |
| vo = UserStringOption(top_name, 'A top level option', top_value) |
| optstore.add_project_option(OptionKey(top_name, ''), vo) |
| self.assertEqual(optstore.get_value_for(top_name, ''), top_value) |
| self.assertEqual(num_options(optstore), 1) |
| vo2 = UserStringOption(sub_name, 'A subproject option', sub_value, True) |
| optstore.add_project_option(OptionKey(sub_name, 'sub'), vo2) |
| self.assertEqual(optstore.get_value_for(top_name, ''), top_value) |
| self.assertEqual(optstore.get_value_for(sub_name, 'sub'), sub_value) |
| self.assertEqual(num_options(optstore), 2) |
| |
| def test_project_yielding_initialize(self): |
| optstore = OptionStore(False) |
| name = 'someoption' |
| top_value = 'top' |
| sub_value = 'sub' |
| subp = 'subp' |
| cmd_line = { OptionKey(name): top_value, OptionKey(name, subp): sub_value } |
| |
| vo = UserStringOption(name, 'A top level option', 'default1') |
| optstore.add_project_option(OptionKey(name, ''), vo) |
| optstore.initialize_from_top_level_project_call({}, cmd_line, {}) |
| self.assertEqual(optstore.get_value_for(name, ''), top_value) |
| self.assertEqual(num_options(optstore), 1) |
| |
| vo2 = UserStringOption(name, 'A subproject option', 'default2', True) |
| optstore.add_project_option(OptionKey(name, 'subp'), vo2) |
| self.assertEqual(optstore.get_value_for(name, ''), top_value) |
| self.assertEqual(optstore.get_value_for(name, subp), top_value) |
| self.assertEqual(num_options(optstore), 2) |
| |
| optstore.initialize_from_subproject_call(subp, {}, {}, cmd_line, {}) |
| self.assertEqual(optstore.get_value_for(name, ''), top_value) |
| self.assertEqual(optstore.get_value_for(name, subp), sub_value) |
| |
| def test_augments(self): |
| optstore = OptionStore(False) |
| name = 'cpp_std' |
| sub_name = 'sub' |
| sub2_name = 'sub2' |
| top_value = 'c++11' |
| aug_value = 'c++23' |
| |
| co = UserComboOption(name, |
| 'C++ language standard to use', |
| top_value, |
| choices=['c++98', 'c++11', 'c++14', 'c++17', 'c++20', 'c++23']) |
| optstore.add_system_option(name, co) |
| self.assertEqual(optstore.get_value_for(name), top_value) |
| self.assertEqual(optstore.get_value_for(name, sub_name), top_value) |
| self.assertEqual(optstore.get_value_for(name, sub2_name), top_value) |
| |
| # First augment a subproject |
| with self.subTest('set subproject override'): |
| optstore.set_from_configure_command({OptionKey.from_string(f'{sub_name}:{name}'): aug_value}) |
| self.assertEqual(optstore.get_value_for(name), top_value) |
| self.assertEqual(optstore.get_value_for(name, sub_name), aug_value) |
| self.assertEqual(optstore.get_value_for(name, sub2_name), top_value) |
| |
| with self.subTest('unset subproject override'): |
| optstore.set_from_configure_command({OptionKey.from_string(f'{sub_name}:{name}'): None}) |
| self.assertEqual(optstore.get_value_for(name), top_value) |
| self.assertEqual(optstore.get_value_for(name, sub_name), top_value) |
| self.assertEqual(optstore.get_value_for(name, sub2_name), top_value) |
| |
| # And now augment the top level option |
| optstore.set_from_configure_command({OptionKey.from_string(f':{name}'): aug_value}) |
| self.assertEqual(optstore.get_value_for(name, None), top_value) |
| self.assertEqual(optstore.get_value_for(name, ''), aug_value) |
| self.assertEqual(optstore.get_value_for(name, sub_name), top_value) |
| self.assertEqual(optstore.get_value_for(name, sub2_name), top_value) |
| |
| optstore.set_from_configure_command({OptionKey.from_string(f':{name}'): None}) |
| self.assertEqual(optstore.get_value_for(name), top_value) |
| self.assertEqual(optstore.get_value_for(name, sub_name), top_value) |
| self.assertEqual(optstore.get_value_for(name, sub2_name), top_value) |
| |
| def test_augment_set_sub(self): |
| optstore = OptionStore(False) |
| name = 'cpp_std' |
| sub_name = 'sub' |
| sub2_name = 'sub2' |
| top_value = 'c++11' |
| aug_value = 'c++23' |
| set_value = 'c++20' |
| |
| co = UserComboOption(name, |
| 'C++ language standard to use', |
| top_value, |
| choices=['c++98', 'c++11', 'c++14', 'c++17', 'c++20', 'c++23'], |
| ) |
| optstore.add_system_option(name, co) |
| optstore.set_from_configure_command({OptionKey.from_string(f'{sub_name}:{name}'): aug_value}) |
| optstore.set_from_configure_command({OptionKey.from_string(f'{sub_name}:{name}'): set_value}) |
| self.assertEqual(optstore.get_value_for(name), top_value) |
| self.assertEqual(optstore.get_value_for(name, sub_name), set_value) |
| |
| def test_build_to_host(self): |
| key = OptionKey('cpp_std') |
| def_value = 'c++98' |
| opt_value = 'c++17' |
| optstore = OptionStore(False) |
| co = UserComboOption(key.name, |
| 'C++ language standard to use', |
| def_value, |
| choices=['c++98', 'c++11', 'c++14', 'c++17', 'c++20', 'c++23'], |
| ) |
| optstore.add_compiler_option('cpp', key, co) |
| |
| cmd_line = {key: opt_value} |
| optstore.initialize_from_top_level_project_call({}, cmd_line, {}) |
| self.assertEqual(optstore.get_option_and_value_for(key.as_build())[1], opt_value) |
| self.assertEqual(optstore.get_value_for(key.as_build()), opt_value) |
| |
| def test_build_to_host_subproject(self): |
| key = OptionKey('cpp_std') |
| def_value = 'c++98' |
| opt_value = 'c++17' |
| subp = 'subp' |
| optstore = OptionStore(False) |
| co = UserComboOption(key.name, |
| 'C++ language standard to use', |
| def_value, |
| choices=['c++98', 'c++11', 'c++14', 'c++17', 'c++20', 'c++23'], |
| ) |
| optstore.add_compiler_option('cpp', key, co) |
| |
| spcall = {key: opt_value} |
| optstore.initialize_from_top_level_project_call({}, {}, {}) |
| optstore.initialize_from_subproject_call(subp, spcall, {}, {}, {}) |
| self.assertEqual(optstore.get_option_and_value_for(key.evolve(subproject=subp, |
| machine=MachineChoice.BUILD))[1], opt_value) |
| self.assertEqual(optstore.get_value_for(key.evolve(subproject=subp, |
| machine=MachineChoice.BUILD)), opt_value) |
| |
| def test_build_to_host_cross(self): |
| key = OptionKey('cpp_std') |
| def_value = 'c++98' |
| opt_value = 'c++17' |
| optstore = OptionStore(True) |
| for k in [key, key.as_build()]: |
| co = UserComboOption(key.name, |
| 'C++ language standard to use', |
| def_value, |
| choices=['c++98', 'c++11', 'c++14', 'c++17', 'c++20', 'c++23'], |
| ) |
| optstore.add_compiler_option('cpp', k, co) |
| |
| cmd_line = {key: opt_value} |
| optstore.initialize_from_top_level_project_call({}, cmd_line, {}) |
| print(optstore.options) |
| |
| self.assertEqual(optstore.get_option_and_value_for(key)[1], opt_value) |
| self.assertEqual(optstore.get_option_and_value_for(key.as_build())[1], def_value) |
| self.assertEqual(optstore.get_value_for(key), opt_value) |
| self.assertEqual(optstore.get_value_for(key.as_build()), def_value) |
| |
| def test_b_nonexistent(self): |
| optstore = OptionStore(False) |
| self.assertTrue(optstore.accept_as_pending_option(OptionKey('b_ndebug'))) |
| self.assertFalse(optstore.accept_as_pending_option(OptionKey('b_whatever'))) |
| |
| def test_backend_option_pending(self): |
| optstore = OptionStore(False) |
| # backend options are known after the first invocation |
| self.assertTrue(optstore.accept_as_pending_option(OptionKey('backend_whatever'), True)) |
| self.assertFalse(optstore.accept_as_pending_option(OptionKey('backend_whatever'), False)) |
| |
| def test_reconfigure_b_nonexistent(self): |
| optstore = OptionStore(False) |
| optstore.set_from_configure_command({OptionKey('b_ndebug'): True}) |
| |
| def test_unconfigure_nonexistent(self): |
| optstore = OptionStore(False) |
| with self.assertRaises(MesonException): |
| optstore.set_from_configure_command({OptionKey('nonexistent'): None}) |
| |
| def test_subproject_proj_opt_with_same_name(self): |
| name = 'tests' |
| subp = 'subp' |
| |
| optstore = OptionStore(False) |
| prefix = UserStringOption('prefix', 'This is needed by OptionStore', '/usr') |
| optstore.add_system_option('prefix', prefix) |
| o = UserBooleanOption(name, 'Tests', False) |
| optstore.add_project_option(OptionKey(name, subproject=''), o) |
| o = UserBooleanOption(name, 'Tests', True) |
| optstore.add_project_option(OptionKey(name, subproject=subp), o) |
| |
| cmd_line = {OptionKey(name): True} |
| spcall = {OptionKey(name): False} |
| |
| optstore.initialize_from_top_level_project_call({}, cmd_line, {}) |
| optstore.initialize_from_subproject_call(subp, spcall, {}, cmd_line, {}) |
| self.assertEqual(optstore.get_value_for(name, ''), True) |
| self.assertEqual(optstore.get_value_for(name, subp), False) |
| |
| def test_subproject_cmdline_override_global(self): |
| name = 'optimization' |
| subp = 'subp' |
| new_value = '0' |
| |
| optstore = OptionStore(False) |
| prefix = UserStringOption('prefix', 'This is needed by OptionStore', '/usr') |
| optstore.add_system_option('prefix', prefix) |
| o = UserComboOption(name, 'Optimization level', '0', choices=['plain', '0', 'g', '1', '2', '3', 's']) |
| optstore.add_system_option(name, o) |
| |
| toplevel_proj_default = {OptionKey(name): 's'} |
| subp_proj_default = {OptionKey(name): '3'} |
| cmd_line = {OptionKey(name): new_value} |
| |
| optstore.initialize_from_top_level_project_call(toplevel_proj_default, cmd_line, {}) |
| optstore.initialize_from_subproject_call(subp, {}, subp_proj_default, cmd_line, {}) |
| self.assertEqual(optstore.get_value_for(name, subp), new_value) |
| self.assertEqual(optstore.get_value_for(name), new_value) |
| |
| def test_subproject_parent_override_subp(self): |
| name = 'optimization' |
| subp = 'subp' |
| default_value = 's' |
| subp_value = '0' |
| |
| optstore = OptionStore(False) |
| prefix = UserStringOption('prefix', 'This is needed by OptionStore', '/usr') |
| optstore.add_system_option('prefix', prefix) |
| o = UserComboOption(name, 'Optimization level', '0', choices=['plain', '0', 'g', '1', '2', '3', 's']) |
| optstore.add_system_option(name, o) |
| |
| toplevel_proj_default = {OptionKey(name, subproject=subp): subp_value, OptionKey(name): default_value} |
| subp_proj_default = {OptionKey(name): '3'} |
| |
| optstore.initialize_from_top_level_project_call(toplevel_proj_default, {}, {}) |
| optstore.initialize_from_subproject_call(subp, {}, subp_proj_default, {}, {}) |
| self.assertEqual(optstore.get_value_for(name, subp), subp_value) |
| self.assertEqual(optstore.get_value_for(name), default_value) |
| |
| def test_subproject_cmdline_override_global_and_augment(self): |
| name = 'optimization' |
| subp = 'subp' |
| global_value = 's' |
| new_value = '0' |
| |
| optstore = OptionStore(False) |
| prefix = UserStringOption('prefix', 'This is needed by OptionStore', '/usr') |
| optstore.add_system_option('prefix', prefix) |
| o = UserComboOption(name, 'Optimization level', '0', choices=['plain', '0', 'g', '1', '2', '3', 's']) |
| optstore.add_system_option(name, o) |
| |
| toplevel_proj_default = {OptionKey(name): '1'} |
| subp_proj_default = {OptionKey(name): '3'} |
| cmd_line = {OptionKey(name): global_value, OptionKey(name, subproject=subp): new_value} |
| |
| optstore.initialize_from_top_level_project_call(toplevel_proj_default, cmd_line, {}) |
| optstore.initialize_from_subproject_call(subp, {}, subp_proj_default, cmd_line, {}) |
| self.assertEqual(optstore.get_value_for(name, subp), new_value) |
| self.assertEqual(optstore.get_value_for(name), global_value) |
| |
| def test_subproject_cmdline_override_toplevel(self): |
| name = 'default_library' |
| subp = 'subp' |
| toplevel_value = 'both' |
| subp_value = 'static' |
| |
| optstore = OptionStore(False) |
| prefix = UserStringOption('prefix', 'This is needed by OptionStore', '/usr') |
| optstore.add_system_option('prefix', prefix) |
| o = UserComboOption(name, 'Kind of library', 'both', choices=['shared', 'static', 'both']) |
| optstore.add_system_option(name, o) |
| |
| toplevel_proj_default = {OptionKey(name): 'shared'} |
| subp_proj_default = {OptionKey(name): subp_value} |
| cmd_line = {OptionKey(name, subproject=''): toplevel_value} |
| |
| optstore.initialize_from_top_level_project_call(toplevel_proj_default, cmd_line, {}) |
| optstore.initialize_from_subproject_call(subp, {}, subp_proj_default, cmd_line, {}) |
| self.assertEqual(optstore.get_value_for(name, subp), subp_value) |
| self.assertEqual(optstore.get_value_for(name, ''), toplevel_value) |
| |
| def test_subproject_buildtype(self): |
| subp = 'subp' |
| main1 = {OptionKey('buildtype'): 'release'} |
| main2 = {OptionKey('optimization'): '3', OptionKey('debug'): 'false'} |
| sub1 = {OptionKey('buildtype'): 'debug'} |
| sub2 = {OptionKey('optimization'): '0', OptionKey('debug'): 'true'} |
| |
| for mainopt, subopt in ((main1, sub1), |
| (main2, sub2), |
| ({**main1, **main2}, {**sub1, **sub2})): |
| optstore = OptionStore(False) |
| prefix = UserStringOption('prefix', 'This is needed by OptionStore', '/usr') |
| optstore.add_system_option('prefix', prefix) |
| o = UserComboOption('buildtype', 'Build type to use', 'debug', choices=['plain', 'debug', 'debugoptimized', 'release', 'minsize', 'custom']) |
| optstore.add_system_option(o.name, o) |
| o = UserComboOption('optimization', 'Optimization level', '0', choices=['plain', '0', 'g', '1', '2', '3', 's']) |
| optstore.add_system_option(o.name, o) |
| o = UserBooleanOption('debug', 'Enable debug symbols and other information', True) |
| optstore.add_system_option(o.name, o) |
| |
| optstore.initialize_from_top_level_project_call(mainopt, {}, {}) |
| optstore.initialize_from_subproject_call(subp, {}, subopt, {}, {}) |
| self.assertEqual(optstore.get_value_for('buildtype', subp), 'debug') |
| self.assertEqual(optstore.get_value_for('optimization', subp), '0') |
| self.assertEqual(optstore.get_value_for('debug', subp), True) |
| |
| def test_deprecated_nonstring_value(self): |
| # TODO: add a lot more deprecated option tests |
| optstore = OptionStore(False) |
| name = 'deprecated' |
| do = UserStringOption(name, 'An option with some deprecation', '0', |
| deprecated={'true': '1'}) |
| optstore.add_system_option(name, do) |
| optstore.set_option(OptionKey(name), True) |
| value = optstore.get_value_for(name) |
| self.assertEqual(value, '1') |
| |
| def test_pending_augment_validation(self): |
| name = 'b_lto' |
| subproject = 'mysubproject' |
| |
| optstore = OptionStore(False) |
| prefix = UserStringOption('prefix', 'This is needed by OptionStore', '/usr') |
| optstore.add_system_option('prefix', prefix) |
| |
| optstore.initialize_from_top_level_project_call({}, {}, {}) |
| optstore.initialize_from_subproject_call(subproject, {}, {OptionKey(name): 'true'}, {}, {}) |
| |
| bo = UserBooleanOption(name, 'LTO', False) |
| key = OptionKey(name, subproject=subproject) |
| optstore.add_system_option(key, bo) |
| stored_value = optstore.get_value_for(key) |
| self.assertIsInstance(stored_value, bool) |
| self.assertTrue(stored_value) |
| |
| def test_yielding_boolean_option_with_falsy_parent(self): |
| """Test that yielding is correctly initialized when parent option value is False.""" |
| optstore = OptionStore(False) |
| name = 'someoption' |
| subproject_name = 'sub' |
| parent_option = UserBooleanOption(name, 'A parent boolean option', False, yielding=True) |
| optstore.add_project_option(OptionKey(name, ''), parent_option) |
| |
| child_option = UserBooleanOption(name, 'A child boolean option', True, yielding=True) |
| child_key = OptionKey(name, subproject_name) |
| optstore.add_project_option(child_key, child_option) |
| self.assertTrue(optstore.options[child_key].yielding) |
| |
| def test_machine_canonicalization_cross(self): |
| """Test that BUILD machine options are handled correctly in cross compilation.""" |
| optstore = OptionStore(True) |
| |
| # Test that BUILD machine per-machine option is NOT canonicalized to HOST |
| host_pkg_config = OptionKey('pkg_config_path', machine=MachineChoice.HOST) |
| build_pkg_config = OptionKey('pkg_config_path', machine=MachineChoice.BUILD) |
| host_option_obj = UserStringArrayOption('pkg_config_path', 'Host pkg-config paths', ['/mingw/lib64/pkgconfig']) |
| build_option_obj = UserStringArrayOption('pkg_config_path', 'Build pkg-config paths', ['/usr/lib64/pkgconfig']) |
| optstore.add_system_option(host_pkg_config, host_option_obj) |
| optstore.add_system_option(build_pkg_config, build_option_obj) |
| option, value = optstore.get_option_and_value_for(build_pkg_config) |
| self.assertEqual(value, ['/usr/lib64/pkgconfig']) |
| |
| # Test that non-per-machine BUILD option IS canonicalized to HOST |
| build_opt = OptionKey('optimization', machine=MachineChoice.BUILD) |
| host_opt = OptionKey('optimization', machine=MachineChoice.HOST) |
| common_option_obj = UserComboOption('optimization', 'Optimization level', '0', |
| choices=['plain', '0', 'g', '1', '2', '3', 's']) |
| optstore.add_system_option(host_opt, common_option_obj) |
| self.assertEqual(optstore.get_value_for(build_opt), '0') |
| |
| def test_machine_canonicalization_native(self): |
| """Test that BUILD machine options are canonicalized to HOST when not cross compiling.""" |
| optstore = OptionStore(False) |
| |
| host_pkg_config = OptionKey('pkg_config_path', machine=MachineChoice.HOST) |
| build_pkg_config = OptionKey('pkg_config_path', machine=MachineChoice.BUILD) |
| host_option_obj = UserStringArrayOption('pkg_config_path', 'Host pkg-config paths', ['/mingw/lib64/pkgconfig']) |
| build_option_obj = UserStringArrayOption('pkg_config_path', 'Build pkg-config paths', ['/usr/lib64/pkgconfig']) |
| |
| # Add per-machine option for HOST only (BUILD will be canonicalized) |
| optstore.add_system_option(host_pkg_config, host_option_obj) |
| option, value = optstore.get_option_and_value_for(build_pkg_config) |
| self.assertEqual(value, ['/mingw/lib64/pkgconfig']) |
| |
| # Try again adding build option too, for completeness |
| optstore.add_system_option(build_pkg_config, build_option_obj) |
| option, value = optstore.get_option_and_value_for(build_pkg_config) |
| self.assertEqual(value, ['/mingw/lib64/pkgconfig']) |
| |
| def test_sanitize_prefix_windows_host(self): |
| """Test that Windows paths are accepted when host is Windows.""" |
| optstore = OptionStore(True) # cross-compile |
| optstore.set_host_machine(make_machine('windows')) |
| result = optstore.sanitize_prefix('C:\\Windows') |
| self.assertEqual(result, 'C:\\Windows') |
| result = optstore.sanitize_prefix('\\\\server\\share') |
| self.assertEqual(result, '\\\\server\\share') |
| # Forward slashes should also be accepted on Windows |
| result = optstore.sanitize_prefix('C:/Windows') |
| self.assertEqual(result, 'C:/Windows') |
| result = optstore.sanitize_prefix('//server/share') |
| self.assertEqual(result, '//server/share') |
| |
| def test_sanitize_prefix_posix_host(self): |
| """Test that POSIX paths are accepted when host is POSIX.""" |
| optstore = OptionStore(True) # cross-compile |
| optstore.set_host_machine(make_machine('linux')) |
| result = optstore.sanitize_prefix('/usr/local') |
| self.assertEqual(result, '/usr/local') |
| # Windows path should be rejected |
| with self.assertRaises(MesonException): |
| optstore.sanitize_prefix('\\myprog') |
| with self.assertRaises(MesonException): |
| optstore.sanitize_prefix('C:\\Windows') |
| with self.assertRaises(MesonException): |
| optstore.sanitize_prefix('C:/Windows') |
| with self.assertRaises(MesonException): |
| optstore.sanitize_prefix('\\\\server\\share') |
| # This one is not parsed as UNC |
| result = optstore.sanitize_prefix('//server/share') |
| self.assertEqual(result, '//server/share') |
| |
| def test_sanitize_prefix_cygwin_host(self): |
| """Test that Cygwin uses POSIX-style paths.""" |
| optstore = OptionStore(True) |
| optstore.set_host_machine(make_machine('cygwin')) |
| result = optstore.sanitize_prefix('/usr/local') |
| self.assertEqual(result, '/usr/local') |
| result = optstore.sanitize_prefix('/cygdrive/c/Windows') |
| self.assertEqual(result, '/cygdrive/c/Windows') |
| |
| def test_sanitize_dir_option_cross_to_windows(self): |
| """Test directory option sanitization when cross-compiling to Windows.""" |
| optstore = OptionStore(True) |
| optstore.set_host_machine(make_machine('windows')) |
| optstore.init_builtins() |
| # Set libdir to absolute path inside prefix, should be relativized |
| optstore.set_option(OptionKey('prefix'), 'C:\\Program Files\\MyProg') |
| optstore.set_option(OptionKey('libdir'), 'C:\\Program Files\\MyProg\\lib') |
| self.assertEqual(optstore.get_value_for('libdir'), 'lib') |
| |
| def test_sanitize_dir_option_cross_to_linux(self): |
| """Test directory option sanitization when cross-compiling to Linux.""" |
| optstore = OptionStore(True) |
| optstore.set_host_machine(make_machine('linux')) |
| optstore.init_builtins() |
| # Set libdir to absolute path inside prefix, should be relativized |
| optstore.set_option(OptionKey('prefix'), '/opt/myapp') |
| optstore.set_option(OptionKey('libdir'), '/opt/myapp/lib64') |
| self.assertEqual(optstore.get_value_for('libdir'), 'lib64') |
| |
| def test_sanitize_prefix_native_path(self): |
| """Test that native paths are accepted without set_host_machine().""" |
| optstore = OptionStore(False) |
| native_path = os.sep + 'myprog' |
| result = optstore.sanitize_prefix(native_path) |
| self.assertEqual(result, native_path) |
| |
| def test_is_host_absolute(self): |
| """Test _is_host_absolute with various host configurations.""" |
| # POSIX host |
| optstore = OptionStore(True) |
| optstore.set_host_machine(make_machine('linux')) |
| self.assertTrue(optstore._is_host_absolute('/usr')) |
| self.assertTrue(optstore._is_host_absolute('/usr/local')) |
| self.assertFalse(optstore._is_host_absolute('relative')) |
| self.assertFalse(optstore._is_host_absolute('C:\\Windows')) |
| self.assertFalse(optstore._is_host_absolute('C:/Windows')) |
| |
| # Windows host - accepts both full absolute and root-relative |
| optstore = OptionStore(True) |
| optstore.set_host_machine(make_machine('windows')) |
| self.assertTrue(optstore._is_host_absolute('C:\\Windows')) |
| self.assertTrue(optstore._is_host_absolute('C:/Windows')) |
| self.assertTrue(optstore._is_host_absolute('//server/share')) |
| self.assertTrue(optstore._is_host_absolute('\\\\server\\share')) |
| # Root-relative paths accepted for backwards compat |
| self.assertTrue(optstore._is_host_absolute('/usr')) |
| self.assertTrue(optstore._is_host_absolute('\\myprog')) |
| self.assertFalse(optstore._is_host_absolute('relative')) |
| |
| # No host set - uses build machine semantics |
| optstore = OptionStore(False) |
| self.assertTrue(optstore._is_host_absolute(os.sep + 'myprog')) |
| self.assertTrue(optstore._is_host_absolute('/myprog')) |
