java_test.go 56 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177
  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. "io/ioutil"
  17. "os"
  18. "path/filepath"
  19. "reflect"
  20. "regexp"
  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. "android/soong/python"
  30. )
  31. var buildDir string
  32. func setUp() {
  33. var err error
  34. buildDir, err = ioutil.TempDir("", "soong_java_test")
  35. if err != nil {
  36. panic(err)
  37. }
  38. }
  39. func tearDown() {
  40. os.RemoveAll(buildDir)
  41. }
  42. func TestMain(m *testing.M) {
  43. run := func() int {
  44. setUp()
  45. defer tearDown()
  46. return m.Run()
  47. }
  48. os.Exit(run())
  49. }
  50. func testConfig(env map[string]string, bp string, fs map[string][]byte) android.Config {
  51. bp += dexpreopt.BpToolModulesForTest()
  52. config := TestConfig(buildDir, env, bp, fs)
  53. // Set up the global Once cache used for dexpreopt.GlobalSoongConfig, so that
  54. // it doesn't create a real one, which would fail.
  55. _ = dexpreopt.GlobalSoongConfigForTests(config)
  56. return config
  57. }
  58. func testContext() *android.TestContext {
  59. ctx := android.NewTestArchContext()
  60. RegisterJavaBuildComponents(ctx)
  61. RegisterAppBuildComponents(ctx)
  62. RegisterAARBuildComponents(ctx)
  63. RegisterGenRuleBuildComponents(ctx)
  64. RegisterSystemModulesBuildComponents(ctx)
  65. ctx.RegisterModuleType("java_plugin", PluginFactory)
  66. ctx.RegisterModuleType("filegroup", android.FileGroupFactory)
  67. ctx.RegisterModuleType("genrule", genrule.GenRuleFactory)
  68. ctx.RegisterModuleType("python_binary_host", python.PythonBinaryHostFactory)
  69. RegisterDocsBuildComponents(ctx)
  70. RegisterStubsBuildComponents(ctx)
  71. RegisterSdkLibraryBuildComponents(ctx)
  72. ctx.PreArchMutators(android.RegisterDefaultsPreArchMutators)
  73. ctx.PreArchMutators(android.RegisterComponentsMutator)
  74. RegisterPrebuiltApisBuildComponents(ctx)
  75. ctx.PreDepsMutators(python.RegisterPythonPreDepsMutators)
  76. ctx.PostDepsMutators(android.RegisterOverridePostDepsMutators)
  77. ctx.RegisterPreSingletonType("overlay", android.SingletonFactoryAdaptor(OverlaySingletonFactory))
  78. ctx.RegisterPreSingletonType("sdk_versions", android.SingletonFactoryAdaptor(sdkPreSingletonFactory))
  79. android.RegisterPrebuiltMutators(ctx)
  80. // Register module types and mutators from cc needed for JNI testing
  81. cc.RegisterRequiredBuildComponentsForTest(ctx)
  82. dexpreopt.RegisterToolModulesForTest(ctx)
  83. return ctx
  84. }
  85. func run(t *testing.T, ctx *android.TestContext, config android.Config) {
  86. t.Helper()
  87. pathCtx := android.PathContextForTesting(config)
  88. dexpreopt.SetTestGlobalConfig(config, dexpreopt.GlobalConfigForTests(pathCtx))
  89. ctx.Register(config)
  90. _, errs := ctx.ParseBlueprintsFiles("Android.bp")
  91. android.FailIfErrored(t, errs)
  92. _, errs = ctx.PrepareBuildActions(config)
  93. android.FailIfErrored(t, errs)
  94. }
  95. func testJavaError(t *testing.T, pattern string, bp string) (*android.TestContext, android.Config) {
  96. t.Helper()
  97. return testJavaErrorWithConfig(t, pattern, testConfig(nil, bp, nil))
  98. }
  99. func testJavaErrorWithConfig(t *testing.T, pattern string, config android.Config) (*android.TestContext, android.Config) {
  100. t.Helper()
  101. ctx := testContext()
  102. pathCtx := android.PathContextForTesting(config)
  103. dexpreopt.SetTestGlobalConfig(config, dexpreopt.GlobalConfigForTests(pathCtx))
  104. ctx.Register(config)
  105. _, errs := ctx.ParseBlueprintsFiles("Android.bp")
  106. if len(errs) > 0 {
  107. android.FailIfNoMatchingErrors(t, pattern, errs)
  108. return ctx, config
  109. }
  110. _, errs = ctx.PrepareBuildActions(config)
  111. if len(errs) > 0 {
  112. android.FailIfNoMatchingErrors(t, pattern, errs)
  113. return ctx, config
  114. }
  115. t.Fatalf("missing expected error %q (0 errors are returned)", pattern)
  116. return ctx, config
  117. }
  118. func testJavaWithFS(t *testing.T, bp string, fs map[string][]byte) (*android.TestContext, android.Config) {
  119. t.Helper()
  120. return testJavaWithConfig(t, testConfig(nil, bp, fs))
  121. }
  122. func testJava(t *testing.T, bp string) (*android.TestContext, android.Config) {
  123. t.Helper()
  124. return testJavaWithFS(t, bp, nil)
  125. }
  126. func testJavaWithConfig(t *testing.T, config android.Config) (*android.TestContext, android.Config) {
  127. t.Helper()
  128. ctx := testContext()
  129. run(t, ctx, config)
  130. return ctx, config
  131. }
  132. func moduleToPath(name string) string {
  133. switch {
  134. case name == `""`:
  135. return name
  136. case strings.HasSuffix(name, ".jar"):
  137. return name
  138. default:
  139. return filepath.Join(buildDir, ".intermediates", name, "android_common", "turbine-combined", name+".jar")
  140. }
  141. }
  142. func TestJavaLinkType(t *testing.T) {
  143. testJava(t, `
  144. java_library {
  145. name: "foo",
  146. srcs: ["a.java"],
  147. libs: ["bar"],
  148. static_libs: ["baz"],
  149. }
  150. java_library {
  151. name: "bar",
  152. sdk_version: "current",
  153. srcs: ["b.java"],
  154. }
  155. java_library {
  156. name: "baz",
  157. sdk_version: "system_current",
  158. srcs: ["c.java"],
  159. }
  160. `)
  161. testJavaError(t, "Adjust sdk_version: property of the source or target module so that target module is built with the same or smaller API set than the source.", `
  162. java_library {
  163. name: "foo",
  164. srcs: ["a.java"],
  165. libs: ["bar"],
  166. sdk_version: "current",
  167. static_libs: ["baz"],
  168. }
  169. java_library {
  170. name: "bar",
  171. sdk_version: "current",
  172. srcs: ["b.java"],
  173. }
  174. java_library {
  175. name: "baz",
  176. sdk_version: "system_current",
  177. srcs: ["c.java"],
  178. }
  179. `)
  180. testJava(t, `
  181. java_library {
  182. name: "foo",
  183. srcs: ["a.java"],
  184. libs: ["bar"],
  185. sdk_version: "system_current",
  186. static_libs: ["baz"],
  187. }
  188. java_library {
  189. name: "bar",
  190. sdk_version: "current",
  191. srcs: ["b.java"],
  192. }
  193. java_library {
  194. name: "baz",
  195. sdk_version: "system_current",
  196. srcs: ["c.java"],
  197. }
  198. `)
  199. testJavaError(t, "Adjust sdk_version: property of the source or target module so that target module is built with the same or smaller API set than the source.", `
  200. java_library {
  201. name: "foo",
  202. srcs: ["a.java"],
  203. libs: ["bar"],
  204. sdk_version: "system_current",
  205. static_libs: ["baz"],
  206. }
  207. java_library {
  208. name: "bar",
  209. sdk_version: "current",
  210. srcs: ["b.java"],
  211. }
  212. java_library {
  213. name: "baz",
  214. srcs: ["c.java"],
  215. }
  216. `)
  217. }
  218. func TestSimple(t *testing.T) {
  219. ctx, _ := testJava(t, `
  220. java_library {
  221. name: "foo",
  222. srcs: ["a.java"],
  223. libs: ["bar"],
  224. static_libs: ["baz"],
  225. }
  226. java_library {
  227. name: "bar",
  228. srcs: ["b.java"],
  229. }
  230. java_library {
  231. name: "baz",
  232. srcs: ["c.java"],
  233. }
  234. `)
  235. javac := ctx.ModuleForTests("foo", "android_common").Rule("javac")
  236. combineJar := ctx.ModuleForTests("foo", "android_common").Description("for javac")
  237. if len(javac.Inputs) != 1 || javac.Inputs[0].String() != "a.java" {
  238. t.Errorf(`foo inputs %v != ["a.java"]`, javac.Inputs)
  239. }
  240. baz := ctx.ModuleForTests("baz", "android_common").Rule("javac").Output.String()
  241. barTurbine := filepath.Join(buildDir, ".intermediates", "bar", "android_common", "turbine-combined", "bar.jar")
  242. bazTurbine := filepath.Join(buildDir, ".intermediates", "baz", "android_common", "turbine-combined", "baz.jar")
  243. if !strings.Contains(javac.Args["classpath"], barTurbine) {
  244. t.Errorf("foo classpath %v does not contain %q", javac.Args["classpath"], barTurbine)
  245. }
  246. if !strings.Contains(javac.Args["classpath"], bazTurbine) {
  247. t.Errorf("foo classpath %v does not contain %q", javac.Args["classpath"], bazTurbine)
  248. }
  249. if len(combineJar.Inputs) != 2 || combineJar.Inputs[1].String() != baz {
  250. t.Errorf("foo combineJar inputs %v does not contain %q", combineJar.Inputs, baz)
  251. }
  252. }
  253. func TestExportedPlugins(t *testing.T) {
  254. type Result struct {
  255. library string
  256. processors string
  257. }
  258. var tests = []struct {
  259. name string
  260. extra string
  261. results []Result
  262. }{
  263. {
  264. name: "Exported plugin is not a direct plugin",
  265. extra: `java_library { name: "exports", srcs: ["a.java"], exported_plugins: ["plugin"] }`,
  266. results: []Result{{library: "exports", processors: "-proc:none"}},
  267. },
  268. {
  269. name: "Exports plugin to dependee",
  270. extra: `
  271. java_library{name: "exports", exported_plugins: ["plugin"]}
  272. java_library{name: "foo", srcs: ["a.java"], libs: ["exports"]}
  273. java_library{name: "bar", srcs: ["a.java"], static_libs: ["exports"]}
  274. `,
  275. results: []Result{
  276. {library: "foo", processors: "-processor com.android.TestPlugin"},
  277. {library: "bar", processors: "-processor com.android.TestPlugin"},
  278. },
  279. },
  280. {
  281. name: "Exports plugin to android_library",
  282. extra: `
  283. java_library{name: "exports", exported_plugins: ["plugin"]}
  284. android_library{name: "foo", srcs: ["a.java"], libs: ["exports"]}
  285. android_library{name: "bar", srcs: ["a.java"], static_libs: ["exports"]}
  286. `,
  287. results: []Result{
  288. {library: "foo", processors: "-processor com.android.TestPlugin"},
  289. {library: "bar", processors: "-processor com.android.TestPlugin"},
  290. },
  291. },
  292. {
  293. name: "Exports plugin is not propagated via transitive deps",
  294. extra: `
  295. java_library{name: "exports", exported_plugins: ["plugin"]}
  296. java_library{name: "foo", srcs: ["a.java"], libs: ["exports"]}
  297. java_library{name: "bar", srcs: ["a.java"], static_libs: ["foo"]}
  298. `,
  299. results: []Result{
  300. {library: "foo", processors: "-processor com.android.TestPlugin"},
  301. {library: "bar", processors: "-proc:none"},
  302. },
  303. },
  304. {
  305. name: "Exports plugin appends to plugins",
  306. extra: `
  307. java_plugin{name: "plugin2", processor_class: "com.android.TestPlugin2"}
  308. java_library{name: "exports", exported_plugins: ["plugin"]}
  309. java_library{name: "foo", srcs: ["a.java"], libs: ["exports"], plugins: ["plugin2"]}
  310. `,
  311. results: []Result{
  312. {library: "foo", processors: "-processor com.android.TestPlugin,com.android.TestPlugin2"},
  313. },
  314. },
  315. }
  316. for _, test := range tests {
  317. t.Run(test.name, func(t *testing.T) {
  318. ctx, _ := testJava(t, `
  319. java_plugin {
  320. name: "plugin",
  321. processor_class: "com.android.TestPlugin",
  322. }
  323. `+test.extra)
  324. for _, want := range test.results {
  325. javac := ctx.ModuleForTests(want.library, "android_common").Rule("javac")
  326. if javac.Args["processor"] != want.processors {
  327. t.Errorf("For library %v, expected %v, found %v", want.library, want.processors, javac.Args["processor"])
  328. }
  329. }
  330. })
  331. }
  332. }
  333. func TestSdkVersionByPartition(t *testing.T) {
  334. testJavaError(t, "sdk_version must have a value when the module is located at vendor or product", `
  335. java_library {
  336. name: "foo",
  337. srcs: ["a.java"],
  338. vendor: true,
  339. }
  340. `)
  341. testJava(t, `
  342. java_library {
  343. name: "bar",
  344. srcs: ["b.java"],
  345. }
  346. `)
  347. for _, enforce := range []bool{true, false} {
  348. bp := `
  349. java_library {
  350. name: "foo",
  351. srcs: ["a.java"],
  352. product_specific: true,
  353. }
  354. `
  355. config := testConfig(nil, bp, nil)
  356. config.TestProductVariables.EnforceProductPartitionInterface = proptools.BoolPtr(enforce)
  357. if enforce {
  358. testJavaErrorWithConfig(t, "sdk_version must have a value when the module is located at vendor or product", config)
  359. } else {
  360. testJavaWithConfig(t, config)
  361. }
  362. }
  363. }
  364. func TestArchSpecific(t *testing.T) {
  365. ctx, _ := testJava(t, `
  366. java_library {
  367. name: "foo",
  368. srcs: ["a.java"],
  369. target: {
  370. android: {
  371. srcs: ["b.java"],
  372. },
  373. },
  374. }
  375. `)
  376. javac := ctx.ModuleForTests("foo", "android_common").Rule("javac")
  377. if len(javac.Inputs) != 2 || javac.Inputs[0].String() != "a.java" || javac.Inputs[1].String() != "b.java" {
  378. t.Errorf(`foo inputs %v != ["a.java", "b.java"]`, javac.Inputs)
  379. }
  380. }
  381. func TestBinary(t *testing.T) {
  382. ctx, _ := testJava(t, `
  383. java_library_host {
  384. name: "foo",
  385. srcs: ["a.java"],
  386. }
  387. java_binary_host {
  388. name: "bar",
  389. srcs: ["b.java"],
  390. static_libs: ["foo"],
  391. }
  392. `)
  393. buildOS := android.BuildOs.String()
  394. bar := ctx.ModuleForTests("bar", buildOS+"_common")
  395. barJar := bar.Output("bar.jar").Output.String()
  396. barWrapper := ctx.ModuleForTests("bar", buildOS+"_x86_64")
  397. barWrapperDeps := barWrapper.Output("bar").Implicits.Strings()
  398. // Test that the install binary wrapper depends on the installed jar file
  399. if len(barWrapperDeps) != 1 || barWrapperDeps[0] != barJar {
  400. t.Errorf("expected binary wrapper implicits [%q], got %v",
  401. barJar, barWrapperDeps)
  402. }
  403. }
  404. func TestHostBinaryNoJavaDebugInfoOverride(t *testing.T) {
  405. bp := `
  406. java_library {
  407. name: "target_library",
  408. srcs: ["a.java"],
  409. }
  410. java_binary_host {
  411. name: "host_binary",
  412. srcs: ["b.java"],
  413. }
  414. `
  415. config := testConfig(nil, bp, nil)
  416. config.TestProductVariables.MinimizeJavaDebugInfo = proptools.BoolPtr(true)
  417. ctx, _ := testJavaWithConfig(t, config)
  418. // first, check that the -g flag is added to target modules
  419. targetLibrary := ctx.ModuleForTests("target_library", "android_common")
  420. targetJavaFlags := targetLibrary.Module().VariablesForTests()["javacFlags"]
  421. if !strings.Contains(targetJavaFlags, "-g:source,lines") {
  422. t.Errorf("target library javac flags %v should contain "+
  423. "-g:source,lines override with MinimizeJavaDebugInfo", targetJavaFlags)
  424. }
  425. // check that -g is not overridden for host modules
  426. buildOS := android.BuildOs.String()
  427. hostBinary := ctx.ModuleForTests("host_binary", buildOS+"_common")
  428. hostJavaFlags := hostBinary.Module().VariablesForTests()["javacFlags"]
  429. if strings.Contains(hostJavaFlags, "-g:source,lines") {
  430. t.Errorf("java_binary_host javac flags %v should not have "+
  431. "-g:source,lines override with MinimizeJavaDebugInfo", hostJavaFlags)
  432. }
  433. }
  434. func TestPrebuilts(t *testing.T) {
  435. ctx, _ := testJava(t, `
  436. java_library {
  437. name: "foo",
  438. srcs: ["a.java", ":stubs-source"],
  439. libs: ["bar", "sdklib"],
  440. static_libs: ["baz"],
  441. }
  442. java_import {
  443. name: "bar",
  444. jars: ["a.jar"],
  445. }
  446. java_import {
  447. name: "baz",
  448. jars: ["b.jar"],
  449. sdk_version: "current",
  450. compile_dex: true,
  451. }
  452. dex_import {
  453. name: "qux",
  454. jars: ["b.jar"],
  455. }
  456. java_sdk_library_import {
  457. name: "sdklib",
  458. public: {
  459. jars: ["c.jar"],
  460. },
  461. }
  462. prebuilt_stubs_sources {
  463. name: "stubs-source",
  464. srcs: ["stubs/sources"],
  465. }
  466. java_test_import {
  467. name: "test",
  468. jars: ["a.jar"],
  469. test_suites: ["cts"],
  470. test_config: "AndroidTest.xml",
  471. }
  472. `)
  473. fooModule := ctx.ModuleForTests("foo", "android_common")
  474. javac := fooModule.Rule("javac")
  475. combineJar := ctx.ModuleForTests("foo", "android_common").Description("for javac")
  476. barModule := ctx.ModuleForTests("bar", "android_common")
  477. barJar := barModule.Rule("combineJar").Output
  478. bazModule := ctx.ModuleForTests("baz", "android_common")
  479. bazJar := bazModule.Rule("combineJar").Output
  480. sdklibStubsJar := ctx.ModuleForTests("sdklib.stubs", "android_common").Rule("combineJar").Output
  481. fooLibrary := fooModule.Module().(*Library)
  482. assertDeepEquals(t, "foo java sources incorrect",
  483. []string{"a.java"}, fooLibrary.compiledJavaSrcs.Strings())
  484. assertDeepEquals(t, "foo java source jars incorrect",
  485. []string{".intermediates/stubs-source/android_common/stubs-source-stubs.srcjar"},
  486. android.NormalizePathsForTesting(fooLibrary.compiledSrcJars))
  487. if !strings.Contains(javac.Args["classpath"], barJar.String()) {
  488. t.Errorf("foo classpath %v does not contain %q", javac.Args["classpath"], barJar.String())
  489. }
  490. barDexJar := barModule.Module().(*Import).DexJarBuildPath()
  491. if barDexJar != nil {
  492. t.Errorf("bar dex jar build path expected to be nil, got %q", barDexJar)
  493. }
  494. if !strings.Contains(javac.Args["classpath"], sdklibStubsJar.String()) {
  495. t.Errorf("foo classpath %v does not contain %q", javac.Args["classpath"], sdklibStubsJar.String())
  496. }
  497. if len(combineJar.Inputs) != 2 || combineJar.Inputs[1].String() != bazJar.String() {
  498. t.Errorf("foo combineJar inputs %v does not contain %q", combineJar.Inputs, bazJar.String())
  499. }
  500. bazDexJar := bazModule.Module().(*Import).DexJarBuildPath().String()
  501. expectedDexJar := buildDir + "/.intermediates/baz/android_common/dex/baz.jar"
  502. if bazDexJar != expectedDexJar {
  503. t.Errorf("baz dex jar build path expected %q, got %q", expectedDexJar, bazDexJar)
  504. }
  505. ctx.ModuleForTests("qux", "android_common").Rule("Cp")
  506. }
  507. func assertDeepEquals(t *testing.T, message string, expected interface{}, actual interface{}) {
  508. if !reflect.DeepEqual(expected, actual) {
  509. t.Errorf("%s: expected %q, found %q", message, expected, actual)
  510. }
  511. }
  512. func TestJavaSdkLibraryImport(t *testing.T) {
  513. ctx, _ := testJava(t, `
  514. java_library {
  515. name: "foo",
  516. srcs: ["a.java"],
  517. libs: ["sdklib"],
  518. sdk_version: "current",
  519. }
  520. java_library {
  521. name: "foo.system",
  522. srcs: ["a.java"],
  523. libs: ["sdklib"],
  524. sdk_version: "system_current",
  525. }
  526. java_library {
  527. name: "foo.test",
  528. srcs: ["a.java"],
  529. libs: ["sdklib"],
  530. sdk_version: "test_current",
  531. }
  532. java_sdk_library_import {
  533. name: "sdklib",
  534. public: {
  535. jars: ["a.jar"],
  536. },
  537. system: {
  538. jars: ["b.jar"],
  539. },
  540. test: {
  541. jars: ["c.jar"],
  542. stub_srcs: ["c.java"],
  543. },
  544. }
  545. `)
  546. for _, scope := range []string{"", ".system", ".test"} {
  547. fooModule := ctx.ModuleForTests("foo"+scope, "android_common")
  548. javac := fooModule.Rule("javac")
  549. sdklibStubsJar := ctx.ModuleForTests("sdklib.stubs"+scope, "android_common").Rule("combineJar").Output
  550. if !strings.Contains(javac.Args["classpath"], sdklibStubsJar.String()) {
  551. t.Errorf("foo classpath %v does not contain %q", javac.Args["classpath"], sdklibStubsJar.String())
  552. }
  553. }
  554. CheckModuleDependencies(t, ctx, "sdklib", "android_common", []string{
  555. `prebuilt_sdklib.stubs`,
  556. `prebuilt_sdklib.stubs.source.test`,
  557. `prebuilt_sdklib.stubs.system`,
  558. `prebuilt_sdklib.stubs.test`,
  559. })
  560. }
  561. func TestJavaSdkLibraryImport_WithSource(t *testing.T) {
  562. ctx, _ := testJava(t, `
  563. java_sdk_library {
  564. name: "sdklib",
  565. srcs: ["a.java"],
  566. sdk_version: "none",
  567. system_modules: "none",
  568. public: {
  569. enabled: true,
  570. },
  571. }
  572. java_sdk_library_import {
  573. name: "sdklib",
  574. public: {
  575. jars: ["a.jar"],
  576. },
  577. }
  578. `)
  579. CheckModuleDependencies(t, ctx, "sdklib", "android_common", []string{
  580. `dex2oatd`,
  581. `prebuilt_sdklib`,
  582. `sdklib.impl`,
  583. `sdklib.stubs`,
  584. `sdklib.stubs.source`,
  585. `sdklib.xml`,
  586. })
  587. CheckModuleDependencies(t, ctx, "prebuilt_sdklib", "android_common", []string{
  588. `prebuilt_sdklib.stubs`,
  589. `sdklib.impl`,
  590. // This should be prebuilt_sdklib.stubs but is set to sdklib.stubs because the
  591. // dependency is added after prebuilts may have been renamed and so has to use
  592. // the renamed name.
  593. `sdklib.xml`,
  594. })
  595. }
  596. func TestJavaSdkLibraryImport_Preferred(t *testing.T) {
  597. ctx, _ := testJava(t, `
  598. java_sdk_library {
  599. name: "sdklib",
  600. srcs: ["a.java"],
  601. sdk_version: "none",
  602. system_modules: "none",
  603. public: {
  604. enabled: true,
  605. },
  606. }
  607. java_sdk_library_import {
  608. name: "sdklib",
  609. prefer: true,
  610. public: {
  611. jars: ["a.jar"],
  612. },
  613. }
  614. `)
  615. CheckModuleDependencies(t, ctx, "sdklib", "android_common", []string{
  616. `dex2oatd`,
  617. `prebuilt_sdklib`,
  618. `sdklib.impl`,
  619. `sdklib.stubs`,
  620. `sdklib.stubs.source`,
  621. `sdklib.xml`,
  622. })
  623. CheckModuleDependencies(t, ctx, "prebuilt_sdklib", "android_common", []string{
  624. `prebuilt_sdklib.stubs`,
  625. `sdklib.impl`,
  626. `sdklib.xml`,
  627. })
  628. }
  629. func TestDefaults(t *testing.T) {
  630. ctx, _ := testJava(t, `
  631. java_defaults {
  632. name: "defaults",
  633. srcs: ["a.java"],
  634. libs: ["bar"],
  635. static_libs: ["baz"],
  636. optimize: {enabled: false},
  637. }
  638. java_library {
  639. name: "foo",
  640. defaults: ["defaults"],
  641. }
  642. java_library {
  643. name: "bar",
  644. srcs: ["b.java"],
  645. }
  646. java_library {
  647. name: "baz",
  648. srcs: ["c.java"],
  649. }
  650. android_test {
  651. name: "atestOptimize",
  652. defaults: ["defaults"],
  653. optimize: {enabled: true},
  654. }
  655. android_test {
  656. name: "atestNoOptimize",
  657. defaults: ["defaults"],
  658. }
  659. android_test {
  660. name: "atestDefault",
  661. srcs: ["a.java"],
  662. }
  663. `)
  664. javac := ctx.ModuleForTests("foo", "android_common").Rule("javac")
  665. combineJar := ctx.ModuleForTests("foo", "android_common").Description("for javac")
  666. if len(javac.Inputs) != 1 || javac.Inputs[0].String() != "a.java" {
  667. t.Errorf(`foo inputs %v != ["a.java"]`, javac.Inputs)
  668. }
  669. barTurbine := filepath.Join(buildDir, ".intermediates", "bar", "android_common", "turbine-combined", "bar.jar")
  670. if !strings.Contains(javac.Args["classpath"], barTurbine) {
  671. t.Errorf("foo classpath %v does not contain %q", javac.Args["classpath"], barTurbine)
  672. }
  673. baz := ctx.ModuleForTests("baz", "android_common").Rule("javac").Output.String()
  674. if len(combineJar.Inputs) != 2 || combineJar.Inputs[1].String() != baz {
  675. t.Errorf("foo combineJar inputs %v does not contain %q", combineJar.Inputs, baz)
  676. }
  677. atestOptimize := ctx.ModuleForTests("atestOptimize", "android_common").MaybeRule("r8")
  678. if atestOptimize.Output == nil {
  679. t.Errorf("atestOptimize should optimize APK")
  680. }
  681. atestNoOptimize := ctx.ModuleForTests("atestNoOptimize", "android_common").MaybeRule("d8")
  682. if atestNoOptimize.Output == nil {
  683. t.Errorf("atestNoOptimize should not optimize APK")
  684. }
  685. atestDefault := ctx.ModuleForTests("atestDefault", "android_common").MaybeRule("r8")
  686. if atestDefault.Output == nil {
  687. t.Errorf("atestDefault should optimize APK")
  688. }
  689. }
  690. func TestResources(t *testing.T) {
  691. var table = []struct {
  692. name string
  693. prop string
  694. extra string
  695. args string
  696. }{
  697. {
  698. // Test that a module with java_resource_dirs includes the files
  699. name: "resource dirs",
  700. prop: `java_resource_dirs: ["java-res"]`,
  701. args: "-C java-res -f java-res/a/a -f java-res/b/b",
  702. },
  703. {
  704. // Test that a module with java_resources includes the files
  705. name: "resource files",
  706. prop: `java_resources: ["java-res/a/a", "java-res/b/b"]`,
  707. args: "-C . -f java-res/a/a -f java-res/b/b",
  708. },
  709. {
  710. // Test that a module with a filegroup in java_resources includes the files with the
  711. // path prefix
  712. name: "resource filegroup",
  713. prop: `java_resources: [":foo-res"]`,
  714. extra: `
  715. filegroup {
  716. name: "foo-res",
  717. path: "java-res",
  718. srcs: ["java-res/a/a", "java-res/b/b"],
  719. }`,
  720. args: "-C java-res -f java-res/a/a -f java-res/b/b",
  721. },
  722. {
  723. // Test that a module with wildcards in java_resource_dirs has the correct path prefixes
  724. name: "wildcard dirs",
  725. prop: `java_resource_dirs: ["java-res/*"]`,
  726. args: "-C java-res/a -f java-res/a/a -C java-res/b -f java-res/b/b",
  727. },
  728. {
  729. // Test that a module exclude_java_resource_dirs excludes the files
  730. name: "wildcard dirs",
  731. prop: `java_resource_dirs: ["java-res/*"], exclude_java_resource_dirs: ["java-res/b"]`,
  732. args: "-C java-res/a -f java-res/a/a",
  733. },
  734. {
  735. // Test wildcards in java_resources
  736. name: "wildcard files",
  737. prop: `java_resources: ["java-res/**/*"]`,
  738. args: "-C . -f java-res/a/a -f java-res/b/b",
  739. },
  740. {
  741. // Test exclude_java_resources with java_resources
  742. name: "wildcard files with exclude",
  743. prop: `java_resources: ["java-res/**/*"], exclude_java_resources: ["java-res/b/*"]`,
  744. args: "-C . -f java-res/a/a",
  745. },
  746. {
  747. // Test exclude_java_resources with java_resource_dirs
  748. name: "resource dirs with exclude files",
  749. prop: `java_resource_dirs: ["java-res"], exclude_java_resources: ["java-res/b/b"]`,
  750. args: "-C java-res -f java-res/a/a",
  751. },
  752. {
  753. // Test exclude_java_resource_dirs with java_resource_dirs
  754. name: "resource dirs with exclude files",
  755. prop: `java_resource_dirs: ["java-res", "java-res2"], exclude_java_resource_dirs: ["java-res2"]`,
  756. args: "-C java-res -f java-res/a/a -f java-res/b/b",
  757. },
  758. }
  759. for _, test := range table {
  760. t.Run(test.name, func(t *testing.T) {
  761. ctx, _ := testJavaWithFS(t, `
  762. java_library {
  763. name: "foo",
  764. srcs: [
  765. "a.java",
  766. "b.java",
  767. "c.java",
  768. ],
  769. `+test.prop+`,
  770. }
  771. `+test.extra,
  772. map[string][]byte{
  773. "java-res/a/a": nil,
  774. "java-res/b/b": nil,
  775. "java-res2/a": nil,
  776. },
  777. )
  778. foo := ctx.ModuleForTests("foo", "android_common").Output("withres/foo.jar")
  779. fooRes := ctx.ModuleForTests("foo", "android_common").Output("res/foo.jar")
  780. if !inList(fooRes.Output.String(), foo.Inputs.Strings()) {
  781. t.Errorf("foo combined jars %v does not contain %q",
  782. foo.Inputs.Strings(), fooRes.Output.String())
  783. }
  784. if fooRes.Args["jarArgs"] != test.args {
  785. t.Errorf("foo resource jar args %q is not %q",
  786. fooRes.Args["jarArgs"], test.args)
  787. }
  788. })
  789. }
  790. }
  791. func TestIncludeSrcs(t *testing.T) {
  792. ctx, _ := testJavaWithFS(t, `
  793. java_library {
  794. name: "foo",
  795. srcs: [
  796. "a.java",
  797. "b.java",
  798. "c.java",
  799. ],
  800. include_srcs: true,
  801. }
  802. java_library {
  803. name: "bar",
  804. srcs: [
  805. "a.java",
  806. "b.java",
  807. "c.java",
  808. ],
  809. java_resource_dirs: ["java-res"],
  810. include_srcs: true,
  811. }
  812. `, map[string][]byte{
  813. "java-res/a/a": nil,
  814. "java-res/b/b": nil,
  815. "java-res2/a": nil,
  816. })
  817. // Test a library with include_srcs: true
  818. foo := ctx.ModuleForTests("foo", "android_common").Output("withres/foo.jar")
  819. fooSrcJar := ctx.ModuleForTests("foo", "android_common").Output("foo.srcjar")
  820. if g, w := fooSrcJar.Output.String(), foo.Inputs.Strings(); !inList(g, w) {
  821. t.Errorf("foo combined jars %v does not contain %q", w, g)
  822. }
  823. if g, w := fooSrcJar.Args["jarArgs"], "-C . -f a.java -f b.java -f c.java"; g != w {
  824. t.Errorf("foo source jar args %q is not %q", w, g)
  825. }
  826. // Test a library with include_srcs: true and resources
  827. bar := ctx.ModuleForTests("bar", "android_common").Output("withres/bar.jar")
  828. barResCombined := ctx.ModuleForTests("bar", "android_common").Output("res-combined/bar.jar")
  829. barRes := ctx.ModuleForTests("bar", "android_common").Output("res/bar.jar")
  830. barSrcJar := ctx.ModuleForTests("bar", "android_common").Output("bar.srcjar")
  831. if g, w := barSrcJar.Output.String(), barResCombined.Inputs.Strings(); !inList(g, w) {
  832. t.Errorf("bar combined resource jars %v does not contain %q", w, g)
  833. }
  834. if g, w := barRes.Output.String(), barResCombined.Inputs.Strings(); !inList(g, w) {
  835. t.Errorf("bar combined resource jars %v does not contain %q", w, g)
  836. }
  837. if g, w := barResCombined.Output.String(), bar.Inputs.Strings(); !inList(g, w) {
  838. t.Errorf("bar combined jars %v does not contain %q", w, g)
  839. }
  840. if g, w := barSrcJar.Args["jarArgs"], "-C . -f a.java -f b.java -f c.java"; g != w {
  841. t.Errorf("bar source jar args %q is not %q", w, g)
  842. }
  843. if g, w := barRes.Args["jarArgs"], "-C java-res -f java-res/a/a -f java-res/b/b"; g != w {
  844. t.Errorf("bar resource jar args %q is not %q", w, g)
  845. }
  846. }
  847. func TestGeneratedSources(t *testing.T) {
  848. ctx, _ := testJavaWithFS(t, `
  849. java_library {
  850. name: "foo",
  851. srcs: [
  852. "a*.java",
  853. ":gen",
  854. "b*.java",
  855. ],
  856. }
  857. genrule {
  858. name: "gen",
  859. tool_files: ["java-res/a"],
  860. out: ["gen.java"],
  861. }
  862. `, map[string][]byte{
  863. "a.java": nil,
  864. "b.java": nil,
  865. })
  866. javac := ctx.ModuleForTests("foo", "android_common").Rule("javac")
  867. genrule := ctx.ModuleForTests("gen", "").Rule("generator")
  868. if filepath.Base(genrule.Output.String()) != "gen.java" {
  869. t.Fatalf(`gen output file %v is not ".../gen.java"`, genrule.Output.String())
  870. }
  871. if len(javac.Inputs) != 3 ||
  872. javac.Inputs[0].String() != "a.java" ||
  873. javac.Inputs[1].String() != genrule.Output.String() ||
  874. javac.Inputs[2].String() != "b.java" {
  875. t.Errorf(`foo inputs %v != ["a.java", ".../gen.java", "b.java"]`, javac.Inputs)
  876. }
  877. }
  878. func TestTurbine(t *testing.T) {
  879. ctx, _ := testJava(t, `
  880. java_library {
  881. name: "foo",
  882. srcs: ["a.java"],
  883. sdk_version: "14",
  884. }
  885. java_library {
  886. name: "bar",
  887. srcs: ["b.java"],
  888. static_libs: ["foo"],
  889. sdk_version: "14",
  890. }
  891. java_library {
  892. name: "baz",
  893. srcs: ["c.java"],
  894. libs: ["bar"],
  895. sdk_version: "14",
  896. }
  897. `)
  898. fooTurbine := ctx.ModuleForTests("foo", "android_common").Rule("turbine")
  899. barTurbine := ctx.ModuleForTests("bar", "android_common").Rule("turbine")
  900. barJavac := ctx.ModuleForTests("bar", "android_common").Rule("javac")
  901. barTurbineCombined := ctx.ModuleForTests("bar", "android_common").Description("for turbine")
  902. bazJavac := ctx.ModuleForTests("baz", "android_common").Rule("javac")
  903. if len(fooTurbine.Inputs) != 1 || fooTurbine.Inputs[0].String() != "a.java" {
  904. t.Errorf(`foo inputs %v != ["a.java"]`, fooTurbine.Inputs)
  905. }
  906. fooHeaderJar := filepath.Join(buildDir, ".intermediates", "foo", "android_common", "turbine-combined", "foo.jar")
  907. if !strings.Contains(barTurbine.Args["classpath"], fooHeaderJar) {
  908. t.Errorf("bar turbine classpath %v does not contain %q", barTurbine.Args["classpath"], fooHeaderJar)
  909. }
  910. if !strings.Contains(barJavac.Args["classpath"], fooHeaderJar) {
  911. t.Errorf("bar javac classpath %v does not contain %q", barJavac.Args["classpath"], fooHeaderJar)
  912. }
  913. if len(barTurbineCombined.Inputs) != 2 || barTurbineCombined.Inputs[1].String() != fooHeaderJar {
  914. t.Errorf("bar turbine combineJar inputs %v does not contain %q", barTurbineCombined.Inputs, fooHeaderJar)
  915. }
  916. if !strings.Contains(bazJavac.Args["classpath"], "prebuilts/sdk/14/public/android.jar") {
  917. t.Errorf("baz javac classpath %v does not contain %q", bazJavac.Args["classpath"],
  918. "prebuilts/sdk/14/public/android.jar")
  919. }
  920. }
  921. func TestSharding(t *testing.T) {
  922. ctx, _ := testJava(t, `
  923. java_library {
  924. name: "bar",
  925. srcs: ["a.java","b.java","c.java"],
  926. javac_shard_size: 1
  927. }
  928. `)
  929. barHeaderJar := filepath.Join(buildDir, ".intermediates", "bar", "android_common", "turbine-combined", "bar.jar")
  930. for i := 0; i < 3; i++ {
  931. barJavac := ctx.ModuleForTests("bar", "android_common").Description("javac" + strconv.Itoa(i))
  932. if !strings.Contains(barJavac.Args["classpath"], barHeaderJar) {
  933. t.Errorf("bar javac classpath %v does not contain %q", barJavac.Args["classpath"], barHeaderJar)
  934. }
  935. }
  936. }
  937. func TestDroiddoc(t *testing.T) {
  938. ctx, _ := testJavaWithFS(t, `
  939. droiddoc_exported_dir {
  940. name: "droiddoc-templates-sdk",
  941. path: ".",
  942. }
  943. filegroup {
  944. name: "bar-doc-aidl-srcs",
  945. srcs: ["bar-doc/IBar.aidl"],
  946. path: "bar-doc",
  947. }
  948. droidstubs {
  949. name: "bar-stubs",
  950. srcs: [
  951. "bar-doc/a.java",
  952. ],
  953. exclude_srcs: [
  954. "bar-doc/b.java"
  955. ],
  956. api_levels_annotations_dirs: [
  957. "droiddoc-templates-sdk",
  958. ],
  959. api_levels_annotations_enabled: true,
  960. }
  961. droiddoc {
  962. name: "bar-doc",
  963. srcs: [
  964. ":bar-stubs",
  965. "bar-doc/IFoo.aidl",
  966. ":bar-doc-aidl-srcs",
  967. ],
  968. custom_template: "droiddoc-templates-sdk",
  969. hdf: [
  970. "android.whichdoc offline",
  971. ],
  972. knowntags: [
  973. "bar-doc/known_oj_tags.txt",
  974. ],
  975. proofread_file: "libcore-proofread.txt",
  976. todo_file: "libcore-docs-todo.html",
  977. flags: ["-offlinemode -title \"libcore\""],
  978. }
  979. `,
  980. map[string][]byte{
  981. "bar-doc/a.java": nil,
  982. "bar-doc/b.java": nil,
  983. })
  984. barStubs := ctx.ModuleForTests("bar-stubs", "android_common")
  985. barStubsOutputs, err := barStubs.Module().(*Droidstubs).OutputFiles("")
  986. if err != nil {
  987. t.Errorf("Unexpected error %q retrieving \"bar-stubs\" output file", err)
  988. }
  989. if len(barStubsOutputs) != 1 {
  990. t.Errorf("Expected one output from \"bar-stubs\" got %s", barStubsOutputs)
  991. }
  992. barStubsOutput := barStubsOutputs[0]
  993. barDoc := ctx.ModuleForTests("bar-doc", "android_common")
  994. javaDoc := barDoc.Rule("javadoc")
  995. if g, w := javaDoc.Implicits.Strings(), barStubsOutput.String(); !inList(w, g) {
  996. t.Errorf("implicits of bar-doc must contain %q, but was %q.", w, g)
  997. }
  998. expected := "-sourcepath " + buildDir + "/.intermediates/bar-doc/android_common/srcjars "
  999. if !strings.Contains(javaDoc.RuleParams.Command, expected) {
  1000. t.Errorf("bar-doc command does not contain flag %q, but should\n%q", expected, javaDoc.RuleParams.Command)
  1001. }
  1002. aidl := barDoc.Rule("aidl")
  1003. if g, w := javaDoc.Implicits.Strings(), aidl.Output.String(); !inList(w, g) {
  1004. t.Errorf("implicits of bar-doc must contain %q, but was %q.", w, g)
  1005. }
  1006. if g, w := aidl.Implicits.Strings(), []string{"bar-doc/IBar.aidl", "bar-doc/IFoo.aidl"}; !reflect.DeepEqual(w, g) {
  1007. t.Errorf("aidl inputs must be %q, but was %q", w, g)
  1008. }
  1009. }
  1010. func TestDroiddocArgsAndFlagsCausesError(t *testing.T) {
  1011. testJavaError(t, "flags is set. Cannot set args", `
  1012. droiddoc_exported_dir {
  1013. name: "droiddoc-templates-sdk",
  1014. path: ".",
  1015. }
  1016. filegroup {
  1017. name: "bar-doc-aidl-srcs",
  1018. srcs: ["bar-doc/IBar.aidl"],
  1019. path: "bar-doc",
  1020. }
  1021. droidstubs {
  1022. name: "bar-stubs",
  1023. srcs: [
  1024. "bar-doc/a.java",
  1025. ],
  1026. exclude_srcs: [
  1027. "bar-doc/b.java"
  1028. ],
  1029. api_levels_annotations_dirs: [
  1030. "droiddoc-templates-sdk",
  1031. ],
  1032. api_levels_annotations_enabled: true,
  1033. }
  1034. droiddoc {
  1035. name: "bar-doc",
  1036. srcs: [
  1037. ":bar-stubs",
  1038. "bar-doc/IFoo.aidl",
  1039. ":bar-doc-aidl-srcs",
  1040. ],
  1041. custom_template: "droiddoc-templates-sdk",
  1042. hdf: [
  1043. "android.whichdoc offline",
  1044. ],
  1045. knowntags: [
  1046. "bar-doc/known_oj_tags.txt",
  1047. ],
  1048. proofread_file: "libcore-proofread.txt",
  1049. todo_file: "libcore-docs-todo.html",
  1050. flags: ["-offlinemode -title \"libcore\""],
  1051. args: "-offlinemode -title \"libcore\"",
  1052. }
  1053. `)
  1054. }
  1055. func TestDroidstubs(t *testing.T) {
  1056. ctx, _ := testJavaWithFS(t, `
  1057. droiddoc_exported_dir {
  1058. name: "droiddoc-templates-sdk",
  1059. path: ".",
  1060. }
  1061. droidstubs {
  1062. name: "bar-stubs",
  1063. srcs: [
  1064. "bar-doc/a.java",
  1065. ],
  1066. api_levels_annotations_dirs: [
  1067. "droiddoc-templates-sdk",
  1068. ],
  1069. api_levels_annotations_enabled: true,
  1070. }
  1071. droidstubs {
  1072. name: "bar-stubs-other",
  1073. srcs: [
  1074. "bar-doc/a.java",
  1075. ],
  1076. api_levels_annotations_dirs: [
  1077. "droiddoc-templates-sdk",
  1078. ],
  1079. api_levels_annotations_enabled: true,
  1080. api_levels_jar_filename: "android.other.jar",
  1081. }
  1082. `,
  1083. map[string][]byte{
  1084. "bar-doc/a.java": nil,
  1085. })
  1086. testcases := []struct {
  1087. moduleName string
  1088. expectedJarFilename string
  1089. }{
  1090. {
  1091. moduleName: "bar-stubs",
  1092. expectedJarFilename: "android.jar",
  1093. },
  1094. {
  1095. moduleName: "bar-stubs-other",
  1096. expectedJarFilename: "android.other.jar",
  1097. },
  1098. }
  1099. for _, c := range testcases {
  1100. m := ctx.ModuleForTests(c.moduleName, "android_common")
  1101. metalava := m.Rule("metalava")
  1102. expected := "--android-jar-pattern ./%/public/" + c.expectedJarFilename
  1103. if actual := metalava.RuleParams.Command; !strings.Contains(actual, expected) {
  1104. t.Errorf("For %q, expected metalava argument %q, but was not found %q", c.moduleName, expected, actual)
  1105. }
  1106. }
  1107. }
  1108. func TestDroidstubsWithSystemModules(t *testing.T) {
  1109. ctx, _ := testJava(t, `
  1110. droidstubs {
  1111. name: "stubs-source-system-modules",
  1112. srcs: [
  1113. "bar-doc/a.java",
  1114. ],
  1115. sdk_version: "none",
  1116. system_modules: "source-system-modules",
  1117. }
  1118. java_library {
  1119. name: "source-jar",
  1120. srcs: [
  1121. "a.java",
  1122. ],
  1123. }
  1124. java_system_modules {
  1125. name: "source-system-modules",
  1126. libs: ["source-jar"],
  1127. }
  1128. droidstubs {
  1129. name: "stubs-prebuilt-system-modules",
  1130. srcs: [
  1131. "bar-doc/a.java",
  1132. ],
  1133. sdk_version: "none",
  1134. system_modules: "prebuilt-system-modules",
  1135. }
  1136. java_import {
  1137. name: "prebuilt-jar",
  1138. jars: ["a.jar"],
  1139. }
  1140. java_system_modules_import {
  1141. name: "prebuilt-system-modules",
  1142. libs: ["prebuilt-jar"],
  1143. }
  1144. `)
  1145. checkSystemModulesUseByDroidstubs(t, ctx, "stubs-source-system-modules", "source-jar.jar")
  1146. checkSystemModulesUseByDroidstubs(t, ctx, "stubs-prebuilt-system-modules", "prebuilt-jar.jar")
  1147. }
  1148. func checkSystemModulesUseByDroidstubs(t *testing.T, ctx *android.TestContext, moduleName string, systemJar string) {
  1149. metalavaRule := ctx.ModuleForTests(moduleName, "android_common").Rule("metalava")
  1150. var systemJars []string
  1151. for _, i := range metalavaRule.Implicits {
  1152. systemJars = append(systemJars, i.Base())
  1153. }
  1154. if len(systemJars) < 1 || systemJars[0] != systemJar {
  1155. t.Errorf("inputs of %q must be []string{%q}, but was %#v.", moduleName, systemJar, systemJars)
  1156. }
  1157. }
  1158. func TestJarGenrules(t *testing.T) {
  1159. ctx, _ := testJava(t, `
  1160. java_library {
  1161. name: "foo",
  1162. srcs: ["a.java"],
  1163. }
  1164. java_genrule {
  1165. name: "jargen",
  1166. tool_files: ["b.java"],
  1167. cmd: "$(location b.java) $(in) $(out)",
  1168. out: ["jargen.jar"],
  1169. srcs: [":foo"],
  1170. }
  1171. java_library {
  1172. name: "bar",
  1173. static_libs: ["jargen"],
  1174. srcs: ["c.java"],
  1175. }
  1176. java_library {
  1177. name: "baz",
  1178. libs: ["jargen"],
  1179. srcs: ["c.java"],
  1180. }
  1181. `)
  1182. foo := ctx.ModuleForTests("foo", "android_common").Output("javac/foo.jar")
  1183. jargen := ctx.ModuleForTests("jargen", "android_common").Output("jargen.jar")
  1184. bar := ctx.ModuleForTests("bar", "android_common").Output("javac/bar.jar")
  1185. baz := ctx.ModuleForTests("baz", "android_common").Output("javac/baz.jar")
  1186. barCombined := ctx.ModuleForTests("bar", "android_common").Output("combined/bar.jar")
  1187. if len(jargen.Inputs) != 1 || jargen.Inputs[0].String() != foo.Output.String() {
  1188. t.Errorf("expected jargen inputs [%q], got %q", foo.Output.String(), jargen.Inputs.Strings())
  1189. }
  1190. if !strings.Contains(bar.Args["classpath"], jargen.Output.String()) {
  1191. t.Errorf("bar classpath %v does not contain %q", bar.Args["classpath"], jargen.Output.String())
  1192. }
  1193. if !strings.Contains(baz.Args["classpath"], jargen.Output.String()) {
  1194. t.Errorf("baz classpath %v does not contain %q", baz.Args["classpath"], jargen.Output.String())
  1195. }
  1196. if len(barCombined.Inputs) != 2 ||
  1197. barCombined.Inputs[0].String() != bar.Output.String() ||
  1198. barCombined.Inputs[1].String() != jargen.Output.String() {
  1199. t.Errorf("bar combined jar inputs %v is not [%q, %q]",
  1200. barCombined.Inputs.Strings(), bar.Output.String(), jargen.Output.String())
  1201. }
  1202. }
  1203. func TestExcludeFileGroupInSrcs(t *testing.T) {
  1204. ctx, _ := testJava(t, `
  1205. java_library {
  1206. name: "foo",
  1207. srcs: ["a.java", ":foo-srcs"],
  1208. exclude_srcs: ["a.java", ":foo-excludes"],
  1209. }
  1210. filegroup {
  1211. name: "foo-srcs",
  1212. srcs: ["java-fg/a.java", "java-fg/b.java", "java-fg/c.java"],
  1213. }
  1214. filegroup {
  1215. name: "foo-excludes",
  1216. srcs: ["java-fg/a.java", "java-fg/b.java"],
  1217. }
  1218. `)
  1219. javac := ctx.ModuleForTests("foo", "android_common").Rule("javac")
  1220. if len(javac.Inputs) != 1 || javac.Inputs[0].String() != "java-fg/c.java" {
  1221. t.Errorf(`foo inputs %v != ["java-fg/c.java"]`, javac.Inputs)
  1222. }
  1223. }
  1224. func TestJavaLibrary(t *testing.T) {
  1225. config := testConfig(nil, "", map[string][]byte{
  1226. "libcore/Android.bp": []byte(`
  1227. java_library {
  1228. name: "core",
  1229. sdk_version: "none",
  1230. system_modules: "none",
  1231. }
  1232. filegroup {
  1233. name: "core-jar",
  1234. srcs: [":core{.jar}"],
  1235. }
  1236. `),
  1237. })
  1238. ctx := testContext()
  1239. run(t, ctx, config)
  1240. }
  1241. func TestJavaImport(t *testing.T) {
  1242. config := testConfig(nil, "", map[string][]byte{
  1243. "libcore/Android.bp": []byte(`
  1244. java_import {
  1245. name: "core",
  1246. sdk_version: "none",
  1247. }
  1248. filegroup {
  1249. name: "core-jar",
  1250. srcs: [":core{.jar}"],
  1251. }
  1252. `),
  1253. })
  1254. ctx := testContext()
  1255. run(t, ctx, config)
  1256. }
  1257. func TestJavaSdkLibrary(t *testing.T) {
  1258. ctx, _ := testJava(t, `
  1259. droiddoc_exported_dir {
  1260. name: "droiddoc-templates-sdk",
  1261. path: ".",
  1262. }
  1263. java_sdk_library {
  1264. name: "foo",
  1265. srcs: ["a.java", "b.java"],
  1266. api_packages: ["foo"],
  1267. }
  1268. java_sdk_library {
  1269. name: "bar",
  1270. srcs: ["a.java", "b.java"],
  1271. api_packages: ["bar"],
  1272. }
  1273. java_library {
  1274. name: "baz",
  1275. srcs: ["c.java"],
  1276. libs: ["foo", "bar.stubs"],
  1277. sdk_version: "system_current",
  1278. }
  1279. java_sdk_library {
  1280. name: "barney",
  1281. srcs: ["c.java"],
  1282. api_only: true,
  1283. }
  1284. java_sdk_library {
  1285. name: "betty",
  1286. srcs: ["c.java"],
  1287. shared_library: false,
  1288. }
  1289. java_sdk_library_import {
  1290. name: "quuz",
  1291. public: {
  1292. jars: ["c.jar"],
  1293. },
  1294. }
  1295. java_sdk_library_import {
  1296. name: "fred",
  1297. public: {
  1298. jars: ["b.jar"],
  1299. },
  1300. }
  1301. java_sdk_library_import {
  1302. name: "wilma",
  1303. public: {
  1304. jars: ["b.jar"],
  1305. },
  1306. shared_library: false,
  1307. }
  1308. java_library {
  1309. name: "qux",
  1310. srcs: ["c.java"],
  1311. libs: ["baz", "fred", "quuz.stubs", "wilma", "barney", "betty"],
  1312. sdk_version: "system_current",
  1313. }
  1314. java_library {
  1315. name: "baz-test",
  1316. srcs: ["c.java"],
  1317. libs: ["foo"],
  1318. sdk_version: "test_current",
  1319. }
  1320. java_library {
  1321. name: "baz-29",
  1322. srcs: ["c.java"],
  1323. libs: ["foo"],
  1324. sdk_version: "system_29",
  1325. }
  1326. java_library {
  1327. name: "baz-module-30",
  1328. srcs: ["c.java"],
  1329. libs: ["foo"],
  1330. sdk_version: "module_30",
  1331. }
  1332. `)
  1333. // check the existence of the internal modules
  1334. ctx.ModuleForTests("foo", "android_common")
  1335. ctx.ModuleForTests(apiScopePublic.stubsLibraryModuleName("foo"), "android_common")
  1336. ctx.ModuleForTests(apiScopeSystem.stubsLibraryModuleName("foo"), "android_common")
  1337. ctx.ModuleForTests(apiScopeTest.stubsLibraryModuleName("foo"), "android_common")
  1338. ctx.ModuleForTests(apiScopePublic.stubsSourceModuleName("foo"), "android_common")
  1339. ctx.ModuleForTests(apiScopeSystem.stubsSourceModuleName("foo"), "android_common")
  1340. ctx.ModuleForTests(apiScopeTest.stubsSourceModuleName("foo"), "android_common")
  1341. ctx.ModuleForTests("foo"+sdkXmlFileSuffix, "android_common")
  1342. ctx.ModuleForTests("foo.api.public.28", "")
  1343. ctx.ModuleForTests("foo.api.system.28", "")
  1344. ctx.ModuleForTests("foo.api.test.28", "")
  1345. bazJavac := ctx.ModuleForTests("baz", "android_common").Rule("javac")
  1346. // tests if baz is actually linked to the stubs lib
  1347. if !strings.Contains(bazJavac.Args["classpath"], "foo.stubs.system.jar") {
  1348. t.Errorf("baz javac classpath %v does not contain %q", bazJavac.Args["classpath"],
  1349. "foo.stubs.system.jar")
  1350. }
  1351. // ... and not to the impl lib
  1352. if strings.Contains(bazJavac.Args["classpath"], "foo.jar") {
  1353. t.Errorf("baz javac classpath %v should not contain %q", bazJavac.Args["classpath"],
  1354. "foo.jar")
  1355. }
  1356. // test if baz is not linked to the system variant of foo
  1357. if strings.Contains(bazJavac.Args["classpath"], "foo.stubs.jar") {
  1358. t.Errorf("baz javac classpath %v should not contain %q", bazJavac.Args["classpath"],
  1359. "foo.stubs.jar")
  1360. }
  1361. bazTestJavac := ctx.ModuleForTests("baz-test", "android_common").Rule("javac")
  1362. // tests if baz-test is actually linked to the test stubs lib
  1363. if !strings.Contains(bazTestJavac.Args["classpath"], "foo.stubs.test.jar") {
  1364. t.Errorf("baz-test javac classpath %v does not contain %q", bazTestJavac.Args["classpath"],
  1365. "foo.stubs.test.jar")
  1366. }
  1367. baz29Javac := ctx.ModuleForTests("baz-29", "android_common").Rule("javac")
  1368. // tests if baz-29 is actually linked to the system 29 stubs lib
  1369. if !strings.Contains(baz29Javac.Args["classpath"], "prebuilts/sdk/29/system/foo.jar") {
  1370. t.Errorf("baz-29 javac classpath %v does not contain %q", baz29Javac.Args["classpath"],
  1371. "prebuilts/sdk/29/system/foo.jar")
  1372. }
  1373. bazModule30Javac := ctx.ModuleForTests("baz-module-30", "android_common").Rule("javac")
  1374. // tests if "baz-module-30" is actually linked to the module 30 stubs lib
  1375. if !strings.Contains(bazModule30Javac.Args["classpath"], "prebuilts/sdk/30/module-lib/foo.jar") {
  1376. t.Errorf("baz-module-30 javac classpath %v does not contain %q", bazModule30Javac.Args["classpath"],
  1377. "prebuilts/sdk/30/module-lib/foo.jar")
  1378. }
  1379. // test if baz has exported SDK lib names foo and bar to qux
  1380. qux := ctx.ModuleForTests("qux", "android_common")
  1381. if quxLib, ok := qux.Module().(*Library); ok {
  1382. sdkLibs := android.SortedStringKeys(quxLib.ExportedSdkLibs())
  1383. if w := []string{"bar", "foo", "fred", "quuz"}; !reflect.DeepEqual(w, sdkLibs) {
  1384. t.Errorf("qux should export %q but exports %q", w, sdkLibs)
  1385. }
  1386. }
  1387. }
  1388. func TestJavaSdkLibrary_DoNotAccessImplWhenItIsNotBuilt(t *testing.T) {
  1389. ctx, _ := testJava(t, `
  1390. java_sdk_library {
  1391. name: "foo",
  1392. srcs: ["a.java"],
  1393. api_only: true,
  1394. public: {
  1395. enabled: true,
  1396. },
  1397. }
  1398. java_library {
  1399. name: "bar",
  1400. srcs: ["b.java"],
  1401. libs: ["foo"],
  1402. }
  1403. `)
  1404. // The bar library should depend on the stubs jar.
  1405. barLibrary := ctx.ModuleForTests("bar", "android_common").Rule("javac")
  1406. if expected, actual := `^-classpath .*:/[^:]*/turbine-combined/foo\.stubs\.jar$`, barLibrary.Args["classpath"]; !regexp.MustCompile(expected).MatchString(actual) {
  1407. t.Errorf("expected %q, found %#q", expected, actual)
  1408. }
  1409. }
  1410. func TestJavaSdkLibrary_UseSourcesFromAnotherSdkLibrary(t *testing.T) {
  1411. testJava(t, `
  1412. java_sdk_library {
  1413. name: "foo",
  1414. srcs: ["a.java"],
  1415. api_packages: ["foo"],
  1416. public: {
  1417. enabled: true,
  1418. },
  1419. }
  1420. java_library {
  1421. name: "bar",
  1422. srcs: ["b.java", ":foo{.public.stubs.source}"],
  1423. }
  1424. `)
  1425. }
  1426. func TestJavaSdkLibrary_AccessOutputFiles_MissingScope(t *testing.T) {
  1427. testJavaError(t, `"foo" does not provide api scope system`, `
  1428. java_sdk_library {
  1429. name: "foo",
  1430. srcs: ["a.java"],
  1431. api_packages: ["foo"],
  1432. public: {
  1433. enabled: true,
  1434. },
  1435. }
  1436. java_library {
  1437. name: "bar",
  1438. srcs: ["b.java", ":foo{.system.stubs.source}"],
  1439. }
  1440. `)
  1441. }
  1442. func TestJavaSdkLibrary_Deps(t *testing.T) {
  1443. ctx, _ := testJava(t, `
  1444. java_sdk_library {
  1445. name: "sdklib",
  1446. srcs: ["a.java"],
  1447. sdk_version: "none",
  1448. system_modules: "none",
  1449. public: {
  1450. enabled: true,
  1451. },
  1452. }
  1453. `)
  1454. CheckModuleDependencies(t, ctx, "sdklib", "android_common", []string{
  1455. `dex2oatd`,
  1456. `sdklib.impl`,
  1457. `sdklib.stubs`,
  1458. `sdklib.stubs.source`,
  1459. `sdklib.xml`,
  1460. })
  1461. }
  1462. func TestJavaSdkLibraryImport_AccessOutputFiles(t *testing.T) {
  1463. testJava(t, `
  1464. java_sdk_library_import {
  1465. name: "foo",
  1466. public: {
  1467. jars: ["a.jar"],
  1468. stub_srcs: ["a.java"],
  1469. current_api: "api/current.txt",
  1470. removed_api: "api/removed.txt",
  1471. },
  1472. }
  1473. java_library {
  1474. name: "bar",
  1475. srcs: [":foo{.public.stubs.source}"],
  1476. java_resources: [
  1477. ":foo{.public.api.txt}",
  1478. ":foo{.public.removed-api.txt}",
  1479. ],
  1480. }
  1481. `)
  1482. }
  1483. func TestJavaSdkLibraryImport_AccessOutputFiles_Invalid(t *testing.T) {
  1484. bp := `
  1485. java_sdk_library_import {
  1486. name: "foo",
  1487. public: {
  1488. jars: ["a.jar"],
  1489. },
  1490. }
  1491. `
  1492. t.Run("stubs.source", func(t *testing.T) {
  1493. testJavaError(t, `stubs.source not available for api scope public`, bp+`
  1494. java_library {
  1495. name: "bar",
  1496. srcs: [":foo{.public.stubs.source}"],
  1497. java_resources: [
  1498. ":foo{.public.api.txt}",
  1499. ":foo{.public.removed-api.txt}",
  1500. ],
  1501. }
  1502. `)
  1503. })
  1504. t.Run("api.txt", func(t *testing.T) {
  1505. testJavaError(t, `api.txt not available for api scope public`, bp+`
  1506. java_library {
  1507. name: "bar",
  1508. srcs: ["a.java"],
  1509. java_resources: [
  1510. ":foo{.public.api.txt}",
  1511. ],
  1512. }
  1513. `)
  1514. })
  1515. t.Run("removed-api.txt", func(t *testing.T) {
  1516. testJavaError(t, `removed-api.txt not available for api scope public`, bp+`
  1517. java_library {
  1518. name: "bar",
  1519. srcs: ["a.java"],
  1520. java_resources: [
  1521. ":foo{.public.removed-api.txt}",
  1522. ],
  1523. }
  1524. `)
  1525. })
  1526. }
  1527. func TestJavaSdkLibrary_InvalidScopes(t *testing.T) {
  1528. testJavaError(t, `module "foo": enabled api scope "system" depends on disabled scope "public"`, `
  1529. java_sdk_library {
  1530. name: "foo",
  1531. srcs: ["a.java", "b.java"],
  1532. api_packages: ["foo"],
  1533. // Explicitly disable public to test the check that ensures the set of enabled
  1534. // scopes is consistent.
  1535. public: {
  1536. enabled: false,
  1537. },
  1538. system: {
  1539. enabled: true,
  1540. },
  1541. }
  1542. `)
  1543. }
  1544. func TestJavaSdkLibrary_SdkVersion_ForScope(t *testing.T) {
  1545. testJava(t, `
  1546. java_sdk_library {
  1547. name: "foo",
  1548. srcs: ["a.java", "b.java"],
  1549. api_packages: ["foo"],
  1550. system: {
  1551. enabled: true,
  1552. sdk_version: "module_current",
  1553. },
  1554. }
  1555. `)
  1556. }
  1557. func TestJavaSdkLibrary_ModuleLib(t *testing.T) {
  1558. testJava(t, `
  1559. java_sdk_library {
  1560. name: "foo",
  1561. srcs: ["a.java", "b.java"],
  1562. api_packages: ["foo"],
  1563. system: {
  1564. enabled: true,
  1565. },
  1566. module_lib: {
  1567. enabled: true,
  1568. },
  1569. }
  1570. `)
  1571. }
  1572. func TestJavaSdkLibrary_SystemServer(t *testing.T) {
  1573. testJava(t, `
  1574. java_sdk_library {
  1575. name: "foo",
  1576. srcs: ["a.java", "b.java"],
  1577. api_packages: ["foo"],
  1578. system: {
  1579. enabled: true,
  1580. },
  1581. system_server: {
  1582. enabled: true,
  1583. },
  1584. }
  1585. `)
  1586. }
  1587. func TestJavaSdkLibrary_MissingScope(t *testing.T) {
  1588. testJavaError(t, `requires api scope module-lib from foo but it only has \[\] available`, `
  1589. java_sdk_library {
  1590. name: "foo",
  1591. srcs: ["a.java"],
  1592. public: {
  1593. enabled: false,
  1594. },
  1595. }
  1596. java_library {
  1597. name: "baz",
  1598. srcs: ["a.java"],
  1599. libs: ["foo"],
  1600. sdk_version: "module_current",
  1601. }
  1602. `)
  1603. }
  1604. func TestJavaSdkLibrary_FallbackScope(t *testing.T) {
  1605. testJava(t, `
  1606. java_sdk_library {
  1607. name: "foo",
  1608. srcs: ["a.java"],
  1609. system: {
  1610. enabled: true,
  1611. },
  1612. }
  1613. java_library {
  1614. name: "baz",
  1615. srcs: ["a.java"],
  1616. libs: ["foo"],
  1617. // foo does not have module-lib scope so it should fallback to system
  1618. sdk_version: "module_current",
  1619. }
  1620. `)
  1621. }
  1622. func TestJavaSdkLibrary_DefaultToStubs(t *testing.T) {
  1623. ctx, _ := testJava(t, `
  1624. java_sdk_library {
  1625. name: "foo",
  1626. srcs: ["a.java"],
  1627. system: {
  1628. enabled: true,
  1629. },
  1630. default_to_stubs: true,
  1631. }
  1632. java_library {
  1633. name: "baz",
  1634. srcs: ["a.java"],
  1635. libs: ["foo"],
  1636. // does not have sdk_version set, should fallback to module,
  1637. // which will then fallback to system because the module scope
  1638. // is not enabled.
  1639. }
  1640. `)
  1641. // The baz library should depend on the system stubs jar.
  1642. bazLibrary := ctx.ModuleForTests("baz", "android_common").Rule("javac")
  1643. if expected, actual := `^-classpath .*:/[^:]*/turbine-combined/foo\.stubs.system\.jar$`, bazLibrary.Args["classpath"]; !regexp.MustCompile(expected).MatchString(actual) {
  1644. t.Errorf("expected %q, found %#q", expected, actual)
  1645. }
  1646. }
  1647. var compilerFlagsTestCases = []struct {
  1648. in string
  1649. out bool
  1650. }{
  1651. {
  1652. in: "a",
  1653. out: false,
  1654. },
  1655. {
  1656. in: "-a",
  1657. out: true,
  1658. },
  1659. {
  1660. in: "-no-jdk",
  1661. out: false,
  1662. },
  1663. {
  1664. in: "-no-stdlib",
  1665. out: false,
  1666. },
  1667. {
  1668. in: "-kotlin-home",
  1669. out: false,
  1670. },
  1671. {
  1672. in: "-kotlin-home /some/path",
  1673. out: false,
  1674. },
  1675. {
  1676. in: "-include-runtime",
  1677. out: false,
  1678. },
  1679. {
  1680. in: "-Xintellij-plugin-root",
  1681. out: false,
  1682. },
  1683. }
  1684. type mockContext struct {
  1685. android.ModuleContext
  1686. result bool
  1687. }
  1688. func (ctx *mockContext) PropertyErrorf(property, format string, args ...interface{}) {
  1689. // CheckBadCompilerFlags calls this function when the flag should be rejected
  1690. ctx.result = false
  1691. }
  1692. func TestCompilerFlags(t *testing.T) {
  1693. for _, testCase := range compilerFlagsTestCases {
  1694. ctx := &mockContext{result: true}
  1695. CheckKotlincFlags(ctx, []string{testCase.in})
  1696. if ctx.result != testCase.out {
  1697. t.Errorf("incorrect output:")
  1698. t.Errorf(" input: %#v", testCase.in)
  1699. t.Errorf(" expected: %#v", testCase.out)
  1700. t.Errorf(" got: %#v", ctx.result)
  1701. }
  1702. }
  1703. }
  1704. // TODO(jungjw): Consider making this more robust by ignoring path order.
  1705. func checkPatchModuleFlag(t *testing.T, ctx *android.TestContext, moduleName string, expected string) {
  1706. variables := ctx.ModuleForTests(moduleName, "android_common").Module().VariablesForTests()
  1707. flags := strings.Split(variables["javacFlags"], " ")
  1708. got := ""
  1709. for _, flag := range flags {
  1710. keyEnd := strings.Index(flag, "=")
  1711. if keyEnd > -1 && flag[:keyEnd] == "--patch-module" {
  1712. got = flag[keyEnd+1:]
  1713. break
  1714. }
  1715. }
  1716. if expected != got {
  1717. t.Errorf("Unexpected patch-module flag for module %q - expected %q, but got %q", moduleName, expected, got)
  1718. }
  1719. }
  1720. func TestPatchModule(t *testing.T) {
  1721. t.Run("Java language level 8", func(t *testing.T) {
  1722. // Test with legacy javac -source 1.8 -target 1.8
  1723. bp := `
  1724. java_library {
  1725. name: "foo",
  1726. srcs: ["a.java"],
  1727. java_version: "1.8",
  1728. }
  1729. java_library {
  1730. name: "bar",
  1731. srcs: ["b.java"],
  1732. sdk_version: "none",
  1733. system_modules: "none",
  1734. patch_module: "java.base",
  1735. java_version: "1.8",
  1736. }
  1737. java_library {
  1738. name: "baz",
  1739. srcs: ["c.java"],
  1740. patch_module: "java.base",
  1741. java_version: "1.8",
  1742. }
  1743. `
  1744. ctx, _ := testJava(t, bp)
  1745. checkPatchModuleFlag(t, ctx, "foo", "")
  1746. checkPatchModuleFlag(t, ctx, "bar", "")
  1747. checkPatchModuleFlag(t, ctx, "baz", "")
  1748. })
  1749. t.Run("Java language level 9", func(t *testing.T) {
  1750. // Test with default javac -source 9 -target 9
  1751. bp := `
  1752. java_library {
  1753. name: "foo",
  1754. srcs: ["a.java"],
  1755. }
  1756. java_library {
  1757. name: "bar",
  1758. srcs: ["b.java"],
  1759. sdk_version: "none",
  1760. system_modules: "none",
  1761. patch_module: "java.base",
  1762. }
  1763. java_library {
  1764. name: "baz",
  1765. srcs: ["c.java"],
  1766. patch_module: "java.base",
  1767. }
  1768. `
  1769. ctx, _ := testJava(t, bp)
  1770. checkPatchModuleFlag(t, ctx, "foo", "")
  1771. expected := "java.base=.:" + buildDir
  1772. checkPatchModuleFlag(t, ctx, "bar", expected)
  1773. expected = "java.base=" + strings.Join([]string{".", buildDir, moduleToPath("ext"), moduleToPath("framework")}, ":")
  1774. checkPatchModuleFlag(t, ctx, "baz", expected)
  1775. })
  1776. }
  1777. func TestJavaSystemModules(t *testing.T) {
  1778. ctx, _ := testJava(t, `
  1779. java_system_modules {
  1780. name: "system-modules",
  1781. libs: ["system-module1", "system-module2"],
  1782. }
  1783. java_library {
  1784. name: "system-module1",
  1785. srcs: ["a.java"],
  1786. sdk_version: "none",
  1787. system_modules: "none",
  1788. }
  1789. java_library {
  1790. name: "system-module2",
  1791. srcs: ["b.java"],
  1792. sdk_version: "none",
  1793. system_modules: "none",
  1794. }
  1795. `)
  1796. // check the existence of the module
  1797. systemModules := ctx.ModuleForTests("system-modules", "android_common")
  1798. cmd := systemModules.Rule("jarsTosystemModules")
  1799. // make sure the command compiles against the supplied modules.
  1800. for _, module := range []string{"system-module1.jar", "system-module2.jar"} {
  1801. if !strings.Contains(cmd.Args["classpath"], module) {
  1802. t.Errorf("system modules classpath %v does not contain %q", cmd.Args["classpath"],
  1803. module)
  1804. }
  1805. }
  1806. }
  1807. func TestJavaSystemModulesImport(t *testing.T) {
  1808. ctx, _ := testJava(t, `
  1809. java_system_modules_import {
  1810. name: "system-modules",
  1811. libs: ["system-module1", "system-module2"],
  1812. }
  1813. java_import {
  1814. name: "system-module1",
  1815. jars: ["a.jar"],
  1816. }
  1817. java_import {
  1818. name: "system-module2",
  1819. jars: ["b.jar"],
  1820. }
  1821. `)
  1822. // check the existence of the module
  1823. systemModules := ctx.ModuleForTests("system-modules", "android_common")
  1824. cmd := systemModules.Rule("jarsTosystemModules")
  1825. // make sure the command compiles against the supplied modules.
  1826. for _, module := range []string{"system-module1.jar", "system-module2.jar"} {
  1827. if !strings.Contains(cmd.Args["classpath"], module) {
  1828. t.Errorf("system modules classpath %v does not contain %q", cmd.Args["classpath"],
  1829. module)
  1830. }
  1831. }
  1832. }
  1833. func TestJavaLibraryWithSystemModules(t *testing.T) {
  1834. ctx, _ := testJava(t, `
  1835. java_library {
  1836. name: "lib-with-source-system-modules",
  1837. srcs: [
  1838. "a.java",
  1839. ],
  1840. sdk_version: "none",
  1841. system_modules: "source-system-modules",
  1842. }
  1843. java_library {
  1844. name: "source-jar",
  1845. srcs: [
  1846. "a.java",
  1847. ],
  1848. }
  1849. java_system_modules {
  1850. name: "source-system-modules",
  1851. libs: ["source-jar"],
  1852. }
  1853. java_library {
  1854. name: "lib-with-prebuilt-system-modules",
  1855. srcs: [
  1856. "a.java",
  1857. ],
  1858. sdk_version: "none",
  1859. system_modules: "prebuilt-system-modules",
  1860. }
  1861. java_import {
  1862. name: "prebuilt-jar",
  1863. jars: ["a.jar"],
  1864. }
  1865. java_system_modules_import {
  1866. name: "prebuilt-system-modules",
  1867. libs: ["prebuilt-jar"],
  1868. }
  1869. `)
  1870. checkBootClasspathForSystemModule(t, ctx, "lib-with-source-system-modules", "/source-jar.jar")
  1871. checkBootClasspathForSystemModule(t, ctx, "lib-with-prebuilt-system-modules", "/prebuilt-jar.jar")
  1872. }
  1873. func checkBootClasspathForSystemModule(t *testing.T, ctx *android.TestContext, moduleName string, expectedSuffix string) {
  1874. javacRule := ctx.ModuleForTests(moduleName, "android_common").Rule("javac")
  1875. bootClasspath := javacRule.Args["bootClasspath"]
  1876. if strings.HasPrefix(bootClasspath, "--system ") && strings.HasSuffix(bootClasspath, expectedSuffix) {
  1877. t.Errorf("bootclasspath of %q must start with --system and end with %q, but was %#v.", moduleName, expectedSuffix, bootClasspath)
  1878. }
  1879. }
  1880. func TestAidlExportIncludeDirsFromImports(t *testing.T) {
  1881. ctx, _ := testJava(t, `
  1882. java_library {
  1883. name: "foo",
  1884. srcs: ["aidl/foo/IFoo.aidl"],
  1885. libs: ["bar"],
  1886. }
  1887. java_import {
  1888. name: "bar",
  1889. jars: ["a.jar"],
  1890. aidl: {
  1891. export_include_dirs: ["aidl/bar"],
  1892. },
  1893. }
  1894. `)
  1895. aidlCommand := ctx.ModuleForTests("foo", "android_common").Rule("aidl").RuleParams.Command
  1896. expectedAidlFlag := "-Iaidl/bar"
  1897. if !strings.Contains(aidlCommand, expectedAidlFlag) {
  1898. t.Errorf("aidl command %q does not contain %q", aidlCommand, expectedAidlFlag)
  1899. }
  1900. }
  1901. func TestDataNativeBinaries(t *testing.T) {
  1902. ctx, config := testJava(t, `
  1903. java_test_host {
  1904. name: "foo",
  1905. srcs: ["a.java"],
  1906. data_native_bins: ["bin"]
  1907. }
  1908. python_binary_host {
  1909. name: "bin",
  1910. srcs: ["bin.py"],
  1911. }
  1912. `)
  1913. buildOS := android.BuildOs.String()
  1914. test := ctx.ModuleForTests("foo", buildOS+"_common").Module().(*TestHost)
  1915. entries := android.AndroidMkEntriesForTest(t, config, "", test)[0]
  1916. expected := []string{buildDir + "/.intermediates/bin/" + buildOS + "_x86_64_PY3/bin:bin"}
  1917. actual := entries.EntryMap["LOCAL_COMPATIBILITY_SUPPORT_FILES"]
  1918. if !reflect.DeepEqual(expected, actual) {
  1919. t.Errorf("Unexpected test data - expected: %q, actual: %q", expected, actual)
  1920. }
  1921. }