build_soong/bp2build/cc_binary_conversion_test.go

// Copyright 2021 Google Inc. All rights reserved.
//
// 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.

package bp2build

import (
	"android/soong/android"
	"android/soong/cc"
	"android/soong/genrule"
	"fmt"
	"strings"
	"testing"
)

const (
	ccBinaryTypePlaceHolder   = "{rule_name}"
	compatibleWithPlaceHolder = "{target_compatible_with}"
)

func registerCcBinaryModuleTypes(ctx android.RegistrationContext) {
	cc.RegisterCCBuildComponents(ctx)
	ctx.RegisterModuleType("filegroup", android.FileGroupFactory)
	ctx.RegisterModuleType("cc_library_static", cc.LibraryStaticFactory)
	ctx.RegisterModuleType("cc_library", cc.LibraryFactory)
	ctx.RegisterModuleType("genrule", genrule.GenRuleFactory)
}

var binaryReplacer = strings.NewReplacer(ccBinaryTypePlaceHolder, "cc_binary", compatibleWithPlaceHolder, "")
var hostBinaryReplacer = strings.NewReplacer(ccBinaryTypePlaceHolder, "cc_binary_host", compatibleWithPlaceHolder, `
    target_compatible_with = select({
        "//build/bazel/platforms/os:android": ["@platforms//:incompatible"],
        "//conditions:default": [],
    }),`)

func runCcBinaryTests(t *testing.T, tc bp2buildTestCase) {
	t.Helper()
	runCcBinaryTestCase(t, tc)
	runCcHostBinaryTestCase(t, tc)
}

func runCcBinaryTestCase(t *testing.T, tc bp2buildTestCase) {
	t.Helper()
	testCase := tc
	testCase.expectedBazelTargets = append([]string{}, tc.expectedBazelTargets...)
	testCase.moduleTypeUnderTest = "cc_binary"
	testCase.moduleTypeUnderTestFactory = cc.BinaryFactory
	testCase.moduleTypeUnderTestBp2BuildMutator = cc.BinaryBp2build
	testCase.description = fmt.Sprintf("%s %s", testCase.moduleTypeUnderTest, testCase.description)
	testCase.blueprint = binaryReplacer.Replace(testCase.blueprint)
	for i, et := range testCase.expectedBazelTargets {
		testCase.expectedBazelTargets[i] = binaryReplacer.Replace(et)
	}
	t.Run(testCase.description, func(t *testing.T) {
		runBp2BuildTestCase(t, registerCcBinaryModuleTypes, testCase)
	})
}

func runCcHostBinaryTestCase(t *testing.T, tc bp2buildTestCase) {
	t.Helper()
	testCase := tc
	testCase.expectedBazelTargets = append([]string{}, tc.expectedBazelTargets...)
	testCase.moduleTypeUnderTest = "cc_binary_host"
	testCase.moduleTypeUnderTestFactory = cc.BinaryHostFactory
	testCase.moduleTypeUnderTestBp2BuildMutator = cc.BinaryHostBp2build
	testCase.description = fmt.Sprintf("%s %s", testCase.moduleTypeUnderTest, testCase.description)
	testCase.blueprint = hostBinaryReplacer.Replace(testCase.blueprint)
	for i, et := range testCase.expectedBazelTargets {
		testCase.expectedBazelTargets[i] = hostBinaryReplacer.Replace(et)
	}
	t.Run(testCase.description, func(t *testing.T) {
		runBp2BuildTestCase(t, registerCcBinaryModuleTypes, testCase)
	})
}

func TestBasicCcBinary(t *testing.T) {
	runCcBinaryTests(t, bp2buildTestCase{
		description: "basic -- properties -> attrs with little/no transformation",
		blueprint: `
{rule_name} {
    name: "foo",
    srcs: ["a.cc"],
    local_include_dirs: ["dir"],
    include_dirs: ["absolute_dir"],
    cflags: ["-Dcopt"],
    cppflags: ["-Dcppflag"],
    conlyflags: ["-Dconlyflag"],
    asflags: ["-Dasflag"],
    ldflags: ["ld-flag"],
    rtti: true,
    strip: {
        all: true,
        keep_symbols: true,
        keep_symbols_and_debug_frame: true,
        keep_symbols_list: ["symbol"],
        none: true,
    },
}
`,
		expectedBazelTargets: []string{`cc_binary(
    name = "foo",
    absolute_includes = ["absolute_dir"],
    asflags = ["-Dasflag"],
    conlyflags = ["-Dconlyflag"],
    copts = ["-Dcopt"],
    cppflags = ["-Dcppflag"],
    linkopts = ["ld-flag"],
    local_includes = [
        "dir",
        ".",
    ],
    rtti = True,
    srcs = ["a.cc"],
    strip = {
        "all": True,
        "keep_symbols": True,
        "keep_symbols_and_debug_frame": True,
        "keep_symbols_list": ["symbol"],
        "none": True,
    },{target_compatible_with}
)`},
	})
}

