android_app_conversion_test.go 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398
  1. // Copyright 2021 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 bp2build
  15. import (
  16. "android/soong/android"
  17. "android/soong/java"
  18. "testing"
  19. )
  20. func runAndroidAppTestCase(t *testing.T, tc Bp2buildTestCase) {
  21. t.Helper()
  22. RunBp2BuildTestCase(t, registerAndroidAppModuleTypes, tc)
  23. }
  24. func registerAndroidAppModuleTypes(ctx android.RegistrationContext) {
  25. ctx.RegisterModuleType("filegroup", android.FileGroupFactory)
  26. ctx.RegisterModuleType("java_library", java.LibraryFactory)
  27. }
  28. func TestMinimalAndroidApp(t *testing.T) {
  29. runAndroidAppTestCase(t, Bp2buildTestCase{
  30. Description: "Android app - simple example",
  31. ModuleTypeUnderTest: "android_app",
  32. ModuleTypeUnderTestFactory: java.AndroidAppFactory,
  33. Filesystem: map[string]string{
  34. "app.java": "",
  35. "res/res.png": "",
  36. "AndroidManifest.xml": "",
  37. },
  38. Blueprint: `
  39. android_app {
  40. name: "TestApp",
  41. srcs: ["app.java"],
  42. sdk_version: "current",
  43. }
  44. `,
  45. ExpectedBazelTargets: []string{
  46. MakeBazelTarget("android_binary", "TestApp", AttrNameToString{
  47. "srcs": `["app.java"]`,
  48. "manifest": `"AndroidManifest.xml"`,
  49. "resource_files": `["res/res.png"]`,
  50. "sdk_version": `"current"`,
  51. }),
  52. }})
  53. }
  54. func TestAndroidAppAllSupportedFields(t *testing.T) {
  55. runAndroidAppTestCase(t, Bp2buildTestCase{
  56. Description: "Android app - all supported fields",
  57. ModuleTypeUnderTest: "android_app",
  58. ModuleTypeUnderTestFactory: java.AndroidAppFactory,
  59. Filesystem: map[string]string{
  60. "app.java": "",
  61. "resa/res.png": "",
  62. "resb/res.png": "",
  63. "manifest/AndroidManifest.xml": "",
  64. },
  65. Blueprint: simpleModuleDoNotConvertBp2build("android_app", "static_lib_dep") + `
  66. android_app {
  67. name: "TestApp",
  68. srcs: ["app.java"],
  69. sdk_version: "current",
  70. package_name: "com.google",
  71. resource_dirs: ["resa", "resb"],
  72. manifest: "manifest/AndroidManifest.xml",
  73. static_libs: ["static_lib_dep"],
  74. java_version: "7",
  75. certificate: "foocert",
  76. }
  77. `,
  78. ExpectedBazelTargets: []string{
  79. MakeBazelTarget("android_binary", "TestApp", AttrNameToString{
  80. "srcs": `["app.java"]`,
  81. "manifest": `"manifest/AndroidManifest.xml"`,
  82. "resource_files": `[
  83. "resa/res.png",
  84. "resb/res.png",
  85. ]`,
  86. "custom_package": `"com.google"`,
  87. "deps": `[":static_lib_dep"]`,
  88. "java_version": `"7"`,
  89. "sdk_version": `"current"`,
  90. "certificate_name": `"foocert"`,
  91. }),
  92. }})
  93. }
  94. func TestAndroidAppArchVariantSrcs(t *testing.T) {
  95. runAndroidAppTestCase(t, Bp2buildTestCase{
  96. Description: "Android app - arch variant srcs",
  97. ModuleTypeUnderTest: "android_app",
  98. ModuleTypeUnderTestFactory: java.AndroidAppFactory,
  99. Filesystem: map[string]string{
  100. "arm.java": "",
  101. "x86.java": "",
  102. "res/res.png": "",
  103. "AndroidManifest.xml": "",
  104. },
  105. Blueprint: `
  106. android_app {
  107. name: "TestApp",
  108. sdk_version: "current",
  109. arch: {
  110. arm: {
  111. srcs: ["arm.java"],
  112. },
  113. x86: {
  114. srcs: ["x86.java"],
  115. }
  116. }
  117. }
  118. `,
  119. ExpectedBazelTargets: []string{
  120. MakeBazelTarget("android_binary", "TestApp", AttrNameToString{
  121. "srcs": `select({
  122. "//build/bazel/platforms/arch:arm": ["arm.java"],
  123. "//build/bazel/platforms/arch:x86": ["x86.java"],
  124. "//conditions:default": [],
  125. })`,
  126. "manifest": `"AndroidManifest.xml"`,
  127. "resource_files": `["res/res.png"]`,
  128. "sdk_version": `"current"`,
  129. }),
  130. }})
  131. }
  132. func TestAndroidAppCertIsModule(t *testing.T) {
  133. runAndroidAppTestCase(t, Bp2buildTestCase{
  134. Description: "Android app - cert is module",
  135. ModuleTypeUnderTest: "android_app",
  136. ModuleTypeUnderTestFactory: java.AndroidAppFactory,
  137. Filesystem: map[string]string{},
  138. Blueprint: simpleModuleDoNotConvertBp2build("filegroup", "foocert") + `
  139. android_app {
  140. name: "TestApp",
  141. certificate: ":foocert",
  142. }
  143. `,
  144. ExpectedBazelTargets: []string{
  145. MakeBazelTarget("android_binary", "TestApp", AttrNameToString{
  146. "certificate": `":foocert"`,
  147. "manifest": `"AndroidManifest.xml"`,
  148. "resource_files": `[]`,
  149. }),
  150. }})
  151. }
  152. func TestAndroidAppCertIsSrcFile(t *testing.T) {
  153. runAndroidAppTestCase(t, Bp2buildTestCase{
  154. Description: "Android app - cert is src file",
  155. ModuleTypeUnderTest: "android_app",
  156. ModuleTypeUnderTestFactory: java.AndroidAppFactory,
  157. Filesystem: map[string]string{
  158. "foocert": "",
  159. },
  160. Blueprint: `
  161. android_app {
  162. name: "TestApp",
  163. certificate: "foocert",
  164. }
  165. `,
  166. ExpectedBazelTargets: []string{
  167. MakeBazelTarget("android_binary", "TestApp", AttrNameToString{
  168. "certificate": `"foocert"`,
  169. "manifest": `"AndroidManifest.xml"`,
  170. "resource_files": `[]`,
  171. }),
  172. }})
  173. }
  174. func TestAndroidAppCertIsNotSrcOrModule(t *testing.T) {
  175. runAndroidAppTestCase(t, Bp2buildTestCase{
  176. Description: "Android app - cert is not src or module",
  177. ModuleTypeUnderTest: "android_app",
  178. ModuleTypeUnderTestFactory: java.AndroidAppFactory,
  179. Filesystem: map[string]string{
  180. // deliberate empty
  181. },
  182. Blueprint: `
  183. android_app {
  184. name: "TestApp",
  185. certificate: "foocert",
  186. }
  187. `,
  188. ExpectedBazelTargets: []string{
  189. MakeBazelTarget("android_binary", "TestApp", AttrNameToString{
  190. "certificate_name": `"foocert"`,
  191. "manifest": `"AndroidManifest.xml"`,
  192. "resource_files": `[]`,
  193. }),
  194. }})
  195. }
  196. func TestAndroidAppLibs(t *testing.T) {
  197. runAndroidAppTestCase(t, Bp2buildTestCase{
  198. Description: "Android app with libs",
  199. ModuleTypeUnderTest: "android_app",
  200. ModuleTypeUnderTestFactory: java.AndroidAppFactory,
  201. Filesystem: map[string]string{},
  202. Blueprint: simpleModuleDoNotConvertBp2build("filegroup", "foocert") + `
  203. android_app {
  204. name: "foo",
  205. libs: ["barLib"]
  206. }
  207. java_library{
  208. name: "barLib",
  209. }
  210. `,
  211. ExpectedBazelTargets: []string{
  212. MakeBazelTarget("java_library", "barLib", AttrNameToString{}),
  213. MakeNeverlinkDuplicateTarget("java_library", "barLib"),
  214. MakeBazelTarget("android_binary", "foo", AttrNameToString{
  215. "manifest": `"AndroidManifest.xml"`,
  216. "resource_files": `[]`,
  217. "deps": `[":barLib-neverlink"]`,
  218. }),
  219. }})
  220. }
  221. func TestAndroidAppKotlinSrcs(t *testing.T) {
  222. runAndroidAppTestCase(t, Bp2buildTestCase{
  223. Description: "Android app with kotlin sources and common_srcs",
  224. ModuleTypeUnderTest: "android_app",
  225. ModuleTypeUnderTestFactory: java.AndroidAppFactory,
  226. Filesystem: map[string]string{
  227. "res/res.png": "",
  228. },
  229. Blueprint: simpleModuleDoNotConvertBp2build("filegroup", "foocert") + `
  230. android_app {
  231. name: "foo",
  232. srcs: ["a.java", "b.kt"],
  233. certificate: ":foocert",
  234. manifest: "fooManifest.xml",
  235. libs: ["barLib"]
  236. }
  237. java_library{
  238. name: "barLib",
  239. }
  240. `,
  241. ExpectedBazelTargets: []string{
  242. MakeBazelTarget("java_library", "barLib", AttrNameToString{}),
  243. MakeNeverlinkDuplicateTarget("java_library", "barLib"),
  244. MakeBazelTarget("android_library", "foo_kt", AttrNameToString{
  245. "srcs": `[
  246. "a.java",
  247. "b.kt",
  248. ]`,
  249. "manifest": `"fooManifest.xml"`,
  250. "resource_files": `["res/res.png"]`,
  251. "deps": `[":barLib-neverlink"]`,
  252. }),
  253. MakeBazelTarget("android_binary", "foo", AttrNameToString{
  254. "deps": `[":foo_kt"]`,
  255. "certificate": `":foocert"`,
  256. "manifest": `"fooManifest.xml"`,
  257. }),
  258. }})
  259. }
  260. func TestAndroidAppCommonSrcs(t *testing.T) {
  261. runAndroidAppTestCase(t, Bp2buildTestCase{
  262. Description: "Android app with common_srcs",
  263. ModuleTypeUnderTest: "android_app",
  264. ModuleTypeUnderTestFactory: java.AndroidAppFactory,
  265. Filesystem: map[string]string{
  266. "res/res.png": "",
  267. },
  268. Blueprint: simpleModuleDoNotConvertBp2build("filegroup", "foocert") + `
  269. android_app {
  270. name: "foo",
  271. srcs: ["a.java"],
  272. common_srcs: ["b.kt"],
  273. certificate: "foocert",
  274. manifest: "fooManifest.xml",
  275. libs: ["barLib"],
  276. }
  277. java_library{
  278. name: "barLib",
  279. }
  280. `,
  281. ExpectedBazelTargets: []string{
  282. MakeBazelTarget("java_library", "barLib", AttrNameToString{}),
  283. MakeNeverlinkDuplicateTarget("java_library", "barLib"),
  284. MakeBazelTarget("android_library", "foo_kt", AttrNameToString{
  285. "srcs": `["a.java"]`,
  286. "common_srcs": `["b.kt"]`,
  287. "manifest": `"fooManifest.xml"`,
  288. "resource_files": `["res/res.png"]`,
  289. "deps": `[":barLib-neverlink"]`,
  290. }),
  291. MakeBazelTarget("android_binary", "foo", AttrNameToString{
  292. "deps": `[":foo_kt"]`,
  293. "certificate_name": `"foocert"`,
  294. "manifest": `"fooManifest.xml"`,
  295. }),
  296. }})
  297. }
  298. func TestAndroidAppKotlinCflags(t *testing.T) {
  299. runAndroidAppTestCase(t, Bp2buildTestCase{
  300. Description: "Android app with kotlincflags",
  301. ModuleTypeUnderTest: "android_app",
  302. ModuleTypeUnderTestFactory: java.AndroidAppFactory,
  303. Filesystem: map[string]string{
  304. "res/res.png": "",
  305. },
  306. Blueprint: simpleModuleDoNotConvertBp2build("filegroup", "foocert") + `
  307. android_app {
  308. name: "foo",
  309. srcs: ["a.java", "b.kt"],
  310. certificate: ":foocert",
  311. manifest: "fooManifest.xml",
  312. kotlincflags: ["-flag1", "-flag2"],
  313. }
  314. `,
  315. ExpectedBazelTargets: []string{
  316. MakeBazelTarget("android_library", "foo_kt", AttrNameToString{
  317. "srcs": `[
  318. "a.java",
  319. "b.kt",
  320. ]`,
  321. "manifest": `"fooManifest.xml"`,
  322. "resource_files": `["res/res.png"]`,
  323. "kotlincflags": `[
  324. "-flag1",
  325. "-flag2",
  326. ]`,
  327. }),
  328. MakeBazelTarget("android_binary", "foo", AttrNameToString{
  329. "deps": `[":foo_kt"]`,
  330. "certificate": `":foocert"`,
  331. "manifest": `"fooManifest.xml"`,
  332. }),
  333. }})
  334. }
  335. func TestAndroidAppMinSdkProvided(t *testing.T) {
  336. runAndroidAppTestCase(t, Bp2buildTestCase{
  337. Description: "Android app with value for min_sdk_version",
  338. ModuleTypeUnderTest: "android_app",
  339. ModuleTypeUnderTestFactory: java.AndroidAppFactory,
  340. Filesystem: map[string]string{},
  341. Blueprint: simpleModuleDoNotConvertBp2build("filegroup", "foocert") + `
  342. android_app {
  343. name: "foo",
  344. sdk_version: "current",
  345. min_sdk_version: "24",
  346. }
  347. `,
  348. ExpectedBazelTargets: []string{
  349. MakeBazelTarget("android_binary", "foo", AttrNameToString{
  350. "manifest": `"AndroidManifest.xml"`,
  351. "resource_files": `[]`,
  352. "manifest_values": `{
  353. "minSdkVersion": "24",
  354. }`,
  355. "sdk_version": `"current"`,
  356. }),
  357. }})
  358. }
  359. func TestAndroidAppMinSdkDefaultToSdkVersion(t *testing.T) {
  360. runAndroidAppTestCase(t, Bp2buildTestCase{
  361. Description: "Android app with value for sdk_version",
  362. ModuleTypeUnderTest: "android_app",
  363. ModuleTypeUnderTestFactory: java.AndroidAppFactory,
  364. Filesystem: map[string]string{},
  365. Blueprint: simpleModuleDoNotConvertBp2build("filegroup", "foocert") + `
  366. android_app {
  367. name: "foo",
  368. sdk_version: "30",
  369. }
  370. `,
  371. ExpectedBazelTargets: []string{
  372. MakeBazelTarget("android_binary", "foo", AttrNameToString{
  373. "manifest": `"AndroidManifest.xml"`,
  374. "resource_files": `[]`,
  375. "manifest_values": `{
  376. "minSdkVersion": "30",
  377. }`,
  378. "sdk_version": `"30"`,
  379. }),
  380. }})
  381. }