app_import_test.go 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772
  1. // Copyright 2020 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. package java
  15. import (
  16. "fmt"
  17. "reflect"
  18. "strings"
  19. "testing"
  20. "github.com/google/blueprint/proptools"
  21. "android/soong/android"
  22. )
  23. func TestAndroidAppImport(t *testing.T) {
  24. ctx, _ := testJava(t, `
  25. android_app_import {
  26. name: "foo",
  27. apk: "prebuilts/apk/app.apk",
  28. certificate: "platform",
  29. dex_preopt: {
  30. enabled: true,
  31. },
  32. }
  33. `)
  34. variant := ctx.ModuleForTests("foo", "android_common")
  35. // Check dexpreopt outputs.
  36. if variant.MaybeOutput("dexpreopt/oat/arm64/package.vdex").Rule == nil ||
  37. variant.MaybeOutput("dexpreopt/oat/arm64/package.odex").Rule == nil {
  38. t.Errorf("can't find dexpreopt outputs")
  39. }
  40. // Check cert signing flag.
  41. signedApk := variant.Output("signed/foo.apk")
  42. signingFlag := signedApk.Args["certificates"]
  43. expected := "build/make/target/product/security/platform.x509.pem build/make/target/product/security/platform.pk8"
  44. if expected != signingFlag {
  45. t.Errorf("Incorrect signing flags, expected: %q, got: %q", expected, signingFlag)
  46. }
  47. rule := variant.Rule("genProvenanceMetaData")
  48. android.AssertStringEquals(t, "Invalid input", "prebuilts/apk/app.apk", rule.Inputs[0].String())
  49. android.AssertStringEquals(t, "Invalid output", "out/soong/.intermediates/provenance_metadata/foo/provenance_metadata.textproto", rule.Output.String())
  50. android.AssertStringEquals(t, "Invalid args", "foo", rule.Args["module_name"])
  51. android.AssertStringEquals(t, "Invalid args", "/system/app/foo/foo.apk", rule.Args["install_path"])
  52. }
  53. func TestAndroidAppImport_NoDexPreopt(t *testing.T) {
  54. ctx, _ := testJava(t, `
  55. android_app_import {
  56. name: "foo",
  57. apk: "prebuilts/apk/app.apk",
  58. certificate: "platform",
  59. dex_preopt: {
  60. enabled: false,
  61. },
  62. }
  63. `)
  64. variant := ctx.ModuleForTests("foo", "android_common")
  65. // Check dexpreopt outputs. They shouldn't exist.
  66. if variant.MaybeOutput("dexpreopt/oat/arm64/package.vdex").Rule != nil ||
  67. variant.MaybeOutput("dexpreopt/oat/arm64/package.odex").Rule != nil {
  68. t.Errorf("dexpreopt shouldn't have run.")
  69. }
  70. rule := variant.Rule("genProvenanceMetaData")
  71. android.AssertStringEquals(t, "Invalid input", "prebuilts/apk/app.apk", rule.Inputs[0].String())
  72. android.AssertStringEquals(t, "Invalid output", "out/soong/.intermediates/provenance_metadata/foo/provenance_metadata.textproto", rule.Output.String())
  73. android.AssertStringEquals(t, "Invalid args", "foo", rule.Args["module_name"])
  74. android.AssertStringEquals(t, "Invalid args", "/system/app/foo/foo.apk", rule.Args["install_path"])
  75. }
  76. func TestAndroidAppImport_Presigned(t *testing.T) {
  77. ctx, _ := testJava(t, `
  78. android_app_import {
  79. name: "foo",
  80. apk: "prebuilts/apk/app.apk",
  81. presigned: true,
  82. dex_preopt: {
  83. enabled: true,
  84. },
  85. }
  86. `)
  87. variant := ctx.ModuleForTests("foo", "android_common")
  88. // Check dexpreopt outputs.
  89. if variant.MaybeOutput("dexpreopt/oat/arm64/package.vdex").Rule == nil ||
  90. variant.MaybeOutput("dexpreopt/oat/arm64/package.odex").Rule == nil {
  91. t.Errorf("can't find dexpreopt outputs")
  92. }
  93. // Make sure signing was skipped and aligning was done.
  94. if variant.MaybeOutput("signed/foo.apk").Rule != nil {
  95. t.Errorf("signing rule shouldn't be included.")
  96. }
  97. if variant.MaybeOutput("zip-aligned/foo.apk").Rule == nil {
  98. t.Errorf("can't find aligning rule")
  99. }
  100. rule := variant.Rule("genProvenanceMetaData")
  101. android.AssertStringEquals(t, "Invalid input", "prebuilts/apk/app.apk", rule.Inputs[0].String())
  102. android.AssertStringEquals(t, "Invalid output", "out/soong/.intermediates/provenance_metadata/foo/provenance_metadata.textproto", rule.Output.String())
  103. android.AssertStringEquals(t, "Invalid args", "foo", rule.Args["module_name"])
  104. android.AssertStringEquals(t, "Invalid args", "/system/app/foo/foo.apk", rule.Args["install_path"])
  105. }
  106. func TestAndroidAppImport_SigningLineage(t *testing.T) {
  107. ctx, _ := testJava(t, `
  108. android_app_import {
  109. name: "foo",
  110. apk: "prebuilts/apk/app.apk",
  111. certificate: "platform",
  112. additional_certificates: [":additional_certificate"],
  113. lineage: "lineage.bin",
  114. rotationMinSdkVersion: "32",
  115. }
  116. android_app_certificate {
  117. name: "additional_certificate",
  118. certificate: "cert/additional_cert",
  119. }
  120. `)
  121. variant := ctx.ModuleForTests("foo", "android_common")
  122. signedApk := variant.Output("signed/foo.apk")
  123. // Check certificates
  124. certificatesFlag := signedApk.Args["certificates"]
  125. expected := "build/make/target/product/security/platform.x509.pem " +
  126. "build/make/target/product/security/platform.pk8 " +
  127. "cert/additional_cert.x509.pem cert/additional_cert.pk8"
  128. if expected != certificatesFlag {
  129. t.Errorf("Incorrect certificates flags, expected: %q, got: %q", expected, certificatesFlag)
  130. }
  131. // Check cert signing flags.
  132. actualCertSigningFlags := signedApk.Args["flags"]
  133. expectedCertSigningFlags := "--lineage lineage.bin --rotation-min-sdk-version 32"
  134. if expectedCertSigningFlags != actualCertSigningFlags {
  135. t.Errorf("Incorrect signing flags, expected: %q, got: %q", expectedCertSigningFlags, actualCertSigningFlags)
  136. }
  137. rule := variant.Rule("genProvenanceMetaData")
  138. android.AssertStringEquals(t, "Invalid input", "prebuilts/apk/app.apk", rule.Inputs[0].String())
  139. android.AssertStringEquals(t, "Invalid output", "out/soong/.intermediates/provenance_metadata/foo/provenance_metadata.textproto", rule.Output.String())
  140. android.AssertStringEquals(t, "Invalid args", "foo", rule.Args["module_name"])
  141. android.AssertStringEquals(t, "Invalid args", "/system/app/foo/foo.apk", rule.Args["install_path"])
  142. }
  143. func TestAndroidAppImport_SigningLineageFilegroup(t *testing.T) {
  144. ctx, _ := testJava(t, `
  145. android_app_import {
  146. name: "foo",
  147. apk: "prebuilts/apk/app.apk",
  148. certificate: "platform",
  149. lineage: ":lineage_bin",
  150. }
  151. filegroup {
  152. name: "lineage_bin",
  153. srcs: ["lineage.bin"],
  154. }
  155. `)
  156. variant := ctx.ModuleForTests("foo", "android_common")
  157. signedApk := variant.Output("signed/foo.apk")
  158. // Check cert signing lineage flag.
  159. signingFlag := signedApk.Args["flags"]
  160. expected := "--lineage lineage.bin"
  161. if expected != signingFlag {
  162. t.Errorf("Incorrect signing flags, expected: %q, got: %q", expected, signingFlag)
  163. }
  164. rule := variant.Rule("genProvenanceMetaData")
  165. android.AssertStringEquals(t, "Invalid input", "prebuilts/apk/app.apk", rule.Inputs[0].String())
  166. android.AssertStringEquals(t, "Invalid output", "out/soong/.intermediates/provenance_metadata/foo/provenance_metadata.textproto", rule.Output.String())
  167. android.AssertStringEquals(t, "Invalid args", "foo", rule.Args["module_name"])
  168. android.AssertStringEquals(t, "Invalid args", "/system/app/foo/foo.apk", rule.Args["install_path"])
  169. }
  170. func TestAndroidAppImport_DefaultDevCert(t *testing.T) {
  171. ctx, _ := testJava(t, `
  172. android_app_import {
  173. name: "foo",
  174. apk: "prebuilts/apk/app.apk",
  175. default_dev_cert: true,
  176. dex_preopt: {
  177. enabled: true,
  178. },
  179. }
  180. `)
  181. variant := ctx.ModuleForTests("foo", "android_common")
  182. // Check dexpreopt outputs.
  183. if variant.MaybeOutput("dexpreopt/oat/arm64/package.vdex").Rule == nil ||
  184. variant.MaybeOutput("dexpreopt/oat/arm64/package.odex").Rule == nil {
  185. t.Errorf("can't find dexpreopt outputs")
  186. }
  187. // Check cert signing flag.
  188. signedApk := variant.Output("signed/foo.apk")
  189. signingFlag := signedApk.Args["certificates"]
  190. expected := "build/make/target/product/security/testkey.x509.pem build/make/target/product/security/testkey.pk8"
  191. if expected != signingFlag {
  192. t.Errorf("Incorrect signing flags, expected: %q, got: %q", expected, signingFlag)
  193. }
  194. rule := variant.Rule("genProvenanceMetaData")
  195. android.AssertStringEquals(t, "Invalid input", "prebuilts/apk/app.apk", rule.Inputs[0].String())
  196. android.AssertStringEquals(t, "Invalid output", "out/soong/.intermediates/provenance_metadata/foo/provenance_metadata.textproto", rule.Output.String())
  197. android.AssertStringEquals(t, "Invalid args", "foo", rule.Args["module_name"])
  198. android.AssertStringEquals(t, "Invalid args", "/system/app/foo/foo.apk", rule.Args["install_path"])
  199. }
  200. func TestAndroidAppImport_DpiVariants(t *testing.T) {
  201. bp := `
  202. android_app_import {
  203. name: "foo",
  204. apk: "prebuilts/apk/app.apk",
  205. dpi_variants: {
  206. xhdpi: {
  207. apk: "prebuilts/apk/app_xhdpi.apk",
  208. },
  209. xxhdpi: {
  210. apk: "prebuilts/apk/app_xxhdpi.apk",
  211. },
  212. },
  213. presigned: true,
  214. dex_preopt: {
  215. enabled: true,
  216. },
  217. }
  218. `
  219. testCases := []struct {
  220. name string
  221. aaptPreferredConfig *string
  222. aaptPrebuiltDPI []string
  223. expected string
  224. expectedProvenanceMetaDataArtifactPath string
  225. }{
  226. {
  227. name: "no preferred",
  228. aaptPreferredConfig: nil,
  229. aaptPrebuiltDPI: []string{},
  230. expected: "verify_uses_libraries/apk/app.apk",
  231. expectedProvenanceMetaDataArtifactPath: "prebuilts/apk/app.apk",
  232. },
  233. {
  234. name: "AAPTPreferredConfig matches",
  235. aaptPreferredConfig: proptools.StringPtr("xhdpi"),
  236. aaptPrebuiltDPI: []string{"xxhdpi", "ldpi"},
  237. expected: "verify_uses_libraries/apk/app_xhdpi.apk",
  238. expectedProvenanceMetaDataArtifactPath: "prebuilts/apk/app_xhdpi.apk",
  239. },
  240. {
  241. name: "AAPTPrebuiltDPI matches",
  242. aaptPreferredConfig: proptools.StringPtr("mdpi"),
  243. aaptPrebuiltDPI: []string{"xxhdpi", "xhdpi"},
  244. expected: "verify_uses_libraries/apk/app_xxhdpi.apk",
  245. expectedProvenanceMetaDataArtifactPath: "prebuilts/apk/app_xxhdpi.apk",
  246. },
  247. {
  248. name: "non-first AAPTPrebuiltDPI matches",
  249. aaptPreferredConfig: proptools.StringPtr("mdpi"),
  250. aaptPrebuiltDPI: []string{"ldpi", "xhdpi"},
  251. expected: "verify_uses_libraries/apk/app_xhdpi.apk",
  252. expectedProvenanceMetaDataArtifactPath: "prebuilts/apk/app_xhdpi.apk",
  253. },
  254. {
  255. name: "no matches",
  256. aaptPreferredConfig: proptools.StringPtr("mdpi"),
  257. aaptPrebuiltDPI: []string{"ldpi", "xxxhdpi"},
  258. expected: "verify_uses_libraries/apk/app.apk",
  259. expectedProvenanceMetaDataArtifactPath: "prebuilts/apk/app.apk",
  260. },
  261. }
  262. for _, test := range testCases {
  263. result := android.GroupFixturePreparers(
  264. PrepareForTestWithJavaDefaultModules,
  265. android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
  266. variables.AAPTPreferredConfig = test.aaptPreferredConfig
  267. variables.AAPTPrebuiltDPI = test.aaptPrebuiltDPI
  268. }),
  269. ).RunTestWithBp(t, bp)
  270. variant := result.ModuleForTests("foo", "android_common")
  271. input := variant.Output("jnis-uncompressed/foo.apk").Input.String()
  272. if strings.HasSuffix(input, test.expected) {
  273. t.Errorf("wrong src apk, expected: %q got: %q", test.expected, input)
  274. }
  275. provenanceMetaDataRule := variant.Rule("genProvenanceMetaData")
  276. android.AssertStringEquals(t, "Invalid input", test.expectedProvenanceMetaDataArtifactPath, provenanceMetaDataRule.Inputs[0].String())
  277. android.AssertStringEquals(t, "Invalid output", "out/soong/.intermediates/provenance_metadata/foo/provenance_metadata.textproto", provenanceMetaDataRule.Output.String())
  278. android.AssertStringEquals(t, "Invalid args", "foo", provenanceMetaDataRule.Args["module_name"])
  279. android.AssertStringEquals(t, "Invalid args", "/system/app/foo/foo.apk", provenanceMetaDataRule.Args["install_path"])
  280. }
  281. }
  282. func TestAndroidAppImport_Filename(t *testing.T) {
  283. ctx, _ := testJava(t, `
  284. android_app_import {
  285. name: "foo",
  286. apk: "prebuilts/apk/app.apk",
  287. presigned: true,
  288. }
  289. android_app_import {
  290. name: "bar",
  291. apk: "prebuilts/apk/app.apk",
  292. presigned: true,
  293. filename: "bar_sample.apk"
  294. }
  295. `)
  296. testCases := []struct {
  297. name string
  298. expected string
  299. onDevice string
  300. expectedArtifactPath string
  301. expectedMetaDataPath string
  302. }{
  303. {
  304. name: "foo",
  305. expected: "foo.apk",
  306. onDevice: "/system/app/foo/foo.apk",
  307. expectedArtifactPath: "prebuilts/apk/app.apk",
  308. expectedMetaDataPath: "out/soong/.intermediates/provenance_metadata/foo/provenance_metadata.textproto",
  309. },
  310. {
  311. name: "bar",
  312. expected: "bar_sample.apk",
  313. onDevice: "/system/app/bar/bar_sample.apk",
  314. expectedArtifactPath: "prebuilts/apk/app.apk",
  315. expectedMetaDataPath: "out/soong/.intermediates/provenance_metadata/bar/provenance_metadata.textproto",
  316. },
  317. }
  318. for _, test := range testCases {
  319. variant := ctx.ModuleForTests(test.name, "android_common")
  320. if variant.MaybeOutput(test.expected).Rule == nil {
  321. t.Errorf("can't find output named %q - all outputs: %v", test.expected, variant.AllOutputs())
  322. }
  323. a := variant.Module().(*AndroidAppImport)
  324. expectedValues := []string{test.expected}
  325. entries := android.AndroidMkEntriesForTest(t, ctx, a)[0]
  326. actualValues := entries.EntryMap["LOCAL_INSTALLED_MODULE_STEM"]
  327. if !reflect.DeepEqual(actualValues, expectedValues) {
  328. t.Errorf("Incorrect LOCAL_INSTALLED_MODULE_STEM value '%s', expected '%s'",
  329. actualValues, expectedValues)
  330. }
  331. android.AssertStringEquals(t, "unexpected LOCAL_SOONG_MODULE_TYPE", "android_app_import", entries.EntryMap["LOCAL_SOONG_MODULE_TYPE"][0])
  332. rule := variant.Rule("genProvenanceMetaData")
  333. android.AssertStringEquals(t, "Invalid input", test.expectedArtifactPath, rule.Inputs[0].String())
  334. android.AssertStringEquals(t, "Invalid output", test.expectedMetaDataPath, rule.Output.String())
  335. android.AssertStringEquals(t, "Invalid args", test.name, rule.Args["module_name"])
  336. android.AssertStringEquals(t, "Invalid args", test.onDevice, rule.Args["install_path"])
  337. }
  338. }
  339. func TestAndroidAppImport_ArchVariants(t *testing.T) {
  340. // The test config's target arch is ARM64.
  341. testCases := []struct {
  342. name string
  343. bp string
  344. expected string
  345. artifactPath string
  346. metaDataPath string
  347. installPath string
  348. }{
  349. {
  350. name: "matching arch",
  351. bp: `
  352. android_app_import {
  353. name: "foo",
  354. apk: "prebuilts/apk/app.apk",
  355. arch: {
  356. arm64: {
  357. apk: "prebuilts/apk/app_arm64.apk",
  358. },
  359. },
  360. presigned: true,
  361. dex_preopt: {
  362. enabled: true,
  363. },
  364. }
  365. `,
  366. expected: "verify_uses_libraries/apk/app_arm64.apk",
  367. artifactPath: "prebuilts/apk/app_arm64.apk",
  368. installPath: "/system/app/foo/foo.apk",
  369. },
  370. {
  371. name: "no matching arch",
  372. bp: `
  373. android_app_import {
  374. name: "foo",
  375. apk: "prebuilts/apk/app.apk",
  376. arch: {
  377. arm: {
  378. apk: "prebuilts/apk/app_arm.apk",
  379. },
  380. },
  381. presigned: true,
  382. dex_preopt: {
  383. enabled: true,
  384. },
  385. }
  386. `,
  387. expected: "verify_uses_libraries/apk/app.apk",
  388. artifactPath: "prebuilts/apk/app.apk",
  389. installPath: "/system/app/foo/foo.apk",
  390. },
  391. {
  392. name: "no matching arch without default",
  393. bp: `
  394. android_app_import {
  395. name: "foo",
  396. arch: {
  397. arm: {
  398. apk: "prebuilts/apk/app_arm.apk",
  399. },
  400. },
  401. presigned: true,
  402. dex_preopt: {
  403. enabled: true,
  404. },
  405. }
  406. `,
  407. expected: "",
  408. artifactPath: "prebuilts/apk/app_arm.apk",
  409. installPath: "/system/app/foo/foo.apk",
  410. },
  411. }
  412. for _, test := range testCases {
  413. ctx, _ := testJava(t, test.bp)
  414. variant := ctx.ModuleForTests("foo", "android_common")
  415. if test.expected == "" {
  416. if variant.Module().Enabled() {
  417. t.Error("module should have been disabled, but wasn't")
  418. }
  419. rule := variant.MaybeRule("genProvenanceMetaData")
  420. android.AssertDeepEquals(t, "Provenance metadata is not empty", android.TestingBuildParams{}, rule)
  421. continue
  422. }
  423. input := variant.Output("jnis-uncompressed/foo.apk").Input.String()
  424. if strings.HasSuffix(input, test.expected) {
  425. t.Errorf("wrong src apk, expected: %q got: %q", test.expected, input)
  426. }
  427. rule := variant.Rule("genProvenanceMetaData")
  428. android.AssertStringEquals(t, "Invalid input", test.artifactPath, rule.Inputs[0].String())
  429. android.AssertStringEquals(t, "Invalid output", "out/soong/.intermediates/provenance_metadata/foo/provenance_metadata.textproto", rule.Output.String())
  430. android.AssertStringEquals(t, "Invalid args", "foo", rule.Args["module_name"])
  431. android.AssertStringEquals(t, "Invalid args", test.installPath, rule.Args["install_path"])
  432. }
  433. }
  434. func TestAndroidAppImport_overridesDisabledAndroidApp(t *testing.T) {
  435. ctx, _ := testJava(t, `
  436. android_app {
  437. name: "foo",
  438. srcs: ["a.java"],
  439. enabled: false,
  440. }
  441. android_app_import {
  442. name: "foo",
  443. apk: "prebuilts/apk/app.apk",
  444. certificate: "platform",
  445. prefer: true,
  446. }
  447. `)
  448. variant := ctx.ModuleForTests("prebuilt_foo", "android_common")
  449. a := variant.Module().(*AndroidAppImport)
  450. // The prebuilt module should still be enabled and active even if the source-based counterpart
  451. // is disabled.
  452. if !a.prebuilt.UsePrebuilt() {
  453. t.Errorf("prebuilt foo module is not active")
  454. }
  455. if !a.Enabled() {
  456. t.Errorf("prebuilt foo module is disabled")
  457. }
  458. }
  459. func TestAndroidAppImport_relativeInstallPath(t *testing.T) {
  460. bp := `
  461. android_app_import {
  462. name: "no_relative_install_path",
  463. apk: "prebuilts/apk/app.apk",
  464. presigned: true,
  465. }
  466. android_app_import {
  467. name: "relative_install_path",
  468. apk: "prebuilts/apk/app.apk",
  469. presigned: true,
  470. relative_install_path: "my/path",
  471. }
  472. android_app_import {
  473. name: "privileged_relative_install_path",
  474. apk: "prebuilts/apk/app.apk",
  475. presigned: true,
  476. privileged: true,
  477. relative_install_path: "my/path"
  478. }
  479. `
  480. testCases := []struct {
  481. name string
  482. expectedInstallPath string
  483. errorMessage string
  484. }{
  485. {
  486. name: "no_relative_install_path",
  487. expectedInstallPath: "out/soong/target/product/test_device/system/app/no_relative_install_path/no_relative_install_path.apk",
  488. errorMessage: "Install path is not correct when relative_install_path is missing",
  489. },
  490. {
  491. name: "relative_install_path",
  492. expectedInstallPath: "out/soong/target/product/test_device/system/app/my/path/relative_install_path/relative_install_path.apk",
  493. errorMessage: "Install path is not correct for app when relative_install_path is present",
  494. },
  495. {
  496. name: "privileged_relative_install_path",
  497. expectedInstallPath: "out/soong/target/product/test_device/system/priv-app/my/path/privileged_relative_install_path/privileged_relative_install_path.apk",
  498. errorMessage: "Install path is not correct for privileged app when relative_install_path is present",
  499. },
  500. }
  501. for _, testCase := range testCases {
  502. ctx, _ := testJava(t, bp)
  503. mod := ctx.ModuleForTests(testCase.name, "android_common").Module().(*AndroidAppImport)
  504. android.AssertPathRelativeToTopEquals(t, testCase.errorMessage, testCase.expectedInstallPath, mod.installPath)
  505. }
  506. }
  507. func TestAndroidTestImport(t *testing.T) {
  508. ctx, _ := testJava(t, `
  509. android_test_import {
  510. name: "foo",
  511. apk: "prebuilts/apk/app.apk",
  512. presigned: true,
  513. data: [
  514. "testdata/data",
  515. ],
  516. }
  517. `)
  518. test := ctx.ModuleForTests("foo", "android_common").Module().(*AndroidTestImport)
  519. // Check android mks.
  520. entries := android.AndroidMkEntriesForTest(t, ctx, test)[0]
  521. expected := []string{"tests"}
  522. actual := entries.EntryMap["LOCAL_MODULE_TAGS"]
  523. if !reflect.DeepEqual(expected, actual) {
  524. t.Errorf("Unexpected module tags - expected: %q, actual: %q", expected, actual)
  525. }
  526. expected = []string{"testdata/data:testdata/data"}
  527. actual = entries.EntryMap["LOCAL_COMPATIBILITY_SUPPORT_FILES"]
  528. if !reflect.DeepEqual(expected, actual) {
  529. t.Errorf("Unexpected test data - expected: %q, actual: %q", expected, actual)
  530. }
  531. }
  532. func TestAndroidTestImport_NoJinUncompressForPresigned(t *testing.T) {
  533. ctx, _ := testJava(t, `
  534. android_test_import {
  535. name: "foo",
  536. apk: "prebuilts/apk/app.apk",
  537. certificate: "cert/new_cert",
  538. data: [
  539. "testdata/data",
  540. ],
  541. }
  542. android_test_import {
  543. name: "foo_presigned",
  544. apk: "prebuilts/apk/app.apk",
  545. presigned: true,
  546. data: [
  547. "testdata/data",
  548. ],
  549. }
  550. `)
  551. variant := ctx.ModuleForTests("foo", "android_common")
  552. jniRule := variant.Output("jnis-uncompressed/foo.apk").BuildParams.Rule.String()
  553. if jniRule == android.Cp.String() {
  554. t.Errorf("Unexpected JNI uncompress rule command: " + jniRule)
  555. }
  556. variant = ctx.ModuleForTests("foo_presigned", "android_common")
  557. jniRule = variant.Output("jnis-uncompressed/foo_presigned.apk").BuildParams.Rule.String()
  558. if jniRule != android.Cp.String() {
  559. t.Errorf("Unexpected JNI uncompress rule: " + jniRule)
  560. }
  561. if variant.MaybeOutput("zip-aligned/foo_presigned.apk").Rule == nil {
  562. t.Errorf("Presigned test apk should be aligned")
  563. }
  564. }
  565. func TestAndroidTestImport_Preprocessed(t *testing.T) {
  566. ctx, _ := testJava(t, `
  567. android_test_import {
  568. name: "foo",
  569. apk: "prebuilts/apk/app.apk",
  570. presigned: true,
  571. preprocessed: true,
  572. }
  573. android_test_import {
  574. name: "foo_cert",
  575. apk: "prebuilts/apk/app.apk",
  576. certificate: "cert/new_cert",
  577. preprocessed: true,
  578. }
  579. `)
  580. testModules := []string{"foo", "foo_cert"}
  581. for _, m := range testModules {
  582. apkName := m + ".apk"
  583. variant := ctx.ModuleForTests(m, "android_common")
  584. jniRule := variant.Output("jnis-uncompressed/" + apkName).BuildParams.Rule.String()
  585. if jniRule != android.Cp.String() {
  586. t.Errorf("Unexpected JNI uncompress rule: " + jniRule)
  587. }
  588. // Make sure signing and aligning were skipped.
  589. if variant.MaybeOutput("signed/"+apkName).Rule != nil {
  590. t.Errorf("signing rule shouldn't be included for preprocessed.")
  591. }
  592. if variant.MaybeOutput("zip-aligned/"+apkName).Rule != nil {
  593. t.Errorf("aligning rule shouldn't be for preprocessed")
  594. }
  595. }
  596. }
  597. func TestAndroidAppImport_Preprocessed(t *testing.T) {
  598. ctx, _ := testJava(t, `
  599. android_app_import {
  600. name: "foo",
  601. apk: "prebuilts/apk/app.apk",
  602. presigned: true,
  603. preprocessed: true,
  604. }
  605. `)
  606. apkName := "foo.apk"
  607. variant := ctx.ModuleForTests("foo", "android_common")
  608. outputBuildParams := variant.Output("validated-prebuilt/" + apkName).BuildParams
  609. if outputBuildParams.Rule.String() != android.Cp.String() {
  610. t.Errorf("Unexpected prebuilt android_app_import rule: " + outputBuildParams.Rule.String())
  611. }
  612. // Make sure compression and aligning were validated.
  613. if len(outputBuildParams.Validations) != 2 {
  614. t.Errorf("Expected compression/alignment validation rules, found %d validations", len(outputBuildParams.Validations))
  615. }
  616. }
  617. func TestAndroidTestImport_UncompressDex(t *testing.T) {
  618. testCases := []struct {
  619. name string
  620. bp string
  621. }{
  622. {
  623. name: "normal",
  624. bp: `
  625. android_app_import {
  626. name: "foo",
  627. presigned: true,
  628. apk: "prebuilts/apk/app.apk",
  629. }
  630. `,
  631. },
  632. {
  633. name: "privileged",
  634. bp: `
  635. android_app_import {
  636. name: "foo",
  637. presigned: true,
  638. privileged: true,
  639. apk: "prebuilts/apk/app.apk",
  640. }
  641. `,
  642. },
  643. }
  644. test := func(t *testing.T, bp string, unbundled bool, dontUncompressPrivAppDexs bool) {
  645. t.Helper()
  646. result := android.GroupFixturePreparers(
  647. prepareForJavaTest,
  648. android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
  649. if unbundled {
  650. variables.Unbundled_build = proptools.BoolPtr(true)
  651. }
  652. variables.UncompressPrivAppDex = proptools.BoolPtr(!dontUncompressPrivAppDexs)
  653. }),
  654. ).RunTestWithBp(t, bp)
  655. foo := result.ModuleForTests("foo", "android_common")
  656. actual := foo.MaybeRule("uncompress-dex").Rule != nil
  657. expect := !unbundled
  658. if strings.Contains(bp, "privileged: true") {
  659. if dontUncompressPrivAppDexs {
  660. expect = false
  661. } else {
  662. // TODO(b/194504107): shouldn't priv-apps be always uncompressed unless
  663. // DONT_UNCOMPRESS_PRIV_APPS_DEXS is true (regardless of unbundling)?
  664. // expect = true
  665. }
  666. }
  667. android.AssertBoolEquals(t, "uncompress dex", expect, actual)
  668. }
  669. for _, unbundled := range []bool{false, true} {
  670. for _, dontUncompressPrivAppDexs := range []bool{false, true} {
  671. for _, tt := range testCases {
  672. name := fmt.Sprintf("%s,unbundled:%t,dontUncompressPrivAppDexs:%t",
  673. tt.name, unbundled, dontUncompressPrivAppDexs)
  674. t.Run(name, func(t *testing.T) {
  675. test(t, tt.bp, unbundled, dontUncompressPrivAppDexs)
  676. })
  677. }
  678. }
  679. }
  680. }
  681. func TestAppImportMissingCertificateAllowMissingDependencies(t *testing.T) {
  682. result := android.GroupFixturePreparers(
  683. PrepareForTestWithJavaDefaultModules,
  684. android.PrepareForTestWithAllowMissingDependencies,
  685. android.PrepareForTestWithAndroidMk,
  686. ).RunTestWithBp(t, `
  687. android_app_import {
  688. name: "foo",
  689. apk: "a.apk",
  690. certificate: ":missing_certificate",
  691. }`)
  692. foo := result.ModuleForTests("foo", "android_common")
  693. fooApk := foo.Output("signed/foo.apk")
  694. if fooApk.Rule != android.ErrorRule {
  695. t.Fatalf("expected ErrorRule for foo.apk, got %s", fooApk.Rule.String())
  696. }
  697. android.AssertStringDoesContain(t, "expected error rule message", fooApk.Args["error"], "missing dependencies: missing_certificate\n")
  698. }