| """White-box unit test of cc_binary rule.""" |
| |
| load("@bazel_features//:features.bzl", "bazel_features") |
| load("@rules_testing//lib:analysis_test.bzl", "analysis_test", "test_suite") |
| load("@rules_testing//lib:truth.bzl", "matching", "subjects") |
| load("@rules_testing//lib:util.bzl", "TestingAspectInfo", "util") |
| load("//cc:action_names.bzl", "ACTION_NAMES") |
| load("//cc:cc_binary.bzl", _actual_cc_binary = "cc_binary") |
| load("//cc:cc_import.bzl", "cc_import") |
| load("//cc:cc_library.bzl", "cc_library") |
| load("//cc:cc_test.bzl", _actual_cc_test = "cc_test") |
| load("//tests/cc/testutil:cc_analysis_test.bzl", "MOCK_TOOLCHAINS", "cc_analysis_test") |
| load("//tests/cc/testutil:cc_binary_target_subject.bzl", "cc_binary_target_subject") |
| load("//tests/cc/testutil:link_action_subject.bzl", "link_action_subject") |
| load( |
| "//tests/cc/testutil:mock_rules.bzl", |
| "cc_runtimes_toolchain", |
| "mock_go_library", |
| "mock_runtime_library", |
| ) |
| load("//tests/cc/testutil/toolchains:features.bzl", "FEATURE_NAMES") |
| |
| # Wrap cc_binary to mock out common dependencies. |
| def cc_binary(name, **kwargs): |
| if "malloc" not in kwargs: |
| # Avoid the real "malloc", which might use arbitrary toolchain actions and features. |
| kwargs["malloc"] = "//tests/cc/testutil/toolchains:mock_malloc" |
| _actual_cc_binary( |
| name = name, |
| **kwargs |
| ) |
| |
| # Wrap cc_test to mock out common dependencies. |
| def cc_test(name, **kwargs): |
| if "malloc" not in kwargs: |
| # Avoid the real "malloc", which might use arbitrary toolchain actions and features. |
| kwargs["malloc"] = "//tests/cc/testutil/toolchains:mock_malloc" |
| _actual_cc_test( |
| name = name, |
| **kwargs |
| ) |
| |
| def _test_files_to_build(name, **kwargs): |
| util.helper_target( |
| cc_binary, |
| name = name + "/hello", |
| srcs = ["hello.cc"], |
| ) |
| cc_analysis_test( |
| name = name, |
| impl = _test_files_to_build_impl, |
| target = name + "/hello", |
| **kwargs |
| ) |
| |
| def _test_files_to_build_impl(env, target): |
| cc_binary_subject = cc_binary_target_subject.from_target(env, target) |
| cc_binary_subject.default_outputs().contains_exactly(["{package}/{name}{binary_extension}"]) |
| cc_binary_subject.executable().short_path_equals("{package}/{name}{binary_extension}") |
| |
| def _test_headers_not_passed_to_linking_action(name, **kwargs): |
| util.helper_target( |
| cc_binary, |
| name = name + "/bye", |
| srcs = ["bye.cc", "bye.h"], |
| ) |
| cc_analysis_test( |
| name = name, |
| impl = _test_headers_not_passed_to_linking_action_impl, |
| target = name + "/bye", |
| config_settings = { |
| "//command_line_option:features": ["parse_headers"], |
| "//command_line_option:process_headers_in_dependencies": True, |
| }, |
| **kwargs |
| ) |
| |
| def _test_headers_not_passed_to_linking_action_impl(env, target): |
| link_action_subject.from_target(env, target).inputs().not_contains_predicate( |
| matching.file_extension_in(["h", "hpp", "hxx"]), |
| ) |
| |
| def _test_no_duplicate_linkopts(name, **kwargs): |
| # Regression test for b/943558: linkopts duplicated in linker invocation |
| util.helper_target( |
| cc_binary, |
| name = name + "/hello", |
| srcs = ["hello.cc"], |
| linkopts = ["-fake_option"], |
| ) |
| cc_analysis_test( |
| name = name, |
| impl = _test_no_duplicate_linkopts_impl, |
| target = name + "/hello", |
| **kwargs |
| ) |
| |
| def _test_no_duplicate_linkopts_impl(env, target): |
| link_action = link_action_subject.from_target(env, target) |
| link_action.argv().contains("-fake_option") |
| link_action.argv().transform( |
| filter = matching.equals_wrapper("-fake_option"), |
| ).contains_no_duplicates() |
| |
| def _test_action_graph(name, **kwargs): |
| util.helper_target( |
| cc_binary, |
| name = name + "/hello", |
| srcs = ["hello.cc"], |
| ) |
| config_settings = { |
| "//command_line_option:force_pic": False, |
| } |
| |
| cc_analysis_test( |
| name = name, |
| impl = _test_action_graph_impl, |
| target = name + "/hello", |
| config_settings = config_settings, |
| test_features = [ |
| "no_dotd_file", |
| ], |
| **kwargs |
| ) |
| |
| def _test_action_graph_impl(env, target): |
| executable = target[DefaultInfo].files_to_run.executable |
| link_action = link_action_subject.from_target(env, target) |
| |
| object_file = "{package}/_objs/{name}/hello.o" |
| |
| # link.inputs = { hello.o } |
| link_action.inputs().contains(object_file) |
| |
| # link.outputs = { hello } |
| link_action.outputs().contains_exactly([executable.short_path]) |
| |
| compile_action = env.expect.that_target(target).action_generating(object_file) |
| compile_action.mnemonic().equals("CppCompile") |
| |
| # compile.inputs = { hello_cc } |
| compile_action.inputs().contains("{package}/hello.cc") |
| |
| # compile.outputs = { hello.o } (mock toolchain doesn't generate .d) |
| compile_action.outputs().contains_exactly([ |
| object_file, |
| ]) |
| |
| # TODO: Test stripped action |
| |
| def _make_dll(name): |
| # make a fake dll so the dll shows up in the output directory (where the |
| # binary will be) instead of as a source file (the way cc_import on its own would) |
| # Example taken from |
| # https://github.com/bazelbuild/bazel/blob/f720ed385e245e292b0afe19ebd84e4283c30565/examples/windows/dll/windows_dll_library.bzl |
| dll = name + ".dll" |
| mask = name + "_mask" |
| |
| util.helper_target( |
| cc_binary, |
| name = dll, |
| srcs = ["hello.cc"], |
| linkshared = 1, |
| ) |
| |
| # Mask the cc_binary behind a cc_import so we can depend on it as a library |
| util.helper_target( |
| cc_import, |
| name = mask, |
| shared_library = dll, |
| ) |
| |
| # cc_imports are always source files, so make it a generated file again |
| util.helper_target( |
| cc_library, |
| name = name, |
| deps = [mask], |
| ) |
| |
| def _test_runtime_dynamic_libraries_copy_behavior(name, **kwargs): |
| sub_dir_lib = name + "/dst/sub/sub_dir_lib" |
| same_dir_lib = name + "/dst/same_dir_lib" |
| binary_target = name + "/dst/hello" |
| |
| # project a dll into the same directory as the binary, and a second one in |
| # a subdirectory |
| _make_dll(same_dir_lib) |
| _make_dll(sub_dir_lib) |
| |
| util.helper_target( |
| cc_binary, |
| name = binary_target, |
| srcs = ["hello.cc"], |
| deps = [ |
| same_dir_lib, |
| sub_dir_lib, |
| ], |
| linkstatic = False, |
| ) |
| |
| analysis_test( |
| name = name, |
| impl = _test_runtime_dynamic_libraries_copy_behavior_impl, |
| target = binary_target, |
| # TODO: This would be better-done with the mock toolchain, once that is |
| # wired up |
| attrs = { |
| "copy_feature_supported": attr.bool(), |
| }, |
| attr_values = { |
| "copy_feature_supported": select({ |
| # copy_dynamic_libraries_to_binary is only defined in the |
| # windows toolchain currently |
| "@platforms//os:windows": True, |
| "//conditions:default": False, |
| }), |
| "size": "small", |
| }, |
| **kwargs |
| ) |
| |
| def _test_runtime_dynamic_libraries_copy_behavior_impl(env, target): |
| if not env.ctx.attr.copy_feature_supported: |
| return |
| |
| test_name = env.ctx.label.name |
| |
| expected_copied_library = "tests/cc/common/{name}/dst/sub_dir_lib.dll".format( |
| name = test_name, |
| ) |
| expected_same_dir_library = "tests/cc/common/{name}/dst/same_dir_lib.dll".format( |
| name = test_name, |
| ) |
| |
| # Both libraries should be listed as runtime dependencies, but... |
| expected_libraries = [expected_copied_library, expected_same_dir_library] |
| |
| env.expect \ |
| .that_target(target) \ |
| .output_group("runtime_dynamic_libraries") \ |
| .contains_exactly(expected_libraries) |
| |
| actions = {} |
| for action in target[TestingAspectInfo].actions: |
| if action.mnemonic != "Symlink": |
| continue |
| |
| for output in action.outputs.to_list(): |
| if output.short_path in expected_libraries: |
| actions[output.short_path] = action |
| |
| # ... only one of the libraries should have a Symlink action (Copying |
| # Execution Dynamic Library) since the other one should already be in the |
| # same dir |
| expected_copies = [expected_copied_library] |
| env.expect.that_dict(actions).keys().contains_exactly(expected_copies) |
| |
| def _test_pic(name, **kwargs): |
| util.helper_target( |
| cc_binary, |
| name = name + "/hello", |
| srcs = ["hello.cc"], |
| ) |
| cc_analysis_test( |
| name = name, |
| impl = _test_pic_impl, |
| target = name + "/hello", |
| test_features = [FEATURE_NAMES.supports_pic], |
| config_settings = { |
| "//command_line_option:force_pic": True, |
| }, |
| **kwargs |
| ) |
| |
| def _test_pic_impl(env, target): |
| link_action = link_action_subject.from_target(env, target) |
| link_action.inputs().contains_predicate( |
| matching.file_basename_equals("hello.pic.o"), |
| ) |
| |
| def _generated_def_file_test(name, impl, with_action_configs = None, **kwargs): |
| if with_action_configs == None: |
| with_action_configs = [] |
| |
| util.helper_target( |
| cc_binary, |
| name = name + "/hello", |
| srcs = ["hello.cc"], |
| linkshared = True, |
| ) |
| cc_analysis_test( |
| name = name, |
| impl = impl, |
| target = name + "/hello", |
| test_features = [ |
| FEATURE_NAMES.copy_dynamic_libraries_to_binary, |
| FEATURE_NAMES.targets_windows, |
| FEATURE_NAMES.windows_export_all_symbols, |
| ], |
| with_action_configs = with_action_configs, |
| **kwargs |
| ) |
| |
| def _generated_def_file_action(env, target): |
| action = cc_binary_target_subject.from_target(env, target).action_generating( |
| "{package}/{name}.gen.def", |
| ) |
| action.mnemonic().equals("DefParser") |
| return action |
| |
| # buildifier: disable=unused-variable |
| def _test_generated_def_file_uses_default_tool(name, **kwargs): |
| _generated_def_file_test( |
| name, |
| _test_generated_def_file_uses_default_tool_impl, |
| **kwargs |
| ) |
| |
| def _test_generated_def_file_uses_default_tool_impl(env, target): |
| _generated_def_file_action(env, target).argv().contains_predicate( |
| matching.contains("tools/def_parser"), |
| ) |
| |
| # buildifier: disable=unused-variable |
| def _test_generated_def_file_uses_toolchain_action(name, **kwargs): |
| _generated_def_file_test( |
| name, |
| _test_generated_def_file_uses_toolchain_action_impl, |
| with_action_configs = [ACTION_NAMES.generate_def_file], |
| **kwargs |
| ) |
| |
| def _test_generated_def_file_uses_toolchain_action_impl(env, target): |
| _generated_def_file_action(env, target).argv().contains_predicate( |
| matching.contains("def_parser_tool"), |
| ) |
| |
| def _test_duplicate_linkopts(name, **kwargs): |
| util.helper_target( |
| cc_library, |
| name = name + "/lib", |
| srcs = ["lib.cc"], |
| linkopts = [ |
| "-z bar", |
| "-z baz", |
| ], |
| ) |
| |
| util.helper_target( |
| cc_binary, |
| name = name + "/app", |
| srcs = ["app.cc"], |
| linkopts = [ |
| "-z foo", |
| "-z bar", |
| ], |
| deps = [name + "/lib"], |
| ) |
| |
| cc_analysis_test( |
| name = name, |
| impl = _test_duplicate_linkopts_impl, |
| target = name + "/app", |
| **kwargs |
| ) |
| |
| def _test_duplicate_linkopts_impl(env, target): |
| executable = target[DefaultInfo].files_to_run.executable |
| link_action = env.expect.that_target(target).action_generating(executable.short_path) |
| argv = link_action.actual.argv |
| env.expect.that_collection(argv).contains_at_least([ |
| "-z", |
| "foo", |
| "-z", |
| "bar", |
| "-z", |
| "bar", |
| "-z", |
| "baz", |
| ]).in_order() |
| |
| def _test_unsupported_src_file(name, **kwargs): |
| util.helper_target( |
| cc_binary, |
| name = name + "/bad", |
| srcs = ["bad.unknown"], |
| ) |
| |
| cc_analysis_test( |
| name = name, |
| impl = _test_unsupported_src_file_impl, |
| target = name + "/bad", |
| expect_failure = True, |
| **kwargs |
| ) |
| |
| def _test_unsupported_src_file_impl(env, target): |
| env.expect.that_target(target).failures().contains_predicate( |
| matching.contains("is misplaced here"), |
| ) |
| env.expect.that_target(target).failures().contains_predicate( |
| matching.contains("bad.unknown"), |
| ) |
| |
| def _test_missing_action_config_for_strip_is_a_rule_error(name, **kwargs): |
| util.helper_target( |
| cc_binary, |
| name = name + "/hello", |
| srcs = ["hello.cc"], |
| ) |
| cc_analysis_test( |
| name = name, |
| impl = _test_missing_action_config_for_strip_is_a_rule_error_impl, |
| target = name + "/hello", |
| test_features = [FEATURE_NAMES.no_legacy_features, FEATURE_NAMES.pic], |
| with_action_configs = [ |
| ACTION_NAMES.cpp_compile, |
| ACTION_NAMES.cpp_link_static_library, |
| ACTION_NAMES.cpp_link_executable, |
| ], |
| expect_failure = True, |
| **kwargs |
| ) |
| |
| def _test_missing_action_config_for_strip_is_a_rule_error_impl(env, target): |
| env.expect.that_target(target).failures().contains_predicate( |
| matching.contains("Expected action_config for 'strip' to be configured."), |
| ) |
| |
| def _test_sanitize_pwd_feature_enabled(name, **kwargs): |
| """sanitize_pwd is on by default, PWD should be set via the feature's env_set.""" |
| util.helper_target( |
| cc_binary, |
| name = name + "/hello", |
| srcs = ["hello.cc"], |
| ) |
| cc_analysis_test( |
| name = name, |
| impl = _test_sanitize_pwd_feature_enabled_impl, |
| target = name + "/hello", |
| config_settings = { |
| "//command_line_option:platforms": str(Label("//tests/cc/testutil/toolchains:linux_x86_64")), |
| }, |
| **kwargs |
| ) |
| |
| def _test_sanitize_pwd_feature_enabled_impl(env, target): |
| link_action = link_action_subject.from_target(env, target) |
| link_action.env().get("PWD", factory = subjects.str).equals("/proc/self/cwd") |
| |
| def _test_sanitize_pwd_feature_disabled(name, **kwargs): |
| """When sanitize_pwd is explicitly disabled, the legacy requires_darwin fallback still applies.""" |
| util.helper_target( |
| cc_binary, |
| name = name + "/hello", |
| srcs = ["hello.cc"], |
| ) |
| cc_analysis_test( |
| name = name, |
| impl = _test_sanitize_pwd_feature_disabled_impl, |
| target = name + "/hello", |
| config_settings = { |
| "//command_line_option:features": ["-sanitize_pwd"], |
| }, |
| **kwargs |
| ) |
| |
| def _test_sanitize_pwd_feature_disabled_impl(env, target): |
| link_action = link_action_subject.from_target(env, target) |
| link_action.env().get("PWD", factory = subjects.str).equals("/proc/self/cwd") |
| |
| def _test_sanitize_pwd_macos_no_pwd(name, **kwargs): |
| """On macOS, sanitize_pwd is enabled but should not set PWD.""" |
| util.helper_target( |
| cc_binary, |
| name = name + "/hello", |
| srcs = ["hello.cc"], |
| ) |
| cc_analysis_test( |
| name = name, |
| impl = _test_sanitize_pwd_macos_no_pwd_impl, |
| target = name + "/hello", |
| config_settings = { |
| "//command_line_option:platforms": str(Label("//tests/cc/testutil/toolchains:macos_arm64")), |
| }, |
| **kwargs |
| ) |
| |
| def _test_sanitize_pwd_macos_no_pwd_impl(env, target): |
| link_action = link_action_subject.from_target(env, target) |
| link_action.env().keys().not_contains("PWD") |
| |
| def _include_paths_from_argv(argv, flag): |
| include_paths = [] |
| for i in range(len(argv) - 1): |
| if argv[i] == flag: |
| include_paths.append(argv[i + 1]) |
| return include_paths |
| |
| def _system_include_paths_from_argv(argv): |
| return _include_paths_from_argv(argv, "-isystem") |
| |
| def _test_system_include_paths_reclassifies_local_includes_without_propagation(name, **kwargs): |
| util.helper_target( |
| cc_library, |
| name = name + "/dep", |
| srcs = ["dep.cc", "dep_local.h"], |
| hdrs = ["dep_public.h"], |
| local_includes = ["dep_private"], |
| ) |
| util.helper_target( |
| cc_binary, |
| name = name + "/hello", |
| srcs = ["hello.cc", "hello_local.h"], |
| deps = [name + "/dep"], |
| local_includes = ["hello_private"], |
| ) |
| cc_analysis_test( |
| name = name, |
| impl = _test_system_include_paths_reclassifies_local_includes_without_propagation_impl, |
| target = name + "/hello", |
| config_settings = { |
| "//command_line_option:features": ["system_include_paths"], |
| }, |
| **kwargs |
| ) |
| |
| def _test_system_include_paths_reclassifies_local_includes_without_propagation_impl(env, target): |
| executable = target[DefaultInfo].files_to_run.executable |
| link_action = env.expect.that_target(target).action_generating(executable.short_path) |
| hello_obj_files = [ |
| f |
| for f in link_action.actual.inputs.to_list() |
| if f.basename.startswith("hello.") and f.extension in ["o", "obj"] |
| ] |
| |
| env.expect.that_collection(hello_obj_files).has_size(1) |
| compile_action = env.expect.that_target(target).action_generating(hello_obj_files[0].short_path) |
| system_include_paths = _system_include_paths_from_argv(compile_action.actual.argv) |
| |
| env.expect.that_collection(system_include_paths).contains_predicate( |
| matching.str_endswith("/hello_private"), |
| ) |
| env.expect.that_collection(system_include_paths).transform( |
| filter = matching.str_endswith("/dep_private"), |
| ).contains_exactly([]) |
| |
| def _test_system_include_paths_reclassifies_local_includes_after_includes(name, **kwargs): |
| util.helper_target( |
| cc_library, |
| name = name + "/dep", |
| srcs = ["dep.cc", "dep_local.h"], |
| hdrs = ["dep_public.h"], |
| includes = ["dep_includes"], |
| local_includes = ["dep_private"], |
| ) |
| cc_analysis_test( |
| name = name, |
| impl = _test_system_include_paths_reclassifies_local_includes_after_includes_impl, |
| target = name + "/dep", |
| config_settings = { |
| "//command_line_option:features": ["system_include_paths"], |
| }, |
| **kwargs |
| ) |
| |
| def _test_system_include_paths_reclassifies_local_includes_after_includes_impl(env, target): |
| dep_compile_actions = [] |
| for action in target[TestingAspectInfo].actions: |
| if action.mnemonic != "CppCompile": |
| continue |
| for output in action.outputs.to_list(): |
| if output.basename.startswith("dep.") and output.extension in ["o", "obj"]: |
| dep_compile_actions.append(action) |
| break |
| |
| env.expect.that_collection(dep_compile_actions).has_size(1) |
| dep_system_include_paths = _system_include_paths_from_argv(dep_compile_actions[0].argv) |
| |
| dep_system_include_kinds = [] |
| for path in dep_system_include_paths: |
| if path.endswith("/dep_includes"): |
| dep_system_include_kinds.append("dep_includes") |
| elif path.endswith("/dep_private"): |
| dep_system_include_kinds.append("dep_private") |
| |
| env.expect.that_collection(dep_system_include_kinds).contains_at_least([ |
| "dep_includes", |
| "dep_private", |
| ]).in_order() |
| |
| # buildifier: disable=unused-variable |
| def _test_external_include_paths_reclassifies_external_quote_includes(name, **kwargs): |
| util.helper_target( |
| cc_binary, |
| name = name + "/hello", |
| srcs = ["hello.cc"], |
| deps = ["@googletest//:gtest"], |
| ) |
| cc_analysis_test( |
| name = name, |
| impl = _test_external_include_paths_reclassifies_external_quote_includes_impl, |
| target = name + "/hello", |
| test_features = [FEATURE_NAMES.external_include_paths], |
| **kwargs |
| ) |
| |
| def _test_external_include_paths_reclassifies_external_quote_includes_impl(env, target): |
| executable = target[DefaultInfo].files_to_run.executable |
| link_action = env.expect.that_target(target).action_generating(executable.short_path) |
| hello_obj_files = [ |
| f |
| for f in link_action.actual.inputs.to_list() |
| if f.basename.startswith("hello.") and f.extension in ["o", "obj"] |
| ] |
| |
| env.expect.that_collection(hello_obj_files).has_size(1) |
| compile_action = env.expect.that_target(target).action_generating(hello_obj_files[0].short_path) |
| quote_include_paths = _include_paths_from_argv(compile_action.actual.argv, "-iquote") |
| system_include_paths = _system_include_paths_from_argv(compile_action.actual.argv) |
| |
| if not quote_include_paths: |
| fail("expected the compile action to still have non-external -iquote paths") |
| env.expect.that_collection(system_include_paths).contains_predicate( |
| matching.contains("googletest"), |
| ) |
| env.expect.that_collection(quote_include_paths).transform( |
| filter = matching.contains("googletest"), |
| ).contains_exactly([]) |
| |
| def _test_linkopts_diamond(name, **kwargs): |
| util.helper_target( |
| cc_library, |
| name = name + "/core", |
| srcs = ["core.cc"], |
| linkopts = ["-z core"], |
| ) |
| util.helper_target( |
| cc_library, |
| name = name + "/lib1", |
| srcs = ["lib1.cc"], |
| linkopts = ["-z lib1"], |
| deps = [name + "/core"], |
| ) |
| util.helper_target( |
| cc_library, |
| name = name + "/lib2", |
| srcs = ["lib2.cc"], |
| linkopts = ["-z lib2"], |
| deps = [name + "/core"], |
| ) |
| util.helper_target( |
| cc_binary, |
| name = name + "/app", |
| srcs = ["app.cc"], |
| linkopts = ["-z app"], |
| deps = [ |
| name + "/lib1", |
| name + "/lib2", |
| ], |
| ) |
| cc_analysis_test( |
| name = name, |
| impl = _test_linkopts_diamond_impl, |
| target = name + "/app", |
| **kwargs |
| ) |
| |
| def _test_linkopts_diamond_impl(env, target): |
| link_action = link_action_subject.from_target(env, target) |
| link_action.argv().contains_at_least([ |
| "-z", |
| "app", |
| "-z", |
| "lib1", |
| "-z", |
| "lib2", |
| "-z", |
| "core", |
| ]).in_order() |
| |
| def _test_linkopts_fake_diamond(name, **kwargs): |
| util.helper_target( |
| cc_library, |
| name = name + "/core1", |
| srcs = ["core.cc"], |
| linkopts = ["-z core"], |
| ) |
| util.helper_target( |
| cc_library, |
| name = name + "/core2", |
| srcs = ["core.cc"], |
| linkopts = ["-z core"], |
| ) |
| util.helper_target( |
| cc_library, |
| name = name + "/lib1", |
| srcs = ["lib1.cc"], |
| linkopts = ["-z lib1"], |
| deps = [name + "/core1"], |
| ) |
| util.helper_target( |
| cc_library, |
| name = name + "/lib2", |
| srcs = ["lib2.cc"], |
| linkopts = ["-z lib2"], |
| deps = [name + "/core2"], |
| ) |
| util.helper_target( |
| cc_binary, |
| name = name + "/app", |
| srcs = ["app.cc"], |
| linkopts = ["-z app"], |
| deps = [ |
| name + "/lib1", |
| name + "/lib2", |
| ], |
| ) |
| cc_analysis_test( |
| name = name, |
| impl = _test_linkopts_fake_diamond_impl, |
| target = name + "/app", |
| **kwargs |
| ) |
| |
| def _test_linkopts_fake_diamond_impl(env, target): |
| link_action = link_action_subject.from_target(env, target) |
| link_action.argv().contains_at_least([ |
| "-z", |
| "app", |
| "-z", |
| "lib1", |
| "-z", |
| "core", |
| "-z", |
| "lib2", |
| "-z", |
| "core", |
| ]).in_order() |
| |
| def _is_shared_library(f): |
| return f.extension in ["so", "dylib", "dll", "ifso"] or ".so" in f.basename or ".dylib" in f.basename |
| |
| def _assert_link_staticness(env, target, expected_static): |
| link_action = link_action_subject.from_target(env, target) |
| shared_library_matcher = matching.custom("is shared library", _is_shared_library) |
| |
| if expected_static: |
| link_action.inputs().not_contains_predicate(shared_library_matcher) |
| else: |
| link_action.inputs().contains_predicate(shared_library_matcher) |
| |
| def _create_dep_tree(name, use_actual_cc_binary = False): |
| binary_rule = _actual_cc_binary if use_actual_cc_binary else cc_binary |
| |
| # Mallocs |
| util.helper_target( |
| cc_library, |
| name = name + "/system_malloc", |
| srcs = ["system_malloc.cc"], |
| ) |
| util.helper_target( |
| cc_library, |
| name = name + "/mymalloc", |
| srcs = ["mymalloc.cc"], |
| linkopts = ["-Lmalloc_dir -lmalloc_opt"], |
| ) |
| |
| # Infrastructure |
| util.helper_target( |
| cc_library, |
| name = name + "/infrastructure1", |
| srcs = ["infrastructure1.cc"], |
| linkopts = [ |
| "-Linfrastructure1_dir", |
| "-linfrastructure1_opt", |
| ], |
| linkstamp = "linkstamp.cc", |
| linkstatic = 1, |
| ) |
| util.helper_target( |
| cc_library, |
| name = name + "/infrastructure2", |
| srcs = ["infrastructure2.cc"], |
| linkopts = ["-Linfrastructure2_dir -linfrastructure2_opt"], |
| linkstamp = "linkstamp.cc", |
| ) |
| |
| # Middleware |
| util.helper_target( |
| cc_library, |
| name = name + "/middleware1", |
| srcs = ["middleware1.cc"], |
| linkopts = [ |
| "-Lmiddleware1_dir", |
| "-lmiddleware1_opt", |
| ], |
| deps = [name + "/infrastructure1"], |
| ) |
| util.helper_target( |
| binary_rule, |
| name = name + "/middleware2.so", |
| srcs = ["middleware2.cc"], |
| linkopts = [ |
| "-Lmiddleware2_dir", |
| "-lmiddleware2_opt", |
| ], |
| linkshared = 1, |
| linkstatic = 1, |
| deps = [name + "/infrastructure2"], |
| ) |
| util.helper_target( |
| binary_rule, |
| name = name + "/middleware3.so.1", |
| srcs = ["middleware3.cc"], |
| linkopts = [ |
| "-Lmiddleware3_dir", |
| "-lmiddleware3_opt", |
| ], |
| linkshared = 1, |
| deps = [name + "/infrastructure2"], |
| ) |
| |
| # App |
| util.helper_target( |
| binary_rule, |
| name = name + "/app", |
| srcs = ["app.cc"], |
| # Override potential default link_extra_lib attribute value |
| link_extra_lib = "//tests/cc/testutil/toolchains:link_extra_lib", |
| linkopts = [ |
| "-Lapp_dir1 -Lapp_dir2", |
| "-lapp_opt", |
| ], |
| deps = [ |
| name + "/middleware1", |
| name + "/middleware2.so", |
| name + "/middleware3.so.1", |
| ], |
| ) |
| util.helper_target( |
| binary_rule, |
| name = name + "/app_nonstatic", |
| srcs = ["app.cc"], |
| # Override potential default link_extra_lib attribute value |
| link_extra_lib = "//tests/cc/testutil/toolchains:link_extra_lib", |
| linkopts = [ |
| "-Lapp_dir1 -Lapp_dir2", |
| "-lapp_opt", |
| ], |
| linkstatic = 0, |
| deps = [ |
| name + "/middleware1", |
| name + "/middleware2.so", |
| name + "/middleware3.so.1", |
| ], |
| ) |
| |
| # buildifier: disable=unused-variable |
| def _test_cc_runtimes_added_to_libraries(name, **kwargs): |
| _create_dep_tree(name) |
| cc_analysis_test( |
| name = name, |
| impl = _test_cc_runtimes_added_to_libraries_impl, |
| target = name + "/app", |
| test_features = [ |
| FEATURE_NAMES.supports_pic, |
| ], |
| config_settings = { |
| "//command_line_option:extra_toolchains": ",".join( |
| MOCK_TOOLCHAINS + [ |
| "//tests/cc/common:cc_runtimes_mock_toolchain", |
| ], |
| ), |
| }, |
| **kwargs |
| ) |
| |
| def _test_cc_runtimes_added_to_libraries_impl(env, target): |
| link_action = link_action_subject.from_target(env, target) |
| link_action.inputs().contains_at_least_predicates([ |
| matching.file_basename_equals("app.pic.o"), |
| matching.file_basename_equals("libmiddleware1.a"), |
| matching.file_basename_equals("libinfrastructure1.a"), |
| matching.file_basename_equals("liblink_extra_lib.a"), |
| matching.file_basename_equals("libruntime.a"), |
| matching.file_basename_equals("linkstamp.o"), |
| ]) |
| |
| def _test_ignore_custom_malloc(name, **kwargs): |
| _create_dep_tree(name, use_actual_cc_binary = True) |
| custom_malloc_label = Label("//tests/cc/common:" + name + "/system_malloc") |
| cc_analysis_test( |
| name = name, |
| impl = _test_ignore_custom_malloc_impl, |
| target = name + "/app", |
| config_settings = { |
| "//command_line_option:custom_malloc": custom_malloc_label, |
| }, |
| **kwargs |
| ) |
| |
| def _test_ignore_custom_malloc_impl(env, target): |
| link_action = link_action_subject.from_target(env, target) |
| link_action.inputs().contains_predicate(matching.file_basename_equals("libsystem_malloc.a")) |
| link_action.inputs().not_contains_predicate(matching.file_basename_equals("libmock_malloc.a")) |
| |
| def _test_custom_malloc(name, **kwargs): |
| _create_dep_tree(name, use_actual_cc_binary = True) |
| custom_malloc_label = Label("//tests/cc/common:" + name + "/mymalloc") |
| cc_analysis_test( |
| name = name, |
| impl = _test_custom_malloc_impl, |
| target = name + "/app", |
| test_features = [FEATURE_NAMES.supports_pic], |
| config_settings = { |
| "//command_line_option:custom_malloc": custom_malloc_label, |
| }, |
| **kwargs |
| ) |
| |
| def _test_custom_malloc_impl(env, target): |
| link_action = link_action_subject.from_target(env, target) |
| link_action.inputs().contains_predicate(matching.file_basename_equals("libmymalloc.a")) |
| link_action.inputs().not_contains_predicate(matching.file_basename_equals("libmock_malloc.a")) |
| |
| def _test_app_linking_static(name, **kwargs): |
| _create_dep_tree(name) |
| cc_analysis_test( |
| name = name, |
| impl = _test_app_linking_static_impl, |
| target = name + "/app", |
| test_features = [ |
| FEATURE_NAMES.supports_pic, |
| FEATURE_NAMES.supports_dynamic_linker, |
| FEATURE_NAMES.supports_interface_shared_libraries, |
| ], |
| **kwargs |
| ) |
| |
| def _test_app_linking_static_impl(env, target): |
| link_action = link_action_subject.from_target(env, target) |
| |
| # Assert inputs |
| link_action.inputs().contains_at_least_predicates([ |
| matching.file_basename_equals("app.pic.o"), |
| matching.file_basename_equals("libmiddleware1.a"), |
| matching.file_basename_equals("libinfrastructure1.a"), |
| matching.file_basename_equals("linkstamp.o"), |
| ]) |
| |
| # Assert NOT inputs |
| link_action.inputs().not_contains_predicate(matching.file_basename_equals("libinfrastructure2.a")) |
| link_action.inputs().not_contains_predicate(matching.file_basename_equals("libmiddleware2.so")) |
| link_action.inputs().not_contains_predicate(matching.file_basename_equals("libmiddleware3.so.1")) |
| |
| # Assert linkopts |
| link_action.argv().contains_at_least([ |
| "-Lapp_dir1", |
| "-Lapp_dir2", |
| "-lapp_opt", |
| "-Lmiddleware1_dir", |
| "-lmiddleware1_opt", |
| "-Linfrastructure1_dir", |
| "-linfrastructure1_opt", |
| ]).in_order() |
| |
| def _test_app_linking_dynamic(name, **kwargs): |
| _create_dep_tree(name) |
| cc_analysis_test( |
| name = name, |
| impl = _test_app_linking_dynamic_impl, |
| target = name + "/app_nonstatic", |
| test_features = [ |
| FEATURE_NAMES.supports_pic, |
| FEATURE_NAMES.supports_dynamic_linker, |
| FEATURE_NAMES.supports_interface_shared_libraries, |
| ], |
| **kwargs |
| ) |
| |
| def _test_app_linking_dynamic_impl(env, target): |
| link_action = link_action_subject.from_target(env, target) |
| |
| # Assert inputs |
| link_action.inputs().contains_at_least_predicates([ |
| matching.file_basename_equals("app.pic.o"), |
| matching.file_basename_equals("libinfrastructure1.a"), |
| matching.file_basename_equals("linkstamp.o"), |
| ]) |
| |
| # Assert dynamic library symlink (mangled) |
| link_action.inputs().contains_predicate( |
| matching.custom("basename ends with _Slibmiddleware1.ifso", lambda f: f.basename.endswith("_Slibmiddleware1.ifso")), |
| ) |
| |
| # Assert NOT inputs |
| link_action.inputs().not_contains_predicate(matching.file_basename_equals("libmiddleware1.a")) |
| link_action.inputs().not_contains_predicate(matching.file_basename_equals("libinfrastructure2.a")) |
| |
| # Assert linkopts |
| link_action.argv().contains_at_least([ |
| "-Lapp_dir1", |
| "-Lapp_dir2", |
| "-lapp_opt", |
| "-Lmiddleware1_dir", |
| "-lmiddleware1_opt", |
| "-Linfrastructure1_dir", |
| "-linfrastructure1_opt", |
| ]).in_order() |
| |
| def _test_so_in_srcs(name, **kwargs): |
| util.helper_target( |
| cc_binary, |
| name = name + "/cookies", |
| srcs = [ |
| "cookies.cc", |
| "library.so", |
| "library2.so.1", |
| ], |
| ) |
| cc_analysis_test( |
| name = name, |
| impl = _test_so_in_srcs_impl, |
| target = name + "/cookies", |
| **kwargs |
| ) |
| |
| def _test_so_in_srcs_impl(env, target): |
| runfiles = env.expect.that_target(target).runfiles() |
| runfiles.contains_predicate(matching.str_endswith("library.so")) |
| runfiles.not_contains_predicate(matching.str_endswith("library.so.1")) |
| runfiles.contains_predicate(matching.str_endswith("library2.so.1")) |
| runfiles.not_contains_predicate(matching.str_endswith("library2.so")) |
| |
| def _create_three_rules_chain(name): |
| util.helper_target( |
| cc_library, |
| name = name + "/baz", |
| srcs = ["baz.cc"], |
| linkstamp = "linkstamp.cc", |
| ) |
| util.helper_target( |
| cc_library, |
| name = name + "/bar", |
| srcs = ["bar.cc"], |
| deps = [":" + name + "/baz"], |
| ) |
| util.helper_target( |
| cc_binary, |
| name = name + "/foo", |
| srcs = ["foo.cc"], |
| deps = [":" + name + "/bar"], |
| ) |
| |
| def _test_transitive_libs_are_collected(name, **kwargs): |
| _create_three_rules_chain(name) |
| cc_analysis_test( |
| name = name, |
| impl = _test_transitive_libs_are_collected_impl, |
| target = name + "/foo", |
| config_settings = { |
| "//command_line_option:start_end_lib": False, |
| }, |
| test_features = [FEATURE_NAMES.supports_pic], |
| **kwargs |
| ) |
| |
| def _test_transitive_libs_are_collected_impl(env, target): |
| link_action = link_action_subject.from_target(env, target) |
| link_action.inputs().contains_at_least_predicates([ |
| matching.file_basename_equals("foo.pic.o"), |
| matching.file_basename_equals("libbar.a"), |
| matching.file_basename_equals("libbaz.a"), |
| matching.file_basename_equals("linkstamp.o"), |
| ]) |
| |
| def _test_transitive_linkstamps_are_collected(name, **kwargs): |
| _create_three_rules_chain(name) |
| cc_analysis_test( |
| name = name, |
| impl = _test_transitive_linkstamps_are_collected_impl, |
| target = name + "/foo", |
| **kwargs |
| ) |
| |
| def _test_transitive_linkstamps_are_collected_impl(env, target): |
| link_action = link_action_subject.from_target(env, target) |
| link_action.inputs().contains_predicate(matching.file_basename_equals("linkstamp.o")) |
| link_action.inputs().not_contains_predicate(matching.file_basename_equals("linkstamp.cc")) |
| |
| def _test_linker_toolchain_feature(name, **kwargs): |
| util.helper_target( |
| cc_binary, |
| name = name + "/foo", |
| srcs = ["foo.cc"], |
| ) |
| cc_analysis_test( |
| name = name, |
| impl = _test_linker_toolchain_feature_impl, |
| target = name + "/foo", |
| test_features = [FEATURE_NAMES.link_env], |
| **kwargs |
| ) |
| |
| def _test_linker_toolchain_feature_impl(env, target): |
| link_action = link_action_subject.from_target(env, target) |
| link_action.env().contains_at_least({"foo": "bar"}) |
| |
| def _test_go_code_comes_after_deps(name, **kwargs): |
| util.helper_target( |
| mock_go_library, |
| name = name + "/go_lib", |
| ) |
| util.helper_target( |
| cc_library, |
| name = name + "/cc_lib", |
| srcs = ["cc_lib.cc"], |
| deps = [":" + name + "/go_lib"], |
| ) |
| util.helper_target( |
| cc_binary, |
| name = name + "/bin", |
| srcs = ["binary.cc"], |
| deps = [":" + name + "/cc_lib"], |
| ) |
| cc_analysis_test( |
| name = name, |
| impl = _test_go_code_comes_after_deps_impl, |
| target = name + "/bin", |
| **kwargs |
| ) |
| |
| def _test_go_code_comes_after_deps_impl(env, target): |
| link_action = link_action_subject.from_target(env, target) |
| link_action.argv().contains_at_least_predicates([ |
| matching.str_endswith("libcc_lib.a"), |
| matching.str_endswith("libgo_lib.a"), |
| ]).in_order() |
| |
| def _test_additional_linker_inputs(name, **kwargs): |
| util.helper_target( |
| native.genrule, |
| name = name + "/gen_extra", |
| outs = ["main.extra_file"], |
| cmd = "echo '' > $@", |
| ) |
| util.helper_target( |
| cc_binary, |
| name = name + "/bin", |
| srcs = ["main.cc"], |
| additional_linker_inputs = [":" + name + "/gen_extra"], |
| linkopts = ["--option=$(location :" + name + "/gen_extra)"], |
| ) |
| cc_analysis_test( |
| name = name, |
| impl = _test_additional_linker_inputs_impl, |
| target = name + "/bin", |
| **kwargs |
| ) |
| |
| def _test_additional_linker_inputs_impl(env, target): |
| link_action = link_action_subject.from_target(env, target) |
| link_action.argv().contains_predicate( |
| matching.custom( |
| "starts with --option= and ends with main.extra_file", |
| lambda arg: arg.startswith("--option=") and arg.endswith("main.extra_file"), |
| ), |
| ) |
| link_action.inputs().contains_predicate(matching.file_basename_equals("main.extra_file")) |
| |
| # Regression test for b/193125967 |
| def _test_conflicting_linkstamps(name, **kwargs): |
| util.helper_target( |
| cc_library, |
| name = name + "/foo", |
| hdrs = ["foo.h"], |
| linkstamp = "foo.cc", |
| ) |
| util.helper_target( |
| cc_library, |
| name = name + "/bar", |
| hdrs = ["bar.h"], |
| linkstamp = "foo.cc", |
| ) |
| util.helper_target( |
| cc_binary, |
| name = name + "/bin", |
| deps = [ |
| ":" + name + "/bar", |
| ":" + name + "/foo", |
| ], |
| ) |
| cc_analysis_test( |
| name = name, |
| impl = _test_conflicting_linkstamps_impl, |
| target = name + "/bin", |
| **kwargs |
| ) |
| |
| def _test_conflicting_linkstamps_impl(_env, _target): |
| # The test passes if analysis succeeds. |
| pass |
| |
| def _test_compilation_prerequisites_in_output_group(name, **kwargs): |
| out_file = name + "_a.cc" |
| util.helper_target( |
| native.genrule, |
| name = name + "/gen", |
| outs = [out_file], |
| cmd = "echo '' > $@", |
| ) |
| util.helper_target( |
| cc_library, |
| name = name + "/mylib", |
| hdrs = ["b.h"], |
| ) |
| util.helper_target( |
| cc_binary, |
| name = name + "/prerequisites", |
| srcs = [ |
| name + "/gen", |
| "hello.cc", |
| "hello.h", |
| ], |
| deps = [name + "/mylib"], |
| ) |
| cc_analysis_test( |
| name = name, |
| impl = _test_compilation_prerequisites_in_output_group_impl, |
| target = name + "/prerequisites", |
| attrs = { |
| "out_file": attr.string(), |
| }, |
| attr_values = { |
| "out_file": out_file, |
| }, |
| **kwargs |
| ) |
| |
| def _test_compilation_prerequisites_in_output_group_impl(env, target): |
| prereqs = target[OutputGroupInfo].compilation_prerequisites_INTERNAL_.to_list() |
| prereq_paths = [f.short_path for f in prereqs] |
| target_subject = env.expect.that_target(target) |
| prereqs_subject = subjects.collection( |
| prereq_paths, |
| meta = target_subject.meta.derive("compilation_prerequisites"), |
| format = True, |
| ) |
| |
| prereqs_subject.contains("{package}/hello.cc") |
| prereqs_subject.contains("{package}/hello.h") |
| prereqs_subject.contains("{package}/b.h") |
| |
| out_file = env.ctx.attr.out_file |
| prereqs_subject.contains("{package}/" + out_file) |
| prereqs_subject.contains_predicate(matching.str_endswith("cppmap")) |
| |
| def _create_prefers_pic_libs_dep_tree(name): |
| util.helper_target( |
| cc_library, |
| name = name + "/mylib", |
| srcs = ["dep.pic.a", "dep.nopic.a"], |
| ) |
| util.helper_target( |
| cc_binary, |
| name = name + "/mybinary", |
| srcs = ["mybinary.cc"], |
| deps = [name + "/mylib"], |
| ) |
| |
| def _test_pic_mode_prefers_pic_libs_force_pic_disabled(name, **kwargs): |
| _create_prefers_pic_libs_dep_tree(name) |
| cc_analysis_test( |
| name = name, |
| impl = _test_pic_mode_prefers_pic_libs_force_pic_disabled_impl, |
| target = name + "/mybinary", |
| test_features = [FEATURE_NAMES.supports_pic], |
| config_settings = { |
| "//command_line_option:force_pic": False, |
| }, |
| **kwargs |
| ) |
| |
| def _test_pic_mode_prefers_pic_libs_force_pic_disabled_impl(env, target): |
| link_action = link_action_subject.from_target(env, target) |
| link_action.inputs().contains_predicate(matching.file_basename_equals("dep.nopic.a")) |
| link_action.inputs().not_contains_predicate(matching.file_basename_equals("dep.pic.a")) |
| |
| def _test_pic_mode_prefers_pic_libs_force_pic_enabled(name, **kwargs): |
| _create_prefers_pic_libs_dep_tree(name) |
| cc_analysis_test( |
| name = name, |
| impl = _test_pic_mode_prefers_pic_libs_force_pic_enabled_impl, |
| target = name + "/mybinary", |
| test_features = [FEATURE_NAMES.supports_pic], |
| config_settings = { |
| "//command_line_option:force_pic": True, |
| }, |
| **kwargs |
| ) |
| |
| def _test_pic_mode_prefers_pic_libs_force_pic_enabled_impl(env, target): |
| link_action = link_action_subject.from_target(env, target) |
| link_action.inputs().contains_predicate(matching.file_basename_equals("dep.pic.a")) |
| link_action.inputs().not_contains_predicate(matching.file_basename_equals("dep.nopic.a")) |
| |
| def _test_pic_mode_uses_pic_libs(name, **kwargs): |
| util.helper_target( |
| cc_library, |
| name = name + "/mylib", |
| srcs = ["dep.pic.o"], |
| ) |
| util.helper_target( |
| cc_binary, |
| name = name + "/mybinary", |
| srcs = ["mybinary.cc"], |
| deps = [name + "/mylib"], |
| ) |
| cc_analysis_test( |
| name = name, |
| impl = _test_pic_mode_uses_pic_libs_impl, |
| target = name + "/mybinary", |
| test_features = [ |
| FEATURE_NAMES.supports_pic, |
| FEATURE_NAMES.supports_start_end_lib, |
| ], |
| config_settings = { |
| "//command_line_option:force_pic": True, |
| }, |
| **kwargs |
| ) |
| |
| def _test_pic_mode_uses_pic_libs_impl(env, target): |
| link_action = link_action_subject.from_target(env, target) |
| link_action.inputs().contains_predicate(matching.file_basename_equals("dep.pic.o")) |
| |
| def _create_does_not_use_nopic_library_dep_tree(name): |
| util.helper_target( |
| cc_library, |
| name = name + "/mylib", |
| srcs = ["dep.nopic.o"], |
| ) |
| util.helper_target( |
| cc_binary, |
| name = name + "/mybinary", |
| srcs = ["mybinary.cc"], |
| deps = [name + "/mylib"], |
| ) |
| |
| def _test_pic_mode_does_not_use_nopic_library_force_pic_disabled(name, **kwargs): |
| _create_does_not_use_nopic_library_dep_tree(name) |
| cc_analysis_test( |
| name = name, |
| impl = _test_pic_mode_does_not_use_nopic_library_force_pic_disabled_impl, |
| target = name + "/mybinary", |
| test_features = [FEATURE_NAMES.supports_pic], |
| config_settings = { |
| "//command_line_option:force_pic": False, |
| }, |
| **kwargs |
| ) |
| |
| def _test_pic_mode_does_not_use_nopic_library_force_pic_disabled_impl(env, target): |
| link_action = link_action_subject.from_target(env, target) |
| link_action.inputs().contains_predicate(matching.file_basename_equals("mybinary.pic.o")) |
| link_action.inputs().not_contains_predicate(matching.file_basename_equals("dep.nopic.o")) |
| |
| def _test_pic_mode_does_not_use_nopic_library_force_pic_enabled(name, **kwargs): |
| _create_does_not_use_nopic_library_dep_tree(name) |
| cc_analysis_test( |
| name = name, |
| impl = _test_pic_mode_does_not_use_nopic_library_force_pic_enabled_impl, |
| target = name + "/mybinary", |
| test_features = [FEATURE_NAMES.supports_pic], |
| config_settings = { |
| "//command_line_option:force_pic": True, |
| }, |
| **kwargs |
| ) |
| |
| def _test_pic_mode_does_not_use_nopic_library_force_pic_enabled_impl(env, target): |
| link_action = link_action_subject.from_target(env, target) |
| link_action.inputs().not_contains_predicate(matching.file_basename_equals("dep.nopic.o")) |
| |
| def _test_pic_mode_does_not_use_nopic_binary(name, **kwargs): |
| util.helper_target( |
| cc_binary, |
| name = name + "/mybinary", |
| srcs = ["xyz.nopic.o"], |
| ) |
| cc_analysis_test( |
| name = name, |
| impl = _test_pic_mode_does_not_use_nopic_binary_impl, |
| target = name + "/mybinary", |
| test_features = [FEATURE_NAMES.supports_pic], |
| **kwargs |
| ) |
| |
| def _test_pic_mode_does_not_use_nopic_binary_impl(env, target): |
| link_action = link_action_subject.from_target(env, target) |
| link_action.inputs().not_contains_predicate(matching.file_basename_equals("xyz.nopic.o")) |
| |
| def _setup_cc_runtimes_mock(): |
| util.helper_target( |
| mock_runtime_library, |
| name = "runtime", |
| ) |
| |
| util.helper_target( |
| cc_runtimes_toolchain, |
| name = "runtimes_toolchain", |
| copts = ["-Iruntimes"], |
| runtimes = [":runtime"], |
| ) |
| |
| native.toolchain( |
| name = "cc_runtimes_mock_toolchain", |
| toolchain = ":runtimes_toolchain", |
| toolchain_type = Label("@bazel_tools//tools/cpp:cc_runtimes_toolchain_type"), |
| tags = ["manual", "notap"], |
| ) |
| |
| def _register_link_staticness_test(name, target_under_test, expected_static, config_settings = {}, with_features = [], **kwargs): |
| config_settings = dict( |
| { |
| # Apple builds do not support statically linked binaries so we force the target platform |
| # to Linux. TODO: Do we want to test this separately for Windows targets? |
| # Note: Already the previous Java tests set --cpu=k8 for these tests. |
| "//command_line_option:platforms": [Label("//tests/cc/testutil:linux_x86_64")], |
| }, |
| **config_settings |
| ) |
| cc_analysis_test( |
| name = name, |
| impl = _link_staticness_test_impl, |
| target = target_under_test, |
| config_settings = config_settings, |
| with_features = with_features, |
| attrs = { |
| "expected_static": attr.bool(), |
| }, |
| attr_values = { |
| "expected_static": expected_static, |
| }, |
| **kwargs |
| ) |
| |
| def _link_staticness_test_impl(env, target): |
| _assert_link_staticness(env, target, env.ctx.attr.expected_static) |
| |
| def _create_link_staticness_dep_tree(name): |
| util.helper_target( |
| cc_library, |
| name = name + "/dep", |
| srcs = ["dep.cc"], |
| ) |
| util.helper_target( |
| cc_binary, |
| name = name + "/binary-static", |
| srcs = ["binary.cc"], |
| deps = [name + "/dep"], |
| linkopts = ["-static"], |
| ) |
| util.helper_target( |
| cc_test, |
| name = name + "/test", |
| srcs = ["binary.cc", "test.cc"], |
| deps = [name + "/dep"], |
| ) |
| util.helper_target( |
| cc_test, |
| name = name + "/test-linkstatic", |
| srcs = ["binary.cc", "test.cc"], |
| deps = [name + "/dep"], |
| linkstatic = 1, |
| ) |
| |
| # Default Config Suite |
| def _test_link_staticness_binary_static_dynamic_mode_default(name, **kwargs): |
| _create_link_staticness_dep_tree(name) |
| _register_link_staticness_test( |
| name = name, |
| target_under_test = name + "/binary-static", |
| expected_static = True, |
| config_settings = { |
| "//command_line_option:dynamic_mode": "default", |
| }, |
| with_features = [FEATURE_NAMES.supports_pic, FEATURE_NAMES.supports_dynamic_linker], |
| **kwargs |
| ) |
| |
| def _test_link_staticness_hello_test_dynamic_mode_default(name, **kwargs): |
| _create_link_staticness_dep_tree(name) |
| _register_link_staticness_test( |
| name = name, |
| target_under_test = name + "/test", |
| expected_static = False, |
| config_settings = { |
| "//command_line_option:dynamic_mode": "default", |
| }, |
| with_features = [FEATURE_NAMES.supports_pic, FEATURE_NAMES.supports_dynamic_linker], |
| **kwargs |
| ) |
| |
| def _test_link_staticness_hello_test_linkstatic_dynamic_mode_default(name, **kwargs): |
| _create_link_staticness_dep_tree(name) |
| _register_link_staticness_test( |
| name = name, |
| target_under_test = name + "/test-linkstatic", |
| expected_static = True, |
| config_settings = { |
| "//command_line_option:dynamic_mode": "default", |
| }, |
| with_features = [FEATURE_NAMES.supports_pic, FEATURE_NAMES.supports_dynamic_linker], |
| **kwargs |
| ) |
| |
| # Off Config Suite |
| def _test_link_staticness_binary_static_dynamic_mode_off(name, **kwargs): |
| _create_link_staticness_dep_tree(name) |
| _register_link_staticness_test( |
| name = name, |
| target_under_test = name + "/binary-static", |
| expected_static = True, |
| config_settings = { |
| "//command_line_option:dynamic_mode": "off", |
| }, |
| with_features = [FEATURE_NAMES.supports_pic, FEATURE_NAMES.supports_dynamic_linker], |
| **kwargs |
| ) |
| |
| def _test_link_staticness_hello_test_dynamic_mode_off(name, **kwargs): |
| _create_link_staticness_dep_tree(name) |
| _register_link_staticness_test( |
| name = name, |
| target_under_test = name + "/test", |
| expected_static = True, |
| config_settings = { |
| "//command_line_option:dynamic_mode": "off", |
| }, |
| with_features = [FEATURE_NAMES.supports_pic, FEATURE_NAMES.supports_dynamic_linker], |
| **kwargs |
| ) |
| |
| def _test_link_staticness_hello_test_linkstatic_dynamic_mode_off(name, **kwargs): |
| _create_link_staticness_dep_tree(name) |
| _register_link_staticness_test( |
| name = name, |
| target_under_test = name + "/test-linkstatic", |
| expected_static = True, |
| config_settings = { |
| "//command_line_option:dynamic_mode": "off", |
| }, |
| with_features = [FEATURE_NAMES.supports_pic, FEATURE_NAMES.supports_dynamic_linker], |
| **kwargs |
| ) |
| |
| # Fully Config Suite |
| def _test_link_staticness_binary_static_dynamic_mode_fully(name, **kwargs): |
| _create_link_staticness_dep_tree(name) |
| _register_link_staticness_test( |
| name = name, |
| target_under_test = name + "/binary-static", |
| expected_static = False, |
| config_settings = { |
| "//command_line_option:dynamic_mode": "fully", |
| }, |
| with_features = [FEATURE_NAMES.supports_pic, FEATURE_NAMES.supports_dynamic_linker], |
| **kwargs |
| ) |
| |
| def _test_link_staticness_hello_test_dynamic_mode_fully(name, **kwargs): |
| _create_link_staticness_dep_tree(name) |
| _register_link_staticness_test( |
| name = name, |
| target_under_test = name + "/test", |
| expected_static = False, |
| config_settings = { |
| "//command_line_option:dynamic_mode": "fully", |
| }, |
| with_features = [FEATURE_NAMES.supports_pic, FEATURE_NAMES.supports_dynamic_linker], |
| **kwargs |
| ) |
| |
| def _test_link_staticness_hello_test_linkstatic_dynamic_mode_fully(name, **kwargs): |
| _create_link_staticness_dep_tree(name) |
| _register_link_staticness_test( |
| name = name, |
| target_under_test = name + "/test-linkstatic", |
| expected_static = False, |
| config_settings = { |
| "//command_line_option:dynamic_mode": "fully", |
| }, |
| with_features = [FEATURE_NAMES.supports_pic, FEATURE_NAMES.supports_dynamic_linker], |
| **kwargs |
| ) |
| |
| def _create_linking_mode_features_dep_tree(name): |
| util.helper_target( |
| cc_binary, |
| name = name + "/linkstatic_true", |
| srcs = ["binary.cc"], |
| ) |
| util.helper_target( |
| cc_binary, |
| name = name + "/linkstatic_false", |
| srcs = ["binary.cc"], |
| linkstatic = 0, |
| ) |
| |
| def _register_linking_mode_features_test(name, target_under_test, expected_mode, config_settings = {}, **kwargs): |
| config_settings = dict( |
| { |
| # Windows does not support linking_mode features so we force the target platform to |
| # Linux. TODO: Do we want to test this separately for Apple targets? |
| "//command_line_option:platforms": [Label("//tests/cc/testutil:linux_x86_64")], |
| }, |
| **config_settings |
| ) |
| cc_analysis_test( |
| name = name, |
| impl = _linking_mode_features_test_impl, |
| target = target_under_test, |
| config_settings = config_settings, |
| with_features = [ |
| FEATURE_NAMES.static_linking_mode, |
| FEATURE_NAMES.dynamic_linking_mode, |
| FEATURE_NAMES.supports_dynamic_linker, |
| ], |
| attrs = { |
| "expected_mode": attr.string(), |
| }, |
| attr_values = { |
| "expected_mode": expected_mode, |
| }, |
| **kwargs |
| ) |
| |
| def _linking_mode_features_test_impl(env, target): |
| link_action = link_action_subject.from_target(env, target) |
| link_action.env().get("linking_mode", factory = subjects.str).equals(env.ctx.attr.expected_mode) |
| |
| # Default Config |
| def _test_linking_mode_features_true_default(name, **kwargs): |
| _create_linking_mode_features_dep_tree(name) |
| _register_linking_mode_features_test(name, name + "/linkstatic_true", "static", **kwargs) |
| |
| def _test_linking_mode_features_false_default(name, **kwargs): |
| _create_linking_mode_features_dep_tree(name) |
| _register_linking_mode_features_test(name, name + "/linkstatic_false", "dynamic", **kwargs) |
| |
| # Fully Config |
| def _test_linking_mode_features_true_fully(name, **kwargs): |
| _create_linking_mode_features_dep_tree(name) |
| _register_linking_mode_features_test( |
| name, |
| name + "/linkstatic_true", |
| "dynamic", |
| config_settings = {"//command_line_option:dynamic_mode": "fully"}, |
| **kwargs |
| ) |
| |
| def _test_linking_mode_features_false_fully(name, **kwargs): |
| _create_linking_mode_features_dep_tree(name) |
| _register_linking_mode_features_test( |
| name, |
| name + "/linkstatic_false", |
| "dynamic", |
| config_settings = {"//command_line_option:dynamic_mode": "fully"}, |
| **kwargs |
| ) |
| |
| # Off Config |
| def _test_linking_mode_features_true_off(name, **kwargs): |
| _create_linking_mode_features_dep_tree(name) |
| _register_linking_mode_features_test( |
| name, |
| name + "/linkstatic_true", |
| "static", |
| config_settings = {"//command_line_option:dynamic_mode": "off"}, |
| **kwargs |
| ) |
| |
| def _test_linking_mode_features_false_off(name, **kwargs): |
| _create_linking_mode_features_dep_tree(name) |
| _register_linking_mode_features_test( |
| name, |
| name + "/linkstatic_false", |
| "static", |
| config_settings = {"//command_line_option:dynamic_mode": "off"}, |
| **kwargs |
| ) |
| |
| # Regression test for b/157471662. |
| def _test_link_shared_does_not_have_to_provide_extension(name, **kwargs): |
| util.helper_target( |
| cc_binary, |
| name = name + "/foo", |
| srcs = ["foo.cc"], |
| linkshared = 1, |
| ) |
| cc_analysis_test( |
| name = name, |
| impl = _test_link_shared_does_not_have_to_provide_extension_impl, |
| target = name + "/foo", |
| **kwargs |
| ) |
| |
| def _test_link_shared_does_not_have_to_provide_extension_impl(env, target): |
| executable = target[DefaultInfo].files_to_run.executable |
| env.expect.that_str(executable.basename).equals("libfoo.so") |
| |
| def _test_pdb_files(name, **kwargs): |
| util.helper_target( |
| cc_binary, |
| name = name + "/bin.dll", |
| ) |
| cc_analysis_test( |
| name = name, |
| impl = _test_pdb_files_impl, |
| target = name + "/bin.dll", |
| test_features = [FEATURE_NAMES.generate_pdb_file], |
| **kwargs |
| ) |
| |
| def _test_pdb_files_impl(env, target): |
| env.expect.that_target(target).output_group("pdb_file").contains_predicate( |
| matching.file_basename_equals("bin.pdb"), |
| ) |
| |
| # Even if there are no instrumented C++ files, a C++ binary must provide some form of coverage |
| # support since this is assumed by other tooling. Specifically, lcov_merger. See b/269749859. |
| # TODO(cmita): This doesn't seem reasonable; if nothing C++ is instrumented then we shouldn't |
| # need this. |
| def _test_coverage_support_always_provided(name, **kwargs): |
| util.helper_target( |
| cc_binary, |
| name = name + "/main", |
| srcs = ["main.cc"], |
| ) |
| cc_analysis_test( |
| name = name, |
| impl = _test_coverage_support_always_provided_impl, |
| target = name + "/main", |
| config_settings = { |
| "//command_line_option:collect_code_coverage": "true", |
| "//command_line_option:instrumentation_filter": "/unused", |
| }, |
| **kwargs |
| ) |
| |
| def _test_coverage_support_always_provided_impl(env, target): |
| target_subject = env.expect.that_target(target) |
| target_subject.has_provider(InstrumentedFilesInfo) |
| info_subject = target_subject.provider(InstrumentedFilesInfo) |
| |
| info_subject.metadata_files().contains_exactly([]) |
| info_subject.instrumented_files().contains_exactly([]) |
| |
| info = info_subject.actual |
| |
| # TODO: Remove the hasattr conditions once all supported Bazel versions support these |
| # InstrumentedFilesInfoApi methods. Expected: Bazel 10, Bazel 9.3, maybe Bazel 8.8. |
| if hasattr(info, "get_coverage_environment"): |
| coverage_env = env.expect.that_dict( |
| info.get_coverage_environment(), |
| meta = env.expect.meta.derive("coverage_environment"), |
| ) |
| coverage_env.contains_at_least({ |
| "COVERAGE_GCOV_PATH": "/usr/bin/mock-gcov", |
| "LLVM_COV": "/usr/bin/mock-llvm-cov", |
| "LLVM_PROFDATA": "/usr/bin/mock-llvm-profdata", |
| "GENERATE_LLVM_LCOV": "0", |
| }) |
| if hasattr(info, "get_coverage_support_files"): |
| support_files = env.expect.that_collection( |
| info.get_coverage_support_files().to_list(), |
| expr = "coverage_support_files", |
| ) |
| support_files.contains_predicate( |
| matching.file_basename_equals("coverage-file"), |
| ) |
| |
| def _test_malloc_is_compile_time_dep(name, **kwargs): |
| util.helper_target( |
| cc_library, |
| name = name + "/malloc", |
| defines = ["foobar"], |
| linkstatic = 1, |
| ) |
| util.helper_target( |
| cc_binary, |
| name = name + "/foo", |
| srcs = ["foo.cc"], |
| ) |
| cc_analysis_test( |
| name = name, |
| impl = _test_malloc_is_compile_time_dep_impl, |
| target = name + "/foo", |
| config_settings = { |
| "//command_line_option:custom_malloc": Label("//tests/cc/common:" + name + "/malloc"), |
| }, |
| **kwargs |
| ) |
| |
| def _test_malloc_is_compile_time_dep_impl(env, target): |
| compilation_outputs = target[OutputGroupInfo].compilation_outputs.to_list() |
| env.expect.that_collection(compilation_outputs).has_size(1) |
| compile_action = env.expect.that_target(target).action_generating(compilation_outputs[0].short_path) |
| compile_action.argv().contains("-Dfoobar") |
| |
| def _test_custom_malloc_filegroup(name, **kwargs): |
| util.helper_target( |
| native.filegroup, |
| name = name + "/custom_malloc", |
| srcs = ["malloc.cc"], |
| ) |
| util.helper_target( |
| cc_binary, |
| name = name + "/bin", |
| srcs = ["binary.cc"], |
| ) |
| cc_analysis_test( |
| name = name, |
| impl = _test_custom_malloc_filegroup_impl, |
| target = name + "/bin", |
| config_settings = { |
| "//command_line_option:custom_malloc": Label("//tests/cc/common:" + name + "/custom_malloc"), |
| }, |
| **kwargs |
| ) |
| |
| def _test_custom_malloc_filegroup_impl(env, target): # buildifier: disable=unused-variable |
| pass |
| |
| def _test_pic_and_no_pic_gcno_files(name, **kwargs): |
| util.helper_target( |
| cc_binary, |
| name = name + "/a", |
| srcs = ["a.cc"], |
| ) |
| cc_analysis_test( |
| name = name, |
| impl = _test_pic_and_no_pic_gcno_files_impl, |
| target = name + "/a", |
| test_features = [FEATURE_NAMES.supports_pic], |
| config_settings = { |
| "//command_line_option:collect_code_coverage": "true", |
| "//command_line_option:compilation_mode": "opt", |
| }, |
| **kwargs |
| ) |
| |
| def _test_pic_and_no_pic_gcno_files_impl(env, target): |
| target_subject = env.expect.that_target(target) |
| target_subject.has_provider(InstrumentedFilesInfo) |
| info_subject = target_subject.provider(InstrumentedFilesInfo) |
| info_subject.metadata_files().contains_at_least_predicates([ |
| matching.file_basename_equals("a.gcno"), |
| matching.file_basename_equals("a.pic.gcno"), |
| ]) |
| |
| def _test_cctoolchain_coverage_files(name, **kwargs): |
| util.helper_target( |
| cc_test, |
| name = name + "/a", |
| srcs = ["a.cc"], |
| ) |
| cc_analysis_test( |
| name = name, |
| impl = _test_cctoolchain_coverage_files_impl, |
| target = name + "/a", |
| config_settings = { |
| "//command_line_option:collect_code_coverage": "true", |
| }, |
| **kwargs |
| ) |
| |
| def _test_cctoolchain_coverage_files_impl(env, target): |
| target_subject = env.expect.that_target(target) |
| target_subject.has_provider(InstrumentedFilesInfo) |
| info_subject = target_subject.provider(InstrumentedFilesInfo) |
| |
| # TODO: Remove the hasattr conditions once all supported Bazel versions support these |
| # InstrumentedFilesInfoApi methods. Expected: Bazel 10, Bazel 9.3, maybe Bazel 8.8. |
| if hasattr(info_subject.actual, "get_coverage_support_files"): |
| support_files = env.expect.that_collection( |
| info_subject.actual.get_coverage_support_files().to_list(), |
| expr = "coverage_support_files", |
| ) |
| support_files.contains_exactly_predicates([ |
| matching.file_basename_equals("coverage-file"), |
| ]) |
| |
| def _test_thin_lto(name, **kwargs): |
| util.helper_target( |
| cc_binary, |
| name = name + "/hello", |
| srcs = ["hello.cc"], |
| ) |
| cc_analysis_test( |
| name = name, |
| impl = _test_thin_lto_impl, |
| target = name + "/hello", |
| test_features = ["thin_lto", "supports_start_end_lib"], |
| **kwargs |
| ) |
| |
| def _test_thin_lto_impl(env, target): |
| actions = target[TestingAspectInfo].actions |
| |
| compile_actions = [a for a in actions if a.mnemonic == "CppCompile"] |
| thin_lto_compile_actions = [a for a in compile_actions if "-flto=thin" in a.argv] |
| env.expect.that_collection(thin_lto_compile_actions).is_not_empty() |
| |
| lto_indexing_actions = [a for a in actions if a.mnemonic == "CppLTOIndexing"] |
| env.expect.that_collection(lto_indexing_actions).has_size(1) |
| |
| lto_backend_actions = [a for a in actions if a.mnemonic == "CcLtoBackendCompile"] |
| env.expect.that_collection(lto_backend_actions).is_not_empty() |
| |
| def _test_thin_lto_disabled(name, **kwargs): |
| util.helper_target( |
| cc_binary, |
| name = name + "/hello", |
| srcs = ["hello.cc"], |
| ) |
| cc_analysis_test( |
| name = name, |
| impl = _test_thin_lto_disabled_impl, |
| target = name + "/hello", |
| with_features = ["thin_lto", "supports_start_end_lib"], |
| test_features = ["-thin_lto", "supports_start_end_lib"], |
| **kwargs |
| ) |
| |
| def _test_thin_lto_disabled_impl(env, target): |
| actions = target[TestingAspectInfo].actions |
| |
| compile_actions = [a for a in actions if a.mnemonic == "CppCompile"] |
| env.expect.that_collection(compile_actions).is_not_empty() |
| thin_lto_compile_actions = [a for a in compile_actions if "-flto=thin" in a.argv] |
| env.expect.that_collection(thin_lto_compile_actions).is_empty() |
| |
| lto_indexing_actions = [a for a in actions if a.mnemonic == "CppLTOIndexing"] |
| env.expect.that_collection(lto_indexing_actions).is_empty() |
| |
| lto_backend_actions = [a for a in actions if a.mnemonic == "CcLtoBackendCompile"] |
| env.expect.that_collection(lto_backend_actions).is_empty() |
| |
| def cc_binary_configured_target_tests(name): |
| """Creates the test suite for cc_binary tests. |
| |
| Args: |
| name: The name of the test suite. |
| """ |
| tests = [ |
| _test_files_to_build, |
| _test_headers_not_passed_to_linking_action, |
| _test_no_duplicate_linkopts, |
| _test_action_graph, |
| _test_runtime_dynamic_libraries_copy_behavior, |
| _test_pic, |
| _test_duplicate_linkopts, |
| _test_unsupported_src_file, |
| _test_missing_action_config_for_strip_is_a_rule_error, |
| _test_linkopts_diamond, |
| _test_linkopts_fake_diamond, |
| _test_app_linking_static, |
| _test_app_linking_dynamic, |
| _test_so_in_srcs, |
| _test_transitive_libs_are_collected, |
| _test_transitive_linkstamps_are_collected, |
| _test_go_code_comes_after_deps, |
| _test_additional_linker_inputs, |
| _test_conflicting_linkstamps, |
| _test_compilation_prerequisites_in_output_group, |
| _test_pic_mode_prefers_pic_libs_force_pic_disabled, |
| _test_pic_mode_prefers_pic_libs_force_pic_enabled, |
| _test_pic_mode_uses_pic_libs, |
| _test_pic_mode_does_not_use_nopic_library_force_pic_disabled, |
| _test_pic_mode_does_not_use_nopic_library_force_pic_enabled, |
| _test_pic_mode_does_not_use_nopic_binary, |
| _test_ignore_custom_malloc, |
| _test_custom_malloc, |
| _test_link_shared_does_not_have_to_provide_extension, |
| _test_pdb_files, |
| _test_coverage_support_always_provided, |
| _test_malloc_is_compile_time_dep, |
| _test_custom_malloc_filegroup, |
| _test_pic_and_no_pic_gcno_files, |
| _test_cctoolchain_coverage_files, |
| _test_thin_lto, |
| _test_thin_lto_disabled, |
| ] |
| |
| # sanitize_pwd is implemented in Starlark in rules_cc, requires Bazel 9+. |
| if bazel_features.cc.cc_common_is_in_rules_cc: |
| _setup_cc_runtimes_mock() |
| tests.extend([ |
| _test_sanitize_pwd_feature_enabled, |
| _test_sanitize_pwd_feature_disabled, |
| _test_sanitize_pwd_macos_no_pwd, |
| _test_external_include_paths_reclassifies_external_quote_includes, # copybara-uncomment-this-please |
| _test_system_include_paths_reclassifies_local_includes_after_includes, |
| _test_system_include_paths_reclassifies_local_includes_without_propagation, |
| _test_generated_def_file_uses_toolchain_action, # copybara-uncomment-this-please |
| _test_generated_def_file_uses_default_tool, # copybara-uncomment-this-please |
| _test_linker_toolchain_feature, |
| _test_link_staticness_binary_static_dynamic_mode_default, |
| _test_link_staticness_hello_test_dynamic_mode_default, |
| _test_link_staticness_hello_test_linkstatic_dynamic_mode_default, |
| _test_link_staticness_binary_static_dynamic_mode_off, |
| _test_link_staticness_hello_test_dynamic_mode_off, |
| _test_link_staticness_hello_test_linkstatic_dynamic_mode_off, |
| _test_link_staticness_binary_static_dynamic_mode_fully, |
| _test_link_staticness_hello_test_dynamic_mode_fully, |
| _test_link_staticness_hello_test_linkstatic_dynamic_mode_fully, |
| _test_linking_mode_features_true_default, |
| _test_linking_mode_features_false_default, |
| _test_linking_mode_features_true_fully, |
| _test_linking_mode_features_false_fully, |
| _test_linking_mode_features_true_off, |
| _test_linking_mode_features_false_off, |
| _test_cc_runtimes_added_to_libraries, |
| ]) |
| |
| test_suite( |
| name = name, |
| tests = tests, |
| ) |
