// 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 /* For shareable/common bp2build testing functionality and dumping ground for specific-but-shared functionality among tests in package */ import ( "fmt" "sort" "strings" "testing" "github.com/google/blueprint/proptools" "android/soong/android" "android/soong/android/allowlists" "android/soong/bazel" ) var ( buildDir string ) func checkError(t *testing.T, errs []error, expectedErr error) bool { t.Helper() if len(errs) != 1 { return false } if strings.Contains(errs[0].Error(), expectedErr.Error()) { return true } return false } func errored(t *testing.T, tc Bp2buildTestCase, errs []error) bool { t.Helper() if tc.ExpectedErr != nil { // Rely on checkErrors, as this test case is expected to have an error. return false } if len(errs) > 0 { for _, err := range errs { t.Errorf("%s: %s", tc.Description, err) } return true } // All good, continue execution. return false } func RunBp2BuildTestCaseSimple(t *testing.T, tc Bp2buildTestCase) { t.Helper() RunBp2BuildTestCase(t, func(ctx android.RegistrationContext) {}, tc) } type Bp2buildTestCase struct { Description string ModuleTypeUnderTest string ModuleTypeUnderTestFactory android.ModuleFactory Blueprint string ExpectedBazelTargets []string Filesystem map[string]string Dir string // An error with a string contained within the string of the expected error ExpectedErr error UnconvertedDepsMode unconvertedDepsMode // For every directory listed here, the BUILD file for that directory will // be merged with the generated BUILD file. This allows custom BUILD targets // to be used in tests, or use BUILD files to draw package boundaries. KeepBuildFileForDirs []string } func RunBp2BuildTestCase(t *testing.T, registerModuleTypes func(ctx android.RegistrationContext), tc Bp2buildTestCase) { t.Helper() bp2buildSetup := android.GroupFixturePreparers( android.FixtureRegisterWithContext(registerModuleTypes), SetBp2BuildTestRunner, ) runBp2BuildTestCaseWithSetup(t, bp2buildSetup, tc) } func RunApiBp2BuildTestCase(t *testing.T, registerModuleTypes func(ctx android.RegistrationContext), tc Bp2buildTestCase) { t.Helper() apiBp2BuildSetup := android.GroupFixturePreparers( android.FixtureRegisterWithContext(registerModuleTypes), SetApiBp2BuildTestRunner, ) runBp2BuildTestCaseWithSetup(t, apiBp2BuildSetup, tc) } func runBp2BuildTestCaseWithSetup(t *testing.T, extraPreparer android.FixturePreparer, tc Bp2buildTestCase) { t.Helper() dir := "." filesystem := make(map[string][]byte) for f, content := range tc.Filesystem { filesystem[f] = []byte(content) } preparers := []android.FixturePreparer{ extraPreparer, android.FixtureMergeMockFs(filesystem), android.FixtureWithRootAndroidBp(tc.Blueprint), android.FixtureRegisterWithContext(func(ctx android.RegistrationContext) { ctx.RegisterModuleType(tc.ModuleTypeUnderTest, tc.ModuleTypeUnderTestFactory) }), android.FixtureModifyContext(func(ctx *android.TestContext) { // A default configuration for tests to not have to specify bp2build_available on top level // targets. bp2buildConfig := android.NewBp2BuildAllowlist().SetDefaultConfig( allowlists.Bp2BuildConfig{ android.Bp2BuildTopLevel: allowlists.Bp2BuildDefaultTrueRecursively, }, ) for _, f := range tc.KeepBuildFileForDirs { bp2buildConfig.SetKeepExistingBuildFile(map[string]bool{ f: /*recursive=*/ false, }) } ctx.RegisterBp2BuildConfig(bp2buildConfig) }), android.FixtureModifyEnv(func(env map[string]string) { if tc.UnconvertedDepsMode == errorModulesUnconvertedDeps { env["BP2BUILD_ERROR_UNCONVERTED"] = "true" } }), } preparer := android.GroupFixturePreparers(preparers...) if tc.ExpectedErr != nil { pattern := "\\Q" + tc.ExpectedErr.Error() + "\\E" preparer = preparer.ExtendWithErrorHandler(android.FixtureExpectsOneErrorPattern(pattern)) } result := preparer.RunTestWithCustomResult(t).(*BazelTestResult) if len(result.Errs) > 0 { return } checkDir := dir if tc.Dir != "" { checkDir = tc.Dir } expectedTargets := map[string][]string{ checkDir: tc.ExpectedBazelTargets, } result.CompareAllBazelTargets(t, tc.Description, expectedTargets, true) } // SetBp2BuildTestRunner customizes the test fixture mechanism to run tests in Bp2Build mode. var SetBp2BuildTestRunner = android.FixtureSetTestRunner(&bazelTestRunner{Bp2Build}) // SetApiBp2BuildTestRunner customizes the test fixture mechanism to run tests in ApiBp2build mode. var SetApiBp2BuildTestRunner = android.FixtureSetTestRunner(&bazelTestRunner{ApiBp2build}) // bazelTestRunner customizes the test fixture mechanism to run tests of the bp2build and // apiBp2build build modes. type bazelTestRunner struct { mode CodegenMode } func (b *bazelTestRunner) FinalPreparer(result *android.TestResult) android.CustomTestResult { ctx := result.TestContext switch b.mode { case Bp2Build: ctx.RegisterForBazelConversion() case ApiBp2build: ctx.RegisterForApiBazelConversion() default: panic(fmt.Errorf("unknown build mode: %d", b.mode)) } return &BazelTestResult{TestResult: result} } func (b *bazelTestRunner) PostParseProcessor(result android.CustomTestResult) { bazelResult := result.(*BazelTestResult) ctx := bazelResult.TestContext config := bazelResult.Config _, errs := ctx.ResolveDependencies(config) if bazelResult.CollateErrs(errs) { return } codegenCtx := NewCodegenContext(config, ctx.Context, Bp2Build, "") res, errs := GenerateBazelTargets(codegenCtx, false) if bazelResult.CollateErrs(errs) { return } // Store additional data for access by tests. bazelResult.conversionResults = res } // BazelTestResult is a wrapper around android.TestResult to provide type safe access to the bazel // specific data stored by the bazelTestRunner. type BazelTestResult struct { *android.TestResult // The result returned by the GenerateBazelTargets function. conversionResults } // CompareAllBazelTargets compares the BazelTargets produced by the test for all the directories // with the supplied set of expected targets. // // If ignoreUnexpected=false then this enforces an exact match where every BazelTarget produced must // have a corresponding expected BazelTarget. // // If ignoreUnexpected=true then it will ignore directories for which there are no expected targets. func (b BazelTestResult) CompareAllBazelTargets(t *testing.T, description string, expectedTargets map[string][]string, ignoreUnexpected bool) { t.Helper() actualTargets := b.buildFileToTargets // Generate the sorted set of directories to check. dirsToCheck := android.SortedKeys(expectedTargets) if !ignoreUnexpected { // This needs to perform an exact match so add the directories in which targets were // produced to the list of directories to check. dirsToCheck = append(dirsToCheck, android.SortedKeys(actualTargets)...) dirsToCheck = android.SortedUniqueStrings(dirsToCheck) } for _, dir := range dirsToCheck { expected := expectedTargets[dir] actual := actualTargets[dir] if expected == nil { if actual != nil { t.Errorf("did not expect any bazel modules in %q but found %d", dir, len(actual)) } } else if actual == nil { expectedCount := len(expected) if expectedCount > 0 { t.Errorf("expected %d bazel modules in %q but did not find any", expectedCount, dir) } } else { b.CompareBazelTargets(t, description, expected, actual) } } } func (b BazelTestResult) CompareBazelTargets(t *testing.T, description string, expectedContents []string, actualTargets BazelTargets) { t.Helper() if actualCount, expectedCount := len(actualTargets), len(expectedContents); actualCount != expectedCount { t.Errorf("%s: Expected %d bazel target (%s), got %d (%s)", description, expectedCount, expectedContents, actualCount, actualTargets) } else { sort.SliceStable(actualTargets, func(i, j int) bool { return actualTargets[i].name < actualTargets[j].name }) sort.SliceStable(expectedContents, func(i, j int) bool { return getTargetName(expectedContents[i]) < getTargetName(expectedContents[j]) }) for i, actualTarget := range actualTargets { if w, g := expectedContents[i], actualTarget.content; w != g { t.Errorf( "%s[%d]: Expected generated Bazel target to be `%s`, got `%s`", description, i, w, g) } } } } type nestedProps struct { Nested_prop *string } type EmbeddedProps struct { Embedded_prop *string } type OtherEmbeddedProps struct { Other_embedded_prop *string } type customProps struct { EmbeddedProps *OtherEmbeddedProps Bool_prop bool Bool_ptr_prop *bool // Ensure that properties tagged `blueprint:mutated` are omitted Int_prop int `blueprint:"mutated"` Int64_ptr_prop *int64 String_prop string String_literal_prop *string `android:"arch_variant"` String_ptr_prop *string String_list_prop []string Nested_props nestedProps Nested_props_ptr *nestedProps Arch_paths []string `android:"path,arch_variant"` Arch_paths_exclude []string `android:"path,arch_variant"` // Prop used to indicate this conversion should be 1 module -> multiple targets One_to_many_prop *bool Api *string // File describing the APIs of this module Test_config_setting *bool // Used to test generation of config_setting targets } type customModule struct { android.ModuleBase android.BazelModuleBase props customProps } // OutputFiles is needed because some instances of this module use dist with a // tag property which requires the module implements OutputFileProducer. func (m *customModule) OutputFiles(tag string) (android.Paths, error) { return android.PathsForTesting("path" + tag), nil } func (m *customModule) GenerateAndroidBuildActions(ctx android.ModuleContext) { // nothing for now. } func customModuleFactoryBase() android.Module { module := &customModule{} module.AddProperties(&module.props) android.InitBazelModule(module) return module } func customModuleFactoryHostAndDevice() android.Module { m := customModuleFactoryBase() android.InitAndroidArchModule(m, android.HostAndDeviceSupported, android.MultilibBoth) return m } func customModuleFactoryDeviceSupported() android.Module { m := customModuleFactoryBase() android.InitAndroidArchModule(m, android.DeviceSupported, android.MultilibBoth) return m } func customModuleFactoryHostSupported() android.Module { m := customModuleFactoryBase() android.InitAndroidArchModule(m, android.HostSupported, android.MultilibBoth) return m } func customModuleFactoryHostAndDeviceDefault() android.Module { m := customModuleFactoryBase() android.InitAndroidArchModule(m, android.HostAndDeviceDefault, android.MultilibBoth) return m } func customModuleFactoryNeitherHostNorDeviceSupported() android.Module { m := customModuleFactoryBase() android.InitAndroidArchModule(m, android.NeitherHostNorDeviceSupported, android.MultilibBoth) return m } type testProps struct { Test_prop struct { Test_string_prop string } } type customTestModule struct { android.ModuleBase props customProps test_props testProps } func (m *customTestModule) GenerateAndroidBuildActions(ctx android.ModuleContext) { // nothing for now. } func customTestModuleFactoryBase() android.Module { m := &customTestModule{} m.AddProperties(&m.props) m.AddProperties(&m.test_props) return m } func customTestModuleFactory() android.Module { m := customTestModuleFactoryBase() android.InitAndroidModule(m) return m } type customDefaultsModule struct { android.ModuleBase android.DefaultsModuleBase } func customDefaultsModuleFactoryBase() android.DefaultsModule { module := &customDefaultsModule{} module.AddProperties(&customProps{}) return module } func customDefaultsModuleFactoryBasic() android.Module { return customDefaultsModuleFactoryBase() } func customDefaultsModuleFactory() android.Module { m := customDefaultsModuleFactoryBase() android.InitDefaultsModule(m) return m } type EmbeddedAttr struct { Embedded_attr *string } type OtherEmbeddedAttr struct { Other_embedded_attr *string } type customBazelModuleAttributes struct { EmbeddedAttr *OtherEmbeddedAttr String_literal_prop bazel.StringAttribute String_ptr_prop *string String_list_prop []string Arch_paths bazel.LabelListAttribute Api bazel.LabelAttribute } func (m *customModule) ConvertWithBp2build(ctx android.TopDownMutatorContext) { if p := m.props.One_to_many_prop; p != nil && *p { customBp2buildOneToMany(ctx, m) return } paths := bazel.LabelListAttribute{} strAttr := bazel.StringAttribute{} for axis, configToProps := range m.GetArchVariantProperties(ctx, &customProps{}) { for config, props := range configToProps { if custProps, ok := props.(*customProps); ok { if custProps.Arch_paths != nil { paths.SetSelectValue(axis, config, android.BazelLabelForModuleSrcExcludes(ctx, custProps.Arch_paths, custProps.Arch_paths_exclude)) } if custProps.String_literal_prop != nil { strAttr.SetSelectValue(axis, config, custProps.String_literal_prop) } } } } productVariableProps := android.ProductVariableProperties(ctx, ctx.Module()) if props, ok := productVariableProps["String_literal_prop"]; ok { for c, p := range props { if val, ok := p.(*string); ok { strAttr.SetSelectValue(c.ConfigurationAxis(), c.SelectKey(), val) } } } paths.ResolveExcludes() attrs := &customBazelModuleAttributes{ String_literal_prop: strAttr, String_ptr_prop: m.props.String_ptr_prop, String_list_prop: m.props.String_list_prop, Arch_paths: paths, } attrs.Embedded_attr = m.props.Embedded_prop if m.props.OtherEmbeddedProps != nil { attrs.OtherEmbeddedAttr = &OtherEmbeddedAttr{Other_embedded_attr: m.props.OtherEmbeddedProps.Other_embedded_prop} } props := bazel.BazelTargetModuleProperties{ Rule_class: "custom", } ctx.CreateBazelTargetModule(props, android.CommonAttributes{Name: m.Name()}, attrs) if proptools.Bool(m.props.Test_config_setting) { m.createConfigSetting(ctx) } } func (m *customModule) createConfigSetting(ctx android.TopDownMutatorContext) { csa := bazel.ConfigSettingAttributes{ Flag_values: bazel.StringMapAttribute{ "//build/bazel/rules/my_string_setting": m.Name(), }, } ca := android.CommonAttributes{ Name: m.Name() + "_config_setting", } ctx.CreateBazelConfigSetting( csa, ca, ctx.ModuleDir(), ) } var _ android.ApiProvider = (*customModule)(nil) func (c *customModule) ConvertWithApiBp2build(ctx android.TopDownMutatorContext) { props := bazel.BazelTargetModuleProperties{ Rule_class: "custom_api_contribution", } apiAttribute := bazel.MakeLabelAttribute( android.BazelLabelForModuleSrcSingle(ctx, proptools.String(c.props.Api)).Label, ) attrs := &customBazelModuleAttributes{ Api: *apiAttribute, } ctx.CreateBazelTargetModule(props, android.CommonAttributes{Name: c.Name()}, attrs) } // A bp2build mutator that uses load statements and creates a 1:M mapping from // module to target. func customBp2buildOneToMany(ctx android.TopDownMutatorContext, m *customModule) { baseName := m.Name() attrs := &customBazelModuleAttributes{} myLibraryProps := bazel.BazelTargetModuleProperties{ Rule_class: "my_library", Bzl_load_location: "//build/bazel/rules:rules.bzl", } ctx.CreateBazelTargetModule(myLibraryProps, android.CommonAttributes{Name: baseName}, attrs) protoLibraryProps := bazel.BazelTargetModuleProperties{ Rule_class: "proto_library", Bzl_load_location: "//build/bazel/rules:proto.bzl", } ctx.CreateBazelTargetModule(protoLibraryProps, android.CommonAttributes{Name: baseName + "_proto_library_deps"}, attrs) myProtoLibraryProps := bazel.BazelTargetModuleProperties{ Rule_class: "my_proto_library", Bzl_load_location: "//build/bazel/rules:proto.bzl", } ctx.CreateBazelTargetModule(myProtoLibraryProps, android.CommonAttributes{Name: baseName + "_my_proto_library_deps"}, attrs) } // Helper method for tests to easily access the targets in a dir. func generateBazelTargetsForDir(codegenCtx *CodegenContext, dir string) (BazelTargets, []error) { // TODO: Set generateFilegroups to true and/or remove the generateFilegroups argument completely res, err := GenerateBazelTargets(codegenCtx, false) if err != nil { return BazelTargets{}, err } return res.buildFileToTargets[dir], err } func registerCustomModuleForBp2buildConversion(ctx *android.TestContext) { ctx.RegisterModuleType("custom", customModuleFactoryHostAndDevice) ctx.RegisterForBazelConversion() } func simpleModuleDoNotConvertBp2build(typ, name string) string { return fmt.Sprintf(` %s { name: "%s", bazel_module: { bp2build_available: false }, }`, typ, name) } type AttrNameToString map[string]string func (a AttrNameToString) clone() AttrNameToString { newAttrs := make(AttrNameToString, len(a)) for k, v := range a { newAttrs[k] = v } return newAttrs } // makeBazelTargetNoRestrictions returns bazel target build file definition that can be host or // device specific, or independent of host/device. func makeBazelTargetHostOrDevice(typ, name string, attrs AttrNameToString, hod android.HostOrDeviceSupported) string { if _, ok := attrs["target_compatible_with"]; !ok { switch hod { case android.HostSupported: attrs["target_compatible_with"] = `select({ "//build/bazel/platforms/os:android": ["@platforms//:incompatible"], "//conditions:default": [], })` case android.DeviceSupported: attrs["target_compatible_with"] = `["//build/bazel/platforms/os:android"]` } } attrStrings := make([]string, 0, len(attrs)+1) if name != "" { attrStrings = append(attrStrings, fmt.Sprintf(` name = "%s",`, name)) } for _, k := range android.SortedKeys(attrs) { attrStrings = append(attrStrings, fmt.Sprintf(" %s = %s,", k, attrs[k])) } return fmt.Sprintf(`%s( %s )`, typ, strings.Join(attrStrings, "\n")) } // MakeBazelTargetNoRestrictions returns bazel target build file definition that does not add a // target_compatible_with. This is useful for module types like filegroup and genrule that arch not // arch variant func MakeBazelTargetNoRestrictions(typ, name string, attrs AttrNameToString) string { return makeBazelTargetHostOrDevice(typ, name, attrs, android.HostAndDeviceDefault) } // makeBazelTargetNoRestrictions returns bazel target build file definition that is device specific // as this is the most common default in Soong. func MakeBazelTarget(typ, name string, attrs AttrNameToString) string { return makeBazelTargetHostOrDevice(typ, name, attrs, android.DeviceSupported) } type ExpectedRuleTarget struct { Rule string Name string Attrs AttrNameToString Hod android.HostOrDeviceSupported } func (ebr ExpectedRuleTarget) String() string { return makeBazelTargetHostOrDevice(ebr.Rule, ebr.Name, ebr.Attrs, ebr.Hod) } func makeCcStubSuiteTargets(name string, attrs AttrNameToString) string { if _, hasStubs := attrs["stubs_symbol_file"]; !hasStubs { return "" } STUB_SUITE_ATTRS := map[string]string{ "stubs_symbol_file": "symbol_file", "stubs_versions": "versions", "soname": "soname", "source_library_label": "source_library_label", } stubSuiteAttrs := AttrNameToString{} for key, _ := range attrs { if _, stubSuiteAttr := STUB_SUITE_ATTRS[key]; stubSuiteAttr { stubSuiteAttrs[STUB_SUITE_ATTRS[key]] = attrs[key] } else { panic(fmt.Sprintf("unused cc_stub_suite attr %q\n", key)) } } return MakeBazelTarget("cc_stub_suite", name+"_stub_libs", stubSuiteAttrs) } func MakeNeverlinkDuplicateTarget(moduleType string, name string) string { return MakeNeverlinkDuplicateTargetWithAttrs(moduleType, name, AttrNameToString{}) } func MakeNeverlinkDuplicateTargetWithAttrs(moduleType string, name string, extraAttrs AttrNameToString) string { attrs := extraAttrs attrs["neverlink"] = `True` attrs["exports"] = `[":` + name + `"]` return MakeBazelTarget(moduleType, name+"-neverlink", attrs) } func getTargetName(targetContent string) string { data := strings.Split(targetContent, "name = \"") if len(data) < 2 { return "" } else { endIndex := strings.Index(data[1], "\"") return data[1][:endIndex] } }