| // 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 |
| |
| // This file contains a collection of types, constants and functions used for |
| // testing. All identifiers are exported, so they may be accessed via tests in |
| // the vdl_test package. Note that since this is a *_test.go file, these |
| // identifiers are still only visible in tests. |
| // |
| // TODO(toddw): Merge with vdl/opconst/testutil_test.go |
| |
| import ( |
| "fmt" |
| "strconv" |
| "strings" |
| "testing" |
| ) |
| |
| const ( |
| // These constants are the same as the ones defined in overflow.go. |
| Float64MaxInt = (1 << 53) |
| Float64MinInt = -(1 << 53) |
| Float32MaxInt = (1 << 24) |
| Float32MinInt = -(1 << 24) |
| ) |
| |
| // CallAndRecover calls the function f and returns the result of recover(). |
| // This minimizes the scope of the deferred recover, to ensure f is actually the |
| // function that paniced. |
| func CallAndRecover(f func()) (result interface{}) { |
| defer func() { |
| result = recover() |
| }() |
| f() |
| return |
| } |
| |
| func ExpectErr(t *testing.T, err error, wantstr string, format string, args ...interface{}) bool { |
| gotstr := fmt.Sprint(err) |
| msg := fmt.Sprintf(format, args...) |
| if wantstr != "" && !strings.Contains(gotstr, wantstr) { |
| t.Errorf(`%s got error %q, want substr %q`, msg, gotstr, wantstr) |
| return false |
| } |
| if wantstr == "" && err != nil { |
| t.Errorf(`%s got error %q, want nil`, msg, gotstr) |
| return false |
| } |
| return true |
| } |
| |
| func ExpectPanic(t *testing.T, f func(), wantstr string, format string, args ...interface{}) { |
| got := CallAndRecover(f) |
| gotstr := fmt.Sprint(got) |
| msg := fmt.Sprintf(format, args...) |
| if wantstr != "" && !strings.Contains(gotstr, wantstr) { |
| t.Errorf(`%s got panic %q, want substr %q`, msg, gotstr, wantstr) |
| } |
| if wantstr == "" && got != nil { |
| t.Errorf(`%s got panic %q, want nil`, msg, gotstr) |
| } |
| } |
| |
| func ExpectMismatchedKind(t *testing.T, f func()) { |
| ExpectPanic(t, f, "mismatched kind", "") |
| } |
| |
| // Define a bunch of regular Go types used in tests. |
| type ( |
| // Scalars |
| NInterface interface{} |
| NType *Type |
| NBool bool |
| NByte byte |
| NUint16 uint16 |
| NUint32 uint32 |
| NUint64 uint64 |
| NUint uint |
| NUintptr uintptr |
| NInt8 int8 |
| NInt16 int16 |
| NInt32 int32 |
| NInt64 int64 |
| NInt int |
| NFloat32 float32 |
| NFloat64 float64 |
| NComplex64 complex64 |
| NComplex128 complex128 |
| NString string |
| // Arrays |
| NArray3Interface [3]NInterface |
| NArray3TypeObject [3]*Type |
| NArray3Bool [3]bool |
| NArray3Byte [3]byte |
| NArray3Uint16 [3]uint16 |
| NArray3Uint32 [3]uint32 |
| NArray3Uint64 [3]uint64 |
| NArray3Uint [3]uint |
| NArray3Uintptr [3]uintptr |
| NArray3Int8 [3]int8 |
| NArray3Int16 [3]int16 |
| NArray3Int32 [3]int32 |
| NArray3Int64 [3]int64 |
| NArray3Int [3]int |
| NArray3Float32 [3]float32 |
| NArray3Float64 [3]float64 |
| NArray3Complex64 [3]complex64 |
| NArray3Complex128 [3]complex128 |
| NArray3String [3]string |
| // Structs |
| NStructInterface struct{ X NInterface } |
| NStructTypeObject struct{ X *Type } |
| NStructBool struct{ X bool } |
| NStructByte struct{ X byte } |
| NStructUint16 struct{ X uint16 } |
| NStructUint32 struct{ X uint32 } |
| NStructUint64 struct{ X uint64 } |
| NStructUint struct{ X uint } |
| NStructUintptr struct{ X uintptr } |
| NStructInt8 struct{ X int8 } |
| NStructInt16 struct{ X int16 } |
| NStructInt32 struct{ X int32 } |
| NStructInt64 struct{ X int64 } |
| NStructInt struct{ X int } |
| NStructFloat32 struct{ X float32 } |
| NStructFloat64 struct{ X float64 } |
| NStructComplex64 struct{ X complex64 } |
| NStructComplex128 struct{ X complex128 } |
| NStructString struct{ X string } |
| NStructOptionalStruct struct{ X *NStructInt } |
| NStructOptionalAny struct{ X interface{} } |
| // Slices |
| NSliceInterface []NInterface |
| NSliceTypeObject []*Type |
| NSliceBool []bool |
| NSliceByte []byte |
| NSliceUint16 []uint16 |
| NSliceUint32 []uint32 |
| NSliceUint64 []uint64 |
| NSliceUint []uint |
| NSliceUintptr []uintptr |
| NSliceInt8 []int8 |
| NSliceInt16 []int16 |
| NSliceInt32 []int32 |
| NSliceInt64 []int64 |
| NSliceInt []int |
| NSliceFloat32 []float32 |
| NSliceFloat64 []float64 |
| NSliceComplex64 []complex64 |
| NSliceComplex128 []complex128 |
| NSliceString []string |
| // Sets |
| NSetInterface map[NInterface]struct{} |
| NSetTypeObject map[*Type]struct{} |
| NSetBool map[bool]struct{} |
| NSetByte map[byte]struct{} |
| NSetUint16 map[uint16]struct{} |
| NSetUint32 map[uint32]struct{} |
| NSetUint64 map[uint64]struct{} |
| NSetUint map[uint]struct{} |
| NSetUintptr map[uintptr]struct{} |
| NSetInt8 map[int8]struct{} |
| NSetInt16 map[int16]struct{} |
| NSetInt32 map[int32]struct{} |
| NSetInt64 map[int64]struct{} |
| NSetInt map[int]struct{} |
| NSetFloat32 map[float32]struct{} |
| NSetFloat64 map[float64]struct{} |
| NSetComplex64 map[complex64]struct{} |
| NSetComplex128 map[complex128]struct{} |
| NSetString map[string]struct{} |
| // Maps |
| NMapInterface map[NInterface]NInterface |
| NMapTypeObject map[*Type]*Type |
| NMapBool map[bool]bool |
| NMapByte map[byte]byte |
| NMapUint16 map[uint16]uint16 |
| NMapUint32 map[uint32]uint32 |
| NMapUint64 map[uint64]uint64 |
| NMapUint map[uint]uint |
| NMapUintptr map[uintptr]uintptr |
| NMapInt8 map[int8]int8 |
| NMapInt16 map[int16]int16 |
| NMapInt32 map[int32]int32 |
| NMapInt64 map[int64]int64 |
| NMapInt map[int]int |
| NMapFloat32 map[float32]float32 |
| NMapFloat64 map[float64]float64 |
| NMapComplex64 map[complex64]complex64 |
| NMapComplex128 map[complex128]complex128 |
| NMapString map[string]string |
| // Recursive types |
| NRecurseSelf struct{ X []NRecurseSelf } |
| NRecurseA struct{ B []NRecurseB } |
| NRecurseB struct{ A []NRecurseA } |
| |
| // Composite types representing sets of numbers. |
| NMapByteEmpty map[NByte]struct{} |
| NMapUint64Empty map[NUint64]struct{} |
| NMapInt64Empty map[NUint64]struct{} |
| NMapFloat64Empty map[NUint64]struct{} |
| NMapComplex64Empty map[NUint64]struct{} |
| NMapByteBool map[NByte]NBool |
| NMapUint64Bool map[NUint64]NBool |
| NMapInt64Bool map[NInt64]NBool |
| NMapFloat64Bool map[NFloat64]NBool |
| NMapComplex64Bool map[NComplex64]NBool |
| // Composite types representing sets of strings. |
| NMapStringEmpty map[NString]struct{} |
| NMapStringBool map[NString]NBool |
| NStructXYZBool struct{ X, Y, Z NBool } |
| NStructXYZBoolUnexported struct{ a, X, b, Y, c, Z, d NBool } |
| NStructWXBool struct{ W, X NBool } |
| // Composite types representing maps of strings to numbers. |
| NMapStringByte map[NString]NByte |
| NMapStringUint64 map[NString]NUint64 |
| NMapStringInt64 map[NString]NInt64 |
| NMapStringFloat64 map[NString]NFloat64 |
| NMapStringComplex64 map[NString]NComplex64 |
| NStructVWXByte struct{ V, W, X NByte } |
| NStructVWXUint64 struct{ V, W, X NUint64 } |
| NStructVWXInt64 struct{ V, W, X NInt64 } |
| NStructVWXFloat64 struct{ V, W, X NFloat64 } |
| NStructVWXComplex64 struct{ V, W, X NComplex64 } |
| NStructVWXMixed struct { |
| // Interleave unexported fields, which are ignored. |
| a bool |
| V int64 |
| b string |
| W float64 |
| c []byte |
| X complex64 |
| d interface{} |
| } |
| NStructUVByte struct{ U, V NByte } |
| NStructUVUint64 struct{ U, V NUint64 } |
| NStructUVInt64 struct{ U, V NInt64 } |
| NStructUVFloat64 struct{ U, V NFloat64 } |
| NStructUVComplex64 struct{ U, V NComplex64 } |
| NStructUVMixed struct { |
| // Interleave unexported fields, which are ignored. |
| a bool |
| U int64 |
| b string |
| V float64 |
| c []byte |
| } |
| // Types that cannot be converted to sets. We represent sets as |
| // map[key]struct{} on the Go side, but don't allow map[key]NEmpty. |
| NEmpty struct{} |
| NMapStringNEmpty map[NString]NEmpty |
| NStructXYZEmpty struct{ X, Y, Z struct{} } |
| NStructXYZNEmpty struct{ X, Y, Z NEmpty } |
| ) |
| |
| func RecurseSelfType() *Type { |
| var builder TypeBuilder |
| n := builder.Named("v.io/v23/vdl.NRecurseSelf") |
| n.AssignBase(builder.Struct().AppendField("X", builder.List().AssignElem(n))) |
| builder.Build() |
| t, err := n.Built() |
| if err != nil { |
| panic(err) |
| } |
| return t |
| } |
| |
| func RecurseABTypes() [2]*Type { |
| var builder TypeBuilder |
| a := builder.Named("v.io/v23/vdl.NRecurseA") |
| b := builder.Named("v.io/v23/vdl.NRecurseB") |
| a.AssignBase(builder.Struct().AppendField("B", builder.List().AssignElem(b))) |
| b.AssignBase(builder.Struct().AppendField("A", builder.List().AssignElem(a))) |
| builder.Build() |
| aT, err := a.Built() |
| if err != nil { |
| panic(err) |
| } |
| bT, err := b.Built() |
| if err != nil { |
| panic(err) |
| } |
| return [2]*Type{aT, bT} |
| } |
| |
| func RecurseAType() *Type { return RecurseABTypes()[0] } |
| func RecurseBType() *Type { return RecurseABTypes()[1] } |
| |
| // Special case enum isn't regularly expressible in Go. |
| type NEnum int |
| |
| const ( |
| NEnumA NEnum = iota |
| NEnumB |
| NEnumC |
| NEnumABC |
| ) |
| |
| func (x *NEnum) Set(label string) error { |
| switch label { |
| case "A": |
| *x = NEnumA |
| return nil |
| case "B": |
| *x = NEnumB |
| return nil |
| case "C": |
| *x = NEnumC |
| return nil |
| case "ABC": |
| *x = NEnumABC |
| return nil |
| } |
| *x = -1 |
| return fmt.Errorf("unknown label %q in NEnum", label) |
| } |
| |
| func (x NEnum) String() string { |
| switch x { |
| case NEnumA: |
| return "A" |
| case NEnumB: |
| return "B" |
| case NEnumC: |
| return "C" |
| case NEnumABC: |
| return "ABC" |
| } |
| return "" |
| } |
| |
| func (NEnum) __VDLReflect(struct{ Enum struct{ A, B, C, ABC string } }) {} |
| |
| var EnumTypeN = NamedType("NEnum", EnumType("A", "B", "C", "ABC")) |
| |
| // union{A bool;B string;C NStructInt64} |
| type ( |
| NUnionABC interface { |
| Index() int |
| Name() string |
| __VDLReflect(__NUnionABCReflect) |
| } |
| NUnionABCA struct{ Value bool } |
| NUnionABCB struct{ Value string } |
| NUnionABCC struct{ Value NStructInt64 } |
| |
| __NUnionABCReflect struct { |
| Type NUnionABC |
| Union struct { |
| A NUnionABCA |
| B NUnionABCB |
| C NUnionABCC |
| } |
| } |
| ) |
| |
| func (NUnionABCA) Name() string { return "A" } |
| func (NUnionABCA) Index() int { return 0 } |
| func (NUnionABCA) __VDLReflect(__NUnionABCReflect) {} |
| func (NUnionABCB) Name() string { return "B" } |
| func (NUnionABCB) Index() int { return 1 } |
| func (NUnionABCB) __VDLReflect(__NUnionABCReflect) {} |
| func (NUnionABCC) Name() string { return "C" } |
| func (NUnionABCC) Index() int { return 2 } |
| func (NUnionABCC) __VDLReflect(__NUnionABCReflect) {} |
| |
| // union{B string;C NStructInt64;D int64} |
| type ( |
| NUnionBCD interface { |
| Index() int |
| Name() string |
| __VDLReflect(__NUnionBCDDesc) |
| } |
| NUnionBCDB struct{ Value string } |
| NUnionBCDC struct{ Value NStructInt64 } |
| NUnionBCDD struct{ Value int64 } |
| |
| __NUnionBCDDesc struct { |
| Type NUnionBCD |
| Union struct { |
| B NUnionBCDB |
| C NUnionBCDC |
| D NUnionBCDD |
| } |
| } |
| ) |
| |
| func (NUnionBCDB) Name() string { return "B" } |
| func (NUnionBCDB) Index() int { return 0 } |
| func (NUnionBCDB) __VDLReflect(__NUnionBCDDesc) {} |
| func (NUnionBCDC) Name() string { return "C" } |
| func (NUnionBCDC) Index() int { return 1 } |
| func (NUnionBCDC) __VDLReflect(__NUnionBCDDesc) {} |
| func (NUnionBCDD) Name() string { return "D" } |
| func (NUnionBCDD) Index() int { return 2 } |
| func (NUnionBCDD) __VDLReflect(__NUnionBCDDesc) {} |
| |
| // Special-case error types |
| type NonPtrError struct{} |
| type PtrError struct{} |
| |
| func (NonPtrError) Error() string { return "" } |
| func (*PtrError) Error() string { return "" } |
| |
| // NWire and NNative are used to test native type support. |
| type NWire struct{ Str string } |
| type NNative int64 |
| |
| func nWireToNative(x NWire, n *NNative) error { |
| *n = 0 |
| i, err := strconv.ParseInt(x.Str, 10, 64) |
| if err != nil { |
| return err |
| } |
| *n = NNative(i) |
| return nil |
| } |
| |
| func nWireFromNative(x *NWire, n NNative) error { |
| x.Str = strconv.FormatInt(int64(n), 10) |
| return nil |
| } |
| |
| func init() { |
| RegisterNative(nWireToNative, nWireFromNative) |
| Register(NWire{}) |
| } |
| |
| // NUnionWire and NUnionNative are used to test native type support for unions. |
| type ( |
| NUnionWire interface { |
| Index() int |
| Interface() interface{} |
| Name() string |
| __VDLReflect(__NUnionWireReflect) |
| } |
| NUnionWireA struct{ Value bool } |
| NUnionWireB struct{ Value int64 } |
| |
| __NUnionWireReflect struct { |
| Type NUnionWire |
| Union struct { |
| A NUnionWireA |
| B NUnionWireB |
| } |
| } |
| |
| NUnionNative string |
| ) |
| |
| func (x NUnionWireA) Name() string { return "A" } |
| func (x NUnionWireA) Interface() interface{} { return x.Value } |
| func (x NUnionWireA) Index() int { return 0 } |
| func (x NUnionWireA) __VDLReflect(__NUnionWireReflect) {} |
| func (x NUnionWireB) Name() string { return "B" } |
| func (x NUnionWireB) Interface() interface{} { return x.Value } |
| func (x NUnionWireB) Index() int { return 1 } |
| func (x NUnionWireB) __VDLReflect(__NUnionWireReflect) {} |
| |
| func nUnionWireToNative(w NUnionWire, n *NUnionNative) error { |
| *n = NUnionNative(fmt.Sprintf("%s=%v", w.Name(), w.Interface())) |
| return nil |
| } |
| |
| func nUnionWireFromNative(w *NUnionWire, n NUnionNative) error { |
| kv := strings.Split(string(n), "=") |
| if len(kv) != 2 { |
| return fmt.Errorf("invalid NUnionNative, no '=': %v", n) |
| } |
| switch kv[0] { |
| case "A": |
| var value bool |
| if _, err := fmt.Sscan(kv[1], &value); err != nil { |
| return err |
| } |
| *w = NUnionWireA{value} |
| return nil |
| case "B": |
| var value int64 |
| if _, err := fmt.Sscan(kv[1], &value); err != nil { |
| return err |
| } |
| *w = NUnionWireB{value} |
| return nil |
| } |
| return fmt.Errorf("invalid NUnionNative, unknown key: %v", n) |
| } |
| |
| func init() { |
| RegisterNative(nUnionWireToNative, nUnionWireFromNative) |
| Register((*NUnionWire)(nil)) |
| } |
| |
| var ( |
| StructInt64TypeN = NamedType("v.io/v23/vdl.NStructInt64", StructType(Field{"X", Int64Type})) |
| UnionABCTypeN = NamedType("v.io/v23/vdl.NUnionABC", UnionType([]Field{{"A", BoolType}, {"B", StringType}, {"C", StructInt64TypeN}}...)) |
| UnionBCDTypeN = NamedType("v.io/v23/vdl.NUnionBCD", UnionType([]Field{{"B", StringType}, {"C", StructInt64TypeN}, {"D", Int64Type}}...)) |
| UnionXYTypeN = NamedType("v.io/v23/vdl.NUnionXY", UnionType([]Field{{"X", StringType}, {"Y", StructInt64TypeN}}...)) |
| ) |
| |
| // Define a bunch of *Type types used in tests. |
| var ( |
| // Named scalar types |
| BoolTypeN = NamedType("NBool", BoolType) |
| ByteTypeN = NamedType("NByte", ByteType) |
| Uint16TypeN = NamedType("NUint16", Uint16Type) |
| Uint32TypeN = NamedType("NUint32", Uint32Type) |
| Uint64TypeN = NamedType("NUint64", Uint64Type) |
| Int8TypeN = NamedType("NInt8", Int8Type) |
| Int16TypeN = NamedType("NInt16", Int16Type) |
| Int32TypeN = NamedType("NInt32", Int32Type) |
| Int64TypeN = NamedType("NInt64", Int64Type) |
| Float32TypeN = NamedType("NFloat32", Float32Type) |
| Float64TypeN = NamedType("NFloat64", Float64Type) |
| Complex64TypeN = NamedType("NComplex64", Complex64Type) |
| Complex128TypeN = NamedType("NComplex128", Complex128Type) |
| StringTypeN = NamedType("NString", StringType) |
| |
| // Composite types representing sequences of numbers. |
| Array3ByteType = ArrayType(3, ByteType) |
| Array3ByteTypeN = NamedType("NArray3Byte", ArrayType(3, ByteTypeN)) |
| Array3Uint64Type = ArrayType(3, Uint64Type) |
| Array3Uint64TypeN = NamedType("NArray3Uint64", ArrayType(3, Uint64TypeN)) |
| Array3Int64Type = ArrayType(3, Int64Type) |
| Array3Int64TypeN = NamedType("NArray3Int64", ArrayType(3, Int64TypeN)) |
| Array3Float64Type = ArrayType(3, Float64Type) |
| Array3Float64TypeN = NamedType("NArray3Float64", ArrayType(3, Float64TypeN)) |
| Array3Complex64Type = ArrayType(3, Complex64Type) |
| Array3Complex64TypeN = NamedType("NArray3Complex64", ArrayType(3, Complex64TypeN)) |
| ListByteType = ListType(ByteType) |
| ListByteTypeN = NamedType("NListByte", ListType(ByteTypeN)) |
| ListUint64Type = ListType(Uint64Type) |
| ListUint64TypeN = NamedType("NListUint64", ListType(Uint64TypeN)) |
| ListInt64Type = ListType(Int64Type) |
| ListInt64TypeN = NamedType("NListInt64", ListType(Int64TypeN)) |
| ListFloat64Type = ListType(Float64Type) |
| ListFloat64TypeN = NamedType("NListFloat64", ListType(Float64TypeN)) |
| ListComplex64Type = ListType(Complex64Type) |
| ListComplex64TypeN = NamedType("NListComplex64", ListType(Complex64TypeN)) |
| // Composite types representing sets of numbers. |
| SetByteType = SetType(ByteType) |
| SetByteTypeN = NamedType("NSetByte", SetType(ByteTypeN)) |
| SetUint64Type = SetType(Uint64Type) |
| SetUint64TypeN = NamedType("NSetUint64", SetType(Uint64TypeN)) |
| SetInt64Type = SetType(Int64Type) |
| SetInt64TypeN = NamedType("NSetInt64", SetType(Int64TypeN)) |
| SetFloat64Type = SetType(Float64Type) |
| SetFloat64TypeN = NamedType("NSetFloat64", SetType(Float64TypeN)) |
| SetComplex64Type = SetType(Complex64Type) |
| SetComplex64TypeN = NamedType("NSetComplex64", SetType(Complex64TypeN)) |
| MapByteBoolType = MapType(ByteType, BoolType) |
| MapByteBoolTypeN = NamedType("NMapByteBool", MapType(ByteTypeN, BoolTypeN)) |
| MapUint64BoolType = MapType(Uint64Type, BoolType) |
| MapUint64BoolTypeN = NamedType("NMapUint64Bool", MapType(Uint64TypeN, BoolTypeN)) |
| MapInt64BoolType = MapType(Int64Type, BoolType) |
| MapInt64BoolTypeN = NamedType("NMapInt64Bool", MapType(Int64TypeN, BoolTypeN)) |
| MapFloat64BoolType = MapType(Float64Type, BoolType) |
| MapFloat64BoolTypeN = NamedType("NMapFloat64Bool", MapType(Float64TypeN, BoolTypeN)) |
| MapComplex64BoolType = MapType(Complex64Type, BoolType) |
| MapComplex64BoolTypeN = NamedType("NMapComplex64Bool", MapType(Complex64TypeN, BoolTypeN)) |
| // Composite types representing sets of strings. |
| SetStringType = SetType(StringType) |
| SetStringTypeN = NamedType("NSetString", SetType(StringTypeN)) |
| MapStringBoolType = MapType(StringType, BoolType) |
| MapStringBoolTypeN = NamedType("NMapStringBool", MapType(StringTypeN, BoolTypeN)) |
| StructXYZBoolType = StructType(Field{"X", BoolType}, Field{"Y", BoolType}, Field{"Z", BoolType}) |
| StructXYZBoolTypeN = NamedType("NStructXYZBool", StructType(Field{"X", BoolTypeN}, Field{"Y", BoolTypeN}, Field{"Z", BoolTypeN})) |
| StructWXBoolType = StructType(Field{"W", BoolType}, Field{"X", BoolType}) |
| StructWXBoolTypeN = NamedType("NStructWXBool", StructType(Field{"W", BoolTypeN}, Field{"X", BoolTypeN})) |
| // Composite types representing maps of strings to numbers. |
| MapStringByteType = MapType(StringType, ByteType) |
| MapStringByteTypeN = NamedType("NMapStringByte", MapType(StringTypeN, ByteTypeN)) |
| MapStringUint64Type = MapType(StringType, Uint64Type) |
| MapStringUint64TypeN = NamedType("NMapStringUint64", MapType(StringTypeN, Uint64TypeN)) |
| MapStringInt64Type = MapType(StringType, Int64Type) |
| MapStringInt64TypeN = NamedType("NMapStringInt64", MapType(StringTypeN, Int64TypeN)) |
| MapStringFloat64Type = MapType(StringType, Float64Type) |
| MapStringFloat64TypeN = NamedType("NMapStringFloat64", MapType(StringTypeN, Float64TypeN)) |
| MapStringComplex64Type = MapType(StringType, Complex64Type) |
| MapStringComplex64TypeN = NamedType("NMapStringComplex64", MapType(StringTypeN, Complex64TypeN)) |
| StructVWXByteType = StructType(Field{"V", ByteType}, Field{"W", ByteType}, Field{"X", ByteType}) |
| StructVWXByteTypeN = NamedType("NStructVWXByte", StructType(Field{"V", ByteTypeN}, Field{"W", ByteTypeN}, Field{"X", ByteTypeN})) |
| StructVWXUint64Type = StructType(Field{"V", Uint64Type}, Field{"W", Uint64Type}, Field{"X", Uint64Type}) |
| StructVWXUint64TypeN = NamedType("NStructVWXUint64", StructType(Field{"V", Uint64TypeN}, Field{"W", Uint64TypeN}, Field{"X", Uint64TypeN})) |
| StructVWXInt64Type = StructType(Field{"V", Int64Type}, Field{"W", Int64Type}, Field{"X", Int64Type}) |
| StructVWXInt64TypeN = NamedType("NStructVWXInt64", StructType(Field{"V", Int64TypeN}, Field{"W", Int64TypeN}, Field{"X", Int64TypeN})) |
| StructVWXFloat64Type = StructType(Field{"V", Float64Type}, Field{"W", Float64Type}, Field{"X", Float64Type}) |
| StructVWXFloat64TypeN = NamedType("NStructVWXFloat64", StructType(Field{"V", Float64TypeN}, Field{"W", Float64TypeN}, Field{"X", Float64TypeN})) |
| StructVWXComplex64Type = StructType(Field{"V", Complex64Type}, Field{"W", Complex64Type}, Field{"X", Complex64Type}) |
| StructVWXComplex64TypeN = NamedType("NStructVWXComplex64", StructType(Field{"V", Complex64TypeN}, Field{"W", Complex64TypeN}, Field{"X", Complex64TypeN})) |
| StructUVByteType = StructType(Field{"U", ByteType}, Field{"V", ByteType}) |
| StructUVByteTypeN = NamedType("NStructUVByte", StructType(Field{"U", ByteTypeN}, Field{"V", ByteTypeN})) |
| StructUVUint64Type = StructType(Field{"U", Uint64Type}, Field{"V", Uint64Type}) |
| StructUVUint64TypeN = NamedType("NStructUVUint64", StructType(Field{"U", Uint64TypeN}, Field{"V", Uint64TypeN})) |
| StructUVInt64Type = StructType(Field{"U", Int64Type}, Field{"V", Int64Type}) |
| StructUVInt64TypeN = NamedType("NStructUVInt64", StructType(Field{"U", Int64TypeN}, Field{"V", Int64TypeN})) |
| StructUVFloat64Type = StructType(Field{"U", Float64Type}, Field{"V", Float64Type}) |
| StructUVFloat64TypeN = NamedType("NStructUVFloat64", StructType(Field{"U", Float64TypeN}, Field{"V", Float64TypeN})) |
| StructUVComplex64Type = StructType(Field{"U", Complex64Type}, Field{"V", Complex64Type}) |
| StructUVComplex64TypeN = NamedType("NStructUVComplex64", StructType(Field{"U", Complex64TypeN}, Field{"V", Complex64TypeN})) |
| |
| StructAIntType = StructType(Field{"A", Int64Type}) |
| StructAIntTypeN = NamedType("NStructA", StructAIntType) |
| |
| UnionTypeN = NameN("Union", UnionType([]Field{{"A", BoolType}, {"B", StringType}, {"C", Int32Type}}...)) |
| WireTypeN = NameN("Wire", StructType(Field{"Str", StringType})) |
| |
| // Types that cannot be converted to sets. Although we represent sets as |
| // map[key]struct{} on the Go side, we don't allow these as general |
| // conversions for val.Value. |
| EmptyType = StructType() |
| EmptyTypeN = NamedType("NEmpty", StructType()) |
| MapStringEmptyType = MapType(StringType, EmptyType) |
| MapStringEmptyTypeN = NamedType("NMapStringEmpty", MapType(StringTypeN, EmptyTypeN)) |
| StructXYZEmptyType = StructType(Field{"X", EmptyType}, Field{"Y", EmptyType}, Field{"Z", EmptyType}) |
| StructXYZEmptyTypeN = NamedType("NStructXYZEmpty", StructType(Field{"X", EmptyTypeN}, Field{"Y", EmptyTypeN}, Field{"Z", EmptyTypeN})) |
| ) |
| |
| func NameN(suffix string, base *Type) *Type { |
| return NamedType("v.io/v23/vdl.N"+suffix, base) |
| } |
| |
| func NameNArray(suffix string, base *Type) *Type { |
| return NamedType("v.io/v23/vdl.NArray3"+suffix, ArrayType(3, base)) |
| } |
| |
| func NameNStruct(suffix string, base *Type) *Type { |
| return NamedType("v.io/v23/vdl.NStruct"+suffix, StructType(Field{"X", base})) |
| } |
| |
| func NameNSlice(suffix string, base *Type) *Type { |
| return NamedType("v.io/v23/vdl.NSlice"+suffix, ListType(base)) |
| } |
| |
| func rtSet(base *Type) *Type { |
| return SetType(base) |
| } |
| |
| func NameNSet(suffix string, base *Type) *Type { |
| return NamedType("v.io/v23/vdl.NSet"+suffix, rtSet(base)) |
| } |
| |
| func rtMap(base *Type) *Type { |
| return MapType(base, base) |
| } |
| |
| func NameNMap(suffix string, base *Type) *Type { |
| return NamedType("v.io/v23/vdl.NMap"+suffix, rtMap(base)) |
| } |
| |
| func SetStringValue(t *Type, x ...string) *Value { |
| res := ZeroValue(t) |
| for _, vx := range x { |
| key := ZeroValue(t.Key()).AssignString(vx) |
| res.AssignSetKey(key) |
| } |
| return res |
| } |
| |
| type SB struct { |
| S string |
| B bool |
| } |
| |
| func MapStringBoolValue(t *Type, x ...SB) *Value { |
| res := ZeroValue(t) |
| for _, sb := range x { |
| key := ZeroValue(t.Key()).AssignString(sb.S) |
| val := ZeroValue(t.Elem()).AssignBool(sb.B) |
| res.AssignMapIndex(key, val) |
| } |
| return res |
| } |
| |
| func MapStringEmptyValue(t *Type, x ...string) *Value { |
| res := ZeroValue(t) |
| for _, vx := range x { |
| key := ZeroValue(t.Key()).AssignString(vx) |
| val := ZeroValue(t.Elem()) |
| res.AssignMapIndex(key, val) |
| } |
| return res |
| } |
| |
| func StructBoolValue(t *Type, x ...SB) *Value { |
| res := ZeroValue(t) |
| for _, sb := range x { |
| _, index := t.FieldByName(sb.S) |
| res.StructField(index).AssignBool(sb.B) |
| } |
| return res |
| } |
| |
| func AssignNum(v *Value, num float64) *Value { |
| switch v.Kind() { |
| case Byte, Uint16, Uint32, Uint64: |
| v.AssignUint(uint64(num)) |
| case Int8, Int16, Int32, Int64: |
| v.AssignInt(int64(num)) |
| case Float32, Float64: |
| v.AssignFloat(num) |
| case Complex64, Complex128: |
| v.AssignComplex(complex(num, 0)) |
| default: |
| panic(fmt.Errorf("vdl: AssignNum unhandled %v", v.Type())) |
| } |
| return v |
| } |
| |
| func SeqNumValue(t *Type, x ...float64) *Value { |
| res := ZeroValue(t) |
| if t.Kind() == List { |
| res.AssignLen(len(x)) |
| } |
| for index, n := range x { |
| AssignNum(res.Index(index), n) |
| } |
| return res |
| } |
| |
| func SetNumValue(t *Type, x ...float64) *Value { |
| res := ZeroValue(t) |
| for _, n := range x { |
| res.AssignSetKey(AssignNum(ZeroValue(t.Key()), n)) |
| } |
| return res |
| } |
| |
| type NB struct { |
| N float64 |
| B bool |
| } |
| |
| func MapNumBoolValue(t *Type, x ...NB) *Value { |
| res := ZeroValue(t) |
| for _, nb := range x { |
| key := AssignNum(ZeroValue(t.Key()), nb.N) |
| val := ZeroValue(t.Elem()).AssignBool(nb.B) |
| res.AssignMapIndex(key, val) |
| } |
| return res |
| } |
| |
| type SN struct { |
| S string |
| N float64 |
| } |
| |
| func MapStringNumValue(t *Type, x ...SN) *Value { |
| res := ZeroValue(t) |
| for _, sn := range x { |
| key := ZeroValue(t.Key()).AssignString(sn.S) |
| val := AssignNum(ZeroValue(t.Elem()), sn.N) |
| res.AssignMapIndex(key, val) |
| } |
| return res |
| } |
| |
| func StructNumValue(t *Type, x ...SN) *Value { |
| res := ZeroValue(t) |
| for _, sn := range x { |
| _, index := t.FieldByName(sn.S) |
| AssignNum(res.StructField(index), sn.N) |
| } |
| return res |
| } |
