java_test.go 65 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353
  1. // Copyright 2017 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. "os"
  18. "path/filepath"
  19. "reflect"
  20. "runtime"
  21. "strconv"
  22. "strings"
  23. "testing"
  24. "github.com/google/blueprint/proptools"
  25. "android/soong/android"
  26. "android/soong/cc"
  27. "android/soong/dexpreopt"
  28. "android/soong/genrule"
  29. )
  30. // Legacy preparer used for running tests within the java package.
  31. //
  32. // This includes everything that was needed to run any test in the java package prior to the
  33. // introduction of the test fixtures. Tests that are being converted to use fixtures directly
  34. // rather than through the testJava...() methods should avoid using this and instead use the
  35. // various preparers directly, using android.GroupFixturePreparers(...) to group them when
  36. // necessary.
  37. //
  38. // deprecated
  39. var prepareForJavaTest = android.GroupFixturePreparers(
  40. genrule.PrepareForTestWithGenRuleBuildComponents,
  41. // Get the CC build components but not default modules.
  42. cc.PrepareForTestWithCcBuildComponents,
  43. // Include all the default java modules.
  44. PrepareForTestWithDexpreopt,
  45. PrepareForTestWithOverlayBuildComponents,
  46. android.FixtureRegisterWithContext(func(ctx android.RegistrationContext) {
  47. ctx.RegisterPreSingletonType("sdk_versions", sdkPreSingletonFactory)
  48. }),
  49. )
  50. func TestMain(m *testing.M) {
  51. os.Exit(m.Run())
  52. }
  53. // testJavaError is a legacy way of running tests of java modules that expect errors.
  54. //
  55. // See testJava for an explanation as to how to stop using this deprecated method.
  56. //
  57. // deprecated
  58. func testJavaError(t *testing.T, pattern string, bp string) (*android.TestContext, android.Config) {
  59. t.Helper()
  60. result := android.GroupFixturePreparers(
  61. prepareForJavaTest, dexpreopt.PrepareForTestByEnablingDexpreopt).
  62. ExtendWithErrorHandler(android.FixtureExpectsAtLeastOneErrorMatchingPattern(pattern)).
  63. RunTestWithBp(t, bp)
  64. return result.TestContext, result.Config
  65. }
  66. // testJavaWithFS runs tests using the prepareForJavaTest
  67. //
  68. // See testJava for an explanation as to how to stop using this deprecated method.
  69. //
  70. // deprecated
  71. func testJavaWithFS(t *testing.T, bp string, fs android.MockFS) (*android.TestContext, android.Config) {
  72. t.Helper()
  73. result := android.GroupFixturePreparers(
  74. prepareForJavaTest, fs.AddToFixture()).RunTestWithBp(t, bp)
  75. return result.TestContext, result.Config
  76. }
  77. // testJava runs tests using the prepareForJavaTest
  78. //
  79. // Do not add any new usages of this, instead use the prepareForJavaTest directly as it makes it
  80. // much easier to customize the test behavior.
  81. //
  82. // If it is necessary to customize the behavior of an existing test that uses this then please first
  83. // convert the test to using prepareForJavaTest first and then in a following change add the
  84. // appropriate fixture preparers. Keeping the conversion change separate makes it easy to verify
  85. // that it did not change the test behavior unexpectedly.
  86. //
  87. // deprecated
  88. func testJava(t *testing.T, bp string) (*android.TestContext, android.Config) {
  89. t.Helper()
  90. result := prepareForJavaTest.RunTestWithBp(t, bp)
  91. return result.TestContext, result.Config
  92. }
  93. // defaultModuleToPath constructs a path to the turbine generate jar for a default test module that
  94. // is defined in PrepareForIntegrationTestWithJava
  95. func defaultModuleToPath(name string) string {
  96. switch {
  97. case name == `""`:
  98. return name
  99. case strings.HasSuffix(name, ".jar"):
  100. return name
  101. default:
  102. return filepath.Join("out", "soong", ".intermediates", defaultJavaDir, name, "android_common", "turbine-combined", name+".jar")
  103. }
  104. }
  105. // Test that the PrepareForTestWithJavaDefaultModules provides all the files that it uses by
  106. // running it in a fixture that requires all source files to exist.
  107. func TestPrepareForTestWithJavaDefaultModules(t *testing.T) {
  108. android.GroupFixturePreparers(
  109. PrepareForTestWithJavaDefaultModules,
  110. android.PrepareForTestDisallowNonExistentPaths,
  111. ).RunTest(t)
  112. }
  113. func TestJavaLinkType(t *testing.T) {
  114. testJava(t, `
  115. java_library {
  116. name: "foo",
  117. srcs: ["a.java"],
  118. libs: ["bar"],
  119. static_libs: ["baz"],
  120. }
  121. java_library {
  122. name: "bar",
  123. sdk_version: "current",
  124. srcs: ["b.java"],
  125. }
  126. java_library {
  127. name: "baz",
  128. sdk_version: "system_current",
  129. srcs: ["c.java"],
  130. }
  131. `)
  132. testJavaError(t, "consider adjusting sdk_version: OR platform_apis:", `
  133. java_library {
  134. name: "foo",
  135. srcs: ["a.java"],
  136. libs: ["bar"],
  137. sdk_version: "current",
  138. static_libs: ["baz"],
  139. }
  140. java_library {
  141. name: "bar",
  142. sdk_version: "current",
  143. srcs: ["b.java"],
  144. }
  145. java_library {
  146. name: "baz",
  147. sdk_version: "system_current",
  148. srcs: ["c.java"],
  149. }
  150. `)
  151. testJava(t, `
  152. java_library {
  153. name: "foo",
  154. srcs: ["a.java"],
  155. libs: ["bar"],
  156. sdk_version: "system_current",
  157. static_libs: ["baz"],
  158. }
  159. java_library {
  160. name: "bar",
  161. sdk_version: "current",
  162. srcs: ["b.java"],
  163. }
  164. java_library {
  165. name: "baz",
  166. sdk_version: "system_current",
  167. srcs: ["c.java"],
  168. }
  169. `)
  170. testJavaError(t, "consider adjusting sdk_version: OR platform_apis:", `
  171. java_library {
  172. name: "foo",
  173. srcs: ["a.java"],
  174. libs: ["bar"],
  175. sdk_version: "system_current",
  176. static_libs: ["baz"],
  177. }
  178. java_library {
  179. name: "bar",
  180. sdk_version: "current",
  181. srcs: ["b.java"],
  182. }
  183. java_library {
  184. name: "baz",
  185. srcs: ["c.java"],
  186. }
  187. `)
  188. }
  189. func TestSimple(t *testing.T) {
  190. ctx, _ := testJava(t, `
  191. java_library {
  192. name: "foo",
  193. srcs: ["a.java"],
  194. libs: ["bar"],
  195. static_libs: ["baz"],
  196. }
  197. java_library {
  198. name: "bar",
  199. srcs: ["b.java"],
  200. }
  201. java_library {
  202. name: "baz",
  203. srcs: ["c.java"],
  204. }
  205. `)
  206. javac := ctx.ModuleForTests("foo", "android_common").Rule("javac")
  207. combineJar := ctx.ModuleForTests("foo", "android_common").Description("for javac")
  208. if len(javac.Inputs) != 1 || javac.Inputs[0].String() != "a.java" {
  209. t.Errorf(`foo inputs %v != ["a.java"]`, javac.Inputs)
  210. }
  211. baz := ctx.ModuleForTests("baz", "android_common").Rule("javac").Output.String()
  212. barTurbine := filepath.Join("out", "soong", ".intermediates", "bar", "android_common", "turbine-combined", "bar.jar")
  213. bazTurbine := filepath.Join("out", "soong", ".intermediates", "baz", "android_common", "turbine-combined", "baz.jar")
  214. android.AssertStringDoesContain(t, "foo classpath", javac.Args["classpath"], barTurbine)
  215. android.AssertStringDoesContain(t, "foo classpath", javac.Args["classpath"], bazTurbine)
  216. if len(combineJar.Inputs) != 2 || combineJar.Inputs[1].String() != baz {
  217. t.Errorf("foo combineJar inputs %v does not contain %q", combineJar.Inputs, baz)
  218. }
  219. }
  220. func TestExportedPlugins(t *testing.T) {
  221. type Result struct {
  222. library string
  223. processors string
  224. disableTurbine bool
  225. }
  226. var tests = []struct {
  227. name string
  228. extra string
  229. results []Result
  230. }{
  231. {
  232. name: "Exported plugin is not a direct plugin",
  233. extra: `java_library { name: "exports", srcs: ["a.java"], exported_plugins: ["plugin"] }`,
  234. results: []Result{{library: "exports", processors: "-proc:none"}},
  235. },
  236. {
  237. name: "Exports plugin to dependee",
  238. extra: `
  239. java_library{name: "exports", exported_plugins: ["plugin"]}
  240. java_library{name: "foo", srcs: ["a.java"], libs: ["exports"]}
  241. java_library{name: "bar", srcs: ["a.java"], static_libs: ["exports"]}
  242. `,
  243. results: []Result{
  244. {library: "foo", processors: "-processor com.android.TestPlugin"},
  245. {library: "bar", processors: "-processor com.android.TestPlugin"},
  246. },
  247. },
  248. {
  249. name: "Exports plugin to android_library",
  250. extra: `
  251. java_library{name: "exports", exported_plugins: ["plugin"]}
  252. android_library{name: "foo", srcs: ["a.java"], libs: ["exports"]}
  253. android_library{name: "bar", srcs: ["a.java"], static_libs: ["exports"]}
  254. `,
  255. results: []Result{
  256. {library: "foo", processors: "-processor com.android.TestPlugin"},
  257. {library: "bar", processors: "-processor com.android.TestPlugin"},
  258. },
  259. },
  260. {
  261. name: "Exports plugin is not propagated via transitive deps",
  262. extra: `
  263. java_library{name: "exports", exported_plugins: ["plugin"]}
  264. java_library{name: "foo", srcs: ["a.java"], libs: ["exports"]}
  265. java_library{name: "bar", srcs: ["a.java"], static_libs: ["foo"]}
  266. `,
  267. results: []Result{
  268. {library: "foo", processors: "-processor com.android.TestPlugin"},
  269. {library: "bar", processors: "-proc:none"},
  270. },
  271. },
  272. {
  273. name: "Exports plugin appends to plugins",
  274. extra: `
  275. java_plugin{name: "plugin2", processor_class: "com.android.TestPlugin2"}
  276. java_library{name: "exports", exported_plugins: ["plugin"]}
  277. java_library{name: "foo", srcs: ["a.java"], libs: ["exports"], plugins: ["plugin2"]}
  278. `,
  279. results: []Result{
  280. {library: "foo", processors: "-processor com.android.TestPlugin,com.android.TestPlugin2"},
  281. },
  282. },
  283. {
  284. name: "Exports plugin to with generates_api to dependee",
  285. extra: `
  286. java_library{name: "exports", exported_plugins: ["plugin_generates_api"]}
  287. java_library{name: "foo", srcs: ["a.java"], libs: ["exports"]}
  288. java_library{name: "bar", srcs: ["a.java"], static_libs: ["exports"]}
  289. `,
  290. results: []Result{
  291. {library: "foo", processors: "-processor com.android.TestPlugin", disableTurbine: true},
  292. {library: "bar", processors: "-processor com.android.TestPlugin", disableTurbine: true},
  293. },
  294. },
  295. }
  296. for _, test := range tests {
  297. t.Run(test.name, func(t *testing.T) {
  298. ctx, _ := testJava(t, `
  299. java_plugin {
  300. name: "plugin",
  301. processor_class: "com.android.TestPlugin",
  302. }
  303. java_plugin {
  304. name: "plugin_generates_api",
  305. generates_api: true,
  306. processor_class: "com.android.TestPlugin",
  307. }
  308. `+test.extra)
  309. for _, want := range test.results {
  310. javac := ctx.ModuleForTests(want.library, "android_common").Rule("javac")
  311. if javac.Args["processor"] != want.processors {
  312. t.Errorf("For library %v, expected %v, found %v", want.library, want.processors, javac.Args["processor"])
  313. }
  314. turbine := ctx.ModuleForTests(want.library, "android_common").MaybeRule("turbine")
  315. disableTurbine := turbine.BuildParams.Rule == nil
  316. if disableTurbine != want.disableTurbine {
  317. t.Errorf("For library %v, expected disableTurbine %v, found %v", want.library, want.disableTurbine, disableTurbine)
  318. }
  319. }
  320. })
  321. }
  322. }
  323. func TestSdkVersionByPartition(t *testing.T) {
  324. testJavaError(t, "sdk_version must have a value when the module is located at vendor or product", `
  325. java_library {
  326. name: "foo",
  327. srcs: ["a.java"],
  328. vendor: true,
  329. }
  330. `)
  331. testJava(t, `
  332. java_library {
  333. name: "bar",
  334. srcs: ["b.java"],
  335. }
  336. `)
  337. for _, enforce := range []bool{true, false} {
  338. bp := `
  339. java_library {
  340. name: "foo",
  341. srcs: ["a.java"],
  342. product_specific: true,
  343. }
  344. `
  345. errorHandler := android.FixtureExpectsNoErrors
  346. if enforce {
  347. errorHandler = android.FixtureExpectsAtLeastOneErrorMatchingPattern("sdk_version must have a value when the module is located at vendor or product")
  348. }
  349. android.GroupFixturePreparers(
  350. PrepareForTestWithJavaDefaultModules,
  351. android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
  352. variables.EnforceProductPartitionInterface = proptools.BoolPtr(enforce)
  353. }),
  354. ).
  355. ExtendWithErrorHandler(errorHandler).
  356. RunTestWithBp(t, bp)
  357. }
  358. }
  359. func TestArchSpecific(t *testing.T) {
  360. ctx, _ := testJava(t, `
  361. java_library {
  362. name: "foo",
  363. srcs: ["a.java"],
  364. target: {
  365. android: {
  366. srcs: ["b.java"],
  367. },
  368. },
  369. }
  370. `)
  371. javac := ctx.ModuleForTests("foo", "android_common").Rule("javac")
  372. if len(javac.Inputs) != 2 || javac.Inputs[0].String() != "a.java" || javac.Inputs[1].String() != "b.java" {
  373. t.Errorf(`foo inputs %v != ["a.java", "b.java"]`, javac.Inputs)
  374. }
  375. }
  376. func TestBinary(t *testing.T) {
  377. ctx, _ := testJava(t, `
  378. java_library_host {
  379. name: "foo",
  380. srcs: ["a.java"],
  381. }
  382. java_binary_host {
  383. name: "bar",
  384. srcs: ["b.java"],
  385. static_libs: ["foo"],
  386. jni_libs: ["libjni"],
  387. }
  388. cc_library_shared {
  389. name: "libjni",
  390. host_supported: true,
  391. device_supported: false,
  392. stl: "none",
  393. }
  394. `)
  395. buildOS := ctx.Config().BuildOS.String()
  396. bar := ctx.ModuleForTests("bar", buildOS+"_common")
  397. barJar := bar.Output("bar.jar").Output.String()
  398. barWrapper := ctx.ModuleForTests("bar", buildOS+"_x86_64")
  399. barWrapperDeps := barWrapper.Output("bar").Implicits.Strings()
  400. libjni := ctx.ModuleForTests("libjni", buildOS+"_x86_64_shared")
  401. libjniSO := libjni.Rule("Cp").Output.String()
  402. // Test that the install binary wrapper depends on the installed jar file
  403. if g, w := barWrapperDeps, barJar; !android.InList(w, g) {
  404. t.Errorf("expected binary wrapper implicits to contain %q, got %q", w, g)
  405. }
  406. // Test that the install binary wrapper depends on the installed JNI libraries
  407. if g, w := barWrapperDeps, libjniSO; !android.InList(w, g) {
  408. t.Errorf("expected binary wrapper implicits to contain %q, got %q", w, g)
  409. }
  410. }
  411. func TestTest(t *testing.T) {
  412. ctx, _ := testJava(t, `
  413. java_test_host {
  414. name: "foo",
  415. srcs: ["a.java"],
  416. jni_libs: ["libjni"],
  417. }
  418. cc_library_shared {
  419. name: "libjni",
  420. host_supported: true,
  421. device_supported: false,
  422. stl: "none",
  423. }
  424. `)
  425. buildOS := ctx.Config().BuildOS.String()
  426. foo := ctx.ModuleForTests("foo", buildOS+"_common").Module().(*TestHost)
  427. expected := "lib64/libjni.so"
  428. if runtime.GOOS == "darwin" {
  429. expected = "lib64/libjni.dylib"
  430. }
  431. fooTestData := foo.data
  432. if len(fooTestData) != 1 || fooTestData[0].Rel() != expected {
  433. t.Errorf(`expected foo test data relative path [%q], got %q`,
  434. expected, fooTestData.Strings())
  435. }
  436. }
  437. func TestHostBinaryNoJavaDebugInfoOverride(t *testing.T) {
  438. bp := `
  439. java_library {
  440. name: "target_library",
  441. srcs: ["a.java"],
  442. }
  443. java_binary_host {
  444. name: "host_binary",
  445. srcs: ["b.java"],
  446. }
  447. `
  448. result := android.GroupFixturePreparers(
  449. PrepareForTestWithJavaDefaultModules,
  450. android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
  451. variables.MinimizeJavaDebugInfo = proptools.BoolPtr(true)
  452. }),
  453. ).RunTestWithBp(t, bp)
  454. // first, check that the -g flag is added to target modules
  455. targetLibrary := result.ModuleForTests("target_library", "android_common")
  456. targetJavaFlags := targetLibrary.Module().VariablesForTests()["javacFlags"]
  457. if !strings.Contains(targetJavaFlags, "-g:source,lines") {
  458. t.Errorf("target library javac flags %v should contain "+
  459. "-g:source,lines override with MinimizeJavaDebugInfo", targetJavaFlags)
  460. }
  461. // check that -g is not overridden for host modules
  462. buildOS := result.Config.BuildOS.String()
  463. hostBinary := result.ModuleForTests("host_binary", buildOS+"_common")
  464. hostJavaFlags := hostBinary.Module().VariablesForTests()["javacFlags"]
  465. if strings.Contains(hostJavaFlags, "-g:source,lines") {
  466. t.Errorf("java_binary_host javac flags %v should not have "+
  467. "-g:source,lines override with MinimizeJavaDebugInfo", hostJavaFlags)
  468. }
  469. }
  470. func TestPrebuilts(t *testing.T) {
  471. ctx, _ := testJava(t, `
  472. java_library {
  473. name: "foo",
  474. srcs: ["a.java", ":stubs-source"],
  475. libs: ["bar", "sdklib"],
  476. static_libs: ["baz"],
  477. }
  478. java_import {
  479. name: "bar",
  480. jars: ["a.jar"],
  481. }
  482. java_import {
  483. name: "baz",
  484. jars: ["b.jar"],
  485. sdk_version: "current",
  486. compile_dex: true,
  487. }
  488. dex_import {
  489. name: "qux",
  490. jars: ["b.jar"],
  491. }
  492. java_sdk_library_import {
  493. name: "sdklib",
  494. public: {
  495. jars: ["c.jar"],
  496. },
  497. }
  498. prebuilt_stubs_sources {
  499. name: "stubs-source",
  500. srcs: ["stubs/sources"],
  501. }
  502. java_test_import {
  503. name: "test",
  504. jars: ["a.jar"],
  505. test_suites: ["cts"],
  506. test_config: "AndroidTest.xml",
  507. }
  508. `)
  509. fooModule := ctx.ModuleForTests("foo", "android_common")
  510. javac := fooModule.Rule("javac")
  511. combineJar := ctx.ModuleForTests("foo", "android_common").Description("for javac")
  512. barModule := ctx.ModuleForTests("bar", "android_common")
  513. barJar := barModule.Rule("combineJar").Output
  514. bazModule := ctx.ModuleForTests("baz", "android_common")
  515. bazJar := bazModule.Rule("combineJar").Output
  516. sdklibStubsJar := ctx.ModuleForTests("sdklib.stubs", "android_common").Rule("combineJar").Output
  517. fooLibrary := fooModule.Module().(*Library)
  518. assertDeepEquals(t, "foo unique sources incorrect",
  519. []string{"a.java"}, fooLibrary.uniqueSrcFiles.Strings())
  520. assertDeepEquals(t, "foo java source jars incorrect",
  521. []string{".intermediates/stubs-source/android_common/stubs-source-stubs.srcjar"},
  522. android.NormalizePathsForTesting(fooLibrary.compiledSrcJars))
  523. if !strings.Contains(javac.Args["classpath"], barJar.String()) {
  524. t.Errorf("foo classpath %v does not contain %q", javac.Args["classpath"], barJar.String())
  525. }
  526. barDexJar := barModule.Module().(*Import).DexJarBuildPath()
  527. if barDexJar.IsSet() {
  528. t.Errorf("bar dex jar build path expected to be set, got %s", barDexJar)
  529. }
  530. if !strings.Contains(javac.Args["classpath"], sdklibStubsJar.String()) {
  531. t.Errorf("foo classpath %v does not contain %q", javac.Args["classpath"], sdklibStubsJar.String())
  532. }
  533. if len(combineJar.Inputs) != 2 || combineJar.Inputs[1].String() != bazJar.String() {
  534. t.Errorf("foo combineJar inputs %v does not contain %q", combineJar.Inputs, bazJar.String())
  535. }
  536. bazDexJar := bazModule.Module().(*Import).DexJarBuildPath().Path()
  537. expectedDexJar := "out/soong/.intermediates/baz/android_common/dex/baz.jar"
  538. android.AssertPathRelativeToTopEquals(t, "baz dex jar build path", expectedDexJar, bazDexJar)
  539. ctx.ModuleForTests("qux", "android_common").Rule("Cp")
  540. entries := android.AndroidMkEntriesForTest(t, ctx, fooModule.Module())[0]
  541. android.AssertStringEquals(t, "unexpected LOCAL_SOONG_MODULE_TYPE", "java_library", entries.EntryMap["LOCAL_SOONG_MODULE_TYPE"][0])
  542. entries = android.AndroidMkEntriesForTest(t, ctx, barModule.Module())[0]
  543. android.AssertStringEquals(t, "unexpected LOCAL_SOONG_MODULE_TYPE", "java_import", entries.EntryMap["LOCAL_SOONG_MODULE_TYPE"][0])
  544. entries = android.AndroidMkEntriesForTest(t, ctx, ctx.ModuleForTests("sdklib", "android_common").Module())[0]
  545. android.AssertStringEquals(t, "unexpected LOCAL_SOONG_MODULE_TYPE", "java_sdk_library_import", entries.EntryMap["LOCAL_SOONG_MODULE_TYPE"][0])
  546. }
  547. func assertDeepEquals(t *testing.T, message string, expected interface{}, actual interface{}) {
  548. if !reflect.DeepEqual(expected, actual) {
  549. t.Errorf("%s: expected %q, found %q", message, expected, actual)
  550. }
  551. }
  552. func TestPrebuiltStubsSources(t *testing.T) {
  553. test := func(t *testing.T, sourcesPath string, expectedInputs []string) {
  554. ctx, _ := testJavaWithFS(t, fmt.Sprintf(`
  555. prebuilt_stubs_sources {
  556. name: "stubs-source",
  557. srcs: ["%s"],
  558. }`, sourcesPath), map[string][]byte{
  559. "stubs/sources/pkg/A.java": nil,
  560. "stubs/sources/pkg/B.java": nil,
  561. })
  562. zipSrc := ctx.ModuleForTests("stubs-source", "android_common").Rule("zip_src")
  563. if expected, actual := expectedInputs, zipSrc.Inputs.Strings(); !reflect.DeepEqual(expected, actual) {
  564. t.Errorf("mismatch of inputs to soong_zip: expected %q, actual %q", expected, actual)
  565. }
  566. }
  567. t.Run("empty/missing directory", func(t *testing.T) {
  568. test(t, "empty-directory", nil)
  569. })
  570. t.Run("non-empty set of sources", func(t *testing.T) {
  571. test(t, "stubs/sources", []string{
  572. "stubs/sources/pkg/A.java",
  573. "stubs/sources/pkg/B.java",
  574. })
  575. })
  576. }
  577. func TestDefaults(t *testing.T) {
  578. ctx, _ := testJava(t, `
  579. java_defaults {
  580. name: "defaults",
  581. srcs: ["a.java"],
  582. libs: ["bar"],
  583. static_libs: ["baz"],
  584. optimize: {enabled: false},
  585. }
  586. java_library {
  587. name: "foo",
  588. defaults: ["defaults"],
  589. }
  590. java_library {
  591. name: "bar",
  592. srcs: ["b.java"],
  593. }
  594. java_library {
  595. name: "baz",
  596. srcs: ["c.java"],
  597. }
  598. android_test {
  599. name: "atestOptimize",
  600. defaults: ["defaults"],
  601. optimize: {enabled: true},
  602. }
  603. android_test {
  604. name: "atestNoOptimize",
  605. defaults: ["defaults"],
  606. }
  607. android_test {
  608. name: "atestDefault",
  609. srcs: ["a.java"],
  610. }
  611. `)
  612. javac := ctx.ModuleForTests("foo", "android_common").Rule("javac")
  613. combineJar := ctx.ModuleForTests("foo", "android_common").Description("for javac")
  614. if len(javac.Inputs) != 1 || javac.Inputs[0].String() != "a.java" {
  615. t.Errorf(`foo inputs %v != ["a.java"]`, javac.Inputs)
  616. }
  617. barTurbine := filepath.Join("out", "soong", ".intermediates", "bar", "android_common", "turbine-combined", "bar.jar")
  618. if !strings.Contains(javac.Args["classpath"], barTurbine) {
  619. t.Errorf("foo classpath %v does not contain %q", javac.Args["classpath"], barTurbine)
  620. }
  621. baz := ctx.ModuleForTests("baz", "android_common").Rule("javac").Output.String()
  622. if len(combineJar.Inputs) != 2 || combineJar.Inputs[1].String() != baz {
  623. t.Errorf("foo combineJar inputs %v does not contain %q", combineJar.Inputs, baz)
  624. }
  625. atestOptimize := ctx.ModuleForTests("atestOptimize", "android_common").MaybeRule("r8")
  626. if atestOptimize.Output == nil {
  627. t.Errorf("atestOptimize should optimize APK")
  628. }
  629. atestNoOptimize := ctx.ModuleForTests("atestNoOptimize", "android_common").MaybeRule("d8")
  630. if atestNoOptimize.Output == nil {
  631. t.Errorf("atestNoOptimize should not optimize APK")
  632. }
  633. atestDefault := ctx.ModuleForTests("atestDefault", "android_common").MaybeRule("d8")
  634. if atestDefault.Output == nil {
  635. t.Errorf("atestDefault should not optimize APK")
  636. }
  637. }
  638. func TestResources(t *testing.T) {
  639. var table = []struct {
  640. name string
  641. prop string
  642. extra string
  643. args string
  644. }{
  645. {
  646. // Test that a module with java_resource_dirs includes the files
  647. name: "resource dirs",
  648. prop: `java_resource_dirs: ["java-res"]`,
  649. args: "-C java-res -f java-res/a/a -f java-res/b/b",
  650. },
  651. {
  652. // Test that a module with java_resources includes the files
  653. name: "resource files",
  654. prop: `java_resources: ["java-res/a/a", "java-res/b/b"]`,
  655. args: "-C . -f java-res/a/a -f java-res/b/b",
  656. },
  657. {
  658. // Test that a module with a filegroup in java_resources includes the files with the
  659. // path prefix
  660. name: "resource filegroup",
  661. prop: `java_resources: [":foo-res"]`,
  662. extra: `
  663. filegroup {
  664. name: "foo-res",
  665. path: "java-res",
  666. srcs: ["java-res/a/a", "java-res/b/b"],
  667. }`,
  668. args: "-C java-res -f java-res/a/a -f java-res/b/b",
  669. },
  670. {
  671. // Test that a module with wildcards in java_resource_dirs has the correct path prefixes
  672. name: "wildcard dirs",
  673. prop: `java_resource_dirs: ["java-res/*"]`,
  674. args: "-C java-res/a -f java-res/a/a -C java-res/b -f java-res/b/b",
  675. },
  676. {
  677. // Test that a module exclude_java_resource_dirs excludes the files
  678. name: "wildcard dirs",
  679. prop: `java_resource_dirs: ["java-res/*"], exclude_java_resource_dirs: ["java-res/b"]`,
  680. args: "-C java-res/a -f java-res/a/a",
  681. },
  682. {
  683. // Test wildcards in java_resources
  684. name: "wildcard files",
  685. prop: `java_resources: ["java-res/**/*"]`,
  686. args: "-C . -f java-res/a/a -f java-res/b/b",
  687. },
  688. {
  689. // Test exclude_java_resources with java_resources
  690. name: "wildcard files with exclude",
  691. prop: `java_resources: ["java-res/**/*"], exclude_java_resources: ["java-res/b/*"]`,
  692. args: "-C . -f java-res/a/a",
  693. },
  694. {
  695. // Test exclude_java_resources with java_resource_dirs
  696. name: "resource dirs with exclude files",
  697. prop: `java_resource_dirs: ["java-res"], exclude_java_resources: ["java-res/b/b"]`,
  698. args: "-C java-res -f java-res/a/a",
  699. },
  700. {
  701. // Test exclude_java_resource_dirs with java_resource_dirs
  702. name: "resource dirs with exclude files",
  703. prop: `java_resource_dirs: ["java-res", "java-res2"], exclude_java_resource_dirs: ["java-res2"]`,
  704. args: "-C java-res -f java-res/a/a -f java-res/b/b",
  705. },
  706. }
  707. for _, test := range table {
  708. t.Run(test.name, func(t *testing.T) {
  709. ctx, _ := testJavaWithFS(t, `
  710. java_library {
  711. name: "foo",
  712. srcs: [
  713. "a.java",
  714. "b.java",
  715. "c.java",
  716. ],
  717. `+test.prop+`,
  718. }
  719. `+test.extra,
  720. map[string][]byte{
  721. "java-res/a/a": nil,
  722. "java-res/b/b": nil,
  723. "java-res2/a": nil,
  724. },
  725. )
  726. foo := ctx.ModuleForTests("foo", "android_common").Output("withres/foo.jar")
  727. fooRes := ctx.ModuleForTests("foo", "android_common").Output("res/foo.jar")
  728. if !inList(fooRes.Output.String(), foo.Inputs.Strings()) {
  729. t.Errorf("foo combined jars %v does not contain %q",
  730. foo.Inputs.Strings(), fooRes.Output.String())
  731. }
  732. if fooRes.Args["jarArgs"] != test.args {
  733. t.Errorf("foo resource jar args %q is not %q",
  734. fooRes.Args["jarArgs"], test.args)
  735. }
  736. })
  737. }
  738. }
  739. func TestIncludeSrcs(t *testing.T) {
  740. ctx, _ := testJavaWithFS(t, `
  741. java_library {
  742. name: "foo",
  743. srcs: [
  744. "a.java",
  745. "b.java",
  746. "c.java",
  747. ],
  748. include_srcs: true,
  749. }
  750. java_library {
  751. name: "bar",
  752. srcs: [
  753. "a.java",
  754. "b.java",
  755. "c.java",
  756. ],
  757. java_resource_dirs: ["java-res"],
  758. include_srcs: true,
  759. }
  760. `, map[string][]byte{
  761. "java-res/a/a": nil,
  762. "java-res/b/b": nil,
  763. "java-res2/a": nil,
  764. })
  765. // Test a library with include_srcs: true
  766. foo := ctx.ModuleForTests("foo", "android_common").Output("withres/foo.jar")
  767. fooSrcJar := ctx.ModuleForTests("foo", "android_common").Output("foo.srcjar")
  768. if g, w := fooSrcJar.Output.String(), foo.Inputs.Strings(); !inList(g, w) {
  769. t.Errorf("foo combined jars %v does not contain %q", w, g)
  770. }
  771. if g, w := fooSrcJar.Args["jarArgs"], "-C . -f a.java -f b.java -f c.java"; g != w {
  772. t.Errorf("foo source jar args %q is not %q", w, g)
  773. }
  774. // Test a library with include_srcs: true and resources
  775. bar := ctx.ModuleForTests("bar", "android_common").Output("withres/bar.jar")
  776. barResCombined := ctx.ModuleForTests("bar", "android_common").Output("res-combined/bar.jar")
  777. barRes := ctx.ModuleForTests("bar", "android_common").Output("res/bar.jar")
  778. barSrcJar := ctx.ModuleForTests("bar", "android_common").Output("bar.srcjar")
  779. if g, w := barSrcJar.Output.String(), barResCombined.Inputs.Strings(); !inList(g, w) {
  780. t.Errorf("bar combined resource jars %v does not contain %q", w, g)
  781. }
  782. if g, w := barRes.Output.String(), barResCombined.Inputs.Strings(); !inList(g, w) {
  783. t.Errorf("bar combined resource jars %v does not contain %q", w, g)
  784. }
  785. if g, w := barResCombined.Output.String(), bar.Inputs.Strings(); !inList(g, w) {
  786. t.Errorf("bar combined jars %v does not contain %q", w, g)
  787. }
  788. if g, w := barSrcJar.Args["jarArgs"], "-C . -f a.java -f b.java -f c.java"; g != w {
  789. t.Errorf("bar source jar args %q is not %q", w, g)
  790. }
  791. if g, w := barRes.Args["jarArgs"], "-C java-res -f java-res/a/a -f java-res/b/b"; g != w {
  792. t.Errorf("bar resource jar args %q is not %q", w, g)
  793. }
  794. }
  795. func TestGeneratedSources(t *testing.T) {
  796. ctx, _ := testJavaWithFS(t, `
  797. java_library {
  798. name: "foo",
  799. srcs: [
  800. "a*.java",
  801. ":gen",
  802. "b*.java",
  803. ],
  804. }
  805. genrule {
  806. name: "gen",
  807. tool_files: ["java-res/a"],
  808. out: ["gen.java"],
  809. }
  810. `, map[string][]byte{
  811. "a.java": nil,
  812. "b.java": nil,
  813. })
  814. javac := ctx.ModuleForTests("foo", "android_common").Rule("javac")
  815. genrule := ctx.ModuleForTests("gen", "").Rule("generator")
  816. if filepath.Base(genrule.Output.String()) != "gen.java" {
  817. t.Fatalf(`gen output file %v is not ".../gen.java"`, genrule.Output.String())
  818. }
  819. if len(javac.Inputs) != 3 ||
  820. javac.Inputs[0].String() != "a.java" ||
  821. javac.Inputs[1].String() != genrule.Output.String() ||
  822. javac.Inputs[2].String() != "b.java" {
  823. t.Errorf(`foo inputs %v != ["a.java", ".../gen.java", "b.java"]`, javac.Inputs)
  824. }
  825. }
  826. func TestTurbine(t *testing.T) {
  827. result := android.GroupFixturePreparers(
  828. prepareForJavaTest, FixtureWithPrebuiltApis(map[string][]string{"14": {"foo"}})).
  829. RunTestWithBp(t, `
  830. java_library {
  831. name: "foo",
  832. srcs: ["a.java"],
  833. sdk_version: "14",
  834. }
  835. java_library {
  836. name: "bar",
  837. srcs: ["b.java"],
  838. static_libs: ["foo"],
  839. sdk_version: "14",
  840. }
  841. java_library {
  842. name: "baz",
  843. srcs: ["c.java"],
  844. libs: ["bar"],
  845. sdk_version: "14",
  846. }
  847. `)
  848. fooTurbine := result.ModuleForTests("foo", "android_common").Rule("turbine")
  849. barTurbine := result.ModuleForTests("bar", "android_common").Rule("turbine")
  850. barJavac := result.ModuleForTests("bar", "android_common").Rule("javac")
  851. barTurbineCombined := result.ModuleForTests("bar", "android_common").Description("for turbine")
  852. bazJavac := result.ModuleForTests("baz", "android_common").Rule("javac")
  853. android.AssertPathsRelativeToTopEquals(t, "foo inputs", []string{"a.java"}, fooTurbine.Inputs)
  854. fooHeaderJar := filepath.Join("out", "soong", ".intermediates", "foo", "android_common", "turbine-combined", "foo.jar")
  855. barTurbineJar := filepath.Join("out", "soong", ".intermediates", "bar", "android_common", "turbine", "bar.jar")
  856. android.AssertStringDoesContain(t, "bar turbine classpath", barTurbine.Args["turbineFlags"], fooHeaderJar)
  857. android.AssertStringDoesContain(t, "bar javac classpath", barJavac.Args["classpath"], fooHeaderJar)
  858. android.AssertPathsRelativeToTopEquals(t, "bar turbine combineJar", []string{barTurbineJar, fooHeaderJar}, barTurbineCombined.Inputs)
  859. android.AssertStringDoesContain(t, "baz javac classpath", bazJavac.Args["classpath"], "prebuilts/sdk/14/public/android.jar")
  860. }
  861. func TestSharding(t *testing.T) {
  862. ctx, _ := testJava(t, `
  863. java_library {
  864. name: "bar",
  865. srcs: ["a.java","b.java","c.java"],
  866. javac_shard_size: 1
  867. }
  868. `)
  869. barHeaderJar := filepath.Join("out", "soong", ".intermediates", "bar", "android_common", "turbine", "bar.jar")
  870. for i := 0; i < 3; i++ {
  871. barJavac := ctx.ModuleForTests("bar", "android_common").Description("javac" + strconv.Itoa(i))
  872. if !strings.HasPrefix(barJavac.Args["classpath"], "-classpath "+barHeaderJar+":") {
  873. t.Errorf("bar javac classpath %v does start with %q", barJavac.Args["classpath"], barHeaderJar)
  874. }
  875. }
  876. }
  877. func TestExcludeFileGroupInSrcs(t *testing.T) {
  878. ctx, _ := testJava(t, `
  879. java_library {
  880. name: "foo",
  881. srcs: ["a.java", ":foo-srcs"],
  882. exclude_srcs: ["a.java", ":foo-excludes"],
  883. }
  884. filegroup {
  885. name: "foo-srcs",
  886. srcs: ["java-fg/a.java", "java-fg/b.java", "java-fg/c.java"],
  887. }
  888. filegroup {
  889. name: "foo-excludes",
  890. srcs: ["java-fg/a.java", "java-fg/b.java"],
  891. }
  892. `)
  893. javac := ctx.ModuleForTests("foo", "android_common").Rule("javac")
  894. if len(javac.Inputs) != 1 || javac.Inputs[0].String() != "java-fg/c.java" {
  895. t.Errorf(`foo inputs %v != ["java-fg/c.java"]`, javac.Inputs)
  896. }
  897. }
  898. func TestJavaLibrary(t *testing.T) {
  899. testJavaWithFS(t, "", map[string][]byte{
  900. "libcore/Android.bp": []byte(`
  901. java_library {
  902. name: "core",
  903. sdk_version: "none",
  904. system_modules: "none",
  905. }
  906. filegroup {
  907. name: "core-jar",
  908. srcs: [":core{.jar}"],
  909. }
  910. `),
  911. })
  912. }
  913. func TestJavaImport(t *testing.T) {
  914. testJavaWithFS(t, "", map[string][]byte{
  915. "libcore/Android.bp": []byte(`
  916. java_import {
  917. name: "core",
  918. sdk_version: "none",
  919. }
  920. filegroup {
  921. name: "core-jar",
  922. srcs: [":core{.jar}"],
  923. }
  924. `),
  925. })
  926. }
  927. var compilerFlagsTestCases = []struct {
  928. in string
  929. out bool
  930. }{
  931. {
  932. in: "a",
  933. out: false,
  934. },
  935. {
  936. in: "-a",
  937. out: true,
  938. },
  939. {
  940. in: "-no-jdk",
  941. out: false,
  942. },
  943. {
  944. in: "-no-stdlib",
  945. out: false,
  946. },
  947. {
  948. in: "-kotlin-home",
  949. out: false,
  950. },
  951. {
  952. in: "-kotlin-home /some/path",
  953. out: false,
  954. },
  955. {
  956. in: "-include-runtime",
  957. out: false,
  958. },
  959. {
  960. in: "-Xintellij-plugin-root",
  961. out: false,
  962. },
  963. }
  964. type mockContext struct {
  965. android.ModuleContext
  966. result bool
  967. }
  968. func (ctx *mockContext) PropertyErrorf(property, format string, args ...interface{}) {
  969. // CheckBadCompilerFlags calls this function when the flag should be rejected
  970. ctx.result = false
  971. }
  972. func TestCompilerFlags(t *testing.T) {
  973. for _, testCase := range compilerFlagsTestCases {
  974. ctx := &mockContext{result: true}
  975. CheckKotlincFlags(ctx, []string{testCase.in})
  976. if ctx.result != testCase.out {
  977. t.Errorf("incorrect output:")
  978. t.Errorf(" input: %#v", testCase.in)
  979. t.Errorf(" expected: %#v", testCase.out)
  980. t.Errorf(" got: %#v", ctx.result)
  981. }
  982. }
  983. }
  984. // TODO(jungjw): Consider making this more robust by ignoring path order.
  985. func checkPatchModuleFlag(t *testing.T, ctx *android.TestContext, moduleName string, expected string) {
  986. variables := ctx.ModuleForTests(moduleName, "android_common").VariablesForTestsRelativeToTop()
  987. flags := strings.Split(variables["javacFlags"], " ")
  988. got := ""
  989. for _, flag := range flags {
  990. keyEnd := strings.Index(flag, "=")
  991. if keyEnd > -1 && flag[:keyEnd] == "--patch-module" {
  992. got = flag[keyEnd+1:]
  993. break
  994. }
  995. }
  996. if expected != android.StringPathRelativeToTop(ctx.Config().SoongOutDir(), got) {
  997. t.Errorf("Unexpected patch-module flag for module %q - expected %q, but got %q", moduleName, expected, got)
  998. }
  999. }
  1000. func TestPatchModule(t *testing.T) {
  1001. t.Run("Java language level 8", func(t *testing.T) {
  1002. // Test with legacy javac -source 1.8 -target 1.8
  1003. bp := `
  1004. java_library {
  1005. name: "foo",
  1006. srcs: ["a.java"],
  1007. java_version: "1.8",
  1008. }
  1009. java_library {
  1010. name: "bar",
  1011. srcs: ["b.java"],
  1012. sdk_version: "none",
  1013. system_modules: "none",
  1014. patch_module: "java.base",
  1015. java_version: "1.8",
  1016. }
  1017. java_library {
  1018. name: "baz",
  1019. srcs: ["c.java"],
  1020. patch_module: "java.base",
  1021. java_version: "1.8",
  1022. }
  1023. `
  1024. ctx, _ := testJava(t, bp)
  1025. checkPatchModuleFlag(t, ctx, "foo", "")
  1026. checkPatchModuleFlag(t, ctx, "bar", "")
  1027. checkPatchModuleFlag(t, ctx, "baz", "")
  1028. })
  1029. t.Run("Java language level 9", func(t *testing.T) {
  1030. // Test with default javac -source 9 -target 9
  1031. bp := `
  1032. java_library {
  1033. name: "foo",
  1034. srcs: ["a.java"],
  1035. }
  1036. java_library {
  1037. name: "bar",
  1038. srcs: ["b.java"],
  1039. sdk_version: "none",
  1040. system_modules: "none",
  1041. patch_module: "java.base",
  1042. }
  1043. java_library {
  1044. name: "baz",
  1045. srcs: [
  1046. "c.java",
  1047. // Tests for b/150878007
  1048. "dir/d.java",
  1049. "dir2/e.java",
  1050. "dir2/f.java",
  1051. "nested/dir/g.java"
  1052. ],
  1053. patch_module: "java.base",
  1054. }
  1055. `
  1056. ctx, _ := testJava(t, bp)
  1057. checkPatchModuleFlag(t, ctx, "foo", "")
  1058. expected := "java.base=.:out/soong"
  1059. checkPatchModuleFlag(t, ctx, "bar", expected)
  1060. expected = "java.base=" + strings.Join([]string{
  1061. ".", "out/soong", "dir", "dir2", "nested", defaultModuleToPath("ext"), defaultModuleToPath("framework")}, ":")
  1062. checkPatchModuleFlag(t, ctx, "baz", expected)
  1063. })
  1064. }
  1065. func TestJavaLibraryWithSystemModules(t *testing.T) {
  1066. ctx, _ := testJava(t, `
  1067. java_library {
  1068. name: "lib-with-source-system-modules",
  1069. srcs: [
  1070. "a.java",
  1071. ],
  1072. sdk_version: "none",
  1073. system_modules: "source-system-modules",
  1074. }
  1075. java_library {
  1076. name: "source-jar",
  1077. srcs: [
  1078. "a.java",
  1079. ],
  1080. }
  1081. java_system_modules {
  1082. name: "source-system-modules",
  1083. libs: ["source-jar"],
  1084. }
  1085. java_library {
  1086. name: "lib-with-prebuilt-system-modules",
  1087. srcs: [
  1088. "a.java",
  1089. ],
  1090. sdk_version: "none",
  1091. system_modules: "prebuilt-system-modules",
  1092. }
  1093. java_import {
  1094. name: "prebuilt-jar",
  1095. jars: ["a.jar"],
  1096. }
  1097. java_system_modules_import {
  1098. name: "prebuilt-system-modules",
  1099. libs: ["prebuilt-jar"],
  1100. }
  1101. `)
  1102. checkBootClasspathForSystemModule(t, ctx, "lib-with-source-system-modules", "/source-jar.jar")
  1103. checkBootClasspathForSystemModule(t, ctx, "lib-with-prebuilt-system-modules", "/prebuilt-jar.jar")
  1104. }
  1105. func checkBootClasspathForSystemModule(t *testing.T, ctx *android.TestContext, moduleName string, expectedSuffix string) {
  1106. javacRule := ctx.ModuleForTests(moduleName, "android_common").Rule("javac")
  1107. bootClasspath := javacRule.Args["bootClasspath"]
  1108. if strings.HasPrefix(bootClasspath, "--system ") && strings.HasSuffix(bootClasspath, expectedSuffix) {
  1109. t.Errorf("bootclasspath of %q must start with --system and end with %q, but was %#v.", moduleName, expectedSuffix, bootClasspath)
  1110. }
  1111. }
  1112. func TestAidlExportIncludeDirsFromImports(t *testing.T) {
  1113. ctx, _ := testJava(t, `
  1114. java_library {
  1115. name: "foo",
  1116. srcs: ["aidl/foo/IFoo.aidl"],
  1117. libs: ["bar"],
  1118. }
  1119. java_import {
  1120. name: "bar",
  1121. jars: ["a.jar"],
  1122. aidl: {
  1123. export_include_dirs: ["aidl/bar"],
  1124. },
  1125. }
  1126. `)
  1127. aidlCommand := ctx.ModuleForTests("foo", "android_common").Rule("aidl").RuleParams.Command
  1128. expectedAidlFlag := "-Iaidl/bar"
  1129. if !strings.Contains(aidlCommand, expectedAidlFlag) {
  1130. t.Errorf("aidl command %q does not contain %q", aidlCommand, expectedAidlFlag)
  1131. }
  1132. }
  1133. func TestAidlIncludeDirFromConvertedFileGroupWithPathPropInMixedBuilds(t *testing.T) {
  1134. // TODO(b/247782695), TODO(b/242847534) Fix mixed builds for filegroups
  1135. t.Skip("Re-enable once filegroups are corrected for mixed builds")
  1136. bp := `
  1137. filegroup {
  1138. name: "foo_aidl",
  1139. srcs: ["aidl/foo/IFoo.aidl"],
  1140. path: "aidl/foo",
  1141. bazel_module: { label: "//:foo_aidl" },
  1142. }
  1143. java_library {
  1144. name: "foo",
  1145. srcs: [":foo_aidl"],
  1146. }
  1147. `
  1148. outBaseDir := "out/bazel/output"
  1149. result := android.GroupFixturePreparers(
  1150. prepareForJavaTest,
  1151. android.PrepareForTestWithFilegroup,
  1152. android.FixtureModifyConfig(func(config android.Config) {
  1153. config.BazelContext = android.MockBazelContext{
  1154. OutputBaseDir: outBaseDir,
  1155. LabelToOutputFiles: map[string][]string{
  1156. "//:foo_aidl": []string{"aidl/foo/IFoo.aidl"},
  1157. },
  1158. }
  1159. }),
  1160. ).RunTestWithBp(t, bp)
  1161. aidlCommand := result.ModuleForTests("foo", "android_common").Rule("aidl").RuleParams.Command
  1162. expectedAidlFlag := "-I" + outBaseDir + "/execroot/__main__/aidl/foo"
  1163. if !strings.Contains(aidlCommand, expectedAidlFlag) {
  1164. t.Errorf("aidl command %q does not contain %q", aidlCommand, expectedAidlFlag)
  1165. }
  1166. }
  1167. func TestAidlFlagsArePassedToTheAidlCompiler(t *testing.T) {
  1168. ctx, _ := testJava(t, `
  1169. java_library {
  1170. name: "foo",
  1171. srcs: ["aidl/foo/IFoo.aidl"],
  1172. aidl: { flags: ["-Werror"], },
  1173. }
  1174. `)
  1175. aidlCommand := ctx.ModuleForTests("foo", "android_common").Rule("aidl").RuleParams.Command
  1176. expectedAidlFlag := "-Werror"
  1177. if !strings.Contains(aidlCommand, expectedAidlFlag) {
  1178. t.Errorf("aidl command %q does not contain %q", aidlCommand, expectedAidlFlag)
  1179. }
  1180. }
  1181. func TestAidlFlagsWithMinSdkVersion(t *testing.T) {
  1182. fixture := android.GroupFixturePreparers(
  1183. prepareForJavaTest, FixtureWithPrebuiltApis(map[string][]string{"14": {"foo"}}))
  1184. for _, tc := range []struct {
  1185. name string
  1186. sdkVersion string
  1187. expected string
  1188. }{
  1189. {"default is current", "", "current"},
  1190. {"use sdk_version", `sdk_version: "14"`, "14"},
  1191. {"system_current", `sdk_version: "system_current"`, "current"},
  1192. } {
  1193. t.Run(tc.name, func(t *testing.T) {
  1194. ctx := fixture.RunTestWithBp(t, `
  1195. java_library {
  1196. name: "foo",
  1197. srcs: ["aidl/foo/IFoo.aidl"],
  1198. `+tc.sdkVersion+`
  1199. }
  1200. `)
  1201. aidlCommand := ctx.ModuleForTests("foo", "android_common").Rule("aidl").RuleParams.Command
  1202. expectedAidlFlag := "--min_sdk_version=" + tc.expected
  1203. if !strings.Contains(aidlCommand, expectedAidlFlag) {
  1204. t.Errorf("aidl command %q does not contain %q", aidlCommand, expectedAidlFlag)
  1205. }
  1206. })
  1207. }
  1208. }
  1209. func TestAidlFlagsMinSdkVersionDroidstubs(t *testing.T) {
  1210. bpTemplate := `
  1211. droidstubs {
  1212. name: "foo-stubs",
  1213. srcs: ["foo.aidl"],
  1214. %s
  1215. system_modules: "none",
  1216. }
  1217. `
  1218. testCases := []struct {
  1219. desc string
  1220. sdkVersionBp string
  1221. minSdkVersionExpected string
  1222. }{
  1223. {
  1224. desc: "sdk_version not set, module compiles against private platform APIs",
  1225. sdkVersionBp: ``,
  1226. minSdkVersionExpected: "10000",
  1227. },
  1228. {
  1229. desc: "sdk_version set to none, module does not build against an SDK",
  1230. sdkVersionBp: `sdk_version: "none",`,
  1231. minSdkVersionExpected: "10000",
  1232. },
  1233. }
  1234. for _, tc := range testCases {
  1235. ctx := prepareForJavaTest.RunTestWithBp(t, fmt.Sprintf(bpTemplate, tc.sdkVersionBp))
  1236. aidlCmd := ctx.ModuleForTests("foo-stubs", "android_common").Rule("aidl").RuleParams.Command
  1237. expected := "--min_sdk_version=" + tc.minSdkVersionExpected
  1238. android.AssertStringDoesContain(t, "aidl command conatins incorrect min_sdk_version for testCse: "+tc.desc, aidlCmd, expected)
  1239. }
  1240. }
  1241. func TestAidlEnforcePermissions(t *testing.T) {
  1242. ctx, _ := testJava(t, `
  1243. java_library {
  1244. name: "foo",
  1245. srcs: ["aidl/foo/IFoo.aidl"],
  1246. aidl: { enforce_permissions: true },
  1247. }
  1248. `)
  1249. aidlCommand := ctx.ModuleForTests("foo", "android_common").Rule("aidl").RuleParams.Command
  1250. expectedAidlFlag := "-Wmissing-permission-annotation -Werror"
  1251. if !strings.Contains(aidlCommand, expectedAidlFlag) {
  1252. t.Errorf("aidl command %q does not contain %q", aidlCommand, expectedAidlFlag)
  1253. }
  1254. }
  1255. func TestAidlEnforcePermissionsException(t *testing.T) {
  1256. ctx, _ := testJava(t, `
  1257. java_library {
  1258. name: "foo",
  1259. srcs: ["aidl/foo/IFoo.aidl", "aidl/foo/IFoo2.aidl"],
  1260. aidl: { enforce_permissions: true, enforce_permissions_exceptions: ["aidl/foo/IFoo2.aidl"] },
  1261. }
  1262. `)
  1263. aidlCommand := ctx.ModuleForTests("foo", "android_common").Rule("aidl").RuleParams.Command
  1264. expectedAidlFlag := "$$FLAGS -Wmissing-permission-annotation -Werror aidl/foo/IFoo.aidl"
  1265. if !strings.Contains(aidlCommand, expectedAidlFlag) {
  1266. t.Errorf("aidl command %q does not contain %q", aidlCommand, expectedAidlFlag)
  1267. }
  1268. expectedAidlFlag = "$$FLAGS aidl/foo/IFoo2.aidl"
  1269. if !strings.Contains(aidlCommand, expectedAidlFlag) {
  1270. t.Errorf("aidl command %q does not contain %q", aidlCommand, expectedAidlFlag)
  1271. }
  1272. }
  1273. func TestDataNativeBinaries(t *testing.T) {
  1274. ctx := android.GroupFixturePreparers(
  1275. prepareForJavaTest,
  1276. android.PrepareForTestWithAllowMissingDependencies).RunTestWithBp(t, `
  1277. java_test_host {
  1278. name: "foo",
  1279. srcs: ["a.java"],
  1280. data_native_bins: ["bin"]
  1281. }
  1282. cc_binary_host {
  1283. name: "bin",
  1284. srcs: ["bin.cpp"],
  1285. }
  1286. `).TestContext
  1287. buildOS := ctx.Config().BuildOS.String()
  1288. test := ctx.ModuleForTests("foo", buildOS+"_common").Module().(*TestHost)
  1289. entries := android.AndroidMkEntriesForTest(t, ctx, test)[0]
  1290. expected := []string{"out/soong/.intermediates/bin/" + buildOS + "_x86_64/bin:bin"}
  1291. actual := entries.EntryMap["LOCAL_COMPATIBILITY_SUPPORT_FILES"]
  1292. android.AssertStringPathsRelativeToTopEquals(t, "LOCAL_COMPATIBILITY_SUPPORT_FILES", ctx.Config(), expected, actual)
  1293. }
  1294. func TestDefaultInstallable(t *testing.T) {
  1295. ctx, _ := testJava(t, `
  1296. java_test_host {
  1297. name: "foo"
  1298. }
  1299. `)
  1300. buildOS := ctx.Config().BuildOS.String()
  1301. module := ctx.ModuleForTests("foo", buildOS+"_common").Module().(*TestHost)
  1302. assertDeepEquals(t, "Default installable value should be true.", proptools.BoolPtr(true),
  1303. module.properties.Installable)
  1304. }
  1305. func TestErrorproneEnabled(t *testing.T) {
  1306. ctx, _ := testJava(t, `
  1307. java_library {
  1308. name: "foo",
  1309. srcs: ["a.java"],
  1310. errorprone: {
  1311. enabled: true,
  1312. },
  1313. }
  1314. `)
  1315. javac := ctx.ModuleForTests("foo", "android_common").Description("javac")
  1316. // Test that the errorprone plugins are passed to javac
  1317. expectedSubstring := "-Xplugin:ErrorProne"
  1318. if !strings.Contains(javac.Args["javacFlags"], expectedSubstring) {
  1319. t.Errorf("expected javacFlags to contain %q, got %q", expectedSubstring, javac.Args["javacFlags"])
  1320. }
  1321. // Modules with errorprone { enabled: true } will include errorprone checks
  1322. // in the main javac build rule. Only when RUN_ERROR_PRONE is true will
  1323. // the explicit errorprone build rule be created.
  1324. errorprone := ctx.ModuleForTests("foo", "android_common").MaybeDescription("errorprone")
  1325. if errorprone.RuleParams.Description != "" {
  1326. t.Errorf("expected errorprone build rule to not exist, but it did")
  1327. }
  1328. }
  1329. func TestErrorproneDisabled(t *testing.T) {
  1330. bp := `
  1331. java_library {
  1332. name: "foo",
  1333. srcs: ["a.java"],
  1334. errorprone: {
  1335. enabled: false,
  1336. },
  1337. }
  1338. `
  1339. ctx := android.GroupFixturePreparers(
  1340. PrepareForTestWithJavaDefaultModules,
  1341. android.FixtureMergeEnv(map[string]string{
  1342. "RUN_ERROR_PRONE": "true",
  1343. }),
  1344. ).RunTestWithBp(t, bp)
  1345. javac := ctx.ModuleForTests("foo", "android_common").Description("javac")
  1346. // Test that the errorprone plugins are not passed to javac, like they would
  1347. // be if enabled was true.
  1348. expectedSubstring := "-Xplugin:ErrorProne"
  1349. if strings.Contains(javac.Args["javacFlags"], expectedSubstring) {
  1350. t.Errorf("expected javacFlags to not contain %q, got %q", expectedSubstring, javac.Args["javacFlags"])
  1351. }
  1352. // Check that no errorprone build rule is created, like there would be
  1353. // if enabled was unset and RUN_ERROR_PRONE was true.
  1354. errorprone := ctx.ModuleForTests("foo", "android_common").MaybeDescription("errorprone")
  1355. if errorprone.RuleParams.Description != "" {
  1356. t.Errorf("expected errorprone build rule to not exist, but it did")
  1357. }
  1358. }
  1359. func TestErrorproneEnabledOnlyByEnvironmentVariable(t *testing.T) {
  1360. bp := `
  1361. java_library {
  1362. name: "foo",
  1363. srcs: ["a.java"],
  1364. }
  1365. `
  1366. ctx := android.GroupFixturePreparers(
  1367. PrepareForTestWithJavaDefaultModules,
  1368. android.FixtureMergeEnv(map[string]string{
  1369. "RUN_ERROR_PRONE": "true",
  1370. }),
  1371. ).RunTestWithBp(t, bp)
  1372. javac := ctx.ModuleForTests("foo", "android_common").Description("javac")
  1373. errorprone := ctx.ModuleForTests("foo", "android_common").Description("errorprone")
  1374. // Check that the errorprone plugins are not passed to javac, because they
  1375. // will instead be passed to the separate errorprone compilation
  1376. expectedSubstring := "-Xplugin:ErrorProne"
  1377. if strings.Contains(javac.Args["javacFlags"], expectedSubstring) {
  1378. t.Errorf("expected javacFlags to not contain %q, got %q", expectedSubstring, javac.Args["javacFlags"])
  1379. }
  1380. // Check that the errorprone plugin is enabled
  1381. if !strings.Contains(errorprone.Args["javacFlags"], expectedSubstring) {
  1382. t.Errorf("expected errorprone to contain %q, got %q", expectedSubstring, javac.Args["javacFlags"])
  1383. }
  1384. }
  1385. func TestDataDeviceBinsBuildsDeviceBinary(t *testing.T) {
  1386. testCases := []struct {
  1387. dataDeviceBinType string
  1388. depCompileMultilib string
  1389. variants []string
  1390. expectedError string
  1391. }{
  1392. {
  1393. dataDeviceBinType: "first",
  1394. depCompileMultilib: "first",
  1395. variants: []string{"android_arm64_armv8-a"},
  1396. },
  1397. {
  1398. dataDeviceBinType: "first",
  1399. depCompileMultilib: "both",
  1400. variants: []string{"android_arm64_armv8-a"},
  1401. },
  1402. {
  1403. // this is true because our testing framework is set up with
  1404. // Targets ~ [<64bit target>, <32bit target>], where 64bit is "first"
  1405. dataDeviceBinType: "first",
  1406. depCompileMultilib: "32",
  1407. expectedError: `Android.bp:2:3: dependency "bar" of "foo" missing variant`,
  1408. },
  1409. {
  1410. dataDeviceBinType: "first",
  1411. depCompileMultilib: "64",
  1412. variants: []string{"android_arm64_armv8-a"},
  1413. },
  1414. {
  1415. dataDeviceBinType: "both",
  1416. depCompileMultilib: "both",
  1417. variants: []string{
  1418. "android_arm_armv7-a-neon",
  1419. "android_arm64_armv8-a",
  1420. },
  1421. },
  1422. {
  1423. dataDeviceBinType: "both",
  1424. depCompileMultilib: "32",
  1425. expectedError: `Android.bp:2:3: dependency "bar" of "foo" missing variant`,
  1426. },
  1427. {
  1428. dataDeviceBinType: "both",
  1429. depCompileMultilib: "64",
  1430. expectedError: `Android.bp:2:3: dependency "bar" of "foo" missing variant`,
  1431. },
  1432. {
  1433. dataDeviceBinType: "both",
  1434. depCompileMultilib: "first",
  1435. expectedError: `Android.bp:2:3: dependency "bar" of "foo" missing variant`,
  1436. },
  1437. {
  1438. dataDeviceBinType: "32",
  1439. depCompileMultilib: "32",
  1440. variants: []string{"android_arm_armv7-a-neon"},
  1441. },
  1442. {
  1443. dataDeviceBinType: "32",
  1444. depCompileMultilib: "first",
  1445. expectedError: `Android.bp:2:3: dependency "bar" of "foo" missing variant`,
  1446. },
  1447. {
  1448. dataDeviceBinType: "32",
  1449. depCompileMultilib: "both",
  1450. variants: []string{"android_arm_armv7-a-neon"},
  1451. },
  1452. {
  1453. dataDeviceBinType: "32",
  1454. depCompileMultilib: "64",
  1455. expectedError: `Android.bp:2:3: dependency "bar" of "foo" missing variant`,
  1456. },
  1457. {
  1458. dataDeviceBinType: "64",
  1459. depCompileMultilib: "64",
  1460. variants: []string{"android_arm64_armv8-a"},
  1461. },
  1462. {
  1463. dataDeviceBinType: "64",
  1464. depCompileMultilib: "both",
  1465. variants: []string{"android_arm64_armv8-a"},
  1466. },
  1467. {
  1468. dataDeviceBinType: "64",
  1469. depCompileMultilib: "first",
  1470. variants: []string{"android_arm64_armv8-a"},
  1471. },
  1472. {
  1473. dataDeviceBinType: "64",
  1474. depCompileMultilib: "32",
  1475. expectedError: `Android.bp:2:3: dependency "bar" of "foo" missing variant`,
  1476. },
  1477. {
  1478. dataDeviceBinType: "prefer32",
  1479. depCompileMultilib: "32",
  1480. variants: []string{"android_arm_armv7-a-neon"},
  1481. },
  1482. {
  1483. dataDeviceBinType: "prefer32",
  1484. depCompileMultilib: "both",
  1485. variants: []string{"android_arm_armv7-a-neon"},
  1486. },
  1487. {
  1488. dataDeviceBinType: "prefer32",
  1489. depCompileMultilib: "first",
  1490. expectedError: `Android.bp:2:3: dependency "bar" of "foo" missing variant`,
  1491. },
  1492. {
  1493. dataDeviceBinType: "prefer32",
  1494. depCompileMultilib: "64",
  1495. expectedError: `Android.bp:2:3: dependency "bar" of "foo" missing variant`,
  1496. },
  1497. }
  1498. bpTemplate := `
  1499. java_test_host {
  1500. name: "foo",
  1501. srcs: ["test.java"],
  1502. data_device_bins_%s: ["bar"],
  1503. }
  1504. cc_binary {
  1505. name: "bar",
  1506. compile_multilib: "%s",
  1507. }
  1508. `
  1509. for _, tc := range testCases {
  1510. bp := fmt.Sprintf(bpTemplate, tc.dataDeviceBinType, tc.depCompileMultilib)
  1511. errorHandler := android.FixtureExpectsNoErrors
  1512. if tc.expectedError != "" {
  1513. errorHandler = android.FixtureExpectsAtLeastOneErrorMatchingPattern(tc.expectedError)
  1514. }
  1515. testName := fmt.Sprintf(`data_device_bins_%s with compile_multilib:"%s"`, tc.dataDeviceBinType, tc.depCompileMultilib)
  1516. t.Run(testName, func(t *testing.T) {
  1517. ctx := android.GroupFixturePreparers(PrepareForIntegrationTestWithJava).
  1518. ExtendWithErrorHandler(errorHandler).
  1519. RunTestWithBp(t, bp)
  1520. if tc.expectedError != "" {
  1521. return
  1522. }
  1523. buildOS := ctx.Config.BuildOS.String()
  1524. fooVariant := ctx.ModuleForTests("foo", buildOS+"_common")
  1525. fooMod := fooVariant.Module().(*TestHost)
  1526. entries := android.AndroidMkEntriesForTest(t, ctx.TestContext, fooMod)[0]
  1527. expectedAutogenConfig := `<option name="push-file" key="bar" value="/data/local/tests/unrestricted/foo/bar" />`
  1528. autogen := fooVariant.Rule("autogen")
  1529. if !strings.Contains(autogen.Args["extraConfigs"], expectedAutogenConfig) {
  1530. t.Errorf("foo extraConfigs %v does not contain %q", autogen.Args["extraConfigs"], expectedAutogenConfig)
  1531. }
  1532. expectedData := []string{}
  1533. for _, variant := range tc.variants {
  1534. barVariant := ctx.ModuleForTests("bar", variant)
  1535. relocated := barVariant.Output("bar")
  1536. expectedInput := fmt.Sprintf("out/soong/.intermediates/bar/%s/unstripped/bar", variant)
  1537. android.AssertPathRelativeToTopEquals(t, "relocation input", expectedInput, relocated.Input)
  1538. expectedData = append(expectedData, fmt.Sprintf("out/soong/.intermediates/bar/%s/bar:bar", variant))
  1539. }
  1540. actualData := entries.EntryMap["LOCAL_COMPATIBILITY_SUPPORT_FILES"]
  1541. android.AssertStringPathsRelativeToTopEquals(t, "LOCAL_TEST_DATA", ctx.Config, expectedData, actualData)
  1542. })
  1543. }
  1544. }
  1545. func TestImportMixedBuild(t *testing.T) {
  1546. bp := `
  1547. java_import {
  1548. name: "baz",
  1549. jars: [
  1550. "test1.jar",
  1551. "test2.jar",
  1552. ],
  1553. bazel_module: { label: "//foo/bar:baz" },
  1554. }
  1555. `
  1556. ctx := android.GroupFixturePreparers(
  1557. prepareForJavaTest,
  1558. android.FixtureModifyConfig(func(config android.Config) {
  1559. config.BazelContext = android.MockBazelContext{
  1560. OutputBaseDir: "outputbase",
  1561. LabelToOutputFiles: map[string][]string{
  1562. "//foo/bar:baz": []string{"test1.jar", "test2.jar"},
  1563. },
  1564. }
  1565. }),
  1566. ).RunTestWithBp(t, bp)
  1567. bazMod := ctx.ModuleForTests("baz", "android_common").Module()
  1568. producer := bazMod.(android.OutputFileProducer)
  1569. expectedOutputFiles := []string{".intermediates/baz/android_common/bazelCombined/baz.jar"}
  1570. outputFiles, err := producer.OutputFiles("")
  1571. if err != nil {
  1572. t.Errorf("Unexpected error getting java_import outputfiles %s", err)
  1573. }
  1574. actualOutputFiles := android.NormalizePathsForTesting(outputFiles)
  1575. android.AssertDeepEquals(t, "Output files are produced", expectedOutputFiles, actualOutputFiles)
  1576. javaInfoProvider := ctx.ModuleProvider(bazMod, JavaInfoProvider)
  1577. javaInfo, ok := javaInfoProvider.(JavaInfo)
  1578. if !ok {
  1579. t.Error("could not get JavaInfo from java_import module")
  1580. }
  1581. android.AssertDeepEquals(t, "Header JARs are produced", expectedOutputFiles, android.NormalizePathsForTesting(javaInfo.HeaderJars))
  1582. android.AssertDeepEquals(t, "Implementation/Resources JARs are produced", expectedOutputFiles, android.NormalizePathsForTesting(javaInfo.ImplementationAndResourcesJars))
  1583. android.AssertDeepEquals(t, "Implementation JARs are produced", expectedOutputFiles, android.NormalizePathsForTesting(javaInfo.ImplementationJars))
  1584. }
  1585. func TestGenAidlIncludeFlagsForMixedBuilds(t *testing.T) {
  1586. bazelOutputBaseDir := filepath.Join("out", "bazel")
  1587. result := android.GroupFixturePreparers(
  1588. PrepareForIntegrationTestWithJava,
  1589. android.FixtureModifyConfig(func(config android.Config) {
  1590. config.BazelContext = android.MockBazelContext{
  1591. OutputBaseDir: bazelOutputBaseDir,
  1592. }
  1593. }),
  1594. ).RunTest(t)
  1595. ctx := &android.TestPathContext{TestResult: result}
  1596. srcDirectory := filepath.Join("frameworks", "base")
  1597. srcDirectoryAlreadyIncluded := filepath.Join("frameworks", "base", "core", "java")
  1598. bazelSrcDirectory := android.PathForBazelOut(ctx, srcDirectory)
  1599. bazelSrcDirectoryAlreadyIncluded := android.PathForBazelOut(ctx, srcDirectoryAlreadyIncluded)
  1600. srcs := android.Paths{
  1601. android.PathForTestingWithRel(bazelSrcDirectory.String(), "bazelAidl.aidl"),
  1602. android.PathForTestingWithRel(bazelSrcDirectory.String(), "bazelAidl2.aidl"),
  1603. android.PathForTestingWithRel(bazelSrcDirectoryAlreadyIncluded.String(), "bazelAidlExclude.aidl"),
  1604. android.PathForTestingWithRel(bazelSrcDirectoryAlreadyIncluded.String(), "bazelAidl2Exclude.aidl"),
  1605. }
  1606. dirsAlreadyIncluded := android.Paths{
  1607. android.PathForTesting(srcDirectoryAlreadyIncluded),
  1608. }
  1609. expectedFlags := " -Iout/bazel/execroot/__main__/frameworks/base"
  1610. flags := genAidlIncludeFlags(ctx, srcs, dirsAlreadyIncluded)
  1611. if flags != expectedFlags {
  1612. t.Errorf("expected flags to be %q; was %q", expectedFlags, flags)
  1613. }
  1614. }
  1615. func TestDeviceBinaryWrapperGeneration(t *testing.T) {
  1616. // Scenario 1: java_binary has main_class property in its bp
  1617. ctx, _ := testJava(t, `
  1618. java_binary {
  1619. name: "foo",
  1620. srcs: ["foo.java"],
  1621. main_class: "foo.bar.jb",
  1622. }
  1623. `)
  1624. wrapperPath := fmt.Sprint(ctx.ModuleForTests("foo", "android_arm64_armv8-a").AllOutputs())
  1625. if !strings.Contains(wrapperPath, "foo.sh") {
  1626. t.Errorf("wrapper file foo.sh is not generated")
  1627. }
  1628. // Scenario 2: java_binary has neither wrapper nor main_class, its build
  1629. // is expected to be failed.
  1630. testJavaError(t, "main_class property is required for device binary if no default wrapper is assigned", `
  1631. java_binary {
  1632. name: "foo",
  1633. srcs: ["foo.java"],
  1634. }`)
  1635. }
  1636. func TestJavaApiContributionEmptyApiFile(t *testing.T) {
  1637. testJavaError(t,
  1638. "Error: foo has an empty api file.",
  1639. `java_api_contribution {
  1640. name: "foo",
  1641. }
  1642. java_api_library {
  1643. name: "bar",
  1644. api_surface: "public",
  1645. api_contributions: ["foo"],
  1646. }
  1647. `)
  1648. }
  1649. func TestJavaApiLibraryAndProviderLink(t *testing.T) {
  1650. provider_bp_a := `
  1651. java_api_contribution {
  1652. name: "foo1",
  1653. api_file: "foo1.txt",
  1654. }
  1655. `
  1656. provider_bp_b := `java_api_contribution {
  1657. name: "foo2",
  1658. api_file: "foo2.txt",
  1659. }
  1660. `
  1661. ctx, _ := testJavaWithFS(t, `
  1662. java_api_library {
  1663. name: "bar1",
  1664. api_surface: "public",
  1665. api_contributions: ["foo1"],
  1666. }
  1667. java_api_library {
  1668. name: "bar2",
  1669. api_surface: "system",
  1670. api_contributions: ["foo1", "foo2"],
  1671. api_files: ["api1/current.txt", "api2/current.txt"]
  1672. }
  1673. `,
  1674. map[string][]byte{
  1675. "a/Android.bp": []byte(provider_bp_a),
  1676. "b/Android.bp": []byte(provider_bp_b),
  1677. })
  1678. testcases := []struct {
  1679. moduleName string
  1680. sourceTextFileDirs []string
  1681. }{
  1682. {
  1683. moduleName: "bar1",
  1684. sourceTextFileDirs: []string{"a/foo1.txt"},
  1685. },
  1686. {
  1687. moduleName: "bar2",
  1688. sourceTextFileDirs: []string{"a/foo1.txt", "b/foo2.txt", "api1/current.txt", "api2/current.txt"},
  1689. },
  1690. }
  1691. for _, c := range testcases {
  1692. m := ctx.ModuleForTests(c.moduleName, "android_common")
  1693. manifest := m.Output("metalava.sbox.textproto")
  1694. sboxProto := android.RuleBuilderSboxProtoForTests(t, manifest)
  1695. manifestCommand := sboxProto.Commands[0].GetCommand()
  1696. sourceFilesFlag := "--source-files " + strings.Join(c.sourceTextFileDirs, " ")
  1697. android.AssertStringDoesContain(t, "source text files not present", manifestCommand, sourceFilesFlag)
  1698. }
  1699. }
  1700. func TestJavaApiLibraryAndDefaultsLink(t *testing.T) {
  1701. provider_bp_a := `
  1702. java_api_contribution {
  1703. name: "foo1",
  1704. api_file: "foo1.txt",
  1705. }
  1706. `
  1707. provider_bp_b := `
  1708. java_api_contribution {
  1709. name: "foo2",
  1710. api_file: "foo2.txt",
  1711. }
  1712. `
  1713. provider_bp_c := `
  1714. java_api_contribution {
  1715. name: "foo3",
  1716. api_file: "foo3.txt",
  1717. }
  1718. `
  1719. provider_bp_d := `
  1720. java_api_contribution {
  1721. name: "foo4",
  1722. api_file: "foo4.txt",
  1723. }
  1724. `
  1725. ctx, _ := testJavaWithFS(t, `
  1726. java_defaults {
  1727. name: "baz1",
  1728. api_surface: "public",
  1729. api_contributions: ["foo1", "foo2"],
  1730. }
  1731. java_defaults {
  1732. name: "baz2",
  1733. api_surface: "system",
  1734. api_contributions: ["foo3"],
  1735. }
  1736. java_api_library {
  1737. name: "bar1",
  1738. api_surface: "public",
  1739. api_contributions: ["foo1"],
  1740. }
  1741. java_api_library {
  1742. name: "bar2",
  1743. api_surface: "public",
  1744. defaults:["baz1"],
  1745. }
  1746. java_api_library {
  1747. name: "bar3",
  1748. api_surface: "system",
  1749. defaults:["baz1", "baz2"],
  1750. api_contributions: ["foo4"],
  1751. api_files: ["api1/current.txt", "api2/current.txt"]
  1752. }
  1753. `,
  1754. map[string][]byte{
  1755. "a/Android.bp": []byte(provider_bp_a),
  1756. "b/Android.bp": []byte(provider_bp_b),
  1757. "c/Android.bp": []byte(provider_bp_c),
  1758. "d/Android.bp": []byte(provider_bp_d),
  1759. })
  1760. testcases := []struct {
  1761. moduleName string
  1762. sourceTextFileDirs []string
  1763. }{
  1764. {
  1765. moduleName: "bar1",
  1766. sourceTextFileDirs: []string{"a/foo1.txt"},
  1767. },
  1768. {
  1769. moduleName: "bar2",
  1770. sourceTextFileDirs: []string{"a/foo1.txt", "b/foo2.txt"},
  1771. },
  1772. {
  1773. moduleName: "bar3",
  1774. sourceTextFileDirs: []string{"c/foo3.txt", "a/foo1.txt", "b/foo2.txt", "d/foo4.txt", "api1/current.txt", "api2/current.txt"},
  1775. },
  1776. }
  1777. for _, c := range testcases {
  1778. m := ctx.ModuleForTests(c.moduleName, "android_common")
  1779. manifest := m.Output("metalava.sbox.textproto")
  1780. sboxProto := android.RuleBuilderSboxProtoForTests(t, manifest)
  1781. manifestCommand := sboxProto.Commands[0].GetCommand()
  1782. sourceFilesFlag := "--source-files " + strings.Join(c.sourceTextFileDirs, " ")
  1783. android.AssertStringDoesContain(t, "source text files not present", manifestCommand, sourceFilesFlag)
  1784. }
  1785. }
  1786. func TestJavaApiLibraryJarGeneration(t *testing.T) {
  1787. provider_bp_a := `
  1788. java_api_contribution {
  1789. name: "foo1",
  1790. api_file: "foo1.txt",
  1791. }
  1792. `
  1793. provider_bp_b := `
  1794. java_api_contribution {
  1795. name: "foo2",
  1796. api_file: "foo2.txt",
  1797. }
  1798. `
  1799. ctx, _ := testJavaWithFS(t, `
  1800. java_api_library {
  1801. name: "bar1",
  1802. api_surface: "public",
  1803. api_contributions: ["foo1"],
  1804. }
  1805. java_api_library {
  1806. name: "bar2",
  1807. api_surface: "system",
  1808. api_contributions: ["foo1", "foo2"],
  1809. }
  1810. `,
  1811. map[string][]byte{
  1812. "a/Android.bp": []byte(provider_bp_a),
  1813. "b/Android.bp": []byte(provider_bp_b),
  1814. })
  1815. testcases := []struct {
  1816. moduleName string
  1817. outputJarName string
  1818. }{
  1819. {
  1820. moduleName: "bar1",
  1821. outputJarName: "bar1/bar1.jar",
  1822. },
  1823. {
  1824. moduleName: "bar2",
  1825. outputJarName: "bar2/bar2.jar",
  1826. },
  1827. }
  1828. for _, c := range testcases {
  1829. m := ctx.ModuleForTests(c.moduleName, "android_common")
  1830. outputs := fmt.Sprint(m.AllOutputs())
  1831. if !strings.Contains(outputs, c.outputJarName) {
  1832. t.Errorf("Module output does not contain expected jar %s", c.outputJarName)
  1833. }
  1834. }
  1835. }
  1836. func TestJavaApiLibraryLibsLink(t *testing.T) {
  1837. provider_bp_a := `
  1838. java_api_contribution {
  1839. name: "foo1",
  1840. api_file: "foo1.txt",
  1841. }
  1842. `
  1843. provider_bp_b := `
  1844. java_api_contribution {
  1845. name: "foo2",
  1846. api_file: "foo2.txt",
  1847. }
  1848. `
  1849. lib_bp_a := `
  1850. java_library {
  1851. name: "lib1",
  1852. srcs: ["Lib.java"],
  1853. }
  1854. `
  1855. lib_bp_b := `
  1856. java_library {
  1857. name: "lib2",
  1858. srcs: ["Lib.java"],
  1859. }
  1860. `
  1861. ctx, _ := testJavaWithFS(t, `
  1862. java_api_library {
  1863. name: "bar1",
  1864. api_surface: "public",
  1865. api_contributions: ["foo1"],
  1866. libs: ["lib1"],
  1867. }
  1868. java_api_library {
  1869. name: "bar2",
  1870. api_surface: "system",
  1871. api_contributions: ["foo1", "foo2"],
  1872. libs: ["lib1", "lib2", "bar1"],
  1873. }
  1874. `,
  1875. map[string][]byte{
  1876. "a/Android.bp": []byte(provider_bp_a),
  1877. "b/Android.bp": []byte(provider_bp_b),
  1878. "c/Android.bp": []byte(lib_bp_a),
  1879. "c/Lib.java": {},
  1880. "d/Android.bp": []byte(lib_bp_b),
  1881. "d/Lib.java": {},
  1882. })
  1883. testcases := []struct {
  1884. moduleName string
  1885. classPathJarNames []string
  1886. }{
  1887. {
  1888. moduleName: "bar1",
  1889. classPathJarNames: []string{"lib1.jar"},
  1890. },
  1891. {
  1892. moduleName: "bar2",
  1893. classPathJarNames: []string{"lib1.jar", "lib2.jar", "bar1/bar1.jar"},
  1894. },
  1895. }
  1896. for _, c := range testcases {
  1897. m := ctx.ModuleForTests(c.moduleName, "android_common")
  1898. javacRules := m.Rule("javac")
  1899. classPathArgs := javacRules.Args["classpath"]
  1900. for _, jarName := range c.classPathJarNames {
  1901. if !strings.Contains(classPathArgs, jarName) {
  1902. t.Errorf("Module output does not contain expected jar %s", jarName)
  1903. }
  1904. }
  1905. }
  1906. }
  1907. func TestJavaApiLibraryStaticLibsLink(t *testing.T) {
  1908. provider_bp_a := `
  1909. java_api_contribution {
  1910. name: "foo1",
  1911. api_file: "foo1.txt",
  1912. }
  1913. `
  1914. provider_bp_b := `
  1915. java_api_contribution {
  1916. name: "foo2",
  1917. api_file: "foo2.txt",
  1918. }
  1919. `
  1920. lib_bp_a := `
  1921. java_library {
  1922. name: "lib1",
  1923. srcs: ["Lib.java"],
  1924. }
  1925. `
  1926. lib_bp_b := `
  1927. java_library {
  1928. name: "lib2",
  1929. srcs: ["Lib.java"],
  1930. }
  1931. `
  1932. ctx, _ := testJavaWithFS(t, `
  1933. java_api_library {
  1934. name: "bar1",
  1935. api_surface: "public",
  1936. api_contributions: ["foo1"],
  1937. static_libs: ["lib1"],
  1938. }
  1939. java_api_library {
  1940. name: "bar2",
  1941. api_surface: "system",
  1942. api_contributions: ["foo1", "foo2"],
  1943. static_libs: ["lib1", "lib2", "bar1"],
  1944. }
  1945. `,
  1946. map[string][]byte{
  1947. "a/Android.bp": []byte(provider_bp_a),
  1948. "b/Android.bp": []byte(provider_bp_b),
  1949. "c/Android.bp": []byte(lib_bp_a),
  1950. "c/Lib.java": {},
  1951. "d/Android.bp": []byte(lib_bp_b),
  1952. "d/Lib.java": {},
  1953. })
  1954. testcases := []struct {
  1955. moduleName string
  1956. staticLibJarNames []string
  1957. }{
  1958. {
  1959. moduleName: "bar1",
  1960. staticLibJarNames: []string{"lib1.jar"},
  1961. },
  1962. {
  1963. moduleName: "bar2",
  1964. staticLibJarNames: []string{"lib1.jar", "lib2.jar", "bar1/bar1.jar"},
  1965. },
  1966. }
  1967. for _, c := range testcases {
  1968. m := ctx.ModuleForTests(c.moduleName, "android_common")
  1969. mergeZipsCommand := m.Rule("merge_zips").RuleParams.Command
  1970. for _, jarName := range c.staticLibJarNames {
  1971. if !strings.Contains(mergeZipsCommand, jarName) {
  1972. t.Errorf("merge_zips command does not contain expected jar %s", jarName)
  1973. }
  1974. }
  1975. }
  1976. }
  1977. func TestJavaApiLibraryFullApiSurfaceStub(t *testing.T) {
  1978. provider_bp_a := `
  1979. java_api_contribution {
  1980. name: "foo1",
  1981. api_file: "foo1.txt",
  1982. }
  1983. `
  1984. provider_bp_b := `
  1985. java_api_contribution {
  1986. name: "foo2",
  1987. api_file: "foo2.txt",
  1988. }
  1989. `
  1990. lib_bp_a := `
  1991. java_api_library {
  1992. name: "lib1",
  1993. api_surface: "public",
  1994. api_contributions: ["foo1", "foo2"],
  1995. }
  1996. `
  1997. ctx, _ := testJavaWithFS(t, `
  1998. java_api_library {
  1999. name: "bar1",
  2000. api_surface: "public",
  2001. api_contributions: ["foo1"],
  2002. full_api_surface_stub: "lib1",
  2003. }
  2004. `,
  2005. map[string][]byte{
  2006. "a/Android.bp": []byte(provider_bp_a),
  2007. "b/Android.bp": []byte(provider_bp_b),
  2008. "c/Android.bp": []byte(lib_bp_a),
  2009. })
  2010. m := ctx.ModuleForTests("bar1", "android_common")
  2011. manifest := m.Output("metalava.sbox.textproto")
  2012. sboxProto := android.RuleBuilderSboxProtoForTests(t, manifest)
  2013. manifestCommand := sboxProto.Commands[0].GetCommand()
  2014. android.AssertStringDoesContain(t, "Command expected to contain full_api_surface_stub output jar", manifestCommand, "lib1.jar")
  2015. }
  2016. func TestJavaApiLibraryFilegroupInput(t *testing.T) {
  2017. ctx, _ := testJavaWithFS(t, `
  2018. filegroup {
  2019. name: "default_current.txt",
  2020. srcs: ["current.txt"],
  2021. }
  2022. java_api_library {
  2023. name: "foo",
  2024. api_files: [":default_current.txt"],
  2025. }
  2026. `,
  2027. map[string][]byte{
  2028. "current.txt": nil,
  2029. })
  2030. m := ctx.ModuleForTests("foo", "android_common")
  2031. outputs := fmt.Sprint(m.AllOutputs())
  2032. if !strings.Contains(outputs, "foo/foo.jar") {
  2033. t.Errorf("Module output does not contain expected jar %s", "foo/foo.jar")
  2034. }
  2035. }
  2036. func TestTradefedOptions(t *testing.T) {
  2037. result := PrepareForTestWithJavaBuildComponents.RunTestWithBp(t, `
  2038. java_test_host {
  2039. name: "foo",
  2040. test_options: {
  2041. tradefed_options: [
  2042. {
  2043. name: "exclude-path",
  2044. value: "org/apache"
  2045. }
  2046. ]
  2047. }
  2048. }
  2049. `)
  2050. buildOS := result.Config.BuildOS.String()
  2051. args := result.ModuleForTests("foo", buildOS+"_common").
  2052. Output("out/soong/.intermediates/foo/" + buildOS + "_common/foo.config").Args
  2053. expected := proptools.NinjaAndShellEscape("<option name=\"exclude-path\" value=\"org/apache\" />")
  2054. if args["extraConfigs"] != expected {
  2055. t.Errorf("Expected args[\"extraConfigs\"] to equal %q, was %q", expected, args["extraConfigs"])
  2056. }
  2057. }
  2058. func TestTestRunnerOptions(t *testing.T) {
  2059. result := PrepareForTestWithJavaBuildComponents.RunTestWithBp(t, `
  2060. java_test_host {
  2061. name: "foo",
  2062. test_options: {
  2063. test_runner_options: [
  2064. {
  2065. name: "test-timeout",
  2066. value: "10m"
  2067. }
  2068. ]
  2069. }
  2070. }
  2071. `)
  2072. buildOS := result.Config.BuildOS.String()
  2073. args := result.ModuleForTests("foo", buildOS+"_common").
  2074. Output("out/soong/.intermediates/foo/" + buildOS + "_common/foo.config").Args
  2075. expected := proptools.NinjaAndShellEscape("<option name=\"test-timeout\" value=\"10m\" />\\n ")
  2076. if args["extraTestRunnerConfigs"] != expected {
  2077. t.Errorf("Expected args[\"extraTestRunnerConfigs\"] to equal %q, was %q", expected, args["extraTestRunnerConfigs"])
  2078. }
  2079. }
  2080. func TestJavaExcludeStaticLib(t *testing.T) {
  2081. ctx, _ := testJava(t, `
  2082. java_library {
  2083. name: "bar",
  2084. }
  2085. java_library {
  2086. name: "foo",
  2087. }
  2088. java_library {
  2089. name: "baz",
  2090. static_libs: [
  2091. "foo",
  2092. "bar",
  2093. ],
  2094. exclude_static_libs: [
  2095. "bar",
  2096. ],
  2097. }
  2098. `)
  2099. // "bar" not included as dependency of "baz"
  2100. CheckModuleDependencies(t, ctx, "baz", "android_common", []string{
  2101. `core-lambda-stubs`,
  2102. `ext`,
  2103. `foo`,
  2104. `framework`,
  2105. `stable-core-platform-api-stubs-system-modules`,
  2106. `stable.core.platform.api.stubs`,
  2107. })
  2108. }