unplugged-system/build/bazel/rules/cc/cc_prebuilt_library_static_test.bzl

"""
Copyright (C) 2023 The Android Open Source Project

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""

load("@bazel_skylib//lib:unittest.bzl", "analysistest", "asserts")
load("//build/bazel/rules/cc:cc_prebuilt_library_static.bzl", "cc_prebuilt_library_static")
load("//build/bazel/rules/test_common:paths.bzl", "get_output_and_package_dir_based_path")

_fake_expected_lib = "{[()]}"

def _cc_prebuilt_library_static_alwayslink_test_impl(ctx):
    env = analysistest.begin(ctx)
    target = analysistest.target_under_test(env)
    expected_lib = ctx.attr.expected_lib
    alwayslink = ctx.attr.alwayslink
    cc_info = target[CcInfo]
    linker_inputs = cc_info.linking_context.linker_inputs.to_list()
    libs_to_link = []
    for l in linker_inputs:
        libs_to_link += l.libraries

    has_lib = False
    has_alwayslink = False
    libs = {}
    for lib_to_link in libs_to_link:
        lib = lib_to_link.static_library.basename
        libs[lib_to_link.static_library] = lib_to_link.alwayslink
        if lib == expected_lib:
            has_lib = True
            has_alwayslink = lib_to_link.alwayslink
        if has_alwayslink:
            break
    asserts.true(
        env,
        has_lib,
        "\nExpected to find the static library `%s` in the linker_input:\n\t%s" % (expected_lib, str(libs)),
    )
    asserts.equals(
        env,
        has_alwayslink,
        alwayslink,
        "\nExpected to find the static library `%s` unconditionally in the linker_input, with alwayslink set to %s:\n\t%s" % (expected_lib, alwayslink, str(libs)),
    )

    return analysistest.end(env)

_cc_prebuilt_library_static_alwayslink_test = analysistest.make(
    _cc_prebuilt_library_static_alwayslink_test_impl,
    attrs = {
        "expected_lib": attr.string(),
        "alwayslink": attr.bool(),
    },
)

def _cc_prebuilt_library_static_alwayslink_lib(alwayslink):
    name = "_cc_prebuilt_library_static_alwayslink_lib_" + str(alwayslink)
    test_name = name + "_test"
    lib = "libfoo.a"

    cc_prebuilt_library_static(
        name = name,
        static_library = lib,
        alwayslink = alwayslink,
        tags = ["manual"],
    )
    _cc_prebuilt_library_static_alwayslink_test(
        name = test_name,
        target_under_test = name,
        expected_lib = lib,
        alwayslink = alwayslink,
    )

    return test_name

def _cc_prebuilt_library_static_test_impl(ctx):
    env = analysistest.begin(ctx)
    target = analysistest.target_under_test(env)
    expected_lib = ctx.attr.expected_lib
    cc_info = target[CcInfo]
    compilation_context = cc_info.compilation_context
    linker_inputs = cc_info.linking_context.linker_inputs.to_list()
    libs_to_link = []
    for lib in linker_inputs:
        libs_to_link += lib.libraries

    if expected_lib == _fake_expected_lib:
        asserts.true(
            env,
            len(libs_to_link) == 0,
            "\nExpected the static library to be empty, but instead got:\n\t%s\n" % str(libs_to_link),
        )
    else:
        asserts.true(
            env,
            expected_lib in [lib.static_library.basename for lib in libs_to_link],
            "\nExpected the target to include the static library %s; but instead got:\n\t%s\n" % (expected_lib, libs_to_link),
        )

    # Checking for the expected {,system_}includes
    assert_template = "\nExpected the %s for " + expected_lib + " to be:\n\t%s\n, but instead got:\n\t%s\n"
    expand_paths = lambda paths: [get_output_and_package_dir_based_path(env, p) for p in paths]
    expected_includes = expand_paths(ctx.attr.expected_includes)
    expected_system_includes = expand_paths(ctx.attr.expected_system_includes)

    includes = compilation_context.includes.to_list()
    for include in expected_includes:
        asserts.true(env, include in includes, assert_template % ("includes", expected_includes, includes))

    system_includes = compilation_context.system_includes.to_list()
    for include in expected_system_includes:
        asserts.true(env, include in system_includes, assert_template % ("system_includes", expected_system_includes, system_includes))

    return analysistest.end(env)

_cc_prebuilt_library_static_test = analysistest.make(
    _cc_prebuilt_library_static_test_impl,
    attrs = dict(
        expected_lib = attr.string(default = _fake_expected_lib),
        expected_includes = attr.string_list(),
        expected_system_includes = attr.string_list(),
    ),
)

def _cc_prebuilt_library_static_simple():
    name = "_cc_prebuilt_library_static_simple"
    test_name = name + "_test"
    lib = "libfoo.a"

    cc_prebuilt_library_static(
        name = name,
        static_library = lib,
        tags = ["manual"],
    )
    _cc_prebuilt_library_static_test(
        name = test_name,
        target_under_test = name,
        expected_lib = lib,
    )

    return test_name

def _cc_prebuilt_library_static_None():
    name = "_cc_prebuilt_library_static_None"
    test_name = name + "_test"
    lib = None

    cc_prebuilt_library_static(
        name = name,
        static_library = lib,
        tags = ["manual"],
    )
    _cc_prebuilt_library_static_test(
        name = test_name,
        target_under_test = name,
        expected_lib = lib,  # We expect the default of _fake_expected_lib
    )

    return test_name

def _cc_prebuilt_library_static_has_all_includes():
    name = "_cc_prebuilt_library_static_has_all_includes"
    test_name = name + "_test"
    lib = "libfoo.a"
    includes = ["includes"]
    system_includes = ["system_includes"]

    cc_prebuilt_library_static(
        name = name,
        static_library = lib,
        export_includes = includes,
        export_system_includes = system_includes,
        tags = ["manual"],
    )
    _cc_prebuilt_library_static_test(
        name = test_name,
        target_under_test = name,
        expected_lib = lib,
        expected_includes = includes,
        expected_system_includes = system_includes,
    )

    return test_name

# TODO: Test that is alwayslink = alse

def cc_prebuilt_library_static_test_suite(name):
    native.test_suite(
        name = name,
        tests = [
            _cc_prebuilt_library_static_simple(),
            _cc_prebuilt_library_static_None(),
            _cc_prebuilt_library_static_alwayslink_lib(True),
            _cc_prebuilt_library_static_alwayslink_lib(False),
            _cc_prebuilt_library_static_has_all_includes(),
        ],
    )