| // Copyright 2015 The Vanadium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package vdl_test |
| |
| // This test is in the vdl_test package to avoid a cyclic dependency with the |
| // "v.io/v23/verror" package. We need to import the verror package in |
| // order to test error conversions. |
| // |
| // TODO(toddw): test values of recursive types. |
| |
| import ( |
| "fmt" |
| "math" |
| "reflect" |
| "testing" |
| |
| "v.io/v23/vdl" |
| "v.io/v23/vdl/vdltest" |
| "v.io/v23/verror" |
| ) |
| |
| func errorValue(e verror.E) *vdl.Value { |
| verr := vdl.NonNilZeroValue(vdl.ErrorType) |
| vv := verr.Elem() |
| vv.StructField(0).AssignString(string(e.ID)) |
| vv.StructField(1).AssignEnumLabel(retryFromAction(e.Action)) |
| vv.StructField(2).AssignString(e.Msg) |
| vv.StructField(3).AssignLen(len(e.ParamList)) |
| for ix, p := range e.ParamList { |
| vv.StructField(3).Index(ix).Assign(vdl.ValueOf(p)) |
| } |
| return verr |
| } |
| |
| func retryFromAction(action verror.ActionCode) string { |
| switch action.RetryAction() { |
| case verror.NoRetry: |
| return vdl.WireRetryCodeNoRetry.String() |
| case verror.RetryConnection: |
| return vdl.WireRetryCodeRetryConnection.String() |
| case verror.RetryRefetch: |
| return vdl.WireRetryCodeRetryRefetch.String() |
| case verror.RetryBackoff: |
| return vdl.WireRetryCodeRetryBackoff.String() |
| } |
| // Default to NoRetry. |
| return vdl.WireRetryCodeNoRetry.String() |
| } |
| |
| // Each group of values in vvNAME and rvNAME are all mutually convertible. |
| var ( |
| rvError1 = verror.E{ |
| ID: verror.ID("id1"), |
| Action: verror.NoRetry, |
| Msg: "msg1", |
| ParamList: nil, |
| } |
| rvError2 = verror.E{ |
| ID: verror.ID("id2"), |
| Action: verror.RetryConnection, |
| Msg: "msg2", |
| ParamList: []interface{}{"abc", int32(123)}, |
| } |
| rvError3 = verror.E{ |
| ID: verror.ID("id3"), |
| Action: verror.RetryBackoff, |
| Msg: "msg3", |
| ParamList: []interface{}{rvError1, &rvError2}, |
| } |
| |
| vvBoolTrue = []*vdl.Value{ |
| vdl.BoolValue(nil, true), vdl.BoolValue(vdl.BoolTypeN, true), |
| } |
| vvStrABC = []*vdl.Value{ |
| vdl.StringValue(nil, "ABC"), vdl.StringValue(vdl.StringTypeN, "ABC"), |
| vdl.EnumValue(vdl.EnumTypeN, 3), |
| } |
| vvTypeObjectBool = []*vdl.Value{ |
| vdl.TypeObjectValue(vdl.BoolType), |
| } |
| vvSeq123 = []*vdl.Value{ |
| vdl.SeqNumValue(vdl.Array3ByteType, 1, 2, 3), |
| vdl.SeqNumValue(vdl.Array3ByteTypeN, 1, 2, 3), |
| vdl.SeqNumValue(vdl.Array3Uint64Type, 1, 2, 3), |
| vdl.SeqNumValue(vdl.Array3Uint64TypeN, 1, 2, 3), |
| vdl.SeqNumValue(vdl.Array3Int64Type, 1, 2, 3), |
| vdl.SeqNumValue(vdl.Array3Int64TypeN, 1, 2, 3), |
| vdl.SeqNumValue(vdl.Array3Float64Type, 1, 2, 3), |
| vdl.SeqNumValue(vdl.Array3Float64TypeN, 1, 2, 3), |
| vdl.SeqNumValue(vdl.ListByteType, 1, 2, 3), |
| vdl.SeqNumValue(vdl.ListByteTypeN, 1, 2, 3), |
| vdl.SeqNumValue(vdl.ListUint64Type, 1, 2, 3), |
| vdl.SeqNumValue(vdl.ListUint64TypeN, 1, 2, 3), |
| vdl.SeqNumValue(vdl.ListInt64Type, 1, 2, 3), |
| vdl.SeqNumValue(vdl.ListInt64TypeN, 1, 2, 3), |
| vdl.SeqNumValue(vdl.ListFloat64Type, 1, 2, 3), |
| vdl.SeqNumValue(vdl.ListFloat64TypeN, 1, 2, 3), |
| } |
| vvSet123 = []*vdl.Value{ |
| vdl.SetNumValue(vdl.SetByteType, 1, 2, 3), |
| vdl.SetNumValue(vdl.SetByteTypeN, 1, 2, 3), |
| vdl.SetNumValue(vdl.SetUint64Type, 1, 2, 3), |
| vdl.SetNumValue(vdl.SetUint64TypeN, 1, 2, 3), |
| vdl.SetNumValue(vdl.SetInt64Type, 1, 2, 3), |
| vdl.SetNumValue(vdl.SetInt64TypeN, 1, 2, 3), |
| vdl.SetNumValue(vdl.SetFloat64Type, 1, 2, 3), |
| vdl.SetNumValue(vdl.SetFloat64TypeN, 1, 2, 3), |
| } |
| vvMap123True = []*vdl.Value{ |
| vdl.MapNumBoolValue(vdl.MapByteBoolType, vdl.NB{1, true}, vdl.NB{2, true}, vdl.NB{3, true}), |
| vdl.MapNumBoolValue(vdl.MapByteBoolTypeN, vdl.NB{1, true}, vdl.NB{2, true}, vdl.NB{3, true}), |
| vdl.MapNumBoolValue(vdl.MapUint64BoolType, vdl.NB{1, true}, vdl.NB{2, true}, vdl.NB{3, true}), |
| vdl.MapNumBoolValue(vdl.MapUint64BoolTypeN, vdl.NB{1, true}, vdl.NB{2, true}, vdl.NB{3, true}), |
| vdl.MapNumBoolValue(vdl.MapInt64BoolType, vdl.NB{1, true}, vdl.NB{2, true}, vdl.NB{3, true}), |
| vdl.MapNumBoolValue(vdl.MapInt64BoolTypeN, vdl.NB{1, true}, vdl.NB{2, true}, vdl.NB{3, true}), |
| vdl.MapNumBoolValue(vdl.MapFloat64BoolType, vdl.NB{1, true}, vdl.NB{2, true}, vdl.NB{3, true}), |
| vdl.MapNumBoolValue(vdl.MapFloat64BoolTypeN, vdl.NB{1, true}, vdl.NB{2, true}, vdl.NB{3, true}), |
| } |
| vvMap123FalseTrue = []*vdl.Value{ |
| vdl.MapNumBoolValue(vdl.MapByteBoolType, vdl.NB{1, false}, vdl.NB{2, true}, vdl.NB{3, false}), |
| vdl.MapNumBoolValue(vdl.MapByteBoolTypeN, vdl.NB{1, false}, vdl.NB{2, true}, vdl.NB{3, false}), |
| vdl.MapNumBoolValue(vdl.MapUint64BoolType, vdl.NB{1, false}, vdl.NB{2, true}, vdl.NB{3, false}), |
| vdl.MapNumBoolValue(vdl.MapUint64BoolTypeN, vdl.NB{1, false}, vdl.NB{2, true}, vdl.NB{3, false}), |
| vdl.MapNumBoolValue(vdl.MapInt64BoolType, vdl.NB{1, false}, vdl.NB{2, true}, vdl.NB{3, false}), |
| vdl.MapNumBoolValue(vdl.MapInt64BoolTypeN, vdl.NB{1, false}, vdl.NB{2, true}, vdl.NB{3, false}), |
| vdl.MapNumBoolValue(vdl.MapFloat64BoolType, vdl.NB{1, false}, vdl.NB{2, true}, vdl.NB{3, false}), |
| vdl.MapNumBoolValue(vdl.MapFloat64BoolTypeN, vdl.NB{1, false}, vdl.NB{2, true}, vdl.NB{3, false}), |
| } |
| vvSetXYZ = []*vdl.Value{ |
| vdl.SetStringValue(vdl.SetStringType, "X", "Y", "Z"), |
| vdl.SetStringValue(vdl.SetStringTypeN, "X", "Y", "Z"), |
| } |
| vvMapXYZTrue = []*vdl.Value{ |
| vdl.MapStringBoolValue(vdl.MapStringBoolType, vdl.SB{"X", true}, vdl.SB{"Y", true}, vdl.SB{"Z", true}), |
| vdl.MapStringBoolValue(vdl.MapStringBoolTypeN, vdl.SB{"X", true}, vdl.SB{"Y", true}, vdl.SB{"Z", true}), |
| } |
| vvStructXYZTrue = []*vdl.Value{ |
| vdl.StructBoolValue(vdl.StructXYZBoolType, vdl.SB{"X", true}, vdl.SB{"Y", true}, vdl.SB{"Z", true}), |
| vdl.StructBoolValue(vdl.StructXYZBoolTypeN, vdl.SB{"X", true}, vdl.SB{"Y", true}, vdl.SB{"Z", true}), |
| } |
| vvMapXYZFalseTrue = []*vdl.Value{ |
| vdl.MapStringBoolValue(vdl.MapStringBoolType, vdl.SB{"X", false}, vdl.SB{"Y", true}, vdl.SB{"Z", false}), |
| vdl.MapStringBoolValue(vdl.MapStringBoolTypeN, vdl.SB{"X", false}, vdl.SB{"Y", true}, vdl.SB{"Z", false}), |
| } |
| vvMapStructXYZEmpty = []*vdl.Value{ |
| vdl.MapStringEmptyValue(vdl.MapStringEmptyType, "X", "Y", "Z"), |
| vdl.MapStringEmptyValue(vdl.MapStringEmptyTypeN, "X", "Y", "Z"), |
| vdl.ZeroValue(vdl.StructXYZEmptyType), vdl.ZeroValue(vdl.StructXYZEmptyTypeN), |
| } |
| vvStructWXFalseTrue = []*vdl.Value{ |
| vdl.StructBoolValue(vdl.StructWXBoolType, vdl.SB{"W", false}, vdl.SB{"X", true}), |
| vdl.StructBoolValue(vdl.StructWXBoolTypeN, vdl.SB{"W", false}, vdl.SB{"X", true}), |
| } |
| vvMapVWX123 = []*vdl.Value{ |
| vdl.MapStringNumValue(vdl.MapStringByteType, vdl.SN{"V", 1}, vdl.SN{"W", 2}, vdl.SN{"X", 3}), |
| vdl.MapStringNumValue(vdl.MapStringByteTypeN, vdl.SN{"V", 1}, vdl.SN{"W", 2}, vdl.SN{"X", 3}), |
| vdl.MapStringNumValue(vdl.MapStringUint64Type, vdl.SN{"V", 1}, vdl.SN{"W", 2}, vdl.SN{"X", 3}), |
| vdl.MapStringNumValue(vdl.MapStringUint64TypeN, vdl.SN{"V", 1}, vdl.SN{"W", 2}, vdl.SN{"X", 3}), |
| vdl.MapStringNumValue(vdl.MapStringInt64Type, vdl.SN{"V", 1}, vdl.SN{"W", 2}, vdl.SN{"X", 3}), |
| vdl.MapStringNumValue(vdl.MapStringInt64TypeN, vdl.SN{"V", 1}, vdl.SN{"W", 2}, vdl.SN{"X", 3}), |
| vdl.MapStringNumValue(vdl.MapStringFloat64Type, vdl.SN{"V", 1}, vdl.SN{"W", 2}, vdl.SN{"X", 3}), |
| vdl.MapStringNumValue(vdl.MapStringFloat64TypeN, vdl.SN{"V", 1}, vdl.SN{"W", 2}, vdl.SN{"X", 3}), |
| } |
| vvStructVWX123 = []*vdl.Value{ |
| vdl.StructNumValue(vdl.StructVWXByteType, vdl.SN{"V", 1}, vdl.SN{"W", 2}, vdl.SN{"X", 3}), |
| vdl.StructNumValue(vdl.StructVWXByteTypeN, vdl.SN{"V", 1}, vdl.SN{"W", 2}, vdl.SN{"X", 3}), |
| vdl.StructNumValue(vdl.StructVWXUint64Type, vdl.SN{"V", 1}, vdl.SN{"W", 2}, vdl.SN{"X", 3}), |
| vdl.StructNumValue(vdl.StructVWXUint64TypeN, vdl.SN{"V", 1}, vdl.SN{"W", 2}, vdl.SN{"X", 3}), |
| vdl.StructNumValue(vdl.StructVWXInt64Type, vdl.SN{"V", 1}, vdl.SN{"W", 2}, vdl.SN{"X", 3}), |
| vdl.StructNumValue(vdl.StructVWXInt64TypeN, vdl.SN{"V", 1}, vdl.SN{"W", 2}, vdl.SN{"X", 3}), |
| vdl.StructNumValue(vdl.StructVWXFloat64Type, vdl.SN{"V", 1}, vdl.SN{"W", 2}, vdl.SN{"X", 3}), |
| vdl.StructNumValue(vdl.StructVWXFloat64TypeN, vdl.SN{"V", 1}, vdl.SN{"W", 2}, vdl.SN{"X", 3}), |
| } |
| vvStructUV01 = []*vdl.Value{ |
| vdl.StructNumValue(vdl.StructUVByteType, vdl.SN{"U", 0}, vdl.SN{"V", 1}), |
| vdl.StructNumValue(vdl.StructUVByteTypeN, vdl.SN{"U", 0}, vdl.SN{"V", 1}), |
| vdl.StructNumValue(vdl.StructUVUint64Type, vdl.SN{"U", 0}, vdl.SN{"V", 1}), |
| vdl.StructNumValue(vdl.StructUVUint64TypeN, vdl.SN{"U", 0}, vdl.SN{"V", 1}), |
| vdl.StructNumValue(vdl.StructUVInt64Type, vdl.SN{"U", 0}, vdl.SN{"V", 1}), |
| vdl.StructNumValue(vdl.StructUVInt64TypeN, vdl.SN{"U", 0}, vdl.SN{"V", 1}), |
| vdl.StructNumValue(vdl.StructUVFloat64Type, vdl.SN{"U", 0}, vdl.SN{"V", 1}), |
| vdl.StructNumValue(vdl.StructUVFloat64TypeN, vdl.SN{"U", 0}, vdl.SN{"V", 1}), |
| } |
| |
| rvBoolTrue = []interface{}{ |
| bool(true), vdl.NBool(true), |
| } |
| rvStrABC = []interface{}{ |
| string("ABC"), vdl.NString("ABC"), vdl.NEnumABC, |
| } |
| rvTypeObjectBool = []interface{}{ |
| vdl.BoolType, |
| } |
| rvSeq123 = []interface{}{ |
| [3]byte{1, 2, 3}, []byte{1, 2, 3}, vdl.NArray3Byte{1, 2, 3}, vdl.NSliceByte{1, 2, 3}, |
| [3]uint64{1, 2, 3}, []uint64{1, 2, 3}, vdl.NArray3Uint64{1, 2, 3}, vdl.NSliceUint64{1, 2, 3}, |
| [3]int64{1, 2, 3}, []int64{1, 2, 3}, vdl.NArray3Int64{1, 2, 3}, vdl.NSliceInt64{1, 2, 3}, |
| [3]float64{1, 2, 3}, []float64{1, 2, 3}, vdl.NArray3Float64{1, 2, 3}, vdl.NSliceFloat64{1, 2, 3}, |
| } |
| rvSet123 = []interface{}{ |
| map[byte]struct{}{1: struct{}{}, 2: struct{}{}, 3: struct{}{}}, |
| map[uint64]struct{}{1: struct{}{}, 2: struct{}{}, 3: struct{}{}}, |
| map[int64]struct{}{1: struct{}{}, 2: struct{}{}, 3: struct{}{}}, |
| map[float64]struct{}{1: struct{}{}, 2: struct{}{}, 3: struct{}{}}, |
| vdl.NMapByteEmpty{1: struct{}{}, 2: struct{}{}, 3: struct{}{}}, |
| vdl.NMapUint64Empty{1: struct{}{}, 2: struct{}{}, 3: struct{}{}}, |
| vdl.NMapInt64Empty{1: struct{}{}, 2: struct{}{}, 3: struct{}{}}, |
| vdl.NMapFloat64Empty{1: struct{}{}, 2: struct{}{}, 3: struct{}{}}, |
| } |
| rvMap123True = []interface{}{ |
| map[byte]bool{1: true, 2: true, 3: true}, |
| map[uint64]bool{1: true, 2: true, 3: true}, |
| map[int64]bool{1: true, 2: true, 3: true}, |
| map[float64]bool{1: true, 2: true, 3: true}, |
| vdl.NMapByteBool{1: true, 2: true, 3: true}, |
| vdl.NMapUint64Bool{1: true, 2: true, 3: true}, |
| vdl.NMapInt64Bool{1: true, 2: true, 3: true}, |
| vdl.NMapFloat64Bool{1: true, 2: true, 3: true}, |
| } |
| rvMap123FalseTrue = []interface{}{ |
| map[byte]bool{1: false, 2: true, 3: false}, |
| map[uint64]bool{1: false, 2: true, 3: false}, |
| map[int64]bool{1: false, 2: true, 3: false}, |
| map[float64]bool{1: false, 2: true, 3: false}, |
| vdl.NMapByteBool{1: false, 2: true, 3: false}, |
| vdl.NMapUint64Bool{1: false, 2: true, 3: false}, |
| vdl.NMapInt64Bool{1: false, 2: true, 3: false}, |
| vdl.NMapFloat64Bool{1: false, 2: true, 3: false}, |
| } |
| rvSetXYZ = []interface{}{ |
| map[string]struct{}{"X": struct{}{}, "Y": struct{}{}, "Z": struct{}{}}, |
| vdl.NMapStringEmpty{"X": struct{}{}, "Y": struct{}{}, "Z": struct{}{}}, |
| } |
| rvMapXYZTrue = []interface{}{ |
| map[string]bool{"X": true, "Y": true, "Z": true}, |
| vdl.NMapStringBool{"X": true, "Y": true, "Z": true}, |
| } |
| rvStructXYZTrue = []interface{}{ |
| struct{ X, Y, Z bool }{X: true, Y: true, Z: true}, |
| struct{ a, X, b, Y, c, Z, d bool }{X: true, Y: true, Z: true}, |
| vdl.NStructXYZBool{X: true, Y: true, Z: true}, |
| vdl.NStructXYZBoolUnexported{X: true, Y: true, Z: true}, |
| } |
| rvMapXYZFalseTrue = []interface{}{ |
| map[string]bool{"X": false, "Y": true, "Z": false}, |
| vdl.NMapStringBool{"X": false, "Y": true, "Z": false}, |
| } |
| rvStructXYZEmpty = []interface{}{ |
| vdl.NStructXYZEmpty{}, vdl.NStructXYZNEmpty{}, |
| } |
| rvMapXYZEmpty = []interface{}{ |
| map[string]vdl.NEmpty{"X": vdl.NEmpty{}, "Y": vdl.NEmpty{}, "Z": vdl.NEmpty{}}, |
| vdl.NMapStringNEmpty{"X": vdl.NEmpty{}, "Y": vdl.NEmpty{}, "Z": vdl.NEmpty{}}, |
| } |
| rvStructWXFalseTrue = []interface{}{ |
| struct{ W, X bool }{W: false, X: true}, |
| vdl.NStructWXBool{W: false, X: true}, |
| } |
| rvMapVWX123 = []interface{}{ |
| map[string]byte{"V": 1, "W": 2, "X": 3}, |
| map[string]uint64{"V": 1, "W": 2, "X": 3}, |
| map[string]int64{"V": 1, "W": 2, "X": 3}, |
| map[string]float64{"V": 1, "W": 2, "X": 3}, |
| vdl.NMapStringByte{"V": 1, "W": 2, "X": 3}, |
| vdl.NMapStringUint64{"V": 1, "W": 2, "X": 3}, |
| vdl.NMapStringInt64{"V": 1, "W": 2, "X": 3}, |
| vdl.NMapStringFloat64{"V": 1, "W": 2, "X": 3}, |
| } |
| rvStructVWX123 = []interface{}{ |
| struct{ V, W, X byte }{V: 1, W: 2, X: 3}, |
| struct{ V, W, X uint64 }{V: 1, W: 2, X: 3}, |
| struct{ V, W, X int64 }{V: 1, W: 2, X: 3}, |
| struct{ V, W, X float64 }{V: 1, W: 2, X: 3}, |
| struct { |
| // Interleave unexported fields, which are ignored. |
| a bool |
| V int64 |
| b string |
| W float64 |
| X float32 |
| c []byte |
| d interface{} |
| }{V: 1, W: 2, X: 3}, |
| vdl.NStructVWXByte{V: 1, W: 2, X: 3}, |
| vdl.NStructVWXUint64{V: 1, W: 2, X: 3}, |
| vdl.NStructVWXInt64{V: 1, W: 2, X: 3}, |
| vdl.NStructVWXFloat64{V: 1, W: 2, X: 3}, |
| vdl.NStructVWXMixed{V: 1, W: 2, X: 3}, |
| } |
| rvStructUV01 = []interface{}{ |
| struct{ U, V byte }{U: 0, V: 1}, |
| struct{ U, V uint64 }{U: 0, V: 1}, |
| struct{ U, V int64 }{U: 0, V: 1}, |
| struct{ U, V float64 }{U: 0, V: 1}, |
| struct { |
| // Interleave unexported fields, which are ignored. |
| a bool |
| U int64 |
| b string |
| V float64 |
| c []byte |
| }{U: 0, V: 1}, |
| vdl.NStructUVByte{U: 0, V: 1}, |
| vdl.NStructUVUint64{U: 0, V: 1}, |
| vdl.NStructUVInt64{U: 0, V: 1}, |
| vdl.NStructUVFloat64{U: 0, V: 1}, |
| vdl.NStructUVMixed{U: 0, V: 1}, |
| } |
| rvEmptyStruct = []interface{}{struct{}{}, vdl.NEmpty{}} |
| |
| ttBools = ttTypes(vvBoolTrue) |
| ttStrs = ttTypes(vvStrABC) |
| ttTypeObjects = ttTypes(vvTypeObjectBool) |
| ttSeq123 = ttTypes(vvSeq123) |
| ttSet123 = ttTypes(vvSet123) |
| ttMap123 = ttTypes(vvMap123True) |
| ttSetXYZ = ttTypes(vvSetXYZ) |
| ttMapXYZBool = ttTypes(vvMapXYZTrue) |
| ttStructXYZBool = ttTypes(vvStructXYZTrue) |
| ttStructWXBool = ttTypes(vvStructWXFalseTrue) |
| ttMapVWXNum = ttTypes(vvMapVWX123) |
| ttStructVWXNum = ttTypes(vvStructVWX123) |
| ttStructUVNum = ttTypes(vvStructUV01) |
| ttUints = []*vdl.Type{ |
| vdl.ByteType, vdl.ByteTypeN, |
| vdl.Uint16Type, vdl.Uint16TypeN, |
| vdl.Uint32Type, vdl.Uint32TypeN, |
| vdl.Uint64Type, vdl.Uint64TypeN, |
| } |
| ttInts = []*vdl.Type{ |
| vdl.Int8Type, vdl.Int8TypeN, |
| vdl.Int16Type, vdl.Int16TypeN, |
| vdl.Int32Type, vdl.Int32TypeN, |
| vdl.Int64Type, vdl.Int64TypeN, |
| } |
| ttFloat32s = []*vdl.Type{vdl.Float32Type, vdl.Float32TypeN} |
| ttFloat64s = []*vdl.Type{vdl.Float64Type, vdl.Float64TypeN} |
| ttFloats = ttJoin(ttFloat32s, ttFloat64s) |
| ttIntegers = ttJoin(ttUints, ttInts) |
| ttNumbers = ttJoin(ttIntegers, ttFloats) |
| ttAllTypes = ttJoin(ttBools, ttStrs, ttTypeObjects, ttNumbers, ttSeq123, ttSet123, ttMap123, ttSetXYZ, ttMapXYZBool, ttStructXYZBool, ttMapVWXNum, ttStructVWXNum) |
| |
| rtBools = rtTypes(rvBoolTrue) |
| rtStrs = rtTypes(rvStrABC) |
| rtTypeObjects = rtTypes(rvTypeObjectBool) |
| rtSeq123 = rtTypes(rvSeq123) |
| rtSet123 = rtTypes(rvSet123) |
| rtMap123 = rtTypes(rvMap123True) |
| rtSetXYZ = rtTypes(rvSetXYZ) |
| rtMapXYZBool = rtTypes(rvMapXYZTrue) |
| rtStructXYZBool = rtTypes(rvStructXYZTrue) |
| rtStructWXBool = rtTypes(rvStructWXFalseTrue) |
| rtMapVWXNum = rtTypes(rvMapVWX123) |
| rtStructVWXNum = rtTypes(rvStructVWX123) |
| rtStructUVNum = rtTypes(rvStructUV01) |
| rtUints = []reflect.Type{ |
| reflect.TypeOf(byte(0)), reflect.TypeOf(vdl.NByte(0)), |
| reflect.TypeOf(uint16(0)), reflect.TypeOf(vdl.NUint16(0)), |
| reflect.TypeOf(uint32(0)), reflect.TypeOf(vdl.NUint32(0)), |
| reflect.TypeOf(uint64(0)), reflect.TypeOf(vdl.NUint64(0)), |
| } |
| rtInts = []reflect.Type{ |
| reflect.TypeOf(int8(0)), reflect.TypeOf(vdl.NInt8(0)), |
| reflect.TypeOf(int16(0)), reflect.TypeOf(vdl.NInt16(0)), |
| reflect.TypeOf(int32(0)), reflect.TypeOf(vdl.NInt32(0)), |
| reflect.TypeOf(int64(0)), reflect.TypeOf(vdl.NInt64(0)), |
| } |
| rtFloat32s = []reflect.Type{ |
| reflect.TypeOf(float32(0)), reflect.TypeOf(vdl.NFloat32(0)), |
| } |
| rtFloat64s = []reflect.Type{ |
| reflect.TypeOf(float64(0)), reflect.TypeOf(vdl.NFloat64(0)), |
| } |
| rtFloats = rtJoin(rtFloat32s, rtFloat64s) |
| rtIntegers = rtJoin(rtUints, rtInts) |
| rtNumbers = rtJoin(rtIntegers, rtFloats) |
| rtAllTypes = rtJoin(rtBools, rtStrs, rtTypeObjects, rtNumbers, rtSeq123, rtSet123, rtMap123, rtSetXYZ, rtMapXYZBool, rtStructXYZBool, rtMapVWXNum, rtStructVWXNum) |
| |
| rtInterface = reflect.TypeOf((*interface{})(nil)).Elem() |
| rtPtrToType = reflect.TypeOf((*vdl.Type)(nil)) |
| ) |
| |
| // Helpers to manipulate slices of *Type |
| func ttSetToSlice(set map[*vdl.Type]bool) (result []*vdl.Type) { |
| for tt, _ := range set { |
| result = append(result, tt) |
| } |
| return |
| } |
| func ttTypes(values []*vdl.Value) []*vdl.Type { |
| uniq := make(map[*vdl.Type]bool) |
| for _, v := range values { |
| uniq[v.Type()] = true |
| } |
| return ttSetToSlice(uniq) |
| } |
| func ttJoin(types ...[]*vdl.Type) []*vdl.Type { |
| uniq := make(map[*vdl.Type]bool) |
| for _, ttSlice := range types { |
| for _, tt := range ttSlice { |
| uniq[tt] = true |
| } |
| } |
| return ttSetToSlice(uniq) |
| } |
| |
| // ttOtherThan returns all types from types that aren't represented in other. |
| func ttOtherThan(types []*vdl.Type, other ...[]*vdl.Type) (result []*vdl.Type) { |
| otherMap := make(map[*vdl.Type]bool) |
| for _, oo := range other { |
| for _, o := range oo { |
| otherMap[o] = true |
| } |
| } |
| for _, t := range types { |
| if !otherMap[t] { |
| result = append(result, t) |
| } |
| } |
| return |
| } |
| |
| // Helpers to manipulate slices of reflect.Type |
| func rtSetToSlice(set map[reflect.Type]bool) (result []reflect.Type) { |
| for rt, _ := range set { |
| result = append(result, rt) |
| } |
| return |
| } |
| func rtTypes(values []interface{}) []reflect.Type { |
| uniq := make(map[reflect.Type]bool) |
| for _, v := range values { |
| uniq[reflect.TypeOf(v)] = true |
| } |
| return rtSetToSlice(uniq) |
| } |
| func rtJoin(types ...[]reflect.Type) (result []reflect.Type) { |
| uniq := make(map[reflect.Type]bool) |
| for _, rtSlice := range types { |
| for _, rt := range rtSlice { |
| uniq[rt] = true |
| } |
| } |
| return rtSetToSlice(uniq) |
| } |
| |
| // rtOtherThan returns all types from types that aren't represented in other. |
| func rtOtherThan(types []reflect.Type, other ...[]reflect.Type) (result []reflect.Type) { |
| otherMap := make(map[reflect.Type]bool) |
| for _, oo := range other { |
| for _, o := range oo { |
| otherMap[o] = true |
| } |
| } |
| for _, t := range types { |
| if !otherMap[t] { |
| result = append(result, t) |
| } |
| } |
| return |
| } |
| |
| // vvOnlyFrom returns all values from values that are represented in from. |
| func vvOnlyFrom(values []*vdl.Value, from []*vdl.Type) (result []*vdl.Value) { |
| fromMap := make(map[*vdl.Type]bool) |
| for _, f := range from { |
| fromMap[f] = true |
| } |
| for _, v := range values { |
| if fromMap[v.Type()] { |
| result = append(result, v) |
| } |
| } |
| return |
| } |
| |
| // rvOnlyFrom returns all values from values that are represented in from. |
| func rvOnlyFrom(values []interface{}, from []reflect.Type) (result []interface{}) { |
| fromMap := make(map[reflect.Type]bool) |
| for _, f := range from { |
| fromMap[f] = true |
| } |
| for _, v := range values { |
| if fromMap[reflect.TypeOf(v)] { |
| result = append(result, v) |
| } |
| } |
| return |
| } |
| |
| // vvFromUint returns all *Values that can represent u without loss of precision. |
| func vvFromUint(u uint64) (result []*vdl.Value) { |
| i, f := int64(u), float64(u) |
| switch { |
| case u <= math.MaxInt8: |
| result = append(result, |
| vdl.IntValue(vdl.Int8Type, i), |
| vdl.IntValue(vdl.Int8TypeN, i)) |
| fallthrough |
| case u <= math.MaxUint8: |
| result = append(result, |
| vdl.UintValue(vdl.ByteType, u), |
| vdl.UintValue(vdl.ByteTypeN, u)) |
| fallthrough |
| case u <= math.MaxInt16: |
| result = append(result, |
| vdl.IntValue(vdl.Int16Type, i), |
| vdl.IntValue(vdl.Int16TypeN, i)) |
| fallthrough |
| case u <= math.MaxUint16: |
| result = append(result, |
| vdl.UintValue(vdl.Uint16Type, u), |
| vdl.UintValue(vdl.Uint16TypeN, u)) |
| fallthrough |
| case u <= 1<<24: |
| result = append(result, |
| vdl.FloatValue(vdl.Float32Type, f), |
| vdl.FloatValue(vdl.Float32TypeN, f)) |
| fallthrough |
| case u <= math.MaxInt32: |
| result = append(result, |
| vdl.IntValue(vdl.Int32Type, i), |
| vdl.IntValue(vdl.Int32TypeN, i)) |
| fallthrough |
| case u <= math.MaxUint32: |
| result = append(result, |
| vdl.UintValue(vdl.Uint32Type, u), |
| vdl.UintValue(vdl.Uint32TypeN, u)) |
| fallthrough |
| case u <= 1<<53: |
| result = append(result, |
| vdl.FloatValue(vdl.Float64Type, f), |
| vdl.FloatValue(vdl.Float64TypeN, f)) |
| fallthrough |
| case u <= math.MaxInt64: |
| result = append(result, |
| vdl.IntValue(vdl.Int64Type, i), |
| vdl.IntValue(vdl.Int64TypeN, i)) |
| fallthrough |
| default: |
| result = append(result, |
| vdl.UintValue(vdl.Uint64Type, u), |
| vdl.UintValue(vdl.Uint64TypeN, u)) |
| } |
| return result |
| } |
| |
| // rvFromUint returns all values that can represent u without loss of precision. |
| func rvFromUint(u uint64) (result []interface{}) { |
| switch { |
| case u <= math.MaxInt8: |
| result = append(result, int8(u), vdl.NInt8(u)) |
| fallthrough |
| case u <= math.MaxUint8: |
| result = append(result, byte(u), vdl.NByte(u)) |
| fallthrough |
| case u <= math.MaxInt16: |
| result = append(result, int16(u), vdl.NInt16(u)) |
| fallthrough |
| case u <= math.MaxUint16: |
| result = append(result, uint16(u), vdl.NUint16(u)) |
| fallthrough |
| case u <= 1<<24: |
| result = append(result, float32(u), vdl.NFloat32(u)) |
| fallthrough |
| case u <= math.MaxInt32: |
| result = append(result, int32(u), vdl.NInt32(u)) |
| fallthrough |
| case u <= math.MaxUint32: |
| result = append(result, uint32(u), vdl.NUint32(u)) |
| fallthrough |
| case u <= 1<<53: |
| result = append(result, float64(u), vdl.NFloat64(u)) |
| fallthrough |
| case u <= math.MaxInt64: |
| result = append(result, int64(u), vdl.NInt64(u)) |
| fallthrough |
| default: |
| result = append(result, uint64(u), vdl.NUint64(u)) |
| } |
| return result |
| } |
| |
| // vvFromInt returns all *Values that can represent i without loss of precision. |
| func vvFromInt(i int64) (result []*vdl.Value) { |
| u, f := uint64(i), float64(i) |
| switch { |
| case math.MinInt8 <= i && i <= math.MaxInt8: |
| result = append(result, |
| vdl.IntValue(vdl.Int8Type, i), |
| vdl.IntValue(vdl.Int8TypeN, i)) |
| fallthrough |
| case math.MinInt16 <= i && i <= math.MaxInt16: |
| result = append(result, |
| vdl.IntValue(vdl.Int16Type, i), |
| vdl.IntValue(vdl.Int16TypeN, i)) |
| fallthrough |
| case -1<<24 <= i && i <= 1<<24: |
| result = append(result, |
| vdl.FloatValue(vdl.Float32Type, f), |
| vdl.FloatValue(vdl.Float32TypeN, f)) |
| fallthrough |
| case math.MinInt32 <= i && i <= math.MaxInt32: |
| result = append(result, |
| vdl.IntValue(vdl.Int32Type, i), |
| vdl.IntValue(vdl.Int32TypeN, i)) |
| fallthrough |
| case -1<<53 <= i && i <= 1<<53: |
| result = append(result, |
| vdl.FloatValue(vdl.Float64Type, f), |
| vdl.FloatValue(vdl.Float64TypeN, f)) |
| fallthrough |
| default: |
| result = append(result, |
| vdl.IntValue(vdl.Int64Type, i), |
| vdl.IntValue(vdl.Int64TypeN, i)) |
| } |
| if i < 0 { |
| return |
| } |
| switch { |
| case i <= math.MaxUint8: |
| result = append(result, |
| vdl.UintValue(vdl.ByteType, u), |
| vdl.UintValue(vdl.ByteTypeN, u)) |
| fallthrough |
| case i <= math.MaxUint16: |
| result = append(result, |
| vdl.UintValue(vdl.Uint16Type, u), |
| vdl.UintValue(vdl.Uint16TypeN, u)) |
| fallthrough |
| case i <= math.MaxUint32: |
| result = append(result, |
| vdl.UintValue(vdl.Uint32Type, u), |
| vdl.UintValue(vdl.Uint32TypeN, u)) |
| fallthrough |
| default: |
| result = append(result, |
| vdl.UintValue(vdl.Uint64Type, u), |
| vdl.UintValue(vdl.Uint64TypeN, u)) |
| } |
| return |
| } |
| |
| // rvFromInt returns all values that can represent i without loss of precision. |
| func rvFromInt(i int64) (result []interface{}) { |
| switch { |
| case math.MinInt8 <= i && i <= math.MaxInt8: |
| result = append(result, int8(i), vdl.NInt8(i)) |
| fallthrough |
| case math.MinInt16 <= i && i <= math.MaxInt16: |
| result = append(result, int16(i), vdl.NInt16(i)) |
| fallthrough |
| case -1<<24 <= i && i <= 1<<24: |
| result = append(result, float32(i), vdl.NFloat32(i)) |
| fallthrough |
| case math.MinInt32 <= i && i <= math.MaxInt32: |
| result = append(result, int32(i), vdl.NInt32(i)) |
| fallthrough |
| case -1<<53 <= i && i <= 1<<53: |
| result = append(result, float64(i), vdl.NFloat64(i)) |
| fallthrough |
| default: |
| result = append(result, int64(i), vdl.NInt64(i)) |
| } |
| if i < 0 { |
| return |
| } |
| switch { |
| case i <= math.MaxUint8: |
| result = append(result, byte(i), vdl.NByte(i)) |
| fallthrough |
| case i <= math.MaxUint16: |
| result = append(result, uint16(i), vdl.NUint16(i)) |
| fallthrough |
| case i <= math.MaxUint32: |
| result = append(result, uint32(i), vdl.NUint32(i)) |
| fallthrough |
| default: |
| result = append(result, uint64(i), vdl.NUint64(i)) |
| } |
| return |
| } |
| |
| func vvFloat(f float64) []*vdl.Value { |
| return []*vdl.Value{ |
| vdl.FloatValue(vdl.Float32Type, f), |
| vdl.FloatValue(vdl.Float32TypeN, f), |
| vdl.FloatValue(vdl.Float64Type, f), |
| vdl.FloatValue(vdl.Float64TypeN, f), |
| } |
| } |
| |
| func rvFloat(f float64) []interface{} { |
| return []interface{}{ |
| float32(f), vdl.NFloat32(f), |
| float64(f), vdl.NFloat64(f), |
| } |
| } |
| |
| // Test successful conversions. Each test contains a set of values and |
| // interfaces that are all equivalent and convertible to each other. |
| func TestConverter(t *testing.T) { |
| tests := []struct { |
| vv []*vdl.Value |
| rv []interface{} |
| }{ |
| // TODO(bprosnitz) Convert needs to be switched to the new reader for this to work. |
| // There is currently a bug where Convert will incorrectly return "error" typed value |
| // when "?error" is correct. |
| /*{[]*vdl.Value{vvError1}, []interface{}{rvError1}}, |
| {[]*vdl.Value{vvError2}, []interface{}{rvError2}}, |
| {[]*vdl.Value{vvError3}, []interface{}{rvError3}},*/ |
| {vvBoolTrue, rvBoolTrue}, |
| {vvStrABC, rvStrABC}, |
| {vvFromUint(math.MaxUint8), rvFromUint(math.MaxUint8)}, |
| {vvFromUint(math.MaxUint16), rvFromUint(math.MaxUint16)}, |
| {vvFromUint(math.MaxUint32), rvFromUint(math.MaxUint32)}, |
| {vvFromUint(math.MaxUint64), rvFromUint(math.MaxUint64)}, |
| {vvFromInt(math.MaxInt8), rvFromInt(math.MaxInt8)}, |
| {vvFromInt(math.MaxInt16), rvFromInt(math.MaxInt16)}, |
| {vvFromInt(math.MaxInt32), rvFromInt(math.MaxInt32)}, |
| {vvFromInt(math.MaxInt64), rvFromInt(math.MaxInt64)}, |
| {vvFromInt(math.MinInt8), rvFromInt(math.MinInt8)}, |
| {vvFromInt(math.MinInt16), rvFromInt(math.MinInt16)}, |
| {vvFromInt(math.MinInt32), rvFromInt(math.MinInt32)}, |
| {vvFromInt(math.MinInt64), rvFromInt(math.MinInt64)}, |
| {vvFromInt(vdl.Float32MaxInt), rvFromInt(vdl.Float32MaxInt)}, |
| {vvFromInt(vdl.Float64MaxInt), rvFromInt(vdl.Float64MaxInt)}, |
| {vvFromInt(vdl.Float32MinInt), rvFromInt(vdl.Float32MinInt)}, |
| {vvFromInt(vdl.Float64MinInt), rvFromInt(vdl.Float64MinInt)}, |
| {vvTypeObjectBool, rvTypeObjectBool}, |
| {vvSeq123, rvSeq123}, |
| {vvSet123, rvSet123}, |
| {vvMap123True, rvMap123True}, |
| {vvSetXYZ, rvSetXYZ}, |
| {vvMapXYZTrue, rvMapXYZTrue}, |
| {vvStructXYZTrue, rvStructXYZTrue}, |
| {vvMapVWX123, rvMapVWX123}, |
| {vvStructVWX123, rvStructVWX123}, |
| {vvStructUV01, rvStructUV01}, |
| {nil, []interface{}{vdl.NNative(0)}}, |
| {nil, []interface{}{vdl.NNative(1)}}, |
| {nil, []interface{}{vdl.NNative(-(1 << 63))}}, |
| {nil, []interface{}{vdl.NNative((1 << 63) - 1)}}, |
| {nil, []interface{}{vdl.NUnionNative("A=false")}}, |
| {nil, []interface{}{vdl.NUnionNative("A=true")}}, |
| {nil, []interface{}{vdl.NUnionNative("B=123")}}, |
| {nil, []interface{}{vdl.NUnionNative("B=-123")}}, |
| } |
| for _, test := range tests { |
| testConverterWantSrc(t, vvrv{test.vv, test.rv}, vvrv{test.vv, test.rv}) |
| } |
| } |
| |
| // Test successful conversions that drop and ignore fields in the dst struct. |
| func TestConverterStructDropIgnore(t *testing.T) { |
| tests := []struct { |
| vvWant []*vdl.Value |
| rvWant []interface{} |
| vvSrc []*vdl.Value |
| rvSrc []interface{} |
| }{ |
| {vvStructWXFalseTrue, rvStructWXFalseTrue, vvStructXYZTrue, rvStructXYZTrue}, |
| {vvStructUV01, rvStructUV01, vvStructVWX123, rvStructVWX123}, |
| } |
| for _, test := range tests { |
| testConverterWantSrc(t, vvrv{test.vvWant, test.rvWant}, vvrv{test.vvSrc, test.rvSrc}) |
| } |
| } |
| |
| // Test successful conversions to and from union values. |
| func TestConverterUnion(t *testing.T) { |
| // values for union component types |
| vvTrue := vdl.BoolValue(nil, true) |
| vv123 := vdl.IntValue(vdl.Int64Type, 123) |
| vvAbc := vdl.StringValue(nil, "Abc") |
| vvStruct123 := vdl.ZeroValue(vdl.StructInt64TypeN) |
| vvStruct123.StructField(0).Assign(vv123) |
| rvTrue := bool(true) |
| rv123 := int64(123) |
| rvAbc := string("Abc") |
| rvStruct123 := vdl.NStructInt64{123} |
| // values for union{A bool;B string;C struct} |
| vvTrueABC := vdl.UnionValue(vdl.UnionABCTypeN, 0, vvTrue) |
| vvAbcABC := vdl.UnionValue(vdl.UnionABCTypeN, 1, vvAbc) |
| vvStruct123ABC := vdl.UnionValue(vdl.UnionABCTypeN, 2, vvStruct123) |
| rvTrueABC := vdl.NUnionABCA{rvTrue} |
| rvAbcABC := vdl.NUnionABCB{rvAbc} |
| rvStruct123ABC := vdl.NUnionABCC{rvStruct123} |
| rvTrueABCi := vdl.NUnionABC(rvTrueABC) |
| rvAbcABCi := vdl.NUnionABC(rvAbcABC) |
| rvStruct123ABCi := vdl.NUnionABC(rvStruct123ABC) |
| // values for union{B string;C struct;D int64} |
| vvAbcBCD := vdl.UnionValue(vdl.UnionBCDTypeN, 0, vvAbc) |
| vvStruct123BCD := vdl.UnionValue(vdl.UnionBCDTypeN, 1, vvStruct123) |
| vv123BCD := vdl.UnionValue(vdl.UnionBCDTypeN, 2, vv123) |
| rvAbcBCD := vdl.NUnionBCDB{rvAbc} |
| rvStruct123BCD := vdl.NUnionBCDC{rvStruct123} |
| rv123BCD := vdl.NUnionBCDD{rv123} |
| rvAbcBCDi := vdl.NUnionBCD(rvAbcBCD) |
| rvStruct123BCDi := vdl.NUnionBCD(rvStruct123BCD) |
| rv123BCDi := vdl.NUnionBCD(rv123BCD) |
| // values for union{X string;Y struct}, which has no Go equivalent. |
| vvAbcXY := vdl.UnionValue(vdl.UnionXYTypeN, 0, vvAbc) |
| vvStruct123XY := vdl.UnionValue(vdl.UnionXYTypeN, 1, vvStruct123) |
| |
| tests := []struct { |
| vvWant *vdl.Value |
| rvWant interface{} |
| vvSrc *vdl.Value |
| rvSrc interface{} |
| }{ |
| // Convert source and target same union. |
| {vvTrueABC, rvTrueABC, vvTrueABC, rvTrueABC}, |
| {vv123BCD, rv123BCD, vv123BCD, rv123BCD}, |
| {vvAbcABC, rvAbcABC, vvAbcABC, rvAbcABC}, |
| {vvAbcBCD, rvAbcBCD, vvAbcBCD, rvAbcBCD}, |
| {vvStruct123ABC, rvStruct123ABC, vvStruct123ABC, rvStruct123ABC}, |
| {vvStruct123BCD, rvStruct123BCD, vvStruct123BCD, rvStruct123BCD}, |
| // Same thing, but with pointers to the interface type. |
| {vvTrueABC, &rvTrueABCi, vvTrueABC, &rvTrueABCi}, |
| {vv123BCD, &rv123BCDi, vv123BCD, &rv123BCD}, |
| {vvAbcABC, &rvAbcABCi, vvAbcABC, &rvAbcABC}, |
| {vvAbcBCD, &rvAbcBCDi, vvAbcBCD, &rvAbcBCD}, |
| {vvStruct123ABC, &rvStruct123ABCi, vvStruct123ABC, &rvStruct123ABCi}, |
| {vvStruct123BCD, &rvStruct123BCDi, vvStruct123BCD, &rvStruct123BCDi}, |
| |
| // Convert source and target different union. |
| {vvAbcABC, rvAbcABC, vvAbcBCD, rvAbcBCD}, |
| {vvAbcBCD, rvAbcBCD, vvAbcABC, rvAbcABC}, |
| {vvStruct123ABC, rvStruct123ABC, vvStruct123BCD, rvStruct123BCD}, |
| {vvStruct123BCD, rvStruct123BCD, vvStruct123ABC, rvStruct123ABC}, |
| // Same thing, but with pointers to the interface type. |
| {vvAbcABC, &rvAbcABCi, vvAbcBCD, &rvAbcBCDi}, |
| {vvAbcBCD, &rvAbcBCDi, vvAbcABC, &rvAbcABCi}, |
| {vvStruct123ABC, &rvStruct123ABCi, vvStruct123BCD, &rvStruct123BCDi}, |
| {vvStruct123BCD, &rvStruct123BCDi, vvStruct123ABC, &rvStruct123ABCi}, |
| |
| // Test unions that have no Go equivalent. |
| {vvAbcXY, nil, vvAbcXY, nil}, |
| {vvStruct123XY, nil, vvStruct123XY, nil}, |
| } |
| for _, test := range tests { |
| testConverterWantSrc(t, |
| vvrv{vvSlice(test.vvWant), rvSlice(test.rvWant)}, |
| vvrv{vvSlice(test.vvSrc), rvSlice(test.rvSrc)}) |
| } |
| } |
| |
| func vvSlice(v *vdl.Value) []*vdl.Value { |
| if v != nil { |
| return []*vdl.Value{v} |
| } |
| return nil |
| } |
| |
| func rvSlice(v interface{}) []interface{} { |
| if v != nil { |
| return []interface{}{v} |
| } |
| return nil |
| } |
| |
| // Test successful conversions to and from nil values. |
| func TestConverterNil(t *testing.T) { |
| vvNil := vdl.ZeroValue(vdl.AnyType) |
| rvNil := new(interface{}) |
| vvNilError := vdl.ZeroValue(vdl.ErrorType) |
| rvNilError := new(error) |
| vvNilPtrStruct := vdl.ZeroValue(vdl.TypeOf((*vdl.NStructInt)(nil))) |
| rvNilPtrStruct := (*vdl.NStructInt)(nil) |
| vvStructNilStructField := vdl.ZeroValue(vdl.TypeOf(vdl.NStructOptionalStruct{})) |
| rvStructNilStructField := vdl.NStructOptionalStruct{X: nil} |
| vvStructNilAnyField := vdl.ZeroValue(vdl.TypeOf(vdl.NStructOptionalAny{})) |
| rvStructNilAnyField := vdl.NStructOptionalAny{X: nil} |
| tests := []struct { |
| vvWant *vdl.Value |
| rvWant interface{} |
| vvSrc *vdl.Value |
| rvSrc interface{} |
| }{ |
| // Conversion source and target are the same. |
| {vvNil, rvNil, vvNil, rvNil}, |
| {vvNilError, rvNilError, vvNilError, rvNilError}, |
| {vvNilPtrStruct, rvNilPtrStruct, vvNilPtrStruct, rvNilPtrStruct}, |
| {vvStructNilStructField, rvStructNilStructField, vvStructNilStructField, rvStructNilStructField}, |
| {vvStructNilAnyField, rvStructNilAnyField, vvStructNilAnyField, rvStructNilAnyField}, |
| // All typed nil targets may be converted from any(nil). |
| {vvNilError, rvNilError, vvNil, rvNil}, |
| {vvNilPtrStruct, rvNilPtrStruct, vvNil, rvNil}, |
| {vvStructNilStructField, rvStructNilStructField, vvStructNilAnyField, rvStructNilAnyField}, |
| } |
| for _, test := range tests { |
| testConverterWantSrc(t, |
| vvrv{[]*vdl.Value{test.vvWant}, []interface{}{test.rvWant}}, |
| vvrv{[]*vdl.Value{test.vvSrc}, []interface{}{test.rvSrc}}) |
| } |
| } |
| |
| type vvrv struct { |
| vv []*vdl.Value |
| rv []interface{} |
| } |
| |
| func testConverterWantSrc(t *testing.T, vvrvWant, vvrvSrc vvrv) { |
| // We run each testConvert helper twice; the first call tests filling in a |
| // zero dst, and the second call tests filling in a non-zero dst. |
| |
| // Tests of filling from *Value |
| for _, vvSrc := range vvrvSrc.vv { |
| for _, vvWant := range vvrvWant.vv { |
| // Test filling *Value from *Value |
| vvDst := vdl.ZeroValue(vvWant.Type()) |
| testConvert(t, "vv1", vvDst, vvSrc, vvWant, 0, false, "") |
| testConvert(t, "vv2", vvDst, vvSrc, vvWant, 0, false, "") |
| } |
| for _, want := range vvrvWant.rv { |
| // Test filling reflect.Value from *Value |
| dst := reflect.New(reflect.TypeOf(want)).Interface() |
| testConvert(t, "vv3", dst, vvSrc, want, 1, false, "") |
| testConvert(t, "vv4", dst, vvSrc, want, 1, false, "") |
| } |
| // Test filling Any from *Value |
| vvDst := vdl.ZeroValue(vdl.AnyType) |
| testConvert(t, "vv5", vvDst, vvSrc, vdl.ZeroValue(vdl.AnyType).Assign(vvSrc), 0, false, "") |
| testConvert(t, "vv6", vvDst, vvSrc, vdl.ZeroValue(vdl.AnyType).Assign(vvSrc), 0, false, "") |
| // Test filling Optional from *Value |
| if vvSrc.Type().CanBeOptional() { |
| ttNil := vdl.OptionalType(vvSrc.Type()) |
| vvNil := vdl.ZeroValue(ttNil) |
| vvOptWant := vdl.OptionalValue(vvSrc) |
| testConvert(t, "vv7", vvNil, vvSrc, vvOptWant, 0, false, "") |
| testConvert(t, "vv8", vvNil, vvSrc, vvOptWant, 0, false, "") |
| } |
| // Test filling **Value(nil) from *Value |
| var vvValue *vdl.Value |
| testConvert(t, "vv9", &vvValue, vvSrc, vvSrc, 1, false, "") |
| testConvert(t, "vv10", &vvValue, vvSrc, vvSrc, 1, false, "") |
| // Test filling interface{} from *Value |
| const useOldConverter = true |
| if !useOldConverter { |
| if !canCreateGoObject(vvSrc.Type()) { |
| // When an instance of a go object cannot be created, error. |
| var dst interface{} |
| testConvert(t, "vv11", &dst, vvSrc, vvSrc, 1, false, "not registered") |
| testConvert(t, "vv12", &dst, vvSrc, vvSrc, 1, false, "not registered") |
| } |
| } |
| if vvSrc.Kind() == vdl.Struct { |
| // Every struct may be converted to the empty struct |
| testConvert(t, "vv13", vdl.ZeroValue(vdl.EmptyType), vvSrc, vdl.ZeroValue(vdl.EmptyType), 0, false, "") |
| testConvert(t, "vv14", vdl.ZeroValue(vdl.EmptyTypeN), vvSrc, vdl.ZeroValue(vdl.EmptyTypeN), 0, false, "") |
| var empty struct{} |
| var emptyN vdl.NEmpty |
| testConvert(t, "vv15", &empty, vvSrc, struct{}{}, 1, false, "") |
| testConvert(t, "vv16", &emptyN, vvSrc, vdl.NEmpty{}, 1, false, "") |
| // The empty struct may be converted to the zero value of any struct |
| vvZeroSrc := vdl.ZeroValue(vvSrc.Type()) |
| testConvert(t, "vv17", vdl.ZeroValue(vvSrc.Type()), vdl.ZeroValue(vdl.EmptyType), vvZeroSrc, 0, false, "") |
| testConvert(t, "vv18", vdl.ZeroValue(vvSrc.Type()), vdl.ZeroValue(vdl.EmptyTypeN), vvZeroSrc, 0, false, "") |
| testConvert(t, "vv19", vdl.ZeroValue(vvSrc.Type()), struct{}{}, vvZeroSrc, 0, false, "") |
| testConvert(t, "vv20", vdl.ZeroValue(vvSrc.Type()), vdl.NEmpty{}, vvZeroSrc, 0, false, "") |
| } |
| } |
| |
| // Tests of filling from reflect.Value |
| for _, src := range vvrvSrc.rv { |
| rtSrc := reflect.TypeOf(src) |
| for _, vvWant := range vvrvWant.vv { |
| // Test filling *Value from reflect.Value |
| vvDst := vdl.ZeroValue(vvWant.Type()) |
| testConvert(t, "rv1", vvDst, src, vvWant, 0, false, "") |
| testConvert(t, "rv2", vvDst, src, vvWant, 0, false, "") |
| } |
| for _, want := range vvrvWant.rv { |
| // Test filling reflect.Value from reflect.Value |
| dst := reflect.New(reflect.TypeOf(want)).Interface() |
| testConvert(t, "rv3", dst, src, want, 1, false, "") |
| testConvert(t, "rv4", dst, src, want, 1, false, "") |
| } |
| vvWant := vdl.ValueOf(src) |
| // Test filling Any from reflect.Value |
| vvDst := vdl.ZeroValue(vdl.AnyType) |
| testConvert(t, "rv5", vvDst, src, vdl.ZeroValue(vdl.AnyType).Assign(vvWant), 0, true, "") |
| testConvert(t, "rv6", vvDst, src, vdl.ZeroValue(vdl.AnyType).Assign(vvWant), 0, true, "") |
| // Test filling **Value(nil) from reflect.Value |
| var vvValue *vdl.Value |
| testConvert(t, "rv7", &vvValue, src, vvWant, 1, false, "") |
| testConvert(t, "rv8", &vvValue, src, vvWant, 1, false, "") |
| // Test filling interface{} from reflect.Value |
| const useOldConverter = true |
| if !useOldConverter { |
| if !canCreateGoObject(vvWant.Type()) { |
| // When an instance of a go object cannot be created, error. |
| var dst interface{} |
| testConvert(t, "rv9", &dst, src, src, 1, false, "not registered") |
| testConvert(t, "rv10", &dst, src, src, 1, false, "not registered") |
| } |
| } |
| ttSrc, err := vdl.TypeFromReflect(rtSrc) |
| if err != nil { |
| t.Error(err) |
| continue |
| } |
| if rtSrc.Kind() == reflect.Struct && ttSrc.Kind() != vdl.Union { |
| // Every struct may be converted to the empty struct |
| testConvert(t, "rv11", vdl.ZeroValue(vdl.EmptyType), src, vdl.ZeroValue(vdl.EmptyType), 0, false, "") |
| testConvert(t, "rv12", vdl.ZeroValue(vdl.EmptyTypeN), src, vdl.ZeroValue(vdl.EmptyTypeN), 0, false, "") |
| var empty struct{} |
| var emptyN vdl.NEmpty |
| testConvert(t, "rv13", &empty, src, struct{}{}, 1, false, "") |
| testConvert(t, "rv14", &emptyN, src, vdl.NEmpty{}, 1, false, "") |
| // The empty struct may be converted to the zero value of any struct |
| rvZeroSrc := reflect.Zero(rtSrc).Interface() |
| testConvert(t, "rv15", reflect.New(rtSrc).Interface(), vdl.ZeroValue(vdl.EmptyType), rvZeroSrc, 1, false, "") |
| testConvert(t, "rv16", reflect.New(rtSrc).Interface(), vdl.ZeroValue(vdl.EmptyTypeN), rvZeroSrc, 1, false, "") |
| testConvert(t, "rv17", reflect.New(rtSrc).Interface(), struct{}{}, rvZeroSrc, 1, false, "") |
| testConvert(t, "rv18", reflect.New(rtSrc).Interface(), vdl.NEmpty{}, rvZeroSrc, 1, false, "") |
| } |
| } |
| } |
| |
| // canCreateGoObject returns true iff we can create a regular Go object from a |
| // value of type tt. We can create a real Go object if the Go type for tt has |
| // been registered, or if tt is the special-cased error type. |
| func canCreateGoObject(tt *vdl.Type) bool { |
| return tt == vdl.AnyType || vdl.TypeToReflect(tt) != nil || tt == vdl.ErrorType || tt == vdl.ErrorType.Elem() |
| } |
| |
| func testConvert(t *testing.T, prefix string, dst, src, want interface{}, deref int, optWant bool, expectedErr string) { |
| const ptrDepth = 3 |
| rvDst := reflect.ValueOf(dst) |
| for dstptrs := 0; dstptrs < ptrDepth; dstptrs++ { |
| rvSrc := reflect.ValueOf(src) |
| for srcptrs := 0; srcptrs < ptrDepth; srcptrs++ { |
| tname := fmt.Sprintf("%s Convert(%v, %v)", prefix, rvDst.Type(), rvSrc.Type()) |
| // This is tricky - if optWant is set, we might need to change the want |
| // value to become optional or non-optional. |
| eWant, rvWant, ttWant := want, reflect.ValueOf(want), vdl.TypeOf(want) |
| if optWant { |
| vvWant, wantIsVV := want.(*vdl.Value) |
| if srcptrs > 0 { |
| if wantIsVV { |
| switch { |
| case vvWant.Kind() == vdl.Any && !vvWant.IsNil() && vvWant.Elem().Type().CanBeOptional(): |
| // Turn any(struct{...}) into any(?struct{...}) |
| eWant = vdl.ZeroValue(vdl.AnyType).Assign(vdl.OptionalValue(vvWant.Elem())) |
| case vvWant.Type().CanBeOptional(): |
| // Turn struct{...} into ?struct{...} |
| eWant = vdl.OptionalValue(vvWant) |
| } |
| } else if (ttWant.Kind() == vdl.Optional || ttWant.CanBeOptional()) && rvWant.Kind() != reflect.Ptr { |
| // Add a pointer to non-pointers that can be optional. |
| rvPtrWant := reflect.New(rvWant.Type()) |
| rvPtrWant.Elem().Set(rvWant) |
| eWant = rvPtrWant.Interface() |
| } |
| } |
| if !wantIsVV && ttWant.Kind() != vdl.TypeObject && !ttWant.CanBeOptional() && rvWant.Kind() == reflect.Ptr && !rvWant.IsNil() { |
| // Remove a pointer from anything that can't be optional. |
| eWant = rvWant.Elem().Interface() |
| } |
| } |
| err := vdl.Convert(rvDst.Interface(), rvSrc.Interface()) |
| vdl.ExpectErr(t, err, expectedErr, tname) |
| if expectedErr == "" { |
| expectConvert(t, tname, dst, eWant, deref) |
| } |
| // Next iteration adds a pointer to src. |
| rvNewSrc := reflect.New(rvSrc.Type()) |
| rvNewSrc.Elem().Set(rvSrc) |
| rvSrc = rvNewSrc |
| } |
| // Next iteration adds a pointer to dst. |
| rvNewDst := reflect.New(rvDst.Type()) |
| rvNewDst.Elem().Set(rvDst) |
| rvDst = rvNewDst |
| } |
| } |
| |
| func expectConvert(t *testing.T, tname string, got, want interface{}, deref int) { |
| rvGot := reflect.ValueOf(got) |
| for d := 0; d < deref; d++ { |
| if rvGot.Kind() != reflect.Ptr || rvGot.IsNil() { |
| t.Errorf("%s can't deref %d %T %v", tname, deref, got, got) |
| return |
| } |
| rvGot = rvGot.Elem() |
| } |
| got = rvGot.Interface() |
| vvGot, ok1 := got.(*vdl.Value) |
| vvWant, ok2 := want.(*vdl.Value) |
| if ok1 && ok2 { |
| if !vdl.EqualValue(vvGot, vvWant) { |
| t.Errorf("%s\nGOT %v\nWANT %v", tname, vvGot, vvWant) |
| } |
| return |
| } |
| if !reflect.DeepEqual(got, want) { |
| t.Errorf("%s\nGOT %#v\nWANT %#v", tname, got, want) |
| } |
| } |
| |
| // Test failed conversions. |
| func TestConverterError(t *testing.T) { |
| tests := []struct { |
| ttDst []*vdl.Type |
| rtDst []reflect.Type |
| vvSrc []*vdl.Value |
| rvSrc []interface{} |
| }{ |
| {ttOtherThan(ttAllTypes, ttBools), rtOtherThan(rtAllTypes, rtBools), |
| vvBoolTrue, rvBoolTrue}, |
| {ttOtherThan(ttAllTypes, ttStrs), rtOtherThan(rtAllTypes, rtStrs), |
| vvStrABC, rvStrABC}, |
| {ttOtherThan(ttAllTypes, ttTypeObjects), rtOtherThan(rtAllTypes, rtTypeObjects), |
| vvTypeObjectBool, rvTypeObjectBool}, |
| {ttOtherThan(ttAllTypes, ttSeq123), rtOtherThan(rtAllTypes, rtSeq123), |
| vvSeq123, rvSeq123}, |
| // Test invalid conversions to set types |
| {ttSet123, rtSet123, vvMap123FalseTrue, rvMap123FalseTrue}, |
| {ttSetXYZ, rtSetXYZ, vvMapXYZFalseTrue, rvMapXYZFalseTrue}, |
| // Test invalid conversions to struct types: no fields in common |
| {ttStructWXBool, rtStructWXBool, vvStructUV01, rvStructUV01}, |
| {ttStructUVNum, rtStructUVNum, vvStructWXFalseTrue, rvStructWXFalseTrue}, |
| // Test uint values one past the max bound. |
| {ttOtherThan(ttIntegers, ttTypes(vvFromUint(math.MaxUint8))), |
| rtOtherThan(rtIntegers, rtTypes(rvFromUint(math.MaxUint8))), |
| vvFromUint(math.MaxUint8 + 1), |
| rvFromUint(math.MaxUint8 + 1)}, |
| {ttOtherThan(ttIntegers, ttTypes(vvFromUint(math.MaxUint16))), |
| rtOtherThan(rtIntegers, rtTypes(rvFromUint(math.MaxUint16))), |
| vvFromUint(math.MaxUint16 + 1), |
| rvFromUint(math.MaxUint16 + 1)}, |
| {ttOtherThan(ttIntegers, ttTypes(vvFromUint(math.MaxUint32))), |
| rtOtherThan(rtIntegers, rtTypes(rvFromUint(math.MaxUint32))), |
| vvFromUint(math.MaxUint32 + 1), |
| rvFromUint(math.MaxUint32 + 1)}, |
| // Test int values one past the max bound. |
| {ttOtherThan(ttIntegers, ttTypes(vvFromUint(math.MaxInt8))), |
| rtOtherThan(rtIntegers, rtTypes(rvFromUint(math.MaxInt8))), |
| vvFromUint(math.MaxInt8 + 1), |
| rvFromUint(math.MaxInt8 + 1)}, |
| {ttOtherThan(ttIntegers, ttTypes(vvFromUint(math.MaxInt16))), |
| rtOtherThan(rtIntegers, rtTypes(rvFromUint(math.MaxInt16))), |
| vvFromUint(math.MaxInt16 + 1), |
| rvFromUint(math.MaxInt16 + 1)}, |
| {ttOtherThan(ttIntegers, ttTypes(vvFromUint(math.MaxInt32))), |
| rtOtherThan(rtIntegers, rtTypes(rvFromUint(math.MaxInt32))), |
| vvFromUint(math.MaxInt32 + 1), |
| rvFromUint(math.MaxInt32 + 1)}, |
| {ttOtherThan(ttIntegers, ttTypes(vvFromUint(math.MaxInt64))), |
| rtOtherThan(rtIntegers, rtTypes(rvFromUint(math.MaxInt64))), |
| vvFromUint(math.MaxInt64 + 1), |
| rvFromUint(math.MaxInt64 + 1)}, |
| // Test int values one past the min bound. |
| {ttOtherThan(ttIntegers, ttTypes(vvFromInt(math.MinInt8))), |
| rtOtherThan(rtIntegers, rtTypes(rvFromInt(math.MinInt8))), |
| vvFromInt(math.MinInt8 - 1), |
| rvFromInt(math.MinInt8 - 1)}, |
| {ttOtherThan(ttIntegers, ttTypes(vvFromInt(math.MinInt16))), |
| rtOtherThan(rtIntegers, rtTypes(rvFromInt(math.MinInt16))), |
| vvFromInt(math.MinInt16 - 1), |
| rvFromInt(math.MinInt16 - 1)}, |
| {ttOtherThan(ttIntegers, ttTypes(vvFromInt(math.MinInt32))), |
| rtOtherThan(rtIntegers, rtTypes(rvFromInt(math.MinInt32))), |
| vvFromInt(math.MinInt32 - 1), |
| rvFromInt(math.MinInt32 - 1)}, |
| // Test int to float max bound. |
| {ttJoin(ttFloat32s), rtJoin(rtFloat32s), |
| vvOnlyFrom(vvFromInt(vdl.Float32MaxInt+1), ttIntegers), |
| rvOnlyFrom(rvFromInt(vdl.Float32MaxInt+1), rtIntegers)}, |
| {ttJoin(ttFloat64s), rtJoin(rtFloat64s), |
| vvOnlyFrom(vvFromInt(vdl.Float64MaxInt+1), ttIntegers), |
| rvOnlyFrom(rvFromInt(vdl.Float64MaxInt+1), rtIntegers)}, |
| // Test int to float min bound. |
| {ttJoin(ttFloat32s), rtJoin(rtFloat32s), |
| vvOnlyFrom(vvFromInt(vdl.Float32MinInt-1), ttIntegers), |
| rvOnlyFrom(rvFromInt(vdl.Float32MinInt-1), rtIntegers)}, |
| {ttJoin(ttFloat64s), rtJoin(rtFloat64s), |
| vvOnlyFrom(vvFromInt(vdl.Float64MinInt-1), ttIntegers), |
| rvOnlyFrom(rvFromInt(vdl.Float64MinInt-1), rtIntegers)}, |
| // Test negative uints, fractional integers. |
| {ttUints, rtUints, vvFromInt(-1), rvFromInt(-1)}, |
| {ttIntegers, rtIntegers, vvFloat(1.5), rvFloat(1.5)}, |
| } |
| for _, test := range tests { |
| for _, rtDst := range test.rtDst { |
| rvDst := reflect.New(rtDst) |
| got := rvDst.Elem().Interface() |
| for _, vvSrc := range test.vvSrc { |
| if err := vdl.ConvertReflect(rvDst, reflect.ValueOf(vvSrc)); err == nil { |
| t.Errorf("%s ConvertReflect(%v, %v), want error", rvDst.Type(), vvSrc.Type(), got) |
| } |
| } |
| for _, src := range test.rvSrc { |
| rvSrc := reflect.ValueOf(src) |
| if err := vdl.ConvertReflect(rvDst, rvSrc); err == nil { |
| t.Errorf("%s FromReflect(%v, %v), want error", rvDst.Type(), rvSrc.Type(), got) |
| } |
| } |
| } |
| } |
| } |
| |
| // Note: There are no other tests which cover these cases outside of a test in |
| // v.io/v23/security. |
| // These tests also can't be moved to TestConverter because it involves |
| // conversion to an interface which will resolve in a non-wiretype output. |
| func TestConverterToWiretype(t *testing.T) { |
| var nWire vdl.NWire |
| if err := vdl.Convert(&nWire, vdl.NWire{"100"}); err != nil { |
| t.Fatalf("unexpected error converting to wire type") |
| } |
| if got, want := nWire, (vdl.NWire{"100"}); got != want { |
| t.Errorf("got %#v, want %#v", got, want) |
| } |
| var nUnionWire vdl.NUnionWire |
| if err := vdl.Convert(&nUnionWire, vdl.NUnionNative("A=false")); err != nil { |
| t.Fatalf("unexpected error converting to wire type") |
| } |
| if got, want := nUnionWire, (vdl.NUnionWireA{false}); got != want { |
| t.Errorf("got %#v, want %#v", got, want) |
| } |
| } |
| |
| func TestConvertNew(t *testing.T) { |
| for _, entry := range vdltest.AllPass() { |
| rvTargetPtr := reflect.New(entry.Target.Type()) |
| if err := vdl.Convert(rvTargetPtr.Interface(), entry.Source.Interface()); err != nil { |
| t.Errorf("%s: Convert failed: %v", entry.Name(), err) |
| } |
| if got, want := rvTargetPtr.Elem(), entry.Target; !vdl.DeepEqualReflect(got, want) { |
| t.Errorf("%s\nGOT %v\nWANT %v", entry.Name(), got, want) |
| } |
| } |
| } |
| |
| func TestConvertFailNew(t *testing.T) { |
| for _, entry := range vdltest.AllFail() { |
| rvTargetPtr := reflect.New(entry.Target.Type()) |
| if err := vdl.Convert(rvTargetPtr.Interface(), entry.Source.Interface()); err == nil { |
| t.Errorf("%s: Convert passed, wanted failure", entry.Name()) |
| } |
| } |
| } |
