021bf3d973
Previously, I had changed some loadhook-appended property structs
to use selects instead of the "target" property struct. This seems
to not be exactly equivalent because "target" properties are merged
with the regular properties later, at the time the arch mutator runs.
With this reapplication, leave those target property structs alone
to avoid breakages, but I'll have to look into what the issue is
with them later.
This reverts commit ed5276f082.
Ignore-AOSP-First: This cl needs to be in a topic with internal-only projects, will cherrypick to aosp after.
Bug: 323382414
Test: m nothing --no-skip-soong-tests
Change-Id: If355d24506e3f117d27b21442a6c02bca3402dc7
761 lines
20 KiB
Go
761 lines
20 KiB
Go
// Copyright 2019 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 (
|
|
"reflect"
|
|
"runtime"
|
|
"testing"
|
|
|
|
"github.com/google/blueprint/proptools"
|
|
)
|
|
|
|
type Named struct {
|
|
A *string `android:"arch_variant"`
|
|
B *string
|
|
}
|
|
|
|
type NamedAllFiltered struct {
|
|
A *string
|
|
}
|
|
|
|
type NamedNoneFiltered struct {
|
|
A *string `android:"arch_variant"`
|
|
}
|
|
|
|
func TestFilterArchStruct(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
in interface{}
|
|
out interface{}
|
|
filtered bool
|
|
}{
|
|
// Property tests
|
|
{
|
|
name: "basic",
|
|
in: &struct {
|
|
A *string `android:"arch_variant"`
|
|
B *string
|
|
}{},
|
|
out: &struct {
|
|
A *string
|
|
}{},
|
|
filtered: true,
|
|
},
|
|
{
|
|
name: "tags",
|
|
in: &struct {
|
|
A *string `android:"arch_variant"`
|
|
B *string `android:"arch_variant,path"`
|
|
C *string `android:"arch_variant,path,variant_prepend"`
|
|
D *string `android:"path,variant_prepend,arch_variant"`
|
|
E *string `android:"path"`
|
|
F *string
|
|
}{},
|
|
out: &struct {
|
|
A *string
|
|
B *string
|
|
C *string
|
|
D *string
|
|
}{},
|
|
filtered: true,
|
|
},
|
|
{
|
|
name: "all filtered",
|
|
in: &struct {
|
|
A *string
|
|
}{},
|
|
out: nil,
|
|
filtered: true,
|
|
},
|
|
{
|
|
name: "none filtered",
|
|
in: &struct {
|
|
A *string `android:"arch_variant"`
|
|
}{},
|
|
out: &struct {
|
|
A *string `android:"arch_variant"`
|
|
}{},
|
|
filtered: false,
|
|
},
|
|
|
|
// Sub-struct tests
|
|
{
|
|
name: "substruct",
|
|
in: &struct {
|
|
A struct {
|
|
A *string `android:"arch_variant"`
|
|
B *string
|
|
} `android:"arch_variant"`
|
|
}{},
|
|
out: &struct {
|
|
A struct {
|
|
A *string
|
|
}
|
|
}{},
|
|
filtered: true,
|
|
},
|
|
{
|
|
name: "substruct all filtered",
|
|
in: &struct {
|
|
A struct {
|
|
A *string
|
|
} `android:"arch_variant"`
|
|
}{},
|
|
out: nil,
|
|
filtered: true,
|
|
},
|
|
{
|
|
name: "substruct none filtered",
|
|
in: &struct {
|
|
A struct {
|
|
A *string `android:"arch_variant"`
|
|
} `android:"arch_variant"`
|
|
}{},
|
|
out: &struct {
|
|
A struct {
|
|
A *string `android:"arch_variant"`
|
|
} `android:"arch_variant"`
|
|
}{},
|
|
filtered: false,
|
|
},
|
|
|
|
// Named sub-struct tests
|
|
{
|
|
name: "named substruct",
|
|
in: &struct {
|
|
A Named `android:"arch_variant"`
|
|
}{},
|
|
out: &struct {
|
|
A struct {
|
|
A *string
|
|
}
|
|
}{},
|
|
filtered: true,
|
|
},
|
|
{
|
|
name: "substruct all filtered",
|
|
in: &struct {
|
|
A NamedAllFiltered `android:"arch_variant"`
|
|
}{},
|
|
out: nil,
|
|
filtered: true,
|
|
},
|
|
{
|
|
name: "substruct none filtered",
|
|
in: &struct {
|
|
A NamedNoneFiltered `android:"arch_variant"`
|
|
}{},
|
|
out: &struct {
|
|
A NamedNoneFiltered `android:"arch_variant"`
|
|
}{},
|
|
filtered: false,
|
|
},
|
|
|
|
// Pointer to sub-struct tests
|
|
{
|
|
name: "pointer substruct",
|
|
in: &struct {
|
|
A *struct {
|
|
A *string `android:"arch_variant"`
|
|
B *string
|
|
} `android:"arch_variant"`
|
|
}{},
|
|
out: &struct {
|
|
A *struct {
|
|
A *string
|
|
}
|
|
}{},
|
|
filtered: true,
|
|
},
|
|
{
|
|
name: "pointer substruct all filtered",
|
|
in: &struct {
|
|
A *struct {
|
|
A *string
|
|
} `android:"arch_variant"`
|
|
}{},
|
|
out: nil,
|
|
filtered: true,
|
|
},
|
|
{
|
|
name: "pointer substruct none filtered",
|
|
in: &struct {
|
|
A *struct {
|
|
A *string `android:"arch_variant"`
|
|
} `android:"arch_variant"`
|
|
}{},
|
|
out: &struct {
|
|
A *struct {
|
|
A *string `android:"arch_variant"`
|
|
} `android:"arch_variant"`
|
|
}{},
|
|
filtered: false,
|
|
},
|
|
|
|
// Pointer to named sub-struct tests
|
|
{
|
|
name: "pointer named substruct",
|
|
in: &struct {
|
|
A *Named `android:"arch_variant"`
|
|
}{},
|
|
out: &struct {
|
|
A *struct {
|
|
A *string
|
|
}
|
|
}{},
|
|
filtered: true,
|
|
},
|
|
{
|
|
name: "pointer substruct all filtered",
|
|
in: &struct {
|
|
A *NamedAllFiltered `android:"arch_variant"`
|
|
}{},
|
|
out: nil,
|
|
filtered: true,
|
|
},
|
|
{
|
|
name: "pointer substruct none filtered",
|
|
in: &struct {
|
|
A *NamedNoneFiltered `android:"arch_variant"`
|
|
}{},
|
|
out: &struct {
|
|
A *NamedNoneFiltered `android:"arch_variant"`
|
|
}{},
|
|
filtered: false,
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
out, filtered := proptools.FilterPropertyStruct(reflect.TypeOf(test.in), filterArchStruct)
|
|
if filtered != test.filtered {
|
|
t.Errorf("expected filtered %v, got %v", test.filtered, filtered)
|
|
}
|
|
expected := reflect.TypeOf(test.out)
|
|
if out != expected {
|
|
t.Errorf("expected type %v, got %v", expected, out)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
type archTestModule struct {
|
|
ModuleBase
|
|
props struct {
|
|
Deps []string
|
|
}
|
|
}
|
|
|
|
func (m *archTestMultiTargetsModule) GenerateAndroidBuildActions(ctx ModuleContext) {
|
|
}
|
|
|
|
func (m *archTestMultiTargetsModule) DepsMutator(ctx BottomUpMutatorContext) {
|
|
ctx.AddDependency(ctx.Module(), nil, m.props.Deps...)
|
|
}
|
|
|
|
func archTestMultiTargetsModuleFactory() Module {
|
|
m := &archTestMultiTargetsModule{}
|
|
m.AddProperties(&m.props)
|
|
InitAndroidMultiTargetsArchModule(m, HostAndDeviceSupported, MultilibCommon)
|
|
return m
|
|
}
|
|
|
|
type archTestMultiTargetsModule struct {
|
|
ModuleBase
|
|
props struct {
|
|
Deps []string
|
|
}
|
|
}
|
|
|
|
func (m *archTestModule) GenerateAndroidBuildActions(ctx ModuleContext) {
|
|
}
|
|
|
|
func (m *archTestModule) DepsMutator(ctx BottomUpMutatorContext) {
|
|
ctx.AddDependency(ctx.Module(), nil, m.props.Deps...)
|
|
}
|
|
|
|
func archTestModuleFactory() Module {
|
|
m := &archTestModule{}
|
|
m.AddProperties(&m.props)
|
|
InitAndroidArchModule(m, HostAndDeviceSupported, MultilibBoth)
|
|
return m
|
|
}
|
|
|
|
var prepareForArchTest = GroupFixturePreparers(
|
|
PrepareForTestWithArchMutator,
|
|
FixtureRegisterWithContext(func(ctx RegistrationContext) {
|
|
ctx.RegisterModuleType("module", archTestModuleFactory)
|
|
ctx.RegisterModuleType("multi_targets_module", archTestMultiTargetsModuleFactory)
|
|
}),
|
|
)
|
|
|
|
func TestArchMutator(t *testing.T) {
|
|
var buildOSVariants []string
|
|
var buildOS64Variants []string
|
|
var buildOS32Variants []string
|
|
var buildOSCommonVariant string
|
|
|
|
switch runtime.GOOS {
|
|
case "linux":
|
|
buildOSVariants = []string{"linux_glibc_x86_64", "linux_glibc_x86"}
|
|
buildOS64Variants = []string{"linux_glibc_x86_64"}
|
|
buildOS32Variants = []string{"linux_glibc_x86"}
|
|
buildOSCommonVariant = "linux_glibc_common"
|
|
case "darwin":
|
|
buildOSVariants = []string{"darwin_x86_64"}
|
|
buildOS64Variants = []string{"darwin_x86_64"}
|
|
buildOS32Variants = nil
|
|
buildOSCommonVariant = "darwin_common"
|
|
}
|
|
|
|
bp := `
|
|
module {
|
|
name: "foo",
|
|
}
|
|
|
|
module {
|
|
name: "bar",
|
|
host_supported: true,
|
|
}
|
|
|
|
module {
|
|
name: "baz",
|
|
device_supported: false,
|
|
}
|
|
|
|
module {
|
|
name: "qux",
|
|
host_supported: true,
|
|
compile_multilib: "32",
|
|
}
|
|
|
|
module {
|
|
name: "first",
|
|
host_supported: true,
|
|
compile_multilib: "first",
|
|
}
|
|
|
|
multi_targets_module {
|
|
name: "multi_targets",
|
|
host_supported: true,
|
|
}
|
|
`
|
|
|
|
testCases := []struct {
|
|
name string
|
|
preparer FixturePreparer
|
|
fooVariants []string
|
|
barVariants []string
|
|
bazVariants []string
|
|
quxVariants []string
|
|
firstVariants []string
|
|
|
|
multiTargetVariants []string
|
|
multiTargetVariantsMap map[string][]string
|
|
|
|
goOS string
|
|
}{
|
|
{
|
|
name: "normal",
|
|
preparer: nil,
|
|
fooVariants: []string{"android_arm64_armv8-a", "android_arm_armv7-a-neon"},
|
|
barVariants: append(buildOSVariants, "android_arm64_armv8-a", "android_arm_armv7-a-neon"),
|
|
bazVariants: nil,
|
|
quxVariants: append(buildOS32Variants, "android_arm_armv7-a-neon"),
|
|
firstVariants: append(buildOS64Variants, "android_arm64_armv8-a"),
|
|
multiTargetVariants: []string{buildOSCommonVariant, "android_common"},
|
|
multiTargetVariantsMap: map[string][]string{
|
|
buildOSCommonVariant: buildOS64Variants,
|
|
"android_common": {"android_arm64_armv8-a"},
|
|
}},
|
|
{
|
|
name: "host-only",
|
|
preparer: FixtureModifyConfig(func(config Config) {
|
|
config.BuildOSTarget = Target{}
|
|
config.BuildOSCommonTarget = Target{}
|
|
config.Targets[Android] = nil
|
|
}),
|
|
fooVariants: nil,
|
|
barVariants: buildOSVariants,
|
|
bazVariants: nil,
|
|
quxVariants: buildOS32Variants,
|
|
firstVariants: buildOS64Variants,
|
|
multiTargetVariants: []string{buildOSCommonVariant},
|
|
multiTargetVariantsMap: map[string][]string{
|
|
buildOSCommonVariant: buildOS64Variants,
|
|
},
|
|
},
|
|
{
|
|
name: "same arch host and host cross",
|
|
preparer: FixtureModifyConfig(func(config Config) {
|
|
ModifyTestConfigForMusl(config)
|
|
modifyTestConfigForMuslArm64HostCross(config)
|
|
}),
|
|
fooVariants: []string{"android_arm64_armv8-a", "android_arm_armv7-a-neon"},
|
|
barVariants: []string{"linux_musl_x86_64", "linux_musl_arm64", "linux_musl_x86", "android_arm64_armv8-a", "android_arm_armv7-a-neon"},
|
|
bazVariants: nil,
|
|
quxVariants: []string{"linux_musl_x86", "android_arm_armv7-a-neon"},
|
|
firstVariants: []string{"linux_musl_x86_64", "linux_musl_arm64", "android_arm64_armv8-a"},
|
|
multiTargetVariants: []string{"linux_musl_common", "android_common"},
|
|
multiTargetVariantsMap: map[string][]string{
|
|
"linux_musl_common": {"linux_musl_x86_64"},
|
|
"android_common": {"android_arm64_armv8-a"},
|
|
},
|
|
goOS: "linux",
|
|
},
|
|
}
|
|
|
|
enabledVariants := func(ctx *TestContext, name string) []string {
|
|
var ret []string
|
|
variants := ctx.ModuleVariantsForTests(name)
|
|
for _, variant := range variants {
|
|
m := ctx.ModuleForTests(name, variant)
|
|
if m.Module().Enabled(PanickingConfigAndErrorContext(ctx)) {
|
|
ret = append(ret, variant)
|
|
}
|
|
}
|
|
return ret
|
|
}
|
|
|
|
moduleMultiTargets := func(ctx *TestContext, name string, variant string) []string {
|
|
var ret []string
|
|
targets := ctx.ModuleForTests(name, variant).Module().MultiTargets()
|
|
for _, t := range targets {
|
|
ret = append(ret, t.String())
|
|
}
|
|
return ret
|
|
}
|
|
|
|
for _, tt := range testCases {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
if tt.goOS != runtime.GOOS {
|
|
t.Skipf("requries runtime.GOOS %s", tt.goOS)
|
|
}
|
|
|
|
result := GroupFixturePreparers(
|
|
prepareForArchTest,
|
|
// Test specific preparer
|
|
OptionalFixturePreparer(tt.preparer),
|
|
FixtureWithRootAndroidBp(bp),
|
|
).RunTest(t)
|
|
ctx := result.TestContext
|
|
|
|
if g, w := enabledVariants(ctx, "foo"), tt.fooVariants; !reflect.DeepEqual(w, g) {
|
|
t.Errorf("want foo variants:\n%q\ngot:\n%q\n", w, g)
|
|
}
|
|
|
|
if g, w := enabledVariants(ctx, "bar"), tt.barVariants; !reflect.DeepEqual(w, g) {
|
|
t.Errorf("want bar variants:\n%q\ngot:\n%q\n", w, g)
|
|
}
|
|
|
|
if g, w := enabledVariants(ctx, "baz"), tt.bazVariants; !reflect.DeepEqual(w, g) {
|
|
t.Errorf("want baz variants:\n%q\ngot:\n%q\n", w, g)
|
|
}
|
|
|
|
if g, w := enabledVariants(ctx, "qux"), tt.quxVariants; !reflect.DeepEqual(w, g) {
|
|
t.Errorf("want qux variants:\n%q\ngot:\n%q\n", w, g)
|
|
}
|
|
if g, w := enabledVariants(ctx, "first"), tt.firstVariants; !reflect.DeepEqual(w, g) {
|
|
t.Errorf("want first variants:\n%q\ngot:\n%q\n", w, g)
|
|
}
|
|
|
|
if g, w := enabledVariants(ctx, "multi_targets"), tt.multiTargetVariants; !reflect.DeepEqual(w, g) {
|
|
t.Fatalf("want multi_target variants:\n%q\ngot:\n%q\n", w, g)
|
|
}
|
|
|
|
for _, variant := range tt.multiTargetVariants {
|
|
targets := moduleMultiTargets(ctx, "multi_targets", variant)
|
|
if g, w := targets, tt.multiTargetVariantsMap[variant]; !reflect.DeepEqual(w, g) {
|
|
t.Errorf("want ctx.MultiTarget() for %q:\n%q\ngot:\n%q\n", variant, w, g)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestArchMutatorNativeBridge(t *testing.T) {
|
|
bp := `
|
|
// This module is only enabled for x86.
|
|
module {
|
|
name: "foo",
|
|
}
|
|
|
|
// This module is enabled for x86 and arm (via native bridge).
|
|
module {
|
|
name: "bar",
|
|
native_bridge_supported: true,
|
|
}
|
|
|
|
// This module is enabled for arm (native_bridge) only.
|
|
module {
|
|
name: "baz",
|
|
native_bridge_supported: true,
|
|
enabled: false,
|
|
target: {
|
|
native_bridge: {
|
|
enabled: true,
|
|
}
|
|
}
|
|
}
|
|
`
|
|
|
|
testCases := []struct {
|
|
name string
|
|
preparer FixturePreparer
|
|
fooVariants []string
|
|
barVariants []string
|
|
bazVariants []string
|
|
}{
|
|
{
|
|
name: "normal",
|
|
preparer: nil,
|
|
fooVariants: []string{"android_x86_64_silvermont", "android_x86_silvermont"},
|
|
barVariants: []string{"android_x86_64_silvermont", "android_native_bridge_arm64_armv8-a", "android_x86_silvermont", "android_native_bridge_arm_armv7-a-neon"},
|
|
bazVariants: []string{"android_native_bridge_arm64_armv8-a", "android_native_bridge_arm_armv7-a-neon"},
|
|
},
|
|
}
|
|
|
|
enabledVariants := func(ctx *TestContext, name string) []string {
|
|
var ret []string
|
|
variants := ctx.ModuleVariantsForTests(name)
|
|
for _, variant := range variants {
|
|
m := ctx.ModuleForTests(name, variant)
|
|
if m.Module().Enabled(PanickingConfigAndErrorContext(ctx)) {
|
|
ret = append(ret, variant)
|
|
}
|
|
}
|
|
return ret
|
|
}
|
|
|
|
for _, tt := range testCases {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
result := GroupFixturePreparers(
|
|
prepareForArchTest,
|
|
// Test specific preparer
|
|
OptionalFixturePreparer(tt.preparer),
|
|
// Prepare for native bridge test
|
|
FixtureModifyConfig(func(config Config) {
|
|
config.Targets[Android] = []Target{
|
|
{Android, Arch{ArchType: X86_64, ArchVariant: "silvermont", Abi: []string{"arm64-v8a"}}, NativeBridgeDisabled, "", "", false},
|
|
{Android, Arch{ArchType: X86, ArchVariant: "silvermont", Abi: []string{"armeabi-v7a"}}, NativeBridgeDisabled, "", "", false},
|
|
{Android, Arch{ArchType: Arm64, ArchVariant: "armv8-a", Abi: []string{"arm64-v8a"}}, NativeBridgeEnabled, "x86_64", "arm64", false},
|
|
{Android, Arch{ArchType: Arm, ArchVariant: "armv7-a-neon", Abi: []string{"armeabi-v7a"}}, NativeBridgeEnabled, "x86", "arm", false},
|
|
}
|
|
}),
|
|
FixtureWithRootAndroidBp(bp),
|
|
).RunTest(t)
|
|
|
|
ctx := result.TestContext
|
|
|
|
if g, w := enabledVariants(ctx, "foo"), tt.fooVariants; !reflect.DeepEqual(w, g) {
|
|
t.Errorf("want foo variants:\n%q\ngot:\n%q\n", w, g)
|
|
}
|
|
|
|
if g, w := enabledVariants(ctx, "bar"), tt.barVariants; !reflect.DeepEqual(w, g) {
|
|
t.Errorf("want bar variants:\n%q\ngot:\n%q\n", w, g)
|
|
}
|
|
|
|
if g, w := enabledVariants(ctx, "baz"), tt.bazVariants; !reflect.DeepEqual(w, g) {
|
|
t.Errorf("want qux variants:\n%q\ngot:\n%q\n", w, g)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
type testArchPropertiesModule struct {
|
|
ModuleBase
|
|
properties struct {
|
|
A []string `android:"arch_variant"`
|
|
}
|
|
}
|
|
|
|
func (testArchPropertiesModule) GenerateAndroidBuildActions(ctx ModuleContext) {}
|
|
|
|
// Module property "a" does not have "variant_prepend" tag.
|
|
// Expected variant property orders are based on this fact.
|
|
func TestArchProperties(t *testing.T) {
|
|
bp := `
|
|
module {
|
|
name: "foo",
|
|
a: ["root"],
|
|
arch: {
|
|
arm: {
|
|
a: ["arm"],
|
|
},
|
|
arm64: {
|
|
a: ["arm64"],
|
|
},
|
|
riscv64: { a: ["riscv64"] },
|
|
x86: { a: ["x86"] },
|
|
x86_64: { a: ["x86_64"] },
|
|
},
|
|
multilib: {
|
|
lib32: { a: ["lib32"] },
|
|
lib64: { a: ["lib64"] },
|
|
},
|
|
target: {
|
|
bionic: { a: ["bionic"] },
|
|
host: { a: ["host"] },
|
|
android: { a: ["android"] },
|
|
glibc: { a: ["glibc"] },
|
|
musl: { a: ["musl"] },
|
|
linux_bionic: { a: ["linux_bionic"] },
|
|
linux: { a: ["linux"] },
|
|
host_linux: { a: ["host_linux"] },
|
|
linux_glibc: { a: ["linux_glibc"] },
|
|
linux_musl: { a: ["linux_musl"] },
|
|
windows: { a: ["windows"], enabled: true },
|
|
darwin: { a: ["darwin"] },
|
|
not_windows: { a: ["not_windows"] },
|
|
android32: { a: ["android32"] },
|
|
android64: { a: ["android64"] },
|
|
android_arm: { a: ["android_arm"] },
|
|
android_arm64: { a: ["android_arm64"] },
|
|
linux_x86: { a: ["linux_x86"] },
|
|
linux_x86_64: { a: ["linux_x86_64"] },
|
|
linux_glibc_x86: { a: ["linux_glibc_x86"] },
|
|
linux_glibc_x86_64: { a: ["linux_glibc_x86_64"] },
|
|
linux_musl_x86: { a: ["linux_musl_x86"] },
|
|
linux_musl_x86_64: { a: ["linux_musl_x86_64"] },
|
|
darwin_x86_64: { a: ["darwin_x86_64"] },
|
|
windows_x86: { a: ["windows_x86"] },
|
|
windows_x86_64: { a: ["windows_x86_64"] },
|
|
},
|
|
}
|
|
`
|
|
|
|
type result struct {
|
|
module string
|
|
variant string
|
|
property []string
|
|
}
|
|
|
|
testCases := []struct {
|
|
name string
|
|
goOS string
|
|
preparer FixturePreparer
|
|
results []result
|
|
}{
|
|
{
|
|
name: "default",
|
|
results: []result{
|
|
{
|
|
module: "foo",
|
|
variant: "android_arm64_armv8-a",
|
|
property: []string{"root", "linux", "bionic", "android", "android64", "arm64", "lib64", "android_arm64"},
|
|
},
|
|
{
|
|
module: "foo",
|
|
variant: "android_arm_armv7-a-neon",
|
|
property: []string{"root", "linux", "bionic", "android", "android64", "arm", "lib32", "android_arm"},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "linux",
|
|
goOS: "linux",
|
|
results: []result{
|
|
{
|
|
module: "foo",
|
|
variant: "linux_glibc_x86_64",
|
|
property: []string{"root", "host", "linux", "host_linux", "glibc", "linux_glibc", "not_windows", "x86_64", "lib64", "linux_x86_64", "linux_glibc_x86_64"},
|
|
},
|
|
{
|
|
module: "foo",
|
|
variant: "linux_glibc_x86",
|
|
property: []string{"root", "host", "linux", "host_linux", "glibc", "linux_glibc", "not_windows", "x86", "lib32", "linux_x86", "linux_glibc_x86"},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "windows",
|
|
goOS: "linux",
|
|
preparer: FixtureModifyConfig(func(config Config) {
|
|
config.Targets[Windows] = []Target{
|
|
{Windows, Arch{ArchType: X86_64}, NativeBridgeDisabled, "", "", true},
|
|
{Windows, Arch{ArchType: X86}, NativeBridgeDisabled, "", "", true},
|
|
}
|
|
}),
|
|
results: []result{
|
|
{
|
|
module: "foo",
|
|
variant: "windows_x86_64",
|
|
property: []string{"root", "host", "windows", "x86_64", "lib64", "windows_x86_64"},
|
|
},
|
|
{
|
|
module: "foo",
|
|
variant: "windows_x86",
|
|
property: []string{"root", "host", "windows", "x86", "lib32", "windows_x86"},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "linux_musl",
|
|
goOS: "linux",
|
|
preparer: FixtureModifyConfig(ModifyTestConfigForMusl),
|
|
results: []result{
|
|
{
|
|
module: "foo",
|
|
variant: "linux_musl_x86_64",
|
|
property: []string{"root", "host", "linux", "host_linux", "musl", "linux_musl", "not_windows", "x86_64", "lib64", "linux_x86_64", "linux_musl_x86_64"},
|
|
},
|
|
{
|
|
module: "foo",
|
|
variant: "linux_musl_x86",
|
|
property: []string{"root", "host", "linux", "host_linux", "musl", "linux_musl", "not_windows", "x86", "lib32", "linux_x86", "linux_musl_x86"},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "darwin",
|
|
goOS: "darwin",
|
|
results: []result{
|
|
{
|
|
module: "foo",
|
|
variant: "darwin_x86_64",
|
|
property: []string{"root", "host", "darwin", "not_windows", "x86_64", "lib64", "darwin_x86_64"},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tt := range testCases {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
if tt.goOS != "" && tt.goOS != runtime.GOOS {
|
|
t.Skipf("test requires runtime.GOOS==%s, got %s", tt.goOS, runtime.GOOS)
|
|
}
|
|
result := GroupFixturePreparers(
|
|
PrepareForTestWithArchMutator,
|
|
OptionalFixturePreparer(tt.preparer),
|
|
FixtureRegisterWithContext(func(ctx RegistrationContext) {
|
|
ctx.RegisterModuleType("module", func() Module {
|
|
module := &testArchPropertiesModule{}
|
|
module.AddProperties(&module.properties)
|
|
InitAndroidArchModule(module, HostAndDeviceDefault, MultilibBoth)
|
|
return module
|
|
})
|
|
}),
|
|
).RunTestWithBp(t, bp)
|
|
|
|
for _, want := range tt.results {
|
|
t.Run(want.module+"_"+want.variant, func(t *testing.T) {
|
|
got := result.ModuleForTests(want.module, want.variant).Module().(*testArchPropertiesModule).properties.A
|
|
AssertArrayString(t, "arch mutator property", want.property, got)
|
|
})
|
|
}
|
|
})
|
|
}
|
|
}
|