blob: 1ca742213ee24df62754d61e7e0ddaf0aafb4085 [file] [log] [blame]
// Copyright 2015 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 android
import (
"github.com/google/blueprint"
"path/filepath"
"runtime"
"testing"
)
func TestSrcIsModule(t *testing.T) {
type args struct {
s string
}
tests := []struct {
name string
args args
wantModule string
}{
{
name: "file",
args: args{
s: "foo",
},
wantModule: "",
},
{
name: "module",
args: args{
s: ":foo",
},
wantModule: "foo",
},
{
name: "tag",
args: args{
s: ":foo{.bar}",
},
wantModule: "foo{.bar}",
},
{
name: "extra colon",
args: args{
s: ":foo:bar",
},
wantModule: "foo:bar",
},
{
name: "fully qualified",
args: args{
s: "//foo:bar",
},
wantModule: "//foo:bar",
},
{
name: "fully qualified with tag",
args: args{
s: "//foo:bar{.tag}",
},
wantModule: "//foo:bar{.tag}",
},
{
name: "invalid unqualified name",
args: args{
s: ":foo/bar",
},
wantModule: "",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if gotModule := SrcIsModule(tt.args.s); gotModule != tt.wantModule {
t.Errorf("SrcIsModule() = %v, want %v", gotModule, tt.wantModule)
}
})
}
}
func TestSrcIsModuleWithTag(t *testing.T) {
type args struct {
s string
}
tests := []struct {
name string
args args
wantModule string
wantTag string
}{
{
name: "file",
args: args{
s: "foo",
},
wantModule: "",
wantTag: "",
},
{
name: "module",
args: args{
s: ":foo",
},
wantModule: "foo",
wantTag: "",
},
{
name: "tag",
args: args{
s: ":foo{.bar}",
},
wantModule: "foo",
wantTag: ".bar",
},
{
name: "empty tag",
args: args{
s: ":foo{}",
},
wantModule: "foo",
wantTag: "",
},
{
name: "extra colon",
args: args{
s: ":foo:bar",
},
wantModule: "foo:bar",
},
{
name: "invalid tag",
args: args{
s: ":foo{.bar",
},
wantModule: "foo{.bar",
},
{
name: "invalid tag 2",
args: args{
s: ":foo.bar}",
},
wantModule: "foo.bar}",
},
{
name: "fully qualified",
args: args{
s: "//foo:bar",
},
wantModule: "//foo:bar",
},
{
name: "fully qualified with tag",
args: args{
s: "//foo:bar{.tag}",
},
wantModule: "//foo:bar",
wantTag: ".tag",
},
{
name: "invalid unqualified name",
args: args{
s: ":foo/bar",
},
wantModule: "",
},
{
name: "invalid unqualified name with tag",
args: args{
s: ":foo/bar{.tag}",
},
wantModule: "",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
gotModule, gotTag := SrcIsModuleWithTag(tt.args.s)
if gotModule != tt.wantModule {
t.Errorf("SrcIsModuleWithTag() gotModule = %v, want %v", gotModule, tt.wantModule)
}
if gotTag != tt.wantTag {
t.Errorf("SrcIsModuleWithTag() gotTag = %v, want %v", gotTag, tt.wantTag)
}
})
}
}
type depsModule struct {
ModuleBase
props struct {
Deps []string
}
}
func (m *depsModule) GenerateAndroidBuildActions(ctx ModuleContext) {
outputFile := PathForModuleOut(ctx, ctx.ModuleName())
ctx.Build(pctx, BuildParams{
Rule: Touch,
Output: outputFile,
})
installFile := ctx.InstallFile(PathForModuleInstall(ctx), ctx.ModuleName(), outputFile)
ctx.InstallSymlink(PathForModuleInstall(ctx, "symlinks"), ctx.ModuleName(), installFile)
}
func (m *depsModule) DepsMutator(ctx BottomUpMutatorContext) {
ctx.AddDependency(ctx.Module(), installDepTag{}, m.props.Deps...)
}
func depsModuleFactory() Module {
m := &depsModule{}
m.AddProperties(&m.props)
InitAndroidArchModule(m, HostAndDeviceDefault, MultilibCommon)
return m
}
var prepareForModuleTests = FixtureRegisterWithContext(func(ctx RegistrationContext) {
ctx.RegisterModuleType("deps", depsModuleFactory)
})
func TestErrorDependsOnDisabledModule(t *testing.T) {
bp := `
deps {
name: "foo",
deps: ["bar"],
}
deps {
name: "bar",
enabled: false,
}
`
prepareForModuleTests.
ExtendWithErrorHandler(FixtureExpectsAtLeastOneErrorMatchingPattern(`module "foo": depends on disabled module "bar"`)).
RunTestWithBp(t, bp)
}
func TestValidateCorrectBuildParams(t *testing.T) {
config := TestConfig(t.TempDir(), nil, "", nil)
pathContext := PathContextForTesting(config)
bparams := convertBuildParams(BuildParams{
// Test with Output
Output: PathForOutput(pathContext, "undeclared_symlink"),
SymlinkOutput: PathForOutput(pathContext, "undeclared_symlink"),
})
err := validateBuildParams(bparams)
if err != nil {
t.Error(err)
}
bparams = convertBuildParams(BuildParams{
// Test with ImplicitOutput
ImplicitOutput: PathForOutput(pathContext, "undeclared_symlink"),
SymlinkOutput: PathForOutput(pathContext, "undeclared_symlink"),
})
err = validateBuildParams(bparams)
if err != nil {
t.Error(err)
}
}
func TestValidateIncorrectBuildParams(t *testing.T) {
config := TestConfig(t.TempDir(), nil, "", nil)
pathContext := PathContextForTesting(config)
params := BuildParams{
Output: PathForOutput(pathContext, "regular_output"),
Outputs: PathsForOutput(pathContext, []string{"out1", "out2"}),
ImplicitOutput: PathForOutput(pathContext, "implicit_output"),
ImplicitOutputs: PathsForOutput(pathContext, []string{"i_out1", "_out2"}),
SymlinkOutput: PathForOutput(pathContext, "undeclared_symlink"),
}
bparams := convertBuildParams(params)
err := validateBuildParams(bparams)
if err != nil {
FailIfNoMatchingErrors(t, "undeclared_symlink is not a declared output or implicit output", []error{err})
} else {
t.Errorf("Expected build params to fail validation: %+v", bparams)
}
}
func TestDistErrorChecking(t *testing.T) {
bp := `
deps {
name: "foo",
dist: {
dest: "../invalid-dest",
dir: "../invalid-dir",
suffix: "invalid/suffix",
},
dists: [
{
dest: "../invalid-dest0",
dir: "../invalid-dir0",
suffix: "invalid/suffix0",
},
{
dest: "../invalid-dest1",
dir: "../invalid-dir1",
suffix: "invalid/suffix1",
},
],
}
`
expectedErrs := []string{
"\\QAndroid.bp:5:13: module \"foo\": dist.dest: Path is outside directory: ../invalid-dest\\E",
"\\QAndroid.bp:6:12: module \"foo\": dist.dir: Path is outside directory: ../invalid-dir\\E",
"\\QAndroid.bp:7:15: module \"foo\": dist.suffix: Suffix may not contain a '/' character.\\E",
"\\QAndroid.bp:11:15: module \"foo\": dists[0].dest: Path is outside directory: ../invalid-dest0\\E",
"\\QAndroid.bp:12:14: module \"foo\": dists[0].dir: Path is outside directory: ../invalid-dir0\\E",
"\\QAndroid.bp:13:17: module \"foo\": dists[0].suffix: Suffix may not contain a '/' character.\\E",
"\\QAndroid.bp:16:15: module \"foo\": dists[1].dest: Path is outside directory: ../invalid-dest1\\E",
"\\QAndroid.bp:17:14: module \"foo\": dists[1].dir: Path is outside directory: ../invalid-dir1\\E",
"\\QAndroid.bp:18:17: module \"foo\": dists[1].suffix: Suffix may not contain a '/' character.\\E",
}
prepareForModuleTests.
ExtendWithErrorHandler(FixtureExpectsAllErrorsToMatchAPattern(expectedErrs)).
RunTestWithBp(t, bp)
}
func TestInstall(t *testing.T) {
if runtime.GOOS != "linux" {
t.Skip("requires linux")
}
bp := `
deps {
name: "foo",
deps: ["bar"],
}
deps {
name: "bar",
deps: ["baz", "qux"],
}
deps {
name: "baz",
deps: ["qux"],
}
deps {
name: "qux",
}
`
result := GroupFixturePreparers(
prepareForModuleTests,
PrepareForTestWithArchMutator,
).RunTestWithBp(t, bp)
module := func(name string, host bool) TestingModule {
variant := "android_common"
if host {
variant = result.Config.BuildOSCommonTarget.String()
}
return result.ModuleForTests(name, variant)
}
outputRule := func(name string) TestingBuildParams { return module(name, false).Output(name) }
installRule := func(name string) TestingBuildParams {
return module(name, false).Output(filepath.Join("out/soong/target/product/test_device/system", name))
}
symlinkRule := func(name string) TestingBuildParams {
return module(name, false).Output(filepath.Join("out/soong/target/product/test_device/system/symlinks", name))
}
hostOutputRule := func(name string) TestingBuildParams { return module(name, true).Output(name) }
hostInstallRule := func(name string) TestingBuildParams {
return module(name, true).Output(filepath.Join("out/soong/host/linux-x86", name))
}
hostSymlinkRule := func(name string) TestingBuildParams {
return module(name, true).Output(filepath.Join("out/soong/host/linux-x86/symlinks", name))
}
assertInputs := func(params TestingBuildParams, inputs ...Path) {
t.Helper()
AssertArrayString(t, "expected inputs", Paths(inputs).Strings(),
append(PathsIfNonNil(params.Input), params.Inputs...).Strings())
}
assertImplicits := func(params TestingBuildParams, implicits ...Path) {
t.Helper()
AssertArrayString(t, "expected implicit dependencies", Paths(implicits).Strings(),
append(PathsIfNonNil(params.Implicit), params.Implicits...).Strings())
}
assertOrderOnlys := func(params TestingBuildParams, orderonlys ...Path) {
t.Helper()
AssertArrayString(t, "expected orderonly dependencies", Paths(orderonlys).Strings(),
params.OrderOnly.Strings())
}
// Check host install rule dependencies
assertInputs(hostInstallRule("foo"), hostOutputRule("foo").Output)
assertImplicits(hostInstallRule("foo"),
hostInstallRule("bar").Output,
hostSymlinkRule("bar").Output,
hostInstallRule("baz").Output,
hostSymlinkRule("baz").Output,
hostInstallRule("qux").Output,
hostSymlinkRule("qux").Output,
)
assertOrderOnlys(hostInstallRule("foo"))
// Check host symlink rule dependencies. Host symlinks must use a normal dependency, not an
// order-only dependency, so that the tool gets updated when the symlink is depended on.
assertInputs(hostSymlinkRule("foo"), hostInstallRule("foo").Output)
assertImplicits(hostSymlinkRule("foo"))
assertOrderOnlys(hostSymlinkRule("foo"))
// Check device install rule dependencies
assertInputs(installRule("foo"), outputRule("foo").Output)
assertImplicits(installRule("foo"))
assertOrderOnlys(installRule("foo"),
installRule("bar").Output,
symlinkRule("bar").Output,
installRule("baz").Output,
symlinkRule("baz").Output,
installRule("qux").Output,
symlinkRule("qux").Output,
)
// Check device symlink rule dependencies. Device symlinks could use an order-only dependency,
// but the current implementation uses a normal dependency.
assertInputs(symlinkRule("foo"), installRule("foo").Output)
assertImplicits(symlinkRule("foo"))
assertOrderOnlys(symlinkRule("foo"))
}
func TestInstallKatiEnabled(t *testing.T) {
if runtime.GOOS != "linux" {
t.Skip("requires linux")
}
bp := `
deps {
name: "foo",
deps: ["bar"],
}
deps {
name: "bar",
deps: ["baz", "qux"],
}
deps {
name: "baz",
deps: ["qux"],
}
deps {
name: "qux",
}
`
result := GroupFixturePreparers(
prepareForModuleTests,
PrepareForTestWithArchMutator,
FixtureModifyConfig(SetKatiEnabledForTests),
PrepareForTestWithMakevars,
).RunTestWithBp(t, bp)
rules := result.InstallMakeRulesForTesting(t)
module := func(name string, host bool) TestingModule {
variant := "android_common"
if host {
variant = result.Config.BuildOSCommonTarget.String()
}
return result.ModuleForTests(name, variant)
}
outputRule := func(name string) TestingBuildParams { return module(name, false).Output(name) }
ruleForOutput := func(output string) InstallMakeRule {
for _, rule := range rules {
if rule.Target == output {
return rule
}
}
t.Fatalf("no make install rule for %s", output)
return InstallMakeRule{}
}
installRule := func(name string) InstallMakeRule {
return ruleForOutput(filepath.Join("out/target/product/test_device/system", name))
}
symlinkRule := func(name string) InstallMakeRule {
return ruleForOutput(filepath.Join("out/target/product/test_device/system/symlinks", name))
}
hostOutputRule := func(name string) TestingBuildParams { return module(name, true).Output(name) }
hostInstallRule := func(name string) InstallMakeRule {
return ruleForOutput(filepath.Join("out/host/linux-x86", name))
}
hostSymlinkRule := func(name string) InstallMakeRule {
return ruleForOutput(filepath.Join("out/host/linux-x86/symlinks", name))
}
assertDeps := func(rule InstallMakeRule, deps ...string) {
t.Helper()
AssertArrayString(t, "expected inputs", deps, rule.Deps)
}
assertOrderOnlys := func(rule InstallMakeRule, orderonlys ...string) {
t.Helper()
AssertArrayString(t, "expected orderonly dependencies", orderonlys, rule.OrderOnlyDeps)
}
// Check host install rule dependencies
assertDeps(hostInstallRule("foo"),
hostOutputRule("foo").Output.String(),
hostInstallRule("bar").Target,
hostSymlinkRule("bar").Target,
hostInstallRule("baz").Target,
hostSymlinkRule("baz").Target,
hostInstallRule("qux").Target,
hostSymlinkRule("qux").Target,
)
assertOrderOnlys(hostInstallRule("foo"))
// Check host symlink rule dependencies. Host symlinks must use a normal dependency, not an
// order-only dependency, so that the tool gets updated when the symlink is depended on.
assertDeps(hostSymlinkRule("foo"), hostInstallRule("foo").Target)
assertOrderOnlys(hostSymlinkRule("foo"))
// Check device install rule dependencies
assertDeps(installRule("foo"), outputRule("foo").Output.String())
assertOrderOnlys(installRule("foo"),
installRule("bar").Target,
symlinkRule("bar").Target,
installRule("baz").Target,
symlinkRule("baz").Target,
installRule("qux").Target,
symlinkRule("qux").Target,
)
// Check device symlink rule dependencies. Device symlinks could use an order-only dependency,
// but the current implementation uses a normal dependency.
assertDeps(symlinkRule("foo"), installRule("foo").Target)
assertOrderOnlys(symlinkRule("foo"))
}
type PropsTestModuleEmbedded struct {
Embedded_prop *string
}
type StructInSlice struct {
G string
H bool
I []string
}
type propsTestModule struct {
ModuleBase
DefaultableModuleBase
props struct {
A string `android:"arch_variant"`
B *bool
C []string
}
otherProps struct {
PropsTestModuleEmbedded
D *int64
Nested struct {
E *string
}
F *string `blueprint:"mutated"`
Slice_of_struct []StructInSlice
}
}
func propsTestModuleFactory() Module {
module := &propsTestModule{}
module.AddProperties(&module.props, &module.otherProps)
InitAndroidArchModule(module, HostAndDeviceSupported, MultilibBoth)
InitDefaultableModule(module)
return module
}
type propsTestModuleDefaults struct {
ModuleBase
DefaultsModuleBase
}
func propsTestModuleDefaultsFactory() Module {
defaults := &propsTestModuleDefaults{}
module := propsTestModule{}
defaults.AddProperties(&module.props, &module.otherProps)
InitDefaultsModule(defaults)
return defaults
}
func (p *propsTestModule) GenerateAndroidBuildActions(ctx ModuleContext) {
str := "abc"
p.otherProps.F = &str
}
func TestUsedProperties(t *testing.T) {
testCases := []struct {
desc string
bp string
expectedProps []propInfo
}{
{
desc: "only name",
bp: `test {
name: "foo",
}
`,
expectedProps: []propInfo{
propInfo{Name: "Name", Type: "string", Value: "foo"},
},
},
{
desc: "some props",
bp: `test {
name: "foo",
a: "abc",
b: true,
d: 123,
}
`,
expectedProps: []propInfo{
propInfo{Name: "A", Type: "string", Value: "abc"},
propInfo{Name: "B", Type: "bool", Value: "true"},
propInfo{Name: "D", Type: "int64", Value: "123"},
propInfo{Name: "Name", Type: "string", Value: "foo"},
},
},
{
desc: "unused non-pointer prop",
bp: `test {
name: "foo",
b: true,
d: 123,
}
`,
expectedProps: []propInfo{
// for non-pointer cannot distinguish between unused and intentionally set to empty
propInfo{Name: "A", Type: "string", Value: ""},
propInfo{Name: "B", Type: "bool", Value: "true"},
propInfo{Name: "D", Type: "int64", Value: "123"},
propInfo{Name: "Name", Type: "string", Value: "foo"},
},
},
{
desc: "nested props",
bp: `test {
name: "foo",
nested: {
e: "abc",
}
}
`,
expectedProps: []propInfo{
propInfo{Name: "Name", Type: "string", Value: "foo"},
propInfo{Name: "Nested.E", Type: "string", Value: "abc"},
},
},
{
desc: "arch props",
bp: `test {
name: "foo",
arch: {
x86_64: {
a: "abc",
},
}
}
`,
expectedProps: []propInfo{
propInfo{Name: "Arch.X86_64.A", Type: "string", Value: "abc"},
propInfo{Name: "Name", Type: "string", Value: "foo"},
},
},
{
desc: "embedded props",
bp: `test {
name: "foo",
embedded_prop: "a",
}
`,
expectedProps: []propInfo{
propInfo{Name: "Embedded_prop", Type: "string", Value: "a"},
propInfo{Name: "Name", Type: "string", Value: "foo"},
},
},
{
desc: "struct slice",
bp: `test {
name: "foo",
slice_of_struct: [
{
g: "abc",
h: false,
i: ["baz"],
},
{
g: "def",
h: true,
i: [],
},
]
}
`,
expectedProps: []propInfo{
propInfo{Name: "Name", Type: "string", Value: "foo"},
propInfo{Name: "Slice_of_struct", Type: "struct slice", Values: []string{
`android.StructInSlice{G: abc, H: false, I: [baz]}`,
`android.StructInSlice{G: def, H: true, I: []}`,
}},
},
},
{
desc: "defaults",
bp: `
test_defaults {
name: "foo_defaults",
a: "a",
b: true,
c: ["default_c"],
embedded_prop:"a",
arch: {
x86_64: {
a: "x86_64 a",
},
},
}
test {
name: "foo",
defaults: ["foo_defaults"],
c: ["c"],
nested: {
e: "nested e",
},
target: {
linux: {
a: "a",
},
},
}
`,
expectedProps: []propInfo{
propInfo{Name: "A", Type: "string", Value: "a"},
propInfo{Name: "Arch.X86_64.A", Type: "string", Value: "x86_64 a"},
propInfo{Name: "B", Type: "bool", Value: "true"},
propInfo{Name: "C", Type: "string slice", Values: []string{"default_c", "c"}},
propInfo{Name: "Defaults", Type: "string slice", Values: []string{"foo_defaults"}},
propInfo{Name: "Embedded_prop", Type: "string", Value: "a"},
propInfo{Name: "Name", Type: "string", Value: "foo"},
propInfo{Name: "Nested.E", Type: "string", Value: "nested e"},
propInfo{Name: "Target.Linux.A", Type: "string", Value: "a"},
},
},
}
for _, tc := range testCases {
t.Run(tc.desc, func(t *testing.T) {
result := GroupFixturePreparers(
PrepareForTestWithAllowMissingDependencies,
PrepareForTestWithDefaults,
FixtureRegisterWithContext(func(ctx RegistrationContext) {
ctx.RegisterModuleType("test", propsTestModuleFactory)
ctx.RegisterModuleType("test_defaults", propsTestModuleDefaultsFactory)
}),
FixtureWithRootAndroidBp(tc.bp),
).RunTest(t)
foo := result.ModuleForTests("foo", "").Module().base()
AssertDeepEquals(t, "foo ", tc.expectedProps, foo.propertiesWithValues())
})
}
}
func TestSortedUniqueNamedPaths(t *testing.T) {
type np struct {
path, name string
}
makePaths := func(l []np) NamedPaths {
result := make(NamedPaths, 0, len(l))
for _, p := range l {
result = append(result, NamedPath{PathForTesting(p.path), p.name})
}
return result
}
tests := []struct {
name string
in []np
expectedOut []np
}{
{
name: "empty",
in: []np{},
expectedOut: []np{},
},
{
name: "all_same",
in: []np{
{"a.txt", "A"},
{"a.txt", "A"},
{"a.txt", "A"},
{"a.txt", "A"},
{"a.txt", "A"},
},
expectedOut: []np{
{"a.txt", "A"},
},
},
{
name: "same_path_different_names",
in: []np{
{"a.txt", "C"},
{"a.txt", "A"},
{"a.txt", "D"},
{"a.txt", "B"},
{"a.txt", "E"},
},
expectedOut: []np{
{"a.txt", "A"},
{"a.txt", "B"},
{"a.txt", "C"},
{"a.txt", "D"},
{"a.txt", "E"},
},
},
{
name: "different_paths_same_name",
in: []np{
{"b/b.txt", "A"},
{"a/a.txt", "A"},
{"a/txt", "A"},
{"b", "A"},
{"a/b/d", "A"},
},
expectedOut: []np{
{"a/a.txt", "A"},
{"a/b/d", "A"},
{"a/txt", "A"},
{"b/b.txt", "A"},
{"b", "A"},
},
},
{
name: "all_different",
in: []np{
{"b/b.txt", "A"},
{"a/a.txt", "B"},
{"a/txt", "D"},
{"b", "C"},
{"a/b/d", "E"},
},
expectedOut: []np{
{"a/a.txt", "B"},
{"a/b/d", "E"},
{"a/txt", "D"},
{"b/b.txt", "A"},
{"b", "C"},
},
},
{
name: "some_different",
in: []np{
{"b/b.txt", "A"},
{"a/a.txt", "B"},
{"a/txt", "D"},
{"a/b/d", "E"},
{"b", "C"},
{"a/a.txt", "B"},
{"a/b/d", "E"},
},
expectedOut: []np{
{"a/a.txt", "B"},
{"a/b/d", "E"},
{"a/txt", "D"},
{"b/b.txt", "A"},
{"b", "C"},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
actual := SortedUniqueNamedPaths(makePaths(tt.in))
expected := makePaths(tt.expectedOut)
t.Logf("actual: %v", actual)
t.Logf("expected: %v", expected)
AssertDeepEquals(t, "SortedUniqueNamedPaths ", expected, actual)
})
}
}
func TestSetAndroidMkEntriesWithTestOptions(t *testing.T) {
tests := []struct {
name string
testOptions CommonTestOptions
expected map[string][]string
}{
{
name: "empty",
testOptions: CommonTestOptions{},
expected: map[string][]string{},
},
{
name: "is unit test",
testOptions: CommonTestOptions{
Unit_test: boolPtr(true),
},
expected: map[string][]string{
"LOCAL_IS_UNIT_TEST": []string{"true"},
},
},
{
name: "is not unit test",
testOptions: CommonTestOptions{
Unit_test: boolPtr(false),
},
expected: map[string][]string{},
},
{
name: "empty tag",
testOptions: CommonTestOptions{
Tags: []string{},
},
expected: map[string][]string{},
},
{
name: "single tag",
testOptions: CommonTestOptions{
Tags: []string{"tag1"},
},
expected: map[string][]string{
"LOCAL_TEST_OPTIONS_TAGS": []string{"tag1"},
},
},
{
name: "multiple tag",
testOptions: CommonTestOptions{
Tags: []string{"tag1", "tag2", "tag3"},
},
expected: map[string][]string{
"LOCAL_TEST_OPTIONS_TAGS": []string{"tag1", "tag2", "tag3"},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
actualEntries := AndroidMkEntries{
EntryMap: map[string][]string{},
}
tt.testOptions.SetAndroidMkEntries(&actualEntries)
actual := actualEntries.EntryMap
t.Logf("actual: %v", actual)
t.Logf("expected: %v", tt.expected)
AssertDeepEquals(t, "TestProcessCommonTestOptions ", tt.expected, actual)
})
}
}
type fakeBlueprintModule struct{}
func (fakeBlueprintModule) Name() string { return "foo" }
func (fakeBlueprintModule) GenerateBuildActions(blueprint.ModuleContext) {}
type sourceProducerTestModule struct {
fakeBlueprintModule
source Path
}
func (s sourceProducerTestModule) Srcs() Paths { return Paths{s.source} }
type outputFileProducerTestModule struct {
fakeBlueprintModule
output map[string]Path
error map[string]error
}
func (o outputFileProducerTestModule) OutputFiles(tag string) (Paths, error) {
return PathsIfNonNil(o.output[tag]), o.error[tag]
}
type pathContextAddMissingDependenciesWrapper struct {
PathContext
missingDeps []string
}
func (p *pathContextAddMissingDependenciesWrapper) AddMissingDependencies(deps []string) {
p.missingDeps = append(p.missingDeps, deps...)
}
func (p *pathContextAddMissingDependenciesWrapper) OtherModuleName(module blueprint.Module) string {
return module.Name()
}
func TestOutputFileForModule(t *testing.T) {
testcases := []struct {
name string
module blueprint.Module
tag string
env map[string]string
config func(*config)
expected string
missingDeps []string
}{
{
name: "SourceFileProducer",
module: &sourceProducerTestModule{source: PathForTesting("foo.txt")},
expected: "foo.txt",
},
{
name: "OutputFileProducer",
module: &outputFileProducerTestModule{output: map[string]Path{"": PathForTesting("foo.txt")}},
expected: "foo.txt",
},
{
name: "OutputFileProducer_tag",
module: &outputFileProducerTestModule{output: map[string]Path{"foo": PathForTesting("foo.txt")}},
tag: "foo",
expected: "foo.txt",
},
{
name: "OutputFileProducer_AllowMissingDependencies",
config: func(config *config) {
config.TestProductVariables.Allow_missing_dependencies = boolPtr(true)
},
module: &outputFileProducerTestModule{},
missingDeps: []string{"foo"},
expected: "missing_output_file/foo",
},
}
for _, tt := range testcases {
config := TestConfig(buildDir, tt.env, "", nil)
if tt.config != nil {
tt.config(config.config)
}
ctx := &pathContextAddMissingDependenciesWrapper{
PathContext: PathContextForTesting(config),
}
got := OutputFileForModule(ctx, tt.module, tt.tag)
AssertPathRelativeToTopEquals(t, "expected source path", tt.expected, got)
AssertArrayString(t, "expected missing deps", tt.missingDeps, ctx.missingDeps)
}
}