sdk_library_test.go 42 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476
  1. // Copyright 2021 Google Inc. All rights reserved.
  2. //
  3. // Licensed under the Apache License, Version 2.0 (the "License");
  4. // you may not use this file except in compliance with the License.
  5. // You may obtain a copy of the License at
  6. //
  7. // http://www.apache.org/licenses/LICENSE-2.0
  8. //
  9. // Unless required by applicable law or agreed to in writing, software
  10. // distributed under the License is distributed on an "AS IS" BASIS,
  11. // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12. // See the License for the specific language governing permissions and
  13. // limitations under the License.
  14. package java
  15. import (
  16. "fmt"
  17. "path/filepath"
  18. "regexp"
  19. "strings"
  20. "testing"
  21. "android/soong/android"
  22. "github.com/google/blueprint/proptools"
  23. )
  24. func TestJavaSdkLibrary(t *testing.T) {
  25. result := android.GroupFixturePreparers(
  26. prepareForJavaTest,
  27. PrepareForTestWithJavaSdkLibraryFiles,
  28. FixtureWithPrebuiltApis(map[string][]string{
  29. "28": {"foo"},
  30. "29": {"foo"},
  31. "30": {"bar", "barney", "baz", "betty", "foo", "fred", "quuz", "wilma"},
  32. }),
  33. android.FixtureModifyConfig(func(config android.Config) {
  34. config.SetApiLibraries([]string{"foo"})
  35. }),
  36. ).RunTestWithBp(t, `
  37. droiddoc_exported_dir {
  38. name: "droiddoc-templates-sdk",
  39. path: ".",
  40. }
  41. java_sdk_library {
  42. name: "foo",
  43. srcs: ["a.java", "b.java"],
  44. api_packages: ["foo"],
  45. }
  46. java_sdk_library {
  47. name: "bar",
  48. srcs: ["a.java", "b.java"],
  49. api_packages: ["bar"],
  50. exclude_kotlinc_generated_files: true,
  51. }
  52. java_library {
  53. name: "baz",
  54. srcs: ["c.java"],
  55. libs: ["foo", "bar.stubs"],
  56. sdk_version: "system_current",
  57. }
  58. java_sdk_library {
  59. name: "barney",
  60. srcs: ["c.java"],
  61. api_only: true,
  62. }
  63. java_sdk_library {
  64. name: "betty",
  65. srcs: ["c.java"],
  66. shared_library: false,
  67. }
  68. java_sdk_library_import {
  69. name: "quuz",
  70. public: {
  71. jars: ["c.jar"],
  72. },
  73. }
  74. java_sdk_library_import {
  75. name: "fred",
  76. public: {
  77. jars: ["b.jar"],
  78. },
  79. }
  80. java_sdk_library_import {
  81. name: "wilma",
  82. public: {
  83. jars: ["b.jar"],
  84. },
  85. shared_library: false,
  86. }
  87. java_library {
  88. name: "qux",
  89. srcs: ["c.java"],
  90. libs: ["baz", "fred", "quuz.stubs", "wilma", "barney", "betty"],
  91. sdk_version: "system_current",
  92. }
  93. java_library {
  94. name: "baz-test",
  95. srcs: ["c.java"],
  96. libs: ["foo"],
  97. sdk_version: "test_current",
  98. }
  99. java_library {
  100. name: "baz-29",
  101. srcs: ["c.java"],
  102. libs: ["foo"],
  103. sdk_version: "system_29",
  104. }
  105. java_library {
  106. name: "baz-module-30",
  107. srcs: ["c.java"],
  108. libs: ["foo"],
  109. sdk_version: "module_30",
  110. }
  111. `)
  112. // check the existence of the internal modules
  113. foo := result.ModuleForTests("foo", "android_common")
  114. result.ModuleForTests(apiScopePublic.stubsLibraryModuleName("foo"), "android_common")
  115. result.ModuleForTests(apiScopeSystem.stubsLibraryModuleName("foo"), "android_common")
  116. result.ModuleForTests(apiScopeTest.stubsLibraryModuleName("foo"), "android_common")
  117. result.ModuleForTests(apiScopePublic.stubsSourceModuleName("foo"), "android_common")
  118. result.ModuleForTests(apiScopeSystem.stubsSourceModuleName("foo"), "android_common")
  119. result.ModuleForTests(apiScopeTest.stubsSourceModuleName("foo"), "android_common")
  120. result.ModuleForTests(apiScopePublic.stubsSourceModuleName("foo")+".api.contribution", "")
  121. result.ModuleForTests(apiScopePublic.apiLibraryModuleName("foo"), "android_common")
  122. result.ModuleForTests("foo"+sdkXmlFileSuffix, "android_common")
  123. result.ModuleForTests("foo.api.public.28", "")
  124. result.ModuleForTests("foo.api.system.28", "")
  125. result.ModuleForTests("foo.api.test.28", "")
  126. exportedComponentsInfo := result.ModuleProvider(foo.Module(), android.ExportedComponentsInfoProvider).(android.ExportedComponentsInfo)
  127. expectedFooExportedComponents := []string{
  128. "foo-removed.api.public.latest",
  129. "foo-removed.api.system.latest",
  130. "foo.api.public.latest",
  131. "foo.api.system.latest",
  132. "foo.stubs",
  133. "foo.stubs.source",
  134. "foo.stubs.source.system",
  135. "foo.stubs.source.test",
  136. "foo.stubs.system",
  137. "foo.stubs.test",
  138. }
  139. android.AssertArrayString(t, "foo exported components", expectedFooExportedComponents, exportedComponentsInfo.Components)
  140. bazJavac := result.ModuleForTests("baz", "android_common").Rule("javac")
  141. // tests if baz is actually linked to the stubs lib
  142. android.AssertStringDoesContain(t, "baz javac classpath", bazJavac.Args["classpath"], "foo.stubs.system.jar")
  143. // ... and not to the impl lib
  144. android.AssertStringDoesNotContain(t, "baz javac classpath", bazJavac.Args["classpath"], "foo.jar")
  145. // test if baz is not linked to the system variant of foo
  146. android.AssertStringDoesNotContain(t, "baz javac classpath", bazJavac.Args["classpath"], "foo.stubs.jar")
  147. bazTestJavac := result.ModuleForTests("baz-test", "android_common").Rule("javac")
  148. // tests if baz-test is actually linked to the test stubs lib
  149. android.AssertStringDoesContain(t, "baz-test javac classpath", bazTestJavac.Args["classpath"], "foo.stubs.test.jar")
  150. baz29Javac := result.ModuleForTests("baz-29", "android_common").Rule("javac")
  151. // tests if baz-29 is actually linked to the system 29 stubs lib
  152. android.AssertStringDoesContain(t, "baz-29 javac classpath", baz29Javac.Args["classpath"], "prebuilts/sdk/29/system/foo.jar")
  153. bazModule30Javac := result.ModuleForTests("baz-module-30", "android_common").Rule("javac")
  154. // tests if "baz-module-30" is actually linked to the module 30 stubs lib
  155. android.AssertStringDoesContain(t, "baz-module-30 javac classpath", bazModule30Javac.Args["classpath"], "prebuilts/sdk/30/module-lib/foo.jar")
  156. // test if baz has exported SDK lib names foo and bar to qux
  157. qux := result.ModuleForTests("qux", "android_common")
  158. if quxLib, ok := qux.Module().(*Library); ok {
  159. requiredSdkLibs, optionalSdkLibs := quxLib.ClassLoaderContexts().UsesLibs()
  160. android.AssertDeepEquals(t, "qux exports (required)", []string{"fred", "quuz", "foo", "bar"}, requiredSdkLibs)
  161. android.AssertDeepEquals(t, "qux exports (optional)", []string{}, optionalSdkLibs)
  162. }
  163. fooDexJar := result.ModuleForTests("foo", "android_common").Rule("d8")
  164. // tests if kotlinc generated files are NOT excluded from output of foo.
  165. android.AssertStringDoesNotContain(t, "foo dex", fooDexJar.BuildParams.Args["mergeZipsFlags"], "-stripFile META-INF/*.kotlin_module")
  166. barDexJar := result.ModuleForTests("bar", "android_common").Rule("d8")
  167. // tests if kotlinc generated files are excluded from output of bar.
  168. android.AssertStringDoesContain(t, "bar dex", barDexJar.BuildParams.Args["mergeZipsFlags"], "-stripFile META-INF/*.kotlin_module")
  169. }
  170. func TestJavaSdkLibrary_UpdatableLibrary(t *testing.T) {
  171. result := android.GroupFixturePreparers(
  172. prepareForJavaTest,
  173. PrepareForTestWithJavaSdkLibraryFiles,
  174. FixtureWithPrebuiltApis(map[string][]string{
  175. "28": {"foo"},
  176. "29": {"foo"},
  177. "30": {"foo", "fooUpdatable", "fooUpdatableErr"},
  178. }),
  179. android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
  180. variables.Platform_version_active_codenames = []string{"Tiramisu", "U", "V", "W", "X"}
  181. }),
  182. ).RunTestWithBp(t,
  183. `
  184. java_sdk_library {
  185. name: "fooUpdatable",
  186. srcs: ["a.java", "b.java"],
  187. api_packages: ["foo"],
  188. on_bootclasspath_since: "U",
  189. on_bootclasspath_before: "V",
  190. min_device_sdk: "W",
  191. max_device_sdk: "X",
  192. min_sdk_version: "S",
  193. }
  194. java_sdk_library {
  195. name: "foo",
  196. srcs: ["a.java", "b.java"],
  197. api_packages: ["foo"],
  198. }
  199. `)
  200. // test that updatability attributes are passed on correctly
  201. fooUpdatable := result.ModuleForTests("fooUpdatable.xml", "android_common").Rule("java_sdk_xml")
  202. android.AssertStringDoesContain(t, "fooUpdatable.xml java_sdk_xml command", fooUpdatable.RuleParams.Command, `on-bootclasspath-since=\"U\"`)
  203. android.AssertStringDoesContain(t, "fooUpdatable.xml java_sdk_xml command", fooUpdatable.RuleParams.Command, `on-bootclasspath-before=\"V\"`)
  204. android.AssertStringDoesContain(t, "fooUpdatable.xml java_sdk_xml command", fooUpdatable.RuleParams.Command, `min-device-sdk=\"W\"`)
  205. android.AssertStringDoesContain(t, "fooUpdatable.xml java_sdk_xml command", fooUpdatable.RuleParams.Command, `max-device-sdk=\"X\"`)
  206. // double check that updatability attributes are not written if they don't exist in the bp file
  207. // the permissions file for the foo library defined above
  208. fooPermissions := result.ModuleForTests("foo.xml", "android_common").Rule("java_sdk_xml")
  209. android.AssertStringDoesNotContain(t, "foo.xml java_sdk_xml command", fooPermissions.RuleParams.Command, `on-bootclasspath-since`)
  210. android.AssertStringDoesNotContain(t, "foo.xml java_sdk_xml command", fooPermissions.RuleParams.Command, `on-bootclasspath-before`)
  211. android.AssertStringDoesNotContain(t, "foo.xml java_sdk_xml command", fooPermissions.RuleParams.Command, `min-device-sdk`)
  212. android.AssertStringDoesNotContain(t, "foo.xml java_sdk_xml command", fooPermissions.RuleParams.Command, `max-device-sdk`)
  213. }
  214. func TestJavaSdkLibrary_UpdatableLibrary_Validation_ValidVersion(t *testing.T) {
  215. android.GroupFixturePreparers(
  216. prepareForJavaTest,
  217. PrepareForTestWithJavaSdkLibraryFiles,
  218. FixtureWithPrebuiltApis(map[string][]string{
  219. "30": {"fooUpdatable", "fooUpdatableErr"},
  220. }),
  221. ).ExtendWithErrorHandler(android.FixtureExpectsAllErrorsToMatchAPattern(
  222. []string{
  223. `on_bootclasspath_since: "aaa" could not be parsed as an integer and is not a recognized codename`,
  224. `on_bootclasspath_before: "bbc" could not be parsed as an integer and is not a recognized codename`,
  225. `min_device_sdk: "ccc" could not be parsed as an integer and is not a recognized codename`,
  226. `max_device_sdk: "current" is not an allowed value for this attribute`,
  227. })).RunTestWithBp(t,
  228. `
  229. java_sdk_library {
  230. name: "fooUpdatableErr",
  231. srcs: ["a.java", "b.java"],
  232. api_packages: ["foo"],
  233. on_bootclasspath_since: "aaa",
  234. on_bootclasspath_before: "bbc",
  235. min_device_sdk: "ccc",
  236. max_device_sdk: "current",
  237. }
  238. `)
  239. }
  240. func TestJavaSdkLibrary_UpdatableLibrary_Validation_AtLeastTAttributes(t *testing.T) {
  241. android.GroupFixturePreparers(
  242. prepareForJavaTest,
  243. PrepareForTestWithJavaSdkLibraryFiles,
  244. FixtureWithPrebuiltApis(map[string][]string{
  245. "28": {"foo"},
  246. }),
  247. ).ExtendWithErrorHandler(android.FixtureExpectsAllErrorsToMatchAPattern(
  248. []string{
  249. "on_bootclasspath_since: Attribute value needs to be at least T",
  250. "on_bootclasspath_before: Attribute value needs to be at least T",
  251. "min_device_sdk: Attribute value needs to be at least T",
  252. "max_device_sdk: Attribute value needs to be at least T",
  253. },
  254. )).RunTestWithBp(t,
  255. `
  256. java_sdk_library {
  257. name: "foo",
  258. srcs: ["a.java", "b.java"],
  259. api_packages: ["foo"],
  260. on_bootclasspath_since: "S",
  261. on_bootclasspath_before: "S",
  262. min_device_sdk: "S",
  263. max_device_sdk: "S",
  264. min_sdk_version: "S",
  265. }
  266. `)
  267. }
  268. func TestJavaSdkLibrary_UpdatableLibrary_Validation_MinAndMaxDeviceSdk(t *testing.T) {
  269. android.GroupFixturePreparers(
  270. prepareForJavaTest,
  271. PrepareForTestWithJavaSdkLibraryFiles,
  272. FixtureWithPrebuiltApis(map[string][]string{
  273. "28": {"foo"},
  274. }),
  275. android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
  276. variables.Platform_version_active_codenames = []string{"Tiramisu", "U", "V"}
  277. }),
  278. ).ExtendWithErrorHandler(android.FixtureExpectsAllErrorsToMatchAPattern(
  279. []string{
  280. "min_device_sdk can't be greater than max_device_sdk",
  281. },
  282. )).RunTestWithBp(t,
  283. `
  284. java_sdk_library {
  285. name: "foo",
  286. srcs: ["a.java", "b.java"],
  287. api_packages: ["foo"],
  288. min_device_sdk: "V",
  289. max_device_sdk: "U",
  290. min_sdk_version: "S",
  291. }
  292. `)
  293. }
  294. func TestJavaSdkLibrary_UpdatableLibrary_Validation_MinAndMaxDeviceSdkAndModuleMinSdk(t *testing.T) {
  295. android.GroupFixturePreparers(
  296. prepareForJavaTest,
  297. PrepareForTestWithJavaSdkLibraryFiles,
  298. FixtureWithPrebuiltApis(map[string][]string{
  299. "28": {"foo"},
  300. }),
  301. android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
  302. variables.Platform_version_active_codenames = []string{"Tiramisu", "U", "V"}
  303. }),
  304. ).ExtendWithErrorHandler(android.FixtureExpectsAllErrorsToMatchAPattern(
  305. []string{
  306. regexp.QuoteMeta("min_device_sdk: Can't be less than module's min sdk (V)"),
  307. regexp.QuoteMeta("max_device_sdk: Can't be less than module's min sdk (V)"),
  308. },
  309. )).RunTestWithBp(t,
  310. `
  311. java_sdk_library {
  312. name: "foo",
  313. srcs: ["a.java", "b.java"],
  314. api_packages: ["foo"],
  315. min_device_sdk: "U",
  316. max_device_sdk: "U",
  317. min_sdk_version: "V",
  318. }
  319. `)
  320. }
  321. func TestJavaSdkLibrary_UpdatableLibrary_usesNewTag(t *testing.T) {
  322. result := android.GroupFixturePreparers(
  323. prepareForJavaTest,
  324. PrepareForTestWithJavaSdkLibraryFiles,
  325. FixtureWithPrebuiltApis(map[string][]string{
  326. "30": {"foo"},
  327. }),
  328. ).RunTestWithBp(t,
  329. `
  330. java_sdk_library {
  331. name: "foo",
  332. srcs: ["a.java", "b.java"],
  333. min_device_sdk: "Tiramisu",
  334. min_sdk_version: "S",
  335. }
  336. `)
  337. // test that updatability attributes are passed on correctly
  338. fooUpdatable := result.ModuleForTests("foo.xml", "android_common").Rule("java_sdk_xml")
  339. android.AssertStringDoesContain(t, "foo.xml java_sdk_xml command", fooUpdatable.RuleParams.Command, `<apex-library`)
  340. android.AssertStringDoesNotContain(t, "foo.xml java_sdk_xml command", fooUpdatable.RuleParams.Command, `<library`)
  341. }
  342. func TestJavaSdkLibrary_StubOrImplOnlyLibs(t *testing.T) {
  343. result := android.GroupFixturePreparers(
  344. prepareForJavaTest,
  345. PrepareForTestWithJavaSdkLibraryFiles,
  346. FixtureWithLastReleaseApis("sdklib"),
  347. ).RunTestWithBp(t, `
  348. java_sdk_library {
  349. name: "sdklib",
  350. srcs: ["a.java"],
  351. libs: ["lib"],
  352. static_libs: ["static-lib"],
  353. impl_only_libs: ["impl-only-lib"],
  354. stub_only_libs: ["stub-only-lib"],
  355. stub_only_static_libs: ["stub-only-static-lib"],
  356. }
  357. java_defaults {
  358. name: "defaults",
  359. srcs: ["a.java"],
  360. sdk_version: "current",
  361. }
  362. java_library { name: "lib", defaults: ["defaults"] }
  363. java_library { name: "static-lib", defaults: ["defaults"] }
  364. java_library { name: "impl-only-lib", defaults: ["defaults"] }
  365. java_library { name: "stub-only-lib", defaults: ["defaults"] }
  366. java_library { name: "stub-only-static-lib", defaults: ["defaults"] }
  367. `)
  368. var expectations = []struct {
  369. lib string
  370. on_impl_classpath bool
  371. on_stub_classpath bool
  372. in_impl_combined bool
  373. in_stub_combined bool
  374. }{
  375. {lib: "lib", on_impl_classpath: true},
  376. {lib: "static-lib", in_impl_combined: true},
  377. {lib: "impl-only-lib", on_impl_classpath: true},
  378. {lib: "stub-only-lib", on_stub_classpath: true},
  379. {lib: "stub-only-static-lib", in_stub_combined: true},
  380. }
  381. verify := func(sdklib, dep string, cp, combined bool) {
  382. sdklibCp := result.ModuleForTests(sdklib, "android_common").Rule("javac").Args["classpath"]
  383. expected := cp || combined // Every combined jar is also on the classpath.
  384. android.AssertStringContainsEquals(t, "bad classpath for "+sdklib, sdklibCp, "/"+dep+".jar", expected)
  385. combineJarInputs := result.ModuleForTests(sdklib, "android_common").Rule("combineJar").Inputs.Strings()
  386. depPath := filepath.Join("out", "soong", ".intermediates", dep, "android_common", "turbine-combined", dep+".jar")
  387. android.AssertStringListContainsEquals(t, "bad combined inputs for "+sdklib, combineJarInputs, depPath, combined)
  388. }
  389. for _, expectation := range expectations {
  390. verify("sdklib.impl", expectation.lib, expectation.on_impl_classpath, expectation.in_impl_combined)
  391. stubName := apiScopePublic.sourceStubLibraryModuleName("sdklib")
  392. verify(stubName, expectation.lib, expectation.on_stub_classpath, expectation.in_stub_combined)
  393. }
  394. }
  395. func TestJavaSdkLibrary_DoNotAccessImplWhenItIsNotBuilt(t *testing.T) {
  396. result := android.GroupFixturePreparers(
  397. prepareForJavaTest,
  398. PrepareForTestWithJavaSdkLibraryFiles,
  399. FixtureWithLastReleaseApis("foo"),
  400. ).RunTestWithBp(t, `
  401. java_sdk_library {
  402. name: "foo",
  403. srcs: ["a.java"],
  404. api_only: true,
  405. public: {
  406. enabled: true,
  407. },
  408. }
  409. java_library {
  410. name: "bar",
  411. srcs: ["b.java"],
  412. libs: ["foo"],
  413. }
  414. `)
  415. // The bar library should depend on the stubs jar.
  416. barLibrary := result.ModuleForTests("bar", "android_common").Rule("javac")
  417. if expected, actual := `^-classpath .*:out/soong/[^:]*/turbine-combined/foo\.stubs\.jar$`, barLibrary.Args["classpath"]; !regexp.MustCompile(expected).MatchString(actual) {
  418. t.Errorf("expected %q, found %#q", expected, actual)
  419. }
  420. }
  421. func TestJavaSdkLibrary_AccessOutputFiles(t *testing.T) {
  422. android.GroupFixturePreparers(
  423. prepareForJavaTest,
  424. PrepareForTestWithJavaSdkLibraryFiles,
  425. FixtureWithLastReleaseApis("foo"),
  426. ).RunTestWithBp(t, `
  427. java_sdk_library {
  428. name: "foo",
  429. srcs: ["a.java"],
  430. api_packages: ["foo"],
  431. annotations_enabled: true,
  432. public: {
  433. enabled: true,
  434. },
  435. }
  436. java_library {
  437. name: "bar",
  438. srcs: ["b.java", ":foo{.public.stubs.source}"],
  439. java_resources: [":foo{.public.annotations.zip}"],
  440. }
  441. `)
  442. }
  443. func TestJavaSdkLibrary_AccessOutputFiles_NoAnnotations(t *testing.T) {
  444. android.GroupFixturePreparers(
  445. prepareForJavaTest,
  446. PrepareForTestWithJavaSdkLibraryFiles,
  447. FixtureWithLastReleaseApis("foo"),
  448. ).
  449. ExtendWithErrorHandler(android.FixtureExpectsAtLeastOneErrorMatchingPattern(`module "bar" variant "android_common": path dependency ":foo{.public.annotations.zip}": annotations.zip not available for api scope public`)).
  450. RunTestWithBp(t, `
  451. java_sdk_library {
  452. name: "foo",
  453. srcs: ["a.java"],
  454. api_packages: ["foo"],
  455. public: {
  456. enabled: true,
  457. },
  458. }
  459. java_library {
  460. name: "bar",
  461. srcs: ["b.java", ":foo{.public.stubs.source}"],
  462. java_resources: [":foo{.public.annotations.zip}"],
  463. }
  464. `)
  465. }
  466. func TestJavaSdkLibrary_AccessOutputFiles_MissingScope(t *testing.T) {
  467. android.GroupFixturePreparers(
  468. prepareForJavaTest,
  469. PrepareForTestWithJavaSdkLibraryFiles,
  470. FixtureWithLastReleaseApis("foo"),
  471. ).
  472. ExtendWithErrorHandler(android.FixtureExpectsAtLeastOneErrorMatchingPattern(`"foo" does not provide api scope system`)).
  473. RunTestWithBp(t, `
  474. java_sdk_library {
  475. name: "foo",
  476. srcs: ["a.java"],
  477. api_packages: ["foo"],
  478. public: {
  479. enabled: true,
  480. },
  481. }
  482. java_library {
  483. name: "bar",
  484. srcs: ["b.java", ":foo{.system.stubs.source}"],
  485. }
  486. `)
  487. }
  488. func TestJavaSdkLibrary_Deps(t *testing.T) {
  489. result := android.GroupFixturePreparers(
  490. prepareForJavaTest,
  491. PrepareForTestWithJavaSdkLibraryFiles,
  492. FixtureWithLastReleaseApis("sdklib"),
  493. ).RunTestWithBp(t, `
  494. java_sdk_library {
  495. name: "sdklib",
  496. srcs: ["a.java"],
  497. sdk_version: "none",
  498. system_modules: "none",
  499. public: {
  500. enabled: true,
  501. },
  502. }
  503. `)
  504. CheckModuleDependencies(t, result.TestContext, "sdklib", "android_common", []string{
  505. `dex2oatd`,
  506. `sdklib-removed.api.public.latest`,
  507. `sdklib.api.public.latest`,
  508. `sdklib.impl`,
  509. `sdklib.stubs`,
  510. `sdklib.stubs.source`,
  511. `sdklib.xml`,
  512. })
  513. }
  514. func TestJavaSdkLibraryImport_AccessOutputFiles(t *testing.T) {
  515. prepareForJavaTest.RunTestWithBp(t, `
  516. java_sdk_library_import {
  517. name: "foo",
  518. public: {
  519. jars: ["a.jar"],
  520. stub_srcs: ["a.java"],
  521. current_api: "api/current.txt",
  522. removed_api: "api/removed.txt",
  523. annotations: "x/annotations.zip",
  524. },
  525. }
  526. java_library {
  527. name: "bar",
  528. srcs: [":foo{.public.stubs.source}"],
  529. java_resources: [
  530. ":foo{.public.api.txt}",
  531. ":foo{.public.removed-api.txt}",
  532. ":foo{.public.annotations.zip}",
  533. ],
  534. }
  535. `)
  536. }
  537. func TestJavaSdkLibraryImport_AccessOutputFiles_Invalid(t *testing.T) {
  538. bp := `
  539. java_sdk_library_import {
  540. name: "foo",
  541. public: {
  542. jars: ["a.jar"],
  543. },
  544. }
  545. `
  546. t.Run("stubs.source", func(t *testing.T) {
  547. prepareForJavaTest.
  548. ExtendWithErrorHandler(android.FixtureExpectsAtLeastOneErrorMatchingPattern(`stubs.source not available for api scope public`)).
  549. RunTestWithBp(t, bp+`
  550. java_library {
  551. name: "bar",
  552. srcs: [":foo{.public.stubs.source}"],
  553. java_resources: [
  554. ":foo{.public.api.txt}",
  555. ":foo{.public.removed-api.txt}",
  556. ],
  557. }
  558. `)
  559. })
  560. t.Run("api.txt", func(t *testing.T) {
  561. prepareForJavaTest.
  562. ExtendWithErrorHandler(android.FixtureExpectsAtLeastOneErrorMatchingPattern(`api.txt not available for api scope public`)).
  563. RunTestWithBp(t, bp+`
  564. java_library {
  565. name: "bar",
  566. srcs: ["a.java"],
  567. java_resources: [
  568. ":foo{.public.api.txt}",
  569. ],
  570. }
  571. `)
  572. })
  573. t.Run("removed-api.txt", func(t *testing.T) {
  574. prepareForJavaTest.
  575. ExtendWithErrorHandler(android.FixtureExpectsAtLeastOneErrorMatchingPattern(`removed-api.txt not available for api scope public`)).
  576. RunTestWithBp(t, bp+`
  577. java_library {
  578. name: "bar",
  579. srcs: ["a.java"],
  580. java_resources: [
  581. ":foo{.public.removed-api.txt}",
  582. ],
  583. }
  584. `)
  585. })
  586. }
  587. func TestJavaSdkLibrary_InvalidScopes(t *testing.T) {
  588. prepareForJavaTest.
  589. ExtendWithErrorHandler(android.FixtureExpectsAtLeastOneErrorMatchingPattern(`module "foo": enabled api scope "system" depends on disabled scope "public"`)).
  590. RunTestWithBp(t, `
  591. java_sdk_library {
  592. name: "foo",
  593. srcs: ["a.java", "b.java"],
  594. api_packages: ["foo"],
  595. // Explicitly disable public to test the check that ensures the set of enabled
  596. // scopes is consistent.
  597. public: {
  598. enabled: false,
  599. },
  600. system: {
  601. enabled: true,
  602. },
  603. }
  604. `)
  605. }
  606. func TestJavaSdkLibrary_SdkVersion_ForScope(t *testing.T) {
  607. android.GroupFixturePreparers(
  608. prepareForJavaTest,
  609. PrepareForTestWithJavaSdkLibraryFiles,
  610. FixtureWithLastReleaseApis("foo"),
  611. ).RunTestWithBp(t, `
  612. java_sdk_library {
  613. name: "foo",
  614. srcs: ["a.java", "b.java"],
  615. api_packages: ["foo"],
  616. system: {
  617. enabled: true,
  618. sdk_version: "module_current",
  619. },
  620. }
  621. `)
  622. }
  623. func TestJavaSdkLibrary_ModuleLib(t *testing.T) {
  624. android.GroupFixturePreparers(
  625. prepareForJavaTest,
  626. PrepareForTestWithJavaSdkLibraryFiles,
  627. FixtureWithLastReleaseApis("foo"),
  628. ).RunTestWithBp(t, `
  629. java_sdk_library {
  630. name: "foo",
  631. srcs: ["a.java", "b.java"],
  632. api_packages: ["foo"],
  633. system: {
  634. enabled: true,
  635. },
  636. module_lib: {
  637. enabled: true,
  638. },
  639. }
  640. `)
  641. }
  642. func TestJavaSdkLibrary_SystemServer(t *testing.T) {
  643. android.GroupFixturePreparers(
  644. prepareForJavaTest,
  645. PrepareForTestWithJavaSdkLibraryFiles,
  646. FixtureWithLastReleaseApis("foo"),
  647. ).RunTestWithBp(t, `
  648. java_sdk_library {
  649. name: "foo",
  650. srcs: ["a.java", "b.java"],
  651. api_packages: ["foo"],
  652. system: {
  653. enabled: true,
  654. },
  655. system_server: {
  656. enabled: true,
  657. },
  658. }
  659. `)
  660. }
  661. func TestJavaSdkLibrary_SystemServer_AccessToStubScopeLibs(t *testing.T) {
  662. result := android.GroupFixturePreparers(
  663. prepareForJavaTest,
  664. PrepareForTestWithJavaSdkLibraryFiles,
  665. FixtureWithLastReleaseApis("foo-public", "foo-system", "foo-module-lib", "foo-system-server"),
  666. ).RunTestWithBp(t, `
  667. java_sdk_library {
  668. name: "foo-public",
  669. srcs: ["a.java"],
  670. api_packages: ["foo"],
  671. public: {
  672. enabled: true,
  673. },
  674. }
  675. java_sdk_library {
  676. name: "foo-system",
  677. srcs: ["a.java"],
  678. api_packages: ["foo"],
  679. system: {
  680. enabled: true,
  681. },
  682. }
  683. java_sdk_library {
  684. name: "foo-module-lib",
  685. srcs: ["a.java"],
  686. api_packages: ["foo"],
  687. system: {
  688. enabled: true,
  689. },
  690. module_lib: {
  691. enabled: true,
  692. },
  693. }
  694. java_sdk_library {
  695. name: "foo-system-server",
  696. srcs: ["a.java"],
  697. api_packages: ["foo"],
  698. system_server: {
  699. enabled: true,
  700. },
  701. }
  702. java_library {
  703. name: "bar",
  704. srcs: ["a.java"],
  705. libs: ["foo-public", "foo-system", "foo-module-lib", "foo-system-server"],
  706. sdk_version: "system_server_current",
  707. }
  708. `)
  709. stubsPath := func(name string, scope *apiScope) string {
  710. name = scope.stubsLibraryModuleName(name)
  711. return fmt.Sprintf("out/soong/.intermediates/%[1]s/android_common/turbine-combined/%[1]s.jar", name)
  712. }
  713. // The bar library should depend on the highest (where system server is highest and public is
  714. // lowest) API scopes provided by each of the foo-* modules. The highest API scope provided by the
  715. // foo-<x> module is <x>.
  716. barLibrary := result.ModuleForTests("bar", "android_common").Rule("javac")
  717. stubLibraries := []string{
  718. stubsPath("foo-public", apiScopePublic),
  719. stubsPath("foo-system", apiScopeSystem),
  720. stubsPath("foo-module-lib", apiScopeModuleLib),
  721. stubsPath("foo-system-server", apiScopeSystemServer),
  722. }
  723. expectedPattern := fmt.Sprintf(`^-classpath .*:\Q%s\E$`, strings.Join(stubLibraries, ":"))
  724. if expected, actual := expectedPattern, barLibrary.Args["classpath"]; !regexp.MustCompile(expected).MatchString(actual) {
  725. t.Errorf("expected pattern %q to match %#q", expected, actual)
  726. }
  727. }
  728. func TestJavaSdkLibrary_MissingScope(t *testing.T) {
  729. prepareForJavaTest.
  730. ExtendWithErrorHandler(android.FixtureExpectsAtLeastOneErrorMatchingPattern(`requires api scope module-lib from foo but it only has \[\] available`)).
  731. RunTestWithBp(t, `
  732. java_sdk_library {
  733. name: "foo",
  734. srcs: ["a.java"],
  735. public: {
  736. enabled: false,
  737. },
  738. }
  739. java_library {
  740. name: "baz",
  741. srcs: ["a.java"],
  742. libs: ["foo"],
  743. sdk_version: "module_current",
  744. }
  745. `)
  746. }
  747. func TestJavaSdkLibrary_FallbackScope(t *testing.T) {
  748. android.GroupFixturePreparers(
  749. prepareForJavaTest,
  750. PrepareForTestWithJavaSdkLibraryFiles,
  751. FixtureWithLastReleaseApis("foo"),
  752. ).RunTestWithBp(t, `
  753. java_sdk_library {
  754. name: "foo",
  755. srcs: ["a.java"],
  756. system: {
  757. enabled: true,
  758. },
  759. }
  760. java_library {
  761. name: "baz",
  762. srcs: ["a.java"],
  763. libs: ["foo"],
  764. // foo does not have module-lib scope so it should fallback to system
  765. sdk_version: "module_current",
  766. }
  767. `)
  768. }
  769. func TestJavaSdkLibrary_DefaultToStubs(t *testing.T) {
  770. result := android.GroupFixturePreparers(
  771. prepareForJavaTest,
  772. PrepareForTestWithJavaSdkLibraryFiles,
  773. FixtureWithLastReleaseApis("foo"),
  774. ).RunTestWithBp(t, `
  775. java_sdk_library {
  776. name: "foo",
  777. srcs: ["a.java"],
  778. system: {
  779. enabled: true,
  780. },
  781. default_to_stubs: true,
  782. }
  783. java_library {
  784. name: "baz",
  785. srcs: ["a.java"],
  786. libs: ["foo"],
  787. // does not have sdk_version set, should fallback to module,
  788. // which will then fallback to system because the module scope
  789. // is not enabled.
  790. }
  791. `)
  792. // The baz library should depend on the system stubs jar.
  793. bazLibrary := result.ModuleForTests("baz", "android_common").Rule("javac")
  794. if expected, actual := `^-classpath .*:out/soong/[^:]*/turbine-combined/foo\.stubs.system\.jar$`, bazLibrary.Args["classpath"]; !regexp.MustCompile(expected).MatchString(actual) {
  795. t.Errorf("expected %q, found %#q", expected, actual)
  796. }
  797. }
  798. func TestJavaSdkLibraryImport(t *testing.T) {
  799. result := prepareForJavaTest.RunTestWithBp(t, `
  800. java_library {
  801. name: "foo",
  802. srcs: ["a.java"],
  803. libs: ["sdklib"],
  804. sdk_version: "current",
  805. }
  806. java_library {
  807. name: "foo.system",
  808. srcs: ["a.java"],
  809. libs: ["sdklib"],
  810. sdk_version: "system_current",
  811. }
  812. java_library {
  813. name: "foo.test",
  814. srcs: ["a.java"],
  815. libs: ["sdklib"],
  816. sdk_version: "test_current",
  817. }
  818. java_sdk_library_import {
  819. name: "sdklib",
  820. public: {
  821. jars: ["a.jar"],
  822. },
  823. system: {
  824. jars: ["b.jar"],
  825. },
  826. test: {
  827. jars: ["c.jar"],
  828. stub_srcs: ["c.java"],
  829. },
  830. }
  831. `)
  832. for _, scope := range []string{"", ".system", ".test"} {
  833. fooModule := result.ModuleForTests("foo"+scope, "android_common")
  834. javac := fooModule.Rule("javac")
  835. sdklibStubsJar := result.ModuleForTests("sdklib.stubs"+scope, "android_common").Rule("combineJar").Output
  836. android.AssertStringDoesContain(t, "foo classpath", javac.Args["classpath"], sdklibStubsJar.String())
  837. }
  838. CheckModuleDependencies(t, result.TestContext, "sdklib", "android_common", []string{
  839. `dex2oatd`,
  840. `prebuilt_sdklib.stubs`,
  841. `prebuilt_sdklib.stubs.source.test`,
  842. `prebuilt_sdklib.stubs.system`,
  843. `prebuilt_sdklib.stubs.test`,
  844. })
  845. }
  846. func TestJavaSdkLibraryImport_WithSource(t *testing.T) {
  847. result := android.GroupFixturePreparers(
  848. prepareForJavaTest,
  849. PrepareForTestWithJavaSdkLibraryFiles,
  850. FixtureWithLastReleaseApis("sdklib"),
  851. ).RunTestWithBp(t, `
  852. java_sdk_library {
  853. name: "sdklib",
  854. srcs: ["a.java"],
  855. sdk_version: "none",
  856. system_modules: "none",
  857. public: {
  858. enabled: true,
  859. },
  860. }
  861. java_sdk_library_import {
  862. name: "sdklib",
  863. public: {
  864. jars: ["a.jar"],
  865. },
  866. }
  867. `)
  868. CheckModuleDependencies(t, result.TestContext, "sdklib", "android_common", []string{
  869. `dex2oatd`,
  870. `prebuilt_sdklib`,
  871. `sdklib-removed.api.public.latest`,
  872. `sdklib.api.public.latest`,
  873. `sdklib.impl`,
  874. `sdklib.stubs`,
  875. `sdklib.stubs.source`,
  876. `sdklib.xml`,
  877. })
  878. CheckModuleDependencies(t, result.TestContext, "prebuilt_sdklib", "android_common", []string{
  879. `prebuilt_sdklib.stubs`,
  880. `sdklib.impl`,
  881. // This should be prebuilt_sdklib.stubs but is set to sdklib.stubs because the
  882. // dependency is added after prebuilts may have been renamed and so has to use
  883. // the renamed name.
  884. `sdklib.xml`,
  885. })
  886. }
  887. func testJavaSdkLibraryImport_Preferred(t *testing.T, prefer string, preparer android.FixturePreparer) {
  888. result := android.GroupFixturePreparers(
  889. prepareForJavaTest,
  890. PrepareForTestWithJavaSdkLibraryFiles,
  891. FixtureWithLastReleaseApis("sdklib"),
  892. preparer,
  893. ).RunTestWithBp(t, `
  894. java_sdk_library {
  895. name: "sdklib",
  896. srcs: ["a.java"],
  897. sdk_version: "none",
  898. system_modules: "none",
  899. public: {
  900. enabled: true,
  901. },
  902. }
  903. java_sdk_library_import {
  904. name: "sdklib",
  905. `+prefer+`
  906. public: {
  907. jars: ["a.jar"],
  908. stub_srcs: ["a.java"],
  909. current_api: "current.txt",
  910. removed_api: "removed.txt",
  911. annotations: "annotations.zip",
  912. },
  913. }
  914. java_library {
  915. name: "combined",
  916. static_libs: [
  917. "sdklib.stubs",
  918. ],
  919. java_resources: [
  920. ":sdklib.stubs.source",
  921. ":sdklib{.public.api.txt}",
  922. ":sdklib{.public.removed-api.txt}",
  923. ":sdklib{.public.annotations.zip}",
  924. ],
  925. sdk_version: "none",
  926. system_modules: "none",
  927. }
  928. java_library {
  929. name: "public",
  930. srcs: ["a.java"],
  931. libs: ["sdklib"],
  932. sdk_version: "current",
  933. }
  934. `)
  935. CheckModuleDependencies(t, result.TestContext, "sdklib", "android_common", []string{
  936. `prebuilt_sdklib`,
  937. `sdklib-removed.api.public.latest`,
  938. `sdklib.api.public.latest`,
  939. `sdklib.impl`,
  940. `sdklib.stubs`,
  941. `sdklib.stubs.source`,
  942. `sdklib.xml`,
  943. })
  944. CheckModuleDependencies(t, result.TestContext, "prebuilt_sdklib", "android_common", []string{
  945. `dex2oatd`,
  946. `prebuilt_sdklib.stubs`,
  947. `prebuilt_sdklib.stubs.source`,
  948. `sdklib.impl`,
  949. `sdklib.xml`,
  950. })
  951. // Make sure that dependencies on child modules use the prebuilt when preferred.
  952. CheckModuleDependencies(t, result.TestContext, "combined", "android_common", []string{
  953. // Each use of :sdklib{...} adds a dependency onto prebuilt_sdklib.
  954. `prebuilt_sdklib`,
  955. `prebuilt_sdklib`,
  956. `prebuilt_sdklib`,
  957. `prebuilt_sdklib.stubs`,
  958. `prebuilt_sdklib.stubs.source`,
  959. })
  960. // Make sure that dependencies on sdklib that resolve to one of the child libraries use the
  961. // prebuilt library.
  962. public := result.ModuleForTests("public", "android_common")
  963. rule := public.Output("javac/public.jar")
  964. inputs := rule.Implicits.Strings()
  965. expected := "out/soong/.intermediates/prebuilt_sdklib.stubs/android_common/combined/sdklib.stubs.jar"
  966. if !android.InList(expected, inputs) {
  967. t.Errorf("expected %q to contain %q", inputs, expected)
  968. }
  969. }
  970. func TestJavaSdkLibraryImport_Preferred(t *testing.T) {
  971. t.Run("prefer", func(t *testing.T) {
  972. testJavaSdkLibraryImport_Preferred(t, "prefer: true,", android.NullFixturePreparer)
  973. })
  974. t.Run("use_source_config_var", func(t *testing.T) {
  975. testJavaSdkLibraryImport_Preferred(t,
  976. "use_source_config_var: {config_namespace: \"acme\", var_name: \"use_source\"},",
  977. android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
  978. variables.VendorVars = map[string]map[string]string{
  979. "acme": {
  980. "use_source": "false",
  981. },
  982. }
  983. }))
  984. })
  985. }
  986. func TestJavaSdkLibraryEnforce(t *testing.T) {
  987. partitionToBpOption := func(partition string) string {
  988. switch partition {
  989. case "system":
  990. return ""
  991. case "vendor":
  992. return "soc_specific: true,"
  993. case "product":
  994. return "product_specific: true,"
  995. default:
  996. panic("Invalid partition group name: " + partition)
  997. }
  998. }
  999. type testConfigInfo struct {
  1000. libraryType string
  1001. fromPartition string
  1002. toPartition string
  1003. enforceVendorInterface bool
  1004. enforceProductInterface bool
  1005. enforceJavaSdkLibraryCheck bool
  1006. allowList []string
  1007. }
  1008. createPreparer := func(info testConfigInfo) android.FixturePreparer {
  1009. bpFileTemplate := `
  1010. java_library {
  1011. name: "foo",
  1012. srcs: ["foo.java"],
  1013. libs: ["bar"],
  1014. sdk_version: "current",
  1015. %s
  1016. }
  1017. %s {
  1018. name: "bar",
  1019. srcs: ["bar.java"],
  1020. sdk_version: "current",
  1021. %s
  1022. }
  1023. `
  1024. bpFile := fmt.Sprintf(bpFileTemplate,
  1025. partitionToBpOption(info.fromPartition),
  1026. info.libraryType,
  1027. partitionToBpOption(info.toPartition))
  1028. return android.GroupFixturePreparers(
  1029. PrepareForTestWithJavaSdkLibraryFiles,
  1030. FixtureWithLastReleaseApis("bar"),
  1031. android.FixtureWithRootAndroidBp(bpFile),
  1032. android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
  1033. variables.EnforceProductPartitionInterface = proptools.BoolPtr(info.enforceProductInterface)
  1034. if info.enforceVendorInterface {
  1035. variables.DeviceVndkVersion = proptools.StringPtr("current")
  1036. }
  1037. variables.EnforceInterPartitionJavaSdkLibrary = proptools.BoolPtr(info.enforceJavaSdkLibraryCheck)
  1038. variables.InterPartitionJavaLibraryAllowList = info.allowList
  1039. }),
  1040. )
  1041. }
  1042. runTest := func(t *testing.T, info testConfigInfo, expectedErrorPattern string) {
  1043. t.Run(fmt.Sprintf("%v", info), func(t *testing.T) {
  1044. errorHandler := android.FixtureExpectsNoErrors
  1045. if expectedErrorPattern != "" {
  1046. errorHandler = android.FixtureExpectsAtLeastOneErrorMatchingPattern(expectedErrorPattern)
  1047. }
  1048. android.GroupFixturePreparers(
  1049. prepareForJavaTest,
  1050. createPreparer(info),
  1051. ).
  1052. ExtendWithErrorHandler(errorHandler).
  1053. RunTest(t)
  1054. })
  1055. }
  1056. errorMessage := "is not allowed across the partitions"
  1057. runTest(t, testConfigInfo{
  1058. libraryType: "java_library",
  1059. fromPartition: "product",
  1060. toPartition: "system",
  1061. enforceVendorInterface: true,
  1062. enforceProductInterface: true,
  1063. enforceJavaSdkLibraryCheck: false,
  1064. }, "")
  1065. runTest(t, testConfigInfo{
  1066. libraryType: "java_library",
  1067. fromPartition: "product",
  1068. toPartition: "system",
  1069. enforceVendorInterface: true,
  1070. enforceProductInterface: false,
  1071. enforceJavaSdkLibraryCheck: true,
  1072. }, "")
  1073. runTest(t, testConfigInfo{
  1074. libraryType: "java_library",
  1075. fromPartition: "product",
  1076. toPartition: "system",
  1077. enforceVendorInterface: true,
  1078. enforceProductInterface: true,
  1079. enforceJavaSdkLibraryCheck: true,
  1080. }, errorMessage)
  1081. runTest(t, testConfigInfo{
  1082. libraryType: "java_library",
  1083. fromPartition: "vendor",
  1084. toPartition: "system",
  1085. enforceVendorInterface: true,
  1086. enforceProductInterface: true,
  1087. enforceJavaSdkLibraryCheck: true,
  1088. }, errorMessage)
  1089. runTest(t, testConfigInfo{
  1090. libraryType: "java_library",
  1091. fromPartition: "vendor",
  1092. toPartition: "system",
  1093. enforceVendorInterface: true,
  1094. enforceProductInterface: true,
  1095. enforceJavaSdkLibraryCheck: true,
  1096. allowList: []string{"bar"},
  1097. }, "")
  1098. runTest(t, testConfigInfo{
  1099. libraryType: "java_library",
  1100. fromPartition: "vendor",
  1101. toPartition: "product",
  1102. enforceVendorInterface: true,
  1103. enforceProductInterface: true,
  1104. enforceJavaSdkLibraryCheck: true,
  1105. }, errorMessage)
  1106. runTest(t, testConfigInfo{
  1107. libraryType: "java_sdk_library",
  1108. fromPartition: "product",
  1109. toPartition: "system",
  1110. enforceVendorInterface: true,
  1111. enforceProductInterface: true,
  1112. enforceJavaSdkLibraryCheck: true,
  1113. }, "")
  1114. runTest(t, testConfigInfo{
  1115. libraryType: "java_sdk_library",
  1116. fromPartition: "vendor",
  1117. toPartition: "system",
  1118. enforceVendorInterface: true,
  1119. enforceProductInterface: true,
  1120. enforceJavaSdkLibraryCheck: true,
  1121. }, "")
  1122. runTest(t, testConfigInfo{
  1123. libraryType: "java_sdk_library",
  1124. fromPartition: "vendor",
  1125. toPartition: "product",
  1126. enforceVendorInterface: true,
  1127. enforceProductInterface: true,
  1128. enforceJavaSdkLibraryCheck: true,
  1129. }, "")
  1130. }
  1131. func TestJavaSdkLibraryDist(t *testing.T) {
  1132. result := android.GroupFixturePreparers(
  1133. PrepareForTestWithJavaBuildComponents,
  1134. PrepareForTestWithJavaDefaultModules,
  1135. PrepareForTestWithJavaSdkLibraryFiles,
  1136. FixtureWithLastReleaseApis(
  1137. "sdklib_no_group",
  1138. "sdklib_group_foo",
  1139. "sdklib_owner_foo",
  1140. "foo"),
  1141. ).RunTestWithBp(t, `
  1142. java_sdk_library {
  1143. name: "sdklib_no_group",
  1144. srcs: ["foo.java"],
  1145. }
  1146. java_sdk_library {
  1147. name: "sdklib_group_foo",
  1148. srcs: ["foo.java"],
  1149. dist_group: "foo",
  1150. }
  1151. java_sdk_library {
  1152. name: "sdklib_owner_foo",
  1153. srcs: ["foo.java"],
  1154. owner: "foo",
  1155. }
  1156. java_sdk_library {
  1157. name: "sdklib_stem_foo",
  1158. srcs: ["foo.java"],
  1159. dist_stem: "foo",
  1160. }
  1161. `)
  1162. type testCase struct {
  1163. module string
  1164. distDir string
  1165. distStem string
  1166. }
  1167. testCases := []testCase{
  1168. {
  1169. module: "sdklib_no_group",
  1170. distDir: "apistubs/unknown/public",
  1171. distStem: "sdklib_no_group.jar",
  1172. },
  1173. {
  1174. module: "sdklib_group_foo",
  1175. distDir: "apistubs/foo/public",
  1176. distStem: "sdklib_group_foo.jar",
  1177. },
  1178. {
  1179. // Owner doesn't affect distDir after b/186723288.
  1180. module: "sdklib_owner_foo",
  1181. distDir: "apistubs/unknown/public",
  1182. distStem: "sdklib_owner_foo.jar",
  1183. },
  1184. {
  1185. module: "sdklib_stem_foo",
  1186. distDir: "apistubs/unknown/public",
  1187. distStem: "foo.jar",
  1188. },
  1189. }
  1190. for _, tt := range testCases {
  1191. t.Run(tt.module, func(t *testing.T) {
  1192. m := result.ModuleForTests(tt.module+".stubs", "android_common").Module().(*Library)
  1193. dists := m.Dists()
  1194. if len(dists) != 1 {
  1195. t.Fatalf("expected exactly 1 dist entry, got %d", len(dists))
  1196. }
  1197. if g, w := String(dists[0].Dir), tt.distDir; g != w {
  1198. t.Errorf("expected dist dir %q, got %q", w, g)
  1199. }
  1200. if g, w := String(dists[0].Dest), tt.distStem; g != w {
  1201. t.Errorf("expected dist stem %q, got %q", w, g)
  1202. }
  1203. })
  1204. }
  1205. }
  1206. func TestSdkLibrary_CheckMinSdkVersion(t *testing.T) {
  1207. preparer := android.GroupFixturePreparers(
  1208. PrepareForTestWithJavaBuildComponents,
  1209. PrepareForTestWithJavaDefaultModules,
  1210. PrepareForTestWithJavaSdkLibraryFiles,
  1211. )
  1212. preparer.RunTestWithBp(t, `
  1213. java_sdk_library {
  1214. name: "sdklib",
  1215. srcs: ["a.java"],
  1216. static_libs: ["util"],
  1217. min_sdk_version: "30",
  1218. unsafe_ignore_missing_latest_api: true,
  1219. }
  1220. java_library {
  1221. name: "util",
  1222. srcs: ["a.java"],
  1223. min_sdk_version: "30",
  1224. }
  1225. `)
  1226. preparer.
  1227. RunTestWithBp(t, `
  1228. java_sdk_library {
  1229. name: "sdklib",
  1230. srcs: ["a.java"],
  1231. libs: ["util"],
  1232. impl_only_libs: ["util"],
  1233. stub_only_libs: ["util"],
  1234. stub_only_static_libs: ["util"],
  1235. min_sdk_version: "30",
  1236. unsafe_ignore_missing_latest_api: true,
  1237. }
  1238. java_library {
  1239. name: "util",
  1240. srcs: ["a.java"],
  1241. }
  1242. `)
  1243. preparer.ExtendWithErrorHandler(android.FixtureExpectsAtLeastOneErrorMatchingPattern(`module "util".*should support min_sdk_version\(30\)`)).
  1244. RunTestWithBp(t, `
  1245. java_sdk_library {
  1246. name: "sdklib",
  1247. srcs: ["a.java"],
  1248. static_libs: ["util"],
  1249. min_sdk_version: "30",
  1250. unsafe_ignore_missing_latest_api: true,
  1251. }
  1252. java_library {
  1253. name: "util",
  1254. srcs: ["a.java"],
  1255. min_sdk_version: "31",
  1256. }
  1257. `)
  1258. preparer.ExtendWithErrorHandler(android.FixtureExpectsAtLeastOneErrorMatchingPattern(`module "another_util".*should support min_sdk_version\(30\)`)).
  1259. RunTestWithBp(t, `
  1260. java_sdk_library {
  1261. name: "sdklib",
  1262. srcs: ["a.java"],
  1263. static_libs: ["util"],
  1264. min_sdk_version: "30",
  1265. unsafe_ignore_missing_latest_api: true,
  1266. }
  1267. java_library {
  1268. name: "util",
  1269. srcs: ["a.java"],
  1270. static_libs: ["another_util"],
  1271. min_sdk_version: "30",
  1272. }
  1273. java_library {
  1274. name: "another_util",
  1275. srcs: ["a.java"],
  1276. min_sdk_version: "31",
  1277. }
  1278. `)
  1279. }
  1280. func TestJavaSdkLibrary_StubOnlyLibs_PassedToDroidstubs(t *testing.T) {
  1281. result := android.GroupFixturePreparers(
  1282. prepareForJavaTest,
  1283. PrepareForTestWithJavaSdkLibraryFiles,
  1284. FixtureWithLastReleaseApis("foo"),
  1285. ).RunTestWithBp(t, `
  1286. java_sdk_library {
  1287. name: "foo",
  1288. srcs: ["a.java"],
  1289. public: {
  1290. enabled: true,
  1291. },
  1292. stub_only_libs: ["bar-lib"],
  1293. }
  1294. java_library {
  1295. name: "bar-lib",
  1296. srcs: ["b.java"],
  1297. }
  1298. `)
  1299. // The foo.stubs.source should depend on bar-lib
  1300. fooStubsSources := result.ModuleForTests("foo.stubs.source", "android_common").Module().(*Droidstubs)
  1301. android.AssertStringListContains(t, "foo stubs should depend on bar-lib", fooStubsSources.Javadoc.properties.Libs, "bar-lib")
  1302. }
  1303. func TestJavaSdkLibrary_ApiLibrary(t *testing.T) {
  1304. result := android.GroupFixturePreparers(
  1305. prepareForJavaTest,
  1306. PrepareForTestWithJavaSdkLibraryFiles,
  1307. FixtureWithLastReleaseApis("foo"),
  1308. android.FixtureModifyConfig(func(config android.Config) {
  1309. config.SetApiLibraries([]string{"foo"})
  1310. }),
  1311. ).RunTestWithBp(t, `
  1312. java_sdk_library {
  1313. name: "foo",
  1314. srcs: ["a.java", "b.java"],
  1315. api_packages: ["foo"],
  1316. system: {
  1317. enabled: true,
  1318. },
  1319. module_lib: {
  1320. enabled: true,
  1321. },
  1322. test: {
  1323. enabled: true,
  1324. },
  1325. }
  1326. `)
  1327. testCases := []struct {
  1328. scope *apiScope
  1329. apiContributions []string
  1330. fullApiSurfaceStub string
  1331. }{
  1332. {
  1333. scope: apiScopePublic,
  1334. apiContributions: []string{"foo.stubs.source.api.contribution"},
  1335. fullApiSurfaceStub: "android_stubs_current.from-text",
  1336. },
  1337. {
  1338. scope: apiScopeSystem,
  1339. apiContributions: []string{"foo.stubs.source.system.api.contribution", "foo.stubs.source.api.contribution"},
  1340. fullApiSurfaceStub: "android_system_stubs_current.from-text",
  1341. },
  1342. {
  1343. scope: apiScopeTest,
  1344. apiContributions: []string{"foo.stubs.source.test.api.contribution", "foo.stubs.source.system.api.contribution", "foo.stubs.source.api.contribution"},
  1345. fullApiSurfaceStub: "android_test_stubs_current.from-text",
  1346. },
  1347. {
  1348. scope: apiScopeModuleLib,
  1349. apiContributions: []string{"foo.stubs.source.module_lib.api.contribution", "foo.stubs.source.system.api.contribution", "foo.stubs.source.api.contribution"},
  1350. fullApiSurfaceStub: "android_module_lib_stubs_current_full.from-text",
  1351. },
  1352. }
  1353. for _, c := range testCases {
  1354. m := result.ModuleForTests(c.scope.apiLibraryModuleName("foo"), "android_common").Module().(*ApiLibrary)
  1355. android.AssertArrayString(t, "Module expected to contain api contributions", c.apiContributions, m.properties.Api_contributions)
  1356. android.AssertStringEquals(t, "Module expected to contain full api surface api library", c.fullApiSurfaceStub, *m.properties.Full_api_surface_stub)
  1357. }
  1358. }