c1ccfee2bd
This support enables specifying properties of the type "map" within a Soong module, but explicitly does not allow them to be used within a bp file. This means that rather than specifying each arch/os/target within a struct to support arch-variant properties/attributes, we can use a map. This allows us to simplify the implementation of LabelAttribute, StringListAttribute, and LabelListAttribute as the number of select statements supported becoming large and hard results in a lot of duplication. Test: go test blueprint tests Test: m nothing Change-Id: I88cc5952a6bdb60a2344fa0737216f016086cea5
556 lines
10 KiB
Go
556 lines
10 KiB
Go
// 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 proptools
|
|
|
|
import (
|
|
"fmt"
|
|
"reflect"
|
|
"testing"
|
|
)
|
|
|
|
var clonePropertiesTestCases = []struct {
|
|
in interface{}
|
|
out interface{}
|
|
err error
|
|
}{
|
|
// Valid inputs
|
|
|
|
{
|
|
// Clone bool
|
|
in: &struct{ B1, B2 bool }{
|
|
B1: true,
|
|
B2: false,
|
|
},
|
|
out: &struct{ B1, B2 bool }{
|
|
B1: true,
|
|
B2: false,
|
|
},
|
|
},
|
|
{
|
|
// Clone strings
|
|
in: &struct{ S string }{
|
|
S: "string1",
|
|
},
|
|
out: &struct{ S string }{
|
|
S: "string1",
|
|
},
|
|
},
|
|
{
|
|
// Clone slice
|
|
in: &struct{ S []string }{
|
|
S: []string{"string1"},
|
|
},
|
|
out: &struct{ S []string }{
|
|
S: []string{"string1"},
|
|
},
|
|
},
|
|
{
|
|
// Clone empty slice
|
|
in: &struct{ S []string }{
|
|
S: []string{},
|
|
},
|
|
out: &struct{ S []string }{
|
|
S: []string{},
|
|
},
|
|
},
|
|
{
|
|
// Clone nil slice
|
|
in: &struct{ S []string }{},
|
|
out: &struct{ S []string }{},
|
|
},
|
|
{
|
|
// Clone slice of structs
|
|
in: &struct{ S []struct{ T string } }{
|
|
S: []struct{ T string }{
|
|
{"string1"}, {"string2"},
|
|
},
|
|
},
|
|
out: &struct{ S []struct{ T string } }{
|
|
S: []struct{ T string }{
|
|
{"string1"}, {"string2"},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
// Clone map
|
|
in: &struct{ S map[string]string }{
|
|
S: map[string]string{"key": "string1"},
|
|
},
|
|
out: &struct{ S map[string]string }{
|
|
S: map[string]string{"key": "string1"},
|
|
},
|
|
},
|
|
{
|
|
// Clone empty map
|
|
in: &struct{ S map[string]string }{
|
|
S: map[string]string{},
|
|
},
|
|
out: &struct{ S map[string]string }{
|
|
S: map[string]string{},
|
|
},
|
|
},
|
|
{
|
|
// Clone nil map
|
|
in: &struct{ S map[string]string }{},
|
|
out: &struct{ S map[string]string }{},
|
|
},
|
|
{
|
|
// Clone pointer to bool
|
|
in: &struct{ B1, B2 *bool }{
|
|
B1: BoolPtr(true),
|
|
B2: BoolPtr(false),
|
|
},
|
|
out: &struct{ B1, B2 *bool }{
|
|
B1: BoolPtr(true),
|
|
B2: BoolPtr(false),
|
|
},
|
|
},
|
|
{
|
|
// Clone pointer to string
|
|
in: &struct{ S *string }{
|
|
S: StringPtr("string1"),
|
|
},
|
|
out: &struct{ S *string }{
|
|
S: StringPtr("string1"),
|
|
},
|
|
},
|
|
{
|
|
// Clone pointer to int64
|
|
in: &struct{ S *int64 }{
|
|
S: Int64Ptr(5),
|
|
},
|
|
out: &struct{ S *int64 }{
|
|
S: Int64Ptr(5),
|
|
},
|
|
},
|
|
{
|
|
// Clone struct
|
|
in: &struct{ S struct{ S string } }{
|
|
S: struct{ S string }{
|
|
S: "string1",
|
|
},
|
|
},
|
|
out: &struct{ S struct{ S string } }{
|
|
S: struct{ S string }{
|
|
S: "string1",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
// Clone struct pointer
|
|
in: &struct{ S *struct{ S string } }{
|
|
S: &struct{ S string }{
|
|
S: "string1",
|
|
},
|
|
},
|
|
out: &struct{ S *struct{ S string } }{
|
|
S: &struct{ S string }{
|
|
S: "string1",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
// Clone interface
|
|
in: &struct{ S interface{} }{
|
|
S: &struct{ S string }{
|
|
S: "string1",
|
|
},
|
|
},
|
|
out: &struct{ S interface{} }{
|
|
S: &struct{ S string }{
|
|
S: "string1",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
// Clone nested interface
|
|
in: &struct {
|
|
Nested struct{ S interface{} }
|
|
}{
|
|
Nested: struct{ S interface{} }{
|
|
S: &struct{ S string }{
|
|
S: "string1",
|
|
},
|
|
},
|
|
},
|
|
out: &struct {
|
|
Nested struct{ S interface{} }
|
|
}{
|
|
Nested: struct{ S interface{} }{
|
|
S: &struct{ S string }{
|
|
S: "string1",
|
|
},
|
|
},
|
|
},
|
|
}, {
|
|
// Empty struct
|
|
in: &struct{}{},
|
|
out: &struct{}{},
|
|
},
|
|
{
|
|
// Interface nil
|
|
in: &struct{ S interface{} }{
|
|
S: nil,
|
|
},
|
|
out: &struct{ S interface{} }{
|
|
S: nil,
|
|
},
|
|
},
|
|
{
|
|
// Interface pointer to nil
|
|
in: &struct{ S interface{} }{
|
|
S: (*struct{ S string })(nil),
|
|
},
|
|
out: &struct{ S interface{} }{
|
|
S: (*struct{ S string })(nil),
|
|
},
|
|
},
|
|
{
|
|
// Pointer nil
|
|
in: &struct{ S *struct{} }{
|
|
S: nil,
|
|
},
|
|
out: &struct{ S *struct{} }{
|
|
S: nil,
|
|
},
|
|
},
|
|
{
|
|
// Anonymous struct
|
|
in: &struct {
|
|
EmbeddedStruct
|
|
Nested struct{ EmbeddedStruct }
|
|
}{
|
|
EmbeddedStruct: EmbeddedStruct{
|
|
S: "string1",
|
|
I: Int64Ptr(55),
|
|
},
|
|
Nested: struct{ EmbeddedStruct }{
|
|
EmbeddedStruct: EmbeddedStruct{
|
|
S: "string2",
|
|
I: Int64Ptr(5),
|
|
},
|
|
},
|
|
},
|
|
out: &struct {
|
|
EmbeddedStruct
|
|
Nested struct{ EmbeddedStruct }
|
|
}{
|
|
EmbeddedStruct: EmbeddedStruct{
|
|
S: "string1",
|
|
I: Int64Ptr(55),
|
|
},
|
|
Nested: struct{ EmbeddedStruct }{
|
|
EmbeddedStruct: EmbeddedStruct{
|
|
S: "string2",
|
|
I: Int64Ptr(5),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
// Anonymous interface
|
|
in: &struct {
|
|
EmbeddedInterface
|
|
Nested struct{ EmbeddedInterface }
|
|
}{
|
|
EmbeddedInterface: &struct{ S string }{
|
|
S: "string1",
|
|
},
|
|
Nested: struct{ EmbeddedInterface }{
|
|
EmbeddedInterface: &struct{ S string }{
|
|
S: "string2",
|
|
},
|
|
},
|
|
},
|
|
out: &struct {
|
|
EmbeddedInterface
|
|
Nested struct{ EmbeddedInterface }
|
|
}{
|
|
EmbeddedInterface: &struct{ S string }{
|
|
S: "string1",
|
|
},
|
|
Nested: struct{ EmbeddedInterface }{
|
|
EmbeddedInterface: &struct{ S string }{
|
|
S: "string2",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
type EmbeddedStruct struct {
|
|
S string
|
|
I *int64
|
|
}
|
|
type EmbeddedInterface interface{}
|
|
|
|
func TestCloneProperties(t *testing.T) {
|
|
for _, testCase := range clonePropertiesTestCases {
|
|
testString := fmt.Sprintf("%s", testCase.in)
|
|
|
|
got := CloneProperties(reflect.ValueOf(testCase.in)).Interface()
|
|
|
|
if !reflect.DeepEqual(testCase.out, got) {
|
|
t.Errorf("test case %s", testString)
|
|
t.Errorf("incorrect output")
|
|
t.Errorf(" expected: %#v", testCase.out)
|
|
t.Errorf(" got: %#v", got)
|
|
}
|
|
if testCase.out == got {
|
|
t.Errorf("test case %s", testString)
|
|
t.Errorf("items should be cloned, not the original")
|
|
t.Errorf(" expected: %s", testCase.out)
|
|
t.Errorf(" got: %s", got)
|
|
}
|
|
}
|
|
}
|
|
|
|
var cloneEmptyPropertiesTestCases = []struct {
|
|
in interface{}
|
|
out interface{}
|
|
err error
|
|
}{
|
|
// Valid inputs
|
|
|
|
{
|
|
// Clone bool
|
|
in: &struct{ B1, B2 bool }{
|
|
B1: true,
|
|
B2: false,
|
|
},
|
|
out: &struct{ B1, B2 bool }{},
|
|
},
|
|
{
|
|
// Clone strings
|
|
in: &struct{ S string }{
|
|
S: "string1",
|
|
},
|
|
out: &struct{ S string }{},
|
|
},
|
|
{
|
|
// Clone slice
|
|
in: &struct{ S []string }{
|
|
S: []string{"string1"},
|
|
},
|
|
out: &struct{ S []string }{},
|
|
},
|
|
{
|
|
// Clone empty slice
|
|
in: &struct{ S []string }{
|
|
S: []string{},
|
|
},
|
|
out: &struct{ S []string }{},
|
|
},
|
|
{
|
|
// Clone nil slice
|
|
in: &struct{ S []string }{},
|
|
out: &struct{ S []string }{},
|
|
},
|
|
{
|
|
// Clone slice of structs
|
|
in: &struct{ S []struct{ T string } }{
|
|
S: []struct{ T string }{
|
|
{"string1"}, {"string2"},
|
|
},
|
|
},
|
|
out: &struct{ S []struct{ T string } }{
|
|
S: []struct{ T string }(nil),
|
|
},
|
|
},
|
|
{
|
|
// Clone pointer to bool
|
|
in: &struct{ B1, B2 *bool }{
|
|
B1: BoolPtr(true),
|
|
B2: BoolPtr(false),
|
|
},
|
|
out: &struct{ B1, B2 *bool }{},
|
|
},
|
|
{
|
|
// Clone pointer to int64
|
|
in: &struct{ B1, B2 *int64 }{
|
|
B1: Int64Ptr(5),
|
|
B2: Int64Ptr(4),
|
|
},
|
|
out: &struct{ B1, B2 *int64 }{},
|
|
},
|
|
{
|
|
// Clone pointer to string
|
|
in: &struct{ S *string }{
|
|
S: StringPtr("string1"),
|
|
},
|
|
out: &struct{ S *string }{},
|
|
},
|
|
{
|
|
// Clone struct
|
|
in: &struct{ S struct{ S string } }{
|
|
S: struct{ S string }{
|
|
S: "string1",
|
|
},
|
|
},
|
|
out: &struct{ S struct{ S string } }{
|
|
S: struct{ S string }{},
|
|
},
|
|
},
|
|
{
|
|
// Clone struct pointer
|
|
in: &struct{ S *struct{ S string } }{
|
|
S: &struct{ S string }{
|
|
S: "string1",
|
|
},
|
|
},
|
|
out: &struct{ S *struct{ S string } }{
|
|
S: &struct{ S string }{},
|
|
},
|
|
},
|
|
{
|
|
// Clone interface
|
|
in: &struct{ S interface{} }{
|
|
S: &struct{ S string }{
|
|
S: "string1",
|
|
},
|
|
},
|
|
out: &struct{ S interface{} }{
|
|
S: &struct{ S string }{},
|
|
},
|
|
},
|
|
{
|
|
// Clone nested interface
|
|
in: &struct {
|
|
Nested struct{ S interface{} }
|
|
}{
|
|
Nested: struct{ S interface{} }{
|
|
S: &struct{ S string }{
|
|
S: "string1",
|
|
},
|
|
},
|
|
},
|
|
out: &struct {
|
|
Nested struct{ S interface{} }
|
|
}{
|
|
Nested: struct{ S interface{} }{
|
|
S: &struct{ S string }{},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
// Empty struct
|
|
in: &struct{}{},
|
|
out: &struct{}{},
|
|
},
|
|
{
|
|
// Interface nil
|
|
in: &struct{ S interface{} }{
|
|
S: nil,
|
|
},
|
|
out: &struct{ S interface{} }{},
|
|
},
|
|
{
|
|
// Interface pointer to nil
|
|
in: &struct{ S interface{} }{
|
|
S: (*struct{ S string })(nil),
|
|
},
|
|
out: &struct{ S interface{} }{
|
|
S: (*struct{ S string })(nil),
|
|
},
|
|
},
|
|
{
|
|
// Pointer nil
|
|
in: &struct{ S *struct{} }{
|
|
S: nil,
|
|
},
|
|
out: &struct{ S *struct{} }{},
|
|
},
|
|
{
|
|
// Anonymous struct
|
|
in: &struct {
|
|
EmbeddedStruct
|
|
Nested struct{ EmbeddedStruct }
|
|
}{
|
|
EmbeddedStruct: EmbeddedStruct{
|
|
S: "string1",
|
|
},
|
|
Nested: struct{ EmbeddedStruct }{
|
|
EmbeddedStruct: EmbeddedStruct{
|
|
S: "string2",
|
|
},
|
|
},
|
|
},
|
|
out: &struct {
|
|
EmbeddedStruct
|
|
Nested struct{ EmbeddedStruct }
|
|
}{
|
|
EmbeddedStruct: EmbeddedStruct{},
|
|
Nested: struct{ EmbeddedStruct }{
|
|
EmbeddedStruct: EmbeddedStruct{},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
// Anonymous interface
|
|
in: &struct {
|
|
EmbeddedInterface
|
|
Nested struct{ EmbeddedInterface }
|
|
}{
|
|
EmbeddedInterface: &struct{ S string }{
|
|
S: "string1",
|
|
},
|
|
Nested: struct{ EmbeddedInterface }{
|
|
EmbeddedInterface: &struct{ S string }{
|
|
S: "string2",
|
|
},
|
|
},
|
|
},
|
|
out: &struct {
|
|
EmbeddedInterface
|
|
Nested struct{ EmbeddedInterface }
|
|
}{
|
|
EmbeddedInterface: &struct{ S string }{},
|
|
Nested: struct{ EmbeddedInterface }{
|
|
EmbeddedInterface: &struct{ S string }{},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
func TestCloneEmptyProperties(t *testing.T) {
|
|
for _, testCase := range cloneEmptyPropertiesTestCases {
|
|
testString := fmt.Sprintf("%#v", testCase.in)
|
|
|
|
got := CloneEmptyProperties(reflect.ValueOf(testCase.in)).Interface()
|
|
|
|
if !reflect.DeepEqual(testCase.out, got) {
|
|
t.Errorf("test case %s", testString)
|
|
t.Errorf("incorrect output")
|
|
t.Errorf(" expected: %#v", testCase.out)
|
|
t.Errorf(" got: %#v", got)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestZeroProperties(t *testing.T) {
|
|
for _, testCase := range cloneEmptyPropertiesTestCases {
|
|
testString := fmt.Sprintf("%#v", testCase.in)
|
|
|
|
got := CloneProperties(reflect.ValueOf(testCase.in)).Interface()
|
|
ZeroProperties(reflect.ValueOf(got))
|
|
|
|
if !reflect.DeepEqual(testCase.out, got) {
|
|
t.Errorf("test case %s", testString)
|
|
t.Errorf("incorrect output")
|
|
t.Errorf(" expected: %#v", testCase.out)
|
|
t.Errorf(" got: %#v", got)
|
|
}
|
|
}
|
|
}
|