blob: b724b4de24870b2dd7030e4825d22979a41a6584 [file] [log] [blame]
Colin Cross72bb3632017-07-13 16:23:21 -07001// Copyright 2017 Google Inc. All rights reserved.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package java
16
17import (
Colin Cross72bb3632017-07-13 16:23:21 -070018 "io/ioutil"
19 "os"
20 "path/filepath"
Colin Crossc0806172019-06-14 18:51:47 -070021 "reflect"
Nan Zhang61eaedb2017-11-02 13:28:15 -070022 "strconv"
Colin Cross72bb3632017-07-13 16:23:21 -070023 "strings"
24 "testing"
Colin Cross86a60ae2018-05-29 14:44:55 -070025
Jeongik Cha28df2572019-11-11 10:46:36 +090026 "github.com/google/blueprint/proptools"
27
Colin Crossa4f08812018-10-02 22:03:40 -070028 "android/soong/android"
29 "android/soong/cc"
Colin Crossc28bb0b2019-02-25 14:20:47 -080030 "android/soong/dexpreopt"
Colin Crossa4f08812018-10-02 22:03:40 -070031 "android/soong/genrule"
Colin Cross72bb3632017-07-13 16:23:21 -070032)
33
34var buildDir string
35
36func setUp() {
37 var err error
38 buildDir, err = ioutil.TempDir("", "soong_java_test")
39 if err != nil {
40 panic(err)
41 }
42}
43
44func tearDown() {
45 os.RemoveAll(buildDir)
46}
47
48func TestMain(m *testing.M) {
49 run := func() int {
50 setUp()
51 defer tearDown()
52
53 return m.Run()
54 }
55
56 os.Exit(run())
57}
Colin Cross527012a2017-11-30 22:56:16 -080058
Colin Cross98be1bb2019-12-13 20:41:13 -080059func testConfig(env map[string]string, bp string, fs map[string][]byte) android.Config {
Martin Stjernholm335d5962020-01-11 00:37:30 +000060 bp += dexpreopt.BpToolModulesForTest()
61
Martin Stjernholmbe9d0d22020-01-10 20:32:59 +000062 config := TestConfig(buildDir, env, bp, fs)
63
64 // Set up the global Once cache used for dexpreopt.GlobalSoongConfig, so that
65 // it doesn't create a real one, which would fail.
66 _ = dexpreopt.GlobalSoongConfigForTests(config)
67
68 return config
Colin Cross1369cdb2017-09-29 17:58:17 -070069}
70
Colin Cross98be1bb2019-12-13 20:41:13 -080071func testContext() *android.TestContext {
Colin Cross72bb3632017-07-13 16:23:21 -070072
Colin Cross4c428df2017-09-15 17:36:05 -070073 ctx := android.NewTestArchContext()
Paul Duffinf9b1da02019-12-18 19:51:55 +000074 RegisterJavaBuildComponents(ctx)
75 RegisterAppBuildComponents(ctx)
76 RegisterAARBuildComponents(ctx)
Paul Duffinb0f85072019-12-19 10:28:56 +000077 RegisterGenRuleBuildComponents(ctx)
Paul Duffin43dc1cc2019-12-19 11:18:54 +000078 RegisterSystemModulesBuildComponents(ctx)
Colin Cross4b49b762019-11-22 15:25:03 -080079 ctx.RegisterModuleType("java_plugin", PluginFactory)
Colin Cross4b49b762019-11-22 15:25:03 -080080 ctx.RegisterModuleType("filegroup", android.FileGroupFactory)
81 ctx.RegisterModuleType("genrule", genrule.GenRuleFactory)
Paul Duffin884363e2019-12-19 10:21:09 +000082 RegisterDocsBuildComponents(ctx)
83 RegisterStubsBuildComponents(ctx)
Paul Duffin43dc1cc2019-12-19 11:18:54 +000084 RegisterSdkLibraryBuildComponents(ctx)
Colin Cross89536d42017-07-07 14:35:50 -070085 ctx.PreArchMutators(android.RegisterDefaultsPreArchMutators)
Paul Duffina48f7582019-12-19 11:25:19 +000086
87 RegisterPrebuiltApisBuildComponents(ctx)
88
Jaewoong Jungb639a6a2019-05-10 15:16:29 -070089 ctx.PostDepsMutators(android.RegisterOverridePostDepsMutators)
Colin Cross3bc7ffa2017-11-22 16:19:37 -080090 ctx.RegisterPreSingletonType("overlay", android.SingletonFactoryAdaptor(OverlaySingletonFactory))
Colin Cross3047fa22019-04-18 10:56:44 -070091 ctx.RegisterPreSingletonType("sdk_versions", android.SingletonFactoryAdaptor(sdkPreSingletonFactory))
Colin Crossa4f08812018-10-02 22:03:40 -070092
93 // Register module types and mutators from cc needed for JNI testing
Paul Duffin77980a82019-12-19 16:01:36 +000094 cc.RegisterRequiredBuildComponentsForTest(ctx)
Colin Cross4b49b762019-11-22 15:25:03 -080095 ctx.RegisterModuleType("ndk_prebuilt_shared_stl", cc.NdkPrebuiltSharedStlFactory)
Colin Crossa4f08812018-10-02 22:03:40 -070096
Martin Stjernholm335d5962020-01-11 00:37:30 +000097 dexpreopt.RegisterToolModulesForTest(ctx)
98
Colin Cross527012a2017-11-30 22:56:16 -080099 return ctx
100}
101
102func run(t *testing.T, ctx *android.TestContext, config android.Config) {
Colin Cross6b4a32d2017-12-05 13:42:45 -0800103 t.Helper()
Colin Crossc28bb0b2019-02-25 14:20:47 -0800104
Colin Cross98be1bb2019-12-13 20:41:13 -0800105 pathCtx := android.PathContextForTesting(config)
Martin Stjernholmdae8a802020-01-20 18:12:23 +0000106 dexpreopt.SetTestGlobalConfig(config, dexpreopt.GlobalConfigForTests(pathCtx))
Colin Crossc28bb0b2019-02-25 14:20:47 -0800107
Colin Cross98be1bb2019-12-13 20:41:13 -0800108 ctx.Register(config)
Paul Duffinbaccf7e2019-06-11 11:58:30 +0100109 _, errs := ctx.ParseBlueprintsFiles("Android.bp")
Logan Chien42039712018-03-12 16:29:17 +0800110 android.FailIfErrored(t, errs)
Colin Cross72bb3632017-07-13 16:23:21 -0700111 _, errs = ctx.PrepareBuildActions(config)
Logan Chien42039712018-03-12 16:29:17 +0800112 android.FailIfErrored(t, errs)
Colin Cross527012a2017-11-30 22:56:16 -0800113}
114
Jeongik Cha2cc570d2019-10-29 15:44:45 +0900115func testJavaError(t *testing.T, pattern string, bp string) (*android.TestContext, android.Config) {
Jeongik Cha538c0d02019-07-11 15:54:27 +0900116 t.Helper()
Colin Cross98be1bb2019-12-13 20:41:13 -0800117 return testJavaErrorWithConfig(t, pattern, testConfig(nil, bp, nil))
Jeongik Cha2cc570d2019-10-29 15:44:45 +0900118}
119
Colin Cross98be1bb2019-12-13 20:41:13 -0800120func testJavaErrorWithConfig(t *testing.T, pattern string, config android.Config) (*android.TestContext, android.Config) {
Jeongik Cha2cc570d2019-10-29 15:44:45 +0900121 t.Helper()
Colin Cross98be1bb2019-12-13 20:41:13 -0800122 ctx := testContext()
Jeongik Cha538c0d02019-07-11 15:54:27 +0900123
Colin Cross98be1bb2019-12-13 20:41:13 -0800124 pathCtx := android.PathContextForTesting(config)
Martin Stjernholmdae8a802020-01-20 18:12:23 +0000125 dexpreopt.SetTestGlobalConfig(config, dexpreopt.GlobalConfigForTests(pathCtx))
Jeongik Cha538c0d02019-07-11 15:54:27 +0900126
Colin Cross98be1bb2019-12-13 20:41:13 -0800127 ctx.Register(config)
Jeongik Cha538c0d02019-07-11 15:54:27 +0900128 _, errs := ctx.ParseBlueprintsFiles("Android.bp")
129 if len(errs) > 0 {
130 android.FailIfNoMatchingErrors(t, pattern, errs)
Jeongik Cha2cc570d2019-10-29 15:44:45 +0900131 return ctx, config
Jeongik Cha538c0d02019-07-11 15:54:27 +0900132 }
133 _, errs = ctx.PrepareBuildActions(config)
134 if len(errs) > 0 {
135 android.FailIfNoMatchingErrors(t, pattern, errs)
Jeongik Cha2cc570d2019-10-29 15:44:45 +0900136 return ctx, config
Jeongik Cha538c0d02019-07-11 15:54:27 +0900137 }
138
139 t.Fatalf("missing expected error %q (0 errors are returned)", pattern)
Jeongik Cha2cc570d2019-10-29 15:44:45 +0900140
141 return ctx, config
Jeongik Cha538c0d02019-07-11 15:54:27 +0900142}
143
Jaewoong Jungf9a04432019-07-17 11:15:09 -0700144func testJava(t *testing.T, bp string) (*android.TestContext, android.Config) {
Colin Cross6b4a32d2017-12-05 13:42:45 -0800145 t.Helper()
Colin Cross98be1bb2019-12-13 20:41:13 -0800146 return testJavaWithConfig(t, testConfig(nil, bp, nil))
Jeongik Cha2cc570d2019-10-29 15:44:45 +0900147}
148
Colin Cross98be1bb2019-12-13 20:41:13 -0800149func testJavaWithConfig(t *testing.T, config android.Config) (*android.TestContext, android.Config) {
Jeongik Cha2cc570d2019-10-29 15:44:45 +0900150 t.Helper()
Colin Cross98be1bb2019-12-13 20:41:13 -0800151 ctx := testContext()
Colin Cross527012a2017-11-30 22:56:16 -0800152 run(t, ctx, config)
Colin Cross72bb3632017-07-13 16:23:21 -0700153
Jaewoong Jungf9a04432019-07-17 11:15:09 -0700154 return ctx, config
Colin Cross72bb3632017-07-13 16:23:21 -0700155}
156
Colin Cross2acdae82017-09-15 19:44:24 -0700157func moduleToPath(name string) string {
158 switch {
159 case name == `""`:
160 return name
Colin Crossfc3674a2017-09-18 17:41:52 -0700161 case strings.HasSuffix(name, ".jar"):
162 return name
Nan Zhanged19fc32017-10-19 13:06:22 -0700163 default:
164 return filepath.Join(buildDir, ".intermediates", name, "android_common", "turbine-combined", name+".jar")
Colin Cross2acdae82017-09-15 19:44:24 -0700165 }
166}
167
Jeongik Chae403e9e2019-12-07 00:16:24 +0900168func TestJavaLinkType(t *testing.T) {
169 testJava(t, `
170 java_library {
171 name: "foo",
172 srcs: ["a.java"],
173 libs: ["bar"],
174 static_libs: ["baz"],
175 }
176
177 java_library {
178 name: "bar",
179 sdk_version: "current",
180 srcs: ["b.java"],
181 }
182
183 java_library {
184 name: "baz",
185 sdk_version: "system_current",
186 srcs: ["c.java"],
187 }
188 `)
189
190 testJavaError(t, "Adjust sdk_version: property of the source or target module so that target module is built with the same or smaller API set than the source.", `
191 java_library {
192 name: "foo",
193 srcs: ["a.java"],
194 libs: ["bar"],
195 sdk_version: "current",
196 static_libs: ["baz"],
197 }
198
199 java_library {
200 name: "bar",
201 sdk_version: "current",
202 srcs: ["b.java"],
203 }
204
205 java_library {
206 name: "baz",
207 sdk_version: "system_current",
208 srcs: ["c.java"],
209 }
210 `)
211
212 testJava(t, `
213 java_library {
214 name: "foo",
215 srcs: ["a.java"],
216 libs: ["bar"],
217 sdk_version: "system_current",
218 static_libs: ["baz"],
219 }
220
221 java_library {
222 name: "bar",
223 sdk_version: "current",
224 srcs: ["b.java"],
225 }
226
227 java_library {
228 name: "baz",
229 sdk_version: "system_current",
230 srcs: ["c.java"],
231 }
232 `)
233
234 testJavaError(t, "Adjust sdk_version: property of the source or target module so that target module is built with the same or smaller API set than the source.", `
235 java_library {
236 name: "foo",
237 srcs: ["a.java"],
238 libs: ["bar"],
239 sdk_version: "system_current",
240 static_libs: ["baz"],
241 }
242
243 java_library {
244 name: "bar",
245 sdk_version: "current",
246 srcs: ["b.java"],
247 }
248
249 java_library {
250 name: "baz",
251 srcs: ["c.java"],
252 }
253 `)
254}
255
Colin Cross72bb3632017-07-13 16:23:21 -0700256func TestSimple(t *testing.T) {
Jaewoong Jungf9a04432019-07-17 11:15:09 -0700257 ctx, _ := testJava(t, `
Colin Cross72bb3632017-07-13 16:23:21 -0700258 java_library {
259 name: "foo",
260 srcs: ["a.java"],
Colin Crosse8dc34a2017-07-19 11:22:16 -0700261 libs: ["bar"],
262 static_libs: ["baz"],
Colin Cross72bb3632017-07-13 16:23:21 -0700263 }
264
265 java_library {
266 name: "bar",
267 srcs: ["b.java"],
268 }
269
270 java_library {
271 name: "baz",
272 srcs: ["c.java"],
273 }
Colin Crossd5934c82017-10-02 13:55:26 -0700274 `)
Colin Cross72bb3632017-07-13 16:23:21 -0700275
Colin Cross4c428df2017-09-15 17:36:05 -0700276 javac := ctx.ModuleForTests("foo", "android_common").Rule("javac")
Nan Zhanged19fc32017-10-19 13:06:22 -0700277 combineJar := ctx.ModuleForTests("foo", "android_common").Description("for javac")
Colin Cross72bb3632017-07-13 16:23:21 -0700278
279 if len(javac.Inputs) != 1 || javac.Inputs[0].String() != "a.java" {
280 t.Errorf(`foo inputs %v != ["a.java"]`, javac.Inputs)
281 }
282
Colin Cross1ee23172017-10-18 14:44:18 -0700283 baz := ctx.ModuleForTests("baz", "android_common").Rule("javac").Output.String()
Nan Zhanged19fc32017-10-19 13:06:22 -0700284 barTurbine := filepath.Join(buildDir, ".intermediates", "bar", "android_common", "turbine-combined", "bar.jar")
285 bazTurbine := filepath.Join(buildDir, ".intermediates", "baz", "android_common", "turbine-combined", "baz.jar")
Colin Cross0a6e0072017-08-30 14:24:55 -0700286
Nan Zhanged19fc32017-10-19 13:06:22 -0700287 if !strings.Contains(javac.Args["classpath"], barTurbine) {
288 t.Errorf("foo classpath %v does not contain %q", javac.Args["classpath"], barTurbine)
Colin Cross72bb3632017-07-13 16:23:21 -0700289 }
290
Nan Zhanged19fc32017-10-19 13:06:22 -0700291 if !strings.Contains(javac.Args["classpath"], bazTurbine) {
292 t.Errorf("foo classpath %v does not contain %q", javac.Args["classpath"], bazTurbine)
Colin Cross0a6e0072017-08-30 14:24:55 -0700293 }
294
295 if len(combineJar.Inputs) != 2 || combineJar.Inputs[1].String() != baz {
296 t.Errorf("foo combineJar inputs %v does not contain %q", combineJar.Inputs, baz)
Colin Cross72bb3632017-07-13 16:23:21 -0700297 }
298}
299
Artur Satayev9cf46692019-11-26 18:08:34 +0000300func TestExportedPlugins(t *testing.T) {
301 type Result struct {
302 library string
303 processors string
304 }
305 var tests = []struct {
306 name string
307 extra string
308 results []Result
309 }{
310 {
311 name: "Exported plugin is not a direct plugin",
312 extra: `java_library { name: "exports", srcs: ["a.java"], exported_plugins: ["plugin"] }`,
313 results: []Result{{library: "exports", processors: "-proc:none"}},
314 },
315 {
316 name: "Exports plugin to dependee",
317 extra: `
318 java_library{name: "exports", exported_plugins: ["plugin"]}
319 java_library{name: "foo", srcs: ["a.java"], libs: ["exports"]}
320 java_library{name: "bar", srcs: ["a.java"], static_libs: ["exports"]}
321 `,
322 results: []Result{
323 {library: "foo", processors: "-processor com.android.TestPlugin"},
324 {library: "bar", processors: "-processor com.android.TestPlugin"},
325 },
326 },
327 {
328 name: "Exports plugin to android_library",
329 extra: `
330 java_library{name: "exports", exported_plugins: ["plugin"]}
331 android_library{name: "foo", srcs: ["a.java"], libs: ["exports"]}
332 android_library{name: "bar", srcs: ["a.java"], static_libs: ["exports"]}
333 `,
334 results: []Result{
335 {library: "foo", processors: "-processor com.android.TestPlugin"},
336 {library: "bar", processors: "-processor com.android.TestPlugin"},
337 },
338 },
339 {
340 name: "Exports plugin is not propagated via transitive deps",
341 extra: `
342 java_library{name: "exports", exported_plugins: ["plugin"]}
343 java_library{name: "foo", srcs: ["a.java"], libs: ["exports"]}
344 java_library{name: "bar", srcs: ["a.java"], static_libs: ["foo"]}
345 `,
346 results: []Result{
347 {library: "foo", processors: "-processor com.android.TestPlugin"},
348 {library: "bar", processors: "-proc:none"},
349 },
350 },
351 {
352 name: "Exports plugin appends to plugins",
353 extra: `
354 java_plugin{name: "plugin2", processor_class: "com.android.TestPlugin2"}
355 java_library{name: "exports", exported_plugins: ["plugin"]}
356 java_library{name: "foo", srcs: ["a.java"], libs: ["exports"], plugins: ["plugin2"]}
357 `,
358 results: []Result{
359 {library: "foo", processors: "-processor com.android.TestPlugin,com.android.TestPlugin2"},
360 },
361 },
362 }
363
364 for _, test := range tests {
365 t.Run(test.name, func(t *testing.T) {
366 ctx, _ := testJava(t, `
367 java_plugin {
368 name: "plugin",
369 processor_class: "com.android.TestPlugin",
370 }
371 `+test.extra)
372
373 for _, want := range test.results {
374 javac := ctx.ModuleForTests(want.library, "android_common").Rule("javac")
375 if javac.Args["processor"] != want.processors {
376 t.Errorf("For library %v, expected %v, found %v", want.library, want.processors, javac.Args["processor"])
377 }
378 }
379 })
380 }
381}
382
Jeongik Cha2cc570d2019-10-29 15:44:45 +0900383func TestSdkVersionByPartition(t *testing.T) {
384 testJavaError(t, "sdk_version must have a value when the module is located at vendor or product", `
Jeongik Cha6bd33c12019-06-25 16:26:18 +0900385 java_library {
386 name: "foo",
387 srcs: ["a.java"],
388 vendor: true,
389 }
Jeongik Cha2cc570d2019-10-29 15:44:45 +0900390 `)
Jeongik Cha6bd33c12019-06-25 16:26:18 +0900391
Jeongik Cha2cc570d2019-10-29 15:44:45 +0900392 testJava(t, `
Jeongik Cha6bd33c12019-06-25 16:26:18 +0900393 java_library {
394 name: "bar",
395 srcs: ["b.java"],
396 }
397 `)
398
Jeongik Cha2cc570d2019-10-29 15:44:45 +0900399 for _, enforce := range []bool{true, false} {
Jeongik Cha2cc570d2019-10-29 15:44:45 +0900400 bp := `
401 java_library {
402 name: "foo",
403 srcs: ["a.java"],
404 product_specific: true,
405 }
406 `
Colin Cross98be1bb2019-12-13 20:41:13 -0800407
408 config := testConfig(nil, bp, nil)
409 config.TestProductVariables.EnforceProductPartitionInterface = proptools.BoolPtr(enforce)
Jeongik Cha2cc570d2019-10-29 15:44:45 +0900410 if enforce {
Colin Cross98be1bb2019-12-13 20:41:13 -0800411 testJavaErrorWithConfig(t, "sdk_version must have a value when the module is located at vendor or product", config)
Jeongik Cha2cc570d2019-10-29 15:44:45 +0900412 } else {
Colin Cross98be1bb2019-12-13 20:41:13 -0800413 testJavaWithConfig(t, config)
Jeongik Cha2cc570d2019-10-29 15:44:45 +0900414 }
Jeongik Cha6bd33c12019-06-25 16:26:18 +0900415 }
416}
417
Colin Crossd5934c82017-10-02 13:55:26 -0700418func TestArchSpecific(t *testing.T) {
Jaewoong Jungf9a04432019-07-17 11:15:09 -0700419 ctx, _ := testJava(t, `
Colin Crossd5934c82017-10-02 13:55:26 -0700420 java_library {
421 name: "foo",
422 srcs: ["a.java"],
423 target: {
424 android: {
425 srcs: ["b.java"],
426 },
427 },
428 }
429 `)
430
431 javac := ctx.ModuleForTests("foo", "android_common").Rule("javac")
432 if len(javac.Inputs) != 2 || javac.Inputs[0].String() != "a.java" || javac.Inputs[1].String() != "b.java" {
433 t.Errorf(`foo inputs %v != ["a.java", "b.java"]`, javac.Inputs)
434 }
435}
436
Colin Cross6b4a32d2017-12-05 13:42:45 -0800437func TestBinary(t *testing.T) {
Jaewoong Jungf9a04432019-07-17 11:15:09 -0700438 ctx, _ := testJava(t, `
Colin Cross6b4a32d2017-12-05 13:42:45 -0800439 java_library_host {
440 name: "foo",
441 srcs: ["a.java"],
442 }
443
444 java_binary_host {
445 name: "bar",
446 srcs: ["b.java"],
447 static_libs: ["foo"],
448 }
449 `)
450
451 buildOS := android.BuildOs.String()
452
453 bar := ctx.ModuleForTests("bar", buildOS+"_common")
454 barJar := bar.Output("bar.jar").Output.String()
455 barWrapper := ctx.ModuleForTests("bar", buildOS+"_x86_64")
456 barWrapperDeps := barWrapper.Output("bar").Implicits.Strings()
457
458 // Test that the install binary wrapper depends on the installed jar file
459 if len(barWrapperDeps) != 1 || barWrapperDeps[0] != barJar {
460 t.Errorf("expected binary wrapper implicits [%q], got %v",
461 barJar, barWrapperDeps)
462 }
463
464}
465
Colin Cross72bb3632017-07-13 16:23:21 -0700466func TestPrebuilts(t *testing.T) {
Jaewoong Jungf9a04432019-07-17 11:15:09 -0700467 ctx, _ := testJava(t, `
Colin Cross72bb3632017-07-13 16:23:21 -0700468 java_library {
469 name: "foo",
Paul Duffin91547182019-11-12 19:39:36 +0000470 srcs: ["a.java", ":stubs-source"],
Colin Cross79c7c262019-04-17 11:11:46 -0700471 libs: ["bar", "sdklib"],
Colin Crosse8dc34a2017-07-19 11:22:16 -0700472 static_libs: ["baz"],
Colin Cross72bb3632017-07-13 16:23:21 -0700473 }
474
Colin Cross74d73e22017-08-02 11:05:49 -0700475 java_import {
Colin Cross72bb3632017-07-13 16:23:21 -0700476 name: "bar",
Colin Cross74d73e22017-08-02 11:05:49 -0700477 jars: ["a.jar"],
Colin Cross72bb3632017-07-13 16:23:21 -0700478 }
479
Colin Cross74d73e22017-08-02 11:05:49 -0700480 java_import {
Colin Cross72bb3632017-07-13 16:23:21 -0700481 name: "baz",
Colin Cross74d73e22017-08-02 11:05:49 -0700482 jars: ["b.jar"],
Colin Cross72bb3632017-07-13 16:23:21 -0700483 }
Colin Cross42be7612019-02-21 18:12:14 -0800484
485 dex_import {
486 name: "qux",
487 jars: ["b.jar"],
488 }
Colin Cross79c7c262019-04-17 11:11:46 -0700489
490 java_sdk_library_import {
491 name: "sdklib",
492 jars: ["b.jar"],
493 }
Paul Duffin91547182019-11-12 19:39:36 +0000494
495 prebuilt_stubs_sources {
496 name: "stubs-source",
Paul Duffin9b478b02019-12-10 13:41:51 +0000497 srcs: ["stubs/sources"],
Paul Duffin91547182019-11-12 19:39:36 +0000498 }
Paul Duffin1b82e6a2019-12-03 18:06:47 +0000499
500 java_test_import {
501 name: "test",
502 jars: ["a.jar"],
503 test_suites: ["cts"],
504 test_config: "AndroidTest.xml",
505 }
Colin Cross72bb3632017-07-13 16:23:21 -0700506 `)
507
Paul Duffin9b478b02019-12-10 13:41:51 +0000508 fooModule := ctx.ModuleForTests("foo", "android_common")
509 javac := fooModule.Rule("javac")
Nan Zhanged19fc32017-10-19 13:06:22 -0700510 combineJar := ctx.ModuleForTests("foo", "android_common").Description("for javac")
Colin Cross37f6d792018-07-12 12:28:41 -0700511 barJar := ctx.ModuleForTests("bar", "android_common").Rule("combineJar").Output
512 bazJar := ctx.ModuleForTests("baz", "android_common").Rule("combineJar").Output
Colin Cross79c7c262019-04-17 11:11:46 -0700513 sdklibStubsJar := ctx.ModuleForTests("sdklib.stubs", "android_common").Rule("combineJar").Output
Colin Cross72bb3632017-07-13 16:23:21 -0700514
Paul Duffin9b478b02019-12-10 13:41:51 +0000515 fooLibrary := fooModule.Module().(*Library)
516 assertDeepEquals(t, "foo java sources incorrect",
517 []string{"a.java"}, fooLibrary.compiledJavaSrcs.Strings())
Paul Duffin91547182019-11-12 19:39:36 +0000518
Paul Duffin9b478b02019-12-10 13:41:51 +0000519 assertDeepEquals(t, "foo java source jars incorrect",
520 []string{".intermediates/stubs-source/android_common/stubs-source-stubs.srcjar"},
521 android.NormalizePathsForTesting(fooLibrary.compiledSrcJars))
Paul Duffin91547182019-11-12 19:39:36 +0000522
Colin Cross37f6d792018-07-12 12:28:41 -0700523 if !strings.Contains(javac.Args["classpath"], barJar.String()) {
524 t.Errorf("foo classpath %v does not contain %q", javac.Args["classpath"], barJar.String())
Colin Cross72bb3632017-07-13 16:23:21 -0700525 }
526
Colin Cross79c7c262019-04-17 11:11:46 -0700527 if !strings.Contains(javac.Args["classpath"], sdklibStubsJar.String()) {
528 t.Errorf("foo classpath %v does not contain %q", javac.Args["classpath"], sdklibStubsJar.String())
529 }
530
Colin Cross37f6d792018-07-12 12:28:41 -0700531 if len(combineJar.Inputs) != 2 || combineJar.Inputs[1].String() != bazJar.String() {
532 t.Errorf("foo combineJar inputs %v does not contain %q", combineJar.Inputs, bazJar.String())
Colin Cross72bb3632017-07-13 16:23:21 -0700533 }
Colin Cross42be7612019-02-21 18:12:14 -0800534
535 ctx.ModuleForTests("qux", "android_common").Rule("Cp")
Colin Cross72bb3632017-07-13 16:23:21 -0700536}
537
Paul Duffin9b478b02019-12-10 13:41:51 +0000538func assertDeepEquals(t *testing.T, message string, expected interface{}, actual interface{}) {
539 if !reflect.DeepEqual(expected, actual) {
540 t.Errorf("%s: expected %q, found %q", message, expected, actual)
541 }
542}
543
Colin Cross89536d42017-07-07 14:35:50 -0700544func TestDefaults(t *testing.T) {
Jaewoong Jungf9a04432019-07-17 11:15:09 -0700545 ctx, _ := testJava(t, `
Colin Cross89536d42017-07-07 14:35:50 -0700546 java_defaults {
547 name: "defaults",
548 srcs: ["a.java"],
549 libs: ["bar"],
550 static_libs: ["baz"],
Sasha Smundak2057f822019-04-16 17:16:58 -0700551 optimize: {enabled: false},
Colin Cross89536d42017-07-07 14:35:50 -0700552 }
553
554 java_library {
555 name: "foo",
556 defaults: ["defaults"],
557 }
558
559 java_library {
560 name: "bar",
561 srcs: ["b.java"],
562 }
563
564 java_library {
565 name: "baz",
566 srcs: ["c.java"],
567 }
Sasha Smundak2057f822019-04-16 17:16:58 -0700568
569 android_test {
570 name: "atestOptimize",
571 defaults: ["defaults"],
572 optimize: {enabled: true},
573 }
574
575 android_test {
576 name: "atestNoOptimize",
577 defaults: ["defaults"],
578 }
579
580 android_test {
581 name: "atestDefault",
582 srcs: ["a.java"],
583 }
Colin Cross89536d42017-07-07 14:35:50 -0700584 `)
585
Colin Cross4c428df2017-09-15 17:36:05 -0700586 javac := ctx.ModuleForTests("foo", "android_common").Rule("javac")
Nan Zhanged19fc32017-10-19 13:06:22 -0700587 combineJar := ctx.ModuleForTests("foo", "android_common").Description("for javac")
Colin Cross89536d42017-07-07 14:35:50 -0700588
589 if len(javac.Inputs) != 1 || javac.Inputs[0].String() != "a.java" {
590 t.Errorf(`foo inputs %v != ["a.java"]`, javac.Inputs)
591 }
592
Nan Zhanged19fc32017-10-19 13:06:22 -0700593 barTurbine := filepath.Join(buildDir, ".intermediates", "bar", "android_common", "turbine-combined", "bar.jar")
594 if !strings.Contains(javac.Args["classpath"], barTurbine) {
595 t.Errorf("foo classpath %v does not contain %q", javac.Args["classpath"], barTurbine)
Colin Cross89536d42017-07-07 14:35:50 -0700596 }
597
Colin Cross1ee23172017-10-18 14:44:18 -0700598 baz := ctx.ModuleForTests("baz", "android_common").Rule("javac").Output.String()
Colin Cross0a6e0072017-08-30 14:24:55 -0700599 if len(combineJar.Inputs) != 2 || combineJar.Inputs[1].String() != baz {
600 t.Errorf("foo combineJar inputs %v does not contain %q", combineJar.Inputs, baz)
Colin Cross89536d42017-07-07 14:35:50 -0700601 }
Sasha Smundak2057f822019-04-16 17:16:58 -0700602
603 atestOptimize := ctx.ModuleForTests("atestOptimize", "android_common").MaybeRule("r8")
604 if atestOptimize.Output == nil {
605 t.Errorf("atestOptimize should optimize APK")
606 }
607
608 atestNoOptimize := ctx.ModuleForTests("atestNoOptimize", "android_common").MaybeRule("d8")
609 if atestNoOptimize.Output == nil {
610 t.Errorf("atestNoOptimize should not optimize APK")
611 }
612
613 atestDefault := ctx.ModuleForTests("atestDefault", "android_common").MaybeRule("r8")
614 if atestDefault.Output == nil {
615 t.Errorf("atestDefault should optimize APK")
616 }
Colin Cross89536d42017-07-07 14:35:50 -0700617}
618
Colin Cross0f37af02017-09-27 17:42:05 -0700619func TestResources(t *testing.T) {
620 var table = []struct {
621 name string
622 prop string
623 extra string
624 args string
625 }{
626 {
Colin Crossaf9c55b2017-10-03 14:50:08 -0700627 // Test that a module with java_resource_dirs includes the files
Colin Cross0f37af02017-09-27 17:42:05 -0700628 name: "resource dirs",
Colin Cross824bee32017-11-22 17:27:51 -0800629 prop: `java_resource_dirs: ["java-res"]`,
Colin Cross0ead1d72018-04-10 13:07:42 -0700630 args: "-C java-res -f java-res/a/a -f java-res/b/b",
Colin Cross0f37af02017-09-27 17:42:05 -0700631 },
632 {
633 // Test that a module with java_resources includes the files
634 name: "resource files",
Colin Cross0ead1d72018-04-10 13:07:42 -0700635 prop: `java_resources: ["java-res/a/a", "java-res/b/b"]`,
636 args: "-C . -f java-res/a/a -f java-res/b/b",
Colin Cross0f37af02017-09-27 17:42:05 -0700637 },
638 {
639 // Test that a module with a filegroup in java_resources includes the files with the
640 // path prefix
641 name: "resource filegroup",
642 prop: `java_resources: [":foo-res"]`,
643 extra: `
644 filegroup {
645 name: "foo-res",
Colin Cross824bee32017-11-22 17:27:51 -0800646 path: "java-res",
Colin Cross0ead1d72018-04-10 13:07:42 -0700647 srcs: ["java-res/a/a", "java-res/b/b"],
Colin Cross0f37af02017-09-27 17:42:05 -0700648 }`,
Colin Cross0ead1d72018-04-10 13:07:42 -0700649 args: "-C java-res -f java-res/a/a -f java-res/b/b",
Colin Cross0f37af02017-09-27 17:42:05 -0700650 },
651 {
Colin Cross0ead1d72018-04-10 13:07:42 -0700652 // Test that a module with wildcards in java_resource_dirs has the correct path prefixes
653 name: "wildcard dirs",
654 prop: `java_resource_dirs: ["java-res/*"]`,
655 args: "-C java-res/a -f java-res/a/a -C java-res/b -f java-res/b/b",
656 },
657 {
658 // Test that a module exclude_java_resource_dirs excludes the files
659 name: "wildcard dirs",
660 prop: `java_resource_dirs: ["java-res/*"], exclude_java_resource_dirs: ["java-res/b"]`,
661 args: "-C java-res/a -f java-res/a/a",
662 },
Colin Crosscedd4762018-09-13 11:26:19 -0700663 {
664 // Test wildcards in java_resources
665 name: "wildcard files",
666 prop: `java_resources: ["java-res/**/*"]`,
667 args: "-C . -f java-res/a/a -f java-res/b/b",
668 },
669 {
670 // Test exclude_java_resources with java_resources
671 name: "wildcard files with exclude",
672 prop: `java_resources: ["java-res/**/*"], exclude_java_resources: ["java-res/b/*"]`,
673 args: "-C . -f java-res/a/a",
674 },
675 {
676 // Test exclude_java_resources with java_resource_dirs
677 name: "resource dirs with exclude files",
678 prop: `java_resource_dirs: ["java-res"], exclude_java_resources: ["java-res/b/b"]`,
679 args: "-C java-res -f java-res/a/a",
680 },
681 {
682 // Test exclude_java_resource_dirs with java_resource_dirs
683 name: "resource dirs with exclude files",
684 prop: `java_resource_dirs: ["java-res", "java-res2"], exclude_java_resource_dirs: ["java-res2"]`,
685 args: "-C java-res -f java-res/a/a -f java-res/b/b",
686 },
Colin Cross0f37af02017-09-27 17:42:05 -0700687 }
688
689 for _, test := range table {
690 t.Run(test.name, func(t *testing.T) {
Jaewoong Jungf9a04432019-07-17 11:15:09 -0700691 ctx, _ := testJava(t, `
Colin Cross0f37af02017-09-27 17:42:05 -0700692 java_library {
693 name: "foo",
694 srcs: [
695 "a.java",
696 "b.java",
697 "c.java",
698 ],
699 `+test.prop+`,
700 }
701 `+test.extra)
702
Colin Cross331a1212018-08-15 20:40:52 -0700703 foo := ctx.ModuleForTests("foo", "android_common").Output("withres/foo.jar")
Colin Cross1ee23172017-10-18 14:44:18 -0700704 fooRes := ctx.ModuleForTests("foo", "android_common").Output("res/foo.jar")
Colin Cross0f37af02017-09-27 17:42:05 -0700705
706 if !inList(fooRes.Output.String(), foo.Inputs.Strings()) {
707 t.Errorf("foo combined jars %v does not contain %q",
708 foo.Inputs.Strings(), fooRes.Output.String())
709 }
710
Colin Crossaf9c55b2017-10-03 14:50:08 -0700711 if fooRes.Args["jarArgs"] != test.args {
712 t.Errorf("foo resource jar args %q is not %q",
Colin Cross0f37af02017-09-27 17:42:05 -0700713 fooRes.Args["jarArgs"], test.args)
714 }
715 })
716 }
717}
718
Colin Cross0c4ce212019-05-03 15:28:19 -0700719func TestIncludeSrcs(t *testing.T) {
Jaewoong Jungf9a04432019-07-17 11:15:09 -0700720 ctx, _ := testJava(t, `
Colin Cross0c4ce212019-05-03 15:28:19 -0700721 java_library {
722 name: "foo",
723 srcs: [
724 "a.java",
725 "b.java",
726 "c.java",
727 ],
728 include_srcs: true,
729 }
730
731 java_library {
732 name: "bar",
733 srcs: [
734 "a.java",
735 "b.java",
736 "c.java",
737 ],
738 java_resource_dirs: ["java-res"],
739 include_srcs: true,
740 }
741 `)
742
743 // Test a library with include_srcs: true
744 foo := ctx.ModuleForTests("foo", "android_common").Output("withres/foo.jar")
745 fooSrcJar := ctx.ModuleForTests("foo", "android_common").Output("foo.srcjar")
746
747 if g, w := fooSrcJar.Output.String(), foo.Inputs.Strings(); !inList(g, w) {
748 t.Errorf("foo combined jars %v does not contain %q", w, g)
749 }
750
751 if g, w := fooSrcJar.Args["jarArgs"], "-C . -f a.java -f b.java -f c.java"; g != w {
752 t.Errorf("foo source jar args %q is not %q", w, g)
753 }
754
755 // Test a library with include_srcs: true and resources
756 bar := ctx.ModuleForTests("bar", "android_common").Output("withres/bar.jar")
757 barResCombined := ctx.ModuleForTests("bar", "android_common").Output("res-combined/bar.jar")
758 barRes := ctx.ModuleForTests("bar", "android_common").Output("res/bar.jar")
759 barSrcJar := ctx.ModuleForTests("bar", "android_common").Output("bar.srcjar")
760
761 if g, w := barSrcJar.Output.String(), barResCombined.Inputs.Strings(); !inList(g, w) {
762 t.Errorf("bar combined resource jars %v does not contain %q", w, g)
763 }
764
765 if g, w := barRes.Output.String(), barResCombined.Inputs.Strings(); !inList(g, w) {
766 t.Errorf("bar combined resource jars %v does not contain %q", w, g)
767 }
768
769 if g, w := barResCombined.Output.String(), bar.Inputs.Strings(); !inList(g, w) {
770 t.Errorf("bar combined jars %v does not contain %q", w, g)
771 }
772
773 if g, w := barSrcJar.Args["jarArgs"], "-C . -f a.java -f b.java -f c.java"; g != w {
774 t.Errorf("bar source jar args %q is not %q", w, g)
775 }
776
777 if g, w := barRes.Args["jarArgs"], "-C java-res -f java-res/a/a -f java-res/b/b"; g != w {
778 t.Errorf("bar resource jar args %q is not %q", w, g)
779 }
780}
781
Colin Cross54190b32017-10-09 15:34:10 -0700782func TestGeneratedSources(t *testing.T) {
Jaewoong Jungf9a04432019-07-17 11:15:09 -0700783 ctx, _ := testJava(t, `
Colin Cross54190b32017-10-09 15:34:10 -0700784 java_library {
785 name: "foo",
786 srcs: [
787 "a*.java",
788 ":gen",
789 "b*.java",
790 ],
791 }
792
793 genrule {
794 name: "gen",
Colin Cross824bee32017-11-22 17:27:51 -0800795 tool_files: ["java-res/a"],
Colin Cross54190b32017-10-09 15:34:10 -0700796 out: ["gen.java"],
797 }
798 `)
799
800 javac := ctx.ModuleForTests("foo", "android_common").Rule("javac")
801 genrule := ctx.ModuleForTests("gen", "").Rule("generator")
802
Colin Cross15e86d92017-10-20 15:07:08 -0700803 if filepath.Base(genrule.Output.String()) != "gen.java" {
804 t.Fatalf(`gen output file %v is not ".../gen.java"`, genrule.Output.String())
Colin Cross54190b32017-10-09 15:34:10 -0700805 }
806
807 if len(javac.Inputs) != 3 ||
808 javac.Inputs[0].String() != "a.java" ||
Colin Cross15e86d92017-10-20 15:07:08 -0700809 javac.Inputs[1].String() != genrule.Output.String() ||
Colin Cross54190b32017-10-09 15:34:10 -0700810 javac.Inputs[2].String() != "b.java" {
811 t.Errorf(`foo inputs %v != ["a.java", ".../gen.java", "b.java"]`, javac.Inputs)
812 }
813}
814
Nan Zhang61eaedb2017-11-02 13:28:15 -0700815func TestTurbine(t *testing.T) {
Jaewoong Jungf9a04432019-07-17 11:15:09 -0700816 ctx, _ := testJava(t, `
Nan Zhang61eaedb2017-11-02 13:28:15 -0700817 java_library {
818 name: "foo",
819 srcs: ["a.java"],
Jiyong Park2d492942018-03-05 17:44:10 +0900820 sdk_version: "14",
Nan Zhang61eaedb2017-11-02 13:28:15 -0700821 }
822
823 java_library {
824 name: "bar",
Colin Cross9bc43432017-12-15 20:20:39 -0800825 srcs: ["b.java"],
Nan Zhang61eaedb2017-11-02 13:28:15 -0700826 static_libs: ["foo"],
Jiyong Park2d492942018-03-05 17:44:10 +0900827 sdk_version: "14",
Nan Zhang61eaedb2017-11-02 13:28:15 -0700828 }
829
830 java_library {
831 name: "baz",
832 srcs: ["c.java"],
833 libs: ["bar"],
834 sdk_version: "14",
835 }
836 `)
837
838 fooTurbine := ctx.ModuleForTests("foo", "android_common").Rule("turbine")
839 barTurbine := ctx.ModuleForTests("bar", "android_common").Rule("turbine")
840 barJavac := ctx.ModuleForTests("bar", "android_common").Rule("javac")
841 barTurbineCombined := ctx.ModuleForTests("bar", "android_common").Description("for turbine")
842 bazJavac := ctx.ModuleForTests("baz", "android_common").Rule("javac")
843
844 if len(fooTurbine.Inputs) != 1 || fooTurbine.Inputs[0].String() != "a.java" {
845 t.Errorf(`foo inputs %v != ["a.java"]`, fooTurbine.Inputs)
846 }
847
848 fooHeaderJar := filepath.Join(buildDir, ".intermediates", "foo", "android_common", "turbine-combined", "foo.jar")
849 if !strings.Contains(barTurbine.Args["classpath"], fooHeaderJar) {
850 t.Errorf("bar turbine classpath %v does not contain %q", barTurbine.Args["classpath"], fooHeaderJar)
851 }
852 if !strings.Contains(barJavac.Args["classpath"], fooHeaderJar) {
853 t.Errorf("bar javac classpath %v does not contain %q", barJavac.Args["classpath"], fooHeaderJar)
854 }
855 if len(barTurbineCombined.Inputs) != 2 || barTurbineCombined.Inputs[1].String() != fooHeaderJar {
856 t.Errorf("bar turbine combineJar inputs %v does not contain %q", barTurbineCombined.Inputs, fooHeaderJar)
857 }
Anton Hanssonf66efeb2018-04-11 13:57:30 +0100858 if !strings.Contains(bazJavac.Args["classpath"], "prebuilts/sdk/14/public/android.jar") {
Nan Zhang61eaedb2017-11-02 13:28:15 -0700859 t.Errorf("baz javac classpath %v does not contain %q", bazJavac.Args["classpath"],
Anton Hanssonf66efeb2018-04-11 13:57:30 +0100860 "prebuilts/sdk/14/public/android.jar")
Nan Zhang61eaedb2017-11-02 13:28:15 -0700861 }
862}
863
864func TestSharding(t *testing.T) {
Jaewoong Jungf9a04432019-07-17 11:15:09 -0700865 ctx, _ := testJava(t, `
Nan Zhang61eaedb2017-11-02 13:28:15 -0700866 java_library {
867 name: "bar",
868 srcs: ["a.java","b.java","c.java"],
869 javac_shard_size: 1
870 }
871 `)
872
873 barHeaderJar := filepath.Join(buildDir, ".intermediates", "bar", "android_common", "turbine-combined", "bar.jar")
874 for i := 0; i < 3; i++ {
875 barJavac := ctx.ModuleForTests("bar", "android_common").Description("javac" + strconv.Itoa(i))
876 if !strings.Contains(barJavac.Args["classpath"], barHeaderJar) {
877 t.Errorf("bar javac classpath %v does not contain %q", barJavac.Args["classpath"], barHeaderJar)
878 }
879 }
880}
881
Nan Zhang581fd212018-01-10 16:06:12 -0800882func TestDroiddoc(t *testing.T) {
Jaewoong Jungf9a04432019-07-17 11:15:09 -0700883 ctx, _ := testJava(t, `
Paul Duffin884363e2019-12-19 10:21:09 +0000884 droiddoc_exported_dir {
Dan Willemsencc090972018-02-26 14:33:31 -0800885 name: "droiddoc-templates-sdk",
886 path: ".",
887 }
Jiyong Park29074592019-07-07 16:27:47 +0900888 filegroup {
889 name: "bar-doc-aidl-srcs",
890 srcs: ["bar-doc/IBar.aidl"],
891 path: "bar-doc",
892 }
Nan Zhang581fd212018-01-10 16:06:12 -0800893 droiddoc {
894 name: "bar-doc",
895 srcs: [
896 "bar-doc/*.java",
Jiyong Park1e440682018-05-23 18:42:04 +0900897 "bar-doc/IFoo.aidl",
Jiyong Park29074592019-07-07 16:27:47 +0900898 ":bar-doc-aidl-srcs",
Nan Zhang581fd212018-01-10 16:06:12 -0800899 ],
900 exclude_srcs: [
901 "bar-doc/b.java"
902 ],
Dan Willemsencc090972018-02-26 14:33:31 -0800903 custom_template: "droiddoc-templates-sdk",
Nan Zhang581fd212018-01-10 16:06:12 -0800904 hdf: [
905 "android.whichdoc offline",
906 ],
907 knowntags: [
908 "bar-doc/known_oj_tags.txt",
909 ],
910 proofread_file: "libcore-proofread.txt",
911 todo_file: "libcore-docs-todo.html",
912 args: "-offlinemode -title \"libcore\"",
913 }
914 `)
915
Colin Crossc0806172019-06-14 18:51:47 -0700916 barDoc := ctx.ModuleForTests("bar-doc", "android_common").Rule("javadoc")
Jiyong Park1e440682018-05-23 18:42:04 +0900917 var javaSrcs []string
Colin Crossc0806172019-06-14 18:51:47 -0700918 for _, i := range barDoc.Inputs {
Jiyong Park1e440682018-05-23 18:42:04 +0900919 javaSrcs = append(javaSrcs, i.Base())
920 }
Colin Crossc0806172019-06-14 18:51:47 -0700921 if len(javaSrcs) != 1 || javaSrcs[0] != "a.java" {
922 t.Errorf("inputs of bar-doc must be []string{\"a.java\"}, but was %#v.", javaSrcs)
Jiyong Park29074592019-07-07 16:27:47 +0900923 }
924
Colin Crossc0806172019-06-14 18:51:47 -0700925 aidl := ctx.ModuleForTests("bar-doc", "android_common").Rule("aidl")
926 if g, w := barDoc.Implicits.Strings(), aidl.Output.String(); !inList(w, g) {
927 t.Errorf("implicits of bar-doc must contain %q, but was %q.", w, g)
928 }
929
930 if g, w := aidl.Implicits.Strings(), []string{"bar-doc/IBar.aidl", "bar-doc/IFoo.aidl"}; !reflect.DeepEqual(w, g) {
931 t.Errorf("aidl inputs must be %q, but was %q", w, g)
Jiyong Park1e440682018-05-23 18:42:04 +0900932 }
Nan Zhang581fd212018-01-10 16:06:12 -0800933}
934
Colin Cross54250902017-12-05 09:28:08 -0800935func TestJarGenrules(t *testing.T) {
Jaewoong Jungf9a04432019-07-17 11:15:09 -0700936 ctx, _ := testJava(t, `
Colin Cross54250902017-12-05 09:28:08 -0800937 java_library {
938 name: "foo",
939 srcs: ["a.java"],
940 }
941
942 java_genrule {
943 name: "jargen",
944 tool_files: ["b.java"],
945 cmd: "$(location b.java) $(in) $(out)",
946 out: ["jargen.jar"],
947 srcs: [":foo"],
948 }
949
950 java_library {
951 name: "bar",
952 static_libs: ["jargen"],
953 srcs: ["c.java"],
954 }
955
956 java_library {
957 name: "baz",
958 libs: ["jargen"],
959 srcs: ["c.java"],
960 }
961 `)
962
963 foo := ctx.ModuleForTests("foo", "android_common").Output("javac/foo.jar")
964 jargen := ctx.ModuleForTests("jargen", "android_common").Output("jargen.jar")
965 bar := ctx.ModuleForTests("bar", "android_common").Output("javac/bar.jar")
966 baz := ctx.ModuleForTests("baz", "android_common").Output("javac/baz.jar")
967 barCombined := ctx.ModuleForTests("bar", "android_common").Output("combined/bar.jar")
968
969 if len(jargen.Inputs) != 1 || jargen.Inputs[0].String() != foo.Output.String() {
970 t.Errorf("expected jargen inputs [%q], got %q", foo.Output.String(), jargen.Inputs.Strings())
971 }
972
973 if !strings.Contains(bar.Args["classpath"], jargen.Output.String()) {
974 t.Errorf("bar classpath %v does not contain %q", bar.Args["classpath"], jargen.Output.String())
975 }
976
977 if !strings.Contains(baz.Args["classpath"], jargen.Output.String()) {
978 t.Errorf("baz classpath %v does not contain %q", baz.Args["classpath"], jargen.Output.String())
979 }
980
981 if len(barCombined.Inputs) != 2 ||
982 barCombined.Inputs[0].String() != bar.Output.String() ||
983 barCombined.Inputs[1].String() != jargen.Output.String() {
984 t.Errorf("bar combined jar inputs %v is not [%q, %q]",
985 barCombined.Inputs.Strings(), bar.Output.String(), jargen.Output.String())
986 }
987}
988
Nan Zhang27e284d2018-02-09 21:03:53 +0000989func TestExcludeFileGroupInSrcs(t *testing.T) {
Jaewoong Jungf9a04432019-07-17 11:15:09 -0700990 ctx, _ := testJava(t, `
Nan Zhang27e284d2018-02-09 21:03:53 +0000991 java_library {
992 name: "foo",
993 srcs: ["a.java", ":foo-srcs"],
994 exclude_srcs: ["a.java", ":foo-excludes"],
995 }
996
997 filegroup {
998 name: "foo-srcs",
999 srcs: ["java-fg/a.java", "java-fg/b.java", "java-fg/c.java"],
1000 }
1001
1002 filegroup {
1003 name: "foo-excludes",
1004 srcs: ["java-fg/a.java", "java-fg/b.java"],
1005 }
1006 `)
1007
1008 javac := ctx.ModuleForTests("foo", "android_common").Rule("javac")
1009
1010 if len(javac.Inputs) != 1 || javac.Inputs[0].String() != "java-fg/c.java" {
1011 t.Errorf(`foo inputs %v != ["java-fg/c.java"]`, javac.Inputs)
1012 }
1013}
Jiyong Parkc678ad32018-04-10 13:07:10 +09001014
Paul Duffin52d398a2019-06-11 12:31:14 +01001015func TestJavaLibrary(t *testing.T) {
Colin Cross98be1bb2019-12-13 20:41:13 -08001016 config := testConfig(nil, "", map[string][]byte{
Paul Duffin52d398a2019-06-11 12:31:14 +01001017 "libcore/Android.bp": []byte(`
1018 java_library {
1019 name: "core",
1020 sdk_version: "none",
1021 system_modules: "none",
1022 }`),
1023 })
Colin Cross98be1bb2019-12-13 20:41:13 -08001024 ctx := testContext()
Paul Duffin52d398a2019-06-11 12:31:14 +01001025 run(t, ctx, config)
1026}
1027
Jiyong Parkc678ad32018-04-10 13:07:10 +09001028func TestJavaSdkLibrary(t *testing.T) {
Jaewoong Jungf9a04432019-07-17 11:15:09 -07001029 ctx, _ := testJava(t, `
Paul Duffin884363e2019-12-19 10:21:09 +00001030 droiddoc_exported_dir {
Jiyong Parkc678ad32018-04-10 13:07:10 +09001031 name: "droiddoc-templates-sdk",
1032 path: ".",
1033 }
Jiyong Parkc678ad32018-04-10 13:07:10 +09001034 java_sdk_library {
1035 name: "foo",
1036 srcs: ["a.java", "b.java"],
1037 api_packages: ["foo"],
1038 }
1039 java_sdk_library {
1040 name: "bar",
1041 srcs: ["a.java", "b.java"],
1042 api_packages: ["bar"],
1043 }
1044 java_library {
1045 name: "baz",
1046 srcs: ["c.java"],
1047 libs: ["foo", "bar"],
1048 sdk_version: "system_current",
1049 }
Jiyong Park1be96912018-05-28 18:02:19 +09001050 java_library {
1051 name: "qux",
1052 srcs: ["c.java"],
1053 libs: ["baz"],
1054 sdk_version: "system_current",
1055 }
Jiyong Parkc678ad32018-04-10 13:07:10 +09001056 `)
1057
1058 // check the existence of the internal modules
1059 ctx.ModuleForTests("foo", "android_common")
1060 ctx.ModuleForTests("foo"+sdkStubsLibrarySuffix, "android_common")
1061 ctx.ModuleForTests("foo"+sdkStubsLibrarySuffix+sdkSystemApiSuffix, "android_common")
Jiyong Park58c518b2018-05-12 22:29:12 +09001062 ctx.ModuleForTests("foo"+sdkStubsLibrarySuffix+sdkTestApiSuffix, "android_common")
Jiyong Parkc678ad32018-04-10 13:07:10 +09001063 ctx.ModuleForTests("foo"+sdkDocsSuffix, "android_common")
1064 ctx.ModuleForTests("foo"+sdkDocsSuffix+sdkSystemApiSuffix, "android_common")
Jiyong Park58c518b2018-05-12 22:29:12 +09001065 ctx.ModuleForTests("foo"+sdkDocsSuffix+sdkTestApiSuffix, "android_common")
Colin Cross7113d202019-11-20 16:39:12 -08001066 ctx.ModuleForTests("foo"+sdkXmlFileSuffix, "android_arm64_armv8-a")
Jiyong Park58c518b2018-05-12 22:29:12 +09001067 ctx.ModuleForTests("foo.api.public.28", "")
1068 ctx.ModuleForTests("foo.api.system.28", "")
1069 ctx.ModuleForTests("foo.api.test.28", "")
Jiyong Parkc678ad32018-04-10 13:07:10 +09001070
1071 bazJavac := ctx.ModuleForTests("baz", "android_common").Rule("javac")
1072 // tests if baz is actually linked to the stubs lib
1073 if !strings.Contains(bazJavac.Args["classpath"], "foo.stubs.system.jar") {
1074 t.Errorf("baz javac classpath %v does not contain %q", bazJavac.Args["classpath"],
1075 "foo.stubs.system.jar")
1076 }
1077 // ... and not to the impl lib
Sundong Ahn054b19a2018-10-19 13:46:09 +09001078 if strings.Contains(bazJavac.Args["classpath"], "foo.jar") {
Jiyong Parkc678ad32018-04-10 13:07:10 +09001079 t.Errorf("baz javac classpath %v should not contain %q", bazJavac.Args["classpath"],
Sundong Ahn054b19a2018-10-19 13:46:09 +09001080 "foo.jar")
Jiyong Parkc678ad32018-04-10 13:07:10 +09001081 }
1082 // test if baz is not linked to the system variant of foo
1083 if strings.Contains(bazJavac.Args["classpath"], "foo.stubs.jar") {
1084 t.Errorf("baz javac classpath %v should not contain %q", bazJavac.Args["classpath"],
1085 "foo.stubs.jar")
1086 }
Jiyong Park1be96912018-05-28 18:02:19 +09001087
1088 // test if baz has exported SDK lib names foo and bar to qux
1089 qux := ctx.ModuleForTests("qux", "android_common")
1090 if quxLib, ok := qux.Module().(*Library); ok {
1091 sdkLibs := quxLib.ExportedSdkLibs()
1092 if len(sdkLibs) != 2 || !android.InList("foo", sdkLibs) || !android.InList("bar", sdkLibs) {
1093 t.Errorf("qux should export \"foo\" and \"bar\" but exports %v", sdkLibs)
1094 }
1095 }
Jiyong Parkc678ad32018-04-10 13:07:10 +09001096}
Zoran Jovanovic8736ce22018-08-21 17:10:29 +02001097
1098var compilerFlagsTestCases = []struct {
1099 in string
1100 out bool
1101}{
1102 {
1103 in: "a",
1104 out: false,
1105 },
1106 {
1107 in: "-a",
1108 out: true,
1109 },
1110 {
1111 in: "-no-jdk",
1112 out: false,
1113 },
1114 {
1115 in: "-no-stdlib",
1116 out: false,
1117 },
1118 {
1119 in: "-kotlin-home",
1120 out: false,
1121 },
1122 {
1123 in: "-kotlin-home /some/path",
1124 out: false,
1125 },
1126 {
1127 in: "-include-runtime",
1128 out: false,
1129 },
1130 {
1131 in: "-Xintellij-plugin-root",
1132 out: false,
1133 },
1134}
1135
1136type mockContext struct {
1137 android.ModuleContext
1138 result bool
1139}
1140
1141func (ctx *mockContext) PropertyErrorf(property, format string, args ...interface{}) {
1142 // CheckBadCompilerFlags calls this function when the flag should be rejected
1143 ctx.result = false
1144}
1145
1146func TestCompilerFlags(t *testing.T) {
1147 for _, testCase := range compilerFlagsTestCases {
1148 ctx := &mockContext{result: true}
1149 CheckKotlincFlags(ctx, []string{testCase.in})
1150 if ctx.result != testCase.out {
1151 t.Errorf("incorrect output:")
1152 t.Errorf(" input: %#v", testCase.in)
1153 t.Errorf(" expected: %#v", testCase.out)
1154 t.Errorf(" got: %#v", ctx.result)
1155 }
1156 }
1157}
Jaewoong Jung38e4fb22018-12-12 09:01:34 -08001158
1159// TODO(jungjw): Consider making this more robust by ignoring path order.
1160func checkPatchModuleFlag(t *testing.T, ctx *android.TestContext, moduleName string, expected string) {
1161 variables := ctx.ModuleForTests(moduleName, "android_common").Module().VariablesForTests()
1162 flags := strings.Split(variables["javacFlags"], " ")
1163 got := ""
1164 for _, flag := range flags {
1165 keyEnd := strings.Index(flag, "=")
1166 if keyEnd > -1 && flag[:keyEnd] == "--patch-module" {
1167 got = flag[keyEnd+1:]
1168 break
1169 }
1170 }
1171 if expected != got {
1172 t.Errorf("Unexpected patch-module flag for module %q - expected %q, but got %q", moduleName, expected, got)
1173 }
1174}
1175
1176func TestPatchModule(t *testing.T) {
Pete Gillin0c2143e2019-05-02 15:32:11 +01001177 t.Run("Java language level 8", func(t *testing.T) {
Pete Gillin1b3370f2019-10-01 13:57:31 +01001178 // Test with legacy javac -source 1.8 -target 1.8
Pete Gillinbdf5d712019-10-21 14:29:58 +01001179 bp := `
1180 java_library {
1181 name: "foo",
1182 srcs: ["a.java"],
1183 java_version: "1.8",
1184 }
1185
1186 java_library {
1187 name: "bar",
1188 srcs: ["b.java"],
1189 sdk_version: "none",
1190 system_modules: "none",
1191 patch_module: "java.base",
1192 java_version: "1.8",
1193 }
1194
1195 java_library {
1196 name: "baz",
1197 srcs: ["c.java"],
1198 patch_module: "java.base",
1199 java_version: "1.8",
1200 }
1201 `
1202 ctx, _ := testJava(t, bp)
Jaewoong Jung38e4fb22018-12-12 09:01:34 -08001203
1204 checkPatchModuleFlag(t, ctx, "foo", "")
1205 checkPatchModuleFlag(t, ctx, "bar", "")
1206 checkPatchModuleFlag(t, ctx, "baz", "")
1207 })
1208
Pete Gillin0c2143e2019-05-02 15:32:11 +01001209 t.Run("Java language level 9", func(t *testing.T) {
Pete Gillin1b3370f2019-10-01 13:57:31 +01001210 // Test with default javac -source 9 -target 9
Pete Gillinbdf5d712019-10-21 14:29:58 +01001211 bp := `
1212 java_library {
1213 name: "foo",
1214 srcs: ["a.java"],
1215 }
1216
1217 java_library {
1218 name: "bar",
1219 srcs: ["b.java"],
1220 sdk_version: "none",
1221 system_modules: "none",
1222 patch_module: "java.base",
1223 }
1224
1225 java_library {
1226 name: "baz",
1227 srcs: ["c.java"],
1228 patch_module: "java.base",
1229 }
1230 `
Pete Gillin1b3370f2019-10-01 13:57:31 +01001231 ctx, _ := testJava(t, bp)
Jaewoong Jung38e4fb22018-12-12 09:01:34 -08001232
1233 checkPatchModuleFlag(t, ctx, "foo", "")
1234 expected := "java.base=.:" + buildDir
1235 checkPatchModuleFlag(t, ctx, "bar", expected)
Jiyong Park231d0562019-12-18 17:28:17 +09001236 expected = "java.base=" + strings.Join([]string{".", buildDir, moduleToPath("ext"), moduleToPath("framework")}, ":")
Jaewoong Jung38e4fb22018-12-12 09:01:34 -08001237 checkPatchModuleFlag(t, ctx, "baz", expected)
1238 })
1239}
Paul Duffina7b9f422020-01-10 17:12:18 +00001240
1241func TestJavaSystemModules(t *testing.T) {
1242 ctx, _ := testJava(t, `
1243 java_system_modules {
1244 name: "system-modules",
1245 libs: ["system-module1", "system-module2"],
1246 }
1247 java_library {
1248 name: "system-module1",
1249 srcs: ["a.java"],
1250 sdk_version: "none",
1251 system_modules: "none",
1252 }
1253 java_library {
1254 name: "system-module2",
1255 srcs: ["b.java"],
1256 sdk_version: "none",
1257 system_modules: "none",
1258 }
1259 `)
1260
1261 // check the existence of the module
1262 systemModules := ctx.ModuleForTests("system-modules", "android_common")
1263
1264 cmd := systemModules.Rule("jarsTosystemModules")
1265
1266 // make sure the command compiles against the supplied modules.
1267 for _, module := range []string{"system-module1.jar", "system-module2.jar"} {
1268 if !strings.Contains(cmd.Args["classpath"], module) {
1269 t.Errorf("system modules classpath %v does not contain %q", cmd.Args["classpath"],
1270 module)
1271 }
1272 }
1273}
Paul Duffin90169ba2020-01-10 17:16:44 +00001274
1275func TestJavaSystemModulesImport(t *testing.T) {
1276 ctx, _ := testJava(t, `
1277 java_system_modules_import {
1278 name: "system-modules",
1279 libs: ["system-module1", "system-module2"],
1280 }
1281 java_import {
1282 name: "system-module1",
1283 jars: ["a.jar"],
1284 }
1285 java_import {
1286 name: "system-module2",
1287 jars: ["b.jar"],
1288 }
1289 `)
1290
1291 // check the existence of the module
1292 systemModules := ctx.ModuleForTests("system-modules", "android_common")
1293
1294 cmd := systemModules.Rule("jarsTosystemModules")
1295
1296 // make sure the command compiles against the supplied modules.
1297 for _, module := range []string{"system-module1.jar", "system-module2.jar"} {
1298 if !strings.Contains(cmd.Args["classpath"], module) {
1299 t.Errorf("system modules classpath %v does not contain %q", cmd.Args["classpath"],
1300 module)
1301 }
1302 }
1303}