mirror of
https://github.com/bazelbuild/rules_cc
synced 2024-11-30 22:41:22 +00:00
0c017ebc6d
https://github.com/bazelbuild/bazel/issues/6861 RELNOTES: None. PiperOrigin-RevId: 238941083
1241 lines
50 KiB
Python
1241 lines
50 KiB
Python
import unittest
|
|
from google.protobuf import text_format
|
|
from third_party.com.github.bazelbuild.bazel.src.main.protobuf import crosstool_config_pb2
|
|
from tools.migration.legacy_fields_migration_lib import ALL_CC_COMPILE_ACTIONS
|
|
from tools.migration.legacy_fields_migration_lib import ALL_OBJC_COMPILE_ACTIONS
|
|
from tools.migration.legacy_fields_migration_lib import ALL_CXX_COMPILE_ACTIONS
|
|
from tools.migration.legacy_fields_migration_lib import ALL_CC_LINK_ACTIONS
|
|
from tools.migration.legacy_fields_migration_lib import ALL_OBJC_LINK_ACTIONS
|
|
from tools.migration.legacy_fields_migration_lib import DYNAMIC_LIBRARY_LINK_ACTIONS
|
|
from tools.migration.legacy_fields_migration_lib import NODEPS_DYNAMIC_LIBRARY_LINK_ACTIONS
|
|
from tools.migration.legacy_fields_migration_lib import TRANSITIVE_LINK_ACTIONS
|
|
from tools.migration.legacy_fields_migration_lib import TRANSITIVE_DYNAMIC_LIBRARY_LINK_ACTIONS
|
|
from tools.migration.legacy_fields_migration_lib import CC_LINK_EXECUTABLE
|
|
from tools.migration.legacy_fields_migration_lib import migrate_legacy_fields
|
|
|
|
|
|
def assert_has_feature(self, toolchain, name):
|
|
self.assertTrue(any(feature.name == name for feature in toolchain.feature))
|
|
|
|
|
|
def make_crosstool(string):
|
|
crosstool = crosstool_config_pb2.CrosstoolRelease()
|
|
text_format.Merge("major_version: '123' minor_version: '456'", crosstool)
|
|
toolchain = crosstool.toolchain.add()
|
|
text_format.Merge(string, toolchain)
|
|
return crosstool
|
|
|
|
|
|
def migrate_to_string(crosstool):
|
|
migrate_legacy_fields(crosstool)
|
|
return to_string(crosstool)
|
|
|
|
|
|
def to_string(crosstool):
|
|
return text_format.MessageToString(crosstool)
|
|
|
|
|
|
class LegacyFieldsMigrationLibTest(unittest.TestCase):
|
|
|
|
def test_deletes_fields(self):
|
|
crosstool = make_crosstool("""
|
|
debian_extra_requires: 'debian-1'
|
|
gcc_plugin_compiler_flag: 'gcc_plugin_compiler_flag-1'
|
|
ar_flag: 'ar_flag-1'
|
|
ar_thin_archives_flag: 'ar_thin_archives_flag-1'
|
|
gcc_plugin_header_directory: 'gcc_plugin_header_directory-1'
|
|
mao_plugin_header_directory: 'mao_plugin_header_directory-1'
|
|
default_python_top: 'default_python_top-1'
|
|
default_python_version: 'default_python_version-1'
|
|
python_preload_swigdeps: false
|
|
supports_normalizing_ar: false
|
|
supports_thin_archives: false
|
|
supports_incremental_linker: false
|
|
supports_dsym: false
|
|
supports_gold_linker: false
|
|
needsPic: false
|
|
supports_start_end_lib: false
|
|
supports_interface_shared_objects: false
|
|
supports_fission: false
|
|
supports_embedded_runtimes: false
|
|
static_runtimes_filegroup: 'yolo'
|
|
dynamic_runtimes_filegroup: 'yolo'
|
|
""")
|
|
output = migrate_to_string(crosstool)
|
|
self.assertNotIn("debian_extra_requires", output)
|
|
self.assertNotIn("gcc_plugin_compiler_flag", output)
|
|
self.assertNotIn("ar_flag", output)
|
|
self.assertNotIn("ar_thin_archives_flag", output)
|
|
self.assertNotIn("gcc_plugin_header_directory", output)
|
|
self.assertNotIn("mao_plugin_header_directory", output)
|
|
self.assertNotIn("supports_normalizing_ar", output)
|
|
self.assertNotIn("supports_thin_archives", output)
|
|
self.assertNotIn("supports_incremental_linker", output)
|
|
self.assertNotIn("supports_dsym", output)
|
|
self.assertNotIn("default_python_top", output)
|
|
self.assertNotIn("default_python_version", output)
|
|
self.assertNotIn("python_preload_swigdeps", output)
|
|
self.assertNotIn("supports_gold_linker", output)
|
|
self.assertNotIn("needsPic", output)
|
|
self.assertNotIn("supports_start_end_lib", output)
|
|
self.assertNotIn("supports_interface_shared_objects", output)
|
|
self.assertNotIn("supports_fission", output)
|
|
self.assertNotIn("supports_embedded_runtimes", output)
|
|
self.assertNotIn("static_runtimes_filegroup", output)
|
|
self.assertNotIn("dynamic_runtimes_filegroup", output)
|
|
|
|
def test_deletes_default_toolchains(self):
|
|
crosstool = make_crosstool("")
|
|
crosstool.default_toolchain.add()
|
|
self.assertEqual(len(crosstool.default_toolchain), 1)
|
|
migrate_legacy_fields(crosstool)
|
|
self.assertEqual(len(crosstool.default_toolchain), 0)
|
|
|
|
def test_replace_legacy_compile_flags(self):
|
|
crosstool = make_crosstool("""
|
|
feature { name: 'foo' }
|
|
feature { name: 'legacy_compile_flags' }
|
|
compiler_flag: 'clang-flag-1'
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(len(output.compiler_flag), 0)
|
|
self.assertEqual(output.feature[0].name, "foo")
|
|
self.assertEqual(output.feature[1].name, "default_compile_flags")
|
|
self.assertEqual(output.feature[1].flag_set[0].action,
|
|
ALL_CC_COMPILE_ACTIONS)
|
|
self.assertEqual(output.feature[1].flag_set[0].flag_group[0].flag,
|
|
["clang-flag-1"])
|
|
|
|
def test_replace_legacy_compile_flags_in_action_configs(self):
|
|
crosstool = make_crosstool("""
|
|
feature {
|
|
name: 'foo'
|
|
implies: 'legacy_compile_flags'
|
|
requires: { feature: 'legacy_compile_flags' }
|
|
flag_set {
|
|
with_feature { feature: 'legacy_compile_flags' }
|
|
with_feature { not_feature: 'legacy_compile_flags' }
|
|
}
|
|
env_set {
|
|
with_feature { feature: 'legacy_compile_flags' }
|
|
with_feature { not_feature: 'legacy_compile_flags' }
|
|
}
|
|
}
|
|
feature { name: 'legacy_compile_flags' }
|
|
action_config {
|
|
action_name: 'foo'
|
|
config_name: 'foo'
|
|
implies: 'legacy_compile_flags'
|
|
requires: { feature: 'legacy_compile_flags' }
|
|
flag_set {
|
|
with_feature { feature: 'legacy_compile_flags' }
|
|
with_feature { not_feature: 'legacy_compile_flags' }
|
|
}
|
|
env_set {
|
|
with_feature { feature: 'legacy_compile_flags' }
|
|
with_feature { not_feature: 'legacy_compile_flags' }
|
|
}
|
|
}
|
|
compiler_flag: 'clang-flag-1'
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.action_config[0].action_name, "foo")
|
|
self.assertEqual(output.action_config[0].implies, [])
|
|
self.assertEqual(output.action_config[0].requires[0].feature,
|
|
["default_compile_flags"])
|
|
self.assertEqual(
|
|
output.action_config[0].flag_set[0].with_feature[0].feature,
|
|
["default_compile_flags"])
|
|
self.assertEqual(
|
|
output.action_config[0].flag_set[0].with_feature[1].not_feature,
|
|
["default_compile_flags"])
|
|
self.assertEqual(output.action_config[0].env_set[0].with_feature[0].feature,
|
|
["default_compile_flags"])
|
|
self.assertEqual(
|
|
output.action_config[0].env_set[0].with_feature[1].not_feature,
|
|
["default_compile_flags"])
|
|
self.assertEqual(output.feature[0].name, "foo")
|
|
self.assertEqual(output.feature[0].implies, [])
|
|
self.assertEqual(output.feature[0].requires[0].feature,
|
|
["default_compile_flags"])
|
|
self.assertEqual(output.feature[0].flag_set[0].with_feature[0].feature,
|
|
["default_compile_flags"])
|
|
self.assertEqual(output.feature[0].flag_set[0].with_feature[1].not_feature,
|
|
["default_compile_flags"])
|
|
self.assertEqual(output.feature[0].env_set[0].with_feature[0].feature,
|
|
["default_compile_flags"])
|
|
self.assertEqual(output.feature[0].env_set[0].with_feature[1].not_feature,
|
|
["default_compile_flags"])
|
|
|
|
def test_replace_legacy_link_flags(self):
|
|
crosstool = make_crosstool("""
|
|
feature { name: 'foo' }
|
|
feature { name: 'legacy_link_flags' }
|
|
linker_flag: 'ld-flag-1'
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(len(output.compiler_flag), 0)
|
|
self.assertEqual(output.feature[0].name, "foo")
|
|
self.assertEqual(output.feature[1].name, "default_link_flags")
|
|
self.assertEqual(output.feature[1].flag_set[0].action, ALL_CC_LINK_ACTIONS)
|
|
self.assertEqual(output.feature[1].flag_set[0].flag_group[0].flag,
|
|
["ld-flag-1"])
|
|
|
|
def test_replace_legacy_link_flags_in_action_configs(self):
|
|
crosstool = make_crosstool("""
|
|
feature {
|
|
name: 'foo'
|
|
implies: 'legacy_link_flags'
|
|
requires: { feature: 'legacy_link_flags' }
|
|
flag_set {
|
|
with_feature { feature: 'legacy_link_flags' }
|
|
with_feature { not_feature: 'legacy_link_flags' }
|
|
}
|
|
env_set {
|
|
with_feature { feature: 'legacy_link_flags' }
|
|
with_feature { not_feature: 'legacy_link_flags' }
|
|
}
|
|
}
|
|
feature { name: 'legacy_link_flags' }
|
|
action_config {
|
|
action_name: 'foo'
|
|
config_name: 'foo'
|
|
implies: 'legacy_link_flags'
|
|
requires: { feature: 'legacy_link_flags' }
|
|
flag_set {
|
|
with_feature { feature: 'legacy_link_flags' }
|
|
with_feature { not_feature: 'legacy_link_flags' }
|
|
}
|
|
env_set {
|
|
with_feature { feature: 'legacy_link_flags' }
|
|
with_feature { not_feature: 'legacy_link_flags' }
|
|
}
|
|
}
|
|
linker_flag: 'clang-flag-1'
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.action_config[0].action_name, "foo")
|
|
self.assertEqual(output.action_config[0].implies, [])
|
|
self.assertEqual(output.action_config[0].requires[0].feature,
|
|
["default_link_flags"])
|
|
self.assertEqual(
|
|
output.action_config[0].flag_set[0].with_feature[0].feature,
|
|
["default_link_flags"])
|
|
self.assertEqual(
|
|
output.action_config[0].flag_set[0].with_feature[1].not_feature,
|
|
["default_link_flags"])
|
|
self.assertEqual(output.action_config[0].env_set[0].with_feature[0].feature,
|
|
["default_link_flags"])
|
|
self.assertEqual(
|
|
output.action_config[0].env_set[0].with_feature[1].not_feature,
|
|
["default_link_flags"])
|
|
self.assertEqual(output.feature[0].name, "foo")
|
|
self.assertEqual(output.feature[0].implies, [])
|
|
self.assertEqual(output.feature[0].requires[0].feature,
|
|
["default_link_flags"])
|
|
self.assertEqual(output.feature[0].flag_set[0].with_feature[0].feature,
|
|
["default_link_flags"])
|
|
self.assertEqual(output.feature[0].flag_set[0].with_feature[1].not_feature,
|
|
["default_link_flags"])
|
|
self.assertEqual(output.feature[0].env_set[0].with_feature[0].feature,
|
|
["default_link_flags"])
|
|
self.assertEqual(output.feature[0].env_set[0].with_feature[1].not_feature,
|
|
["default_link_flags"])
|
|
|
|
|
|
def test_migrate_compiler_flags(self):
|
|
crosstool = make_crosstool("""
|
|
compiler_flag: 'clang-flag-1'
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(len(output.compiler_flag), 0)
|
|
self.assertEqual(output.feature[0].name, "default_compile_flags")
|
|
self.assertEqual(output.feature[0].flag_set[0].action, ALL_CC_COMPILE_ACTIONS)
|
|
self.assertEqual(output.feature[0].flag_set[0].flag_group[0].flag,
|
|
["clang-flag-1"])
|
|
|
|
def test_migrate_compiler_flags_for_objc(self):
|
|
crosstool = make_crosstool("""
|
|
action_config { action_name: "objc-compile" }
|
|
compiler_flag: 'clang-flag-1'
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(len(output.compiler_flag), 0)
|
|
self.assertEqual(output.feature[0].name, "default_compile_flags")
|
|
self.assertEqual(output.feature[0].flag_set[0].action, ALL_CC_COMPILE_ACTIONS + ALL_OBJC_COMPILE_ACTIONS)
|
|
self.assertEqual(output.feature[0].flag_set[0].flag_group[0].flag,
|
|
["clang-flag-1"])
|
|
|
|
def test_migrate_cxx_flags(self):
|
|
crosstool = make_crosstool("""
|
|
cxx_flag: 'clang-flag-1'
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(len(output.cxx_flag), 0)
|
|
self.assertEqual(output.feature[0].name, "default_compile_flags")
|
|
self.assertEqual(output.feature[0].flag_set[0].action,
|
|
ALL_CXX_COMPILE_ACTIONS)
|
|
self.assertEqual(output.feature[0].flag_set[0].flag_group[0].flag,
|
|
["clang-flag-1"])
|
|
|
|
def test_compiler_flag_come_before_cxx_flags(self):
|
|
crosstool = make_crosstool("""
|
|
compiler_flag: 'clang-flag-1'
|
|
cxx_flag: 'clang-flag-2'
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.feature[0].name, "default_compile_flags")
|
|
self.assertEqual(output.feature[0].flag_set[0].action, ALL_CC_COMPILE_ACTIONS)
|
|
self.assertEqual(output.feature[0].flag_set[1].action,
|
|
ALL_CXX_COMPILE_ACTIONS)
|
|
self.assertEqual(output.feature[0].flag_set[0].flag_group[0].flag,
|
|
["clang-flag-1"])
|
|
self.assertEqual(output.feature[0].flag_set[1].flag_group[0].flag,
|
|
["clang-flag-2"])
|
|
|
|
def test_migrate_linker_flags(self):
|
|
crosstool = make_crosstool("""
|
|
linker_flag: 'linker-flag-1'
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(len(output.linker_flag), 0)
|
|
self.assertEqual(output.feature[0].name, "default_link_flags")
|
|
self.assertEqual(output.feature[0].flag_set[0].action, ALL_CC_LINK_ACTIONS)
|
|
self.assertEqual(output.feature[0].flag_set[0].flag_group[0].flag,
|
|
["linker-flag-1"])
|
|
|
|
def test_migrate_dynamic_library_linker_flags(self):
|
|
crosstool = make_crosstool("""
|
|
dynamic_library_linker_flag: 'linker-flag-1'
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(len(output.dynamic_library_linker_flag), 0)
|
|
self.assertEqual(output.feature[0].name, "default_link_flags")
|
|
self.assertEqual(output.feature[0].flag_set[0].action,
|
|
DYNAMIC_LIBRARY_LINK_ACTIONS)
|
|
self.assertEqual(output.feature[0].flag_set[0].flag_group[0].flag,
|
|
["linker-flag-1"])
|
|
|
|
def test_compilation_mode_flags(self):
|
|
crosstool = make_crosstool("""
|
|
compiler_flag: "compile-flag-1"
|
|
cxx_flag: "cxx-flag-1"
|
|
linker_flag: "linker-flag-1"
|
|
compilation_mode_flags {
|
|
mode: OPT
|
|
compiler_flag: "opt-flag-1"
|
|
cxx_flag: "opt-flag-2"
|
|
linker_flag: "opt-flag-3"
|
|
}
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(len(output.compilation_mode_flags), 0)
|
|
assert_has_feature(self, output, "opt")
|
|
|
|
self.assertEqual(output.feature[0].name, "default_compile_flags")
|
|
self.assertEqual(output.feature[1].name, "default_link_flags")
|
|
|
|
# flag set for compiler_flag fields
|
|
self.assertEqual(len(output.feature[0].flag_set[0].with_feature), 0)
|
|
self.assertEqual(output.feature[0].flag_set[0].flag_group[0].flag,
|
|
["compile-flag-1"])
|
|
|
|
# flag set for compiler_flag from compilation_mode_flags
|
|
self.assertEqual(len(output.feature[0].flag_set[1].with_feature), 1)
|
|
self.assertEqual(output.feature[0].flag_set[1].with_feature[0].feature[0],
|
|
"opt")
|
|
self.assertEqual(output.feature[0].flag_set[1].flag_group[0].flag,
|
|
["opt-flag-1"])
|
|
|
|
# flag set for cxx_flag fields
|
|
self.assertEqual(len(output.feature[0].flag_set[2].with_feature), 0)
|
|
self.assertEqual(output.feature[0].flag_set[2].flag_group[0].flag,
|
|
["cxx-flag-1"])
|
|
|
|
# flag set for cxx_flag from compilation_mode_flags
|
|
self.assertEqual(len(output.feature[0].flag_set[3].with_feature), 1)
|
|
self.assertEqual(output.feature[0].flag_set[3].with_feature[0].feature[0],
|
|
"opt")
|
|
self.assertEqual(output.feature[0].flag_set[3].flag_group[0].flag,
|
|
["opt-flag-2"])
|
|
|
|
# default_link_flags, flag set for linker_flag
|
|
self.assertEqual(len(output.feature[1].flag_set[0].with_feature), 0)
|
|
self.assertEqual(output.feature[1].flag_set[0].flag_group[0].flag,
|
|
["linker-flag-1"])
|
|
|
|
# default_link_flags, flag set for linker_flag from
|
|
# compilation_mode_flags
|
|
self.assertEqual(len(output.feature[1].flag_set[1].with_feature), 1)
|
|
self.assertEqual(output.feature[1].flag_set[1].with_feature[0].feature[0],
|
|
"opt")
|
|
self.assertEqual(output.feature[1].flag_set[1].flag_group[0].flag,
|
|
["opt-flag-3"])
|
|
|
|
def test_linking_mode_flags(self):
|
|
crosstool = make_crosstool("""
|
|
linker_flag: "linker-flag-1"
|
|
compilation_mode_flags {
|
|
mode: DBG
|
|
linker_flag: "dbg-flag-1"
|
|
}
|
|
linking_mode_flags {
|
|
mode: MOSTLY_STATIC
|
|
linker_flag: "mostly-static-flag-1"
|
|
}
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(len(output.compilation_mode_flags), 0)
|
|
self.assertEqual(len(output.linking_mode_flags), 0)
|
|
|
|
# flag set for linker_flag
|
|
self.assertEqual(len(output.feature[0].flag_set[0].with_feature), 0)
|
|
self.assertEqual(output.feature[0].flag_set[0].flag_group[0].flag,
|
|
["linker-flag-1"])
|
|
|
|
# flag set for compilation_mode_flags
|
|
self.assertEqual(len(output.feature[0].flag_set[1].with_feature), 1)
|
|
self.assertEqual(output.feature[0].flag_set[1].with_feature[0].feature[0],
|
|
"dbg")
|
|
self.assertEqual(output.feature[0].flag_set[1].flag_group[0].flag,
|
|
["dbg-flag-1"])
|
|
|
|
# flag set for linking_mode_flags
|
|
self.assertEqual(len(output.feature[0].flag_set[2].with_feature), 1)
|
|
self.assertEqual(output.feature[0].flag_set[2].action, CC_LINK_EXECUTABLE)
|
|
self.assertEqual(output.feature[0].flag_set[2].with_feature[0].feature[0],
|
|
"static_linking_mode")
|
|
self.assertEqual(output.feature[0].flag_set[2].flag_group[0].flag,
|
|
["mostly-static-flag-1"])
|
|
|
|
def test_coverage_compilation_mode_ignored(self):
|
|
crosstool = make_crosstool("""
|
|
compilation_mode_flags {
|
|
mode: COVERAGE
|
|
compiler_flag: "coverage-flag-1"
|
|
cxx_flag: "coverage-flag-2"
|
|
linker_flag: "coverage-flag-3"
|
|
}
|
|
""")
|
|
output = migrate_to_string(crosstool)
|
|
self.assertNotIn("compilation_mode_flags", output)
|
|
self.assertNotIn("coverage-flag-1", output)
|
|
self.assertNotIn("coverage-flag-2", output)
|
|
self.assertNotIn("coverage-flag-3", output)
|
|
self.assertNotIn("COVERAGE", output)
|
|
|
|
def test_supports_dynamic_linker_when_dynamic_library_linker_flag_is_used(
|
|
self):
|
|
crosstool = make_crosstool("""
|
|
dynamic_library_linker_flag: "foo"
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.feature[0].name, "default_link_flags")
|
|
self.assertEqual(output.feature[1].name, "supports_dynamic_linker")
|
|
self.assertEqual(output.feature[1].enabled, True)
|
|
|
|
def test_supports_dynamic_linker_is_added_when_DYNAMIC_present(self):
|
|
crosstool = make_crosstool("""
|
|
linking_mode_flags {
|
|
mode: DYNAMIC
|
|
}
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.feature[0].name, "supports_dynamic_linker")
|
|
self.assertEqual(output.feature[0].enabled, True)
|
|
|
|
def test_supports_dynamic_linker_is_not_added_when_present(self):
|
|
crosstool = make_crosstool("""
|
|
feature { name: "supports_dynamic_linker" enabled: false }
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.feature[0].name, "supports_dynamic_linker")
|
|
self.assertEqual(output.feature[0].enabled, False)
|
|
|
|
def test_all_linker_flag_ordering(self):
|
|
crosstool = make_crosstool("""
|
|
linker_flag: 'linker-flag-1'
|
|
compilation_mode_flags {
|
|
mode: OPT
|
|
linker_flag: 'cmf-flag-2'
|
|
}
|
|
linking_mode_flags {
|
|
mode: MOSTLY_STATIC
|
|
linker_flag: 'lmf-flag-3'
|
|
}
|
|
linking_mode_flags {
|
|
mode: DYNAMIC
|
|
linker_flag: 'lmf-dynamic-flag-4'
|
|
}
|
|
dynamic_library_linker_flag: 'dl-flag-5'
|
|
test_only_linker_flag: 'to-flag-6'
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.feature[0].name, "default_link_flags")
|
|
self.assertEqual(output.feature[0].enabled, True)
|
|
self.assertEqual(output.feature[0].flag_set[0].action[:], ALL_CC_LINK_ACTIONS)
|
|
self.assertEqual(output.feature[0].flag_set[0].flag_group[0].flag[:],
|
|
["linker-flag-1"])
|
|
|
|
self.assertEqual(output.feature[0].flag_set[1].action[:], ALL_CC_LINK_ACTIONS)
|
|
self.assertEqual(output.feature[0].flag_set[1].with_feature[0].feature[0],
|
|
"opt")
|
|
self.assertEqual(output.feature[0].flag_set[1].flag_group[0].flag,
|
|
["cmf-flag-2"])
|
|
|
|
self.assertEqual(output.feature[0].flag_set[2].action, CC_LINK_EXECUTABLE)
|
|
self.assertEqual(output.feature[0].flag_set[2].with_feature[0].feature[0],
|
|
"static_linking_mode")
|
|
self.assertEqual(output.feature[0].flag_set[2].flag_group[0].flag,
|
|
["lmf-flag-3"])
|
|
|
|
self.assertEqual(len(output.feature[0].flag_set[3].with_feature), 0)
|
|
self.assertEqual(output.feature[0].flag_set[3].flag_group[0].flag,
|
|
["lmf-dynamic-flag-4"])
|
|
self.assertEqual(output.feature[0].flag_set[3].action,
|
|
NODEPS_DYNAMIC_LIBRARY_LINK_ACTIONS)
|
|
|
|
self.assertEqual(
|
|
output.feature[0].flag_set[4].with_feature[0].not_feature[0],
|
|
"static_link_cpp_runtimes")
|
|
self.assertEqual(output.feature[0].flag_set[4].flag_group[0].flag,
|
|
["lmf-dynamic-flag-4"])
|
|
self.assertEqual(output.feature[0].flag_set[4].action,
|
|
TRANSITIVE_DYNAMIC_LIBRARY_LINK_ACTIONS)
|
|
|
|
self.assertEqual(output.feature[0].flag_set[5].with_feature[0].feature[0],
|
|
"dynamic_linking_mode")
|
|
self.assertEqual(output.feature[0].flag_set[5].flag_group[0].flag,
|
|
["lmf-dynamic-flag-4"])
|
|
self.assertEqual(output.feature[0].flag_set[5].action,
|
|
CC_LINK_EXECUTABLE)
|
|
|
|
self.assertEqual(output.feature[0].flag_set[6].flag_group[0].flag,
|
|
["dl-flag-5"])
|
|
self.assertEqual(output.feature[0].flag_set[6].action,
|
|
DYNAMIC_LIBRARY_LINK_ACTIONS)
|
|
|
|
self.assertEqual(output.feature[0].flag_set[7].flag_group[0].flag,
|
|
["to-flag-6"])
|
|
self.assertEqual(output.feature[0].flag_set[7].action, ALL_CC_LINK_ACTIONS)
|
|
self.assertEqual(
|
|
output.feature[0].flag_set[7].flag_group[0].expand_if_all_available,
|
|
["is_cc_test"])
|
|
|
|
def test_all_linker_flag_objc_actions(self):
|
|
crosstool = make_crosstool("""
|
|
action_config { action_name: "objc-compile" }
|
|
linker_flag: 'linker-flag-1'
|
|
compilation_mode_flags {
|
|
mode: OPT
|
|
linker_flag: 'cmf-flag-2'
|
|
}
|
|
linking_mode_flags {
|
|
mode: MOSTLY_STATIC
|
|
linker_flag: 'lmf-flag-3'
|
|
}
|
|
dynamic_library_linker_flag: 'dl-flag-5'
|
|
test_only_linker_flag: 'to-flag-6'
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.feature[0].name, "default_link_flags")
|
|
self.assertEqual(output.feature[0].flag_set[0].action[:],
|
|
ALL_CC_LINK_ACTIONS + ALL_OBJC_LINK_ACTIONS)
|
|
self.assertEqual(output.feature[0].flag_set[1].action[:],
|
|
ALL_CC_LINK_ACTIONS + ALL_OBJC_LINK_ACTIONS)
|
|
self.assertEqual(output.feature[0].flag_set[2].action[:],
|
|
CC_LINK_EXECUTABLE)
|
|
self.assertEqual(output.feature[0].flag_set[3].action[:],
|
|
DYNAMIC_LIBRARY_LINK_ACTIONS)
|
|
self.assertEqual(output.feature[0].flag_set[4].action[:],
|
|
ALL_CC_LINK_ACTIONS + ALL_OBJC_LINK_ACTIONS)
|
|
|
|
def test_linking_mode_features_are_not_added_when_present(self):
|
|
crosstool = make_crosstool("""
|
|
linking_mode_flags {
|
|
mode: DYNAMIC
|
|
linker_flag: 'dynamic-flag'
|
|
}
|
|
linking_mode_flags {
|
|
mode: FULLY_STATIC
|
|
linker_flag: 'fully-static-flag'
|
|
}
|
|
linking_mode_flags {
|
|
mode: MOSTLY_STATIC
|
|
linker_flag: 'mostly-static-flag'
|
|
}
|
|
linking_mode_flags {
|
|
mode: MOSTLY_STATIC_LIBRARIES
|
|
linker_flag: 'mostly-static-libraries-flag'
|
|
}
|
|
feature { name: "static_linking_mode" }
|
|
feature { name: "dynamic_linking_mode" }
|
|
feature { name: "static_linking_mode_nodeps_library" }
|
|
feature { name: "fully_static_link" }
|
|
""")
|
|
output = migrate_to_string(crosstool)
|
|
self.assertNotIn("linking_mode_flags", output)
|
|
self.assertNotIn("DYNAMIC", output)
|
|
self.assertNotIn("MOSTLY_STATIC", output)
|
|
self.assertNotIn("MOSTLY_STATIC_LIBRARIES", output)
|
|
self.assertNotIn("MOSTLY_STATIC_LIBRARIES", output)
|
|
self.assertNotIn("dynamic-flag", output)
|
|
self.assertNotIn("fully-static-flag", output)
|
|
self.assertNotIn("mostly-static-flag", output)
|
|
self.assertNotIn("mostly-static-libraries-flag", output)
|
|
|
|
def test_unfiltered_require_user_compile_flags_and_sysroot(self):
|
|
crosstool = make_crosstool("""
|
|
feature { name: 'preexisting_feature' }
|
|
unfiltered_cxx_flag: 'unfiltered-flag-1'
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
# all these features are added after features that are already present in
|
|
# the crosstool
|
|
self.assertEqual(output.feature[0].name, "preexisting_feature")
|
|
self.assertEqual(output.feature[1].name, "user_compile_flags")
|
|
self.assertEqual(output.feature[2].name, "sysroot")
|
|
self.assertEqual(output.feature[3].name, "unfiltered_compile_flags")
|
|
|
|
def test_user_compile_flags_not_migrated_when_present(self):
|
|
crosstool = make_crosstool("""
|
|
unfiltered_cxx_flag: 'unfiltered-flag-1'
|
|
feature { name: 'user_compile_flags' }
|
|
feature { name: 'preexisting_feature' }
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.feature[0].name, "user_compile_flags")
|
|
self.assertEqual(output.feature[1].name, "preexisting_feature")
|
|
self.assertEqual(output.feature[2].name, "sysroot")
|
|
self.assertEqual(output.feature[3].name, "unfiltered_compile_flags")
|
|
|
|
def test_sysroot_not_migrated_when_present(self):
|
|
crosstool = make_crosstool("""
|
|
unfiltered_cxx_flag: 'unfiltered-flag-1'
|
|
feature { name: 'sysroot' }
|
|
feature { name: 'preexisting_feature' }
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.feature[0].name, "sysroot")
|
|
self.assertEqual(output.feature[1].name, "preexisting_feature")
|
|
self.assertEqual(output.feature[2].name, "user_compile_flags")
|
|
self.assertEqual(output.feature[3].name, "unfiltered_compile_flags")
|
|
|
|
def test_user_compile_flags(self):
|
|
crosstool = make_crosstool("""
|
|
unfiltered_cxx_flag: 'unfiltered-flag-1'
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.feature[0].name, "user_compile_flags")
|
|
self.assertEqual(output.feature[0].enabled, True)
|
|
self.assertEqual(output.feature[0].flag_set[0].action,
|
|
ALL_CC_COMPILE_ACTIONS)
|
|
self.assertEqual(
|
|
output.feature[0].flag_set[0].flag_group[0].expand_if_all_available,
|
|
["user_compile_flags"])
|
|
self.assertEqual(output.feature[0].flag_set[0].flag_group[0].iterate_over,
|
|
"user_compile_flags")
|
|
self.assertEqual(output.feature[0].flag_set[0].flag_group[0].flag,
|
|
["%{user_compile_flags}"])
|
|
|
|
def test_sysroot(self):
|
|
sysroot_actions = ALL_CC_COMPILE_ACTIONS + ALL_CC_LINK_ACTIONS
|
|
sysroot_actions.remove("assemble")
|
|
self.assertTrue("assemble" not in sysroot_actions)
|
|
crosstool = make_crosstool("""
|
|
unfiltered_cxx_flag: 'unfiltered-flag-1'
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.feature[1].name, "sysroot")
|
|
self.assertEqual(output.feature[1].enabled, True)
|
|
self.assertEqual(output.feature[1].flag_set[0].action, sysroot_actions)
|
|
self.assertEqual(
|
|
output.feature[1].flag_set[0].flag_group[0].expand_if_all_available,
|
|
["sysroot"])
|
|
self.assertEqual(output.feature[1].flag_set[0].flag_group[0].flag,
|
|
["--sysroot=%{sysroot}"])
|
|
|
|
def test_unfiltered_compile_flags_is_not_added_when_already_present(self):
|
|
crosstool = make_crosstool("""
|
|
unfiltered_cxx_flag: 'unfiltered-flag-1'
|
|
feature { name: 'something_else' }
|
|
feature { name: 'unfiltered_compile_flags' }
|
|
feature { name: 'something_else_2' }
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.feature[0].name, "something_else")
|
|
self.assertEqual(output.feature[1].name, "unfiltered_compile_flags")
|
|
self.assertEqual(len(output.feature[1].flag_set), 0)
|
|
self.assertEqual(output.feature[2].name, "something_else_2")
|
|
|
|
def test_unfiltered_compile_flags_is_not_edited_if_old_variant_present(self):
|
|
crosstool = make_crosstool("""
|
|
unfiltered_cxx_flag: 'unfiltered-flag-1'
|
|
feature {
|
|
name: 'unfiltered_compile_flags'
|
|
flag_set {
|
|
action: 'c-compile'
|
|
flag_group {
|
|
flag: 'foo-flag-1'
|
|
}
|
|
}
|
|
}
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.feature[0].name, "unfiltered_compile_flags")
|
|
self.assertEqual(len(output.feature[0].flag_set), 1)
|
|
self.assertEqual(output.feature[0].flag_set[0].action, ["c-compile"])
|
|
self.assertEqual(output.feature[0].flag_set[0].flag_group[0].flag,
|
|
["foo-flag-1"])
|
|
|
|
def test_use_of_unfiltered_compile_flags_var_is_removed_and_replaced(self):
|
|
crosstool = make_crosstool("""
|
|
unfiltered_cxx_flag: 'unfiltered-flag-1'
|
|
feature {
|
|
name: 'unfiltered_compile_flags'
|
|
flag_set {
|
|
action: 'c-compile'
|
|
flag_group {
|
|
flag: 'foo-flag-1'
|
|
}
|
|
}
|
|
flag_set {
|
|
action: 'c++-compile'
|
|
flag_group {
|
|
flag: 'bar-flag-1'
|
|
}
|
|
flag_group {
|
|
expand_if_all_available: 'unfiltered_compile_flags'
|
|
iterate_over: 'unfiltered_compile_flags'
|
|
flag: '%{unfiltered_compile_flags}'
|
|
}
|
|
flag_group {
|
|
flag: 'bar-flag-2'
|
|
}
|
|
}
|
|
flag_set {
|
|
action: 'c-compile'
|
|
flag_group {
|
|
flag: 'foo-flag-2'
|
|
}
|
|
}
|
|
}
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.feature[0].name, "unfiltered_compile_flags")
|
|
self.assertEqual(output.feature[0].flag_set[0].action, ["c-compile"])
|
|
self.assertEqual(output.feature[0].flag_set[0].flag_group[0].flag,
|
|
["foo-flag-1"])
|
|
self.assertEqual(output.feature[0].flag_set[1].action, ["c++-compile"])
|
|
self.assertEqual(output.feature[0].flag_set[1].flag_group[0].flag,
|
|
["bar-flag-1"])
|
|
self.assertEqual(output.feature[0].flag_set[1].flag_group[1].flag,
|
|
["unfiltered-flag-1"])
|
|
self.assertEqual(output.feature[0].flag_set[1].flag_group[2].flag,
|
|
["bar-flag-2"])
|
|
self.assertEqual(output.feature[0].flag_set[2].action, ["c-compile"])
|
|
self.assertEqual(output.feature[0].flag_set[2].flag_group[0].flag,
|
|
["foo-flag-2"])
|
|
|
|
def test_unfiltered_compile_flags_is_added_at_the_end(self):
|
|
crosstool = make_crosstool("""
|
|
feature { name: 'something_else' }
|
|
unfiltered_cxx_flag: 'unfiltered-flag-1'
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.feature[0].name, "something_else")
|
|
self.assertEqual(output.feature[1].name, "user_compile_flags")
|
|
self.assertEqual(output.feature[2].name, "sysroot")
|
|
self.assertEqual(output.feature[3].name, "unfiltered_compile_flags")
|
|
self.assertEqual(output.feature[3].flag_set[0].action,
|
|
ALL_CC_COMPILE_ACTIONS)
|
|
self.assertEqual(output.feature[3].flag_set[0].flag_group[0].flag,
|
|
["unfiltered-flag-1"])
|
|
|
|
def test_unfiltered_compile_flags_are_not_added_for_objc(self):
|
|
crosstool = make_crosstool("""
|
|
action_config { action_name: "obc-compile" }
|
|
feature { name: 'something_else' }
|
|
unfiltered_cxx_flag: 'unfiltered-flag-1'
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.feature[3].name, "unfiltered_compile_flags")
|
|
self.assertEqual(output.feature[3].flag_set[0].action,
|
|
ALL_CC_COMPILE_ACTIONS)
|
|
self.assertEqual(output.feature[3].flag_set[0].flag_group[0].flag,
|
|
["unfiltered-flag-1"])
|
|
|
|
def test_default_link_flags_is_added_first(self):
|
|
crosstool = make_crosstool("""
|
|
linker_flag: 'linker-flag-1'
|
|
feature { name: 'something_else' }
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.feature[0].name, "default_link_flags")
|
|
self.assertEqual(output.feature[0].enabled, True)
|
|
self.assertEqual(output.feature[0].flag_set[0].flag_group[0].flag,
|
|
["linker-flag-1"])
|
|
|
|
def test_default_link_flags_is_not_added_when_already_present(self):
|
|
crosstool = make_crosstool("""
|
|
linker_flag: 'linker-flag-1'
|
|
feature { name: 'something_else' }
|
|
feature { name: 'default_link_flags' }
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.feature[0].name, "something_else")
|
|
self.assertEqual(output.feature[1].name, "default_link_flags")
|
|
|
|
def test_default_compile_flags_is_not_added_when_no_reason_to(self):
|
|
crosstool = make_crosstool("""
|
|
feature { name: 'something_else' }
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.feature[0].name, "something_else")
|
|
self.assertEqual(len(output.feature), 1)
|
|
|
|
def test_default_compile_flags_is_first(self):
|
|
crosstool = make_crosstool("""
|
|
compiler_flag: 'compiler-flag-1'
|
|
feature { name: 'something_else' }
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.feature[0].name, "default_compile_flags")
|
|
self.assertEqual(output.feature[0].enabled, True)
|
|
self.assertEqual(output.feature[0].flag_set[0].flag_group[0].flag,
|
|
["compiler-flag-1"])
|
|
|
|
def test_default_compile_flags_not_added_when_present(self):
|
|
crosstool = make_crosstool("""
|
|
compiler_flag: 'compiler-flag-1'
|
|
feature { name: 'something_else' }
|
|
feature { name: 'default_compile_flags' }
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.feature[0].name, "something_else")
|
|
self.assertEqual(output.feature[1].name, "default_compile_flags")
|
|
self.assertEqual(len(output.feature[1].flag_set), 0)
|
|
|
|
def test_supports_start_end_lib_migrated(self):
|
|
crosstool = make_crosstool("supports_start_end_lib: true")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.feature[0].name, "supports_start_end_lib")
|
|
self.assertEqual(output.feature[0].enabled, True)
|
|
|
|
def test_supports_start_end_lib_not_migrated_on_false(self):
|
|
crosstool = make_crosstool("supports_start_end_lib: false")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(len(output.feature), 0)
|
|
|
|
def test_supports_start_end_lib_not_migrated_when_already_present(self):
|
|
crosstool = make_crosstool("""
|
|
supports_start_end_lib: true
|
|
feature { name: "supports_start_end_lib" enabled: false }
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.feature[0].name, "supports_start_end_lib")
|
|
self.assertEqual(output.feature[0].enabled, False)
|
|
|
|
def test_supports_interface_shared_libraries_migrated(self):
|
|
crosstool = make_crosstool("supports_interface_shared_objects: true")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.feature[0].name,
|
|
"supports_interface_shared_libraries")
|
|
self.assertEqual(output.feature[0].enabled, True)
|
|
|
|
def test_supports_interface_shared_libraries_not_migrated_on_false(self):
|
|
crosstool = make_crosstool("supports_interface_shared_objects: false")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(len(output.feature), 0)
|
|
|
|
def test_supports_interface_shared_libraries_not_migrated_when_present(self):
|
|
crosstool = make_crosstool("""
|
|
supports_interface_shared_objects: true
|
|
feature {
|
|
name: "supports_interface_shared_libraries"
|
|
enabled: false }
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.feature[0].name,
|
|
"supports_interface_shared_libraries")
|
|
self.assertEqual(output.feature[0].enabled, False)
|
|
|
|
def test_supports_embedded_runtimes_migrated(self):
|
|
crosstool = make_crosstool("supports_embedded_runtimes: true")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.feature[0].name, "static_link_cpp_runtimes")
|
|
self.assertEqual(output.feature[0].enabled, True)
|
|
|
|
def test_supports_embedded_runtimes_not_migrated_on_false(self):
|
|
crosstool = make_crosstool("supports_embedded_runtimes: false")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(len(output.feature), 0)
|
|
|
|
def test_supports_embedded_runtimes_not_migrated_when_already_present(self):
|
|
crosstool = make_crosstool("""
|
|
supports_embedded_runtimes: true
|
|
feature { name: "static_link_cpp_runtimes" enabled: false }
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.feature[0].name, "static_link_cpp_runtimes")
|
|
self.assertEqual(output.feature[0].enabled, False)
|
|
|
|
def test_needs_pic_migrated(self):
|
|
crosstool = make_crosstool("needsPic: true")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.feature[0].name, "supports_pic")
|
|
self.assertEqual(output.feature[0].enabled, True)
|
|
|
|
def test_needs_pic_not_migrated_on_false(self):
|
|
crosstool = make_crosstool("needsPic: false")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(len(output.feature), 0)
|
|
|
|
def test_needs_pic_not_migrated_when_already_present(self):
|
|
crosstool = make_crosstool("""
|
|
needsPic: true
|
|
feature { name: "supports_pic" enabled: false }
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.feature[0].name, "supports_pic")
|
|
self.assertEqual(output.feature[0].enabled, False)
|
|
|
|
def test_supports_fission_migrated(self):
|
|
crosstool = make_crosstool("supports_fission: true")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.feature[0].name, "per_object_debug_info")
|
|
self.assertEqual(output.feature[0].enabled, True)
|
|
self.assertEqual(
|
|
output.feature[0].flag_set[0].flag_group[0].expand_if_all_available,
|
|
["is_using_fission"])
|
|
|
|
def test_supports_fission_not_migrated_on_false(self):
|
|
crosstool = make_crosstool("supports_fission: false")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(len(output.feature), 0)
|
|
|
|
def test_supports_fission_not_migrated_when_already_present(self):
|
|
crosstool = make_crosstool("""
|
|
supports_fission: true
|
|
feature { name: "per_object_debug_info" enabled: false }
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.feature[0].name, "per_object_debug_info")
|
|
self.assertEqual(output.feature[0].enabled, False)
|
|
|
|
def test_migrating_objcopy_embed_flag(self):
|
|
crosstool = make_crosstool("""
|
|
tool_path { name: "objcopy" path: "foo/objcopy" }
|
|
objcopy_embed_flag: "a"
|
|
objcopy_embed_flag: "b"
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.feature[0].name, "objcopy_embed_flags")
|
|
self.assertEqual(output.feature[0].enabled, True)
|
|
self.assertEqual(output.feature[0].flag_set[0].action[:],
|
|
["objcopy_embed_data"])
|
|
self.assertEqual(output.feature[0].flag_set[0].flag_group[0].flag[:],
|
|
["a", "b"])
|
|
self.assertEqual(len(output.objcopy_embed_flag), 0)
|
|
self.assertEqual(output.action_config[0].action_name, "objcopy_embed_data")
|
|
self.assertEqual(output.action_config[0].tool[0].tool_path, "foo/objcopy")
|
|
|
|
def test_not_migrating_objcopy_embed_flag_when_feature_present(self):
|
|
crosstool = make_crosstool("""
|
|
objcopy_embed_flag: "a"
|
|
objcopy_embed_flag: "b"
|
|
feature { name: "objcopy_embed_flags" }
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.feature[0].name, "objcopy_embed_flags")
|
|
self.assertEqual(output.feature[0].enabled, False)
|
|
|
|
def test_migrating_ld_embed_flag(self):
|
|
crosstool = make_crosstool("""
|
|
tool_path { name: "ld" path: "foo/ld" }
|
|
ld_embed_flag: "a"
|
|
ld_embed_flag: "b"
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.feature[0].name, "ld_embed_flags")
|
|
self.assertEqual(output.feature[0].enabled, True)
|
|
self.assertEqual(output.feature[0].flag_set[0].action[:], ["ld_embed_data"])
|
|
self.assertEqual(output.feature[0].flag_set[0].flag_group[0].flag[:],
|
|
["a", "b"])
|
|
self.assertEqual(len(output.ld_embed_flag), 0)
|
|
self.assertEqual(output.action_config[0].action_name, "ld_embed_data")
|
|
self.assertEqual(output.action_config[0].tool[0].tool_path, "foo/ld")
|
|
|
|
def test_not_migrating_objcopy_embed_flag_when_feature_present(self):
|
|
crosstool = make_crosstool("""
|
|
objcopy_embed_flag: "a"
|
|
objcopy_embed_flag: "b"
|
|
feature { name: "objcopy_embed_flags" }
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.feature[0].name, "objcopy_embed_flags")
|
|
self.assertEqual(output.feature[0].enabled, False)
|
|
|
|
def test_migrate_expand_if_all_available_from_flag_sets(self):
|
|
crosstool = make_crosstool("""
|
|
action_config {
|
|
action_name: 'something'
|
|
config_name: 'something'
|
|
flag_set {
|
|
expand_if_all_available: 'foo'
|
|
flag_group {
|
|
flag: '%{foo}'
|
|
}
|
|
flag_group {
|
|
flag: 'bar'
|
|
}
|
|
}
|
|
}
|
|
feature {
|
|
name: 'something_else'
|
|
flag_set {
|
|
action: 'c-compile'
|
|
expand_if_all_available: 'foo'
|
|
flag_group {
|
|
flag: '%{foo}'
|
|
}
|
|
flag_group {
|
|
flag: 'bar'
|
|
}
|
|
}
|
|
}
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.action_config[0].action_name, "something")
|
|
self.assertEqual(len(output.action_config[0].flag_set), 1)
|
|
self.assertEqual(
|
|
len(output.action_config[0].flag_set[0].expand_if_all_available), 0)
|
|
self.assertEqual(len(output.action_config[0].flag_set[0].flag_group), 2)
|
|
self.assertEqual(
|
|
output.action_config[0].flag_set[0].flag_group[0]
|
|
.expand_if_all_available, ["foo"])
|
|
self.assertEqual(
|
|
output.action_config[0].flag_set[0].flag_group[1]
|
|
.expand_if_all_available, ["foo"])
|
|
|
|
self.assertEqual(output.feature[0].name, "something_else")
|
|
self.assertEqual(len(output.feature[0].flag_set), 1)
|
|
self.assertEqual(
|
|
len(output.feature[0].flag_set[0].expand_if_all_available), 0)
|
|
self.assertEqual(len(output.feature[0].flag_set[0].flag_group), 2)
|
|
self.assertEqual(
|
|
output.feature[0].flag_set[0].flag_group[0].expand_if_all_available,
|
|
["foo"])
|
|
self.assertEqual(
|
|
output.feature[0].flag_set[0].flag_group[1].expand_if_all_available,
|
|
["foo"])
|
|
|
|
def test_enable_previously_default_features(self):
|
|
default_features = [
|
|
"dependency_file", "random_seed", "module_maps", "module_map_home_cwd",
|
|
"header_module_compile", "include_paths", "pic", "preprocessor_define"
|
|
]
|
|
crosstool = make_crosstool("""
|
|
feature { name: "dependency_file" }
|
|
feature { name: "random_seed" }
|
|
feature { name: "module_maps" }
|
|
feature { name: "module_map_home_cwd" }
|
|
feature { name: "header_module_compile" }
|
|
feature { name: "include_paths" }
|
|
feature { name: "pic" }
|
|
feature { name: "preprocessor_define" }
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
for i in range(0, 8):
|
|
self.assertEqual(output.feature[i].name, default_features[i])
|
|
self.assertTrue(output.feature[i].enabled)
|
|
|
|
def test_migrate_repeated_expand_if_all_available_from_flag_groups(self):
|
|
crosstool = make_crosstool("""
|
|
action_config {
|
|
action_name: 'something'
|
|
config_name: 'something'
|
|
flag_set {
|
|
flag_group {
|
|
expand_if_all_available: 'foo'
|
|
expand_if_all_available: 'bar'
|
|
flag: '%{foo}'
|
|
}
|
|
flag_group {
|
|
expand_if_none_available: 'foo'
|
|
expand_if_none_available: 'bar'
|
|
flag: 'bar'
|
|
}
|
|
}
|
|
}
|
|
feature {
|
|
name: 'something_else'
|
|
flag_set {
|
|
action: 'c-compile'
|
|
flag_group {
|
|
expand_if_all_available: 'foo'
|
|
expand_if_all_available: 'bar'
|
|
flag: '%{foo}'
|
|
}
|
|
flag_group {
|
|
expand_if_none_available: 'foo'
|
|
expand_if_none_available: 'bar'
|
|
flag: 'bar'
|
|
}
|
|
}
|
|
}
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
self.assertEqual(output.action_config[0].action_name, "something")
|
|
self.assertEqual(len(output.action_config[0].flag_set), 1)
|
|
self.assertEqual(
|
|
len(output.action_config[0].flag_set[0].expand_if_all_available), 0)
|
|
self.assertEqual(len(output.action_config[0].flag_set[0].flag_group), 2)
|
|
self.assertEqual(
|
|
output.action_config[0].flag_set[0].flag_group[0]
|
|
.expand_if_all_available, ["foo"])
|
|
self.assertEqual(
|
|
output.action_config[0].flag_set[0].flag_group[0].flag_group[0]
|
|
.expand_if_all_available, ["bar"])
|
|
self.assertEqual(
|
|
output.action_config[0].flag_set[0].flag_group[1]
|
|
.expand_if_none_available, ["foo"])
|
|
self.assertEqual(
|
|
output.action_config[0].flag_set[0].flag_group[1].flag_group[0]
|
|
.expand_if_none_available, ["bar"])
|
|
|
|
self.assertEqual(output.feature[0].name, "something_else")
|
|
self.assertEqual(len(output.feature[0].flag_set), 1)
|
|
self.assertEqual(
|
|
len(output.feature[0].flag_set[0].expand_if_all_available), 0)
|
|
self.assertEqual(len(output.feature[0].flag_set[0].flag_group), 2)
|
|
self.assertEqual(
|
|
output.feature[0].flag_set[0].flag_group[0].expand_if_all_available,
|
|
["foo"])
|
|
self.assertEqual(
|
|
output.feature[0].flag_set[0].flag_group[0].flag_group[0]
|
|
.expand_if_all_available, ["bar"])
|
|
self.assertEqual(
|
|
output.feature[0].flag_set[0].flag_group[1].expand_if_none_available,
|
|
["foo"])
|
|
self.assertEqual(
|
|
output.feature[0].flag_set[0].flag_group[1].flag_group[0]
|
|
.expand_if_none_available, ["bar"])
|
|
|
|
def test_migrate_repeated_expands_from_nested_flag_groups(self):
|
|
crosstool = make_crosstool("""
|
|
feature {
|
|
name: 'something'
|
|
flag_set {
|
|
action: 'c-compile'
|
|
flag_group {
|
|
flag_group {
|
|
expand_if_all_available: 'foo'
|
|
expand_if_all_available: 'bar'
|
|
flag: '%{foo}'
|
|
}
|
|
}
|
|
flag_group {
|
|
flag_group {
|
|
expand_if_all_available: 'foo'
|
|
expand_if_all_available: 'bar'
|
|
expand_if_none_available: 'foo'
|
|
expand_if_none_available: 'bar'
|
|
flag: '%{foo}'
|
|
}
|
|
}
|
|
}
|
|
}
|
|
""")
|
|
migrate_legacy_fields(crosstool)
|
|
output = crosstool.toolchain[0]
|
|
|
|
self.assertEqual(output.feature[0].name, "something")
|
|
self.assertEqual(len(output.feature[0].flag_set[0].flag_group), 2)
|
|
self.assertEqual(
|
|
len(output.feature[0].flag_set[0].flag_group[0].expand_if_all_available
|
|
), 0)
|
|
self.assertEqual(
|
|
output.feature[0].flag_set[0].flag_group[0].flag_group[0]
|
|
.expand_if_all_available, ["foo"])
|
|
self.assertEqual(
|
|
output.feature[0].flag_set[0].flag_group[0].flag_group[0].flag_group[0]
|
|
.expand_if_all_available, ["bar"])
|
|
self.assertEqual(
|
|
output.feature[0].flag_set[0].flag_group[0].flag_group[0].flag_group[0]
|
|
.flag, ["%{foo}"])
|
|
|
|
self.assertEqual(
|
|
output.feature[0].flag_set[0].flag_group[1].flag_group[0]
|
|
.expand_if_all_available, ["foo"])
|
|
self.assertEqual(
|
|
output.feature[0].flag_set[0].flag_group[1].flag_group[0]
|
|
.expand_if_none_available, ["foo"])
|
|
self.assertEqual(
|
|
output.feature[0].flag_set[0].flag_group[1].flag_group[0].flag_group[0]
|
|
.expand_if_none_available, ["bar"])
|
|
self.assertEqual(
|
|
output.feature[0].flag_set[0].flag_group[1].flag_group[0].flag_group[0]
|
|
.expand_if_all_available, ["bar"])
|
|
self.assertEqual(
|
|
output.feature[0].flag_set[0].flag_group[1].flag_group[0].flag_group[0]
|
|
.flag, ["%{foo}"])
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|