You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1279 lines
30 KiB
1279 lines
30 KiB
// Copyright (C) 2019 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.
|
|
|
|
package aidl
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/google/blueprint"
|
|
"github.com/google/blueprint/proptools"
|
|
|
|
"android/soong/android"
|
|
"android/soong/apex"
|
|
"android/soong/cc"
|
|
"android/soong/genrule"
|
|
"android/soong/java"
|
|
"android/soong/rust"
|
|
)
|
|
|
|
func TestMain(m *testing.M) {
|
|
os.Exit(m.Run())
|
|
}
|
|
|
|
func withFiles(files map[string][]byte) android.FixturePreparer {
|
|
return android.FixtureMergeMockFs(files)
|
|
}
|
|
|
|
func intPtr(v int) *int {
|
|
return &v
|
|
}
|
|
|
|
func setReleaseEnv() android.FixturePreparer {
|
|
return android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
|
|
// Q is finalized as 29. No codename that is actively being developed.
|
|
variables.Platform_sdk_version = intPtr(29)
|
|
variables.Platform_sdk_codename = proptools.StringPtr("REL")
|
|
variables.Platform_sdk_final = proptools.BoolPtr(true)
|
|
variables.Platform_version_active_codenames = []string{}
|
|
})
|
|
}
|
|
|
|
func _testAidl(t *testing.T, bp string, customizers ...android.FixturePreparer) android.FixturePreparer {
|
|
t.Helper()
|
|
|
|
preparers := []android.FixturePreparer{}
|
|
|
|
preparers = append(preparers,
|
|
cc.PrepareForTestWithCcDefaultModules,
|
|
java.PrepareForTestWithJavaDefaultModules,
|
|
genrule.PrepareForTestWithGenRuleBuildComponents,
|
|
)
|
|
|
|
bp = bp + `
|
|
package {
|
|
default_visibility: ["//visibility:public"],
|
|
}
|
|
java_defaults {
|
|
name: "aidl-java-module-defaults",
|
|
}
|
|
cc_defaults {
|
|
name: "aidl-cpp-module-defaults",
|
|
}
|
|
rust_defaults {
|
|
name: "aidl-rust-module-defaults",
|
|
}
|
|
cc_library {
|
|
name: "libbinder",
|
|
}
|
|
cc_library {
|
|
name: "libutils",
|
|
}
|
|
cc_library {
|
|
name: "libcutils",
|
|
}
|
|
cc_library {
|
|
name: "libbinder_ndk",
|
|
stubs: {
|
|
versions: ["29"],
|
|
}
|
|
}
|
|
ndk_library {
|
|
name: "libbinder_ndk",
|
|
symbol_file: "libbinder_ndk.map.txt",
|
|
first_version: "29",
|
|
}
|
|
cc_library {
|
|
name: "liblog",
|
|
no_libcrt: true,
|
|
nocrt: true,
|
|
system_shared_libs: [],
|
|
}
|
|
rust_library {
|
|
name: "libstd",
|
|
crate_name: "std",
|
|
srcs: [""],
|
|
no_stdlibs: true,
|
|
sysroot: true,
|
|
}
|
|
rust_library {
|
|
name: "libtest",
|
|
crate_name: "test",
|
|
srcs: [""],
|
|
no_stdlibs: true,
|
|
sysroot: true,
|
|
}
|
|
rust_library {
|
|
name: "liblazy_static",
|
|
crate_name: "lazy_static",
|
|
srcs: [""],
|
|
}
|
|
rust_library {
|
|
name: "libbinder_rs",
|
|
crate_name: "binder",
|
|
srcs: [""],
|
|
}
|
|
`
|
|
|
|
preparers = append(preparers, android.FixtureWithRootAndroidBp(bp))
|
|
preparers = append(preparers, android.FixtureAddTextFile("system/tools/aidl/build/Android.bp", `
|
|
aidl_interfaces_metadata {
|
|
name: "aidl_metadata_json",
|
|
visibility: ["//system/tools/aidl:__subpackages__"],
|
|
}
|
|
`))
|
|
|
|
preparers = append(preparers, android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
|
|
// To keep tests stable, fix Platform_sdk_codename and Platform_sdk_final
|
|
// Use setReleaseEnv() to test release version
|
|
variables.Platform_sdk_version = intPtr(28)
|
|
variables.Platform_sdk_codename = proptools.StringPtr("Q")
|
|
variables.Platform_version_active_codenames = []string{"Q"}
|
|
variables.Platform_sdk_final = proptools.BoolPtr(false)
|
|
}))
|
|
|
|
preparers = append(preparers, customizers...)
|
|
|
|
preparers = append(preparers,
|
|
apex.PrepareForTestWithApexBuildComponents,
|
|
rust.PrepareForTestWithRustBuildComponents,
|
|
android.FixtureRegisterWithContext(func(ctx android.RegistrationContext) {
|
|
ctx.RegisterModuleType("aidl_interface", aidlInterfaceFactory)
|
|
ctx.RegisterModuleType("aidl_interfaces_metadata", aidlInterfacesMetadataSingletonFactory)
|
|
ctx.RegisterModuleType("rust_defaults", func() android.Module {
|
|
return rust.DefaultsFactory()
|
|
})
|
|
|
|
ctx.PreArchMutators(func(ctx android.RegisterMutatorsContext) {
|
|
ctx.BottomUp("checkImports", checkImports)
|
|
ctx.TopDown("createAidlInterface", createAidlInterfaceMutator)
|
|
})
|
|
|
|
ctx.PostDepsMutators(func(ctx android.RegisterMutatorsContext) {
|
|
ctx.BottomUp("checkUnstableModule", checkUnstableModuleMutator).Parallel()
|
|
ctx.BottomUp("recordVersions", recordVersions).Parallel()
|
|
ctx.BottomUp("checkDuplicatedVersions", checkDuplicatedVersions).Parallel()
|
|
})
|
|
}),
|
|
)
|
|
|
|
return android.GroupFixturePreparers(preparers...)
|
|
}
|
|
|
|
func testAidl(t *testing.T, bp string, customizers ...android.FixturePreparer) (*android.TestContext, android.Config) {
|
|
t.Helper()
|
|
preparer := _testAidl(t, bp, customizers...)
|
|
result := preparer.RunTest(t)
|
|
return result.TestContext, result.Config
|
|
}
|
|
|
|
func testAidlError(t *testing.T, pattern, bp string, customizers ...android.FixturePreparer) {
|
|
t.Helper()
|
|
preparer := _testAidl(t, bp, customizers...)
|
|
preparer.
|
|
ExtendWithErrorHandler(android.FixtureExpectsAtLeastOneErrorMatchingPattern(pattern)).
|
|
RunTest(t)
|
|
}
|
|
|
|
// asserts that there are expected module regardless of variants
|
|
func assertModulesExists(t *testing.T, ctx *android.TestContext, names ...string) {
|
|
t.Helper()
|
|
missing := []string{}
|
|
for _, name := range names {
|
|
variants := ctx.ModuleVariantsForTests(name)
|
|
if len(variants) == 0 {
|
|
missing = append(missing, name)
|
|
}
|
|
}
|
|
if len(missing) > 0 {
|
|
// find all the modules that do exist
|
|
allModuleNames := make(map[string]bool)
|
|
ctx.VisitAllModules(func(m blueprint.Module) {
|
|
allModuleNames[ctx.ModuleName(m)] = true
|
|
})
|
|
t.Errorf("expected modules(%v) not found. all modules: %v", missing, android.SortedStringKeys(allModuleNames))
|
|
}
|
|
}
|
|
|
|
func assertContains(t *testing.T, actual, expected string) {
|
|
t.Helper()
|
|
if !strings.Contains(actual, expected) {
|
|
t.Errorf("%q is not found in %q.", expected, actual)
|
|
}
|
|
}
|
|
|
|
func assertListContains(t *testing.T, actual []string, expected string) {
|
|
t.Helper()
|
|
for _, a := range actual {
|
|
if strings.Contains(a, expected) {
|
|
return
|
|
}
|
|
}
|
|
t.Errorf("%q is not found in %v.", expected, actual)
|
|
}
|
|
|
|
// Vintf module must have versions in release version
|
|
func TestVintfWithoutVersionInRelease(t *testing.T) {
|
|
vintfWithoutVersionBp := `
|
|
aidl_interface {
|
|
name: "foo",
|
|
stability: "vintf",
|
|
srcs: [
|
|
"IFoo.aidl",
|
|
],
|
|
backend: {
|
|
rust: {
|
|
enabled: true,
|
|
},
|
|
},
|
|
}`
|
|
expectedError := `module "foo_interface": versions: must be set \(need to be frozen\) when "unstable" is false, PLATFORM_VERSION_CODENAME is REL, and "owner" property is missing.`
|
|
testAidlError(t, expectedError, vintfWithoutVersionBp, setReleaseEnv())
|
|
|
|
ctx, _ := testAidl(t, vintfWithoutVersionBp)
|
|
assertModulesExists(t, ctx, "foo-V1-java", "foo-V1-rust", "foo-V1-cpp", "foo-V1-ndk", "foo-V1-ndk_platform")
|
|
}
|
|
|
|
// Check if using unstable version in release cause an error.
|
|
func TestUnstableVersionUsageInRelease(t *testing.T) {
|
|
unstableVersionUsageInJavaBp := `
|
|
aidl_interface {
|
|
name: "foo",
|
|
versions: [
|
|
"1",
|
|
],
|
|
srcs: [
|
|
"IFoo.aidl",
|
|
],
|
|
}
|
|
java_library {
|
|
name: "bar",
|
|
libs: ["foo-V2-java"],
|
|
}`
|
|
|
|
expectedError := `foo-V2-java is disallowed in release version because it is unstable.`
|
|
testAidlError(t, expectedError, unstableVersionUsageInJavaBp, setReleaseEnv(), withFiles(map[string][]byte{
|
|
"aidl_api/foo/1/foo.1.aidl": nil,
|
|
}))
|
|
|
|
testAidl(t, unstableVersionUsageInJavaBp, withFiles(map[string][]byte{
|
|
"aidl_api/foo/1/foo.1.aidl": nil,
|
|
}))
|
|
|
|
// A stable version can be used in release version
|
|
stableVersionUsageInJavaBp := `
|
|
aidl_interface {
|
|
name: "foo",
|
|
versions: [
|
|
"1",
|
|
],
|
|
srcs: [
|
|
"IFoo.aidl",
|
|
],
|
|
}
|
|
java_library {
|
|
name: "bar",
|
|
libs: ["foo-V1-java"],
|
|
}`
|
|
|
|
testAidl(t, stableVersionUsageInJavaBp, setReleaseEnv(), withFiles(map[string][]byte{
|
|
"aidl_api/foo/1/foo.1.aidl": nil,
|
|
}))
|
|
|
|
testAidl(t, stableVersionUsageInJavaBp, withFiles(map[string][]byte{
|
|
"aidl_api/foo/1/foo.1.aidl": nil,
|
|
}))
|
|
}
|
|
|
|
// The module which has never been frozen and is not "unstable" is not allowed in release version.
|
|
func TestNonVersionedModuleUsageInRelease(t *testing.T) {
|
|
nonVersionedModuleUsageInJavaBp := `
|
|
aidl_interface {
|
|
name: "foo",
|
|
srcs: [
|
|
"IFoo.aidl",
|
|
],
|
|
}
|
|
|
|
java_library {
|
|
name: "bar",
|
|
libs: ["foo-V1-java"],
|
|
}`
|
|
|
|
expectedError := `"foo_interface": versions: must be set \(need to be frozen\) when "unstable" is false, PLATFORM_VERSION_CODENAME is REL, and "owner" property is missing.`
|
|
testAidlError(t, expectedError, nonVersionedModuleUsageInJavaBp, setReleaseEnv())
|
|
testAidl(t, nonVersionedModuleUsageInJavaBp)
|
|
|
|
nonVersionedUnstableModuleUsageInJavaBp := `
|
|
aidl_interface {
|
|
name: "foo",
|
|
srcs: [
|
|
"IFoo.aidl",
|
|
],
|
|
unstable: true,
|
|
}
|
|
|
|
java_library {
|
|
name: "bar",
|
|
libs: ["foo-java"],
|
|
}`
|
|
|
|
testAidl(t, nonVersionedUnstableModuleUsageInJavaBp, setReleaseEnv())
|
|
testAidl(t, nonVersionedUnstableModuleUsageInJavaBp)
|
|
}
|
|
|
|
func TestImportInRelease(t *testing.T) {
|
|
importInRelease := `
|
|
aidl_interface {
|
|
name: "foo",
|
|
srcs: [
|
|
"IFoo.aidl",
|
|
],
|
|
imports: ["bar"],
|
|
versions: ["1"],
|
|
}
|
|
|
|
aidl_interface {
|
|
name: "bar",
|
|
srcs: [
|
|
"IBar.aidl",
|
|
],
|
|
versions: ["1"],
|
|
}
|
|
`
|
|
|
|
testAidl(t, importInRelease, setReleaseEnv(), withFiles(map[string][]byte{
|
|
"aidl_api/foo/1/foo.1.aidl": nil,
|
|
"aidl_api/foo/1/.hash": nil,
|
|
"aidl_api/bar/1/bar.1.aidl": nil,
|
|
"aidl_api/bar/1/.hash": nil,
|
|
}))
|
|
}
|
|
|
|
func TestUnstableVersionedModuleUsageInRelease(t *testing.T) {
|
|
nonVersionedModuleUsageInJavaBp := `
|
|
aidl_interface {
|
|
name: "foo",
|
|
srcs: [
|
|
"IFoo.aidl",
|
|
],
|
|
versions: ["1"],
|
|
}
|
|
|
|
java_library {
|
|
name: "bar",
|
|
libs: ["foo-V2-java"],
|
|
}`
|
|
|
|
expectedError := `Android.bp:10:2: module \"bar\" variant \"android_common\": foo-V2-java is disallowed in release version because it is unstable, and its \"owner\" property is missing.`
|
|
testAidlError(t, expectedError, nonVersionedModuleUsageInJavaBp, setReleaseEnv())
|
|
testAidl(t, nonVersionedModuleUsageInJavaBp, withFiles(map[string][]byte{
|
|
"aidl_api/foo/1/foo.1.aidl": nil,
|
|
}))
|
|
}
|
|
|
|
func TestUnstableModules(t *testing.T) {
|
|
testAidlError(t, `module "foo_interface": stability: must be empty when "unstable" is true`, `
|
|
aidl_interface {
|
|
name: "foo",
|
|
stability: "vintf",
|
|
unstable: true,
|
|
srcs: [
|
|
"IFoo.aidl",
|
|
],
|
|
backend: {
|
|
rust: {
|
|
enabled: true,
|
|
},
|
|
},
|
|
}
|
|
`)
|
|
|
|
testAidlError(t, `module "foo_interface": versions: cannot have versions for an unstable interface`, `
|
|
aidl_interface {
|
|
name: "foo",
|
|
versions: [
|
|
"1",
|
|
],
|
|
unstable: true,
|
|
srcs: [
|
|
"IFoo.aidl",
|
|
],
|
|
backend: {
|
|
rust: {
|
|
enabled: true,
|
|
},
|
|
},
|
|
}
|
|
`)
|
|
|
|
ctx, _ := testAidl(t, `
|
|
aidl_interface {
|
|
name: "foo",
|
|
unstable: true,
|
|
srcs: [
|
|
"IFoo.aidl",
|
|
],
|
|
backend: {
|
|
rust: {
|
|
enabled: true,
|
|
},
|
|
},
|
|
}
|
|
`)
|
|
|
|
assertModulesExists(t, ctx, "foo-java", "foo-rust", "foo-cpp", "foo-ndk", "foo-ndk_platform")
|
|
}
|
|
|
|
func TestCreatesModulesWithNoVersions(t *testing.T) {
|
|
ctx, _ := testAidl(t, `
|
|
aidl_interface {
|
|
name: "foo",
|
|
srcs: [
|
|
"IFoo.aidl",
|
|
],
|
|
backend: {
|
|
rust: {
|
|
enabled: true,
|
|
},
|
|
},
|
|
}
|
|
`)
|
|
|
|
assertModulesExists(t, ctx, "foo-V1-java", "foo-V1-rust", "foo-V1-cpp", "foo-V1-ndk", "foo-V1-ndk_platform")
|
|
}
|
|
|
|
func TestCreatesModulesWithFrozenVersions(t *testing.T) {
|
|
// Each version should be under aidl_api/<name>/<ver>
|
|
testAidlError(t, `aidl_api/foo/1`, `
|
|
aidl_interface {
|
|
name: "foo",
|
|
srcs: [
|
|
"IFoo.aidl",
|
|
],
|
|
versions: [
|
|
"1",
|
|
],
|
|
backend: {
|
|
rust: {
|
|
enabled: true,
|
|
},
|
|
},
|
|
}
|
|
`)
|
|
|
|
ctx, _ := testAidl(t, `
|
|
aidl_interface {
|
|
name: "foo",
|
|
srcs: [
|
|
"IFoo.aidl",
|
|
],
|
|
versions: [
|
|
"1",
|
|
],
|
|
backend: {
|
|
rust: {
|
|
enabled: true,
|
|
},
|
|
},
|
|
}
|
|
`, withFiles(map[string][]byte{
|
|
"aidl_api/foo/1/foo.1.aidl": nil,
|
|
}))
|
|
|
|
// For frozen version "1"
|
|
assertModulesExists(t, ctx, "foo-V1-java", "foo-V1-rust", "foo-V1-cpp", "foo-V1-ndk", "foo-V1-ndk_platform")
|
|
|
|
// For ToT (current)
|
|
assertModulesExists(t, ctx, "foo-V2-java", "foo-V2-rust", "foo-V2-cpp", "foo-V2-ndk", "foo-V2-ndk_platform")
|
|
}
|
|
|
|
func TestErrorsWithUnsortedVersions(t *testing.T) {
|
|
testAidlError(t, `versions: should be sorted`, `
|
|
aidl_interface {
|
|
name: "foo",
|
|
srcs: [
|
|
"IFoo.aidl",
|
|
],
|
|
versions: [
|
|
"2",
|
|
"1",
|
|
],
|
|
backend: {
|
|
rust: {
|
|
enabled: true,
|
|
},
|
|
},
|
|
}
|
|
`)
|
|
}
|
|
|
|
func TestErrorsWithDuplicateVersions(t *testing.T) {
|
|
testAidlError(t, `versions: duplicate`, `
|
|
aidl_interface {
|
|
name: "foo",
|
|
srcs: [
|
|
"IFoo.aidl",
|
|
],
|
|
versions: [
|
|
"1",
|
|
"1",
|
|
],
|
|
}
|
|
`)
|
|
}
|
|
|
|
func TestErrorsWithNonPositiveVersions(t *testing.T) {
|
|
testAidlError(t, `versions: should be > 0`, `
|
|
aidl_interface {
|
|
name: "foo",
|
|
srcs: [
|
|
"IFoo.aidl",
|
|
],
|
|
versions: [
|
|
"-1",
|
|
"1",
|
|
],
|
|
}
|
|
`)
|
|
}
|
|
|
|
func TestErrorsWithNonIntegerVersions(t *testing.T) {
|
|
testAidlError(t, `versions: "first" is not an integer`, `
|
|
aidl_interface {
|
|
name: "foo",
|
|
srcs: [
|
|
"IFoo.aidl",
|
|
],
|
|
versions: [
|
|
"first",
|
|
],
|
|
}
|
|
`)
|
|
}
|
|
|
|
const (
|
|
androidVariant = "android_common"
|
|
nativeVariant = "android_arm_armv7-a-neon_shared"
|
|
nativeRustVariant = "android_arm_armv7-a-neon_dylib"
|
|
)
|
|
|
|
func TestNativeOutputIsAlwaysVersioned(t *testing.T) {
|
|
var ctx *android.TestContext
|
|
assertOutput := func(moduleName, variant, outputFilename string) {
|
|
t.Helper()
|
|
producer, ok := ctx.ModuleForTests(moduleName, variant).Module().(android.OutputFileProducer)
|
|
if !ok {
|
|
t.Errorf("%s(%s): should be OutputFileProducer.", moduleName, variant)
|
|
}
|
|
paths, err := producer.OutputFiles("")
|
|
if err != nil {
|
|
t.Errorf("%s(%s): failed to get OutputFiles: %v", moduleName, variant, err)
|
|
}
|
|
if len(paths) != 1 || paths[0].Base() != outputFilename {
|
|
t.Errorf("%s(%s): expected output %q, but got %v", moduleName, variant, outputFilename, paths)
|
|
}
|
|
}
|
|
|
|
// No versions
|
|
ctx, _ = testAidl(t, `
|
|
aidl_interface {
|
|
name: "foo",
|
|
srcs: [
|
|
"IFoo.aidl",
|
|
],
|
|
backend: {
|
|
rust: {
|
|
enabled: true,
|
|
},
|
|
},
|
|
}
|
|
`)
|
|
// Even though there is no version, generated modules have version(V1) unless it isn't an unstable interface.
|
|
assertOutput("foo-V1-java", androidVariant, "foo-V1-java.jar")
|
|
|
|
assertOutput("foo-V1-cpp", nativeVariant, "foo-V1-cpp.so")
|
|
assertOutput("foo-V1-rust", nativeRustVariant, "libfoo_V1.dylib.so")
|
|
|
|
// With versions: "1", "2"
|
|
ctx, _ = testAidl(t, `
|
|
aidl_interface {
|
|
name: "foo",
|
|
srcs: [
|
|
"IFoo.aidl",
|
|
],
|
|
versions: [
|
|
"1", "2",
|
|
],
|
|
backend: {
|
|
rust: {
|
|
enabled: true,
|
|
},
|
|
},
|
|
}
|
|
`, withFiles(map[string][]byte{
|
|
"aidl_api/foo/1/foo.1.aidl": nil,
|
|
"aidl_api/foo/2/foo.2.aidl": nil,
|
|
}))
|
|
|
|
// alias for the latest frozen version (=2)
|
|
assertOutput("foo-V2-java", androidVariant, "foo-V2-java.jar")
|
|
assertOutput("foo-V2-cpp", nativeVariant, "foo-V2-cpp.so")
|
|
assertOutput("foo-V2-rust", nativeRustVariant, "libfoo_V2.dylib.so")
|
|
|
|
// frozen "1"
|
|
assertOutput("foo-V1-java", androidVariant, "foo-V1-java.jar")
|
|
assertOutput("foo-V1-cpp", nativeVariant, "foo-V1-cpp.so")
|
|
assertOutput("foo-V1-rust", nativeRustVariant, "libfoo_V1.dylib.so")
|
|
|
|
// tot
|
|
assertOutput("foo-V3-java", androidVariant, "foo-V3-java.jar")
|
|
assertOutput("foo-V3-cpp", nativeVariant, "foo-V3-cpp.so")
|
|
assertOutput("foo-V3-rust", nativeRustVariant, "libfoo_V3.dylib.so")
|
|
|
|
// skip ndk/ndk_platform since they follow the same rule with cpp
|
|
}
|
|
|
|
func TestImports(t *testing.T) {
|
|
testAidlError(t, `Import does not exist:`, `
|
|
aidl_interface {
|
|
name: "foo",
|
|
srcs: [
|
|
"IFoo.aidl",
|
|
],
|
|
imports: [
|
|
"bar",
|
|
]
|
|
}
|
|
`)
|
|
|
|
testAidlError(t, `backend.java.enabled: Java backend not enabled in the imported AIDL interface "bar"`, `
|
|
aidl_interface {
|
|
name: "foo",
|
|
srcs: [
|
|
"IFoo.aidl",
|
|
],
|
|
imports: [
|
|
"bar",
|
|
]
|
|
}
|
|
aidl_interface {
|
|
name: "bar",
|
|
srcs: [
|
|
"IBar.aidl",
|
|
],
|
|
backend: {
|
|
java: {
|
|
enabled: false,
|
|
},
|
|
},
|
|
}
|
|
`)
|
|
|
|
testAidlError(t, `backend.cpp.enabled: C\+\+ backend not enabled in the imported AIDL interface "bar"`, `
|
|
aidl_interface {
|
|
name: "foo",
|
|
srcs: [
|
|
"IFoo.aidl",
|
|
],
|
|
imports: [
|
|
"bar",
|
|
]
|
|
}
|
|
aidl_interface {
|
|
name: "bar",
|
|
srcs: [
|
|
"IBar.aidl",
|
|
],
|
|
backend: {
|
|
cpp: {
|
|
enabled: false,
|
|
},
|
|
},
|
|
}
|
|
`)
|
|
|
|
ctx, _ := testAidl(t, `
|
|
aidl_interface {
|
|
name: "foo",
|
|
srcs: [
|
|
"IFoo.aidl",
|
|
],
|
|
backend: {
|
|
rust: {
|
|
enabled: true,
|
|
},
|
|
},
|
|
imports: [
|
|
"bar.1",
|
|
]
|
|
}
|
|
aidl_interface {
|
|
name: "bar.1",
|
|
srcs: [
|
|
"IBar.aidl",
|
|
],
|
|
backend: {
|
|
rust: {
|
|
enabled: true,
|
|
},
|
|
},
|
|
}
|
|
`)
|
|
|
|
ldRule := ctx.ModuleForTests("foo-V1-cpp", nativeVariant).Rule("ld")
|
|
libFlags := ldRule.Args["libFlags"]
|
|
libBar := filepath.Join("bar.1-V1-cpp", nativeVariant, "bar.1-V1-cpp.so")
|
|
if !strings.Contains(libFlags, libBar) {
|
|
t.Errorf("%q is not found in %q", libBar, libFlags)
|
|
}
|
|
|
|
rustcRule := ctx.ModuleForTests("foo-V1-rust", nativeRustVariant).Rule("rustc")
|
|
libFlags = rustcRule.Args["libFlags"]
|
|
libBar = filepath.Join("out", "soong", ".intermediates", "bar.1-V1-rust", nativeRustVariant, "libbar_1_V1.dylib.so")
|
|
libBarFlag := "--extern bar_1=" + libBar
|
|
if !strings.Contains(libFlags, libBarFlag) {
|
|
t.Errorf("%q is not found in %q", libBarFlag, libFlags)
|
|
}
|
|
}
|
|
|
|
func TestDuplicatedVersions(t *testing.T) {
|
|
// foo depends on myiface-V2-ndk via direct dep and also on
|
|
// myiface-V1-ndk via indirect dep. This should be prohibited.
|
|
testAidlError(t, `depends on multiple versions of the same aidl_interface: myiface-V1-ndk, myiface-V2-ndk`, `
|
|
aidl_interface {
|
|
name: "myiface",
|
|
srcs: ["IFoo.aidl"],
|
|
versions: ["1", "2"],
|
|
}
|
|
|
|
cc_library {
|
|
name: "foo",
|
|
shared_libs: ["myiface-V2-ndk", "bar"],
|
|
}
|
|
|
|
cc_library {
|
|
name: "bar",
|
|
shared_libs: ["myiface-V1-ndk"],
|
|
}
|
|
|
|
`, withFiles(map[string][]byte{
|
|
"aidl_api/myiface/1/myiface.1.aidl": nil,
|
|
"aidl_api/myiface/1/.hash": nil,
|
|
"aidl_api/myiface/2/myiface.2.aidl": nil,
|
|
"aidl_api/myiface/2/.hash": nil,
|
|
}))
|
|
testAidlError(t, `depends on multiple versions of the same aidl_interface: myiface-V1-ndk, myiface-V2-ndk`, `
|
|
aidl_interface {
|
|
name: "myiface",
|
|
srcs: ["IFoo.aidl"],
|
|
versions: ["1"],
|
|
}
|
|
|
|
aidl_interface {
|
|
name: "myiface2",
|
|
srcs: ["IBar.aidl"],
|
|
imports: ["myiface"]
|
|
}
|
|
|
|
cc_library {
|
|
name: "foobar",
|
|
shared_libs: ["myiface-V1-ndk", "myiface2-V1-ndk"],
|
|
}
|
|
|
|
`, withFiles(map[string][]byte{
|
|
"aidl_api/myiface/1/myiface.1.aidl": nil,
|
|
"aidl_api/myiface/1/.hash": nil,
|
|
}))
|
|
testAidlError(t, `depends on multiple versions of the same aidl_interface: myiface-V1-ndk-source, myiface-V2-ndk`, `
|
|
aidl_interface {
|
|
name: "myiface",
|
|
srcs: ["IFoo.aidl"],
|
|
versions: ["1"],
|
|
backend: {
|
|
ndk: {
|
|
srcs_available: true,
|
|
},
|
|
},
|
|
}
|
|
|
|
aidl_interface {
|
|
name: "myiface2",
|
|
srcs: ["IBar.aidl"],
|
|
imports: ["myiface"]
|
|
}
|
|
|
|
cc_library {
|
|
name: "foobar",
|
|
srcs: [":myiface-V1-ndk-source"],
|
|
shared_libs: ["myiface2-V1-ndk"],
|
|
}
|
|
|
|
`, withFiles(map[string][]byte{
|
|
"aidl_api/myiface/1/myiface.1.aidl": nil,
|
|
"aidl_api/myiface/1/.hash": nil,
|
|
}))
|
|
testAidl(t, `
|
|
aidl_interface {
|
|
name: "myiface",
|
|
srcs: ["IFoo.aidl"],
|
|
versions: ["1"],
|
|
backend: {
|
|
ndk: {
|
|
srcs_available: true,
|
|
},
|
|
},
|
|
}
|
|
|
|
aidl_interface {
|
|
name: "myiface2",
|
|
srcs: ["IBar.aidl"],
|
|
imports: ["myiface"]
|
|
}
|
|
|
|
cc_library {
|
|
name: "foobar",
|
|
srcs: [":myiface-V2-ndk-source"],
|
|
shared_libs: ["myiface2-V1-ndk"],
|
|
}
|
|
|
|
`, withFiles(map[string][]byte{
|
|
"aidl_api/myiface/1/myiface.1.aidl": nil,
|
|
"aidl_api/myiface/1/.hash": nil,
|
|
}))
|
|
testAidl(t, `
|
|
aidl_interface {
|
|
name: "myiface",
|
|
srcs: ["IFoo.aidl"],
|
|
versions: ["1"],
|
|
}
|
|
|
|
aidl_interface {
|
|
name: "myiface2",
|
|
srcs: ["IBar.aidl"],
|
|
imports: ["myiface"]
|
|
}
|
|
|
|
cc_library {
|
|
name: "foobar",
|
|
shared_libs: ["myiface-V2-ndk", "myiface2-V1-ndk"],
|
|
}
|
|
|
|
`, withFiles(map[string][]byte{
|
|
"aidl_api/myiface/1/myiface.1.aidl": nil,
|
|
"aidl_api/myiface/1/.hash": nil,
|
|
}))
|
|
}
|
|
|
|
func TestUnstableVndkModule(t *testing.T) {
|
|
testAidlError(t, `module "myiface_interface": stability: must be "vintf" if the module is for VNDK.`, `
|
|
aidl_interface {
|
|
name: "myiface",
|
|
srcs: ["IFoo.aidl"],
|
|
vendor_available: true,
|
|
product_available: true,
|
|
unstable: true,
|
|
vndk: {
|
|
enabled: true,
|
|
},
|
|
}
|
|
`)
|
|
testAidlError(t, `module "myiface_interface": stability: must be "vintf" if the module is for VNDK.`, `
|
|
aidl_interface {
|
|
name: "myiface",
|
|
vendor_available: true,
|
|
product_available: true,
|
|
srcs: ["IFoo.aidl"],
|
|
vndk: {
|
|
enabled: true,
|
|
},
|
|
}
|
|
`)
|
|
testAidl(t, `
|
|
aidl_interface {
|
|
name: "myiface",
|
|
vendor_available: true,
|
|
product_available: true,
|
|
srcs: ["IFoo.aidl"],
|
|
stability: "vintf",
|
|
vndk: {
|
|
enabled: true,
|
|
},
|
|
}
|
|
`)
|
|
}
|
|
|
|
func TestCcModuleWithApexNameMacro(t *testing.T) {
|
|
ctx, _ := testAidl(t, `
|
|
aidl_interface {
|
|
name: "myiface",
|
|
srcs: ["IFoo.aidl"],
|
|
backend: {
|
|
ndk: {
|
|
apex_available: ["myapex"],
|
|
},
|
|
},
|
|
}
|
|
apex {
|
|
name: "myapex",
|
|
key: "myapex.key",
|
|
native_shared_libs: ["myiface-V1-ndk_platform"],
|
|
updatable: false,
|
|
}
|
|
apex_key {
|
|
name: "myapex.key",
|
|
public_key: "testkey.avbpubkey",
|
|
private_key: "testkey.pem",
|
|
}
|
|
`, withFiles(map[string][]byte{
|
|
"system/sepolicy/apex/myapex-file_contexts": nil,
|
|
}))
|
|
|
|
ccRule := ctx.ModuleForTests("myiface-V1-ndk_platform", "android_arm64_armv8-a_static_myapex").Rule("cc")
|
|
assertContains(t, ccRule.Args["cFlags"], "-D__ANDROID_APEX__")
|
|
assertContains(t, ccRule.Args["cFlags"], "-D__ANDROID_APEX_NAME__='\"myapex\"'")
|
|
assertContains(t, ccRule.Args["cFlags"], "-D__ANDROID_APEX_MYAPEX__")
|
|
}
|
|
|
|
func TestSrcsAvailable(t *testing.T) {
|
|
bp := `
|
|
aidl_interface {
|
|
name: "myiface",
|
|
srcs: ["IFoo.aidl"],
|
|
backend: {
|
|
java: {
|
|
srcs_available: %s,
|
|
},
|
|
cpp: {
|
|
srcs_available: %s,
|
|
},
|
|
},
|
|
}
|
|
`
|
|
customizer := withFiles(map[string][]byte{
|
|
"otherpackage/Android.bp": []byte(`
|
|
java_library {
|
|
name: "javalib",
|
|
srcs: [":myiface-V1-java-source"],
|
|
}
|
|
cc_library_shared {
|
|
name: "cclib",
|
|
srcs: [":myiface-V1-cpp-source"],
|
|
}
|
|
`),
|
|
})
|
|
ctx, _ := testAidl(t, fmt.Sprintf(bp, "true", "true"), customizer)
|
|
javaInputs := ctx.ModuleForTests("javalib", "android_common").Rule("javac").Inputs.Strings()
|
|
assertListContains(t, javaInputs, "myiface-V1-java-source/gen/IFoo.java")
|
|
ccInput := ctx.ModuleForTests("cclib", "android_arm64_armv8-a_shared").Rule("cc").Input.String()
|
|
assertContains(t, ccInput, "myiface-V1-cpp-source/gen/IFoo.cpp")
|
|
|
|
testAidlError(t, `depends on //.:myiface-V1-java-source which is not visible to this module`,
|
|
fmt.Sprintf(bp, "false", "true"), customizer)
|
|
testAidlError(t, `depends on //.:myiface-V1-cpp-source which is not visible to this module`,
|
|
fmt.Sprintf(bp, "true", "false"), customizer)
|
|
}
|
|
|
|
func TestRustDuplicateNames(t *testing.T) {
|
|
testAidl(t, `
|
|
aidl_interface {
|
|
name: "myiface",
|
|
srcs: ["dir/a/Foo.aidl", "dir/b/Foo.aidl"],
|
|
backend: {
|
|
rust: {
|
|
enabled: true,
|
|
},
|
|
},
|
|
}
|
|
`)
|
|
}
|
|
|
|
func TestAidlImportFlagsForIncludeDirs(t *testing.T) {
|
|
customizer := withFiles(map[string][]byte{
|
|
"foo/Android.bp": []byte(`
|
|
aidl_interface {
|
|
name: "foo-iface",
|
|
local_include_dir: "src",
|
|
include_dirs: [
|
|
"path1",
|
|
"path2/sub",
|
|
],
|
|
srcs: [
|
|
"src/foo/Foo.aidl",
|
|
],
|
|
imports: [
|
|
"bar-iface",
|
|
],
|
|
versions: ["1", "2"],
|
|
}
|
|
aidl_interface {
|
|
name: "bar-iface",
|
|
local_include_dir: "src",
|
|
srcs: [
|
|
"src/bar/Bar.aidl",
|
|
],
|
|
}
|
|
`),
|
|
"foo/src/foo/Foo.aidl": nil,
|
|
"foo/src/bar/Bar.aidl": nil,
|
|
"foo/aidl_api/foo-iface/current/foo/Foo.aidl": nil,
|
|
"foo/aidl_api/foo-iface/1/foo/Foo.aidl": nil,
|
|
"foo/aidl_api/foo-iface/1/.hash": nil,
|
|
"foo/aidl_api/foo-iface/2/foo/Foo.aidl": nil,
|
|
"foo/aidl_api/foo-iface/2/.hash": nil,
|
|
})
|
|
ctx, _ := testAidl(t, ``, customizer)
|
|
|
|
// compile for older version
|
|
{
|
|
rule := ctx.ModuleForTests("foo-iface-V1-cpp-source", "").Output("foo/Foo.cpp")
|
|
imports := strings.Split(rule.Args["imports"], " ")
|
|
android.AssertArrayString(t, "should import foo/1(target) and bar/current(imported)", []string{
|
|
"-Ifoo/aidl_api/foo-iface/1",
|
|
"-Ipath1",
|
|
"-Ipath2/sub",
|
|
"-Ifoo/aidl_api/bar-iface/current",
|
|
}, imports)
|
|
}
|
|
// compile for tot version
|
|
{
|
|
rule := ctx.ModuleForTests("foo-iface-V3-cpp-source", "").Output("foo/Foo.cpp")
|
|
imports := strings.Split(rule.Args["imports"], " ")
|
|
android.AssertArrayString(t, "aidlCompile should import ToT", []string{
|
|
"-Ifoo/src",
|
|
"-Ipath1",
|
|
"-Ipath2/sub",
|
|
"-Ifoo/src",
|
|
}, imports)
|
|
}
|
|
}
|
|
|
|
func TestSupportsGenruleAndFilegroup(t *testing.T) {
|
|
customizer := withFiles(map[string][]byte{
|
|
"foo/Android.bp": []byte(`
|
|
aidl_interface {
|
|
name: "foo-iface",
|
|
local_include_dir: "src",
|
|
include_dirs: [
|
|
"path1",
|
|
"path2/sub",
|
|
],
|
|
srcs: [
|
|
"src/foo/Foo.aidl",
|
|
":filegroup1",
|
|
":gen1",
|
|
],
|
|
imports: [
|
|
"bar-iface",
|
|
],
|
|
versions: ["1"],
|
|
}
|
|
filegroup {
|
|
name: "filegroup1",
|
|
path: "filegroup/sub",
|
|
srcs: [
|
|
"filegroup/sub/pkg/Bar.aidl",
|
|
],
|
|
}
|
|
genrule {
|
|
name: "gen1",
|
|
cmd: "generate baz/Baz.aidl",
|
|
out: [
|
|
"baz/Baz.aidl",
|
|
]
|
|
}
|
|
aidl_interface {
|
|
name: "bar-iface",
|
|
local_include_dir: "src",
|
|
srcs: [
|
|
"src/bar/Bar.aidl",
|
|
],
|
|
}
|
|
`),
|
|
"foo/aidl_api/foo-iface/1/foo/Foo.aidl": nil,
|
|
"foo/aidl_api/foo-iface/1/.hash": nil,
|
|
"foo/filegroup/sub/pkg/Bar.aidl": nil,
|
|
"foo/src/foo/Foo.aidl": nil,
|
|
})
|
|
ctx, _ := testAidl(t, ``, customizer)
|
|
|
|
// aidlCompile for snapshots (v1)
|
|
{
|
|
rule := ctx.ModuleForTests("foo-iface-V1-cpp-source", "").Output("foo/Foo.cpp")
|
|
imports := strings.Split(rule.Args["imports"], " ")
|
|
android.AssertArrayString(t, "aidlCompile should import filegroup/genrule as well", []string{
|
|
"-Ifoo/aidl_api/foo-iface/1",
|
|
"-Ipath1",
|
|
"-Ipath2/sub",
|
|
"-Ifoo/aidl_api/bar-iface/current",
|
|
}, imports)
|
|
}
|
|
// aidlCompile for ToT (v2)
|
|
{
|
|
rule := ctx.ModuleForTests("foo-iface-V2-cpp-source", "").Output("foo/Foo.cpp")
|
|
imports := strings.Split(rule.Args["imports"], " ")
|
|
android.AssertArrayString(t, "aidlCompile should import filegroup/genrule as well", []string{
|
|
"-Ifoo/src",
|
|
"-Ifoo/filegroup/sub",
|
|
"-Iout/soong/.intermediates/foo/gen1/gen",
|
|
"-Ipath1",
|
|
"-Ipath2/sub",
|
|
"-Ifoo/src",
|
|
}, imports)
|
|
}
|
|
|
|
// dumpapi
|
|
{
|
|
rule := ctx.ModuleForTests("foo-iface-api", "").Rule("aidlDumpApiRule")
|
|
android.AssertPathsRelativeToTopEquals(t, "dumpapi should dump srcs/filegroups/genrules", []string{
|
|
"foo/src/foo/Foo.aidl",
|
|
"foo/filegroup/sub/pkg/Bar.aidl",
|
|
"out/soong/.intermediates/foo/gen1/gen/baz/Baz.aidl",
|
|
}, rule.Inputs)
|
|
|
|
dumpDir := "out/soong/.intermediates/foo/foo-iface-api/dump"
|
|
android.AssertPathsRelativeToTopEquals(t, "dumpapi should dump with rel paths", []string{
|
|
dumpDir + "/foo/Foo.aidl",
|
|
dumpDir + "/pkg/Bar.aidl",
|
|
dumpDir + "/baz/Baz.aidl",
|
|
dumpDir + "/.hash",
|
|
}, rule.Outputs.Paths())
|
|
|
|
imports := strings.Split(rule.Args["imports"], " ")
|
|
android.AssertArrayString(t, "dumpapi should import filegroup/genrule as well", []string{
|
|
// these are from foo-iface.srcs
|
|
"-Ifoo/src",
|
|
"-Ifoo/filegroup/sub",
|
|
"-Iout/soong/.intermediates/foo/gen1/gen",
|
|
|
|
// this is from bar-iface.srcs
|
|
"-Ifoo/src",
|
|
|
|
// this is from foo-iface.Local_include_dir
|
|
"-Ifoo/src",
|
|
|
|
// these are from foo-iface.include_dirs
|
|
"-Ipath1",
|
|
"-Ipath2/sub",
|
|
}, imports)
|
|
}
|
|
}
|
|
|
|
func TestAidlFlags(t *testing.T) {
|
|
ctx, _ := testAidl(t, `
|
|
aidl_interface {
|
|
name: "myiface",
|
|
srcs: ["a/Foo.aidl", "b/Bar.aidl"],
|
|
flags: ["-Weverything", "-Werror"],
|
|
backend: { rust: { enabled: true }}
|
|
}
|
|
`)
|
|
for module, outputs := range map[string][]string{
|
|
"myiface-V1-cpp-source": {"a/Foo.h", "b/Bar.h"},
|
|
"myiface-V1-java-source": {"a/Foo.java", "b/Bar.java"},
|
|
"myiface-V1-ndk-source": {"aidl/a/Foo.h", "aidl/b/Bar.h"},
|
|
"myiface-V1-rust-source": {"a/Foo.rs", "b/Bar.rs"},
|
|
} {
|
|
for _, output := range outputs {
|
|
t.Run(module+"/"+output, func(t *testing.T) {
|
|
params := ctx.ModuleForTests(module, "").Output(output)
|
|
assertContains(t, params.Args["optionalFlags"], "-Weverything")
|
|
assertContains(t, params.Args["optionalFlags"], "-Werror")
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestAidlModuleNameContainsVersion(t *testing.T) {
|
|
testAidlError(t, "aidl_interface should not have '-V<number> suffix", `
|
|
aidl_interface {
|
|
name: "myiface-V2",
|
|
srcs: ["a/Foo.aidl", "b/Bar.aidl"],
|
|
}
|
|
`)
|
|
// Ugly, but okay
|
|
testAidl(t, `
|
|
aidl_interface {
|
|
name: "myiface-V2aa",
|
|
srcs: ["a/Foo.aidl", "b/Bar.aidl"],
|
|
}
|
|
`)
|
|
}
|
|
|
|
func TestExplicitAidlModuleImport(t *testing.T) {
|
|
for _, importVersion := range []string{"V1", "V2"} {
|
|
|
|
ctx, _ := testAidl(t, `
|
|
aidl_interface {
|
|
name: "foo",
|
|
srcs: ["Foo.aidl"],
|
|
versions: [
|
|
"1",
|
|
],
|
|
imports: ["bar-`+importVersion+`"]
|
|
}
|
|
|
|
aidl_interface {
|
|
name: "bar",
|
|
srcs: ["Bar.aidl"],
|
|
versions: [
|
|
"1",
|
|
],
|
|
}
|
|
`, withFiles(map[string][]byte{
|
|
"aidl_api/foo/1/Foo.aidl": nil,
|
|
"aidl_api/foo/1/.hash": nil,
|
|
"aidl_api/bar/1/Bar.aidl": nil,
|
|
"aidl_api/bar/1/.hash": nil,
|
|
}))
|
|
for _, foo := range []string{"foo-V1-cpp", "foo-V2-cpp"} {
|
|
ldRule := ctx.ModuleForTests(foo, nativeVariant).Rule("ld")
|
|
libFlags := ldRule.Args["libFlags"]
|
|
libBar := filepath.Join("bar-"+importVersion+"-cpp", nativeVariant, "bar-"+importVersion+"-cpp.so")
|
|
if !strings.Contains(libFlags, libBar) {
|
|
t.Errorf("%q is not found in %q", libBar, libFlags)
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
testAidlError(t, "module \"foo_interface\": imports: \"foo\" depends on \"bar\" version \"3\"", `
|
|
aidl_interface {
|
|
name: "foo",
|
|
srcs: ["Foo.aidl"],
|
|
versions: [
|
|
"1",
|
|
],
|
|
imports: ["bar-V3"]
|
|
}
|
|
|
|
aidl_interface {
|
|
name: "bar",
|
|
srcs: ["Bar.aidl"],
|
|
versions: [
|
|
"1",
|
|
],
|
|
}
|
|
`, withFiles(map[string][]byte{
|
|
"aidl_api/foo/1/Foo.aidl": nil,
|
|
"aidl_api/foo/1/.hash": nil,
|
|
"aidl_api/bar/1/Bar.aidl": nil,
|
|
"aidl_api/bar/1/.hash": nil,
|
|
}))
|
|
}
|