java_test.go 63 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277
  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 TestJavaApiLibraryDepApiSrcs(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. dep_api_srcs: "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 module srcjar file", manifestCommand, "bar1-stubs.srcjar")
  2015. android.AssertStringDoesContain(t, "Command expected to contain output files list text file flag", manifestCommand, "--out __SBOX_SANDBOX_DIR__/out/sources.txt")
  2016. }
  2017. func TestTradefedOptions(t *testing.T) {
  2018. result := PrepareForTestWithJavaBuildComponents.RunTestWithBp(t, `
  2019. java_test_host {
  2020. name: "foo",
  2021. test_options: {
  2022. tradefed_options: [
  2023. {
  2024. name: "exclude-path",
  2025. value: "org/apache"
  2026. }
  2027. ]
  2028. }
  2029. }
  2030. `)
  2031. buildOS := result.Config.BuildOS.String()
  2032. args := result.ModuleForTests("foo", buildOS+"_common").
  2033. Output("out/soong/.intermediates/foo/" + buildOS + "_common/foo.config").Args
  2034. expected := proptools.NinjaAndShellEscape("<option name=\"exclude-path\" value=\"org/apache\" />")
  2035. if args["extraConfigs"] != expected {
  2036. t.Errorf("Expected args[\"extraConfigs\"] to equal %q, was %q", expected, args["extraConfigs"])
  2037. }
  2038. }