| /* |
| Copyright 2020 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/json" |
| "errors" |
| "fmt" |
| "reflect" |
| "testing" |
| "time" |
| ) |
| |
| type CustomValue struct { |
| data []byte |
| } |
| |
| // MarshalJSON has a value receiver on this type. |
| func (c CustomValue) MarshalJSON() ([]byte, error) { |
| return c.data, nil |
| } |
| |
| type CustomPointer struct { |
| data []byte |
| } |
| |
| // MarshalJSON has a pointer receiver on this type. |
| func (c *CustomPointer) MarshalJSON() ([]byte, error) { |
| return c.data, nil |
| } |
| |
| // Mimics https://github.com/kubernetes/apimachinery/blob/master/pkg/apis/meta/v1/time.go. |
| type Time struct { |
| time.Time |
| } |
| |
| // ToUnstructured implements the value.UnstructuredConverter interface. |
| func (t Time) ToUnstructured() interface{} { |
| if t.IsZero() { |
| return nil |
| } |
| buf := make([]byte, 0, len(time.RFC3339)) |
| buf = t.UTC().AppendFormat(buf, time.RFC3339) |
| return string(buf) |
| } |
| |
| // PointerUnstructuredConverter implements UnstructuredConverter with a pointer receiver. |
| type PointerUnstructuredConverter struct { |
| val any |
| } |
| |
| func (c *PointerUnstructuredConverter) MarshalJSON() ([]byte, error) { |
| return []byte(`"MarshalJSON"`), nil |
| } |
| |
| func (c *PointerUnstructuredConverter) ToUnstructured() any { |
| return c.val |
| } |
| |
| // ValueUnstructuredConverterWithError implements UnstructuredConverterWithError with a value |
| // receiver. |
| type ValueUnstructuredConverterWithError struct { |
| val any |
| err error |
| } |
| |
| func (c ValueUnstructuredConverterWithError) MarshalJSON() ([]byte, error) { |
| return []byte(`"MarshalJSON"`), nil |
| } |
| |
| func (c ValueUnstructuredConverterWithError) ToUnstructuredWithError() (any, error) { |
| return c.val, c.err |
| } |
| |
| // PointerUnstructuredConverterWithError implements UnstructuredConverterWithError with a pointer |
| // receiver. |
| type PointerUnstructuredConverterWithError struct { |
| val any |
| err error |
| } |
| |
| func (c *PointerUnstructuredConverterWithError) MarshalJSON() ([]byte, error) { |
| return []byte(`"MarshalJSON"`), nil |
| } |
| |
| func (c *PointerUnstructuredConverterWithError) ToUnstructuredWithError() (any, error) { |
| return c.val, c.err |
| } |
| |
| // ValueUnstructuredConverterWithAndWithoutError implements both UnstructuredConverter and |
| // UnstructuredConverterWithError. |
| type ValueUnstructuredConverterWithAndWithoutError struct{} |
| |
| func (c ValueUnstructuredConverterWithAndWithoutError) MarshalJSON() ([]byte, error) { |
| return []byte(`"MarshalJSON"`), nil |
| } |
| |
| func (c ValueUnstructuredConverterWithAndWithoutError) ToUnstructured() any { |
| return "ToUnstructured" |
| } |
| |
| func (c ValueUnstructuredConverterWithAndWithoutError) ToUnstructuredWithError() (any, error) { |
| return "ToUnstructuredWithError", nil |
| } |
| |
| func TestUnstructuredConverterWithError(t *testing.T) { |
| t.Run("value receiver", func(t *testing.T) { |
| c := ValueUnstructuredConverterWithError{val: "hello"} |
| rv := reflect.ValueOf(c) |
| entry := TypeReflectEntryOf(rv.Type()) |
| if !entry.CanConvertToUnstructured() { |
| t.Fatal("expected CanConvertToUnstructured to be true") |
| } |
| result, err := entry.ToUnstructured(rv) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if result != "hello" { |
| t.Errorf("expected %q but got %#v", "hello", result) |
| } |
| }) |
| |
| t.Run("pointer receiver", func(t *testing.T) { |
| c := PointerUnstructuredConverterWithError{val: int64(42)} |
| rv := reflect.ValueOf(&c).Elem() |
| entry := TypeReflectEntryOf(rv.Type()) |
| if !entry.CanConvertToUnstructured() { |
| t.Fatal("expected CanConvertToUnstructured to be true") |
| } |
| result, err := entry.ToUnstructured(rv) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if result != int64(42) { |
| t.Errorf("expected %v but got %#v", int64(42), result) |
| } |
| }) |
| |
| t.Run("error with value receiver", func(t *testing.T) { |
| convertErr := errors.New("cannot convert") |
| c := ValueUnstructuredConverterWithError{err: convertErr} |
| rv := reflect.ValueOf(c) |
| _, err := TypeReflectEntryOf(rv.Type()).ToUnstructured(rv) |
| if err == nil { |
| t.Fatal("expected error but got nil") |
| } |
| if err != convertErr { |
| t.Fatalf("expected error %q but got %q", convertErr, err) |
| } |
| }) |
| |
| t.Run("error with pointer receiver", func(t *testing.T) { |
| convertErr := errors.New("cannot convert") |
| c := PointerUnstructuredConverterWithError{err: convertErr} |
| rv := reflect.ValueOf(&c).Elem() |
| _, err := TypeReflectEntryOf(rv.Type()).ToUnstructured(rv) |
| if err == nil { |
| t.Fatal("expected error but got nil") |
| } |
| if err != convertErr { |
| t.Fatalf("expected error %q but got %q", convertErr, err) |
| } |
| }) |
| |
| t.Run("precedence over UnstructuredConverter", func(t *testing.T) { |
| c := ValueUnstructuredConverterWithAndWithoutError{} |
| rv := reflect.ValueOf(c) |
| result, err := TypeReflectEntryOf(rv.Type()).ToUnstructured(rv) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if result != "ToUnstructuredWithError" { |
| t.Errorf("expected %q but got %#v", "from-fallible", result) |
| } |
| }) |
| |
| t.Run("nil-valued pointer receiver returns nil", func(t *testing.T) { |
| var c *PointerUnstructuredConverterWithError |
| rv := reflect.ValueOf(c) |
| result, err := TypeReflectEntryOf(rv.Type()).ToUnstructured(rv) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if result != nil { |
| t.Errorf("expected nil but got %#v", result) |
| } |
| }) |
| } |
| |
| func TestToUnstructured(t *testing.T) { |
| testcases := []struct { |
| Data string |
| Expected interface{} |
| ExpectedErrorMessage string |
| }{ |
| {Data: `null`, Expected: nil}, |
| {Data: `true`, Expected: true}, |
| {Data: `false`, Expected: false}, |
| {Data: `[]`, Expected: []interface{}{}}, |
| {Data: `[1]`, Expected: []interface{}{int64(1)}}, |
| {Data: `{}`, Expected: map[string]interface{}{}}, |
| {Data: `{"a":1}`, Expected: map[string]interface{}{"a": int64(1)}}, |
| {Data: `0`, Expected: int64(0)}, |
| {Data: `0.0`, Expected: float64(0)}, |
| {Data: "{} \t\r\n", Expected: map[string]interface{}{}}, |
| {Data: "{} \t\r\n}", ExpectedErrorMessage: "error decoding object from json: unexpected trailing data at offset 6"}, |
| {Data: "{} \t\r\n{}", ExpectedErrorMessage: "error decoding object from json: unexpected trailing data at offset 6"}, |
| {Data: "[] \t\r\n", Expected: []interface{}{}}, |
| {Data: "[] \t\r\n]", ExpectedErrorMessage: "error decoding array from json: unexpected trailing data at offset 6"}, |
| {Data: "[] \t\r\n[]", ExpectedErrorMessage: "error decoding array from json: unexpected trailing data at offset 6"}, |
| } |
| |
| for _, tc := range testcases { |
| tc := tc |
| t.Run(tc.Data, func(t *testing.T) { |
| t.Parallel() |
| custom := []interface{}{ |
| CustomValue{data: []byte(tc.Data)}, |
| &CustomValue{data: []byte(tc.Data)}, |
| &CustomPointer{data: []byte(tc.Data)}, |
| } |
| for _, custom := range custom { |
| rv := reflect.ValueOf(custom) |
| result, err := TypeReflectEntryOf(rv.Type()).ToUnstructured(rv) |
| if err != nil { |
| if tc.ExpectedErrorMessage == "" { |
| t.Fatal(err) |
| } else if got := err.Error(); got != tc.ExpectedErrorMessage { |
| t.Fatalf("expected error message %q but got %q", tc.ExpectedErrorMessage, got) |
| } |
| } else if tc.ExpectedErrorMessage != "" { |
| t.Fatalf("expected error message %q but got nil error", tc.ExpectedErrorMessage) |
| } |
| if !reflect.DeepEqual(result, tc.Expected) { |
| t.Errorf("expected %#v but got %#v", tc.Expected, result) |
| } |
| } |
| }) |
| } |
| } |
| |
| func timePtr(t time.Time) *time.Time { return &t } |
| |
| func TestTimeToUnstructured(t *testing.T) { |
| testcases := []struct { |
| Name string |
| Time *time.Time |
| Expected interface{} |
| }{ |
| {Name: "nil", Time: nil, Expected: nil}, |
| {Name: "zero", Time: &time.Time{}, Expected: nil}, |
| {Name: "1", Time: timePtr(time.Time{}.Add(time.Second)), Expected: "0001-01-01T00:00:01Z"}, |
| } |
| |
| for _, tc := range testcases { |
| tc := tc |
| t.Run(tc.Name, func(t *testing.T) { |
| t.Parallel() |
| var time *Time |
| rv := reflect.ValueOf(time) |
| if tc.Time != nil { |
| rv = reflect.ValueOf(Time{Time: *tc.Time}) |
| } |
| result, err := TypeReflectEntryOf(rv.Type()).ToUnstructured(rv) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if !reflect.DeepEqual(result, tc.Expected) { |
| t.Errorf("expected %#v but got %#v", tc.Expected, result) |
| } |
| }) |
| } |
| } |
| |
| func TestPointerUnstructuredConverterToUnstructured(t *testing.T) { |
| c := PointerUnstructuredConverter{val: "hello"} |
| rv := reflect.ValueOf(&c).Elem() |
| entry := TypeReflectEntryOf(rv.Type()) |
| if !entry.CanConvertToUnstructured() { |
| t.Fatal("expected CanConvertToUnstructured to be true") |
| } |
| result, err := entry.ToUnstructured(rv) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if result != "hello" { |
| t.Errorf("expected %q but got %#v", "hello", result) |
| } |
| } |
| |
| func TestTypeReflectEntryOf(t *testing.T) { |
| testString := "" |
| testCustomType := customOmitZeroType{} |
| tests := map[string]struct { |
| arg interface{} |
| want *TypeReflectCacheEntry |
| }{ |
| "StructWithStringField": { |
| arg: struct { |
| F1 string `json:"f1"` |
| }{}, |
| want: &TypeReflectCacheEntry{ |
| structFields: map[string]*FieldCacheEntry{ |
| "f1": { |
| JsonName: "f1", |
| fieldPath: [][]int{{0}}, |
| fieldType: reflect.TypeOf(testString), |
| TypeEntry: &TypeReflectCacheEntry{}, |
| }, |
| }, |
| orderedStructFields: []*FieldCacheEntry{ |
| { |
| JsonName: "f1", |
| fieldPath: [][]int{{0}}, |
| fieldType: reflect.TypeOf(testString), |
| TypeEntry: &TypeReflectCacheEntry{}, |
| }, |
| }, |
| }, |
| }, |
| "StructWith*StringFieldOmitempty": { |
| arg: struct { |
| F1 *string `json:"f1,omitempty"` |
| }{}, |
| want: &TypeReflectCacheEntry{ |
| structFields: map[string]*FieldCacheEntry{ |
| "f1": { |
| JsonName: "f1", |
| isOmitEmpty: true, |
| fieldPath: [][]int{{0}}, |
| fieldType: reflect.TypeOf(&testString), |
| TypeEntry: &TypeReflectCacheEntry{}, |
| }, |
| }, |
| orderedStructFields: []*FieldCacheEntry{ |
| { |
| JsonName: "f1", |
| isOmitEmpty: true, |
| fieldPath: [][]int{{0}}, |
| fieldType: reflect.TypeOf(&testString), |
| TypeEntry: &TypeReflectCacheEntry{}, |
| }, |
| }, |
| }, |
| }, |
| "StructWith*StringFieldOmitzero": { |
| arg: struct { |
| F1 *string `json:"f1,omitzero"` |
| }{}, |
| want: &TypeReflectCacheEntry{ |
| structFields: map[string]*FieldCacheEntry{ |
| "f1": { |
| JsonName: "f1", |
| omitzero: func(v reflect.Value) bool { return v.IsZero() }, |
| fieldPath: [][]int{{0}}, |
| fieldType: reflect.TypeOf(&testString), |
| TypeEntry: &TypeReflectCacheEntry{}, |
| }, |
| }, |
| orderedStructFields: []*FieldCacheEntry{ |
| { |
| JsonName: "f1", |
| omitzero: func(v reflect.Value) bool { return v.IsZero() }, |
| fieldPath: [][]int{{0}}, |
| fieldType: reflect.TypeOf(&testString), |
| TypeEntry: &TypeReflectCacheEntry{}, |
| }, |
| }, |
| }, |
| }, |
| "StructWith*CustomFieldOmitzero": { |
| arg: struct { |
| F1 customOmitZeroType `json:"f1,omitzero"` |
| }{}, |
| want: &TypeReflectCacheEntry{ |
| structFields: map[string]*FieldCacheEntry{ |
| "f1": { |
| JsonName: "f1", |
| omitzero: func(v reflect.Value) bool { return false }, |
| fieldPath: [][]int{{0}}, |
| fieldType: reflect.TypeOf(testCustomType), |
| TypeEntry: &TypeReflectCacheEntry{ |
| structFields: map[string]*FieldCacheEntry{}, |
| orderedStructFields: []*FieldCacheEntry{}, |
| }, |
| }, |
| }, |
| orderedStructFields: []*FieldCacheEntry{ |
| { |
| JsonName: "f1", |
| omitzero: func(v reflect.Value) bool { return false }, |
| fieldPath: [][]int{{0}}, |
| fieldType: reflect.TypeOf(testCustomType), |
| TypeEntry: &TypeReflectCacheEntry{ |
| structFields: map[string]*FieldCacheEntry{}, |
| orderedStructFields: []*FieldCacheEntry{}, |
| }, |
| }, |
| }, |
| }, |
| }, |
| "StructWithNonEmbeddedInlineTag": { |
| arg: struct { |
| F1 string `json:",inline"` |
| }{}, |
| want: &TypeReflectCacheEntry{ |
| structFields: map[string]*FieldCacheEntry{ |
| "F1": { |
| JsonName: "F1", |
| fieldPath: [][]int{{0}}, |
| fieldType: reflect.TypeOf(testString), |
| TypeEntry: &TypeReflectCacheEntry{}, |
| }, |
| }, |
| orderedStructFields: []*FieldCacheEntry{ |
| { |
| JsonName: "F1", |
| fieldPath: [][]int{{0}}, |
| fieldType: reflect.TypeOf(testString), |
| TypeEntry: &TypeReflectCacheEntry{}, |
| }, |
| }, |
| }, |
| }, |
| "EmbeddedWithInlineTag": { |
| arg: struct { |
| Inlined `json:",inline"` |
| }{}, |
| want: &TypeReflectCacheEntry{ |
| structFields: map[string]*FieldCacheEntry{ |
| "f1": { |
| JsonName: "f1", |
| fieldPath: [][]int{{0}, {0}}, |
| fieldType: reflect.TypeOf(testString), |
| TypeEntry: &TypeReflectCacheEntry{}, |
| }, |
| }, |
| orderedStructFields: []*FieldCacheEntry{ |
| { |
| JsonName: "f1", |
| fieldPath: [][]int{{0}, {0}}, |
| fieldType: reflect.TypeOf(testString), |
| TypeEntry: &TypeReflectCacheEntry{}, |
| }, |
| }, |
| }, |
| }, |
| "EmbeddedWithEmptyJSONTag": { |
| arg: struct { |
| Inlined `json:""` |
| }{}, |
| want: &TypeReflectCacheEntry{ |
| structFields: map[string]*FieldCacheEntry{ |
| "f1": { |
| JsonName: "f1", |
| fieldPath: [][]int{{0}, {0}}, |
| fieldType: reflect.TypeOf(testString), |
| TypeEntry: &TypeReflectCacheEntry{}, |
| }, |
| }, |
| orderedStructFields: []*FieldCacheEntry{ |
| { |
| JsonName: "f1", |
| fieldPath: [][]int{{0}, {0}}, |
| fieldType: reflect.TypeOf(testString), |
| TypeEntry: &TypeReflectCacheEntry{}, |
| }, |
| }, |
| }, |
| }, |
| "EmbeddedWithNoTag": { |
| arg: struct { |
| Inlined |
| }{}, |
| want: &TypeReflectCacheEntry{ |
| structFields: map[string]*FieldCacheEntry{ |
| "f1": { |
| JsonName: "f1", |
| fieldPath: [][]int{{0}, {0}}, |
| fieldType: reflect.TypeOf(testString), |
| TypeEntry: &TypeReflectCacheEntry{}, |
| }, |
| }, |
| orderedStructFields: []*FieldCacheEntry{ |
| { |
| JsonName: "f1", |
| fieldPath: [][]int{{0}, {0}}, |
| fieldType: reflect.TypeOf(testString), |
| TypeEntry: &TypeReflectCacheEntry{}, |
| }, |
| }, |
| }, |
| }, |
| "StructWithUnexportedField": { |
| arg: struct { |
| Exported string `json:"exported"` |
| unexported string |
| }{}, |
| want: &TypeReflectCacheEntry{ |
| structFields: map[string]*FieldCacheEntry{ |
| "exported": { |
| JsonName: "exported", |
| fieldPath: [][]int{{0}}, |
| fieldType: reflect.TypeOf(testString), |
| TypeEntry: &TypeReflectCacheEntry{}, |
| }, |
| }, |
| orderedStructFields: []*FieldCacheEntry{ |
| { |
| JsonName: "exported", |
| fieldPath: [][]int{{0}}, |
| fieldType: reflect.TypeOf(testString), |
| TypeEntry: &TypeReflectCacheEntry{}, |
| }, |
| }, |
| }, |
| }, |
| } |
| for name, tt := range tests { |
| t.Run(name, func(t *testing.T) { |
| got := TypeReflectEntryOf(reflect.TypeOf(tt.arg)) |
| |
| // evaluate non-comparable omitzero functions |
| for k, v := range got.structFields { |
| compareOmitZero(t, v.fieldType, v.omitzero, tt.want.structFields[k].omitzero) |
| } |
| for i, v := range got.orderedStructFields { |
| compareOmitZero(t, v.fieldType, v.omitzero, tt.want.orderedStructFields[i].omitzero) |
| } |
| |
| // clear non-comparable omitzero functions |
| for k, v := range got.structFields { |
| v.omitzero = nil |
| tt.want.structFields[k].omitzero = nil |
| } |
| for i, v := range got.orderedStructFields { |
| v.omitzero = nil |
| tt.want.orderedStructFields[i].omitzero = nil |
| } |
| |
| // compare remaining fields |
| if !reflect.DeepEqual(got, tt.want) { |
| t.Errorf("TypeReflectEntryOf() got\n%#v\nwant\n%#v", got, tt.want) |
| } |
| }) |
| } |
| } |
| |
| type Inlined struct { |
| F1 string `json:"f1"` |
| } |
| |
| type customOmitZeroType struct { |
| } |
| |
| func (c *customOmitZeroType) IsZero() bool { |
| return false |
| } |
| |
| func compareOmitZero(t *testing.T, fieldType reflect.Type, got, want func(reflect.Value) bool) { |
| t.Helper() |
| if (want == nil) != (got == nil) { |
| t.Fatalf("wanted omitzero=%v, got omitzero=%v", (want == nil), (got == nil)) |
| } |
| if want == nil { |
| return |
| } |
| v := reflect.New(fieldType).Elem() |
| if e, a := want(v), got(v); e != a { |
| t.Fatalf("wanted omitzero()=%v, got omitzero()=%v", e, a) |
| } |
| } |
| |
| func TestUnmarshal(t *testing.T) { |
| for _, tc := range []struct { |
| JSON string |
| IntoType reflect.Type |
| Want interface{} |
| WantError bool |
| }{ |
| { |
| JSON: "{}}", |
| IntoType: reflect.TypeOf([0]interface{}{}).Elem(), |
| Want: map[string]interface{}{}, |
| WantError: true, |
| }, |
| { |
| JSON: `1.0`, |
| IntoType: reflect.TypeOf(json.Number("")), |
| Want: json.Number("1.0"), |
| }, |
| { |
| JSON: `1`, |
| IntoType: reflect.TypeOf(json.Number("")), |
| Want: json.Number("1"), |
| }, |
| { |
| JSON: `1.0`, |
| IntoType: reflect.TypeOf(float64(0)), |
| Want: float64(1), |
| }, |
| { |
| JSON: `1`, |
| IntoType: reflect.TypeOf(float64(0)), |
| Want: float64(1), |
| }, |
| { |
| JSON: `1.0`, |
| IntoType: reflect.TypeOf(int64(0)), |
| Want: int64(0), |
| WantError: true, |
| }, |
| { |
| JSON: `1`, |
| IntoType: reflect.TypeOf(int64(0)), |
| Want: int64(1), |
| }, |
| { |
| JSON: `1.0`, |
| IntoType: reflect.TypeOf([0]interface{}{}).Elem(), |
| Want: float64(1), |
| }, |
| { |
| JSON: `1`, |
| IntoType: reflect.TypeOf([0]interface{}{}).Elem(), |
| Want: int64(1), |
| }, |
| { |
| JSON: `[1.0,[1.0],{"":1.0}]`, |
| IntoType: reflect.TypeOf([0]interface{}{}).Elem(), |
| Want: []interface{}{ |
| float64(1), |
| []interface{}{float64(1)}, |
| map[string]interface{}{"": float64(1)}, |
| }, |
| }, |
| { |
| JSON: `[1.0,[1.0],{"":1.0}]`, |
| IntoType: reflect.TypeOf([]interface{}{}), |
| Want: []interface{}{ |
| float64(1), |
| []interface{}{float64(1)}, |
| map[string]interface{}{"": float64(1)}, |
| }, |
| }, |
| { |
| JSON: `[1,[1],{"":1}]`, |
| IntoType: reflect.TypeOf([0]interface{}{}).Elem(), |
| Want: []interface{}{ |
| int64(1), |
| []interface{}{int64(1)}, |
| map[string]interface{}{"": int64(1)}, |
| }, |
| }, |
| { |
| JSON: `[1,[1],{"":1}]`, |
| IntoType: reflect.TypeOf([]interface{}{}), |
| Want: []interface{}{ |
| int64(1), |
| []interface{}{int64(1)}, |
| map[string]interface{}{"": int64(1)}, |
| }, |
| }, |
| { |
| JSON: `{"x":1.0,"y":[1.0],"z":{"":1.0}}`, |
| IntoType: reflect.TypeOf([0]interface{}{}).Elem(), |
| Want: map[string]interface{}{ |
| "x": float64(1), |
| "y": []interface{}{float64(1)}, |
| "z": map[string]interface{}{"": float64(1)}, |
| }, |
| }, |
| { |
| JSON: `{"x":1.0,"y":[1.0],"z":{"":1.0}}`, |
| IntoType: reflect.TypeOf(map[string]interface{}{}), |
| Want: map[string]interface{}{ |
| "x": float64(1), |
| "y": []interface{}{float64(1)}, |
| "z": map[string]interface{}{"": float64(1)}, |
| }, |
| }, |
| { |
| JSON: `{"x":1,"y":[1],"z":{"":1}}`, |
| IntoType: reflect.TypeOf([0]interface{}{}).Elem(), |
| Want: map[string]interface{}{ |
| "x": int64(1), |
| "y": []interface{}{int64(1)}, |
| "z": map[string]interface{}{"": int64(1)}, |
| }, |
| }, |
| { |
| JSON: `{"x":1,"y":[1],"z":{"":1}}`, |
| IntoType: reflect.TypeOf(map[string]interface{}{}), |
| Want: map[string]interface{}{ |
| "x": int64(1), |
| "y": []interface{}{int64(1)}, |
| "z": map[string]interface{}{"": int64(1)}, |
| }, |
| }, |
| } { |
| t.Run(fmt.Sprintf("%s into %v", tc.JSON, reflect.PointerTo(tc.IntoType)), func(t *testing.T) { |
| into := reflect.New(tc.IntoType) |
| if err := unmarshal([]byte(tc.JSON), into.Interface()); tc.WantError != (err != nil) { |
| t.Fatalf("unexpected error: %v", err) |
| } |
| if got := into.Elem().Interface(); !reflect.DeepEqual(tc.Want, got) { |
| t.Errorf("want %#v (%T), got %#v (%T)", tc.Want, tc.Want, got, got) |
| } |
| }) |
| } |
| } |
