0061c0d1da
Don't uncompress priv-app dex for `android_app_import` if DONT_UNCOMPRESS_PRIV_APPS_DEXS is true. Update expected test results. Bug: 194504107 Test: m nothing Change-Id: I4e7aa1a3deea856f388ae5ecd9292301f8a09a2f
730 lines
20 KiB
Go
730 lines
20 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 java
|
|
|
|
import (
|
|
"fmt"
|
|
"reflect"
|
|
"regexp"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/google/blueprint/proptools"
|
|
|
|
"android/soong/android"
|
|
)
|
|
|
|
func TestAndroidAppImport(t *testing.T) {
|
|
ctx, _ := testJava(t, `
|
|
android_app_import {
|
|
name: "foo",
|
|
apk: "prebuilts/apk/app.apk",
|
|
certificate: "platform",
|
|
dex_preopt: {
|
|
enabled: true,
|
|
},
|
|
}
|
|
`)
|
|
|
|
variant := ctx.ModuleForTests("foo", "android_common")
|
|
|
|
// Check dexpreopt outputs.
|
|
if variant.MaybeOutput("dexpreopt/oat/arm64/package.vdex").Rule == nil ||
|
|
variant.MaybeOutput("dexpreopt/oat/arm64/package.odex").Rule == nil {
|
|
t.Errorf("can't find dexpreopt outputs")
|
|
}
|
|
|
|
// Check cert signing flag.
|
|
signedApk := variant.Output("signed/foo.apk")
|
|
signingFlag := signedApk.Args["certificates"]
|
|
expected := "build/make/target/product/security/platform.x509.pem build/make/target/product/security/platform.pk8"
|
|
if expected != signingFlag {
|
|
t.Errorf("Incorrect signing flags, expected: %q, got: %q", expected, signingFlag)
|
|
}
|
|
}
|
|
|
|
func TestAndroidAppImport_NoDexPreopt(t *testing.T) {
|
|
ctx, _ := testJava(t, `
|
|
android_app_import {
|
|
name: "foo",
|
|
apk: "prebuilts/apk/app.apk",
|
|
certificate: "platform",
|
|
dex_preopt: {
|
|
enabled: false,
|
|
},
|
|
}
|
|
`)
|
|
|
|
variant := ctx.ModuleForTests("foo", "android_common")
|
|
|
|
// Check dexpreopt outputs. They shouldn't exist.
|
|
if variant.MaybeOutput("dexpreopt/oat/arm64/package.vdex").Rule != nil ||
|
|
variant.MaybeOutput("dexpreopt/oat/arm64/package.odex").Rule != nil {
|
|
t.Errorf("dexpreopt shouldn't have run.")
|
|
}
|
|
}
|
|
|
|
func TestAndroidAppImport_Presigned(t *testing.T) {
|
|
ctx, _ := testJava(t, `
|
|
android_app_import {
|
|
name: "foo",
|
|
apk: "prebuilts/apk/app.apk",
|
|
presigned: true,
|
|
dex_preopt: {
|
|
enabled: true,
|
|
},
|
|
}
|
|
`)
|
|
|
|
variant := ctx.ModuleForTests("foo", "android_common")
|
|
|
|
// Check dexpreopt outputs.
|
|
if variant.MaybeOutput("dexpreopt/oat/arm64/package.vdex").Rule == nil ||
|
|
variant.MaybeOutput("dexpreopt/oat/arm64/package.odex").Rule == nil {
|
|
t.Errorf("can't find dexpreopt outputs")
|
|
}
|
|
// Make sure signing was skipped and aligning was done.
|
|
if variant.MaybeOutput("signed/foo.apk").Rule != nil {
|
|
t.Errorf("signing rule shouldn't be included.")
|
|
}
|
|
if variant.MaybeOutput("zip-aligned/foo.apk").Rule == nil {
|
|
t.Errorf("can't find aligning rule")
|
|
}
|
|
}
|
|
|
|
func TestAndroidAppImport_SigningLineage(t *testing.T) {
|
|
ctx, _ := testJava(t, `
|
|
android_app_import {
|
|
name: "foo",
|
|
apk: "prebuilts/apk/app.apk",
|
|
certificate: "platform",
|
|
additional_certificates: [":additional_certificate"],
|
|
lineage: "lineage.bin",
|
|
}
|
|
|
|
android_app_certificate {
|
|
name: "additional_certificate",
|
|
certificate: "cert/additional_cert",
|
|
}
|
|
`)
|
|
|
|
variant := ctx.ModuleForTests("foo", "android_common")
|
|
|
|
signedApk := variant.Output("signed/foo.apk")
|
|
// Check certificates
|
|
certificatesFlag := signedApk.Args["certificates"]
|
|
expected := "build/make/target/product/security/platform.x509.pem " +
|
|
"build/make/target/product/security/platform.pk8 " +
|
|
"cert/additional_cert.x509.pem cert/additional_cert.pk8"
|
|
if expected != certificatesFlag {
|
|
t.Errorf("Incorrect certificates flags, expected: %q, got: %q", expected, certificatesFlag)
|
|
}
|
|
// Check cert signing lineage flag.
|
|
signingFlag := signedApk.Args["flags"]
|
|
expected = "--lineage lineage.bin"
|
|
if expected != signingFlag {
|
|
t.Errorf("Incorrect signing flags, expected: %q, got: %q", expected, signingFlag)
|
|
}
|
|
}
|
|
|
|
func TestAndroidAppImport_SigningLineageFilegroup(t *testing.T) {
|
|
ctx, _ := testJava(t, `
|
|
android_app_import {
|
|
name: "foo",
|
|
apk: "prebuilts/apk/app.apk",
|
|
certificate: "platform",
|
|
lineage: ":lineage_bin",
|
|
}
|
|
|
|
filegroup {
|
|
name: "lineage_bin",
|
|
srcs: ["lineage.bin"],
|
|
}
|
|
`)
|
|
|
|
variant := ctx.ModuleForTests("foo", "android_common")
|
|
|
|
signedApk := variant.Output("signed/foo.apk")
|
|
// Check cert signing lineage flag.
|
|
signingFlag := signedApk.Args["flags"]
|
|
expected := "--lineage lineage.bin"
|
|
if expected != signingFlag {
|
|
t.Errorf("Incorrect signing flags, expected: %q, got: %q", expected, signingFlag)
|
|
}
|
|
}
|
|
|
|
func TestAndroidAppImport_DefaultDevCert(t *testing.T) {
|
|
ctx, _ := testJava(t, `
|
|
android_app_import {
|
|
name: "foo",
|
|
apk: "prebuilts/apk/app.apk",
|
|
default_dev_cert: true,
|
|
dex_preopt: {
|
|
enabled: true,
|
|
},
|
|
}
|
|
`)
|
|
|
|
variant := ctx.ModuleForTests("foo", "android_common")
|
|
|
|
// Check dexpreopt outputs.
|
|
if variant.MaybeOutput("dexpreopt/oat/arm64/package.vdex").Rule == nil ||
|
|
variant.MaybeOutput("dexpreopt/oat/arm64/package.odex").Rule == nil {
|
|
t.Errorf("can't find dexpreopt outputs")
|
|
}
|
|
|
|
// Check cert signing flag.
|
|
signedApk := variant.Output("signed/foo.apk")
|
|
signingFlag := signedApk.Args["certificates"]
|
|
expected := "build/make/target/product/security/testkey.x509.pem build/make/target/product/security/testkey.pk8"
|
|
if expected != signingFlag {
|
|
t.Errorf("Incorrect signing flags, expected: %q, got: %q", expected, signingFlag)
|
|
}
|
|
}
|
|
|
|
func TestAndroidAppImport_DpiVariants(t *testing.T) {
|
|
bp := `
|
|
android_app_import {
|
|
name: "foo",
|
|
apk: "prebuilts/apk/app.apk",
|
|
dpi_variants: {
|
|
xhdpi: {
|
|
apk: "prebuilts/apk/app_xhdpi.apk",
|
|
},
|
|
xxhdpi: {
|
|
apk: "prebuilts/apk/app_xxhdpi.apk",
|
|
},
|
|
},
|
|
presigned: true,
|
|
dex_preopt: {
|
|
enabled: true,
|
|
},
|
|
}
|
|
`
|
|
testCases := []struct {
|
|
name string
|
|
aaptPreferredConfig *string
|
|
aaptPrebuiltDPI []string
|
|
expected string
|
|
}{
|
|
{
|
|
name: "no preferred",
|
|
aaptPreferredConfig: nil,
|
|
aaptPrebuiltDPI: []string{},
|
|
expected: "verify_uses_libraries/apk/app.apk",
|
|
},
|
|
{
|
|
name: "AAPTPreferredConfig matches",
|
|
aaptPreferredConfig: proptools.StringPtr("xhdpi"),
|
|
aaptPrebuiltDPI: []string{"xxhdpi", "ldpi"},
|
|
expected: "verify_uses_libraries/apk/app_xhdpi.apk",
|
|
},
|
|
{
|
|
name: "AAPTPrebuiltDPI matches",
|
|
aaptPreferredConfig: proptools.StringPtr("mdpi"),
|
|
aaptPrebuiltDPI: []string{"xxhdpi", "xhdpi"},
|
|
expected: "verify_uses_libraries/apk/app_xxhdpi.apk",
|
|
},
|
|
{
|
|
name: "non-first AAPTPrebuiltDPI matches",
|
|
aaptPreferredConfig: proptools.StringPtr("mdpi"),
|
|
aaptPrebuiltDPI: []string{"ldpi", "xhdpi"},
|
|
expected: "verify_uses_libraries/apk/app_xhdpi.apk",
|
|
},
|
|
{
|
|
name: "no matches",
|
|
aaptPreferredConfig: proptools.StringPtr("mdpi"),
|
|
aaptPrebuiltDPI: []string{"ldpi", "xxxhdpi"},
|
|
expected: "verify_uses_libraries/apk/app.apk",
|
|
},
|
|
}
|
|
|
|
jniRuleRe := regexp.MustCompile("^if \\(zipinfo (\\S+)")
|
|
for _, test := range testCases {
|
|
result := android.GroupFixturePreparers(
|
|
PrepareForTestWithJavaDefaultModules,
|
|
android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
|
|
variables.AAPTPreferredConfig = test.aaptPreferredConfig
|
|
variables.AAPTPrebuiltDPI = test.aaptPrebuiltDPI
|
|
}),
|
|
).RunTestWithBp(t, bp)
|
|
|
|
variant := result.ModuleForTests("foo", "android_common")
|
|
jniRuleCommand := variant.Output("jnis-uncompressed/foo.apk").RuleParams.Command
|
|
matches := jniRuleRe.FindStringSubmatch(jniRuleCommand)
|
|
if len(matches) != 2 {
|
|
t.Errorf("failed to extract the src apk path from %q", jniRuleCommand)
|
|
}
|
|
if strings.HasSuffix(matches[1], test.expected) {
|
|
t.Errorf("wrong src apk, expected: %q got: %q", test.expected, matches[1])
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestAndroidAppImport_Filename(t *testing.T) {
|
|
ctx, _ := testJava(t, `
|
|
android_app_import {
|
|
name: "foo",
|
|
apk: "prebuilts/apk/app.apk",
|
|
presigned: true,
|
|
}
|
|
|
|
android_app_import {
|
|
name: "bar",
|
|
apk: "prebuilts/apk/app.apk",
|
|
presigned: true,
|
|
filename: "bar_sample.apk"
|
|
}
|
|
`)
|
|
|
|
testCases := []struct {
|
|
name string
|
|
expected string
|
|
}{
|
|
{
|
|
name: "foo",
|
|
expected: "foo.apk",
|
|
},
|
|
{
|
|
name: "bar",
|
|
expected: "bar_sample.apk",
|
|
},
|
|
}
|
|
|
|
for _, test := range testCases {
|
|
variant := ctx.ModuleForTests(test.name, "android_common")
|
|
if variant.MaybeOutput(test.expected).Rule == nil {
|
|
t.Errorf("can't find output named %q - all outputs: %v", test.expected, variant.AllOutputs())
|
|
}
|
|
|
|
a := variant.Module().(*AndroidAppImport)
|
|
expectedValues := []string{test.expected}
|
|
actualValues := android.AndroidMkEntriesForTest(t, ctx, a)[0].EntryMap["LOCAL_INSTALLED_MODULE_STEM"]
|
|
if !reflect.DeepEqual(actualValues, expectedValues) {
|
|
t.Errorf("Incorrect LOCAL_INSTALLED_MODULE_STEM value '%s', expected '%s'",
|
|
actualValues, expectedValues)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestAndroidAppImport_ArchVariants(t *testing.T) {
|
|
// The test config's target arch is ARM64.
|
|
testCases := []struct {
|
|
name string
|
|
bp string
|
|
expected string
|
|
}{
|
|
{
|
|
name: "matching arch",
|
|
bp: `
|
|
android_app_import {
|
|
name: "foo",
|
|
apk: "prebuilts/apk/app.apk",
|
|
arch: {
|
|
arm64: {
|
|
apk: "prebuilts/apk/app_arm64.apk",
|
|
},
|
|
},
|
|
presigned: true,
|
|
dex_preopt: {
|
|
enabled: true,
|
|
},
|
|
}
|
|
`,
|
|
expected: "verify_uses_libraries/apk/app_arm64.apk",
|
|
},
|
|
{
|
|
name: "no matching arch",
|
|
bp: `
|
|
android_app_import {
|
|
name: "foo",
|
|
apk: "prebuilts/apk/app.apk",
|
|
arch: {
|
|
arm: {
|
|
apk: "prebuilts/apk/app_arm.apk",
|
|
},
|
|
},
|
|
presigned: true,
|
|
dex_preopt: {
|
|
enabled: true,
|
|
},
|
|
}
|
|
`,
|
|
expected: "verify_uses_libraries/apk/app.apk",
|
|
},
|
|
{
|
|
name: "no matching arch without default",
|
|
bp: `
|
|
android_app_import {
|
|
name: "foo",
|
|
arch: {
|
|
arm: {
|
|
apk: "prebuilts/apk/app_arm.apk",
|
|
},
|
|
},
|
|
presigned: true,
|
|
dex_preopt: {
|
|
enabled: true,
|
|
},
|
|
}
|
|
`,
|
|
expected: "",
|
|
},
|
|
}
|
|
|
|
jniRuleRe := regexp.MustCompile("^if \\(zipinfo (\\S+)")
|
|
for _, test := range testCases {
|
|
ctx, _ := testJava(t, test.bp)
|
|
|
|
variant := ctx.ModuleForTests("foo", "android_common")
|
|
if test.expected == "" {
|
|
if variant.Module().Enabled() {
|
|
t.Error("module should have been disabled, but wasn't")
|
|
}
|
|
continue
|
|
}
|
|
jniRuleCommand := variant.Output("jnis-uncompressed/foo.apk").RuleParams.Command
|
|
matches := jniRuleRe.FindStringSubmatch(jniRuleCommand)
|
|
if len(matches) != 2 {
|
|
t.Errorf("failed to extract the src apk path from %q", jniRuleCommand)
|
|
}
|
|
if strings.HasSuffix(matches[1], test.expected) {
|
|
t.Errorf("wrong src apk, expected: %q got: %q", test.expected, matches[1])
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestAndroidAppImport_overridesDisabledAndroidApp(t *testing.T) {
|
|
ctx, _ := testJava(t, `
|
|
android_app {
|
|
name: "foo",
|
|
srcs: ["a.java"],
|
|
enabled: false,
|
|
}
|
|
|
|
android_app_import {
|
|
name: "foo",
|
|
apk: "prebuilts/apk/app.apk",
|
|
certificate: "platform",
|
|
prefer: true,
|
|
}
|
|
`)
|
|
|
|
variant := ctx.ModuleForTests("prebuilt_foo", "android_common")
|
|
a := variant.Module().(*AndroidAppImport)
|
|
// The prebuilt module should still be enabled and active even if the source-based counterpart
|
|
// is disabled.
|
|
if !a.prebuilt.UsePrebuilt() {
|
|
t.Errorf("prebuilt foo module is not active")
|
|
}
|
|
if !a.Enabled() {
|
|
t.Errorf("prebuilt foo module is disabled")
|
|
}
|
|
}
|
|
|
|
func TestAndroidAppImport_frameworkRes(t *testing.T) {
|
|
ctx, _ := testJava(t, `
|
|
android_app_import {
|
|
name: "framework-res",
|
|
certificate: "platform",
|
|
apk: "package-res.apk",
|
|
prefer: true,
|
|
export_package_resources: true,
|
|
// Disable dexpreopt and verify_uses_libraries check as the app
|
|
// contains no Java code to be dexpreopted.
|
|
enforce_uses_libs: false,
|
|
dex_preopt: {
|
|
enabled: false,
|
|
},
|
|
}
|
|
`)
|
|
|
|
mod := ctx.ModuleForTests("prebuilt_framework-res", "android_common").Module()
|
|
a := mod.(*AndroidAppImport)
|
|
|
|
if !a.preprocessed {
|
|
t.Errorf("prebuilt framework-res is not preprocessed")
|
|
}
|
|
|
|
expectedInstallPath := "out/soong/target/product/test_device/system/framework/framework-res.apk"
|
|
|
|
android.AssertPathRelativeToTopEquals(t, "prebuilt framework-res install location", expectedInstallPath, a.dexpreopter.installPath)
|
|
|
|
entries := android.AndroidMkEntriesForTest(t, ctx, mod)[0]
|
|
|
|
expectedPath := "."
|
|
// From apk property above, in the root of the source tree.
|
|
expectedPrebuiltModuleFile := "package-res.apk"
|
|
// Verify that the apk is preprocessed: The export package is the same
|
|
// as the prebuilt.
|
|
expectedSoongResourceExportPackage := expectedPrebuiltModuleFile
|
|
|
|
actualPath := entries.EntryMap["LOCAL_PATH"]
|
|
actualPrebuiltModuleFile := entries.EntryMap["LOCAL_PREBUILT_MODULE_FILE"]
|
|
actualSoongResourceExportPackage := entries.EntryMap["LOCAL_SOONG_RESOURCE_EXPORT_PACKAGE"]
|
|
|
|
if len(actualPath) != 1 {
|
|
t.Errorf("LOCAL_PATH incorrect len %d", len(actualPath))
|
|
} else if actualPath[0] != expectedPath {
|
|
t.Errorf("LOCAL_PATH mismatch, actual: %s, expected: %s", actualPath[0], expectedPath)
|
|
}
|
|
|
|
if len(actualPrebuiltModuleFile) != 1 {
|
|
t.Errorf("LOCAL_PREBUILT_MODULE_FILE incorrect len %d", len(actualPrebuiltModuleFile))
|
|
} else if actualPrebuiltModuleFile[0] != expectedPrebuiltModuleFile {
|
|
t.Errorf("LOCAL_PREBUILT_MODULE_FILE mismatch, actual: %s, expected: %s", actualPrebuiltModuleFile[0], expectedPrebuiltModuleFile)
|
|
}
|
|
|
|
if len(actualSoongResourceExportPackage) != 1 {
|
|
t.Errorf("LOCAL_SOONG_RESOURCE_EXPORT_PACKAGE incorrect len %d", len(actualSoongResourceExportPackage))
|
|
} else if actualSoongResourceExportPackage[0] != expectedSoongResourceExportPackage {
|
|
t.Errorf("LOCAL_SOONG_RESOURCE_EXPORT_PACKAGE mismatch, actual: %s, expected: %s", actualSoongResourceExportPackage[0], expectedSoongResourceExportPackage)
|
|
}
|
|
}
|
|
|
|
func TestAndroidAppImport_relativeInstallPath(t *testing.T) {
|
|
bp := `
|
|
android_app_import {
|
|
name: "no_relative_install_path",
|
|
apk: "prebuilts/apk/app.apk",
|
|
presigned: true,
|
|
}
|
|
|
|
android_app_import {
|
|
name: "relative_install_path",
|
|
apk: "prebuilts/apk/app.apk",
|
|
presigned: true,
|
|
relative_install_path: "my/path",
|
|
}
|
|
|
|
android_app_import {
|
|
name: "framework-res",
|
|
apk: "prebuilts/apk/app.apk",
|
|
presigned: true,
|
|
prefer: true,
|
|
}
|
|
|
|
android_app_import {
|
|
name: "privileged_relative_install_path",
|
|
apk: "prebuilts/apk/app.apk",
|
|
presigned: true,
|
|
privileged: true,
|
|
relative_install_path: "my/path"
|
|
}
|
|
`
|
|
testCases := []struct {
|
|
name string
|
|
expectedInstallPath string
|
|
errorMessage string
|
|
}{
|
|
{
|
|
name: "no_relative_install_path",
|
|
expectedInstallPath: "out/soong/target/product/test_device/system/app/no_relative_install_path/no_relative_install_path.apk",
|
|
errorMessage: "Install path is not correct when relative_install_path is missing",
|
|
},
|
|
{
|
|
name: "relative_install_path",
|
|
expectedInstallPath: "out/soong/target/product/test_device/system/app/my/path/relative_install_path/relative_install_path.apk",
|
|
errorMessage: "Install path is not correct for app when relative_install_path is present",
|
|
},
|
|
{
|
|
name: "prebuilt_framework-res",
|
|
expectedInstallPath: "out/soong/target/product/test_device/system/framework/framework-res.apk",
|
|
errorMessage: "Install path is not correct for framework-res",
|
|
},
|
|
{
|
|
name: "privileged_relative_install_path",
|
|
expectedInstallPath: "out/soong/target/product/test_device/system/priv-app/my/path/privileged_relative_install_path/privileged_relative_install_path.apk",
|
|
errorMessage: "Install path is not correct for privileged app when relative_install_path is present",
|
|
},
|
|
}
|
|
for _, testCase := range testCases {
|
|
ctx, _ := testJava(t, bp)
|
|
mod := ctx.ModuleForTests(testCase.name, "android_common").Module().(*AndroidAppImport)
|
|
android.AssertPathRelativeToTopEquals(t, testCase.errorMessage, testCase.expectedInstallPath, mod.installPath)
|
|
}
|
|
}
|
|
|
|
func TestAndroidTestImport(t *testing.T) {
|
|
ctx, _ := testJava(t, `
|
|
android_test_import {
|
|
name: "foo",
|
|
apk: "prebuilts/apk/app.apk",
|
|
presigned: true,
|
|
data: [
|
|
"testdata/data",
|
|
],
|
|
}
|
|
`)
|
|
|
|
test := ctx.ModuleForTests("foo", "android_common").Module().(*AndroidTestImport)
|
|
|
|
// Check android mks.
|
|
entries := android.AndroidMkEntriesForTest(t, ctx, test)[0]
|
|
expected := []string{"tests"}
|
|
actual := entries.EntryMap["LOCAL_MODULE_TAGS"]
|
|
if !reflect.DeepEqual(expected, actual) {
|
|
t.Errorf("Unexpected module tags - expected: %q, actual: %q", expected, actual)
|
|
}
|
|
expected = []string{"testdata/data:testdata/data"}
|
|
actual = entries.EntryMap["LOCAL_COMPATIBILITY_SUPPORT_FILES"]
|
|
if !reflect.DeepEqual(expected, actual) {
|
|
t.Errorf("Unexpected test data - expected: %q, actual: %q", expected, actual)
|
|
}
|
|
}
|
|
|
|
func TestAndroidTestImport_NoJinUncompressForPresigned(t *testing.T) {
|
|
ctx, _ := testJava(t, `
|
|
android_test_import {
|
|
name: "foo",
|
|
apk: "prebuilts/apk/app.apk",
|
|
certificate: "cert/new_cert",
|
|
data: [
|
|
"testdata/data",
|
|
],
|
|
}
|
|
|
|
android_test_import {
|
|
name: "foo_presigned",
|
|
apk: "prebuilts/apk/app.apk",
|
|
presigned: true,
|
|
data: [
|
|
"testdata/data",
|
|
],
|
|
}
|
|
`)
|
|
|
|
variant := ctx.ModuleForTests("foo", "android_common")
|
|
jniRule := variant.Output("jnis-uncompressed/foo.apk").RuleParams.Command
|
|
if !strings.HasPrefix(jniRule, "if (zipinfo") {
|
|
t.Errorf("Unexpected JNI uncompress rule command: " + jniRule)
|
|
}
|
|
|
|
variant = ctx.ModuleForTests("foo_presigned", "android_common")
|
|
jniRule = variant.Output("jnis-uncompressed/foo_presigned.apk").BuildParams.Rule.String()
|
|
if jniRule != android.Cp.String() {
|
|
t.Errorf("Unexpected JNI uncompress rule: " + jniRule)
|
|
}
|
|
if variant.MaybeOutput("zip-aligned/foo_presigned.apk").Rule == nil {
|
|
t.Errorf("Presigned test apk should be aligned")
|
|
}
|
|
}
|
|
|
|
func TestAndroidTestImport_Preprocessed(t *testing.T) {
|
|
ctx, _ := testJava(t, `
|
|
android_test_import {
|
|
name: "foo",
|
|
apk: "prebuilts/apk/app.apk",
|
|
presigned: true,
|
|
preprocessed: true,
|
|
}
|
|
|
|
android_test_import {
|
|
name: "foo_cert",
|
|
apk: "prebuilts/apk/app.apk",
|
|
certificate: "cert/new_cert",
|
|
preprocessed: true,
|
|
}
|
|
`)
|
|
|
|
testModules := []string{"foo", "foo_cert"}
|
|
for _, m := range testModules {
|
|
apkName := m + ".apk"
|
|
variant := ctx.ModuleForTests(m, "android_common")
|
|
jniRule := variant.Output("jnis-uncompressed/" + apkName).BuildParams.Rule.String()
|
|
if jniRule != android.Cp.String() {
|
|
t.Errorf("Unexpected JNI uncompress rule: " + jniRule)
|
|
}
|
|
|
|
// Make sure signing and aligning were skipped.
|
|
if variant.MaybeOutput("signed/"+apkName).Rule != nil {
|
|
t.Errorf("signing rule shouldn't be included for preprocessed.")
|
|
}
|
|
if variant.MaybeOutput("zip-aligned/"+apkName).Rule != nil {
|
|
t.Errorf("aligning rule shouldn't be for preprocessed")
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestAndroidTestImport_UncompressDex(t *testing.T) {
|
|
testCases := []struct {
|
|
name string
|
|
bp string
|
|
}{
|
|
{
|
|
name: "normal",
|
|
bp: `
|
|
android_app_import {
|
|
name: "foo",
|
|
presigned: true,
|
|
apk: "prebuilts/apk/app.apk",
|
|
}
|
|
`,
|
|
},
|
|
{
|
|
name: "privileged",
|
|
bp: `
|
|
android_app_import {
|
|
name: "foo",
|
|
presigned: true,
|
|
privileged: true,
|
|
apk: "prebuilts/apk/app.apk",
|
|
}
|
|
`,
|
|
},
|
|
}
|
|
|
|
test := func(t *testing.T, bp string, unbundled bool, dontUncompressPrivAppDexs bool) {
|
|
t.Helper()
|
|
|
|
result := android.GroupFixturePreparers(
|
|
prepareForJavaTest,
|
|
android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
|
|
if unbundled {
|
|
variables.Unbundled_build = proptools.BoolPtr(true)
|
|
}
|
|
variables.UncompressPrivAppDex = proptools.BoolPtr(!dontUncompressPrivAppDexs)
|
|
}),
|
|
).RunTestWithBp(t, bp)
|
|
|
|
foo := result.ModuleForTests("foo", "android_common")
|
|
actual := foo.MaybeRule("uncompress-dex").Rule != nil
|
|
|
|
expect := !unbundled
|
|
if strings.Contains(bp, "privileged: true") {
|
|
if dontUncompressPrivAppDexs {
|
|
expect = false
|
|
} else {
|
|
// TODO(b/194504107): shouldn't priv-apps be always uncompressed unless
|
|
// DONT_UNCOMPRESS_PRIV_APPS_DEXS is true (regardless of unbundling)?
|
|
// expect = true
|
|
}
|
|
}
|
|
|
|
android.AssertBoolEquals(t, "uncompress dex", expect, actual)
|
|
}
|
|
|
|
for _, unbundled := range []bool{false, true} {
|
|
for _, dontUncompressPrivAppDexs := range []bool{false, true} {
|
|
for _, tt := range testCases {
|
|
name := fmt.Sprintf("%s,unbundled:%t,dontUncompressPrivAppDexs:%t",
|
|
tt.name, unbundled, dontUncompressPrivAppDexs)
|
|
t.Run(name, func(t *testing.T) {
|
|
test(t, tt.bp, unbundled, dontUncompressPrivAppDexs)
|
|
})
|
|
}
|
|
}
|
|
}
|
|
}
|