Minimal license feature. (58d85b87) · Commits · e / os / android_build_soong

Android.bp

+4 −0

Original line number	Diff line number	Diff line
		@@ -49,6 +49,7 @@ bootstrap_go_package {
		"android/expand.go",
		"android/filegroup.go",
		"android/hooks.go",
		"android/license.go",
		"android/makevars.go",
		"android/module.go",
		"android/mutator.go",
		@@ -57,6 +58,7 @@ bootstrap_go_package {
		"android/notices.go",
		"android/onceper.go",
		"android/override_module.go",
		"android/package.go",
		"android/package_ctx.go",
		"android/path_properties.go",
		"android/paths.go",
		@@ -80,10 +82,12 @@ bootstrap_go_package {
		"android/arch_test.go",
		"android/config_test.go",
		"android/expand_test.go",
		"android/license_test.go",
		"android/namespace_test.go",
		"android/neverallow_test.go",
		"android/onceper_test.go",
		"android/path_properties_test.go",
		"android/package_test.go",
		"android/paths_test.go",
		"android/prebuilt_test.go",
		"android/prebuilt_etc_test.go",

android/license.go

0 → 100644

+69 −0

Original line number	Diff line number	Diff line
		// Copyright 2020 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 android

		import (
		"github.com/google/blueprint"
		)

		func init() {
		RegisterModuleType("license", LicenseFactory)
		}

		type licenseProperties struct {
		// Specifies the kinds of license that apply.
		License_kinds []string
		// Specifies a short copyright notice to use for the license.
		Copyright_notice *string
		// Specifies the path or label for the text of the license.
		License_text []string `android:"path"`
		// Specifies the package name to which the license applies.
		Package_name *string
		// Specifies where this license can be used
		Visibility []string
		}

		type licenseModule struct {
		ModuleBase
		DefaultableModuleBase

		properties licenseProperties
		}

		func (m *licenseModule) DepsMutator(ctx BottomUpMutatorContext) {
		// Do nothing.
		}

		func (m *licenseModule) GenerateAndroidBuildActions(ctx ModuleContext) {
		// Nothing to do.
		}

		func (m *licenseModule) GenerateBuildActions(ctx blueprint.ModuleContext) {
		// Nothing to do.
		}

		func LicenseFactory() Module {
		module := &licenseModule{}

		base := module.base()
		module.AddProperties(
		&base.nameProperties,
		&module.properties)

		base.generalProperties = module.GetProperties()
		base.customizableProperties = module.GetProperties()

		return module
		}

android/license_test.go

0 → 100644

+150 −0

Original line number	Diff line number	Diff line
		package android

		import (
		"io/ioutil"
		"os"
		"testing"
		)

		var licenseTests = []struct {
		name string
		fs map[string][]byte
		expectedErrors []string
		}{
		{
		name: "license must not accept licenses property",
		fs: map[string][]byte{
		"top/Blueprints": []byte(`
		license {
		name: "top_license",
		visibility: ["//visibility:private"],
		licenses: ["other_license"],

		}`),
		},
		expectedErrors: []string{
		`top/Blueprints:5:14: unrecognized property "licenses"`,
		},
		},
		{
		name: "public license",
		fs: map[string][]byte{
		"top/Blueprints": []byte(`
		license {
		name: "top_proprietary",
		license_kinds: ["top_by_exception_only"],
		visibility: ["//visibility:public"],
		}`),
		"other/Blueprints": []byte(`
		rule {
		name: "arule",
		licenses: ["top_proprietary"],

		}`),
		"yetmore/Blueprints": []byte(`
		package {
		default_applicable_licenses: ["top_proprietary"],
		}`),
		},
		},
		{
		name: "multiple licenses",
		fs: map[string][]byte{
		"top/Blueprints": []byte(`
		package {
		default_applicable_licenses: ["top_proprietary"],
		}
		license {
		name: "top_allowed_as_notice",
		license_kinds: ["top_notice"],
		}
		license {
		name: "top_proprietary",
		license_kinds: ["top_by_exception_only"],
		visibility: ["//visibility:public"],
		}
		rule {
		name: "myrule",
		licenses: ["top_allowed_as_notice", "top_proprietary"]
		}`),
		"other/Blueprints": []byte(`
		rule {
		name: "arule",
		licenses: ["top_proprietary"],

		}`),
		"yetmore/Blueprints": []byte(`
		package {
		default_applicable_licenses: ["top_proprietary"],
		}`),
		},
		},
		}

		func TestLicense(t *testing.T) {
		for _, test := range licenseTests {
		t.Run(test.name, func(t *testing.T) {
		_, errs := testLicense(test.fs)
		expectedErrors := test.expectedErrors
		if expectedErrors == nil {
		FailIfErrored(t, errs)
		} else {
		for _, expectedError := range expectedErrors {
		FailIfNoMatchingErrors(t, expectedError, errs)
		}
		if len(errs) > len(expectedErrors) {
		t.Errorf("additional errors found, expected %d, found %d", len(expectedErrors), len(errs))
		for i, expectedError := range expectedErrors {
		t.Errorf("expectedErrors[%d] = %s", i, expectedError)
		}
		for i, err := range errs {
		t.Errorf("errs[%d] = %s", i, err)
		}
		}
		}
		})
		}
		}
		func testLicense(fs map[string][]byte) (*TestContext, []error) {
		buildDir, err := ioutil.TempDir("", "license_test")
		if err != nil {
		return nil, []error{err}
		}
		defer os.RemoveAll(buildDir)

		// Create a new config per test as visibility information is stored in the config.
		env := make(map[string]string)
		env["ANDROID_REQUIRE_LICENSES"] = "1"
		config := TestArchConfig(buildDir, env)
		ctx := NewTestArchContext()
		ctx.MockFileSystem(fs)
		ctx.RegisterModuleType("package", ModuleFactoryAdaptor(PackageFactory))
		ctx.RegisterModuleType("license", ModuleFactoryAdaptor(LicenseFactory))
		ctx.RegisterModuleType("rule", ModuleFactoryAdaptor(newMockRuleModule))
		ctx.PreArchMutators(registerPackageRenamer)
		ctx.Register()
		_, errs := ctx.ParseBlueprintsFiles(".")
		if len(errs) > 0 {
		return ctx, errs
		}
		_, errs = ctx.PrepareBuildActions(config)
		return ctx, errs
		}

		type mockRuleModule struct {
		ModuleBase
		DefaultableModuleBase
		}

		func newMockRuleModule() Module {
		m := &mockRuleModule{}
		InitAndroidModule(m)
		InitDefaultableModule(m)
		return m
		}

		func (p *mockRuleModule) GenerateAndroidBuildActions(ModuleContext) {
		}

		func (p *mockRuleModule) DepsMutator(BottomUpMutatorContext) {
		}

android/module.go

+3 −0

Original line number	Diff line number	Diff line
		@@ -208,6 +208,9 @@ type commonProperties struct {
		// emit build rules for this module
		Enabled *bool `android:"arch_variant"`

		// Names of the licenses that apply to this module.
		Licenses []string

		// control whether this module compiles for 32-bit, 64-bit, or both. Possible values
		// are "32" (compile for 32-bit only), "64" (compile for 64-bit only), "both" (compile for both
		// architectures), or "first" (compile for 64-bit on a 64-bit platform, and 32-bit on a 32-bit

android/mutator.go

+1 −0

Original line number	Diff line number	Diff line
		@@ -77,6 +77,7 @@ var preArch = []RegisterMutatorFunc{
		ctx.TopDown("load_hooks", LoadHookMutator).Parallel()
		},
		RegisterNamespaceMutator,
		registerPackageRenamer,
		RegisterPrebuiltsPreArchMutators,
		RegisterDefaultsPreArchMutators,
		RegisterOverridePreArchMutators,