fc0f6e34ce
Previously manifest_fixer used a naive way to distiniguish optional libs from required ones: it checked if a library is on the list of optional compatibility libraries. This works for compatibility libs, but not for other libs. Now we properly track optionality through all stages of the build, starting with the addition of the library as a dependency (here's where the `uses_libs`/`optional_uses_libs` distinction kicks in), store it in dependency tag and propagate to class loader context, and from there to the manifest_fixer. The tests have been updated accordingly. Bug: 196377222 Test: lunch bertha_x86_64-userdebug && m droid dist cts mts Change-Id: I3631ce59ebe47116ce7a9b3d33a86f636846ef0f
302 lines
12 KiB
Go
302 lines
12 KiB
Go
// 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 dexpreopt
|
|
|
|
// This file contains unit tests for class loader context structure.
|
|
// For class loader context tests involving .bp files, see TestUsesLibraries in java package.
|
|
|
|
import (
|
|
"fmt"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
|
|
"android/soong/android"
|
|
)
|
|
|
|
func TestCLC(t *testing.T) {
|
|
// Construct class loader context with the following structure:
|
|
// .
|
|
// ├── 29
|
|
// │ ├── android.hidl.manager
|
|
// │ └── android.hidl.base
|
|
// │
|
|
// └── any
|
|
// ├── a
|
|
// ├── b
|
|
// ├── c
|
|
// ├── d
|
|
// │ ├── a2
|
|
// │ ├── b2
|
|
// │ └── c2
|
|
// │ ├── a1
|
|
// │ └── b1
|
|
// ├── f
|
|
// ├── a3
|
|
// └── b3
|
|
//
|
|
ctx := testContext()
|
|
|
|
optional := false
|
|
|
|
m := make(ClassLoaderContextMap)
|
|
|
|
m.AddContext(ctx, AnySdkVersion, "a", optional, buildPath(ctx, "a"), installPath(ctx, "a"), nil)
|
|
m.AddContext(ctx, AnySdkVersion, "b", optional, buildPath(ctx, "b"), installPath(ctx, "b"), nil)
|
|
m.AddContext(ctx, AnySdkVersion, "c", optional, buildPath(ctx, "c"), installPath(ctx, "c"), nil)
|
|
|
|
// Add some libraries with nested subcontexts.
|
|
|
|
m1 := make(ClassLoaderContextMap)
|
|
m1.AddContext(ctx, AnySdkVersion, "a1", optional, buildPath(ctx, "a1"), installPath(ctx, "a1"), nil)
|
|
m1.AddContext(ctx, AnySdkVersion, "b1", optional, buildPath(ctx, "b1"), installPath(ctx, "b1"), nil)
|
|
|
|
m2 := make(ClassLoaderContextMap)
|
|
m2.AddContext(ctx, AnySdkVersion, "a2", optional, buildPath(ctx, "a2"), installPath(ctx, "a2"), nil)
|
|
m2.AddContext(ctx, AnySdkVersion, "b2", optional, buildPath(ctx, "b2"), installPath(ctx, "b2"), nil)
|
|
m2.AddContext(ctx, AnySdkVersion, "c2", optional, buildPath(ctx, "c2"), installPath(ctx, "c2"), m1)
|
|
|
|
m3 := make(ClassLoaderContextMap)
|
|
m3.AddContext(ctx, AnySdkVersion, "a3", optional, buildPath(ctx, "a3"), installPath(ctx, "a3"), nil)
|
|
m3.AddContext(ctx, AnySdkVersion, "b3", optional, buildPath(ctx, "b3"), installPath(ctx, "b3"), nil)
|
|
|
|
m.AddContext(ctx, AnySdkVersion, "d", optional, buildPath(ctx, "d"), installPath(ctx, "d"), m2)
|
|
// When the same library is both in conditional and unconditional context, it should be removed
|
|
// from conditional context.
|
|
m.AddContext(ctx, 42, "f", optional, buildPath(ctx, "f"), installPath(ctx, "f"), nil)
|
|
m.AddContext(ctx, AnySdkVersion, "f", optional, buildPath(ctx, "f"), installPath(ctx, "f"), nil)
|
|
|
|
// Merge map with implicit root library that is among toplevel contexts => does nothing.
|
|
m.AddContextMap(m1, "c")
|
|
// Merge map with implicit root library that is not among toplevel contexts => all subcontexts
|
|
// of the other map are added as toplevel contexts.
|
|
m.AddContextMap(m3, "m_g")
|
|
|
|
// Compatibility libraries with unknown install paths get default paths.
|
|
m.AddContext(ctx, 29, AndroidHidlManager, optional, buildPath(ctx, AndroidHidlManager), nil, nil)
|
|
m.AddContext(ctx, 29, AndroidHidlBase, optional, buildPath(ctx, AndroidHidlBase), nil, nil)
|
|
|
|
// Add "android.test.mock" to conditional CLC, observe that is gets removed because it is only
|
|
// needed as a compatibility library if "android.test.runner" is in CLC as well.
|
|
m.AddContext(ctx, 30, AndroidTestMock, optional, buildPath(ctx, AndroidTestMock), nil, nil)
|
|
|
|
valid, validationError := validateClassLoaderContext(m)
|
|
|
|
fixClassLoaderContext(m)
|
|
|
|
var haveStr string
|
|
var havePaths android.Paths
|
|
var haveUsesLibsReq, haveUsesLibsOpt []string
|
|
if valid && validationError == nil {
|
|
haveStr, havePaths = ComputeClassLoaderContext(m)
|
|
haveUsesLibsReq, haveUsesLibsOpt = m.UsesLibs()
|
|
}
|
|
|
|
// Test that validation is successful (all paths are known).
|
|
t.Run("validate", func(t *testing.T) {
|
|
if !(valid && validationError == nil) {
|
|
t.Errorf("invalid class loader context")
|
|
}
|
|
})
|
|
|
|
// Test that class loader context structure is correct.
|
|
t.Run("string", func(t *testing.T) {
|
|
wantStr := " --host-context-for-sdk 29 " +
|
|
"PCL[out/" + AndroidHidlManager + ".jar]#" +
|
|
"PCL[out/" + AndroidHidlBase + ".jar]" +
|
|
" --target-context-for-sdk 29 " +
|
|
"PCL[/system/framework/" + AndroidHidlManager + ".jar]#" +
|
|
"PCL[/system/framework/" + AndroidHidlBase + ".jar]" +
|
|
" --host-context-for-sdk any " +
|
|
"PCL[out/a.jar]#PCL[out/b.jar]#PCL[out/c.jar]#PCL[out/d.jar]" +
|
|
"{PCL[out/a2.jar]#PCL[out/b2.jar]#PCL[out/c2.jar]" +
|
|
"{PCL[out/a1.jar]#PCL[out/b1.jar]}}#" +
|
|
"PCL[out/f.jar]#PCL[out/a3.jar]#PCL[out/b3.jar]" +
|
|
" --target-context-for-sdk any " +
|
|
"PCL[/system/a.jar]#PCL[/system/b.jar]#PCL[/system/c.jar]#PCL[/system/d.jar]" +
|
|
"{PCL[/system/a2.jar]#PCL[/system/b2.jar]#PCL[/system/c2.jar]" +
|
|
"{PCL[/system/a1.jar]#PCL[/system/b1.jar]}}#" +
|
|
"PCL[/system/f.jar]#PCL[/system/a3.jar]#PCL[/system/b3.jar]"
|
|
if wantStr != haveStr {
|
|
t.Errorf("\nwant class loader context: %s\nhave class loader context: %s", wantStr, haveStr)
|
|
}
|
|
})
|
|
|
|
// Test that all expected build paths are gathered.
|
|
t.Run("paths", func(t *testing.T) {
|
|
wantPaths := []string{
|
|
"out/android.hidl.manager-V1.0-java.jar", "out/android.hidl.base-V1.0-java.jar",
|
|
"out/a.jar", "out/b.jar", "out/c.jar", "out/d.jar",
|
|
"out/a2.jar", "out/b2.jar", "out/c2.jar",
|
|
"out/a1.jar", "out/b1.jar",
|
|
"out/f.jar", "out/a3.jar", "out/b3.jar",
|
|
}
|
|
if !reflect.DeepEqual(wantPaths, havePaths.Strings()) {
|
|
t.Errorf("\nwant paths: %s\nhave paths: %s", wantPaths, havePaths)
|
|
}
|
|
})
|
|
|
|
// Test for libraries that are added by the manifest_fixer.
|
|
t.Run("uses libs", func(t *testing.T) {
|
|
wantUsesLibsReq := []string{"a", "b", "c", "d", "f", "a3", "b3"}
|
|
wantUsesLibsOpt := []string{}
|
|
if !reflect.DeepEqual(wantUsesLibsReq, haveUsesLibsReq) {
|
|
t.Errorf("\nwant required uses libs: %s\nhave required uses libs: %s", wantUsesLibsReq, haveUsesLibsReq)
|
|
}
|
|
if !reflect.DeepEqual(wantUsesLibsOpt, haveUsesLibsOpt) {
|
|
t.Errorf("\nwant optional uses libs: %s\nhave optional uses libs: %s", wantUsesLibsOpt, haveUsesLibsOpt)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestCLCJson(t *testing.T) {
|
|
ctx := testContext()
|
|
optional := false
|
|
m := make(ClassLoaderContextMap)
|
|
m.AddContext(ctx, 28, "a", optional, buildPath(ctx, "a"), installPath(ctx, "a"), nil)
|
|
m.AddContext(ctx, 29, "b", optional, buildPath(ctx, "b"), installPath(ctx, "b"), nil)
|
|
m.AddContext(ctx, 30, "c", optional, buildPath(ctx, "c"), installPath(ctx, "c"), nil)
|
|
m.AddContext(ctx, AnySdkVersion, "d", optional, buildPath(ctx, "d"), installPath(ctx, "d"), nil)
|
|
jsonCLC := toJsonClassLoaderContext(m)
|
|
restored := fromJsonClassLoaderContext(ctx, jsonCLC)
|
|
android.AssertIntEquals(t, "The size of the maps should be the same.", len(m), len(restored))
|
|
for k := range m {
|
|
a, _ := m[k]
|
|
b, ok := restored[k]
|
|
android.AssertBoolEquals(t, "The both maps should have the same keys.", ok, true)
|
|
android.AssertIntEquals(t, "The size of the elements should be the same.", len(a), len(b))
|
|
for i, elemA := range a {
|
|
before := fmt.Sprintf("%v", *elemA)
|
|
after := fmt.Sprintf("%v", *b[i])
|
|
android.AssertStringEquals(t, "The content should be the same.", before, after)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Test that unknown library paths cause a validation error.
|
|
func testCLCUnknownPath(t *testing.T, whichPath string) {
|
|
ctx := testContext()
|
|
optional := false
|
|
|
|
m := make(ClassLoaderContextMap)
|
|
if whichPath == "build" {
|
|
m.AddContext(ctx, AnySdkVersion, "a", optional, nil, nil, nil)
|
|
} else {
|
|
m.AddContext(ctx, AnySdkVersion, "a", optional, buildPath(ctx, "a"), nil, nil)
|
|
}
|
|
|
|
// The library should be added to <uses-library> tags by the manifest_fixer.
|
|
t.Run("uses libs", func(t *testing.T) {
|
|
haveUsesLibsReq, haveUsesLibsOpt := m.UsesLibs()
|
|
wantUsesLibsReq := []string{"a"}
|
|
wantUsesLibsOpt := []string{}
|
|
if !reflect.DeepEqual(wantUsesLibsReq, haveUsesLibsReq) {
|
|
t.Errorf("\nwant required uses libs: %s\nhave required uses libs: %s", wantUsesLibsReq, haveUsesLibsReq)
|
|
}
|
|
if !reflect.DeepEqual(wantUsesLibsOpt, haveUsesLibsOpt) {
|
|
t.Errorf("\nwant optional uses libs: %s\nhave optional uses libs: %s", wantUsesLibsOpt, haveUsesLibsOpt)
|
|
}
|
|
})
|
|
|
|
// But CLC cannot be constructed: there is a validation error.
|
|
_, err := validateClassLoaderContext(m)
|
|
checkError(t, err, fmt.Sprintf("invalid %s path for <uses-library> \"a\"", whichPath))
|
|
}
|
|
|
|
// Test that unknown build path is an error.
|
|
func TestCLCUnknownBuildPath(t *testing.T) {
|
|
testCLCUnknownPath(t, "build")
|
|
}
|
|
|
|
// Test that unknown install path is an error.
|
|
func TestCLCUnknownInstallPath(t *testing.T) {
|
|
testCLCUnknownPath(t, "install")
|
|
}
|
|
|
|
// An attempt to add conditional nested subcontext should fail.
|
|
func TestCLCNestedConditional(t *testing.T) {
|
|
ctx := testContext()
|
|
optional := false
|
|
m1 := make(ClassLoaderContextMap)
|
|
m1.AddContext(ctx, 42, "a", optional, buildPath(ctx, "a"), installPath(ctx, "a"), nil)
|
|
m := make(ClassLoaderContextMap)
|
|
err := m.addContext(ctx, AnySdkVersion, "b", optional, buildPath(ctx, "b"), installPath(ctx, "b"), m1)
|
|
checkError(t, err, "nested class loader context shouldn't have conditional part")
|
|
}
|
|
|
|
// Test for SDK version order in conditional CLC: no matter in what order the libraries are added,
|
|
// they end up in the order that agrees with PackageManager.
|
|
func TestCLCSdkVersionOrder(t *testing.T) {
|
|
ctx := testContext()
|
|
optional := false
|
|
m := make(ClassLoaderContextMap)
|
|
m.AddContext(ctx, 28, "a", optional, buildPath(ctx, "a"), installPath(ctx, "a"), nil)
|
|
m.AddContext(ctx, 29, "b", optional, buildPath(ctx, "b"), installPath(ctx, "b"), nil)
|
|
m.AddContext(ctx, 30, "c", optional, buildPath(ctx, "c"), installPath(ctx, "c"), nil)
|
|
m.AddContext(ctx, AnySdkVersion, "d", optional, buildPath(ctx, "d"), installPath(ctx, "d"), nil)
|
|
|
|
valid, validationError := validateClassLoaderContext(m)
|
|
|
|
fixClassLoaderContext(m)
|
|
|
|
var haveStr string
|
|
if valid && validationError == nil {
|
|
haveStr, _ = ComputeClassLoaderContext(m)
|
|
}
|
|
|
|
// Test that validation is successful (all paths are known).
|
|
t.Run("validate", func(t *testing.T) {
|
|
if !(valid && validationError == nil) {
|
|
t.Errorf("invalid class loader context")
|
|
}
|
|
})
|
|
|
|
// Test that class loader context structure is correct.
|
|
t.Run("string", func(t *testing.T) {
|
|
wantStr := " --host-context-for-sdk 30 PCL[out/c.jar]" +
|
|
" --target-context-for-sdk 30 PCL[/system/c.jar]" +
|
|
" --host-context-for-sdk 29 PCL[out/b.jar]" +
|
|
" --target-context-for-sdk 29 PCL[/system/b.jar]" +
|
|
" --host-context-for-sdk 28 PCL[out/a.jar]" +
|
|
" --target-context-for-sdk 28 PCL[/system/a.jar]" +
|
|
" --host-context-for-sdk any PCL[out/d.jar]" +
|
|
" --target-context-for-sdk any PCL[/system/d.jar]"
|
|
if wantStr != haveStr {
|
|
t.Errorf("\nwant class loader context: %s\nhave class loader context: %s", wantStr, haveStr)
|
|
}
|
|
})
|
|
}
|
|
|
|
func checkError(t *testing.T, have error, want string) {
|
|
if have == nil {
|
|
t.Errorf("\nwant error: '%s'\nhave: none", want)
|
|
} else if msg := have.Error(); !strings.HasPrefix(msg, want) {
|
|
t.Errorf("\nwant error: '%s'\nhave error: '%s'\n", want, msg)
|
|
}
|
|
}
|
|
|
|
func testContext() android.ModuleInstallPathContext {
|
|
config := android.TestConfig("out", nil, "", nil)
|
|
return android.ModuleInstallPathContextForTesting(config)
|
|
}
|
|
|
|
func buildPath(ctx android.PathContext, lib string) android.Path {
|
|
return android.PathForOutput(ctx, lib+".jar")
|
|
}
|
|
|
|
func installPath(ctx android.ModuleInstallPathContext, lib string) android.InstallPath {
|
|
return android.PathForModuleInstall(ctx, lib+".jar")
|
|
}
|