java_test.go 60 KB

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