blob: f53be9229c1b6dafdee2fad0bf918848020578dc [file] [log] [blame]
Jiyong Park25fc6a92018-11-18 18:02:45 +09001// Copyright 2018 Google Inc. All rights reserved.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package apex
16
17import (
Jiyong Parkf7c3bbe2020-12-09 21:18:56 +090018 "fmt"
Jiyong Park25fc6a92018-11-18 18:02:45 +090019 "os"
Jooyung Han39edb6c2019-11-06 16:53:07 +090020 "path"
Paul Duffin37856732021-02-26 14:24:15 +000021 "path/filepath"
Jaewoong Jung22f7d182019-07-16 18:25:41 -070022 "reflect"
Paul Duffin9b879592020-05-26 13:21:35 +010023 "regexp"
Jooyung Han31c470b2019-10-18 16:26:59 +090024 "sort"
Jiyong Parkd4a3a132021-03-17 20:21:35 +090025 "strconv"
Jiyong Park25fc6a92018-11-18 18:02:45 +090026 "strings"
27 "testing"
Jiyong Parkda6eb592018-12-19 17:12:36 +090028
29 "github.com/google/blueprint/proptools"
30
31 "android/soong/android"
markchien2f59ec92020-09-02 16:23:38 +080032 "android/soong/bpf"
Jiyong Parkda6eb592018-12-19 17:12:36 +090033 "android/soong/cc"
Ulya Trafimovichb28cc372020-01-13 15:18:16 +000034 "android/soong/dexpreopt"
Jaewoong Jung4b79e982020-06-01 10:45:49 -070035 prebuilt_etc "android/soong/etc"
Jiyong Parkb2742fd2019-02-11 11:38:15 +090036 "android/soong/java"
Jiyong Park99644e92020-11-17 22:21:02 +090037 "android/soong/rust"
Jaewoong Jung4b79e982020-06-01 10:45:49 -070038 "android/soong/sh"
Jiyong Park25fc6a92018-11-18 18:02:45 +090039)
40
Jooyung Hand3639552019-08-09 12:57:43 +090041// names returns name list from white space separated string
42func names(s string) (ns []string) {
43 for _, n := range strings.Split(s, " ") {
44 if len(n) > 0 {
45 ns = append(ns, n)
46 }
47 }
48 return
49}
50
Paul Duffin40b62572021-03-20 11:39:01 +000051func testApexError(t *testing.T, pattern, bp string, preparers ...android.FixturePreparer) {
Jooyung Han344d5432019-08-23 11:17:39 +090052 t.Helper()
Paul Duffin284165a2021-03-29 01:50:31 +010053 android.GroupFixturePreparers(
54 prepareForApexTest,
55 android.GroupFixturePreparers(preparers...),
56 ).
Paul Duffine05480a2021-03-08 15:07:14 +000057 ExtendWithErrorHandler(android.FixtureExpectsAtLeastOneErrorMatchingPattern(pattern)).
Paul Duffin40b62572021-03-20 11:39:01 +000058 RunTestWithBp(t, bp)
Jooyung Han5c998b92019-06-27 11:30:33 +090059}
60
Paul Duffin40b62572021-03-20 11:39:01 +000061func testApex(t *testing.T, bp string, preparers ...android.FixturePreparer) *android.TestContext {
Jooyung Han344d5432019-08-23 11:17:39 +090062 t.Helper()
Paul Duffin284165a2021-03-29 01:50:31 +010063
64 optionalBpPreparer := android.NullFixturePreparer
Paul Duffin40b62572021-03-20 11:39:01 +000065 if bp != "" {
Paul Duffin284165a2021-03-29 01:50:31 +010066 optionalBpPreparer = android.FixtureWithRootAndroidBp(bp)
Paul Duffin40b62572021-03-20 11:39:01 +000067 }
Paul Duffin284165a2021-03-29 01:50:31 +010068
69 result := android.GroupFixturePreparers(
70 prepareForApexTest,
71 android.GroupFixturePreparers(preparers...),
72 optionalBpPreparer,
73 ).RunTest(t)
74
Paul Duffine05480a2021-03-08 15:07:14 +000075 return result.TestContext
Jooyung Han5c998b92019-06-27 11:30:33 +090076}
77
Paul Duffin810f33d2021-03-09 14:12:32 +000078func withFiles(files android.MockFS) android.FixturePreparer {
79 return files.AddToFixture()
Jooyung Han344d5432019-08-23 11:17:39 +090080}
81
Paul Duffin810f33d2021-03-09 14:12:32 +000082func withTargets(targets map[android.OsType][]android.Target) android.FixturePreparer {
83 return android.FixtureModifyConfig(func(config android.Config) {
Jooyung Han344d5432019-08-23 11:17:39 +090084 for k, v := range targets {
85 config.Targets[k] = v
86 }
Paul Duffin810f33d2021-03-09 14:12:32 +000087 })
Jooyung Han344d5432019-08-23 11:17:39 +090088}
89
Jooyung Han35155c42020-02-06 17:33:20 +090090// withNativeBridgeTargets sets configuration with targets including:
91// - X86_64 (primary)
92// - X86 (secondary)
93// - Arm64 on X86_64 (native bridge)
94// - Arm on X86 (native bridge)
Paul Duffin810f33d2021-03-09 14:12:32 +000095var withNativeBridgeEnabled = android.FixtureModifyConfig(
96 func(config android.Config) {
97 config.Targets[android.Android] = []android.Target{
98 {Os: android.Android, Arch: android.Arch{ArchType: android.X86_64, ArchVariant: "silvermont", Abi: []string{"arm64-v8a"}},
99 NativeBridge: android.NativeBridgeDisabled, NativeBridgeHostArchName: "", NativeBridgeRelativePath: ""},
100 {Os: android.Android, Arch: android.Arch{ArchType: android.X86, ArchVariant: "silvermont", Abi: []string{"armeabi-v7a"}},
101 NativeBridge: android.NativeBridgeDisabled, NativeBridgeHostArchName: "", NativeBridgeRelativePath: ""},
102 {Os: android.Android, Arch: android.Arch{ArchType: android.Arm64, ArchVariant: "armv8-a", Abi: []string{"arm64-v8a"}},
103 NativeBridge: android.NativeBridgeEnabled, NativeBridgeHostArchName: "x86_64", NativeBridgeRelativePath: "arm64"},
104 {Os: android.Android, Arch: android.Arch{ArchType: android.Arm, ArchVariant: "armv7-a-neon", Abi: []string{"armeabi-v7a"}},
105 NativeBridge: android.NativeBridgeEnabled, NativeBridgeHostArchName: "x86", NativeBridgeRelativePath: "arm"},
106 }
107 },
108)
109
110func withManifestPackageNameOverrides(specs []string) android.FixturePreparer {
111 return android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
112 variables.ManifestPackageNameOverrides = specs
113 })
Jooyung Han35155c42020-02-06 17:33:20 +0900114}
115
Albert Martin55ccba22022-03-21 20:11:16 +0000116func withApexGlobalMinSdkVersionOverride(minSdkOverride *string) android.FixturePreparer {
117 return android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
118 variables.ApexGlobalMinSdkVersionOverride = minSdkOverride
119 })
120}
121
Paul Duffin810f33d2021-03-09 14:12:32 +0000122var withBinder32bit = android.FixtureModifyProductVariables(
123 func(variables android.FixtureProductVariables) {
124 variables.Binder32bit = proptools.BoolPtr(true)
125 },
126)
Jiyong Parkcfaa1642020-02-28 16:51:07 +0900127
Paul Duffin810f33d2021-03-09 14:12:32 +0000128var withUnbundledBuild = android.FixtureModifyProductVariables(
129 func(variables android.FixtureProductVariables) {
130 variables.Unbundled_build = proptools.BoolPtr(true)
131 },
132)
Jiyong Park7cd10e32020-01-14 09:22:18 +0900133
Paul Duffin284165a2021-03-29 01:50:31 +0100134// Legacy preparer used for running tests within the apex package.
135//
136// This includes everything that was needed to run any test in the apex package prior to the
137// introduction of the test fixtures. Tests that are being converted to use fixtures directly
138// rather than through the testApex...() methods should avoid using this and instead use the
139// various preparers directly, using android.GroupFixturePreparers(...) to group them when
140// necessary.
141//
142// deprecated
143var prepareForApexTest = android.GroupFixturePreparers(
Paul Duffin37aad602021-03-08 09:47:16 +0000144 // General preparers in alphabetical order as test infrastructure will enforce correct
145 // registration order.
146 android.PrepareForTestWithAndroidBuildComponents,
147 bpf.PrepareForTestWithBpf,
148 cc.PrepareForTestWithCcBuildComponents,
149 java.PrepareForTestWithJavaDefaultModules,
150 prebuilt_etc.PrepareForTestWithPrebuiltEtc,
151 rust.PrepareForTestWithRustDefaultModules,
152 sh.PrepareForTestWithShBuildComponents,
153
154 PrepareForTestWithApexBuildComponents,
155
156 // Additional apex test specific preparers.
157 android.FixtureAddTextFile("system/sepolicy/Android.bp", `
158 filegroup {
159 name: "myapex-file_contexts",
160 srcs: [
161 "apex/myapex-file_contexts",
162 ],
163 }
164 `),
Paul Duffin52bfaa42021-03-23 23:40:12 +0000165 prepareForTestWithMyapex,
Paul Duffin37aad602021-03-08 09:47:16 +0000166 android.FixtureMergeMockFs(android.MockFS{
Paul Duffin52bfaa42021-03-23 23:40:12 +0000167 "a.java": nil,
168 "PrebuiltAppFoo.apk": nil,
169 "PrebuiltAppFooPriv.apk": nil,
170 "apex_manifest.json": nil,
171 "AndroidManifest.xml": nil,
Paul Duffin37aad602021-03-08 09:47:16 +0000172 "system/sepolicy/apex/myapex.updatable-file_contexts": nil,
173 "system/sepolicy/apex/myapex2-file_contexts": nil,
174 "system/sepolicy/apex/otherapex-file_contexts": nil,
175 "system/sepolicy/apex/com.android.vndk-file_contexts": nil,
176 "system/sepolicy/apex/com.android.vndk.current-file_contexts": nil,
177 "mylib.cpp": nil,
178 "mytest.cpp": nil,
179 "mytest1.cpp": nil,
180 "mytest2.cpp": nil,
181 "mytest3.cpp": nil,
182 "myprebuilt": nil,
183 "my_include": nil,
184 "foo/bar/MyClass.java": nil,
185 "prebuilt.jar": nil,
186 "prebuilt.so": nil,
187 "vendor/foo/devkeys/test.x509.pem": nil,
188 "vendor/foo/devkeys/test.pk8": nil,
189 "testkey.x509.pem": nil,
190 "testkey.pk8": nil,
191 "testkey.override.x509.pem": nil,
192 "testkey.override.pk8": nil,
193 "vendor/foo/devkeys/testkey.avbpubkey": nil,
194 "vendor/foo/devkeys/testkey.pem": nil,
195 "NOTICE": nil,
196 "custom_notice": nil,
197 "custom_notice_for_static_lib": nil,
198 "testkey2.avbpubkey": nil,
199 "testkey2.pem": nil,
200 "myapex-arm64.apex": nil,
201 "myapex-arm.apex": nil,
202 "myapex.apks": nil,
203 "frameworks/base/api/current.txt": nil,
204 "framework/aidl/a.aidl": nil,
205 "build/make/core/proguard.flags": nil,
206 "build/make/core/proguard_basic_keeps.flags": nil,
207 "dummy.txt": nil,
208 "baz": nil,
209 "bar/baz": nil,
210 "testdata/baz": nil,
211 "AppSet.apks": nil,
212 "foo.rs": nil,
213 "libfoo.jar": nil,
214 "libbar.jar": nil,
215 },
216 ),
217
218 android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
219 variables.DeviceVndkVersion = proptools.StringPtr("current")
220 variables.DefaultAppCertificate = proptools.StringPtr("vendor/foo/devkeys/test")
221 variables.CertificateOverrides = []string{"myapex_keytest:myapex.certificate.override"}
222 variables.Platform_sdk_codename = proptools.StringPtr("Q")
223 variables.Platform_sdk_final = proptools.BoolPtr(false)
Pedro Loureiroc3621422021-09-28 15:40:23 +0000224 // "Tiramisu" needs to be in the next line for compatibility with soong code,
225 // not because of these tests specifically (it's not used by the tests)
226 variables.Platform_version_active_codenames = []string{"Q", "Tiramisu"}
Jiyong Parkf58c46e2021-04-01 21:35:20 +0900227 variables.Platform_vndk_version = proptools.StringPtr("29")
Paul Duffin37aad602021-03-08 09:47:16 +0000228 }),
229)
230
Paul Duffin52bfaa42021-03-23 23:40:12 +0000231var prepareForTestWithMyapex = android.FixtureMergeMockFs(android.MockFS{
232 "system/sepolicy/apex/myapex-file_contexts": nil,
233})
234
Jooyung Han643adc42020-02-27 13:50:06 +0900235// ensure that 'result' equals 'expected'
236func ensureEquals(t *testing.T, result string, expected string) {
237 t.Helper()
238 if result != expected {
239 t.Errorf("%q != %q", expected, result)
240 }
241}
242
Jiyong Park25fc6a92018-11-18 18:02:45 +0900243// ensure that 'result' contains 'expected'
244func ensureContains(t *testing.T, result string, expected string) {
Jooyung Han5c998b92019-06-27 11:30:33 +0900245 t.Helper()
Jiyong Park25fc6a92018-11-18 18:02:45 +0900246 if !strings.Contains(result, expected) {
247 t.Errorf("%q is not found in %q", expected, result)
248 }
249}
250
Liz Kammer5bd365f2020-05-27 15:15:11 -0700251// ensure that 'result' contains 'expected' exactly one time
252func ensureContainsOnce(t *testing.T, result string, expected string) {
253 t.Helper()
254 count := strings.Count(result, expected)
255 if count != 1 {
256 t.Errorf("%q is found %d times (expected 1 time) in %q", expected, count, result)
257 }
258}
259
Jiyong Park25fc6a92018-11-18 18:02:45 +0900260// ensures that 'result' does not contain 'notExpected'
261func ensureNotContains(t *testing.T, result string, notExpected string) {
Jooyung Han5c998b92019-06-27 11:30:33 +0900262 t.Helper()
Jiyong Park25fc6a92018-11-18 18:02:45 +0900263 if strings.Contains(result, notExpected) {
264 t.Errorf("%q is found in %q", notExpected, result)
265 }
266}
267
Sasha Smundak18d98bc2020-05-27 16:36:07 -0700268func ensureMatches(t *testing.T, result string, expectedRex string) {
269 ok, err := regexp.MatchString(expectedRex, result)
270 if err != nil {
271 t.Fatalf("regexp failure trying to match %s against `%s` expression: %s", result, expectedRex, err)
272 return
273 }
274 if !ok {
275 t.Errorf("%s does not match regular expession %s", result, expectedRex)
276 }
277}
278
Jiyong Park25fc6a92018-11-18 18:02:45 +0900279func ensureListContains(t *testing.T, result []string, expected string) {
Jooyung Han5c998b92019-06-27 11:30:33 +0900280 t.Helper()
Jiyong Park25fc6a92018-11-18 18:02:45 +0900281 if !android.InList(expected, result) {
282 t.Errorf("%q is not found in %v", expected, result)
283 }
284}
285
286func ensureListNotContains(t *testing.T, result []string, notExpected string) {
Jooyung Han5c998b92019-06-27 11:30:33 +0900287 t.Helper()
Jiyong Park25fc6a92018-11-18 18:02:45 +0900288 if android.InList(notExpected, result) {
289 t.Errorf("%q is found in %v", notExpected, result)
290 }
291}
292
Jooyung Hane1633032019-08-01 17:41:43 +0900293func ensureListEmpty(t *testing.T, result []string) {
294 t.Helper()
295 if len(result) > 0 {
296 t.Errorf("%q is expected to be empty", result)
297 }
298}
299
Mohammad Samiul Islam3cd005d2020-11-26 13:32:26 +0000300func ensureListNotEmpty(t *testing.T, result []string) {
301 t.Helper()
302 if len(result) == 0 {
303 t.Errorf("%q is expected to be not empty", result)
304 }
305}
306
Jiyong Park25fc6a92018-11-18 18:02:45 +0900307// Minimal test
308func TestBasicApex(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -0800309 ctx := testApex(t, `
Jiyong Park30ca9372019-02-07 16:27:23 +0900310 apex_defaults {
311 name: "myapex-defaults",
Jiyong Park809bb722019-02-13 21:33:49 +0900312 manifest: ":myapex.manifest",
313 androidManifest: ":myapex.androidmanifest",
Jiyong Park25fc6a92018-11-18 18:02:45 +0900314 key: "myapex.key",
Jiyong Park99644e92020-11-17 22:21:02 +0900315 binaries: ["foo.rust"],
Jiyong Parkf2cc1b72020-12-09 00:20:45 +0900316 native_shared_libs: [
317 "mylib",
318 "libfoo.ffi",
319 ],
Jiyong Park99644e92020-11-17 22:21:02 +0900320 rust_dyn_libs: ["libfoo.dylib.rust"],
Alex Light3d673592019-01-18 14:37:31 -0800321 multilib: {
322 both: {
Jiyong Park99644e92020-11-17 22:21:02 +0900323 binaries: ["foo"],
Alex Light3d673592019-01-18 14:37:31 -0800324 }
Jiyong Park7f7766d2019-07-25 22:02:35 +0900325 },
Jiyong Park77acec62020-06-01 21:39:15 +0900326 java_libs: [
327 "myjar",
328 "myjar_dex",
329 ],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +0000330 updatable: false,
Jiyong Park25fc6a92018-11-18 18:02:45 +0900331 }
332
Jiyong Park30ca9372019-02-07 16:27:23 +0900333 apex {
334 name: "myapex",
335 defaults: ["myapex-defaults"],
336 }
337
Jiyong Park25fc6a92018-11-18 18:02:45 +0900338 apex_key {
339 name: "myapex.key",
340 public_key: "testkey.avbpubkey",
341 private_key: "testkey.pem",
342 }
343
Jiyong Park809bb722019-02-13 21:33:49 +0900344 filegroup {
345 name: "myapex.manifest",
346 srcs: ["apex_manifest.json"],
347 }
348
349 filegroup {
350 name: "myapex.androidmanifest",
351 srcs: ["AndroidManifest.xml"],
352 }
353
Jiyong Park25fc6a92018-11-18 18:02:45 +0900354 cc_library {
355 name: "mylib",
356 srcs: ["mylib.cpp"],
Jiyong Parkf2cc1b72020-12-09 00:20:45 +0900357 shared_libs: [
358 "mylib2",
359 "libbar.ffi",
360 ],
Jiyong Park25fc6a92018-11-18 18:02:45 +0900361 system_shared_libs: [],
362 stl: "none",
Anton Hanssoneec79eb2020-01-10 15:12:39 +0000363 // TODO: remove //apex_available:platform
364 apex_available: [
365 "//apex_available:platform",
366 "myapex",
367 ],
Jiyong Park25fc6a92018-11-18 18:02:45 +0900368 }
369
Alex Light3d673592019-01-18 14:37:31 -0800370 cc_binary {
371 name: "foo",
372 srcs: ["mylib.cpp"],
373 compile_multilib: "both",
374 multilib: {
375 lib32: {
376 suffix: "32",
377 },
378 lib64: {
379 suffix: "64",
380 },
381 },
382 symlinks: ["foo_link_"],
383 symlink_preferred_arch: true,
384 system_shared_libs: [],
Alex Light3d673592019-01-18 14:37:31 -0800385 stl: "none",
Yifan Hongd22a84a2020-07-28 17:37:46 -0700386 apex_available: [ "myapex", "com.android.gki.*" ],
387 }
388
Jiyong Park99644e92020-11-17 22:21:02 +0900389 rust_binary {
Artur Satayev533b98c2021-03-11 18:03:42 +0000390 name: "foo.rust",
Jiyong Park99644e92020-11-17 22:21:02 +0900391 srcs: ["foo.rs"],
392 rlibs: ["libfoo.rlib.rust"],
393 dylibs: ["libfoo.dylib.rust"],
394 apex_available: ["myapex"],
395 }
396
397 rust_library_rlib {
Artur Satayev533b98c2021-03-11 18:03:42 +0000398 name: "libfoo.rlib.rust",
Jiyong Park99644e92020-11-17 22:21:02 +0900399 srcs: ["foo.rs"],
400 crate_name: "foo",
401 apex_available: ["myapex"],
Jiyong Park94e22fd2021-04-08 18:19:15 +0900402 shared_libs: ["libfoo.shared_from_rust"],
403 }
404
405 cc_library_shared {
406 name: "libfoo.shared_from_rust",
407 srcs: ["mylib.cpp"],
408 system_shared_libs: [],
409 stl: "none",
410 apex_available: ["myapex"],
Jiyong Park99644e92020-11-17 22:21:02 +0900411 }
412
413 rust_library_dylib {
Artur Satayev533b98c2021-03-11 18:03:42 +0000414 name: "libfoo.dylib.rust",
Jiyong Park99644e92020-11-17 22:21:02 +0900415 srcs: ["foo.rs"],
416 crate_name: "foo",
417 apex_available: ["myapex"],
418 }
419
Jiyong Parkf2cc1b72020-12-09 00:20:45 +0900420 rust_ffi_shared {
421 name: "libfoo.ffi",
422 srcs: ["foo.rs"],
423 crate_name: "foo",
424 apex_available: ["myapex"],
425 }
426
427 rust_ffi_shared {
428 name: "libbar.ffi",
429 srcs: ["foo.rs"],
430 crate_name: "bar",
431 apex_available: ["myapex"],
432 }
433
Yifan Hongd22a84a2020-07-28 17:37:46 -0700434 apex {
435 name: "com.android.gki.fake",
436 binaries: ["foo"],
437 key: "myapex.key",
438 file_contexts: ":myapex-file_contexts",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +0000439 updatable: false,
Alex Light3d673592019-01-18 14:37:31 -0800440 }
441
Paul Duffindddd5462020-04-07 15:25:44 +0100442 cc_library_shared {
Jiyong Park25fc6a92018-11-18 18:02:45 +0900443 name: "mylib2",
444 srcs: ["mylib.cpp"],
445 system_shared_libs: [],
446 stl: "none",
Jiyong Park52818fc2019-03-18 12:01:38 +0900447 notice: "custom_notice",
Jiyong Park9918e1a2020-03-17 19:16:40 +0900448 static_libs: ["libstatic"],
449 // TODO: remove //apex_available:platform
450 apex_available: [
451 "//apex_available:platform",
452 "myapex",
453 ],
454 }
455
Paul Duffindddd5462020-04-07 15:25:44 +0100456 cc_prebuilt_library_shared {
457 name: "mylib2",
458 srcs: ["prebuilt.so"],
459 // TODO: remove //apex_available:platform
460 apex_available: [
461 "//apex_available:platform",
462 "myapex",
463 ],
464 }
465
Jiyong Park9918e1a2020-03-17 19:16:40 +0900466 cc_library_static {
467 name: "libstatic",
468 srcs: ["mylib.cpp"],
469 system_shared_libs: [],
470 stl: "none",
471 notice: "custom_notice_for_static_lib",
Anton Hanssoneec79eb2020-01-10 15:12:39 +0000472 // TODO: remove //apex_available:platform
473 apex_available: [
474 "//apex_available:platform",
475 "myapex",
476 ],
Jiyong Park25fc6a92018-11-18 18:02:45 +0900477 }
Jiyong Park7f7766d2019-07-25 22:02:35 +0900478
479 java_library {
480 name: "myjar",
481 srcs: ["foo/bar/MyClass.java"],
Jiyong Parka62aa232020-05-28 23:46:55 +0900482 stem: "myjar_stem",
Jiyong Park7f7766d2019-07-25 22:02:35 +0900483 sdk_version: "none",
484 system_modules: "none",
Jiyong Park7f7766d2019-07-25 22:02:35 +0900485 static_libs: ["myotherjar"],
Jiyong Park3ff16992019-12-27 14:11:47 +0900486 libs: ["mysharedjar"],
Anton Hanssoneec79eb2020-01-10 15:12:39 +0000487 // TODO: remove //apex_available:platform
488 apex_available: [
489 "//apex_available:platform",
490 "myapex",
491 ],
Jiyong Park7f7766d2019-07-25 22:02:35 +0900492 }
493
Jiyong Park77acec62020-06-01 21:39:15 +0900494 dex_import {
495 name: "myjar_dex",
496 jars: ["prebuilt.jar"],
497 apex_available: [
498 "//apex_available:platform",
499 "myapex",
500 ],
501 }
502
Jiyong Park7f7766d2019-07-25 22:02:35 +0900503 java_library {
504 name: "myotherjar",
505 srcs: ["foo/bar/MyClass.java"],
506 sdk_version: "none",
507 system_modules: "none",
Jiyong Park0f80c182020-01-31 02:49:53 +0900508 // TODO: remove //apex_available:platform
509 apex_available: [
510 "//apex_available:platform",
511 "myapex",
512 ],
Jiyong Park7f7766d2019-07-25 22:02:35 +0900513 }
Jiyong Park3ff16992019-12-27 14:11:47 +0900514
515 java_library {
516 name: "mysharedjar",
517 srcs: ["foo/bar/MyClass.java"],
518 sdk_version: "none",
519 system_modules: "none",
Jiyong Park3ff16992019-12-27 14:11:47 +0900520 }
Jiyong Park25fc6a92018-11-18 18:02:45 +0900521 `)
522
Paul Duffina71a67a2021-03-29 00:42:57 +0100523 apexRule := ctx.ModuleForTests("myapex", "android_common_myapex_image").Rule("apexRule")
Jiyong Park42cca6c2019-04-01 11:15:50 +0900524
Jiyong Park9e83f0b2020-06-11 00:35:03 +0900525 // Make sure that Android.mk is created
526 ab := ctx.ModuleForTests("myapex", "android_common_myapex_image").Module().(*apexBundle)
Colin Crossaa255532020-07-03 13:18:24 -0700527 data := android.AndroidMkDataForTest(t, ctx, ab)
Jiyong Park9e83f0b2020-06-11 00:35:03 +0900528 var builder strings.Builder
529 data.Custom(&builder, ab.BaseModuleName(), "TARGET_", "", data)
530
531 androidMk := builder.String()
532 ensureContains(t, androidMk, "LOCAL_MODULE := mylib.myapex\n")
533 ensureNotContains(t, androidMk, "LOCAL_MODULE := mylib.com.android.myapex\n")
534
Jiyong Park42cca6c2019-04-01 11:15:50 +0900535 optFlags := apexRule.Args["opt_flags"]
536 ensureContains(t, optFlags, "--pubkey vendor/foo/devkeys/testkey.avbpubkey")
Jaewoong Jung14f5ff62019-06-18 13:09:13 -0700537 // Ensure that the NOTICE output is being packaged as an asset.
Paul Duffin37ba3442021-03-29 00:21:08 +0100538 ensureContains(t, optFlags, "--assets_dir out/soong/.intermediates/myapex/android_common_myapex_image/NOTICE")
Jiyong Park42cca6c2019-04-01 11:15:50 +0900539
Jiyong Park25fc6a92018-11-18 18:02:45 +0900540 copyCmds := apexRule.Args["copy_commands"]
541
542 // Ensure that main rule creates an output
543 ensureContains(t, apexRule.Output.String(), "myapex.apex.unsigned")
544
545 // Ensure that apex variant is created for the direct dep
Colin Crossaede88c2020-08-11 12:17:01 -0700546 ensureListContains(t, ctx.ModuleVariantsForTests("mylib"), "android_arm64_armv8-a_shared_apex10000")
547 ensureListContains(t, ctx.ModuleVariantsForTests("myjar"), "android_common_apex10000")
548 ensureListContains(t, ctx.ModuleVariantsForTests("myjar_dex"), "android_common_apex10000")
Jiyong Park99644e92020-11-17 22:21:02 +0900549 ensureListContains(t, ctx.ModuleVariantsForTests("foo.rust"), "android_arm64_armv8-a_apex10000")
Jiyong Parkf2cc1b72020-12-09 00:20:45 +0900550 ensureListContains(t, ctx.ModuleVariantsForTests("libfoo.ffi"), "android_arm64_armv8-a_shared_apex10000")
Jiyong Park25fc6a92018-11-18 18:02:45 +0900551
552 // Ensure that apex variant is created for the indirect dep
Colin Crossaede88c2020-08-11 12:17:01 -0700553 ensureListContains(t, ctx.ModuleVariantsForTests("mylib2"), "android_arm64_armv8-a_shared_apex10000")
554 ensureListContains(t, ctx.ModuleVariantsForTests("myotherjar"), "android_common_apex10000")
Jiyong Park99644e92020-11-17 22:21:02 +0900555 ensureListContains(t, ctx.ModuleVariantsForTests("libfoo.rlib.rust"), "android_arm64_armv8-a_rlib_dylib-std_apex10000")
556 ensureListContains(t, ctx.ModuleVariantsForTests("libfoo.dylib.rust"), "android_arm64_armv8-a_dylib_apex10000")
Jiyong Parkf2cc1b72020-12-09 00:20:45 +0900557 ensureListContains(t, ctx.ModuleVariantsForTests("libbar.ffi"), "android_arm64_armv8-a_shared_apex10000")
Jiyong Park94e22fd2021-04-08 18:19:15 +0900558 ensureListContains(t, ctx.ModuleVariantsForTests("libfoo.shared_from_rust"), "android_arm64_armv8-a_shared_apex10000")
Jiyong Park25fc6a92018-11-18 18:02:45 +0900559
560 // Ensure that both direct and indirect deps are copied into apex
Alex Light5098a612018-11-29 17:12:15 -0800561 ensureContains(t, copyCmds, "image.apex/lib64/mylib.so")
562 ensureContains(t, copyCmds, "image.apex/lib64/mylib2.so")
Jiyong Parka62aa232020-05-28 23:46:55 +0900563 ensureContains(t, copyCmds, "image.apex/javalib/myjar_stem.jar")
Jiyong Park77acec62020-06-01 21:39:15 +0900564 ensureContains(t, copyCmds, "image.apex/javalib/myjar_dex.jar")
Jiyong Park99644e92020-11-17 22:21:02 +0900565 ensureContains(t, copyCmds, "image.apex/lib64/libfoo.dylib.rust.dylib.so")
Jiyong Parkf2cc1b72020-12-09 00:20:45 +0900566 ensureContains(t, copyCmds, "image.apex/lib64/libfoo.ffi.so")
567 ensureContains(t, copyCmds, "image.apex/lib64/libbar.ffi.so")
Jiyong Park94e22fd2021-04-08 18:19:15 +0900568 ensureContains(t, copyCmds, "image.apex/lib64/libfoo.shared_from_rust.so")
Jiyong Park7f7766d2019-07-25 22:02:35 +0900569 // .. but not for java libs
570 ensureNotContains(t, copyCmds, "image.apex/javalib/myotherjar.jar")
Jiyong Park3ff16992019-12-27 14:11:47 +0900571 ensureNotContains(t, copyCmds, "image.apex/javalib/msharedjar.jar")
Logan Chien3aeedc92018-12-26 15:32:21 +0800572
Colin Cross7113d202019-11-20 16:39:12 -0800573 // Ensure that the platform variant ends with _shared or _common
574 ensureListContains(t, ctx.ModuleVariantsForTests("mylib"), "android_arm64_armv8-a_shared")
575 ensureListContains(t, ctx.ModuleVariantsForTests("mylib2"), "android_arm64_armv8-a_shared")
Jiyong Park7f7766d2019-07-25 22:02:35 +0900576 ensureListContains(t, ctx.ModuleVariantsForTests("myjar"), "android_common")
577 ensureListContains(t, ctx.ModuleVariantsForTests("myotherjar"), "android_common")
Jiyong Park3ff16992019-12-27 14:11:47 +0900578 ensureListContains(t, ctx.ModuleVariantsForTests("mysharedjar"), "android_common")
579
580 // Ensure that dynamic dependency to java libs are not included
581 ensureListNotContains(t, ctx.ModuleVariantsForTests("mysharedjar"), "android_common_myapex")
Alex Light3d673592019-01-18 14:37:31 -0800582
583 // Ensure that all symlinks are present.
584 found_foo_link_64 := false
585 found_foo := false
586 for _, cmd := range strings.Split(copyCmds, " && ") {
Jiyong Park7cd10e32020-01-14 09:22:18 +0900587 if strings.HasPrefix(cmd, "ln -sfn foo64") {
Alex Light3d673592019-01-18 14:37:31 -0800588 if strings.HasSuffix(cmd, "bin/foo") {
589 found_foo = true
590 } else if strings.HasSuffix(cmd, "bin/foo_link_64") {
591 found_foo_link_64 = true
592 }
593 }
594 }
595 good := found_foo && found_foo_link_64
596 if !good {
597 t.Errorf("Could not find all expected symlinks! foo: %t, foo_link_64: %t. Command was %s", found_foo, found_foo_link_64, copyCmds)
598 }
Jiyong Park52818fc2019-03-18 12:01:38 +0900599
Sundong Ahnabb64432019-10-22 13:58:29 +0900600 mergeNoticesRule := ctx.ModuleForTests("myapex", "android_common_myapex_image").Rule("mergeNoticesRule")
Jaewoong Jung5b425e22019-06-17 17:40:56 -0700601 noticeInputs := mergeNoticesRule.Inputs.Strings()
Jiyong Park9918e1a2020-03-17 19:16:40 +0900602 if len(noticeInputs) != 3 {
603 t.Errorf("number of input notice files: expected = 3, actual = %q", len(noticeInputs))
Jiyong Park52818fc2019-03-18 12:01:38 +0900604 }
605 ensureListContains(t, noticeInputs, "NOTICE")
606 ensureListContains(t, noticeInputs, "custom_notice")
Jiyong Park9918e1a2020-03-17 19:16:40 +0900607 ensureListContains(t, noticeInputs, "custom_notice_for_static_lib")
Jiyong Park83dc74b2020-01-14 18:38:44 +0900608
Artur Satayeva8bd1132020-04-27 18:07:06 +0100609 fullDepsInfo := strings.Split(ctx.ModuleForTests("myapex", "android_common_myapex_image").Output("depsinfo/fulllist.txt").Args["content"], "\\n")
Artur Satayev4e1f2bd2020-05-14 15:15:01 +0100610 ensureListContains(t, fullDepsInfo, " myjar(minSdkVersion:(no version)) <- myapex")
Artur Satayev4e1f2bd2020-05-14 15:15:01 +0100611 ensureListContains(t, fullDepsInfo, " mylib2(minSdkVersion:(no version)) <- mylib")
612 ensureListContains(t, fullDepsInfo, " myotherjar(minSdkVersion:(no version)) <- myjar")
613 ensureListContains(t, fullDepsInfo, " mysharedjar(minSdkVersion:(no version)) (external) <- myjar")
Artur Satayeva8bd1132020-04-27 18:07:06 +0100614
615 flatDepsInfo := strings.Split(ctx.ModuleForTests("myapex", "android_common_myapex_image").Output("depsinfo/flatlist.txt").Args["content"], "\\n")
Artur Satayev4e1f2bd2020-05-14 15:15:01 +0100616 ensureListContains(t, flatDepsInfo, "myjar(minSdkVersion:(no version))")
Artur Satayev4e1f2bd2020-05-14 15:15:01 +0100617 ensureListContains(t, flatDepsInfo, "mylib2(minSdkVersion:(no version))")
618 ensureListContains(t, flatDepsInfo, "myotherjar(minSdkVersion:(no version))")
619 ensureListContains(t, flatDepsInfo, "mysharedjar(minSdkVersion:(no version)) (external)")
Alex Light5098a612018-11-29 17:12:15 -0800620}
621
Jooyung Hanf21c7972019-12-16 22:32:06 +0900622func TestDefaults(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -0800623 ctx := testApex(t, `
Jooyung Hanf21c7972019-12-16 22:32:06 +0900624 apex_defaults {
625 name: "myapex-defaults",
626 key: "myapex.key",
627 prebuilts: ["myetc"],
628 native_shared_libs: ["mylib"],
629 java_libs: ["myjar"],
630 apps: ["AppFoo"],
Jiyong Park69aeba92020-04-24 21:16:36 +0900631 rros: ["rro"],
Ken Chenfad7f9d2021-11-10 22:02:57 +0800632 bpfs: ["bpf", "netd_test"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +0000633 updatable: false,
Jooyung Hanf21c7972019-12-16 22:32:06 +0900634 }
635
636 prebuilt_etc {
637 name: "myetc",
638 src: "myprebuilt",
639 }
640
641 apex {
642 name: "myapex",
643 defaults: ["myapex-defaults"],
644 }
645
646 apex_key {
647 name: "myapex.key",
648 public_key: "testkey.avbpubkey",
649 private_key: "testkey.pem",
650 }
651
652 cc_library {
653 name: "mylib",
654 system_shared_libs: [],
655 stl: "none",
Anton Hanssoneec79eb2020-01-10 15:12:39 +0000656 apex_available: [ "myapex" ],
Jooyung Hanf21c7972019-12-16 22:32:06 +0900657 }
658
659 java_library {
660 name: "myjar",
661 srcs: ["foo/bar/MyClass.java"],
662 sdk_version: "none",
663 system_modules: "none",
Anton Hanssoneec79eb2020-01-10 15:12:39 +0000664 apex_available: [ "myapex" ],
Jooyung Hanf21c7972019-12-16 22:32:06 +0900665 }
666
667 android_app {
668 name: "AppFoo",
669 srcs: ["foo/bar/MyClass.java"],
670 sdk_version: "none",
671 system_modules: "none",
Anton Hanssoneec79eb2020-01-10 15:12:39 +0000672 apex_available: [ "myapex" ],
Jooyung Hanf21c7972019-12-16 22:32:06 +0900673 }
Jiyong Park69aeba92020-04-24 21:16:36 +0900674
675 runtime_resource_overlay {
676 name: "rro",
677 theme: "blue",
678 }
679
markchien2f59ec92020-09-02 16:23:38 +0800680 bpf {
681 name: "bpf",
682 srcs: ["bpf.c", "bpf2.c"],
683 }
684
Ken Chenfad7f9d2021-11-10 22:02:57 +0800685 bpf {
686 name: "netd_test",
687 srcs: ["netd_test.c"],
688 sub_dir: "netd",
689 }
690
Jooyung Hanf21c7972019-12-16 22:32:06 +0900691 `)
Jooyung Hana57af4a2020-01-23 05:36:59 +0000692 ensureExactContents(t, ctx, "myapex", "android_common_myapex_image", []string{
Jooyung Hanf21c7972019-12-16 22:32:06 +0900693 "etc/myetc",
694 "javalib/myjar.jar",
695 "lib64/mylib.so",
696 "app/AppFoo/AppFoo.apk",
Jiyong Park69aeba92020-04-24 21:16:36 +0900697 "overlay/blue/rro.apk",
markchien2f59ec92020-09-02 16:23:38 +0800698 "etc/bpf/bpf.o",
699 "etc/bpf/bpf2.o",
Ken Chenfad7f9d2021-11-10 22:02:57 +0800700 "etc/bpf/netd/netd_test.o",
Jooyung Hanf21c7972019-12-16 22:32:06 +0900701 })
702}
703
Jooyung Han01a3ee22019-11-02 02:52:25 +0900704func TestApexManifest(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -0800705 ctx := testApex(t, `
Jooyung Han01a3ee22019-11-02 02:52:25 +0900706 apex {
707 name: "myapex",
708 key: "myapex.key",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +0000709 updatable: false,
Jooyung Han01a3ee22019-11-02 02:52:25 +0900710 }
711
712 apex_key {
713 name: "myapex.key",
714 public_key: "testkey.avbpubkey",
715 private_key: "testkey.pem",
716 }
717 `)
718
719 module := ctx.ModuleForTests("myapex", "android_common_myapex_image")
Jooyung Han214bf372019-11-12 13:03:50 +0900720 args := module.Rule("apexRule").Args
721 if manifest := args["manifest"]; manifest != module.Output("apex_manifest.pb").Output.String() {
722 t.Error("manifest should be apex_manifest.pb, but " + manifest)
723 }
Jooyung Han01a3ee22019-11-02 02:52:25 +0900724}
725
Liz Kammer4854a7d2021-05-27 14:28:27 -0400726func TestApexManifestMinSdkVersion(t *testing.T) {
727 ctx := testApex(t, `
728 apex_defaults {
729 name: "my_defaults",
730 key: "myapex.key",
731 product_specific: true,
732 file_contexts: ":my-file-contexts",
733 updatable: false,
734 }
735 apex {
736 name: "myapex_30",
737 min_sdk_version: "30",
738 defaults: ["my_defaults"],
739 }
740
741 apex {
742 name: "myapex_current",
743 min_sdk_version: "current",
744 defaults: ["my_defaults"],
745 }
746
747 apex {
748 name: "myapex_none",
749 defaults: ["my_defaults"],
750 }
751
752 apex_key {
753 name: "myapex.key",
754 public_key: "testkey.avbpubkey",
755 private_key: "testkey.pem",
756 }
757
758 filegroup {
759 name: "my-file-contexts",
760 srcs: ["product_specific_file_contexts"],
761 }
762 `, withFiles(map[string][]byte{
763 "product_specific_file_contexts": nil,
764 }), android.FixtureModifyProductVariables(
765 func(variables android.FixtureProductVariables) {
766 variables.Unbundled_build = proptools.BoolPtr(true)
767 variables.Always_use_prebuilt_sdks = proptools.BoolPtr(false)
768 }), android.FixtureMergeEnv(map[string]string{
769 "UNBUNDLED_BUILD_TARGET_SDK_WITH_API_FINGERPRINT": "true",
770 }))
771
772 testCases := []struct {
773 module string
774 minSdkVersion string
775 }{
776 {
777 module: "myapex_30",
778 minSdkVersion: "30",
779 },
780 {
781 module: "myapex_current",
782 minSdkVersion: "Q.$$(cat out/soong/api_fingerprint.txt)",
783 },
784 {
785 module: "myapex_none",
786 minSdkVersion: "Q.$$(cat out/soong/api_fingerprint.txt)",
787 },
788 }
789 for _, tc := range testCases {
790 module := ctx.ModuleForTests(tc.module, "android_common_"+tc.module+"_image")
791 args := module.Rule("apexRule").Args
792 optFlags := args["opt_flags"]
793 if !strings.Contains(optFlags, "--min_sdk_version "+tc.minSdkVersion) {
794 t.Errorf("%s: Expected min_sdk_version=%s, got: %s", tc.module, tc.minSdkVersion, optFlags)
795 }
796 }
797}
798
Alex Light5098a612018-11-29 17:12:15 -0800799func TestBasicZipApex(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -0800800 ctx := testApex(t, `
Alex Light5098a612018-11-29 17:12:15 -0800801 apex {
802 name: "myapex",
803 key: "myapex.key",
804 payload_type: "zip",
805 native_shared_libs: ["mylib"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +0000806 updatable: false,
Alex Light5098a612018-11-29 17:12:15 -0800807 }
808
809 apex_key {
810 name: "myapex.key",
811 public_key: "testkey.avbpubkey",
812 private_key: "testkey.pem",
813 }
814
815 cc_library {
816 name: "mylib",
817 srcs: ["mylib.cpp"],
818 shared_libs: ["mylib2"],
819 system_shared_libs: [],
820 stl: "none",
Anton Hanssoneec79eb2020-01-10 15:12:39 +0000821 apex_available: [ "myapex" ],
Alex Light5098a612018-11-29 17:12:15 -0800822 }
823
824 cc_library {
825 name: "mylib2",
826 srcs: ["mylib.cpp"],
827 system_shared_libs: [],
828 stl: "none",
Anton Hanssoneec79eb2020-01-10 15:12:39 +0000829 apex_available: [ "myapex" ],
Alex Light5098a612018-11-29 17:12:15 -0800830 }
831 `)
832
Sundong Ahnabb64432019-10-22 13:58:29 +0900833 zipApexRule := ctx.ModuleForTests("myapex", "android_common_myapex_zip").Rule("zipApexRule")
Alex Light5098a612018-11-29 17:12:15 -0800834 copyCmds := zipApexRule.Args["copy_commands"]
835
836 // Ensure that main rule creates an output
837 ensureContains(t, zipApexRule.Output.String(), "myapex.zipapex.unsigned")
838
839 // Ensure that APEX variant is created for the direct dep
Colin Crossaede88c2020-08-11 12:17:01 -0700840 ensureListContains(t, ctx.ModuleVariantsForTests("mylib"), "android_arm64_armv8-a_shared_apex10000")
Alex Light5098a612018-11-29 17:12:15 -0800841
842 // Ensure that APEX variant is created for the indirect dep
Colin Crossaede88c2020-08-11 12:17:01 -0700843 ensureListContains(t, ctx.ModuleVariantsForTests("mylib2"), "android_arm64_armv8-a_shared_apex10000")
Alex Light5098a612018-11-29 17:12:15 -0800844
845 // Ensure that both direct and indirect deps are copied into apex
846 ensureContains(t, copyCmds, "image.zipapex/lib64/mylib.so")
847 ensureContains(t, copyCmds, "image.zipapex/lib64/mylib2.so")
Jiyong Park25fc6a92018-11-18 18:02:45 +0900848}
849
850func TestApexWithStubs(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -0800851 ctx := testApex(t, `
Jiyong Park25fc6a92018-11-18 18:02:45 +0900852 apex {
853 name: "myapex",
854 key: "myapex.key",
855 native_shared_libs: ["mylib", "mylib3"],
Jiyong Park105dc322021-06-11 17:22:09 +0900856 binaries: ["foo.rust"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +0000857 updatable: false,
Jiyong Park25fc6a92018-11-18 18:02:45 +0900858 }
859
860 apex_key {
861 name: "myapex.key",
862 public_key: "testkey.avbpubkey",
863 private_key: "testkey.pem",
864 }
865
866 cc_library {
867 name: "mylib",
868 srcs: ["mylib.cpp"],
869 shared_libs: ["mylib2", "mylib3"],
870 system_shared_libs: [],
871 stl: "none",
Anton Hanssoneec79eb2020-01-10 15:12:39 +0000872 apex_available: [ "myapex" ],
Jiyong Park25fc6a92018-11-18 18:02:45 +0900873 }
874
875 cc_library {
876 name: "mylib2",
877 srcs: ["mylib.cpp"],
Jiyong Park64379952018-12-13 18:37:29 +0900878 cflags: ["-include mylib.h"],
Jiyong Park25fc6a92018-11-18 18:02:45 +0900879 system_shared_libs: [],
880 stl: "none",
881 stubs: {
882 versions: ["1", "2", "3"],
883 },
884 }
885
886 cc_library {
887 name: "mylib3",
Jiyong Park28d395a2018-12-07 22:42:47 +0900888 srcs: ["mylib.cpp"],
889 shared_libs: ["mylib4"],
890 system_shared_libs: [],
Jiyong Park25fc6a92018-11-18 18:02:45 +0900891 stl: "none",
892 stubs: {
893 versions: ["10", "11", "12"],
894 },
Anton Hanssoneec79eb2020-01-10 15:12:39 +0000895 apex_available: [ "myapex" ],
Jiyong Park25fc6a92018-11-18 18:02:45 +0900896 }
Jiyong Park28d395a2018-12-07 22:42:47 +0900897
898 cc_library {
899 name: "mylib4",
900 srcs: ["mylib.cpp"],
901 system_shared_libs: [],
902 stl: "none",
Anton Hanssoneec79eb2020-01-10 15:12:39 +0000903 apex_available: [ "myapex" ],
Jiyong Park28d395a2018-12-07 22:42:47 +0900904 }
Jiyong Park105dc322021-06-11 17:22:09 +0900905
906 rust_binary {
907 name: "foo.rust",
908 srcs: ["foo.rs"],
909 shared_libs: ["libfoo.shared_from_rust"],
910 prefer_rlib: true,
911 apex_available: ["myapex"],
912 }
913
914 cc_library_shared {
915 name: "libfoo.shared_from_rust",
916 srcs: ["mylib.cpp"],
917 system_shared_libs: [],
918 stl: "none",
919 stubs: {
920 versions: ["10", "11", "12"],
921 },
922 }
923
Jiyong Park25fc6a92018-11-18 18:02:45 +0900924 `)
925
Sundong Ahnabb64432019-10-22 13:58:29 +0900926 apexRule := ctx.ModuleForTests("myapex", "android_common_myapex_image").Rule("apexRule")
Jiyong Park25fc6a92018-11-18 18:02:45 +0900927 copyCmds := apexRule.Args["copy_commands"]
928
929 // Ensure that direct non-stubs dep is always included
Alex Light5098a612018-11-29 17:12:15 -0800930 ensureContains(t, copyCmds, "image.apex/lib64/mylib.so")
Jiyong Park25fc6a92018-11-18 18:02:45 +0900931
932 // Ensure that indirect stubs dep is not included
Alex Light5098a612018-11-29 17:12:15 -0800933 ensureNotContains(t, copyCmds, "image.apex/lib64/mylib2.so")
Jiyong Park25fc6a92018-11-18 18:02:45 +0900934
935 // Ensure that direct stubs dep is included
Alex Light5098a612018-11-29 17:12:15 -0800936 ensureContains(t, copyCmds, "image.apex/lib64/mylib3.so")
Jiyong Park25fc6a92018-11-18 18:02:45 +0900937
Colin Crossaede88c2020-08-11 12:17:01 -0700938 mylibLdFlags := ctx.ModuleForTests("mylib", "android_arm64_armv8-a_shared_apex10000").Rule("ld").Args["libFlags"]
Jiyong Park25fc6a92018-11-18 18:02:45 +0900939
940 // Ensure that mylib is linking with the latest version of stubs for mylib2
Jiyong Parkd4a3a132021-03-17 20:21:35 +0900941 ensureContains(t, mylibLdFlags, "mylib2/android_arm64_armv8-a_shared_current/mylib2.so")
Jiyong Park25fc6a92018-11-18 18:02:45 +0900942 // ... and not linking to the non-stub (impl) variant of mylib2
Jiyong Park3ff16992019-12-27 14:11:47 +0900943 ensureNotContains(t, mylibLdFlags, "mylib2/android_arm64_armv8-a_shared/mylib2.so")
Jiyong Park25fc6a92018-11-18 18:02:45 +0900944
945 // Ensure that mylib is linking with the non-stub (impl) of mylib3 (because mylib3 is in the same apex)
Colin Crossaede88c2020-08-11 12:17:01 -0700946 ensureContains(t, mylibLdFlags, "mylib3/android_arm64_armv8-a_shared_apex10000/mylib3.so")
Jiyong Park25fc6a92018-11-18 18:02:45 +0900947 // .. and not linking to the stubs variant of mylib3
Colin Crossaede88c2020-08-11 12:17:01 -0700948 ensureNotContains(t, mylibLdFlags, "mylib3/android_arm64_armv8-a_shared_12/mylib3.so")
Jiyong Park64379952018-12-13 18:37:29 +0900949
Chih-Hung Hsiehb8082292021-09-09 23:20:39 -0700950 // Comment out this test. Now it fails after the optimization of sharing "cflags" in cc/cc.go
951 // is replaced by sharing of "cFlags" in cc/builder.go.
952 // The "cflags" contains "-include mylib.h", but cFlags contained only a reference to the
953 // module variable representing "cflags". So it was not detected by ensureNotContains.
954 // Now "cFlags" is a reference to a module variable like $flags1, which includes all previous
955 // content of "cflags". ModuleForTests...Args["cFlags"] returns the full string of $flags1,
956 // including the original cflags's "-include mylib.h".
957 //
Jiyong Park64379952018-12-13 18:37:29 +0900958 // Ensure that stubs libs are built without -include flags
Chih-Hung Hsiehb8082292021-09-09 23:20:39 -0700959 // mylib2Cflags := ctx.ModuleForTests("mylib2", "android_arm64_armv8-a_static").Rule("cc").Args["cFlags"]
960 // ensureNotContains(t, mylib2Cflags, "-include ")
Jiyong Park3fd0baf2018-12-07 16:25:39 +0900961
962 // Ensure that genstub is invoked with --apex
Colin Crossa717db72020-10-23 14:53:06 -0700963 ensureContains(t, "--apex", ctx.ModuleForTests("mylib2", "android_arm64_armv8-a_shared_3").Rule("genStubSrc").Args["flags"])
Jooyung Han671f1ce2019-12-17 12:47:13 +0900964
Jooyung Hana57af4a2020-01-23 05:36:59 +0000965 ensureExactContents(t, ctx, "myapex", "android_common_myapex_image", []string{
Jooyung Han671f1ce2019-12-17 12:47:13 +0900966 "lib64/mylib.so",
967 "lib64/mylib3.so",
968 "lib64/mylib4.so",
Jiyong Park105dc322021-06-11 17:22:09 +0900969 "bin/foo.rust",
970 "lib64/libc++.so", // by the implicit dependency from foo.rust
971 "lib64/liblog.so", // by the implicit dependency from foo.rust
Jooyung Han671f1ce2019-12-17 12:47:13 +0900972 })
Jiyong Park105dc322021-06-11 17:22:09 +0900973
974 // Ensure that stub dependency from a rust module is not included
975 ensureNotContains(t, copyCmds, "image.apex/lib64/libfoo.shared_from_rust.so")
976 // The rust module is linked to the stub cc library
977 rustDeps := ctx.ModuleForTests("foo.rust", "android_arm64_armv8-a_apex10000").Rule("rustc").Args["linkFlags"]
978 ensureContains(t, rustDeps, "libfoo.shared_from_rust/android_arm64_armv8-a_shared_current/libfoo.shared_from_rust.so")
979 ensureNotContains(t, rustDeps, "libfoo.shared_from_rust/android_arm64_armv8-a_shared/libfoo.shared_from_rust.so")
Jiyong Park34d5c332022-02-24 18:02:44 +0900980
981 apexManifestRule := ctx.ModuleForTests("myapex", "android_common_myapex_image").Rule("apexManifestRule")
982 ensureListContains(t, names(apexManifestRule.Args["requireNativeLibs"]), "libfoo.shared_from_rust.so")
Jiyong Park25fc6a92018-11-18 18:02:45 +0900983}
984
Jiyong Park1bc84122021-06-22 20:23:05 +0900985func TestApexCanUsePrivateApis(t *testing.T) {
986 ctx := testApex(t, `
987 apex {
988 name: "myapex",
989 key: "myapex.key",
990 native_shared_libs: ["mylib"],
991 binaries: ["foo.rust"],
992 updatable: false,
993 platform_apis: true,
994 }
995
996 apex_key {
997 name: "myapex.key",
998 public_key: "testkey.avbpubkey",
999 private_key: "testkey.pem",
1000 }
1001
1002 cc_library {
1003 name: "mylib",
1004 srcs: ["mylib.cpp"],
1005 shared_libs: ["mylib2"],
1006 system_shared_libs: [],
1007 stl: "none",
1008 apex_available: [ "myapex" ],
1009 }
1010
1011 cc_library {
1012 name: "mylib2",
1013 srcs: ["mylib.cpp"],
1014 cflags: ["-include mylib.h"],
1015 system_shared_libs: [],
1016 stl: "none",
1017 stubs: {
1018 versions: ["1", "2", "3"],
1019 },
1020 }
1021
1022 rust_binary {
1023 name: "foo.rust",
1024 srcs: ["foo.rs"],
1025 shared_libs: ["libfoo.shared_from_rust"],
1026 prefer_rlib: true,
1027 apex_available: ["myapex"],
1028 }
1029
1030 cc_library_shared {
1031 name: "libfoo.shared_from_rust",
1032 srcs: ["mylib.cpp"],
1033 system_shared_libs: [],
1034 stl: "none",
1035 stubs: {
1036 versions: ["10", "11", "12"],
1037 },
1038 }
1039 `)
1040
1041 apexRule := ctx.ModuleForTests("myapex", "android_common_myapex_image").Rule("apexRule")
1042 copyCmds := apexRule.Args["copy_commands"]
1043
1044 // Ensure that indirect stubs dep is not included
1045 ensureNotContains(t, copyCmds, "image.apex/lib64/mylib2.so")
1046 ensureNotContains(t, copyCmds, "image.apex/lib64/libfoo.shared_from_rust.so")
1047
1048 // Ensure that we are using non-stub variants of mylib2 and libfoo.shared_from_rust (because
1049 // of the platform_apis: true)
1050 mylibLdFlags := ctx.ModuleForTests("mylib", "android_arm64_armv8-a_shared_apex10000_private").Rule("ld").Args["libFlags"]
1051 ensureNotContains(t, mylibLdFlags, "mylib2/android_arm64_armv8-a_shared_current/mylib2.so")
1052 ensureContains(t, mylibLdFlags, "mylib2/android_arm64_armv8-a_shared/mylib2.so")
1053 rustDeps := ctx.ModuleForTests("foo.rust", "android_arm64_armv8-a_apex10000_private").Rule("rustc").Args["linkFlags"]
1054 ensureNotContains(t, rustDeps, "libfoo.shared_from_rust/android_arm64_armv8-a_shared_current/libfoo.shared_from_rust.so")
1055 ensureContains(t, rustDeps, "libfoo.shared_from_rust/android_arm64_armv8-a_shared/libfoo.shared_from_rust.so")
1056}
1057
Colin Cross7812fd32020-09-25 12:35:10 -07001058func TestApexWithStubsWithMinSdkVersion(t *testing.T) {
1059 t.Parallel()
Colin Cross1c460562021-02-16 17:55:47 -08001060 ctx := testApex(t, `
Colin Cross7812fd32020-09-25 12:35:10 -07001061 apex {
1062 name: "myapex",
1063 key: "myapex.key",
1064 native_shared_libs: ["mylib", "mylib3"],
1065 min_sdk_version: "29",
1066 }
1067
1068 apex_key {
1069 name: "myapex.key",
1070 public_key: "testkey.avbpubkey",
1071 private_key: "testkey.pem",
1072 }
1073
1074 cc_library {
1075 name: "mylib",
1076 srcs: ["mylib.cpp"],
1077 shared_libs: ["mylib2", "mylib3"],
1078 system_shared_libs: [],
1079 stl: "none",
1080 apex_available: [ "myapex" ],
1081 min_sdk_version: "28",
1082 }
1083
1084 cc_library {
1085 name: "mylib2",
1086 srcs: ["mylib.cpp"],
1087 cflags: ["-include mylib.h"],
1088 system_shared_libs: [],
1089 stl: "none",
1090 stubs: {
1091 versions: ["28", "29", "30", "current"],
1092 },
1093 min_sdk_version: "28",
1094 }
1095
1096 cc_library {
1097 name: "mylib3",
1098 srcs: ["mylib.cpp"],
1099 shared_libs: ["mylib4"],
1100 system_shared_libs: [],
1101 stl: "none",
1102 stubs: {
1103 versions: ["28", "29", "30", "current"],
1104 },
1105 apex_available: [ "myapex" ],
1106 min_sdk_version: "28",
1107 }
1108
1109 cc_library {
1110 name: "mylib4",
1111 srcs: ["mylib.cpp"],
1112 system_shared_libs: [],
1113 stl: "none",
1114 apex_available: [ "myapex" ],
1115 min_sdk_version: "28",
1116 }
1117 `)
1118
1119 apexRule := ctx.ModuleForTests("myapex", "android_common_myapex_image").Rule("apexRule")
1120 copyCmds := apexRule.Args["copy_commands"]
1121
1122 // Ensure that direct non-stubs dep is always included
1123 ensureContains(t, copyCmds, "image.apex/lib64/mylib.so")
1124
1125 // Ensure that indirect stubs dep is not included
1126 ensureNotContains(t, copyCmds, "image.apex/lib64/mylib2.so")
1127
1128 // Ensure that direct stubs dep is included
1129 ensureContains(t, copyCmds, "image.apex/lib64/mylib3.so")
1130
1131 mylibLdFlags := ctx.ModuleForTests("mylib", "android_arm64_armv8-a_shared_apex29").Rule("ld").Args["libFlags"]
1132
Jiyong Park55549df2021-02-26 23:57:23 +09001133 // Ensure that mylib is linking with the latest version of stub for mylib2
1134 ensureContains(t, mylibLdFlags, "mylib2/android_arm64_armv8-a_shared_current/mylib2.so")
Colin Cross7812fd32020-09-25 12:35:10 -07001135 // ... and not linking to the non-stub (impl) variant of mylib2
1136 ensureNotContains(t, mylibLdFlags, "mylib2/android_arm64_armv8-a_shared/mylib2.so")
1137
1138 // Ensure that mylib is linking with the non-stub (impl) of mylib3 (because mylib3 is in the same apex)
1139 ensureContains(t, mylibLdFlags, "mylib3/android_arm64_armv8-a_shared_apex29/mylib3.so")
1140 // .. and not linking to the stubs variant of mylib3
1141 ensureNotContains(t, mylibLdFlags, "mylib3/android_arm64_armv8-a_shared_29/mylib3.so")
1142
1143 // Ensure that stubs libs are built without -include flags
Colin Crossa717db72020-10-23 14:53:06 -07001144 mylib2Cflags := ctx.ModuleForTests("mylib2", "android_arm64_armv8-a_shared_29").Rule("cc").Args["cFlags"]
Colin Cross7812fd32020-09-25 12:35:10 -07001145 ensureNotContains(t, mylib2Cflags, "-include ")
1146
1147 // Ensure that genstub is invoked with --apex
Colin Crossa717db72020-10-23 14:53:06 -07001148 ensureContains(t, "--apex", ctx.ModuleForTests("mylib2", "android_arm64_armv8-a_shared_29").Rule("genStubSrc").Args["flags"])
Colin Cross7812fd32020-09-25 12:35:10 -07001149
1150 ensureExactContents(t, ctx, "myapex", "android_common_myapex_image", []string{
1151 "lib64/mylib.so",
1152 "lib64/mylib3.so",
1153 "lib64/mylib4.so",
1154 })
1155}
1156
Jooyung Han11b0fbd2021-02-05 02:28:22 +09001157func TestApex_PlatformUsesLatestStubFromApex(t *testing.T) {
1158 t.Parallel()
1159 // myapex (Z)
1160 // mylib -----------------.
1161 // |
1162 // otherapex (29) |
1163 // libstub's versions: 29 Z current
1164 // |
1165 // <platform> |
1166 // libplatform ----------------'
Colin Cross1c460562021-02-16 17:55:47 -08001167 ctx := testApex(t, `
Jooyung Han11b0fbd2021-02-05 02:28:22 +09001168 apex {
1169 name: "myapex",
1170 key: "myapex.key",
1171 native_shared_libs: ["mylib"],
1172 min_sdk_version: "Z", // non-final
1173 }
1174
1175 cc_library {
1176 name: "mylib",
1177 srcs: ["mylib.cpp"],
1178 shared_libs: ["libstub"],
1179 apex_available: ["myapex"],
1180 min_sdk_version: "Z",
1181 }
1182
1183 apex_key {
1184 name: "myapex.key",
1185 public_key: "testkey.avbpubkey",
1186 private_key: "testkey.pem",
1187 }
1188
1189 apex {
1190 name: "otherapex",
1191 key: "myapex.key",
1192 native_shared_libs: ["libstub"],
1193 min_sdk_version: "29",
1194 }
1195
1196 cc_library {
1197 name: "libstub",
1198 srcs: ["mylib.cpp"],
1199 stubs: {
1200 versions: ["29", "Z", "current"],
1201 },
1202 apex_available: ["otherapex"],
1203 min_sdk_version: "29",
1204 }
1205
1206 // platform module depending on libstub from otherapex should use the latest stub("current")
1207 cc_library {
1208 name: "libplatform",
1209 srcs: ["mylib.cpp"],
1210 shared_libs: ["libstub"],
1211 }
Paul Duffin0a49fdc2021-03-08 11:28:25 +00001212 `,
1213 android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
1214 variables.Platform_sdk_codename = proptools.StringPtr("Z")
1215 variables.Platform_sdk_final = proptools.BoolPtr(false)
1216 variables.Platform_version_active_codenames = []string{"Z"}
1217 }),
1218 )
Jooyung Han11b0fbd2021-02-05 02:28:22 +09001219
Jiyong Park55549df2021-02-26 23:57:23 +09001220 // Ensure that mylib from myapex is built against the latest stub (current)
Jooyung Han11b0fbd2021-02-05 02:28:22 +09001221 mylibCflags := ctx.ModuleForTests("mylib", "android_arm64_armv8-a_static_apex10000").Rule("cc").Args["cFlags"]
Jiyong Park55549df2021-02-26 23:57:23 +09001222 ensureContains(t, mylibCflags, "-D__LIBSTUB_API__=10000 ")
Jooyung Han11b0fbd2021-02-05 02:28:22 +09001223 mylibLdflags := ctx.ModuleForTests("mylib", "android_arm64_armv8-a_shared_apex10000").Rule("ld").Args["libFlags"]
Jiyong Park55549df2021-02-26 23:57:23 +09001224 ensureContains(t, mylibLdflags, "libstub/android_arm64_armv8-a_shared_current/libstub.so ")
Jooyung Han11b0fbd2021-02-05 02:28:22 +09001225
1226 // Ensure that libplatform is built against latest stub ("current") of mylib3 from the apex
1227 libplatformCflags := ctx.ModuleForTests("libplatform", "android_arm64_armv8-a_static").Rule("cc").Args["cFlags"]
1228 ensureContains(t, libplatformCflags, "-D__LIBSTUB_API__=10000 ") // "current" maps to 10000
1229 libplatformLdflags := ctx.ModuleForTests("libplatform", "android_arm64_armv8-a_shared").Rule("ld").Args["libFlags"]
1230 ensureContains(t, libplatformLdflags, "libstub/android_arm64_armv8-a_shared_current/libstub.so ")
1231}
1232
Jiyong Park0ddfcd12018-12-11 01:35:25 +09001233func TestApexWithExplicitStubsDependency(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08001234 ctx := testApex(t, `
Jiyong Park0ddfcd12018-12-11 01:35:25 +09001235 apex {
Jiyong Park83dc74b2020-01-14 18:38:44 +09001236 name: "myapex2",
1237 key: "myapex2.key",
Jiyong Park0ddfcd12018-12-11 01:35:25 +09001238 native_shared_libs: ["mylib"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00001239 updatable: false,
Jiyong Park0ddfcd12018-12-11 01:35:25 +09001240 }
1241
1242 apex_key {
Jiyong Park83dc74b2020-01-14 18:38:44 +09001243 name: "myapex2.key",
Jiyong Park0ddfcd12018-12-11 01:35:25 +09001244 public_key: "testkey.avbpubkey",
1245 private_key: "testkey.pem",
1246 }
1247
1248 cc_library {
1249 name: "mylib",
1250 srcs: ["mylib.cpp"],
1251 shared_libs: ["libfoo#10"],
Jiyong Park678c8812020-02-07 17:25:49 +09001252 static_libs: ["libbaz"],
Jiyong Park0ddfcd12018-12-11 01:35:25 +09001253 system_shared_libs: [],
1254 stl: "none",
Anton Hanssoneec79eb2020-01-10 15:12:39 +00001255 apex_available: [ "myapex2" ],
Jiyong Park0ddfcd12018-12-11 01:35:25 +09001256 }
1257
1258 cc_library {
1259 name: "libfoo",
1260 srcs: ["mylib.cpp"],
1261 shared_libs: ["libbar"],
1262 system_shared_libs: [],
1263 stl: "none",
1264 stubs: {
1265 versions: ["10", "20", "30"],
1266 },
1267 }
1268
1269 cc_library {
1270 name: "libbar",
1271 srcs: ["mylib.cpp"],
1272 system_shared_libs: [],
1273 stl: "none",
1274 }
1275
Jiyong Park678c8812020-02-07 17:25:49 +09001276 cc_library_static {
1277 name: "libbaz",
1278 srcs: ["mylib.cpp"],
1279 system_shared_libs: [],
1280 stl: "none",
1281 apex_available: [ "myapex2" ],
1282 }
1283
Jiyong Park0ddfcd12018-12-11 01:35:25 +09001284 `)
1285
Jiyong Park83dc74b2020-01-14 18:38:44 +09001286 apexRule := ctx.ModuleForTests("myapex2", "android_common_myapex2_image").Rule("apexRule")
Jiyong Park0ddfcd12018-12-11 01:35:25 +09001287 copyCmds := apexRule.Args["copy_commands"]
1288
1289 // Ensure that direct non-stubs dep is always included
1290 ensureContains(t, copyCmds, "image.apex/lib64/mylib.so")
1291
1292 // Ensure that indirect stubs dep is not included
1293 ensureNotContains(t, copyCmds, "image.apex/lib64/libfoo.so")
1294
1295 // Ensure that dependency of stubs is not included
1296 ensureNotContains(t, copyCmds, "image.apex/lib64/libbar.so")
1297
Colin Crossaede88c2020-08-11 12:17:01 -07001298 mylibLdFlags := ctx.ModuleForTests("mylib", "android_arm64_armv8-a_shared_apex10000").Rule("ld").Args["libFlags"]
Jiyong Park0ddfcd12018-12-11 01:35:25 +09001299
1300 // Ensure that mylib is linking with version 10 of libfoo
Jiyong Park3ff16992019-12-27 14:11:47 +09001301 ensureContains(t, mylibLdFlags, "libfoo/android_arm64_armv8-a_shared_10/libfoo.so")
Jiyong Park0ddfcd12018-12-11 01:35:25 +09001302 // ... and not linking to the non-stub (impl) variant of libfoo
Jiyong Park3ff16992019-12-27 14:11:47 +09001303 ensureNotContains(t, mylibLdFlags, "libfoo/android_arm64_armv8-a_shared/libfoo.so")
Jiyong Park0ddfcd12018-12-11 01:35:25 +09001304
Jiyong Park3ff16992019-12-27 14:11:47 +09001305 libFooStubsLdFlags := ctx.ModuleForTests("libfoo", "android_arm64_armv8-a_shared_10").Rule("ld").Args["libFlags"]
Jiyong Park0ddfcd12018-12-11 01:35:25 +09001306
1307 // Ensure that libfoo stubs is not linking to libbar (since it is a stubs)
1308 ensureNotContains(t, libFooStubsLdFlags, "libbar.so")
Jiyong Park83dc74b2020-01-14 18:38:44 +09001309
Artur Satayeva8bd1132020-04-27 18:07:06 +01001310 fullDepsInfo := strings.Split(ctx.ModuleForTests("myapex2", "android_common_myapex2_image").Output("depsinfo/fulllist.txt").Args["content"], "\\n")
Artur Satayev4e1f2bd2020-05-14 15:15:01 +01001311 ensureListContains(t, fullDepsInfo, " libfoo(minSdkVersion:(no version)) (external) <- mylib")
Jiyong Park678c8812020-02-07 17:25:49 +09001312
Artur Satayeva8bd1132020-04-27 18:07:06 +01001313 flatDepsInfo := strings.Split(ctx.ModuleForTests("myapex2", "android_common_myapex2_image").Output("depsinfo/flatlist.txt").Args["content"], "\\n")
Artur Satayev4e1f2bd2020-05-14 15:15:01 +01001314 ensureListContains(t, flatDepsInfo, "libfoo(minSdkVersion:(no version)) (external)")
Jiyong Park0ddfcd12018-12-11 01:35:25 +09001315}
1316
Jooyung Hand3639552019-08-09 12:57:43 +09001317func TestApexWithRuntimeLibsDependency(t *testing.T) {
1318 /*
1319 myapex
1320 |
1321 v (runtime_libs)
1322 mylib ------+------> libfoo [provides stub]
1323 |
1324 `------> libbar
1325 */
Colin Cross1c460562021-02-16 17:55:47 -08001326 ctx := testApex(t, `
Jooyung Hand3639552019-08-09 12:57:43 +09001327 apex {
1328 name: "myapex",
1329 key: "myapex.key",
1330 native_shared_libs: ["mylib"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00001331 updatable: false,
Jooyung Hand3639552019-08-09 12:57:43 +09001332 }
1333
1334 apex_key {
1335 name: "myapex.key",
1336 public_key: "testkey.avbpubkey",
1337 private_key: "testkey.pem",
1338 }
1339
1340 cc_library {
1341 name: "mylib",
1342 srcs: ["mylib.cpp"],
1343 runtime_libs: ["libfoo", "libbar"],
1344 system_shared_libs: [],
1345 stl: "none",
Anton Hanssoneec79eb2020-01-10 15:12:39 +00001346 apex_available: [ "myapex" ],
Jooyung Hand3639552019-08-09 12:57:43 +09001347 }
1348
1349 cc_library {
1350 name: "libfoo",
1351 srcs: ["mylib.cpp"],
1352 system_shared_libs: [],
1353 stl: "none",
1354 stubs: {
1355 versions: ["10", "20", "30"],
1356 },
1357 }
1358
1359 cc_library {
1360 name: "libbar",
1361 srcs: ["mylib.cpp"],
1362 system_shared_libs: [],
1363 stl: "none",
Anton Hanssoneec79eb2020-01-10 15:12:39 +00001364 apex_available: [ "myapex" ],
Jooyung Hand3639552019-08-09 12:57:43 +09001365 }
1366
1367 `)
1368
Sundong Ahnabb64432019-10-22 13:58:29 +09001369 apexRule := ctx.ModuleForTests("myapex", "android_common_myapex_image").Rule("apexRule")
Jooyung Hand3639552019-08-09 12:57:43 +09001370 copyCmds := apexRule.Args["copy_commands"]
1371
1372 // Ensure that direct non-stubs dep is always included
1373 ensureContains(t, copyCmds, "image.apex/lib64/mylib.so")
1374
1375 // Ensure that indirect stubs dep is not included
1376 ensureNotContains(t, copyCmds, "image.apex/lib64/libfoo.so")
1377
1378 // Ensure that runtime_libs dep in included
1379 ensureContains(t, copyCmds, "image.apex/lib64/libbar.so")
1380
Sundong Ahnabb64432019-10-22 13:58:29 +09001381 apexManifestRule := ctx.ModuleForTests("myapex", "android_common_myapex_image").Rule("apexManifestRule")
Jooyung Hand15aa1f2019-09-27 00:38:03 +09001382 ensureListEmpty(t, names(apexManifestRule.Args["provideNativeLibs"]))
1383 ensureListContains(t, names(apexManifestRule.Args["requireNativeLibs"]), "libfoo.so")
Jooyung Hand3639552019-08-09 12:57:43 +09001384
1385}
1386
Paul Duffina02cae32021-03-09 01:44:06 +00001387var prepareForTestOfRuntimeApexWithHwasan = android.GroupFixturePreparers(
1388 cc.PrepareForTestWithCcBuildComponents,
1389 PrepareForTestWithApexBuildComponents,
1390 android.FixtureAddTextFile("bionic/apex/Android.bp", `
Jooyung Han8ce8db92020-05-15 19:05:05 +09001391 apex {
1392 name: "com.android.runtime",
1393 key: "com.android.runtime.key",
1394 native_shared_libs: ["libc"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00001395 updatable: false,
Jooyung Han8ce8db92020-05-15 19:05:05 +09001396 }
1397
1398 apex_key {
1399 name: "com.android.runtime.key",
1400 public_key: "testkey.avbpubkey",
1401 private_key: "testkey.pem",
1402 }
Paul Duffina02cae32021-03-09 01:44:06 +00001403 `),
1404 android.FixtureAddFile("system/sepolicy/apex/com.android.runtime-file_contexts", nil),
1405)
Jooyung Han8ce8db92020-05-15 19:05:05 +09001406
Paul Duffina02cae32021-03-09 01:44:06 +00001407func TestRuntimeApexShouldInstallHwasanIfLibcDependsOnIt(t *testing.T) {
Paul Duffin70d3bee2021-03-21 11:26:05 +00001408 result := android.GroupFixturePreparers(prepareForTestOfRuntimeApexWithHwasan).RunTestWithBp(t, `
Jooyung Han8ce8db92020-05-15 19:05:05 +09001409 cc_library {
1410 name: "libc",
1411 no_libcrt: true,
1412 nocrt: true,
1413 stl: "none",
1414 system_shared_libs: [],
1415 stubs: { versions: ["1"] },
1416 apex_available: ["com.android.runtime"],
1417
1418 sanitize: {
1419 hwaddress: true,
1420 }
1421 }
1422
1423 cc_prebuilt_library_shared {
Colin Cross4c4c1be2022-02-10 11:41:18 -08001424 name: "libclang_rt.hwasan",
Jooyung Han8ce8db92020-05-15 19:05:05 +09001425 no_libcrt: true,
1426 nocrt: true,
1427 stl: "none",
1428 system_shared_libs: [],
1429 srcs: [""],
1430 stubs: { versions: ["1"] },
Colin Cross4c4c1be2022-02-10 11:41:18 -08001431 stem: "libclang_rt.hwasan-aarch64-android",
Jooyung Han8ce8db92020-05-15 19:05:05 +09001432
1433 sanitize: {
1434 never: true,
1435 },
Paul Duffina02cae32021-03-09 01:44:06 +00001436 } `)
1437 ctx := result.TestContext
Jooyung Han8ce8db92020-05-15 19:05:05 +09001438
1439 ensureExactContents(t, ctx, "com.android.runtime", "android_common_hwasan_com.android.runtime_image", []string{
1440 "lib64/bionic/libc.so",
1441 "lib64/bionic/libclang_rt.hwasan-aarch64-android.so",
1442 })
1443
Colin Cross4c4c1be2022-02-10 11:41:18 -08001444 hwasan := ctx.ModuleForTests("libclang_rt.hwasan", "android_arm64_armv8-a_shared")
Jooyung Han8ce8db92020-05-15 19:05:05 +09001445
1446 installed := hwasan.Description("install libclang_rt.hwasan")
1447 ensureContains(t, installed.Output.String(), "/system/lib64/bootstrap/libclang_rt.hwasan-aarch64-android.so")
1448
1449 symlink := hwasan.Description("install symlink libclang_rt.hwasan")
1450 ensureEquals(t, symlink.Args["fromPath"], "/apex/com.android.runtime/lib64/bionic/libclang_rt.hwasan-aarch64-android.so")
1451 ensureContains(t, symlink.Output.String(), "/system/lib64/libclang_rt.hwasan-aarch64-android.so")
1452}
1453
1454func TestRuntimeApexShouldInstallHwasanIfHwaddressSanitized(t *testing.T) {
Paul Duffin70d3bee2021-03-21 11:26:05 +00001455 result := android.GroupFixturePreparers(
Paul Duffina02cae32021-03-09 01:44:06 +00001456 prepareForTestOfRuntimeApexWithHwasan,
1457 android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
1458 variables.SanitizeDevice = []string{"hwaddress"}
1459 }),
1460 ).RunTestWithBp(t, `
Jooyung Han8ce8db92020-05-15 19:05:05 +09001461 cc_library {
1462 name: "libc",
1463 no_libcrt: true,
1464 nocrt: true,
1465 stl: "none",
1466 system_shared_libs: [],
1467 stubs: { versions: ["1"] },
1468 apex_available: ["com.android.runtime"],
1469 }
1470
1471 cc_prebuilt_library_shared {
Colin Cross4c4c1be2022-02-10 11:41:18 -08001472 name: "libclang_rt.hwasan",
Jooyung Han8ce8db92020-05-15 19:05:05 +09001473 no_libcrt: true,
1474 nocrt: true,
1475 stl: "none",
1476 system_shared_libs: [],
1477 srcs: [""],
1478 stubs: { versions: ["1"] },
Colin Cross4c4c1be2022-02-10 11:41:18 -08001479 stem: "libclang_rt.hwasan-aarch64-android",
Jooyung Han8ce8db92020-05-15 19:05:05 +09001480
1481 sanitize: {
1482 never: true,
1483 },
1484 }
Paul Duffina02cae32021-03-09 01:44:06 +00001485 `)
1486 ctx := result.TestContext
Jooyung Han8ce8db92020-05-15 19:05:05 +09001487
1488 ensureExactContents(t, ctx, "com.android.runtime", "android_common_hwasan_com.android.runtime_image", []string{
1489 "lib64/bionic/libc.so",
1490 "lib64/bionic/libclang_rt.hwasan-aarch64-android.so",
1491 })
1492
Colin Cross4c4c1be2022-02-10 11:41:18 -08001493 hwasan := ctx.ModuleForTests("libclang_rt.hwasan", "android_arm64_armv8-a_shared")
Jooyung Han8ce8db92020-05-15 19:05:05 +09001494
1495 installed := hwasan.Description("install libclang_rt.hwasan")
1496 ensureContains(t, installed.Output.String(), "/system/lib64/bootstrap/libclang_rt.hwasan-aarch64-android.so")
1497
1498 symlink := hwasan.Description("install symlink libclang_rt.hwasan")
1499 ensureEquals(t, symlink.Args["fromPath"], "/apex/com.android.runtime/lib64/bionic/libclang_rt.hwasan-aarch64-android.so")
1500 ensureContains(t, symlink.Output.String(), "/system/lib64/libclang_rt.hwasan-aarch64-android.so")
1501}
1502
Jooyung Han61b66e92020-03-21 14:21:46 +00001503func TestApexDependsOnLLNDKTransitively(t *testing.T) {
1504 testcases := []struct {
1505 name string
1506 minSdkVersion string
Colin Crossaede88c2020-08-11 12:17:01 -07001507 apexVariant string
Jooyung Han61b66e92020-03-21 14:21:46 +00001508 shouldLink string
1509 shouldNotLink []string
1510 }{
1511 {
Jiyong Park55549df2021-02-26 23:57:23 +09001512 name: "unspecified version links to the latest",
Jooyung Han749dc692020-04-15 11:03:39 +09001513 minSdkVersion: "",
Colin Crossaede88c2020-08-11 12:17:01 -07001514 apexVariant: "apex10000",
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001515 shouldLink: "current",
1516 shouldNotLink: []string{"29", "30"},
Jooyung Han61b66e92020-03-21 14:21:46 +00001517 },
1518 {
Jiyong Park55549df2021-02-26 23:57:23 +09001519 name: "always use the latest",
Jooyung Han749dc692020-04-15 11:03:39 +09001520 minSdkVersion: "min_sdk_version: \"29\",",
Colin Crossaede88c2020-08-11 12:17:01 -07001521 apexVariant: "apex29",
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001522 shouldLink: "current",
1523 shouldNotLink: []string{"29", "30"},
Jooyung Han61b66e92020-03-21 14:21:46 +00001524 },
1525 }
1526 for _, tc := range testcases {
1527 t.Run(tc.name, func(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08001528 ctx := testApex(t, `
Jooyung Han61b66e92020-03-21 14:21:46 +00001529 apex {
1530 name: "myapex",
1531 key: "myapex.key",
Jooyung Han61b66e92020-03-21 14:21:46 +00001532 native_shared_libs: ["mylib"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00001533 updatable: false,
Jooyung Han749dc692020-04-15 11:03:39 +09001534 `+tc.minSdkVersion+`
Jooyung Han61b66e92020-03-21 14:21:46 +00001535 }
Jooyung Han9c80bae2019-08-20 17:30:57 +09001536
Jooyung Han61b66e92020-03-21 14:21:46 +00001537 apex_key {
1538 name: "myapex.key",
1539 public_key: "testkey.avbpubkey",
1540 private_key: "testkey.pem",
1541 }
Jooyung Han9c80bae2019-08-20 17:30:57 +09001542
Jooyung Han61b66e92020-03-21 14:21:46 +00001543 cc_library {
1544 name: "mylib",
1545 srcs: ["mylib.cpp"],
1546 vendor_available: true,
1547 shared_libs: ["libbar"],
1548 system_shared_libs: [],
1549 stl: "none",
1550 apex_available: [ "myapex" ],
Jooyung Han749dc692020-04-15 11:03:39 +09001551 min_sdk_version: "29",
Jooyung Han61b66e92020-03-21 14:21:46 +00001552 }
Jooyung Han9c80bae2019-08-20 17:30:57 +09001553
Jooyung Han61b66e92020-03-21 14:21:46 +00001554 cc_library {
1555 name: "libbar",
1556 srcs: ["mylib.cpp"],
1557 system_shared_libs: [],
1558 stl: "none",
1559 stubs: { versions: ["29","30"] },
Colin Cross203b4212021-04-26 17:19:41 -07001560 llndk: {
1561 symbol_file: "libbar.map.txt",
1562 }
Jooyung Han61b66e92020-03-21 14:21:46 +00001563 }
Paul Duffin0a49fdc2021-03-08 11:28:25 +00001564 `,
Paul Duffin0a49fdc2021-03-08 11:28:25 +00001565 withUnbundledBuild,
1566 )
Jooyung Han9c80bae2019-08-20 17:30:57 +09001567
Jooyung Han61b66e92020-03-21 14:21:46 +00001568 // Ensure that LLNDK dep is not included
1569 ensureExactContents(t, ctx, "myapex", "android_common_myapex_image", []string{
1570 "lib64/mylib.so",
1571 })
Jooyung Han9c80bae2019-08-20 17:30:57 +09001572
Jooyung Han61b66e92020-03-21 14:21:46 +00001573 // Ensure that LLNDK dep is required
1574 apexManifestRule := ctx.ModuleForTests("myapex", "android_common_myapex_image").Rule("apexManifestRule")
1575 ensureListEmpty(t, names(apexManifestRule.Args["provideNativeLibs"]))
1576 ensureListContains(t, names(apexManifestRule.Args["requireNativeLibs"]), "libbar.so")
Jooyung Han9c80bae2019-08-20 17:30:57 +09001577
Steven Moreland2c4000c2021-04-27 02:08:49 +00001578 mylibLdFlags := ctx.ModuleForTests("mylib", "android_arm64_armv8-a_shared_"+tc.apexVariant).Rule("ld").Args["libFlags"]
1579 ensureContains(t, mylibLdFlags, "libbar/android_arm64_armv8-a_shared_"+tc.shouldLink+"/libbar.so")
Jooyung Han61b66e92020-03-21 14:21:46 +00001580 for _, ver := range tc.shouldNotLink {
Steven Moreland2c4000c2021-04-27 02:08:49 +00001581 ensureNotContains(t, mylibLdFlags, "libbar/android_arm64_armv8-a_shared_"+ver+"/libbar.so")
Jooyung Han61b66e92020-03-21 14:21:46 +00001582 }
Jooyung Han9c80bae2019-08-20 17:30:57 +09001583
Steven Moreland2c4000c2021-04-27 02:08:49 +00001584 mylibCFlags := ctx.ModuleForTests("mylib", "android_arm64_armv8-a_static_"+tc.apexVariant).Rule("cc").Args["cFlags"]
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001585 ver := tc.shouldLink
1586 if tc.shouldLink == "current" {
1587 ver = strconv.Itoa(android.FutureApiLevelInt)
1588 }
1589 ensureContains(t, mylibCFlags, "__LIBBAR_API__="+ver)
Jooyung Han61b66e92020-03-21 14:21:46 +00001590 })
1591 }
Jooyung Han9c80bae2019-08-20 17:30:57 +09001592}
1593
Jiyong Park25fc6a92018-11-18 18:02:45 +09001594func TestApexWithSystemLibsStubs(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08001595 ctx := testApex(t, `
Jiyong Park25fc6a92018-11-18 18:02:45 +09001596 apex {
1597 name: "myapex",
1598 key: "myapex.key",
1599 native_shared_libs: ["mylib", "mylib_shared", "libdl", "libm"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00001600 updatable: false,
Jiyong Park25fc6a92018-11-18 18:02:45 +09001601 }
1602
1603 apex_key {
1604 name: "myapex.key",
1605 public_key: "testkey.avbpubkey",
1606 private_key: "testkey.pem",
1607 }
1608
1609 cc_library {
1610 name: "mylib",
1611 srcs: ["mylib.cpp"],
Colin Cross0de8a1e2020-09-18 14:15:30 -07001612 system_shared_libs: ["libc", "libm"],
Jiyong Park25fc6a92018-11-18 18:02:45 +09001613 shared_libs: ["libdl#27"],
1614 stl: "none",
Anton Hanssoneec79eb2020-01-10 15:12:39 +00001615 apex_available: [ "myapex" ],
Jiyong Park25fc6a92018-11-18 18:02:45 +09001616 }
1617
1618 cc_library_shared {
1619 name: "mylib_shared",
1620 srcs: ["mylib.cpp"],
1621 shared_libs: ["libdl#27"],
1622 stl: "none",
Anton Hanssoneec79eb2020-01-10 15:12:39 +00001623 apex_available: [ "myapex" ],
Jiyong Park25fc6a92018-11-18 18:02:45 +09001624 }
1625
1626 cc_library {
Jiyong Parkb0788572018-12-20 22:10:17 +09001627 name: "libBootstrap",
1628 srcs: ["mylib.cpp"],
1629 stl: "none",
1630 bootstrap: true,
1631 }
Jiyong Park25fc6a92018-11-18 18:02:45 +09001632 `)
1633
Sundong Ahnabb64432019-10-22 13:58:29 +09001634 apexRule := ctx.ModuleForTests("myapex", "android_common_myapex_image").Rule("apexRule")
Jiyong Park25fc6a92018-11-18 18:02:45 +09001635 copyCmds := apexRule.Args["copy_commands"]
1636
1637 // Ensure that mylib, libm, libdl are included.
Alex Light5098a612018-11-29 17:12:15 -08001638 ensureContains(t, copyCmds, "image.apex/lib64/mylib.so")
Jiyong Parkb0788572018-12-20 22:10:17 +09001639 ensureContains(t, copyCmds, "image.apex/lib64/bionic/libm.so")
1640 ensureContains(t, copyCmds, "image.apex/lib64/bionic/libdl.so")
Jiyong Park25fc6a92018-11-18 18:02:45 +09001641
1642 // Ensure that libc is not included (since it has stubs and not listed in native_shared_libs)
Jiyong Parkb0788572018-12-20 22:10:17 +09001643 ensureNotContains(t, copyCmds, "image.apex/lib64/bionic/libc.so")
Jiyong Park25fc6a92018-11-18 18:02:45 +09001644
Colin Crossaede88c2020-08-11 12:17:01 -07001645 mylibLdFlags := ctx.ModuleForTests("mylib", "android_arm64_armv8-a_shared_apex10000").Rule("ld").Args["libFlags"]
1646 mylibCFlags := ctx.ModuleForTests("mylib", "android_arm64_armv8-a_static_apex10000").Rule("cc").Args["cFlags"]
1647 mylibSharedCFlags := ctx.ModuleForTests("mylib_shared", "android_arm64_armv8-a_shared_apex10000").Rule("cc").Args["cFlags"]
Jiyong Park25fc6a92018-11-18 18:02:45 +09001648
1649 // For dependency to libc
1650 // Ensure that mylib is linking with the latest version of stubs
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001651 ensureContains(t, mylibLdFlags, "libc/android_arm64_armv8-a_shared_current/libc.so")
Jiyong Park25fc6a92018-11-18 18:02:45 +09001652 // ... and not linking to the non-stub (impl) variant
Jiyong Park3ff16992019-12-27 14:11:47 +09001653 ensureNotContains(t, mylibLdFlags, "libc/android_arm64_armv8-a_shared/libc.so")
Jiyong Park25fc6a92018-11-18 18:02:45 +09001654 // ... Cflags from stub is correctly exported to mylib
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001655 ensureContains(t, mylibCFlags, "__LIBC_API__=10000")
1656 ensureContains(t, mylibSharedCFlags, "__LIBC_API__=10000")
Jiyong Park25fc6a92018-11-18 18:02:45 +09001657
1658 // For dependency to libm
1659 // Ensure that mylib is linking with the non-stub (impl) variant
Colin Crossaede88c2020-08-11 12:17:01 -07001660 ensureContains(t, mylibLdFlags, "libm/android_arm64_armv8-a_shared_apex10000/libm.so")
Jiyong Park25fc6a92018-11-18 18:02:45 +09001661 // ... and not linking to the stub variant
Jiyong Park3ff16992019-12-27 14:11:47 +09001662 ensureNotContains(t, mylibLdFlags, "libm/android_arm64_armv8-a_shared_29/libm.so")
Jiyong Park25fc6a92018-11-18 18:02:45 +09001663 // ... and is not compiling with the stub
1664 ensureNotContains(t, mylibCFlags, "__LIBM_API__=29")
1665 ensureNotContains(t, mylibSharedCFlags, "__LIBM_API__=29")
1666
1667 // For dependency to libdl
1668 // Ensure that mylib is linking with the specified version of stubs
Jiyong Park3ff16992019-12-27 14:11:47 +09001669 ensureContains(t, mylibLdFlags, "libdl/android_arm64_armv8-a_shared_27/libdl.so")
Jiyong Park25fc6a92018-11-18 18:02:45 +09001670 // ... and not linking to the other versions of stubs
Jiyong Park3ff16992019-12-27 14:11:47 +09001671 ensureNotContains(t, mylibLdFlags, "libdl/android_arm64_armv8-a_shared_28/libdl.so")
1672 ensureNotContains(t, mylibLdFlags, "libdl/android_arm64_armv8-a_shared_29/libdl.so")
Jiyong Park25fc6a92018-11-18 18:02:45 +09001673 // ... and not linking to the non-stub (impl) variant
Colin Crossaede88c2020-08-11 12:17:01 -07001674 ensureNotContains(t, mylibLdFlags, "libdl/android_arm64_armv8-a_shared_apex10000/libdl.so")
Jiyong Park25fc6a92018-11-18 18:02:45 +09001675 // ... Cflags from stub is correctly exported to mylib
1676 ensureContains(t, mylibCFlags, "__LIBDL_API__=27")
1677 ensureContains(t, mylibSharedCFlags, "__LIBDL_API__=27")
Jiyong Parkb0788572018-12-20 22:10:17 +09001678
1679 // Ensure that libBootstrap is depending on the platform variant of bionic libs
Colin Cross7113d202019-11-20 16:39:12 -08001680 libFlags := ctx.ModuleForTests("libBootstrap", "android_arm64_armv8-a_shared").Rule("ld").Args["libFlags"]
1681 ensureContains(t, libFlags, "libc/android_arm64_armv8-a_shared/libc.so")
1682 ensureContains(t, libFlags, "libm/android_arm64_armv8-a_shared/libm.so")
1683 ensureContains(t, libFlags, "libdl/android_arm64_armv8-a_shared/libdl.so")
Jiyong Park25fc6a92018-11-18 18:02:45 +09001684}
Jiyong Park7c2ee712018-12-07 00:42:25 +09001685
Jooyung Han749dc692020-04-15 11:03:39 +09001686func TestApexMinSdkVersion_NativeModulesShouldBeBuiltAgainstStubs(t *testing.T) {
Jiyong Park55549df2021-02-26 23:57:23 +09001687 // there are three links between liba --> libz.
1688 // 1) myapex -> libx -> liba -> libz : this should be #30 link
Jooyung Han749dc692020-04-15 11:03:39 +09001689 // 2) otherapex -> liby -> liba -> libz : this should be #30 link
Jooyung Han03b51852020-02-26 22:45:42 +09001690 // 3) (platform) -> liba -> libz : this should be non-stub link
Colin Cross1c460562021-02-16 17:55:47 -08001691 ctx := testApex(t, `
Jooyung Han03b51852020-02-26 22:45:42 +09001692 apex {
1693 name: "myapex",
1694 key: "myapex.key",
1695 native_shared_libs: ["libx"],
Jooyung Han749dc692020-04-15 11:03:39 +09001696 min_sdk_version: "29",
Jooyung Han03b51852020-02-26 22:45:42 +09001697 }
1698
1699 apex {
1700 name: "otherapex",
1701 key: "myapex.key",
1702 native_shared_libs: ["liby"],
Jooyung Han749dc692020-04-15 11:03:39 +09001703 min_sdk_version: "30",
Jooyung Han03b51852020-02-26 22:45:42 +09001704 }
1705
1706 apex_key {
1707 name: "myapex.key",
1708 public_key: "testkey.avbpubkey",
1709 private_key: "testkey.pem",
1710 }
1711
1712 cc_library {
1713 name: "libx",
1714 shared_libs: ["liba"],
1715 system_shared_libs: [],
1716 stl: "none",
1717 apex_available: [ "myapex" ],
Jooyung Han749dc692020-04-15 11:03:39 +09001718 min_sdk_version: "29",
Jooyung Han03b51852020-02-26 22:45:42 +09001719 }
1720
1721 cc_library {
1722 name: "liby",
1723 shared_libs: ["liba"],
1724 system_shared_libs: [],
1725 stl: "none",
1726 apex_available: [ "otherapex" ],
Jooyung Han749dc692020-04-15 11:03:39 +09001727 min_sdk_version: "29",
Jooyung Han03b51852020-02-26 22:45:42 +09001728 }
1729
1730 cc_library {
1731 name: "liba",
1732 shared_libs: ["libz"],
1733 system_shared_libs: [],
1734 stl: "none",
1735 apex_available: [
1736 "//apex_available:anyapex",
1737 "//apex_available:platform",
1738 ],
Jooyung Han749dc692020-04-15 11:03:39 +09001739 min_sdk_version: "29",
Jooyung Han03b51852020-02-26 22:45:42 +09001740 }
1741
1742 cc_library {
1743 name: "libz",
1744 system_shared_libs: [],
1745 stl: "none",
1746 stubs: {
Jooyung Han749dc692020-04-15 11:03:39 +09001747 versions: ["28", "30"],
Jooyung Han03b51852020-02-26 22:45:42 +09001748 },
1749 }
Jooyung Han749dc692020-04-15 11:03:39 +09001750 `)
Jooyung Han03b51852020-02-26 22:45:42 +09001751
1752 expectLink := func(from, from_variant, to, to_variant string) {
1753 ldArgs := ctx.ModuleForTests(from, "android_arm64_armv8-a_"+from_variant).Rule("ld").Args["libFlags"]
1754 ensureContains(t, ldArgs, "android_arm64_armv8-a_"+to_variant+"/"+to+".so")
1755 }
1756 expectNoLink := func(from, from_variant, to, to_variant string) {
1757 ldArgs := ctx.ModuleForTests(from, "android_arm64_armv8-a_"+from_variant).Rule("ld").Args["libFlags"]
1758 ensureNotContains(t, ldArgs, "android_arm64_armv8-a_"+to_variant+"/"+to+".so")
1759 }
1760 // platform liba is linked to non-stub version
1761 expectLink("liba", "shared", "libz", "shared")
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001762 // liba in myapex is linked to current
1763 expectLink("liba", "shared_apex29", "libz", "shared_current")
1764 expectNoLink("liba", "shared_apex29", "libz", "shared_30")
Jiyong Park55549df2021-02-26 23:57:23 +09001765 expectNoLink("liba", "shared_apex29", "libz", "shared_28")
Colin Crossaede88c2020-08-11 12:17:01 -07001766 expectNoLink("liba", "shared_apex29", "libz", "shared")
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001767 // liba in otherapex is linked to current
1768 expectLink("liba", "shared_apex30", "libz", "shared_current")
1769 expectNoLink("liba", "shared_apex30", "libz", "shared_30")
Colin Crossaede88c2020-08-11 12:17:01 -07001770 expectNoLink("liba", "shared_apex30", "libz", "shared_28")
1771 expectNoLink("liba", "shared_apex30", "libz", "shared")
Jooyung Han03b51852020-02-26 22:45:42 +09001772}
1773
Jooyung Hanaed150d2020-04-02 01:41:41 +09001774func TestApexMinSdkVersion_SupportsCodeNames(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08001775 ctx := testApex(t, `
Jooyung Hanaed150d2020-04-02 01:41:41 +09001776 apex {
1777 name: "myapex",
1778 key: "myapex.key",
1779 native_shared_libs: ["libx"],
1780 min_sdk_version: "R",
1781 }
1782
1783 apex_key {
1784 name: "myapex.key",
1785 public_key: "testkey.avbpubkey",
1786 private_key: "testkey.pem",
1787 }
1788
1789 cc_library {
1790 name: "libx",
1791 shared_libs: ["libz"],
1792 system_shared_libs: [],
1793 stl: "none",
1794 apex_available: [ "myapex" ],
Jooyung Han749dc692020-04-15 11:03:39 +09001795 min_sdk_version: "R",
Jooyung Hanaed150d2020-04-02 01:41:41 +09001796 }
1797
1798 cc_library {
1799 name: "libz",
1800 system_shared_libs: [],
1801 stl: "none",
1802 stubs: {
1803 versions: ["29", "R"],
1804 },
1805 }
Paul Duffin0a49fdc2021-03-08 11:28:25 +00001806 `,
1807 android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
1808 variables.Platform_version_active_codenames = []string{"R"}
1809 }),
1810 )
Jooyung Hanaed150d2020-04-02 01:41:41 +09001811
1812 expectLink := func(from, from_variant, to, to_variant string) {
1813 ldArgs := ctx.ModuleForTests(from, "android_arm64_armv8-a_"+from_variant).Rule("ld").Args["libFlags"]
1814 ensureContains(t, ldArgs, "android_arm64_armv8-a_"+to_variant+"/"+to+".so")
1815 }
1816 expectNoLink := func(from, from_variant, to, to_variant string) {
1817 ldArgs := ctx.ModuleForTests(from, "android_arm64_armv8-a_"+from_variant).Rule("ld").Args["libFlags"]
1818 ensureNotContains(t, ldArgs, "android_arm64_armv8-a_"+to_variant+"/"+to+".so")
1819 }
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001820 expectLink("libx", "shared_apex10000", "libz", "shared_current")
1821 expectNoLink("libx", "shared_apex10000", "libz", "shared_R")
Colin Crossaede88c2020-08-11 12:17:01 -07001822 expectNoLink("libx", "shared_apex10000", "libz", "shared_29")
1823 expectNoLink("libx", "shared_apex10000", "libz", "shared")
Jooyung Hanaed150d2020-04-02 01:41:41 +09001824}
1825
Jooyung Han4c4da062021-06-23 10:23:16 +09001826func TestApexMinSdkVersion_SupportsCodeNames_JavaLibs(t *testing.T) {
1827 testApex(t, `
1828 apex {
1829 name: "myapex",
1830 key: "myapex.key",
1831 java_libs: ["libx"],
1832 min_sdk_version: "S",
1833 }
1834
1835 apex_key {
1836 name: "myapex.key",
1837 public_key: "testkey.avbpubkey",
1838 private_key: "testkey.pem",
1839 }
1840
1841 java_library {
1842 name: "libx",
1843 srcs: ["a.java"],
1844 apex_available: [ "myapex" ],
1845 sdk_version: "current",
1846 min_sdk_version: "S", // should be okay
1847 }
1848 `,
1849 android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
1850 variables.Platform_version_active_codenames = []string{"S"}
1851 variables.Platform_sdk_codename = proptools.StringPtr("S")
1852 }),
1853 )
1854}
1855
Jooyung Han749dc692020-04-15 11:03:39 +09001856func TestApexMinSdkVersion_DefaultsToLatest(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08001857 ctx := testApex(t, `
Jooyung Han03b51852020-02-26 22:45:42 +09001858 apex {
1859 name: "myapex",
1860 key: "myapex.key",
1861 native_shared_libs: ["libx"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00001862 updatable: false,
Jooyung Han03b51852020-02-26 22:45:42 +09001863 }
1864
1865 apex_key {
1866 name: "myapex.key",
1867 public_key: "testkey.avbpubkey",
1868 private_key: "testkey.pem",
1869 }
1870
1871 cc_library {
1872 name: "libx",
1873 shared_libs: ["libz"],
1874 system_shared_libs: [],
1875 stl: "none",
1876 apex_available: [ "myapex" ],
1877 }
1878
1879 cc_library {
1880 name: "libz",
1881 system_shared_libs: [],
1882 stl: "none",
1883 stubs: {
1884 versions: ["1", "2"],
1885 },
1886 }
1887 `)
1888
1889 expectLink := func(from, from_variant, to, to_variant string) {
1890 ldArgs := ctx.ModuleForTests(from, "android_arm64_armv8-a_"+from_variant).Rule("ld").Args["libFlags"]
1891 ensureContains(t, ldArgs, "android_arm64_armv8-a_"+to_variant+"/"+to+".so")
1892 }
1893 expectNoLink := func(from, from_variant, to, to_variant string) {
1894 ldArgs := ctx.ModuleForTests(from, "android_arm64_armv8-a_"+from_variant).Rule("ld").Args["libFlags"]
1895 ensureNotContains(t, ldArgs, "android_arm64_armv8-a_"+to_variant+"/"+to+".so")
1896 }
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001897 expectLink("libx", "shared_apex10000", "libz", "shared_current")
Colin Crossaede88c2020-08-11 12:17:01 -07001898 expectNoLink("libx", "shared_apex10000", "libz", "shared_1")
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001899 expectNoLink("libx", "shared_apex10000", "libz", "shared_2")
Colin Crossaede88c2020-08-11 12:17:01 -07001900 expectNoLink("libx", "shared_apex10000", "libz", "shared")
Jooyung Han03b51852020-02-26 22:45:42 +09001901}
1902
Jiyong Park5df7bd32021-08-25 16:18:46 +09001903func TestApexMinSdkVersion_crtobjectInVendorApex(t *testing.T) {
1904 ctx := testApex(t, `
1905 apex {
1906 name: "myapex",
1907 key: "myapex.key",
1908 native_shared_libs: ["mylib"],
1909 updatable: false,
1910 vendor: true,
1911 min_sdk_version: "29",
1912 }
1913
1914 apex_key {
1915 name: "myapex.key",
1916 public_key: "testkey.avbpubkey",
1917 private_key: "testkey.pem",
1918 }
1919
1920 cc_library {
1921 name: "mylib",
1922 vendor_available: true,
1923 system_shared_libs: [],
1924 stl: "none",
1925 apex_available: [ "myapex" ],
1926 min_sdk_version: "29",
1927 }
1928 `)
1929
1930 vendorVariant := "android_vendor.29_arm64_armv8-a"
1931
1932 // First check that the correct variant of crtbegin_so is used.
1933 ldRule := ctx.ModuleForTests("mylib", vendorVariant+"_shared_apex29").Rule("ld")
1934 crtBegin := names(ldRule.Args["crtBegin"])
1935 ensureListContains(t, crtBegin, "out/soong/.intermediates/"+cc.DefaultCcCommonTestModulesDir+"crtbegin_so/"+vendorVariant+"_apex29/crtbegin_so.o")
1936
1937 // Ensure that the crtbegin_so used by the APEX is targeting 29
1938 cflags := ctx.ModuleForTests("crtbegin_so", vendorVariant+"_apex29").Rule("cc").Args["cFlags"]
1939 android.AssertStringDoesContain(t, "cflags", cflags, "-target aarch64-linux-android29")
1940}
1941
Jooyung Han03b51852020-02-26 22:45:42 +09001942func TestPlatformUsesLatestStubsFromApexes(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08001943 ctx := testApex(t, `
Jooyung Han03b51852020-02-26 22:45:42 +09001944 apex {
1945 name: "myapex",
1946 key: "myapex.key",
1947 native_shared_libs: ["libx"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00001948 updatable: false,
Jooyung Han03b51852020-02-26 22:45:42 +09001949 }
1950
1951 apex_key {
1952 name: "myapex.key",
1953 public_key: "testkey.avbpubkey",
1954 private_key: "testkey.pem",
1955 }
1956
1957 cc_library {
1958 name: "libx",
1959 system_shared_libs: [],
1960 stl: "none",
1961 apex_available: [ "myapex" ],
1962 stubs: {
1963 versions: ["1", "2"],
1964 },
1965 }
1966
1967 cc_library {
1968 name: "libz",
1969 shared_libs: ["libx"],
1970 system_shared_libs: [],
1971 stl: "none",
1972 }
1973 `)
1974
1975 expectLink := func(from, from_variant, to, to_variant string) {
Colin Cross56a83212020-09-15 18:30:11 -07001976 t.Helper()
Jooyung Han03b51852020-02-26 22:45:42 +09001977 ldArgs := ctx.ModuleForTests(from, "android_arm64_armv8-a_"+from_variant).Rule("ld").Args["libFlags"]
1978 ensureContains(t, ldArgs, "android_arm64_armv8-a_"+to_variant+"/"+to+".so")
1979 }
1980 expectNoLink := func(from, from_variant, to, to_variant string) {
Colin Cross56a83212020-09-15 18:30:11 -07001981 t.Helper()
Jooyung Han03b51852020-02-26 22:45:42 +09001982 ldArgs := ctx.ModuleForTests(from, "android_arm64_armv8-a_"+from_variant).Rule("ld").Args["libFlags"]
1983 ensureNotContains(t, ldArgs, "android_arm64_armv8-a_"+to_variant+"/"+to+".so")
1984 }
Jiyong Parkd4a3a132021-03-17 20:21:35 +09001985 expectLink("libz", "shared", "libx", "shared_current")
1986 expectNoLink("libz", "shared", "libx", "shared_2")
Jooyung Han03b51852020-02-26 22:45:42 +09001987 expectNoLink("libz", "shared", "libz", "shared_1")
1988 expectNoLink("libz", "shared", "libz", "shared")
1989}
1990
Paul Duffin0a49fdc2021-03-08 11:28:25 +00001991var prepareForTestWithSantitizeHwaddress = android.FixtureModifyProductVariables(
1992 func(variables android.FixtureProductVariables) {
1993 variables.SanitizeDevice = []string{"hwaddress"}
1994 },
1995)
1996
Jooyung Han75568392020-03-20 04:29:24 +09001997func TestQApexesUseLatestStubsInBundledBuildsAndHWASAN(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08001998 ctx := testApex(t, `
Jooyung Han03b51852020-02-26 22:45:42 +09001999 apex {
2000 name: "myapex",
2001 key: "myapex.key",
2002 native_shared_libs: ["libx"],
2003 min_sdk_version: "29",
2004 }
2005
2006 apex_key {
2007 name: "myapex.key",
2008 public_key: "testkey.avbpubkey",
2009 private_key: "testkey.pem",
2010 }
2011
2012 cc_library {
2013 name: "libx",
2014 shared_libs: ["libbar"],
2015 apex_available: [ "myapex" ],
Jooyung Han749dc692020-04-15 11:03:39 +09002016 min_sdk_version: "29",
Jooyung Han03b51852020-02-26 22:45:42 +09002017 }
2018
2019 cc_library {
2020 name: "libbar",
2021 stubs: {
2022 versions: ["29", "30"],
2023 },
2024 }
Paul Duffin0a49fdc2021-03-08 11:28:25 +00002025 `,
2026 prepareForTestWithSantitizeHwaddress,
2027 )
Jooyung Han03b51852020-02-26 22:45:42 +09002028 expectLink := func(from, from_variant, to, to_variant string) {
2029 ld := ctx.ModuleForTests(from, "android_arm64_armv8-a_"+from_variant).Rule("ld")
2030 libFlags := ld.Args["libFlags"]
2031 ensureContains(t, libFlags, "android_arm64_armv8-a_"+to_variant+"/"+to+".so")
2032 }
Jiyong Parkd4a3a132021-03-17 20:21:35 +09002033 expectLink("libx", "shared_hwasan_apex29", "libbar", "shared_current")
Jooyung Han03b51852020-02-26 22:45:42 +09002034}
2035
Jooyung Han75568392020-03-20 04:29:24 +09002036func TestQTargetApexUsesStaticUnwinder(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08002037 ctx := testApex(t, `
Jooyung Han03b51852020-02-26 22:45:42 +09002038 apex {
2039 name: "myapex",
2040 key: "myapex.key",
2041 native_shared_libs: ["libx"],
2042 min_sdk_version: "29",
2043 }
2044
2045 apex_key {
2046 name: "myapex.key",
2047 public_key: "testkey.avbpubkey",
2048 private_key: "testkey.pem",
2049 }
2050
2051 cc_library {
2052 name: "libx",
2053 apex_available: [ "myapex" ],
Jooyung Han749dc692020-04-15 11:03:39 +09002054 min_sdk_version: "29",
Jooyung Han03b51852020-02-26 22:45:42 +09002055 }
Jooyung Han75568392020-03-20 04:29:24 +09002056 `)
Jooyung Han03b51852020-02-26 22:45:42 +09002057
2058 // ensure apex variant of c++ is linked with static unwinder
Colin Crossaede88c2020-08-11 12:17:01 -07002059 cm := ctx.ModuleForTests("libc++", "android_arm64_armv8-a_shared_apex29").Module().(*cc.Module)
Ryan Prichardb35a85e2021-01-13 19:18:53 -08002060 ensureListContains(t, cm.Properties.AndroidMkStaticLibs, "libunwind")
Jooyung Han03b51852020-02-26 22:45:42 +09002061 // note that platform variant is not.
2062 cm = ctx.ModuleForTests("libc++", "android_arm64_armv8-a_shared").Module().(*cc.Module)
Ryan Prichardb35a85e2021-01-13 19:18:53 -08002063 ensureListNotContains(t, cm.Properties.AndroidMkStaticLibs, "libunwind")
Jooyung Han03b51852020-02-26 22:45:42 +09002064}
2065
Jooyung Han749dc692020-04-15 11:03:39 +09002066func TestApexMinSdkVersion_ErrorIfIncompatibleVersion(t *testing.T) {
2067 testApexError(t, `module "mylib".*: should support min_sdk_version\(29\)`, `
Jooyung Han03b51852020-02-26 22:45:42 +09002068 apex {
2069 name: "myapex",
2070 key: "myapex.key",
Jooyung Han749dc692020-04-15 11:03:39 +09002071 native_shared_libs: ["mylib"],
2072 min_sdk_version: "29",
Jooyung Han03b51852020-02-26 22:45:42 +09002073 }
2074
2075 apex_key {
2076 name: "myapex.key",
2077 public_key: "testkey.avbpubkey",
2078 private_key: "testkey.pem",
2079 }
Jooyung Han749dc692020-04-15 11:03:39 +09002080
2081 cc_library {
2082 name: "mylib",
2083 srcs: ["mylib.cpp"],
2084 system_shared_libs: [],
2085 stl: "none",
2086 apex_available: [
2087 "myapex",
2088 ],
2089 min_sdk_version: "30",
2090 }
2091 `)
Ivan Lozano3e9f9e42020-12-04 15:05:43 -05002092
2093 testApexError(t, `module "libfoo.ffi".*: should support min_sdk_version\(29\)`, `
2094 apex {
2095 name: "myapex",
2096 key: "myapex.key",
2097 native_shared_libs: ["libfoo.ffi"],
2098 min_sdk_version: "29",
2099 }
2100
2101 apex_key {
2102 name: "myapex.key",
2103 public_key: "testkey.avbpubkey",
2104 private_key: "testkey.pem",
2105 }
2106
2107 rust_ffi_shared {
2108 name: "libfoo.ffi",
2109 srcs: ["foo.rs"],
2110 crate_name: "foo",
2111 apex_available: [
2112 "myapex",
2113 ],
2114 min_sdk_version: "30",
2115 }
2116 `)
Jaewoong Jung56e12db2021-04-02 00:38:25 +00002117
2118 testApexError(t, `module "libfoo".*: should support min_sdk_version\(29\)`, `
2119 apex {
2120 name: "myapex",
2121 key: "myapex.key",
2122 java_libs: ["libfoo"],
2123 min_sdk_version: "29",
2124 }
2125
2126 apex_key {
2127 name: "myapex.key",
2128 public_key: "testkey.avbpubkey",
2129 private_key: "testkey.pem",
2130 }
2131
2132 java_import {
2133 name: "libfoo",
2134 jars: ["libfoo.jar"],
2135 apex_available: [
2136 "myapex",
2137 ],
2138 min_sdk_version: "30",
2139 }
2140 `)
Jooyung Han749dc692020-04-15 11:03:39 +09002141}
2142
2143func TestApexMinSdkVersion_Okay(t *testing.T) {
2144 testApex(t, `
2145 apex {
2146 name: "myapex",
2147 key: "myapex.key",
2148 native_shared_libs: ["libfoo"],
2149 java_libs: ["libbar"],
2150 min_sdk_version: "29",
2151 }
2152
2153 apex_key {
2154 name: "myapex.key",
2155 public_key: "testkey.avbpubkey",
2156 private_key: "testkey.pem",
2157 }
2158
2159 cc_library {
2160 name: "libfoo",
2161 srcs: ["mylib.cpp"],
2162 shared_libs: ["libfoo_dep"],
2163 apex_available: ["myapex"],
2164 min_sdk_version: "29",
2165 }
2166
2167 cc_library {
2168 name: "libfoo_dep",
2169 srcs: ["mylib.cpp"],
2170 apex_available: ["myapex"],
2171 min_sdk_version: "29",
2172 }
2173
2174 java_library {
2175 name: "libbar",
2176 sdk_version: "current",
2177 srcs: ["a.java"],
Jaewoong Jung56e12db2021-04-02 00:38:25 +00002178 static_libs: [
2179 "libbar_dep",
2180 "libbar_import_dep",
2181 ],
Jooyung Han749dc692020-04-15 11:03:39 +09002182 apex_available: ["myapex"],
2183 min_sdk_version: "29",
2184 }
2185
2186 java_library {
2187 name: "libbar_dep",
2188 sdk_version: "current",
2189 srcs: ["a.java"],
2190 apex_available: ["myapex"],
2191 min_sdk_version: "29",
2192 }
Jaewoong Jung56e12db2021-04-02 00:38:25 +00002193
2194 java_import {
2195 name: "libbar_import_dep",
2196 jars: ["libbar.jar"],
2197 apex_available: ["myapex"],
2198 min_sdk_version: "29",
2199 }
Jooyung Han03b51852020-02-26 22:45:42 +09002200 `)
2201}
2202
Artur Satayev8cf899a2020-04-15 17:29:42 +01002203func TestJavaStableSdkVersion(t *testing.T) {
2204 testCases := []struct {
2205 name string
2206 expectedError string
2207 bp string
Paul Duffin1ea7c9f2021-03-15 09:39:13 +00002208 preparer android.FixturePreparer
Artur Satayev8cf899a2020-04-15 17:29:42 +01002209 }{
2210 {
2211 name: "Non-updatable apex with non-stable dep",
2212 bp: `
2213 apex {
2214 name: "myapex",
2215 java_libs: ["myjar"],
2216 key: "myapex.key",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00002217 updatable: false,
Artur Satayev8cf899a2020-04-15 17:29:42 +01002218 }
2219 apex_key {
2220 name: "myapex.key",
2221 public_key: "testkey.avbpubkey",
2222 private_key: "testkey.pem",
2223 }
2224 java_library {
2225 name: "myjar",
2226 srcs: ["foo/bar/MyClass.java"],
Paul Duffin043f5e72021-03-05 00:00:01 +00002227 sdk_version: "test_current",
Artur Satayev8cf899a2020-04-15 17:29:42 +01002228 apex_available: ["myapex"],
2229 }
2230 `,
2231 },
2232 {
2233 name: "Updatable apex with stable dep",
2234 bp: `
2235 apex {
2236 name: "myapex",
2237 java_libs: ["myjar"],
2238 key: "myapex.key",
2239 updatable: true,
2240 min_sdk_version: "29",
2241 }
2242 apex_key {
2243 name: "myapex.key",
2244 public_key: "testkey.avbpubkey",
2245 private_key: "testkey.pem",
2246 }
2247 java_library {
2248 name: "myjar",
2249 srcs: ["foo/bar/MyClass.java"],
2250 sdk_version: "current",
2251 apex_available: ["myapex"],
Jooyung Han749dc692020-04-15 11:03:39 +09002252 min_sdk_version: "29",
Artur Satayev8cf899a2020-04-15 17:29:42 +01002253 }
2254 `,
2255 },
2256 {
2257 name: "Updatable apex with non-stable dep",
2258 expectedError: "cannot depend on \"myjar\"",
2259 bp: `
2260 apex {
2261 name: "myapex",
2262 java_libs: ["myjar"],
2263 key: "myapex.key",
2264 updatable: true,
2265 }
2266 apex_key {
2267 name: "myapex.key",
2268 public_key: "testkey.avbpubkey",
2269 private_key: "testkey.pem",
2270 }
2271 java_library {
2272 name: "myjar",
2273 srcs: ["foo/bar/MyClass.java"],
Paul Duffin043f5e72021-03-05 00:00:01 +00002274 sdk_version: "test_current",
Artur Satayev8cf899a2020-04-15 17:29:42 +01002275 apex_available: ["myapex"],
2276 }
2277 `,
2278 },
2279 {
Paul Duffin1ea7c9f2021-03-15 09:39:13 +00002280 name: "Updatable apex with non-stable legacy core platform dep",
2281 expectedError: `\Qcannot depend on "myjar-uses-legacy": non stable SDK core_platform_current - uses legacy core platform\E`,
2282 bp: `
2283 apex {
2284 name: "myapex",
2285 java_libs: ["myjar-uses-legacy"],
2286 key: "myapex.key",
2287 updatable: true,
2288 }
2289 apex_key {
2290 name: "myapex.key",
2291 public_key: "testkey.avbpubkey",
2292 private_key: "testkey.pem",
2293 }
2294 java_library {
2295 name: "myjar-uses-legacy",
2296 srcs: ["foo/bar/MyClass.java"],
2297 sdk_version: "core_platform",
2298 apex_available: ["myapex"],
2299 }
2300 `,
2301 preparer: java.FixtureUseLegacyCorePlatformApi("myjar-uses-legacy"),
2302 },
2303 {
Paul Duffin043f5e72021-03-05 00:00:01 +00002304 name: "Updatable apex with non-stable transitive dep",
2305 // This is not actually detecting that the transitive dependency is unstable, rather it is
2306 // detecting that the transitive dependency is building against a wider API surface than the
2307 // module that depends on it is using.
Jiyong Park670e0f62021-02-18 13:10:18 +09002308 expectedError: "compiles against Android API, but dependency \"transitive-jar\" is compiling against private API.",
Artur Satayev8cf899a2020-04-15 17:29:42 +01002309 bp: `
2310 apex {
2311 name: "myapex",
2312 java_libs: ["myjar"],
2313 key: "myapex.key",
2314 updatable: true,
2315 }
2316 apex_key {
2317 name: "myapex.key",
2318 public_key: "testkey.avbpubkey",
2319 private_key: "testkey.pem",
2320 }
2321 java_library {
2322 name: "myjar",
2323 srcs: ["foo/bar/MyClass.java"],
2324 sdk_version: "current",
2325 apex_available: ["myapex"],
2326 static_libs: ["transitive-jar"],
2327 }
2328 java_library {
2329 name: "transitive-jar",
2330 srcs: ["foo/bar/MyClass.java"],
2331 sdk_version: "core_platform",
2332 apex_available: ["myapex"],
2333 }
2334 `,
2335 },
2336 }
2337
2338 for _, test := range testCases {
Paul Duffin1ea7c9f2021-03-15 09:39:13 +00002339 if test.name != "Updatable apex with non-stable legacy core platform dep" {
2340 continue
2341 }
Artur Satayev8cf899a2020-04-15 17:29:42 +01002342 t.Run(test.name, func(t *testing.T) {
Paul Duffin1ea7c9f2021-03-15 09:39:13 +00002343 errorHandler := android.FixtureExpectsNoErrors
2344 if test.expectedError != "" {
2345 errorHandler = android.FixtureExpectsAtLeastOneErrorMatchingPattern(test.expectedError)
Artur Satayev8cf899a2020-04-15 17:29:42 +01002346 }
Paul Duffin1ea7c9f2021-03-15 09:39:13 +00002347 android.GroupFixturePreparers(
2348 java.PrepareForTestWithJavaDefaultModules,
2349 PrepareForTestWithApexBuildComponents,
2350 prepareForTestWithMyapex,
2351 android.OptionalFixturePreparer(test.preparer),
2352 ).
2353 ExtendWithErrorHandler(errorHandler).
2354 RunTestWithBp(t, test.bp)
Artur Satayev8cf899a2020-04-15 17:29:42 +01002355 })
2356 }
2357}
2358
Jooyung Han749dc692020-04-15 11:03:39 +09002359func TestApexMinSdkVersion_ErrorIfDepIsNewer(t *testing.T) {
2360 testApexError(t, `module "mylib2".*: should support min_sdk_version\(29\) for "myapex"`, `
2361 apex {
2362 name: "myapex",
2363 key: "myapex.key",
2364 native_shared_libs: ["mylib"],
2365 min_sdk_version: "29",
2366 }
2367
2368 apex_key {
2369 name: "myapex.key",
2370 public_key: "testkey.avbpubkey",
2371 private_key: "testkey.pem",
2372 }
2373
2374 cc_library {
2375 name: "mylib",
2376 srcs: ["mylib.cpp"],
2377 shared_libs: ["mylib2"],
2378 system_shared_libs: [],
2379 stl: "none",
2380 apex_available: [
2381 "myapex",
2382 ],
2383 min_sdk_version: "29",
2384 }
2385
2386 // indirect part of the apex
2387 cc_library {
2388 name: "mylib2",
2389 srcs: ["mylib.cpp"],
2390 system_shared_libs: [],
2391 stl: "none",
2392 apex_available: [
2393 "myapex",
2394 ],
2395 min_sdk_version: "30",
2396 }
2397 `)
2398}
2399
2400func TestApexMinSdkVersion_ErrorIfDepIsNewer_Java(t *testing.T) {
2401 testApexError(t, `module "bar".*: should support min_sdk_version\(29\) for "myapex"`, `
2402 apex {
2403 name: "myapex",
2404 key: "myapex.key",
2405 apps: ["AppFoo"],
2406 min_sdk_version: "29",
2407 }
2408
2409 apex_key {
2410 name: "myapex.key",
2411 public_key: "testkey.avbpubkey",
2412 private_key: "testkey.pem",
2413 }
2414
2415 android_app {
2416 name: "AppFoo",
2417 srcs: ["foo/bar/MyClass.java"],
2418 sdk_version: "current",
2419 min_sdk_version: "29",
2420 system_modules: "none",
2421 stl: "none",
2422 static_libs: ["bar"],
2423 apex_available: [ "myapex" ],
2424 }
2425
2426 java_library {
2427 name: "bar",
2428 sdk_version: "current",
2429 srcs: ["a.java"],
2430 apex_available: [ "myapex" ],
2431 }
2432 `)
2433}
2434
2435func TestApexMinSdkVersion_OkayEvenWhenDepIsNewer_IfItSatisfiesApexMinSdkVersion(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08002436 ctx := testApex(t, `
Jooyung Han749dc692020-04-15 11:03:39 +09002437 apex {
2438 name: "myapex",
2439 key: "myapex.key",
2440 native_shared_libs: ["mylib"],
2441 min_sdk_version: "29",
2442 }
2443
2444 apex_key {
2445 name: "myapex.key",
2446 public_key: "testkey.avbpubkey",
2447 private_key: "testkey.pem",
2448 }
2449
Jiyong Parkd4a3a132021-03-17 20:21:35 +09002450 // mylib in myapex will link to mylib2#current
Jooyung Han749dc692020-04-15 11:03:39 +09002451 // mylib in otherapex will link to mylib2(non-stub) in otherapex as well
2452 cc_library {
2453 name: "mylib",
2454 srcs: ["mylib.cpp"],
2455 shared_libs: ["mylib2"],
2456 system_shared_libs: [],
2457 stl: "none",
2458 apex_available: ["myapex", "otherapex"],
2459 min_sdk_version: "29",
2460 }
2461
2462 cc_library {
2463 name: "mylib2",
2464 srcs: ["mylib.cpp"],
2465 system_shared_libs: [],
2466 stl: "none",
2467 apex_available: ["otherapex"],
2468 stubs: { versions: ["29", "30"] },
2469 min_sdk_version: "30",
2470 }
2471
2472 apex {
2473 name: "otherapex",
2474 key: "myapex.key",
2475 native_shared_libs: ["mylib", "mylib2"],
2476 min_sdk_version: "30",
2477 }
2478 `)
2479 expectLink := func(from, from_variant, to, to_variant string) {
2480 ld := ctx.ModuleForTests(from, "android_arm64_armv8-a_"+from_variant).Rule("ld")
2481 libFlags := ld.Args["libFlags"]
2482 ensureContains(t, libFlags, "android_arm64_armv8-a_"+to_variant+"/"+to+".so")
2483 }
Jiyong Parkd4a3a132021-03-17 20:21:35 +09002484 expectLink("mylib", "shared_apex29", "mylib2", "shared_current")
Colin Crossaede88c2020-08-11 12:17:01 -07002485 expectLink("mylib", "shared_apex30", "mylib2", "shared_apex30")
Jooyung Han749dc692020-04-15 11:03:39 +09002486}
2487
Jooyung Haned124c32021-01-26 11:43:46 +09002488func TestApexMinSdkVersion_WorksWithSdkCodename(t *testing.T) {
Paul Duffin0a49fdc2021-03-08 11:28:25 +00002489 withSAsActiveCodeNames := android.FixtureModifyProductVariables(
2490 func(variables android.FixtureProductVariables) {
2491 variables.Platform_sdk_codename = proptools.StringPtr("S")
2492 variables.Platform_version_active_codenames = []string{"S"}
2493 },
2494 )
Jooyung Haned124c32021-01-26 11:43:46 +09002495 testApexError(t, `libbar.*: should support min_sdk_version\(S\)`, `
2496 apex {
2497 name: "myapex",
2498 key: "myapex.key",
2499 native_shared_libs: ["libfoo"],
2500 min_sdk_version: "S",
2501 }
2502 apex_key {
2503 name: "myapex.key",
2504 public_key: "testkey.avbpubkey",
2505 private_key: "testkey.pem",
2506 }
2507 cc_library {
2508 name: "libfoo",
2509 shared_libs: ["libbar"],
2510 apex_available: ["myapex"],
2511 min_sdk_version: "29",
2512 }
2513 cc_library {
2514 name: "libbar",
2515 apex_available: ["myapex"],
2516 }
2517 `, withSAsActiveCodeNames)
2518}
2519
2520func TestApexMinSdkVersion_WorksWithActiveCodenames(t *testing.T) {
Paul Duffin0a49fdc2021-03-08 11:28:25 +00002521 withSAsActiveCodeNames := android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
2522 variables.Platform_sdk_codename = proptools.StringPtr("S")
2523 variables.Platform_version_active_codenames = []string{"S", "T"}
2524 })
Colin Cross1c460562021-02-16 17:55:47 -08002525 ctx := testApex(t, `
Jooyung Haned124c32021-01-26 11:43:46 +09002526 apex {
2527 name: "myapex",
2528 key: "myapex.key",
2529 native_shared_libs: ["libfoo"],
2530 min_sdk_version: "S",
2531 }
2532 apex_key {
2533 name: "myapex.key",
2534 public_key: "testkey.avbpubkey",
2535 private_key: "testkey.pem",
2536 }
2537 cc_library {
2538 name: "libfoo",
2539 shared_libs: ["libbar"],
2540 apex_available: ["myapex"],
2541 min_sdk_version: "S",
2542 }
2543 cc_library {
2544 name: "libbar",
2545 stubs: {
2546 symbol_file: "libbar.map.txt",
2547 versions: ["30", "S", "T"],
2548 },
2549 }
2550 `, withSAsActiveCodeNames)
2551
Jiyong Parkd4a3a132021-03-17 20:21:35 +09002552 // ensure libfoo is linked with current version of libbar stub
Jooyung Haned124c32021-01-26 11:43:46 +09002553 libfoo := ctx.ModuleForTests("libfoo", "android_arm64_armv8-a_shared_apex10000")
2554 libFlags := libfoo.Rule("ld").Args["libFlags"]
Jiyong Parkd4a3a132021-03-17 20:21:35 +09002555 ensureContains(t, libFlags, "android_arm64_armv8-a_shared_current/libbar.so")
Jooyung Haned124c32021-01-26 11:43:46 +09002556}
2557
Jiyong Park7c2ee712018-12-07 00:42:25 +09002558func TestFilesInSubDir(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08002559 ctx := testApex(t, `
Jiyong Park7c2ee712018-12-07 00:42:25 +09002560 apex {
2561 name: "myapex",
2562 key: "myapex.key",
Jiyong Parkb7c24df2019-02-01 12:03:59 +09002563 native_shared_libs: ["mylib"],
2564 binaries: ["mybin"],
Jiyong Park7c2ee712018-12-07 00:42:25 +09002565 prebuilts: ["myetc"],
Jiyong Parkb7c24df2019-02-01 12:03:59 +09002566 compile_multilib: "both",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00002567 updatable: false,
Jiyong Park7c2ee712018-12-07 00:42:25 +09002568 }
2569
2570 apex_key {
2571 name: "myapex.key",
2572 public_key: "testkey.avbpubkey",
2573 private_key: "testkey.pem",
2574 }
2575
2576 prebuilt_etc {
2577 name: "myetc",
2578 src: "myprebuilt",
2579 sub_dir: "foo/bar",
2580 }
Jiyong Parkb7c24df2019-02-01 12:03:59 +09002581
2582 cc_library {
2583 name: "mylib",
2584 srcs: ["mylib.cpp"],
2585 relative_install_path: "foo/bar",
2586 system_shared_libs: [],
2587 stl: "none",
Anton Hanssoneec79eb2020-01-10 15:12:39 +00002588 apex_available: [ "myapex" ],
Jiyong Parkb7c24df2019-02-01 12:03:59 +09002589 }
2590
2591 cc_binary {
2592 name: "mybin",
2593 srcs: ["mylib.cpp"],
2594 relative_install_path: "foo/bar",
2595 system_shared_libs: [],
Jiyong Parkb7c24df2019-02-01 12:03:59 +09002596 stl: "none",
Anton Hanssoneec79eb2020-01-10 15:12:39 +00002597 apex_available: [ "myapex" ],
Jiyong Parkb7c24df2019-02-01 12:03:59 +09002598 }
Jiyong Park7c2ee712018-12-07 00:42:25 +09002599 `)
2600
Sundong Ahnabb64432019-10-22 13:58:29 +09002601 generateFsRule := ctx.ModuleForTests("myapex", "android_common_myapex_image").Rule("generateFsConfig")
Jiyong Park1b0893e2021-12-13 23:40:17 +09002602 cmd := generateFsRule.RuleParams.Command
Jiyong Park7c2ee712018-12-07 00:42:25 +09002603
Jiyong Parkb7c24df2019-02-01 12:03:59 +09002604 // Ensure that the subdirectories are all listed
Jiyong Park1b0893e2021-12-13 23:40:17 +09002605 ensureContains(t, cmd, "/etc ")
2606 ensureContains(t, cmd, "/etc/foo ")
2607 ensureContains(t, cmd, "/etc/foo/bar ")
2608 ensureContains(t, cmd, "/lib64 ")
2609 ensureContains(t, cmd, "/lib64/foo ")
2610 ensureContains(t, cmd, "/lib64/foo/bar ")
2611 ensureContains(t, cmd, "/lib ")
2612 ensureContains(t, cmd, "/lib/foo ")
2613 ensureContains(t, cmd, "/lib/foo/bar ")
2614 ensureContains(t, cmd, "/bin ")
2615 ensureContains(t, cmd, "/bin/foo ")
2616 ensureContains(t, cmd, "/bin/foo/bar ")
Jiyong Park7c2ee712018-12-07 00:42:25 +09002617}
Jiyong Parkda6eb592018-12-19 17:12:36 +09002618
Jooyung Han35155c42020-02-06 17:33:20 +09002619func TestFilesInSubDirWhenNativeBridgeEnabled(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08002620 ctx := testApex(t, `
Jooyung Han35155c42020-02-06 17:33:20 +09002621 apex {
2622 name: "myapex",
2623 key: "myapex.key",
2624 multilib: {
2625 both: {
2626 native_shared_libs: ["mylib"],
2627 binaries: ["mybin"],
2628 },
2629 },
2630 compile_multilib: "both",
2631 native_bridge_supported: true,
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00002632 updatable: false,
Jooyung Han35155c42020-02-06 17:33:20 +09002633 }
2634
2635 apex_key {
2636 name: "myapex.key",
2637 public_key: "testkey.avbpubkey",
2638 private_key: "testkey.pem",
2639 }
2640
2641 cc_library {
2642 name: "mylib",
2643 relative_install_path: "foo/bar",
2644 system_shared_libs: [],
2645 stl: "none",
2646 apex_available: [ "myapex" ],
2647 native_bridge_supported: true,
2648 }
2649
2650 cc_binary {
2651 name: "mybin",
2652 relative_install_path: "foo/bar",
2653 system_shared_libs: [],
Jooyung Han35155c42020-02-06 17:33:20 +09002654 stl: "none",
2655 apex_available: [ "myapex" ],
2656 native_bridge_supported: true,
2657 compile_multilib: "both", // default is "first" for binary
2658 multilib: {
2659 lib64: {
2660 suffix: "64",
2661 },
2662 },
2663 }
2664 `, withNativeBridgeEnabled)
2665 ensureExactContents(t, ctx, "myapex", "android_common_myapex_image", []string{
2666 "bin/foo/bar/mybin",
2667 "bin/foo/bar/mybin64",
2668 "bin/arm/foo/bar/mybin",
2669 "bin/arm64/foo/bar/mybin64",
2670 "lib/foo/bar/mylib.so",
2671 "lib/arm/foo/bar/mylib.so",
2672 "lib64/foo/bar/mylib.so",
2673 "lib64/arm64/foo/bar/mylib.so",
2674 })
2675}
2676
Jooyung Han85d61762020-06-24 23:50:26 +09002677func TestVendorApex(t *testing.T) {
Colin Crossc68db4b2021-11-11 18:59:15 -08002678 result := android.GroupFixturePreparers(
2679 prepareForApexTest,
2680 android.FixtureModifyConfig(android.SetKatiEnabledForTests),
2681 ).RunTestWithBp(t, `
Jooyung Han85d61762020-06-24 23:50:26 +09002682 apex {
2683 name: "myapex",
2684 key: "myapex.key",
2685 binaries: ["mybin"],
2686 vendor: true,
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00002687 updatable: false,
Jooyung Han85d61762020-06-24 23:50:26 +09002688 }
2689 apex_key {
2690 name: "myapex.key",
2691 public_key: "testkey.avbpubkey",
2692 private_key: "testkey.pem",
2693 }
2694 cc_binary {
2695 name: "mybin",
2696 vendor: true,
2697 shared_libs: ["libfoo"],
2698 }
2699 cc_library {
2700 name: "libfoo",
2701 proprietary: true,
2702 }
2703 `)
2704
Colin Crossc68db4b2021-11-11 18:59:15 -08002705 ensureExactContents(t, result.TestContext, "myapex", "android_common_myapex_image", []string{
Jooyung Han85d61762020-06-24 23:50:26 +09002706 "bin/mybin",
2707 "lib64/libfoo.so",
2708 // TODO(b/159195575): Add an option to use VNDK libs from VNDK APEX
2709 "lib64/libc++.so",
2710 })
2711
Colin Crossc68db4b2021-11-11 18:59:15 -08002712 apexBundle := result.ModuleForTests("myapex", "android_common_myapex_image").Module().(*apexBundle)
2713 data := android.AndroidMkDataForTest(t, result.TestContext, apexBundle)
Jooyung Han85d61762020-06-24 23:50:26 +09002714 name := apexBundle.BaseModuleName()
2715 prefix := "TARGET_"
2716 var builder strings.Builder
2717 data.Custom(&builder, name, prefix, "", data)
Colin Crossc68db4b2021-11-11 18:59:15 -08002718 androidMk := android.StringRelativeToTop(result.Config, builder.String())
Paul Duffin37ba3442021-03-29 00:21:08 +01002719 installPath := "out/target/product/test_device/vendor/apex"
Lukacs T. Berki7690c092021-02-26 14:27:36 +01002720 ensureContains(t, androidMk, "LOCAL_MODULE_PATH := "+installPath)
Jooyung Han6c4cc9c2020-07-29 16:00:54 +09002721
Colin Crossc68db4b2021-11-11 18:59:15 -08002722 apexManifestRule := result.ModuleForTests("myapex", "android_common_myapex_image").Rule("apexManifestRule")
Jooyung Han6c4cc9c2020-07-29 16:00:54 +09002723 requireNativeLibs := names(apexManifestRule.Args["requireNativeLibs"])
2724 ensureListNotContains(t, requireNativeLibs, ":vndk")
Jooyung Han85d61762020-06-24 23:50:26 +09002725}
2726
Jooyung Hanc5a96762022-02-04 11:54:50 +09002727func TestVendorApex_use_vndk_as_stable_TryingToIncludeVNDKLib(t *testing.T) {
2728 testApexError(t, `Trying to include a VNDK library`, `
2729 apex {
2730 name: "myapex",
2731 key: "myapex.key",
2732 native_shared_libs: ["libc++"], // libc++ is a VNDK lib
2733 vendor: true,
2734 use_vndk_as_stable: true,
2735 updatable: false,
2736 }
2737 apex_key {
2738 name: "myapex.key",
2739 public_key: "testkey.avbpubkey",
2740 private_key: "testkey.pem",
2741 }`)
2742}
2743
Jooyung Handf78e212020-07-22 15:54:47 +09002744func TestVendorApex_use_vndk_as_stable(t *testing.T) {
Jooyung Han91f92032022-02-04 12:36:33 +09002745 // myapex myapex2
2746 // | |
2747 // mybin ------. mybin2
2748 // \ \ / |
2749 // (stable) .---\--------` |
2750 // \ / \ |
2751 // \ / \ /
2752 // libvndk libvendor
2753 // (vndk)
Colin Cross1c460562021-02-16 17:55:47 -08002754 ctx := testApex(t, `
Jooyung Handf78e212020-07-22 15:54:47 +09002755 apex {
2756 name: "myapex",
2757 key: "myapex.key",
2758 binaries: ["mybin"],
2759 vendor: true,
2760 use_vndk_as_stable: true,
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00002761 updatable: false,
Jooyung Handf78e212020-07-22 15:54:47 +09002762 }
2763 apex_key {
2764 name: "myapex.key",
2765 public_key: "testkey.avbpubkey",
2766 private_key: "testkey.pem",
2767 }
2768 cc_binary {
2769 name: "mybin",
2770 vendor: true,
2771 shared_libs: ["libvndk", "libvendor"],
2772 }
2773 cc_library {
2774 name: "libvndk",
2775 vndk: {
2776 enabled: true,
2777 },
2778 vendor_available: true,
Justin Yun63e9ec72020-10-29 16:49:43 +09002779 product_available: true,
Jooyung Handf78e212020-07-22 15:54:47 +09002780 }
2781 cc_library {
2782 name: "libvendor",
2783 vendor: true,
Jooyung Han91f92032022-02-04 12:36:33 +09002784 stl: "none",
2785 }
2786 apex {
2787 name: "myapex2",
2788 key: "myapex.key",
2789 binaries: ["mybin2"],
2790 vendor: true,
2791 use_vndk_as_stable: false,
2792 updatable: false,
2793 }
2794 cc_binary {
2795 name: "mybin2",
2796 vendor: true,
2797 shared_libs: ["libvndk", "libvendor"],
Jooyung Handf78e212020-07-22 15:54:47 +09002798 }
2799 `)
2800
Jiyong Parkf58c46e2021-04-01 21:35:20 +09002801 vendorVariant := "android_vendor.29_arm64_armv8-a"
Jooyung Handf78e212020-07-22 15:54:47 +09002802
Jooyung Han91f92032022-02-04 12:36:33 +09002803 for _, tc := range []struct {
2804 name string
2805 apexName string
2806 moduleName string
2807 moduleVariant string
2808 libs []string
2809 contents []string
2810 requireVndkNamespace bool
2811 }{
2812 {
2813 name: "use_vndk_as_stable",
2814 apexName: "myapex",
2815 moduleName: "mybin",
2816 moduleVariant: vendorVariant + "_apex10000",
2817 libs: []string{
2818 // should link with vendor variants of VNDK libs(libvndk/libc++)
2819 "out/soong/.intermediates/libvndk/" + vendorVariant + "_shared/libvndk.so",
2820 "out/soong/.intermediates/" + cc.DefaultCcCommonTestModulesDir + "libc++/" + vendorVariant + "_shared/libc++.so",
2821 // unstable Vendor libs as APEX variant
2822 "out/soong/.intermediates/libvendor/" + vendorVariant + "_shared_apex10000/libvendor.so",
2823 },
2824 contents: []string{
2825 "bin/mybin",
2826 "lib64/libvendor.so",
2827 // VNDK libs (libvndk/libc++) are not included
2828 },
2829 requireVndkNamespace: true,
2830 },
2831 {
2832 name: "!use_vndk_as_stable",
2833 apexName: "myapex2",
2834 moduleName: "mybin2",
2835 moduleVariant: vendorVariant + "_myapex2",
2836 libs: []string{
2837 // should link with "unique" APEX(myapex2) variant of VNDK libs(libvndk/libc++)
2838 "out/soong/.intermediates/libvndk/" + vendorVariant + "_shared_myapex2/libvndk.so",
2839 "out/soong/.intermediates/" + cc.DefaultCcCommonTestModulesDir + "libc++/" + vendorVariant + "_shared_myapex2/libc++.so",
2840 // unstable vendor libs have "merged" APEX variants
2841 "out/soong/.intermediates/libvendor/" + vendorVariant + "_shared_apex10000/libvendor.so",
2842 },
2843 contents: []string{
2844 "bin/mybin2",
2845 "lib64/libvendor.so",
2846 // VNDK libs are included as well
2847 "lib64/libvndk.so",
2848 "lib64/libc++.so",
2849 },
2850 requireVndkNamespace: false,
2851 },
2852 } {
2853 t.Run(tc.name, func(t *testing.T) {
2854 // Check linked libs
2855 ldRule := ctx.ModuleForTests(tc.moduleName, tc.moduleVariant).Rule("ld")
2856 libs := names(ldRule.Args["libFlags"])
2857 for _, lib := range tc.libs {
2858 ensureListContains(t, libs, lib)
2859 }
2860 // Check apex contents
2861 ensureExactContents(t, ctx, tc.apexName, "android_common_"+tc.apexName+"_image", tc.contents)
Jooyung Handf78e212020-07-22 15:54:47 +09002862
Jooyung Han91f92032022-02-04 12:36:33 +09002863 // Check "requireNativeLibs"
2864 apexManifestRule := ctx.ModuleForTests(tc.apexName, "android_common_"+tc.apexName+"_image").Rule("apexManifestRule")
2865 requireNativeLibs := names(apexManifestRule.Args["requireNativeLibs"])
2866 if tc.requireVndkNamespace {
2867 ensureListContains(t, requireNativeLibs, ":vndk")
2868 } else {
2869 ensureListNotContains(t, requireNativeLibs, ":vndk")
2870 }
2871 })
2872 }
Jooyung Handf78e212020-07-22 15:54:47 +09002873}
2874
Justin Yun13decfb2021-03-08 19:25:55 +09002875func TestProductVariant(t *testing.T) {
2876 ctx := testApex(t, `
2877 apex {
2878 name: "myapex",
2879 key: "myapex.key",
2880 updatable: false,
2881 product_specific: true,
2882 binaries: ["foo"],
2883 }
2884
2885 apex_key {
2886 name: "myapex.key",
2887 public_key: "testkey.avbpubkey",
2888 private_key: "testkey.pem",
2889 }
2890
2891 cc_binary {
2892 name: "foo",
2893 product_available: true,
2894 apex_available: ["myapex"],
2895 srcs: ["foo.cpp"],
2896 }
Paul Duffin0a49fdc2021-03-08 11:28:25 +00002897 `, android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
2898 variables.ProductVndkVersion = proptools.StringPtr("current")
2899 }),
2900 )
Justin Yun13decfb2021-03-08 19:25:55 +09002901
2902 cflags := strings.Fields(
Jooyung Han91f92032022-02-04 12:36:33 +09002903 ctx.ModuleForTests("foo", "android_product.29_arm64_armv8-a_myapex").Rule("cc").Args["cFlags"])
Justin Yun13decfb2021-03-08 19:25:55 +09002904 ensureListContains(t, cflags, "-D__ANDROID_VNDK__")
2905 ensureListContains(t, cflags, "-D__ANDROID_APEX__")
2906 ensureListContains(t, cflags, "-D__ANDROID_PRODUCT__")
2907 ensureListNotContains(t, cflags, "-D__ANDROID_VENDOR__")
2908}
2909
Jooyung Han8e5685d2020-09-21 11:02:57 +09002910func TestApex_withPrebuiltFirmware(t *testing.T) {
2911 testCases := []struct {
2912 name string
2913 additionalProp string
2914 }{
2915 {"system apex with prebuilt_firmware", ""},
2916 {"vendor apex with prebuilt_firmware", "vendor: true,"},
2917 }
2918 for _, tc := range testCases {
2919 t.Run(tc.name, func(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08002920 ctx := testApex(t, `
Jooyung Han8e5685d2020-09-21 11:02:57 +09002921 apex {
2922 name: "myapex",
2923 key: "myapex.key",
2924 prebuilts: ["myfirmware"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00002925 updatable: false,
Jooyung Han8e5685d2020-09-21 11:02:57 +09002926 `+tc.additionalProp+`
2927 }
2928 apex_key {
2929 name: "myapex.key",
2930 public_key: "testkey.avbpubkey",
2931 private_key: "testkey.pem",
2932 }
2933 prebuilt_firmware {
2934 name: "myfirmware",
2935 src: "myfirmware.bin",
2936 filename_from_src: true,
2937 `+tc.additionalProp+`
2938 }
2939 `)
2940 ensureExactContents(t, ctx, "myapex", "android_common_myapex_image", []string{
2941 "etc/firmware/myfirmware.bin",
2942 })
2943 })
2944 }
Jooyung Han0703fd82020-08-26 22:11:53 +09002945}
2946
Jooyung Hanefb184e2020-06-25 17:14:25 +09002947func TestAndroidMk_VendorApexRequired(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08002948 ctx := testApex(t, `
Jooyung Hanefb184e2020-06-25 17:14:25 +09002949 apex {
2950 name: "myapex",
2951 key: "myapex.key",
2952 vendor: true,
2953 native_shared_libs: ["mylib"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00002954 updatable: false,
Jooyung Hanefb184e2020-06-25 17:14:25 +09002955 }
2956
2957 apex_key {
2958 name: "myapex.key",
2959 public_key: "testkey.avbpubkey",
2960 private_key: "testkey.pem",
2961 }
2962
2963 cc_library {
2964 name: "mylib",
2965 vendor_available: true,
2966 }
2967 `)
2968
2969 apexBundle := ctx.ModuleForTests("myapex", "android_common_myapex_image").Module().(*apexBundle)
Colin Crossaa255532020-07-03 13:18:24 -07002970 data := android.AndroidMkDataForTest(t, ctx, apexBundle)
Jooyung Hanefb184e2020-06-25 17:14:25 +09002971 name := apexBundle.BaseModuleName()
2972 prefix := "TARGET_"
2973 var builder strings.Builder
2974 data.Custom(&builder, name, prefix, "", data)
2975 androidMk := builder.String()
2976 ensureContains(t, androidMk, "LOCAL_REQUIRED_MODULES += libc.vendor libm.vendor libdl.vendor\n")
2977}
2978
Jooyung Han2ed99d02020-06-24 23:26:26 +09002979func TestAndroidMkWritesCommonProperties(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08002980 ctx := testApex(t, `
Jooyung Han2ed99d02020-06-24 23:26:26 +09002981 apex {
2982 name: "myapex",
2983 key: "myapex.key",
2984 vintf_fragments: ["fragment.xml"],
2985 init_rc: ["init.rc"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00002986 updatable: false,
Jooyung Han2ed99d02020-06-24 23:26:26 +09002987 }
2988 apex_key {
2989 name: "myapex.key",
2990 public_key: "testkey.avbpubkey",
2991 private_key: "testkey.pem",
2992 }
2993 cc_binary {
2994 name: "mybin",
2995 }
2996 `)
2997
2998 apexBundle := ctx.ModuleForTests("myapex", "android_common_myapex_image").Module().(*apexBundle)
Colin Crossaa255532020-07-03 13:18:24 -07002999 data := android.AndroidMkDataForTest(t, ctx, apexBundle)
Jooyung Han2ed99d02020-06-24 23:26:26 +09003000 name := apexBundle.BaseModuleName()
3001 prefix := "TARGET_"
3002 var builder strings.Builder
3003 data.Custom(&builder, name, prefix, "", data)
3004 androidMk := builder.String()
Liz Kammer7b3dc8a2021-04-16 16:41:59 -04003005 ensureContains(t, androidMk, "LOCAL_FULL_VINTF_FRAGMENTS := fragment.xml\n")
Liz Kammer0c4f71c2021-04-06 10:35:10 -04003006 ensureContains(t, androidMk, "LOCAL_FULL_INIT_RC := init.rc\n")
Jooyung Han2ed99d02020-06-24 23:26:26 +09003007}
3008
Jiyong Park16e91a02018-12-20 18:18:08 +09003009func TestStaticLinking(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08003010 ctx := testApex(t, `
Jiyong Park16e91a02018-12-20 18:18:08 +09003011 apex {
3012 name: "myapex",
3013 key: "myapex.key",
3014 native_shared_libs: ["mylib"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00003015 updatable: false,
Jiyong Park16e91a02018-12-20 18:18:08 +09003016 }
3017
3018 apex_key {
3019 name: "myapex.key",
3020 public_key: "testkey.avbpubkey",
3021 private_key: "testkey.pem",
3022 }
3023
3024 cc_library {
3025 name: "mylib",
3026 srcs: ["mylib.cpp"],
3027 system_shared_libs: [],
3028 stl: "none",
3029 stubs: {
3030 versions: ["1", "2", "3"],
3031 },
Anton Hanssoneec79eb2020-01-10 15:12:39 +00003032 apex_available: [
3033 "//apex_available:platform",
3034 "myapex",
3035 ],
Jiyong Park16e91a02018-12-20 18:18:08 +09003036 }
3037
3038 cc_binary {
3039 name: "not_in_apex",
3040 srcs: ["mylib.cpp"],
3041 static_libs: ["mylib"],
3042 static_executable: true,
3043 system_shared_libs: [],
3044 stl: "none",
3045 }
Jiyong Park16e91a02018-12-20 18:18:08 +09003046 `)
3047
Colin Cross7113d202019-11-20 16:39:12 -08003048 ldFlags := ctx.ModuleForTests("not_in_apex", "android_arm64_armv8-a").Rule("ld").Args["libFlags"]
Jiyong Park16e91a02018-12-20 18:18:08 +09003049
3050 // Ensure that not_in_apex is linking with the static variant of mylib
Colin Cross7113d202019-11-20 16:39:12 -08003051 ensureContains(t, ldFlags, "mylib/android_arm64_armv8-a_static/mylib.a")
Jiyong Park16e91a02018-12-20 18:18:08 +09003052}
Jiyong Park9335a262018-12-24 11:31:58 +09003053
3054func TestKeys(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08003055 ctx := testApex(t, `
Jiyong Park9335a262018-12-24 11:31:58 +09003056 apex {
Jiyong Parkb2742fd2019-02-11 11:38:15 +09003057 name: "myapex_keytest",
Jiyong Park9335a262018-12-24 11:31:58 +09003058 key: "myapex.key",
Jiyong Parkb2742fd2019-02-11 11:38:15 +09003059 certificate: ":myapex.certificate",
Jiyong Park9335a262018-12-24 11:31:58 +09003060 native_shared_libs: ["mylib"],
Jooyung Han54aca7b2019-11-20 02:26:02 +09003061 file_contexts: ":myapex-file_contexts",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00003062 updatable: false,
Jiyong Park9335a262018-12-24 11:31:58 +09003063 }
3064
3065 cc_library {
3066 name: "mylib",
3067 srcs: ["mylib.cpp"],
3068 system_shared_libs: [],
3069 stl: "none",
Anton Hanssoneec79eb2020-01-10 15:12:39 +00003070 apex_available: [ "myapex_keytest" ],
Jiyong Park9335a262018-12-24 11:31:58 +09003071 }
3072
3073 apex_key {
3074 name: "myapex.key",
3075 public_key: "testkey.avbpubkey",
3076 private_key: "testkey.pem",
3077 }
3078
Jiyong Parkb2742fd2019-02-11 11:38:15 +09003079 android_app_certificate {
3080 name: "myapex.certificate",
3081 certificate: "testkey",
3082 }
3083
3084 android_app_certificate {
3085 name: "myapex.certificate.override",
3086 certificate: "testkey.override",
3087 }
3088
Jiyong Park9335a262018-12-24 11:31:58 +09003089 `)
3090
3091 // check the APEX keys
Jiyong Parkd1e293d2019-03-15 02:13:21 +09003092 keys := ctx.ModuleForTests("myapex.key", "android_common").Module().(*apexKey)
Jiyong Park9335a262018-12-24 11:31:58 +09003093
Jaewoong Jung18aefc12020-12-21 09:11:10 -08003094 if keys.publicKeyFile.String() != "vendor/foo/devkeys/testkey.avbpubkey" {
3095 t.Errorf("public key %q is not %q", keys.publicKeyFile.String(),
Jiyong Park9335a262018-12-24 11:31:58 +09003096 "vendor/foo/devkeys/testkey.avbpubkey")
3097 }
Jaewoong Jung18aefc12020-12-21 09:11:10 -08003098 if keys.privateKeyFile.String() != "vendor/foo/devkeys/testkey.pem" {
3099 t.Errorf("private key %q is not %q", keys.privateKeyFile.String(),
Jiyong Park9335a262018-12-24 11:31:58 +09003100 "vendor/foo/devkeys/testkey.pem")
3101 }
3102
Jiyong Parkb2742fd2019-02-11 11:38:15 +09003103 // check the APK certs. It should be overridden to myapex.certificate.override
Sundong Ahnabb64432019-10-22 13:58:29 +09003104 certs := ctx.ModuleForTests("myapex_keytest", "android_common_myapex_keytest_image").Rule("signapk").Args["certificates"]
Jiyong Parkb2742fd2019-02-11 11:38:15 +09003105 if certs != "testkey.override.x509.pem testkey.override.pk8" {
Jiyong Park9335a262018-12-24 11:31:58 +09003106 t.Errorf("cert and private key %q are not %q", certs,
Jiyong Parkb2742fd2019-02-11 11:38:15 +09003107 "testkey.override.509.pem testkey.override.pk8")
Jiyong Park9335a262018-12-24 11:31:58 +09003108 }
3109}
Jiyong Park58e364a2019-01-19 19:24:06 +09003110
Jooyung Hanf121a652019-12-17 14:30:11 +09003111func TestCertificate(t *testing.T) {
3112 t.Run("if unspecified, it defaults to DefaultAppCertificate", func(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08003113 ctx := testApex(t, `
Jooyung Hanf121a652019-12-17 14:30:11 +09003114 apex {
3115 name: "myapex",
3116 key: "myapex.key",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00003117 updatable: false,
Jooyung Hanf121a652019-12-17 14:30:11 +09003118 }
3119 apex_key {
3120 name: "myapex.key",
3121 public_key: "testkey.avbpubkey",
3122 private_key: "testkey.pem",
3123 }`)
3124 rule := ctx.ModuleForTests("myapex", "android_common_myapex_image").Rule("signapk")
3125 expected := "vendor/foo/devkeys/test.x509.pem vendor/foo/devkeys/test.pk8"
3126 if actual := rule.Args["certificates"]; actual != expected {
3127 t.Errorf("certificates should be %q, not %q", expected, actual)
3128 }
3129 })
3130 t.Run("override when unspecified", func(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08003131 ctx := testApex(t, `
Jooyung Hanf121a652019-12-17 14:30:11 +09003132 apex {
3133 name: "myapex_keytest",
3134 key: "myapex.key",
3135 file_contexts: ":myapex-file_contexts",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00003136 updatable: false,
Jooyung Hanf121a652019-12-17 14:30:11 +09003137 }
3138 apex_key {
3139 name: "myapex.key",
3140 public_key: "testkey.avbpubkey",
3141 private_key: "testkey.pem",
3142 }
3143 android_app_certificate {
3144 name: "myapex.certificate.override",
3145 certificate: "testkey.override",
3146 }`)
3147 rule := ctx.ModuleForTests("myapex_keytest", "android_common_myapex_keytest_image").Rule("signapk")
3148 expected := "testkey.override.x509.pem testkey.override.pk8"
3149 if actual := rule.Args["certificates"]; actual != expected {
3150 t.Errorf("certificates should be %q, not %q", expected, actual)
3151 }
3152 })
3153 t.Run("if specified as :module, it respects the prop", func(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08003154 ctx := testApex(t, `
Jooyung Hanf121a652019-12-17 14:30:11 +09003155 apex {
3156 name: "myapex",
3157 key: "myapex.key",
3158 certificate: ":myapex.certificate",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00003159 updatable: false,
Jooyung Hanf121a652019-12-17 14:30:11 +09003160 }
3161 apex_key {
3162 name: "myapex.key",
3163 public_key: "testkey.avbpubkey",
3164 private_key: "testkey.pem",
3165 }
3166 android_app_certificate {
3167 name: "myapex.certificate",
3168 certificate: "testkey",
3169 }`)
3170 rule := ctx.ModuleForTests("myapex", "android_common_myapex_image").Rule("signapk")
3171 expected := "testkey.x509.pem testkey.pk8"
3172 if actual := rule.Args["certificates"]; actual != expected {
3173 t.Errorf("certificates should be %q, not %q", expected, actual)
3174 }
3175 })
3176 t.Run("override when specifiec as <:module>", func(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08003177 ctx := testApex(t, `
Jooyung Hanf121a652019-12-17 14:30:11 +09003178 apex {
3179 name: "myapex_keytest",
3180 key: "myapex.key",
3181 file_contexts: ":myapex-file_contexts",
3182 certificate: ":myapex.certificate",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00003183 updatable: false,
Jooyung Hanf121a652019-12-17 14:30:11 +09003184 }
3185 apex_key {
3186 name: "myapex.key",
3187 public_key: "testkey.avbpubkey",
3188 private_key: "testkey.pem",
3189 }
3190 android_app_certificate {
3191 name: "myapex.certificate.override",
3192 certificate: "testkey.override",
3193 }`)
3194 rule := ctx.ModuleForTests("myapex_keytest", "android_common_myapex_keytest_image").Rule("signapk")
3195 expected := "testkey.override.x509.pem testkey.override.pk8"
3196 if actual := rule.Args["certificates"]; actual != expected {
3197 t.Errorf("certificates should be %q, not %q", expected, actual)
3198 }
3199 })
3200 t.Run("if specified as name, finds it from DefaultDevKeyDir", func(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08003201 ctx := testApex(t, `
Jooyung Hanf121a652019-12-17 14:30:11 +09003202 apex {
3203 name: "myapex",
3204 key: "myapex.key",
3205 certificate: "testkey",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00003206 updatable: false,
Jooyung Hanf121a652019-12-17 14:30:11 +09003207 }
3208 apex_key {
3209 name: "myapex.key",
3210 public_key: "testkey.avbpubkey",
3211 private_key: "testkey.pem",
3212 }`)
3213 rule := ctx.ModuleForTests("myapex", "android_common_myapex_image").Rule("signapk")
3214 expected := "vendor/foo/devkeys/testkey.x509.pem vendor/foo/devkeys/testkey.pk8"
3215 if actual := rule.Args["certificates"]; actual != expected {
3216 t.Errorf("certificates should be %q, not %q", expected, actual)
3217 }
3218 })
3219 t.Run("override when specified as <name>", func(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08003220 ctx := testApex(t, `
Jooyung Hanf121a652019-12-17 14:30:11 +09003221 apex {
3222 name: "myapex_keytest",
3223 key: "myapex.key",
3224 file_contexts: ":myapex-file_contexts",
3225 certificate: "testkey",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00003226 updatable: false,
Jooyung Hanf121a652019-12-17 14:30:11 +09003227 }
3228 apex_key {
3229 name: "myapex.key",
3230 public_key: "testkey.avbpubkey",
3231 private_key: "testkey.pem",
3232 }
3233 android_app_certificate {
3234 name: "myapex.certificate.override",
3235 certificate: "testkey.override",
3236 }`)
3237 rule := ctx.ModuleForTests("myapex_keytest", "android_common_myapex_keytest_image").Rule("signapk")
3238 expected := "testkey.override.x509.pem testkey.override.pk8"
3239 if actual := rule.Args["certificates"]; actual != expected {
3240 t.Errorf("certificates should be %q, not %q", expected, actual)
3241 }
3242 })
3243}
3244
Jiyong Park58e364a2019-01-19 19:24:06 +09003245func TestMacro(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08003246 ctx := testApex(t, `
Jiyong Park58e364a2019-01-19 19:24:06 +09003247 apex {
3248 name: "myapex",
3249 key: "myapex.key",
Jooyung Hanc87a0592020-03-02 17:44:33 +09003250 native_shared_libs: ["mylib", "mylib2"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00003251 updatable: false,
Jiyong Park58e364a2019-01-19 19:24:06 +09003252 }
3253
3254 apex {
3255 name: "otherapex",
3256 key: "myapex.key",
Jooyung Hanc87a0592020-03-02 17:44:33 +09003257 native_shared_libs: ["mylib", "mylib2"],
Jooyung Hanccce2f22020-03-07 03:45:53 +09003258 min_sdk_version: "29",
Jiyong Park58e364a2019-01-19 19:24:06 +09003259 }
3260
3261 apex_key {
3262 name: "myapex.key",
3263 public_key: "testkey.avbpubkey",
3264 private_key: "testkey.pem",
3265 }
3266
3267 cc_library {
3268 name: "mylib",
3269 srcs: ["mylib.cpp"],
3270 system_shared_libs: [],
3271 stl: "none",
Anton Hanssoneec79eb2020-01-10 15:12:39 +00003272 apex_available: [
Anton Hanssoneec79eb2020-01-10 15:12:39 +00003273 "myapex",
3274 "otherapex",
3275 ],
Jooyung Han24282772020-03-21 23:20:55 +09003276 recovery_available: true,
Jooyung Han749dc692020-04-15 11:03:39 +09003277 min_sdk_version: "29",
Jiyong Park58e364a2019-01-19 19:24:06 +09003278 }
Jooyung Hanc87a0592020-03-02 17:44:33 +09003279 cc_library {
3280 name: "mylib2",
3281 srcs: ["mylib.cpp"],
3282 system_shared_libs: [],
3283 stl: "none",
3284 apex_available: [
3285 "myapex",
3286 "otherapex",
3287 ],
Colin Crossaede88c2020-08-11 12:17:01 -07003288 static_libs: ["mylib3"],
3289 recovery_available: true,
3290 min_sdk_version: "29",
3291 }
3292 cc_library {
3293 name: "mylib3",
3294 srcs: ["mylib.cpp"],
3295 system_shared_libs: [],
3296 stl: "none",
3297 apex_available: [
3298 "myapex",
3299 "otherapex",
3300 ],
Colin Crossaede88c2020-08-11 12:17:01 -07003301 recovery_available: true,
Jooyung Han749dc692020-04-15 11:03:39 +09003302 min_sdk_version: "29",
Jooyung Hanc87a0592020-03-02 17:44:33 +09003303 }
Jiyong Park58e364a2019-01-19 19:24:06 +09003304 `)
3305
Jooyung Hanc87a0592020-03-02 17:44:33 +09003306 // non-APEX variant does not have __ANDROID_APEX__ defined
Colin Cross7113d202019-11-20 16:39:12 -08003307 mylibCFlags := ctx.ModuleForTests("mylib", "android_arm64_armv8-a_static").Rule("cc").Args["cFlags"]
Jooyung Han6b8459b2019-10-30 08:29:25 +09003308 ensureNotContains(t, mylibCFlags, "-D__ANDROID_APEX__")
Dan Albertb19953d2020-11-17 15:29:36 -08003309 ensureNotContains(t, mylibCFlags, "-D__ANDROID_APEX_MIN_SDK_VERSION__")
Jooyung Hanc87a0592020-03-02 17:44:33 +09003310
Jooyung Hanccce2f22020-03-07 03:45:53 +09003311 // APEX variant has __ANDROID_APEX__ and __ANDROID_APEX_SDK__ defined
Colin Crossaede88c2020-08-11 12:17:01 -07003312 mylibCFlags = ctx.ModuleForTests("mylib", "android_arm64_armv8-a_static_apex10000").Rule("cc").Args["cFlags"]
Jooyung Hanc87a0592020-03-02 17:44:33 +09003313 ensureContains(t, mylibCFlags, "-D__ANDROID_APEX__")
Dan Albertb19953d2020-11-17 15:29:36 -08003314 ensureContains(t, mylibCFlags, "-D__ANDROID_APEX_MIN_SDK_VERSION__=10000")
Jooyung Hanc87a0592020-03-02 17:44:33 +09003315
Jooyung Hanccce2f22020-03-07 03:45:53 +09003316 // APEX variant has __ANDROID_APEX__ and __ANDROID_APEX_SDK__ defined
Colin Crossaede88c2020-08-11 12:17:01 -07003317 mylibCFlags = ctx.ModuleForTests("mylib", "android_arm64_armv8-a_static_apex29").Rule("cc").Args["cFlags"]
Jooyung Hanc87a0592020-03-02 17:44:33 +09003318 ensureContains(t, mylibCFlags, "-D__ANDROID_APEX__")
Dan Albertb19953d2020-11-17 15:29:36 -08003319 ensureContains(t, mylibCFlags, "-D__ANDROID_APEX_MIN_SDK_VERSION__=29")
Jiyong Park58e364a2019-01-19 19:24:06 +09003320
Colin Crossaede88c2020-08-11 12:17:01 -07003321 // When a cc_library sets use_apex_name_macro: true each apex gets a unique variant and
3322 // each variant defines additional macros to distinguish which apex variant it is built for
3323
3324 // non-APEX variant does not have __ANDROID_APEX__ defined
3325 mylibCFlags = ctx.ModuleForTests("mylib3", "android_arm64_armv8-a_static").Rule("cc").Args["cFlags"]
3326 ensureNotContains(t, mylibCFlags, "-D__ANDROID_APEX__")
3327
Dan Albertb19953d2020-11-17 15:29:36 -08003328 // recovery variant does not set __ANDROID_APEX_MIN_SDK_VERSION__
Colin Crossaede88c2020-08-11 12:17:01 -07003329 mylibCFlags = ctx.ModuleForTests("mylib3", "android_recovery_arm64_armv8-a_static").Rule("cc").Args["cFlags"]
3330 ensureNotContains(t, mylibCFlags, "-D__ANDROID_APEX__")
Dan Albertb19953d2020-11-17 15:29:36 -08003331 ensureNotContains(t, mylibCFlags, "-D__ANDROID_APEX_MIN_SDK_VERSION__")
Colin Crossaede88c2020-08-11 12:17:01 -07003332
Jooyung Hanc87a0592020-03-02 17:44:33 +09003333 // non-APEX variant does not have __ANDROID_APEX__ defined
3334 mylibCFlags = ctx.ModuleForTests("mylib2", "android_arm64_armv8-a_static").Rule("cc").Args["cFlags"]
3335 ensureNotContains(t, mylibCFlags, "-D__ANDROID_APEX__")
3336
Dan Albertb19953d2020-11-17 15:29:36 -08003337 // recovery variant does not set __ANDROID_APEX_MIN_SDK_VERSION__
Colin Crossaede88c2020-08-11 12:17:01 -07003338 mylibCFlags = ctx.ModuleForTests("mylib2", "android_recovery_arm64_armv8-a_static").Rule("cc").Args["cFlags"]
Jooyung Han24282772020-03-21 23:20:55 +09003339 ensureNotContains(t, mylibCFlags, "-D__ANDROID_APEX__")
Dan Albertb19953d2020-11-17 15:29:36 -08003340 ensureNotContains(t, mylibCFlags, "-D__ANDROID_APEX_MIN_SDK_VERSION__")
Jiyong Park58e364a2019-01-19 19:24:06 +09003341}
Jiyong Park7e636d02019-01-28 16:16:54 +09003342
3343func TestHeaderLibsDependency(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08003344 ctx := testApex(t, `
Jiyong Park7e636d02019-01-28 16:16:54 +09003345 apex {
3346 name: "myapex",
3347 key: "myapex.key",
3348 native_shared_libs: ["mylib"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00003349 updatable: false,
Jiyong Park7e636d02019-01-28 16:16:54 +09003350 }
3351
3352 apex_key {
3353 name: "myapex.key",
3354 public_key: "testkey.avbpubkey",
3355 private_key: "testkey.pem",
3356 }
3357
3358 cc_library_headers {
3359 name: "mylib_headers",
3360 export_include_dirs: ["my_include"],
3361 system_shared_libs: [],
3362 stl: "none",
Jiyong Park0f80c182020-01-31 02:49:53 +09003363 apex_available: [ "myapex" ],
Jiyong Park7e636d02019-01-28 16:16:54 +09003364 }
3365
3366 cc_library {
3367 name: "mylib",
3368 srcs: ["mylib.cpp"],
3369 system_shared_libs: [],
3370 stl: "none",
3371 header_libs: ["mylib_headers"],
3372 export_header_lib_headers: ["mylib_headers"],
3373 stubs: {
3374 versions: ["1", "2", "3"],
3375 },
Anton Hanssoneec79eb2020-01-10 15:12:39 +00003376 apex_available: [ "myapex" ],
Jiyong Park7e636d02019-01-28 16:16:54 +09003377 }
3378
3379 cc_library {
3380 name: "otherlib",
3381 srcs: ["mylib.cpp"],
3382 system_shared_libs: [],
3383 stl: "none",
3384 shared_libs: ["mylib"],
3385 }
3386 `)
3387
Colin Cross7113d202019-11-20 16:39:12 -08003388 cFlags := ctx.ModuleForTests("otherlib", "android_arm64_armv8-a_static").Rule("cc").Args["cFlags"]
Jiyong Park7e636d02019-01-28 16:16:54 +09003389
3390 // Ensure that the include path of the header lib is exported to 'otherlib'
3391 ensureContains(t, cFlags, "-Imy_include")
3392}
Alex Light9670d332019-01-29 18:07:33 -08003393
Jiyong Park7cd10e32020-01-14 09:22:18 +09003394type fileInApex struct {
3395 path string // path in apex
Jooyung Hana57af4a2020-01-23 05:36:59 +00003396 src string // src path
Jiyong Park7cd10e32020-01-14 09:22:18 +09003397 isLink bool
3398}
3399
Jooyung Hana57af4a2020-01-23 05:36:59 +00003400func getFiles(t *testing.T, ctx *android.TestContext, moduleName, variant string) []fileInApex {
Jooyung Han31c470b2019-10-18 16:26:59 +09003401 t.Helper()
Jooyung Hana57af4a2020-01-23 05:36:59 +00003402 apexRule := ctx.ModuleForTests(moduleName, variant).Rule("apexRule")
Jooyung Han31c470b2019-10-18 16:26:59 +09003403 copyCmds := apexRule.Args["copy_commands"]
3404 imageApexDir := "/image.apex/"
Jiyong Park7cd10e32020-01-14 09:22:18 +09003405 var ret []fileInApex
Jooyung Han31c470b2019-10-18 16:26:59 +09003406 for _, cmd := range strings.Split(copyCmds, "&&") {
3407 cmd = strings.TrimSpace(cmd)
3408 if cmd == "" {
3409 continue
3410 }
3411 terms := strings.Split(cmd, " ")
Jooyung Hana57af4a2020-01-23 05:36:59 +00003412 var dst, src string
Jiyong Park7cd10e32020-01-14 09:22:18 +09003413 var isLink bool
Jooyung Han31c470b2019-10-18 16:26:59 +09003414 switch terms[0] {
3415 case "mkdir":
3416 case "cp":
Jiyong Park7cd10e32020-01-14 09:22:18 +09003417 if len(terms) != 3 && len(terms) != 4 {
Jooyung Han31c470b2019-10-18 16:26:59 +09003418 t.Fatal("copyCmds contains invalid cp command", cmd)
3419 }
Jiyong Park7cd10e32020-01-14 09:22:18 +09003420 dst = terms[len(terms)-1]
Jooyung Hana57af4a2020-01-23 05:36:59 +00003421 src = terms[len(terms)-2]
Jiyong Park7cd10e32020-01-14 09:22:18 +09003422 isLink = false
3423 case "ln":
3424 if len(terms) != 3 && len(terms) != 4 {
3425 // ln LINK TARGET or ln -s LINK TARGET
3426 t.Fatal("copyCmds contains invalid ln command", cmd)
3427 }
3428 dst = terms[len(terms)-1]
Jooyung Hana57af4a2020-01-23 05:36:59 +00003429 src = terms[len(terms)-2]
Jiyong Park7cd10e32020-01-14 09:22:18 +09003430 isLink = true
3431 default:
3432 t.Fatalf("copyCmds should contain mkdir/cp commands only: %q", cmd)
3433 }
3434 if dst != "" {
Jooyung Han31c470b2019-10-18 16:26:59 +09003435 index := strings.Index(dst, imageApexDir)
3436 if index == -1 {
3437 t.Fatal("copyCmds should copy a file to image.apex/", cmd)
3438 }
3439 dstFile := dst[index+len(imageApexDir):]
Jooyung Hana57af4a2020-01-23 05:36:59 +00003440 ret = append(ret, fileInApex{path: dstFile, src: src, isLink: isLink})
Jooyung Han31c470b2019-10-18 16:26:59 +09003441 }
3442 }
Jiyong Park7cd10e32020-01-14 09:22:18 +09003443 return ret
3444}
3445
Jooyung Hana57af4a2020-01-23 05:36:59 +00003446func ensureExactContents(t *testing.T, ctx *android.TestContext, moduleName, variant string, files []string) {
3447 t.Helper()
Jiyong Park7cd10e32020-01-14 09:22:18 +09003448 var failed bool
3449 var surplus []string
3450 filesMatched := make(map[string]bool)
Jooyung Hana57af4a2020-01-23 05:36:59 +00003451 for _, file := range getFiles(t, ctx, moduleName, variant) {
Jooyung Hane6436d72020-02-27 13:31:56 +09003452 mactchFound := false
Jiyong Park7cd10e32020-01-14 09:22:18 +09003453 for _, expected := range files {
3454 if matched, _ := path.Match(expected, file.path); matched {
3455 filesMatched[expected] = true
Jooyung Hane6436d72020-02-27 13:31:56 +09003456 mactchFound = true
3457 break
Jiyong Park7cd10e32020-01-14 09:22:18 +09003458 }
3459 }
Jooyung Hane6436d72020-02-27 13:31:56 +09003460 if !mactchFound {
3461 surplus = append(surplus, file.path)
3462 }
Jiyong Park7cd10e32020-01-14 09:22:18 +09003463 }
Jooyung Han31c470b2019-10-18 16:26:59 +09003464
Jooyung Han31c470b2019-10-18 16:26:59 +09003465 if len(surplus) > 0 {
Jooyung Han39edb6c2019-11-06 16:53:07 +09003466 sort.Strings(surplus)
Jooyung Han31c470b2019-10-18 16:26:59 +09003467 t.Log("surplus files", surplus)
3468 failed = true
3469 }
Jooyung Han39edb6c2019-11-06 16:53:07 +09003470
3471 if len(files) > len(filesMatched) {
3472 var missing []string
3473 for _, expected := range files {
3474 if !filesMatched[expected] {
3475 missing = append(missing, expected)
3476 }
3477 }
3478 sort.Strings(missing)
Jooyung Han31c470b2019-10-18 16:26:59 +09003479 t.Log("missing files", missing)
3480 failed = true
3481 }
3482 if failed {
3483 t.Fail()
3484 }
3485}
3486
Jooyung Han344d5432019-08-23 11:17:39 +09003487func TestVndkApexCurrent(t *testing.T) {
Jooyung Han7d6e79b2021-06-24 01:53:43 +09003488 commonFiles := []string{
Jooyung Hane6436d72020-02-27 13:31:56 +09003489 "lib/libc++.so",
Jooyung Hane6436d72020-02-27 13:31:56 +09003490 "lib64/libc++.so",
Jiyong Parkf58c46e2021-04-01 21:35:20 +09003491 "etc/llndk.libraries.29.txt",
3492 "etc/vndkcore.libraries.29.txt",
3493 "etc/vndksp.libraries.29.txt",
3494 "etc/vndkprivate.libraries.29.txt",
3495 "etc/vndkproduct.libraries.29.txt",
Jooyung Han7d6e79b2021-06-24 01:53:43 +09003496 }
3497 testCases := []struct {
3498 vndkVersion string
3499 expectedFiles []string
3500 }{
3501 {
3502 vndkVersion: "current",
3503 expectedFiles: append(commonFiles,
3504 "lib/libvndk.so",
3505 "lib/libvndksp.so",
3506 "lib64/libvndk.so",
3507 "lib64/libvndksp.so"),
3508 },
3509 {
3510 vndkVersion: "",
3511 expectedFiles: append(commonFiles,
3512 // Legacy VNDK APEX contains only VNDK-SP files (of core variant)
3513 "lib/libvndksp.so",
3514 "lib64/libvndksp.so"),
3515 },
3516 }
3517 for _, tc := range testCases {
3518 t.Run("VNDK.current with DeviceVndkVersion="+tc.vndkVersion, func(t *testing.T) {
3519 ctx := testApex(t, `
3520 apex_vndk {
3521 name: "com.android.vndk.current",
3522 key: "com.android.vndk.current.key",
3523 updatable: false,
3524 }
3525
3526 apex_key {
3527 name: "com.android.vndk.current.key",
3528 public_key: "testkey.avbpubkey",
3529 private_key: "testkey.pem",
3530 }
3531
3532 cc_library {
3533 name: "libvndk",
3534 srcs: ["mylib.cpp"],
3535 vendor_available: true,
3536 product_available: true,
3537 vndk: {
3538 enabled: true,
3539 },
3540 system_shared_libs: [],
3541 stl: "none",
3542 apex_available: [ "com.android.vndk.current" ],
3543 }
3544
3545 cc_library {
3546 name: "libvndksp",
3547 srcs: ["mylib.cpp"],
3548 vendor_available: true,
3549 product_available: true,
3550 vndk: {
3551 enabled: true,
3552 support_system_process: true,
3553 },
3554 system_shared_libs: [],
3555 stl: "none",
3556 apex_available: [ "com.android.vndk.current" ],
3557 }
3558
3559 // VNDK-Ext should not cause any problems
3560
3561 cc_library {
3562 name: "libvndk.ext",
3563 srcs: ["mylib2.cpp"],
3564 vendor: true,
3565 vndk: {
3566 enabled: true,
3567 extends: "libvndk",
3568 },
3569 system_shared_libs: [],
3570 stl: "none",
3571 }
3572
3573 cc_library {
3574 name: "libvndksp.ext",
3575 srcs: ["mylib2.cpp"],
3576 vendor: true,
3577 vndk: {
3578 enabled: true,
3579 support_system_process: true,
3580 extends: "libvndksp",
3581 },
3582 system_shared_libs: [],
3583 stl: "none",
3584 }
3585 `+vndkLibrariesTxtFiles("current"), android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
3586 variables.DeviceVndkVersion = proptools.StringPtr(tc.vndkVersion)
3587 }))
3588 ensureExactContents(t, ctx, "com.android.vndk.current", "android_common_image", tc.expectedFiles)
3589 })
3590 }
Jooyung Han344d5432019-08-23 11:17:39 +09003591}
3592
3593func TestVndkApexWithPrebuilt(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08003594 ctx := testApex(t, `
Jooyung Han344d5432019-08-23 11:17:39 +09003595 apex_vndk {
Colin Cross2807f002021-03-02 10:15:29 -08003596 name: "com.android.vndk.current",
3597 key: "com.android.vndk.current.key",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00003598 updatable: false,
Jooyung Han344d5432019-08-23 11:17:39 +09003599 }
3600
3601 apex_key {
Colin Cross2807f002021-03-02 10:15:29 -08003602 name: "com.android.vndk.current.key",
Jooyung Han344d5432019-08-23 11:17:39 +09003603 public_key: "testkey.avbpubkey",
3604 private_key: "testkey.pem",
3605 }
3606
3607 cc_prebuilt_library_shared {
Jooyung Han31c470b2019-10-18 16:26:59 +09003608 name: "libvndk",
3609 srcs: ["libvndk.so"],
Jooyung Han344d5432019-08-23 11:17:39 +09003610 vendor_available: true,
Justin Yun63e9ec72020-10-29 16:49:43 +09003611 product_available: true,
Jooyung Han344d5432019-08-23 11:17:39 +09003612 vndk: {
3613 enabled: true,
3614 },
3615 system_shared_libs: [],
3616 stl: "none",
Colin Cross2807f002021-03-02 10:15:29 -08003617 apex_available: [ "com.android.vndk.current" ],
Jooyung Han344d5432019-08-23 11:17:39 +09003618 }
Jooyung Han31c470b2019-10-18 16:26:59 +09003619
3620 cc_prebuilt_library_shared {
3621 name: "libvndk.arm",
3622 srcs: ["libvndk.arm.so"],
3623 vendor_available: true,
Justin Yun63e9ec72020-10-29 16:49:43 +09003624 product_available: true,
Jooyung Han31c470b2019-10-18 16:26:59 +09003625 vndk: {
3626 enabled: true,
3627 },
3628 enabled: false,
3629 arch: {
3630 arm: {
3631 enabled: true,
3632 },
3633 },
3634 system_shared_libs: [],
3635 stl: "none",
Colin Cross2807f002021-03-02 10:15:29 -08003636 apex_available: [ "com.android.vndk.current" ],
Jooyung Han31c470b2019-10-18 16:26:59 +09003637 }
Jooyung Han39edb6c2019-11-06 16:53:07 +09003638 `+vndkLibrariesTxtFiles("current"),
3639 withFiles(map[string][]byte{
3640 "libvndk.so": nil,
3641 "libvndk.arm.so": nil,
3642 }))
Colin Cross2807f002021-03-02 10:15:29 -08003643 ensureExactContents(t, ctx, "com.android.vndk.current", "android_common_image", []string{
Jooyung Han31c470b2019-10-18 16:26:59 +09003644 "lib/libvndk.so",
3645 "lib/libvndk.arm.so",
3646 "lib64/libvndk.so",
Jooyung Hane6436d72020-02-27 13:31:56 +09003647 "lib/libc++.so",
3648 "lib64/libc++.so",
Jooyung Han39edb6c2019-11-06 16:53:07 +09003649 "etc/*",
Jooyung Han31c470b2019-10-18 16:26:59 +09003650 })
Jooyung Han344d5432019-08-23 11:17:39 +09003651}
3652
Jooyung Han39edb6c2019-11-06 16:53:07 +09003653func vndkLibrariesTxtFiles(vers ...string) (result string) {
3654 for _, v := range vers {
3655 if v == "current" {
Justin Yun8a2600c2020-12-07 12:44:03 +09003656 for _, txt := range []string{"llndk", "vndkcore", "vndksp", "vndkprivate", "vndkproduct"} {
Jooyung Han39edb6c2019-11-06 16:53:07 +09003657 result += `
Colin Crosse4e44bc2020-12-28 13:50:21 -08003658 ` + txt + `_libraries_txt {
Jooyung Han39edb6c2019-11-06 16:53:07 +09003659 name: "` + txt + `.libraries.txt",
3660 }
3661 `
3662 }
3663 } else {
Justin Yun8a2600c2020-12-07 12:44:03 +09003664 for _, txt := range []string{"llndk", "vndkcore", "vndksp", "vndkprivate", "vndkproduct"} {
Jooyung Han39edb6c2019-11-06 16:53:07 +09003665 result += `
3666 prebuilt_etc {
3667 name: "` + txt + `.libraries.` + v + `.txt",
3668 src: "dummy.txt",
3669 }
3670 `
3671 }
3672 }
3673 }
3674 return
3675}
3676
Jooyung Han344d5432019-08-23 11:17:39 +09003677func TestVndkApexVersion(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08003678 ctx := testApex(t, `
Jooyung Han344d5432019-08-23 11:17:39 +09003679 apex_vndk {
Colin Cross2807f002021-03-02 10:15:29 -08003680 name: "com.android.vndk.v27",
Jooyung Han344d5432019-08-23 11:17:39 +09003681 key: "myapex.key",
Jooyung Han54aca7b2019-11-20 02:26:02 +09003682 file_contexts: ":myapex-file_contexts",
Jooyung Han344d5432019-08-23 11:17:39 +09003683 vndk_version: "27",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00003684 updatable: false,
Jooyung Han344d5432019-08-23 11:17:39 +09003685 }
3686
3687 apex_key {
3688 name: "myapex.key",
3689 public_key: "testkey.avbpubkey",
3690 private_key: "testkey.pem",
3691 }
3692
Jooyung Han31c470b2019-10-18 16:26:59 +09003693 vndk_prebuilt_shared {
3694 name: "libvndk27",
3695 version: "27",
Jooyung Han344d5432019-08-23 11:17:39 +09003696 vendor_available: true,
Justin Yun63e9ec72020-10-29 16:49:43 +09003697 product_available: true,
Jooyung Han344d5432019-08-23 11:17:39 +09003698 vndk: {
3699 enabled: true,
3700 },
Jooyung Han31c470b2019-10-18 16:26:59 +09003701 target_arch: "arm64",
3702 arch: {
3703 arm: {
3704 srcs: ["libvndk27_arm.so"],
3705 },
3706 arm64: {
3707 srcs: ["libvndk27_arm64.so"],
3708 },
3709 },
Colin Cross2807f002021-03-02 10:15:29 -08003710 apex_available: [ "com.android.vndk.v27" ],
Jooyung Han344d5432019-08-23 11:17:39 +09003711 }
3712
3713 vndk_prebuilt_shared {
3714 name: "libvndk27",
3715 version: "27",
3716 vendor_available: true,
Justin Yun63e9ec72020-10-29 16:49:43 +09003717 product_available: true,
Jooyung Han344d5432019-08-23 11:17:39 +09003718 vndk: {
3719 enabled: true,
3720 },
Jooyung Han31c470b2019-10-18 16:26:59 +09003721 target_arch: "x86_64",
3722 arch: {
3723 x86: {
3724 srcs: ["libvndk27_x86.so"],
3725 },
3726 x86_64: {
3727 srcs: ["libvndk27_x86_64.so"],
3728 },
3729 },
Jooyung Han39edb6c2019-11-06 16:53:07 +09003730 }
3731 `+vndkLibrariesTxtFiles("27"),
3732 withFiles(map[string][]byte{
3733 "libvndk27_arm.so": nil,
3734 "libvndk27_arm64.so": nil,
3735 "libvndk27_x86.so": nil,
3736 "libvndk27_x86_64.so": nil,
3737 }))
Jooyung Han344d5432019-08-23 11:17:39 +09003738
Colin Cross2807f002021-03-02 10:15:29 -08003739 ensureExactContents(t, ctx, "com.android.vndk.v27", "android_common_image", []string{
Jooyung Han31c470b2019-10-18 16:26:59 +09003740 "lib/libvndk27_arm.so",
3741 "lib64/libvndk27_arm64.so",
Jooyung Han39edb6c2019-11-06 16:53:07 +09003742 "etc/*",
Jooyung Han31c470b2019-10-18 16:26:59 +09003743 })
Jooyung Han344d5432019-08-23 11:17:39 +09003744}
3745
Jooyung Han90eee022019-10-01 20:02:42 +09003746func TestVndkApexNameRule(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08003747 ctx := testApex(t, `
Jooyung Han90eee022019-10-01 20:02:42 +09003748 apex_vndk {
Colin Cross2807f002021-03-02 10:15:29 -08003749 name: "com.android.vndk.current",
Jooyung Han90eee022019-10-01 20:02:42 +09003750 key: "myapex.key",
Jooyung Han54aca7b2019-11-20 02:26:02 +09003751 file_contexts: ":myapex-file_contexts",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00003752 updatable: false,
Jooyung Han90eee022019-10-01 20:02:42 +09003753 }
3754 apex_vndk {
Colin Cross2807f002021-03-02 10:15:29 -08003755 name: "com.android.vndk.v28",
Jooyung Han90eee022019-10-01 20:02:42 +09003756 key: "myapex.key",
Jooyung Han54aca7b2019-11-20 02:26:02 +09003757 file_contexts: ":myapex-file_contexts",
Jooyung Han90eee022019-10-01 20:02:42 +09003758 vndk_version: "28",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00003759 updatable: false,
Jooyung Han90eee022019-10-01 20:02:42 +09003760 }
3761 apex_key {
3762 name: "myapex.key",
3763 public_key: "testkey.avbpubkey",
3764 private_key: "testkey.pem",
Jooyung Han39edb6c2019-11-06 16:53:07 +09003765 }`+vndkLibrariesTxtFiles("28", "current"))
Jooyung Han90eee022019-10-01 20:02:42 +09003766
3767 assertApexName := func(expected, moduleName string) {
Jooyung Hana57af4a2020-01-23 05:36:59 +00003768 bundle := ctx.ModuleForTests(moduleName, "android_common_image").Module().(*apexBundle)
Jooyung Han90eee022019-10-01 20:02:42 +09003769 actual := proptools.String(bundle.properties.Apex_name)
3770 if !reflect.DeepEqual(actual, expected) {
3771 t.Errorf("Got '%v', expected '%v'", actual, expected)
3772 }
3773 }
3774
Jiyong Parkf58c46e2021-04-01 21:35:20 +09003775 assertApexName("com.android.vndk.v29", "com.android.vndk.current")
Colin Cross2807f002021-03-02 10:15:29 -08003776 assertApexName("com.android.vndk.v28", "com.android.vndk.v28")
Jooyung Han90eee022019-10-01 20:02:42 +09003777}
3778
Jooyung Han344d5432019-08-23 11:17:39 +09003779func TestVndkApexSkipsNativeBridgeSupportedModules(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08003780 ctx := testApex(t, `
Jooyung Han344d5432019-08-23 11:17:39 +09003781 apex_vndk {
Colin Cross2807f002021-03-02 10:15:29 -08003782 name: "com.android.vndk.current",
3783 key: "com.android.vndk.current.key",
Jooyung Han54aca7b2019-11-20 02:26:02 +09003784 file_contexts: ":myapex-file_contexts",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00003785 updatable: false,
Jooyung Han344d5432019-08-23 11:17:39 +09003786 }
3787
3788 apex_key {
Colin Cross2807f002021-03-02 10:15:29 -08003789 name: "com.android.vndk.current.key",
Jooyung Han344d5432019-08-23 11:17:39 +09003790 public_key: "testkey.avbpubkey",
3791 private_key: "testkey.pem",
3792 }
3793
3794 cc_library {
3795 name: "libvndk",
3796 srcs: ["mylib.cpp"],
3797 vendor_available: true,
Justin Yun63e9ec72020-10-29 16:49:43 +09003798 product_available: true,
Jooyung Han344d5432019-08-23 11:17:39 +09003799 native_bridge_supported: true,
3800 host_supported: true,
3801 vndk: {
3802 enabled: true,
3803 },
3804 system_shared_libs: [],
3805 stl: "none",
Colin Cross2807f002021-03-02 10:15:29 -08003806 apex_available: [ "com.android.vndk.current" ],
Jooyung Han344d5432019-08-23 11:17:39 +09003807 }
Colin Cross2807f002021-03-02 10:15:29 -08003808 `+vndkLibrariesTxtFiles("current"),
3809 withNativeBridgeEnabled)
Jooyung Han344d5432019-08-23 11:17:39 +09003810
Colin Cross2807f002021-03-02 10:15:29 -08003811 ensureExactContents(t, ctx, "com.android.vndk.current", "android_common_image", []string{
Jooyung Han31c470b2019-10-18 16:26:59 +09003812 "lib/libvndk.so",
3813 "lib64/libvndk.so",
Jooyung Hane6436d72020-02-27 13:31:56 +09003814 "lib/libc++.so",
3815 "lib64/libc++.so",
Jooyung Han39edb6c2019-11-06 16:53:07 +09003816 "etc/*",
Jooyung Han31c470b2019-10-18 16:26:59 +09003817 })
Jooyung Han344d5432019-08-23 11:17:39 +09003818}
3819
3820func TestVndkApexDoesntSupportNativeBridgeSupported(t *testing.T) {
Colin Cross2807f002021-03-02 10:15:29 -08003821 testApexError(t, `module "com.android.vndk.current" .*: native_bridge_supported: .* doesn't support native bridge binary`, `
Jooyung Han344d5432019-08-23 11:17:39 +09003822 apex_vndk {
Colin Cross2807f002021-03-02 10:15:29 -08003823 name: "com.android.vndk.current",
3824 key: "com.android.vndk.current.key",
Jooyung Han54aca7b2019-11-20 02:26:02 +09003825 file_contexts: ":myapex-file_contexts",
Jooyung Han344d5432019-08-23 11:17:39 +09003826 native_bridge_supported: true,
3827 }
3828
3829 apex_key {
Colin Cross2807f002021-03-02 10:15:29 -08003830 name: "com.android.vndk.current.key",
Jooyung Han344d5432019-08-23 11:17:39 +09003831 public_key: "testkey.avbpubkey",
3832 private_key: "testkey.pem",
3833 }
3834
3835 cc_library {
3836 name: "libvndk",
3837 srcs: ["mylib.cpp"],
3838 vendor_available: true,
Justin Yun63e9ec72020-10-29 16:49:43 +09003839 product_available: true,
Jooyung Han344d5432019-08-23 11:17:39 +09003840 native_bridge_supported: true,
3841 host_supported: true,
3842 vndk: {
3843 enabled: true,
3844 },
3845 system_shared_libs: [],
3846 stl: "none",
3847 }
3848 `)
3849}
3850
Jooyung Han31c470b2019-10-18 16:26:59 +09003851func TestVndkApexWithBinder32(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08003852 ctx := testApex(t, `
Jooyung Han31c470b2019-10-18 16:26:59 +09003853 apex_vndk {
Colin Cross2807f002021-03-02 10:15:29 -08003854 name: "com.android.vndk.v27",
Jooyung Han31c470b2019-10-18 16:26:59 +09003855 key: "myapex.key",
Jooyung Han54aca7b2019-11-20 02:26:02 +09003856 file_contexts: ":myapex-file_contexts",
Jooyung Han31c470b2019-10-18 16:26:59 +09003857 vndk_version: "27",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00003858 updatable: false,
Jooyung Han31c470b2019-10-18 16:26:59 +09003859 }
3860
3861 apex_key {
3862 name: "myapex.key",
3863 public_key: "testkey.avbpubkey",
3864 private_key: "testkey.pem",
3865 }
3866
3867 vndk_prebuilt_shared {
3868 name: "libvndk27",
3869 version: "27",
3870 target_arch: "arm",
3871 vendor_available: true,
Justin Yun63e9ec72020-10-29 16:49:43 +09003872 product_available: true,
Jooyung Han31c470b2019-10-18 16:26:59 +09003873 vndk: {
3874 enabled: true,
3875 },
3876 arch: {
3877 arm: {
3878 srcs: ["libvndk27.so"],
3879 }
3880 },
3881 }
3882
3883 vndk_prebuilt_shared {
3884 name: "libvndk27",
3885 version: "27",
3886 target_arch: "arm",
3887 binder32bit: true,
3888 vendor_available: true,
Justin Yun63e9ec72020-10-29 16:49:43 +09003889 product_available: true,
Jooyung Han31c470b2019-10-18 16:26:59 +09003890 vndk: {
3891 enabled: true,
3892 },
3893 arch: {
3894 arm: {
3895 srcs: ["libvndk27binder32.so"],
3896 }
3897 },
Colin Cross2807f002021-03-02 10:15:29 -08003898 apex_available: [ "com.android.vndk.v27" ],
Jooyung Han31c470b2019-10-18 16:26:59 +09003899 }
Jooyung Han39edb6c2019-11-06 16:53:07 +09003900 `+vndkLibrariesTxtFiles("27"),
Jooyung Han31c470b2019-10-18 16:26:59 +09003901 withFiles(map[string][]byte{
3902 "libvndk27.so": nil,
3903 "libvndk27binder32.so": nil,
3904 }),
3905 withBinder32bit,
3906 withTargets(map[android.OsType][]android.Target{
3907 android.Android: []android.Target{
Jooyung Han35155c42020-02-06 17:33:20 +09003908 {Os: android.Android, Arch: android.Arch{ArchType: android.Arm, ArchVariant: "armv7-a-neon", Abi: []string{"armeabi-v7a"}},
3909 NativeBridge: android.NativeBridgeDisabled, NativeBridgeHostArchName: "", NativeBridgeRelativePath: ""},
Jooyung Han31c470b2019-10-18 16:26:59 +09003910 },
3911 }),
3912 )
3913
Colin Cross2807f002021-03-02 10:15:29 -08003914 ensureExactContents(t, ctx, "com.android.vndk.v27", "android_common_image", []string{
Jooyung Han31c470b2019-10-18 16:26:59 +09003915 "lib/libvndk27binder32.so",
Jooyung Han39edb6c2019-11-06 16:53:07 +09003916 "etc/*",
Jooyung Han31c470b2019-10-18 16:26:59 +09003917 })
3918}
3919
Jooyung Han45a96772020-06-15 14:59:42 +09003920func TestVndkApexShouldNotProvideNativeLibs(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08003921 ctx := testApex(t, `
Jooyung Han45a96772020-06-15 14:59:42 +09003922 apex_vndk {
Colin Cross2807f002021-03-02 10:15:29 -08003923 name: "com.android.vndk.current",
3924 key: "com.android.vndk.current.key",
Jooyung Han45a96772020-06-15 14:59:42 +09003925 file_contexts: ":myapex-file_contexts",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00003926 updatable: false,
Jooyung Han45a96772020-06-15 14:59:42 +09003927 }
3928
3929 apex_key {
Colin Cross2807f002021-03-02 10:15:29 -08003930 name: "com.android.vndk.current.key",
Jooyung Han45a96772020-06-15 14:59:42 +09003931 public_key: "testkey.avbpubkey",
3932 private_key: "testkey.pem",
3933 }
3934
3935 cc_library {
3936 name: "libz",
3937 vendor_available: true,
Justin Yun63e9ec72020-10-29 16:49:43 +09003938 product_available: true,
Jooyung Han45a96772020-06-15 14:59:42 +09003939 vndk: {
3940 enabled: true,
3941 },
3942 stubs: {
3943 symbol_file: "libz.map.txt",
3944 versions: ["30"],
3945 }
3946 }
3947 `+vndkLibrariesTxtFiles("current"), withFiles(map[string][]byte{
3948 "libz.map.txt": nil,
3949 }))
3950
Colin Cross2807f002021-03-02 10:15:29 -08003951 apexManifestRule := ctx.ModuleForTests("com.android.vndk.current", "android_common_image").Rule("apexManifestRule")
Jooyung Han45a96772020-06-15 14:59:42 +09003952 provideNativeLibs := names(apexManifestRule.Args["provideNativeLibs"])
3953 ensureListEmpty(t, provideNativeLibs)
3954}
3955
Jooyung Hane1633032019-08-01 17:41:43 +09003956func TestDependenciesInApexManifest(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08003957 ctx := testApex(t, `
Jooyung Hane1633032019-08-01 17:41:43 +09003958 apex {
3959 name: "myapex_nodep",
3960 key: "myapex.key",
3961 native_shared_libs: ["lib_nodep"],
3962 compile_multilib: "both",
Jooyung Han54aca7b2019-11-20 02:26:02 +09003963 file_contexts: ":myapex-file_contexts",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00003964 updatable: false,
Jooyung Hane1633032019-08-01 17:41:43 +09003965 }
3966
3967 apex {
3968 name: "myapex_dep",
3969 key: "myapex.key",
3970 native_shared_libs: ["lib_dep"],
3971 compile_multilib: "both",
Jooyung Han54aca7b2019-11-20 02:26:02 +09003972 file_contexts: ":myapex-file_contexts",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00003973 updatable: false,
Jooyung Hane1633032019-08-01 17:41:43 +09003974 }
3975
3976 apex {
3977 name: "myapex_provider",
3978 key: "myapex.key",
3979 native_shared_libs: ["libfoo"],
3980 compile_multilib: "both",
Jooyung Han54aca7b2019-11-20 02:26:02 +09003981 file_contexts: ":myapex-file_contexts",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00003982 updatable: false,
Jooyung Hane1633032019-08-01 17:41:43 +09003983 }
3984
3985 apex {
3986 name: "myapex_selfcontained",
3987 key: "myapex.key",
3988 native_shared_libs: ["lib_dep", "libfoo"],
3989 compile_multilib: "both",
Jooyung Han54aca7b2019-11-20 02:26:02 +09003990 file_contexts: ":myapex-file_contexts",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00003991 updatable: false,
Jooyung Hane1633032019-08-01 17:41:43 +09003992 }
3993
3994 apex_key {
3995 name: "myapex.key",
3996 public_key: "testkey.avbpubkey",
3997 private_key: "testkey.pem",
3998 }
3999
4000 cc_library {
4001 name: "lib_nodep",
4002 srcs: ["mylib.cpp"],
4003 system_shared_libs: [],
4004 stl: "none",
Anton Hanssoneec79eb2020-01-10 15:12:39 +00004005 apex_available: [ "myapex_nodep" ],
Jooyung Hane1633032019-08-01 17:41:43 +09004006 }
4007
4008 cc_library {
4009 name: "lib_dep",
4010 srcs: ["mylib.cpp"],
4011 shared_libs: ["libfoo"],
4012 system_shared_libs: [],
4013 stl: "none",
Anton Hanssoneec79eb2020-01-10 15:12:39 +00004014 apex_available: [
4015 "myapex_dep",
4016 "myapex_provider",
4017 "myapex_selfcontained",
4018 ],
Jooyung Hane1633032019-08-01 17:41:43 +09004019 }
4020
4021 cc_library {
4022 name: "libfoo",
4023 srcs: ["mytest.cpp"],
4024 stubs: {
4025 versions: ["1"],
4026 },
4027 system_shared_libs: [],
4028 stl: "none",
Anton Hanssoneec79eb2020-01-10 15:12:39 +00004029 apex_available: [
4030 "myapex_provider",
4031 "myapex_selfcontained",
4032 ],
Jooyung Hane1633032019-08-01 17:41:43 +09004033 }
4034 `)
4035
Jooyung Hand15aa1f2019-09-27 00:38:03 +09004036 var apexManifestRule android.TestingBuildParams
Jooyung Hane1633032019-08-01 17:41:43 +09004037 var provideNativeLibs, requireNativeLibs []string
4038
Sundong Ahnabb64432019-10-22 13:58:29 +09004039 apexManifestRule = ctx.ModuleForTests("myapex_nodep", "android_common_myapex_nodep_image").Rule("apexManifestRule")
Jooyung Hand15aa1f2019-09-27 00:38:03 +09004040 provideNativeLibs = names(apexManifestRule.Args["provideNativeLibs"])
4041 requireNativeLibs = names(apexManifestRule.Args["requireNativeLibs"])
Jooyung Hane1633032019-08-01 17:41:43 +09004042 ensureListEmpty(t, provideNativeLibs)
4043 ensureListEmpty(t, requireNativeLibs)
4044
Sundong Ahnabb64432019-10-22 13:58:29 +09004045 apexManifestRule = ctx.ModuleForTests("myapex_dep", "android_common_myapex_dep_image").Rule("apexManifestRule")
Jooyung Hand15aa1f2019-09-27 00:38:03 +09004046 provideNativeLibs = names(apexManifestRule.Args["provideNativeLibs"])
4047 requireNativeLibs = names(apexManifestRule.Args["requireNativeLibs"])
Jooyung Hane1633032019-08-01 17:41:43 +09004048 ensureListEmpty(t, provideNativeLibs)
4049 ensureListContains(t, requireNativeLibs, "libfoo.so")
4050
Sundong Ahnabb64432019-10-22 13:58:29 +09004051 apexManifestRule = ctx.ModuleForTests("myapex_provider", "android_common_myapex_provider_image").Rule("apexManifestRule")
Jooyung Hand15aa1f2019-09-27 00:38:03 +09004052 provideNativeLibs = names(apexManifestRule.Args["provideNativeLibs"])
4053 requireNativeLibs = names(apexManifestRule.Args["requireNativeLibs"])
Jooyung Hane1633032019-08-01 17:41:43 +09004054 ensureListContains(t, provideNativeLibs, "libfoo.so")
4055 ensureListEmpty(t, requireNativeLibs)
4056
Sundong Ahnabb64432019-10-22 13:58:29 +09004057 apexManifestRule = ctx.ModuleForTests("myapex_selfcontained", "android_common_myapex_selfcontained_image").Rule("apexManifestRule")
Jooyung Hand15aa1f2019-09-27 00:38:03 +09004058 provideNativeLibs = names(apexManifestRule.Args["provideNativeLibs"])
4059 requireNativeLibs = names(apexManifestRule.Args["requireNativeLibs"])
Jooyung Hane1633032019-08-01 17:41:43 +09004060 ensureListContains(t, provideNativeLibs, "libfoo.so")
4061 ensureListEmpty(t, requireNativeLibs)
4062}
4063
Jooyung Hand15aa1f2019-09-27 00:38:03 +09004064func TestApexName(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08004065 ctx := testApex(t, `
Jooyung Hand15aa1f2019-09-27 00:38:03 +09004066 apex {
4067 name: "myapex",
4068 key: "myapex.key",
4069 apex_name: "com.android.myapex",
Jiyong Parkdb334862020-02-05 17:19:28 +09004070 native_shared_libs: ["mylib"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00004071 updatable: false,
Jooyung Hand15aa1f2019-09-27 00:38:03 +09004072 }
4073
4074 apex_key {
4075 name: "myapex.key",
4076 public_key: "testkey.avbpubkey",
4077 private_key: "testkey.pem",
4078 }
Jiyong Parkdb334862020-02-05 17:19:28 +09004079
4080 cc_library {
4081 name: "mylib",
4082 srcs: ["mylib.cpp"],
4083 system_shared_libs: [],
4084 stl: "none",
4085 apex_available: [
4086 "//apex_available:platform",
4087 "myapex",
4088 ],
4089 }
Jooyung Hand15aa1f2019-09-27 00:38:03 +09004090 `)
4091
Martin Stjernholmbfffae72021-06-24 14:37:13 +01004092 module := ctx.ModuleForTests("myapex", "android_common_com.android.myapex_image")
Jooyung Hand15aa1f2019-09-27 00:38:03 +09004093 apexManifestRule := module.Rule("apexManifestRule")
4094 ensureContains(t, apexManifestRule.Args["opt"], "-v name com.android.myapex")
4095 apexRule := module.Rule("apexRule")
4096 ensureContains(t, apexRule.Args["opt_flags"], "--do_not_check_keyname")
Jiyong Parkdb334862020-02-05 17:19:28 +09004097
Martin Stjernholmbfffae72021-06-24 14:37:13 +01004098 apexBundle := module.Module().(*apexBundle)
Colin Crossaa255532020-07-03 13:18:24 -07004099 data := android.AndroidMkDataForTest(t, ctx, apexBundle)
Jiyong Parkdb334862020-02-05 17:19:28 +09004100 name := apexBundle.BaseModuleName()
4101 prefix := "TARGET_"
4102 var builder strings.Builder
4103 data.Custom(&builder, name, prefix, "", data)
4104 androidMk := builder.String()
4105 ensureContains(t, androidMk, "LOCAL_MODULE := mylib.myapex\n")
4106 ensureNotContains(t, androidMk, "LOCAL_MODULE := mylib.com.android.myapex\n")
Jooyung Hand15aa1f2019-09-27 00:38:03 +09004107}
4108
Alex Light0851b882019-02-07 13:20:53 -08004109func TestNonTestApex(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08004110 ctx := testApex(t, `
Alex Light0851b882019-02-07 13:20:53 -08004111 apex {
4112 name: "myapex",
4113 key: "myapex.key",
4114 native_shared_libs: ["mylib_common"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00004115 updatable: false,
Alex Light0851b882019-02-07 13:20:53 -08004116 }
4117
4118 apex_key {
4119 name: "myapex.key",
4120 public_key: "testkey.avbpubkey",
4121 private_key: "testkey.pem",
4122 }
4123
4124 cc_library {
4125 name: "mylib_common",
4126 srcs: ["mylib.cpp"],
4127 system_shared_libs: [],
4128 stl: "none",
Anton Hanssoneec79eb2020-01-10 15:12:39 +00004129 apex_available: [
4130 "//apex_available:platform",
4131 "myapex",
4132 ],
Alex Light0851b882019-02-07 13:20:53 -08004133 }
4134 `)
4135
Sundong Ahnabb64432019-10-22 13:58:29 +09004136 module := ctx.ModuleForTests("myapex", "android_common_myapex_image")
Alex Light0851b882019-02-07 13:20:53 -08004137 apexRule := module.Rule("apexRule")
4138 copyCmds := apexRule.Args["copy_commands"]
4139
4140 if apex, ok := module.Module().(*apexBundle); !ok || apex.testApex {
4141 t.Log("Apex was a test apex!")
4142 t.Fail()
4143 }
4144 // Ensure that main rule creates an output
4145 ensureContains(t, apexRule.Output.String(), "myapex.apex.unsigned")
4146
4147 // Ensure that apex variant is created for the direct dep
Colin Crossaede88c2020-08-11 12:17:01 -07004148 ensureListContains(t, ctx.ModuleVariantsForTests("mylib_common"), "android_arm64_armv8-a_shared_apex10000")
Alex Light0851b882019-02-07 13:20:53 -08004149
4150 // Ensure that both direct and indirect deps are copied into apex
4151 ensureContains(t, copyCmds, "image.apex/lib64/mylib_common.so")
4152
Colin Cross7113d202019-11-20 16:39:12 -08004153 // Ensure that the platform variant ends with _shared
4154 ensureListContains(t, ctx.ModuleVariantsForTests("mylib_common"), "android_arm64_armv8-a_shared")
Alex Light0851b882019-02-07 13:20:53 -08004155
Colin Cross56a83212020-09-15 18:30:11 -07004156 if !ctx.ModuleForTests("mylib_common", "android_arm64_armv8-a_shared_apex10000").Module().(*cc.Module).InAnyApex() {
Alex Light0851b882019-02-07 13:20:53 -08004157 t.Log("Found mylib_common not in any apex!")
4158 t.Fail()
4159 }
4160}
4161
4162func TestTestApex(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08004163 ctx := testApex(t, `
Alex Light0851b882019-02-07 13:20:53 -08004164 apex_test {
4165 name: "myapex",
4166 key: "myapex.key",
4167 native_shared_libs: ["mylib_common_test"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00004168 updatable: false,
Alex Light0851b882019-02-07 13:20:53 -08004169 }
4170
4171 apex_key {
4172 name: "myapex.key",
4173 public_key: "testkey.avbpubkey",
4174 private_key: "testkey.pem",
4175 }
4176
4177 cc_library {
4178 name: "mylib_common_test",
4179 srcs: ["mylib.cpp"],
4180 system_shared_libs: [],
4181 stl: "none",
Anton Hanssoneec79eb2020-01-10 15:12:39 +00004182 // TODO: remove //apex_available:platform
4183 apex_available: [
4184 "//apex_available:platform",
4185 "myapex",
4186 ],
Alex Light0851b882019-02-07 13:20:53 -08004187 }
4188 `)
4189
Sundong Ahnabb64432019-10-22 13:58:29 +09004190 module := ctx.ModuleForTests("myapex", "android_common_myapex_image")
Alex Light0851b882019-02-07 13:20:53 -08004191 apexRule := module.Rule("apexRule")
4192 copyCmds := apexRule.Args["copy_commands"]
4193
4194 if apex, ok := module.Module().(*apexBundle); !ok || !apex.testApex {
4195 t.Log("Apex was not a test apex!")
4196 t.Fail()
4197 }
4198 // Ensure that main rule creates an output
4199 ensureContains(t, apexRule.Output.String(), "myapex.apex.unsigned")
4200
4201 // Ensure that apex variant is created for the direct dep
Colin Crossaede88c2020-08-11 12:17:01 -07004202 ensureListContains(t, ctx.ModuleVariantsForTests("mylib_common_test"), "android_arm64_armv8-a_shared_apex10000")
Alex Light0851b882019-02-07 13:20:53 -08004203
4204 // Ensure that both direct and indirect deps are copied into apex
4205 ensureContains(t, copyCmds, "image.apex/lib64/mylib_common_test.so")
4206
Colin Cross7113d202019-11-20 16:39:12 -08004207 // Ensure that the platform variant ends with _shared
4208 ensureListContains(t, ctx.ModuleVariantsForTests("mylib_common_test"), "android_arm64_armv8-a_shared")
Alex Light0851b882019-02-07 13:20:53 -08004209}
4210
Alex Light9670d332019-01-29 18:07:33 -08004211func TestApexWithTarget(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08004212 ctx := testApex(t, `
Alex Light9670d332019-01-29 18:07:33 -08004213 apex {
4214 name: "myapex",
4215 key: "myapex.key",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00004216 updatable: false,
Alex Light9670d332019-01-29 18:07:33 -08004217 multilib: {
4218 first: {
4219 native_shared_libs: ["mylib_common"],
4220 }
4221 },
4222 target: {
4223 android: {
4224 multilib: {
4225 first: {
4226 native_shared_libs: ["mylib"],
4227 }
4228 }
4229 },
4230 host: {
4231 multilib: {
4232 first: {
4233 native_shared_libs: ["mylib2"],
4234 }
4235 }
4236 }
4237 }
4238 }
4239
4240 apex_key {
4241 name: "myapex.key",
4242 public_key: "testkey.avbpubkey",
4243 private_key: "testkey.pem",
4244 }
4245
4246 cc_library {
4247 name: "mylib",
4248 srcs: ["mylib.cpp"],
4249 system_shared_libs: [],
4250 stl: "none",
Anton Hanssoneec79eb2020-01-10 15:12:39 +00004251 // TODO: remove //apex_available:platform
4252 apex_available: [
4253 "//apex_available:platform",
4254 "myapex",
4255 ],
Alex Light9670d332019-01-29 18:07:33 -08004256 }
4257
4258 cc_library {
4259 name: "mylib_common",
4260 srcs: ["mylib.cpp"],
4261 system_shared_libs: [],
4262 stl: "none",
4263 compile_multilib: "first",
Anton Hanssoneec79eb2020-01-10 15:12:39 +00004264 // TODO: remove //apex_available:platform
4265 apex_available: [
4266 "//apex_available:platform",
4267 "myapex",
4268 ],
Alex Light9670d332019-01-29 18:07:33 -08004269 }
4270
4271 cc_library {
4272 name: "mylib2",
4273 srcs: ["mylib.cpp"],
4274 system_shared_libs: [],
4275 stl: "none",
4276 compile_multilib: "first",
4277 }
4278 `)
4279
Sundong Ahnabb64432019-10-22 13:58:29 +09004280 apexRule := ctx.ModuleForTests("myapex", "android_common_myapex_image").Rule("apexRule")
Alex Light9670d332019-01-29 18:07:33 -08004281 copyCmds := apexRule.Args["copy_commands"]
4282
4283 // Ensure that main rule creates an output
4284 ensureContains(t, apexRule.Output.String(), "myapex.apex.unsigned")
4285
4286 // Ensure that apex variant is created for the direct dep
Colin Crossaede88c2020-08-11 12:17:01 -07004287 ensureListContains(t, ctx.ModuleVariantsForTests("mylib"), "android_arm64_armv8-a_shared_apex10000")
4288 ensureListContains(t, ctx.ModuleVariantsForTests("mylib_common"), "android_arm64_armv8-a_shared_apex10000")
4289 ensureListNotContains(t, ctx.ModuleVariantsForTests("mylib2"), "android_arm64_armv8-a_shared_apex10000")
Alex Light9670d332019-01-29 18:07:33 -08004290
4291 // Ensure that both direct and indirect deps are copied into apex
4292 ensureContains(t, copyCmds, "image.apex/lib64/mylib.so")
4293 ensureContains(t, copyCmds, "image.apex/lib64/mylib_common.so")
4294 ensureNotContains(t, copyCmds, "image.apex/lib64/mylib2.so")
4295
Colin Cross7113d202019-11-20 16:39:12 -08004296 // Ensure that the platform variant ends with _shared
4297 ensureListContains(t, ctx.ModuleVariantsForTests("mylib"), "android_arm64_armv8-a_shared")
4298 ensureListContains(t, ctx.ModuleVariantsForTests("mylib_common"), "android_arm64_armv8-a_shared")
4299 ensureListContains(t, ctx.ModuleVariantsForTests("mylib2"), "android_arm64_armv8-a_shared")
Alex Light9670d332019-01-29 18:07:33 -08004300}
Jiyong Park04480cf2019-02-06 00:16:29 +09004301
Jiyong Park59140302020-12-14 18:44:04 +09004302func TestApexWithArch(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08004303 ctx := testApex(t, `
Jiyong Park59140302020-12-14 18:44:04 +09004304 apex {
4305 name: "myapex",
4306 key: "myapex.key",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00004307 updatable: false,
Jiyong Park59140302020-12-14 18:44:04 +09004308 arch: {
4309 arm64: {
4310 native_shared_libs: ["mylib.arm64"],
4311 },
4312 x86_64: {
4313 native_shared_libs: ["mylib.x64"],
4314 },
4315 }
4316 }
4317
4318 apex_key {
4319 name: "myapex.key",
4320 public_key: "testkey.avbpubkey",
4321 private_key: "testkey.pem",
4322 }
4323
4324 cc_library {
4325 name: "mylib.arm64",
4326 srcs: ["mylib.cpp"],
4327 system_shared_libs: [],
4328 stl: "none",
4329 // TODO: remove //apex_available:platform
4330 apex_available: [
4331 "//apex_available:platform",
4332 "myapex",
4333 ],
4334 }
4335
4336 cc_library {
4337 name: "mylib.x64",
4338 srcs: ["mylib.cpp"],
4339 system_shared_libs: [],
4340 stl: "none",
4341 // TODO: remove //apex_available:platform
4342 apex_available: [
4343 "//apex_available:platform",
4344 "myapex",
4345 ],
4346 }
4347 `)
4348
4349 apexRule := ctx.ModuleForTests("myapex", "android_common_myapex_image").Rule("apexRule")
4350 copyCmds := apexRule.Args["copy_commands"]
4351
4352 // Ensure that apex variant is created for the direct dep
4353 ensureListContains(t, ctx.ModuleVariantsForTests("mylib.arm64"), "android_arm64_armv8-a_shared_apex10000")
4354 ensureListNotContains(t, ctx.ModuleVariantsForTests("mylib.x64"), "android_arm64_armv8-a_shared_apex10000")
4355
4356 // Ensure that both direct and indirect deps are copied into apex
4357 ensureContains(t, copyCmds, "image.apex/lib64/mylib.arm64.so")
4358 ensureNotContains(t, copyCmds, "image.apex/lib64/mylib.x64.so")
4359}
4360
Jiyong Park04480cf2019-02-06 00:16:29 +09004361func TestApexWithShBinary(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08004362 ctx := testApex(t, `
Jiyong Park04480cf2019-02-06 00:16:29 +09004363 apex {
4364 name: "myapex",
4365 key: "myapex.key",
Sundong Ahn80c04892021-11-23 00:57:19 +00004366 sh_binaries: ["myscript"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00004367 updatable: false,
Jiyong Park04480cf2019-02-06 00:16:29 +09004368 }
4369
4370 apex_key {
4371 name: "myapex.key",
4372 public_key: "testkey.avbpubkey",
4373 private_key: "testkey.pem",
4374 }
4375
4376 sh_binary {
4377 name: "myscript",
4378 src: "mylib.cpp",
4379 filename: "myscript.sh",
4380 sub_dir: "script",
4381 }
4382 `)
4383
Sundong Ahnabb64432019-10-22 13:58:29 +09004384 apexRule := ctx.ModuleForTests("myapex", "android_common_myapex_image").Rule("apexRule")
Jiyong Park04480cf2019-02-06 00:16:29 +09004385 copyCmds := apexRule.Args["copy_commands"]
4386
4387 ensureContains(t, copyCmds, "image.apex/bin/script/myscript.sh")
4388}
Jiyong Parkd1e293d2019-03-15 02:13:21 +09004389
Jooyung Han91df2082019-11-20 01:49:42 +09004390func TestApexInVariousPartition(t *testing.T) {
4391 testcases := []struct {
4392 propName, parition, flattenedPartition string
4393 }{
4394 {"", "system", "system_ext"},
4395 {"product_specific: true", "product", "product"},
4396 {"soc_specific: true", "vendor", "vendor"},
4397 {"proprietary: true", "vendor", "vendor"},
4398 {"vendor: true", "vendor", "vendor"},
4399 {"system_ext_specific: true", "system_ext", "system_ext"},
4400 }
4401 for _, tc := range testcases {
4402 t.Run(tc.propName+":"+tc.parition, func(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08004403 ctx := testApex(t, `
Jooyung Han91df2082019-11-20 01:49:42 +09004404 apex {
4405 name: "myapex",
4406 key: "myapex.key",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00004407 updatable: false,
Jooyung Han91df2082019-11-20 01:49:42 +09004408 `+tc.propName+`
4409 }
Jiyong Parkd1e293d2019-03-15 02:13:21 +09004410
Jooyung Han91df2082019-11-20 01:49:42 +09004411 apex_key {
4412 name: "myapex.key",
4413 public_key: "testkey.avbpubkey",
4414 private_key: "testkey.pem",
4415 }
4416 `)
Jiyong Parkd1e293d2019-03-15 02:13:21 +09004417
Jooyung Han91df2082019-11-20 01:49:42 +09004418 apex := ctx.ModuleForTests("myapex", "android_common_myapex_image").Module().(*apexBundle)
Paul Duffin37ba3442021-03-29 00:21:08 +01004419 expected := "out/soong/target/product/test_device/" + tc.parition + "/apex"
4420 actual := apex.installDir.RelativeToTop().String()
Jooyung Han91df2082019-11-20 01:49:42 +09004421 if actual != expected {
4422 t.Errorf("wrong install path. expected %q. actual %q", expected, actual)
4423 }
Jiyong Parkd1e293d2019-03-15 02:13:21 +09004424
Jooyung Han91df2082019-11-20 01:49:42 +09004425 flattened := ctx.ModuleForTests("myapex", "android_common_myapex_flattened").Module().(*apexBundle)
Paul Duffin37ba3442021-03-29 00:21:08 +01004426 expected = "out/soong/target/product/test_device/" + tc.flattenedPartition + "/apex"
4427 actual = flattened.installDir.RelativeToTop().String()
Jooyung Han91df2082019-11-20 01:49:42 +09004428 if actual != expected {
4429 t.Errorf("wrong install path. expected %q. actual %q", expected, actual)
4430 }
4431 })
Jiyong Parkd1e293d2019-03-15 02:13:21 +09004432 }
Jiyong Parkd1e293d2019-03-15 02:13:21 +09004433}
Jiyong Park67882562019-03-21 01:11:21 +09004434
Jooyung Han580eb4f2020-06-24 19:33:06 +09004435func TestFileContexts_FindInDefaultLocationIfNotSet(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08004436 ctx := testApex(t, `
Jooyung Han580eb4f2020-06-24 19:33:06 +09004437 apex {
4438 name: "myapex",
4439 key: "myapex.key",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00004440 updatable: false,
Jooyung Han580eb4f2020-06-24 19:33:06 +09004441 }
Jooyung Han54aca7b2019-11-20 02:26:02 +09004442
Jooyung Han580eb4f2020-06-24 19:33:06 +09004443 apex_key {
4444 name: "myapex.key",
4445 public_key: "testkey.avbpubkey",
4446 private_key: "testkey.pem",
4447 }
Jooyung Han54aca7b2019-11-20 02:26:02 +09004448 `)
4449 module := ctx.ModuleForTests("myapex", "android_common_myapex_image")
Jooyung Han580eb4f2020-06-24 19:33:06 +09004450 rule := module.Output("file_contexts")
4451 ensureContains(t, rule.RuleParams.Command, "cat system/sepolicy/apex/myapex-file_contexts")
4452}
Jooyung Han54aca7b2019-11-20 02:26:02 +09004453
Jooyung Han580eb4f2020-06-24 19:33:06 +09004454func TestFileContexts_ShouldBeUnderSystemSepolicyForSystemApexes(t *testing.T) {
Jooyung Han54aca7b2019-11-20 02:26:02 +09004455 testApexError(t, `"myapex" .*: file_contexts: should be under system/sepolicy`, `
Jooyung Han580eb4f2020-06-24 19:33:06 +09004456 apex {
4457 name: "myapex",
4458 key: "myapex.key",
4459 file_contexts: "my_own_file_contexts",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00004460 updatable: false,
Jooyung Han580eb4f2020-06-24 19:33:06 +09004461 }
Jooyung Han54aca7b2019-11-20 02:26:02 +09004462
Jooyung Han580eb4f2020-06-24 19:33:06 +09004463 apex_key {
4464 name: "myapex.key",
4465 public_key: "testkey.avbpubkey",
4466 private_key: "testkey.pem",
4467 }
Jooyung Han54aca7b2019-11-20 02:26:02 +09004468 `, withFiles(map[string][]byte{
4469 "my_own_file_contexts": nil,
4470 }))
Jooyung Han580eb4f2020-06-24 19:33:06 +09004471}
Jooyung Han54aca7b2019-11-20 02:26:02 +09004472
Jooyung Han580eb4f2020-06-24 19:33:06 +09004473func TestFileContexts_ProductSpecificApexes(t *testing.T) {
Jooyung Han54aca7b2019-11-20 02:26:02 +09004474 testApexError(t, `"myapex" .*: file_contexts: cannot find`, `
Jooyung Han580eb4f2020-06-24 19:33:06 +09004475 apex {
4476 name: "myapex",
4477 key: "myapex.key",
4478 product_specific: true,
4479 file_contexts: "product_specific_file_contexts",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00004480 updatable: false,
Jooyung Han580eb4f2020-06-24 19:33:06 +09004481 }
Jooyung Han54aca7b2019-11-20 02:26:02 +09004482
Jooyung Han580eb4f2020-06-24 19:33:06 +09004483 apex_key {
4484 name: "myapex.key",
4485 public_key: "testkey.avbpubkey",
4486 private_key: "testkey.pem",
4487 }
Jooyung Han54aca7b2019-11-20 02:26:02 +09004488 `)
4489
Colin Cross1c460562021-02-16 17:55:47 -08004490 ctx := testApex(t, `
Jooyung Han580eb4f2020-06-24 19:33:06 +09004491 apex {
4492 name: "myapex",
4493 key: "myapex.key",
4494 product_specific: true,
4495 file_contexts: "product_specific_file_contexts",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00004496 updatable: false,
Jooyung Han580eb4f2020-06-24 19:33:06 +09004497 }
Jooyung Han54aca7b2019-11-20 02:26:02 +09004498
Jooyung Han580eb4f2020-06-24 19:33:06 +09004499 apex_key {
4500 name: "myapex.key",
4501 public_key: "testkey.avbpubkey",
4502 private_key: "testkey.pem",
4503 }
Jooyung Han54aca7b2019-11-20 02:26:02 +09004504 `, withFiles(map[string][]byte{
4505 "product_specific_file_contexts": nil,
4506 }))
Jooyung Han580eb4f2020-06-24 19:33:06 +09004507 module := ctx.ModuleForTests("myapex", "android_common_myapex_image")
4508 rule := module.Output("file_contexts")
4509 ensureContains(t, rule.RuleParams.Command, "cat product_specific_file_contexts")
4510}
Jooyung Han54aca7b2019-11-20 02:26:02 +09004511
Jooyung Han580eb4f2020-06-24 19:33:06 +09004512func TestFileContexts_SetViaFileGroup(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08004513 ctx := testApex(t, `
Jooyung Han580eb4f2020-06-24 19:33:06 +09004514 apex {
4515 name: "myapex",
4516 key: "myapex.key",
4517 product_specific: true,
4518 file_contexts: ":my-file-contexts",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00004519 updatable: false,
Jooyung Han580eb4f2020-06-24 19:33:06 +09004520 }
Jooyung Han54aca7b2019-11-20 02:26:02 +09004521
Jooyung Han580eb4f2020-06-24 19:33:06 +09004522 apex_key {
4523 name: "myapex.key",
4524 public_key: "testkey.avbpubkey",
4525 private_key: "testkey.pem",
4526 }
Jooyung Han54aca7b2019-11-20 02:26:02 +09004527
Jooyung Han580eb4f2020-06-24 19:33:06 +09004528 filegroup {
4529 name: "my-file-contexts",
4530 srcs: ["product_specific_file_contexts"],
4531 }
Jooyung Han54aca7b2019-11-20 02:26:02 +09004532 `, withFiles(map[string][]byte{
4533 "product_specific_file_contexts": nil,
4534 }))
Jooyung Han580eb4f2020-06-24 19:33:06 +09004535 module := ctx.ModuleForTests("myapex", "android_common_myapex_image")
4536 rule := module.Output("file_contexts")
4537 ensureContains(t, rule.RuleParams.Command, "cat product_specific_file_contexts")
Jooyung Han54aca7b2019-11-20 02:26:02 +09004538}
4539
Jiyong Park67882562019-03-21 01:11:21 +09004540func TestApexKeyFromOtherModule(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08004541 ctx := testApex(t, `
Jiyong Park67882562019-03-21 01:11:21 +09004542 apex_key {
4543 name: "myapex.key",
4544 public_key: ":my.avbpubkey",
4545 private_key: ":my.pem",
4546 product_specific: true,
4547 }
4548
4549 filegroup {
4550 name: "my.avbpubkey",
4551 srcs: ["testkey2.avbpubkey"],
4552 }
4553
4554 filegroup {
4555 name: "my.pem",
4556 srcs: ["testkey2.pem"],
4557 }
4558 `)
4559
4560 apex_key := ctx.ModuleForTests("myapex.key", "android_common").Module().(*apexKey)
4561 expected_pubkey := "testkey2.avbpubkey"
Jaewoong Jung18aefc12020-12-21 09:11:10 -08004562 actual_pubkey := apex_key.publicKeyFile.String()
Jiyong Park67882562019-03-21 01:11:21 +09004563 if actual_pubkey != expected_pubkey {
4564 t.Errorf("wrong public key path. expected %q. actual %q", expected_pubkey, actual_pubkey)
4565 }
4566 expected_privkey := "testkey2.pem"
Jaewoong Jung18aefc12020-12-21 09:11:10 -08004567 actual_privkey := apex_key.privateKeyFile.String()
Jiyong Park67882562019-03-21 01:11:21 +09004568 if actual_privkey != expected_privkey {
4569 t.Errorf("wrong private key path. expected %q. actual %q", expected_privkey, actual_privkey)
4570 }
4571}
Jaewoong Jung939ebd52019-03-26 15:07:36 -07004572
4573func TestPrebuilt(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08004574 ctx := testApex(t, `
Jaewoong Jung939ebd52019-03-26 15:07:36 -07004575 prebuilt_apex {
4576 name: "myapex",
Jiyong Parkc95714e2019-03-29 14:23:10 +09004577 arch: {
4578 arm64: {
4579 src: "myapex-arm64.apex",
4580 },
4581 arm: {
4582 src: "myapex-arm.apex",
4583 },
4584 },
Jaewoong Jung939ebd52019-03-26 15:07:36 -07004585 }
4586 `)
4587
Paul Duffin6717d882021-06-15 19:09:41 +01004588 prebuilt := ctx.ModuleForTests("myapex", "android_common_myapex").Module().(*Prebuilt)
Jaewoong Jung939ebd52019-03-26 15:07:36 -07004589
Jiyong Parkc95714e2019-03-29 14:23:10 +09004590 expectedInput := "myapex-arm64.apex"
4591 if prebuilt.inputApex.String() != expectedInput {
4592 t.Errorf("inputApex invalid. expected: %q, actual: %q", expectedInput, prebuilt.inputApex.String())
4593 }
Jaewoong Jung939ebd52019-03-26 15:07:36 -07004594}
Nikita Ioffe7a41ebd2019-04-04 18:09:48 +01004595
Paul Duffinc0609c62021-03-01 17:27:16 +00004596func TestPrebuiltMissingSrc(t *testing.T) {
Paul Duffin6717d882021-06-15 19:09:41 +01004597 testApexError(t, `module "myapex" variant "android_common_myapex".*: prebuilt_apex does not support "arm64_armv8-a"`, `
Paul Duffinc0609c62021-03-01 17:27:16 +00004598 prebuilt_apex {
4599 name: "myapex",
4600 }
4601 `)
4602}
4603
Nikita Ioffe7a41ebd2019-04-04 18:09:48 +01004604func TestPrebuiltFilenameOverride(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08004605 ctx := testApex(t, `
Nikita Ioffe7a41ebd2019-04-04 18:09:48 +01004606 prebuilt_apex {
4607 name: "myapex",
4608 src: "myapex-arm.apex",
4609 filename: "notmyapex.apex",
4610 }
4611 `)
4612
Paul Duffin6717d882021-06-15 19:09:41 +01004613 p := ctx.ModuleForTests("myapex", "android_common_myapex").Module().(*Prebuilt)
Nikita Ioffe7a41ebd2019-04-04 18:09:48 +01004614
4615 expected := "notmyapex.apex"
4616 if p.installFilename != expected {
4617 t.Errorf("installFilename invalid. expected: %q, actual: %q", expected, p.installFilename)
4618 }
4619}
Jaewoong Jungc1001ec2019-06-25 11:20:53 -07004620
Samiul Islam7c02e262021-09-08 17:48:28 +01004621func TestApexSetFilenameOverride(t *testing.T) {
4622 testApex(t, `
4623 apex_set {
4624 name: "com.company.android.myapex",
4625 apex_name: "com.android.myapex",
4626 set: "company-myapex.apks",
4627 filename: "com.company.android.myapex.apex"
4628 }
4629 `).ModuleForTests("com.company.android.myapex", "android_common_com.android.myapex")
4630
4631 testApex(t, `
4632 apex_set {
4633 name: "com.company.android.myapex",
4634 apex_name: "com.android.myapex",
4635 set: "company-myapex.apks",
4636 filename: "com.company.android.myapex.capex"
4637 }
4638 `).ModuleForTests("com.company.android.myapex", "android_common_com.android.myapex")
4639
4640 testApexError(t, `filename should end in .apex or .capex for apex_set`, `
4641 apex_set {
4642 name: "com.company.android.myapex",
4643 apex_name: "com.android.myapex",
4644 set: "company-myapex.apks",
4645 filename: "some-random-suffix"
4646 }
4647 `)
4648}
4649
Jaewoong Jung22f7d182019-07-16 18:25:41 -07004650func TestPrebuiltOverrides(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08004651 ctx := testApex(t, `
Jaewoong Jung22f7d182019-07-16 18:25:41 -07004652 prebuilt_apex {
4653 name: "myapex.prebuilt",
4654 src: "myapex-arm.apex",
4655 overrides: [
4656 "myapex",
4657 ],
4658 }
4659 `)
4660
Paul Duffin6717d882021-06-15 19:09:41 +01004661 p := ctx.ModuleForTests("myapex.prebuilt", "android_common_myapex.prebuilt").Module().(*Prebuilt)
Jaewoong Jung22f7d182019-07-16 18:25:41 -07004662
4663 expected := []string{"myapex"}
Colin Crossaa255532020-07-03 13:18:24 -07004664 actual := android.AndroidMkEntriesForTest(t, ctx, p)[0].EntryMap["LOCAL_OVERRIDES_MODULES"]
Jaewoong Jung22f7d182019-07-16 18:25:41 -07004665 if !reflect.DeepEqual(actual, expected) {
Jiyong Parkb0a012c2019-11-14 17:17:03 +09004666 t.Errorf("Incorrect LOCAL_OVERRIDES_MODULES value '%s', expected '%s'", actual, expected)
Jaewoong Jung22f7d182019-07-16 18:25:41 -07004667 }
4668}
4669
Martin Stjernholmbfffae72021-06-24 14:37:13 +01004670func TestPrebuiltApexName(t *testing.T) {
4671 testApex(t, `
4672 prebuilt_apex {
4673 name: "com.company.android.myapex",
4674 apex_name: "com.android.myapex",
4675 src: "company-myapex-arm.apex",
4676 }
4677 `).ModuleForTests("com.company.android.myapex", "android_common_com.android.myapex")
4678
4679 testApex(t, `
4680 apex_set {
4681 name: "com.company.android.myapex",
4682 apex_name: "com.android.myapex",
4683 set: "company-myapex.apks",
4684 }
4685 `).ModuleForTests("com.company.android.myapex", "android_common_com.android.myapex")
4686}
4687
4688func TestPrebuiltApexNameWithPlatformBootclasspath(t *testing.T) {
4689 _ = android.GroupFixturePreparers(
4690 java.PrepareForTestWithJavaDefaultModules,
4691 PrepareForTestWithApexBuildComponents,
4692 android.FixtureWithRootAndroidBp(`
4693 platform_bootclasspath {
4694 name: "platform-bootclasspath",
4695 fragments: [
4696 {
4697 apex: "com.android.art",
4698 module: "art-bootclasspath-fragment",
4699 },
4700 ],
4701 }
4702
4703 prebuilt_apex {
4704 name: "com.company.android.art",
4705 apex_name: "com.android.art",
4706 src: "com.company.android.art-arm.apex",
4707 exported_bootclasspath_fragments: ["art-bootclasspath-fragment"],
4708 }
4709
4710 prebuilt_bootclasspath_fragment {
4711 name: "art-bootclasspath-fragment",
satayevabcd5972021-08-06 17:49:46 +01004712 image_name: "art",
Martin Stjernholmbfffae72021-06-24 14:37:13 +01004713 contents: ["core-oj"],
Paul Duffin54e41972021-07-19 13:23:40 +01004714 hidden_api: {
4715 annotation_flags: "my-bootclasspath-fragment/annotation-flags.csv",
4716 metadata: "my-bootclasspath-fragment/metadata.csv",
4717 index: "my-bootclasspath-fragment/index.csv",
4718 stub_flags: "my-bootclasspath-fragment/stub-flags.csv",
4719 all_flags: "my-bootclasspath-fragment/all-flags.csv",
4720 },
Martin Stjernholmbfffae72021-06-24 14:37:13 +01004721 }
4722
4723 java_import {
4724 name: "core-oj",
4725 jars: ["prebuilt.jar"],
4726 }
4727 `),
4728 ).RunTest(t)
4729}
4730
Paul Duffin092153d2021-01-26 11:42:39 +00004731// These tests verify that the prebuilt_apex/deapexer to java_import wiring allows for the
4732// propagation of paths to dex implementation jars from the former to the latter.
Paul Duffin064b70c2020-11-02 17:32:38 +00004733func TestPrebuiltExportDexImplementationJars(t *testing.T) {
Paul Duffin60264a02021-04-12 20:02:36 +01004734 transform := android.NullFixturePreparer
Paul Duffin064b70c2020-11-02 17:32:38 +00004735
Paul Duffin89886cb2021-02-05 16:44:03 +00004736 checkDexJarBuildPath := func(t *testing.T, ctx *android.TestContext, name string) {
Martin Stjernholm8be1e6d2021-09-15 03:34:04 +01004737 t.Helper()
Paul Duffin064b70c2020-11-02 17:32:38 +00004738 // Make sure the import has been given the correct path to the dex jar.
Colin Crossdcf71b22021-02-01 13:59:03 -08004739 p := ctx.ModuleForTests(name, "android_common_myapex").Module().(java.UsesLibraryDependency)
Martin Stjernholm8be1e6d2021-09-15 03:34:04 +01004740 dexJarBuildPath := p.DexJarBuildPath().PathOrNil()
Paul Duffin39853512021-02-26 11:09:39 +00004741 stem := android.RemoveOptionalPrebuiltPrefix(name)
Jeongik Chad5fe8782021-07-08 01:13:11 +09004742 android.AssertStringEquals(t, "DexJarBuildPath should be apex-related path.",
4743 ".intermediates/myapex.deapexer/android_common/deapexer/javalib/"+stem+".jar",
4744 android.NormalizePathForTesting(dexJarBuildPath))
4745 }
4746
4747 checkDexJarInstallPath := func(t *testing.T, ctx *android.TestContext, name string) {
Martin Stjernholm8be1e6d2021-09-15 03:34:04 +01004748 t.Helper()
Jeongik Chad5fe8782021-07-08 01:13:11 +09004749 // Make sure the import has been given the correct path to the dex jar.
4750 p := ctx.ModuleForTests(name, "android_common_myapex").Module().(java.UsesLibraryDependency)
4751 dexJarBuildPath := p.DexJarInstallPath()
4752 stem := android.RemoveOptionalPrebuiltPrefix(name)
4753 android.AssertStringEquals(t, "DexJarInstallPath should be apex-related path.",
4754 "target/product/test_device/apex/myapex/javalib/"+stem+".jar",
4755 android.NormalizePathForTesting(dexJarBuildPath))
Paul Duffin064b70c2020-11-02 17:32:38 +00004756 }
4757
Paul Duffin39853512021-02-26 11:09:39 +00004758 ensureNoSourceVariant := func(t *testing.T, ctx *android.TestContext, name string) {
Martin Stjernholm8be1e6d2021-09-15 03:34:04 +01004759 t.Helper()
Paul Duffin064b70c2020-11-02 17:32:38 +00004760 // Make sure that an apex variant is not created for the source module.
Jeongik Chad5fe8782021-07-08 01:13:11 +09004761 android.AssertArrayString(t, "Check if there is no source variant",
4762 []string{"android_common"},
4763 ctx.ModuleVariantsForTests(name))
Paul Duffin064b70c2020-11-02 17:32:38 +00004764 }
4765
4766 t.Run("prebuilt only", func(t *testing.T) {
4767 bp := `
4768 prebuilt_apex {
4769 name: "myapex",
4770 arch: {
4771 arm64: {
4772 src: "myapex-arm64.apex",
4773 },
4774 arm: {
4775 src: "myapex-arm.apex",
4776 },
4777 },
Paul Duffin39853512021-02-26 11:09:39 +00004778 exported_java_libs: ["libfoo", "libbar"],
Paul Duffin064b70c2020-11-02 17:32:38 +00004779 }
4780
4781 java_import {
4782 name: "libfoo",
4783 jars: ["libfoo.jar"],
4784 }
Paul Duffin39853512021-02-26 11:09:39 +00004785
4786 java_sdk_library_import {
4787 name: "libbar",
4788 public: {
4789 jars: ["libbar.jar"],
4790 },
4791 }
Paul Duffin064b70c2020-11-02 17:32:38 +00004792 `
4793
4794 // Make sure that dexpreopt can access dex implementation files from the prebuilt.
4795 ctx := testDexpreoptWithApexes(t, bp, "", transform)
4796
Martin Stjernholm44825602021-09-17 01:44:12 +01004797 deapexerName := deapexerModuleName("myapex")
4798 android.AssertStringEquals(t, "APEX module name from deapexer name", "myapex", apexModuleName(deapexerName))
4799
Paul Duffinf6932af2021-02-26 18:21:56 +00004800 // Make sure that the deapexer has the correct input APEX.
Martin Stjernholm44825602021-09-17 01:44:12 +01004801 deapexer := ctx.ModuleForTests(deapexerName, "android_common")
Paul Duffinf6932af2021-02-26 18:21:56 +00004802 rule := deapexer.Rule("deapexer")
4803 if expected, actual := []string{"myapex-arm64.apex"}, android.NormalizePathsForTesting(rule.Implicits); !reflect.DeepEqual(expected, actual) {
4804 t.Errorf("expected: %q, found: %q", expected, actual)
4805 }
4806
Paul Duffin0d10c3c2021-03-01 17:09:32 +00004807 // Make sure that the prebuilt_apex has the correct input APEX.
Paul Duffin6717d882021-06-15 19:09:41 +01004808 prebuiltApex := ctx.ModuleForTests("myapex", "android_common_myapex")
Paul Duffin0d10c3c2021-03-01 17:09:32 +00004809 rule = prebuiltApex.Rule("android/soong/android.Cp")
4810 if expected, actual := "myapex-arm64.apex", android.NormalizePathForTesting(rule.Input); !reflect.DeepEqual(expected, actual) {
4811 t.Errorf("expected: %q, found: %q", expected, actual)
4812 }
4813
Paul Duffin89886cb2021-02-05 16:44:03 +00004814 checkDexJarBuildPath(t, ctx, "libfoo")
Jeongik Chad5fe8782021-07-08 01:13:11 +09004815 checkDexJarInstallPath(t, ctx, "libfoo")
Paul Duffin39853512021-02-26 11:09:39 +00004816
4817 checkDexJarBuildPath(t, ctx, "libbar")
Jeongik Chad5fe8782021-07-08 01:13:11 +09004818 checkDexJarInstallPath(t, ctx, "libbar")
Paul Duffin064b70c2020-11-02 17:32:38 +00004819 })
4820
4821 t.Run("prebuilt with source preferred", func(t *testing.T) {
4822
4823 bp := `
4824 prebuilt_apex {
4825 name: "myapex",
4826 arch: {
4827 arm64: {
4828 src: "myapex-arm64.apex",
4829 },
4830 arm: {
4831 src: "myapex-arm.apex",
4832 },
4833 },
Paul Duffin39853512021-02-26 11:09:39 +00004834 exported_java_libs: ["libfoo", "libbar"],
Paul Duffin064b70c2020-11-02 17:32:38 +00004835 }
4836
4837 java_import {
4838 name: "libfoo",
4839 jars: ["libfoo.jar"],
4840 }
4841
4842 java_library {
4843 name: "libfoo",
4844 }
Paul Duffin39853512021-02-26 11:09:39 +00004845
4846 java_sdk_library_import {
4847 name: "libbar",
4848 public: {
4849 jars: ["libbar.jar"],
4850 },
4851 }
4852
4853 java_sdk_library {
4854 name: "libbar",
4855 srcs: ["foo/bar/MyClass.java"],
4856 unsafe_ignore_missing_latest_api: true,
4857 }
Paul Duffin064b70c2020-11-02 17:32:38 +00004858 `
4859
4860 // Make sure that dexpreopt can access dex implementation files from the prebuilt.
4861 ctx := testDexpreoptWithApexes(t, bp, "", transform)
4862
Paul Duffin89886cb2021-02-05 16:44:03 +00004863 checkDexJarBuildPath(t, ctx, "prebuilt_libfoo")
Jeongik Chad5fe8782021-07-08 01:13:11 +09004864 checkDexJarInstallPath(t, ctx, "prebuilt_libfoo")
Paul Duffin39853512021-02-26 11:09:39 +00004865 ensureNoSourceVariant(t, ctx, "libfoo")
4866
4867 checkDexJarBuildPath(t, ctx, "prebuilt_libbar")
Jeongik Chad5fe8782021-07-08 01:13:11 +09004868 checkDexJarInstallPath(t, ctx, "prebuilt_libbar")
Paul Duffin39853512021-02-26 11:09:39 +00004869 ensureNoSourceVariant(t, ctx, "libbar")
Paul Duffin064b70c2020-11-02 17:32:38 +00004870 })
4871
4872 t.Run("prebuilt preferred with source", func(t *testing.T) {
4873 bp := `
4874 prebuilt_apex {
4875 name: "myapex",
Paul Duffin064b70c2020-11-02 17:32:38 +00004876 arch: {
4877 arm64: {
4878 src: "myapex-arm64.apex",
4879 },
4880 arm: {
4881 src: "myapex-arm.apex",
4882 },
4883 },
Paul Duffin39853512021-02-26 11:09:39 +00004884 exported_java_libs: ["libfoo", "libbar"],
Paul Duffin064b70c2020-11-02 17:32:38 +00004885 }
4886
4887 java_import {
4888 name: "libfoo",
Paul Duffin092153d2021-01-26 11:42:39 +00004889 prefer: true,
Paul Duffin064b70c2020-11-02 17:32:38 +00004890 jars: ["libfoo.jar"],
4891 }
4892
4893 java_library {
4894 name: "libfoo",
4895 }
Paul Duffin39853512021-02-26 11:09:39 +00004896
4897 java_sdk_library_import {
4898 name: "libbar",
4899 prefer: true,
4900 public: {
4901 jars: ["libbar.jar"],
4902 },
4903 }
4904
4905 java_sdk_library {
4906 name: "libbar",
4907 srcs: ["foo/bar/MyClass.java"],
4908 unsafe_ignore_missing_latest_api: true,
4909 }
Paul Duffin064b70c2020-11-02 17:32:38 +00004910 `
4911
4912 // Make sure that dexpreopt can access dex implementation files from the prebuilt.
4913 ctx := testDexpreoptWithApexes(t, bp, "", transform)
4914
Paul Duffin89886cb2021-02-05 16:44:03 +00004915 checkDexJarBuildPath(t, ctx, "prebuilt_libfoo")
Jeongik Chad5fe8782021-07-08 01:13:11 +09004916 checkDexJarInstallPath(t, ctx, "prebuilt_libfoo")
Paul Duffin39853512021-02-26 11:09:39 +00004917 ensureNoSourceVariant(t, ctx, "libfoo")
4918
4919 checkDexJarBuildPath(t, ctx, "prebuilt_libbar")
Jeongik Chad5fe8782021-07-08 01:13:11 +09004920 checkDexJarInstallPath(t, ctx, "prebuilt_libbar")
Paul Duffin39853512021-02-26 11:09:39 +00004921 ensureNoSourceVariant(t, ctx, "libbar")
Paul Duffin064b70c2020-11-02 17:32:38 +00004922 })
4923}
4924
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +00004925func TestBootDexJarsFromSourcesAndPrebuilts(t *testing.T) {
Paul Duffinb6f53c02021-05-14 07:52:42 +01004926 preparer := android.GroupFixturePreparers(
satayevabcd5972021-08-06 17:49:46 +01004927 java.FixtureConfigureApexBootJars("myapex:libfoo", "myapex:libbar"),
Paul Duffinb6f53c02021-05-14 07:52:42 +01004928 // Make sure that the frameworks/base/Android.bp file exists as otherwise hidden API encoding
4929 // is disabled.
4930 android.FixtureAddTextFile("frameworks/base/Android.bp", ""),
4931 )
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +00004932
Paul Duffin37856732021-02-26 14:24:15 +00004933 checkBootDexJarPath := func(t *testing.T, ctx *android.TestContext, stem string, bootDexJarPath string) {
4934 t.Helper()
Paul Duffin7ebebfd2021-04-27 19:36:57 +01004935 s := ctx.ModuleForTests("platform-bootclasspath", "android_common")
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +00004936 foundLibfooJar := false
Paul Duffin37856732021-02-26 14:24:15 +00004937 base := stem + ".jar"
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +00004938 for _, output := range s.AllOutputs() {
Paul Duffin37856732021-02-26 14:24:15 +00004939 if filepath.Base(output) == base {
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +00004940 foundLibfooJar = true
4941 buildRule := s.Output(output)
Paul Duffin55607122021-03-30 23:32:51 +01004942 android.AssertStringEquals(t, "boot dex jar path", bootDexJarPath, buildRule.Input.String())
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +00004943 }
4944 }
4945 if !foundLibfooJar {
Lukacs T. Berki9f6c24a2021-08-26 15:07:24 +02004946 t.Errorf("Rule for libfoo.jar missing in dex_bootjars singleton outputs %q", android.StringPathsRelativeToTop(ctx.Config().SoongOutDir(), s.AllOutputs()))
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +00004947 }
4948 }
4949
Paul Duffin40a3f652021-07-19 13:11:24 +01004950 checkHiddenAPIIndexFromClassesInputs := func(t *testing.T, ctx *android.TestContext, expectedIntermediateInputs string) {
Paul Duffin37856732021-02-26 14:24:15 +00004951 t.Helper()
Paul Duffin00b2bfd2021-04-12 17:24:36 +01004952 platformBootclasspath := ctx.ModuleForTests("platform-bootclasspath", "android_common")
Paul Duffind061d402021-06-07 21:36:01 +01004953 var rule android.TestingBuildParams
4954
4955 rule = platformBootclasspath.Output("hiddenapi-monolithic/index-from-classes.csv")
4956 java.CheckHiddenAPIRuleInputs(t, "intermediate index", expectedIntermediateInputs, rule)
Paul Duffin4fd997b2021-02-03 20:06:33 +00004957 }
4958
Paul Duffin40a3f652021-07-19 13:11:24 +01004959 checkHiddenAPIIndexFromFlagsInputs := func(t *testing.T, ctx *android.TestContext, expectedIntermediateInputs string) {
4960 t.Helper()
4961 platformBootclasspath := ctx.ModuleForTests("platform-bootclasspath", "android_common")
4962 var rule android.TestingBuildParams
4963
4964 rule = platformBootclasspath.Output("hiddenapi-index.csv")
4965 java.CheckHiddenAPIRuleInputs(t, "monolithic index", expectedIntermediateInputs, rule)
4966 }
4967
Paul Duffin89f570a2021-06-16 01:42:33 +01004968 fragment := java.ApexVariantReference{
4969 Apex: proptools.StringPtr("myapex"),
4970 Module: proptools.StringPtr("my-bootclasspath-fragment"),
4971 }
4972
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +00004973 t.Run("prebuilt only", func(t *testing.T) {
4974 bp := `
4975 prebuilt_apex {
4976 name: "myapex",
4977 arch: {
4978 arm64: {
4979 src: "myapex-arm64.apex",
4980 },
4981 arm: {
4982 src: "myapex-arm.apex",
4983 },
4984 },
Paul Duffin89f570a2021-06-16 01:42:33 +01004985 exported_bootclasspath_fragments: ["my-bootclasspath-fragment"],
4986 }
4987
4988 prebuilt_bootclasspath_fragment {
4989 name: "my-bootclasspath-fragment",
4990 contents: ["libfoo", "libbar"],
4991 apex_available: ["myapex"],
Paul Duffin54e41972021-07-19 13:23:40 +01004992 hidden_api: {
4993 annotation_flags: "my-bootclasspath-fragment/annotation-flags.csv",
4994 metadata: "my-bootclasspath-fragment/metadata.csv",
4995 index: "my-bootclasspath-fragment/index.csv",
Paul Duffin191be3a2021-08-10 16:14:16 +01004996 signature_patterns: "my-bootclasspath-fragment/signature-patterns.csv",
4997 filtered_stub_flags: "my-bootclasspath-fragment/filtered-stub-flags.csv",
4998 filtered_flags: "my-bootclasspath-fragment/filtered-flags.csv",
Paul Duffin54e41972021-07-19 13:23:40 +01004999 },
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +00005000 }
5001
5002 java_import {
5003 name: "libfoo",
5004 jars: ["libfoo.jar"],
5005 apex_available: ["myapex"],
satayevabcd5972021-08-06 17:49:46 +01005006 permitted_packages: ["foo"],
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +00005007 }
Paul Duffin37856732021-02-26 14:24:15 +00005008
5009 java_sdk_library_import {
5010 name: "libbar",
5011 public: {
5012 jars: ["libbar.jar"],
5013 },
5014 apex_available: ["myapex"],
Paul Duffin89f570a2021-06-16 01:42:33 +01005015 shared_library: false,
satayevabcd5972021-08-06 17:49:46 +01005016 permitted_packages: ["bar"],
Paul Duffin37856732021-02-26 14:24:15 +00005017 }
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +00005018 `
5019
Paul Duffin89f570a2021-06-16 01:42:33 +01005020 ctx := testDexpreoptWithApexes(t, bp, "", preparer, fragment)
Paul Duffin55607122021-03-30 23:32:51 +01005021 checkBootDexJarPath(t, ctx, "libfoo", "out/soong/.intermediates/myapex.deapexer/android_common/deapexer/javalib/libfoo.jar")
5022 checkBootDexJarPath(t, ctx, "libbar", "out/soong/.intermediates/myapex.deapexer/android_common/deapexer/javalib/libbar.jar")
Paul Duffin4fd997b2021-02-03 20:06:33 +00005023
Paul Duffin537ea3d2021-05-14 10:38:00 +01005024 // Verify the correct module jars contribute to the hiddenapi index file.
Paul Duffin54e41972021-07-19 13:23:40 +01005025 checkHiddenAPIIndexFromClassesInputs(t, ctx, ``)
Paul Duffin40a3f652021-07-19 13:11:24 +01005026 checkHiddenAPIIndexFromFlagsInputs(t, ctx, `
Paul Duffin54e41972021-07-19 13:23:40 +01005027 my-bootclasspath-fragment/index.csv
Paul Duffin40a3f652021-07-19 13:11:24 +01005028 out/soong/.intermediates/frameworks/base/boot/platform-bootclasspath/android_common/hiddenapi-monolithic/index-from-classes.csv
5029 `)
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +00005030 })
5031
Paul Duffinf58fd9a2021-04-06 16:00:22 +01005032 t.Run("apex_set only", func(t *testing.T) {
5033 bp := `
5034 apex_set {
5035 name: "myapex",
5036 set: "myapex.apks",
Paul Duffin89f570a2021-06-16 01:42:33 +01005037 exported_bootclasspath_fragments: ["my-bootclasspath-fragment"],
5038 }
5039
5040 prebuilt_bootclasspath_fragment {
5041 name: "my-bootclasspath-fragment",
5042 contents: ["libfoo", "libbar"],
5043 apex_available: ["myapex"],
Paul Duffin54e41972021-07-19 13:23:40 +01005044 hidden_api: {
5045 annotation_flags: "my-bootclasspath-fragment/annotation-flags.csv",
5046 metadata: "my-bootclasspath-fragment/metadata.csv",
5047 index: "my-bootclasspath-fragment/index.csv",
Paul Duffin191be3a2021-08-10 16:14:16 +01005048 signature_patterns: "my-bootclasspath-fragment/signature-patterns.csv",
5049 filtered_stub_flags: "my-bootclasspath-fragment/filtered-stub-flags.csv",
5050 filtered_flags: "my-bootclasspath-fragment/filtered-flags.csv",
Paul Duffin54e41972021-07-19 13:23:40 +01005051 },
Paul Duffinf58fd9a2021-04-06 16:00:22 +01005052 }
5053
5054 java_import {
5055 name: "libfoo",
5056 jars: ["libfoo.jar"],
5057 apex_available: ["myapex"],
satayevabcd5972021-08-06 17:49:46 +01005058 permitted_packages: ["foo"],
Paul Duffinf58fd9a2021-04-06 16:00:22 +01005059 }
5060
5061 java_sdk_library_import {
5062 name: "libbar",
5063 public: {
5064 jars: ["libbar.jar"],
5065 },
5066 apex_available: ["myapex"],
Paul Duffin89f570a2021-06-16 01:42:33 +01005067 shared_library: false,
satayevabcd5972021-08-06 17:49:46 +01005068 permitted_packages: ["bar"],
Paul Duffinf58fd9a2021-04-06 16:00:22 +01005069 }
5070 `
5071
Paul Duffin89f570a2021-06-16 01:42:33 +01005072 ctx := testDexpreoptWithApexes(t, bp, "", preparer, fragment)
Paul Duffinf58fd9a2021-04-06 16:00:22 +01005073 checkBootDexJarPath(t, ctx, "libfoo", "out/soong/.intermediates/myapex.deapexer/android_common/deapexer/javalib/libfoo.jar")
5074 checkBootDexJarPath(t, ctx, "libbar", "out/soong/.intermediates/myapex.deapexer/android_common/deapexer/javalib/libbar.jar")
5075
Paul Duffin537ea3d2021-05-14 10:38:00 +01005076 // Verify the correct module jars contribute to the hiddenapi index file.
Paul Duffin54e41972021-07-19 13:23:40 +01005077 checkHiddenAPIIndexFromClassesInputs(t, ctx, ``)
Paul Duffin40a3f652021-07-19 13:11:24 +01005078 checkHiddenAPIIndexFromFlagsInputs(t, ctx, `
Paul Duffin54e41972021-07-19 13:23:40 +01005079 my-bootclasspath-fragment/index.csv
Paul Duffin40a3f652021-07-19 13:11:24 +01005080 out/soong/.intermediates/frameworks/base/boot/platform-bootclasspath/android_common/hiddenapi-monolithic/index-from-classes.csv
5081 `)
Paul Duffinf58fd9a2021-04-06 16:00:22 +01005082 })
5083
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +00005084 t.Run("prebuilt with source library preferred", func(t *testing.T) {
5085 bp := `
5086 prebuilt_apex {
5087 name: "myapex",
5088 arch: {
5089 arm64: {
5090 src: "myapex-arm64.apex",
5091 },
5092 arm: {
5093 src: "myapex-arm.apex",
5094 },
5095 },
Paul Duffin89f570a2021-06-16 01:42:33 +01005096 exported_bootclasspath_fragments: ["my-bootclasspath-fragment"],
5097 }
5098
5099 prebuilt_bootclasspath_fragment {
5100 name: "my-bootclasspath-fragment",
5101 contents: ["libfoo", "libbar"],
5102 apex_available: ["myapex"],
Paul Duffin54e41972021-07-19 13:23:40 +01005103 hidden_api: {
5104 annotation_flags: "my-bootclasspath-fragment/annotation-flags.csv",
5105 metadata: "my-bootclasspath-fragment/metadata.csv",
5106 index: "my-bootclasspath-fragment/index.csv",
5107 stub_flags: "my-bootclasspath-fragment/stub-flags.csv",
5108 all_flags: "my-bootclasspath-fragment/all-flags.csv",
5109 },
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +00005110 }
5111
5112 java_import {
5113 name: "libfoo",
5114 jars: ["libfoo.jar"],
5115 apex_available: ["myapex"],
5116 }
5117
5118 java_library {
5119 name: "libfoo",
5120 srcs: ["foo/bar/MyClass.java"],
5121 apex_available: ["myapex"],
5122 }
Paul Duffin37856732021-02-26 14:24:15 +00005123
5124 java_sdk_library_import {
5125 name: "libbar",
5126 public: {
5127 jars: ["libbar.jar"],
5128 },
5129 apex_available: ["myapex"],
Paul Duffin89f570a2021-06-16 01:42:33 +01005130 shared_library: false,
Paul Duffin37856732021-02-26 14:24:15 +00005131 }
5132
5133 java_sdk_library {
5134 name: "libbar",
5135 srcs: ["foo/bar/MyClass.java"],
5136 unsafe_ignore_missing_latest_api: true,
5137 apex_available: ["myapex"],
5138 }
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +00005139 `
5140
5141 // In this test the source (java_library) libfoo is active since the
5142 // prebuilt (java_import) defaults to prefer:false. However the
5143 // prebuilt_apex module always depends on the prebuilt, and so it doesn't
5144 // find the dex boot jar in it. We either need to disable the source libfoo
5145 // or make the prebuilt libfoo preferred.
Paul Duffin89f570a2021-06-16 01:42:33 +01005146 testDexpreoptWithApexes(t, bp, "module libfoo does not provide a dex boot jar", preparer, fragment)
Spandan Das10ea4bf2021-08-20 19:18:16 +00005147 // dexbootjar check is skipped if AllowMissingDependencies is true
5148 preparerAllowMissingDeps := android.GroupFixturePreparers(
5149 preparer,
5150 android.PrepareForTestWithAllowMissingDependencies,
5151 )
5152 testDexpreoptWithApexes(t, bp, "", preparerAllowMissingDeps, fragment)
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +00005153 })
5154
5155 t.Run("prebuilt library preferred with source", func(t *testing.T) {
5156 bp := `
5157 prebuilt_apex {
5158 name: "myapex",
5159 arch: {
5160 arm64: {
5161 src: "myapex-arm64.apex",
5162 },
5163 arm: {
5164 src: "myapex-arm.apex",
5165 },
5166 },
Paul Duffin89f570a2021-06-16 01:42:33 +01005167 exported_bootclasspath_fragments: ["my-bootclasspath-fragment"],
5168 }
5169
5170 prebuilt_bootclasspath_fragment {
5171 name: "my-bootclasspath-fragment",
5172 contents: ["libfoo", "libbar"],
5173 apex_available: ["myapex"],
Paul Duffin54e41972021-07-19 13:23:40 +01005174 hidden_api: {
5175 annotation_flags: "my-bootclasspath-fragment/annotation-flags.csv",
5176 metadata: "my-bootclasspath-fragment/metadata.csv",
5177 index: "my-bootclasspath-fragment/index.csv",
Paul Duffin191be3a2021-08-10 16:14:16 +01005178 signature_patterns: "my-bootclasspath-fragment/signature-patterns.csv",
5179 filtered_stub_flags: "my-bootclasspath-fragment/filtered-stub-flags.csv",
5180 filtered_flags: "my-bootclasspath-fragment/filtered-flags.csv",
Paul Duffin54e41972021-07-19 13:23:40 +01005181 },
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +00005182 }
5183
5184 java_import {
5185 name: "libfoo",
5186 prefer: true,
5187 jars: ["libfoo.jar"],
5188 apex_available: ["myapex"],
satayevabcd5972021-08-06 17:49:46 +01005189 permitted_packages: ["foo"],
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +00005190 }
5191
5192 java_library {
5193 name: "libfoo",
5194 srcs: ["foo/bar/MyClass.java"],
5195 apex_available: ["myapex"],
5196 }
Paul Duffin37856732021-02-26 14:24:15 +00005197
5198 java_sdk_library_import {
5199 name: "libbar",
5200 prefer: true,
5201 public: {
5202 jars: ["libbar.jar"],
5203 },
5204 apex_available: ["myapex"],
Paul Duffin89f570a2021-06-16 01:42:33 +01005205 shared_library: false,
satayevabcd5972021-08-06 17:49:46 +01005206 permitted_packages: ["bar"],
Paul Duffin37856732021-02-26 14:24:15 +00005207 }
5208
5209 java_sdk_library {
5210 name: "libbar",
5211 srcs: ["foo/bar/MyClass.java"],
5212 unsafe_ignore_missing_latest_api: true,
5213 apex_available: ["myapex"],
5214 }
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +00005215 `
5216
Paul Duffin89f570a2021-06-16 01:42:33 +01005217 ctx := testDexpreoptWithApexes(t, bp, "", preparer, fragment)
Paul Duffin55607122021-03-30 23:32:51 +01005218 checkBootDexJarPath(t, ctx, "libfoo", "out/soong/.intermediates/myapex.deapexer/android_common/deapexer/javalib/libfoo.jar")
5219 checkBootDexJarPath(t, ctx, "libbar", "out/soong/.intermediates/myapex.deapexer/android_common/deapexer/javalib/libbar.jar")
Paul Duffin4fd997b2021-02-03 20:06:33 +00005220
Paul Duffin537ea3d2021-05-14 10:38:00 +01005221 // Verify the correct module jars contribute to the hiddenapi index file.
Paul Duffin54e41972021-07-19 13:23:40 +01005222 checkHiddenAPIIndexFromClassesInputs(t, ctx, ``)
Paul Duffin40a3f652021-07-19 13:11:24 +01005223 checkHiddenAPIIndexFromFlagsInputs(t, ctx, `
Paul Duffin54e41972021-07-19 13:23:40 +01005224 my-bootclasspath-fragment/index.csv
Paul Duffin40a3f652021-07-19 13:11:24 +01005225 out/soong/.intermediates/frameworks/base/boot/platform-bootclasspath/android_common/hiddenapi-monolithic/index-from-classes.csv
5226 `)
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +00005227 })
5228
5229 t.Run("prebuilt with source apex preferred", func(t *testing.T) {
5230 bp := `
5231 apex {
5232 name: "myapex",
5233 key: "myapex.key",
Paul Duffin37856732021-02-26 14:24:15 +00005234 java_libs: ["libfoo", "libbar"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00005235 updatable: false,
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +00005236 }
5237
5238 apex_key {
5239 name: "myapex.key",
5240 public_key: "testkey.avbpubkey",
5241 private_key: "testkey.pem",
5242 }
5243
5244 prebuilt_apex {
5245 name: "myapex",
5246 arch: {
5247 arm64: {
5248 src: "myapex-arm64.apex",
5249 },
5250 arm: {
5251 src: "myapex-arm.apex",
5252 },
5253 },
Paul Duffin89f570a2021-06-16 01:42:33 +01005254 exported_bootclasspath_fragments: ["my-bootclasspath-fragment"],
5255 }
5256
5257 prebuilt_bootclasspath_fragment {
5258 name: "my-bootclasspath-fragment",
5259 contents: ["libfoo", "libbar"],
5260 apex_available: ["myapex"],
Paul Duffin54e41972021-07-19 13:23:40 +01005261 hidden_api: {
5262 annotation_flags: "my-bootclasspath-fragment/annotation-flags.csv",
5263 metadata: "my-bootclasspath-fragment/metadata.csv",
5264 index: "my-bootclasspath-fragment/index.csv",
Paul Duffin191be3a2021-08-10 16:14:16 +01005265 signature_patterns: "my-bootclasspath-fragment/signature-patterns.csv",
5266 filtered_stub_flags: "my-bootclasspath-fragment/filtered-stub-flags.csv",
5267 filtered_flags: "my-bootclasspath-fragment/filtered-flags.csv",
Paul Duffin54e41972021-07-19 13:23:40 +01005268 },
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +00005269 }
5270
5271 java_import {
5272 name: "libfoo",
5273 jars: ["libfoo.jar"],
5274 apex_available: ["myapex"],
5275 }
5276
5277 java_library {
5278 name: "libfoo",
5279 srcs: ["foo/bar/MyClass.java"],
5280 apex_available: ["myapex"],
satayevabcd5972021-08-06 17:49:46 +01005281 permitted_packages: ["foo"],
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +00005282 }
Paul Duffin37856732021-02-26 14:24:15 +00005283
5284 java_sdk_library_import {
5285 name: "libbar",
5286 public: {
5287 jars: ["libbar.jar"],
5288 },
5289 apex_available: ["myapex"],
Paul Duffin89f570a2021-06-16 01:42:33 +01005290 shared_library: false,
Paul Duffin37856732021-02-26 14:24:15 +00005291 }
5292
5293 java_sdk_library {
5294 name: "libbar",
5295 srcs: ["foo/bar/MyClass.java"],
5296 unsafe_ignore_missing_latest_api: true,
5297 apex_available: ["myapex"],
satayevabcd5972021-08-06 17:49:46 +01005298 permitted_packages: ["bar"],
Paul Duffin37856732021-02-26 14:24:15 +00005299 }
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +00005300 `
5301
Paul Duffin89f570a2021-06-16 01:42:33 +01005302 ctx := testDexpreoptWithApexes(t, bp, "", preparer, fragment)
Paul Duffin55607122021-03-30 23:32:51 +01005303 checkBootDexJarPath(t, ctx, "libfoo", "out/soong/.intermediates/libfoo/android_common_apex10000/hiddenapi/libfoo.jar")
5304 checkBootDexJarPath(t, ctx, "libbar", "out/soong/.intermediates/libbar/android_common_myapex/hiddenapi/libbar.jar")
Paul Duffin4fd997b2021-02-03 20:06:33 +00005305
Paul Duffin537ea3d2021-05-14 10:38:00 +01005306 // Verify the correct module jars contribute to the hiddenapi index file.
Paul Duffin54e41972021-07-19 13:23:40 +01005307 checkHiddenAPIIndexFromClassesInputs(t, ctx, ``)
Paul Duffin40a3f652021-07-19 13:11:24 +01005308 checkHiddenAPIIndexFromFlagsInputs(t, ctx, `
Paul Duffin54e41972021-07-19 13:23:40 +01005309 my-bootclasspath-fragment/index.csv
Paul Duffin40a3f652021-07-19 13:11:24 +01005310 out/soong/.intermediates/frameworks/base/boot/platform-bootclasspath/android_common/hiddenapi-monolithic/index-from-classes.csv
5311 `)
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +00005312 })
5313
5314 t.Run("prebuilt preferred with source apex disabled", func(t *testing.T) {
5315 bp := `
5316 apex {
5317 name: "myapex",
5318 enabled: false,
5319 key: "myapex.key",
Paul Duffin8f146b92021-04-12 17:24:18 +01005320 java_libs: ["libfoo", "libbar"],
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +00005321 }
5322
5323 apex_key {
5324 name: "myapex.key",
5325 public_key: "testkey.avbpubkey",
5326 private_key: "testkey.pem",
5327 }
5328
5329 prebuilt_apex {
5330 name: "myapex",
5331 arch: {
5332 arm64: {
5333 src: "myapex-arm64.apex",
5334 },
5335 arm: {
5336 src: "myapex-arm.apex",
5337 },
5338 },
Paul Duffin89f570a2021-06-16 01:42:33 +01005339 exported_bootclasspath_fragments: ["my-bootclasspath-fragment"],
5340 }
5341
5342 prebuilt_bootclasspath_fragment {
5343 name: "my-bootclasspath-fragment",
5344 contents: ["libfoo", "libbar"],
5345 apex_available: ["myapex"],
Paul Duffin54e41972021-07-19 13:23:40 +01005346 hidden_api: {
5347 annotation_flags: "my-bootclasspath-fragment/annotation-flags.csv",
5348 metadata: "my-bootclasspath-fragment/metadata.csv",
5349 index: "my-bootclasspath-fragment/index.csv",
Paul Duffin191be3a2021-08-10 16:14:16 +01005350 signature_patterns: "my-bootclasspath-fragment/signature-patterns.csv",
5351 filtered_stub_flags: "my-bootclasspath-fragment/filtered-stub-flags.csv",
5352 filtered_flags: "my-bootclasspath-fragment/filtered-flags.csv",
Paul Duffin54e41972021-07-19 13:23:40 +01005353 },
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +00005354 }
5355
5356 java_import {
5357 name: "libfoo",
5358 prefer: true,
5359 jars: ["libfoo.jar"],
5360 apex_available: ["myapex"],
satayevabcd5972021-08-06 17:49:46 +01005361 permitted_packages: ["foo"],
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +00005362 }
5363
5364 java_library {
5365 name: "libfoo",
5366 srcs: ["foo/bar/MyClass.java"],
5367 apex_available: ["myapex"],
5368 }
Paul Duffin37856732021-02-26 14:24:15 +00005369
5370 java_sdk_library_import {
5371 name: "libbar",
5372 prefer: true,
5373 public: {
5374 jars: ["libbar.jar"],
5375 },
5376 apex_available: ["myapex"],
Paul Duffin89f570a2021-06-16 01:42:33 +01005377 shared_library: false,
satayevabcd5972021-08-06 17:49:46 +01005378 permitted_packages: ["bar"],
Paul Duffin37856732021-02-26 14:24:15 +00005379 }
5380
5381 java_sdk_library {
5382 name: "libbar",
5383 srcs: ["foo/bar/MyClass.java"],
5384 unsafe_ignore_missing_latest_api: true,
5385 apex_available: ["myapex"],
5386 }
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +00005387 `
5388
Paul Duffin89f570a2021-06-16 01:42:33 +01005389 ctx := testDexpreoptWithApexes(t, bp, "", preparer, fragment)
Paul Duffin55607122021-03-30 23:32:51 +01005390 checkBootDexJarPath(t, ctx, "libfoo", "out/soong/.intermediates/myapex.deapexer/android_common/deapexer/javalib/libfoo.jar")
5391 checkBootDexJarPath(t, ctx, "libbar", "out/soong/.intermediates/myapex.deapexer/android_common/deapexer/javalib/libbar.jar")
Paul Duffin4fd997b2021-02-03 20:06:33 +00005392
Paul Duffin537ea3d2021-05-14 10:38:00 +01005393 // Verify the correct module jars contribute to the hiddenapi index file.
Paul Duffin54e41972021-07-19 13:23:40 +01005394 checkHiddenAPIIndexFromClassesInputs(t, ctx, ``)
Paul Duffin40a3f652021-07-19 13:11:24 +01005395 checkHiddenAPIIndexFromFlagsInputs(t, ctx, `
Paul Duffin54e41972021-07-19 13:23:40 +01005396 my-bootclasspath-fragment/index.csv
Paul Duffin40a3f652021-07-19 13:11:24 +01005397 out/soong/.intermediates/frameworks/base/boot/platform-bootclasspath/android_common/hiddenapi-monolithic/index-from-classes.csv
5398 `)
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +00005399 })
5400}
5401
Roland Levillain630846d2019-06-26 12:48:34 +01005402func TestApexWithTests(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08005403 ctx := testApex(t, `
Roland Levillain630846d2019-06-26 12:48:34 +01005404 apex_test {
5405 name: "myapex",
5406 key: "myapex.key",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00005407 updatable: false,
Roland Levillain630846d2019-06-26 12:48:34 +01005408 tests: [
5409 "mytest",
Roland Levillain9b5fde92019-06-28 15:41:19 +01005410 "mytests",
Roland Levillain630846d2019-06-26 12:48:34 +01005411 ],
5412 }
5413
5414 apex_key {
5415 name: "myapex.key",
5416 public_key: "testkey.avbpubkey",
5417 private_key: "testkey.pem",
5418 }
5419
Liz Kammer1c14a212020-05-12 15:26:55 -07005420 filegroup {
5421 name: "fg",
5422 srcs: [
5423 "baz",
5424 "bar/baz"
5425 ],
5426 }
5427
Roland Levillain630846d2019-06-26 12:48:34 +01005428 cc_test {
5429 name: "mytest",
5430 gtest: false,
5431 srcs: ["mytest.cpp"],
5432 relative_install_path: "test",
Jiyong Parkaf9539f2020-05-04 10:31:32 +09005433 shared_libs: ["mylib"],
Roland Levillain630846d2019-06-26 12:48:34 +01005434 system_shared_libs: [],
5435 static_executable: true,
5436 stl: "none",
Liz Kammer1c14a212020-05-12 15:26:55 -07005437 data: [":fg"],
Roland Levillain630846d2019-06-26 12:48:34 +01005438 }
Roland Levillain9b5fde92019-06-28 15:41:19 +01005439
Jiyong Parkaf9539f2020-05-04 10:31:32 +09005440 cc_library {
5441 name: "mylib",
5442 srcs: ["mylib.cpp"],
5443 system_shared_libs: [],
5444 stl: "none",
5445 }
5446
Liz Kammer5bd365f2020-05-27 15:15:11 -07005447 filegroup {
5448 name: "fg2",
5449 srcs: [
5450 "testdata/baz"
5451 ],
5452 }
5453
Roland Levillain9b5fde92019-06-28 15:41:19 +01005454 cc_test {
5455 name: "mytests",
5456 gtest: false,
5457 srcs: [
5458 "mytest1.cpp",
5459 "mytest2.cpp",
5460 "mytest3.cpp",
5461 ],
5462 test_per_src: true,
5463 relative_install_path: "test",
5464 system_shared_libs: [],
5465 static_executable: true,
5466 stl: "none",
Liz Kammer5bd365f2020-05-27 15:15:11 -07005467 data: [
5468 ":fg",
5469 ":fg2",
5470 ],
Roland Levillain9b5fde92019-06-28 15:41:19 +01005471 }
Roland Levillain630846d2019-06-26 12:48:34 +01005472 `)
5473
Sundong Ahnabb64432019-10-22 13:58:29 +09005474 apexRule := ctx.ModuleForTests("myapex", "android_common_myapex_image").Rule("apexRule")
Roland Levillain630846d2019-06-26 12:48:34 +01005475 copyCmds := apexRule.Args["copy_commands"]
5476
Jiyong Parkaf9539f2020-05-04 10:31:32 +09005477 // Ensure that test dep (and their transitive dependencies) are copied into apex.
Roland Levillain630846d2019-06-26 12:48:34 +01005478 ensureContains(t, copyCmds, "image.apex/bin/test/mytest")
Jiyong Parkaf9539f2020-05-04 10:31:32 +09005479 ensureContains(t, copyCmds, "image.apex/lib64/mylib.so")
Roland Levillain9b5fde92019-06-28 15:41:19 +01005480
Liz Kammer1c14a212020-05-12 15:26:55 -07005481 //Ensure that test data are copied into apex.
5482 ensureContains(t, copyCmds, "image.apex/bin/test/baz")
5483 ensureContains(t, copyCmds, "image.apex/bin/test/bar/baz")
5484
Roland Levillain9b5fde92019-06-28 15:41:19 +01005485 // Ensure that test deps built with `test_per_src` are copied into apex.
5486 ensureContains(t, copyCmds, "image.apex/bin/test/mytest1")
5487 ensureContains(t, copyCmds, "image.apex/bin/test/mytest2")
5488 ensureContains(t, copyCmds, "image.apex/bin/test/mytest3")
Roland Levillainf89cd092019-07-29 16:22:59 +01005489
5490 // Ensure the module is correctly translated.
Liz Kammer81faaaf2020-05-20 09:57:08 -07005491 bundle := ctx.ModuleForTests("myapex", "android_common_myapex_image").Module().(*apexBundle)
Colin Crossaa255532020-07-03 13:18:24 -07005492 data := android.AndroidMkDataForTest(t, ctx, bundle)
Liz Kammer81faaaf2020-05-20 09:57:08 -07005493 name := bundle.BaseModuleName()
Roland Levillainf89cd092019-07-29 16:22:59 +01005494 prefix := "TARGET_"
5495 var builder strings.Builder
5496 data.Custom(&builder, name, prefix, "", data)
5497 androidMk := builder.String()
Jooyung Han31c470b2019-10-18 16:26:59 +09005498 ensureContains(t, androidMk, "LOCAL_MODULE := mytest.myapex\n")
5499 ensureContains(t, androidMk, "LOCAL_MODULE := mytest1.myapex\n")
5500 ensureContains(t, androidMk, "LOCAL_MODULE := mytest2.myapex\n")
5501 ensureContains(t, androidMk, "LOCAL_MODULE := mytest3.myapex\n")
Jooyung Han214bf372019-11-12 13:03:50 +09005502 ensureContains(t, androidMk, "LOCAL_MODULE := apex_manifest.pb.myapex\n")
Jooyung Han31c470b2019-10-18 16:26:59 +09005503 ensureContains(t, androidMk, "LOCAL_MODULE := apex_pubkey.myapex\n")
Roland Levillainf89cd092019-07-29 16:22:59 +01005504 ensureContains(t, androidMk, "LOCAL_MODULE := myapex\n")
Liz Kammer81faaaf2020-05-20 09:57:08 -07005505
5506 flatBundle := ctx.ModuleForTests("myapex", "android_common_myapex_flattened").Module().(*apexBundle)
Colin Crossaa255532020-07-03 13:18:24 -07005507 data = android.AndroidMkDataForTest(t, ctx, flatBundle)
Liz Kammer81faaaf2020-05-20 09:57:08 -07005508 data.Custom(&builder, name, prefix, "", data)
5509 flatAndroidMk := builder.String()
Liz Kammer5bd365f2020-05-27 15:15:11 -07005510 ensureContainsOnce(t, flatAndroidMk, "LOCAL_TEST_DATA := :baz :bar/baz\n")
5511 ensureContainsOnce(t, flatAndroidMk, "LOCAL_TEST_DATA := :testdata/baz\n")
Roland Levillain630846d2019-06-26 12:48:34 +01005512}
5513
Jooyung Han3ab2c3e2019-12-05 16:27:44 +09005514func TestInstallExtraFlattenedApexes(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08005515 ctx := testApex(t, `
Jooyung Han3ab2c3e2019-12-05 16:27:44 +09005516 apex {
5517 name: "myapex",
5518 key: "myapex.key",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00005519 updatable: false,
Jooyung Han3ab2c3e2019-12-05 16:27:44 +09005520 }
5521 apex_key {
5522 name: "myapex.key",
5523 public_key: "testkey.avbpubkey",
5524 private_key: "testkey.pem",
5525 }
Paul Duffin0a49fdc2021-03-08 11:28:25 +00005526 `,
5527 android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
5528 variables.InstallExtraFlattenedApexes = proptools.BoolPtr(true)
5529 }),
5530 )
Jooyung Han3ab2c3e2019-12-05 16:27:44 +09005531 ab := ctx.ModuleForTests("myapex", "android_common_myapex_image").Module().(*apexBundle)
Jiyong Park83dc74b2020-01-14 18:38:44 +09005532 ensureListContains(t, ab.requiredDeps, "myapex.flattened")
Colin Crossaa255532020-07-03 13:18:24 -07005533 mk := android.AndroidMkDataForTest(t, ctx, ab)
Jooyung Han3ab2c3e2019-12-05 16:27:44 +09005534 var builder strings.Builder
5535 mk.Custom(&builder, ab.Name(), "TARGET_", "", mk)
5536 androidMk := builder.String()
5537 ensureContains(t, androidMk, "LOCAL_REQUIRED_MODULES += myapex.flattened")
5538}
5539
Jooyung Hand48f3c32019-08-23 11:18:57 +09005540func TestErrorsIfDepsAreNotEnabled(t *testing.T) {
5541 testApexError(t, `module "myapex" .* depends on disabled module "libfoo"`, `
5542 apex {
5543 name: "myapex",
5544 key: "myapex.key",
5545 native_shared_libs: ["libfoo"],
5546 }
5547
5548 apex_key {
5549 name: "myapex.key",
5550 public_key: "testkey.avbpubkey",
5551 private_key: "testkey.pem",
5552 }
5553
5554 cc_library {
5555 name: "libfoo",
5556 stl: "none",
5557 system_shared_libs: [],
5558 enabled: false,
Jooyung Han5e9013b2020-03-10 06:23:13 +09005559 apex_available: ["myapex"],
Jooyung Hand48f3c32019-08-23 11:18:57 +09005560 }
5561 `)
5562 testApexError(t, `module "myapex" .* depends on disabled module "myjar"`, `
5563 apex {
5564 name: "myapex",
5565 key: "myapex.key",
5566 java_libs: ["myjar"],
5567 }
5568
5569 apex_key {
5570 name: "myapex.key",
5571 public_key: "testkey.avbpubkey",
5572 private_key: "testkey.pem",
5573 }
5574
5575 java_library {
5576 name: "myjar",
5577 srcs: ["foo/bar/MyClass.java"],
5578 sdk_version: "none",
5579 system_modules: "none",
Jooyung Hand48f3c32019-08-23 11:18:57 +09005580 enabled: false,
Jooyung Han5e9013b2020-03-10 06:23:13 +09005581 apex_available: ["myapex"],
Jooyung Hand48f3c32019-08-23 11:18:57 +09005582 }
5583 `)
5584}
5585
Bill Peckhama41a6962021-01-11 10:58:54 -08005586func TestApexWithJavaImport(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08005587 ctx := testApex(t, `
Bill Peckhama41a6962021-01-11 10:58:54 -08005588 apex {
5589 name: "myapex",
5590 key: "myapex.key",
5591 java_libs: ["myjavaimport"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00005592 updatable: false,
Bill Peckhama41a6962021-01-11 10:58:54 -08005593 }
5594
5595 apex_key {
5596 name: "myapex.key",
5597 public_key: "testkey.avbpubkey",
5598 private_key: "testkey.pem",
5599 }
5600
5601 java_import {
5602 name: "myjavaimport",
5603 apex_available: ["myapex"],
5604 jars: ["my.jar"],
5605 compile_dex: true,
5606 }
5607 `)
5608
5609 module := ctx.ModuleForTests("myapex", "android_common_myapex_image")
5610 apexRule := module.Rule("apexRule")
5611 copyCmds := apexRule.Args["copy_commands"]
5612 ensureContains(t, copyCmds, "image.apex/javalib/myjavaimport.jar")
5613}
5614
Sundong Ahne1f05aa2019-08-27 13:55:42 +09005615func TestApexWithApps(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08005616 ctx := testApex(t, `
Sundong Ahne1f05aa2019-08-27 13:55:42 +09005617 apex {
5618 name: "myapex",
5619 key: "myapex.key",
5620 apps: [
5621 "AppFoo",
Jiyong Parkf7487312019-10-17 12:54:30 +09005622 "AppFooPriv",
Sundong Ahne1f05aa2019-08-27 13:55:42 +09005623 ],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00005624 updatable: false,
Sundong Ahne1f05aa2019-08-27 13:55:42 +09005625 }
5626
5627 apex_key {
5628 name: "myapex.key",
5629 public_key: "testkey.avbpubkey",
5630 private_key: "testkey.pem",
5631 }
5632
5633 android_app {
5634 name: "AppFoo",
5635 srcs: ["foo/bar/MyClass.java"],
Colin Cross094cde42020-02-15 10:38:00 -08005636 sdk_version: "current",
Sundong Ahne1f05aa2019-08-27 13:55:42 +09005637 system_modules: "none",
Jiyong Park8be103b2019-11-08 15:53:48 +09005638 jni_libs: ["libjni"],
Colin Cross094cde42020-02-15 10:38:00 -08005639 stl: "none",
Anton Hanssoneec79eb2020-01-10 15:12:39 +00005640 apex_available: [ "myapex" ],
Sundong Ahne1f05aa2019-08-27 13:55:42 +09005641 }
Jiyong Parkf7487312019-10-17 12:54:30 +09005642
5643 android_app {
5644 name: "AppFooPriv",
5645 srcs: ["foo/bar/MyClass.java"],
Colin Cross094cde42020-02-15 10:38:00 -08005646 sdk_version: "current",
Jiyong Parkf7487312019-10-17 12:54:30 +09005647 system_modules: "none",
5648 privileged: true,
Colin Cross094cde42020-02-15 10:38:00 -08005649 stl: "none",
Anton Hanssoneec79eb2020-01-10 15:12:39 +00005650 apex_available: [ "myapex" ],
Jiyong Parkf7487312019-10-17 12:54:30 +09005651 }
Jiyong Park8be103b2019-11-08 15:53:48 +09005652
5653 cc_library_shared {
5654 name: "libjni",
5655 srcs: ["mylib.cpp"],
Jooyung Hanb7bebe22020-02-25 16:59:29 +09005656 shared_libs: ["libfoo"],
5657 stl: "none",
5658 system_shared_libs: [],
5659 apex_available: [ "myapex" ],
5660 sdk_version: "current",
5661 }
5662
5663 cc_library_shared {
5664 name: "libfoo",
Jiyong Park8be103b2019-11-08 15:53:48 +09005665 stl: "none",
5666 system_shared_libs: [],
Jiyong Park0f80c182020-01-31 02:49:53 +09005667 apex_available: [ "myapex" ],
Colin Cross094cde42020-02-15 10:38:00 -08005668 sdk_version: "current",
Jiyong Park8be103b2019-11-08 15:53:48 +09005669 }
Sundong Ahne1f05aa2019-08-27 13:55:42 +09005670 `)
5671
Sundong Ahnabb64432019-10-22 13:58:29 +09005672 module := ctx.ModuleForTests("myapex", "android_common_myapex_image")
Sundong Ahne1f05aa2019-08-27 13:55:42 +09005673 apexRule := module.Rule("apexRule")
5674 copyCmds := apexRule.Args["copy_commands"]
5675
5676 ensureContains(t, copyCmds, "image.apex/app/AppFoo/AppFoo.apk")
Jiyong Parkf7487312019-10-17 12:54:30 +09005677 ensureContains(t, copyCmds, "image.apex/priv-app/AppFooPriv/AppFooPriv.apk")
Jiyong Park52cd06f2019-11-11 10:14:32 +09005678
Colin Crossaede88c2020-08-11 12:17:01 -07005679 appZipRule := ctx.ModuleForTests("AppFoo", "android_common_apex10000").Description("zip jni libs")
Jooyung Hanb7bebe22020-02-25 16:59:29 +09005680 // JNI libraries are uncompressed
Jiyong Park52cd06f2019-11-11 10:14:32 +09005681 if args := appZipRule.Args["jarArgs"]; !strings.Contains(args, "-L 0") {
Jooyung Hanb7bebe22020-02-25 16:59:29 +09005682 t.Errorf("jni libs are not uncompressed for AppFoo")
Jiyong Park52cd06f2019-11-11 10:14:32 +09005683 }
Jooyung Hanb7bebe22020-02-25 16:59:29 +09005684 // JNI libraries including transitive deps are
5685 for _, jni := range []string{"libjni", "libfoo"} {
Paul Duffinafdd4062021-03-30 19:44:07 +01005686 jniOutput := ctx.ModuleForTests(jni, "android_arm64_armv8-a_sdk_shared_apex10000").Module().(*cc.Module).OutputFile().RelativeToTop()
Jooyung Hanb7bebe22020-02-25 16:59:29 +09005687 // ... embedded inside APK (jnilibs.zip)
5688 ensureListContains(t, appZipRule.Implicits.Strings(), jniOutput.String())
5689 // ... and not directly inside the APEX
5690 ensureNotContains(t, copyCmds, "image.apex/lib64/"+jni+".so")
5691 }
Dario Frenicde2a032019-10-27 00:29:22 +01005692}
Sundong Ahne1f05aa2019-08-27 13:55:42 +09005693
Dario Frenicde2a032019-10-27 00:29:22 +01005694func TestApexWithAppImports(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08005695 ctx := testApex(t, `
Dario Frenicde2a032019-10-27 00:29:22 +01005696 apex {
5697 name: "myapex",
5698 key: "myapex.key",
5699 apps: [
5700 "AppFooPrebuilt",
5701 "AppFooPrivPrebuilt",
5702 ],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00005703 updatable: false,
Dario Frenicde2a032019-10-27 00:29:22 +01005704 }
5705
5706 apex_key {
5707 name: "myapex.key",
5708 public_key: "testkey.avbpubkey",
5709 private_key: "testkey.pem",
5710 }
5711
5712 android_app_import {
5713 name: "AppFooPrebuilt",
5714 apk: "PrebuiltAppFoo.apk",
5715 presigned: true,
5716 dex_preopt: {
5717 enabled: false,
5718 },
Jiyong Park592a6a42020-04-21 22:34:28 +09005719 apex_available: ["myapex"],
Dario Frenicde2a032019-10-27 00:29:22 +01005720 }
5721
5722 android_app_import {
5723 name: "AppFooPrivPrebuilt",
5724 apk: "PrebuiltAppFooPriv.apk",
5725 privileged: true,
5726 presigned: true,
5727 dex_preopt: {
5728 enabled: false,
5729 },
Jooyung Han39ee1192020-03-23 20:21:11 +09005730 filename: "AwesomePrebuiltAppFooPriv.apk",
Jiyong Park592a6a42020-04-21 22:34:28 +09005731 apex_available: ["myapex"],
Dario Frenicde2a032019-10-27 00:29:22 +01005732 }
5733 `)
5734
Sundong Ahnabb64432019-10-22 13:58:29 +09005735 module := ctx.ModuleForTests("myapex", "android_common_myapex_image")
Dario Frenicde2a032019-10-27 00:29:22 +01005736 apexRule := module.Rule("apexRule")
5737 copyCmds := apexRule.Args["copy_commands"]
5738
5739 ensureContains(t, copyCmds, "image.apex/app/AppFooPrebuilt/AppFooPrebuilt.apk")
Jooyung Han39ee1192020-03-23 20:21:11 +09005740 ensureContains(t, copyCmds, "image.apex/priv-app/AppFooPrivPrebuilt/AwesomePrebuiltAppFooPriv.apk")
5741}
5742
5743func TestApexWithAppImportsPrefer(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08005744 ctx := testApex(t, `
Jooyung Han39ee1192020-03-23 20:21:11 +09005745 apex {
5746 name: "myapex",
5747 key: "myapex.key",
5748 apps: [
5749 "AppFoo",
5750 ],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00005751 updatable: false,
Jooyung Han39ee1192020-03-23 20:21:11 +09005752 }
5753
5754 apex_key {
5755 name: "myapex.key",
5756 public_key: "testkey.avbpubkey",
5757 private_key: "testkey.pem",
5758 }
5759
5760 android_app {
5761 name: "AppFoo",
5762 srcs: ["foo/bar/MyClass.java"],
5763 sdk_version: "none",
5764 system_modules: "none",
5765 apex_available: [ "myapex" ],
5766 }
5767
5768 android_app_import {
5769 name: "AppFoo",
5770 apk: "AppFooPrebuilt.apk",
5771 filename: "AppFooPrebuilt.apk",
5772 presigned: true,
5773 prefer: true,
Jiyong Park592a6a42020-04-21 22:34:28 +09005774 apex_available: ["myapex"],
Jooyung Han39ee1192020-03-23 20:21:11 +09005775 }
5776 `, withFiles(map[string][]byte{
5777 "AppFooPrebuilt.apk": nil,
5778 }))
5779
5780 ensureExactContents(t, ctx, "myapex", "android_common_myapex_image", []string{
Jooyung Han86feead2021-03-08 13:11:48 +09005781 "app/AppFoo/AppFooPrebuilt.apk",
Jooyung Han39ee1192020-03-23 20:21:11 +09005782 })
Sundong Ahne1f05aa2019-08-27 13:55:42 +09005783}
5784
Dario Freni6f3937c2019-12-20 22:58:03 +00005785func TestApexWithTestHelperApp(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08005786 ctx := testApex(t, `
Dario Freni6f3937c2019-12-20 22:58:03 +00005787 apex {
5788 name: "myapex",
5789 key: "myapex.key",
5790 apps: [
5791 "TesterHelpAppFoo",
5792 ],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00005793 updatable: false,
Dario Freni6f3937c2019-12-20 22:58:03 +00005794 }
5795
5796 apex_key {
5797 name: "myapex.key",
5798 public_key: "testkey.avbpubkey",
5799 private_key: "testkey.pem",
5800 }
5801
5802 android_test_helper_app {
5803 name: "TesterHelpAppFoo",
5804 srcs: ["foo/bar/MyClass.java"],
Anton Hanssoneec79eb2020-01-10 15:12:39 +00005805 apex_available: [ "myapex" ],
Dario Freni6f3937c2019-12-20 22:58:03 +00005806 }
5807
5808 `)
5809
5810 module := ctx.ModuleForTests("myapex", "android_common_myapex_image")
5811 apexRule := module.Rule("apexRule")
5812 copyCmds := apexRule.Args["copy_commands"]
5813
5814 ensureContains(t, copyCmds, "image.apex/app/TesterHelpAppFoo/TesterHelpAppFoo.apk")
5815}
5816
Jooyung Han18020ea2019-11-13 10:50:48 +09005817func TestApexPropertiesShouldBeDefaultable(t *testing.T) {
5818 // libfoo's apex_available comes from cc_defaults
Steven Moreland6e36cd62020-10-22 01:08:35 +00005819 testApexError(t, `requires "libfoo" that doesn't list the APEX under 'apex_available'.`, `
Jooyung Han18020ea2019-11-13 10:50:48 +09005820 apex {
5821 name: "myapex",
5822 key: "myapex.key",
5823 native_shared_libs: ["libfoo"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00005824 updatable: false,
Jooyung Han18020ea2019-11-13 10:50:48 +09005825 }
5826
5827 apex_key {
5828 name: "myapex.key",
5829 public_key: "testkey.avbpubkey",
5830 private_key: "testkey.pem",
5831 }
5832
5833 apex {
5834 name: "otherapex",
5835 key: "myapex.key",
5836 native_shared_libs: ["libfoo"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00005837 updatable: false,
Jooyung Han18020ea2019-11-13 10:50:48 +09005838 }
5839
5840 cc_defaults {
5841 name: "libfoo-defaults",
5842 apex_available: ["otherapex"],
5843 }
5844
5845 cc_library {
5846 name: "libfoo",
5847 defaults: ["libfoo-defaults"],
5848 stl: "none",
5849 system_shared_libs: [],
5850 }`)
5851}
5852
Paul Duffine52e66f2020-03-30 17:54:29 +01005853func TestApexAvailable_DirectDep(t *testing.T) {
Jiyong Park127b40b2019-09-30 16:04:35 +09005854 // libfoo is not available to myapex, but only to otherapex
Steven Moreland6e36cd62020-10-22 01:08:35 +00005855 testApexError(t, "requires \"libfoo\" that doesn't list the APEX under 'apex_available'.", `
Jiyong Park127b40b2019-09-30 16:04:35 +09005856 apex {
5857 name: "myapex",
5858 key: "myapex.key",
5859 native_shared_libs: ["libfoo"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00005860 updatable: false,
Jiyong Park127b40b2019-09-30 16:04:35 +09005861 }
5862
5863 apex_key {
5864 name: "myapex.key",
5865 public_key: "testkey.avbpubkey",
5866 private_key: "testkey.pem",
5867 }
5868
5869 apex {
5870 name: "otherapex",
5871 key: "otherapex.key",
5872 native_shared_libs: ["libfoo"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00005873 updatable: false,
Jiyong Park127b40b2019-09-30 16:04:35 +09005874 }
5875
5876 apex_key {
5877 name: "otherapex.key",
5878 public_key: "testkey.avbpubkey",
5879 private_key: "testkey.pem",
5880 }
5881
5882 cc_library {
5883 name: "libfoo",
5884 stl: "none",
5885 system_shared_libs: [],
5886 apex_available: ["otherapex"],
5887 }`)
Paul Duffine52e66f2020-03-30 17:54:29 +01005888}
Jiyong Park127b40b2019-09-30 16:04:35 +09005889
Paul Duffine52e66f2020-03-30 17:54:29 +01005890func TestApexAvailable_IndirectDep(t *testing.T) {
Jooyung Han5e9013b2020-03-10 06:23:13 +09005891 // libbbaz is an indirect dep
Jiyong Park767dbd92021-03-04 13:03:10 +09005892 testApexError(t, `requires "libbaz" that doesn't list the APEX under 'apex_available'.\n\nDependency path:
Colin Cross6e511a92020-07-27 21:26:48 -07005893.*via tag apex\.dependencyTag.*name:sharedLib.*
Paul Duffindf915ff2020-03-30 17:58:21 +01005894.*-> libfoo.*link:shared.*
Colin Cross6e511a92020-07-27 21:26:48 -07005895.*via tag cc\.libraryDependencyTag.*Kind:sharedLibraryDependency.*
Paul Duffindf915ff2020-03-30 17:58:21 +01005896.*-> libbar.*link:shared.*
Colin Cross6e511a92020-07-27 21:26:48 -07005897.*via tag cc\.libraryDependencyTag.*Kind:sharedLibraryDependency.*
Paul Duffin65347702020-03-31 15:23:40 +01005898.*-> libbaz.*link:shared.*`, `
Jiyong Park127b40b2019-09-30 16:04:35 +09005899 apex {
5900 name: "myapex",
5901 key: "myapex.key",
5902 native_shared_libs: ["libfoo"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00005903 updatable: false,
Jiyong Park127b40b2019-09-30 16:04:35 +09005904 }
5905
5906 apex_key {
5907 name: "myapex.key",
5908 public_key: "testkey.avbpubkey",
5909 private_key: "testkey.pem",
5910 }
5911
Jiyong Park127b40b2019-09-30 16:04:35 +09005912 cc_library {
5913 name: "libfoo",
5914 stl: "none",
5915 shared_libs: ["libbar"],
5916 system_shared_libs: [],
Jooyung Han5e9013b2020-03-10 06:23:13 +09005917 apex_available: ["myapex"],
Jiyong Park127b40b2019-09-30 16:04:35 +09005918 }
5919
5920 cc_library {
5921 name: "libbar",
5922 stl: "none",
Jooyung Han5e9013b2020-03-10 06:23:13 +09005923 shared_libs: ["libbaz"],
Jiyong Park127b40b2019-09-30 16:04:35 +09005924 system_shared_libs: [],
Jooyung Han5e9013b2020-03-10 06:23:13 +09005925 apex_available: ["myapex"],
5926 }
5927
5928 cc_library {
5929 name: "libbaz",
5930 stl: "none",
5931 system_shared_libs: [],
Jiyong Park127b40b2019-09-30 16:04:35 +09005932 }`)
Paul Duffine52e66f2020-03-30 17:54:29 +01005933}
Jiyong Park127b40b2019-09-30 16:04:35 +09005934
Paul Duffine52e66f2020-03-30 17:54:29 +01005935func TestApexAvailable_InvalidApexName(t *testing.T) {
Jiyong Park127b40b2019-09-30 16:04:35 +09005936 testApexError(t, "\"otherapex\" is not a valid module name", `
5937 apex {
5938 name: "myapex",
5939 key: "myapex.key",
5940 native_shared_libs: ["libfoo"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00005941 updatable: false,
Jiyong Park127b40b2019-09-30 16:04:35 +09005942 }
5943
5944 apex_key {
5945 name: "myapex.key",
5946 public_key: "testkey.avbpubkey",
5947 private_key: "testkey.pem",
5948 }
5949
5950 cc_library {
5951 name: "libfoo",
5952 stl: "none",
5953 system_shared_libs: [],
5954 apex_available: ["otherapex"],
5955 }`)
5956
Paul Duffine52e66f2020-03-30 17:54:29 +01005957 testApex(t, `
Jiyong Park127b40b2019-09-30 16:04:35 +09005958 apex {
5959 name: "myapex",
5960 key: "myapex.key",
5961 native_shared_libs: ["libfoo", "libbar"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00005962 updatable: false,
Jiyong Park127b40b2019-09-30 16:04:35 +09005963 }
5964
5965 apex_key {
5966 name: "myapex.key",
5967 public_key: "testkey.avbpubkey",
5968 private_key: "testkey.pem",
5969 }
5970
5971 cc_library {
5972 name: "libfoo",
5973 stl: "none",
5974 system_shared_libs: [],
Jiyong Park323a4c32020-03-01 17:29:06 +09005975 runtime_libs: ["libbaz"],
Jiyong Park127b40b2019-09-30 16:04:35 +09005976 apex_available: ["myapex"],
5977 }
5978
5979 cc_library {
5980 name: "libbar",
5981 stl: "none",
5982 system_shared_libs: [],
5983 apex_available: ["//apex_available:anyapex"],
Jiyong Park323a4c32020-03-01 17:29:06 +09005984 }
5985
5986 cc_library {
5987 name: "libbaz",
5988 stl: "none",
5989 system_shared_libs: [],
5990 stubs: {
5991 versions: ["10", "20", "30"],
5992 },
Jiyong Park127b40b2019-09-30 16:04:35 +09005993 }`)
Paul Duffine52e66f2020-03-30 17:54:29 +01005994}
Jiyong Park127b40b2019-09-30 16:04:35 +09005995
Jiyong Park89e850a2020-04-07 16:37:39 +09005996func TestApexAvailable_CheckForPlatform(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08005997 ctx := testApex(t, `
Jiyong Park127b40b2019-09-30 16:04:35 +09005998 apex {
5999 name: "myapex",
6000 key: "myapex.key",
Jiyong Park89e850a2020-04-07 16:37:39 +09006001 native_shared_libs: ["libbar", "libbaz"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00006002 updatable: false,
Jiyong Park127b40b2019-09-30 16:04:35 +09006003 }
6004
6005 apex_key {
6006 name: "myapex.key",
6007 public_key: "testkey.avbpubkey",
6008 private_key: "testkey.pem",
6009 }
6010
6011 cc_library {
6012 name: "libfoo",
6013 stl: "none",
6014 system_shared_libs: [],
Jiyong Park89e850a2020-04-07 16:37:39 +09006015 shared_libs: ["libbar"],
Jiyong Park127b40b2019-09-30 16:04:35 +09006016 apex_available: ["//apex_available:platform"],
Jiyong Park89e850a2020-04-07 16:37:39 +09006017 }
6018
6019 cc_library {
6020 name: "libfoo2",
6021 stl: "none",
6022 system_shared_libs: [],
6023 shared_libs: ["libbaz"],
6024 apex_available: ["//apex_available:platform"],
6025 }
6026
6027 cc_library {
6028 name: "libbar",
6029 stl: "none",
6030 system_shared_libs: [],
6031 apex_available: ["myapex"],
6032 }
6033
6034 cc_library {
6035 name: "libbaz",
6036 stl: "none",
6037 system_shared_libs: [],
6038 apex_available: ["myapex"],
6039 stubs: {
6040 versions: ["1"],
6041 },
Jiyong Park127b40b2019-09-30 16:04:35 +09006042 }`)
6043
Jiyong Park89e850a2020-04-07 16:37:39 +09006044 // libfoo shouldn't be available to platform even though it has "//apex_available:platform",
6045 // because it depends on libbar which isn't available to platform
6046 libfoo := ctx.ModuleForTests("libfoo", "android_arm64_armv8-a_shared").Module().(*cc.Module)
6047 if libfoo.NotAvailableForPlatform() != true {
6048 t.Errorf("%q shouldn't be available to platform", libfoo.String())
6049 }
6050
6051 // libfoo2 however can be available to platform because it depends on libbaz which provides
6052 // stubs
6053 libfoo2 := ctx.ModuleForTests("libfoo2", "android_arm64_armv8-a_shared").Module().(*cc.Module)
6054 if libfoo2.NotAvailableForPlatform() == true {
6055 t.Errorf("%q should be available to platform", libfoo2.String())
6056 }
Paul Duffine52e66f2020-03-30 17:54:29 +01006057}
Jiyong Parka90ca002019-10-07 15:47:24 +09006058
Paul Duffine52e66f2020-03-30 17:54:29 +01006059func TestApexAvailable_CreatedForApex(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08006060 ctx := testApex(t, `
Jiyong Parka90ca002019-10-07 15:47:24 +09006061 apex {
6062 name: "myapex",
6063 key: "myapex.key",
6064 native_shared_libs: ["libfoo"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00006065 updatable: false,
Jiyong Parka90ca002019-10-07 15:47:24 +09006066 }
6067
6068 apex_key {
6069 name: "myapex.key",
6070 public_key: "testkey.avbpubkey",
6071 private_key: "testkey.pem",
6072 }
6073
6074 cc_library {
6075 name: "libfoo",
6076 stl: "none",
6077 system_shared_libs: [],
6078 apex_available: ["myapex"],
6079 static: {
6080 apex_available: ["//apex_available:platform"],
6081 },
6082 }`)
6083
Jiyong Park89e850a2020-04-07 16:37:39 +09006084 libfooShared := ctx.ModuleForTests("libfoo", "android_arm64_armv8-a_shared").Module().(*cc.Module)
6085 if libfooShared.NotAvailableForPlatform() != true {
6086 t.Errorf("%q shouldn't be available to platform", libfooShared.String())
6087 }
6088 libfooStatic := ctx.ModuleForTests("libfoo", "android_arm64_armv8-a_static").Module().(*cc.Module)
6089 if libfooStatic.NotAvailableForPlatform() != false {
6090 t.Errorf("%q should be available to platform", libfooStatic.String())
6091 }
Jiyong Park127b40b2019-09-30 16:04:35 +09006092}
6093
Jiyong Park5d790c32019-11-15 18:40:32 +09006094func TestOverrideApex(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08006095 ctx := testApex(t, `
Jiyong Park5d790c32019-11-15 18:40:32 +09006096 apex {
6097 name: "myapex",
6098 key: "myapex.key",
6099 apps: ["app"],
markchien7c803b82021-08-26 22:10:06 +08006100 bpfs: ["bpf"],
Daniel Norman5a3ce132021-08-26 15:44:43 -07006101 prebuilts: ["myetc"],
Remi NGUYEN VANbe901722022-03-02 21:00:33 +09006102 bootclasspath_fragments: ["mybootclasspath_fragment"],
6103 systemserverclasspath_fragments: ["mysystemserverclasspath_fragment"],
6104 java_libs: ["myjava_library"],
Jaewoong Jung7abcf8e2019-12-19 17:32:06 -08006105 overrides: ["oldapex"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00006106 updatable: false,
Jiyong Park5d790c32019-11-15 18:40:32 +09006107 }
6108
6109 override_apex {
6110 name: "override_myapex",
6111 base: "myapex",
6112 apps: ["override_app"],
markchien7c803b82021-08-26 22:10:06 +08006113 bpfs: ["override_bpf"],
Daniel Norman5a3ce132021-08-26 15:44:43 -07006114 prebuilts: ["override_myetc"],
Remi NGUYEN VANbe901722022-03-02 21:00:33 +09006115 bootclasspath_fragments: ["override_bootclasspath_fragment"],
6116 systemserverclasspath_fragments: ["override_systemserverclasspath_fragment"],
6117 java_libs: ["override_java_library"],
Jaewoong Jung7abcf8e2019-12-19 17:32:06 -08006118 overrides: ["unknownapex"],
Baligh Uddin004d7172020-02-19 21:29:28 -08006119 logging_parent: "com.foo.bar",
Baligh Uddin5b57dba2020-03-15 13:01:05 -07006120 package_name: "test.overridden.package",
Jaewoong Jung4cfdf7d2021-04-20 16:21:24 -07006121 key: "mynewapex.key",
6122 certificate: ":myapex.certificate",
Jiyong Park5d790c32019-11-15 18:40:32 +09006123 }
6124
6125 apex_key {
6126 name: "myapex.key",
6127 public_key: "testkey.avbpubkey",
6128 private_key: "testkey.pem",
6129 }
6130
Jaewoong Jung4cfdf7d2021-04-20 16:21:24 -07006131 apex_key {
6132 name: "mynewapex.key",
6133 public_key: "testkey2.avbpubkey",
6134 private_key: "testkey2.pem",
6135 }
6136
6137 android_app_certificate {
6138 name: "myapex.certificate",
6139 certificate: "testkey",
6140 }
6141
Jiyong Park5d790c32019-11-15 18:40:32 +09006142 android_app {
6143 name: "app",
6144 srcs: ["foo/bar/MyClass.java"],
6145 package_name: "foo",
6146 sdk_version: "none",
6147 system_modules: "none",
Anton Hanssoneec79eb2020-01-10 15:12:39 +00006148 apex_available: [ "myapex" ],
Jiyong Park5d790c32019-11-15 18:40:32 +09006149 }
6150
6151 override_android_app {
6152 name: "override_app",
6153 base: "app",
6154 package_name: "bar",
6155 }
markchien7c803b82021-08-26 22:10:06 +08006156
6157 bpf {
6158 name: "bpf",
6159 srcs: ["bpf.c"],
6160 }
6161
6162 bpf {
6163 name: "override_bpf",
6164 srcs: ["override_bpf.c"],
6165 }
Daniel Norman5a3ce132021-08-26 15:44:43 -07006166
6167 prebuilt_etc {
6168 name: "myetc",
6169 src: "myprebuilt",
6170 }
6171
6172 prebuilt_etc {
6173 name: "override_myetc",
6174 src: "override_myprebuilt",
6175 }
Remi NGUYEN VANbe901722022-03-02 21:00:33 +09006176
6177 java_library {
6178 name: "bcplib",
6179 srcs: ["a.java"],
6180 compile_dex: true,
6181 apex_available: ["myapex"],
6182 permitted_packages: ["bcp.lib"],
6183 }
6184
6185 bootclasspath_fragment {
6186 name: "mybootclasspath_fragment",
6187 contents: ["bcplib"],
6188 apex_available: ["myapex"],
6189 }
6190
6191 java_library {
6192 name: "override_bcplib",
6193 srcs: ["a.java"],
6194 compile_dex: true,
6195 apex_available: ["myapex"],
6196 permitted_packages: ["override.bcp.lib"],
6197 }
6198
6199 bootclasspath_fragment {
6200 name: "override_bootclasspath_fragment",
6201 contents: ["override_bcplib"],
6202 apex_available: ["myapex"],
6203 }
6204
6205 java_library {
6206 name: "systemserverlib",
6207 srcs: ["a.java"],
6208 apex_available: ["myapex"],
6209 }
6210
6211 systemserverclasspath_fragment {
6212 name: "mysystemserverclasspath_fragment",
6213 standalone_contents: ["systemserverlib"],
6214 apex_available: ["myapex"],
6215 }
6216
6217 java_library {
6218 name: "override_systemserverlib",
6219 srcs: ["a.java"],
6220 apex_available: ["myapex"],
6221 }
6222
6223 systemserverclasspath_fragment {
6224 name: "override_systemserverclasspath_fragment",
6225 standalone_contents: ["override_systemserverlib"],
6226 apex_available: ["myapex"],
6227 }
6228
6229 java_library {
6230 name: "myjava_library",
6231 srcs: ["a.java"],
6232 compile_dex: true,
6233 apex_available: ["myapex"],
6234 }
6235
6236 java_library {
6237 name: "override_java_library",
6238 srcs: ["a.java"],
6239 compile_dex: true,
6240 apex_available: ["myapex"],
6241 }
Jiyong Park20bacab2020-03-03 11:45:41 +09006242 `, withManifestPackageNameOverrides([]string{"myapex:com.android.myapex"}))
Jiyong Park5d790c32019-11-15 18:40:32 +09006243
Jiyong Park317645e2019-12-05 13:20:58 +09006244 originalVariant := ctx.ModuleForTests("myapex", "android_common_myapex_image").Module().(android.OverridableModule)
6245 overriddenVariant := ctx.ModuleForTests("myapex", "android_common_override_myapex_myapex_image").Module().(android.OverridableModule)
6246 if originalVariant.GetOverriddenBy() != "" {
6247 t.Errorf("GetOverriddenBy should be empty, but was %q", originalVariant.GetOverriddenBy())
6248 }
6249 if overriddenVariant.GetOverriddenBy() != "override_myapex" {
6250 t.Errorf("GetOverriddenBy should be \"override_myapex\", but was %q", overriddenVariant.GetOverriddenBy())
6251 }
6252
Jiyong Park5d790c32019-11-15 18:40:32 +09006253 module := ctx.ModuleForTests("myapex", "android_common_override_myapex_myapex_image")
6254 apexRule := module.Rule("apexRule")
6255 copyCmds := apexRule.Args["copy_commands"]
6256
6257 ensureNotContains(t, copyCmds, "image.apex/app/app/app.apk")
Jooyung Han39ee1192020-03-23 20:21:11 +09006258 ensureContains(t, copyCmds, "image.apex/app/override_app/override_app.apk")
Jaewoong Jung1670ca02019-11-22 14:50:42 -08006259
markchien7c803b82021-08-26 22:10:06 +08006260 ensureNotContains(t, copyCmds, "image.apex/etc/bpf/bpf.o")
6261 ensureContains(t, copyCmds, "image.apex/etc/bpf/override_bpf.o")
6262
Daniel Norman5a3ce132021-08-26 15:44:43 -07006263 ensureNotContains(t, copyCmds, "image.apex/etc/myetc")
6264 ensureContains(t, copyCmds, "image.apex/etc/override_myetc")
6265
Jaewoong Jung1670ca02019-11-22 14:50:42 -08006266 apexBundle := module.Module().(*apexBundle)
6267 name := apexBundle.Name()
6268 if name != "override_myapex" {
6269 t.Errorf("name should be \"override_myapex\", but was %q", name)
6270 }
6271
Baligh Uddin004d7172020-02-19 21:29:28 -08006272 if apexBundle.overridableProperties.Logging_parent != "com.foo.bar" {
6273 t.Errorf("override_myapex should have logging parent (com.foo.bar), but was %q.", apexBundle.overridableProperties.Logging_parent)
6274 }
6275
Remi NGUYEN VANbe901722022-03-02 21:00:33 +09006276 android.AssertArrayString(t, "Bootclasspath_fragments does not match",
6277 []string{"override_bootclasspath_fragment"}, apexBundle.overridableProperties.Bootclasspath_fragments)
6278 android.AssertArrayString(t, "Systemserverclasspath_fragments does not match",
6279 []string{"override_systemserverclasspath_fragment"}, apexBundle.overridableProperties.Systemserverclasspath_fragments)
6280 android.AssertArrayString(t, "Java_libs does not match",
6281 []string{"override_java_library"}, apexBundle.overridableProperties.Java_libs)
6282
Jiyong Park20bacab2020-03-03 11:45:41 +09006283 optFlags := apexRule.Args["opt_flags"]
Baligh Uddin5b57dba2020-03-15 13:01:05 -07006284 ensureContains(t, optFlags, "--override_apk_package_name test.overridden.package")
Jaewoong Jung4cfdf7d2021-04-20 16:21:24 -07006285 ensureContains(t, optFlags, "--pubkey testkey2.avbpubkey")
6286
6287 signApkRule := module.Rule("signapk")
6288 ensureEquals(t, signApkRule.Args["certificates"], "testkey.x509.pem testkey.pk8")
Jiyong Park20bacab2020-03-03 11:45:41 +09006289
Colin Crossaa255532020-07-03 13:18:24 -07006290 data := android.AndroidMkDataForTest(t, ctx, apexBundle)
Jaewoong Jung1670ca02019-11-22 14:50:42 -08006291 var builder strings.Builder
6292 data.Custom(&builder, name, "TARGET_", "", data)
6293 androidMk := builder.String()
Jiyong Parkf653b052019-11-18 15:39:01 +09006294 ensureContains(t, androidMk, "LOCAL_MODULE := override_app.override_myapex")
markchien7c803b82021-08-26 22:10:06 +08006295 ensureContains(t, androidMk, "LOCAL_MODULE := override_bpf.o.override_myapex")
Jaewoong Jung1670ca02019-11-22 14:50:42 -08006296 ensureContains(t, androidMk, "LOCAL_MODULE := apex_manifest.pb.override_myapex")
Remi NGUYEN VANbe901722022-03-02 21:00:33 +09006297 ensureContains(t, androidMk, "LOCAL_MODULE := override_bcplib.override_myapex")
6298 ensureContains(t, androidMk, "LOCAL_MODULE := override_systemserverlib.override_myapex")
6299 ensureContains(t, androidMk, "LOCAL_MODULE := override_java_library.override_myapex")
Jaewoong Jung1670ca02019-11-22 14:50:42 -08006300 ensureContains(t, androidMk, "LOCAL_MODULE_STEM := override_myapex.apex")
Jaewoong Jung7abcf8e2019-12-19 17:32:06 -08006301 ensureContains(t, androidMk, "LOCAL_OVERRIDES_MODULES := unknownapex myapex")
Jaewoong Jung1670ca02019-11-22 14:50:42 -08006302 ensureNotContains(t, androidMk, "LOCAL_MODULE := app.myapex")
markchien7c803b82021-08-26 22:10:06 +08006303 ensureNotContains(t, androidMk, "LOCAL_MODULE := bpf.myapex")
Jiyong Parkf653b052019-11-18 15:39:01 +09006304 ensureNotContains(t, androidMk, "LOCAL_MODULE := override_app.myapex")
Jaewoong Jung1670ca02019-11-22 14:50:42 -08006305 ensureNotContains(t, androidMk, "LOCAL_MODULE := apex_manifest.pb.myapex")
Remi NGUYEN VANbe901722022-03-02 21:00:33 +09006306 ensureNotContains(t, androidMk, "LOCAL_MODULE := override_bcplib.myapex")
6307 ensureNotContains(t, androidMk, "LOCAL_MODULE := override_systemserverlib.myapex")
6308 ensureNotContains(t, androidMk, "LOCAL_MODULE := override_java_library.pb.myapex")
Jaewoong Jung1670ca02019-11-22 14:50:42 -08006309 ensureNotContains(t, androidMk, "LOCAL_MODULE_STEM := myapex.apex")
Jiyong Park5d790c32019-11-15 18:40:32 +09006310}
6311
Albert Martin55ccba22022-03-21 20:11:16 +00006312func TestMinSdkVersionOverride(t *testing.T) {
6313 // Override from 29 to 31
6314 minSdkOverride31 := "31"
6315 ctx := testApex(t, `
6316 apex {
6317 name: "myapex",
6318 key: "myapex.key",
6319 native_shared_libs: ["mylib"],
6320 updatable: true,
6321 min_sdk_version: "29"
6322 }
6323
6324 override_apex {
6325 name: "override_myapex",
6326 base: "myapex",
6327 logging_parent: "com.foo.bar",
6328 package_name: "test.overridden.package"
6329 }
6330
6331 apex_key {
6332 name: "myapex.key",
6333 public_key: "testkey.avbpubkey",
6334 private_key: "testkey.pem",
6335 }
6336
6337 cc_library {
6338 name: "mylib",
6339 srcs: ["mylib.cpp"],
6340 runtime_libs: ["libbar"],
6341 system_shared_libs: [],
6342 stl: "none",
6343 apex_available: [ "myapex" ],
6344 min_sdk_version: "apex_inherit"
6345 }
6346
6347 cc_library {
6348 name: "libbar",
6349 srcs: ["mylib.cpp"],
6350 system_shared_libs: [],
6351 stl: "none",
6352 apex_available: [ "myapex" ],
6353 min_sdk_version: "apex_inherit"
6354 }
6355
6356 `, withApexGlobalMinSdkVersionOverride(&minSdkOverride31))
6357
6358 apexRule := ctx.ModuleForTests("myapex", "android_common_myapex_image").Rule("apexRule")
6359 copyCmds := apexRule.Args["copy_commands"]
6360
6361 // Ensure that direct non-stubs dep is always included
6362 ensureContains(t, copyCmds, "image.apex/lib64/mylib.so")
6363
6364 // Ensure that runtime_libs dep in included
6365 ensureContains(t, copyCmds, "image.apex/lib64/libbar.so")
6366
6367 // Ensure libraries target overridden min_sdk_version value
6368 ensureListContains(t, ctx.ModuleVariantsForTests("libbar"), "android_arm64_armv8-a_shared_apex31")
6369}
6370
6371func TestMinSdkVersionOverrideToLowerVersionNoOp(t *testing.T) {
6372 // Attempt to override from 31 to 29, should be a NOOP
6373 minSdkOverride29 := "29"
6374 ctx := testApex(t, `
6375 apex {
6376 name: "myapex",
6377 key: "myapex.key",
6378 native_shared_libs: ["mylib"],
6379 updatable: true,
6380 min_sdk_version: "31"
6381 }
6382
6383 override_apex {
6384 name: "override_myapex",
6385 base: "myapex",
6386 logging_parent: "com.foo.bar",
6387 package_name: "test.overridden.package"
6388 }
6389
6390 apex_key {
6391 name: "myapex.key",
6392 public_key: "testkey.avbpubkey",
6393 private_key: "testkey.pem",
6394 }
6395
6396 cc_library {
6397 name: "mylib",
6398 srcs: ["mylib.cpp"],
6399 runtime_libs: ["libbar"],
6400 system_shared_libs: [],
6401 stl: "none",
6402 apex_available: [ "myapex" ],
6403 min_sdk_version: "apex_inherit"
6404 }
6405
6406 cc_library {
6407 name: "libbar",
6408 srcs: ["mylib.cpp"],
6409 system_shared_libs: [],
6410 stl: "none",
6411 apex_available: [ "myapex" ],
6412 min_sdk_version: "apex_inherit"
6413 }
6414
6415 `, withApexGlobalMinSdkVersionOverride(&minSdkOverride29))
6416
6417 apexRule := ctx.ModuleForTests("myapex", "android_common_myapex_image").Rule("apexRule")
6418 copyCmds := apexRule.Args["copy_commands"]
6419
6420 // Ensure that direct non-stubs dep is always included
6421 ensureContains(t, copyCmds, "image.apex/lib64/mylib.so")
6422
6423 // Ensure that runtime_libs dep in included
6424 ensureContains(t, copyCmds, "image.apex/lib64/libbar.so")
6425
6426 // Ensure libraries target the original min_sdk_version value rather than the overridden
6427 ensureListContains(t, ctx.ModuleVariantsForTests("libbar"), "android_arm64_armv8-a_shared_apex31")
6428}
6429
Jooyung Han214bf372019-11-12 13:03:50 +09006430func TestLegacyAndroid10Support(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08006431 ctx := testApex(t, `
Jooyung Han214bf372019-11-12 13:03:50 +09006432 apex {
6433 name: "myapex",
6434 key: "myapex.key",
Peter Collingbournedc4f9862020-02-12 17:13:25 -08006435 native_shared_libs: ["mylib"],
Jooyung Han5417f772020-03-12 18:37:20 +09006436 min_sdk_version: "29",
Jooyung Han214bf372019-11-12 13:03:50 +09006437 }
6438
6439 apex_key {
6440 name: "myapex.key",
6441 public_key: "testkey.avbpubkey",
6442 private_key: "testkey.pem",
6443 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08006444
6445 cc_library {
6446 name: "mylib",
6447 srcs: ["mylib.cpp"],
6448 stl: "libc++",
6449 system_shared_libs: [],
6450 apex_available: [ "myapex" ],
Jooyung Han749dc692020-04-15 11:03:39 +09006451 min_sdk_version: "29",
Peter Collingbournedc4f9862020-02-12 17:13:25 -08006452 }
Peter Collingbournedc4f9862020-02-12 17:13:25 -08006453 `, withUnbundledBuild)
Jooyung Han214bf372019-11-12 13:03:50 +09006454
6455 module := ctx.ModuleForTests("myapex", "android_common_myapex_image")
6456 args := module.Rule("apexRule").Args
6457 ensureContains(t, args["opt_flags"], "--manifest_json "+module.Output("apex_manifest.json").Output.String())
Dario Frenie3546902020-01-14 23:50:25 +00006458 ensureNotContains(t, args["opt_flags"], "--no_hashtree")
Peter Collingbournedc4f9862020-02-12 17:13:25 -08006459
6460 // The copies of the libraries in the apex should have one more dependency than
6461 // the ones outside the apex, namely the unwinder. Ideally we should check
6462 // the dependency names directly here but for some reason the names are blank in
6463 // this test.
6464 for _, lib := range []string{"libc++", "mylib"} {
Colin Crossaede88c2020-08-11 12:17:01 -07006465 apexImplicits := ctx.ModuleForTests(lib, "android_arm64_armv8-a_shared_apex29").Rule("ld").Implicits
Peter Collingbournedc4f9862020-02-12 17:13:25 -08006466 nonApexImplicits := ctx.ModuleForTests(lib, "android_arm64_armv8-a_shared").Rule("ld").Implicits
6467 if len(apexImplicits) != len(nonApexImplicits)+1 {
6468 t.Errorf("%q missing unwinder dep", lib)
6469 }
6470 }
Jooyung Han214bf372019-11-12 13:03:50 +09006471}
6472
Paul Duffine05480a2021-03-08 15:07:14 +00006473var filesForSdkLibrary = android.MockFS{
Paul Duffin9b879592020-05-26 13:21:35 +01006474 "api/current.txt": nil,
6475 "api/removed.txt": nil,
6476 "api/system-current.txt": nil,
6477 "api/system-removed.txt": nil,
6478 "api/test-current.txt": nil,
6479 "api/test-removed.txt": nil,
Paul Duffineedc5d52020-06-12 17:46:39 +01006480
Anton Hanssondff2c782020-12-21 17:10:01 +00006481 "100/public/api/foo.txt": nil,
6482 "100/public/api/foo-removed.txt": nil,
6483 "100/system/api/foo.txt": nil,
6484 "100/system/api/foo-removed.txt": nil,
6485
Paul Duffineedc5d52020-06-12 17:46:39 +01006486 // For java_sdk_library_import
6487 "a.jar": nil,
Paul Duffin9b879592020-05-26 13:21:35 +01006488}
6489
Jooyung Han58f26ab2019-12-18 15:34:32 +09006490func TestJavaSDKLibrary(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08006491 ctx := testApex(t, `
Jooyung Han58f26ab2019-12-18 15:34:32 +09006492 apex {
6493 name: "myapex",
6494 key: "myapex.key",
6495 java_libs: ["foo"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00006496 updatable: false,
Jooyung Han58f26ab2019-12-18 15:34:32 +09006497 }
6498
6499 apex_key {
6500 name: "myapex.key",
6501 public_key: "testkey.avbpubkey",
6502 private_key: "testkey.pem",
6503 }
6504
6505 java_sdk_library {
6506 name: "foo",
6507 srcs: ["a.java"],
6508 api_packages: ["foo"],
Anton Hanssoneec79eb2020-01-10 15:12:39 +00006509 apex_available: [ "myapex" ],
Jooyung Han58f26ab2019-12-18 15:34:32 +09006510 }
Anton Hanssondff2c782020-12-21 17:10:01 +00006511
6512 prebuilt_apis {
6513 name: "sdk",
6514 api_dirs: ["100"],
6515 }
Paul Duffin9b879592020-05-26 13:21:35 +01006516 `, withFiles(filesForSdkLibrary))
Jooyung Han58f26ab2019-12-18 15:34:32 +09006517
6518 // java_sdk_library installs both impl jar and permission XML
Jooyung Hana57af4a2020-01-23 05:36:59 +00006519 ensureExactContents(t, ctx, "myapex", "android_common_myapex_image", []string{
Jooyung Han58f26ab2019-12-18 15:34:32 +09006520 "javalib/foo.jar",
6521 "etc/permissions/foo.xml",
6522 })
6523 // Permission XML should point to the activated path of impl jar of java_sdk_library
Jiyong Parke3833882020-02-17 17:28:10 +09006524 sdkLibrary := ctx.ModuleForTests("foo.xml", "android_common_myapex").Rule("java_sdk_xml")
Pedro Loureiro9956e5e2021-09-07 17:21:59 +00006525 ensureMatches(t, sdkLibrary.RuleParams.Command, `<library\\n\s+name=\\\"foo\\\"\\n\s+file=\\\"/apex/myapex/javalib/foo.jar\\\"`)
Jooyung Han58f26ab2019-12-18 15:34:32 +09006526}
6527
Paul Duffin9b879592020-05-26 13:21:35 +01006528func TestJavaSDKLibrary_WithinApex(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08006529 ctx := testApex(t, `
Paul Duffin9b879592020-05-26 13:21:35 +01006530 apex {
6531 name: "myapex",
6532 key: "myapex.key",
6533 java_libs: ["foo", "bar"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00006534 updatable: false,
Paul Duffin9b879592020-05-26 13:21:35 +01006535 }
6536
6537 apex_key {
6538 name: "myapex.key",
6539 public_key: "testkey.avbpubkey",
6540 private_key: "testkey.pem",
6541 }
6542
6543 java_sdk_library {
6544 name: "foo",
6545 srcs: ["a.java"],
6546 api_packages: ["foo"],
6547 apex_available: ["myapex"],
6548 sdk_version: "none",
6549 system_modules: "none",
6550 }
6551
6552 java_library {
6553 name: "bar",
6554 srcs: ["a.java"],
6555 libs: ["foo"],
6556 apex_available: ["myapex"],
6557 sdk_version: "none",
6558 system_modules: "none",
6559 }
Anton Hanssondff2c782020-12-21 17:10:01 +00006560
6561 prebuilt_apis {
6562 name: "sdk",
6563 api_dirs: ["100"],
6564 }
Paul Duffin9b879592020-05-26 13:21:35 +01006565 `, withFiles(filesForSdkLibrary))
6566
6567 // java_sdk_library installs both impl jar and permission XML
6568 ensureExactContents(t, ctx, "myapex", "android_common_myapex_image", []string{
6569 "javalib/bar.jar",
6570 "javalib/foo.jar",
6571 "etc/permissions/foo.xml",
6572 })
6573
6574 // The bar library should depend on the implementation jar.
6575 barLibrary := ctx.ModuleForTests("bar", "android_common_myapex").Rule("javac")
Paul Duffincf8d7db2021-03-29 00:29:53 +01006576 if expected, actual := `^-classpath [^:]*/turbine-combined/foo\.jar$`, barLibrary.Args["classpath"]; !regexp.MustCompile(expected).MatchString(actual) {
Paul Duffin9b879592020-05-26 13:21:35 +01006577 t.Errorf("expected %q, found %#q", expected, actual)
6578 }
6579}
6580
6581func TestJavaSDKLibrary_CrossBoundary(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08006582 ctx := testApex(t, `
Paul Duffin9b879592020-05-26 13:21:35 +01006583 apex {
6584 name: "myapex",
6585 key: "myapex.key",
6586 java_libs: ["foo"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00006587 updatable: false,
Paul Duffin9b879592020-05-26 13:21:35 +01006588 }
6589
6590 apex_key {
6591 name: "myapex.key",
6592 public_key: "testkey.avbpubkey",
6593 private_key: "testkey.pem",
6594 }
6595
6596 java_sdk_library {
6597 name: "foo",
6598 srcs: ["a.java"],
6599 api_packages: ["foo"],
6600 apex_available: ["myapex"],
6601 sdk_version: "none",
6602 system_modules: "none",
6603 }
6604
6605 java_library {
6606 name: "bar",
6607 srcs: ["a.java"],
6608 libs: ["foo"],
6609 sdk_version: "none",
6610 system_modules: "none",
6611 }
Anton Hanssondff2c782020-12-21 17:10:01 +00006612
6613 prebuilt_apis {
6614 name: "sdk",
6615 api_dirs: ["100"],
6616 }
Paul Duffin9b879592020-05-26 13:21:35 +01006617 `, withFiles(filesForSdkLibrary))
6618
6619 // java_sdk_library installs both impl jar and permission XML
6620 ensureExactContents(t, ctx, "myapex", "android_common_myapex_image", []string{
6621 "javalib/foo.jar",
6622 "etc/permissions/foo.xml",
6623 })
6624
6625 // The bar library should depend on the stubs jar.
6626 barLibrary := ctx.ModuleForTests("bar", "android_common").Rule("javac")
Paul Duffincf8d7db2021-03-29 00:29:53 +01006627 if expected, actual := `^-classpath [^:]*/turbine-combined/foo\.stubs\.jar$`, barLibrary.Args["classpath"]; !regexp.MustCompile(expected).MatchString(actual) {
Paul Duffin9b879592020-05-26 13:21:35 +01006628 t.Errorf("expected %q, found %#q", expected, actual)
6629 }
6630}
6631
Paul Duffineedc5d52020-06-12 17:46:39 +01006632func TestJavaSDKLibrary_ImportPreferred(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08006633 ctx := testApex(t, `
Anton Hanssondff2c782020-12-21 17:10:01 +00006634 prebuilt_apis {
6635 name: "sdk",
6636 api_dirs: ["100"],
6637 }`,
Paul Duffineedc5d52020-06-12 17:46:39 +01006638 withFiles(map[string][]byte{
6639 "apex/a.java": nil,
6640 "apex/apex_manifest.json": nil,
6641 "apex/Android.bp": []byte(`
6642 package {
6643 default_visibility: ["//visibility:private"],
6644 }
6645
6646 apex {
6647 name: "myapex",
6648 key: "myapex.key",
6649 java_libs: ["foo", "bar"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00006650 updatable: false,
Paul Duffineedc5d52020-06-12 17:46:39 +01006651 }
6652
6653 apex_key {
6654 name: "myapex.key",
6655 public_key: "testkey.avbpubkey",
6656 private_key: "testkey.pem",
6657 }
6658
6659 java_library {
6660 name: "bar",
6661 srcs: ["a.java"],
6662 libs: ["foo"],
6663 apex_available: ["myapex"],
6664 sdk_version: "none",
6665 system_modules: "none",
6666 }
6667`),
6668 "source/a.java": nil,
6669 "source/api/current.txt": nil,
6670 "source/api/removed.txt": nil,
6671 "source/Android.bp": []byte(`
6672 package {
6673 default_visibility: ["//visibility:private"],
6674 }
6675
6676 java_sdk_library {
6677 name: "foo",
6678 visibility: ["//apex"],
6679 srcs: ["a.java"],
6680 api_packages: ["foo"],
6681 apex_available: ["myapex"],
6682 sdk_version: "none",
6683 system_modules: "none",
6684 public: {
6685 enabled: true,
6686 },
6687 }
6688`),
6689 "prebuilt/a.jar": nil,
6690 "prebuilt/Android.bp": []byte(`
6691 package {
6692 default_visibility: ["//visibility:private"],
6693 }
6694
6695 java_sdk_library_import {
6696 name: "foo",
6697 visibility: ["//apex", "//source"],
6698 apex_available: ["myapex"],
6699 prefer: true,
6700 public: {
6701 jars: ["a.jar"],
6702 },
6703 }
6704`),
Anton Hanssondff2c782020-12-21 17:10:01 +00006705 }), withFiles(filesForSdkLibrary),
Paul Duffineedc5d52020-06-12 17:46:39 +01006706 )
6707
6708 // java_sdk_library installs both impl jar and permission XML
6709 ensureExactContents(t, ctx, "myapex", "android_common_myapex_image", []string{
6710 "javalib/bar.jar",
6711 "javalib/foo.jar",
6712 "etc/permissions/foo.xml",
6713 })
6714
6715 // The bar library should depend on the implementation jar.
6716 barLibrary := ctx.ModuleForTests("bar", "android_common_myapex").Rule("javac")
Paul Duffincf8d7db2021-03-29 00:29:53 +01006717 if expected, actual := `^-classpath [^:]*/turbine-combined/foo\.impl\.jar$`, barLibrary.Args["classpath"]; !regexp.MustCompile(expected).MatchString(actual) {
Paul Duffineedc5d52020-06-12 17:46:39 +01006718 t.Errorf("expected %q, found %#q", expected, actual)
6719 }
6720}
6721
6722func TestJavaSDKLibrary_ImportOnly(t *testing.T) {
6723 testApexError(t, `java_libs: "foo" is not configured to be compiled into dex`, `
6724 apex {
6725 name: "myapex",
6726 key: "myapex.key",
6727 java_libs: ["foo"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00006728 updatable: false,
Paul Duffineedc5d52020-06-12 17:46:39 +01006729 }
6730
6731 apex_key {
6732 name: "myapex.key",
6733 public_key: "testkey.avbpubkey",
6734 private_key: "testkey.pem",
6735 }
6736
6737 java_sdk_library_import {
6738 name: "foo",
6739 apex_available: ["myapex"],
6740 prefer: true,
6741 public: {
6742 jars: ["a.jar"],
6743 },
6744 }
6745
6746 `, withFiles(filesForSdkLibrary))
6747}
6748
atrost6e126252020-01-27 17:01:16 +00006749func TestCompatConfig(t *testing.T) {
Paul Duffin284165a2021-03-29 01:50:31 +01006750 result := android.GroupFixturePreparers(
6751 prepareForApexTest,
6752 java.PrepareForTestWithPlatformCompatConfig,
6753 ).RunTestWithBp(t, `
atrost6e126252020-01-27 17:01:16 +00006754 apex {
6755 name: "myapex",
6756 key: "myapex.key",
Paul Duffin3abc1742021-03-15 19:32:23 +00006757 compat_configs: ["myjar-platform-compat-config"],
atrost6e126252020-01-27 17:01:16 +00006758 java_libs: ["myjar"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00006759 updatable: false,
atrost6e126252020-01-27 17:01:16 +00006760 }
6761
6762 apex_key {
6763 name: "myapex.key",
6764 public_key: "testkey.avbpubkey",
6765 private_key: "testkey.pem",
6766 }
6767
6768 platform_compat_config {
6769 name: "myjar-platform-compat-config",
6770 src: ":myjar",
6771 }
6772
6773 java_library {
6774 name: "myjar",
6775 srcs: ["foo/bar/MyClass.java"],
6776 sdk_version: "none",
6777 system_modules: "none",
atrost6e126252020-01-27 17:01:16 +00006778 apex_available: [ "myapex" ],
6779 }
Paul Duffin1b29e002021-03-16 15:06:54 +00006780
6781 // Make sure that a preferred prebuilt does not affect the apex contents.
6782 prebuilt_platform_compat_config {
6783 name: "myjar-platform-compat-config",
6784 metadata: "compat-config/metadata.xml",
6785 prefer: true,
6786 }
atrost6e126252020-01-27 17:01:16 +00006787 `)
Paul Duffina369c7b2021-03-09 03:08:05 +00006788 ctx := result.TestContext
atrost6e126252020-01-27 17:01:16 +00006789 ensureExactContents(t, ctx, "myapex", "android_common_myapex_image", []string{
6790 "etc/compatconfig/myjar-platform-compat-config.xml",
6791 "javalib/myjar.jar",
6792 })
6793}
6794
Jiyong Park479321d2019-12-16 11:47:12 +09006795func TestRejectNonInstallableJavaLibrary(t *testing.T) {
6796 testApexError(t, `"myjar" is not configured to be compiled into dex`, `
6797 apex {
6798 name: "myapex",
6799 key: "myapex.key",
6800 java_libs: ["myjar"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00006801 updatable: false,
Jiyong Park479321d2019-12-16 11:47:12 +09006802 }
6803
6804 apex_key {
6805 name: "myapex.key",
6806 public_key: "testkey.avbpubkey",
6807 private_key: "testkey.pem",
6808 }
6809
6810 java_library {
6811 name: "myjar",
6812 srcs: ["foo/bar/MyClass.java"],
6813 sdk_version: "none",
6814 system_modules: "none",
Jiyong Park6b21c7d2020-02-11 09:16:01 +09006815 compile_dex: false,
Jooyung Han5e9013b2020-03-10 06:23:13 +09006816 apex_available: ["myapex"],
Jiyong Park479321d2019-12-16 11:47:12 +09006817 }
6818 `)
6819}
6820
Jiyong Park7afd1072019-12-30 16:56:33 +09006821func TestCarryRequiredModuleNames(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08006822 ctx := testApex(t, `
Jiyong Park7afd1072019-12-30 16:56:33 +09006823 apex {
6824 name: "myapex",
6825 key: "myapex.key",
6826 native_shared_libs: ["mylib"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00006827 updatable: false,
Jiyong Park7afd1072019-12-30 16:56:33 +09006828 }
6829
6830 apex_key {
6831 name: "myapex.key",
6832 public_key: "testkey.avbpubkey",
6833 private_key: "testkey.pem",
6834 }
6835
6836 cc_library {
6837 name: "mylib",
6838 srcs: ["mylib.cpp"],
6839 system_shared_libs: [],
6840 stl: "none",
6841 required: ["a", "b"],
6842 host_required: ["c", "d"],
6843 target_required: ["e", "f"],
Anton Hanssoneec79eb2020-01-10 15:12:39 +00006844 apex_available: [ "myapex" ],
Jiyong Park7afd1072019-12-30 16:56:33 +09006845 }
6846 `)
6847
6848 apexBundle := ctx.ModuleForTests("myapex", "android_common_myapex_image").Module().(*apexBundle)
Colin Crossaa255532020-07-03 13:18:24 -07006849 data := android.AndroidMkDataForTest(t, ctx, apexBundle)
Jiyong Park7afd1072019-12-30 16:56:33 +09006850 name := apexBundle.BaseModuleName()
6851 prefix := "TARGET_"
6852 var builder strings.Builder
6853 data.Custom(&builder, name, prefix, "", data)
6854 androidMk := builder.String()
6855 ensureContains(t, androidMk, "LOCAL_REQUIRED_MODULES += a b\n")
6856 ensureContains(t, androidMk, "LOCAL_HOST_REQUIRED_MODULES += c d\n")
6857 ensureContains(t, androidMk, "LOCAL_TARGET_REQUIRED_MODULES += e f\n")
6858}
6859
Jiyong Park7cd10e32020-01-14 09:22:18 +09006860func TestSymlinksFromApexToSystem(t *testing.T) {
6861 bp := `
6862 apex {
6863 name: "myapex",
6864 key: "myapex.key",
6865 native_shared_libs: ["mylib"],
6866 java_libs: ["myjar"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00006867 updatable: false,
Jiyong Park7cd10e32020-01-14 09:22:18 +09006868 }
6869
Jiyong Park9d677202020-02-19 16:29:35 +09006870 apex {
6871 name: "myapex.updatable",
6872 key: "myapex.key",
6873 native_shared_libs: ["mylib"],
6874 java_libs: ["myjar"],
6875 updatable: true,
Jooyung Han548640b2020-04-27 12:10:30 +09006876 min_sdk_version: "current",
Jiyong Park9d677202020-02-19 16:29:35 +09006877 }
6878
Jiyong Park7cd10e32020-01-14 09:22:18 +09006879 apex_key {
6880 name: "myapex.key",
6881 public_key: "testkey.avbpubkey",
6882 private_key: "testkey.pem",
6883 }
6884
6885 cc_library {
6886 name: "mylib",
6887 srcs: ["mylib.cpp"],
6888 shared_libs: ["myotherlib"],
6889 system_shared_libs: [],
6890 stl: "none",
6891 apex_available: [
6892 "myapex",
Jiyong Park9d677202020-02-19 16:29:35 +09006893 "myapex.updatable",
Jiyong Park7cd10e32020-01-14 09:22:18 +09006894 "//apex_available:platform",
6895 ],
Jooyung Han749dc692020-04-15 11:03:39 +09006896 min_sdk_version: "current",
Jiyong Park7cd10e32020-01-14 09:22:18 +09006897 }
6898
6899 cc_library {
6900 name: "myotherlib",
6901 srcs: ["mylib.cpp"],
6902 system_shared_libs: [],
6903 stl: "none",
6904 apex_available: [
6905 "myapex",
Jiyong Park9d677202020-02-19 16:29:35 +09006906 "myapex.updatable",
Jiyong Park7cd10e32020-01-14 09:22:18 +09006907 "//apex_available:platform",
6908 ],
Jooyung Han749dc692020-04-15 11:03:39 +09006909 min_sdk_version: "current",
Jiyong Park7cd10e32020-01-14 09:22:18 +09006910 }
6911
6912 java_library {
6913 name: "myjar",
6914 srcs: ["foo/bar/MyClass.java"],
6915 sdk_version: "none",
6916 system_modules: "none",
6917 libs: ["myotherjar"],
Jiyong Park7cd10e32020-01-14 09:22:18 +09006918 apex_available: [
6919 "myapex",
Jiyong Park9d677202020-02-19 16:29:35 +09006920 "myapex.updatable",
Jiyong Park7cd10e32020-01-14 09:22:18 +09006921 "//apex_available:platform",
6922 ],
Jooyung Han749dc692020-04-15 11:03:39 +09006923 min_sdk_version: "current",
Jiyong Park7cd10e32020-01-14 09:22:18 +09006924 }
6925
6926 java_library {
6927 name: "myotherjar",
6928 srcs: ["foo/bar/MyClass.java"],
6929 sdk_version: "none",
6930 system_modules: "none",
6931 apex_available: [
6932 "myapex",
Jiyong Park9d677202020-02-19 16:29:35 +09006933 "myapex.updatable",
Jiyong Park7cd10e32020-01-14 09:22:18 +09006934 "//apex_available:platform",
6935 ],
Jooyung Han749dc692020-04-15 11:03:39 +09006936 min_sdk_version: "current",
Jiyong Park7cd10e32020-01-14 09:22:18 +09006937 }
6938 `
6939
6940 ensureRealfileExists := func(t *testing.T, files []fileInApex, file string) {
6941 for _, f := range files {
6942 if f.path == file {
6943 if f.isLink {
6944 t.Errorf("%q is not a real file", file)
6945 }
6946 return
6947 }
6948 }
6949 t.Errorf("%q is not found", file)
6950 }
6951
6952 ensureSymlinkExists := func(t *testing.T, files []fileInApex, file string) {
6953 for _, f := range files {
6954 if f.path == file {
6955 if !f.isLink {
6956 t.Errorf("%q is not a symlink", file)
6957 }
6958 return
6959 }
6960 }
6961 t.Errorf("%q is not found", file)
6962 }
6963
Jiyong Park9d677202020-02-19 16:29:35 +09006964 // For unbundled build, symlink shouldn't exist regardless of whether an APEX
6965 // is updatable or not
Colin Cross1c460562021-02-16 17:55:47 -08006966 ctx := testApex(t, bp, withUnbundledBuild)
Jooyung Hana57af4a2020-01-23 05:36:59 +00006967 files := getFiles(t, ctx, "myapex", "android_common_myapex_image")
Jiyong Park7cd10e32020-01-14 09:22:18 +09006968 ensureRealfileExists(t, files, "javalib/myjar.jar")
6969 ensureRealfileExists(t, files, "lib64/mylib.so")
6970 ensureRealfileExists(t, files, "lib64/myotherlib.so")
6971
Jiyong Park9d677202020-02-19 16:29:35 +09006972 files = getFiles(t, ctx, "myapex.updatable", "android_common_myapex.updatable_image")
6973 ensureRealfileExists(t, files, "javalib/myjar.jar")
6974 ensureRealfileExists(t, files, "lib64/mylib.so")
6975 ensureRealfileExists(t, files, "lib64/myotherlib.so")
6976
6977 // For bundled build, symlink to the system for the non-updatable APEXes only
Colin Cross1c460562021-02-16 17:55:47 -08006978 ctx = testApex(t, bp)
Jooyung Hana57af4a2020-01-23 05:36:59 +00006979 files = getFiles(t, ctx, "myapex", "android_common_myapex_image")
Jiyong Park7cd10e32020-01-14 09:22:18 +09006980 ensureRealfileExists(t, files, "javalib/myjar.jar")
6981 ensureRealfileExists(t, files, "lib64/mylib.so")
6982 ensureSymlinkExists(t, files, "lib64/myotherlib.so") // this is symlink
Jiyong Park9d677202020-02-19 16:29:35 +09006983
6984 files = getFiles(t, ctx, "myapex.updatable", "android_common_myapex.updatable_image")
6985 ensureRealfileExists(t, files, "javalib/myjar.jar")
6986 ensureRealfileExists(t, files, "lib64/mylib.so")
6987 ensureRealfileExists(t, files, "lib64/myotherlib.so") // this is a real file
Jiyong Park7cd10e32020-01-14 09:22:18 +09006988}
6989
Yo Chiange8128052020-07-23 20:09:18 +08006990func TestSymlinksFromApexToSystemRequiredModuleNames(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08006991 ctx := testApex(t, `
Yo Chiange8128052020-07-23 20:09:18 +08006992 apex {
6993 name: "myapex",
6994 key: "myapex.key",
6995 native_shared_libs: ["mylib"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00006996 updatable: false,
Yo Chiange8128052020-07-23 20:09:18 +08006997 }
6998
6999 apex_key {
7000 name: "myapex.key",
7001 public_key: "testkey.avbpubkey",
7002 private_key: "testkey.pem",
7003 }
7004
7005 cc_library_shared {
7006 name: "mylib",
7007 srcs: ["mylib.cpp"],
7008 shared_libs: ["myotherlib"],
7009 system_shared_libs: [],
7010 stl: "none",
7011 apex_available: [
7012 "myapex",
7013 "//apex_available:platform",
7014 ],
7015 }
7016
7017 cc_prebuilt_library_shared {
7018 name: "myotherlib",
7019 srcs: ["prebuilt.so"],
7020 system_shared_libs: [],
7021 stl: "none",
7022 apex_available: [
7023 "myapex",
7024 "//apex_available:platform",
7025 ],
7026 }
7027 `)
7028
7029 apexBundle := ctx.ModuleForTests("myapex", "android_common_myapex_image").Module().(*apexBundle)
Colin Crossaa255532020-07-03 13:18:24 -07007030 data := android.AndroidMkDataForTest(t, ctx, apexBundle)
Yo Chiange8128052020-07-23 20:09:18 +08007031 var builder strings.Builder
7032 data.Custom(&builder, apexBundle.BaseModuleName(), "TARGET_", "", data)
7033 androidMk := builder.String()
7034 // `myotherlib` is added to `myapex` as symlink
7035 ensureContains(t, androidMk, "LOCAL_MODULE := mylib.myapex\n")
7036 ensureNotContains(t, androidMk, "LOCAL_MODULE := prebuilt_myotherlib.myapex\n")
7037 ensureNotContains(t, androidMk, "LOCAL_MODULE := myotherlib.myapex\n")
7038 // `myapex` should have `myotherlib` in its required line, not `prebuilt_myotherlib`
Jiyong Park57621b22021-01-20 20:33:11 +09007039 ensureContains(t, androidMk, "LOCAL_REQUIRED_MODULES += mylib.myapex:64 myotherlib:64 apex_manifest.pb.myapex apex_pubkey.myapex\n")
Yo Chiange8128052020-07-23 20:09:18 +08007040}
7041
Jooyung Han643adc42020-02-27 13:50:06 +09007042func TestApexWithJniLibs(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08007043 ctx := testApex(t, `
Jooyung Han643adc42020-02-27 13:50:06 +09007044 apex {
7045 name: "myapex",
7046 key: "myapex.key",
Jiyong Park34d5c332022-02-24 18:02:44 +09007047 jni_libs: ["mylib", "libfoo.rust"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00007048 updatable: false,
Jooyung Han643adc42020-02-27 13:50:06 +09007049 }
7050
7051 apex_key {
7052 name: "myapex.key",
7053 public_key: "testkey.avbpubkey",
7054 private_key: "testkey.pem",
7055 }
7056
7057 cc_library {
7058 name: "mylib",
7059 srcs: ["mylib.cpp"],
7060 shared_libs: ["mylib2"],
7061 system_shared_libs: [],
7062 stl: "none",
7063 apex_available: [ "myapex" ],
7064 }
7065
7066 cc_library {
7067 name: "mylib2",
7068 srcs: ["mylib.cpp"],
7069 system_shared_libs: [],
7070 stl: "none",
7071 apex_available: [ "myapex" ],
7072 }
Jiyong Park34d5c332022-02-24 18:02:44 +09007073
7074 rust_ffi_shared {
7075 name: "libfoo.rust",
7076 crate_name: "foo",
7077 srcs: ["foo.rs"],
7078 shared_libs: ["libfoo.shared_from_rust"],
7079 prefer_rlib: true,
7080 apex_available: ["myapex"],
7081 }
7082
7083 cc_library_shared {
7084 name: "libfoo.shared_from_rust",
7085 srcs: ["mylib.cpp"],
7086 system_shared_libs: [],
7087 stl: "none",
7088 stubs: {
7089 versions: ["10", "11", "12"],
7090 },
7091 }
7092
Jooyung Han643adc42020-02-27 13:50:06 +09007093 `)
7094
7095 rule := ctx.ModuleForTests("myapex", "android_common_myapex_image").Rule("apexManifestRule")
7096 // Notice mylib2.so (transitive dep) is not added as a jni_lib
Jiyong Park34d5c332022-02-24 18:02:44 +09007097 ensureEquals(t, rule.Args["opt"], "-a jniLibs libfoo.rust.so mylib.so")
Jooyung Han643adc42020-02-27 13:50:06 +09007098 ensureExactContents(t, ctx, "myapex", "android_common_myapex_image", []string{
7099 "lib64/mylib.so",
7100 "lib64/mylib2.so",
Jiyong Park34d5c332022-02-24 18:02:44 +09007101 "lib64/libfoo.rust.so",
7102 "lib64/libc++.so", // auto-added to libfoo.rust by Soong
7103 "lib64/liblog.so", // auto-added to libfoo.rust by Soong
Jooyung Han643adc42020-02-27 13:50:06 +09007104 })
Jiyong Park34d5c332022-02-24 18:02:44 +09007105
7106 // b/220397949
7107 ensureListContains(t, names(rule.Args["requireNativeLibs"]), "libfoo.shared_from_rust.so")
Jooyung Han643adc42020-02-27 13:50:06 +09007108}
7109
Jooyung Han49f67012020-04-17 13:43:10 +09007110func TestApexMutatorsDontRunIfDisabled(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08007111 ctx := testApex(t, `
Jooyung Han49f67012020-04-17 13:43:10 +09007112 apex {
7113 name: "myapex",
7114 key: "myapex.key",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00007115 updatable: false,
Jooyung Han49f67012020-04-17 13:43:10 +09007116 }
7117 apex_key {
7118 name: "myapex.key",
7119 public_key: "testkey.avbpubkey",
7120 private_key: "testkey.pem",
7121 }
Paul Duffin0a49fdc2021-03-08 11:28:25 +00007122 `,
7123 android.FixtureModifyConfig(func(config android.Config) {
7124 delete(config.Targets, android.Android)
7125 config.AndroidCommonTarget = android.Target{}
7126 }),
7127 )
Jooyung Han49f67012020-04-17 13:43:10 +09007128
7129 if expected, got := []string{""}, ctx.ModuleVariantsForTests("myapex"); !reflect.DeepEqual(expected, got) {
7130 t.Errorf("Expected variants: %v, but got: %v", expected, got)
7131 }
7132}
7133
Jiyong Parkbd159612020-02-28 15:22:21 +09007134func TestAppBundle(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08007135 ctx := testApex(t, `
Jiyong Parkbd159612020-02-28 15:22:21 +09007136 apex {
7137 name: "myapex",
7138 key: "myapex.key",
7139 apps: ["AppFoo"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00007140 updatable: false,
Jiyong Parkbd159612020-02-28 15:22:21 +09007141 }
7142
7143 apex_key {
7144 name: "myapex.key",
7145 public_key: "testkey.avbpubkey",
7146 private_key: "testkey.pem",
7147 }
7148
7149 android_app {
7150 name: "AppFoo",
7151 srcs: ["foo/bar/MyClass.java"],
7152 sdk_version: "none",
7153 system_modules: "none",
7154 apex_available: [ "myapex" ],
7155 }
Jiyong Parkcfaa1642020-02-28 16:51:07 +09007156 `, withManifestPackageNameOverrides([]string{"AppFoo:com.android.foo"}))
Jiyong Parkbd159612020-02-28 15:22:21 +09007157
Colin Crosscf371cc2020-11-13 11:48:42 -08007158 bundleConfigRule := ctx.ModuleForTests("myapex", "android_common_myapex_image").Output("bundle_config.json")
Jiyong Parkbd159612020-02-28 15:22:21 +09007159 content := bundleConfigRule.Args["content"]
7160
7161 ensureContains(t, content, `"compression":{"uncompressed_glob":["apex_payload.img","apex_manifest.*"]}`)
Jiyong Parkcfaa1642020-02-28 16:51:07 +09007162 ensureContains(t, content, `"apex_config":{"apex_embedded_apk_config":[{"package_name":"com.android.foo","path":"app/AppFoo/AppFoo.apk"}]}`)
Jiyong Parkbd159612020-02-28 15:22:21 +09007163}
7164
Sasha Smundak18d98bc2020-05-27 16:36:07 -07007165func TestAppSetBundle(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08007166 ctx := testApex(t, `
Sasha Smundak18d98bc2020-05-27 16:36:07 -07007167 apex {
7168 name: "myapex",
7169 key: "myapex.key",
7170 apps: ["AppSet"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00007171 updatable: false,
Sasha Smundak18d98bc2020-05-27 16:36:07 -07007172 }
7173
7174 apex_key {
7175 name: "myapex.key",
7176 public_key: "testkey.avbpubkey",
7177 private_key: "testkey.pem",
7178 }
7179
7180 android_app_set {
7181 name: "AppSet",
7182 set: "AppSet.apks",
7183 }`)
7184 mod := ctx.ModuleForTests("myapex", "android_common_myapex_image")
Colin Crosscf371cc2020-11-13 11:48:42 -08007185 bundleConfigRule := mod.Output("bundle_config.json")
Sasha Smundak18d98bc2020-05-27 16:36:07 -07007186 content := bundleConfigRule.Args["content"]
7187 ensureContains(t, content, `"compression":{"uncompressed_glob":["apex_payload.img","apex_manifest.*"]}`)
7188 s := mod.Rule("apexRule").Args["copy_commands"]
7189 copyCmds := regexp.MustCompile(" *&& *").Split(s, -1)
7190 if len(copyCmds) != 3 {
7191 t.Fatalf("Expected 3 commands, got %d in:\n%s", len(copyCmds), s)
7192 }
7193 ensureMatches(t, copyCmds[0], "^rm -rf .*/app/AppSet$")
7194 ensureMatches(t, copyCmds[1], "^mkdir -p .*/app/AppSet$")
7195 ensureMatches(t, copyCmds[2], "^unzip .*-d .*/app/AppSet .*/AppSet.zip$")
7196}
7197
Evgenii Stepanov2080bfe2020-07-24 15:35:40 -07007198func TestAppSetBundlePrebuilt(t *testing.T) {
Paul Duffin24704672021-04-06 16:09:30 +01007199 bp := `
Evgenii Stepanov2080bfe2020-07-24 15:35:40 -07007200 apex_set {
7201 name: "myapex",
7202 filename: "foo_v2.apex",
7203 sanitized: {
7204 none: { set: "myapex.apks", },
7205 hwaddress: { set: "myapex.hwasan.apks", },
7206 },
Paul Duffin24704672021-04-06 16:09:30 +01007207 }
7208 `
7209 ctx := testApex(t, bp, prepareForTestWithSantitizeHwaddress)
Evgenii Stepanov2080bfe2020-07-24 15:35:40 -07007210
Paul Duffin24704672021-04-06 16:09:30 +01007211 // Check that the extractor produces the correct output file from the correct input file.
7212 extractorOutput := "out/soong/.intermediates/myapex.apex.extractor/android_common/extracted/myapex.hwasan.apks"
Evgenii Stepanov2080bfe2020-07-24 15:35:40 -07007213
Paul Duffin24704672021-04-06 16:09:30 +01007214 m := ctx.ModuleForTests("myapex.apex.extractor", "android_common")
7215 extractedApex := m.Output(extractorOutput)
Evgenii Stepanov2080bfe2020-07-24 15:35:40 -07007216
Paul Duffin24704672021-04-06 16:09:30 +01007217 android.AssertArrayString(t, "extractor input", []string{"myapex.hwasan.apks"}, extractedApex.Inputs.Strings())
7218
7219 // Ditto for the apex.
Paul Duffin6717d882021-06-15 19:09:41 +01007220 m = ctx.ModuleForTests("myapex", "android_common_myapex")
7221 copiedApex := m.Output("out/soong/.intermediates/myapex/android_common_myapex/foo_v2.apex")
Paul Duffin24704672021-04-06 16:09:30 +01007222
7223 android.AssertStringEquals(t, "myapex input", extractorOutput, copiedApex.Input.String())
Evgenii Stepanov2080bfe2020-07-24 15:35:40 -07007224}
7225
Paul Duffin89f570a2021-06-16 01:42:33 +01007226func testNoUpdatableJarsInBootImage(t *testing.T, errmsg string, preparer android.FixturePreparer, fragments ...java.ApexVariantReference) {
Ulya Trafimovichb28cc372020-01-13 15:18:16 +00007227 t.Helper()
7228
Ulya Trafimovich7caef202020-05-19 12:00:52 +01007229 bp := `
7230 java_library {
7231 name: "some-updatable-apex-lib",
7232 srcs: ["a.java"],
7233 sdk_version: "current",
7234 apex_available: [
7235 "some-updatable-apex",
7236 ],
satayevabcd5972021-08-06 17:49:46 +01007237 permitted_packages: ["some.updatable.apex.lib"],
Ulya Trafimovich7caef202020-05-19 12:00:52 +01007238 }
7239
7240 java_library {
7241 name: "some-non-updatable-apex-lib",
7242 srcs: ["a.java"],
7243 apex_available: [
7244 "some-non-updatable-apex",
7245 ],
Paul Duffin89f570a2021-06-16 01:42:33 +01007246 compile_dex: true,
satayevabcd5972021-08-06 17:49:46 +01007247 permitted_packages: ["some.non.updatable.apex.lib"],
Paul Duffin89f570a2021-06-16 01:42:33 +01007248 }
7249
7250 bootclasspath_fragment {
7251 name: "some-non-updatable-fragment",
7252 contents: ["some-non-updatable-apex-lib"],
7253 apex_available: [
7254 "some-non-updatable-apex",
7255 ],
Ulya Trafimovich7caef202020-05-19 12:00:52 +01007256 }
7257
7258 java_library {
7259 name: "some-platform-lib",
7260 srcs: ["a.java"],
7261 sdk_version: "current",
7262 installable: true,
7263 }
7264
7265 java_library {
7266 name: "some-art-lib",
7267 srcs: ["a.java"],
7268 sdk_version: "current",
7269 apex_available: [
Paul Duffind376f792021-01-26 11:59:35 +00007270 "com.android.art.debug",
Ulya Trafimovich7caef202020-05-19 12:00:52 +01007271 ],
7272 hostdex: true,
Paul Duffine5218812021-06-07 13:28:19 +01007273 compile_dex: true,
Ulya Trafimovich7caef202020-05-19 12:00:52 +01007274 }
7275
7276 apex {
7277 name: "some-updatable-apex",
7278 key: "some-updatable-apex.key",
7279 java_libs: ["some-updatable-apex-lib"],
7280 updatable: true,
7281 min_sdk_version: "current",
7282 }
7283
7284 apex {
7285 name: "some-non-updatable-apex",
7286 key: "some-non-updatable-apex.key",
Paul Duffin89f570a2021-06-16 01:42:33 +01007287 bootclasspath_fragments: ["some-non-updatable-fragment"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00007288 updatable: false,
Ulya Trafimovich7caef202020-05-19 12:00:52 +01007289 }
7290
7291 apex_key {
7292 name: "some-updatable-apex.key",
7293 }
7294
7295 apex_key {
7296 name: "some-non-updatable-apex.key",
7297 }
7298
7299 apex {
Paul Duffind376f792021-01-26 11:59:35 +00007300 name: "com.android.art.debug",
7301 key: "com.android.art.debug.key",
Paul Duffin89f570a2021-06-16 01:42:33 +01007302 bootclasspath_fragments: ["art-bootclasspath-fragment"],
Ulya Trafimovich7caef202020-05-19 12:00:52 +01007303 updatable: true,
7304 min_sdk_version: "current",
7305 }
7306
Paul Duffinf23bc472021-04-27 12:42:20 +01007307 bootclasspath_fragment {
7308 name: "art-bootclasspath-fragment",
7309 image_name: "art",
7310 contents: ["some-art-lib"],
7311 apex_available: [
7312 "com.android.art.debug",
7313 ],
7314 }
7315
Ulya Trafimovich7caef202020-05-19 12:00:52 +01007316 apex_key {
Paul Duffind376f792021-01-26 11:59:35 +00007317 name: "com.android.art.debug.key",
Ulya Trafimovich7caef202020-05-19 12:00:52 +01007318 }
7319
Ulya Trafimovichb28cc372020-01-13 15:18:16 +00007320 filegroup {
7321 name: "some-updatable-apex-file_contexts",
7322 srcs: [
7323 "system/sepolicy/apex/some-updatable-apex-file_contexts",
7324 ],
7325 }
Ulya Trafimovich7c140d82020-04-22 18:05:58 +01007326
7327 filegroup {
7328 name: "some-non-updatable-apex-file_contexts",
7329 srcs: [
7330 "system/sepolicy/apex/some-non-updatable-apex-file_contexts",
7331 ],
7332 }
Ulya Trafimovichb28cc372020-01-13 15:18:16 +00007333 `
Paul Duffinc3bbb962020-12-10 19:15:49 +00007334
Paul Duffin89f570a2021-06-16 01:42:33 +01007335 testDexpreoptWithApexes(t, bp, errmsg, preparer, fragments...)
Paul Duffinc3bbb962020-12-10 19:15:49 +00007336}
7337
Paul Duffin89f570a2021-06-16 01:42:33 +01007338func testDexpreoptWithApexes(t *testing.T, bp, errmsg string, preparer android.FixturePreparer, fragments ...java.ApexVariantReference) *android.TestContext {
Paul Duffinc3bbb962020-12-10 19:15:49 +00007339 t.Helper()
7340
Paul Duffin55607122021-03-30 23:32:51 +01007341 fs := android.MockFS{
7342 "a.java": nil,
7343 "a.jar": nil,
7344 "apex_manifest.json": nil,
7345 "AndroidManifest.xml": nil,
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +00007346 "system/sepolicy/apex/myapex-file_contexts": nil,
Paul Duffind376f792021-01-26 11:59:35 +00007347 "system/sepolicy/apex/some-updatable-apex-file_contexts": nil,
7348 "system/sepolicy/apex/some-non-updatable-apex-file_contexts": nil,
7349 "system/sepolicy/apex/com.android.art.debug-file_contexts": nil,
Martin Stjernholm1dc0d6d2021-01-17 21:05:12 +00007350 "framework/aidl/a.aidl": nil,
Ulya Trafimovichb28cc372020-01-13 15:18:16 +00007351 }
Ulya Trafimovichb28cc372020-01-13 15:18:16 +00007352
Paul Duffin55607122021-03-30 23:32:51 +01007353 errorHandler := android.FixtureExpectsNoErrors
7354 if errmsg != "" {
7355 errorHandler = android.FixtureExpectsAtLeastOneErrorMatchingPattern(errmsg)
Ulya Trafimovichb28cc372020-01-13 15:18:16 +00007356 }
Paul Duffin064b70c2020-11-02 17:32:38 +00007357
Paul Duffin55607122021-03-30 23:32:51 +01007358 result := android.GroupFixturePreparers(
7359 cc.PrepareForTestWithCcDefaultModules,
7360 java.PrepareForTestWithHiddenApiBuildComponents,
7361 java.PrepareForTestWithJavaDefaultModules,
7362 java.PrepareForTestWithJavaSdkLibraryFiles,
7363 PrepareForTestWithApexBuildComponents,
Paul Duffin60264a02021-04-12 20:02:36 +01007364 preparer,
Paul Duffin55607122021-03-30 23:32:51 +01007365 fs.AddToFixture(),
Paul Duffin89f570a2021-06-16 01:42:33 +01007366 android.FixtureModifyMockFS(func(fs android.MockFS) {
7367 if _, ok := fs["frameworks/base/boot/Android.bp"]; !ok {
7368 insert := ""
7369 for _, fragment := range fragments {
7370 insert += fmt.Sprintf("{apex: %q, module: %q},\n", *fragment.Apex, *fragment.Module)
7371 }
7372 fs["frameworks/base/boot/Android.bp"] = []byte(fmt.Sprintf(`
7373 platform_bootclasspath {
7374 name: "platform-bootclasspath",
7375 fragments: [
7376 %s
7377 ],
7378 }
7379 `, insert))
Paul Duffin8f146b92021-04-12 17:24:18 +01007380 }
Paul Duffin89f570a2021-06-16 01:42:33 +01007381 }),
Jiakai Zhang49b1eb62021-11-26 18:09:27 +00007382 dexpreopt.FixtureSetBootImageProfiles("art/build/boot/boot-image-profile.txt"),
Paul Duffin55607122021-03-30 23:32:51 +01007383 ).
7384 ExtendWithErrorHandler(errorHandler).
7385 RunTestWithBp(t, bp)
7386
7387 return result.TestContext
Ulya Trafimovichb28cc372020-01-13 15:18:16 +00007388}
7389
Martin Stjernholm43c44b02021-06-30 16:35:07 +01007390func TestDuplicateDeapexeresFromPrebuiltApexes(t *testing.T) {
7391 preparers := android.GroupFixturePreparers(
7392 java.PrepareForTestWithJavaDefaultModules,
7393 PrepareForTestWithApexBuildComponents,
7394 ).
7395 ExtendWithErrorHandler(android.FixtureExpectsAtLeastOneErrorMatchingPattern(
7396 "Multiple installable prebuilt APEXes provide ambiguous deapexers: com.android.myapex and com.mycompany.android.myapex"))
7397
7398 bpBase := `
7399 apex_set {
7400 name: "com.android.myapex",
7401 installable: true,
7402 exported_bootclasspath_fragments: ["my-bootclasspath-fragment"],
7403 set: "myapex.apks",
7404 }
7405
7406 apex_set {
7407 name: "com.mycompany.android.myapex",
7408 apex_name: "com.android.myapex",
7409 installable: true,
7410 exported_bootclasspath_fragments: ["my-bootclasspath-fragment"],
7411 set: "company-myapex.apks",
7412 }
7413
7414 prebuilt_bootclasspath_fragment {
7415 name: "my-bootclasspath-fragment",
7416 apex_available: ["com.android.myapex"],
7417 %s
7418 }
7419 `
7420
7421 t.Run("java_import", func(t *testing.T) {
7422 _ = preparers.RunTestWithBp(t, fmt.Sprintf(bpBase, `contents: ["libfoo"]`)+`
7423 java_import {
7424 name: "libfoo",
7425 jars: ["libfoo.jar"],
7426 apex_available: ["com.android.myapex"],
7427 }
7428 `)
7429 })
7430
7431 t.Run("java_sdk_library_import", func(t *testing.T) {
7432 _ = preparers.RunTestWithBp(t, fmt.Sprintf(bpBase, `contents: ["libfoo"]`)+`
7433 java_sdk_library_import {
7434 name: "libfoo",
7435 public: {
7436 jars: ["libbar.jar"],
7437 },
7438 apex_available: ["com.android.myapex"],
7439 }
7440 `)
7441 })
7442
7443 t.Run("prebuilt_bootclasspath_fragment", func(t *testing.T) {
7444 _ = preparers.RunTestWithBp(t, fmt.Sprintf(bpBase, `
7445 image_name: "art",
7446 contents: ["libfoo"],
7447 `)+`
7448 java_sdk_library_import {
7449 name: "libfoo",
7450 public: {
7451 jars: ["libbar.jar"],
7452 },
7453 apex_available: ["com.android.myapex"],
7454 }
7455 `)
7456 })
7457}
7458
Jooyung Han548640b2020-04-27 12:10:30 +09007459func TestUpdatable_should_set_min_sdk_version(t *testing.T) {
7460 testApexError(t, `"myapex" .*: updatable: updatable APEXes should set min_sdk_version`, `
7461 apex {
7462 name: "myapex",
7463 key: "myapex.key",
7464 updatable: true,
7465 }
7466
7467 apex_key {
7468 name: "myapex.key",
7469 public_key: "testkey.avbpubkey",
7470 private_key: "testkey.pem",
7471 }
7472 `)
7473}
7474
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00007475func TestUpdatableDefault_should_set_min_sdk_version(t *testing.T) {
7476 testApexError(t, `"myapex" .*: updatable: updatable APEXes should set min_sdk_version`, `
7477 apex {
7478 name: "myapex",
7479 key: "myapex.key",
7480 }
7481
7482 apex_key {
7483 name: "myapex.key",
7484 public_key: "testkey.avbpubkey",
7485 private_key: "testkey.pem",
7486 }
7487 `)
7488}
7489
Daniel Norman69109112021-12-02 12:52:42 -08007490func TestUpdatable_cannot_be_vendor_apex(t *testing.T) {
7491 testApexError(t, `"myapex" .*: updatable: vendor APEXes are not updatable`, `
7492 apex {
7493 name: "myapex",
7494 key: "myapex.key",
7495 updatable: true,
7496 soc_specific: true,
7497 }
7498
7499 apex_key {
7500 name: "myapex.key",
7501 public_key: "testkey.avbpubkey",
7502 private_key: "testkey.pem",
7503 }
7504 `)
7505}
7506
satayevb98371c2021-06-15 16:49:50 +01007507func TestUpdatable_should_not_set_generate_classpaths_proto(t *testing.T) {
7508 testApexError(t, `"mysystemserverclasspathfragment" .* it must not set generate_classpaths_proto to false`, `
7509 apex {
7510 name: "myapex",
7511 key: "myapex.key",
7512 systemserverclasspath_fragments: [
7513 "mysystemserverclasspathfragment",
7514 ],
7515 min_sdk_version: "29",
7516 updatable: true,
7517 }
7518
7519 apex_key {
7520 name: "myapex.key",
7521 public_key: "testkey.avbpubkey",
7522 private_key: "testkey.pem",
7523 }
7524
7525 java_library {
7526 name: "foo",
7527 srcs: ["b.java"],
7528 min_sdk_version: "29",
7529 installable: true,
7530 apex_available: [
7531 "myapex",
7532 ],
7533 }
7534
7535 systemserverclasspath_fragment {
7536 name: "mysystemserverclasspathfragment",
7537 generate_classpaths_proto: false,
7538 contents: [
7539 "foo",
7540 ],
7541 apex_available: [
7542 "myapex",
7543 ],
7544 }
satayevabcd5972021-08-06 17:49:46 +01007545 `,
7546 dexpreopt.FixtureSetApexSystemServerJars("myapex:foo"),
7547 )
satayevb98371c2021-06-15 16:49:50 +01007548}
7549
Ulya Trafimovichb28cc372020-01-13 15:18:16 +00007550func TestNoUpdatableJarsInBootImage(t *testing.T) {
Paul Duffin60264a02021-04-12 20:02:36 +01007551 // Set the BootJars in dexpreopt.GlobalConfig and productVariables to the same value. This can
7552 // result in an invalid configuration as it does not set the ArtApexJars and allows art apex
7553 // modules to be included in the BootJars.
7554 prepareSetBootJars := func(bootJars ...string) android.FixturePreparer {
7555 return android.GroupFixturePreparers(
7556 dexpreopt.FixtureSetBootJars(bootJars...),
7557 android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
7558 variables.BootJars = android.CreateTestConfiguredJarList(bootJars)
7559 }),
7560 )
7561 }
7562
7563 // Set the ArtApexJars and BootJars in dexpreopt.GlobalConfig and productVariables all to the
7564 // same value. This can result in an invalid configuration as it allows non art apex jars to be
7565 // specified in the ArtApexJars configuration.
7566 prepareSetArtJars := func(bootJars ...string) android.FixturePreparer {
7567 return android.GroupFixturePreparers(
7568 dexpreopt.FixtureSetArtBootJars(bootJars...),
7569 dexpreopt.FixtureSetBootJars(bootJars...),
7570 android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
7571 variables.BootJars = android.CreateTestConfiguredJarList(bootJars)
7572 }),
7573 )
7574 }
Ulya Trafimovichb28cc372020-01-13 15:18:16 +00007575
Ulya Trafimovich7caef202020-05-19 12:00:52 +01007576 t.Run("updatable jar from ART apex in the ART boot image => ok", func(t *testing.T) {
satayevabcd5972021-08-06 17:49:46 +01007577 preparer := android.GroupFixturePreparers(
7578 java.FixtureConfigureBootJars("com.android.art.debug:some-art-lib"),
7579 java.FixtureConfigureApexBootJars("some-non-updatable-apex:some-non-updatable-apex-lib"),
7580 )
7581 fragments := []java.ApexVariantReference{
7582 {
7583 Apex: proptools.StringPtr("com.android.art.debug"),
7584 Module: proptools.StringPtr("art-bootclasspath-fragment"),
7585 },
7586 {
7587 Apex: proptools.StringPtr("some-non-updatable-apex"),
7588 Module: proptools.StringPtr("some-non-updatable-fragment"),
7589 },
Paul Duffin89f570a2021-06-16 01:42:33 +01007590 }
satayevabcd5972021-08-06 17:49:46 +01007591 testNoUpdatableJarsInBootImage(t, "", preparer, fragments...)
Ulya Trafimovich7caef202020-05-19 12:00:52 +01007592 })
Ulya Trafimovichb28cc372020-01-13 15:18:16 +00007593
Ulya Trafimovich7caef202020-05-19 12:00:52 +01007594 t.Run("updatable jar from ART apex in the framework boot image => error", func(t *testing.T) {
Paul Duffin60264a02021-04-12 20:02:36 +01007595 err := `module "some-art-lib" from updatable apexes \["com.android.art.debug"\] is not allowed in the framework boot image`
7596 // Update the dexpreopt BootJars directly.
satayevabcd5972021-08-06 17:49:46 +01007597 preparer := android.GroupFixturePreparers(
7598 prepareSetBootJars("com.android.art.debug:some-art-lib"),
7599 java.FixtureConfigureApexBootJars("some-non-updatable-apex:some-non-updatable-apex-lib"),
7600 )
Paul Duffin60264a02021-04-12 20:02:36 +01007601 testNoUpdatableJarsInBootImage(t, err, preparer)
Ulya Trafimovich7caef202020-05-19 12:00:52 +01007602 })
Ulya Trafimovichb28cc372020-01-13 15:18:16 +00007603
Ulya Trafimovich7caef202020-05-19 12:00:52 +01007604 t.Run("updatable jar from some other apex in the ART boot image => error", func(t *testing.T) {
Paul Duffinf23bc472021-04-27 12:42:20 +01007605 err := `ArtApexJars expects this to be in apex "some-updatable-apex" but this is only in apexes.*"com.android.art.debug"`
Paul Duffin60264a02021-04-12 20:02:36 +01007606 // Update the dexpreopt ArtApexJars directly.
7607 preparer := prepareSetArtJars("some-updatable-apex:some-updatable-apex-lib")
7608 testNoUpdatableJarsInBootImage(t, err, preparer)
Ulya Trafimovich7caef202020-05-19 12:00:52 +01007609 })
Ulya Trafimovichb28cc372020-01-13 15:18:16 +00007610
Ulya Trafimovich7caef202020-05-19 12:00:52 +01007611 t.Run("non-updatable jar from some other apex in the ART boot image => error", func(t *testing.T) {
Paul Duffinf23bc472021-04-27 12:42:20 +01007612 err := `ArtApexJars expects this to be in apex "some-non-updatable-apex" but this is only in apexes.*"com.android.art.debug"`
Paul Duffin60264a02021-04-12 20:02:36 +01007613 // Update the dexpreopt ArtApexJars directly.
7614 preparer := prepareSetArtJars("some-non-updatable-apex:some-non-updatable-apex-lib")
7615 testNoUpdatableJarsInBootImage(t, err, preparer)
Ulya Trafimovich7caef202020-05-19 12:00:52 +01007616 })
Ulya Trafimovich7c140d82020-04-22 18:05:58 +01007617
Ulya Trafimovich7caef202020-05-19 12:00:52 +01007618 t.Run("updatable jar from some other apex in the framework boot image => error", func(t *testing.T) {
Paul Duffin60264a02021-04-12 20:02:36 +01007619 err := `module "some-updatable-apex-lib" from updatable apexes \["some-updatable-apex"\] is not allowed in the framework boot image`
satayevabcd5972021-08-06 17:49:46 +01007620 preparer := android.GroupFixturePreparers(
7621 java.FixtureConfigureBootJars("some-updatable-apex:some-updatable-apex-lib"),
7622 java.FixtureConfigureApexBootJars("some-non-updatable-apex:some-non-updatable-apex-lib"),
7623 )
Paul Duffin60264a02021-04-12 20:02:36 +01007624 testNoUpdatableJarsInBootImage(t, err, preparer)
Ulya Trafimovich7caef202020-05-19 12:00:52 +01007625 })
Ulya Trafimovichb28cc372020-01-13 15:18:16 +00007626
Ulya Trafimovich7caef202020-05-19 12:00:52 +01007627 t.Run("non-updatable jar from some other apex in the framework boot image => ok", func(t *testing.T) {
satayevabcd5972021-08-06 17:49:46 +01007628 preparer := java.FixtureConfigureApexBootJars("some-non-updatable-apex:some-non-updatable-apex-lib")
Paul Duffin89f570a2021-06-16 01:42:33 +01007629 fragment := java.ApexVariantReference{
7630 Apex: proptools.StringPtr("some-non-updatable-apex"),
7631 Module: proptools.StringPtr("some-non-updatable-fragment"),
7632 }
7633 testNoUpdatableJarsInBootImage(t, "", preparer, fragment)
Ulya Trafimovich7caef202020-05-19 12:00:52 +01007634 })
Ulya Trafimovich7c140d82020-04-22 18:05:58 +01007635
Ulya Trafimovich7caef202020-05-19 12:00:52 +01007636 t.Run("nonexistent jar in the ART boot image => error", func(t *testing.T) {
Paul Duffin8f146b92021-04-12 17:24:18 +01007637 err := `"platform-bootclasspath" depends on undefined module "nonexistent"`
Paul Duffin60264a02021-04-12 20:02:36 +01007638 preparer := java.FixtureConfigureBootJars("platform:nonexistent")
7639 testNoUpdatableJarsInBootImage(t, err, preparer)
Ulya Trafimovich7caef202020-05-19 12:00:52 +01007640 })
Ulya Trafimovichb28cc372020-01-13 15:18:16 +00007641
Ulya Trafimovich7caef202020-05-19 12:00:52 +01007642 t.Run("nonexistent jar in the framework boot image => error", func(t *testing.T) {
Paul Duffin8f146b92021-04-12 17:24:18 +01007643 err := `"platform-bootclasspath" depends on undefined module "nonexistent"`
Paul Duffin60264a02021-04-12 20:02:36 +01007644 preparer := java.FixtureConfigureBootJars("platform:nonexistent")
7645 testNoUpdatableJarsInBootImage(t, err, preparer)
Ulya Trafimovich7caef202020-05-19 12:00:52 +01007646 })
Ulya Trafimovichb28cc372020-01-13 15:18:16 +00007647
Ulya Trafimovich7caef202020-05-19 12:00:52 +01007648 t.Run("platform jar in the ART boot image => error", func(t *testing.T) {
Paul Duffinf23bc472021-04-27 12:42:20 +01007649 err := `ArtApexJars is invalid as it requests a platform variant of "some-platform-lib"`
Paul Duffin60264a02021-04-12 20:02:36 +01007650 // Update the dexpreopt ArtApexJars directly.
7651 preparer := prepareSetArtJars("platform:some-platform-lib")
7652 testNoUpdatableJarsInBootImage(t, err, preparer)
Ulya Trafimovich7caef202020-05-19 12:00:52 +01007653 })
Ulya Trafimovichb28cc372020-01-13 15:18:16 +00007654
Ulya Trafimovich7caef202020-05-19 12:00:52 +01007655 t.Run("platform jar in the framework boot image => ok", func(t *testing.T) {
satayevabcd5972021-08-06 17:49:46 +01007656 preparer := android.GroupFixturePreparers(
7657 java.FixtureConfigureBootJars("platform:some-platform-lib"),
7658 java.FixtureConfigureApexBootJars("some-non-updatable-apex:some-non-updatable-apex-lib"),
7659 )
7660 fragments := []java.ApexVariantReference{
7661 {
7662 Apex: proptools.StringPtr("some-non-updatable-apex"),
7663 Module: proptools.StringPtr("some-non-updatable-fragment"),
7664 },
7665 }
7666 testNoUpdatableJarsInBootImage(t, "", preparer, fragments...)
Ulya Trafimovich7caef202020-05-19 12:00:52 +01007667 })
Paul Duffin064b70c2020-11-02 17:32:38 +00007668}
7669
7670func TestDexpreoptAccessDexFilesFromPrebuiltApex(t *testing.T) {
satayevabcd5972021-08-06 17:49:46 +01007671 preparer := java.FixtureConfigureApexBootJars("myapex:libfoo")
Paul Duffin064b70c2020-11-02 17:32:38 +00007672 t.Run("prebuilt no source", func(t *testing.T) {
Paul Duffin89f570a2021-06-16 01:42:33 +01007673 fragment := java.ApexVariantReference{
7674 Apex: proptools.StringPtr("myapex"),
7675 Module: proptools.StringPtr("my-bootclasspath-fragment"),
7676 }
7677
Paul Duffin064b70c2020-11-02 17:32:38 +00007678 testDexpreoptWithApexes(t, `
7679 prebuilt_apex {
7680 name: "myapex" ,
7681 arch: {
7682 arm64: {
7683 src: "myapex-arm64.apex",
7684 },
7685 arm: {
7686 src: "myapex-arm.apex",
7687 },
7688 },
Paul Duffin89f570a2021-06-16 01:42:33 +01007689 exported_bootclasspath_fragments: ["my-bootclasspath-fragment"],
7690 }
Paul Duffin064b70c2020-11-02 17:32:38 +00007691
Paul Duffin89f570a2021-06-16 01:42:33 +01007692 prebuilt_bootclasspath_fragment {
7693 name: "my-bootclasspath-fragment",
7694 contents: ["libfoo"],
7695 apex_available: ["myapex"],
Paul Duffin54e41972021-07-19 13:23:40 +01007696 hidden_api: {
7697 annotation_flags: "my-bootclasspath-fragment/annotation-flags.csv",
7698 metadata: "my-bootclasspath-fragment/metadata.csv",
7699 index: "my-bootclasspath-fragment/index.csv",
Paul Duffin191be3a2021-08-10 16:14:16 +01007700 signature_patterns: "my-bootclasspath-fragment/signature-patterns.csv",
7701 filtered_stub_flags: "my-bootclasspath-fragment/filtered-stub-flags.csv",
7702 filtered_flags: "my-bootclasspath-fragment/filtered-flags.csv",
Paul Duffin54e41972021-07-19 13:23:40 +01007703 },
Paul Duffin89f570a2021-06-16 01:42:33 +01007704 }
Paul Duffin064b70c2020-11-02 17:32:38 +00007705
Paul Duffin89f570a2021-06-16 01:42:33 +01007706 java_import {
7707 name: "libfoo",
7708 jars: ["libfoo.jar"],
7709 apex_available: ["myapex"],
satayevabcd5972021-08-06 17:49:46 +01007710 permitted_packages: ["libfoo"],
Paul Duffin89f570a2021-06-16 01:42:33 +01007711 }
7712 `, "", preparer, fragment)
Paul Duffin064b70c2020-11-02 17:32:38 +00007713 })
Ulya Trafimovichb28cc372020-01-13 15:18:16 +00007714}
7715
satayevd604b212021-07-21 14:23:52 +01007716func testApexPermittedPackagesRules(t *testing.T, errmsg, bp string, bootJars []string, rules []android.Rule) {
Andrei Onea115e7e72020-06-05 21:14:03 +01007717 t.Helper()
Andrei Onea115e7e72020-06-05 21:14:03 +01007718 bp += `
7719 apex_key {
7720 name: "myapex.key",
7721 public_key: "testkey.avbpubkey",
7722 private_key: "testkey.pem",
7723 }`
Paul Duffin45338f02021-03-30 23:07:52 +01007724 fs := android.MockFS{
Andrei Onea115e7e72020-06-05 21:14:03 +01007725 "lib1/src/A.java": nil,
7726 "lib2/src/B.java": nil,
7727 "system/sepolicy/apex/myapex-file_contexts": nil,
7728 }
7729
Paul Duffin45338f02021-03-30 23:07:52 +01007730 errorHandler := android.FixtureExpectsNoErrors
7731 if errmsg != "" {
7732 errorHandler = android.FixtureExpectsAtLeastOneErrorMatchingPattern(errmsg)
Colin Crossae8600b2020-10-29 17:09:13 -07007733 }
Colin Crossae8600b2020-10-29 17:09:13 -07007734
Paul Duffin45338f02021-03-30 23:07:52 +01007735 android.GroupFixturePreparers(
7736 android.PrepareForTestWithAndroidBuildComponents,
7737 java.PrepareForTestWithJavaBuildComponents,
7738 PrepareForTestWithApexBuildComponents,
7739 android.PrepareForTestWithNeverallowRules(rules),
7740 android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
satayevd604b212021-07-21 14:23:52 +01007741 apexBootJars := make([]string, 0, len(bootJars))
7742 for _, apexBootJar := range bootJars {
7743 apexBootJars = append(apexBootJars, "myapex:"+apexBootJar)
Paul Duffin45338f02021-03-30 23:07:52 +01007744 }
satayevd604b212021-07-21 14:23:52 +01007745 variables.ApexBootJars = android.CreateTestConfiguredJarList(apexBootJars)
Paul Duffin45338f02021-03-30 23:07:52 +01007746 }),
7747 fs.AddToFixture(),
7748 ).
7749 ExtendWithErrorHandler(errorHandler).
7750 RunTestWithBp(t, bp)
Andrei Onea115e7e72020-06-05 21:14:03 +01007751}
7752
7753func TestApexPermittedPackagesRules(t *testing.T) {
7754 testcases := []struct {
7755 name string
7756 expectedError string
7757 bp string
7758 bootJars []string
7759 modulesPackages map[string][]string
7760 }{
7761
7762 {
7763 name: "Non-Bootclasspath apex jar not satisfying allowed module packages.",
7764 expectedError: "",
7765 bp: `
7766 java_library {
7767 name: "bcp_lib1",
7768 srcs: ["lib1/src/*.java"],
7769 permitted_packages: ["foo.bar"],
7770 apex_available: ["myapex"],
7771 sdk_version: "none",
7772 system_modules: "none",
Remi NGUYEN VAN1fdd6ca2021-12-02 19:39:35 +09007773 min_sdk_version: "30",
Andrei Onea115e7e72020-06-05 21:14:03 +01007774 }
7775 java_library {
7776 name: "nonbcp_lib2",
7777 srcs: ["lib2/src/*.java"],
7778 apex_available: ["myapex"],
7779 permitted_packages: ["a.b"],
7780 sdk_version: "none",
7781 system_modules: "none",
Remi NGUYEN VAN1fdd6ca2021-12-02 19:39:35 +09007782 min_sdk_version: "30",
Andrei Onea115e7e72020-06-05 21:14:03 +01007783 }
7784 apex {
7785 name: "myapex",
Remi NGUYEN VAN1fdd6ca2021-12-02 19:39:35 +09007786 min_sdk_version: "30",
Andrei Onea115e7e72020-06-05 21:14:03 +01007787 key: "myapex.key",
7788 java_libs: ["bcp_lib1", "nonbcp_lib2"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00007789 updatable: false,
Andrei Onea115e7e72020-06-05 21:14:03 +01007790 }`,
7791 bootJars: []string{"bcp_lib1"},
7792 modulesPackages: map[string][]string{
7793 "myapex": []string{
7794 "foo.bar",
7795 },
7796 },
7797 },
7798 {
Remi NGUYEN VAN1fdd6ca2021-12-02 19:39:35 +09007799 name: "Bootclasspath apex jar not satisfying allowed module packages on Q.",
Andrei Onead967aee2022-01-19 15:36:40 +00007800 expectedError: `(?s)module "bcp_lib2" .* which is restricted because jars that are part of the myapex module may only use these package prefixes: foo.bar with min_sdk < T. Please consider the following alternatives:\n 1. If the offending code is from a statically linked library, consider removing that dependency and using an alternative already in the bootclasspath, or perhaps a shared library. 2. Move the offending code into an allowed package.\n 3. Jarjar the offending code. Please be mindful of the potential system health implications of bundling that code, particularly if the offending jar is part of the bootclasspath.`,
Andrei Onea115e7e72020-06-05 21:14:03 +01007801 bp: `
7802 java_library {
7803 name: "bcp_lib1",
7804 srcs: ["lib1/src/*.java"],
7805 apex_available: ["myapex"],
7806 permitted_packages: ["foo.bar"],
7807 sdk_version: "none",
7808 system_modules: "none",
Remi NGUYEN VAN1fdd6ca2021-12-02 19:39:35 +09007809 min_sdk_version: "29",
Andrei Onea115e7e72020-06-05 21:14:03 +01007810 }
7811 java_library {
7812 name: "bcp_lib2",
7813 srcs: ["lib2/src/*.java"],
7814 apex_available: ["myapex"],
7815 permitted_packages: ["foo.bar", "bar.baz"],
7816 sdk_version: "none",
7817 system_modules: "none",
Remi NGUYEN VAN1fdd6ca2021-12-02 19:39:35 +09007818 min_sdk_version: "29",
Andrei Onea115e7e72020-06-05 21:14:03 +01007819 }
7820 apex {
7821 name: "myapex",
Remi NGUYEN VAN1fdd6ca2021-12-02 19:39:35 +09007822 min_sdk_version: "29",
7823 key: "myapex.key",
7824 java_libs: ["bcp_lib1", "bcp_lib2"],
7825 updatable: false,
7826 }
7827 `,
7828 bootJars: []string{"bcp_lib1", "bcp_lib2"},
7829 modulesPackages: map[string][]string{
7830 "myapex": []string{
7831 "foo.bar",
7832 },
7833 },
7834 },
7835 {
7836 name: "Bootclasspath apex jar not satisfying allowed module packages on R.",
Andrei Onead967aee2022-01-19 15:36:40 +00007837 expectedError: `(?s)module "bcp_lib2" .* which is restricted because jars that are part of the myapex module may only use these package prefixes: foo.bar with min_sdk < T. Please consider the following alternatives:\n 1. If the offending code is from a statically linked library, consider removing that dependency and using an alternative already in the bootclasspath, or perhaps a shared library. 2. Move the offending code into an allowed package.\n 3. Jarjar the offending code. Please be mindful of the potential system health implications of bundling that code, particularly if the offending jar is part of the bootclasspath.`,
Remi NGUYEN VAN1fdd6ca2021-12-02 19:39:35 +09007838 bp: `
7839 java_library {
7840 name: "bcp_lib1",
7841 srcs: ["lib1/src/*.java"],
7842 apex_available: ["myapex"],
7843 permitted_packages: ["foo.bar"],
7844 sdk_version: "none",
7845 system_modules: "none",
7846 min_sdk_version: "30",
7847 }
7848 java_library {
7849 name: "bcp_lib2",
7850 srcs: ["lib2/src/*.java"],
7851 apex_available: ["myapex"],
7852 permitted_packages: ["foo.bar", "bar.baz"],
7853 sdk_version: "none",
7854 system_modules: "none",
7855 min_sdk_version: "30",
7856 }
7857 apex {
7858 name: "myapex",
7859 min_sdk_version: "30",
7860 key: "myapex.key",
7861 java_libs: ["bcp_lib1", "bcp_lib2"],
7862 updatable: false,
7863 }
7864 `,
7865 bootJars: []string{"bcp_lib1", "bcp_lib2"},
7866 modulesPackages: map[string][]string{
7867 "myapex": []string{
7868 "foo.bar",
7869 },
7870 },
7871 },
7872 {
7873 name: "Bootclasspath apex jar >= T not satisfying Q/R/S allowed module packages.",
7874 expectedError: "",
7875 bp: `
7876 java_library {
7877 name: "bcp_lib1",
7878 srcs: ["lib1/src/*.java"],
7879 apex_available: ["myapex"],
7880 permitted_packages: ["foo.bar"],
7881 sdk_version: "none",
7882 system_modules: "none",
7883 min_sdk_version: "current",
7884 }
7885 java_library {
7886 name: "bcp_lib2",
7887 srcs: ["lib2/src/*.java"],
7888 apex_available: ["myapex"],
7889 permitted_packages: ["foo.bar", "bar.baz"],
7890 sdk_version: "none",
7891 system_modules: "none",
7892 min_sdk_version: "current",
7893 }
7894 apex {
7895 name: "myapex",
7896 min_sdk_version: "current",
Andrei Onea115e7e72020-06-05 21:14:03 +01007897 key: "myapex.key",
7898 java_libs: ["bcp_lib1", "bcp_lib2"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00007899 updatable: false,
Andrei Onea115e7e72020-06-05 21:14:03 +01007900 }
7901 `,
7902 bootJars: []string{"bcp_lib1", "bcp_lib2"},
7903 modulesPackages: map[string][]string{
7904 "myapex": []string{
7905 "foo.bar",
7906 },
7907 },
7908 },
7909 }
7910 for _, tc := range testcases {
7911 t.Run(tc.name, func(t *testing.T) {
7912 rules := createApexPermittedPackagesRules(tc.modulesPackages)
7913 testApexPermittedPackagesRules(t, tc.expectedError, tc.bp, tc.bootJars, rules)
7914 })
7915 }
7916}
7917
Jiyong Park62304bb2020-04-13 16:19:48 +09007918func TestTestFor(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08007919 ctx := testApex(t, `
Jiyong Park62304bb2020-04-13 16:19:48 +09007920 apex {
7921 name: "myapex",
7922 key: "myapex.key",
7923 native_shared_libs: ["mylib", "myprivlib"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00007924 updatable: false,
Jiyong Park62304bb2020-04-13 16:19:48 +09007925 }
7926
7927 apex_key {
7928 name: "myapex.key",
7929 public_key: "testkey.avbpubkey",
7930 private_key: "testkey.pem",
7931 }
7932
7933 cc_library {
7934 name: "mylib",
7935 srcs: ["mylib.cpp"],
7936 system_shared_libs: [],
7937 stl: "none",
7938 stubs: {
7939 versions: ["1"],
7940 },
7941 apex_available: ["myapex"],
7942 }
7943
7944 cc_library {
7945 name: "myprivlib",
7946 srcs: ["mylib.cpp"],
7947 system_shared_libs: [],
7948 stl: "none",
7949 apex_available: ["myapex"],
7950 }
7951
7952
7953 cc_test {
7954 name: "mytest",
7955 gtest: false,
7956 srcs: ["mylib.cpp"],
7957 system_shared_libs: [],
7958 stl: "none",
Jiyong Park46a512f2020-12-04 18:02:13 +09007959 shared_libs: ["mylib", "myprivlib", "mytestlib"],
Jiyong Park62304bb2020-04-13 16:19:48 +09007960 test_for: ["myapex"]
7961 }
Jiyong Park46a512f2020-12-04 18:02:13 +09007962
7963 cc_library {
7964 name: "mytestlib",
7965 srcs: ["mylib.cpp"],
7966 system_shared_libs: [],
7967 shared_libs: ["mylib", "myprivlib"],
7968 stl: "none",
7969 test_for: ["myapex"],
7970 }
7971
7972 cc_benchmark {
7973 name: "mybench",
7974 srcs: ["mylib.cpp"],
7975 system_shared_libs: [],
7976 shared_libs: ["mylib", "myprivlib"],
7977 stl: "none",
7978 test_for: ["myapex"],
7979 }
Jiyong Park62304bb2020-04-13 16:19:48 +09007980 `)
7981
Martin Stjernholm4e6c2692021-03-25 01:25:06 +00007982 ensureLinkedLibIs := func(mod, variant, linkedLib, expectedVariant string) {
Paul Duffina71a67a2021-03-29 00:42:57 +01007983 ldFlags := strings.Split(ctx.ModuleForTests(mod, variant).Rule("ld").Args["libFlags"], " ")
Martin Stjernholm4e6c2692021-03-25 01:25:06 +00007984 mylibLdFlags := android.FilterListPred(ldFlags, func(s string) bool { return strings.HasPrefix(s, linkedLib) })
7985 android.AssertArrayString(t, "unexpected "+linkedLib+" link library for "+mod, []string{linkedLib + expectedVariant}, mylibLdFlags)
7986 }
7987
7988 // These modules are tests for the apex, therefore are linked to the
Jiyong Park62304bb2020-04-13 16:19:48 +09007989 // actual implementation of mylib instead of its stub.
Martin Stjernholm4e6c2692021-03-25 01:25:06 +00007990 ensureLinkedLibIs("mytest", "android_arm64_armv8-a", "out/soong/.intermediates/mylib/", "android_arm64_armv8-a_shared/mylib.so")
7991 ensureLinkedLibIs("mytestlib", "android_arm64_armv8-a_shared", "out/soong/.intermediates/mylib/", "android_arm64_armv8-a_shared/mylib.so")
7992 ensureLinkedLibIs("mybench", "android_arm64_armv8-a", "out/soong/.intermediates/mylib/", "android_arm64_armv8-a_shared/mylib.so")
7993}
Jiyong Park46a512f2020-12-04 18:02:13 +09007994
Martin Stjernholm4e6c2692021-03-25 01:25:06 +00007995func TestIndirectTestFor(t *testing.T) {
7996 ctx := testApex(t, `
7997 apex {
7998 name: "myapex",
7999 key: "myapex.key",
8000 native_shared_libs: ["mylib", "myprivlib"],
8001 updatable: false,
8002 }
Jiyong Park46a512f2020-12-04 18:02:13 +09008003
Martin Stjernholm4e6c2692021-03-25 01:25:06 +00008004 apex_key {
8005 name: "myapex.key",
8006 public_key: "testkey.avbpubkey",
8007 private_key: "testkey.pem",
8008 }
8009
8010 cc_library {
8011 name: "mylib",
8012 srcs: ["mylib.cpp"],
8013 system_shared_libs: [],
8014 stl: "none",
8015 stubs: {
8016 versions: ["1"],
8017 },
8018 apex_available: ["myapex"],
8019 }
8020
8021 cc_library {
8022 name: "myprivlib",
8023 srcs: ["mylib.cpp"],
8024 system_shared_libs: [],
8025 stl: "none",
8026 shared_libs: ["mylib"],
8027 apex_available: ["myapex"],
8028 }
8029
8030 cc_library {
8031 name: "mytestlib",
8032 srcs: ["mylib.cpp"],
8033 system_shared_libs: [],
8034 shared_libs: ["myprivlib"],
8035 stl: "none",
8036 test_for: ["myapex"],
8037 }
8038 `)
8039
8040 ensureLinkedLibIs := func(mod, variant, linkedLib, expectedVariant string) {
Paul Duffina71a67a2021-03-29 00:42:57 +01008041 ldFlags := strings.Split(ctx.ModuleForTests(mod, variant).Rule("ld").Args["libFlags"], " ")
Martin Stjernholm4e6c2692021-03-25 01:25:06 +00008042 mylibLdFlags := android.FilterListPred(ldFlags, func(s string) bool { return strings.HasPrefix(s, linkedLib) })
8043 android.AssertArrayString(t, "unexpected "+linkedLib+" link library for "+mod, []string{linkedLib + expectedVariant}, mylibLdFlags)
8044 }
8045
8046 // The platform variant of mytestlib links to the platform variant of the
8047 // internal myprivlib.
8048 ensureLinkedLibIs("mytestlib", "android_arm64_armv8-a_shared", "out/soong/.intermediates/myprivlib/", "android_arm64_armv8-a_shared/myprivlib.so")
8049
8050 // The platform variant of myprivlib links to the platform variant of mylib
8051 // and bypasses its stubs.
8052 ensureLinkedLibIs("myprivlib", "android_arm64_armv8-a_shared", "out/soong/.intermediates/mylib/", "android_arm64_armv8-a_shared/mylib.so")
Jiyong Park62304bb2020-04-13 16:19:48 +09008053}
8054
Martin Stjernholmec009002021-03-27 15:18:31 +00008055func TestTestForForLibInOtherApex(t *testing.T) {
8056 // This case is only allowed for known overlapping APEXes, i.e. the ART APEXes.
8057 _ = testApex(t, `
8058 apex {
8059 name: "com.android.art",
8060 key: "myapex.key",
8061 native_shared_libs: ["mylib"],
8062 updatable: false,
8063 }
8064
8065 apex {
8066 name: "com.android.art.debug",
8067 key: "myapex.key",
8068 native_shared_libs: ["mylib", "mytestlib"],
8069 updatable: false,
8070 }
8071
8072 apex_key {
8073 name: "myapex.key",
8074 public_key: "testkey.avbpubkey",
8075 private_key: "testkey.pem",
8076 }
8077
8078 cc_library {
8079 name: "mylib",
8080 srcs: ["mylib.cpp"],
8081 system_shared_libs: [],
8082 stl: "none",
8083 stubs: {
8084 versions: ["1"],
8085 },
8086 apex_available: ["com.android.art", "com.android.art.debug"],
8087 }
8088
8089 cc_library {
8090 name: "mytestlib",
8091 srcs: ["mylib.cpp"],
8092 system_shared_libs: [],
8093 shared_libs: ["mylib"],
8094 stl: "none",
8095 apex_available: ["com.android.art.debug"],
8096 test_for: ["com.android.art"],
8097 }
8098 `,
8099 android.MockFS{
8100 "system/sepolicy/apex/com.android.art-file_contexts": nil,
8101 "system/sepolicy/apex/com.android.art.debug-file_contexts": nil,
8102 }.AddToFixture())
8103}
8104
Jaewoong Jungfa00c062020-05-14 14:15:24 -07008105// TODO(jungjw): Move this to proptools
8106func intPtr(i int) *int {
8107 return &i
8108}
8109
8110func TestApexSet(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08008111 ctx := testApex(t, `
Jaewoong Jungfa00c062020-05-14 14:15:24 -07008112 apex_set {
8113 name: "myapex",
8114 set: "myapex.apks",
8115 filename: "foo_v2.apex",
8116 overrides: ["foo"],
8117 }
Paul Duffin0a49fdc2021-03-08 11:28:25 +00008118 `,
8119 android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
8120 variables.Platform_sdk_version = intPtr(30)
8121 }),
8122 android.FixtureModifyConfig(func(config android.Config) {
8123 config.Targets[android.Android] = []android.Target{
8124 {Os: android.Android, Arch: android.Arch{ArchType: android.Arm, ArchVariant: "armv7-a-neon", Abi: []string{"armeabi-v7a"}}},
8125 {Os: android.Android, Arch: android.Arch{ArchType: android.Arm64, ArchVariant: "armv8-a", Abi: []string{"arm64-v8a"}}},
8126 }
8127 }),
8128 )
Jaewoong Jungfa00c062020-05-14 14:15:24 -07008129
Paul Duffin24704672021-04-06 16:09:30 +01008130 m := ctx.ModuleForTests("myapex.apex.extractor", "android_common")
Jaewoong Jungfa00c062020-05-14 14:15:24 -07008131
8132 // Check extract_apks tool parameters.
Paul Duffin24704672021-04-06 16:09:30 +01008133 extractedApex := m.Output("extracted/myapex.apks")
Jaewoong Jungfa00c062020-05-14 14:15:24 -07008134 actual := extractedApex.Args["abis"]
8135 expected := "ARMEABI_V7A,ARM64_V8A"
8136 if actual != expected {
8137 t.Errorf("Unexpected abis parameter - expected %q vs actual %q", expected, actual)
8138 }
8139 actual = extractedApex.Args["sdk-version"]
8140 expected = "30"
8141 if actual != expected {
8142 t.Errorf("Unexpected abis parameter - expected %q vs actual %q", expected, actual)
8143 }
8144
Paul Duffin6717d882021-06-15 19:09:41 +01008145 m = ctx.ModuleForTests("myapex", "android_common_myapex")
Jaewoong Jungfa00c062020-05-14 14:15:24 -07008146 a := m.Module().(*ApexSet)
8147 expectedOverrides := []string{"foo"}
Colin Crossaa255532020-07-03 13:18:24 -07008148 actualOverrides := android.AndroidMkEntriesForTest(t, ctx, a)[0].EntryMap["LOCAL_OVERRIDES_MODULES"]
Jaewoong Jungfa00c062020-05-14 14:15:24 -07008149 if !reflect.DeepEqual(actualOverrides, expectedOverrides) {
8150 t.Errorf("Incorrect LOCAL_OVERRIDES_MODULES - expected %q vs actual %q", expectedOverrides, actualOverrides)
8151 }
8152}
8153
Jiyong Park7d95a512020-05-10 15:16:24 +09008154func TestNoStaticLinkingToStubsLib(t *testing.T) {
8155 testApexError(t, `.*required by "mylib" is a native library providing stub.*`, `
8156 apex {
8157 name: "myapex",
8158 key: "myapex.key",
8159 native_shared_libs: ["mylib"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00008160 updatable: false,
Jiyong Park7d95a512020-05-10 15:16:24 +09008161 }
8162
8163 apex_key {
8164 name: "myapex.key",
8165 public_key: "testkey.avbpubkey",
8166 private_key: "testkey.pem",
8167 }
8168
8169 cc_library {
8170 name: "mylib",
8171 srcs: ["mylib.cpp"],
8172 static_libs: ["otherlib"],
8173 system_shared_libs: [],
8174 stl: "none",
8175 apex_available: [ "myapex" ],
8176 }
8177
8178 cc_library {
8179 name: "otherlib",
8180 srcs: ["mylib.cpp"],
8181 system_shared_libs: [],
8182 stl: "none",
8183 stubs: {
8184 versions: ["1", "2", "3"],
8185 },
8186 apex_available: [ "myapex" ],
8187 }
8188 `)
8189}
8190
Jiyong Park8d6c51e2020-06-12 17:26:31 +09008191func TestApexKeysTxt(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08008192 ctx := testApex(t, `
Jiyong Park8d6c51e2020-06-12 17:26:31 +09008193 apex {
8194 name: "myapex",
8195 key: "myapex.key",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00008196 updatable: false,
Jooyung Han09c11ad2021-10-27 03:45:31 +09008197 custom_sign_tool: "sign_myapex",
8198 }
8199
8200 apex_key {
8201 name: "myapex.key",
8202 public_key: "testkey.avbpubkey",
8203 private_key: "testkey.pem",
8204 }
8205 `)
8206
8207 apexKeysText := ctx.SingletonForTests("apex_keys_text")
8208 content := apexKeysText.MaybeDescription("apexkeys.txt").BuildParams.Args["content"]
8209 ensureContains(t, content, `name="myapex.apex" public_key="vendor/foo/devkeys/testkey.avbpubkey" private_key="vendor/foo/devkeys/testkey.pem" container_certificate="vendor/foo/devkeys/test.x509.pem" container_private_key="vendor/foo/devkeys/test.pk8" partition="system_ext" sign_tool="sign_myapex"`)
8210}
8211
8212func TestApexKeysTxtOverrides(t *testing.T) {
8213 ctx := testApex(t, `
8214 apex {
8215 name: "myapex",
8216 key: "myapex.key",
8217 updatable: false,
8218 custom_sign_tool: "sign_myapex",
Jiyong Park8d6c51e2020-06-12 17:26:31 +09008219 }
8220
8221 apex_key {
8222 name: "myapex.key",
8223 public_key: "testkey.avbpubkey",
8224 private_key: "testkey.pem",
8225 }
8226
8227 prebuilt_apex {
8228 name: "myapex",
8229 prefer: true,
8230 arch: {
8231 arm64: {
8232 src: "myapex-arm64.apex",
8233 },
8234 arm: {
8235 src: "myapex-arm.apex",
8236 },
8237 },
8238 }
8239
8240 apex_set {
8241 name: "myapex_set",
8242 set: "myapex.apks",
8243 filename: "myapex_set.apex",
8244 overrides: ["myapex"],
8245 }
8246 `)
8247
8248 apexKeysText := ctx.SingletonForTests("apex_keys_text")
8249 content := apexKeysText.MaybeDescription("apexkeys.txt").BuildParams.Args["content"]
8250 ensureContains(t, content, `name="myapex_set.apex" public_key="PRESIGNED" private_key="PRESIGNED" container_certificate="PRESIGNED" container_private_key="PRESIGNED" partition="system"`)
Jiyong Park03a7f3e2020-06-18 19:34:42 +09008251 ensureContains(t, content, `name="myapex.apex" public_key="PRESIGNED" private_key="PRESIGNED" container_certificate="PRESIGNED" container_private_key="PRESIGNED" partition="system"`)
Jiyong Park8d6c51e2020-06-12 17:26:31 +09008252}
8253
Jooyung Han938b5932020-06-20 12:47:47 +09008254func TestAllowedFiles(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08008255 ctx := testApex(t, `
Jooyung Han938b5932020-06-20 12:47:47 +09008256 apex {
8257 name: "myapex",
8258 key: "myapex.key",
8259 apps: ["app"],
8260 allowed_files: "allowed.txt",
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00008261 updatable: false,
Jooyung Han938b5932020-06-20 12:47:47 +09008262 }
8263
8264 apex_key {
8265 name: "myapex.key",
8266 public_key: "testkey.avbpubkey",
8267 private_key: "testkey.pem",
8268 }
8269
8270 android_app {
8271 name: "app",
8272 srcs: ["foo/bar/MyClass.java"],
8273 package_name: "foo",
8274 sdk_version: "none",
8275 system_modules: "none",
8276 apex_available: [ "myapex" ],
8277 }
8278 `, withFiles(map[string][]byte{
8279 "sub/Android.bp": []byte(`
8280 override_apex {
8281 name: "override_myapex",
8282 base: "myapex",
8283 apps: ["override_app"],
8284 allowed_files: ":allowed",
8285 }
8286 // Overridable "path" property should be referenced indirectly
8287 filegroup {
8288 name: "allowed",
8289 srcs: ["allowed.txt"],
8290 }
8291 override_android_app {
8292 name: "override_app",
8293 base: "app",
8294 package_name: "bar",
8295 }
8296 `),
8297 }))
8298
8299 rule := ctx.ModuleForTests("myapex", "android_common_myapex_image").Rule("diffApexContentRule")
8300 if expected, actual := "allowed.txt", rule.Args["allowed_files_file"]; expected != actual {
8301 t.Errorf("allowed_files_file: expected %q but got %q", expected, actual)
8302 }
8303
8304 rule2 := ctx.ModuleForTests("myapex", "android_common_override_myapex_myapex_image").Rule("diffApexContentRule")
8305 if expected, actual := "sub/allowed.txt", rule2.Args["allowed_files_file"]; expected != actual {
8306 t.Errorf("allowed_files_file: expected %q but got %q", expected, actual)
8307 }
8308}
8309
Martin Stjernholm58c33f02020-07-06 22:56:01 +01008310func TestNonPreferredPrebuiltDependency(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08008311 testApex(t, `
Martin Stjernholm58c33f02020-07-06 22:56:01 +01008312 apex {
8313 name: "myapex",
8314 key: "myapex.key",
8315 native_shared_libs: ["mylib"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00008316 updatable: false,
Martin Stjernholm58c33f02020-07-06 22:56:01 +01008317 }
8318
8319 apex_key {
8320 name: "myapex.key",
8321 public_key: "testkey.avbpubkey",
8322 private_key: "testkey.pem",
8323 }
8324
8325 cc_library {
8326 name: "mylib",
8327 srcs: ["mylib.cpp"],
8328 stubs: {
Dan Albertc8060532020-07-22 22:32:17 -07008329 versions: ["current"],
Martin Stjernholm58c33f02020-07-06 22:56:01 +01008330 },
8331 apex_available: ["myapex"],
8332 }
8333
8334 cc_prebuilt_library_shared {
8335 name: "mylib",
8336 prefer: false,
8337 srcs: ["prebuilt.so"],
8338 stubs: {
Dan Albertc8060532020-07-22 22:32:17 -07008339 versions: ["current"],
Martin Stjernholm58c33f02020-07-06 22:56:01 +01008340 },
8341 apex_available: ["myapex"],
8342 }
8343 `)
8344}
8345
Mohammad Samiul Islam3cd005d2020-11-26 13:32:26 +00008346func TestCompressedApex(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08008347 ctx := testApex(t, `
Mohammad Samiul Islam3cd005d2020-11-26 13:32:26 +00008348 apex {
8349 name: "myapex",
8350 key: "myapex.key",
8351 compressible: true,
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00008352 updatable: false,
Mohammad Samiul Islam3cd005d2020-11-26 13:32:26 +00008353 }
8354 apex_key {
8355 name: "myapex.key",
8356 public_key: "testkey.avbpubkey",
8357 private_key: "testkey.pem",
8358 }
Paul Duffin0a49fdc2021-03-08 11:28:25 +00008359 `,
8360 android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
8361 variables.CompressedApex = proptools.BoolPtr(true)
8362 }),
8363 )
Mohammad Samiul Islam3cd005d2020-11-26 13:32:26 +00008364
8365 compressRule := ctx.ModuleForTests("myapex", "android_common_myapex_image").Rule("compressRule")
8366 ensureContains(t, compressRule.Output.String(), "myapex.capex.unsigned")
8367
8368 signApkRule := ctx.ModuleForTests("myapex", "android_common_myapex_image").Description("sign compressedApex")
8369 ensureEquals(t, signApkRule.Input.String(), compressRule.Output.String())
8370
8371 // Make sure output of bundle is .capex
8372 ab := ctx.ModuleForTests("myapex", "android_common_myapex_image").Module().(*apexBundle)
8373 ensureContains(t, ab.outputFile.String(), "myapex.capex")
8374
8375 // Verify android.mk rules
Colin Crossaa255532020-07-03 13:18:24 -07008376 data := android.AndroidMkDataForTest(t, ctx, ab)
Mohammad Samiul Islam3cd005d2020-11-26 13:32:26 +00008377 var builder strings.Builder
8378 data.Custom(&builder, ab.BaseModuleName(), "TARGET_", "", data)
8379 androidMk := builder.String()
8380 ensureContains(t, androidMk, "LOCAL_MODULE_STEM := myapex.capex\n")
8381}
8382
Martin Stjernholm2856c662020-12-02 15:03:42 +00008383func TestPreferredPrebuiltSharedLibDep(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08008384 ctx := testApex(t, `
Martin Stjernholm2856c662020-12-02 15:03:42 +00008385 apex {
8386 name: "myapex",
8387 key: "myapex.key",
8388 native_shared_libs: ["mylib"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00008389 updatable: false,
Martin Stjernholm2856c662020-12-02 15:03:42 +00008390 }
8391
8392 apex_key {
8393 name: "myapex.key",
8394 public_key: "testkey.avbpubkey",
8395 private_key: "testkey.pem",
8396 }
8397
8398 cc_library {
8399 name: "mylib",
8400 srcs: ["mylib.cpp"],
8401 apex_available: ["myapex"],
8402 shared_libs: ["otherlib"],
8403 system_shared_libs: [],
8404 }
8405
8406 cc_library {
8407 name: "otherlib",
8408 srcs: ["mylib.cpp"],
8409 stubs: {
8410 versions: ["current"],
8411 },
8412 }
8413
8414 cc_prebuilt_library_shared {
8415 name: "otherlib",
8416 prefer: true,
8417 srcs: ["prebuilt.so"],
8418 stubs: {
8419 versions: ["current"],
8420 },
8421 }
8422 `)
8423
8424 ab := ctx.ModuleForTests("myapex", "android_common_myapex_image").Module().(*apexBundle)
Colin Crossaa255532020-07-03 13:18:24 -07008425 data := android.AndroidMkDataForTest(t, ctx, ab)
Martin Stjernholm2856c662020-12-02 15:03:42 +00008426 var builder strings.Builder
8427 data.Custom(&builder, ab.BaseModuleName(), "TARGET_", "", data)
8428 androidMk := builder.String()
8429
8430 // The make level dependency needs to be on otherlib - prebuilt_otherlib isn't
8431 // a thing there.
8432 ensureContains(t, androidMk, "LOCAL_REQUIRED_MODULES += otherlib\n")
8433}
8434
Jiyong Parke3867542020-12-03 17:28:25 +09008435func TestExcludeDependency(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08008436 ctx := testApex(t, `
Jiyong Parke3867542020-12-03 17:28:25 +09008437 apex {
8438 name: "myapex",
8439 key: "myapex.key",
8440 native_shared_libs: ["mylib"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00008441 updatable: false,
Jiyong Parke3867542020-12-03 17:28:25 +09008442 }
8443
8444 apex_key {
8445 name: "myapex.key",
8446 public_key: "testkey.avbpubkey",
8447 private_key: "testkey.pem",
8448 }
8449
8450 cc_library {
8451 name: "mylib",
8452 srcs: ["mylib.cpp"],
8453 system_shared_libs: [],
8454 stl: "none",
8455 apex_available: ["myapex"],
8456 shared_libs: ["mylib2"],
8457 target: {
8458 apex: {
8459 exclude_shared_libs: ["mylib2"],
8460 },
8461 },
8462 }
8463
8464 cc_library {
8465 name: "mylib2",
8466 srcs: ["mylib.cpp"],
8467 system_shared_libs: [],
8468 stl: "none",
8469 }
8470 `)
8471
8472 // Check if mylib is linked to mylib2 for the non-apex target
8473 ldFlags := ctx.ModuleForTests("mylib", "android_arm64_armv8-a_shared").Rule("ld").Args["libFlags"]
8474 ensureContains(t, ldFlags, "mylib2/android_arm64_armv8-a_shared/mylib2.so")
8475
8476 // Make sure that the link doesn't occur for the apex target
8477 ldFlags = ctx.ModuleForTests("mylib", "android_arm64_armv8-a_shared_apex10000").Rule("ld").Args["libFlags"]
8478 ensureNotContains(t, ldFlags, "mylib2/android_arm64_armv8-a_shared_apex10000/mylib2.so")
8479
8480 // It shouldn't appear in the copy cmd as well.
8481 copyCmds := ctx.ModuleForTests("myapex", "android_common_myapex_image").Rule("apexRule").Args["copy_commands"]
8482 ensureNotContains(t, copyCmds, "image.apex/lib64/mylib2.so")
8483}
8484
Jiyong Parkf7c3bbe2020-12-09 21:18:56 +09008485func TestPrebuiltStubLibDep(t *testing.T) {
8486 bpBase := `
8487 apex {
8488 name: "myapex",
8489 key: "myapex.key",
8490 native_shared_libs: ["mylib"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00008491 updatable: false,
Jiyong Parkf7c3bbe2020-12-09 21:18:56 +09008492 }
8493 apex_key {
8494 name: "myapex.key",
8495 public_key: "testkey.avbpubkey",
8496 private_key: "testkey.pem",
8497 }
8498 cc_library {
8499 name: "mylib",
8500 srcs: ["mylib.cpp"],
8501 apex_available: ["myapex"],
8502 shared_libs: ["stublib"],
8503 system_shared_libs: [],
8504 }
8505 apex {
8506 name: "otherapex",
8507 enabled: %s,
8508 key: "myapex.key",
8509 native_shared_libs: ["stublib"],
Mathew Inwoodf8dcf5e2021-02-16 11:40:16 +00008510 updatable: false,
Jiyong Parkf7c3bbe2020-12-09 21:18:56 +09008511 }
8512 `
8513
8514 stublibSourceBp := `
8515 cc_library {
8516 name: "stublib",
8517 srcs: ["mylib.cpp"],
8518 apex_available: ["otherapex"],
8519 system_shared_libs: [],
8520 stl: "none",
8521 stubs: {
8522 versions: ["1"],
8523 },
8524 }
8525 `
8526
8527 stublibPrebuiltBp := `
8528 cc_prebuilt_library_shared {
8529 name: "stublib",
8530 srcs: ["prebuilt.so"],
8531 apex_available: ["otherapex"],
8532 stubs: {
8533 versions: ["1"],
8534 },
8535 %s
8536 }
8537 `
8538
8539 tests := []struct {
8540 name string
8541 stublibBp string
8542 usePrebuilt bool
8543 modNames []string // Modules to collect AndroidMkEntries for
8544 otherApexEnabled []string
8545 }{
8546 {
8547 name: "only_source",
8548 stublibBp: stublibSourceBp,
8549 usePrebuilt: false,
8550 modNames: []string{"stublib"},
8551 otherApexEnabled: []string{"true", "false"},
8552 },
8553 {
8554 name: "source_preferred",
8555 stublibBp: stublibSourceBp + fmt.Sprintf(stublibPrebuiltBp, ""),
8556 usePrebuilt: false,
8557 modNames: []string{"stublib", "prebuilt_stublib"},
8558 otherApexEnabled: []string{"true", "false"},
8559 },
8560 {
8561 name: "prebuilt_preferred",
8562 stublibBp: stublibSourceBp + fmt.Sprintf(stublibPrebuiltBp, "prefer: true,"),
8563 usePrebuilt: true,
8564 modNames: []string{"stublib", "prebuilt_stublib"},
8565 otherApexEnabled: []string{"false"}, // No "true" since APEX cannot depend on prebuilt.
8566 },
8567 {
8568 name: "only_prebuilt",
8569 stublibBp: fmt.Sprintf(stublibPrebuiltBp, ""),
8570 usePrebuilt: true,
8571 modNames: []string{"stublib"},
8572 otherApexEnabled: []string{"false"}, // No "true" since APEX cannot depend on prebuilt.
8573 },
8574 }
8575
8576 for _, test := range tests {
8577 t.Run(test.name, func(t *testing.T) {
8578 for _, otherApexEnabled := range test.otherApexEnabled {
8579 t.Run("otherapex_enabled_"+otherApexEnabled, func(t *testing.T) {
Colin Cross1c460562021-02-16 17:55:47 -08008580 ctx := testApex(t, fmt.Sprintf(bpBase, otherApexEnabled)+test.stublibBp)
Jiyong Parkf7c3bbe2020-12-09 21:18:56 +09008581
8582 type modAndMkEntries struct {
8583 mod *cc.Module
8584 mkEntries android.AndroidMkEntries
8585 }
8586 entries := []*modAndMkEntries{}
8587
8588 // Gather shared lib modules that are installable
8589 for _, modName := range test.modNames {
8590 for _, variant := range ctx.ModuleVariantsForTests(modName) {
8591 if !strings.HasPrefix(variant, "android_arm64_armv8-a_shared") {
8592 continue
8593 }
8594 mod := ctx.ModuleForTests(modName, variant).Module().(*cc.Module)
Colin Crossa9c8c9f2020-12-16 10:20:23 -08008595 if !mod.Enabled() || mod.IsHideFromMake() {
Jiyong Parkf7c3bbe2020-12-09 21:18:56 +09008596 continue
8597 }
Colin Crossaa255532020-07-03 13:18:24 -07008598 for _, ent := range android.AndroidMkEntriesForTest(t, ctx, mod) {
Jiyong Parkf7c3bbe2020-12-09 21:18:56 +09008599 if ent.Disabled {
8600 continue
8601 }
8602 entries = append(entries, &modAndMkEntries{
8603 mod: mod,
8604 mkEntries: ent,
8605 })
8606 }
8607 }
8608 }
8609
8610 var entry *modAndMkEntries = nil
8611 for _, ent := range entries {
8612 if strings.Join(ent.mkEntries.EntryMap["LOCAL_MODULE"], ",") == "stublib" {
8613 if entry != nil {
8614 t.Errorf("More than one AndroidMk entry for \"stublib\": %s and %s", entry.mod, ent.mod)
8615 } else {
8616 entry = ent
8617 }
8618 }
8619 }
8620
8621 if entry == nil {
8622 t.Errorf("AndroidMk entry for \"stublib\" missing")
8623 } else {
8624 isPrebuilt := entry.mod.Prebuilt() != nil
8625 if isPrebuilt != test.usePrebuilt {
8626 t.Errorf("Wrong module for \"stublib\" AndroidMk entry: got prebuilt %t, want prebuilt %t", isPrebuilt, test.usePrebuilt)
8627 }
8628 if !entry.mod.IsStubs() {
8629 t.Errorf("Module for \"stublib\" AndroidMk entry isn't a stub: %s", entry.mod)
8630 }
8631 if entry.mkEntries.EntryMap["LOCAL_NOT_AVAILABLE_FOR_PLATFORM"] != nil {
8632 t.Errorf("AndroidMk entry for \"stublib\" has LOCAL_NOT_AVAILABLE_FOR_PLATFORM set: %+v", entry.mkEntries)
8633 }
Jiyong Park892a98f2020-12-14 09:20:00 +09008634 cflags := entry.mkEntries.EntryMap["LOCAL_EXPORT_CFLAGS"]
Jiyong Parkd4a3a132021-03-17 20:21:35 +09008635 expected := "-D__STUBLIB_API__=10000"
Jiyong Park892a98f2020-12-14 09:20:00 +09008636 if !android.InList(expected, cflags) {
8637 t.Errorf("LOCAL_EXPORT_CFLAGS expected to have %q, but got %q", expected, cflags)
8638 }
Jiyong Parkf7c3bbe2020-12-09 21:18:56 +09008639 }
8640 })
8641 }
8642 })
8643 }
8644}
8645
Martin Stjernholmdf298b32021-05-21 20:57:29 +01008646func TestHostApexInHostOnlyBuild(t *testing.T) {
8647 testApex(t, `
8648 apex {
8649 name: "myapex",
8650 host_supported: true,
8651 key: "myapex.key",
8652 updatable: false,
8653 payload_type: "zip",
8654 }
8655 apex_key {
8656 name: "myapex.key",
8657 public_key: "testkey.avbpubkey",
8658 private_key: "testkey.pem",
8659 }
8660 `,
8661 android.FixtureModifyConfig(func(config android.Config) {
8662 // We may not have device targets in all builds, e.g. in
8663 // prebuilts/build-tools/build-prebuilts.sh
8664 config.Targets[android.Android] = []android.Target{}
8665 }))
8666}
8667
Colin Crossc33e5212021-05-25 18:16:02 -07008668func TestApexJavaCoverage(t *testing.T) {
8669 bp := `
8670 apex {
8671 name: "myapex",
8672 key: "myapex.key",
8673 java_libs: ["mylib"],
8674 bootclasspath_fragments: ["mybootclasspathfragment"],
8675 systemserverclasspath_fragments: ["mysystemserverclasspathfragment"],
8676 updatable: false,
8677 }
8678
8679 apex_key {
8680 name: "myapex.key",
8681 public_key: "testkey.avbpubkey",
8682 private_key: "testkey.pem",
8683 }
8684
8685 java_library {
8686 name: "mylib",
8687 srcs: ["mylib.java"],
8688 apex_available: ["myapex"],
8689 compile_dex: true,
8690 }
8691
8692 bootclasspath_fragment {
8693 name: "mybootclasspathfragment",
8694 contents: ["mybootclasspathlib"],
8695 apex_available: ["myapex"],
8696 }
8697
8698 java_library {
8699 name: "mybootclasspathlib",
8700 srcs: ["mybootclasspathlib.java"],
8701 apex_available: ["myapex"],
8702 compile_dex: true,
8703 }
8704
8705 systemserverclasspath_fragment {
8706 name: "mysystemserverclasspathfragment",
8707 contents: ["mysystemserverclasspathlib"],
8708 apex_available: ["myapex"],
8709 }
8710
8711 java_library {
8712 name: "mysystemserverclasspathlib",
8713 srcs: ["mysystemserverclasspathlib.java"],
8714 apex_available: ["myapex"],
8715 compile_dex: true,
8716 }
8717 `
8718
8719 result := android.GroupFixturePreparers(
8720 PrepareForTestWithApexBuildComponents,
8721 prepareForTestWithMyapex,
8722 java.PrepareForTestWithJavaDefaultModules,
8723 android.PrepareForTestWithAndroidBuildComponents,
8724 android.FixtureWithRootAndroidBp(bp),
satayevabcd5972021-08-06 17:49:46 +01008725 dexpreopt.FixtureSetApexBootJars("myapex:mybootclasspathlib"),
8726 dexpreopt.FixtureSetApexSystemServerJars("myapex:mysystemserverclasspathlib"),
Colin Crossc33e5212021-05-25 18:16:02 -07008727 android.FixtureMergeEnv(map[string]string{
8728 "EMMA_INSTRUMENT": "true",
8729 }),
8730 ).RunTest(t)
8731
8732 // Make sure jacoco ran on both mylib and mybootclasspathlib
8733 if result.ModuleForTests("mylib", "android_common_apex10000").MaybeRule("jacoco").Rule == nil {
8734 t.Errorf("Failed to find jacoco rule for mylib")
8735 }
8736 if result.ModuleForTests("mybootclasspathlib", "android_common_apex10000").MaybeRule("jacoco").Rule == nil {
8737 t.Errorf("Failed to find jacoco rule for mybootclasspathlib")
8738 }
8739 if result.ModuleForTests("mysystemserverclasspathlib", "android_common_apex10000").MaybeRule("jacoco").Rule == nil {
8740 t.Errorf("Failed to find jacoco rule for mysystemserverclasspathlib")
8741 }
8742}
8743
Jiyong Park192600a2021-08-03 07:52:17 +00008744func TestProhibitStaticExecutable(t *testing.T) {
8745 testApexError(t, `executable mybin is static`, `
8746 apex {
8747 name: "myapex",
8748 key: "myapex.key",
8749 binaries: ["mybin"],
8750 min_sdk_version: "29",
8751 }
8752
8753 apex_key {
8754 name: "myapex.key",
8755 public_key: "testkey.avbpubkey",
8756 private_key: "testkey.pem",
8757 }
8758
8759 cc_binary {
8760 name: "mybin",
8761 srcs: ["mylib.cpp"],
8762 relative_install_path: "foo/bar",
8763 static_executable: true,
8764 system_shared_libs: [],
8765 stl: "none",
8766 apex_available: [ "myapex" ],
Jiyong Parkd12979d2021-08-03 13:36:09 +09008767 min_sdk_version: "29",
8768 }
8769 `)
8770
8771 testApexError(t, `executable mybin.rust is static`, `
8772 apex {
8773 name: "myapex",
8774 key: "myapex.key",
8775 binaries: ["mybin.rust"],
8776 min_sdk_version: "29",
8777 }
8778
8779 apex_key {
8780 name: "myapex.key",
8781 public_key: "testkey.avbpubkey",
8782 private_key: "testkey.pem",
8783 }
8784
8785 rust_binary {
8786 name: "mybin.rust",
8787 srcs: ["foo.rs"],
8788 static_executable: true,
8789 apex_available: ["myapex"],
8790 min_sdk_version: "29",
Jiyong Park192600a2021-08-03 07:52:17 +00008791 }
8792 `)
8793}
8794
Jiakai Zhang470b7e22021-09-30 09:34:26 +00008795func TestAndroidMk_DexpreoptBuiltInstalledForApex(t *testing.T) {
8796 ctx := testApex(t, `
8797 apex {
8798 name: "myapex",
8799 key: "myapex.key",
8800 updatable: false,
8801 java_libs: ["foo"],
8802 }
8803
8804 apex_key {
8805 name: "myapex.key",
8806 public_key: "testkey.avbpubkey",
8807 private_key: "testkey.pem",
8808 }
8809
8810 java_library {
8811 name: "foo",
8812 srcs: ["foo.java"],
8813 apex_available: ["myapex"],
8814 installable: true,
8815 }
8816 `,
8817 dexpreopt.FixtureSetApexSystemServerJars("myapex:foo"),
8818 )
8819
8820 apexBundle := ctx.ModuleForTests("myapex", "android_common_myapex_image").Module().(*apexBundle)
8821 data := android.AndroidMkDataForTest(t, ctx, apexBundle)
8822 var builder strings.Builder
8823 data.Custom(&builder, apexBundle.BaseModuleName(), "TARGET_", "", data)
8824 androidMk := builder.String()
8825 ensureContains(t, androidMk, "LOCAL_REQUIRED_MODULES += foo-dexpreopt-arm64-apex@myapex@javalib@foo.jar@classes.odex foo-dexpreopt-arm64-apex@myapex@javalib@foo.jar@classes.vdex")
8826}
8827
8828func TestAndroidMk_DexpreoptBuiltInstalledForApex_Prebuilt(t *testing.T) {
8829 ctx := testApex(t, `
8830 prebuilt_apex {
8831 name: "myapex",
8832 arch: {
8833 arm64: {
8834 src: "myapex-arm64.apex",
8835 },
8836 arm: {
8837 src: "myapex-arm.apex",
8838 },
8839 },
8840 exported_java_libs: ["foo"],
8841 }
8842
8843 java_import {
8844 name: "foo",
8845 jars: ["foo.jar"],
Jiakai Zhang28bc9a82021-12-20 15:08:57 +00008846 apex_available: ["myapex"],
Jiakai Zhang470b7e22021-09-30 09:34:26 +00008847 }
8848 `,
8849 dexpreopt.FixtureSetApexSystemServerJars("myapex:foo"),
8850 )
8851
8852 prebuilt := ctx.ModuleForTests("myapex", "android_common_myapex").Module().(*Prebuilt)
8853 entriesList := android.AndroidMkEntriesForTest(t, ctx, prebuilt)
8854 mainModuleEntries := entriesList[0]
8855 android.AssertArrayString(t,
8856 "LOCAL_REQUIRED_MODULES",
8857 mainModuleEntries.EntryMap["LOCAL_REQUIRED_MODULES"],
8858 []string{
8859 "foo-dexpreopt-arm64-apex@myapex@javalib@foo.jar@classes.odex",
8860 "foo-dexpreopt-arm64-apex@myapex@javalib@foo.jar@classes.vdex",
8861 })
8862}
8863
Jiyong Parkcacc4f32021-10-28 14:26:03 +09008864func TestAndroidMk_RequiredModules(t *testing.T) {
8865 ctx := testApex(t, `
8866 apex {
8867 name: "myapex",
8868 key: "myapex.key",
8869 updatable: false,
8870 java_libs: ["foo"],
8871 required: ["otherapex"],
8872 }
8873
8874 apex {
8875 name: "otherapex",
8876 key: "myapex.key",
8877 updatable: false,
8878 java_libs: ["foo"],
8879 required: ["otherapex"],
8880 }
8881
8882 apex_key {
8883 name: "myapex.key",
8884 public_key: "testkey.avbpubkey",
8885 private_key: "testkey.pem",
8886 }
8887
8888 java_library {
8889 name: "foo",
8890 srcs: ["foo.java"],
8891 apex_available: ["myapex", "otherapex"],
8892 installable: true,
8893 }
8894 `)
8895
8896 apexBundle := ctx.ModuleForTests("myapex", "android_common_myapex_image").Module().(*apexBundle)
8897 data := android.AndroidMkDataForTest(t, ctx, apexBundle)
8898 var builder strings.Builder
8899 data.Custom(&builder, apexBundle.BaseModuleName(), "TARGET_", "", data)
8900 androidMk := builder.String()
8901 ensureContains(t, androidMk, "LOCAL_REQUIRED_MODULES += otherapex")
8902}
8903
Jiakai Zhangd70dff72022-02-24 15:06:05 +00008904func TestAndroidMk_RequiredDeps(t *testing.T) {
8905 ctx := testApex(t, `
8906 apex {
8907 name: "myapex",
8908 key: "myapex.key",
8909 updatable: false,
8910 }
8911
8912 apex_key {
8913 name: "myapex.key",
8914 public_key: "testkey.avbpubkey",
8915 private_key: "testkey.pem",
8916 }
8917 `)
8918
8919 bundle := ctx.ModuleForTests("myapex", "android_common_myapex_image").Module().(*apexBundle)
8920 bundle.requiredDeps = append(bundle.requiredDeps, "foo")
8921 data := android.AndroidMkDataForTest(t, ctx, bundle)
8922 var builder strings.Builder
8923 data.Custom(&builder, bundle.BaseModuleName(), "TARGET_", "", data)
8924 androidMk := builder.String()
8925 ensureContains(t, androidMk, "LOCAL_REQUIRED_MODULES += foo")
8926
8927 flattenedBundle := ctx.ModuleForTests("myapex", "android_common_myapex_flattened").Module().(*apexBundle)
8928 flattenedBundle.requiredDeps = append(flattenedBundle.requiredDeps, "foo")
8929 flattenedData := android.AndroidMkDataForTest(t, ctx, flattenedBundle)
8930 var flattenedBuilder strings.Builder
8931 flattenedData.Custom(&flattenedBuilder, flattenedBundle.BaseModuleName(), "TARGET_", "", flattenedData)
8932 flattenedAndroidMk := flattenedBuilder.String()
8933 ensureContains(t, flattenedAndroidMk, "LOCAL_REQUIRED_MODULES += foo")
8934}
8935
Jooyung Hana6d36672022-02-24 13:58:07 +09008936func TestApexOutputFileProducer(t *testing.T) {
8937 for _, tc := range []struct {
8938 name string
8939 ref string
8940 expected_data []string
8941 }{
8942 {
8943 name: "test_using_output",
8944 ref: ":myapex",
8945 expected_data: []string{"out/soong/.intermediates/myapex/android_common_myapex_image/myapex.capex:myapex.capex"},
8946 },
8947 {
8948 name: "test_using_apex",
8949 ref: ":myapex{.apex}",
8950 expected_data: []string{"out/soong/.intermediates/myapex/android_common_myapex_image/myapex.apex:myapex.apex"},
8951 },
8952 } {
8953 t.Run(tc.name, func(t *testing.T) {
8954 ctx := testApex(t, `
8955 apex {
8956 name: "myapex",
8957 key: "myapex.key",
8958 compressible: true,
8959 updatable: false,
8960 }
8961
8962 apex_key {
8963 name: "myapex.key",
8964 public_key: "testkey.avbpubkey",
8965 private_key: "testkey.pem",
8966 }
8967
8968 java_test {
8969 name: "`+tc.name+`",
8970 srcs: ["a.java"],
8971 data: ["`+tc.ref+`"],
8972 }
8973 `,
8974 android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
8975 variables.CompressedApex = proptools.BoolPtr(true)
8976 }))
8977 javaTest := ctx.ModuleForTests(tc.name, "android_common").Module().(*java.Test)
8978 data := android.AndroidMkEntriesForTest(t, ctx, javaTest)[0].EntryMap["LOCAL_COMPATIBILITY_SUPPORT_FILES"]
8979 android.AssertStringPathsRelativeToTopEquals(t, "data", ctx.Config(), tc.expected_data, data)
8980 })
8981 }
8982}
8983
satayev758968a2021-12-06 11:42:40 +00008984func TestSdkLibraryCanHaveHigherMinSdkVersion(t *testing.T) {
8985 preparer := android.GroupFixturePreparers(
8986 PrepareForTestWithApexBuildComponents,
8987 prepareForTestWithMyapex,
8988 java.PrepareForTestWithJavaSdkLibraryFiles,
8989 java.PrepareForTestWithJavaDefaultModules,
8990 android.PrepareForTestWithAndroidBuildComponents,
8991 dexpreopt.FixtureSetApexBootJars("myapex:mybootclasspathlib"),
8992 dexpreopt.FixtureSetApexSystemServerJars("myapex:mysystemserverclasspathlib"),
8993 )
8994
8995 // Test java_sdk_library in bootclasspath_fragment may define higher min_sdk_version than the apex
8996 t.Run("bootclasspath_fragment jar has higher min_sdk_version than apex", func(t *testing.T) {
8997 preparer.RunTestWithBp(t, `
8998 apex {
8999 name: "myapex",
9000 key: "myapex.key",
9001 bootclasspath_fragments: ["mybootclasspathfragment"],
9002 min_sdk_version: "30",
9003 updatable: false,
9004 }
9005
9006 apex_key {
9007 name: "myapex.key",
9008 public_key: "testkey.avbpubkey",
9009 private_key: "testkey.pem",
9010 }
9011
9012 bootclasspath_fragment {
9013 name: "mybootclasspathfragment",
9014 contents: ["mybootclasspathlib"],
9015 apex_available: ["myapex"],
9016 }
9017
9018 java_sdk_library {
9019 name: "mybootclasspathlib",
9020 srcs: ["mybootclasspathlib.java"],
9021 apex_available: ["myapex"],
9022 compile_dex: true,
9023 unsafe_ignore_missing_latest_api: true,
9024 min_sdk_version: "31",
9025 static_libs: ["util"],
9026 }
9027
9028 java_library {
9029 name: "util",
9030 srcs: ["a.java"],
9031 apex_available: ["myapex"],
9032 min_sdk_version: "31",
9033 static_libs: ["another_util"],
9034 }
9035
9036 java_library {
9037 name: "another_util",
9038 srcs: ["a.java"],
9039 min_sdk_version: "31",
9040 apex_available: ["myapex"],
9041 }
9042 `)
9043 })
9044
9045 // Test java_sdk_library in systemserverclasspath_fragment may define higher min_sdk_version than the apex
9046 t.Run("systemserverclasspath_fragment jar has higher min_sdk_version than apex", func(t *testing.T) {
9047 preparer.RunTestWithBp(t, `
9048 apex {
9049 name: "myapex",
9050 key: "myapex.key",
9051 systemserverclasspath_fragments: ["mysystemserverclasspathfragment"],
9052 min_sdk_version: "30",
9053 updatable: false,
9054 }
9055
9056 apex_key {
9057 name: "myapex.key",
9058 public_key: "testkey.avbpubkey",
9059 private_key: "testkey.pem",
9060 }
9061
9062 systemserverclasspath_fragment {
9063 name: "mysystemserverclasspathfragment",
9064 contents: ["mysystemserverclasspathlib"],
9065 apex_available: ["myapex"],
9066 }
9067
9068 java_sdk_library {
9069 name: "mysystemserverclasspathlib",
9070 srcs: ["mysystemserverclasspathlib.java"],
9071 apex_available: ["myapex"],
9072 compile_dex: true,
9073 min_sdk_version: "32",
9074 unsafe_ignore_missing_latest_api: true,
9075 static_libs: ["util"],
9076 }
9077
9078 java_library {
9079 name: "util",
9080 srcs: ["a.java"],
9081 apex_available: ["myapex"],
9082 min_sdk_version: "31",
9083 static_libs: ["another_util"],
9084 }
9085
9086 java_library {
9087 name: "another_util",
9088 srcs: ["a.java"],
9089 min_sdk_version: "31",
9090 apex_available: ["myapex"],
9091 }
9092 `)
9093 })
9094
9095 t.Run("bootclasspath_fragment jar must set min_sdk_version", func(t *testing.T) {
9096 preparer.ExtendWithErrorHandler(android.FixtureExpectsAtLeastOneErrorMatchingPattern(`module "mybootclasspathlib".*must set min_sdk_version`)).
9097 RunTestWithBp(t, `
9098 apex {
9099 name: "myapex",
9100 key: "myapex.key",
9101 bootclasspath_fragments: ["mybootclasspathfragment"],
9102 min_sdk_version: "30",
9103 updatable: false,
9104 }
9105
9106 apex_key {
9107 name: "myapex.key",
9108 public_key: "testkey.avbpubkey",
9109 private_key: "testkey.pem",
9110 }
9111
9112 bootclasspath_fragment {
9113 name: "mybootclasspathfragment",
9114 contents: ["mybootclasspathlib"],
9115 apex_available: ["myapex"],
9116 }
9117
9118 java_sdk_library {
9119 name: "mybootclasspathlib",
9120 srcs: ["mybootclasspathlib.java"],
9121 apex_available: ["myapex"],
9122 compile_dex: true,
9123 unsafe_ignore_missing_latest_api: true,
9124 }
9125 `)
9126 })
9127
9128 t.Run("systemserverclasspath_fragment jar must set min_sdk_version", func(t *testing.T) {
9129 preparer.ExtendWithErrorHandler(android.FixtureExpectsAtLeastOneErrorMatchingPattern(`module "mysystemserverclasspathlib".*must set min_sdk_version`)).
9130 RunTestWithBp(t, `
9131 apex {
9132 name: "myapex",
9133 key: "myapex.key",
9134 systemserverclasspath_fragments: ["mysystemserverclasspathfragment"],
9135 min_sdk_version: "30",
9136 updatable: false,
9137 }
9138
9139 apex_key {
9140 name: "myapex.key",
9141 public_key: "testkey.avbpubkey",
9142 private_key: "testkey.pem",
9143 }
9144
9145 systemserverclasspath_fragment {
9146 name: "mysystemserverclasspathfragment",
9147 contents: ["mysystemserverclasspathlib"],
9148 apex_available: ["myapex"],
9149 }
9150
9151 java_sdk_library {
9152 name: "mysystemserverclasspathlib",
9153 srcs: ["mysystemserverclasspathlib.java"],
9154 apex_available: ["myapex"],
9155 compile_dex: true,
9156 unsafe_ignore_missing_latest_api: true,
9157 }
9158 `)
9159 })
9160}
9161
Jiakai Zhang6decef92022-01-12 17:56:19 +00009162// Verifies that the APEX depends on all the Make modules in the list.
9163func ensureContainsRequiredDeps(t *testing.T, ctx *android.TestContext, moduleName, variant string, deps []string) {
9164 a := ctx.ModuleForTests(moduleName, variant).Module().(*apexBundle)
9165 for _, dep := range deps {
9166 android.AssertStringListContains(t, "", a.requiredDeps, dep)
9167 }
9168}
9169
9170// Verifies that the APEX does not depend on any of the Make modules in the list.
9171func ensureDoesNotContainRequiredDeps(t *testing.T, ctx *android.TestContext, moduleName, variant string, deps []string) {
9172 a := ctx.ModuleForTests(moduleName, variant).Module().(*apexBundle)
9173 for _, dep := range deps {
9174 android.AssertStringListDoesNotContain(t, "", a.requiredDeps, dep)
9175 }
9176}
9177
Spandan Das66773252022-01-15 00:23:18 +00009178func TestApexStrictUpdtabilityLint(t *testing.T) {
9179 bpTemplate := `
9180 apex {
9181 name: "myapex",
9182 key: "myapex.key",
9183 java_libs: ["myjavalib"],
9184 updatable: %v,
9185 min_sdk_version: "29",
9186 }
9187 apex_key {
9188 name: "myapex.key",
9189 }
9190 java_library {
9191 name: "myjavalib",
9192 srcs: ["MyClass.java"],
9193 apex_available: [ "myapex" ],
9194 lint: {
9195 strict_updatability_linting: %v,
9196 },
9197 sdk_version: "current",
9198 min_sdk_version: "29",
9199 }
9200 `
9201 fs := android.MockFS{
9202 "lint-baseline.xml": nil,
9203 }
9204
9205 testCases := []struct {
9206 testCaseName string
9207 apexUpdatable bool
9208 javaStrictUpdtabilityLint bool
9209 lintFileExists bool
9210 disallowedFlagExpected bool
9211 }{
9212 {
9213 testCaseName: "lint-baseline.xml does not exist, no disallowed flag necessary in lint cmd",
9214 apexUpdatable: true,
9215 javaStrictUpdtabilityLint: true,
9216 lintFileExists: false,
9217 disallowedFlagExpected: false,
9218 },
9219 {
9220 testCaseName: "non-updatable apex respects strict_updatability of javalib",
9221 apexUpdatable: false,
9222 javaStrictUpdtabilityLint: false,
9223 lintFileExists: true,
9224 disallowedFlagExpected: false,
9225 },
9226 {
9227 testCaseName: "non-updatable apex respects strict updatability of javalib",
9228 apexUpdatable: false,
9229 javaStrictUpdtabilityLint: true,
9230 lintFileExists: true,
9231 disallowedFlagExpected: true,
9232 },
9233 {
9234 testCaseName: "updatable apex sets strict updatability of javalib to true",
9235 apexUpdatable: true,
9236 javaStrictUpdtabilityLint: false, // will be set to true by mutator
9237 lintFileExists: true,
9238 disallowedFlagExpected: true,
9239 },
9240 }
9241
9242 for _, testCase := range testCases {
9243 bp := fmt.Sprintf(bpTemplate, testCase.apexUpdatable, testCase.javaStrictUpdtabilityLint)
9244 fixtures := []android.FixturePreparer{}
9245 if testCase.lintFileExists {
9246 fixtures = append(fixtures, fs.AddToFixture())
9247 }
9248
9249 result := testApex(t, bp, fixtures...)
9250 myjavalib := result.ModuleForTests("myjavalib", "android_common_apex29")
9251 sboxProto := android.RuleBuilderSboxProtoForTests(t, myjavalib.Output("lint.sbox.textproto"))
9252 disallowedFlagActual := strings.Contains(*sboxProto.Commands[0].Command, "--baseline lint-baseline.xml --disallowed_issues NewApi")
9253
9254 if disallowedFlagActual != testCase.disallowedFlagExpected {
9255 t.Errorf("Failed testcase: %v \nActual lint cmd: %v", testCase.testCaseName, *sboxProto.Commands[0].Command)
9256 }
9257 }
9258}
9259
Spandan Dasd9c23ab2022-02-10 02:34:13 +00009260func TestUpdatabilityLintSkipLibcore(t *testing.T) {
9261 bp := `
9262 apex {
9263 name: "myapex",
9264 key: "myapex.key",
9265 java_libs: ["myjavalib"],
9266 updatable: true,
9267 min_sdk_version: "29",
9268 }
9269 apex_key {
9270 name: "myapex.key",
9271 }
9272 java_library {
9273 name: "myjavalib",
9274 srcs: ["MyClass.java"],
9275 apex_available: [ "myapex" ],
9276 sdk_version: "current",
9277 min_sdk_version: "29",
9278 }
9279 `
9280
9281 testCases := []struct {
9282 testCaseName string
9283 moduleDirectory string
9284 disallowedFlagExpected bool
9285 }{
9286 {
9287 testCaseName: "lintable module defined outside libcore",
9288 moduleDirectory: "",
9289 disallowedFlagExpected: true,
9290 },
9291 {
9292 testCaseName: "lintable module defined in libcore root directory",
9293 moduleDirectory: "libcore/",
9294 disallowedFlagExpected: false,
9295 },
9296 {
9297 testCaseName: "lintable module defined in libcore child directory",
9298 moduleDirectory: "libcore/childdir/",
9299 disallowedFlagExpected: true,
9300 },
9301 }
9302
9303 for _, testCase := range testCases {
9304 lintFileCreator := android.FixtureAddTextFile(testCase.moduleDirectory+"lint-baseline.xml", "")
9305 bpFileCreator := android.FixtureAddTextFile(testCase.moduleDirectory+"Android.bp", bp)
9306 result := testApex(t, "", lintFileCreator, bpFileCreator)
9307 myjavalib := result.ModuleForTests("myjavalib", "android_common_apex29")
9308 sboxProto := android.RuleBuilderSboxProtoForTests(t, myjavalib.Output("lint.sbox.textproto"))
9309 cmdFlags := fmt.Sprintf("--baseline %vlint-baseline.xml --disallowed_issues NewApi", testCase.moduleDirectory)
9310 disallowedFlagActual := strings.Contains(*sboxProto.Commands[0].Command, cmdFlags)
9311
9312 if disallowedFlagActual != testCase.disallowedFlagExpected {
9313 t.Errorf("Failed testcase: %v \nActual lint cmd: %v", testCase.testCaseName, *sboxProto.Commands[0].Command)
9314 }
9315 }
9316}
9317
Spandan Das66773252022-01-15 00:23:18 +00009318// checks transtive deps of an apex coming from bootclasspath_fragment
9319func TestApexStrictUpdtabilityLintBcpFragmentDeps(t *testing.T) {
9320 bp := `
9321 apex {
9322 name: "myapex",
9323 key: "myapex.key",
9324 bootclasspath_fragments: ["mybootclasspathfragment"],
9325 updatable: true,
9326 min_sdk_version: "29",
9327 }
9328 apex_key {
9329 name: "myapex.key",
9330 }
9331 bootclasspath_fragment {
9332 name: "mybootclasspathfragment",
9333 contents: ["myjavalib"],
9334 apex_available: ["myapex"],
9335 }
9336 java_library {
9337 name: "myjavalib",
9338 srcs: ["MyClass.java"],
9339 apex_available: [ "myapex" ],
9340 sdk_version: "current",
9341 min_sdk_version: "29",
9342 compile_dex: true,
9343 }
9344 `
9345 fs := android.MockFS{
9346 "lint-baseline.xml": nil,
9347 }
9348
9349 result := testApex(t, bp, dexpreopt.FixtureSetApexBootJars("myapex:myjavalib"), fs.AddToFixture())
9350 myjavalib := result.ModuleForTests("myjavalib", "android_common_apex29")
9351 sboxProto := android.RuleBuilderSboxProtoForTests(t, myjavalib.Output("lint.sbox.textproto"))
9352 if !strings.Contains(*sboxProto.Commands[0].Command, "--baseline lint-baseline.xml --disallowed_issues NewApi") {
9353 t.Errorf("Strict updabality lint missing in myjavalib coming from bootclasspath_fragment mybootclasspath-fragment\nActual lint cmd: %v", *sboxProto.Commands[0].Command)
9354 }
9355}
9356
Jaewoong Jungc1001ec2019-06-25 11:20:53 -07009357func TestMain(m *testing.M) {
Paul Duffin37ba3442021-03-29 00:21:08 +01009358 os.Exit(m.Run())
Jaewoong Jungc1001ec2019-06-25 11:20:53 -07009359}