| // 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" |
| ) |
| |
| 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(property string, |
| dstField, srcField reflect.StructField, |
| dstValue, srcValue interface{}) (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(property string, |
| dstField, srcField reflect.StructField, |
| dstValue, srcValue interface{}) (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(property string, |
| dstField, srcField reflect.StructField, |
| dstValue, srcValue interface{}) (bool, error) { |
| return property == "s" && |
| dstField.Name == "S" && srcField.Name == "S" && |
| dstValue.(string) == "string1" && srcValue.(string) == "string2", 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(property string, |
| dstField, srcField reflect.StructField, |
| dstValue, srcValue interface{}) (bool, error) { |
| return true, fmt.Errorf("filter error") |
| }, |
| err: extendPropertyErrorf("s", "filter error"), |
| }, |
| } |
| } |
| |
| 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(property string, |
| dstField, srcField reflect.StructField, |
| dstValue, srcValue interface{}) (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(property string, |
| dstField, srcField reflect.StructField, |
| dstValue, srcValue interface{}) (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) |
| } |
| } |