| /* |
| Copyright 2019 The Kubernetes Authors. |
| |
| 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 value |
| |
| import ( |
| "encoding/base64" |
| "encoding/json" |
| "fmt" |
| "reflect" |
| "sort" |
| "testing" |
| "time" |
| ) |
| |
| func MustReflect(i interface{}) Value { |
| if i == nil { |
| return NewValueInterface(nil) |
| } |
| v, err := wrapValueReflect(reflect.ValueOf(i), nil, nil) |
| if err != nil { |
| panic(err) |
| } |
| return v |
| } |
| |
| func TestReflectPrimitives(t *testing.T) { |
| rv := MustReflect("string") |
| if !rv.IsString() { |
| t.Error("expected IsString to be true") |
| } |
| if rv.AsString() != "string" { |
| t.Errorf("expected rv.String to be 'string' but got %v", rv.Unstructured()) |
| } |
| |
| rv = MustReflect([]byte("string")) |
| if !rv.IsString() { |
| t.Error("expected IsString to be true") |
| } |
| if rv.IsList() { |
| t.Error("expected IsList to be false ([]byte is represented as a base64 encoded string)") |
| } |
| encoded := base64.StdEncoding.EncodeToString([]byte("string")) |
| if rv.AsString() != encoded { |
| t.Errorf("expected rv.String to be %v but got %v", []byte(encoded), rv.Unstructured()) |
| } |
| |
| rv = MustReflect(1) |
| if !rv.IsInt() { |
| t.Error("expected IsInt to be true") |
| } |
| if rv.AsInt() != 1 { |
| t.Errorf("expected rv.Int to be 1 but got %v", rv.Unstructured()) |
| } |
| |
| rv = MustReflect(uint32(3000000000)) |
| if !rv.IsInt() { |
| t.Error("expected IsInt to be true") |
| } |
| if rv.AsInt() != 3000000000 { |
| t.Errorf("expected rv.Int to be 3000000000 but got %v", rv.Unstructured()) |
| } |
| |
| rv = MustReflect(1.5) |
| if !rv.IsFloat() { |
| t.Error("expected IsFloat to be true") |
| } |
| if rv.AsFloat() != 1.5 { |
| t.Errorf("expected rv.Float to be 1.1 but got %v", rv.Unstructured()) |
| } |
| |
| rv = MustReflect(true) |
| if !rv.IsBool() { |
| t.Error("expected IsBool to be true") |
| } |
| if rv.AsBool() != true { |
| t.Errorf("expected rv.Bool to be true but got %v", rv.Unstructured()) |
| } |
| |
| rv = MustReflect(nil) |
| if !rv.IsNull() { |
| t.Error("expected IsNull to be true") |
| } |
| } |
| |
| type Convertable struct { |
| Value interface{} |
| } |
| |
| func (t Convertable) MarshalJSON() ([]byte, error) { |
| return json.Marshal(t.Value) |
| } |
| |
| func (t Convertable) UnmarshalJSON(data []byte) error { |
| return json.Unmarshal(data, &t.Value) |
| } |
| |
| type PtrConvertable struct { |
| Value interface{} |
| } |
| |
| func (t *PtrConvertable) MarshalJSON() ([]byte, error) { |
| return json.Marshal(t.Value) |
| } |
| |
| func (t *PtrConvertable) UnmarshalJSON(data []byte) error { |
| return json.Unmarshal(data, &t.Value) |
| } |
| |
| type StringConvertable struct { |
| Value string |
| } |
| |
| func (t StringConvertable) MarshalJSON() ([]byte, error) { |
| return json.Marshal(t.Value) |
| } |
| |
| func (t StringConvertable) ToUnstructured() (string, bool) { |
| return t.Value, true |
| } |
| |
| type PtrStringConvertable struct { |
| Value string |
| } |
| |
| func (t PtrStringConvertable) MarshalJSON() ([]byte, error) { |
| return json.Marshal(t.Value) |
| } |
| |
| func (t *PtrStringConvertable) ToUnstructured() (string, bool) { |
| return t.Value, true |
| } |
| |
| func TestReflectCustomStringConversion(t *testing.T) { |
| dateTime, err := time.Parse(time.RFC3339, "2006-01-02T15:04:05+07:00") |
| if err != nil { |
| t.Fatal(err) |
| } |
| cases := []struct { |
| name string |
| convertable interface{} |
| expected interface{} |
| }{ |
| { |
| name: "marshalable-struct", |
| convertable: Convertable{Value: "struct-test"}, |
| expected: "struct-test", |
| }, |
| { |
| name: "marshalable-pointer", |
| convertable: &PtrConvertable{Value: "pointer-test"}, |
| expected: "pointer-test", |
| }, |
| { |
| name: "pointer-to-marshalable-struct", |
| convertable: &Convertable{Value: "pointer-test"}, |
| expected: "pointer-test", |
| }, |
| { |
| name: "string-convertable-struct", |
| convertable: StringConvertable{Value: "struct-test"}, |
| expected: "struct-test", |
| }, |
| { |
| name: "string-convertable-pointer", |
| convertable: &PtrStringConvertable{Value: "struct-test"}, |
| expected: "struct-test", |
| }, |
| { |
| name: "pointer-to-string-convertable-struct", |
| convertable: &StringConvertable{Value: "pointer-test"}, |
| expected: "pointer-test", |
| }, |
| { |
| name: "time", |
| convertable: dateTime, |
| expected: "2006-01-02T15:04:05+07:00", |
| }, |
| { |
| name: "nil-marshalable-struct", |
| convertable: Convertable{Value: nil}, |
| expected: nil, |
| }, |
| } |
| for _, tc := range cases { |
| t.Run(tc.name, func(t *testing.T) { |
| rv := MustReflect(tc.convertable) |
| if rv.Unstructured() != tc.expected { |
| t.Errorf("expected rv.String to be %v but got %s", tc.expected, rv.AsString()) |
| } |
| }) |
| } |
| } |
| |
| func TestReflectPointers(t *testing.T) { |
| s := "string" |
| rv := MustReflect(&s) |
| if !rv.IsString() { |
| t.Error("expected IsString to be true") |
| } |
| if rv.AsString() != "string" { |
| t.Errorf("expected rv.String to be 'string' but got %s", rv.AsString()) |
| } |
| } |
| |
| type T struct { |
| I int64 `json:"int"` |
| } |
| |
| type emptyStruct struct{} |
| type testBasicStruct struct { |
| I int64 `json:"int"` |
| S string |
| } |
| type testOmitStruct struct { |
| I int64 `json:"-"` |
| S string |
| } |
| type testInlineStruct struct { |
| Inline T `json:",inline"` |
| S string |
| } |
| type testOmitemptyStruct struct { |
| Noomit *string `json:"noomit"` |
| Omit *string `json:"omit,omitempty"` |
| } |
| type testEmbeddedStruct struct { |
| *testBasicStruct `json:",inline"` |
| } |
| |
| func TestReflectStruct(t *testing.T) { |
| cases := []struct { |
| name string |
| val interface{} |
| expectedMap map[string]interface{} |
| expectedUnstructured interface{} |
| }{ |
| { |
| name: "empty", |
| val: emptyStruct{}, |
| expectedMap: map[string]interface{}{}, |
| expectedUnstructured: map[string]interface{}{}, |
| }, |
| { |
| name: "basic", |
| val: testBasicStruct{I: 10, S: "string"}, |
| expectedMap: map[string]interface{}{"int": int64(10), "S": "string"}, |
| expectedUnstructured: map[string]interface{}{"int": int64(10), "S": "string"}, |
| }, |
| { |
| name: "pointerToBasic", |
| val: &testBasicStruct{I: 10, S: "string"}, |
| expectedMap: map[string]interface{}{"int": int64(10), "S": "string"}, |
| expectedUnstructured: map[string]interface{}{"int": int64(10), "S": "string"}, |
| }, |
| { |
| name: "omit", |
| val: testOmitStruct{I: 10, S: "string"}, |
| expectedMap: map[string]interface{}{"S": "string"}, |
| expectedUnstructured: map[string]interface{}{"S": "string"}, |
| }, |
| { |
| name: "inline", |
| val: &testInlineStruct{Inline: T{I: 10}, S: "string"}, |
| expectedMap: map[string]interface{}{"int": int64(10), "S": "string"}, |
| expectedUnstructured: map[string]interface{}{"int": int64(10), "S": "string"}, |
| }, |
| { |
| name: "omitempty", |
| val: testOmitemptyStruct{Noomit: nil, Omit: nil}, |
| expectedMap: map[string]interface{}{"noomit": (*string)(nil)}, |
| expectedUnstructured: map[string]interface{}{"noomit": nil}, |
| }, |
| { |
| name: "embedded", |
| val: testEmbeddedStruct{&testBasicStruct{I: 10, S: "string"}}, |
| expectedMap: map[string]interface{}{"int": int64(10), "S": "string"}, |
| expectedUnstructured: map[string]interface{}{"int": int64(10), "S": "string"}, |
| }, |
| } |
| |
| for _, tc := range cases { |
| t.Run(tc.name, func(t *testing.T) { |
| rv := MustReflect(tc.val) |
| if !rv.IsMap() { |
| t.Error("expected IsMap to be true") |
| } |
| m := rv.AsMap() |
| if m.Length() != len(tc.expectedMap) { |
| t.Errorf("expected map to be of length %d but got %d", len(tc.expectedMap), m.Length()) |
| } |
| iterateResult := map[string]interface{}{} |
| m.Iterate(func(s string, value Value) bool { |
| iterateResult[s] = value.(*valueReflect).Value.Interface() |
| return true |
| }) |
| if !reflect.DeepEqual(iterateResult, tc.expectedMap) { |
| t.Errorf("expected iterate to produce %#v but got %#v", tc.expectedMap, iterateResult) |
| } |
| |
| unstructured := rv.Unstructured() |
| if !reflect.DeepEqual(unstructured, tc.expectedUnstructured) { |
| t.Errorf("expected iterate to produce %#v but got %#v", tc.expectedUnstructured, unstructured) |
| } |
| }) |
| } |
| } |
| |
| type testMutateStruct struct { |
| I1 int64 `json:"key1,omitempty"` |
| S1 string `json:"key2,omitempty"` |
| S2 string `json:"key3,omitempty"` |
| S3 string `json:"key4,omitempty"` |
| } |
| |
| func TestReflectStructMutate(t *testing.T) { |
| rv := MustReflect(&testMutateStruct{I1: 1, S1: "string1"}) |
| if !rv.IsMap() { |
| t.Error("expected IsMap to be true") |
| } |
| m := rv.AsMap() |
| atKey1, ok := m.Get("key1") |
| if !ok { |
| t.Fatalf("expected map.Get(key1) to be 1 but got !ok") |
| } |
| if atKey1.AsInt() != 1 { |
| t.Fatalf("expected map.Get(key1) to be 1 but got: %v", atKey1) |
| } |
| m.Set("key1", NewValueInterface(int64(2))) |
| m.Delete("key2") |
| m.Delete("key3") |
| m.Set("key4", NewValueInterface("string4")) |
| |
| expectedMap := map[string]interface{}{"key1": int64(2), "key4": "string4"} |
| unstructured := rv.Unstructured() |
| if !reflect.DeepEqual(unstructured, expectedMap) { |
| t.Errorf("expected %v but got: %v", expectedMap, unstructured) |
| } |
| } |
| |
| // TestReflectMutateNestedStruct ensures a structs field within various typed can be modified. |
| func TestReflectMutateNestedStruct(t *testing.T) { |
| type field struct { |
| S string `json:"s,omitempty"` |
| } |
| |
| cases := []struct { |
| fieldName string |
| root Value |
| lookupField func(root Value) Value |
| expectUpdated interface{} |
| expectDeleted interface{} |
| }{ |
| { |
| fieldName: "field", |
| root: MustReflect(&struct { |
| Field field `json:"field,omitempty"` |
| }{ |
| Field: field{S: "field"}, |
| }), |
| lookupField: func(rv Value) Value { |
| field, _ := rv.AsMap().Get("field") |
| return field |
| }, |
| expectUpdated: map[string]interface{}{ |
| "field": map[string]interface{}{"s": "updatedValue"}, |
| }, |
| expectDeleted: map[string]interface{}{ |
| "field": map[string]interface{}{}, |
| }, |
| }, |
| { |
| fieldName: "map", |
| root: MustReflect(&struct { |
| Map map[string]field `json:"map,omitempty"` |
| }{ |
| Map: map[string]field{"mapKey": {S: "mapItem"}}, |
| }), |
| lookupField: func(rv Value) Value { |
| m, _ := rv.AsMap().Get("map") |
| mapItem, _ := m.AsMap().Get("mapKey") |
| return mapItem |
| }, |
| expectUpdated: map[string]interface{}{ |
| "map": map[string]interface{}{"mapKey": map[string]interface{}{"s": "updatedValue"}}, |
| }, |
| expectDeleted: map[string]interface{}{ |
| "map": map[string]interface{}{"mapKey": map[string]interface{}{}}, |
| }, |
| }, |
| { |
| fieldName: "mapiter", |
| root: MustReflect(&struct { |
| Mapiter map[string]field `json:"mapiter,omitempty"` |
| }{ |
| Mapiter: map[string]field{"mapKey": {S: "mapItem"}}, |
| }), |
| lookupField: func(rv Value) Value { |
| mapItem := &valueReflect{} |
| m, _ := rv.AsMap().Get("mapiter") |
| m.AsMap().Iterate(func(key string, value Value) bool { |
| if key == "mapKey" { |
| *mapItem = *value.(*valueReflect) |
| return false |
| } |
| return true |
| }) |
| if !mapItem.Value.IsValid() { |
| t.Fatal("map item not found") |
| } |
| return mapItem |
| }, |
| expectUpdated: map[string]interface{}{ |
| "mapiter": map[string]interface{}{"mapKey": map[string]interface{}{"s": "updatedValue"}}, |
| }, |
| expectDeleted: map[string]interface{}{ |
| "mapiter": map[string]interface{}{"mapKey": map[string]interface{}{}}, |
| }, |
| }, |
| { |
| fieldName: "list", |
| root: MustReflect(&struct { |
| List []field `json:"list,omitempty"` |
| }{ |
| List: []field{{S: "listItem"}}, |
| }), |
| lookupField: func(rv Value) Value { |
| list, _ := rv.AsMap().Get("list") |
| return list.AsList().At(0) |
| }, |
| expectUpdated: map[string]interface{}{ |
| "list": []interface{}{map[string]interface{}{"s": "updatedValue"}}, |
| }, |
| expectDeleted: map[string]interface{}{ |
| "list": []interface{}{map[string]interface{}{}}, |
| }, |
| }, |
| { |
| fieldName: "mapOfMaps", |
| root: MustReflect(&struct { |
| MapOfMaps map[string]map[string]field `json:"mapOfMaps,omitempty"` |
| }{ |
| MapOfMaps: map[string]map[string]field{"outer": {"inner": {S: "mapOfMapItem"}}}, |
| }), |
| lookupField: func(rv Value) Value { |
| mapOfMaps, _ := rv.AsMap().Get("mapOfMaps") |
| innerMap, _ := mapOfMaps.AsMap().Get("outer") |
| mapOfMapsItem, _ := innerMap.AsMap().Get("inner") |
| return mapOfMapsItem |
| }, |
| expectUpdated: map[string]interface{}{ |
| "mapOfMaps": map[string]interface{}{"outer": map[string]interface{}{"inner": map[string]interface{}{"s": "updatedValue"}}}, |
| }, |
| expectDeleted: map[string]interface{}{ |
| "mapOfMaps": map[string]interface{}{"outer": map[string]interface{}{"inner": map[string]interface{}{}}}, |
| }, |
| }, |
| { |
| fieldName: "mapOfLists", |
| root: MustReflect(&struct { |
| MapOfLists map[string][]field `json:"mapOfLists,omitempty"` |
| }{ |
| MapOfLists: map[string][]field{"outer": {{S: "mapOfListsItem"}}}, |
| }), |
| lookupField: func(rv Value) Value { |
| mapOfLists, _ := rv.AsMap().Get("mapOfLists") |
| innerList, _ := mapOfLists.AsMap().Get("outer") |
| mapOfListsItem := innerList.AsList().At(0) |
| return mapOfListsItem |
| }, |
| |
| expectUpdated: map[string]interface{}{ |
| "mapOfLists": map[string]interface{}{"outer": []interface{}{map[string]interface{}{"s": "updatedValue"}}}, |
| }, |
| expectDeleted: map[string]interface{}{ |
| "mapOfLists": map[string]interface{}{"outer": []interface{}{map[string]interface{}{}}}, |
| }, |
| }, |
| } |
| |
| for _, tc := range cases { |
| t.Run(tc.fieldName, func(t *testing.T) { |
| root := tc.root |
| field := tc.lookupField(root) |
| field.AsMap().Set("s", NewValueInterface("updatedValue")) |
| unstructured := root.Unstructured() |
| if !reflect.DeepEqual(unstructured, tc.expectUpdated) { |
| t.Errorf("expected %v but got: %v", tc.expectUpdated, unstructured) |
| } |
| |
| field.AsMap().Delete("s") |
| unstructured = root.Unstructured() |
| if !reflect.DeepEqual(unstructured, tc.expectDeleted) { |
| t.Errorf("expected %v but got: %v", tc.expectDeleted, unstructured) |
| } |
| }) |
| } |
| } |
| |
| func TestReflectMap(t *testing.T) { |
| cases := []struct { |
| name string |
| val interface{} |
| expectedMap map[string]interface{} |
| expectedUnstructured interface{} |
| length int |
| }{ |
| { |
| name: "empty", |
| val: map[string]string{}, |
| expectedMap: map[string]interface{}{}, |
| expectedUnstructured: map[string]interface{}{}, |
| length: 0, |
| }, |
| { |
| name: "stringMap", |
| val: map[string]string{"key1": "value1", "key2": "value2"}, |
| expectedMap: map[string]interface{}{"key1": "value1", "key2": "value2"}, |
| expectedUnstructured: map[string]interface{}{"key1": "value1", "key2": "value2"}, |
| length: 2, |
| }, |
| { |
| name: "convertableMap", |
| val: map[string]Convertable{"key1": {"converted1"}, "key2": {"converted2"}}, |
| expectedMap: map[string]interface{}{"key1": "converted1", "key2": "converted2"}, |
| expectedUnstructured: map[string]interface{}{"key1": "converted1", "key2": "converted2"}, |
| length: 2, |
| }, |
| } |
| |
| for _, tc := range cases { |
| t.Run(tc.name, func(t *testing.T) { |
| rv := MustReflect(tc.val) |
| if !rv.IsMap() { |
| t.Error("expected IsMap to be true") |
| } |
| m := rv.AsMap() |
| if m.Length() != tc.length { |
| t.Errorf("expected map to be of length %d but got %d", tc.length, m.Length()) |
| } |
| iterateResult := map[string]interface{}{} |
| m.Iterate(func(s string, value Value) bool { |
| iterateResult[s] = value.AsString() |
| return true |
| }) |
| if !reflect.DeepEqual(iterateResult, tc.expectedMap) { |
| t.Errorf("expected iterate to produce %#v but got %#v", tc.expectedMap, iterateResult) |
| } |
| unstructured := rv.Unstructured() |
| if !reflect.DeepEqual(unstructured, tc.expectedUnstructured) { |
| t.Errorf("expected iterate to produce %#v but got %#v", tc.expectedUnstructured, unstructured) |
| } |
| }) |
| } |
| } |
| |
| func TestReflectMapMutate(t *testing.T) { |
| rv := MustReflect(map[string]string{"key1": "value1", "key2": "value2"}) |
| if !rv.IsMap() { |
| t.Error("expected IsMap to be true") |
| } |
| m := rv.AsMap() |
| atKey1, ok := m.Get("key1") |
| if !ok { |
| t.Errorf("expected map.Get(key1) to be 'value1' but got !ok") |
| } |
| if atKey1.AsString() != "value1" { |
| t.Errorf("expected map.Get(key1) to be 'value1' but got: %v", atKey1) |
| } |
| m.Set("key1", NewValueInterface("replacement")) |
| m.Delete("key2") |
| m.Delete("key3") |
| m.Set("key4", NewValueInterface("value4")) |
| |
| expectedMap := map[string]interface{}{"key1": "replacement", "key4": "value4"} |
| unstructured := rv.Unstructured() |
| if !reflect.DeepEqual(unstructured, expectedMap) { |
| t.Errorf("expected %v but got: %v", expectedMap, unstructured) |
| } |
| } |
| |
| func TestReflectList(t *testing.T) { |
| cases := []struct { |
| name string |
| val interface{} |
| expectedIterate []interface{} |
| expectedUnstructured interface{} |
| length int |
| }{ |
| { |
| name: "empty", |
| val: []string{}, |
| expectedIterate: []interface{}{}, |
| expectedUnstructured: []interface{}{}, |
| length: 0, |
| }, |
| { |
| name: "stringList", |
| val: []string{"value1", "value2"}, |
| expectedIterate: []interface{}{"value1", "value2"}, |
| expectedUnstructured: []interface{}{"value1", "value2"}, |
| length: 2, |
| }, |
| { |
| name: "convertableList", |
| val: []Convertable{{"converted1"}, {"converted2"}}, |
| expectedIterate: []interface{}{"converted1", "converted2"}, |
| expectedUnstructured: []interface{}{"converted1", "converted2"}, |
| length: 2, |
| }, |
| } |
| |
| for _, tc := range cases { |
| t.Run(tc.name, func(t *testing.T) { |
| rv := MustReflect(tc.val) |
| if !rv.IsList() { |
| t.Error("expected IsList to be true") |
| } |
| m := rv.AsList() |
| if m.Length() != tc.length { |
| t.Errorf("expected list to be of length %d but got %d", tc.length, m.Length()) |
| } |
| |
| l := m.Length() |
| iterateResult := make([]interface{}, l) |
| for i := 0; i < l; i++ { |
| iterateResult[i] = m.At(i).AsString() |
| } |
| if !reflect.DeepEqual(iterateResult, tc.expectedIterate) { |
| t.Errorf("expected iterate to produce %#v but got %#v", tc.expectedIterate, iterateResult) |
| } |
| |
| iter := m.Range() |
| iterateResult = make([]interface{}, l) |
| for iter.Next() { |
| i, val := iter.Item() |
| iterateResult[i] = val.AsString() |
| } |
| if !reflect.DeepEqual(iterateResult, tc.expectedIterate) { |
| t.Errorf("expected iterate to produce %#v but got %#v", tc.expectedIterate, iterateResult) |
| } |
| |
| unstructured := rv.Unstructured() |
| if !reflect.DeepEqual(unstructured, tc.expectedUnstructured) { |
| t.Errorf("expected iterate to produce %#v but got %#v", tc.expectedUnstructured, unstructured) |
| } |
| }) |
| } |
| } |
| |
| func TestReflectListAt(t *testing.T) { |
| rv := MustReflect([]string{"one", "two"}) |
| if !rv.IsList() { |
| t.Error("expected IsList to be true") |
| } |
| list := rv.AsList() |
| atOne := list.At(1) |
| if atOne.AsString() != "two" { |
| t.Errorf("expected list.At(1) to be 'two' but got: %v", atOne) |
| } |
| } |
| |
| func TestMapZip(t *testing.T) { |
| type entry struct { |
| key string |
| lhs, rhs interface{} |
| } |
| |
| type s struct { |
| // deliberately unordered |
| C string `json:"c,omitempty"` |
| B string `json:"b,omitempty"` |
| D string `json:"d,omitempty"` |
| A string `json:"a,omitempty"` |
| } |
| cases := []struct { |
| name string |
| lhs interface{} |
| rhs interface{} |
| expectedZipped []entry |
| }{ |
| { |
| name: "structZip", |
| lhs: &s{A: "1", B: "3", C: "5"}, |
| rhs: &s{A: "2", B: "4", D: "6"}, |
| expectedZipped: []entry{ |
| {"a", "1", "2"}, |
| {"b", "3", "4"}, |
| {"c", "5", interface{}(nil)}, |
| {"d", interface{}(nil), "6"}, |
| }, |
| }, |
| { |
| name: "mapZip", |
| lhs: &map[string]interface{}{"a": "1", "b": "3", "c": "5"}, |
| rhs: &map[string]interface{}{"a": "2", "b": "4", "d": "6"}, |
| expectedZipped: []entry{ |
| {"a", "1", "2"}, |
| {"b", "3", "4"}, |
| {"c", "5", interface{}(nil)}, |
| {"d", interface{}(nil), "6"}, |
| }, |
| }, |
| } |
| |
| for _, tc := range cases { |
| t.Run(tc.name, func(t *testing.T) { |
| lhs := MustReflect(tc.lhs) |
| rhs := MustReflect(tc.rhs) |
| for _, lhs := range []Value{lhs, NewValueInterface(lhs.Unstructured())} { |
| for _, rhs := range []Value{rhs, NewValueInterface(rhs.Unstructured())} { |
| t.Run(fmt.Sprintf("%s-%s", reflect.TypeOf(lhs).Elem().Name(), reflect.TypeOf(rhs).Elem().Name()), func(t *testing.T) { |
| for _, order := range []MapTraverseOrder{Unordered, LexicalKeyOrder} { |
| var zipped []entry |
| var name string |
| switch order { |
| case Unordered: |
| name = "Unordered" |
| case LexicalKeyOrder: |
| name = "LexicalKeyOrder" |
| } |
| t.Run(name, func(t *testing.T) { |
| MapZip(lhs.AsMap(), rhs.AsMap(), order, func(key string, lhs, rhs Value) bool { |
| var li, ri interface{} |
| if lhs != nil { |
| li = lhs.Unstructured() |
| } |
| if rhs != nil { |
| ri = rhs.Unstructured() |
| } |
| zipped = append(zipped, entry{key, li, ri}) |
| return true |
| }) |
| if order == Unordered { |
| sort.Slice(zipped, func(i, j int) bool { |
| return zipped[i].key < zipped[j].key |
| }) |
| } |
| if !reflect.DeepEqual(zipped, tc.expectedZipped) { |
| t.Errorf("expected zip to produce:\n%#v\nbut got\n%#v", tc.expectedZipped, zipped) |
| } |
| }) |
| } |
| }) |
| } |
| } |
| }) |
| } |
| } |
