1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353 |
- // Copyright 2017 Google Inc. All rights reserved.
- //
- // Licensed under the Apache License, Version 2.0 (the "License");
- // you may not use this file except in compliance with the License.
- // You may obtain a copy of the License at
- //
- // http://www.apache.org/licenses/LICENSE-2.0
- //
- // Unless required by applicable law or agreed to in writing, software
- // distributed under the License is distributed on an "AS IS" BASIS,
- // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- // See the License for the specific language governing permissions and
- // limitations under the License.
- package java
- import (
- "fmt"
- "os"
- "path/filepath"
- "reflect"
- "runtime"
- "strconv"
- "strings"
- "testing"
- "github.com/google/blueprint/proptools"
- "android/soong/android"
- "android/soong/cc"
- "android/soong/dexpreopt"
- "android/soong/genrule"
- )
- // Legacy preparer used for running tests within the java package.
- //
- // This includes everything that was needed to run any test in the java package prior to the
- // introduction of the test fixtures. Tests that are being converted to use fixtures directly
- // rather than through the testJava...() methods should avoid using this and instead use the
- // various preparers directly, using android.GroupFixturePreparers(...) to group them when
- // necessary.
- //
- // deprecated
- var prepareForJavaTest = android.GroupFixturePreparers(
- genrule.PrepareForTestWithGenRuleBuildComponents,
- // Get the CC build components but not default modules.
- cc.PrepareForTestWithCcBuildComponents,
- // Include all the default java modules.
- PrepareForTestWithDexpreopt,
- PrepareForTestWithOverlayBuildComponents,
- android.FixtureRegisterWithContext(func(ctx android.RegistrationContext) {
- ctx.RegisterPreSingletonType("sdk_versions", sdkPreSingletonFactory)
- }),
- )
- func TestMain(m *testing.M) {
- os.Exit(m.Run())
- }
- // testJavaError is a legacy way of running tests of java modules that expect errors.
- //
- // See testJava for an explanation as to how to stop using this deprecated method.
- //
- // deprecated
- func testJavaError(t *testing.T, pattern string, bp string) (*android.TestContext, android.Config) {
- t.Helper()
- result := android.GroupFixturePreparers(
- prepareForJavaTest, dexpreopt.PrepareForTestByEnablingDexpreopt).
- ExtendWithErrorHandler(android.FixtureExpectsAtLeastOneErrorMatchingPattern(pattern)).
- RunTestWithBp(t, bp)
- return result.TestContext, result.Config
- }
- // testJavaWithFS runs tests using the prepareForJavaTest
- //
- // See testJava for an explanation as to how to stop using this deprecated method.
- //
- // deprecated
- func testJavaWithFS(t *testing.T, bp string, fs android.MockFS) (*android.TestContext, android.Config) {
- t.Helper()
- result := android.GroupFixturePreparers(
- prepareForJavaTest, fs.AddToFixture()).RunTestWithBp(t, bp)
- return result.TestContext, result.Config
- }
- // testJava runs tests using the prepareForJavaTest
- //
- // Do not add any new usages of this, instead use the prepareForJavaTest directly as it makes it
- // much easier to customize the test behavior.
- //
- // If it is necessary to customize the behavior of an existing test that uses this then please first
- // convert the test to using prepareForJavaTest first and then in a following change add the
- // appropriate fixture preparers. Keeping the conversion change separate makes it easy to verify
- // that it did not change the test behavior unexpectedly.
- //
- // deprecated
- func testJava(t *testing.T, bp string) (*android.TestContext, android.Config) {
- t.Helper()
- result := prepareForJavaTest.RunTestWithBp(t, bp)
- return result.TestContext, result.Config
- }
- // defaultModuleToPath constructs a path to the turbine generate jar for a default test module that
- // is defined in PrepareForIntegrationTestWithJava
- func defaultModuleToPath(name string) string {
- switch {
- case name == `""`:
- return name
- case strings.HasSuffix(name, ".jar"):
- return name
- default:
- return filepath.Join("out", "soong", ".intermediates", defaultJavaDir, name, "android_common", "turbine-combined", name+".jar")
- }
- }
- // Test that the PrepareForTestWithJavaDefaultModules provides all the files that it uses by
- // running it in a fixture that requires all source files to exist.
- func TestPrepareForTestWithJavaDefaultModules(t *testing.T) {
- android.GroupFixturePreparers(
- PrepareForTestWithJavaDefaultModules,
- android.PrepareForTestDisallowNonExistentPaths,
- ).RunTest(t)
- }
- func TestJavaLinkType(t *testing.T) {
- testJava(t, `
- java_library {
- name: "foo",
- srcs: ["a.java"],
- libs: ["bar"],
- static_libs: ["baz"],
- }
- java_library {
- name: "bar",
- sdk_version: "current",
- srcs: ["b.java"],
- }
- java_library {
- name: "baz",
- sdk_version: "system_current",
- srcs: ["c.java"],
- }
- `)
- testJavaError(t, "consider adjusting sdk_version: OR platform_apis:", `
- java_library {
- name: "foo",
- srcs: ["a.java"],
- libs: ["bar"],
- sdk_version: "current",
- static_libs: ["baz"],
- }
- java_library {
- name: "bar",
- sdk_version: "current",
- srcs: ["b.java"],
- }
- java_library {
- name: "baz",
- sdk_version: "system_current",
- srcs: ["c.java"],
- }
- `)
- testJava(t, `
- java_library {
- name: "foo",
- srcs: ["a.java"],
- libs: ["bar"],
- sdk_version: "system_current",
- static_libs: ["baz"],
- }
- java_library {
- name: "bar",
- sdk_version: "current",
- srcs: ["b.java"],
- }
- java_library {
- name: "baz",
- sdk_version: "system_current",
- srcs: ["c.java"],
- }
- `)
- testJavaError(t, "consider adjusting sdk_version: OR platform_apis:", `
- java_library {
- name: "foo",
- srcs: ["a.java"],
- libs: ["bar"],
- sdk_version: "system_current",
- static_libs: ["baz"],
- }
- java_library {
- name: "bar",
- sdk_version: "current",
- srcs: ["b.java"],
- }
- java_library {
- name: "baz",
- srcs: ["c.java"],
- }
- `)
- }
- func TestSimple(t *testing.T) {
- ctx, _ := testJava(t, `
- java_library {
- name: "foo",
- srcs: ["a.java"],
- libs: ["bar"],
- static_libs: ["baz"],
- }
- java_library {
- name: "bar",
- srcs: ["b.java"],
- }
- java_library {
- name: "baz",
- srcs: ["c.java"],
- }
- `)
- javac := ctx.ModuleForTests("foo", "android_common").Rule("javac")
- combineJar := ctx.ModuleForTests("foo", "android_common").Description("for javac")
- if len(javac.Inputs) != 1 || javac.Inputs[0].String() != "a.java" {
- t.Errorf(`foo inputs %v != ["a.java"]`, javac.Inputs)
- }
- baz := ctx.ModuleForTests("baz", "android_common").Rule("javac").Output.String()
- barTurbine := filepath.Join("out", "soong", ".intermediates", "bar", "android_common", "turbine-combined", "bar.jar")
- bazTurbine := filepath.Join("out", "soong", ".intermediates", "baz", "android_common", "turbine-combined", "baz.jar")
- android.AssertStringDoesContain(t, "foo classpath", javac.Args["classpath"], barTurbine)
- android.AssertStringDoesContain(t, "foo classpath", javac.Args["classpath"], bazTurbine)
- if len(combineJar.Inputs) != 2 || combineJar.Inputs[1].String() != baz {
- t.Errorf("foo combineJar inputs %v does not contain %q", combineJar.Inputs, baz)
- }
- }
- func TestExportedPlugins(t *testing.T) {
- type Result struct {
- library string
- processors string
- disableTurbine bool
- }
- var tests = []struct {
- name string
- extra string
- results []Result
- }{
- {
- name: "Exported plugin is not a direct plugin",
- extra: `java_library { name: "exports", srcs: ["a.java"], exported_plugins: ["plugin"] }`,
- results: []Result{{library: "exports", processors: "-proc:none"}},
- },
- {
- name: "Exports plugin to dependee",
- extra: `
- java_library{name: "exports", exported_plugins: ["plugin"]}
- java_library{name: "foo", srcs: ["a.java"], libs: ["exports"]}
- java_library{name: "bar", srcs: ["a.java"], static_libs: ["exports"]}
- `,
- results: []Result{
- {library: "foo", processors: "-processor com.android.TestPlugin"},
- {library: "bar", processors: "-processor com.android.TestPlugin"},
- },
- },
- {
- name: "Exports plugin to android_library",
- extra: `
- java_library{name: "exports", exported_plugins: ["plugin"]}
- android_library{name: "foo", srcs: ["a.java"], libs: ["exports"]}
- android_library{name: "bar", srcs: ["a.java"], static_libs: ["exports"]}
- `,
- results: []Result{
- {library: "foo", processors: "-processor com.android.TestPlugin"},
- {library: "bar", processors: "-processor com.android.TestPlugin"},
- },
- },
- {
- name: "Exports plugin is not propagated via transitive deps",
- extra: `
- java_library{name: "exports", exported_plugins: ["plugin"]}
- java_library{name: "foo", srcs: ["a.java"], libs: ["exports"]}
- java_library{name: "bar", srcs: ["a.java"], static_libs: ["foo"]}
- `,
- results: []Result{
- {library: "foo", processors: "-processor com.android.TestPlugin"},
- {library: "bar", processors: "-proc:none"},
- },
- },
- {
- name: "Exports plugin appends to plugins",
- extra: `
- java_plugin{name: "plugin2", processor_class: "com.android.TestPlugin2"}
- java_library{name: "exports", exported_plugins: ["plugin"]}
- java_library{name: "foo", srcs: ["a.java"], libs: ["exports"], plugins: ["plugin2"]}
- `,
- results: []Result{
- {library: "foo", processors: "-processor com.android.TestPlugin,com.android.TestPlugin2"},
- },
- },
- {
- name: "Exports plugin to with generates_api to dependee",
- extra: `
- java_library{name: "exports", exported_plugins: ["plugin_generates_api"]}
- java_library{name: "foo", srcs: ["a.java"], libs: ["exports"]}
- java_library{name: "bar", srcs: ["a.java"], static_libs: ["exports"]}
- `,
- results: []Result{
- {library: "foo", processors: "-processor com.android.TestPlugin", disableTurbine: true},
- {library: "bar", processors: "-processor com.android.TestPlugin", disableTurbine: true},
- },
- },
- }
- for _, test := range tests {
- t.Run(test.name, func(t *testing.T) {
- ctx, _ := testJava(t, `
- java_plugin {
- name: "plugin",
- processor_class: "com.android.TestPlugin",
- }
- java_plugin {
- name: "plugin_generates_api",
- generates_api: true,
- processor_class: "com.android.TestPlugin",
- }
- `+test.extra)
- for _, want := range test.results {
- javac := ctx.ModuleForTests(want.library, "android_common").Rule("javac")
- if javac.Args["processor"] != want.processors {
- t.Errorf("For library %v, expected %v, found %v", want.library, want.processors, javac.Args["processor"])
- }
- turbine := ctx.ModuleForTests(want.library, "android_common").MaybeRule("turbine")
- disableTurbine := turbine.BuildParams.Rule == nil
- if disableTurbine != want.disableTurbine {
- t.Errorf("For library %v, expected disableTurbine %v, found %v", want.library, want.disableTurbine, disableTurbine)
- }
- }
- })
- }
- }
- func TestSdkVersionByPartition(t *testing.T) {
- testJavaError(t, "sdk_version must have a value when the module is located at vendor or product", `
- java_library {
- name: "foo",
- srcs: ["a.java"],
- vendor: true,
- }
- `)
- testJava(t, `
- java_library {
- name: "bar",
- srcs: ["b.java"],
- }
- `)
- for _, enforce := range []bool{true, false} {
- bp := `
- java_library {
- name: "foo",
- srcs: ["a.java"],
- product_specific: true,
- }
- `
- errorHandler := android.FixtureExpectsNoErrors
- if enforce {
- errorHandler = android.FixtureExpectsAtLeastOneErrorMatchingPattern("sdk_version must have a value when the module is located at vendor or product")
- }
- android.GroupFixturePreparers(
- PrepareForTestWithJavaDefaultModules,
- android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
- variables.EnforceProductPartitionInterface = proptools.BoolPtr(enforce)
- }),
- ).
- ExtendWithErrorHandler(errorHandler).
- RunTestWithBp(t, bp)
- }
- }
- func TestArchSpecific(t *testing.T) {
- ctx, _ := testJava(t, `
- java_library {
- name: "foo",
- srcs: ["a.java"],
- target: {
- android: {
- srcs: ["b.java"],
- },
- },
- }
- `)
- javac := ctx.ModuleForTests("foo", "android_common").Rule("javac")
- if len(javac.Inputs) != 2 || javac.Inputs[0].String() != "a.java" || javac.Inputs[1].String() != "b.java" {
- t.Errorf(`foo inputs %v != ["a.java", "b.java"]`, javac.Inputs)
- }
- }
- func TestBinary(t *testing.T) {
- ctx, _ := testJava(t, `
- java_library_host {
- name: "foo",
- srcs: ["a.java"],
- }
- java_binary_host {
- name: "bar",
- srcs: ["b.java"],
- static_libs: ["foo"],
- jni_libs: ["libjni"],
- }
- cc_library_shared {
- name: "libjni",
- host_supported: true,
- device_supported: false,
- stl: "none",
- }
- `)
- buildOS := ctx.Config().BuildOS.String()
- bar := ctx.ModuleForTests("bar", buildOS+"_common")
- barJar := bar.Output("bar.jar").Output.String()
- barWrapper := ctx.ModuleForTests("bar", buildOS+"_x86_64")
- barWrapperDeps := barWrapper.Output("bar").Implicits.Strings()
- libjni := ctx.ModuleForTests("libjni", buildOS+"_x86_64_shared")
- libjniSO := libjni.Rule("Cp").Output.String()
- // Test that the install binary wrapper depends on the installed jar file
- if g, w := barWrapperDeps, barJar; !android.InList(w, g) {
- t.Errorf("expected binary wrapper implicits to contain %q, got %q", w, g)
- }
- // Test that the install binary wrapper depends on the installed JNI libraries
- if g, w := barWrapperDeps, libjniSO; !android.InList(w, g) {
- t.Errorf("expected binary wrapper implicits to contain %q, got %q", w, g)
- }
- }
- func TestTest(t *testing.T) {
- ctx, _ := testJava(t, `
- java_test_host {
- name: "foo",
- srcs: ["a.java"],
- jni_libs: ["libjni"],
- }
- cc_library_shared {
- name: "libjni",
- host_supported: true,
- device_supported: false,
- stl: "none",
- }
- `)
- buildOS := ctx.Config().BuildOS.String()
- foo := ctx.ModuleForTests("foo", buildOS+"_common").Module().(*TestHost)
- expected := "lib64/libjni.so"
- if runtime.GOOS == "darwin" {
- expected = "lib64/libjni.dylib"
- }
- fooTestData := foo.data
- if len(fooTestData) != 1 || fooTestData[0].Rel() != expected {
- t.Errorf(`expected foo test data relative path [%q], got %q`,
- expected, fooTestData.Strings())
- }
- }
- func TestHostBinaryNoJavaDebugInfoOverride(t *testing.T) {
- bp := `
- java_library {
- name: "target_library",
- srcs: ["a.java"],
- }
- java_binary_host {
- name: "host_binary",
- srcs: ["b.java"],
- }
- `
- result := android.GroupFixturePreparers(
- PrepareForTestWithJavaDefaultModules,
- android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
- variables.MinimizeJavaDebugInfo = proptools.BoolPtr(true)
- }),
- ).RunTestWithBp(t, bp)
- // first, check that the -g flag is added to target modules
- targetLibrary := result.ModuleForTests("target_library", "android_common")
- targetJavaFlags := targetLibrary.Module().VariablesForTests()["javacFlags"]
- if !strings.Contains(targetJavaFlags, "-g:source,lines") {
- t.Errorf("target library javac flags %v should contain "+
- "-g:source,lines override with MinimizeJavaDebugInfo", targetJavaFlags)
- }
- // check that -g is not overridden for host modules
- buildOS := result.Config.BuildOS.String()
- hostBinary := result.ModuleForTests("host_binary", buildOS+"_common")
- hostJavaFlags := hostBinary.Module().VariablesForTests()["javacFlags"]
- if strings.Contains(hostJavaFlags, "-g:source,lines") {
- t.Errorf("java_binary_host javac flags %v should not have "+
- "-g:source,lines override with MinimizeJavaDebugInfo", hostJavaFlags)
- }
- }
- func TestPrebuilts(t *testing.T) {
- ctx, _ := testJava(t, `
- java_library {
- name: "foo",
- srcs: ["a.java", ":stubs-source"],
- libs: ["bar", "sdklib"],
- static_libs: ["baz"],
- }
- java_import {
- name: "bar",
- jars: ["a.jar"],
- }
- java_import {
- name: "baz",
- jars: ["b.jar"],
- sdk_version: "current",
- compile_dex: true,
- }
- dex_import {
- name: "qux",
- jars: ["b.jar"],
- }
- java_sdk_library_import {
- name: "sdklib",
- public: {
- jars: ["c.jar"],
- },
- }
- prebuilt_stubs_sources {
- name: "stubs-source",
- srcs: ["stubs/sources"],
- }
- java_test_import {
- name: "test",
- jars: ["a.jar"],
- test_suites: ["cts"],
- test_config: "AndroidTest.xml",
- }
- `)
- fooModule := ctx.ModuleForTests("foo", "android_common")
- javac := fooModule.Rule("javac")
- combineJar := ctx.ModuleForTests("foo", "android_common").Description("for javac")
- barModule := ctx.ModuleForTests("bar", "android_common")
- barJar := barModule.Rule("combineJar").Output
- bazModule := ctx.ModuleForTests("baz", "android_common")
- bazJar := bazModule.Rule("combineJar").Output
- sdklibStubsJar := ctx.ModuleForTests("sdklib.stubs", "android_common").Rule("combineJar").Output
- fooLibrary := fooModule.Module().(*Library)
- assertDeepEquals(t, "foo unique sources incorrect",
- []string{"a.java"}, fooLibrary.uniqueSrcFiles.Strings())
- assertDeepEquals(t, "foo java source jars incorrect",
- []string{".intermediates/stubs-source/android_common/stubs-source-stubs.srcjar"},
- android.NormalizePathsForTesting(fooLibrary.compiledSrcJars))
- if !strings.Contains(javac.Args["classpath"], barJar.String()) {
- t.Errorf("foo classpath %v does not contain %q", javac.Args["classpath"], barJar.String())
- }
- barDexJar := barModule.Module().(*Import).DexJarBuildPath()
- if barDexJar.IsSet() {
- t.Errorf("bar dex jar build path expected to be set, got %s", barDexJar)
- }
- if !strings.Contains(javac.Args["classpath"], sdklibStubsJar.String()) {
- t.Errorf("foo classpath %v does not contain %q", javac.Args["classpath"], sdklibStubsJar.String())
- }
- if len(combineJar.Inputs) != 2 || combineJar.Inputs[1].String() != bazJar.String() {
- t.Errorf("foo combineJar inputs %v does not contain %q", combineJar.Inputs, bazJar.String())
- }
- bazDexJar := bazModule.Module().(*Import).DexJarBuildPath().Path()
- expectedDexJar := "out/soong/.intermediates/baz/android_common/dex/baz.jar"
- android.AssertPathRelativeToTopEquals(t, "baz dex jar build path", expectedDexJar, bazDexJar)
- ctx.ModuleForTests("qux", "android_common").Rule("Cp")
- entries := android.AndroidMkEntriesForTest(t, ctx, fooModule.Module())[0]
- android.AssertStringEquals(t, "unexpected LOCAL_SOONG_MODULE_TYPE", "java_library", entries.EntryMap["LOCAL_SOONG_MODULE_TYPE"][0])
- entries = android.AndroidMkEntriesForTest(t, ctx, barModule.Module())[0]
- android.AssertStringEquals(t, "unexpected LOCAL_SOONG_MODULE_TYPE", "java_import", entries.EntryMap["LOCAL_SOONG_MODULE_TYPE"][0])
- entries = android.AndroidMkEntriesForTest(t, ctx, ctx.ModuleForTests("sdklib", "android_common").Module())[0]
- android.AssertStringEquals(t, "unexpected LOCAL_SOONG_MODULE_TYPE", "java_sdk_library_import", entries.EntryMap["LOCAL_SOONG_MODULE_TYPE"][0])
- }
- func assertDeepEquals(t *testing.T, message string, expected interface{}, actual interface{}) {
- if !reflect.DeepEqual(expected, actual) {
- t.Errorf("%s: expected %q, found %q", message, expected, actual)
- }
- }
- func TestPrebuiltStubsSources(t *testing.T) {
- test := func(t *testing.T, sourcesPath string, expectedInputs []string) {
- ctx, _ := testJavaWithFS(t, fmt.Sprintf(`
- prebuilt_stubs_sources {
- name: "stubs-source",
- srcs: ["%s"],
- }`, sourcesPath), map[string][]byte{
- "stubs/sources/pkg/A.java": nil,
- "stubs/sources/pkg/B.java": nil,
- })
- zipSrc := ctx.ModuleForTests("stubs-source", "android_common").Rule("zip_src")
- if expected, actual := expectedInputs, zipSrc.Inputs.Strings(); !reflect.DeepEqual(expected, actual) {
- t.Errorf("mismatch of inputs to soong_zip: expected %q, actual %q", expected, actual)
- }
- }
- t.Run("empty/missing directory", func(t *testing.T) {
- test(t, "empty-directory", nil)
- })
- t.Run("non-empty set of sources", func(t *testing.T) {
- test(t, "stubs/sources", []string{
- "stubs/sources/pkg/A.java",
- "stubs/sources/pkg/B.java",
- })
- })
- }
- func TestDefaults(t *testing.T) {
- ctx, _ := testJava(t, `
- java_defaults {
- name: "defaults",
- srcs: ["a.java"],
- libs: ["bar"],
- static_libs: ["baz"],
- optimize: {enabled: false},
- }
- java_library {
- name: "foo",
- defaults: ["defaults"],
- }
- java_library {
- name: "bar",
- srcs: ["b.java"],
- }
- java_library {
- name: "baz",
- srcs: ["c.java"],
- }
- android_test {
- name: "atestOptimize",
- defaults: ["defaults"],
- optimize: {enabled: true},
- }
- android_test {
- name: "atestNoOptimize",
- defaults: ["defaults"],
- }
- android_test {
- name: "atestDefault",
- srcs: ["a.java"],
- }
- `)
- javac := ctx.ModuleForTests("foo", "android_common").Rule("javac")
- combineJar := ctx.ModuleForTests("foo", "android_common").Description("for javac")
- if len(javac.Inputs) != 1 || javac.Inputs[0].String() != "a.java" {
- t.Errorf(`foo inputs %v != ["a.java"]`, javac.Inputs)
- }
- barTurbine := filepath.Join("out", "soong", ".intermediates", "bar", "android_common", "turbine-combined", "bar.jar")
- if !strings.Contains(javac.Args["classpath"], barTurbine) {
- t.Errorf("foo classpath %v does not contain %q", javac.Args["classpath"], barTurbine)
- }
- baz := ctx.ModuleForTests("baz", "android_common").Rule("javac").Output.String()
- if len(combineJar.Inputs) != 2 || combineJar.Inputs[1].String() != baz {
- t.Errorf("foo combineJar inputs %v does not contain %q", combineJar.Inputs, baz)
- }
- atestOptimize := ctx.ModuleForTests("atestOptimize", "android_common").MaybeRule("r8")
- if atestOptimize.Output == nil {
- t.Errorf("atestOptimize should optimize APK")
- }
- atestNoOptimize := ctx.ModuleForTests("atestNoOptimize", "android_common").MaybeRule("d8")
- if atestNoOptimize.Output == nil {
- t.Errorf("atestNoOptimize should not optimize APK")
- }
- atestDefault := ctx.ModuleForTests("atestDefault", "android_common").MaybeRule("d8")
- if atestDefault.Output == nil {
- t.Errorf("atestDefault should not optimize APK")
- }
- }
- func TestResources(t *testing.T) {
- var table = []struct {
- name string
- prop string
- extra string
- args string
- }{
- {
- // Test that a module with java_resource_dirs includes the files
- name: "resource dirs",
- prop: `java_resource_dirs: ["java-res"]`,
- args: "-C java-res -f java-res/a/a -f java-res/b/b",
- },
- {
- // Test that a module with java_resources includes the files
- name: "resource files",
- prop: `java_resources: ["java-res/a/a", "java-res/b/b"]`,
- args: "-C . -f java-res/a/a -f java-res/b/b",
- },
- {
- // Test that a module with a filegroup in java_resources includes the files with the
- // path prefix
- name: "resource filegroup",
- prop: `java_resources: [":foo-res"]`,
- extra: `
- filegroup {
- name: "foo-res",
- path: "java-res",
- srcs: ["java-res/a/a", "java-res/b/b"],
- }`,
- args: "-C java-res -f java-res/a/a -f java-res/b/b",
- },
- {
- // Test that a module with wildcards in java_resource_dirs has the correct path prefixes
- name: "wildcard dirs",
- prop: `java_resource_dirs: ["java-res/*"]`,
- args: "-C java-res/a -f java-res/a/a -C java-res/b -f java-res/b/b",
- },
- {
- // Test that a module exclude_java_resource_dirs excludes the files
- name: "wildcard dirs",
- prop: `java_resource_dirs: ["java-res/*"], exclude_java_resource_dirs: ["java-res/b"]`,
- args: "-C java-res/a -f java-res/a/a",
- },
- {
- // Test wildcards in java_resources
- name: "wildcard files",
- prop: `java_resources: ["java-res/**/*"]`,
- args: "-C . -f java-res/a/a -f java-res/b/b",
- },
- {
- // Test exclude_java_resources with java_resources
- name: "wildcard files with exclude",
- prop: `java_resources: ["java-res/**/*"], exclude_java_resources: ["java-res/b/*"]`,
- args: "-C . -f java-res/a/a",
- },
- {
- // Test exclude_java_resources with java_resource_dirs
- name: "resource dirs with exclude files",
- prop: `java_resource_dirs: ["java-res"], exclude_java_resources: ["java-res/b/b"]`,
- args: "-C java-res -f java-res/a/a",
- },
- {
- // Test exclude_java_resource_dirs with java_resource_dirs
- name: "resource dirs with exclude files",
- prop: `java_resource_dirs: ["java-res", "java-res2"], exclude_java_resource_dirs: ["java-res2"]`,
- args: "-C java-res -f java-res/a/a -f java-res/b/b",
- },
- }
- for _, test := range table {
- t.Run(test.name, func(t *testing.T) {
- ctx, _ := testJavaWithFS(t, `
- java_library {
- name: "foo",
- srcs: [
- "a.java",
- "b.java",
- "c.java",
- ],
- `+test.prop+`,
- }
- `+test.extra,
- map[string][]byte{
- "java-res/a/a": nil,
- "java-res/b/b": nil,
- "java-res2/a": nil,
- },
- )
- foo := ctx.ModuleForTests("foo", "android_common").Output("withres/foo.jar")
- fooRes := ctx.ModuleForTests("foo", "android_common").Output("res/foo.jar")
- if !inList(fooRes.Output.String(), foo.Inputs.Strings()) {
- t.Errorf("foo combined jars %v does not contain %q",
- foo.Inputs.Strings(), fooRes.Output.String())
- }
- if fooRes.Args["jarArgs"] != test.args {
- t.Errorf("foo resource jar args %q is not %q",
- fooRes.Args["jarArgs"], test.args)
- }
- })
- }
- }
- func TestIncludeSrcs(t *testing.T) {
- ctx, _ := testJavaWithFS(t, `
- java_library {
- name: "foo",
- srcs: [
- "a.java",
- "b.java",
- "c.java",
- ],
- include_srcs: true,
- }
- java_library {
- name: "bar",
- srcs: [
- "a.java",
- "b.java",
- "c.java",
- ],
- java_resource_dirs: ["java-res"],
- include_srcs: true,
- }
- `, map[string][]byte{
- "java-res/a/a": nil,
- "java-res/b/b": nil,
- "java-res2/a": nil,
- })
- // Test a library with include_srcs: true
- foo := ctx.ModuleForTests("foo", "android_common").Output("withres/foo.jar")
- fooSrcJar := ctx.ModuleForTests("foo", "android_common").Output("foo.srcjar")
- if g, w := fooSrcJar.Output.String(), foo.Inputs.Strings(); !inList(g, w) {
- t.Errorf("foo combined jars %v does not contain %q", w, g)
- }
- if g, w := fooSrcJar.Args["jarArgs"], "-C . -f a.java -f b.java -f c.java"; g != w {
- t.Errorf("foo source jar args %q is not %q", w, g)
- }
- // Test a library with include_srcs: true and resources
- bar := ctx.ModuleForTests("bar", "android_common").Output("withres/bar.jar")
- barResCombined := ctx.ModuleForTests("bar", "android_common").Output("res-combined/bar.jar")
- barRes := ctx.ModuleForTests("bar", "android_common").Output("res/bar.jar")
- barSrcJar := ctx.ModuleForTests("bar", "android_common").Output("bar.srcjar")
- if g, w := barSrcJar.Output.String(), barResCombined.Inputs.Strings(); !inList(g, w) {
- t.Errorf("bar combined resource jars %v does not contain %q", w, g)
- }
- if g, w := barRes.Output.String(), barResCombined.Inputs.Strings(); !inList(g, w) {
- t.Errorf("bar combined resource jars %v does not contain %q", w, g)
- }
- if g, w := barResCombined.Output.String(), bar.Inputs.Strings(); !inList(g, w) {
- t.Errorf("bar combined jars %v does not contain %q", w, g)
- }
- if g, w := barSrcJar.Args["jarArgs"], "-C . -f a.java -f b.java -f c.java"; g != w {
- t.Errorf("bar source jar args %q is not %q", w, g)
- }
- if g, w := barRes.Args["jarArgs"], "-C java-res -f java-res/a/a -f java-res/b/b"; g != w {
- t.Errorf("bar resource jar args %q is not %q", w, g)
- }
- }
- func TestGeneratedSources(t *testing.T) {
- ctx, _ := testJavaWithFS(t, `
- java_library {
- name: "foo",
- srcs: [
- "a*.java",
- ":gen",
- "b*.java",
- ],
- }
- genrule {
- name: "gen",
- tool_files: ["java-res/a"],
- out: ["gen.java"],
- }
- `, map[string][]byte{
- "a.java": nil,
- "b.java": nil,
- })
- javac := ctx.ModuleForTests("foo", "android_common").Rule("javac")
- genrule := ctx.ModuleForTests("gen", "").Rule("generator")
- if filepath.Base(genrule.Output.String()) != "gen.java" {
- t.Fatalf(`gen output file %v is not ".../gen.java"`, genrule.Output.String())
- }
- if len(javac.Inputs) != 3 ||
- javac.Inputs[0].String() != "a.java" ||
- javac.Inputs[1].String() != genrule.Output.String() ||
- javac.Inputs[2].String() != "b.java" {
- t.Errorf(`foo inputs %v != ["a.java", ".../gen.java", "b.java"]`, javac.Inputs)
- }
- }
- func TestTurbine(t *testing.T) {
- result := android.GroupFixturePreparers(
- prepareForJavaTest, FixtureWithPrebuiltApis(map[string][]string{"14": {"foo"}})).
- RunTestWithBp(t, `
- java_library {
- name: "foo",
- srcs: ["a.java"],
- sdk_version: "14",
- }
- java_library {
- name: "bar",
- srcs: ["b.java"],
- static_libs: ["foo"],
- sdk_version: "14",
- }
- java_library {
- name: "baz",
- srcs: ["c.java"],
- libs: ["bar"],
- sdk_version: "14",
- }
- `)
- fooTurbine := result.ModuleForTests("foo", "android_common").Rule("turbine")
- barTurbine := result.ModuleForTests("bar", "android_common").Rule("turbine")
- barJavac := result.ModuleForTests("bar", "android_common").Rule("javac")
- barTurbineCombined := result.ModuleForTests("bar", "android_common").Description("for turbine")
- bazJavac := result.ModuleForTests("baz", "android_common").Rule("javac")
- android.AssertPathsRelativeToTopEquals(t, "foo inputs", []string{"a.java"}, fooTurbine.Inputs)
- fooHeaderJar := filepath.Join("out", "soong", ".intermediates", "foo", "android_common", "turbine-combined", "foo.jar")
- barTurbineJar := filepath.Join("out", "soong", ".intermediates", "bar", "android_common", "turbine", "bar.jar")
- android.AssertStringDoesContain(t, "bar turbine classpath", barTurbine.Args["turbineFlags"], fooHeaderJar)
- android.AssertStringDoesContain(t, "bar javac classpath", barJavac.Args["classpath"], fooHeaderJar)
- android.AssertPathsRelativeToTopEquals(t, "bar turbine combineJar", []string{barTurbineJar, fooHeaderJar}, barTurbineCombined.Inputs)
- android.AssertStringDoesContain(t, "baz javac classpath", bazJavac.Args["classpath"], "prebuilts/sdk/14/public/android.jar")
- }
- func TestSharding(t *testing.T) {
- ctx, _ := testJava(t, `
- java_library {
- name: "bar",
- srcs: ["a.java","b.java","c.java"],
- javac_shard_size: 1
- }
- `)
- barHeaderJar := filepath.Join("out", "soong", ".intermediates", "bar", "android_common", "turbine", "bar.jar")
- for i := 0; i < 3; i++ {
- barJavac := ctx.ModuleForTests("bar", "android_common").Description("javac" + strconv.Itoa(i))
- if !strings.HasPrefix(barJavac.Args["classpath"], "-classpath "+barHeaderJar+":") {
- t.Errorf("bar javac classpath %v does start with %q", barJavac.Args["classpath"], barHeaderJar)
- }
- }
- }
- func TestExcludeFileGroupInSrcs(t *testing.T) {
- ctx, _ := testJava(t, `
- java_library {
- name: "foo",
- srcs: ["a.java", ":foo-srcs"],
- exclude_srcs: ["a.java", ":foo-excludes"],
- }
- filegroup {
- name: "foo-srcs",
- srcs: ["java-fg/a.java", "java-fg/b.java", "java-fg/c.java"],
- }
- filegroup {
- name: "foo-excludes",
- srcs: ["java-fg/a.java", "java-fg/b.java"],
- }
- `)
- javac := ctx.ModuleForTests("foo", "android_common").Rule("javac")
- if len(javac.Inputs) != 1 || javac.Inputs[0].String() != "java-fg/c.java" {
- t.Errorf(`foo inputs %v != ["java-fg/c.java"]`, javac.Inputs)
- }
- }
- func TestJavaLibrary(t *testing.T) {
- testJavaWithFS(t, "", map[string][]byte{
- "libcore/Android.bp": []byte(`
- java_library {
- name: "core",
- sdk_version: "none",
- system_modules: "none",
- }
- filegroup {
- name: "core-jar",
- srcs: [":core{.jar}"],
- }
- `),
- })
- }
- func TestJavaImport(t *testing.T) {
- testJavaWithFS(t, "", map[string][]byte{
- "libcore/Android.bp": []byte(`
- java_import {
- name: "core",
- sdk_version: "none",
- }
- filegroup {
- name: "core-jar",
- srcs: [":core{.jar}"],
- }
- `),
- })
- }
- var compilerFlagsTestCases = []struct {
- in string
- out bool
- }{
- {
- in: "a",
- out: false,
- },
- {
- in: "-a",
- out: true,
- },
- {
- in: "-no-jdk",
- out: false,
- },
- {
- in: "-no-stdlib",
- out: false,
- },
- {
- in: "-kotlin-home",
- out: false,
- },
- {
- in: "-kotlin-home /some/path",
- out: false,
- },
- {
- in: "-include-runtime",
- out: false,
- },
- {
- in: "-Xintellij-plugin-root",
- out: false,
- },
- }
- type mockContext struct {
- android.ModuleContext
- result bool
- }
- func (ctx *mockContext) PropertyErrorf(property, format string, args ...interface{}) {
- // CheckBadCompilerFlags calls this function when the flag should be rejected
- ctx.result = false
- }
- func TestCompilerFlags(t *testing.T) {
- for _, testCase := range compilerFlagsTestCases {
- ctx := &mockContext{result: true}
- CheckKotlincFlags(ctx, []string{testCase.in})
- if ctx.result != testCase.out {
- t.Errorf("incorrect output:")
- t.Errorf(" input: %#v", testCase.in)
- t.Errorf(" expected: %#v", testCase.out)
- t.Errorf(" got: %#v", ctx.result)
- }
- }
- }
- // TODO(jungjw): Consider making this more robust by ignoring path order.
- func checkPatchModuleFlag(t *testing.T, ctx *android.TestContext, moduleName string, expected string) {
- variables := ctx.ModuleForTests(moduleName, "android_common").VariablesForTestsRelativeToTop()
- flags := strings.Split(variables["javacFlags"], " ")
- got := ""
- for _, flag := range flags {
- keyEnd := strings.Index(flag, "=")
- if keyEnd > -1 && flag[:keyEnd] == "--patch-module" {
- got = flag[keyEnd+1:]
- break
- }
- }
- if expected != android.StringPathRelativeToTop(ctx.Config().SoongOutDir(), got) {
- t.Errorf("Unexpected patch-module flag for module %q - expected %q, but got %q", moduleName, expected, got)
- }
- }
- func TestPatchModule(t *testing.T) {
- t.Run("Java language level 8", func(t *testing.T) {
- // Test with legacy javac -source 1.8 -target 1.8
- bp := `
- java_library {
- name: "foo",
- srcs: ["a.java"],
- java_version: "1.8",
- }
- java_library {
- name: "bar",
- srcs: ["b.java"],
- sdk_version: "none",
- system_modules: "none",
- patch_module: "java.base",
- java_version: "1.8",
- }
- java_library {
- name: "baz",
- srcs: ["c.java"],
- patch_module: "java.base",
- java_version: "1.8",
- }
- `
- ctx, _ := testJava(t, bp)
- checkPatchModuleFlag(t, ctx, "foo", "")
- checkPatchModuleFlag(t, ctx, "bar", "")
- checkPatchModuleFlag(t, ctx, "baz", "")
- })
- t.Run("Java language level 9", func(t *testing.T) {
- // Test with default javac -source 9 -target 9
- bp := `
- java_library {
- name: "foo",
- srcs: ["a.java"],
- }
- java_library {
- name: "bar",
- srcs: ["b.java"],
- sdk_version: "none",
- system_modules: "none",
- patch_module: "java.base",
- }
- java_library {
- name: "baz",
- srcs: [
- "c.java",
- // Tests for b/150878007
- "dir/d.java",
- "dir2/e.java",
- "dir2/f.java",
- "nested/dir/g.java"
- ],
- patch_module: "java.base",
- }
- `
- ctx, _ := testJava(t, bp)
- checkPatchModuleFlag(t, ctx, "foo", "")
- expected := "java.base=.:out/soong"
- checkPatchModuleFlag(t, ctx, "bar", expected)
- expected = "java.base=" + strings.Join([]string{
- ".", "out/soong", "dir", "dir2", "nested", defaultModuleToPath("ext"), defaultModuleToPath("framework")}, ":")
- checkPatchModuleFlag(t, ctx, "baz", expected)
- })
- }
- func TestJavaLibraryWithSystemModules(t *testing.T) {
- ctx, _ := testJava(t, `
- java_library {
- name: "lib-with-source-system-modules",
- srcs: [
- "a.java",
- ],
- sdk_version: "none",
- system_modules: "source-system-modules",
- }
- java_library {
- name: "source-jar",
- srcs: [
- "a.java",
- ],
- }
- java_system_modules {
- name: "source-system-modules",
- libs: ["source-jar"],
- }
- java_library {
- name: "lib-with-prebuilt-system-modules",
- srcs: [
- "a.java",
- ],
- sdk_version: "none",
- system_modules: "prebuilt-system-modules",
- }
- java_import {
- name: "prebuilt-jar",
- jars: ["a.jar"],
- }
- java_system_modules_import {
- name: "prebuilt-system-modules",
- libs: ["prebuilt-jar"],
- }
- `)
- checkBootClasspathForSystemModule(t, ctx, "lib-with-source-system-modules", "/source-jar.jar")
- checkBootClasspathForSystemModule(t, ctx, "lib-with-prebuilt-system-modules", "/prebuilt-jar.jar")
- }
- func checkBootClasspathForSystemModule(t *testing.T, ctx *android.TestContext, moduleName string, expectedSuffix string) {
- javacRule := ctx.ModuleForTests(moduleName, "android_common").Rule("javac")
- bootClasspath := javacRule.Args["bootClasspath"]
- if strings.HasPrefix(bootClasspath, "--system ") && strings.HasSuffix(bootClasspath, expectedSuffix) {
- t.Errorf("bootclasspath of %q must start with --system and end with %q, but was %#v.", moduleName, expectedSuffix, bootClasspath)
- }
- }
- func TestAidlExportIncludeDirsFromImports(t *testing.T) {
- ctx, _ := testJava(t, `
- java_library {
- name: "foo",
- srcs: ["aidl/foo/IFoo.aidl"],
- libs: ["bar"],
- }
- java_import {
- name: "bar",
- jars: ["a.jar"],
- aidl: {
- export_include_dirs: ["aidl/bar"],
- },
- }
- `)
- aidlCommand := ctx.ModuleForTests("foo", "android_common").Rule("aidl").RuleParams.Command
- expectedAidlFlag := "-Iaidl/bar"
- if !strings.Contains(aidlCommand, expectedAidlFlag) {
- t.Errorf("aidl command %q does not contain %q", aidlCommand, expectedAidlFlag)
- }
- }
- func TestAidlIncludeDirFromConvertedFileGroupWithPathPropInMixedBuilds(t *testing.T) {
- // TODO(b/247782695), TODO(b/242847534) Fix mixed builds for filegroups
- t.Skip("Re-enable once filegroups are corrected for mixed builds")
- bp := `
- filegroup {
- name: "foo_aidl",
- srcs: ["aidl/foo/IFoo.aidl"],
- path: "aidl/foo",
- bazel_module: { label: "//:foo_aidl" },
- }
- java_library {
- name: "foo",
- srcs: [":foo_aidl"],
- }
- `
- outBaseDir := "out/bazel/output"
- result := android.GroupFixturePreparers(
- prepareForJavaTest,
- android.PrepareForTestWithFilegroup,
- android.FixtureModifyConfig(func(config android.Config) {
- config.BazelContext = android.MockBazelContext{
- OutputBaseDir: outBaseDir,
- LabelToOutputFiles: map[string][]string{
- "//:foo_aidl": []string{"aidl/foo/IFoo.aidl"},
- },
- }
- }),
- ).RunTestWithBp(t, bp)
- aidlCommand := result.ModuleForTests("foo", "android_common").Rule("aidl").RuleParams.Command
- expectedAidlFlag := "-I" + outBaseDir + "/execroot/__main__/aidl/foo"
- if !strings.Contains(aidlCommand, expectedAidlFlag) {
- t.Errorf("aidl command %q does not contain %q", aidlCommand, expectedAidlFlag)
- }
- }
- func TestAidlFlagsArePassedToTheAidlCompiler(t *testing.T) {
- ctx, _ := testJava(t, `
- java_library {
- name: "foo",
- srcs: ["aidl/foo/IFoo.aidl"],
- aidl: { flags: ["-Werror"], },
- }
- `)
- aidlCommand := ctx.ModuleForTests("foo", "android_common").Rule("aidl").RuleParams.Command
- expectedAidlFlag := "-Werror"
- if !strings.Contains(aidlCommand, expectedAidlFlag) {
- t.Errorf("aidl command %q does not contain %q", aidlCommand, expectedAidlFlag)
- }
- }
- func TestAidlFlagsWithMinSdkVersion(t *testing.T) {
- fixture := android.GroupFixturePreparers(
- prepareForJavaTest, FixtureWithPrebuiltApis(map[string][]string{"14": {"foo"}}))
- for _, tc := range []struct {
- name string
- sdkVersion string
- expected string
- }{
- {"default is current", "", "current"},
- {"use sdk_version", `sdk_version: "14"`, "14"},
- {"system_current", `sdk_version: "system_current"`, "current"},
- } {
- t.Run(tc.name, func(t *testing.T) {
- ctx := fixture.RunTestWithBp(t, `
- java_library {
- name: "foo",
- srcs: ["aidl/foo/IFoo.aidl"],
- `+tc.sdkVersion+`
- }
- `)
- aidlCommand := ctx.ModuleForTests("foo", "android_common").Rule("aidl").RuleParams.Command
- expectedAidlFlag := "--min_sdk_version=" + tc.expected
- if !strings.Contains(aidlCommand, expectedAidlFlag) {
- t.Errorf("aidl command %q does not contain %q", aidlCommand, expectedAidlFlag)
- }
- })
- }
- }
- func TestAidlFlagsMinSdkVersionDroidstubs(t *testing.T) {
- bpTemplate := `
- droidstubs {
- name: "foo-stubs",
- srcs: ["foo.aidl"],
- %s
- system_modules: "none",
- }
- `
- testCases := []struct {
- desc string
- sdkVersionBp string
- minSdkVersionExpected string
- }{
- {
- desc: "sdk_version not set, module compiles against private platform APIs",
- sdkVersionBp: ``,
- minSdkVersionExpected: "10000",
- },
- {
- desc: "sdk_version set to none, module does not build against an SDK",
- sdkVersionBp: `sdk_version: "none",`,
- minSdkVersionExpected: "10000",
- },
- }
- for _, tc := range testCases {
- ctx := prepareForJavaTest.RunTestWithBp(t, fmt.Sprintf(bpTemplate, tc.sdkVersionBp))
- aidlCmd := ctx.ModuleForTests("foo-stubs", "android_common").Rule("aidl").RuleParams.Command
- expected := "--min_sdk_version=" + tc.minSdkVersionExpected
- android.AssertStringDoesContain(t, "aidl command conatins incorrect min_sdk_version for testCse: "+tc.desc, aidlCmd, expected)
- }
- }
- func TestAidlEnforcePermissions(t *testing.T) {
- ctx, _ := testJava(t, `
- java_library {
- name: "foo",
- srcs: ["aidl/foo/IFoo.aidl"],
- aidl: { enforce_permissions: true },
- }
- `)
- aidlCommand := ctx.ModuleForTests("foo", "android_common").Rule("aidl").RuleParams.Command
- expectedAidlFlag := "-Wmissing-permission-annotation -Werror"
- if !strings.Contains(aidlCommand, expectedAidlFlag) {
- t.Errorf("aidl command %q does not contain %q", aidlCommand, expectedAidlFlag)
- }
- }
- func TestAidlEnforcePermissionsException(t *testing.T) {
- ctx, _ := testJava(t, `
- java_library {
- name: "foo",
- srcs: ["aidl/foo/IFoo.aidl", "aidl/foo/IFoo2.aidl"],
- aidl: { enforce_permissions: true, enforce_permissions_exceptions: ["aidl/foo/IFoo2.aidl"] },
- }
- `)
- aidlCommand := ctx.ModuleForTests("foo", "android_common").Rule("aidl").RuleParams.Command
- expectedAidlFlag := "$$FLAGS -Wmissing-permission-annotation -Werror aidl/foo/IFoo.aidl"
- if !strings.Contains(aidlCommand, expectedAidlFlag) {
- t.Errorf("aidl command %q does not contain %q", aidlCommand, expectedAidlFlag)
- }
- expectedAidlFlag = "$$FLAGS aidl/foo/IFoo2.aidl"
- if !strings.Contains(aidlCommand, expectedAidlFlag) {
- t.Errorf("aidl command %q does not contain %q", aidlCommand, expectedAidlFlag)
- }
- }
- func TestDataNativeBinaries(t *testing.T) {
- ctx := android.GroupFixturePreparers(
- prepareForJavaTest,
- android.PrepareForTestWithAllowMissingDependencies).RunTestWithBp(t, `
- java_test_host {
- name: "foo",
- srcs: ["a.java"],
- data_native_bins: ["bin"]
- }
- cc_binary_host {
- name: "bin",
- srcs: ["bin.cpp"],
- }
- `).TestContext
- buildOS := ctx.Config().BuildOS.String()
- test := ctx.ModuleForTests("foo", buildOS+"_common").Module().(*TestHost)
- entries := android.AndroidMkEntriesForTest(t, ctx, test)[0]
- expected := []string{"out/soong/.intermediates/bin/" + buildOS + "_x86_64/bin:bin"}
- actual := entries.EntryMap["LOCAL_COMPATIBILITY_SUPPORT_FILES"]
- android.AssertStringPathsRelativeToTopEquals(t, "LOCAL_COMPATIBILITY_SUPPORT_FILES", ctx.Config(), expected, actual)
- }
- func TestDefaultInstallable(t *testing.T) {
- ctx, _ := testJava(t, `
- java_test_host {
- name: "foo"
- }
- `)
- buildOS := ctx.Config().BuildOS.String()
- module := ctx.ModuleForTests("foo", buildOS+"_common").Module().(*TestHost)
- assertDeepEquals(t, "Default installable value should be true.", proptools.BoolPtr(true),
- module.properties.Installable)
- }
- func TestErrorproneEnabled(t *testing.T) {
- ctx, _ := testJava(t, `
- java_library {
- name: "foo",
- srcs: ["a.java"],
- errorprone: {
- enabled: true,
- },
- }
- `)
- javac := ctx.ModuleForTests("foo", "android_common").Description("javac")
- // Test that the errorprone plugins are passed to javac
- expectedSubstring := "-Xplugin:ErrorProne"
- if !strings.Contains(javac.Args["javacFlags"], expectedSubstring) {
- t.Errorf("expected javacFlags to contain %q, got %q", expectedSubstring, javac.Args["javacFlags"])
- }
- // Modules with errorprone { enabled: true } will include errorprone checks
- // in the main javac build rule. Only when RUN_ERROR_PRONE is true will
- // the explicit errorprone build rule be created.
- errorprone := ctx.ModuleForTests("foo", "android_common").MaybeDescription("errorprone")
- if errorprone.RuleParams.Description != "" {
- t.Errorf("expected errorprone build rule to not exist, but it did")
- }
- }
- func TestErrorproneDisabled(t *testing.T) {
- bp := `
- java_library {
- name: "foo",
- srcs: ["a.java"],
- errorprone: {
- enabled: false,
- },
- }
- `
- ctx := android.GroupFixturePreparers(
- PrepareForTestWithJavaDefaultModules,
- android.FixtureMergeEnv(map[string]string{
- "RUN_ERROR_PRONE": "true",
- }),
- ).RunTestWithBp(t, bp)
- javac := ctx.ModuleForTests("foo", "android_common").Description("javac")
- // Test that the errorprone plugins are not passed to javac, like they would
- // be if enabled was true.
- expectedSubstring := "-Xplugin:ErrorProne"
- if strings.Contains(javac.Args["javacFlags"], expectedSubstring) {
- t.Errorf("expected javacFlags to not contain %q, got %q", expectedSubstring, javac.Args["javacFlags"])
- }
- // Check that no errorprone build rule is created, like there would be
- // if enabled was unset and RUN_ERROR_PRONE was true.
- errorprone := ctx.ModuleForTests("foo", "android_common").MaybeDescription("errorprone")
- if errorprone.RuleParams.Description != "" {
- t.Errorf("expected errorprone build rule to not exist, but it did")
- }
- }
- func TestErrorproneEnabledOnlyByEnvironmentVariable(t *testing.T) {
- bp := `
- java_library {
- name: "foo",
- srcs: ["a.java"],
- }
- `
- ctx := android.GroupFixturePreparers(
- PrepareForTestWithJavaDefaultModules,
- android.FixtureMergeEnv(map[string]string{
- "RUN_ERROR_PRONE": "true",
- }),
- ).RunTestWithBp(t, bp)
- javac := ctx.ModuleForTests("foo", "android_common").Description("javac")
- errorprone := ctx.ModuleForTests("foo", "android_common").Description("errorprone")
- // Check that the errorprone plugins are not passed to javac, because they
- // will instead be passed to the separate errorprone compilation
- expectedSubstring := "-Xplugin:ErrorProne"
- if strings.Contains(javac.Args["javacFlags"], expectedSubstring) {
- t.Errorf("expected javacFlags to not contain %q, got %q", expectedSubstring, javac.Args["javacFlags"])
- }
- // Check that the errorprone plugin is enabled
- if !strings.Contains(errorprone.Args["javacFlags"], expectedSubstring) {
- t.Errorf("expected errorprone to contain %q, got %q", expectedSubstring, javac.Args["javacFlags"])
- }
- }
- func TestDataDeviceBinsBuildsDeviceBinary(t *testing.T) {
- testCases := []struct {
- dataDeviceBinType string
- depCompileMultilib string
- variants []string
- expectedError string
- }{
- {
- dataDeviceBinType: "first",
- depCompileMultilib: "first",
- variants: []string{"android_arm64_armv8-a"},
- },
- {
- dataDeviceBinType: "first",
- depCompileMultilib: "both",
- variants: []string{"android_arm64_armv8-a"},
- },
- {
- // this is true because our testing framework is set up with
- // Targets ~ [<64bit target>, <32bit target>], where 64bit is "first"
- dataDeviceBinType: "first",
- depCompileMultilib: "32",
- expectedError: `Android.bp:2:3: dependency "bar" of "foo" missing variant`,
- },
- {
- dataDeviceBinType: "first",
- depCompileMultilib: "64",
- variants: []string{"android_arm64_armv8-a"},
- },
- {
- dataDeviceBinType: "both",
- depCompileMultilib: "both",
- variants: []string{
- "android_arm_armv7-a-neon",
- "android_arm64_armv8-a",
- },
- },
- {
- dataDeviceBinType: "both",
- depCompileMultilib: "32",
- expectedError: `Android.bp:2:3: dependency "bar" of "foo" missing variant`,
- },
- {
- dataDeviceBinType: "both",
- depCompileMultilib: "64",
- expectedError: `Android.bp:2:3: dependency "bar" of "foo" missing variant`,
- },
- {
- dataDeviceBinType: "both",
- depCompileMultilib: "first",
- expectedError: `Android.bp:2:3: dependency "bar" of "foo" missing variant`,
- },
- {
- dataDeviceBinType: "32",
- depCompileMultilib: "32",
- variants: []string{"android_arm_armv7-a-neon"},
- },
- {
- dataDeviceBinType: "32",
- depCompileMultilib: "first",
- expectedError: `Android.bp:2:3: dependency "bar" of "foo" missing variant`,
- },
- {
- dataDeviceBinType: "32",
- depCompileMultilib: "both",
- variants: []string{"android_arm_armv7-a-neon"},
- },
- {
- dataDeviceBinType: "32",
- depCompileMultilib: "64",
- expectedError: `Android.bp:2:3: dependency "bar" of "foo" missing variant`,
- },
- {
- dataDeviceBinType: "64",
- depCompileMultilib: "64",
- variants: []string{"android_arm64_armv8-a"},
- },
- {
- dataDeviceBinType: "64",
- depCompileMultilib: "both",
- variants: []string{"android_arm64_armv8-a"},
- },
- {
- dataDeviceBinType: "64",
- depCompileMultilib: "first",
- variants: []string{"android_arm64_armv8-a"},
- },
- {
- dataDeviceBinType: "64",
- depCompileMultilib: "32",
- expectedError: `Android.bp:2:3: dependency "bar" of "foo" missing variant`,
- },
- {
- dataDeviceBinType: "prefer32",
- depCompileMultilib: "32",
- variants: []string{"android_arm_armv7-a-neon"},
- },
- {
- dataDeviceBinType: "prefer32",
- depCompileMultilib: "both",
- variants: []string{"android_arm_armv7-a-neon"},
- },
- {
- dataDeviceBinType: "prefer32",
- depCompileMultilib: "first",
- expectedError: `Android.bp:2:3: dependency "bar" of "foo" missing variant`,
- },
- {
- dataDeviceBinType: "prefer32",
- depCompileMultilib: "64",
- expectedError: `Android.bp:2:3: dependency "bar" of "foo" missing variant`,
- },
- }
- bpTemplate := `
- java_test_host {
- name: "foo",
- srcs: ["test.java"],
- data_device_bins_%s: ["bar"],
- }
- cc_binary {
- name: "bar",
- compile_multilib: "%s",
- }
- `
- for _, tc := range testCases {
- bp := fmt.Sprintf(bpTemplate, tc.dataDeviceBinType, tc.depCompileMultilib)
- errorHandler := android.FixtureExpectsNoErrors
- if tc.expectedError != "" {
- errorHandler = android.FixtureExpectsAtLeastOneErrorMatchingPattern(tc.expectedError)
- }
- testName := fmt.Sprintf(`data_device_bins_%s with compile_multilib:"%s"`, tc.dataDeviceBinType, tc.depCompileMultilib)
- t.Run(testName, func(t *testing.T) {
- ctx := android.GroupFixturePreparers(PrepareForIntegrationTestWithJava).
- ExtendWithErrorHandler(errorHandler).
- RunTestWithBp(t, bp)
- if tc.expectedError != "" {
- return
- }
- buildOS := ctx.Config.BuildOS.String()
- fooVariant := ctx.ModuleForTests("foo", buildOS+"_common")
- fooMod := fooVariant.Module().(*TestHost)
- entries := android.AndroidMkEntriesForTest(t, ctx.TestContext, fooMod)[0]
- expectedAutogenConfig := `<option name="push-file" key="bar" value="/data/local/tests/unrestricted/foo/bar" />`
- autogen := fooVariant.Rule("autogen")
- if !strings.Contains(autogen.Args["extraConfigs"], expectedAutogenConfig) {
- t.Errorf("foo extraConfigs %v does not contain %q", autogen.Args["extraConfigs"], expectedAutogenConfig)
- }
- expectedData := []string{}
- for _, variant := range tc.variants {
- barVariant := ctx.ModuleForTests("bar", variant)
- relocated := barVariant.Output("bar")
- expectedInput := fmt.Sprintf("out/soong/.intermediates/bar/%s/unstripped/bar", variant)
- android.AssertPathRelativeToTopEquals(t, "relocation input", expectedInput, relocated.Input)
- expectedData = append(expectedData, fmt.Sprintf("out/soong/.intermediates/bar/%s/bar:bar", variant))
- }
- actualData := entries.EntryMap["LOCAL_COMPATIBILITY_SUPPORT_FILES"]
- android.AssertStringPathsRelativeToTopEquals(t, "LOCAL_TEST_DATA", ctx.Config, expectedData, actualData)
- })
- }
- }
- func TestImportMixedBuild(t *testing.T) {
- bp := `
- java_import {
- name: "baz",
- jars: [
- "test1.jar",
- "test2.jar",
- ],
- bazel_module: { label: "//foo/bar:baz" },
- }
- `
- ctx := android.GroupFixturePreparers(
- prepareForJavaTest,
- android.FixtureModifyConfig(func(config android.Config) {
- config.BazelContext = android.MockBazelContext{
- OutputBaseDir: "outputbase",
- LabelToOutputFiles: map[string][]string{
- "//foo/bar:baz": []string{"test1.jar", "test2.jar"},
- },
- }
- }),
- ).RunTestWithBp(t, bp)
- bazMod := ctx.ModuleForTests("baz", "android_common").Module()
- producer := bazMod.(android.OutputFileProducer)
- expectedOutputFiles := []string{".intermediates/baz/android_common/bazelCombined/baz.jar"}
- outputFiles, err := producer.OutputFiles("")
- if err != nil {
- t.Errorf("Unexpected error getting java_import outputfiles %s", err)
- }
- actualOutputFiles := android.NormalizePathsForTesting(outputFiles)
- android.AssertDeepEquals(t, "Output files are produced", expectedOutputFiles, actualOutputFiles)
- javaInfoProvider := ctx.ModuleProvider(bazMod, JavaInfoProvider)
- javaInfo, ok := javaInfoProvider.(JavaInfo)
- if !ok {
- t.Error("could not get JavaInfo from java_import module")
- }
- android.AssertDeepEquals(t, "Header JARs are produced", expectedOutputFiles, android.NormalizePathsForTesting(javaInfo.HeaderJars))
- android.AssertDeepEquals(t, "Implementation/Resources JARs are produced", expectedOutputFiles, android.NormalizePathsForTesting(javaInfo.ImplementationAndResourcesJars))
- android.AssertDeepEquals(t, "Implementation JARs are produced", expectedOutputFiles, android.NormalizePathsForTesting(javaInfo.ImplementationJars))
- }
- func TestGenAidlIncludeFlagsForMixedBuilds(t *testing.T) {
- bazelOutputBaseDir := filepath.Join("out", "bazel")
- result := android.GroupFixturePreparers(
- PrepareForIntegrationTestWithJava,
- android.FixtureModifyConfig(func(config android.Config) {
- config.BazelContext = android.MockBazelContext{
- OutputBaseDir: bazelOutputBaseDir,
- }
- }),
- ).RunTest(t)
- ctx := &android.TestPathContext{TestResult: result}
- srcDirectory := filepath.Join("frameworks", "base")
- srcDirectoryAlreadyIncluded := filepath.Join("frameworks", "base", "core", "java")
- bazelSrcDirectory := android.PathForBazelOut(ctx, srcDirectory)
- bazelSrcDirectoryAlreadyIncluded := android.PathForBazelOut(ctx, srcDirectoryAlreadyIncluded)
- srcs := android.Paths{
- android.PathForTestingWithRel(bazelSrcDirectory.String(), "bazelAidl.aidl"),
- android.PathForTestingWithRel(bazelSrcDirectory.String(), "bazelAidl2.aidl"),
- android.PathForTestingWithRel(bazelSrcDirectoryAlreadyIncluded.String(), "bazelAidlExclude.aidl"),
- android.PathForTestingWithRel(bazelSrcDirectoryAlreadyIncluded.String(), "bazelAidl2Exclude.aidl"),
- }
- dirsAlreadyIncluded := android.Paths{
- android.PathForTesting(srcDirectoryAlreadyIncluded),
- }
- expectedFlags := " -Iout/bazel/execroot/__main__/frameworks/base"
- flags := genAidlIncludeFlags(ctx, srcs, dirsAlreadyIncluded)
- if flags != expectedFlags {
- t.Errorf("expected flags to be %q; was %q", expectedFlags, flags)
- }
- }
- func TestDeviceBinaryWrapperGeneration(t *testing.T) {
- // Scenario 1: java_binary has main_class property in its bp
- ctx, _ := testJava(t, `
- java_binary {
- name: "foo",
- srcs: ["foo.java"],
- main_class: "foo.bar.jb",
- }
- `)
- wrapperPath := fmt.Sprint(ctx.ModuleForTests("foo", "android_arm64_armv8-a").AllOutputs())
- if !strings.Contains(wrapperPath, "foo.sh") {
- t.Errorf("wrapper file foo.sh is not generated")
- }
- // Scenario 2: java_binary has neither wrapper nor main_class, its build
- // is expected to be failed.
- testJavaError(t, "main_class property is required for device binary if no default wrapper is assigned", `
- java_binary {
- name: "foo",
- srcs: ["foo.java"],
- }`)
- }
- func TestJavaApiContributionEmptyApiFile(t *testing.T) {
- testJavaError(t,
- "Error: foo has an empty api file.",
- `java_api_contribution {
- name: "foo",
- }
- java_api_library {
- name: "bar",
- api_surface: "public",
- api_contributions: ["foo"],
- }
- `)
- }
- func TestJavaApiLibraryAndProviderLink(t *testing.T) {
- provider_bp_a := `
- java_api_contribution {
- name: "foo1",
- api_file: "foo1.txt",
- }
- `
- provider_bp_b := `java_api_contribution {
- name: "foo2",
- api_file: "foo2.txt",
- }
- `
- ctx, _ := testJavaWithFS(t, `
- java_api_library {
- name: "bar1",
- api_surface: "public",
- api_contributions: ["foo1"],
- }
- java_api_library {
- name: "bar2",
- api_surface: "system",
- api_contributions: ["foo1", "foo2"],
- api_files: ["api1/current.txt", "api2/current.txt"]
- }
- `,
- map[string][]byte{
- "a/Android.bp": []byte(provider_bp_a),
- "b/Android.bp": []byte(provider_bp_b),
- })
- testcases := []struct {
- moduleName string
- sourceTextFileDirs []string
- }{
- {
- moduleName: "bar1",
- sourceTextFileDirs: []string{"a/foo1.txt"},
- },
- {
- moduleName: "bar2",
- sourceTextFileDirs: []string{"a/foo1.txt", "b/foo2.txt", "api1/current.txt", "api2/current.txt"},
- },
- }
- for _, c := range testcases {
- m := ctx.ModuleForTests(c.moduleName, "android_common")
- manifest := m.Output("metalava.sbox.textproto")
- sboxProto := android.RuleBuilderSboxProtoForTests(t, manifest)
- manifestCommand := sboxProto.Commands[0].GetCommand()
- sourceFilesFlag := "--source-files " + strings.Join(c.sourceTextFileDirs, " ")
- android.AssertStringDoesContain(t, "source text files not present", manifestCommand, sourceFilesFlag)
- }
- }
- func TestJavaApiLibraryAndDefaultsLink(t *testing.T) {
- provider_bp_a := `
- java_api_contribution {
- name: "foo1",
- api_file: "foo1.txt",
- }
- `
- provider_bp_b := `
- java_api_contribution {
- name: "foo2",
- api_file: "foo2.txt",
- }
- `
- provider_bp_c := `
- java_api_contribution {
- name: "foo3",
- api_file: "foo3.txt",
- }
- `
- provider_bp_d := `
- java_api_contribution {
- name: "foo4",
- api_file: "foo4.txt",
- }
- `
- ctx, _ := testJavaWithFS(t, `
- java_defaults {
- name: "baz1",
- api_surface: "public",
- api_contributions: ["foo1", "foo2"],
- }
- java_defaults {
- name: "baz2",
- api_surface: "system",
- api_contributions: ["foo3"],
- }
- java_api_library {
- name: "bar1",
- api_surface: "public",
- api_contributions: ["foo1"],
- }
- java_api_library {
- name: "bar2",
- api_surface: "public",
- defaults:["baz1"],
- }
- java_api_library {
- name: "bar3",
- api_surface: "system",
- defaults:["baz1", "baz2"],
- api_contributions: ["foo4"],
- api_files: ["api1/current.txt", "api2/current.txt"]
- }
- `,
- map[string][]byte{
- "a/Android.bp": []byte(provider_bp_a),
- "b/Android.bp": []byte(provider_bp_b),
- "c/Android.bp": []byte(provider_bp_c),
- "d/Android.bp": []byte(provider_bp_d),
- })
- testcases := []struct {
- moduleName string
- sourceTextFileDirs []string
- }{
- {
- moduleName: "bar1",
- sourceTextFileDirs: []string{"a/foo1.txt"},
- },
- {
- moduleName: "bar2",
- sourceTextFileDirs: []string{"a/foo1.txt", "b/foo2.txt"},
- },
- {
- moduleName: "bar3",
- sourceTextFileDirs: []string{"c/foo3.txt", "a/foo1.txt", "b/foo2.txt", "d/foo4.txt", "api1/current.txt", "api2/current.txt"},
- },
- }
- for _, c := range testcases {
- m := ctx.ModuleForTests(c.moduleName, "android_common")
- manifest := m.Output("metalava.sbox.textproto")
- sboxProto := android.RuleBuilderSboxProtoForTests(t, manifest)
- manifestCommand := sboxProto.Commands[0].GetCommand()
- sourceFilesFlag := "--source-files " + strings.Join(c.sourceTextFileDirs, " ")
- android.AssertStringDoesContain(t, "source text files not present", manifestCommand, sourceFilesFlag)
- }
- }
- func TestJavaApiLibraryJarGeneration(t *testing.T) {
- provider_bp_a := `
- java_api_contribution {
- name: "foo1",
- api_file: "foo1.txt",
- }
- `
- provider_bp_b := `
- java_api_contribution {
- name: "foo2",
- api_file: "foo2.txt",
- }
- `
- ctx, _ := testJavaWithFS(t, `
- java_api_library {
- name: "bar1",
- api_surface: "public",
- api_contributions: ["foo1"],
- }
- java_api_library {
- name: "bar2",
- api_surface: "system",
- api_contributions: ["foo1", "foo2"],
- }
- `,
- map[string][]byte{
- "a/Android.bp": []byte(provider_bp_a),
- "b/Android.bp": []byte(provider_bp_b),
- })
- testcases := []struct {
- moduleName string
- outputJarName string
- }{
- {
- moduleName: "bar1",
- outputJarName: "bar1/bar1.jar",
- },
- {
- moduleName: "bar2",
- outputJarName: "bar2/bar2.jar",
- },
- }
- for _, c := range testcases {
- m := ctx.ModuleForTests(c.moduleName, "android_common")
- outputs := fmt.Sprint(m.AllOutputs())
- if !strings.Contains(outputs, c.outputJarName) {
- t.Errorf("Module output does not contain expected jar %s", c.outputJarName)
- }
- }
- }
- func TestJavaApiLibraryLibsLink(t *testing.T) {
- provider_bp_a := `
- java_api_contribution {
- name: "foo1",
- api_file: "foo1.txt",
- }
- `
- provider_bp_b := `
- java_api_contribution {
- name: "foo2",
- api_file: "foo2.txt",
- }
- `
- lib_bp_a := `
- java_library {
- name: "lib1",
- srcs: ["Lib.java"],
- }
- `
- lib_bp_b := `
- java_library {
- name: "lib2",
- srcs: ["Lib.java"],
- }
- `
- ctx, _ := testJavaWithFS(t, `
- java_api_library {
- name: "bar1",
- api_surface: "public",
- api_contributions: ["foo1"],
- libs: ["lib1"],
- }
- java_api_library {
- name: "bar2",
- api_surface: "system",
- api_contributions: ["foo1", "foo2"],
- libs: ["lib1", "lib2", "bar1"],
- }
- `,
- map[string][]byte{
- "a/Android.bp": []byte(provider_bp_a),
- "b/Android.bp": []byte(provider_bp_b),
- "c/Android.bp": []byte(lib_bp_a),
- "c/Lib.java": {},
- "d/Android.bp": []byte(lib_bp_b),
- "d/Lib.java": {},
- })
- testcases := []struct {
- moduleName string
- classPathJarNames []string
- }{
- {
- moduleName: "bar1",
- classPathJarNames: []string{"lib1.jar"},
- },
- {
- moduleName: "bar2",
- classPathJarNames: []string{"lib1.jar", "lib2.jar", "bar1/bar1.jar"},
- },
- }
- for _, c := range testcases {
- m := ctx.ModuleForTests(c.moduleName, "android_common")
- javacRules := m.Rule("javac")
- classPathArgs := javacRules.Args["classpath"]
- for _, jarName := range c.classPathJarNames {
- if !strings.Contains(classPathArgs, jarName) {
- t.Errorf("Module output does not contain expected jar %s", jarName)
- }
- }
- }
- }
- func TestJavaApiLibraryStaticLibsLink(t *testing.T) {
- provider_bp_a := `
- java_api_contribution {
- name: "foo1",
- api_file: "foo1.txt",
- }
- `
- provider_bp_b := `
- java_api_contribution {
- name: "foo2",
- api_file: "foo2.txt",
- }
- `
- lib_bp_a := `
- java_library {
- name: "lib1",
- srcs: ["Lib.java"],
- }
- `
- lib_bp_b := `
- java_library {
- name: "lib2",
- srcs: ["Lib.java"],
- }
- `
- ctx, _ := testJavaWithFS(t, `
- java_api_library {
- name: "bar1",
- api_surface: "public",
- api_contributions: ["foo1"],
- static_libs: ["lib1"],
- }
- java_api_library {
- name: "bar2",
- api_surface: "system",
- api_contributions: ["foo1", "foo2"],
- static_libs: ["lib1", "lib2", "bar1"],
- }
- `,
- map[string][]byte{
- "a/Android.bp": []byte(provider_bp_a),
- "b/Android.bp": []byte(provider_bp_b),
- "c/Android.bp": []byte(lib_bp_a),
- "c/Lib.java": {},
- "d/Android.bp": []byte(lib_bp_b),
- "d/Lib.java": {},
- })
- testcases := []struct {
- moduleName string
- staticLibJarNames []string
- }{
- {
- moduleName: "bar1",
- staticLibJarNames: []string{"lib1.jar"},
- },
- {
- moduleName: "bar2",
- staticLibJarNames: []string{"lib1.jar", "lib2.jar", "bar1/bar1.jar"},
- },
- }
- for _, c := range testcases {
- m := ctx.ModuleForTests(c.moduleName, "android_common")
- mergeZipsCommand := m.Rule("merge_zips").RuleParams.Command
- for _, jarName := range c.staticLibJarNames {
- if !strings.Contains(mergeZipsCommand, jarName) {
- t.Errorf("merge_zips command does not contain expected jar %s", jarName)
- }
- }
- }
- }
- func TestJavaApiLibraryFullApiSurfaceStub(t *testing.T) {
- provider_bp_a := `
- java_api_contribution {
- name: "foo1",
- api_file: "foo1.txt",
- }
- `
- provider_bp_b := `
- java_api_contribution {
- name: "foo2",
- api_file: "foo2.txt",
- }
- `
- lib_bp_a := `
- java_api_library {
- name: "lib1",
- api_surface: "public",
- api_contributions: ["foo1", "foo2"],
- }
- `
- ctx, _ := testJavaWithFS(t, `
- java_api_library {
- name: "bar1",
- api_surface: "public",
- api_contributions: ["foo1"],
- full_api_surface_stub: "lib1",
- }
- `,
- map[string][]byte{
- "a/Android.bp": []byte(provider_bp_a),
- "b/Android.bp": []byte(provider_bp_b),
- "c/Android.bp": []byte(lib_bp_a),
- })
- m := ctx.ModuleForTests("bar1", "android_common")
- manifest := m.Output("metalava.sbox.textproto")
- sboxProto := android.RuleBuilderSboxProtoForTests(t, manifest)
- manifestCommand := sboxProto.Commands[0].GetCommand()
- android.AssertStringDoesContain(t, "Command expected to contain full_api_surface_stub output jar", manifestCommand, "lib1.jar")
- }
- func TestJavaApiLibraryFilegroupInput(t *testing.T) {
- ctx, _ := testJavaWithFS(t, `
- filegroup {
- name: "default_current.txt",
- srcs: ["current.txt"],
- }
- java_api_library {
- name: "foo",
- api_files: [":default_current.txt"],
- }
- `,
- map[string][]byte{
- "current.txt": nil,
- })
- m := ctx.ModuleForTests("foo", "android_common")
- outputs := fmt.Sprint(m.AllOutputs())
- if !strings.Contains(outputs, "foo/foo.jar") {
- t.Errorf("Module output does not contain expected jar %s", "foo/foo.jar")
- }
- }
- func TestTradefedOptions(t *testing.T) {
- result := PrepareForTestWithJavaBuildComponents.RunTestWithBp(t, `
- java_test_host {
- name: "foo",
- test_options: {
- tradefed_options: [
- {
- name: "exclude-path",
- value: "org/apache"
- }
- ]
- }
- }
- `)
- buildOS := result.Config.BuildOS.String()
- args := result.ModuleForTests("foo", buildOS+"_common").
- Output("out/soong/.intermediates/foo/" + buildOS + "_common/foo.config").Args
- expected := proptools.NinjaAndShellEscape("<option name=\"exclude-path\" value=\"org/apache\" />")
- if args["extraConfigs"] != expected {
- t.Errorf("Expected args[\"extraConfigs\"] to equal %q, was %q", expected, args["extraConfigs"])
- }
- }
- func TestTestRunnerOptions(t *testing.T) {
- result := PrepareForTestWithJavaBuildComponents.RunTestWithBp(t, `
- java_test_host {
- name: "foo",
- test_options: {
- test_runner_options: [
- {
- name: "test-timeout",
- value: "10m"
- }
- ]
- }
- }
- `)
- buildOS := result.Config.BuildOS.String()
- args := result.ModuleForTests("foo", buildOS+"_common").
- Output("out/soong/.intermediates/foo/" + buildOS + "_common/foo.config").Args
- expected := proptools.NinjaAndShellEscape("<option name=\"test-timeout\" value=\"10m\" />\\n ")
- if args["extraTestRunnerConfigs"] != expected {
- t.Errorf("Expected args[\"extraTestRunnerConfigs\"] to equal %q, was %q", expected, args["extraTestRunnerConfigs"])
- }
- }
- func TestJavaExcludeStaticLib(t *testing.T) {
- ctx, _ := testJava(t, `
- java_library {
- name: "bar",
- }
- java_library {
- name: "foo",
- }
- java_library {
- name: "baz",
- static_libs: [
- "foo",
- "bar",
- ],
- exclude_static_libs: [
- "bar",
- ],
- }
- `)
- // "bar" not included as dependency of "baz"
- CheckModuleDependencies(t, ctx, "baz", "android_common", []string{
- `core-lambda-stubs`,
- `ext`,
- `foo`,
- `framework`,
- `stable-core-platform-api-stubs-system-modules`,
- `stable.core.platform.api.stubs`,
- })
- }
|