func TestCcBinaryWithSharedLdflagDisableFeature(t *testing.T) {
	runCcBinaryTests(t, bp2buildTestCase{
		description: `ldflag "-shared" disables static_flag feature`,
		blueprint: `
{rule_name} {
    name: "foo",
    ldflags: ["-shared"],
    include_build_directory: false,
}
`,
		expectedBazelTargets: []string{`cc_binary(
    name = "foo",
    features = ["-static_flag"],
    linkopts = ["-shared"],{target_compatible_with}
)`},
	})
}

func TestCcBinaryWithLinkStatic(t *testing.T) {
	runCcBinaryTests(t, bp2buildTestCase{
		description: "link static",
		blueprint: `
{rule_name} {
    name: "foo",
    static_executable: true,
    include_build_directory: false,
}
`,
		expectedBazelTargets: []string{`cc_binary(
    name = "foo",
    linkshared = False,{target_compatible_with}
)`},
	})
}

func TestCcBinaryVersionScript(t *testing.T) {
	runCcBinaryTests(t, bp2buildTestCase{
		description: `version script`,
		blueprint: `
{rule_name} {
    name: "foo",
    include_build_directory: false,
    version_script: "vs",
}
`,
		expectedBazelTargets: []string{`cc_binary(
    name = "foo",
    additional_linker_inputs = ["vs"],
    linkopts = ["-Wl,--version-script,$(location vs)"],{target_compatible_with}
)`},
	})
}

func TestCcBinarySplitSrcsByLang(t *testing.T) {
	runCcHostBinaryTestCase(t, bp2buildTestCase{
		description: "split srcs by lang",
		blueprint: `
{rule_name} {
    name: "foo",
    srcs: [
        "asonly.S",
        "conly.c",
        "cpponly.cpp",
        ":fg_foo",
    ],
    include_build_directory: false,
}
` + simpleModuleDoNotConvertBp2build("filegroup", "fg_foo"),
		expectedBazelTargets: []string{`cc_binary(
    name = "foo",
    srcs = [
        "cpponly.cpp",
        ":fg_foo_cpp_srcs",
    ],
    srcs_as = [
        "asonly.S",
        ":fg_foo_as_srcs",
    ],
    srcs_c = [
        "conly.c",
        ":fg_foo_c_srcs",
    ],{target_compatible_with}
)`},
	})
}

func TestCcBinaryDoNotDistinguishBetweenDepsAndImplementationDeps(t *testing.T) {
	runCcBinaryTestCase(t, bp2buildTestCase{
		description: "no implementation deps",
		blueprint: `
genrule {
    name: "generated_hdr",
    cmd: "nothing to see here",
}

genrule {
    name: "export_generated_hdr",
    cmd: "nothing to see here",
}

{rule_name} {
    name: "foo",
    srcs: ["foo.cpp"],
    shared_libs: ["implementation_shared_dep", "shared_dep"],
    export_shared_lib_headers: ["shared_dep"],
    static_libs: ["implementation_static_dep", "static_dep"],
    export_static_lib_headers: ["static_dep", "whole_static_dep"],
    whole_static_libs: ["not_explicitly_exported_whole_static_dep", "whole_static_dep"],
    include_build_directory: false,
    generated_headers: ["generated_hdr", "export_generated_hdr"],
    export_generated_headers: ["export_generated_hdr"],
}
` +
			simpleModuleDoNotConvertBp2build("cc_library_static", "static_dep") +
			simpleModuleDoNotConvertBp2build("cc_library_static", "implementation_static_dep") +
			simpleModuleDoNotConvertBp2build("cc_library_static", "whole_static_dep") +
			simpleModuleDoNotConvertBp2build("cc_library_static", "not_explicitly_exported_whole_static_dep") +
			simpleModuleDoNotConvertBp2build("cc_library", "shared_dep") +
			simpleModuleDoNotConvertBp2build("cc_library", "implementation_shared_dep"),
		expectedBazelTargets: []string{`cc_binary(
    name = "foo",
    deps = [
        ":implementation_static_dep",
        ":static_dep",
    ],
    dynamic_deps = [
        ":implementation_shared_dep",
        ":shared_dep",
    ],
    srcs = [
        "foo.cpp",
        ":generated_hdr",
        ":export_generated_hdr",
    ],{target_compatible_with}
    whole_archive_deps = [
        ":not_explicitly_exported_whole_static_dep",
        ":whole_static_dep",
    ],
)`},
	})
}

