tequilaOS/platform_build_blueprint
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
platform_build_blueprint/proptools/extend_test.go
Cole Faust 6437d4e737 Select statements 
Select statements are a new blueprint feature inspired by bazel's select
statements. They are essentially alternative syntax for soong config
variables that require less boilerplate. In addition, they support
making decisions based on a module's variant, which will eliminate
the need for manual property struct manipulation, such as the arch
mutator's arch: and target: properties.

In order to support decisions based on the variant, select statements
cannot be evaluated as soon as they're parsed. Instead, they must be
stored in the property struct unevaluated. This means that individual
properties need to change their type from say, string, to
Configurable[string]. Currently, only configurable strings, bools, and
string slices are supported, but more types can be added later.
The module implementation must call my_property.Evaluate(ctx) in order
to get the final, resolved value of the select statement.

Bug: 323382414
Test: go tests
Change-Id: I62f8721d7f0ac3d1df4a06d7eaa260a5aa7fcba3
2024-03-06 15:00:39 -08:00

1914 lines
40 KiB
Go
Raw Blame History

// 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 (
"errors"
"fmt"
"reflect"
"strings"
"testing"
"github.com/google/blueprint/parser"
)
type appendPropertyTestCase struct {
name string
dst interface{}
src interface{}
out interface{}
order Order // default is Append
filter ExtendPropertyFilterFunc
err error
}
func appendPropertiesTestCases() []appendPropertyTestCase {
return []appendPropertyTestCase{
// Valid inputs
{
name: "Append bool",
dst: &struct{ B1, B2, B3, B4 bool }{
B1: true,
B2: false,
B3: true,
B4: false,
},
src: &struct{ B1, B2, B3, B4 bool }{
B1: true,
B2: true,
B3: false,
B4: false,
},
out: &struct{ B1, B2, B3, B4 bool }{
B1: true,
B2: true,
B3: true,
B4: false,
},
},
{
name: "Prepend bool",
dst: &struct{ B1, B2, B3, B4 bool }{
B1: true,
B2: false,
B3: true,
B4: false,
},
src: &struct{ B1, B2, B3, B4 bool }{
B1: true,
B2: true,
B3: false,
B4: false,
},
out: &struct{ B1, B2, B3, B4 bool }{
B1: true,
B2: true,
B3: true,
B4: false,
},
order: Prepend,
},
{
name: "Append strings",
dst: &struct{ S string }{
S: "string1",
},
src: &struct{ S string }{
S: "string2",
},
out: &struct{ S string }{
S: "string1string2",
},
},
{
name: "Prepend strings",
dst: &struct{ S string }{
S: "string1",
},
src: &struct{ S string }{
S: "string2",
},
out: &struct{ S string }{
S: "string2string1",
},
order: Prepend,
},
{
name: "Append pointer to bool",
dst: &struct{ B1, B2, B3, B4, B5, B6, B7, B8, B9 *bool }{
B1: BoolPtr(true),
B2: BoolPtr(false),
B3: nil,
B4: BoolPtr(true),
B5: BoolPtr(false),
B6: nil,
B7: BoolPtr(true),
B8: BoolPtr(false),
B9: nil,
},
src: &struct{ B1, B2, B3, B4, B5, B6, B7, B8, B9 *bool }{
B1: nil,
B2: nil,
B3: nil,
B4: BoolPtr(true),
B5: BoolPtr(true),
B6: BoolPtr(true),
B7: BoolPtr(false),
B8: BoolPtr(false),
B9: BoolPtr(false),
},
out: &struct{ B1, B2, B3, B4, B5, B6, B7, B8, B9 *bool }{
B1: BoolPtr(true),
B2: BoolPtr(false),
B3: nil,
B4: BoolPtr(true),
B5: BoolPtr(true),
B6: BoolPtr(true),
B7: BoolPtr(false),
B8: BoolPtr(false),
B9: BoolPtr(false),
},
},
{
name: "Prepend pointer to bool",
dst: &struct{ B1, B2, B3, B4, B5, B6, B7, B8, B9 *bool }{
B1: BoolPtr(true),
B2: BoolPtr(false),
B3: nil,
B4: BoolPtr(true),
B5: BoolPtr(false),
B6: nil,
B7: BoolPtr(true),
B8: BoolPtr(false),
B9: nil,
},
src: &struct{ B1, B2, B3, B4, B5, B6, B7, B8, B9 *bool }{
B1: nil,
B2: nil,
B3: nil,
B4: BoolPtr(true),
B5: BoolPtr(true),
B6: BoolPtr(true),
B7: BoolPtr(false),
B8: BoolPtr(false),
B9: BoolPtr(false),
},
out: &struct{ B1, B2, B3, B4, B5, B6, B7, B8, B9 *bool }{
B1: BoolPtr(true),
B2: BoolPtr(false),
B3: nil,
B4: BoolPtr(true),
B5: BoolPtr(false),
B6: BoolPtr(true),
B7: BoolPtr(true),
B8: BoolPtr(false),
B9: BoolPtr(false),
},
order: Prepend,
},
{
name: "Append pointer to integer",
dst: &struct{ I1, I2, I3, I4, I5, I6, I7, I8, I9 *int64 }{
I1: Int64Ptr(55),
I2: Int64Ptr(-3),
I3: nil,
I4: Int64Ptr(100),
I5: Int64Ptr(33),
I6: nil,
I7: Int64Ptr(77),
I8: Int64Ptr(0),
I9: nil,
},
src: &struct{ I1, I2, I3, I4, I5, I6, I7, I8, I9 *int64 }{
I1: nil,
I2: nil,
I3: nil,
I4: Int64Ptr(1),
I5: Int64Ptr(-2),
I6: Int64Ptr(8),
I7: Int64Ptr(9),
I8: Int64Ptr(10),
I9: Int64Ptr(11),
},
out: &struct{ I1, I2, I3, I4, I5, I6, I7, I8, I9 *int64 }{
I1: Int64Ptr(55),
I2: Int64Ptr(-3),
I3: nil,
I4: Int64Ptr(1),
I5: Int64Ptr(-2),
I6: Int64Ptr(8),
I7: Int64Ptr(9),
I8: Int64Ptr(10),
I9: Int64Ptr(11),
},
},
{
name: "Prepend pointer to integer",
dst: &struct{ I1, I2, I3 *int64 }{
I1: Int64Ptr(55),
I3: nil,
},
src: &struct{ I1, I2, I3 *int64 }{
I2: Int64Ptr(33),
},
out: &struct{ I1, I2, I3 *int64 }{
I1: Int64Ptr(55),
I2: Int64Ptr(33),
I3: nil,
},
order: Prepend,
},
{
name: "Append pointer to strings",
dst: &struct{ S1, S2, S3, S4 *string }{
S1: StringPtr("string1"),
S2: StringPtr("string2"),
},
src: &struct{ S1, S2, S3, S4 *string }{
S1: StringPtr("string3"),
S3: StringPtr("string4"),
},
out: &struct{ S1, S2, S3, S4 *string }{
S1: StringPtr("string3"),
S2: StringPtr("string2"),
S3: StringPtr("string4"),
S4: nil,
},
},
{
name: "Prepend pointer to strings",
dst: &struct{ S1, S2, S3, S4 *string }{
S1: StringPtr("string1"),
S2: StringPtr("string2"),
},
src: &struct{ S1, S2, S3, S4 *string }{
S1: StringPtr("string3"),
S3: StringPtr("string4"),
},
out: &struct{ S1, S2, S3, S4 *string }{
S1: StringPtr("string1"),
S2: StringPtr("string2"),
S3: StringPtr("string4"),
S4: nil,
},
order: Prepend,
},
{
name: "Append slice",
dst: &struct{ S []string }{
S: []string{"string1"},
},
src: &struct{ S []string }{
S: []string{"string2"},
},
out: &struct{ S []string }{
S: []string{"string1", "string2"},
},
},
{
name: "Prepend slice",
dst: &struct{ S []string }{
S: []string{"string1"},
},
src: &struct{ S []string }{
S: []string{"string2"},
},
out: &struct{ S []string }{
S: []string{"string2", "string1"},
},
order: Prepend,
},
{
name: "Replace slice",
dst: &struct{ S []string }{
S: []string{"string1"},
},
src: &struct{ S []string }{
S: []string{"string2"},
},
out: &struct{ S []string }{
S: []string{"string2"},
},
order: Replace,
},
{
name: "Append empty slice",
dst: &struct{ S1, S2 []string }{
S1: []string{"string1"},
S2: []string{},
},
src: &struct{ S1, S2 []string }{
S1: []string{},
S2: []string{"string2"},
},
out: &struct{ S1, S2 []string }{
S1: []string{"string1"},
S2: []string{"string2"},
},
},
{
name: "Prepend empty slice",
dst: &struct{ S1, S2 []string }{
S1: []string{"string1"},
S2: []string{},
},
src: &struct{ S1, S2 []string }{
S1: []string{},
S2: []string{"string2"},
},
out: &struct{ S1, S2 []string }{
S1: []string{"string1"},
S2: []string{"string2"},
},
order: Prepend,
},
{
name: "Replace empty slice",
dst: &struct{ S1, S2 []string }{
S1: []string{"string1"},
S2: []string{},
},
src: &struct{ S1, S2 []string }{
S1: []string{},
S2: []string{"string2"},
},
out: &struct{ S1, S2 []string }{
S1: []string{},
S2: []string{"string2"},
},
order: Replace,
},
{
name: "Append nil slice",
dst: &struct{ S1, S2, S3 []string }{
S1: []string{"string1"},
},
src: &struct{ S1, S2, S3 []string }{
S2: []string{"string2"},
},
out: &struct{ S1, S2, S3 []string }{
S1: []string{"string1"},
S2: []string{"string2"},
S3: nil,
},
},
{
name: "Prepend nil slice",
dst: &struct{ S1, S2, S3 []string }{
S1: []string{"string1"},
},
src: &struct{ S1, S2, S3 []string }{
S2: []string{"string2"},
},
out: &struct{ S1, S2, S3 []string }{
S1: []string{"string1"},
S2: []string{"string2"},
S3: nil,
},
order: Prepend,
},
{
name: "Replace nil slice",
dst: &struct{ S1, S2, S3 []string }{
S1: []string{"string1"},
},
src: &struct{ S1, S2, S3 []string }{
S2: []string{"string2"},
},
out: &struct{ S1, S2, S3 []string }{
S1: []string{"string1"},
S2: []string{"string2"},
S3: nil,
},
order: Replace,
},
{
name: "Replace embedded slice",
dst: &struct{ S *struct{ S1 []string } }{
S: &struct{ S1 []string }{
S1: []string{"string1"},
},
},
src: &struct{ S *struct{ S1 []string } }{
S: &struct{ S1 []string }{
S1: []string{"string2"},
},
},
out: &struct{ S *struct{ S1 []string } }{
S: &struct{ S1 []string }{
S1: []string{"string2"},
},
},
order: Replace,
},
{
name: "Append slice of structs",
dst: &struct{ S []struct{ F string } }{
S: []struct{ F string }{
{F: "foo"}, {F: "bar"},
},
},
src: &struct{ S []struct{ F string } }{
S: []struct{ F string }{
{F: "baz"},
},
},
out: &struct{ S []struct{ F string } }{
S: []struct{ F string }{
{F: "foo"}, {F: "bar"}, {F: "baz"},
},
},
order: Append,
},
{
name: "Prepend slice of structs",
dst: &struct{ S []struct{ F string } }{
S: []struct{ F string }{
{F: "foo"}, {F: "bar"},
},
},
src: &struct{ S []struct{ F string } }{
S: []struct{ F string }{
{F: "baz"},
},
},
out: &struct{ S []struct{ F string } }{
S: []struct{ F string }{
{F: "baz"}, {F: "foo"}, {F: "bar"},
},
},
order: Prepend,
},
{
name: "Append map",
dst: &struct{ S map[string]string }{
S: map[string]string{
"key0": "",
"key1": "dst_value1",
"key2": "dst_value2",
},
},
src: &struct{ S map[string]string }{
S: map[string]string{
"key0": "src_value0",
"key1": "src_value1",
"key3": "src_value3",
},
},
out: &struct{ S map[string]string }{
S: map[string]string{
"key0": "src_value0",
"key1": "src_value1",
"key2": "dst_value2",
"key3": "src_value3",
},
},
order: Append,
},
{
name: "Prepend map",
dst: &struct{ S map[string]string }{
S: map[string]string{
"key0": "",
"key1": "dst_value1",
"key2": "dst_value2",
},
},
src: &struct{ S map[string]string }{
S: map[string]string{
"key0": "src_value0",
"key1": "src_value1",
"key3": "src_value3",
},
},
out: &struct{ S map[string]string }{
S: map[string]string{
"key0": "",
"key1": "dst_value1",
"key2": "dst_value2",
"key3": "src_value3",
},
},
order: Prepend,
},
{
name: "Replace map",
dst: &struct{ S map[string]string }{
S: map[string]string{
"key0": "",
"key1": "dst_value1",
"key2": "dst_value2",
},
},
src: &struct{ S map[string]string }{
S: map[string]string{
"key0": "src_value0",
"key1": "src_value1",
"key3": "src_value3",
},
},
out: &struct{ S map[string]string }{
S: map[string]string{
"key0": "src_value0",
"key1": "src_value1",
"key3": "src_value3",
},
},
order: Replace,
},
{
name: "Append empty map",
dst: &struct{ S1, S2 map[string]string }{
S1: map[string]string{"key0": "dst_value0"},
S2: map[string]string{},
},
src: &struct{ S1, S2 map[string]string }{
S1: map[string]string{},
S2: map[string]string{"key0": "src_value0"},
},
out: &struct{ S1, S2 map[string]string }{
S1: map[string]string{"key0": "dst_value0"},
S2: map[string]string{"key0": "src_value0"},
},
order: Append,
},
{
name: "Prepend empty map",
dst: &struct{ S1, S2 map[string]string }{
S1: map[string]string{"key0": "dst_value0"},
S2: map[string]string{},
},
src: &struct{ S1, S2 map[string]string }{
S1: map[string]string{},
S2: map[string]string{"key0": "src_value0"},
},
out: &struct{ S1, S2 map[string]string }{
S1: map[string]string{"key0": "dst_value0"},
S2: map[string]string{"key0": "src_value0"},
},
order: Prepend,
},
{
name: "Replace empty map",
dst: &struct{ S1, S2 map[string]string }{
S1: map[string]string{"key0": "dst_value0"},
S2: map[string]string{},
},
src: &struct{ S1, S2 map[string]string }{
S1: map[string]string{},
S2: map[string]string{"key0": "src_value0"},
},
out: &struct{ S1, S2 map[string]string }{
S1: map[string]string{},
S2: map[string]string{"key0": "src_value0"},
},
order: Replace,
},
{
name: "Append nil map",
dst: &struct{ S1, S2, S3 map[string]string }{
S1: map[string]string{"key0": "dst_value0"},
},
src: &struct{ S1, S2, S3 map[string]string }{
S2: map[string]string{"key0": "src_value0"},
},
out: &struct{ S1, S2, S3 map[string]string }{
S1: map[string]string{"key0": "dst_value0"},
S2: map[string]string{"key0": "src_value0"},
},
order: Append,
},
{
name: "Prepend nil map",
dst: &struct{ S1, S2, S3 map[string]string }{
S1: map[string]string{"key0": "dst_value0"},
},
src: &struct{ S1, S2, S3 map[string]string }{
S2: map[string]string{"key0": "src_value0"},
},
out: &struct{ S1, S2, S3 map[string]string }{
S1: map[string]string{"key0": "dst_value0"},
S2: map[string]string{"key0": "src_value0"},
},
order: Prepend,
},
{
name: "Replace nil map",
dst: &struct{ S1, S2, S3 map[string]string }{
S1: map[string]string{"key0": "dst_value0"},
},
src: &struct{ S1, S2, S3 map[string]string }{
S2: map[string]string{"key0": "src_value0"},
},
out: &struct{ S1, S2, S3 map[string]string }{
S1: map[string]string{"key0": "dst_value0"},
S2: map[string]string{"key0": "src_value0"},
S3: nil,
},
order: Replace,
},
{
name: "Replace slice of structs",
dst: &struct{ S []struct{ F string } }{
S: []struct{ F string }{
{F: "foo"}, {F: "bar"},
},
},
src: &struct{ S []struct{ F string } }{
S: []struct{ F string }{
{F: "baz"},
},
},
out: &struct{ S []struct{ F string } }{
S: []struct{ F string }{
{F: "baz"},
},
},
order: Replace,
},
{
name: "Append pointer",
dst: &struct{ S *struct{ S string } }{
S: &struct{ S string }{
S: "string1",
},
},
src: &struct{ S *struct{ S string } }{
S: &struct{ S string }{
S: "string2",
},
},
out: &struct{ S *struct{ S string } }{
S: &struct{ S string }{
S: "string1string2",
},
},
},
{
name: "Prepend pointer",
dst: &struct{ S *struct{ S string } }{
S: &struct{ S string }{
S: "string1",
},
},
src: &struct{ S *struct{ S string } }{
S: &struct{ S string }{
S: "string2",
},
},
out: &struct{ S *struct{ S string } }{
S: &struct{ S string }{
S: "string2string1",
},
},
order: Prepend,
},
{
name: "Append interface",
dst: &struct{ S interface{} }{
S: &struct{ S string }{
S: "string1",
},
},
src: &struct{ S interface{} }{
S: &struct{ S string }{
S: "string2",
},
},
out: &struct{ S interface{} }{
S: &struct{ S string }{
S: "string1string2",
},
},
},
{
name: "Prepend interface",
dst: &struct{ S interface{} }{
S: &struct{ S string }{
S: "string1",
},
},
src: &struct{ S interface{} }{
S: &struct{ S string }{
S: "string2",
},
},
out: &struct{ S interface{} }{
S: &struct{ S string }{
S: "string2string1",
},
},
order: Prepend,
},
{
name: "Unexported field",
dst: &struct{ s string }{
s: "string1",
},
src: &struct{ s string }{
s: "string2",
},
out: &struct{ s string }{
s: "string1",
},
},
{
name: "Unexported field",
dst: &struct{ i *int64 }{
i: Int64Ptr(33),
},
src: &struct{ i *int64 }{
i: Int64Ptr(5),
},
out: &struct{ i *int64 }{
i: Int64Ptr(33),
},
},
{
name: "Empty struct",
dst: &struct{}{},
src: &struct{}{},
out: &struct{}{},
},
{
name: "Interface nil",
dst: &struct{ S interface{} }{
S: nil,
},
src: &struct{ S interface{} }{
S: nil,
},
out: &struct{ S interface{} }{
S: nil,
},
},
{
name: "Pointer nil",
dst: &struct{ S *struct{} }{
S: nil,
},
src: &struct{ S *struct{} }{
S: nil,
},
out: &struct{ S *struct{} }{
S: nil,
},
},
{
name: "Anonymous struct",
dst: &struct {
EmbeddedStruct
Nested struct{ EmbeddedStruct }
}{
EmbeddedStruct: EmbeddedStruct{
S: "string1",
I: Int64Ptr(55),
},
Nested: struct{ EmbeddedStruct }{
EmbeddedStruct: EmbeddedStruct{
S: "string2",
I: Int64Ptr(-4),
},
},
},
src: &struct {
EmbeddedStruct
Nested struct{ EmbeddedStruct }
}{
EmbeddedStruct: EmbeddedStruct{
S: "string3",
I: Int64Ptr(66),
},
Nested: struct{ EmbeddedStruct }{
EmbeddedStruct: EmbeddedStruct{
S: "string4",
I: Int64Ptr(-8),
},
},
},
out: &struct {
EmbeddedStruct
Nested struct{ EmbeddedStruct }
}{
EmbeddedStruct: EmbeddedStruct{
S: "string1string3",
I: Int64Ptr(66),
},
Nested: struct{ EmbeddedStruct }{
EmbeddedStruct: EmbeddedStruct{
S: "string2string4",
I: Int64Ptr(-8),
},
},
},
},
{
name: "BlueprintEmbed struct",
dst: &struct {
BlueprintEmbed EmbeddedStruct
Nested struct{ BlueprintEmbed EmbeddedStruct }
}{
BlueprintEmbed: EmbeddedStruct{
S: "string1",
I: Int64Ptr(55),
},
Nested: struct{ BlueprintEmbed EmbeddedStruct }{
BlueprintEmbed: EmbeddedStruct{
S: "string2",
I: Int64Ptr(-4),
},
},
},
src: &struct {
BlueprintEmbed EmbeddedStruct
Nested struct{ BlueprintEmbed EmbeddedStruct }
}{
BlueprintEmbed: EmbeddedStruct{
S: "string3",
I: Int64Ptr(66),
},
Nested: struct{ BlueprintEmbed EmbeddedStruct }{
BlueprintEmbed: EmbeddedStruct{
S: "string4",
I: Int64Ptr(-8),
},
},
},
out: &struct {
BlueprintEmbed EmbeddedStruct
Nested struct{ BlueprintEmbed EmbeddedStruct }
}{
BlueprintEmbed: EmbeddedStruct{
S: "string1string3",
I: Int64Ptr(66),
},
Nested: struct{ BlueprintEmbed EmbeddedStruct }{
BlueprintEmbed: EmbeddedStruct{
S: "string2string4",
I: Int64Ptr(-8),
},
},
},
},
{
name: "Anonymous interface",
dst: &struct {
EmbeddedInterface
Nested struct{ EmbeddedInterface }
}{
EmbeddedInterface: &struct {
S string
I *int64
}{
S: "string1",
I: Int64Ptr(-8),
},
Nested: struct{ EmbeddedInterface }{
EmbeddedInterface: &struct {
S string
I *int64
}{
S: "string2",
I: Int64Ptr(55),
},
},
},
src: &struct {
EmbeddedInterface
Nested struct{ EmbeddedInterface }
}{
EmbeddedInterface: &struct {
S string
I *int64
}{
S: "string3",
I: Int64Ptr(6),
},
Nested: struct{ EmbeddedInterface }{
EmbeddedInterface: &struct {
S string
I *int64
}{
S: "string4",
I: Int64Ptr(6),
},
},
},
out: &struct {
EmbeddedInterface
Nested struct{ EmbeddedInterface }
}{
EmbeddedInterface: &struct {
S string
I *int64
}{
S: "string1string3",
I: Int64Ptr(6),
},
Nested: struct{ EmbeddedInterface }{
EmbeddedInterface: &struct {
S string
I *int64
}{
S: "string2string4",
I: Int64Ptr(6),
},
},
},
},
{
name: "Nil pointer to a struct",
dst: &struct {
Nested *struct {
S string
}
}{},
src: &struct {
Nested *struct {
S string
}
}{
Nested: &struct {
S string
}{
S: "string",
},
},
out: &struct {
Nested *struct {
S string
}
}{
Nested: &struct {
S string
}{
S: "string",
},
},
},
{
name: "Nil pointer to a struct in an interface",
dst: &struct {
Nested interface{}
}{
Nested: (*struct{ S string })(nil),
},
src: &struct {
Nested interface{}
}{
Nested: &struct {
S string
}{
S: "string",
},
},
out: &struct {
Nested interface{}
}{
Nested: &struct {
S string
}{
S: "string",
},
},
},
{
name: "Interface src nil",
dst: &struct{ S interface{} }{
S: &struct{ S string }{
S: "string1",
},
},
src: &struct{ S interface{} }{
S: nil,
},
out: &struct{ S interface{} }{
S: &struct{ S string }{
S: "string1",
},
},
},
// Errors
{
name: "Non-pointer dst",
dst: struct{}{},
src: &struct{}{},
err: errors.New("expected pointer to struct, got struct {}"),
out: struct{}{},
},
{
name: "Non-pointer src",
dst: &struct{}{},
src: struct{}{},
err: errors.New("expected pointer to struct, got struct {}"),
out: &struct{}{},
},
{
name: "Non-struct dst",
dst: &[]string{"bad"},
src: &struct{}{},
err: errors.New("expected pointer to struct, got *[]string"),
out: &[]string{"bad"},
},
{
name: "Non-struct src",
dst: &struct{}{},
src: &[]string{"bad"},
err: errors.New("expected pointer to struct, got *[]string"),
out: &struct{}{},
},
{
name: "Mismatched types",
dst: &struct{ A string }{
A: "string1",
},
src: &struct{ B string }{
B: "string2",
},
out: &struct{ A string }{
A: "string1",
},
err: errors.New("expected matching types for dst and src, got *struct { A string } and *struct { B string }"),
},
{
name: "Unsupported kind",
dst: &struct{ I int }{
I: 1,
},
src: &struct{ I int }{
I: 2,
},
out: &struct{ I int }{
I: 1,
},
err: extendPropertyErrorf("i", "unsupported kind int"),
},
{
name: "Unsupported kind",
dst: &struct{ I int64 }{
I: 1,
},
src: &struct{ I int64 }{
I: 2,
},
out: &struct{ I int64 }{
I: 1,
},
err: extendPropertyErrorf("i", "unsupported kind int64"),
},
{
name: "Interface nilitude mismatch",
dst: &struct{ S interface{} }{
S: nil,
},
src: &struct{ S interface{} }{
S: &struct{ S string }{
S: "string1",
},
},
out: &struct{ S interface{} }{
S: nil,
},
err: extendPropertyErrorf("s", "nilitude mismatch"),
},
{
name: "Interface type mismatch",
dst: &struct{ S interface{} }{
S: &struct{ A string }{
A: "string1",
},
},
src: &struct{ S interface{} }{
S: &struct{ B string }{
B: "string2",
},
},
out: &struct{ S interface{} }{
S: &struct{ A string }{
A: "string1",
},
},
err: extendPropertyErrorf("s", "mismatched types struct { A string } and struct { B string }"),
},
{
name: "Interface not a pointer",
dst: &struct{ S interface{} }{
S: struct{ S string }{
S: "string1",
},
},
src: &struct{ S interface{} }{
S: struct{ S string }{
S: "string2",
},
},
out: &struct{ S interface{} }{
S: struct{ S string }{
S: "string1",
},
},
err: extendPropertyErrorf("s", "interface not a pointer"),
},
{
name: "Pointer not a struct",
dst: &struct{ S *[]string }{
S: &[]string{"string1"},
},
src: &struct{ S *[]string }{
S: &[]string{"string2"},
},
out: &struct{ S *[]string }{
S: &[]string{"string1"},
},
err: extendPropertyErrorf("s", "pointer is a slice"),
},
{
name: "Error in nested struct",
dst: &struct{ S interface{} }{
S: &struct{ I int }{
I: 1,
},
},
src: &struct{ S interface{} }{
S: &struct{ I int }{
I: 2,
},
},
out: &struct{ S interface{} }{
S: &struct{ I int }{
I: 1,
},
},
err: extendPropertyErrorf("s.i", "unsupported kind int"),
},
// Filters
{
name: "Filter true",
dst: &struct{ S string }{
S: "string1",
},
src: &struct{ S string }{
S: "string2",
},
out: &struct{ S string }{
S: "string1string2",
},
filter: func(dstField, srcField reflect.StructField) (bool, error) {
return true, nil
},
},
{
name: "Filter false",
dst: &struct{ S string }{
S: "string1",
},
src: &struct{ S string }{
S: "string2",
},
out: &struct{ S string }{
S: "string1",
},
filter: func(dstField, srcField reflect.StructField) (bool, error) {
return false, nil
},
},
{
name: "Filter check args",
dst: &struct{ S string }{
S: "string1",
},
src: &struct{ S string }{
S: "string2",
},
out: &struct{ S string }{
S: "string1string2",
},
filter: func(dstField, srcField reflect.StructField) (bool, error) {
return dstField.Name == "S" && srcField.Name == "S", nil
},
},
{
name: "Filter mutated",
dst: &struct {
S string `blueprint:"mutated"`
}{
S: "string1",
},
src: &struct {
S string `blueprint:"mutated"`
}{
S: "string2",
},
out: &struct {
S string `blueprint:"mutated"`
}{
S: "string1",
},
},
{
name: "Filter mutated",
dst: &struct {
S *int64 `blueprint:"mutated"`
}{
S: Int64Ptr(4),
},
src: &struct {
S *int64 `blueprint:"mutated"`
}{
S: Int64Ptr(5),
},
out: &struct {
S *int64 `blueprint:"mutated"`
}{
S: Int64Ptr(4),
},
},
{
name: "Filter error",
dst: &struct{ S string }{
S: "string1",
},
src: &struct{ S string }{
S: "string2",
},
out: &struct{ S string }{
S: "string1",
},
filter: func(dstField, srcField reflect.StructField) (bool, error) {
return true, fmt.Errorf("filter error")
},
err: extendPropertyErrorf("s", "filter error"),
},
{
name: "Append configurable",
dst: &struct{ S Configurable[[]string] }{
S: Configurable[[]string]{
typ: parser.SelectTypeSoongConfigVariable,
condition: "foo",
cases: map[string][]string{
"a": {"1", "2"},
},
appendWrapper: &appendWrapper[[]string]{},
},
},
src: &struct{ S Configurable[[]string] }{
S: Configurable[[]string]{
typ: parser.SelectTypeReleaseVariable,
condition: "bar",
cases: map[string][]string{
"b": {"3", "4"},
},
appendWrapper: &appendWrapper[[]string]{},
},
},
out: &struct{ S Configurable[[]string] }{
S: Configurable[[]string]{
typ: parser.SelectTypeSoongConfigVariable,
condition: "foo",
cases: map[string][]string{
"a": {"1", "2"},
},
appendWrapper: &appendWrapper[[]string]{
append: Configurable[[]string]{
typ: parser.SelectTypeReleaseVariable,
condition: "bar",
cases: map[string][]string{
"b": {"3", "4"},
},
appendWrapper: &appendWrapper[[]string]{},
},
},
},
},
},
{
name: "Prepend configurable",
order: Prepend,
dst: &struct{ S Configurable[[]string] }{
S: Configurable[[]string]{
typ: parser.SelectTypeSoongConfigVariable,
condition: "foo",
cases: map[string][]string{
"a": {"1", "2"},
},
appendWrapper: &appendWrapper[[]string]{},
},
},
src: &struct{ S Configurable[[]string] }{
S: Configurable[[]string]{
typ: parser.SelectTypeReleaseVariable,
condition: "bar",
cases: map[string][]string{
"b": {"3", "4"},
},
appendWrapper: &appendWrapper[[]string]{},
},
},
out: &struct{ S Configurable[[]string] }{
S: Configurable[[]string]{
typ: parser.SelectTypeReleaseVariable,
condition: "bar",
cases: map[string][]string{
"b": {"3", "4"},
},
appendWrapper: &appendWrapper[[]string]{
append: Configurable[[]string]{
typ: parser.SelectTypeSoongConfigVariable,
condition: "foo",
cases: map[string][]string{
"a": {"1", "2"},
},
appendWrapper: &appendWrapper[[]string]{},
},
},
},
},
},
}
}
func TestAppendProperties(t *testing.T) {
for _, testCase := range appendPropertiesTestCases() {
t.Run(testCase.name, func(t *testing.T) {
got := testCase.dst
var err error
var testType string
switch testCase.order {
case Append:
testType = "append"
err = AppendProperties(got, testCase.src, testCase.filter)
case Prepend:
testType = "prepend"
err = PrependProperties(got, testCase.src, testCase.filter)
case Replace:
testType = "replace"
err = ExtendProperties(got, testCase.src, testCase.filter, OrderReplace)
}
check(t, testType, testCase.name, got, err, testCase.out, testCase.err)
})
}
}
func TestExtendProperties(t *testing.T) {
for _, testCase := range appendPropertiesTestCases() {
t.Run(testCase.name, func(t *testing.T) {
got := testCase.dst
var err error
var testType string
order := func(dstField, srcField reflect.StructField) (Order, error) {
switch testCase.order {
case Append:
return Append, nil
case Prepend:
return Prepend, nil
case Replace:
return Replace, nil
}
return Append, errors.New("unknown order")
}
switch testCase.order {
case Append:
testType = "prepend"
case Prepend:
testType = "append"
case Replace:
testType = "replace"
}
err = ExtendProperties(got, testCase.src, testCase.filter, order)
check(t, testType, testCase.name, got, err, testCase.out, testCase.err)
})
}
}
type appendMatchingPropertiesTestCase struct {
name string
dst []interface{}
src interface{}
out []interface{}
order Order // default is Append
filter ExtendPropertyFilterFunc
err error
}
func appendMatchingPropertiesTestCases() []appendMatchingPropertiesTestCase {
return []appendMatchingPropertiesTestCase{
{
name: "Append strings",
dst: []interface{}{&struct{ S string }{
S: "string1",
}},
src: &struct{ S string }{
S: "string2",
},
out: []interface{}{&struct{ S string }{
S: "string1string2",
}},
},
{
name: "Prepend strings",
dst: []interface{}{&struct{ S string }{
S: "string1",
}},
src: &struct{ S string }{
S: "string2",
},
out: []interface{}{&struct{ S string }{
S: "string2string1",
}},
order: Prepend,
},
{
name: "Append all",
dst: []interface{}{
&struct{ S, A string }{
S: "string1",
},
&struct{ S, B string }{
S: "string2",
},
},
src: &struct{ S string }{
S: "string3",
},
out: []interface{}{
&struct{ S, A string }{
S: "string1string3",
},
&struct{ S, B string }{
S: "string2string3",
},
},
},
{
name: "Append some",
dst: []interface{}{
&struct{ S, A string }{
S: "string1",
},
&struct{ B string }{},
},
src: &struct{ S string }{
S: "string2",
},
out: []interface{}{
&struct{ S, A string }{
S: "string1string2",
},
&struct{ B string }{},
},
},
{
name: "Append mismatched structs",
dst: []interface{}{&struct{ S, A string }{
S: "string1",
}},
src: &struct{ S string }{
S: "string2",
},
out: []interface{}{&struct{ S, A string }{
S: "string1string2",
}},
},
{
name: "Append mismatched pointer structs",
dst: []interface{}{&struct{ S *struct{ S, A string } }{
S: &struct{ S, A string }{
S: "string1",
},
}},
src: &struct{ S *struct{ S string } }{
S: &struct{ S string }{
S: "string2",
},
},
out: []interface{}{&struct{ S *struct{ S, A string } }{
S: &struct{ S, A string }{
S: "string1string2",
},
}},
},
{
name: "Append through mismatched types",
dst: []interface{}{
&struct{ B string }{},
&struct{ S interface{} }{
S: &struct{ S, A string }{
S: "string1",
},
},
},
src: &struct{ S struct{ S string } }{
S: struct{ S string }{
S: "string2",
},
},
out: []interface{}{
&struct{ B string }{},
&struct{ S interface{} }{
S: &struct{ S, A string }{
S: "string1string2",
},
},
},
},
{
name: "Append through mismatched types and nil",
dst: []interface{}{
&struct{ B string }{},
&struct{ S interface{} }{
S: (*struct{ S, A string })(nil),
},
},
src: &struct{ S struct{ S string } }{
S: struct{ S string }{
S: "string2",
},
},
out: []interface{}{
&struct{ B string }{},
&struct{ S interface{} }{
S: &struct{ S, A string }{
S: "string2",
},
},
},
},
{
name: "Append through multiple matches",
dst: []interface{}{
&struct {
S struct{ S, A string }
}{
S: struct{ S, A string }{
S: "string1",
},
},
&struct {
S struct{ S, B string }
}{
S: struct{ S, B string }{
S: "string2",
},
},
},
src: &struct{ S struct{ B string } }{
S: struct{ B string }{
B: "string3",
},
},
out: []interface{}{
&struct {
S struct{ S, A string }
}{
S: struct{ S, A string }{
S: "string1",
},
},
&struct {
S struct{ S, B string }
}{
S: struct{ S, B string }{
S: "string2",
B: "string3",
},
},
},
},
{
name: "Append through embedded struct",
dst: []interface{}{
&struct{ B string }{},
&struct{ EmbeddedStruct }{
EmbeddedStruct: EmbeddedStruct{
S: "string1",
},
},
},
src: &struct{ S string }{
S: "string2",
},
out: []interface{}{
&struct{ B string }{},
&struct{ EmbeddedStruct }{
EmbeddedStruct: EmbeddedStruct{
S: "string1string2",
},
},
},
},
{
name: "Append through BlueprintEmbed struct",
dst: []interface{}{
&struct{ B string }{},
&struct{ BlueprintEmbed EmbeddedStruct }{
BlueprintEmbed: EmbeddedStruct{
S: "string1",
},
},
},
src: &struct{ S string }{
S: "string2",
},
out: []interface{}{
&struct{ B string }{},
&struct{ BlueprintEmbed EmbeddedStruct }{
BlueprintEmbed: EmbeddedStruct{
S: "string1string2",
},
},
},
},
{
name: "Append through embedded pointer to struct",
dst: []interface{}{
&struct{ B string }{},
&struct{ *EmbeddedStruct }{
EmbeddedStruct: &EmbeddedStruct{
S: "string1",
},
},
},
src: &struct{ S string }{
S: "string2",
},
out: []interface{}{
&struct{ B string }{},
&struct{ *EmbeddedStruct }{
EmbeddedStruct: &EmbeddedStruct{
S: "string1string2",
},
},
},
},
{
name: "Append through BlueprintEmbed pointer to struct",
dst: []interface{}{
&struct{ B string }{},
&struct{ BlueprintEmbed *EmbeddedStruct }{
BlueprintEmbed: &EmbeddedStruct{
S: "string1",
},
},
},
src: &struct{ S string }{
S: "string2",
},
out: []interface{}{
&struct{ B string }{},
&struct{ BlueprintEmbed *EmbeddedStruct }{
BlueprintEmbed: &EmbeddedStruct{
S: "string1string2",
},
},
},
},
{
name: "Append through embedded nil pointer to struct",
dst: []interface{}{
&struct{ B string }{},
&struct{ *EmbeddedStruct }{},
},
src: &struct{ S string }{
S: "string2",
},
out: []interface{}{
&struct{ B string }{},
&struct{ *EmbeddedStruct }{
EmbeddedStruct: &EmbeddedStruct{
S: "string2",
},
},
},
},
{
name: "Append through BlueprintEmbed nil pointer to struct",
dst: []interface{}{
&struct{ B string }{},
&struct{ BlueprintEmbed *EmbeddedStruct }{},
},
src: &struct{ S string }{
S: "string2",
},
out: []interface{}{
&struct{ B string }{},
&struct{ BlueprintEmbed *EmbeddedStruct }{
BlueprintEmbed: &EmbeddedStruct{
S: "string2",
},
},
},
},
// Errors
{
name: "Non-pointer dst",
dst: []interface{}{struct{}{}},
src: &struct{}{},
err: errors.New("expected pointer to struct, got struct {}"),
out: []interface{}{struct{}{}},
},
{
name: "Non-pointer src",
dst: []interface{}{&struct{}{}},
src: struct{}{},
err: errors.New("expected pointer to struct, got struct {}"),
out: []interface{}{&struct{}{}},
},
{
name: "Non-struct dst",
dst: []interface{}{&[]string{"bad"}},
src: &struct{}{},
err: errors.New("expected pointer to struct, got *[]string"),
out: []interface{}{&[]string{"bad"}},
},
{
name: "Non-struct src",
dst: []interface{}{&struct{}{}},
src: &[]string{"bad"},
err: errors.New("expected pointer to struct, got *[]string"),
out: []interface{}{&struct{}{}},
},
{
name: "Append none",
dst: []interface{}{
&struct{ A string }{},
&struct{ B string }{},
},
src: &struct{ S string }{
S: "string1",
},
out: []interface{}{
&struct{ A string }{},
&struct{ B string }{},
},
err: extendPropertyErrorf("s", "failed to find property to extend"),
},
{
name: "Append mismatched kinds",
dst: []interface{}{
&struct{ S string }{
S: "string1",
},
},
src: &struct{ S []string }{
S: []string{"string2"},
},
out: []interface{}{
&struct{ S string }{
S: "string1",
},
},
err: extendPropertyErrorf("s", "mismatched types string and []string"),
},
{
name: "Append mismatched types",
dst: []interface{}{
&struct{ S []int }{
S: []int{1},
},
},
src: &struct{ S []string }{
S: []string{"string2"},
},
out: []interface{}{
&struct{ S []int }{
S: []int{1},
},
},
err: extendPropertyErrorf("s", "mismatched types []int and []string"),
},
}
}
func TestAppendMatchingProperties(t *testing.T) {
for _, testCase := range appendMatchingPropertiesTestCases() {
t.Run(testCase.name, func(t *testing.T) {
got := testCase.dst
var err error
var testType string
switch testCase.order {
case Append:
testType = "append"
err = AppendMatchingProperties(got, testCase.src, testCase.filter)
case Prepend:
testType = "prepend"
err = PrependMatchingProperties(got, testCase.src, testCase.filter)
case Replace:
testType = "replace"
err = ExtendMatchingProperties(got, testCase.src, testCase.filter, OrderReplace)
}
check(t, testType, testCase.name, got, err, testCase.out, testCase.err)
})
}
}
func TestExtendMatchingProperties(t *testing.T) {
for _, testCase := range appendMatchingPropertiesTestCases() {
t.Run(testCase.name, func(t *testing.T) {
got := testCase.dst
var err error
var testType string
order := func(dstField, srcField reflect.StructField) (Order, error) {
switch testCase.order {
case Append:
return Append, nil
case Prepend:
return Prepend, nil
case Replace:
return Replace, nil
}
return Append, errors.New("unknown order")
}
switch testCase.order {
case Append:
testType = "prepend matching"
case Prepend:
testType = "append matching"
case Replace:
testType = "replace matching"
}
err = ExtendMatchingProperties(got, testCase.src, testCase.filter, order)
check(t, testType, testCase.name, got, err, testCase.out, testCase.err)
})
}
}
func check(t *testing.T, testType, testString string,
got interface{}, err error,
expected interface{}, expectedErr error) {
printedTestCase := false
e := func(s string, expected, got interface{}) {
if !printedTestCase {
t.Errorf("test case %s: %s", testType, testString)
printedTestCase = true
}
t.Errorf("incorrect %s", s)
t.Errorf(" expected: %s", p(expected))
t.Errorf(" got: %s", p(got))
}
if err != nil {
if expectedErr != nil {
if err.Error() != expectedErr.Error() {
e("unexpected error", expectedErr.Error(), err.Error())
}
} else {
e("unexpected error", nil, err.Error())
}
} else {
if expectedErr != nil {
e("missing error", expectedErr, nil)
}
}
if !reflect.DeepEqual(expected, got) {
e("output:", expected, got)
}
}
func p(in interface{}) string {
if v, ok := in.([]interface{}); ok {
s := make([]string, len(v))
for i := range v {
s[i] = fmt.Sprintf("%#v", v[i])
}
return "[" + strings.Join(s, ", ") + "]"
} else {
return fmt.Sprintf("%#v", in)
}
}
Reference in a new issue View git blame Copy permalink