02c8618e1b
List variables act similar to value variables. Each value in a list variable will be added to a list property after string substitution. Bug: 329208946 Test: m --no-skip-soong-tests Test: m selinux_policy_system_soong Change-Id: I1127bfb0798e7e5f7d665f647307224d5ff5d790
613 lines
13 KiB
Go
613 lines
13 KiB
Go
// Copyright 2020 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 soongconfig
|
|
|
|
import (
|
|
"reflect"
|
|
"testing"
|
|
|
|
"github.com/google/blueprint/proptools"
|
|
)
|
|
|
|
func Test_CanonicalizeToProperty(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
arg string
|
|
want string
|
|
}{
|
|
{
|
|
name: "lowercase",
|
|
arg: "board",
|
|
want: "board",
|
|
},
|
|
{
|
|
name: "uppercase",
|
|
arg: "BOARD",
|
|
want: "BOARD",
|
|
},
|
|
{
|
|
name: "numbers",
|
|
arg: "BOARD123",
|
|
want: "BOARD123",
|
|
},
|
|
{
|
|
name: "underscore",
|
|
arg: "TARGET_BOARD",
|
|
want: "TARGET_BOARD",
|
|
},
|
|
{
|
|
name: "dash",
|
|
arg: "TARGET-BOARD",
|
|
want: "TARGET_BOARD",
|
|
},
|
|
{
|
|
name: "unicode",
|
|
arg: "boardλ",
|
|
want: "board_",
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
if got := CanonicalizeToProperty(tt.arg); got != tt.want {
|
|
t.Errorf("canonicalizeToProperty() = %v, want %v", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_typeForPropertyFromPropertyStruct(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
ps interface{}
|
|
property string
|
|
want string
|
|
}{
|
|
{
|
|
name: "string",
|
|
ps: struct {
|
|
A string
|
|
}{},
|
|
property: "a",
|
|
want: "string",
|
|
},
|
|
{
|
|
name: "list",
|
|
ps: struct {
|
|
A []string
|
|
}{},
|
|
property: "a",
|
|
want: "[]string",
|
|
},
|
|
{
|
|
name: "missing",
|
|
ps: struct {
|
|
A []string
|
|
}{},
|
|
property: "b",
|
|
want: "",
|
|
},
|
|
{
|
|
name: "nested",
|
|
ps: struct {
|
|
A struct {
|
|
B string
|
|
}
|
|
}{},
|
|
property: "a.b",
|
|
want: "string",
|
|
},
|
|
{
|
|
name: "missing nested",
|
|
ps: struct {
|
|
A struct {
|
|
B string
|
|
}
|
|
}{},
|
|
property: "a.c",
|
|
want: "",
|
|
},
|
|
{
|
|
name: "not a struct",
|
|
ps: struct {
|
|
A string
|
|
}{},
|
|
property: "a.b",
|
|
want: "",
|
|
},
|
|
{
|
|
name: "nested pointer",
|
|
ps: struct {
|
|
A *struct {
|
|
B string
|
|
}
|
|
}{},
|
|
property: "a.b",
|
|
want: "string",
|
|
},
|
|
{
|
|
name: "nested interface",
|
|
ps: struct {
|
|
A interface{}
|
|
}{
|
|
A: struct {
|
|
B string
|
|
}{},
|
|
},
|
|
property: "a.b",
|
|
want: "string",
|
|
},
|
|
{
|
|
name: "nested interface pointer",
|
|
ps: struct {
|
|
A interface{}
|
|
}{
|
|
A: &struct {
|
|
B string
|
|
}{},
|
|
},
|
|
property: "a.b",
|
|
want: "string",
|
|
},
|
|
{
|
|
name: "nested interface nil pointer",
|
|
ps: struct {
|
|
A interface{}
|
|
}{
|
|
A: (*struct {
|
|
B string
|
|
})(nil),
|
|
},
|
|
property: "a.b",
|
|
want: "string",
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
typ := typeForPropertyFromPropertyStruct(tt.ps, tt.property)
|
|
got := ""
|
|
if typ != nil {
|
|
got = typ.String()
|
|
}
|
|
if got != tt.want {
|
|
t.Errorf("typeForPropertyFromPropertyStruct() = %v, want %v", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_createAffectablePropertiesType(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
affectableProperties []string
|
|
factoryProps interface{}
|
|
want string
|
|
}{
|
|
{
|
|
name: "string",
|
|
affectableProperties: []string{"cflags"},
|
|
factoryProps: struct {
|
|
Cflags string
|
|
}{},
|
|
want: "*struct { Cflags string }",
|
|
},
|
|
{
|
|
name: "list",
|
|
affectableProperties: []string{"cflags"},
|
|
factoryProps: struct {
|
|
Cflags []string
|
|
}{},
|
|
want: "*struct { Cflags []string }",
|
|
},
|
|
{
|
|
name: "string pointer",
|
|
affectableProperties: []string{"cflags"},
|
|
factoryProps: struct {
|
|
Cflags *string
|
|
}{},
|
|
want: "*struct { Cflags *string }",
|
|
},
|
|
{
|
|
name: "subset",
|
|
affectableProperties: []string{"cflags"},
|
|
factoryProps: struct {
|
|
Cflags string
|
|
Ldflags string
|
|
}{},
|
|
want: "*struct { Cflags string }",
|
|
},
|
|
{
|
|
name: "none",
|
|
affectableProperties: []string{"cflags"},
|
|
factoryProps: struct {
|
|
Ldflags string
|
|
}{},
|
|
want: "",
|
|
},
|
|
{
|
|
name: "nested",
|
|
affectableProperties: []string{"multilib.lib32.cflags"},
|
|
factoryProps: struct {
|
|
Multilib struct {
|
|
Lib32 struct {
|
|
Cflags string
|
|
}
|
|
}
|
|
}{},
|
|
want: "*struct { Multilib struct { Lib32 struct { Cflags string } } }",
|
|
},
|
|
{
|
|
name: "complex",
|
|
affectableProperties: []string{
|
|
"cflags",
|
|
"multilib.lib32.cflags",
|
|
"multilib.lib32.ldflags",
|
|
"multilib.lib64.cflags",
|
|
"multilib.lib64.ldflags",
|
|
"zflags",
|
|
},
|
|
factoryProps: struct {
|
|
Cflags string
|
|
Multilib struct {
|
|
Lib32 struct {
|
|
Cflags string
|
|
Ldflags string
|
|
}
|
|
Lib64 struct {
|
|
Cflags string
|
|
Ldflags string
|
|
}
|
|
}
|
|
Zflags string
|
|
}{},
|
|
want: "*struct { Cflags string; Multilib struct { Lib32 struct { Cflags string; Ldflags string }; Lib64 struct { Cflags string; Ldflags string } }; Zflags string }",
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
typ := createAffectablePropertiesType(tt.affectableProperties, []interface{}{tt.factoryProps})
|
|
got := ""
|
|
if typ != nil {
|
|
got = typ.String()
|
|
}
|
|
if !reflect.DeepEqual(got, tt.want) {
|
|
t.Errorf("createAffectablePropertiesType() = %v, want %v", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
type properties struct {
|
|
A *string
|
|
B bool
|
|
C []string
|
|
}
|
|
|
|
type varProps struct {
|
|
A *string
|
|
B bool
|
|
C []string
|
|
Conditions_default *properties
|
|
}
|
|
|
|
type boolSoongConfigVars struct {
|
|
Bool_var interface{}
|
|
}
|
|
|
|
type stringSoongConfigVars struct {
|
|
String_var interface{}
|
|
}
|
|
|
|
type valueSoongConfigVars struct {
|
|
My_value_var interface{}
|
|
}
|
|
|
|
type listProperties struct {
|
|
C []string
|
|
}
|
|
|
|
type listVarProps struct {
|
|
C []string
|
|
Conditions_default *listProperties
|
|
}
|
|
|
|
type listSoongConfigVars struct {
|
|
List_var interface{}
|
|
}
|
|
|
|
func Test_PropertiesToApply_Bool(t *testing.T) {
|
|
mt, _ := newModuleType(&ModuleTypeProperties{
|
|
Module_type: "foo",
|
|
Config_namespace: "bar",
|
|
Bool_variables: []string{"bool_var"},
|
|
Properties: []string{"a", "b"},
|
|
})
|
|
boolVarPositive := &properties{
|
|
A: proptools.StringPtr("A"),
|
|
B: true,
|
|
}
|
|
conditionsDefault := &properties{
|
|
A: proptools.StringPtr("default"),
|
|
B: false,
|
|
}
|
|
actualProps := &struct {
|
|
Soong_config_variables boolSoongConfigVars
|
|
}{
|
|
Soong_config_variables: boolSoongConfigVars{
|
|
Bool_var: &varProps{
|
|
A: boolVarPositive.A,
|
|
B: boolVarPositive.B,
|
|
Conditions_default: conditionsDefault,
|
|
},
|
|
},
|
|
}
|
|
props := reflect.ValueOf(actualProps)
|
|
|
|
testCases := []struct {
|
|
name string
|
|
config SoongConfig
|
|
wantProps []interface{}
|
|
}{
|
|
{
|
|
name: "no_vendor_config",
|
|
config: Config(map[string]string{}),
|
|
wantProps: []interface{}{conditionsDefault},
|
|
},
|
|
{
|
|
name: "vendor_config_false",
|
|
config: Config(map[string]string{"bool_var": "n"}),
|
|
wantProps: []interface{}{conditionsDefault},
|
|
},
|
|
{
|
|
name: "bool_var_true",
|
|
config: Config(map[string]string{"bool_var": "y"}),
|
|
wantProps: []interface{}{boolVarPositive},
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
gotProps, err := PropertiesToApply(mt, props, tc.config)
|
|
if err != nil {
|
|
t.Errorf("%s: Unexpected error in PropertiesToApply: %s", tc.name, err)
|
|
}
|
|
|
|
if !reflect.DeepEqual(gotProps, tc.wantProps) {
|
|
t.Errorf("%s: Expected %s, got %s", tc.name, tc.wantProps, gotProps)
|
|
}
|
|
}
|
|
}
|
|
|
|
func Test_PropertiesToApply_List(t *testing.T) {
|
|
mt, _ := newModuleType(&ModuleTypeProperties{
|
|
Module_type: "foo",
|
|
Config_namespace: "bar",
|
|
List_variables: []string{"my_list_var"},
|
|
Properties: []string{"c"},
|
|
})
|
|
conditionsDefault := &listProperties{
|
|
C: []string{"default"},
|
|
}
|
|
actualProps := &struct {
|
|
Soong_config_variables listSoongConfigVars
|
|
}{
|
|
Soong_config_variables: listSoongConfigVars{
|
|
List_var: &listVarProps{
|
|
C: []string{"A=%s", "B=%s"},
|
|
Conditions_default: conditionsDefault,
|
|
},
|
|
},
|
|
}
|
|
props := reflect.ValueOf(actualProps)
|
|
|
|
testCases := []struct {
|
|
name string
|
|
config SoongConfig
|
|
wantProps []interface{}
|
|
}{
|
|
{
|
|
name: "no_vendor_config",
|
|
config: Config(map[string]string{}),
|
|
wantProps: []interface{}{conditionsDefault},
|
|
},
|
|
{
|
|
name: "value_var_set",
|
|
config: Config(map[string]string{"my_list_var": "hello there"}),
|
|
wantProps: []interface{}{&listProperties{
|
|
C: []string{"A=hello", "A=there", "B=hello", "B=there"},
|
|
}},
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
gotProps, err := PropertiesToApply(mt, props, tc.config)
|
|
if err != nil {
|
|
t.Errorf("%s: Unexpected error in PropertiesToApply: %s", tc.name, err)
|
|
}
|
|
|
|
if !reflect.DeepEqual(gotProps, tc.wantProps) {
|
|
t.Errorf("%s: Expected %s, got %s", tc.name, tc.wantProps, gotProps)
|
|
}
|
|
}
|
|
}
|
|
|
|
func Test_PropertiesToApply_Value(t *testing.T) {
|
|
mt, _ := newModuleType(&ModuleTypeProperties{
|
|
Module_type: "foo",
|
|
Config_namespace: "bar",
|
|
Value_variables: []string{"my_value_var"},
|
|
Properties: []string{"a", "b"},
|
|
})
|
|
conditionsDefault := &properties{
|
|
A: proptools.StringPtr("default"),
|
|
B: false,
|
|
}
|
|
actualProps := &struct {
|
|
Soong_config_variables valueSoongConfigVars
|
|
}{
|
|
Soong_config_variables: valueSoongConfigVars{
|
|
My_value_var: &varProps{
|
|
A: proptools.StringPtr("A=%s"),
|
|
B: true,
|
|
Conditions_default: conditionsDefault,
|
|
},
|
|
},
|
|
}
|
|
props := reflect.ValueOf(actualProps)
|
|
|
|
testCases := []struct {
|
|
name string
|
|
config SoongConfig
|
|
wantProps []interface{}
|
|
}{
|
|
{
|
|
name: "no_vendor_config",
|
|
config: Config(map[string]string{}),
|
|
wantProps: []interface{}{conditionsDefault},
|
|
},
|
|
{
|
|
name: "value_var_set",
|
|
config: Config(map[string]string{"my_value_var": "Hello"}),
|
|
wantProps: []interface{}{&properties{
|
|
A: proptools.StringPtr("A=Hello"),
|
|
B: true,
|
|
}},
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
gotProps, err := PropertiesToApply(mt, props, tc.config)
|
|
if err != nil {
|
|
t.Errorf("%s: Unexpected error in PropertiesToApply: %s", tc.name, err)
|
|
}
|
|
|
|
if !reflect.DeepEqual(gotProps, tc.wantProps) {
|
|
t.Errorf("%s: Expected %s, got %s", tc.name, tc.wantProps, gotProps)
|
|
}
|
|
}
|
|
}
|
|
|
|
func Test_PropertiesToApply_Value_Nested(t *testing.T) {
|
|
mt, _ := newModuleType(&ModuleTypeProperties{
|
|
Module_type: "foo",
|
|
Config_namespace: "bar",
|
|
Value_variables: []string{"my_value_var"},
|
|
Properties: []string{"a.b"},
|
|
})
|
|
type properties struct {
|
|
A struct {
|
|
B string
|
|
}
|
|
}
|
|
conditionsDefault := &properties{
|
|
A: struct{ B string }{
|
|
B: "default",
|
|
},
|
|
}
|
|
type valueVarProps struct {
|
|
A struct {
|
|
B string
|
|
}
|
|
Conditions_default *properties
|
|
}
|
|
actualProps := &struct {
|
|
Soong_config_variables valueSoongConfigVars
|
|
}{
|
|
Soong_config_variables: valueSoongConfigVars{
|
|
My_value_var: &valueVarProps{
|
|
A: struct{ B string }{
|
|
B: "A.B=%s",
|
|
},
|
|
Conditions_default: conditionsDefault,
|
|
},
|
|
},
|
|
}
|
|
props := reflect.ValueOf(actualProps)
|
|
|
|
testCases := []struct {
|
|
name string
|
|
config SoongConfig
|
|
wantProps []interface{}
|
|
}{
|
|
{
|
|
name: "no_vendor_config",
|
|
config: Config(map[string]string{}),
|
|
wantProps: []interface{}{conditionsDefault},
|
|
},
|
|
{
|
|
name: "value_var_set",
|
|
config: Config(map[string]string{"my_value_var": "Hello"}),
|
|
wantProps: []interface{}{&properties{
|
|
A: struct{ B string }{
|
|
B: "A.B=Hello",
|
|
},
|
|
}},
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
gotProps, err := PropertiesToApply(mt, props, tc.config)
|
|
if err != nil {
|
|
t.Errorf("%s: Unexpected error in PropertiesToApply: %s", tc.name, err)
|
|
}
|
|
|
|
if !reflect.DeepEqual(gotProps, tc.wantProps) {
|
|
t.Errorf("%s: Expected %s, got %s", tc.name, tc.wantProps, gotProps)
|
|
}
|
|
}
|
|
}
|
|
|
|
func Test_PropertiesToApply_String_Error(t *testing.T) {
|
|
mt, _ := newModuleType(&ModuleTypeProperties{
|
|
Module_type: "foo",
|
|
Config_namespace: "bar",
|
|
Variables: []string{"string_var"},
|
|
Properties: []string{"a", "b"},
|
|
})
|
|
mt.Variables = append(mt.Variables, &stringVariable{
|
|
baseVariable: baseVariable{
|
|
variable: "string_var",
|
|
},
|
|
values: []string{"a", "b", "c"},
|
|
})
|
|
stringVarPositive := &properties{
|
|
A: proptools.StringPtr("A"),
|
|
B: true,
|
|
}
|
|
conditionsDefault := &properties{
|
|
A: proptools.StringPtr("default"),
|
|
B: false,
|
|
}
|
|
actualProps := &struct {
|
|
Soong_config_variables stringSoongConfigVars
|
|
}{
|
|
Soong_config_variables: stringSoongConfigVars{
|
|
String_var: &varProps{
|
|
A: stringVarPositive.A,
|
|
B: stringVarPositive.B,
|
|
Conditions_default: conditionsDefault,
|
|
},
|
|
},
|
|
}
|
|
props := reflect.ValueOf(actualProps)
|
|
|
|
_, err := PropertiesToApply(mt, props, Config(map[string]string{
|
|
"string_var": "x",
|
|
}))
|
|
expected := `Soong config property "string_var" must be one of [a b c], found "x"`
|
|
if err == nil {
|
|
t.Fatalf("Expected an error, got nil")
|
|
} else if err.Error() != expected {
|
|
t.Fatalf("Error message was not correct, expected %q, got %q", expected, err.Error())
|
|
}
|
|
}
|