func TestCcBinaryNocrtTests(t *testing.T) {
	baseTestCases := []struct {
		description   string
		soongProperty string
		bazelAttr     string
	}{
		{
			description:   "nocrt: true",
			soongProperty: `nocrt: true,`,
			bazelAttr:     `    link_crt = False,`,
		},
		{
			description:   "nocrt: false",
			soongProperty: `nocrt: false,`,
		},
		{
			description: "nocrt: not set",
		},
	}

	baseBlueprint := `{rule_name} {
    name: "foo",%s
    include_build_directory: false,
}
`

	baseBazelTarget := `cc_binary(
    name = "foo",%s{target_compatible_with}
)`

	for _, btc := range baseTestCases {
		prop := btc.soongProperty
		if len(prop) > 0 {
			prop = "\n" + prop
		}
		attr := btc.bazelAttr
		if len(attr) > 0 {
			attr = "\n" + attr
		}
		runCcBinaryTests(t, bp2buildTestCase{
			description: btc.description,
			blueprint:   fmt.Sprintf(baseBlueprint, prop),
			expectedBazelTargets: []string{
				fmt.Sprintf(baseBazelTarget, attr),
			},
		})
	}
}

func TestCcBinaryNo_libcrtTests(t *testing.T) {
	baseTestCases := []struct {
		description   string
		soongProperty string
		bazelAttr     string
	}{
		{
			description:   "no_libcrt: true",
			soongProperty: `no_libcrt: true,`,
			bazelAttr:     `    use_libcrt = False,`,
		},
		{
			description:   "no_libcrt: false",
			soongProperty: `no_libcrt: false,`,
			bazelAttr:     `    use_libcrt = True,`,
		},
		{
			description: "no_libcrt: not set",
		},
	}

	baseBlueprint := `{rule_name} {
    name: "foo",%s
    include_build_directory: false,
}
`

	baseBazelTarget := `cc_binary(
    name = "foo",{target_compatible_with}%s
)`

	for _, btc := range baseTestCases {
		prop := btc.soongProperty
		if len(prop) > 0 {
			prop = "\n" + prop
		}
		attr := btc.bazelAttr
		if len(attr) > 0 {
			attr = "\n" + attr
		}
		runCcBinaryTests(t, bp2buildTestCase{
			description: btc.description,
			blueprint:   fmt.Sprintf(baseBlueprint, prop),
			expectedBazelTargets: []string{
				fmt.Sprintf(baseBazelTarget, attr),
			},
		})
	}
}

func TestCcBinaryPropertiesToFeatures(t *testing.T) {
	baseTestCases := []struct {
		description   string
		soongProperty string
		bazelAttr     string
	}{
		{
			description:   "pack_relocation: true",
			soongProperty: `pack_relocations: true,`,
		},
		{
			description:   "pack_relocations: false",
			soongProperty: `pack_relocations: false,`,
			bazelAttr:     `    features = ["disable_pack_relocations"],`,
		},
		{
			description: "pack_relocations: not set",
		},
		{
			description:   "pack_relocation: true",
			soongProperty: `allow_undefined_symbols: true,`,
			bazelAttr:     `    features = ["-no_undefined_symbols"],`,
		},
		{
			description:   "allow_undefined_symbols: false",
			soongProperty: `allow_undefined_symbols: false,`,
		},
		{
			description: "allow_undefined_symbols: not set",
		},
	}

	baseBlueprint := `{rule_name} {
    name: "foo",%s
    include_build_directory: false,
}
`

	baseBazelTarget := `cc_binary(
    name = "foo",%s{target_compatible_with}
)`

	for _, btc := range baseTestCases {
		prop := btc.soongProperty
		if len(prop) > 0 {
			prop = "\n" + prop
		}
		attr := btc.bazelAttr
		if len(attr) > 0 {
			attr = "\n" + attr
		}
		runCcBinaryTests(t, bp2buildTestCase{
			description: btc.description,
			blueprint:   fmt.Sprintf(baseBlueprint, prop),
			expectedBazelTargets: []string{
				fmt.Sprintf(baseBazelTarget, attr),
			},
		})
	}
}