fe152e302a
with new expected error message that reflects the real unrecognized property Test: TestNonExistentPropertyInSoongConfigModule and CI Bug: 171232169 Change-Id: I5af8e62b12a80c4891d7f3b57bbf4be456b2a798
702 lines
18 KiB
Go
702 lines
18 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 (
|
|
"fmt"
|
|
"path/filepath"
|
|
"testing"
|
|
)
|
|
|
|
type soongConfigTestDefaultsModule struct {
|
|
ModuleBase
|
|
DefaultsModuleBase
|
|
}
|
|
|
|
func soongConfigTestDefaultsModuleFactory() Module {
|
|
m := &soongConfigTestDefaultsModule{}
|
|
m.AddProperties(&soongConfigTestModuleProperties{})
|
|
InitDefaultsModule(m)
|
|
return m
|
|
}
|
|
|
|
type soongConfigTestModule struct {
|
|
ModuleBase
|
|
DefaultableModuleBase
|
|
props soongConfigTestModuleProperties
|
|
outputPath ModuleOutPath
|
|
}
|
|
|
|
type soongConfigTestModuleProperties struct {
|
|
Cflags []string
|
|
}
|
|
|
|
func soongConfigTestModuleFactory() Module {
|
|
m := &soongConfigTestModule{}
|
|
m.AddProperties(&m.props)
|
|
InitAndroidModule(m)
|
|
InitDefaultableModule(m)
|
|
return m
|
|
}
|
|
|
|
func (t *soongConfigTestModule) GenerateAndroidBuildActions(ctx ModuleContext) {
|
|
t.outputPath = PathForModuleOut(ctx, "test")
|
|
}
|
|
|
|
var prepareForSoongConfigTestModule = FixtureRegisterWithContext(func(ctx RegistrationContext) {
|
|
ctx.RegisterModuleType("test_defaults", soongConfigTestDefaultsModuleFactory)
|
|
ctx.RegisterModuleType("test", soongConfigTestModuleFactory)
|
|
})
|
|
|
|
func TestSoongConfigModule(t *testing.T) {
|
|
configBp := `
|
|
soong_config_module_type {
|
|
name: "acme_test",
|
|
module_type: "test",
|
|
config_namespace: "acme",
|
|
variables: ["board", "feature1", "FEATURE3", "unused_string_var"],
|
|
bool_variables: ["feature2", "unused_feature", "always_true"],
|
|
value_variables: ["size", "unused_size"],
|
|
properties: ["cflags", "srcs", "defaults"],
|
|
}
|
|
|
|
soong_config_string_variable {
|
|
name: "board",
|
|
values: ["soc_a", "soc_b", "soc_c", "soc_d"],
|
|
}
|
|
|
|
soong_config_string_variable {
|
|
name: "unused_string_var",
|
|
values: ["a", "b"],
|
|
}
|
|
|
|
soong_config_bool_variable {
|
|
name: "feature1",
|
|
}
|
|
|
|
soong_config_bool_variable {
|
|
name: "FEATURE3",
|
|
}
|
|
`
|
|
|
|
importBp := `
|
|
soong_config_module_type_import {
|
|
from: "SoongConfig.bp",
|
|
module_types: ["acme_test"],
|
|
}
|
|
`
|
|
|
|
bp := `
|
|
test_defaults {
|
|
name: "foo_defaults",
|
|
cflags: ["DEFAULT"],
|
|
}
|
|
|
|
acme_test {
|
|
name: "foo",
|
|
cflags: ["-DGENERIC"],
|
|
defaults: ["foo_defaults"],
|
|
soong_config_variables: {
|
|
board: {
|
|
soc_a: {
|
|
cflags: ["-DSOC_A"],
|
|
},
|
|
soc_b: {
|
|
cflags: ["-DSOC_B"],
|
|
},
|
|
soc_c: {},
|
|
conditions_default: {
|
|
cflags: ["-DSOC_CONDITIONS_DEFAULT"],
|
|
},
|
|
},
|
|
size: {
|
|
cflags: ["-DSIZE=%s"],
|
|
conditions_default: {
|
|
cflags: ["-DSIZE=CONDITIONS_DEFAULT"],
|
|
},
|
|
},
|
|
feature1: {
|
|
conditions_default: {
|
|
cflags: ["-DF1_CONDITIONS_DEFAULT"],
|
|
},
|
|
cflags: ["-DFEATURE1"],
|
|
},
|
|
feature2: {
|
|
cflags: ["-DFEATURE2"],
|
|
conditions_default: {
|
|
cflags: ["-DF2_CONDITIONS_DEFAULT"],
|
|
},
|
|
},
|
|
FEATURE3: {
|
|
cflags: ["-DFEATURE3"],
|
|
},
|
|
},
|
|
}
|
|
|
|
test_defaults {
|
|
name: "foo_defaults_a",
|
|
cflags: ["DEFAULT_A"],
|
|
}
|
|
|
|
test_defaults {
|
|
name: "foo_defaults_b",
|
|
cflags: ["DEFAULT_B"],
|
|
}
|
|
|
|
test_defaults {
|
|
name: "foo_defaults_always_true",
|
|
cflags: ["DEFAULT_ALWAYS_TRUE"],
|
|
}
|
|
|
|
acme_test {
|
|
name: "foo_with_defaults",
|
|
cflags: ["-DGENERIC"],
|
|
defaults: ["foo_defaults"],
|
|
soong_config_variables: {
|
|
board: {
|
|
soc_a: {
|
|
cflags: ["-DSOC_A"],
|
|
defaults: ["foo_defaults_a"],
|
|
},
|
|
soc_b: {
|
|
cflags: ["-DSOC_B"],
|
|
defaults: ["foo_defaults_b"],
|
|
},
|
|
soc_c: {},
|
|
},
|
|
size: {
|
|
cflags: ["-DSIZE=%s"],
|
|
},
|
|
feature1: {
|
|
cflags: ["-DFEATURE1"],
|
|
},
|
|
feature2: {
|
|
cflags: ["-DFEATURE2"],
|
|
},
|
|
FEATURE3: {
|
|
cflags: ["-DFEATURE3"],
|
|
},
|
|
always_true: {
|
|
defaults: ["foo_defaults_always_true"],
|
|
conditions_default: {
|
|
// verify that conditions_default is skipped if the
|
|
// soong config variable is true by specifying a
|
|
// non-existent module in conditions_default
|
|
defaults: ["//nonexistent:defaults"],
|
|
}
|
|
},
|
|
},
|
|
}
|
|
`
|
|
|
|
fixtureForVendorVars := func(vars map[string]map[string]string) FixturePreparer {
|
|
return FixtureModifyProductVariables(func(variables FixtureProductVariables) {
|
|
variables.VendorVars = vars
|
|
})
|
|
}
|
|
|
|
run := func(t *testing.T, bp string, fs MockFS) {
|
|
testCases := []struct {
|
|
name string
|
|
preparer FixturePreparer
|
|
fooExpectedFlags []string
|
|
fooDefaultsExpectedFlags []string
|
|
}{
|
|
{
|
|
name: "withValues",
|
|
preparer: fixtureForVendorVars(map[string]map[string]string{
|
|
"acme": {
|
|
"board": "soc_a",
|
|
"size": "42",
|
|
"feature1": "true",
|
|
"feature2": "false",
|
|
// FEATURE3 unset
|
|
"unused_feature": "true", // unused
|
|
"unused_size": "1", // unused
|
|
"unused_string_var": "a", // unused
|
|
"always_true": "true",
|
|
},
|
|
}),
|
|
fooExpectedFlags: []string{
|
|
"DEFAULT",
|
|
"-DGENERIC",
|
|
"-DF2_CONDITIONS_DEFAULT",
|
|
"-DSIZE=42",
|
|
"-DSOC_A",
|
|
"-DFEATURE1",
|
|
},
|
|
fooDefaultsExpectedFlags: []string{
|
|
"DEFAULT_A",
|
|
"DEFAULT_ALWAYS_TRUE",
|
|
"DEFAULT",
|
|
"-DGENERIC",
|
|
"-DSIZE=42",
|
|
"-DSOC_A",
|
|
"-DFEATURE1",
|
|
},
|
|
},
|
|
{
|
|
name: "empty_prop_for_string_var",
|
|
preparer: fixtureForVendorVars(map[string]map[string]string{
|
|
"acme": {
|
|
"board": "soc_c",
|
|
"always_true": "true",
|
|
}}),
|
|
fooExpectedFlags: []string{
|
|
"DEFAULT",
|
|
"-DGENERIC",
|
|
"-DF2_CONDITIONS_DEFAULT",
|
|
"-DSIZE=CONDITIONS_DEFAULT",
|
|
"-DF1_CONDITIONS_DEFAULT",
|
|
},
|
|
fooDefaultsExpectedFlags: []string{
|
|
"DEFAULT_ALWAYS_TRUE",
|
|
"DEFAULT",
|
|
"-DGENERIC",
|
|
},
|
|
},
|
|
{
|
|
name: "unused_string_var",
|
|
preparer: fixtureForVendorVars(map[string]map[string]string{
|
|
"acme": {
|
|
"board": "soc_d",
|
|
"always_true": "true",
|
|
}}),
|
|
fooExpectedFlags: []string{
|
|
"DEFAULT",
|
|
"-DGENERIC",
|
|
"-DF2_CONDITIONS_DEFAULT",
|
|
"-DSIZE=CONDITIONS_DEFAULT",
|
|
"-DSOC_CONDITIONS_DEFAULT", // foo does not contain a prop "soc_d", so we use the default
|
|
"-DF1_CONDITIONS_DEFAULT",
|
|
},
|
|
fooDefaultsExpectedFlags: []string{
|
|
"DEFAULT_ALWAYS_TRUE",
|
|
"DEFAULT",
|
|
"-DGENERIC",
|
|
},
|
|
},
|
|
|
|
{
|
|
name: "conditions_default",
|
|
preparer: fixtureForVendorVars(map[string]map[string]string{
|
|
"acme": {
|
|
"always_true": "true",
|
|
}}),
|
|
fooExpectedFlags: []string{
|
|
"DEFAULT",
|
|
"-DGENERIC",
|
|
"-DF2_CONDITIONS_DEFAULT",
|
|
"-DSIZE=CONDITIONS_DEFAULT",
|
|
"-DSOC_CONDITIONS_DEFAULT",
|
|
"-DF1_CONDITIONS_DEFAULT",
|
|
},
|
|
fooDefaultsExpectedFlags: []string{
|
|
"DEFAULT_ALWAYS_TRUE",
|
|
"DEFAULT",
|
|
"-DGENERIC",
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
result := GroupFixturePreparers(
|
|
tc.preparer,
|
|
PrepareForTestWithDefaults,
|
|
PrepareForTestWithSoongConfigModuleBuildComponents,
|
|
prepareForSoongConfigTestModule,
|
|
fs.AddToFixture(),
|
|
FixtureWithRootAndroidBp(bp),
|
|
).RunTest(t)
|
|
|
|
foo := result.ModuleForTests("foo", "").Module().(*soongConfigTestModule)
|
|
AssertDeepEquals(t, "foo cflags", tc.fooExpectedFlags, foo.props.Cflags)
|
|
|
|
fooDefaults := result.ModuleForTests("foo_with_defaults", "").Module().(*soongConfigTestModule)
|
|
AssertDeepEquals(t, "foo_with_defaults cflags", tc.fooDefaultsExpectedFlags, fooDefaults.props.Cflags)
|
|
})
|
|
}
|
|
}
|
|
|
|
t.Run("single file", func(t *testing.T) {
|
|
run(t, configBp+bp, nil)
|
|
})
|
|
|
|
t.Run("import", func(t *testing.T) {
|
|
run(t, importBp+bp, map[string][]byte{
|
|
"SoongConfig.bp": []byte(configBp),
|
|
})
|
|
})
|
|
}
|
|
|
|
func TestNonExistentPropertyInSoongConfigModule(t *testing.T) {
|
|
bp := `
|
|
soong_config_module_type {
|
|
name: "acme_test",
|
|
module_type: "test",
|
|
config_namespace: "acme",
|
|
bool_variables: ["feature1"],
|
|
properties: ["made_up_property"],
|
|
}
|
|
|
|
acme_test {
|
|
name: "foo",
|
|
cflags: ["-DGENERIC"],
|
|
soong_config_variables: {
|
|
feature1: {
|
|
made_up_property: true,
|
|
},
|
|
},
|
|
}
|
|
`
|
|
|
|
fixtureForVendorVars := func(vars map[string]map[string]string) FixturePreparer {
|
|
return FixtureModifyProductVariables(func(variables FixtureProductVariables) {
|
|
variables.VendorVars = vars
|
|
})
|
|
}
|
|
|
|
GroupFixturePreparers(
|
|
fixtureForVendorVars(map[string]map[string]string{"acme": {"feature1": "1"}}),
|
|
PrepareForTestWithDefaults,
|
|
PrepareForTestWithSoongConfigModuleBuildComponents,
|
|
prepareForSoongConfigTestModule,
|
|
FixtureWithRootAndroidBp(bp),
|
|
).ExtendWithErrorHandler(FixtureExpectsAllErrorsToMatchAPattern([]string{
|
|
`unrecognized property "soong_config_variables.feature1.made_up_property`,
|
|
})).RunTest(t)
|
|
}
|
|
|
|
func TestDuplicateStringValueInSoongConfigStringVariable(t *testing.T) {
|
|
bp := `
|
|
soong_config_string_variable {
|
|
name: "board",
|
|
values: ["soc_a", "soc_b", "soc_c", "soc_a"],
|
|
}
|
|
|
|
soong_config_module_type {
|
|
name: "acme_test",
|
|
module_type: "test",
|
|
config_namespace: "acme",
|
|
variables: ["board"],
|
|
properties: ["cflags", "srcs", "defaults"],
|
|
}
|
|
`
|
|
|
|
fixtureForVendorVars := func(vars map[string]map[string]string) FixturePreparer {
|
|
return FixtureModifyProductVariables(func(variables FixtureProductVariables) {
|
|
variables.VendorVars = vars
|
|
})
|
|
}
|
|
|
|
GroupFixturePreparers(
|
|
fixtureForVendorVars(map[string]map[string]string{"acme": {"feature1": "1"}}),
|
|
PrepareForTestWithDefaults,
|
|
PrepareForTestWithSoongConfigModuleBuildComponents,
|
|
prepareForSoongConfigTestModule,
|
|
FixtureWithRootAndroidBp(bp),
|
|
).ExtendWithErrorHandler(FixtureExpectsAllErrorsToMatchAPattern([]string{
|
|
// TODO(b/171232169): improve the error message for non-existent properties
|
|
`Android.bp: soong_config_string_variable: values property error: duplicate value: "soc_a"`,
|
|
})).RunTest(t)
|
|
}
|
|
|
|
type soongConfigTestSingletonModule struct {
|
|
SingletonModuleBase
|
|
props soongConfigTestSingletonModuleProperties
|
|
}
|
|
|
|
type soongConfigTestSingletonModuleProperties struct {
|
|
Fragments []struct {
|
|
Apex string
|
|
Module string
|
|
}
|
|
}
|
|
|
|
func soongConfigTestSingletonModuleFactory() SingletonModule {
|
|
m := &soongConfigTestSingletonModule{}
|
|
m.AddProperties(&m.props)
|
|
InitAndroidModule(m)
|
|
return m
|
|
}
|
|
|
|
func (t *soongConfigTestSingletonModule) GenerateAndroidBuildActions(ModuleContext) {}
|
|
|
|
func (t *soongConfigTestSingletonModule) GenerateSingletonBuildActions(SingletonContext) {}
|
|
|
|
var prepareForSoongConfigTestSingletonModule = FixtureRegisterWithContext(func(ctx RegistrationContext) {
|
|
ctx.RegisterSingletonModuleType("test_singleton", soongConfigTestSingletonModuleFactory)
|
|
})
|
|
|
|
func TestSoongConfigModuleSingletonModule(t *testing.T) {
|
|
bp := `
|
|
soong_config_module_type {
|
|
name: "acme_test_singleton",
|
|
module_type: "test_singleton",
|
|
config_namespace: "acme",
|
|
bool_variables: ["coyote"],
|
|
properties: ["fragments"],
|
|
}
|
|
|
|
acme_test_singleton {
|
|
name: "wiley",
|
|
fragments: [
|
|
{
|
|
apex: "com.android.acme",
|
|
module: "road-runner",
|
|
},
|
|
],
|
|
soong_config_variables: {
|
|
coyote: {
|
|
fragments: [
|
|
{
|
|
apex: "com.android.acme",
|
|
module: "wiley",
|
|
},
|
|
],
|
|
},
|
|
},
|
|
}
|
|
`
|
|
|
|
for _, test := range []struct {
|
|
coyote bool
|
|
expectedFragments string
|
|
}{
|
|
{
|
|
coyote: false,
|
|
expectedFragments: "[{Apex:com.android.acme Module:road-runner}]",
|
|
},
|
|
{
|
|
coyote: true,
|
|
expectedFragments: "[{Apex:com.android.acme Module:road-runner} {Apex:com.android.acme Module:wiley}]",
|
|
},
|
|
} {
|
|
t.Run(fmt.Sprintf("coyote:%t", test.coyote), func(t *testing.T) {
|
|
result := GroupFixturePreparers(
|
|
PrepareForTestWithSoongConfigModuleBuildComponents,
|
|
prepareForSoongConfigTestSingletonModule,
|
|
FixtureWithRootAndroidBp(bp),
|
|
FixtureModifyProductVariables(func(variables FixtureProductVariables) {
|
|
variables.VendorVars = map[string]map[string]string{
|
|
"acme": {
|
|
"coyote": fmt.Sprintf("%t", test.coyote),
|
|
},
|
|
}
|
|
}),
|
|
).RunTest(t)
|
|
|
|
// Make sure that the singleton was created.
|
|
result.SingletonForTests("test_singleton")
|
|
m := result.ModuleForTests("wiley", "").module.(*soongConfigTestSingletonModule)
|
|
AssertStringEquals(t, "fragments", test.expectedFragments, fmt.Sprintf("%+v", m.props.Fragments))
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSoongConfigModuleTrace(t *testing.T) {
|
|
bp := `
|
|
soong_config_module_type {
|
|
name: "acme_test",
|
|
module_type: "test",
|
|
config_namespace: "acme",
|
|
variables: ["board", "feature1", "FEATURE3", "unused_string_var"],
|
|
bool_variables: ["feature2", "unused_feature", "always_true"],
|
|
value_variables: ["size", "unused_size"],
|
|
properties: ["cflags", "srcs", "defaults"],
|
|
}
|
|
|
|
soong_config_module_type {
|
|
name: "acme_test_defaults",
|
|
module_type: "test_defaults",
|
|
config_namespace: "acme",
|
|
variables: ["board", "feature1", "FEATURE3", "unused_string_var"],
|
|
bool_variables: ["feature2", "unused_feature", "always_true"],
|
|
value_variables: ["size", "unused_size"],
|
|
properties: ["cflags", "srcs", "defaults"],
|
|
}
|
|
|
|
soong_config_string_variable {
|
|
name: "board",
|
|
values: ["soc_a", "soc_b", "soc_c"],
|
|
}
|
|
|
|
soong_config_string_variable {
|
|
name: "unused_string_var",
|
|
values: ["a", "b"],
|
|
}
|
|
|
|
soong_config_bool_variable {
|
|
name: "feature1",
|
|
}
|
|
|
|
soong_config_bool_variable {
|
|
name: "FEATURE3",
|
|
}
|
|
|
|
test_defaults {
|
|
name: "test_defaults",
|
|
cflags: ["DEFAULT"],
|
|
}
|
|
|
|
test {
|
|
name: "normal",
|
|
defaults: ["test_defaults"],
|
|
}
|
|
|
|
acme_test {
|
|
name: "board_1",
|
|
defaults: ["test_defaults"],
|
|
soong_config_variables: {
|
|
board: {
|
|
soc_a: {
|
|
cflags: ["-DSOC_A"],
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
acme_test {
|
|
name: "board_2",
|
|
defaults: ["test_defaults"],
|
|
soong_config_variables: {
|
|
board: {
|
|
soc_a: {
|
|
cflags: ["-DSOC_A"],
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
acme_test {
|
|
name: "size",
|
|
defaults: ["test_defaults"],
|
|
soong_config_variables: {
|
|
size: {
|
|
cflags: ["-DSIZE=%s"],
|
|
},
|
|
},
|
|
}
|
|
|
|
acme_test {
|
|
name: "board_and_size",
|
|
defaults: ["test_defaults"],
|
|
soong_config_variables: {
|
|
board: {
|
|
soc_a: {
|
|
cflags: ["-DSOC_A"],
|
|
},
|
|
},
|
|
size: {
|
|
cflags: ["-DSIZE=%s"],
|
|
},
|
|
},
|
|
}
|
|
|
|
acme_test_defaults {
|
|
name: "board_defaults",
|
|
soong_config_variables: {
|
|
board: {
|
|
soc_a: {
|
|
cflags: ["-DSOC_A"],
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
acme_test_defaults {
|
|
name: "size_defaults",
|
|
soong_config_variables: {
|
|
size: {
|
|
cflags: ["-DSIZE=%s"],
|
|
},
|
|
},
|
|
}
|
|
|
|
test {
|
|
name: "board_and_size_with_defaults",
|
|
defaults: ["board_defaults", "size_defaults"],
|
|
}
|
|
`
|
|
|
|
fixtureForVendorVars := func(vars map[string]map[string]string) FixturePreparer {
|
|
return FixtureModifyProductVariables(func(variables FixtureProductVariables) {
|
|
variables.VendorVars = vars
|
|
})
|
|
}
|
|
|
|
preparer := fixtureForVendorVars(map[string]map[string]string{
|
|
"acme": {
|
|
"board": "soc_a",
|
|
"size": "42",
|
|
"feature1": "true",
|
|
"feature2": "false",
|
|
// FEATURE3 unset
|
|
"unused_feature": "true", // unused
|
|
"unused_size": "1", // unused
|
|
"unused_string_var": "a", // unused
|
|
"always_true": "true",
|
|
},
|
|
})
|
|
|
|
t.Run("soong config trace hash", func(t *testing.T) {
|
|
result := GroupFixturePreparers(
|
|
preparer,
|
|
PrepareForTestWithDefaults,
|
|
PrepareForTestWithSoongConfigModuleBuildComponents,
|
|
prepareForSoongConfigTestModule,
|
|
FixtureRegisterWithContext(func(ctx RegistrationContext) {
|
|
ctx.FinalDepsMutators(registerSoongConfigTraceMutator)
|
|
}),
|
|
FixtureWithRootAndroidBp(bp),
|
|
).RunTest(t)
|
|
|
|
// Hashes of modules not using soong config should be empty
|
|
normal := result.ModuleForTests("normal", "").Module().(*soongConfigTestModule)
|
|
AssertDeepEquals(t, "normal hash", normal.base().commonProperties.SoongConfigTraceHash, "")
|
|
AssertDeepEquals(t, "normal hash out", normal.outputPath.RelativeToTop().String(), "out/soong/.intermediates/normal/test")
|
|
|
|
board1 := result.ModuleForTests("board_1", "").Module().(*soongConfigTestModule)
|
|
board2 := result.ModuleForTests("board_2", "").Module().(*soongConfigTestModule)
|
|
size := result.ModuleForTests("size", "").Module().(*soongConfigTestModule)
|
|
|
|
// Trace mutator sets soong config trace hash correctly
|
|
board1Hash := board1.base().commonProperties.SoongConfigTrace.hash()
|
|
board1Output := board1.outputPath.RelativeToTop().String()
|
|
AssertDeepEquals(t, "board hash calc", board1Hash, board1.base().commonProperties.SoongConfigTraceHash)
|
|
AssertDeepEquals(t, "board hash path", board1Output, filepath.Join("out/soong/.intermediates/board_1", board1Hash, "test"))
|
|
|
|
sizeHash := size.base().commonProperties.SoongConfigTrace.hash()
|
|
sizeOutput := size.outputPath.RelativeToTop().String()
|
|
AssertDeepEquals(t, "size hash calc", sizeHash, size.base().commonProperties.SoongConfigTraceHash)
|
|
AssertDeepEquals(t, "size hash path", sizeOutput, filepath.Join("out/soong/.intermediates/size", sizeHash, "test"))
|
|
|
|
// Trace should be identical for modules using the same set of variables
|
|
AssertDeepEquals(t, "board trace", board1.base().commonProperties.SoongConfigTrace, board2.base().commonProperties.SoongConfigTrace)
|
|
AssertDeepEquals(t, "board hash", board1.base().commonProperties.SoongConfigTraceHash, board2.base().commonProperties.SoongConfigTraceHash)
|
|
|
|
// Trace hash should be different for different sets of soong variables
|
|
AssertBoolEquals(t, "board hash not equal to size hash", board1.base().commonProperties.SoongConfigTraceHash == size.commonProperties.SoongConfigTraceHash, false)
|
|
|
|
boardSize := result.ModuleForTests("board_and_size", "").Module().(*soongConfigTestModule)
|
|
boardSizeDefaults := result.ModuleForTests("board_and_size_with_defaults", "").Module()
|
|
|
|
// Trace should propagate
|
|
AssertDeepEquals(t, "board_size hash calc", boardSize.base().commonProperties.SoongConfigTrace.hash(), boardSize.base().commonProperties.SoongConfigTraceHash)
|
|
AssertDeepEquals(t, "board_size trace", boardSize.base().commonProperties.SoongConfigTrace, boardSizeDefaults.base().commonProperties.SoongConfigTrace)
|
|
AssertDeepEquals(t, "board_size hash", boardSize.base().commonProperties.SoongConfigTraceHash, boardSizeDefaults.base().commonProperties.SoongConfigTraceHash)
|
|
})
|
|
}
|