• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1// Copyright 2021 Google Inc. All rights reserved.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package bp2build
16
17import (
18	"android/soong/android"
19	"android/soong/java"
20
21	"testing"
22)
23
24func runAndroidAppTestCase(t *testing.T, tc Bp2buildTestCase) {
25	t.Helper()
26	RunBp2BuildTestCase(t, registerAndroidAppModuleTypes, tc)
27}
28
29func registerAndroidAppModuleTypes(ctx android.RegistrationContext) {
30	ctx.RegisterModuleType("filegroup", android.FileGroupFactory)
31	ctx.RegisterModuleType("java_library", java.LibraryFactory)
32}
33
34func TestMinimalAndroidApp(t *testing.T) {
35	runAndroidAppTestCase(t, Bp2buildTestCase{
36		Description:                "Android app - simple example",
37		ModuleTypeUnderTest:        "android_app",
38		ModuleTypeUnderTestFactory: java.AndroidAppFactory,
39		Filesystem: map[string]string{
40			"app.java":            "",
41			"res/res.png":         "",
42			"AndroidManifest.xml": "",
43		},
44		Blueprint: `
45android_app {
46        name: "TestApp",
47        srcs: ["app.java"],
48        sdk_version: "current",
49}
50`,
51		ExpectedBazelTargets: []string{
52			MakeBazelTarget("android_binary", "TestApp", AttrNameToString{
53				"srcs":           `["app.java"]`,
54				"manifest":       `"AndroidManifest.xml"`,
55				"resource_files": `["res/res.png"]`,
56				"sdk_version":    `"current"`,
57			}),
58		}})
59}
60
61func TestAndroidAppAllSupportedFields(t *testing.T) {
62	runAndroidAppTestCase(t, Bp2buildTestCase{
63		Description:                "Android app - all supported fields",
64		ModuleTypeUnderTest:        "android_app",
65		ModuleTypeUnderTestFactory: java.AndroidAppFactory,
66		Filesystem: map[string]string{
67			"app.java":                     "",
68			"resa/res.png":                 "",
69			"resb/res.png":                 "",
70			"manifest/AndroidManifest.xml": "",
71		},
72		Blueprint: simpleModuleDoNotConvertBp2build("android_app", "static_lib_dep") + `
73android_app {
74        name: "TestApp",
75        srcs: ["app.java"],
76        sdk_version: "current",
77        package_name: "com.google",
78        resource_dirs: ["resa", "resb"],
79        manifest: "manifest/AndroidManifest.xml",
80        static_libs: ["static_lib_dep"],
81        java_version: "7",
82        certificate: "foocert",
83}
84`,
85		ExpectedBazelTargets: []string{
86			MakeBazelTarget("android_binary", "TestApp", AttrNameToString{
87				"srcs":     `["app.java"]`,
88				"manifest": `"manifest/AndroidManifest.xml"`,
89				"resource_files": `[
90        "resa/res.png",
91        "resb/res.png",
92    ]`,
93				"custom_package":   `"com.google"`,
94				"deps":             `[":static_lib_dep"]`,
95				"java_version":     `"7"`,
96				"sdk_version":      `"current"`,
97				"certificate_name": `"foocert"`,
98			}),
99		}})
100}
101
102func TestAndroidAppArchVariantSrcs(t *testing.T) {
103	runAndroidAppTestCase(t, Bp2buildTestCase{
104		Description:                "Android app - arch variant srcs",
105		ModuleTypeUnderTest:        "android_app",
106		ModuleTypeUnderTestFactory: java.AndroidAppFactory,
107		Filesystem: map[string]string{
108			"arm.java":            "",
109			"x86.java":            "",
110			"res/res.png":         "",
111			"AndroidManifest.xml": "",
112		},
113		Blueprint: `
114android_app {
115        name: "TestApp",
116        sdk_version: "current",
117        arch: {
118			arm: {
119				srcs: ["arm.java"],
120			},
121			x86: {
122				srcs: ["x86.java"],
123			}
124		}
125}
126`,
127		ExpectedBazelTargets: []string{
128			MakeBazelTarget("android_binary", "TestApp", AttrNameToString{
129				"srcs": `select({
130        "//build/bazel/platforms/arch:arm": ["arm.java"],
131        "//build/bazel/platforms/arch:x86": ["x86.java"],
132        "//conditions:default": [],
133    })`,
134				"manifest":       `"AndroidManifest.xml"`,
135				"resource_files": `["res/res.png"]`,
136				"sdk_version":    `"current"`,
137			}),
138		}})
139}
140
141func TestAndroidAppCertIsModule(t *testing.T) {
142	runAndroidAppTestCase(t, Bp2buildTestCase{
143		Description:                "Android app - cert is module",
144		ModuleTypeUnderTest:        "android_app",
145		ModuleTypeUnderTestFactory: java.AndroidAppFactory,
146		Filesystem:                 map[string]string{},
147		Blueprint: simpleModuleDoNotConvertBp2build("filegroup", "foocert") + `
148android_app {
149        name: "TestApp",
150        certificate: ":foocert",
151}
152`,
153		ExpectedBazelTargets: []string{
154			MakeBazelTarget("android_binary", "TestApp", AttrNameToString{
155				"certificate":    `":foocert"`,
156				"manifest":       `"AndroidManifest.xml"`,
157				"resource_files": `[]`,
158			}),
159		}})
160}
161
162func TestAndroidAppCertIsSrcFile(t *testing.T) {
163	runAndroidAppTestCase(t, Bp2buildTestCase{
164		Description:                "Android app - cert is src file",
165		ModuleTypeUnderTest:        "android_app",
166		ModuleTypeUnderTestFactory: java.AndroidAppFactory,
167		Filesystem: map[string]string{
168			"foocert": "",
169		},
170		Blueprint: `
171android_app {
172        name: "TestApp",
173        certificate: "foocert",
174}
175`,
176		ExpectedBazelTargets: []string{
177			MakeBazelTarget("android_binary", "TestApp", AttrNameToString{
178				"certificate":    `"foocert"`,
179				"manifest":       `"AndroidManifest.xml"`,
180				"resource_files": `[]`,
181			}),
182		}})
183}
184
185func TestAndroidAppCertIsNotSrcOrModule(t *testing.T) {
186	runAndroidAppTestCase(t, Bp2buildTestCase{
187		Description:                "Android app - cert is not src or module",
188		ModuleTypeUnderTest:        "android_app",
189		ModuleTypeUnderTestFactory: java.AndroidAppFactory,
190		Filesystem:                 map[string]string{
191			// deliberate empty
192		},
193		Blueprint: `
194android_app {
195        name: "TestApp",
196        certificate: "foocert",
197}
198`,
199		ExpectedBazelTargets: []string{
200			MakeBazelTarget("android_binary", "TestApp", AttrNameToString{
201				"certificate_name": `"foocert"`,
202				"manifest":         `"AndroidManifest.xml"`,
203				"resource_files":   `[]`,
204			}),
205		}})
206}
207
208func TestAndroidAppLibs(t *testing.T) {
209	runAndroidAppTestCase(t, Bp2buildTestCase{
210		Description:                "Android app with libs",
211		ModuleTypeUnderTest:        "android_app",
212		ModuleTypeUnderTestFactory: java.AndroidAppFactory,
213		Filesystem:                 map[string]string{},
214		Blueprint: simpleModuleDoNotConvertBp2build("filegroup", "foocert") + `
215android_app {
216        name: "foo",
217				libs: ["barLib"]
218}
219java_library{
220       name: "barLib",
221}
222`,
223		ExpectedBazelTargets: []string{
224			MakeBazelTarget("java_library", "barLib", AttrNameToString{}),
225			MakeNeverlinkDuplicateTarget("java_library", "barLib"),
226			MakeBazelTarget("android_binary", "foo", AttrNameToString{
227				"manifest":       `"AndroidManifest.xml"`,
228				"resource_files": `[]`,
229				"deps":           `[":barLib-neverlink"]`,
230			}),
231		}})
232}
233
234func TestAndroidAppKotlinSrcs(t *testing.T) {
235	runAndroidAppTestCase(t, Bp2buildTestCase{
236		Description:                "Android app with kotlin sources and common_srcs",
237		ModuleTypeUnderTest:        "android_app",
238		ModuleTypeUnderTestFactory: java.AndroidAppFactory,
239		Filesystem: map[string]string{
240			"res/res.png": "",
241		},
242		Blueprint: simpleModuleDoNotConvertBp2build("filegroup", "foocert") + `
243android_app {
244        name: "foo",
245        srcs: ["a.java", "b.kt"],
246        certificate: ":foocert",
247        manifest: "fooManifest.xml",
248        libs: ["barLib"]
249}
250java_library{
251      name:   "barLib",
252}
253`,
254		ExpectedBazelTargets: []string{
255			MakeBazelTarget("java_library", "barLib", AttrNameToString{}),
256			MakeNeverlinkDuplicateTarget("java_library", "barLib"),
257			MakeBazelTarget("android_library", "foo_kt", AttrNameToString{
258				"srcs": `[
259        "a.java",
260        "b.kt",
261    ]`,
262				"manifest":       `"fooManifest.xml"`,
263				"resource_files": `["res/res.png"]`,
264				"deps":           `[":barLib-neverlink"]`,
265			}),
266			MakeBazelTarget("android_binary", "foo", AttrNameToString{
267				"deps":        `[":foo_kt"]`,
268				"certificate": `":foocert"`,
269				"manifest":    `"fooManifest.xml"`,
270			}),
271		}})
272}
273
274func TestAndroidAppCommonSrcs(t *testing.T) {
275	runAndroidAppTestCase(t, Bp2buildTestCase{
276		Description:                "Android app with common_srcs",
277		ModuleTypeUnderTest:        "android_app",
278		ModuleTypeUnderTestFactory: java.AndroidAppFactory,
279		Filesystem: map[string]string{
280			"res/res.png": "",
281		},
282		Blueprint: simpleModuleDoNotConvertBp2build("filegroup", "foocert") + `
283android_app {
284        name: "foo",
285        srcs: ["a.java"],
286        common_srcs: ["b.kt"],
287        certificate: "foocert",
288        manifest: "fooManifest.xml",
289        libs:        ["barLib"],
290}
291java_library{
292      name:   "barLib",
293}
294`,
295		ExpectedBazelTargets: []string{
296			MakeBazelTarget("java_library", "barLib", AttrNameToString{}),
297			MakeNeverlinkDuplicateTarget("java_library", "barLib"),
298			MakeBazelTarget("android_library", "foo_kt", AttrNameToString{
299				"srcs":           `["a.java"]`,
300				"common_srcs":    `["b.kt"]`,
301				"manifest":       `"fooManifest.xml"`,
302				"resource_files": `["res/res.png"]`,
303				"deps":           `[":barLib-neverlink"]`,
304			}),
305			MakeBazelTarget("android_binary", "foo", AttrNameToString{
306				"deps":             `[":foo_kt"]`,
307				"certificate_name": `"foocert"`,
308				"manifest":         `"fooManifest.xml"`,
309			}),
310		}})
311}
312
313func TestAndroidAppKotlinCflags(t *testing.T) {
314	runAndroidAppTestCase(t, Bp2buildTestCase{
315		Description:                "Android app with kotlincflags",
316		ModuleTypeUnderTest:        "android_app",
317		ModuleTypeUnderTestFactory: java.AndroidAppFactory,
318		Filesystem: map[string]string{
319			"res/res.png": "",
320		},
321		Blueprint: simpleModuleDoNotConvertBp2build("filegroup", "foocert") + `
322android_app {
323        name: "foo",
324        srcs: ["a.java", "b.kt"],
325        certificate: ":foocert",
326        manifest: "fooManifest.xml",
327        kotlincflags: ["-flag1", "-flag2"],
328}
329`,
330		ExpectedBazelTargets: []string{
331			MakeBazelTarget("android_library", "foo_kt", AttrNameToString{
332				"srcs": `[
333        "a.java",
334        "b.kt",
335    ]`,
336				"manifest":       `"fooManifest.xml"`,
337				"resource_files": `["res/res.png"]`,
338				"kotlincflags": `[
339        "-flag1",
340        "-flag2",
341    ]`,
342			}),
343			MakeBazelTarget("android_binary", "foo", AttrNameToString{
344				"deps":        `[":foo_kt"]`,
345				"certificate": `":foocert"`,
346				"manifest":    `"fooManifest.xml"`,
347			}),
348		}})
349}
350
351func TestAndroidAppMinSdkProvided(t *testing.T) {
352	runAndroidAppTestCase(t, Bp2buildTestCase{
353		Description:                "Android app with value for min_sdk_version",
354		ModuleTypeUnderTest:        "android_app",
355		ModuleTypeUnderTestFactory: java.AndroidAppFactory,
356		Filesystem:                 map[string]string{},
357		Blueprint: simpleModuleDoNotConvertBp2build("filegroup", "foocert") + `
358android_app {
359        name: "foo",
360        sdk_version: "current",
361				min_sdk_version: "24",
362}
363`,
364		ExpectedBazelTargets: []string{
365			MakeBazelTarget("android_binary", "foo", AttrNameToString{
366				"manifest":       `"AndroidManifest.xml"`,
367				"resource_files": `[]`,
368				"manifest_values": `{
369        "minSdkVersion": "24",
370    }`,
371				"sdk_version": `"current"`,
372			}),
373		}})
374}
375
376func TestAndroidAppMinSdkDefaultToSdkVersion(t *testing.T) {
377	runAndroidAppTestCase(t, Bp2buildTestCase{
378		Description:                "Android app with value for sdk_version",
379		ModuleTypeUnderTest:        "android_app",
380		ModuleTypeUnderTestFactory: java.AndroidAppFactory,
381		Filesystem:                 map[string]string{},
382		Blueprint: simpleModuleDoNotConvertBp2build("filegroup", "foocert") + `
383android_app {
384        name: "foo",
385        sdk_version: "30",
386}
387`,
388		ExpectedBazelTargets: []string{
389			MakeBazelTarget("android_binary", "foo", AttrNameToString{
390				"manifest":       `"AndroidManifest.xml"`,
391				"resource_files": `[]`,
392				"manifest_values": `{
393        "minSdkVersion": "30",
394    }`,
395				"sdk_version": `"30"`,
396			}),
397		}})
398}
399