5405 lines
221 KiB
Go
5405 lines
221 KiB
Go
|
// Copyright (c) Faye Amacker. All rights reserved.
|
||
|
|
// Licensed under the MIT License. See LICENSE in the project root for license information.
|
||
|
|
|
||
|
|
package cbor
|
||
|
|
|
||
|
|
import (
|
||
|
|
"bytes"
|
||
|
|
"encoding/binary"
|
||
|
|
"encoding/hex"
|
||
|
|
"errors"
|
||
|
|
"fmt"
|
||
|
|
"io"
|
||
|
|
"math"
|
||
|
|
"math/big"
|
||
|
|
"reflect"
|
||
|
|
"strings"
|
||
|
|
"testing"
|
||
|
|
"time"
|
||
|
|
)
|
||
|
|
|
||
|
|
var (
|
||
|
|
typeBool = reflect.TypeOf(true)
|
||
|
|
typeUint8 = reflect.TypeOf(uint8(0))
|
||
|
|
typeUint16 = reflect.TypeOf(uint16(0))
|
||
|
|
typeUint32 = reflect.TypeOf(uint32(0))
|
||
|
|
typeUint64 = reflect.TypeOf(uint64(0))
|
||
|
|
typeInt8 = reflect.TypeOf(int8(0))
|
||
|
|
typeInt16 = reflect.TypeOf(int16(0))
|
||
|
|
typeInt32 = reflect.TypeOf(int32(0))
|
||
|
|
typeInt64 = reflect.TypeOf(int64(0))
|
||
|
|
typeFloat32 = reflect.TypeOf(float32(0))
|
||
|
|
typeFloat64 = reflect.TypeOf(float64(0))
|
||
|
|
typeString = reflect.TypeOf("")
|
||
|
|
typeByteSlice = reflect.TypeOf([]byte(nil))
|
||
|
|
typeByteArray = reflect.TypeOf([5]byte{})
|
||
|
|
typeIntSlice = reflect.TypeOf([]int{})
|
||
|
|
typeStringSlice = reflect.TypeOf([]string{})
|
||
|
|
typeMapStringInt = reflect.TypeOf(map[string]int{})
|
||
|
|
typeMapStringString = reflect.TypeOf(map[string]string{})
|
||
|
|
typeMapStringIntf = reflect.TypeOf(map[string]interface{}{})
|
||
|
|
)
|
||
|
|
|
||
|
|
type unmarshalTest struct {
|
||
|
|
cborData []byte
|
||
|
|
emptyInterfaceValue interface{}
|
||
|
|
values []interface{}
|
||
|
|
wrongTypes []reflect.Type
|
||
|
|
}
|
||
|
|
|
||
|
|
var unmarshalTests = []unmarshalTest{
|
||
|
|
// CBOR test data are from https://tools.ietf.org/html/rfc7049#appendix-A.
|
||
|
|
// positive integer
|
||
|
|
{
|
||
|
|
hexDecode("00"),
|
||
|
|
uint64(0),
|
||
|
|
[]interface{}{uint8(0), uint16(0), uint32(0), uint64(0), uint(0), int8(0), int16(0), int32(0), int64(0), int(0), float32(0), float64(0), bigIntOrPanic("0")},
|
||
|
|
[]reflect.Type{typeString, typeBool, typeByteArray, typeIntSlice, typeMapStringInt, typeTag, typeRawTag},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("01"),
|
||
|
|
uint64(1),
|
||
|
|
[]interface{}{uint8(1), uint16(1), uint32(1), uint64(1), uint(1), int8(1), int16(1), int32(1), int64(1), int(1), float32(1), float64(1), bigIntOrPanic("1")},
|
||
|
|
[]reflect.Type{typeString, typeBool, typeByteArray, typeIntSlice, typeMapStringInt, typeTag, typeRawTag},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("0a"),
|
||
|
|
uint64(10),
|
||
|
|
[]interface{}{uint8(10), uint16(10), uint32(10), uint64(10), uint(10), int8(10), int16(10), int32(10), int64(10), int(10), float32(10), float64(10), bigIntOrPanic("10")},
|
||
|
|
[]reflect.Type{typeString, typeBool, typeByteArray, typeIntSlice, typeMapStringInt, typeTag, typeRawTag},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("17"),
|
||
|
|
uint64(23),
|
||
|
|
[]interface{}{uint8(23), uint16(23), uint32(23), uint64(23), uint(23), int8(23), int16(23), int32(23), int64(23), int(23), float32(23), float64(23), bigIntOrPanic("23")},
|
||
|
|
[]reflect.Type{typeString, typeBool, typeByteArray, typeIntSlice, typeMapStringInt, typeTag, typeRawTag},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("1818"),
|
||
|
|
uint64(24),
|
||
|
|
[]interface{}{uint8(24), uint16(24), uint32(24), uint64(24), uint(24), int8(24), int16(24), int32(24), int64(24), int(24), float32(24), float64(24), bigIntOrPanic("24")},
|
||
|
|
[]reflect.Type{typeString, typeBool, typeByteArray, typeIntSlice, typeMapStringInt, typeTag, typeRawTag},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("1819"),
|
||
|
|
uint64(25),
|
||
|
|
[]interface{}{uint8(25), uint16(25), uint32(25), uint64(25), uint(25), int8(25), int16(25), int32(25), int64(25), int(25), float32(25), float64(25), bigIntOrPanic("25")},
|
||
|
|
[]reflect.Type{typeString, typeBool, typeByteArray, typeIntSlice, typeMapStringInt, typeTag, typeRawTag},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("1864"),
|
||
|
|
uint64(100),
|
||
|
|
[]interface{}{uint8(100), uint16(100), uint32(100), uint64(100), uint(100), int8(100), int16(100), int32(100), int64(100), int(100), float32(100), float64(100), bigIntOrPanic("100")},
|
||
|
|
[]reflect.Type{typeString, typeBool, typeByteArray, typeIntSlice, typeMapStringInt, typeTag, typeRawTag},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("1903e8"),
|
||
|
|
uint64(1000),
|
||
|
|
[]interface{}{uint16(1000), uint32(1000), uint64(1000), uint(1000), int16(1000), int32(1000), int64(1000), int(1000), float32(1000), float64(1000), bigIntOrPanic("1000")},
|
||
|
|
[]reflect.Type{typeUint8, typeInt8, typeString, typeBool, typeByteArray, typeIntSlice, typeMapStringInt, typeTag, typeRawTag},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("1a000f4240"),
|
||
|
|
uint64(1000000),
|
||
|
|
[]interface{}{uint32(1000000), uint64(1000000), uint(1000000), int32(1000000), int64(1000000), int(1000000), float32(1000000), float64(1000000), bigIntOrPanic("1000000")},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeInt8, typeInt16, typeString, typeBool, typeByteArray, typeIntSlice, typeMapStringInt, typeTag, typeRawTag},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("1b000000e8d4a51000"),
|
||
|
|
uint64(1000000000000),
|
||
|
|
[]interface{}{uint64(1000000000000), uint(1000000000000), int64(1000000000000), int(1000000000000), float32(1000000000000), float64(1000000000000), bigIntOrPanic("1000000000000")},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeInt8, typeInt16, typeInt32, typeString, typeBool, typeByteArray, typeIntSlice, typeMapStringInt, typeTag, typeRawTag},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("1bffffffffffffffff"),
|
||
|
|
uint64(18446744073709551615),
|
||
|
|
[]interface{}{uint64(18446744073709551615), uint(18446744073709551615), float32(18446744073709551615), float64(18446744073709551615), bigIntOrPanic("18446744073709551615")},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeInt8, typeInt16, typeInt32, typeString, typeBool, typeByteArray, typeIntSlice, typeMapStringInt, typeTag, typeRawTag},
|
||
|
|
},
|
||
|
|
// negative integer
|
||
|
|
{
|
||
|
|
hexDecode("20"),
|
||
|
|
int64(-1),
|
||
|
|
[]interface{}{int8(-1), int16(-1), int32(-1), int64(-1), int(-1), float32(-1), float64(-1), bigIntOrPanic("-1")},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeString, typeBool, typeByteArray, typeIntSlice, typeMapStringInt, typeTag, typeRawTag},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("29"),
|
||
|
|
int64(-10),
|
||
|
|
[]interface{}{int8(-10), int16(-10), int32(-10), int64(-10), int(-10), float32(-10), float64(-10), bigIntOrPanic("-10")},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeString, typeBool, typeByteArray, typeIntSlice, typeMapStringInt, typeTag, typeRawTag},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("3863"),
|
||
|
|
int64(-100),
|
||
|
|
[]interface{}{int8(-100), int16(-100), int32(-100), int64(-100), int(-100), float32(-100), float64(-100), bigIntOrPanic("-100")},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeString, typeBool, typeByteArray, typeIntSlice, typeMapStringInt, typeTag, typeRawTag},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("3903e7"),
|
||
|
|
int64(-1000),
|
||
|
|
[]interface{}{int16(-1000), int32(-1000), int64(-1000), int(-1000), float32(-1000), float64(-1000), bigIntOrPanic("-1000")},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeString, typeBool, typeByteArray, typeIntSlice, typeMapStringInt, typeTag, typeRawTag},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("3bffffffffffffffff"),
|
||
|
|
bigIntOrPanic("-18446744073709551616"),
|
||
|
|
[]interface{}{bigIntOrPanic("-18446744073709551616")},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeString, typeBool, typeByteArray, typeIntSlice, typeMapStringInt, typeTag, typeRawTag},
|
||
|
|
}, // CBOR value -18446744073709551616 overflows Go's int64, see TestNegIntOverflow
|
||
|
|
// byte string
|
||
|
|
{
|
||
|
|
hexDecode("40"),
|
||
|
|
[]byte{},
|
||
|
|
[]interface{}{[]byte{}, [0]byte{}, [1]byte{0}, [5]byte{0, 0, 0, 0, 0}},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("4401020304"),
|
||
|
|
[]byte{1, 2, 3, 4},
|
||
|
|
[]interface{}{[]byte{1, 2, 3, 4}, [0]byte{}, [1]byte{1}, [5]byte{1, 2, 3, 4, 0}},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("5f42010243030405ff"),
|
||
|
|
[]byte{1, 2, 3, 4, 5},
|
||
|
|
[]interface{}{[]byte{1, 2, 3, 4, 5}, [0]byte{}, [1]byte{1}, [5]byte{1, 2, 3, 4, 5}, [6]byte{1, 2, 3, 4, 5, 0}},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
},
|
||
|
|
// text string
|
||
|
|
{
|
||
|
|
hexDecode("60"),
|
||
|
|
"",
|
||
|
|
[]interface{}{""},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeBool, typeByteArray, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("6161"),
|
||
|
|
"a",
|
||
|
|
[]interface{}{"a"},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeBool, typeByteArray, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("6449455446"),
|
||
|
|
"IETF",
|
||
|
|
[]interface{}{"IETF"},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeBool, typeByteArray, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("62225c"),
|
||
|
|
"\"\\",
|
||
|
|
[]interface{}{"\"\\"},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeBool, typeByteArray, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("62c3bc"),
|
||
|
|
"ü",
|
||
|
|
[]interface{}{"ü"},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeBool, typeByteArray, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("63e6b0b4"),
|
||
|
|
"水",
|
||
|
|
[]interface{}{"水"},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeBool, typeByteArray, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("64f0908591"),
|
||
|
|
"𐅑",
|
||
|
|
[]interface{}{"𐅑"},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeBool, typeByteArray, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("7f657374726561646d696e67ff"),
|
||
|
|
"streaming",
|
||
|
|
[]interface{}{"streaming"},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeBool, typeByteArray, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
},
|
||
|
|
// array
|
||
|
|
{
|
||
|
|
hexDecode("80"),
|
||
|
|
[]interface{}{},
|
||
|
|
[]interface{}{[]interface{}{}, []byte{}, []string{}, []int{}, [0]int{}, [1]int{0}, [5]int{0}, []float32{}, []float64{}},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeString, typeBool, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("83010203"),
|
||
|
|
[]interface{}{uint64(1), uint64(2), uint64(3)},
|
||
|
|
[]interface{}{[]interface{}{uint64(1), uint64(2), uint64(3)}, []byte{1, 2, 3}, []int{1, 2, 3}, []uint{1, 2, 3}, [0]int{}, [1]int{1}, [3]int{1, 2, 3}, [5]int{1, 2, 3, 0, 0}, []float32{1, 2, 3}, []float64{1, 2, 3}},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeString, typeBool, typeStringSlice, typeMapStringInt, reflect.TypeOf([3]string{}), typeTag, typeRawTag, typeBigInt},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("8301820203820405"),
|
||
|
|
[]interface{}{uint64(1), []interface{}{uint64(2), uint64(3)}, []interface{}{uint64(4), uint64(5)}},
|
||
|
|
[]interface{}{[]interface{}{uint64(1), []interface{}{uint64(2), uint64(3)}, []interface{}{uint64(4), uint64(5)}}, [...]interface{}{uint64(1), []interface{}{uint64(2), uint64(3)}, []interface{}{uint64(4), uint64(5)}}},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeString, typeBool, typeStringSlice, typeMapStringInt, reflect.TypeOf([3]string{}), typeTag, typeRawTag, typeBigInt},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("83018202039f0405ff"),
|
||
|
|
[]interface{}{uint64(1), []interface{}{uint64(2), uint64(3)}, []interface{}{uint64(4), uint64(5)}},
|
||
|
|
[]interface{}{[]interface{}{uint64(1), []interface{}{uint64(2), uint64(3)}, []interface{}{uint64(4), uint64(5)}}, [...]interface{}{uint64(1), []interface{}{uint64(2), uint64(3)}, []interface{}{uint64(4), uint64(5)}}},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeString, typeBool, typeStringSlice, typeMapStringInt, reflect.TypeOf([3]string{}), typeTag, typeRawTag, typeBigInt},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("83019f0203ff820405"),
|
||
|
|
[]interface{}{uint64(1), []interface{}{uint64(2), uint64(3)}, []interface{}{uint64(4), uint64(5)}},
|
||
|
|
[]interface{}{[]interface{}{uint64(1), []interface{}{uint64(2), uint64(3)}, []interface{}{uint64(4), uint64(5)}}, [...]interface{}{uint64(1), []interface{}{uint64(2), uint64(3)}, []interface{}{uint64(4), uint64(5)}}},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeString, typeBool, typeStringSlice, typeMapStringInt, reflect.TypeOf([3]string{}), typeTag, typeRawTag, typeBigInt},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("98190102030405060708090a0b0c0d0e0f101112131415161718181819"),
|
||
|
|
[]interface{}{uint64(1), uint64(2), uint64(3), uint64(4), uint64(5), uint64(6), uint64(7), uint64(8), uint64(9), uint64(10), uint64(11), uint64(12), uint64(13), uint64(14), uint64(15), uint64(16), uint64(17), uint64(18), uint64(19), uint64(20), uint64(21), uint64(22), uint64(23), uint64(24), uint64(25)},
|
||
|
|
[]interface{}{
|
||
|
|
[]interface{}{uint64(1), uint64(2), uint64(3), uint64(4), uint64(5), uint64(6), uint64(7), uint64(8), uint64(9), uint64(10), uint64(11), uint64(12), uint64(13), uint64(14), uint64(15), uint64(16), uint64(17), uint64(18), uint64(19), uint64(20), uint64(21), uint64(22), uint64(23), uint64(24), uint64(25)},
|
||
|
|
[]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25},
|
||
|
|
[]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25},
|
||
|
|
[]uint{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25},
|
||
|
|
[0]int{},
|
||
|
|
[1]int{1},
|
||
|
|
[...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25},
|
||
|
|
[30]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, 0, 0, 0},
|
||
|
|
[]float32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25},
|
||
|
|
[]float64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25}},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeString, typeBool, typeStringSlice, typeMapStringInt, reflect.TypeOf([3]string{}), typeTag, typeRawTag, typeBigInt},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("9fff"),
|
||
|
|
[]interface{}{},
|
||
|
|
[]interface{}{[]interface{}{}, []byte{}, []string{}, []int{}, [0]int{}, [1]int{0}, [5]int{0, 0, 0, 0, 0}, []float32{}, []float64{}},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeString, typeBool, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("9f018202039f0405ffff"),
|
||
|
|
[]interface{}{uint64(1), []interface{}{uint64(2), uint64(3)}, []interface{}{uint64(4), uint64(5)}},
|
||
|
|
[]interface{}{[]interface{}{uint64(1), []interface{}{uint64(2), uint64(3)}, []interface{}{uint64(4), uint64(5)}}, [...]interface{}{uint64(1), []interface{}{uint64(2), uint64(3)}, []interface{}{uint64(4), uint64(5)}}},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeString, typeBool, typeStringSlice, typeMapStringInt, reflect.TypeOf([3]string{}), typeTag, typeRawTag, typeBigInt},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("9f01820203820405ff"),
|
||
|
|
[]interface{}{uint64(1), []interface{}{uint64(2), uint64(3)}, []interface{}{uint64(4), uint64(5)}},
|
||
|
|
[]interface{}{[]interface{}{uint64(1), []interface{}{uint64(2), uint64(3)}, []interface{}{uint64(4), uint64(5)}}, [...]interface{}{uint64(1), []interface{}{uint64(2), uint64(3)}, []interface{}{uint64(4), uint64(5)}}},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeString, typeBool, typeStringSlice, typeMapStringInt, reflect.TypeOf([3]string{}), typeTag, typeRawTag, typeBigInt},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("9f0102030405060708090a0b0c0d0e0f101112131415161718181819ff"),
|
||
|
|
[]interface{}{uint64(1), uint64(2), uint64(3), uint64(4), uint64(5), uint64(6), uint64(7), uint64(8), uint64(9), uint64(10), uint64(11), uint64(12), uint64(13), uint64(14), uint64(15), uint64(16), uint64(17), uint64(18), uint64(19), uint64(20), uint64(21), uint64(22), uint64(23), uint64(24), uint64(25)},
|
||
|
|
[]interface{}{
|
||
|
|
[]interface{}{uint64(1), uint64(2), uint64(3), uint64(4), uint64(5), uint64(6), uint64(7), uint64(8), uint64(9), uint64(10), uint64(11), uint64(12), uint64(13), uint64(14), uint64(15), uint64(16), uint64(17), uint64(18), uint64(19), uint64(20), uint64(21), uint64(22), uint64(23), uint64(24), uint64(25)},
|
||
|
|
[]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25},
|
||
|
|
[]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25},
|
||
|
|
[]uint{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25},
|
||
|
|
[0]int{},
|
||
|
|
[1]int{1},
|
||
|
|
[...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25},
|
||
|
|
[30]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, 0, 0, 0},
|
||
|
|
[]float32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25},
|
||
|
|
[]float64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25}},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeString, typeBool, typeStringSlice, typeMapStringInt, reflect.TypeOf([3]string{}), typeTag, typeRawTag, typeBigInt},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("826161a161626163"),
|
||
|
|
[]interface{}{"a", map[interface{}]interface{}{"b": "c"}},
|
||
|
|
[]interface{}{[]interface{}{"a", map[interface{}]interface{}{"b": "c"}}, [...]interface{}{"a", map[interface{}]interface{}{"b": "c"}}},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeString, typeBool, typeByteArray, typeStringSlice, typeMapStringInt, reflect.TypeOf([3]string{}), typeTag, typeRawTag, typeBigInt},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("826161bf61626163ff"),
|
||
|
|
[]interface{}{"a", map[interface{}]interface{}{"b": "c"}},
|
||
|
|
[]interface{}{[]interface{}{"a", map[interface{}]interface{}{"b": "c"}}, [...]interface{}{"a", map[interface{}]interface{}{"b": "c"}}},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeString, typeBool, typeByteArray, typeStringSlice, typeMapStringInt, reflect.TypeOf([3]string{}), typeTag, typeRawTag, typeBigInt},
|
||
|
|
},
|
||
|
|
// map
|
||
|
|
{
|
||
|
|
hexDecode("a0"),
|
||
|
|
map[interface{}]interface{}{},
|
||
|
|
[]interface{}{map[interface{}]interface{}{}, map[string]bool{}, map[string]int{}, map[int]string{}, map[int]bool{}},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeByteSlice, typeByteArray, typeString, typeBool, typeIntSlice, typeTag, typeRawTag},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("a201020304"),
|
||
|
|
map[interface{}]interface{}{uint64(1): uint64(2), uint64(3): uint64(4)},
|
||
|
|
[]interface{}{map[interface{}]interface{}{uint64(1): uint64(2), uint64(3): uint64(4)}, map[uint]int{1: 2, 3: 4}, map[int]uint{1: 2, 3: 4}},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeByteSlice, typeByteArray, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("a26161016162820203"),
|
||
|
|
map[interface{}]interface{}{"a": uint64(1), "b": []interface{}{uint64(2), uint64(3)}},
|
||
|
|
[]interface{}{map[interface{}]interface{}{"a": uint64(1), "b": []interface{}{uint64(2), uint64(3)}},
|
||
|
|
map[string]interface{}{"a": uint64(1), "b": []interface{}{uint64(2), uint64(3)}}},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeByteSlice, typeByteArray, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("a56161614161626142616361436164614461656145"),
|
||
|
|
map[interface{}]interface{}{"a": "A", "b": "B", "c": "C", "d": "D", "e": "E"},
|
||
|
|
[]interface{}{map[interface{}]interface{}{"a": "A", "b": "B", "c": "C", "d": "D", "e": "E"},
|
||
|
|
map[string]interface{}{"a": "A", "b": "B", "c": "C", "d": "D", "e": "E"},
|
||
|
|
map[string]string{"a": "A", "b": "B", "c": "C", "d": "D", "e": "E"}},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeByteSlice, typeByteArray, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("bf61610161629f0203ffff"),
|
||
|
|
map[interface{}]interface{}{"a": uint64(1), "b": []interface{}{uint64(2), uint64(3)}},
|
||
|
|
[]interface{}{map[interface{}]interface{}{"a": uint64(1), "b": []interface{}{uint64(2), uint64(3)}},
|
||
|
|
map[string]interface{}{"a": uint64(1), "b": []interface{}{uint64(2), uint64(3)}}},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeByteSlice, typeByteArray, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("bf6346756ef563416d7421ff"),
|
||
|
|
map[interface{}]interface{}{"Fun": true, "Amt": int64(-2)},
|
||
|
|
[]interface{}{map[interface{}]interface{}{"Fun": true, "Amt": int64(-2)},
|
||
|
|
map[string]interface{}{"Fun": true, "Amt": int64(-2)}},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeByteSlice, typeByteArray, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag},
|
||
|
|
},
|
||
|
|
// tag
|
||
|
|
{
|
||
|
|
hexDecode("c074323031332d30332d32315432303a30343a30305a"),
|
||
|
|
time.Date(2013, 3, 21, 20, 4, 0, 0, time.UTC), // 2013-03-21 20:04:00 +0000 UTC
|
||
|
|
[]interface{}{"2013-03-21T20:04:00Z", time.Date(2013, 3, 21, 20, 4, 0, 0, time.UTC), Tag{0, "2013-03-21T20:04:00Z"}, RawTag{0, hexDecode("74323031332d30332d32315432303a30343a30305a")}},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeBool, typeByteArray, typeIntSlice, typeMapStringInt, typeBigInt},
|
||
|
|
}, // 0: standard date/time
|
||
|
|
{
|
||
|
|
hexDecode("c11a514b67b0"),
|
||
|
|
time.Date(2013, 3, 21, 20, 4, 0, 0, time.UTC), // 2013-03-21 20:04:00 +0000 UTC
|
||
|
|
[]interface{}{uint32(1363896240), uint64(1363896240), int32(1363896240), int64(1363896240), float32(1363896240), float64(1363896240), time.Date(2013, 3, 21, 20, 4, 0, 0, time.UTC), Tag{1, uint64(1363896240)}, RawTag{1, hexDecode("1a514b67b0")}},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeInt8, typeInt16, typeByteSlice, typeString, typeBool, typeByteArray, typeIntSlice, typeMapStringInt},
|
||
|
|
}, // 1: epoch-based date/time
|
||
|
|
{
|
||
|
|
hexDecode("c249010000000000000000"),
|
||
|
|
bigIntOrPanic("18446744073709551616"),
|
||
|
|
[]interface{}{
|
||
|
|
// Decode to byte slice
|
||
|
|
[]byte{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
|
||
|
|
// Decode to array of various lengths
|
||
|
|
[0]byte{},
|
||
|
|
[1]byte{0x01},
|
||
|
|
[3]byte{0x01, 0x00, 0x00},
|
||
|
|
[...]byte{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
|
||
|
|
[10]byte{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
|
||
|
|
// Decode to Tag and RawTag
|
||
|
|
Tag{2, []byte{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
|
||
|
|
RawTag{2, hexDecode("49010000000000000000")},
|
||
|
|
// Decode to big.Int
|
||
|
|
bigIntOrPanic("18446744073709551616"),
|
||
|
|
},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeBool, typeIntSlice, typeMapStringInt},
|
||
|
|
}, // 2: positive bignum: 18446744073709551616
|
||
|
|
{
|
||
|
|
hexDecode("c349010000000000000000"),
|
||
|
|
bigIntOrPanic("-18446744073709551617"),
|
||
|
|
[]interface{}{
|
||
|
|
// Decode to byte slice
|
||
|
|
[]byte{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
|
||
|
|
// Decode to array of various lengths
|
||
|
|
[0]byte{},
|
||
|
|
[1]byte{0x01},
|
||
|
|
[3]byte{0x01, 0x00, 0x00},
|
||
|
|
[...]byte{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
|
||
|
|
[10]byte{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
|
||
|
|
// Decode to Tag and RawTag
|
||
|
|
Tag{3, []byte{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
|
||
|
|
RawTag{3, hexDecode("49010000000000000000")},
|
||
|
|
// Decode to big.Int
|
||
|
|
bigIntOrPanic("-18446744073709551617"),
|
||
|
|
},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeBool, typeIntSlice, typeMapStringInt},
|
||
|
|
}, // 3: negative bignum: -18446744073709551617
|
||
|
|
{
|
||
|
|
hexDecode("c1fb41d452d9ec200000"),
|
||
|
|
time.Date(2013, 3, 21, 20, 4, 0, 500000000, time.UTC), // 2013-03-21 20:04:00.5 +0000 UTC
|
||
|
|
[]interface{}{float32(1363896240.5), float64(1363896240.5), time.Date(2013, 3, 21, 20, 4, 0, 500000000, time.UTC), Tag{1, float64(1363896240.5)}, RawTag{1, hexDecode("fb41d452d9ec200000")}},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteSlice, typeByteArray, typeString, typeBool, typeIntSlice, typeMapStringInt, typeBigInt},
|
||
|
|
}, // 1: epoch-based date/time
|
||
|
|
{
|
||
|
|
hexDecode("d74401020304"),
|
||
|
|
Tag{23, []byte{0x01, 0x02, 0x03, 0x04}},
|
||
|
|
[]interface{}{[]byte{0x01, 0x02, 0x03, 0x04}, [0]byte{}, [1]byte{0x01}, [3]byte{0x01, 0x02, 0x03}, [...]byte{0x01, 0x02, 0x03, 0x04}, [5]byte{0x01, 0x02, 0x03, 0x04, 0x00}, Tag{23, []byte{0x01, 0x02, 0x03, 0x04}}, RawTag{23, hexDecode("4401020304")}},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeBool, typeIntSlice, typeMapStringInt, typeBigInt},
|
||
|
|
}, // 23: expected conversion to base16 encoding
|
||
|
|
{
|
||
|
|
hexDecode("d818456449455446"),
|
||
|
|
Tag{24, []byte{0x64, 0x49, 0x45, 0x54, 0x46}},
|
||
|
|
[]interface{}{[]byte{0x64, 0x49, 0x45, 0x54, 0x46}, [0]byte{}, [1]byte{0x64}, [3]byte{0x64, 0x49, 0x45}, [...]byte{0x64, 0x49, 0x45, 0x54, 0x46}, [6]byte{0x64, 0x49, 0x45, 0x54, 0x46, 0x00}, Tag{24, []byte{0x64, 0x49, 0x45, 0x54, 0x46}}, RawTag{24, hexDecode("456449455446")}},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeBool, typeIntSlice, typeMapStringInt, typeBigInt},
|
||
|
|
}, // 24: encoded cborBytes data item
|
||
|
|
{
|
||
|
|
hexDecode("d82076687474703a2f2f7777772e6578616d706c652e636f6d"),
|
||
|
|
Tag{32, "http://www.example.com"},
|
||
|
|
[]interface{}{"http://www.example.com", Tag{32, "http://www.example.com"}, RawTag{32, hexDecode("76687474703a2f2f7777772e6578616d706c652e636f6d")}},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeBool, typeByteArray, typeIntSlice, typeMapStringInt, typeBigInt},
|
||
|
|
}, // 32: URI
|
||
|
|
// primitives
|
||
|
|
{
|
||
|
|
hexDecode("f4"),
|
||
|
|
false,
|
||
|
|
[]interface{}{false},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeByteArray, typeByteSlice, typeString, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("f5"),
|
||
|
|
true,
|
||
|
|
[]interface{}{true},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeByteArray, typeByteSlice, typeString, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("f6"),
|
||
|
|
nil,
|
||
|
|
[]interface{}{false, uint(0), uint8(0), uint16(0), uint32(0), uint64(0), int(0), int8(0), int16(0), int32(0), int64(0), float32(0.0), float64(0.0), "", []byte(nil), []int(nil), []string(nil), map[string]int(nil), time.Time{}, bigIntOrPanic("0"), Tag{}, RawTag{}},
|
||
|
|
nil,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("f7"),
|
||
|
|
nil,
|
||
|
|
[]interface{}{false, uint(0), uint8(0), uint16(0), uint32(0), uint64(0), int(0), int8(0), int16(0), int32(0), int64(0), float32(0.0), float64(0.0), "", []byte(nil), []int(nil), []string(nil), map[string]int(nil), time.Time{}, bigIntOrPanic("0"), Tag{}, RawTag{}},
|
||
|
|
nil,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("f0"),
|
||
|
|
uint64(16),
|
||
|
|
[]interface{}{uint8(16), uint16(16), uint32(16), uint64(16), uint(16), int8(16), int16(16), int32(16), int64(16), int(16), float32(16), float64(16), bigIntOrPanic("16")},
|
||
|
|
[]reflect.Type{typeByteSlice, typeString, typeBool, typeByteArray, typeIntSlice, typeMapStringInt, typeTag, typeRawTag},
|
||
|
|
},
|
||
|
|
// This example is not well-formed because Simple value (with 5-bit value 24) must be >= 32.
|
||
|
|
// See RFC 7049 section 2.3 for details, instead of the incorrect example in RFC 7049 Appendex A.
|
||
|
|
// I reported an errata to RFC 7049 and Carsten Bormann confirmed at https://github.com/fxamacker/cbor/issues/46
|
||
|
|
/*
|
||
|
|
{
|
||
|
|
hexDecode("f818"),
|
||
|
|
uint64(24),
|
||
|
|
[]interface{}{uint8(24), uint16(24), uint32(24), uint64(24), uint(24), int8(24), int16(24), int32(24), int64(24), int(24), float32(24), float64(24)},
|
||
|
|
[]reflect.Type{typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt},
|
||
|
|
},
|
||
|
|
*/
|
||
|
|
{
|
||
|
|
hexDecode("f820"),
|
||
|
|
uint64(32),
|
||
|
|
[]interface{}{uint8(32), uint16(32), uint32(32), uint64(32), uint(32), int8(32), int16(32), int32(32), int64(32), int(32), float32(32), float64(32), bigIntOrPanic("32")},
|
||
|
|
[]reflect.Type{typeByteSlice, typeString, typeBool, typeByteArray, typeIntSlice, typeMapStringInt, typeTag, typeRawTag},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("f8ff"),
|
||
|
|
uint64(255),
|
||
|
|
[]interface{}{uint8(255), uint16(255), uint32(255), uint64(255), uint(255), int16(255), int32(255), int64(255), int(255), float32(255), float64(255), bigIntOrPanic("255")},
|
||
|
|
[]reflect.Type{typeByteSlice, typeString, typeBool, typeByteArray, typeIntSlice, typeMapStringInt, typeTag, typeRawTag},
|
||
|
|
},
|
||
|
|
// More testcases not covered by https://tools.ietf.org/html/rfc7049#appendix-A.
|
||
|
|
{
|
||
|
|
hexDecode("5fff"), // empty indefinite length byte string
|
||
|
|
[]byte{},
|
||
|
|
[]interface{}{[]byte{}, [0]byte{}, [1]byte{0x00}},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("7fff"), // empty indefinite length text string
|
||
|
|
"",
|
||
|
|
[]interface{}{""},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeBool, typeByteArray, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("bfff"), // empty indefinite length map
|
||
|
|
map[interface{}]interface{}{},
|
||
|
|
[]interface{}{map[interface{}]interface{}{}, map[string]bool{}, map[string]int{}, map[int]string{}, map[int]bool{}},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeTag, typeRawTag},
|
||
|
|
},
|
||
|
|
// More test data with tags
|
||
|
|
{
|
||
|
|
hexDecode("c13a0177f2cf"), // 1969-03-21T20:04:00Z, tag 1 with negative integer as epoch time
|
||
|
|
time.Date(1969, 3, 21, 20, 4, 0, 0, time.UTC),
|
||
|
|
[]interface{}{int32(-24638160), int64(-24638160), int32(-24638160), int64(-24638160), float32(-24638160), float64(-24638160), time.Date(1969, 3, 21, 20, 4, 0, 0, time.UTC), Tag{1, int64(-24638160)}, RawTag{1, hexDecode("3a0177f2cf")}, bigIntOrPanic("-24638160")},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeInt8, typeInt16, typeByteSlice, typeString, typeBool, typeByteArray, typeIntSlice, typeMapStringInt},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("d83dd183010203"), // 61(17([1, 2, 3])), nested tags 61 and 17
|
||
|
|
Tag{61, Tag{17, []interface{}{uint64(1), uint64(2), uint64(3)}}},
|
||
|
|
[]interface{}{[]interface{}{uint64(1), uint64(2), uint64(3)}, []byte{1, 2, 3}, [0]byte{}, [1]byte{1}, [3]byte{1, 2, 3}, [5]byte{1, 2, 3, 0, 0}, []int{1, 2, 3}, []uint{1, 2, 3}, [...]int{1, 2, 3}, []float32{1, 2, 3}, []float64{1, 2, 3}, Tag{61, Tag{17, []interface{}{uint64(1), uint64(2), uint64(3)}}}, RawTag{61, hexDecode("d183010203")}},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeString, typeBool, typeStringSlice, typeMapStringInt, reflect.TypeOf([3]string{})},
|
||
|
|
},
|
||
|
|
}
|
||
|
|
|
||
|
|
type unmarshalFloatTest struct {
|
||
|
|
cborData []byte
|
||
|
|
emptyInterfaceValue interface{}
|
||
|
|
values []interface{}
|
||
|
|
wrongTypes []reflect.Type
|
||
|
|
equalityThreshold float64 // Not used for +inf, -inf, and NaN.
|
||
|
|
}
|
||
|
|
|
||
|
|
// unmarshalFloatTests includes test values for float16, float32, and float64.
|
||
|
|
// Note: the function for float16 to float32 conversion was tested with all
|
||
|
|
// 65536 values, which is too many to include here.
|
||
|
|
var unmarshalFloatTests = []unmarshalFloatTest{
|
||
|
|
// CBOR test data are from https://tools.ietf.org/html/rfc7049#appendix-A.
|
||
|
|
// float16
|
||
|
|
{
|
||
|
|
hexDecode("f90000"),
|
||
|
|
float64(0.0),
|
||
|
|
[]interface{}{float32(0.0), float64(0.0)},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
0.0,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("f98000"),
|
||
|
|
float64(-0.0),
|
||
|
|
[]interface{}{float32(-0.0), float64(-0.0)},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
0.0,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("f93c00"),
|
||
|
|
float64(1.0),
|
||
|
|
[]interface{}{float32(1.0), float64(1.0)},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
0.0,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("f93e00"),
|
||
|
|
float64(1.5),
|
||
|
|
[]interface{}{float32(1.5), float64(1.5)},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
0.0,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("f97bff"),
|
||
|
|
float64(65504.0),
|
||
|
|
[]interface{}{float32(65504.0), float64(65504.0)},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
0.0,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("f90001"), // float16 subnormal value
|
||
|
|
float64(5.960464477539063e-08),
|
||
|
|
[]interface{}{float32(5.960464477539063e-08), float64(5.960464477539063e-08)},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
1e-16,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("f90400"),
|
||
|
|
float64(6.103515625e-05),
|
||
|
|
[]interface{}{float32(6.103515625e-05), float64(6.103515625e-05)},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
1e-16,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("f9c400"),
|
||
|
|
float64(-4.0),
|
||
|
|
[]interface{}{float32(-4.0), float64(-4.0)},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
0.0,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("f97c00"),
|
||
|
|
math.Inf(1),
|
||
|
|
[]interface{}{math.Float32frombits(0x7f800000), math.Inf(1)},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
0.0,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("f97e00"),
|
||
|
|
math.NaN(),
|
||
|
|
[]interface{}{math.Float32frombits(0x7fc00000), math.NaN()},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
0.0,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("f9fc00"),
|
||
|
|
math.Inf(-1),
|
||
|
|
[]interface{}{math.Float32frombits(0xff800000), math.Inf(-1)},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
0.0,
|
||
|
|
},
|
||
|
|
// float32
|
||
|
|
{
|
||
|
|
hexDecode("fa47c35000"),
|
||
|
|
float64(100000.0),
|
||
|
|
[]interface{}{float32(100000.0), float64(100000.0)},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
0.0,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("fa7f7fffff"),
|
||
|
|
float64(3.4028234663852886e+38),
|
||
|
|
[]interface{}{float32(3.4028234663852886e+38), float64(3.4028234663852886e+38)},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
1e-9,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("fa7f800000"),
|
||
|
|
math.Inf(1),
|
||
|
|
[]interface{}{math.Float32frombits(0x7f800000), math.Inf(1)},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
0.0,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("fa7fc00000"),
|
||
|
|
math.NaN(),
|
||
|
|
[]interface{}{math.Float32frombits(0x7fc00000), math.NaN()},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
0.0,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("faff800000"),
|
||
|
|
math.Inf(-1),
|
||
|
|
[]interface{}{math.Float32frombits(0xff800000), math.Inf(-1)},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
0.0,
|
||
|
|
},
|
||
|
|
// float64
|
||
|
|
{
|
||
|
|
hexDecode("fb3ff199999999999a"),
|
||
|
|
float64(1.1),
|
||
|
|
[]interface{}{float32(1.1), float64(1.1)},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
1e-9,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("fb7e37e43c8800759c"),
|
||
|
|
float64(1.0e+300),
|
||
|
|
[]interface{}{float64(1.0e+300)},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
1e-9,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("fbc010666666666666"),
|
||
|
|
float64(-4.1),
|
||
|
|
[]interface{}{float32(-4.1), float64(-4.1)},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
1e-9,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("fb7ff0000000000000"),
|
||
|
|
math.Inf(1),
|
||
|
|
[]interface{}{math.Float32frombits(0x7f800000), math.Inf(1)},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
0.0,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("fb7ff8000000000000"),
|
||
|
|
math.NaN(),
|
||
|
|
[]interface{}{math.Float32frombits(0x7fc00000), math.NaN()},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
0.0,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("fbfff0000000000000"),
|
||
|
|
math.Inf(-1),
|
||
|
|
[]interface{}{math.Float32frombits(0xff800000), math.Inf(-1)},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
0.0,
|
||
|
|
},
|
||
|
|
|
||
|
|
// float16 test data from https://en.wikipedia.org/wiki/Half-precision_floating-point_format
|
||
|
|
{
|
||
|
|
hexDecode("f903ff"),
|
||
|
|
float64(0.000060976),
|
||
|
|
[]interface{}{float32(0.000060976), float64(0.000060976)},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
1e-9,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("f93bff"),
|
||
|
|
float64(0.999511719),
|
||
|
|
[]interface{}{float32(0.999511719), float64(0.999511719)},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
1e-9,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("f93c01"),
|
||
|
|
float64(1.000976563),
|
||
|
|
[]interface{}{float32(1.000976563), float64(1.000976563)},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
1e-9,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("f93555"),
|
||
|
|
float64(0.333251953125),
|
||
|
|
[]interface{}{float32(0.333251953125), float64(0.333251953125)},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
1e-9,
|
||
|
|
},
|
||
|
|
// CBOR test data "canonNums" are from https://github.com/cbor-wg/cbor-test-vectors
|
||
|
|
{
|
||
|
|
hexDecode("f9bd00"),
|
||
|
|
float64(-1.25),
|
||
|
|
[]interface{}{float32(-1.25), float64(-1.25)},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
0.0,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("f93e00"),
|
||
|
|
float64(1.5),
|
||
|
|
[]interface{}{float32(1.5), float64(1.5)},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
0.0,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("fb4024333333333333"),
|
||
|
|
float64(10.1),
|
||
|
|
[]interface{}{float32(10.1), float64(10.1)},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
0.0,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("f90001"),
|
||
|
|
float64(5.960464477539063e-8),
|
||
|
|
[]interface{}{float32(5.960464477539063e-8), float64(5.960464477539063e-8)},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
0.0,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("fa7f7fffff"),
|
||
|
|
float64(3.4028234663852886e+38),
|
||
|
|
[]interface{}{float32(3.4028234663852886e+38), float64(3.4028234663852886e+38)},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
0.0,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("f90400"),
|
||
|
|
float64(0.00006103515625),
|
||
|
|
[]interface{}{float32(0.00006103515625), float64(0.00006103515625)},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
0.0,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("f933ff"),
|
||
|
|
float64(0.2498779296875),
|
||
|
|
[]interface{}{float32(0.2498779296875), float64(0.2498779296875)},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
0.0,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("fa33000000"),
|
||
|
|
float64(2.9802322387695312e-8),
|
||
|
|
[]interface{}{float32(2.9802322387695312e-8), float64(2.9802322387695312e-8)},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
0.0,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("fa33333866"),
|
||
|
|
float64(4.1727979294137185e-8),
|
||
|
|
[]interface{}{float32(4.1727979294137185e-8), float64(4.1727979294137185e-8)},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
0.0,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
hexDecode("fa37002000"),
|
||
|
|
float64(0.000007636845111846924),
|
||
|
|
[]interface{}{float32(0.000007636845111846924), float64(0.000007636845111846924)},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeByteArray, typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag, typeBigInt},
|
||
|
|
0.0,
|
||
|
|
},
|
||
|
|
}
|
||
|
|
|
||
|
|
const invalidUTF8ErrorMsg = "cbor: invalid UTF-8 string"
|
||
|
|
|
||
|
|
func hexDecode(s string) []byte {
|
||
|
|
data, err := hex.DecodeString(s)
|
||
|
|
if err != nil {
|
||
|
|
panic(err)
|
||
|
|
}
|
||
|
|
return data
|
||
|
|
}
|
||
|
|
|
||
|
|
func bigIntOrPanic(s string) big.Int {
|
||
|
|
bi, ok := new(big.Int).SetString(s, 10)
|
||
|
|
if !ok {
|
||
|
|
panic("failed to convert " + s + " to big.Int")
|
||
|
|
}
|
||
|
|
return *bi
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshal(t *testing.T) {
|
||
|
|
for _, tc := range unmarshalTests {
|
||
|
|
// Test unmarshalling CBOR into empty interface.
|
||
|
|
var v interface{}
|
||
|
|
if err := Unmarshal(tc.cborData, &v); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", tc.cborData, err)
|
||
|
|
} else {
|
||
|
|
if tm, ok := tc.emptyInterfaceValue.(time.Time); ok {
|
||
|
|
if vt, ok := v.(time.Time); !ok || !tm.Equal(vt) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", tc.cborData, v, v, tc.emptyInterfaceValue, tc.emptyInterfaceValue)
|
||
|
|
}
|
||
|
|
} else if !reflect.DeepEqual(v, tc.emptyInterfaceValue) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", tc.cborData, v, v, tc.emptyInterfaceValue, tc.emptyInterfaceValue)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// Test unmarshalling CBOR into RawMessage.
|
||
|
|
var r RawMessage
|
||
|
|
if err := Unmarshal(tc.cborData, &r); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", tc.cborData, err)
|
||
|
|
} else if !bytes.Equal(r, tc.cborData) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned RawMessage %v, want %v", tc.cborData, r, tc.cborData)
|
||
|
|
}
|
||
|
|
// Test unmarshalling CBOR into compatible data types.
|
||
|
|
for _, value := range tc.values {
|
||
|
|
v := reflect.New(reflect.TypeOf(value))
|
||
|
|
vPtr := v.Interface()
|
||
|
|
if err := Unmarshal(tc.cborData, vPtr); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", tc.cborData, err)
|
||
|
|
} else {
|
||
|
|
if tm, ok := value.(time.Time); ok {
|
||
|
|
if vt, ok := v.Elem().Interface().(time.Time); !ok || !tm.Equal(vt) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", tc.cborData, v.Elem().Interface(), v.Elem().Interface(), value, value)
|
||
|
|
}
|
||
|
|
} else if !reflect.DeepEqual(v.Elem().Interface(), value) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", tc.cborData, v.Elem().Interface(), v.Elem().Interface(), value, value)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// Test unmarshalling CBOR into incompatible data types.
|
||
|
|
for _, typ := range tc.wrongTypes {
|
||
|
|
v := reflect.New(typ)
|
||
|
|
vPtr := v.Interface()
|
||
|
|
if err := Unmarshal(tc.cborData, vPtr); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x, %s) didn't return an error", tc.cborData, typ.String())
|
||
|
|
} else if _, ok := err.(*UnmarshalTypeError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned wrong error type %T, want (*UnmarshalTypeError)", tc.cborData, err)
|
||
|
|
} else if !strings.Contains(err.Error(), "cannot unmarshal") {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing %q", tc.cborData, err.Error(), "cannot unmarshal")
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalFloat(t *testing.T) {
|
||
|
|
for _, tc := range unmarshalFloatTests {
|
||
|
|
// Test unmarshalling CBOR into empty interface.
|
||
|
|
var v interface{}
|
||
|
|
if err := Unmarshal(tc.cborData, &v); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", tc.cborData, err)
|
||
|
|
} else {
|
||
|
|
testFloat(t, tc.cborData, v, tc.emptyInterfaceValue, tc.equalityThreshold)
|
||
|
|
}
|
||
|
|
// Test unmarshalling CBOR into RawMessage.
|
||
|
|
var r RawMessage
|
||
|
|
if err := Unmarshal(tc.cborData, &r); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", tc.cborData, err)
|
||
|
|
} else if !bytes.Equal(r, tc.cborData) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned RawMessage %v, want %v", tc.cborData, r, tc.cborData)
|
||
|
|
}
|
||
|
|
// Test unmarshalling CBOR into compatible data types.
|
||
|
|
for _, value := range tc.values {
|
||
|
|
v := reflect.New(reflect.TypeOf(value))
|
||
|
|
vPtr := v.Interface()
|
||
|
|
if err := Unmarshal(tc.cborData, vPtr); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", tc.cborData, err)
|
||
|
|
} else {
|
||
|
|
testFloat(t, tc.cborData, v.Elem().Interface(), value, tc.equalityThreshold)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// Test unmarshalling CBOR into incompatible data types.
|
||
|
|
for _, typ := range tc.wrongTypes {
|
||
|
|
v := reflect.New(typ)
|
||
|
|
vPtr := v.Interface()
|
||
|
|
if err := Unmarshal(tc.cborData, vPtr); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error", tc.cborData)
|
||
|
|
} else if _, ok := err.(*UnmarshalTypeError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned wrong error type %T, want (*UnmarshalTypeError)", tc.cborData, err)
|
||
|
|
} else if !strings.Contains(err.Error(), "cannot unmarshal") {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing %q", tc.cborData, err.Error(), "cannot unmarshal")
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func testFloat(t *testing.T, cborData []byte, f interface{}, wantf interface{}, equalityThreshold float64) {
|
||
|
|
switch wantf := wantf.(type) {
|
||
|
|
case float32:
|
||
|
|
f, ok := f.(float32)
|
||
|
|
if !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned value of type %T, want float32", cborData, f)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if math.IsNaN(float64(wantf)) {
|
||
|
|
if !math.IsNaN(float64(f)) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %f, want NaN", cborData, f)
|
||
|
|
}
|
||
|
|
} else if math.IsInf(float64(wantf), 0) {
|
||
|
|
if f != wantf {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %f, want %f", cborData, f, wantf)
|
||
|
|
}
|
||
|
|
} else if math.Abs(float64(f-wantf)) > equalityThreshold {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %.18f, want %.18f, diff %.18f > threshold %.18f", cborData, f, wantf, math.Abs(float64(f-wantf)), equalityThreshold)
|
||
|
|
}
|
||
|
|
case float64:
|
||
|
|
f, ok := f.(float64)
|
||
|
|
if !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned value of type %T, want float64", cborData, f)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
if math.IsNaN(wantf) {
|
||
|
|
if !math.IsNaN(f) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %f, want NaN", cborData, f)
|
||
|
|
}
|
||
|
|
} else if math.IsInf(wantf, 0) {
|
||
|
|
if f != wantf {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %f, want %f", cborData, f, wantf)
|
||
|
|
}
|
||
|
|
} else if math.Abs(f-wantf) > equalityThreshold {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %.18f, want %.18f, diff %.18f > threshold %.18f", cborData, f, wantf, math.Abs(f-wantf), equalityThreshold)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestNegIntOverflow(t *testing.T) {
|
||
|
|
cborData := hexDecode("3bffffffffffffffff") // -18446744073709551616
|
||
|
|
|
||
|
|
// Decode CBOR neg int that overflows Go int64 to empty interface
|
||
|
|
var v1 interface{}
|
||
|
|
wantObj := bigIntOrPanic("-18446744073709551616")
|
||
|
|
if err := Unmarshal(cborData, &v1); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %+v", cborData, err)
|
||
|
|
} else if !reflect.DeepEqual(v1, wantObj) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned %v (%T), want %v (%T)", cborData, v1, v1, wantObj, wantObj)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Decode CBOR neg int that overflows Go int64 to big.Int
|
||
|
|
var v2 big.Int
|
||
|
|
if err := Unmarshal(cborData, &v2); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %+v", cborData, err)
|
||
|
|
} else if !reflect.DeepEqual(v2, wantObj) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned %v (%T), want %v (%T)", cborData, v2, v2, wantObj, wantObj)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Decode CBOR neg int that overflows Go int64 to int64
|
||
|
|
var v3 int64
|
||
|
|
if err := Unmarshal(cborData, &v3); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error", cborData)
|
||
|
|
} else if _, ok := err.(*UnmarshalTypeError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned wrong error type %T, want (*UnmarshalTypeError)", cborData, err)
|
||
|
|
} else if !strings.Contains(err.Error(), "cannot unmarshal") {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing %q", cborData, err.Error(), "cannot unmarshal")
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalIntoPtrPrimitives(t *testing.T) {
|
||
|
|
cborDataInt := hexDecode("1818") // 24
|
||
|
|
cborDataString := hexDecode("7f657374726561646d696e67ff") // "streaming"
|
||
|
|
|
||
|
|
const wantInt = 24
|
||
|
|
const wantString = "streaming"
|
||
|
|
|
||
|
|
var p1 *int
|
||
|
|
var p2 *string
|
||
|
|
var p3 *RawMessage
|
||
|
|
|
||
|
|
var i int
|
||
|
|
pi := &i
|
||
|
|
ppi := &pi
|
||
|
|
|
||
|
|
var s string
|
||
|
|
ps := &s
|
||
|
|
pps := &ps
|
||
|
|
|
||
|
|
var r RawMessage
|
||
|
|
pr := &r
|
||
|
|
ppr := &pr
|
||
|
|
|
||
|
|
// Unmarshal CBOR integer into a non-nil pointer.
|
||
|
|
if err := Unmarshal(cborDataInt, &ppi); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborDataInt, err)
|
||
|
|
} else if i != wantInt {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %d", cborDataInt, i, i, wantInt)
|
||
|
|
}
|
||
|
|
// Unmarshal CBOR integer into a nil pointer.
|
||
|
|
if err := Unmarshal(cborDataInt, &p1); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborDataInt, err)
|
||
|
|
} else if *p1 != wantInt {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %d", cborDataInt, *pi, pi, wantInt)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Unmarshal CBOR string into a non-nil pointer.
|
||
|
|
if err := Unmarshal(cborDataString, &pps); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborDataString, err)
|
||
|
|
} else if s != wantString {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v", cborDataString, s, s, wantString)
|
||
|
|
}
|
||
|
|
// Unmarshal CBOR string into a nil pointer.
|
||
|
|
if err := Unmarshal(cborDataString, &p2); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborDataString, err)
|
||
|
|
} else if *p2 != wantString {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v", cborDataString, *p2, p2, wantString)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Unmarshal CBOR string into a non-nil RawMessage.
|
||
|
|
if err := Unmarshal(cborDataString, &ppr); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborDataString, err)
|
||
|
|
} else if !bytes.Equal(r, cborDataString) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v", cborDataString, r, r, cborDataString)
|
||
|
|
}
|
||
|
|
// Unmarshal CBOR string into a nil pointer to RawMessage.
|
||
|
|
if err := Unmarshal(cborDataString, &p3); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborDataString, err)
|
||
|
|
} else if !bytes.Equal(*p3, cborDataString) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v", cborDataString, *p3, p3, cborDataString)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalIntoPtrArrayPtrElem(t *testing.T) {
|
||
|
|
cborData := hexDecode("83010203") // []int{1, 2, 3}
|
||
|
|
|
||
|
|
n1, n2, n3 := 1, 2, 3
|
||
|
|
|
||
|
|
wantArray := []*int{&n1, &n2, &n3}
|
||
|
|
|
||
|
|
var p *[]*int
|
||
|
|
|
||
|
|
var slc []*int
|
||
|
|
pslc := &slc
|
||
|
|
ppslc := &pslc
|
||
|
|
|
||
|
|
// Unmarshal CBOR array into a non-nil pointer.
|
||
|
|
if err := Unmarshal(cborData, &ppslc); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x, %s) returned error %v", cborData, reflect.TypeOf(ppslc), err)
|
||
|
|
} else if !reflect.DeepEqual(slc, wantArray) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v", cborData, slc, slc, wantArray)
|
||
|
|
}
|
||
|
|
// Unmarshal CBOR array into a nil pointer.
|
||
|
|
if err := Unmarshal(cborData, &p); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
} else if !reflect.DeepEqual(*p, wantArray) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v", cborData, *p, p, wantArray)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalIntoPtrMapPtrElem(t *testing.T) {
|
||
|
|
cborData := hexDecode("a201020304") // {1: 2, 3: 4}
|
||
|
|
|
||
|
|
n1, n2, n3, n4 := 1, 2, 3, 4
|
||
|
|
|
||
|
|
wantMap := map[int]*int{n1: &n2, n3: &n4}
|
||
|
|
|
||
|
|
var p *map[int]*int
|
||
|
|
|
||
|
|
var m map[int]*int
|
||
|
|
pm := &m
|
||
|
|
ppm := &pm
|
||
|
|
|
||
|
|
// Unmarshal CBOR map into a non-nil pointer.
|
||
|
|
if err := Unmarshal(cborData, &ppm); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x, %s) returned error %v", cborData, reflect.TypeOf(ppm), err)
|
||
|
|
} else if !reflect.DeepEqual(m, wantMap) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v", cborData, m, m, wantMap)
|
||
|
|
}
|
||
|
|
// Unmarshal CBOR map into a nil pointer.
|
||
|
|
if err := Unmarshal(cborData, &p); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
} else if !reflect.DeepEqual(*p, wantMap) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v", cborData, *p, p, wantMap)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalIntoPtrStructPtrElem(t *testing.T) {
|
||
|
|
type s1 struct {
|
||
|
|
A *string `cbor:"a"`
|
||
|
|
B *string `cbor:"b"`
|
||
|
|
C *string `cbor:"c"`
|
||
|
|
D *string `cbor:"d"`
|
||
|
|
E *string `cbor:"e"`
|
||
|
|
}
|
||
|
|
|
||
|
|
cborData := hexDecode("a56161614161626142616361436164614461656145") // map[string]string{"a": "A", "b": "B", "c": "C", "d": "D", "e": "E"}
|
||
|
|
|
||
|
|
a, b, c, d, e := "A", "B", "C", "D", "E"
|
||
|
|
wantObj := s1{A: &a, B: &b, C: &c, D: &d, E: &e}
|
||
|
|
|
||
|
|
var p *s1
|
||
|
|
|
||
|
|
var s s1
|
||
|
|
ps := &s
|
||
|
|
pps := &ps
|
||
|
|
|
||
|
|
// Unmarshal CBOR map into a non-nil pointer.
|
||
|
|
if err := Unmarshal(cborData, &pps); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x, %s) returned error %v", cborData, reflect.TypeOf(pps), err)
|
||
|
|
} else if !reflect.DeepEqual(s, wantObj) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v", cborData, s, s, wantObj)
|
||
|
|
}
|
||
|
|
// Unmarshal CBOR map into a nil pointer.
|
||
|
|
if err := Unmarshal(cborData, &p); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
} else if !reflect.DeepEqual(*p, wantObj) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v", cborData, *p, p, wantObj)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalIntoArray(t *testing.T) {
|
||
|
|
cborData := hexDecode("83010203") // []int{1, 2, 3}
|
||
|
|
|
||
|
|
// Unmarshal CBOR array into Go array.
|
||
|
|
var arr1 [3]int
|
||
|
|
if err := Unmarshal(cborData, &arr1); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
} else if arr1 != [3]int{1, 2, 3} {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want [3]int{1, 2, 3}", cborData, arr1, arr1)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Unmarshal CBOR array into Go array with more elements.
|
||
|
|
var arr2 [5]int
|
||
|
|
if err := Unmarshal(cborData, &arr2); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
} else if arr2 != [5]int{1, 2, 3, 0, 0} {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want [5]int{1, 2, 3, 0, 0}", cborData, arr2, arr2)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Unmarshal CBOR array into Go array with less elements.
|
||
|
|
var arr3 [1]int
|
||
|
|
if err := Unmarshal(cborData, &arr3); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
} else if arr3 != [1]int{1} {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want [0]int{1}", cborData, arr3, arr3)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
type nilUnmarshaler string
|
||
|
|
|
||
|
|
func (s *nilUnmarshaler) UnmarshalCBOR(data []byte) error {
|
||
|
|
if len(data) == 1 && (data[0] == 0xf6 || data[0] == 0xf7) {
|
||
|
|
*s = "null"
|
||
|
|
} else {
|
||
|
|
*s = nilUnmarshaler(data)
|
||
|
|
}
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalNil(t *testing.T) {
|
||
|
|
type T struct {
|
||
|
|
I int
|
||
|
|
}
|
||
|
|
|
||
|
|
cborData := [][]byte{hexDecode("f6"), hexDecode("f7")} // CBOR null and undefined values
|
||
|
|
|
||
|
|
testCases := []struct {
|
||
|
|
name string
|
||
|
|
value interface{}
|
||
|
|
wantValue interface{}
|
||
|
|
}{
|
||
|
|
// Unmarshalling CBOR null to the following types is a no-op.
|
||
|
|
{"bool", true, true},
|
||
|
|
{"int", int(-1), int(-1)},
|
||
|
|
{"int8", int8(-2), int8(-2)},
|
||
|
|
{"int16", int16(-3), int16(-3)},
|
||
|
|
{"int32", int32(-4), int32(-4)},
|
||
|
|
{"int64", int64(-5), int64(-5)},
|
||
|
|
{"uint", uint(1), uint(1)},
|
||
|
|
{"uint8", uint8(2), uint8(2)},
|
||
|
|
{"uint16", uint16(3), uint16(3)},
|
||
|
|
{"uint32", uint32(4), uint32(4)},
|
||
|
|
{"uint64", uint64(5), uint64(5)},
|
||
|
|
{"float32", float32(1.23), float32(1.23)},
|
||
|
|
{"float64", float64(4.56), float64(4.56)},
|
||
|
|
{"string", "hello", "hello"},
|
||
|
|
{"array", [3]int{1, 2, 3}, [3]int{1, 2, 3}},
|
||
|
|
|
||
|
|
// Unmarshalling CBOR null to slice/map sets Go values to nil.
|
||
|
|
{"[]byte", []byte{1, 2, 3}, []byte(nil)},
|
||
|
|
{"slice", []string{"hello", "world"}, []string(nil)},
|
||
|
|
{"map", map[string]bool{"hello": true, "goodbye": false}, map[string]bool(nil)},
|
||
|
|
|
||
|
|
// Unmarshalling CBOR null to time.Time is a no-op.
|
||
|
|
{"time.Time", time.Date(2020, time.January, 2, 3, 4, 5, 6, time.UTC), time.Date(2020, time.January, 2, 3, 4, 5, 6, time.UTC)},
|
||
|
|
|
||
|
|
// Unmarshalling CBOR null to big.Int is a no-op.
|
||
|
|
{"big.Int", bigIntOrPanic("123"), bigIntOrPanic("123")},
|
||
|
|
|
||
|
|
// Unmarshalling CBOR null to user defined struct types is a no-op.
|
||
|
|
{"user defined struct", T{I: 123}, T{I: 123}},
|
||
|
|
|
||
|
|
// Unmarshalling CBOR null to cbor.Tag and cbor.RawTag is a no-op.
|
||
|
|
{"cbor.RawTag", RawTag{123, []byte{4, 5, 6}}, RawTag{123, []byte{4, 5, 6}}},
|
||
|
|
{"cbor.Tag", Tag{123, "hello world"}, Tag{123, "hello world"}},
|
||
|
|
|
||
|
|
// Unmarshalling to cbor.RawMessage sets cbor.RawMessage to raw CBOR bytes (0xf6 or 0xf7).
|
||
|
|
// It's tested in TestUnmarshal().
|
||
|
|
|
||
|
|
// Unmarshalling to types implementing cbor.BinaryUnmarshaler is a no-op.
|
||
|
|
//{"cbor.BinaryUnmarshaler", nilBinaryUnmarshaler("hello world"), nilBinaryUnmarshaler("hello world")},
|
||
|
|
{"cbor.BinaryUnmarshaler", number(456), number(456)},
|
||
|
|
|
||
|
|
// When unmarshalling to types implementing cbor.Unmarshaler,
|
||
|
|
// UnmarshalCBOR function receives raw CBOR bytes (0xf6 or 0xf7).
|
||
|
|
{"cbor.Unmarshaler", nilUnmarshaler("hello world"), nilUnmarshaler("null")},
|
||
|
|
}
|
||
|
|
|
||
|
|
// Unmarshalling to values of specified Go types.
|
||
|
|
for _, tc := range testCases {
|
||
|
|
t.Run(tc.name, func(t *testing.T) {
|
||
|
|
for _, data := range cborData {
|
||
|
|
v := reflect.New(reflect.TypeOf(tc.value))
|
||
|
|
v.Elem().Set(reflect.ValueOf(tc.value))
|
||
|
|
|
||
|
|
if err := Unmarshal(data, v.Interface()); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) to %T returned error %v", data, v.Elem().Interface(), err)
|
||
|
|
} else if !reflect.DeepEqual(v.Elem().Interface(), tc.wantValue) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", data, v.Elem().Interface(), v.Elem().Interface(), tc.wantValue, tc.wantValue)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
var invalidUnmarshalTests = []struct {
|
||
|
|
name string
|
||
|
|
v interface{}
|
||
|
|
wantErrorMsg string
|
||
|
|
}{
|
||
|
|
{"unmarshal into nil interface{}", nil, "cbor: Unmarshal(nil)"},
|
||
|
|
{"unmarshal into non-pointer value", 5, "cbor: Unmarshal(non-pointer int)"},
|
||
|
|
{"unmarshal into nil pointer", (*int)(nil), "cbor: Unmarshal(nil *int)"},
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestInvalidUnmarshal(t *testing.T) {
|
||
|
|
cborData := []byte{0x00}
|
||
|
|
|
||
|
|
for _, tc := range invalidUnmarshalTests {
|
||
|
|
t.Run(tc.name, func(t *testing.T) {
|
||
|
|
err := Unmarshal(cborData, tc.v)
|
||
|
|
if err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x, %v) didn't return an error", cborData, tc.v)
|
||
|
|
} else if _, ok := err.(*InvalidUnmarshalError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x, %v) error type %T, want *InvalidUnmarshalError", cborData, tc.v, err)
|
||
|
|
} else if err.Error() != tc.wantErrorMsg {
|
||
|
|
t.Errorf("Unmarshal(0x%x, %v) error %q, want %q", cborData, tc.v, err.Error(), tc.wantErrorMsg)
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
var invalidCBORUnmarshalTests = []struct {
|
||
|
|
name string
|
||
|
|
cborData []byte
|
||
|
|
wantErrorMsg string
|
||
|
|
errorMsgPartialMatch bool
|
||
|
|
}{
|
||
|
|
{"Nil data", []byte(nil), "EOF", false},
|
||
|
|
{"Empty data", []byte{}, "EOF", false},
|
||
|
|
{"Tag number not followed by tag content", []byte{0xc0}, "unexpected EOF", false},
|
||
|
|
{"Definite length strings with tagged chunk", hexDecode("5fc64401020304ff"), "cbor: wrong element type tag for indefinite-length byte string", false},
|
||
|
|
{"Definite length strings with tagged chunk", hexDecode("7fc06161ff"), "cbor: wrong element type tag for indefinite-length UTF-8 text string", false},
|
||
|
|
{"Indefinite length strings with invalid head", hexDecode("7f61"), "unexpected EOF", false},
|
||
|
|
{"Invalid nested tag number", hexDecode("d864dc1a514b67b0"), "cbor: invalid additional information", true},
|
||
|
|
// Data from 7049bis G.1
|
||
|
|
// Premature end of the input
|
||
|
|
{"End of input in a head", hexDecode("18"), "unexpected EOF", false},
|
||
|
|
{"End of input in a head", hexDecode("19"), "unexpected EOF", false},
|
||
|
|
{"End of input in a head", hexDecode("1a"), "unexpected EOF", false},
|
||
|
|
{"End of input in a head", hexDecode("1b"), "unexpected EOF", false},
|
||
|
|
{"End of input in a head", hexDecode("1901"), "unexpected EOF", false},
|
||
|
|
{"End of input in a head", hexDecode("1a0102"), "unexpected EOF", false},
|
||
|
|
{"End of input in a head", hexDecode("1b01020304050607"), "unexpected EOF", false},
|
||
|
|
{"End of input in a head", hexDecode("38"), "unexpected EOF", false},
|
||
|
|
{"End of input in a head", hexDecode("58"), "unexpected EOF", false},
|
||
|
|
{"End of input in a head", hexDecode("78"), "unexpected EOF", false},
|
||
|
|
{"End of input in a head", hexDecode("98"), "unexpected EOF", false},
|
||
|
|
{"End of input in a head", hexDecode("9a01ff00"), "unexpected EOF", false},
|
||
|
|
{"End of input in a head", hexDecode("b8"), "unexpected EOF", false},
|
||
|
|
{"End of input in a head", hexDecode("d8"), "unexpected EOF", false},
|
||
|
|
{"End of input in a head", hexDecode("f8"), "unexpected EOF", false},
|
||
|
|
{"End of input in a head", hexDecode("f900"), "unexpected EOF", false},
|
||
|
|
{"End of input in a head", hexDecode("fa0000"), "unexpected EOF", false},
|
||
|
|
{"End of input in a head", hexDecode("fb000000"), "unexpected EOF", false},
|
||
|
|
{"Definite length strings with short data", hexDecode("41"), "unexpected EOF", false},
|
||
|
|
{"Definite length strings with short data", hexDecode("61"), "unexpected EOF", false},
|
||
|
|
{"Definite length strings with short data", hexDecode("5affffffff00"), "unexpected EOF", false},
|
||
|
|
{"Definite length strings with short data", hexDecode("5bffffffffffffffff010203"), "cbor: byte string length 18446744073709551615 is too large, causing integer overflow", false},
|
||
|
|
{"Definite length strings with short data", hexDecode("7affffffff00"), "unexpected EOF", false},
|
||
|
|
{"Definite length strings with short data", hexDecode("7b7fffffffffffffff010203"), "unexpected EOF", false},
|
||
|
|
{"Definite length maps and arrays not closed with enough items", hexDecode("81"), "unexpected EOF", false},
|
||
|
|
{"Definite length maps and arrays not closed with enough items", hexDecode("818181818181818181"), "unexpected EOF", false},
|
||
|
|
{"Definite length maps and arrays not closed with enough items", hexDecode("8200"), "unexpected EOF", false},
|
||
|
|
{"Definite length maps and arrays not closed with enough items", hexDecode("a1"), "unexpected EOF", false},
|
||
|
|
{"Definite length maps and arrays not closed with enough items", hexDecode("a20102"), "unexpected EOF", false},
|
||
|
|
{"Definite length maps and arrays not closed with enough items", hexDecode("a100"), "unexpected EOF", false},
|
||
|
|
{"Definite length maps and arrays not closed with enough items", hexDecode("a2000000"), "unexpected EOF", false},
|
||
|
|
{"Indefinite length strings not closed by a break stop code", hexDecode("5f4100"), "unexpected EOF", false},
|
||
|
|
{"Indefinite length strings not closed by a break stop code", hexDecode("7f6100"), "unexpected EOF", false},
|
||
|
|
{"Indefinite length maps and arrays not closed by a break stop code", hexDecode("9f"), "unexpected EOF", false},
|
||
|
|
{"Indefinite length maps and arrays not closed by a break stop code", hexDecode("9f0102"), "unexpected EOF", false},
|
||
|
|
{"Indefinite length maps and arrays not closed by a break stop code", hexDecode("bf"), "unexpected EOF", false},
|
||
|
|
{"Indefinite length maps and arrays not closed by a break stop code", hexDecode("bf01020102"), "unexpected EOF", false},
|
||
|
|
{"Indefinite length maps and arrays not closed by a break stop code", hexDecode("819f"), "unexpected EOF", false},
|
||
|
|
{"Indefinite length maps and arrays not closed by a break stop code", hexDecode("9f8000"), "unexpected EOF", false},
|
||
|
|
{"Indefinite length maps and arrays not closed by a break stop code", hexDecode("9f9f9f9f9fffffffff"), "unexpected EOF", false},
|
||
|
|
{"Indefinite length maps and arrays not closed by a break stop code", hexDecode("9f819f819f9fffffff"), "unexpected EOF", false},
|
||
|
|
// Five subkinds of well-formedness error kind 3 (syntax error)
|
||
|
|
{"Reserved additional information values", hexDecode("3e"), "cbor: invalid additional information", true},
|
||
|
|
{"Reserved additional information values", hexDecode("5c"), "cbor: invalid additional information", true},
|
||
|
|
{"Reserved additional information values", hexDecode("5d"), "cbor: invalid additional information", true},
|
||
|
|
{"Reserved additional information values", hexDecode("5e"), "cbor: invalid additional information", true},
|
||
|
|
{"Reserved additional information values", hexDecode("7c"), "cbor: invalid additional information", true},
|
||
|
|
{"Reserved additional information values", hexDecode("7d"), "cbor: invalid additional information", true},
|
||
|
|
{"Reserved additional information values", hexDecode("7e"), "cbor: invalid additional information", true},
|
||
|
|
{"Reserved additional information values", hexDecode("9c"), "cbor: invalid additional information", true},
|
||
|
|
{"Reserved additional information values", hexDecode("9d"), "cbor: invalid additional information", true},
|
||
|
|
{"Reserved additional information values", hexDecode("9e"), "cbor: invalid additional information", true},
|
||
|
|
{"Reserved additional information values", hexDecode("bc"), "cbor: invalid additional information", true},
|
||
|
|
{"Reserved additional information values", hexDecode("bd"), "cbor: invalid additional information", true},
|
||
|
|
{"Reserved additional information values", hexDecode("be"), "cbor: invalid additional information", true},
|
||
|
|
{"Reserved additional information values", hexDecode("dc"), "cbor: invalid additional information", true},
|
||
|
|
{"Reserved additional information values", hexDecode("dd"), "cbor: invalid additional information", true},
|
||
|
|
{"Reserved additional information values", hexDecode("de"), "cbor: invalid additional information", true},
|
||
|
|
{"Reserved additional information values", hexDecode("fc"), "cbor: invalid additional information", true},
|
||
|
|
{"Reserved additional information values", hexDecode("fd"), "cbor: invalid additional information", true},
|
||
|
|
{"Reserved additional information values", hexDecode("fe"), "cbor: invalid additional information", true},
|
||
|
|
{"Reserved two-byte encodings of simple types", hexDecode("f800"), "cbor: invalid simple value 0 for type primitives", true},
|
||
|
|
{"Reserved two-byte encodings of simple types", hexDecode("f801"), "cbor: invalid simple value 1 for type primitives", true},
|
||
|
|
{"Reserved two-byte encodings of simple types", hexDecode("f818"), "cbor: invalid simple value 24 for type primitives", true},
|
||
|
|
{"Reserved two-byte encodings of simple types", hexDecode("f81f"), "cbor: invalid simple value 31 for type primitives", true},
|
||
|
|
{"Indefinite length string chunks not of the correct type", hexDecode("5f00ff"), "cbor: wrong element type positive integer for indefinite-length byte string", false},
|
||
|
|
{"Indefinite length string chunks not of the correct type", hexDecode("5f21ff"), "cbor: wrong element type negative integer for indefinite-length byte string", false},
|
||
|
|
{"Indefinite length string chunks not of the correct type", hexDecode("5f6100ff"), "cbor: wrong element type UTF-8 text string for indefinite-length byte string", false},
|
||
|
|
{"Indefinite length string chunks not of the correct type", hexDecode("5f80ff"), "cbor: wrong element type array for indefinite-length byte string", false},
|
||
|
|
{"Indefinite length string chunks not of the correct type", hexDecode("5fa0ff"), "cbor: wrong element type map for indefinite-length byte string", false},
|
||
|
|
{"Indefinite length string chunks not of the correct type", hexDecode("5fc000ff"), "cbor: wrong element type tag for indefinite-length byte string", false},
|
||
|
|
{"Indefinite length string chunks not of the correct type", hexDecode("5fe0ff"), "cbor: wrong element type primitives for indefinite-length byte string", false},
|
||
|
|
{"Indefinite length string chunks not of the correct type", hexDecode("7f4100ff"), "cbor: wrong element type byte string for indefinite-length UTF-8 text string", false},
|
||
|
|
{"Indefinite length string chunks not definite length", hexDecode("5f5f4100ffff"), "cbor: indefinite-length byte string chunk is not definite-length", false},
|
||
|
|
{"Indefinite length string chunks not definite length", hexDecode("7f7f6100ffff"), "cbor: indefinite-length UTF-8 text string chunk is not definite-length", false},
|
||
|
|
{"Break occurring on its own outside of an indefinite length item", hexDecode("ff"), "cbor: unexpected \"break\" code", true},
|
||
|
|
{"Break occurring in a definite length array or map or a tag", hexDecode("81ff"), "cbor: unexpected \"break\" code", true},
|
||
|
|
{"Break occurring in a definite length array or map or a tag", hexDecode("8200ff"), "cbor: unexpected \"break\" code", true},
|
||
|
|
{"Break occurring in a definite length array or map or a tag", hexDecode("a1ff"), "cbor: unexpected \"break\" code", true},
|
||
|
|
{"Break occurring in a definite length array or map or a tag", hexDecode("a1ff00"), "cbor: unexpected \"break\" code", true},
|
||
|
|
{"Break occurring in a definite length array or map or a tag", hexDecode("a100ff"), "cbor: unexpected \"break\" code", true},
|
||
|
|
{"Break occurring in a definite length array or map or a tag", hexDecode("a20000ff"), "cbor: unexpected \"break\" code", true},
|
||
|
|
{"Break occurring in a definite length array or map or a tag", hexDecode("9f81ff"), "cbor: unexpected \"break\" code", true},
|
||
|
|
{"Break occurring in a definite length array or map or a tag", hexDecode("9f829f819f9fffffffff"), "cbor: unexpected \"break\" code", true},
|
||
|
|
{"Break in indefinite length map would lead to odd number of items (break in a value position)", hexDecode("bf00ff"), "cbor: unexpected \"break\" code", true},
|
||
|
|
{"Break in indefinite length map would lead to odd number of items (break in a value position)", hexDecode("bf000000ff"), "cbor: unexpected \"break\" code", true},
|
||
|
|
{"Major type 0 with additional information 31", hexDecode("1f"), "cbor: invalid additional information 31 for type positive integer", true},
|
||
|
|
{"Major type 1 with additional information 31", hexDecode("3f"), "cbor: invalid additional information 31 for type negative integer", true},
|
||
|
|
{"Major type 6 with additional information 31", hexDecode("df"), "cbor: invalid additional information 31 for type tag", true},
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestInvalidCBORUnmarshal(t *testing.T) {
|
||
|
|
for _, tc := range invalidCBORUnmarshalTests {
|
||
|
|
t.Run(tc.name, func(t *testing.T) {
|
||
|
|
var i interface{}
|
||
|
|
err := Unmarshal(tc.cborData, &i)
|
||
|
|
if err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error", tc.cborData)
|
||
|
|
} else if !tc.errorMsgPartialMatch && err.Error() != tc.wantErrorMsg {
|
||
|
|
t.Errorf("Unmarshal(0x%x) error %q, want %q", tc.cborData, err.Error(), tc.wantErrorMsg)
|
||
|
|
} else if tc.errorMsgPartialMatch && !strings.Contains(err.Error(), tc.wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) error %q, want %q", tc.cborData, err.Error(), tc.wantErrorMsg)
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestInvalidUTF8TextString(t *testing.T) {
|
||
|
|
invalidUTF8TextStringTests := []struct {
|
||
|
|
name string
|
||
|
|
cborData []byte
|
||
|
|
wantErrorMsg string
|
||
|
|
}{
|
||
|
|
{"definite length text string", hexDecode("61fe"), invalidUTF8ErrorMsg},
|
||
|
|
{"indefinite length text string", hexDecode("7f62e6b061b4ff"), invalidUTF8ErrorMsg},
|
||
|
|
}
|
||
|
|
for _, tc := range invalidUTF8TextStringTests {
|
||
|
|
t.Run(tc.name, func(t *testing.T) {
|
||
|
|
var i interface{}
|
||
|
|
if err := Unmarshal(tc.cborData, &i); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error", tc.cborData)
|
||
|
|
} else if err.Error() != tc.wantErrorMsg {
|
||
|
|
t.Errorf("Unmarshal(0x%x) error %q, want %q", tc.cborData, err.Error(), tc.wantErrorMsg)
|
||
|
|
}
|
||
|
|
|
||
|
|
var s string
|
||
|
|
if err := Unmarshal(tc.cborData, &s); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error", tc.cborData)
|
||
|
|
} else if err.Error() != tc.wantErrorMsg {
|
||
|
|
t.Errorf("Unmarshal(0x%x) error %q, want %q", tc.cborData, err.Error(), tc.wantErrorMsg)
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
// Test decoding of mixed invalid text string and valid text string
|
||
|
|
cborData := hexDecode("7f62e6b061b4ff7f657374726561646d696e67ff")
|
||
|
|
dec := NewDecoder(bytes.NewReader(cborData))
|
||
|
|
var s string
|
||
|
|
if err := dec.Decode(&s); err == nil {
|
||
|
|
t.Errorf("Decode() didn't return an error")
|
||
|
|
} else if s != "" {
|
||
|
|
t.Errorf("Decode() returned %q, want %q", s, "")
|
||
|
|
}
|
||
|
|
if err := dec.Decode(&s); err != nil {
|
||
|
|
t.Errorf("Decode() returned error %v", err)
|
||
|
|
} else if s != "streaming" {
|
||
|
|
t.Errorf("Decode() returned %q, want %q", s, "streaming")
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalStruct(t *testing.T) {
|
||
|
|
want := outer{
|
||
|
|
IntField: 123,
|
||
|
|
FloatField: 100000.0,
|
||
|
|
BoolField: true,
|
||
|
|
StringField: "test",
|
||
|
|
ByteStringField: []byte{1, 3, 5},
|
||
|
|
ArrayField: []string{"hello", "world"},
|
||
|
|
MapField: map[string]bool{"morning": true, "afternoon": false},
|
||
|
|
NestedStructField: &inner{X: 1000, Y: 1000000},
|
||
|
|
unexportedField: 0,
|
||
|
|
}
|
||
|
|
|
||
|
|
tests := []struct {
|
||
|
|
name string
|
||
|
|
cborData []byte
|
||
|
|
want interface{}
|
||
|
|
}{
|
||
|
|
{"case-insensitive field name match", hexDecode("a868696e746669656c64187b6a666c6f61746669656c64fa47c3500069626f6f6c6669656c64f56b537472696e674669656c6464746573746f42797465537472696e674669656c64430103056a41727261794669656c64826568656c6c6f65776f726c64684d61704669656c64a2676d6f726e696e67f56961667465726e6f6f6ef4714e65737465645374727563744669656c64a261581903e861591a000f4240"), want},
|
||
|
|
{"exact field name match", hexDecode("a868496e744669656c64187b6a466c6f61744669656c64fa47c3500069426f6f6c4669656c64f56b537472696e674669656c6464746573746f42797465537472696e674669656c64430103056a41727261794669656c64826568656c6c6f65776f726c64684d61704669656c64a2676d6f726e696e67f56961667465726e6f6f6ef4714e65737465645374727563744669656c64a261581903e861591a000f4240"), want},
|
||
|
|
}
|
||
|
|
for _, tc := range tests {
|
||
|
|
t.Run(tc.name, func(t *testing.T) {
|
||
|
|
var v outer
|
||
|
|
if err := Unmarshal(tc.cborData, &v); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", tc.cborData, err)
|
||
|
|
} else if !reflect.DeepEqual(v, want) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", tc.cborData, v, v, want, want)
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalStructError1(t *testing.T) {
|
||
|
|
type outer2 struct {
|
||
|
|
IntField int
|
||
|
|
FloatField float32
|
||
|
|
BoolField bool
|
||
|
|
StringField string
|
||
|
|
ByteStringField []byte
|
||
|
|
ArrayField []int // wrong type
|
||
|
|
MapField map[string]bool
|
||
|
|
NestedStructField map[int]string // wrong type
|
||
|
|
unexportedField int64
|
||
|
|
}
|
||
|
|
want := outer2{
|
||
|
|
IntField: 123,
|
||
|
|
FloatField: 100000.0,
|
||
|
|
BoolField: true,
|
||
|
|
StringField: "test",
|
||
|
|
ByteStringField: []byte{1, 3, 5},
|
||
|
|
ArrayField: []int{0, 0},
|
||
|
|
MapField: map[string]bool{"morning": true, "afternoon": false},
|
||
|
|
NestedStructField: map[int]string{},
|
||
|
|
unexportedField: 0,
|
||
|
|
}
|
||
|
|
|
||
|
|
cborData := hexDecode("a868496e744669656c64187b6a466c6f61744669656c64fa47c3500069426f6f6c4669656c64f56b537472696e674669656c6464746573746f42797465537472696e674669656c64430103056a41727261794669656c64826568656c6c6f65776f726c64684d61704669656c64a2676d6f726e696e67f56961667465726e6f6f6ef4714e65737465645374727563744669656c64a261581903e861591a000f4240")
|
||
|
|
wantCBORType := "UTF-8 text string"
|
||
|
|
wantGoType := "int"
|
||
|
|
wantStructFieldName := "cbor.outer2.ArrayField"
|
||
|
|
wantErrorMsg := "cannot unmarshal UTF-8 text string into Go struct field cbor.outer2.ArrayField of type int"
|
||
|
|
|
||
|
|
var v outer2
|
||
|
|
if err := Unmarshal(cborData, &v); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error", cborData)
|
||
|
|
} else {
|
||
|
|
if typeError, ok := err.(*UnmarshalTypeError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned wrong type of error %T, want (*UnmarshalTypeError)", cborData, err)
|
||
|
|
} else {
|
||
|
|
if typeError.CBORType != wantCBORType {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned (*UnmarshalTypeError).CBORType %s, want %s", cborData, typeError.CBORType, wantCBORType)
|
||
|
|
}
|
||
|
|
if typeError.GoType != wantGoType {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned (*UnmarshalTypeError).GoType %s, want %s", cborData, typeError.GoType, wantGoType)
|
||
|
|
}
|
||
|
|
if typeError.StructFieldName != wantStructFieldName {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned (*UnmarshalTypeError).StructFieldName %s, want %s", cborData, typeError.StructFieldName, wantStructFieldName)
|
||
|
|
}
|
||
|
|
if !strings.Contains(err.Error(), wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing %q", cborData, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(v, want) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", cborData, v, v, want, want)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalStructError2(t *testing.T) {
|
||
|
|
// Unmarshal integer and invalid UTF8 string as field name into struct
|
||
|
|
type strc struct {
|
||
|
|
A string `cbor:"a"`
|
||
|
|
B string `cbor:"b"`
|
||
|
|
C string `cbor:"c"`
|
||
|
|
}
|
||
|
|
want := strc{
|
||
|
|
A: "A",
|
||
|
|
}
|
||
|
|
|
||
|
|
// Unmarshal returns first error encountered, which is *UnmarshalTypeError (failed to unmarshal int into Go string)
|
||
|
|
cborData := hexDecode("a3fa47c35000026161614161fe6142") // {100000.0:2, "a":"A", 0xfe: B}
|
||
|
|
wantCBORType := "primitives"
|
||
|
|
wantGoType := "string"
|
||
|
|
wantErrorMsg := "cannot unmarshal primitives into Go value of type string"
|
||
|
|
|
||
|
|
v := strc{}
|
||
|
|
if err := Unmarshal(cborData, &v); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error", cborData)
|
||
|
|
} else {
|
||
|
|
if typeError, ok := err.(*UnmarshalTypeError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned wrong type of error %T, want (*UnmarshalTypeError)", cborData, err)
|
||
|
|
} else {
|
||
|
|
if typeError.CBORType != wantCBORType {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned (*UnmarshalTypeError).CBORType %s, want %s", cborData, typeError.CBORType, wantCBORType)
|
||
|
|
}
|
||
|
|
if typeError.GoType != wantGoType {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned (*UnmarshalTypeError).GoType %s, want %s", cborData, typeError.GoType, wantGoType)
|
||
|
|
}
|
||
|
|
if !strings.Contains(err.Error(), wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing %q", cborData, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(v, want) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", cborData, v, v, want, want)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Unmarshal returns first error encountered, which is *cbor.SemanticError (invalid UTF8 string)
|
||
|
|
cborData = hexDecode("a361fe6142010261616141") // {0xfe: B, 1:2, "a":"A"}
|
||
|
|
v = strc{}
|
||
|
|
if err := Unmarshal(cborData, &v); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error", cborData)
|
||
|
|
} else {
|
||
|
|
if _, ok := err.(*SemanticError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned wrong type of error %T, want (*SemanticError)", cborData, err)
|
||
|
|
} else if err.Error() != invalidUTF8ErrorMsg {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error %q", cborData, err.Error(), invalidUTF8ErrorMsg)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(v, want) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", cborData, v, v, want, want)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Unmarshal returns first error encountered, which is *cbor.SemanticError (invalid UTF8 string)
|
||
|
|
cborData = hexDecode("a3616261fe010261616141") // {"b": 0xfe, 1:2, "a":"A"}
|
||
|
|
v = strc{}
|
||
|
|
if err := Unmarshal(cborData, &v); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error", cborData)
|
||
|
|
} else {
|
||
|
|
if _, ok := err.(*SemanticError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned wrong type of error %T, want (*SemanticError)", cborData, err)
|
||
|
|
} else if err.Error() != invalidUTF8ErrorMsg {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error %q", cborData, err.Error(), invalidUTF8ErrorMsg)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(v, want) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", cborData, v, v, want, want)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalPrefilledArray(t *testing.T) {
|
||
|
|
prefilledArr := []int{1, 2, 3, 4, 5}
|
||
|
|
want := []int{10, 11, 3, 4, 5}
|
||
|
|
cborData := hexDecode("820a0b") // []int{10, 11}
|
||
|
|
if err := Unmarshal(cborData, &prefilledArr); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
}
|
||
|
|
if len(prefilledArr) != 2 || cap(prefilledArr) != 5 {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (len %d, cap %d), want len == 2, cap == 5", cborData, prefilledArr, len(prefilledArr), cap(prefilledArr))
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(prefilledArr[:cap(prefilledArr)], want) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", cborData, prefilledArr, prefilledArr, want, want)
|
||
|
|
}
|
||
|
|
|
||
|
|
cborData = hexDecode("80") // empty array
|
||
|
|
if err := Unmarshal(cborData, &prefilledArr); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
}
|
||
|
|
if len(prefilledArr) != 0 || cap(prefilledArr) != 0 {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (len %d, cap %d), want len == 0, cap == 0", cborData, prefilledArr, len(prefilledArr), cap(prefilledArr))
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalPrefilledMap(t *testing.T) {
|
||
|
|
prefilledMap := map[string]string{"key": "value", "a": "1"}
|
||
|
|
want := map[string]string{"key": "value", "a": "A", "b": "B", "c": "C", "d": "D", "e": "E"}
|
||
|
|
cborData := hexDecode("a56161614161626142616361436164614461656145") // map[string]string{"a": "A", "b": "B", "c": "C", "d": "D", "e": "E"}
|
||
|
|
if err := Unmarshal(cborData, &prefilledMap); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(prefilledMap, want) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", cborData, prefilledMap, prefilledMap, want, want)
|
||
|
|
}
|
||
|
|
|
||
|
|
prefilledMap = map[string]string{"key": "value"}
|
||
|
|
want = map[string]string{"key": "value"}
|
||
|
|
cborData = hexDecode("a0") // map[string]string{}
|
||
|
|
if err := Unmarshal(cborData, &prefilledMap); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(prefilledMap, want) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", cborData, prefilledMap, prefilledMap, want, want)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalPrefilledStruct(t *testing.T) {
|
||
|
|
type s struct {
|
||
|
|
a int
|
||
|
|
B []int
|
||
|
|
C bool
|
||
|
|
}
|
||
|
|
prefilledStruct := s{a: 100, B: []int{200, 300, 400, 500}, C: true}
|
||
|
|
want := s{a: 100, B: []int{2, 3}, C: true}
|
||
|
|
cborData := hexDecode("a26161016162820203") // map[string]interface{} {"a": 1, "b": []int{2, 3}}
|
||
|
|
if err := Unmarshal(cborData, &prefilledStruct); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(prefilledStruct, want) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", cborData, prefilledStruct, prefilledStruct, want, want)
|
||
|
|
}
|
||
|
|
if len(prefilledStruct.B) != 2 || cap(prefilledStruct.B) != 4 {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (len %d, cap %d), want len == 2, cap == 5", cborData, prefilledStruct.B, len(prefilledStruct.B), cap(prefilledStruct.B))
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(prefilledStruct.B[:cap(prefilledStruct.B)], []int{2, 3, 400, 500}) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", cborData, prefilledStruct.B, prefilledStruct.B, []int{2, 3, 400, 500}, []int{2, 3, 400, 500})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestStructFieldNil(t *testing.T) {
|
||
|
|
type TestStruct struct {
|
||
|
|
I int
|
||
|
|
PI *int
|
||
|
|
PPI **int
|
||
|
|
}
|
||
|
|
var struc TestStruct
|
||
|
|
cborData, err := Marshal(struc)
|
||
|
|
if err != nil {
|
||
|
|
t.Fatalf("Marshal(%+v) returned error %v", struc, err)
|
||
|
|
}
|
||
|
|
var struc2 TestStruct
|
||
|
|
err = Unmarshal(cborData, &struc2)
|
||
|
|
if err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
} else if !reflect.DeepEqual(struc, struc2) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned %+v, want %+v", cborData, struc2, struc)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestLengthOverflowsInt(t *testing.T) {
|
||
|
|
// Data is generating by go-fuzz.
|
||
|
|
// string/slice/map length in uint64 cast to int causes integer overflow.
|
||
|
|
cborData := [][]byte{
|
||
|
|
hexDecode("bbcf30303030303030cfd697829782"),
|
||
|
|
hexDecode("5bcf30303030303030cfd697829782"),
|
||
|
|
}
|
||
|
|
wantErrorMsg := "is too large"
|
||
|
|
for _, data := range cborData {
|
||
|
|
var intf interface{}
|
||
|
|
if err := Unmarshal(data, &intf); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error, want error containing substring %q", data, wantErrorMsg)
|
||
|
|
} else if !strings.Contains(err.Error(), wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing substring %q", data, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestMapKeyUnhashable(t *testing.T) {
|
||
|
|
testCases := []struct {
|
||
|
|
name string
|
||
|
|
cborData []byte
|
||
|
|
wantErrorMsg string
|
||
|
|
}{
|
||
|
|
{"slice as map key", hexDecode("bf8030ff"), "cbor: invalid map key type: []interface {}"}, // {[]: -17}
|
||
|
|
{"slice as map key", hexDecode("a1813030"), "cbor: invalid map key type: []interface {}"}, // {[-17]: -17}
|
||
|
|
{"slice as map key", hexDecode("bfd1a388f730303030303030303030303030ff"), "cbor: invalid map key type: []interface {}"}, // {17({[undefined, -17, -17, -17, -17, -17, -17, -17]: -17, -17: -17}): -17}}
|
||
|
|
{"byte slice as map key", hexDecode("8f3030a730304430303030303030303030303030303030303030303030303030303030"), "cbor: invalid map key type: []uint8"}, // [-17, -17, {-17: -17, h'30303030': -17}, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17]
|
||
|
|
{"map as map key", hexDecode("bf30a1a030ff"), "cbor: invalid map key type: map"}, // {-17: {{}: -17}}, empty map as map key
|
||
|
|
{"map as map key", hexDecode("bfb0303030303030303030303030303030303030303030303030303030303030303030ff"), "cbor: invalid map key type: map"}, // {{-17: -17}: -17}, map as key
|
||
|
|
{"tagged slice as map key", hexDecode("a1c84c30303030303030303030303030"), "cbor: invalid map key type: cbor.Tag"}, // {8(h'303030303030303030303030'): -17}
|
||
|
|
{"nested-tagged slice as map key", hexDecode("a33030306430303030d1cb4030"), "cbor: invalid map key type: cbor.Tag"}, // {-17: "0000", 17(11(h'')): -17}
|
||
|
|
{"big.Int as map key", hexDecode("a13bbd3030303030303030"), "cbor: invalid map key type: big.Int"}, // {-13632449055575519281: -17}
|
||
|
|
{"tagged big.Int as map key", hexDecode("a1c24901000000000000000030"), "cbor: invalid map key type: big.Int"}, // {18446744073709551616: -17}
|
||
|
|
{"tagged big.Int as map key", hexDecode("a1c34901000000000000000030"), "cbor: invalid map key type: big.Int"}, //{-18446744073709551617: -17}
|
||
|
|
}
|
||
|
|
for _, tc := range testCases {
|
||
|
|
t.Run(tc.name, func(t *testing.T) {
|
||
|
|
var v interface{}
|
||
|
|
if err := Unmarshal(tc.cborData, &v); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error, want %q", tc.cborData, tc.wantErrorMsg)
|
||
|
|
} else if !strings.Contains(err.Error(), tc.wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want %q", tc.cborData, err.Error(), tc.wantErrorMsg)
|
||
|
|
}
|
||
|
|
if _, ok := v.(map[interface{}]interface{}); ok {
|
||
|
|
var v map[interface{}]interface{}
|
||
|
|
if err := Unmarshal(tc.cborData, &v); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error, want %q", tc.cborData, tc.wantErrorMsg)
|
||
|
|
} else if !strings.Contains(err.Error(), tc.wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want %q", tc.cborData, err.Error(), tc.wantErrorMsg)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestMapKeyNaN(t *testing.T) {
|
||
|
|
// Data is generating by go-fuzz.
|
||
|
|
cborData := hexDecode("b0303030303030303030303030303030303038303030faffff30303030303030303030303030") // {-17: -17, NaN: -17}
|
||
|
|
var intf interface{}
|
||
|
|
if err := Unmarshal(cborData, &intf); err != nil {
|
||
|
|
t.Fatalf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
}
|
||
|
|
em, err := EncOptions{Sort: SortCanonical}.EncMode()
|
||
|
|
if err != nil {
|
||
|
|
t.Errorf("EncMode() returned an error %v", err)
|
||
|
|
}
|
||
|
|
if _, err := em.Marshal(intf); err != nil {
|
||
|
|
t.Errorf("Marshal(%v) returned error %v", intf, err)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalUndefinedElement(t *testing.T) {
|
||
|
|
// Data is generating by go-fuzz.
|
||
|
|
cborData := hexDecode("bfd1a388f730303030303030303030303030ff") // {17({[undefined, -17, -17, -17, -17, -17, -17, -17]: -17, -17: -17}): -17}
|
||
|
|
var intf interface{}
|
||
|
|
wantErrorMsg := "invalid map key type"
|
||
|
|
if err := Unmarshal(cborData, &intf); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error, want error containing substring %q", cborData, wantErrorMsg)
|
||
|
|
} else if !strings.Contains(err.Error(), wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing substring %q", cborData, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestMapKeyNil(t *testing.T) {
|
||
|
|
testData := [][]byte{
|
||
|
|
hexDecode("a1f630"), // {null: -17}
|
||
|
|
}
|
||
|
|
want := map[interface{}]interface{}{nil: int64(-17)}
|
||
|
|
for _, data := range testData {
|
||
|
|
var intf interface{}
|
||
|
|
if err := Unmarshal(data, &intf); err != nil {
|
||
|
|
t.Fatalf("Unmarshal(0x%x) returned error %v", data, err)
|
||
|
|
} else if !reflect.DeepEqual(intf, want) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned %+v, want %+v", data, intf, want)
|
||
|
|
}
|
||
|
|
if _, err := Marshal(intf); err != nil {
|
||
|
|
t.Errorf("Marshal(%v) returned error %v", intf, err)
|
||
|
|
}
|
||
|
|
|
||
|
|
var v map[interface{}]interface{}
|
||
|
|
if err := Unmarshal(data, &v); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", data, err)
|
||
|
|
} else if !reflect.DeepEqual(v, want) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned %+v, want %+v", data, v, want)
|
||
|
|
}
|
||
|
|
if _, err := Marshal(v); err != nil {
|
||
|
|
t.Errorf("Marshal(%v) returned error %v", v, err)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestDecodeTime(t *testing.T) {
|
||
|
|
testCases := []struct {
|
||
|
|
name string
|
||
|
|
cborRFC3339Time []byte
|
||
|
|
cborUnixTime []byte
|
||
|
|
wantTime time.Time
|
||
|
|
}{
|
||
|
|
// Decoding CBOR null/defined to time.Time is no-op. See TestUnmarshalNil.
|
||
|
|
{
|
||
|
|
name: "NaN",
|
||
|
|
cborRFC3339Time: hexDecode("f97e00"),
|
||
|
|
cborUnixTime: hexDecode("f97e00"),
|
||
|
|
wantTime: time.Time{},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "positive infinity",
|
||
|
|
cborRFC3339Time: hexDecode("f97c00"),
|
||
|
|
cborUnixTime: hexDecode("f97c00"),
|
||
|
|
wantTime: time.Time{},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "negative infinity",
|
||
|
|
cborRFC3339Time: hexDecode("f9fc00"),
|
||
|
|
cborUnixTime: hexDecode("f9fc00"),
|
||
|
|
wantTime: time.Time{},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "time without fractional seconds", // positive integer
|
||
|
|
cborRFC3339Time: hexDecode("74323031332d30332d32315432303a30343a30305a"),
|
||
|
|
cborUnixTime: hexDecode("1a514b67b0"),
|
||
|
|
wantTime: parseTime(time.RFC3339Nano, "2013-03-21T20:04:00Z"),
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "time with fractional seconds", // float
|
||
|
|
cborRFC3339Time: hexDecode("7819313937302d30312d30315432313a34363a34302d30363a3030"),
|
||
|
|
cborUnixTime: hexDecode("fa47c35000"),
|
||
|
|
wantTime: parseTime(time.RFC3339Nano, "1970-01-01T21:46:40-06:00"),
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "time with fractional seconds", // float
|
||
|
|
cborRFC3339Time: hexDecode("76323031332d30332d32315432303a30343a30302e355a"),
|
||
|
|
cborUnixTime: hexDecode("fb41d452d9ec200000"),
|
||
|
|
wantTime: parseTime(time.RFC3339Nano, "2013-03-21T20:04:00.5Z"),
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "time before January 1, 1970 UTC without fractional seconds", // negative integer
|
||
|
|
cborRFC3339Time: hexDecode("74313936392d30332d32315432303a30343a30305a"),
|
||
|
|
cborUnixTime: hexDecode("3a0177f2cf"),
|
||
|
|
wantTime: parseTime(time.RFC3339Nano, "1969-03-21T20:04:00Z"),
|
||
|
|
},
|
||
|
|
}
|
||
|
|
for _, tc := range testCases {
|
||
|
|
t.Run(tc.name, func(t *testing.T) {
|
||
|
|
tm := time.Now()
|
||
|
|
if err := Unmarshal(tc.cborRFC3339Time, &tm); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", tc.cborRFC3339Time, err)
|
||
|
|
} else if !tc.wantTime.Equal(tm) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", tc.cborRFC3339Time, tm, tm, tc.wantTime, tc.wantTime)
|
||
|
|
}
|
||
|
|
tm = time.Now()
|
||
|
|
if err := Unmarshal(tc.cborUnixTime, &tm); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", tc.cborUnixTime, err)
|
||
|
|
} else if !tc.wantTime.Equal(tm) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", tc.cborUnixTime, tm, tm, tc.wantTime, tc.wantTime)
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestDecodeTimeWithTag(t *testing.T) {
|
||
|
|
testCases := []struct {
|
||
|
|
name string
|
||
|
|
cborRFC3339Time []byte
|
||
|
|
cborUnixTime []byte
|
||
|
|
wantTime time.Time
|
||
|
|
}{
|
||
|
|
{
|
||
|
|
name: "time without fractional seconds", // positive integer
|
||
|
|
cborRFC3339Time: hexDecode("c074323031332d30332d32315432303a30343a30305a"),
|
||
|
|
cborUnixTime: hexDecode("c11a514b67b0"),
|
||
|
|
wantTime: parseTime(time.RFC3339Nano, "2013-03-21T20:04:00Z"),
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "time with fractional seconds", // float
|
||
|
|
cborRFC3339Time: hexDecode("c076323031332d30332d32315432303a30343a30302e355a"),
|
||
|
|
cborUnixTime: hexDecode("c1fb41d452d9ec200000"),
|
||
|
|
wantTime: parseTime(time.RFC3339Nano, "2013-03-21T20:04:00.5Z"),
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "time before January 1, 1970 UTC without fractional seconds", // negative integer
|
||
|
|
cborRFC3339Time: hexDecode("c074313936392d30332d32315432303a30343a30305a"),
|
||
|
|
cborUnixTime: hexDecode("c13a0177f2cf"),
|
||
|
|
wantTime: parseTime(time.RFC3339Nano, "1969-03-21T20:04:00Z"),
|
||
|
|
},
|
||
|
|
}
|
||
|
|
for _, tc := range testCases {
|
||
|
|
t.Run(tc.name, func(t *testing.T) {
|
||
|
|
tm := time.Now()
|
||
|
|
if err := Unmarshal(tc.cborRFC3339Time, &tm); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", tc.cborRFC3339Time, err)
|
||
|
|
} else if !tc.wantTime.Equal(tm) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", tc.cborRFC3339Time, tm, tm, tc.wantTime, tc.wantTime)
|
||
|
|
}
|
||
|
|
tm = time.Now()
|
||
|
|
if err := Unmarshal(tc.cborUnixTime, &tm); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", tc.cborUnixTime, err)
|
||
|
|
} else if !tc.wantTime.Equal(tm) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", tc.cborUnixTime, tm, tm, tc.wantTime, tc.wantTime)
|
||
|
|
}
|
||
|
|
|
||
|
|
var v interface{}
|
||
|
|
if err := Unmarshal(tc.cborRFC3339Time, &v); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", tc.cborRFC3339Time, err)
|
||
|
|
} else if tm, ok := v.(time.Time); !ok || !tc.wantTime.Equal(tm) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", tc.cborRFC3339Time, v, v, tc.wantTime, tc.wantTime)
|
||
|
|
}
|
||
|
|
v = nil
|
||
|
|
if err := Unmarshal(tc.cborUnixTime, &v); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", tc.cborUnixTime, err)
|
||
|
|
} else if tm, ok := v.(time.Time); !ok || !tc.wantTime.Equal(tm) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", tc.cborUnixTime, v, v, tc.wantTime, tc.wantTime)
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestDecodeTimeError(t *testing.T) {
|
||
|
|
testCases := []struct {
|
||
|
|
name string
|
||
|
|
cborData []byte
|
||
|
|
wantErrorMsg string
|
||
|
|
}{
|
||
|
|
{
|
||
|
|
name: "invalid RFC3339 time string",
|
||
|
|
cborData: hexDecode("7f657374726561646d696e67ff"),
|
||
|
|
wantErrorMsg: "cbor: cannot set streaming for time.Time",
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "byte string data cannot be decoded into time.Time",
|
||
|
|
cborData: hexDecode("4f013030303030303030e03031ed3030"),
|
||
|
|
wantErrorMsg: "cbor: cannot unmarshal byte string into Go value of type time.Time",
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "bool cannot be decoded into time.Time",
|
||
|
|
cborData: hexDecode("f4"),
|
||
|
|
wantErrorMsg: "cbor: cannot unmarshal primitives into Go value of type time.Time",
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "invalid UTF-8 string",
|
||
|
|
cborData: hexDecode("7f62e6b061b4ff"),
|
||
|
|
wantErrorMsg: "cbor: invalid UTF-8 string",
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "negative integer overflow",
|
||
|
|
cborData: hexDecode("3bffffffffffffffff"),
|
||
|
|
wantErrorMsg: "cbor: cannot unmarshal negative integer into Go value of type time.Time",
|
||
|
|
},
|
||
|
|
}
|
||
|
|
for _, tc := range testCases {
|
||
|
|
t.Run(tc.name, func(t *testing.T) {
|
||
|
|
tm := time.Now()
|
||
|
|
if err := Unmarshal(tc.cborData, &tm); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error, want error msg %q", tc.cborData, tc.wantErrorMsg)
|
||
|
|
} else if !strings.Contains(err.Error(), tc.wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want %q", tc.cborData, err.Error(), tc.wantErrorMsg)
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestDecodeInvalidTagTime(t *testing.T) {
|
||
|
|
typeTimeSlice := reflect.TypeOf([]time.Time{})
|
||
|
|
|
||
|
|
testCases := []struct {
|
||
|
|
name string
|
||
|
|
cborData []byte
|
||
|
|
decodeToTypes []reflect.Type
|
||
|
|
wantErrorMsg string
|
||
|
|
}{
|
||
|
|
{
|
||
|
|
name: "Tag 0 with invalid RFC3339 time string",
|
||
|
|
cborData: hexDecode("c07f657374726561646d696e67ff"),
|
||
|
|
decodeToTypes: []reflect.Type{typeIntf, typeTime},
|
||
|
|
wantErrorMsg: "cbor: cannot set streaming for time.Time",
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "Tag 0 with invalid UTF-8 string",
|
||
|
|
cborData: hexDecode("c07f62e6b061b4ff"),
|
||
|
|
decodeToTypes: []reflect.Type{typeIntf, typeTime},
|
||
|
|
wantErrorMsg: "cbor: invalid UTF-8 string",
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "Tag 0 with integer content",
|
||
|
|
cborData: hexDecode("c01a514b67b0"),
|
||
|
|
decodeToTypes: []reflect.Type{typeIntf, typeTime},
|
||
|
|
wantErrorMsg: "cbor: tag number 0 must be followed by text string, got positive integer",
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "Tag 0 with byte string content",
|
||
|
|
cborData: hexDecode("c04f013030303030303030e03031ed3030"),
|
||
|
|
decodeToTypes: []reflect.Type{typeIntf, typeTime},
|
||
|
|
wantErrorMsg: "cbor: tag number 0 must be followed by text string, got byte string",
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "Tag 0 with integer content as array element",
|
||
|
|
cborData: hexDecode("81c01a514b67b0"),
|
||
|
|
decodeToTypes: []reflect.Type{typeIntf, typeTimeSlice},
|
||
|
|
wantErrorMsg: "cbor: tag number 0 must be followed by text string, got positive integer",
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "Tag 1 with negative integer overflow",
|
||
|
|
cborData: hexDecode("c13bffffffffffffffff"),
|
||
|
|
decodeToTypes: []reflect.Type{typeIntf, typeTime},
|
||
|
|
wantErrorMsg: "cbor: cannot unmarshal tag into Go value of type time.Time",
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "Tag 1 with string content",
|
||
|
|
cborData: hexDecode("c174323031332d30332d32315432303a30343a30305a"),
|
||
|
|
decodeToTypes: []reflect.Type{typeIntf, typeTime},
|
||
|
|
wantErrorMsg: "cbor: tag number 1 must be followed by integer or floating-point number, got UTF-8 text string",
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "Tag 1 with simple value",
|
||
|
|
cborData: hexDecode("d801f6"), // 1(null)
|
||
|
|
decodeToTypes: []reflect.Type{typeIntf, typeTime},
|
||
|
|
wantErrorMsg: "cbor: tag number 1 must be followed by integer or floating-point number, got primitive",
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "Tag 1 with string content as array element",
|
||
|
|
cborData: hexDecode("81c174323031332d30332d32315432303a30343a30305a"),
|
||
|
|
decodeToTypes: []reflect.Type{typeIntf, typeTimeSlice},
|
||
|
|
wantErrorMsg: "cbor: tag number 1 must be followed by integer or floating-point number, got UTF-8 text string",
|
||
|
|
},
|
||
|
|
}
|
||
|
|
dm, _ := DecOptions{TimeTag: DecTagOptional}.DecMode()
|
||
|
|
for _, tc := range testCases {
|
||
|
|
for _, decodeToType := range tc.decodeToTypes {
|
||
|
|
t.Run(tc.name+" decode to "+decodeToType.String(), func(t *testing.T) {
|
||
|
|
v := reflect.New(decodeToType)
|
||
|
|
if err := dm.Unmarshal(tc.cborData, v.Interface()); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return error, want error msg %q", tc.cborData, tc.wantErrorMsg)
|
||
|
|
} else if !strings.Contains(err.Error(), tc.wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want %q", tc.cborData, err, tc.wantErrorMsg)
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestDecodeTag0Error(t *testing.T) {
|
||
|
|
cborData := hexDecode("c01a514b67b0") // 0(1363896240)
|
||
|
|
wantErrorMsg := "cbor: tag number 0 must be followed by text string, got positive integer"
|
||
|
|
|
||
|
|
timeTagIgnoredDM, _ := DecOptions{TimeTag: DecTagIgnored}.DecMode()
|
||
|
|
timeTagOptionalDM, _ := DecOptions{TimeTag: DecTagOptional}.DecMode()
|
||
|
|
timeTagRequiredDM, _ := DecOptions{TimeTag: DecTagRequired}.DecMode()
|
||
|
|
|
||
|
|
testCases := []struct {
|
||
|
|
name string
|
||
|
|
dm DecMode
|
||
|
|
}{
|
||
|
|
{name: "DecTagIgnored", dm: timeTagIgnoredDM},
|
||
|
|
{name: "DecTagOptional", dm: timeTagOptionalDM},
|
||
|
|
{name: "DecTagRequired", dm: timeTagRequiredDM},
|
||
|
|
}
|
||
|
|
|
||
|
|
for _, tc := range testCases {
|
||
|
|
t.Run(tc.name, func(t *testing.T) {
|
||
|
|
// Decode to interface{}
|
||
|
|
var v interface{}
|
||
|
|
if err := tc.dm.Unmarshal(cborData, &v); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return error, want error msg %q", cborData, wantErrorMsg)
|
||
|
|
} else if !strings.Contains(err.Error(), wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want %q", cborData, err, wantErrorMsg)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Decode to time.Time
|
||
|
|
var tm time.Time
|
||
|
|
if err := tc.dm.Unmarshal(cborData, &tm); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return error, want error msg %q", cborData, wantErrorMsg)
|
||
|
|
} else if !strings.Contains(err.Error(), wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want %q", cborData, err, wantErrorMsg)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Decode to uint64
|
||
|
|
var ui uint64
|
||
|
|
if err := tc.dm.Unmarshal(cborData, &ui); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return error, want error msg %q", cborData, wantErrorMsg)
|
||
|
|
} else if !strings.Contains(err.Error(), wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want %q", cborData, err, wantErrorMsg)
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestDecodeTag1Error(t *testing.T) {
|
||
|
|
cborData := hexDecode("c174323031332d30332d32315432303a30343a30305a") // 1("2013-03-21T20:04:00Z")
|
||
|
|
wantErrorMsg := "cbor: tag number 1 must be followed by integer or floating-point number, got UTF-8 text string"
|
||
|
|
|
||
|
|
timeTagIgnoredDM, _ := DecOptions{TimeTag: DecTagIgnored}.DecMode()
|
||
|
|
timeTagOptionalDM, _ := DecOptions{TimeTag: DecTagOptional}.DecMode()
|
||
|
|
timeTagRequiredDM, _ := DecOptions{TimeTag: DecTagRequired}.DecMode()
|
||
|
|
|
||
|
|
testCases := []struct {
|
||
|
|
name string
|
||
|
|
dm DecMode
|
||
|
|
}{
|
||
|
|
{name: "DecTagIgnored", dm: timeTagIgnoredDM},
|
||
|
|
{name: "DecTagOptional", dm: timeTagOptionalDM},
|
||
|
|
{name: "DecTagRequired", dm: timeTagRequiredDM},
|
||
|
|
}
|
||
|
|
|
||
|
|
for _, tc := range testCases {
|
||
|
|
t.Run(tc.name, func(t *testing.T) {
|
||
|
|
// Decode to interface{}
|
||
|
|
var v interface{}
|
||
|
|
if err := tc.dm.Unmarshal(cborData, &v); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return error, want error msg %q", cborData, wantErrorMsg)
|
||
|
|
} else if !strings.Contains(err.Error(), wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want %q", cborData, err, wantErrorMsg)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Decode to time.Time
|
||
|
|
var tm time.Time
|
||
|
|
if err := tc.dm.Unmarshal(cborData, &tm); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return error, want error msg %q", cborData, wantErrorMsg)
|
||
|
|
} else if !strings.Contains(err.Error(), wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want %q", cborData, err, wantErrorMsg)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Decode to string
|
||
|
|
var s string
|
||
|
|
if err := tc.dm.Unmarshal(cborData, &s); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return error, want error msg %q", cborData, wantErrorMsg)
|
||
|
|
} else if !strings.Contains(err.Error(), wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want %q", cborData, err, wantErrorMsg)
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestDecodeTimeStreaming(t *testing.T) {
|
||
|
|
// Decoder decodes from mixed invalid and valid time.
|
||
|
|
testCases := []struct {
|
||
|
|
cborData []byte
|
||
|
|
wantErrorMsg string
|
||
|
|
wantObj time.Time
|
||
|
|
}{
|
||
|
|
{
|
||
|
|
cborData: hexDecode("c07f62e6b061b4ff"),
|
||
|
|
wantErrorMsg: "cbor: invalid UTF-8 string",
|
||
|
|
},
|
||
|
|
{
|
||
|
|
cborData: hexDecode("c074323031332d30332d32315432303a30343a30305a"),
|
||
|
|
wantObj: time.Date(2013, 3, 21, 20, 4, 0, 0, time.UTC),
|
||
|
|
},
|
||
|
|
{
|
||
|
|
cborData: hexDecode("c01a514b67b0"),
|
||
|
|
wantErrorMsg: "cbor: tag number 0 must be followed by text string, got positive integer",
|
||
|
|
},
|
||
|
|
{
|
||
|
|
cborData: hexDecode("c074323031332d30332d32315432303a30343a30305a"),
|
||
|
|
wantObj: time.Date(2013, 3, 21, 20, 4, 0, 0, time.UTC),
|
||
|
|
},
|
||
|
|
{
|
||
|
|
cborData: hexDecode("c13bffffffffffffffff"),
|
||
|
|
wantErrorMsg: "cbor: cannot unmarshal tag into Go value of type time.Time",
|
||
|
|
},
|
||
|
|
{
|
||
|
|
cborData: hexDecode("c11a514b67b0"),
|
||
|
|
wantObj: time.Date(2013, 3, 21, 20, 4, 0, 0, time.UTC),
|
||
|
|
},
|
||
|
|
{
|
||
|
|
cborData: hexDecode("c174323031332d30332d32315432303a30343a30305a"),
|
||
|
|
wantErrorMsg: "tag number 1 must be followed by integer or floating-point number, got UTF-8 text string",
|
||
|
|
},
|
||
|
|
{
|
||
|
|
cborData: hexDecode("c11a514b67b0"),
|
||
|
|
wantObj: time.Date(2013, 3, 21, 20, 4, 0, 0, time.UTC),
|
||
|
|
},
|
||
|
|
}
|
||
|
|
// Data is a mixed stream of valid and invalid time data
|
||
|
|
var cborData []byte
|
||
|
|
for _, tc := range testCases {
|
||
|
|
cborData = append(cborData, tc.cborData...)
|
||
|
|
}
|
||
|
|
dm, _ := DecOptions{TimeTag: DecTagOptional}.DecMode()
|
||
|
|
dec := dm.NewDecoder(bytes.NewReader(cborData))
|
||
|
|
for _, tc := range testCases {
|
||
|
|
var v interface{}
|
||
|
|
err := dec.Decode(&v)
|
||
|
|
if tc.wantErrorMsg != "" {
|
||
|
|
if err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return error, want error msg %q", tc.cborData, tc.wantErrorMsg)
|
||
|
|
} else if !strings.Contains(err.Error(), tc.wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error msg %q, want %q", tc.cborData, err, tc.wantErrorMsg)
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
tm, ok := v.(time.Time)
|
||
|
|
if !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned %s (%T), want time.Time", tc.cborData, v, v)
|
||
|
|
}
|
||
|
|
if !tc.wantObj.Equal(tm) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned %s, want %s", tc.cborData, tm, tc.wantObj)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
dec = dm.NewDecoder(bytes.NewReader(cborData))
|
||
|
|
for _, tc := range testCases {
|
||
|
|
var tm time.Time
|
||
|
|
err := dec.Decode(&tm)
|
||
|
|
if tc.wantErrorMsg != "" {
|
||
|
|
if err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) did't return error, want error msg %q", tc.cborData, tc.wantErrorMsg)
|
||
|
|
} else if !strings.Contains(err.Error(), tc.wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error msg %q, want %q", tc.cborData, err, tc.wantErrorMsg)
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if !tc.wantObj.Equal(tm) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned %s, want %s", tc.cborData, tm, tc.wantObj)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestDecTimeTagOption(t *testing.T) {
|
||
|
|
timeTagIgnoredDecMode, _ := DecOptions{TimeTag: DecTagIgnored}.DecMode()
|
||
|
|
timeTagOptionalDecMode, _ := DecOptions{TimeTag: DecTagOptional}.DecMode()
|
||
|
|
timeTagRequiredDecMode, _ := DecOptions{TimeTag: DecTagRequired}.DecMode()
|
||
|
|
|
||
|
|
testCases := []struct {
|
||
|
|
name string
|
||
|
|
cborRFC3339Time []byte
|
||
|
|
cborUnixTime []byte
|
||
|
|
decMode DecMode
|
||
|
|
wantTime time.Time
|
||
|
|
wantErrorMsg string
|
||
|
|
}{
|
||
|
|
// not-tagged time CBOR data
|
||
|
|
{
|
||
|
|
name: "not-tagged data with DecTagIgnored option",
|
||
|
|
cborRFC3339Time: hexDecode("74323031332d30332d32315432303a30343a30305a"),
|
||
|
|
cborUnixTime: hexDecode("1a514b67b0"),
|
||
|
|
decMode: timeTagIgnoredDecMode,
|
||
|
|
wantTime: parseTime(time.RFC3339Nano, "2013-03-21T20:04:00Z"),
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "not-tagged data with timeTagOptionalDecMode option",
|
||
|
|
cborRFC3339Time: hexDecode("74323031332d30332d32315432303a30343a30305a"),
|
||
|
|
cborUnixTime: hexDecode("1a514b67b0"),
|
||
|
|
decMode: timeTagOptionalDecMode,
|
||
|
|
wantTime: parseTime(time.RFC3339Nano, "2013-03-21T20:04:00Z"),
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "not-tagged data with timeTagRequiredDecMode option",
|
||
|
|
cborRFC3339Time: hexDecode("74323031332d30332d32315432303a30343a30305a"),
|
||
|
|
cborUnixTime: hexDecode("1a514b67b0"),
|
||
|
|
decMode: timeTagRequiredDecMode,
|
||
|
|
wantErrorMsg: "expect CBOR tag value",
|
||
|
|
},
|
||
|
|
// tagged time CBOR data
|
||
|
|
{
|
||
|
|
name: "tagged data with timeTagIgnoredDecMode option",
|
||
|
|
cborRFC3339Time: hexDecode("c074323031332d30332d32315432303a30343a30305a"),
|
||
|
|
cborUnixTime: hexDecode("c11a514b67b0"),
|
||
|
|
decMode: timeTagIgnoredDecMode,
|
||
|
|
wantTime: parseTime(time.RFC3339Nano, "2013-03-21T20:04:00Z"),
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "tagged data with timeTagOptionalDecMode option",
|
||
|
|
cborRFC3339Time: hexDecode("c074323031332d30332d32315432303a30343a30305a"),
|
||
|
|
cborUnixTime: hexDecode("c11a514b67b0"),
|
||
|
|
decMode: timeTagOptionalDecMode,
|
||
|
|
wantTime: parseTime(time.RFC3339Nano, "2013-03-21T20:04:00Z"),
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "tagged data with timeTagRequiredDecMode option",
|
||
|
|
cborRFC3339Time: hexDecode("c074323031332d30332d32315432303a30343a30305a"),
|
||
|
|
cborUnixTime: hexDecode("c11a514b67b0"),
|
||
|
|
decMode: timeTagRequiredDecMode,
|
||
|
|
wantTime: parseTime(time.RFC3339Nano, "2013-03-21T20:04:00Z"),
|
||
|
|
},
|
||
|
|
// mis-tagged time CBOR data
|
||
|
|
{
|
||
|
|
name: "mis-tagged data with timeTagIgnoredDecMode option",
|
||
|
|
cborRFC3339Time: hexDecode("c8c974323031332d30332d32315432303a30343a30305a"),
|
||
|
|
cborUnixTime: hexDecode("c8c91a514b67b0"),
|
||
|
|
decMode: timeTagIgnoredDecMode,
|
||
|
|
wantTime: parseTime(time.RFC3339Nano, "2013-03-21T20:04:00Z"),
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "mis-tagged data with timeTagOptionalDecMode option",
|
||
|
|
cborRFC3339Time: hexDecode("c8c974323031332d30332d32315432303a30343a30305a"),
|
||
|
|
cborUnixTime: hexDecode("c8c91a514b67b0"),
|
||
|
|
decMode: timeTagOptionalDecMode,
|
||
|
|
wantErrorMsg: "cbor: wrong tag number for time.Time, got 8, expect 0 or 1",
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "mis-tagged data with timeTagRequiredDecMode option",
|
||
|
|
cborRFC3339Time: hexDecode("c8c974323031332d30332d32315432303a30343a30305a"),
|
||
|
|
cborUnixTime: hexDecode("c8c91a514b67b0"),
|
||
|
|
decMode: timeTagRequiredDecMode,
|
||
|
|
wantErrorMsg: "cbor: wrong tag number for time.Time, got 8, expect 0 or 1",
|
||
|
|
},
|
||
|
|
}
|
||
|
|
for _, tc := range testCases {
|
||
|
|
t.Run(tc.name, func(t *testing.T) {
|
||
|
|
tm := time.Now()
|
||
|
|
err := tc.decMode.Unmarshal(tc.cborRFC3339Time, &tm)
|
||
|
|
if tc.wantErrorMsg != "" {
|
||
|
|
if err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return error", tc.cborRFC3339Time)
|
||
|
|
} else if !strings.Contains(err.Error(), tc.wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing %q", tc.cborRFC3339Time, err.Error(), tc.wantErrorMsg)
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if !tc.wantTime.Equal(tm) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", tc.cborRFC3339Time, tm, tm, tc.wantTime, tc.wantTime)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
tm = time.Now()
|
||
|
|
err = tc.decMode.Unmarshal(tc.cborUnixTime, &tm)
|
||
|
|
if tc.wantErrorMsg != "" {
|
||
|
|
if err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return error", tc.cborRFC3339Time)
|
||
|
|
} else if !strings.Contains(err.Error(), tc.wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing %q", tc.cborRFC3339Time, err.Error(), tc.wantErrorMsg)
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if !tc.wantTime.Equal(tm) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", tc.cborRFC3339Time, tm, tm, tc.wantTime, tc.wantTime)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalStructTag1(t *testing.T) {
|
||
|
|
type strc struct {
|
||
|
|
A string `cbor:"a"`
|
||
|
|
B string `cbor:"b"`
|
||
|
|
C string `cbor:"c"`
|
||
|
|
}
|
||
|
|
want := strc{
|
||
|
|
A: "A",
|
||
|
|
B: "B",
|
||
|
|
C: "C",
|
||
|
|
}
|
||
|
|
cborData := hexDecode("a3616161416162614261636143") // {"a":"A", "b":"B", "c":"C"}
|
||
|
|
|
||
|
|
var v strc
|
||
|
|
if err := Unmarshal(cborData, &v); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(v, want) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", cborData, v, v, want, want)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalStructTag2(t *testing.T) {
|
||
|
|
type strc struct {
|
||
|
|
A string `json:"a"`
|
||
|
|
B string `json:"b"`
|
||
|
|
C string `json:"c"`
|
||
|
|
}
|
||
|
|
want := strc{
|
||
|
|
A: "A",
|
||
|
|
B: "B",
|
||
|
|
C: "C",
|
||
|
|
}
|
||
|
|
cborData := hexDecode("a3616161416162614261636143") // {"a":"A", "b":"B", "c":"C"}
|
||
|
|
|
||
|
|
var v strc
|
||
|
|
if err := Unmarshal(cborData, &v); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(v, want) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", cborData, v, v, want, want)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalStructTag3(t *testing.T) {
|
||
|
|
type strc struct {
|
||
|
|
A string `json:"x" cbor:"a"`
|
||
|
|
B string `json:"y" cbor:"b"`
|
||
|
|
C string `json:"z"`
|
||
|
|
}
|
||
|
|
want := strc{
|
||
|
|
A: "A",
|
||
|
|
B: "B",
|
||
|
|
C: "C",
|
||
|
|
}
|
||
|
|
cborData := hexDecode("a36161614161626142617a6143") // {"a":"A", "b":"B", "z":"C"}
|
||
|
|
|
||
|
|
var v strc
|
||
|
|
if err := Unmarshal(cborData, &v); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(v, want) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %+v (%T), want %+v (%T)", cborData, v, v, want, want)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalStructTag4(t *testing.T) {
|
||
|
|
type strc struct {
|
||
|
|
A string `json:"x" cbor:"a"`
|
||
|
|
B string `json:"y" cbor:"b"`
|
||
|
|
C string `json:"-"`
|
||
|
|
}
|
||
|
|
want := strc{
|
||
|
|
A: "A",
|
||
|
|
B: "B",
|
||
|
|
}
|
||
|
|
cborData := hexDecode("a3616161416162614261636143") // {"a":"A", "b":"B", "c":"C"}
|
||
|
|
|
||
|
|
var v strc
|
||
|
|
if err := Unmarshal(cborData, &v); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(v, want) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %+v (%T), want %+v (%T)", cborData, v, v, want, want)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
type number uint64
|
||
|
|
|
||
|
|
func (n number) MarshalBinary() (data []byte, err error) {
|
||
|
|
if n == 0 {
|
||
|
|
return []byte{}, nil
|
||
|
|
}
|
||
|
|
data = make([]byte, 8)
|
||
|
|
binary.BigEndian.PutUint64(data, uint64(n))
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
func (n *number) UnmarshalBinary(data []byte) (err error) {
|
||
|
|
if len(data) == 0 {
|
||
|
|
*n = 0
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
if len(data) != 8 {
|
||
|
|
return errors.New("number:UnmarshalBinary: invalid length")
|
||
|
|
}
|
||
|
|
*n = number(binary.BigEndian.Uint64(data))
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
type stru struct {
|
||
|
|
a, b, c string
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *stru) MarshalBinary() ([]byte, error) {
|
||
|
|
if s.a == "" && s.b == "" && s.c == "" {
|
||
|
|
return []byte{}, nil
|
||
|
|
}
|
||
|
|
return []byte(fmt.Sprintf("%s,%s,%s", s.a, s.b, s.c)), nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *stru) UnmarshalBinary(data []byte) (err error) {
|
||
|
|
if len(data) == 0 {
|
||
|
|
s.a, s.b, s.c = "", "", ""
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
ss := strings.Split(string(data), ",")
|
||
|
|
if len(ss) != 3 {
|
||
|
|
return errors.New("stru:UnmarshalBinary: invalid element count")
|
||
|
|
}
|
||
|
|
s.a, s.b, s.c = ss[0], ss[1], ss[2]
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
type marshalBinaryError string
|
||
|
|
|
||
|
|
func (n marshalBinaryError) MarshalBinary() (data []byte, err error) {
|
||
|
|
return nil, errors.New(string(n))
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestBinaryMarshalerUnmarshaler(t *testing.T) {
|
||
|
|
testCases := []roundTripTest{
|
||
|
|
{
|
||
|
|
name: "primitive obj",
|
||
|
|
obj: number(1234567890),
|
||
|
|
wantCborData: hexDecode("4800000000499602d2"),
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "struct obj",
|
||
|
|
obj: stru{a: "a", b: "b", c: "c"},
|
||
|
|
wantCborData: hexDecode("45612C622C63"),
|
||
|
|
},
|
||
|
|
}
|
||
|
|
em, _ := EncOptions{}.EncMode()
|
||
|
|
dm, _ := DecOptions{}.DecMode()
|
||
|
|
testRoundTrip(t, testCases, em, dm)
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestBinaryUnmarshalerError(t *testing.T) { //nolint:dupl
|
||
|
|
testCases := []struct {
|
||
|
|
name string
|
||
|
|
typ reflect.Type
|
||
|
|
cborData []byte
|
||
|
|
wantErrorMsg string
|
||
|
|
}{
|
||
|
|
{
|
||
|
|
name: "primitive type",
|
||
|
|
typ: reflect.TypeOf(number(0)),
|
||
|
|
cborData: hexDecode("44499602d2"),
|
||
|
|
wantErrorMsg: "number:UnmarshalBinary: invalid length",
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "struct type",
|
||
|
|
typ: reflect.TypeOf(stru{}),
|
||
|
|
cborData: hexDecode("47612C622C632C64"),
|
||
|
|
wantErrorMsg: "stru:UnmarshalBinary: invalid element count",
|
||
|
|
},
|
||
|
|
}
|
||
|
|
for _, tc := range testCases {
|
||
|
|
t.Run(tc.name, func(t *testing.T) {
|
||
|
|
v := reflect.New(tc.typ)
|
||
|
|
if err := Unmarshal(tc.cborData, v.Interface()); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error, want error msg %q", tc.cborData, tc.wantErrorMsg)
|
||
|
|
} else if err.Error() != tc.wantErrorMsg {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want %q", tc.cborData, err.Error(), tc.wantErrorMsg)
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestBinaryMarshalerError(t *testing.T) {
|
||
|
|
wantErrorMsg := "MarshalBinary: error"
|
||
|
|
v := marshalBinaryError(wantErrorMsg)
|
||
|
|
if _, err := Marshal(v); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error, want error msg %q", v, wantErrorMsg)
|
||
|
|
} else if err.Error() != wantErrorMsg {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want %q", v, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
type number2 uint64
|
||
|
|
|
||
|
|
func (n number2) MarshalCBOR() (data []byte, err error) {
|
||
|
|
m := map[string]uint64{"num": uint64(n)}
|
||
|
|
return Marshal(m)
|
||
|
|
}
|
||
|
|
|
||
|
|
func (n *number2) UnmarshalCBOR(data []byte) (err error) {
|
||
|
|
var v map[string]uint64
|
||
|
|
if err := Unmarshal(data, &v); err != nil {
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
*n = number2(v["num"])
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
|
||
|
|
type stru2 struct {
|
||
|
|
a, b, c string
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *stru2) MarshalCBOR() ([]byte, error) {
|
||
|
|
v := []string{s.a, s.b, s.c}
|
||
|
|
return Marshal(v)
|
||
|
|
}
|
||
|
|
|
||
|
|
func (s *stru2) UnmarshalCBOR(data []byte) (err error) {
|
||
|
|
var v []string
|
||
|
|
if err := Unmarshal(data, &v); err != nil {
|
||
|
|
return err
|
||
|
|
}
|
||
|
|
if len(v) > 0 {
|
||
|
|
s.a = v[0]
|
||
|
|
}
|
||
|
|
if len(v) > 1 {
|
||
|
|
s.b = v[1]
|
||
|
|
}
|
||
|
|
if len(v) > 2 {
|
||
|
|
s.c = v[2]
|
||
|
|
}
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
|
||
|
|
type marshalCBORError string
|
||
|
|
|
||
|
|
func (n marshalCBORError) MarshalCBOR() (data []byte, err error) {
|
||
|
|
return nil, errors.New(string(n))
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestMarshalerUnmarshaler(t *testing.T) {
|
||
|
|
testCases := []roundTripTest{
|
||
|
|
{
|
||
|
|
name: "primitive obj",
|
||
|
|
obj: number2(1),
|
||
|
|
wantCborData: hexDecode("a1636e756d01"),
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "struct obj",
|
||
|
|
obj: stru2{a: "a", b: "b", c: "c"},
|
||
|
|
wantCborData: hexDecode("83616161626163"),
|
||
|
|
},
|
||
|
|
}
|
||
|
|
em, _ := EncOptions{}.EncMode()
|
||
|
|
dm, _ := DecOptions{}.DecMode()
|
||
|
|
testRoundTrip(t, testCases, em, dm)
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalerError(t *testing.T) { //nolint:dupl
|
||
|
|
testCases := []struct {
|
||
|
|
name string
|
||
|
|
typ reflect.Type
|
||
|
|
cborData []byte
|
||
|
|
wantErrorMsg string
|
||
|
|
}{
|
||
|
|
{
|
||
|
|
name: "primitive type",
|
||
|
|
typ: reflect.TypeOf(number2(0)),
|
||
|
|
cborData: hexDecode("44499602d2"),
|
||
|
|
wantErrorMsg: "cbor: cannot unmarshal byte string into Go value of type map[string]uint64",
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "struct type",
|
||
|
|
typ: reflect.TypeOf(stru2{}),
|
||
|
|
cborData: hexDecode("47612C622C632C64"),
|
||
|
|
wantErrorMsg: "cbor: cannot unmarshal byte string into Go value of type []string",
|
||
|
|
},
|
||
|
|
}
|
||
|
|
for _, tc := range testCases {
|
||
|
|
t.Run(tc.name, func(t *testing.T) {
|
||
|
|
v := reflect.New(tc.typ)
|
||
|
|
if err := Unmarshal(tc.cborData, v.Interface()); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error, want error msg %q", tc.cborData, tc.wantErrorMsg)
|
||
|
|
} else if err.Error() != tc.wantErrorMsg {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want %q", tc.cborData, err.Error(), tc.wantErrorMsg)
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestMarshalerError(t *testing.T) {
|
||
|
|
wantErrorMsg := "MarshalCBOR: error"
|
||
|
|
v := marshalCBORError(wantErrorMsg)
|
||
|
|
if _, err := Marshal(v); err == nil {
|
||
|
|
t.Errorf("Marshal(%+v) didn't return an error, want error msg %q", v, wantErrorMsg)
|
||
|
|
} else if err.Error() != wantErrorMsg {
|
||
|
|
t.Errorf("Marshal(%+v) returned error %q, want %q", v, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Found at https://github.com/oasislabs/oasis-core/blob/master/go/common/cbor/cbor_test.go
|
||
|
|
func TestOutOfMem1(t *testing.T) {
|
||
|
|
cborData := []byte("\x9b\x00\x00000000")
|
||
|
|
var f []byte
|
||
|
|
if err := Unmarshal(cborData, &f); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error", cborData)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Found at https://github.com/oasislabs/oasis-core/blob/master/go/common/cbor/cbor_test.go
|
||
|
|
func TestOutOfMem2(t *testing.T) {
|
||
|
|
cborData := []byte("\x9b\x00\x00\x81112233")
|
||
|
|
var f []byte
|
||
|
|
if err := Unmarshal(cborData, &f); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error", cborData)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Found at https://github.com/cose-wg/Examples/tree/master/RFC8152
|
||
|
|
func TestCOSEExamples(t *testing.T) {
|
||
|
|
cborData := [][]byte{
|
||
|
|
hexDecode("D8608443A10101A1054C02D1F7E6F26C43D4868D87CE582464F84D913BA60A76070A9A48F26E97E863E2852948658F0811139868826E89218A75715B818440A101225818DBD43C4E9D719C27C6275C67D628D493F090593DB8218F11818344A1013818A220A401022001215820B2ADD44368EA6D641F9CA9AF308B4079AEB519F11E9B8A55A600B21233E86E6822F40458246D65726961646F632E6272616E64796275636B406275636B6C616E642E6578616D706C6540"),
|
||
|
|
hexDecode("D8628440A054546869732069732074686520636F6E74656E742E818343A10126A1044231315840E2AEAFD40D69D19DFE6E52077C5D7FF4E408282CBEFB5D06CBF414AF2E19D982AC45AC98B8544C908B4507DE1E90B717C3D34816FE926A2B98F53AFD2FA0F30A"),
|
||
|
|
hexDecode("D8628440A054546869732069732074686520636F6E74656E742E828343A10126A1044231315840E2AEAFD40D69D19DFE6E52077C5D7FF4E408282CBEFB5D06CBF414AF2E19D982AC45AC98B8544C908B4507DE1E90B717C3D34816FE926A2B98F53AFD2FA0F30A8344A1013823A104581E62696C626F2E62616767696E7340686F626269746F6E2E6578616D706C65588400A2D28A7C2BDB1587877420F65ADF7D0B9A06635DD1DE64BB62974C863F0B160DD2163734034E6AC003B01E8705524C5C4CA479A952F0247EE8CB0B4FB7397BA08D009E0C8BF482270CC5771AA143966E5A469A09F613488030C5B07EC6D722E3835ADB5B2D8C44E95FFB13877DD2582866883535DE3BB03D01753F83AB87BB4F7A0297"),
|
||
|
|
hexDecode("D8628440A1078343A10126A10442313158405AC05E289D5D0E1B0A7F048A5D2B643813DED50BC9E49220F4F7278F85F19D4A77D655C9D3B51E805A74B099E1E085AACD97FC29D72F887E8802BB6650CCEB2C54546869732069732074686520636F6E74656E742E818343A10126A1044231315840E2AEAFD40D69D19DFE6E52077C5D7FF4E408282CBEFB5D06CBF414AF2E19D982AC45AC98B8544C908B4507DE1E90B717C3D34816FE926A2B98F53AFD2FA0F30A"),
|
||
|
|
hexDecode("D8628456A2687265736572766564F40281687265736572766564A054546869732069732074686520636F6E74656E742E818343A10126A10442313158403FC54702AA56E1B2CB20284294C9106A63F91BAC658D69351210A031D8FC7C5FF3E4BE39445B1A3E83E1510D1ACA2F2E8A7C081C7645042B18ABA9D1FAD1BD9C"),
|
||
|
|
hexDecode("D28443A10126A10442313154546869732069732074686520636F6E74656E742E58408EB33E4CA31D1C465AB05AAC34CC6B23D58FEF5C083106C4D25A91AEF0B0117E2AF9A291AA32E14AB834DC56ED2A223444547E01F11D3B0916E5A4C345CACB36"),
|
||
|
|
hexDecode("D8608443A10101A1054CC9CF4DF2FE6C632BF788641358247ADBE2709CA818FB415F1E5DF66F4E1A51053BA6D65A1A0C52A357DA7A644B8070A151B0818344A1013818A220A40102200121582098F50A4FF6C05861C8860D13A638EA56C3F5AD7590BBFBF054E1C7B4D91D628022F50458246D65726961646F632E6272616E64796275636B406275636B6C616E642E6578616D706C6540"),
|
||
|
|
hexDecode("D8608443A1010AA1054D89F52F65A1C580933B5261A76C581C753548A19B1307084CA7B2056924ED95F2E3B17006DFE931B687B847818343A10129A2335061616262636364646565666667676868044A6F75722D73656372657440"),
|
||
|
|
hexDecode("D8608443A10101A2054CC9CF4DF2FE6C632BF7886413078344A1013823A104581E62696C626F2E62616767696E7340686F626269746F6E2E6578616D706C65588400929663C8789BB28177AE28467E66377DA12302D7F9594D2999AFA5DFA531294F8896F2B6CDF1740014F4C7F1A358E3A6CF57F4ED6FB02FCF8F7AA989F5DFD07F0700A3A7D8F3C604BA70FA9411BD10C2591B483E1D2C31DE003183E434D8FBA18F17A4C7E3DFA003AC1CF3D30D44D2533C4989D3AC38C38B71481CC3430C9D65E7DDFF58247ADBE2709CA818FB415F1E5DF66F4E1A51053BA6D65A1A0C52A357DA7A644B8070A151B0818344A1013818A220A40102200121582098F50A4FF6C05861C8860D13A638EA56C3F5AD7590BBFBF054E1C7B4D91D628022F50458246D65726961646F632E6272616E64796275636B406275636B6C616E642E6578616D706C6540"),
|
||
|
|
hexDecode("D8608443A10101A1054C02D1F7E6F26C43D4868D87CE582464F84D913BA60A76070A9A48F26E97E863E28529D8F5335E5F0165EEE976B4A5F6C6F09D818344A101381FA3225821706572656772696E2E746F6F6B407475636B626F726F7567682E6578616D706C650458246D65726961646F632E6272616E64796275636B406275636B6C616E642E6578616D706C6535420101581841E0D76F579DBD0D936A662D54D8582037DE2E366FDE1C62"),
|
||
|
|
hexDecode("D08343A1010AA1054D89F52F65A1C580933B5261A78C581C5974E1B99A3A4CC09A659AA2E9E7FFF161D38CE71CB45CE460FFB569"),
|
||
|
|
hexDecode("D08343A1010AA1064261A7581C252A8911D465C125B6764739700F0141ED09192DE139E053BD09ABCA"),
|
||
|
|
hexDecode("D8618543A1010FA054546869732069732074686520636F6E74656E742E489E1226BA1F81B848818340A20125044A6F75722D73656372657440"),
|
||
|
|
hexDecode("D8618543A10105A054546869732069732074686520636F6E74656E742E582081A03448ACD3D305376EAA11FB3FE416A955BE2CBE7EC96F012C994BC3F16A41818344A101381AA3225821706572656772696E2E746F6F6B407475636B626F726F7567682E6578616D706C650458246D65726961646F632E6272616E64796275636B406275636B6C616E642E6578616D706C653558404D8553E7E74F3C6A3A9DD3EF286A8195CBF8A23D19558CCFEC7D34B824F42D92BD06BD2C7F0271F0214E141FB779AE2856ABF585A58368B017E7F2A9E5CE4DB540"),
|
||
|
|
hexDecode("D8618543A1010EA054546869732069732074686520636F6E74656E742E4836F5AFAF0BAB5D43818340A2012404582430313863306165352D346439622D343731622D626664362D6565663331346263373033375818711AB0DC2FC4585DCE27EFFA6781C8093EBA906F227B6EB0"),
|
||
|
|
hexDecode("D8618543A10105A054546869732069732074686520636F6E74656E742E5820BF48235E809B5C42E995F2B7D5FA13620E7ED834E337F6AA43DF161E49E9323E828344A101381CA220A4010220032158420043B12669ACAC3FD27898FFBA0BCD2E6C366D53BC4DB71F909A759304ACFB5E18CDC7BA0B13FF8C7636271A6924B1AC63C02688075B55EF2D613574E7DC242F79C322F504581E62696C626F2E62616767696E7340686F626269746F6E2E6578616D706C655828339BC4F79984CDC6B3E6CE5F315A4C7D2B0AC466FCEA69E8C07DFBCA5BB1F661BC5F8E0DF9E3EFF58340A2012404582430313863306165352D346439622D343731622D626664362D65656633313462633730333758280B2C7CFCE04E98276342D6476A7723C090DFDD15F9A518E7736549E998370695E6D6A83B4AE507BB"),
|
||
|
|
hexDecode("D18443A1010FA054546869732069732074686520636F6E74656E742E48726043745027214F"),
|
||
|
|
}
|
||
|
|
for _, d := range cborData {
|
||
|
|
var v interface{}
|
||
|
|
if err := Unmarshal(d, &v); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", d, err)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalStructKeyAsIntError(t *testing.T) {
|
||
|
|
type T1 struct {
|
||
|
|
F1 int `cbor:"1,keyasint"`
|
||
|
|
}
|
||
|
|
cborData := hexDecode("a13bffffffffffffffff01") // {1: -18446744073709551616}
|
||
|
|
var v T1
|
||
|
|
if err := Unmarshal(cborData, &v); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error", cborData)
|
||
|
|
} else if _, ok := err.(*UnmarshalTypeError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned wrong error type %T, want (*UnmarshalTypeError)", cborData, err)
|
||
|
|
} else if !strings.Contains(err.Error(), "cannot unmarshal") {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing %q", cborData, err.Error(), "cannot unmarshal")
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalArrayToStruct(t *testing.T) {
|
||
|
|
type T struct {
|
||
|
|
_ struct{} `cbor:",toarray"`
|
||
|
|
A int
|
||
|
|
B int
|
||
|
|
C int
|
||
|
|
}
|
||
|
|
testCases := []struct {
|
||
|
|
name string
|
||
|
|
cborData []byte
|
||
|
|
}{
|
||
|
|
{"definite length array", hexDecode("83010203")},
|
||
|
|
{"indefinite length array", hexDecode("9f010203ff")},
|
||
|
|
}
|
||
|
|
for _, tc := range testCases {
|
||
|
|
t.Run(tc.name, func(t *testing.T) {
|
||
|
|
var v T
|
||
|
|
if err := Unmarshal(tc.cborData, &v); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", tc.cborData, err)
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalArrayToStructNoToArrayOptionError(t *testing.T) {
|
||
|
|
type T struct {
|
||
|
|
A int
|
||
|
|
B int
|
||
|
|
C int
|
||
|
|
}
|
||
|
|
cborData := hexDecode("8301020383010203")
|
||
|
|
var v1 T
|
||
|
|
wantT := T{}
|
||
|
|
dec := NewDecoder(bytes.NewReader(cborData))
|
||
|
|
if err := dec.Decode(&v1); err == nil {
|
||
|
|
t.Errorf("Decode(%+v) didn't return an error", v1)
|
||
|
|
} else if _, ok := err.(*UnmarshalTypeError); !ok {
|
||
|
|
t.Errorf("Decode(%+v) returned wrong error type %T, want (*UnmarshalTypeError)", v1, err)
|
||
|
|
} else if !strings.Contains(err.Error(), "cannot unmarshal") {
|
||
|
|
t.Errorf("Decode(%+v) returned error %q, want error containing %q", err.Error(), v1, "cannot unmarshal")
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(v1, wantT) {
|
||
|
|
t.Errorf("Decode() = %+v (%T), want %+v (%T)", v1, v1, wantT, wantT)
|
||
|
|
}
|
||
|
|
var v2 []int
|
||
|
|
want := []int{1, 2, 3}
|
||
|
|
if err := dec.Decode(&v2); err != nil {
|
||
|
|
t.Errorf("Decode() returned error %v", err)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(v2, want) {
|
||
|
|
t.Errorf("Decode() = %+v (%T), want %+v (%T)", v2, v2, want, want)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalNonArrayDataToStructToArray(t *testing.T) {
|
||
|
|
type T struct {
|
||
|
|
_ struct{} `cbor:",toarray"`
|
||
|
|
A int
|
||
|
|
B int
|
||
|
|
C int
|
||
|
|
}
|
||
|
|
testCases := []struct {
|
||
|
|
name string
|
||
|
|
cborData []byte
|
||
|
|
}{
|
||
|
|
{"CBOR positive int", hexDecode("00")}, // 0
|
||
|
|
{"CBOR negative int", hexDecode("20")}, // -1
|
||
|
|
{"CBOR byte string", hexDecode("4401020304")}, // h`01020304`
|
||
|
|
{"CBOR text string", hexDecode("7f657374726561646d696e67ff")}, // streaming
|
||
|
|
{"CBOR map", hexDecode("a3614101614202614303")}, // {"A": 1, "B": 2, "C": 3}
|
||
|
|
{"CBOR bool", hexDecode("f5")}, // true
|
||
|
|
{"CBOR float", hexDecode("fa7f7fffff")}, // 3.4028234663852886e+38
|
||
|
|
}
|
||
|
|
wantT := T{}
|
||
|
|
wantErrorMsg := "cannot unmarshal"
|
||
|
|
for _, tc := range testCases {
|
||
|
|
t.Run(tc.name, func(t *testing.T) {
|
||
|
|
var v T
|
||
|
|
if err := Unmarshal(tc.cborData, &v); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error", tc.cborData)
|
||
|
|
} else if _, ok := err.(*UnmarshalTypeError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned wrong error type %T, want (*UnmarshalTypeError)", tc.cborData, err)
|
||
|
|
} else if !strings.Contains(err.Error(), wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing %q", tc.cborData, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(v, wantT) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %+v (%T), want %+v (%T)", tc.cborData, v, v, wantT, wantT)
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalArrayToStructWrongSizeError(t *testing.T) {
|
||
|
|
type T struct {
|
||
|
|
_ struct{} `cbor:",toarray"`
|
||
|
|
A int
|
||
|
|
B int
|
||
|
|
}
|
||
|
|
cborData := hexDecode("8301020383010203")
|
||
|
|
var v1 T
|
||
|
|
wantT := T{}
|
||
|
|
dec := NewDecoder(bytes.NewReader(cborData))
|
||
|
|
if err := dec.Decode(&v1); err == nil {
|
||
|
|
t.Errorf("Decode(%+v) didn't return an error", v1)
|
||
|
|
} else if _, ok := err.(*UnmarshalTypeError); !ok {
|
||
|
|
t.Errorf("Decode(%+v) returned wrong error type %T, want (*UnmarshalTypeError)", v1, err)
|
||
|
|
} else if !strings.Contains(err.Error(), "cannot unmarshal") {
|
||
|
|
t.Errorf("Decode(%+v) returned error %q, want error containing %q", v1, err.Error(), "cannot unmarshal")
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(v1, wantT) {
|
||
|
|
t.Errorf("Decode() = %+v (%T), want %+v (%T)", v1, v1, wantT, wantT)
|
||
|
|
}
|
||
|
|
var v2 []int
|
||
|
|
want := []int{1, 2, 3}
|
||
|
|
if err := dec.Decode(&v2); err != nil {
|
||
|
|
t.Errorf("Decode() returned error %v", err)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(v2, want) {
|
||
|
|
t.Errorf("Decode() = %+v (%T), want %+v (%T)", v2, v2, want, want)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalArrayToStructWrongFieldTypeError(t *testing.T) {
|
||
|
|
type T struct {
|
||
|
|
_ struct{} `cbor:",toarray"`
|
||
|
|
A int
|
||
|
|
B string
|
||
|
|
C int
|
||
|
|
}
|
||
|
|
testCases := []struct {
|
||
|
|
name string
|
||
|
|
cborData []byte
|
||
|
|
wantErrorMsg string
|
||
|
|
wantV interface{}
|
||
|
|
}{
|
||
|
|
// [1, 2, 3]
|
||
|
|
{"wrong field type", hexDecode("83010203"), "cannot unmarshal", T{A: 1, C: 3}},
|
||
|
|
// [1, 0xfe, 3]
|
||
|
|
{"invalid UTF-8 string", hexDecode("830161fe03"), invalidUTF8ErrorMsg, T{A: 1, C: 3}},
|
||
|
|
}
|
||
|
|
for _, tc := range testCases {
|
||
|
|
t.Run(tc.name, func(t *testing.T) {
|
||
|
|
var v T
|
||
|
|
if err := Unmarshal(tc.cborData, &v); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error", tc.cborData)
|
||
|
|
} else if !strings.Contains(err.Error(), tc.wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing %q", tc.cborData, err.Error(), tc.wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(v, tc.wantV) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %+v (%T), want %+v (%T)", tc.cborData, v, v, tc.wantV, tc.wantV)
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalArrayToStructCannotSetEmbeddedPointerError(t *testing.T) {
|
||
|
|
type (
|
||
|
|
s1 struct {
|
||
|
|
x int //nolint:unused,structcheck
|
||
|
|
X int
|
||
|
|
}
|
||
|
|
S2 struct {
|
||
|
|
y int //nolint:unused,structcheck
|
||
|
|
Y int
|
||
|
|
}
|
||
|
|
S struct {
|
||
|
|
_ struct{} `cbor:",toarray"`
|
||
|
|
*s1
|
||
|
|
*S2
|
||
|
|
}
|
||
|
|
)
|
||
|
|
cborData := []byte{0x82, 0x02, 0x04} // [2, 4]
|
||
|
|
const wantErrorMsg = "cannot set embedded pointer to unexported struct"
|
||
|
|
wantV := S{S2: &S2{Y: 4}}
|
||
|
|
var v S
|
||
|
|
err := Unmarshal(cborData, &v)
|
||
|
|
if err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error, want error %q", cborData, wantErrorMsg)
|
||
|
|
} else if !strings.Contains(err.Error(), wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error %q", cborData, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(v, wantV) {
|
||
|
|
t.Errorf("Decode() = %+v (%T), want %+v (%T)", v, v, wantV, wantV)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalIntoSliceError(t *testing.T) {
|
||
|
|
cborData := []byte{0x83, 0x61, 0x61, 0x61, 0xfe, 0x61, 0x62} // ["a", 0xfe, "b"]
|
||
|
|
wantErrorMsg := invalidUTF8ErrorMsg
|
||
|
|
var want interface{}
|
||
|
|
|
||
|
|
// Unmarshal CBOR array into Go empty interface.
|
||
|
|
var v1 interface{}
|
||
|
|
want = []interface{}{"a", interface{}(nil), "b"}
|
||
|
|
if err := Unmarshal(cborData, &v1); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error, want %q", cborData, wantErrorMsg)
|
||
|
|
} else if err.Error() != wantErrorMsg {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want %q", cborData, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(v1, want) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v, want %v", cborData, v1, want)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Unmarshal CBOR array into Go slice.
|
||
|
|
var v2 []string
|
||
|
|
want = []string{"a", "", "b"}
|
||
|
|
if err := Unmarshal(cborData, &v2); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error, want %q", cborData, wantErrorMsg)
|
||
|
|
} else if err.Error() != wantErrorMsg {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want %q", cborData, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(v2, want) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v, want %v", cborData, v2, want)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Unmarshal CBOR array into Go array.
|
||
|
|
var v3 [3]string
|
||
|
|
want = [3]string{"a", "", "b"}
|
||
|
|
if err := Unmarshal(cborData, &v3); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error, want %q", cborData, wantErrorMsg)
|
||
|
|
} else if err.Error() != wantErrorMsg {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want %q", cborData, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(v3, want) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v, want %v", cborData, v3, want)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Unmarshal CBOR array into populated Go slice.
|
||
|
|
v4 := []string{"hello", "to", "you"}
|
||
|
|
want = []string{"a", "to", "b"}
|
||
|
|
if err := Unmarshal(cborData, &v4); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error, want %q", cborData, wantErrorMsg)
|
||
|
|
} else if err.Error() != wantErrorMsg {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want %q", cborData, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(v4, want) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v, want %v", cborData, v4, want)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalIntoMapError(t *testing.T) {
|
||
|
|
cborData := [][]byte{
|
||
|
|
{0xa3, 0x61, 0x61, 0x61, 0x41, 0x61, 0xfe, 0x61, 0x43, 0x61, 0x62, 0x61, 0x42}, // {"a":"A", 0xfe: "C", "b":"B"}
|
||
|
|
{0xa3, 0x61, 0x61, 0x61, 0x41, 0x61, 0x63, 0x61, 0xfe, 0x61, 0x62, 0x61, 0x42}, // {"a":"A", "c": 0xfe, "b":"B"}
|
||
|
|
}
|
||
|
|
wantErrorMsg := invalidUTF8ErrorMsg
|
||
|
|
var want interface{}
|
||
|
|
|
||
|
|
for _, data := range cborData {
|
||
|
|
// Unmarshal CBOR map into Go empty interface.
|
||
|
|
var v1 interface{}
|
||
|
|
want = map[interface{}]interface{}{"a": "A", "b": "B"}
|
||
|
|
if err := Unmarshal(data, &v1); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error, want %q", data, wantErrorMsg)
|
||
|
|
} else if err.Error() != wantErrorMsg {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want %q", data, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(v1, want) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v, want %v", data, v1, want)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Unmarshal CBOR map into Go map[interface{}]interface{}.
|
||
|
|
var v2 map[interface{}]interface{}
|
||
|
|
want = map[interface{}]interface{}{"a": "A", "b": "B"}
|
||
|
|
if err := Unmarshal(data, &v2); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error, want %q", data, wantErrorMsg)
|
||
|
|
} else if err.Error() != wantErrorMsg {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want %q", data, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(v2, want) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v, want %v", data, v2, want)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Unmarshal CBOR array into Go map[string]string.
|
||
|
|
var v3 map[string]string
|
||
|
|
want = map[string]string{"a": "A", "b": "B"}
|
||
|
|
if err := Unmarshal(data, &v3); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error, want %q", data, wantErrorMsg)
|
||
|
|
} else if err.Error() != wantErrorMsg {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want %q", data, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(v3, want) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v, want %v", data, v3, want)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Unmarshal CBOR array into populated Go map[string]string.
|
||
|
|
v4 := map[string]string{"c": "D"}
|
||
|
|
want = map[string]string{"a": "A", "b": "B", "c": "D"}
|
||
|
|
if err := Unmarshal(data, &v4); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error, want %q", data, wantErrorMsg)
|
||
|
|
} else if err.Error() != wantErrorMsg {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want %q", data, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(v4, want) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v, want %v", data, v4, want)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestStructToArrayError(t *testing.T) {
|
||
|
|
type coseHeader struct {
|
||
|
|
Alg int `cbor:"1,keyasint,omitempty"`
|
||
|
|
Kid []byte `cbor:"4,keyasint,omitempty"`
|
||
|
|
IV []byte `cbor:"5,keyasint,omitempty"`
|
||
|
|
}
|
||
|
|
type nestedCWT struct {
|
||
|
|
_ struct{} `cbor:",toarray"`
|
||
|
|
Protected []byte
|
||
|
|
Unprotected coseHeader
|
||
|
|
Ciphertext []byte
|
||
|
|
}
|
||
|
|
for _, tc := range []struct {
|
||
|
|
cborData []byte
|
||
|
|
wantErrorMsg string
|
||
|
|
}{
|
||
|
|
// [-17, [-17, -17], -17]
|
||
|
|
{hexDecode("9f3082303030ff"), "cbor: cannot unmarshal negative integer into Go struct field cbor.nestedCWT.Protected of type []uint8"},
|
||
|
|
// [[], [], ["\x930000", -17]]
|
||
|
|
{hexDecode("9f9fff9fff9f65933030303030ffff"), "cbor: cannot unmarshal array into Go struct field cbor.nestedCWT.Unprotected of type cbor.coseHeader (cannot decode CBOR array to struct without toarray option)"},
|
||
|
|
} {
|
||
|
|
var v nestedCWT
|
||
|
|
if err := Unmarshal(tc.cborData, &v); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error, want %q", tc.cborData, tc.wantErrorMsg)
|
||
|
|
} else if err.Error() != tc.wantErrorMsg {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want %q", tc.cborData, err.Error(), tc.wantErrorMsg)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestStructKeyAsIntError(t *testing.T) {
|
||
|
|
type claims struct {
|
||
|
|
Iss string `cbor:"1,keyasint"`
|
||
|
|
Sub string `cbor:"2,keyasint"`
|
||
|
|
Aud string `cbor:"3,keyasint"`
|
||
|
|
Exp float64 `cbor:"4,keyasint"`
|
||
|
|
Nbf float64 `cbor:"5,keyasint"`
|
||
|
|
Iat float64 `cbor:"6,keyasint"`
|
||
|
|
Cti []byte `cbor:"7,keyasint"`
|
||
|
|
}
|
||
|
|
cborData := hexDecode("bf0783e662f03030ff") // {7: [simple(6), "\xF00", -17]}
|
||
|
|
wantErrorMsg := invalidUTF8ErrorMsg
|
||
|
|
wantV := claims{Cti: []byte{6, 0, 0}}
|
||
|
|
var v claims
|
||
|
|
if err := Unmarshal(cborData, &v); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error, want %q", cborData, wantErrorMsg)
|
||
|
|
} else if err.Error() != wantErrorMsg {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want %q", cborData, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(v, wantV) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v, want %v", cborData, v, wantV)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalToNotNilInterface(t *testing.T) {
|
||
|
|
cborData := hexDecode("83010203") // []uint64{1, 2, 3}
|
||
|
|
s := "hello" //nolint:goconst
|
||
|
|
var v interface{} = s // Unmarshal() sees v as type inteface{} and sets CBOR data as default Go type. s is unmodified. Same behavior as encoding/json.
|
||
|
|
wantV := []interface{}{uint64(1), uint64(2), uint64(3)}
|
||
|
|
if err := Unmarshal(cborData, &v); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
} else if !reflect.DeepEqual(v, wantV) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", cborData, v, v, wantV, wantV)
|
||
|
|
} else if s != "hello" {
|
||
|
|
t.Errorf("Unmarshal(0x%x) modified s %q", cborData, s)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestDecOptions(t *testing.T) {
|
||
|
|
opts1 := DecOptions{
|
||
|
|
TimeTag: DecTagRequired,
|
||
|
|
DupMapKey: DupMapKeyEnforcedAPF,
|
||
|
|
IndefLength: IndefLengthForbidden,
|
||
|
|
MaxNestedLevels: 100,
|
||
|
|
MaxMapPairs: 101,
|
||
|
|
MaxArrayElements: 102,
|
||
|
|
TagsMd: TagsForbidden,
|
||
|
|
IntDec: IntDecConvertSigned,
|
||
|
|
ExtraReturnErrors: ExtraDecErrorUnknownField,
|
||
|
|
}
|
||
|
|
dm, err := opts1.DecMode()
|
||
|
|
if err != nil {
|
||
|
|
t.Errorf("DecMode() returned an error %v", err)
|
||
|
|
} else {
|
||
|
|
opts2 := dm.DecOptions()
|
||
|
|
if !reflect.DeepEqual(opts1, opts2) {
|
||
|
|
t.Errorf("DecOptions->DecMode->DecOptions returned different values: %v, %v", opts1, opts2)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
type roundTripTest struct {
|
||
|
|
name string
|
||
|
|
obj interface{}
|
||
|
|
wantCborData []byte
|
||
|
|
}
|
||
|
|
|
||
|
|
func testRoundTrip(t *testing.T, testCases []roundTripTest, em EncMode, dm DecMode) {
|
||
|
|
for _, tc := range testCases {
|
||
|
|
t.Run(tc.name, func(t *testing.T) {
|
||
|
|
b, err := em.Marshal(tc.obj)
|
||
|
|
if err != nil {
|
||
|
|
t.Errorf("Marshal(%+v) returned error %v", tc.obj, err)
|
||
|
|
}
|
||
|
|
if !bytes.Equal(b, tc.wantCborData) {
|
||
|
|
t.Errorf("Marshal(%+v) = 0x%x, want 0x%x", tc.obj, b, tc.wantCborData)
|
||
|
|
}
|
||
|
|
v := reflect.New(reflect.TypeOf(tc.obj))
|
||
|
|
if err := dm.Unmarshal(b, v.Interface()); err != nil {
|
||
|
|
t.Errorf("Unmarshal() returned error %v", err)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(tc.obj, v.Elem().Interface()) {
|
||
|
|
t.Errorf("Marshal-Unmarshal returned different values: %v, %v", tc.obj, v.Elem().Interface())
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestDecModeInvalidTimeTag(t *testing.T) {
|
||
|
|
wantErrorMsg := "cbor: invalid TimeTag 101"
|
||
|
|
_, err := DecOptions{TimeTag: 101}.DecMode()
|
||
|
|
if err == nil {
|
||
|
|
t.Errorf("DecMode() didn't return an error")
|
||
|
|
} else if err.Error() != wantErrorMsg {
|
||
|
|
t.Errorf("DecMode() returned error %q, want %q", err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestDecModeInvalidDuplicateMapKey(t *testing.T) {
|
||
|
|
wantErrorMsg := "cbor: invalid DupMapKey 101"
|
||
|
|
_, err := DecOptions{DupMapKey: 101}.DecMode()
|
||
|
|
if err == nil {
|
||
|
|
t.Errorf("DecMode() didn't return an error")
|
||
|
|
} else if err.Error() != wantErrorMsg {
|
||
|
|
t.Errorf("DecMode() returned error %q, want %q", err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestDecModeDefaultMaxNestedLevel(t *testing.T) {
|
||
|
|
dm, err := DecOptions{}.DecMode()
|
||
|
|
if err != nil {
|
||
|
|
t.Errorf("DecMode() returned error %v", err)
|
||
|
|
} else {
|
||
|
|
maxNestedLevels := dm.DecOptions().MaxNestedLevels
|
||
|
|
if maxNestedLevels != 32 {
|
||
|
|
t.Errorf("DecOptions().MaxNestedLevels = %d, want %v", maxNestedLevels, 32)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestDecModeInvalidMaxNestedLevel(t *testing.T) {
|
||
|
|
testCases := []struct {
|
||
|
|
name string
|
||
|
|
opts DecOptions
|
||
|
|
wantErrorMsg string
|
||
|
|
}{
|
||
|
|
{
|
||
|
|
name: "MaxNestedLevels < 4",
|
||
|
|
opts: DecOptions{MaxNestedLevels: 1},
|
||
|
|
wantErrorMsg: "cbor: invalid MaxNestedLevels 1 (range is [4, 256])",
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "MaxNestedLevels > 256",
|
||
|
|
opts: DecOptions{MaxNestedLevels: 257},
|
||
|
|
wantErrorMsg: "cbor: invalid MaxNestedLevels 257 (range is [4, 256])",
|
||
|
|
},
|
||
|
|
}
|
||
|
|
for _, tc := range testCases {
|
||
|
|
t.Run(tc.name, func(t *testing.T) {
|
||
|
|
_, err := tc.opts.DecMode()
|
||
|
|
if err == nil {
|
||
|
|
t.Errorf("DecMode() didn't return an error")
|
||
|
|
} else if err.Error() != tc.wantErrorMsg {
|
||
|
|
t.Errorf("DecMode() returned error %q, want %q", err.Error(), tc.wantErrorMsg)
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestDecModeDefaultMaxMapPairs(t *testing.T) {
|
||
|
|
dm, err := DecOptions{}.DecMode()
|
||
|
|
if err != nil {
|
||
|
|
t.Errorf("DecMode() returned error %v", err)
|
||
|
|
} else {
|
||
|
|
maxMapPairs := dm.DecOptions().MaxMapPairs
|
||
|
|
if maxMapPairs != defaultMaxMapPairs {
|
||
|
|
t.Errorf("DecOptions().MaxMapPairs = %d, want %v", maxMapPairs, defaultMaxMapPairs)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestDecModeInvalidMaxMapPairs(t *testing.T) {
|
||
|
|
testCases := []struct {
|
||
|
|
name string
|
||
|
|
opts DecOptions
|
||
|
|
wantErrorMsg string
|
||
|
|
}{
|
||
|
|
{
|
||
|
|
name: "MaxMapPairs < 16",
|
||
|
|
opts: DecOptions{MaxMapPairs: 1},
|
||
|
|
wantErrorMsg: "cbor: invalid MaxMapPairs 1 (range is [16, 2147483647])",
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "MaxMapPairs > 2147483647",
|
||
|
|
opts: DecOptions{MaxMapPairs: 2147483648},
|
||
|
|
wantErrorMsg: "cbor: invalid MaxMapPairs 2147483648 (range is [16, 2147483647])",
|
||
|
|
},
|
||
|
|
}
|
||
|
|
for _, tc := range testCases {
|
||
|
|
t.Run(tc.name, func(t *testing.T) {
|
||
|
|
_, err := tc.opts.DecMode()
|
||
|
|
if err == nil {
|
||
|
|
t.Errorf("DecMode() didn't return an error")
|
||
|
|
} else if err.Error() != tc.wantErrorMsg {
|
||
|
|
t.Errorf("DecMode() returned error %q, want %q", err.Error(), tc.wantErrorMsg)
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestDecModeDefaultMaxArrayElements(t *testing.T) {
|
||
|
|
dm, err := DecOptions{}.DecMode()
|
||
|
|
if err != nil {
|
||
|
|
t.Errorf("DecMode() returned error %v", err)
|
||
|
|
} else {
|
||
|
|
maxArrayElements := dm.DecOptions().MaxArrayElements
|
||
|
|
if maxArrayElements != defaultMaxArrayElements {
|
||
|
|
t.Errorf("DecOptions().MaxArrayElementsr = %d, want %v", maxArrayElements, defaultMaxArrayElements)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestDecModeInvalidMaxArrayElements(t *testing.T) {
|
||
|
|
testCases := []struct {
|
||
|
|
name string
|
||
|
|
opts DecOptions
|
||
|
|
wantErrorMsg string
|
||
|
|
}{
|
||
|
|
{
|
||
|
|
name: "MaxArrayElements < 16",
|
||
|
|
opts: DecOptions{MaxArrayElements: 1},
|
||
|
|
wantErrorMsg: "cbor: invalid MaxArrayElements 1 (range is [16, 2147483647])",
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "MaxArrayElements > 2147483647",
|
||
|
|
opts: DecOptions{MaxArrayElements: 2147483648},
|
||
|
|
wantErrorMsg: "cbor: invalid MaxArrayElements 2147483648 (range is [16, 2147483647])",
|
||
|
|
},
|
||
|
|
}
|
||
|
|
for _, tc := range testCases {
|
||
|
|
t.Run(tc.name, func(t *testing.T) {
|
||
|
|
_, err := tc.opts.DecMode()
|
||
|
|
if err == nil {
|
||
|
|
t.Errorf("DecMode() didn't return an error")
|
||
|
|
} else if err.Error() != tc.wantErrorMsg {
|
||
|
|
t.Errorf("DecMode() returned error %q, want %q", err.Error(), tc.wantErrorMsg)
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestDecModeInvalidIndefiniteLengthMode(t *testing.T) {
|
||
|
|
wantErrorMsg := "cbor: invalid IndefLength 101"
|
||
|
|
_, err := DecOptions{IndefLength: 101}.DecMode()
|
||
|
|
if err == nil {
|
||
|
|
t.Errorf("DecMode() didn't return an error")
|
||
|
|
} else if err.Error() != wantErrorMsg {
|
||
|
|
t.Errorf("DecMode() returned error %q, want %q", err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestDecModeInvalidTagsMode(t *testing.T) {
|
||
|
|
wantErrorMsg := "cbor: invalid TagsMd 101"
|
||
|
|
_, err := DecOptions{TagsMd: 101}.DecMode()
|
||
|
|
if err == nil {
|
||
|
|
t.Errorf("DecMode() didn't return an error")
|
||
|
|
} else if err.Error() != wantErrorMsg {
|
||
|
|
t.Errorf("DecMode() returned error %q, want %q", err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalStructKeyAsIntNumError(t *testing.T) {
|
||
|
|
type T1 struct {
|
||
|
|
F1 int `cbor:"a,keyasint"`
|
||
|
|
}
|
||
|
|
type T2 struct {
|
||
|
|
F1 int `cbor:"-18446744073709551616,keyasint"`
|
||
|
|
}
|
||
|
|
testCases := []struct {
|
||
|
|
name string
|
||
|
|
cborData []byte
|
||
|
|
obj interface{}
|
||
|
|
wantErrorMsg string
|
||
|
|
}{
|
||
|
|
{
|
||
|
|
name: "string as key",
|
||
|
|
cborData: hexDecode("a1616101"),
|
||
|
|
obj: T1{},
|
||
|
|
wantErrorMsg: "cbor: failed to parse field name \"a\" to int",
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "out of range int as key",
|
||
|
|
cborData: hexDecode("a13bffffffffffffffff01"),
|
||
|
|
obj: T2{},
|
||
|
|
wantErrorMsg: "cbor: failed to parse field name \"-18446744073709551616\" to int",
|
||
|
|
},
|
||
|
|
}
|
||
|
|
for _, tc := range testCases {
|
||
|
|
t.Run(tc.name, func(t *testing.T) {
|
||
|
|
v := reflect.New(reflect.TypeOf(tc.obj))
|
||
|
|
err := Unmarshal(tc.cborData, v.Interface())
|
||
|
|
if err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error, want error %q", tc.cborData, tc.wantErrorMsg)
|
||
|
|
} else if !strings.Contains(err.Error(), tc.wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) error %v, want %v", tc.cborData, err.Error(), tc.wantErrorMsg)
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalEmptyMapWithDupMapKeyOpt(t *testing.T) {
|
||
|
|
testCases := []struct {
|
||
|
|
name string
|
||
|
|
cborData []byte
|
||
|
|
wantV interface{}
|
||
|
|
}{
|
||
|
|
{
|
||
|
|
name: "empty map",
|
||
|
|
cborData: hexDecode("a0"),
|
||
|
|
wantV: map[interface{}]interface{}{},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "indefinite empty map",
|
||
|
|
cborData: hexDecode("bfff"),
|
||
|
|
wantV: map[interface{}]interface{}{},
|
||
|
|
},
|
||
|
|
}
|
||
|
|
|
||
|
|
dm, err := DecOptions{DupMapKey: DupMapKeyEnforcedAPF}.DecMode()
|
||
|
|
if err != nil {
|
||
|
|
t.Errorf("DecMode() returned error %v", err)
|
||
|
|
}
|
||
|
|
|
||
|
|
for _, tc := range testCases {
|
||
|
|
t.Run(tc.name, func(t *testing.T) {
|
||
|
|
var v interface{}
|
||
|
|
if err := dm.Unmarshal(tc.cborData, &v); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", tc.cborData, err)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(v, tc.wantV) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", tc.cborData, v, v, tc.wantV, tc.wantV)
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalDupMapKeyToEmptyInterface(t *testing.T) {
|
||
|
|
cborData := hexDecode("a6616161416162614261636143616161466164614461656145") // {"a": "A", "b": "B", "c": "C", "a": "F", "d": "D", "e": "E"}
|
||
|
|
|
||
|
|
// Duplicate key overwrites previous value (default).
|
||
|
|
wantV := map[interface{}]interface{}{"a": "F", "b": "B", "c": "C", "d": "D", "e": "E"}
|
||
|
|
var v interface{}
|
||
|
|
if err := Unmarshal(cborData, &v); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(v, wantV) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", cborData, v, v, wantV, wantV)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Duplicate key triggers error.
|
||
|
|
wantV = map[interface{}]interface{}{"a": nil, "b": "B", "c": "C"}
|
||
|
|
wantErrorMsg := "cbor: found duplicate map key \"a\" at map element index 3"
|
||
|
|
dm, _ := DecOptions{DupMapKey: DupMapKeyEnforcedAPF}.DecMode()
|
||
|
|
var v2 interface{}
|
||
|
|
if err := dm.Unmarshal(cborData, &v2); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error", cborData)
|
||
|
|
} else if _, ok := err.(*DupMapKeyError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned wrong error type %T, want (*DupMapKeyError)", cborData, err)
|
||
|
|
} else if err.Error() != wantErrorMsg {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing %q", cborData, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(v2, wantV) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", cborData, v2, v2, wantV, wantV)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestStreamDupMapKeyToEmptyInterface(t *testing.T) {
|
||
|
|
cborData := hexDecode("a6616161416162614261636143616161466164614461656145") // map with duplicate key "c": {"a": "A", "b": "B", "c": "C", "a": "F", "d": "D", "e": "E"}
|
||
|
|
|
||
|
|
var b []byte
|
||
|
|
for i := 0; i < 3; i++ {
|
||
|
|
b = append(b, cborData...)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Duplicate key overwrites previous value (default).
|
||
|
|
wantV := map[interface{}]interface{}{"a": "F", "b": "B", "c": "C", "d": "D", "e": "E"}
|
||
|
|
dec := NewDecoder(bytes.NewReader(b))
|
||
|
|
for i := 0; i < 3; i++ {
|
||
|
|
var v1 interface{}
|
||
|
|
if err := dec.Decode(&v1); err != nil {
|
||
|
|
t.Errorf("Decode() returned error %v", err)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(v1, wantV) {
|
||
|
|
t.Errorf("Decode() = %v (%T), want %v (%T)", v1, v1, wantV, wantV)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var v interface{}
|
||
|
|
if err := dec.Decode(&v); err != io.EOF {
|
||
|
|
t.Errorf("Decode() returned error %v, want %v", err, io.EOF)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Duplicate key triggers error.
|
||
|
|
wantV = map[interface{}]interface{}{"a": nil, "b": "B", "c": "C"}
|
||
|
|
wantErrorMsg := "cbor: found duplicate map key \"a\" at map element index 3"
|
||
|
|
dm, _ := DecOptions{DupMapKey: DupMapKeyEnforcedAPF}.DecMode()
|
||
|
|
dec = dm.NewDecoder(bytes.NewReader(b))
|
||
|
|
for i := 0; i < 3; i++ {
|
||
|
|
var v2 interface{}
|
||
|
|
if err := dec.Decode(&v2); err == nil {
|
||
|
|
t.Errorf("Decode() didn't return an error")
|
||
|
|
} else if _, ok := err.(*DupMapKeyError); !ok {
|
||
|
|
t.Errorf("Decode() returned wrong error type %T, want (*DupMapKeyError)", err)
|
||
|
|
} else if err.Error() != wantErrorMsg {
|
||
|
|
t.Errorf("Decode() returned error %q, want error containing %q", err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(v2, wantV) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", cborData, v2, v2, wantV, wantV)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if err := dec.Decode(&v); err != io.EOF {
|
||
|
|
t.Errorf("Decode() returned error %v, want %v", err, io.EOF)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalDupMapKeyToEmptyMap(t *testing.T) {
|
||
|
|
cborData := hexDecode("a6616161416162614261636143616161466164614461656145") // {"a": "A", "b": "B", "c": "C", "a": "F", "d": "D", "e": "E"}
|
||
|
|
|
||
|
|
// Duplicate key overwrites previous value (default).
|
||
|
|
wantM := map[string]string{"a": "F", "b": "B", "c": "C", "d": "D", "e": "E"}
|
||
|
|
var m map[string]string
|
||
|
|
if err := Unmarshal(cborData, &m); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(m, wantM) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", cborData, m, m, wantM, wantM)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Duplicate key triggers error.
|
||
|
|
wantM = map[string]string{"a": "", "b": "B", "c": "C"}
|
||
|
|
wantErrorMsg := "cbor: found duplicate map key \"a\" at map element index 3"
|
||
|
|
dm, _ := DecOptions{DupMapKey: DupMapKeyEnforcedAPF}.DecMode()
|
||
|
|
var m2 map[string]string
|
||
|
|
if err := dm.Unmarshal(cborData, &m2); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error", cborData)
|
||
|
|
} else if _, ok := err.(*DupMapKeyError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned wrong error type %T, want (*DupMapKeyError)", cborData, err)
|
||
|
|
} else if err.Error() != wantErrorMsg {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing %q", cborData, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(m2, wantM) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", cborData, m2, m2, wantM, wantM)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestStreamDupMapKeyToEmptyMap(t *testing.T) {
|
||
|
|
cborData := hexDecode("a6616161416162614261636143616161466164614461656145") // {"a": "A", "b": "B", "c": "C", "a": "F", "d": "D", "e": "E"}
|
||
|
|
|
||
|
|
var b []byte
|
||
|
|
for i := 0; i < 3; i++ {
|
||
|
|
b = append(b, cborData...)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Duplicate key overwrites previous value (default).
|
||
|
|
wantM := map[string]string{"a": "F", "b": "B", "c": "C", "d": "D", "e": "E"}
|
||
|
|
dec := NewDecoder(bytes.NewReader(b))
|
||
|
|
for i := 0; i < 3; i++ {
|
||
|
|
var m1 map[string]string
|
||
|
|
if err := dec.Decode(&m1); err != nil {
|
||
|
|
t.Errorf("Decode() returned error %v", err)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(m1, wantM) {
|
||
|
|
t.Errorf("Decode() = %v (%T), want %v (%T)", m1, m1, wantM, wantM)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var v interface{}
|
||
|
|
if err := dec.Decode(&v); err != io.EOF {
|
||
|
|
t.Errorf("Decode() returned error %v, want %v", err, io.EOF)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Duplicate key triggers error.
|
||
|
|
wantM = map[string]string{"a": "", "b": "B", "c": "C"}
|
||
|
|
wantErrorMsg := "cbor: found duplicate map key \"a\" at map element index 3"
|
||
|
|
dm, _ := DecOptions{DupMapKey: DupMapKeyEnforcedAPF}.DecMode()
|
||
|
|
dec = dm.NewDecoder(bytes.NewReader(b))
|
||
|
|
for i := 0; i < 3; i++ {
|
||
|
|
var m2 map[string]string
|
||
|
|
if err := dec.Decode(&m2); err == nil {
|
||
|
|
t.Errorf("Decode() didn't return an error")
|
||
|
|
} else if _, ok := err.(*DupMapKeyError); !ok {
|
||
|
|
t.Errorf("Decode() returned wrong error type %T, want (*DupMapKeyError)", err)
|
||
|
|
} else if err.Error() != wantErrorMsg {
|
||
|
|
t.Errorf("Decode() returned error %q, want error containing %q", err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(m2, wantM) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", cborData, m2, m2, wantM, wantM)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if err := dec.Decode(&v); err != io.EOF {
|
||
|
|
t.Errorf("Decode() returned error %v, want %v", err, io.EOF)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalDupMapKeyToNotEmptyMap(t *testing.T) {
|
||
|
|
cborData := hexDecode("a6616161416162614261636143616161466164614461656145") // {"a": "A", "b": "B", "c": "C", "a": "F", "d": "D", "e": "E"}
|
||
|
|
|
||
|
|
// Duplicate key overwrites previous value (default).
|
||
|
|
m := map[string]string{"a": "Z", "b": "Z", "c": "Z", "d": "Z", "e": "Z", "f": "Z"}
|
||
|
|
wantM := map[string]string{"a": "F", "b": "B", "c": "C", "d": "D", "e": "E", "f": "Z"}
|
||
|
|
if err := Unmarshal(cborData, &m); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(m, wantM) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", cborData, m, m, wantM, wantM)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Duplicate key triggers error.
|
||
|
|
m2 := map[string]string{"a": "Z", "b": "Z", "c": "Z", "d": "Z", "e": "Z", "f": "Z"}
|
||
|
|
wantM = map[string]string{"a": "", "b": "B", "c": "C", "d": "Z", "e": "Z", "f": "Z"}
|
||
|
|
wantErrorMsg := "cbor: found duplicate map key \"a\" at map element index 3"
|
||
|
|
dm, _ := DecOptions{DupMapKey: DupMapKeyEnforcedAPF}.DecMode()
|
||
|
|
if err := dm.Unmarshal(cborData, &m2); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error", cborData)
|
||
|
|
} else if _, ok := err.(*DupMapKeyError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned wrong error type %T, want (*DupMapKeyError)", cborData, err)
|
||
|
|
} else if !strings.Contains(err.Error(), wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing %q", cborData, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(m2, wantM) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", cborData, m2, m2, wantM, wantM)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestStreamDupMapKeyToNotEmptyMap(t *testing.T) {
|
||
|
|
cborData := hexDecode("a6616161416162614261636143616161466164614461656145") // {"a": "A", "b": "B", "c": "C", "a": "F", "d": "D", "e": "E"}
|
||
|
|
|
||
|
|
var b []byte
|
||
|
|
for i := 0; i < 3; i++ {
|
||
|
|
b = append(b, cborData...)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Duplicate key overwrites previous value (default).
|
||
|
|
wantM := map[string]string{"a": "F", "b": "B", "c": "C", "d": "D", "e": "E", "f": "Z"}
|
||
|
|
dec := NewDecoder(bytes.NewReader(b))
|
||
|
|
for i := 0; i < 3; i++ {
|
||
|
|
m1 := map[string]string{"a": "Z", "b": "Z", "c": "Z", "d": "Z", "e": "Z", "f": "Z"}
|
||
|
|
if err := dec.Decode(&m1); err != nil {
|
||
|
|
t.Errorf("Decode() returned error %v", err)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(m1, wantM) {
|
||
|
|
t.Errorf("Decode() = %v (%T), want %v (%T)", m1, m1, wantM, wantM)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var v interface{}
|
||
|
|
if err := dec.Decode(&v); err != io.EOF {
|
||
|
|
t.Errorf("Decode() returned error %v, want %v", err, io.EOF)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Duplicate key triggers error.
|
||
|
|
wantM = map[string]string{"a": "", "b": "B", "c": "C", "d": "Z", "e": "Z", "f": "Z"}
|
||
|
|
wantErrorMsg := "cbor: found duplicate map key \"a\" at map element index 3"
|
||
|
|
dm, _ := DecOptions{DupMapKey: DupMapKeyEnforcedAPF}.DecMode()
|
||
|
|
dec = dm.NewDecoder(bytes.NewReader(b))
|
||
|
|
for i := 0; i < 3; i++ {
|
||
|
|
m2 := map[string]string{"a": "Z", "b": "Z", "c": "Z", "d": "Z", "e": "Z", "f": "Z"}
|
||
|
|
if err := dec.Decode(&m2); err == nil {
|
||
|
|
t.Errorf("Decode() didn't return an error")
|
||
|
|
} else if _, ok := err.(*DupMapKeyError); !ok {
|
||
|
|
t.Errorf("Decode() returned wrong error type %T, want (*DupMapKeyError)", err)
|
||
|
|
} else if err.Error() != wantErrorMsg {
|
||
|
|
t.Errorf("Decode() returned error %q, want error containing %q", err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(m2, wantM) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", cborData, m2, m2, wantM, wantM)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if err := dec.Decode(&v); err != io.EOF {
|
||
|
|
t.Errorf("Decode() returned error %v, want %v", err, io.EOF)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalDupMapKeyToStruct(t *testing.T) {
|
||
|
|
type s struct {
|
||
|
|
A string `cbor:"a"`
|
||
|
|
B string `cbor:"b"`
|
||
|
|
C string `cbor:"c"`
|
||
|
|
D string `cbor:"d"`
|
||
|
|
E string `cbor:"e"`
|
||
|
|
}
|
||
|
|
cborData := hexDecode("a6616161416162614261636143616161466164614461656145") // {"a": "A", "b": "B", "c": "C", "a": "F", "d": "D", "e": "E"}
|
||
|
|
|
||
|
|
// Duplicate key doesn't overwrite previous value (default).
|
||
|
|
wantS := s{A: "A", B: "B", C: "C", D: "D", E: "E"}
|
||
|
|
var s1 s
|
||
|
|
if err := Unmarshal(cborData, &s1); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(s1, wantS) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %+v (%T), want %+v (%T)", cborData, s1, s1, wantS, wantS)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Duplicate key triggers error.
|
||
|
|
wantS = s{A: "A", B: "B", C: "C"}
|
||
|
|
wantErrorMsg := "cbor: found duplicate map key \"a\" at map element index 3"
|
||
|
|
dm, _ := DecOptions{DupMapKey: DupMapKeyEnforcedAPF}.DecMode()
|
||
|
|
var s2 s
|
||
|
|
if err := dm.Unmarshal(cborData, &s2); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x, %s) didn't return an error", cborData, reflect.TypeOf(s2))
|
||
|
|
} else if _, ok := err.(*DupMapKeyError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned wrong error type %T, want (*DupMapKeyError)", cborData, err)
|
||
|
|
} else if !strings.Contains(err.Error(), wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing %q", cborData, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(s2, wantS) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %+v (%T), want %+v (%T)", cborData, s2, s2, wantS, wantS)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestStreamDupMapKeyToStruct(t *testing.T) {
|
||
|
|
type s struct {
|
||
|
|
A string `cbor:"a"`
|
||
|
|
B string `cbor:"b"`
|
||
|
|
C string `cbor:"c"`
|
||
|
|
D string `cbor:"d"`
|
||
|
|
E string `cbor:"e"`
|
||
|
|
}
|
||
|
|
cborData := hexDecode("a6616161416162614261636143616161466164614461656145") // {"a": "A", "b": "B", "c": "C", "a": "F", "d": "D", "e": "E"}
|
||
|
|
|
||
|
|
var b []byte
|
||
|
|
for i := 0; i < 3; i++ {
|
||
|
|
b = append(b, cborData...)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Duplicate key overwrites previous value (default).
|
||
|
|
wantS := s{A: "A", B: "B", C: "C", D: "D", E: "E"}
|
||
|
|
dec := NewDecoder(bytes.NewReader(b))
|
||
|
|
for i := 0; i < 3; i++ {
|
||
|
|
var s1 s
|
||
|
|
if err := dec.Decode(&s1); err != nil {
|
||
|
|
t.Errorf("Decode() returned error %v", err)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(s1, wantS) {
|
||
|
|
t.Errorf("Decode() = %v (%T), want %v (%T)", s1, s1, wantS, wantS)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var v interface{}
|
||
|
|
if err := dec.Decode(&v); err != io.EOF {
|
||
|
|
t.Errorf("Decode() returned error %v, want %v", err, io.EOF)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Duplicate key triggers error.
|
||
|
|
wantS = s{A: "A", B: "B", C: "C"}
|
||
|
|
wantErrorMsg := "cbor: found duplicate map key \"a\" at map element index 3"
|
||
|
|
dm, _ := DecOptions{DupMapKey: DupMapKeyEnforcedAPF}.DecMode()
|
||
|
|
dec = dm.NewDecoder(bytes.NewReader(b))
|
||
|
|
for i := 0; i < 3; i++ {
|
||
|
|
var s2 s
|
||
|
|
if err := dec.Decode(&s2); err == nil {
|
||
|
|
t.Errorf("Decode() didn't return an error")
|
||
|
|
} else if _, ok := err.(*DupMapKeyError); !ok {
|
||
|
|
t.Errorf("Decode() returned wrong error type %T, want (*DupMapKeyError)", err)
|
||
|
|
} else if err.Error() != wantErrorMsg {
|
||
|
|
t.Errorf("Decode() returned error %q, want error containing %q", err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(s2, wantS) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %+v (%T), want %+v (%T)", cborData, s2, s2, wantS, wantS)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if err := dec.Decode(&v); err != io.EOF {
|
||
|
|
t.Errorf("Decode() returned error %v, want %v", err, io.EOF)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// dupl map key is a struct field
|
||
|
|
func TestUnmarshalDupMapKeyToStructKeyAsInt(t *testing.T) {
|
||
|
|
type s struct {
|
||
|
|
A int `cbor:"1,keyasint"`
|
||
|
|
B int `cbor:"3,keyasint"`
|
||
|
|
C int `cbor:"5,keyasint"`
|
||
|
|
}
|
||
|
|
cborData := hexDecode("a40102030401030506") // {1:2, 3:4, 1:3, 5:6}
|
||
|
|
|
||
|
|
// Duplicate key doesn't overwrite previous value (default).
|
||
|
|
wantS := s{A: 2, B: 4, C: 6}
|
||
|
|
var s1 s
|
||
|
|
if err := Unmarshal(cborData, &s1); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(s1, wantS) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %+v (%T), want %+v (%T)", cborData, s1, s1, wantS, wantS)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Duplicate key triggers error.
|
||
|
|
wantS = s{A: 2, B: 4}
|
||
|
|
wantErrorMsg := "cbor: found duplicate map key \"1\" at map element index 2"
|
||
|
|
dm, _ := DecOptions{DupMapKey: DupMapKeyEnforcedAPF}.DecMode()
|
||
|
|
var s2 s
|
||
|
|
if err := dm.Unmarshal(cborData, &s2); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x, %s) didn't return an error", cborData, reflect.TypeOf(s2))
|
||
|
|
} else if _, ok := err.(*DupMapKeyError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned wrong error type %T, want (*DupMapKeyError)", cborData, err)
|
||
|
|
} else if !strings.Contains(err.Error(), wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing %q", cborData, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(s2, wantS) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %+v (%T), want %+v (%T)", cborData, s2, s2, wantS, wantS)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestStreamDupMapKeyToStructKeyAsInt(t *testing.T) {
|
||
|
|
type s struct {
|
||
|
|
A int `cbor:"1,keyasint"`
|
||
|
|
B int `cbor:"3,keyasint"`
|
||
|
|
C int `cbor:"5,keyasint"`
|
||
|
|
}
|
||
|
|
cborData := hexDecode("a40102030401030506") // {1:2, 3:4, 1:3, 5:6}
|
||
|
|
|
||
|
|
var b []byte
|
||
|
|
for i := 0; i < 3; i++ {
|
||
|
|
b = append(b, cborData...)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Duplicate key overwrites previous value (default).
|
||
|
|
wantS := s{A: 2, B: 4, C: 6}
|
||
|
|
dec := NewDecoder(bytes.NewReader(b))
|
||
|
|
for i := 0; i < 3; i++ {
|
||
|
|
var s1 s
|
||
|
|
if err := dec.Decode(&s1); err != nil {
|
||
|
|
t.Errorf("Decode() returned error %v", err)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(s1, wantS) {
|
||
|
|
t.Errorf("Decode() = %v (%T), want %v (%T)", s1, s1, wantS, wantS)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var v interface{}
|
||
|
|
if err := dec.Decode(&v); err != io.EOF {
|
||
|
|
t.Errorf("Decode() returned error %v, want %v", err, io.EOF)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Duplicate key triggers error.
|
||
|
|
wantS = s{A: 2, B: 4}
|
||
|
|
wantErrorMsg := "cbor: found duplicate map key \"1\" at map element index 2"
|
||
|
|
dm, _ := DecOptions{DupMapKey: DupMapKeyEnforcedAPF}.DecMode()
|
||
|
|
dec = dm.NewDecoder(bytes.NewReader(b))
|
||
|
|
for i := 0; i < 3; i++ {
|
||
|
|
var s2 s
|
||
|
|
if err := dec.Decode(&s2); err == nil {
|
||
|
|
t.Errorf("Decode() didn't return an error")
|
||
|
|
} else if _, ok := err.(*DupMapKeyError); !ok {
|
||
|
|
t.Errorf("Decode() returned wrong error type %T, want (*DupMapKeyError)", err)
|
||
|
|
} else if err.Error() != wantErrorMsg {
|
||
|
|
t.Errorf("Decode() returned error %q, want error containing %q", err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(s2, wantS) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %+v (%T), want %+v (%T)", cborData, s2, s2, wantS, wantS)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if err := dec.Decode(&v); err != io.EOF {
|
||
|
|
t.Errorf("Decode() returned error %v, want %v", err, io.EOF)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalDupMapKeyToStructNoMatchingField(t *testing.T) {
|
||
|
|
type s struct {
|
||
|
|
B string `cbor:"b"`
|
||
|
|
C string `cbor:"c"`
|
||
|
|
D string `cbor:"d"`
|
||
|
|
E string `cbor:"e"`
|
||
|
|
}
|
||
|
|
cborData := hexDecode("a6616161416162614261636143616161466164614461656145") // {"a": "A", "b": "B", "c": "C", "a": "F", "d": "D", "e": "E"}
|
||
|
|
|
||
|
|
wantS := s{B: "B", C: "C", D: "D", E: "E"}
|
||
|
|
var s1 s
|
||
|
|
if err := Unmarshal(cborData, &s1); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(s1, wantS) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %+v (%T), want %+v (%T)", cborData, s1, s1, wantS, wantS)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Duplicate key triggers error even though map key "a" doesn't have a corresponding struct field.
|
||
|
|
wantS = s{B: "B", C: "C"}
|
||
|
|
wantErrorMsg := "cbor: found duplicate map key \"a\" at map element index 3"
|
||
|
|
dm, _ := DecOptions{DupMapKey: DupMapKeyEnforcedAPF}.DecMode()
|
||
|
|
var s2 s
|
||
|
|
if err := dm.Unmarshal(cborData, &s2); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x, %s) didn't return an error", cborData, reflect.TypeOf(s2))
|
||
|
|
} else if _, ok := err.(*DupMapKeyError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned wrong error type %T, want (*DupMapKeyError)", cborData, err)
|
||
|
|
} else if !strings.Contains(err.Error(), wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing %q", cborData, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(s2, wantS) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %+v (%T), want %+v (%T)", cborData, s2, s2, wantS, wantS)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestStreamDupMapKeyToStructNoMatchingField(t *testing.T) {
|
||
|
|
type s struct {
|
||
|
|
B string `cbor:"b"`
|
||
|
|
C string `cbor:"c"`
|
||
|
|
D string `cbor:"d"`
|
||
|
|
E string `cbor:"e"`
|
||
|
|
}
|
||
|
|
cborData := hexDecode("a6616161416162614261636143616161466164614461656145") // {"a": "A", "b": "B", "c": "C", "a": "F", "d": "D", "e": "E"}
|
||
|
|
|
||
|
|
var b []byte
|
||
|
|
for i := 0; i < 3; i++ {
|
||
|
|
b = append(b, cborData...)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Duplicate key overwrites previous value (default).
|
||
|
|
wantS := s{B: "B", C: "C", D: "D", E: "E"}
|
||
|
|
dec := NewDecoder(bytes.NewReader(b))
|
||
|
|
for i := 0; i < 3; i++ {
|
||
|
|
var s1 s
|
||
|
|
if err := dec.Decode(&s1); err != nil {
|
||
|
|
t.Errorf("Decode() returned error %v", err)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(s1, wantS) {
|
||
|
|
t.Errorf("Decode() = %v (%T), want %v (%T)", s1, s1, wantS, wantS)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var v interface{}
|
||
|
|
if err := dec.Decode(&v); err != io.EOF {
|
||
|
|
t.Errorf("Decode() returned error %v, want %v", err, io.EOF)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Duplicate key triggers error.
|
||
|
|
wantS = s{B: "B", C: "C"}
|
||
|
|
wantErrorMsg := "cbor: found duplicate map key \"a\" at map element index 3"
|
||
|
|
dm, _ := DecOptions{DupMapKey: DupMapKeyEnforcedAPF}.DecMode()
|
||
|
|
dec = dm.NewDecoder(bytes.NewReader(b))
|
||
|
|
for i := 0; i < 3; i++ {
|
||
|
|
var s2 s
|
||
|
|
if err := dec.Decode(&s2); err == nil {
|
||
|
|
t.Errorf("Decode() didn't return an error")
|
||
|
|
} else if _, ok := err.(*DupMapKeyError); !ok {
|
||
|
|
t.Errorf("Decode() returned wrong error type %T, want (*DupMapKeyError)", err)
|
||
|
|
} else if err.Error() != wantErrorMsg {
|
||
|
|
t.Errorf("Decode() returned error %q, want error containing %q", err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(s2, wantS) {
|
||
|
|
t.Errorf("Decode() = %v (%T), want %v (%T)", s2, s2, wantS, wantS)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if err := dec.Decode(&v); err != io.EOF {
|
||
|
|
t.Errorf("Decode() returned error %v, want %v", err, io.EOF)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalDupMapKeyToStructKeyAsIntNoMatchingField(t *testing.T) {
|
||
|
|
type s struct {
|
||
|
|
B int `cbor:"3,keyasint"`
|
||
|
|
C int `cbor:"5,keyasint"`
|
||
|
|
}
|
||
|
|
cborData := hexDecode("a40102030401030506") // {1:2, 3:4, 1:3, 5:6}
|
||
|
|
|
||
|
|
wantS := s{B: 4, C: 6}
|
||
|
|
var s1 s
|
||
|
|
if err := Unmarshal(cborData, &s1); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(s1, wantS) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %+v (%T), want %+v (%T)", cborData, s1, s1, wantS, wantS)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Duplicate key triggers error even though map key "a" doesn't have a corresponding struct field.
|
||
|
|
wantS = s{B: 4}
|
||
|
|
wantErrorMsg := "cbor: found duplicate map key \"1\" at map element index 2"
|
||
|
|
dm, _ := DecOptions{DupMapKey: DupMapKeyEnforcedAPF}.DecMode()
|
||
|
|
var s2 s
|
||
|
|
if err := dm.Unmarshal(cborData, &s2); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x, %s) didn't return an error", cborData, reflect.TypeOf(s2))
|
||
|
|
} else if _, ok := err.(*DupMapKeyError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned wrong error type %T, want (*DupMapKeyError)", cborData, err)
|
||
|
|
} else if !strings.Contains(err.Error(), wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing %q", cborData, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(s2, wantS) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %+v (%T), want %+v (%T)", cborData, s2, s2, wantS, wantS)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestStreamDupMapKeyToStructKeyAsIntNoMatchingField(t *testing.T) {
|
||
|
|
type s struct {
|
||
|
|
B int `cbor:"3,keyasint"`
|
||
|
|
C int `cbor:"5,keyasint"`
|
||
|
|
}
|
||
|
|
cborData := hexDecode("a40102030401030506") // {1:2, 3:4, 1:3, 5:6}
|
||
|
|
|
||
|
|
var b []byte
|
||
|
|
for i := 0; i < 3; i++ {
|
||
|
|
b = append(b, cborData...)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Duplicate key overwrites previous value (default).
|
||
|
|
wantS := s{B: 4, C: 6}
|
||
|
|
dec := NewDecoder(bytes.NewReader(b))
|
||
|
|
for i := 0; i < 3; i++ {
|
||
|
|
var s1 s
|
||
|
|
if err := dec.Decode(&s1); err != nil {
|
||
|
|
t.Errorf("Decode() returned error %v", err)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(s1, wantS) {
|
||
|
|
t.Errorf("Decode() = %v (%T), want %v (%T)", s1, s1, wantS, wantS)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var v interface{}
|
||
|
|
if err := dec.Decode(&v); err != io.EOF {
|
||
|
|
t.Errorf("Decode() returned error %v, want %v", err, io.EOF)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Duplicate key triggers error.
|
||
|
|
wantS = s{B: 4}
|
||
|
|
wantErrorMsg := "cbor: found duplicate map key \"1\" at map element index 2"
|
||
|
|
dm, _ := DecOptions{DupMapKey: DupMapKeyEnforcedAPF}.DecMode()
|
||
|
|
dec = dm.NewDecoder(bytes.NewReader(b))
|
||
|
|
for i := 0; i < 3; i++ {
|
||
|
|
var s2 s
|
||
|
|
if err := dec.Decode(&s2); err == nil {
|
||
|
|
t.Errorf("Decode() didn't return an error")
|
||
|
|
} else if _, ok := err.(*DupMapKeyError); !ok {
|
||
|
|
t.Errorf("Decode() returned wrong error type %T, want (*DupMapKeyError)", err)
|
||
|
|
} else if err.Error() != wantErrorMsg {
|
||
|
|
t.Errorf("Decode() returned error %q, want error containing %q", err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(s2, wantS) {
|
||
|
|
t.Errorf("Decode() = %v (%T), want %v (%T)", s2, s2, wantS, wantS)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if err := dec.Decode(&v); err != io.EOF {
|
||
|
|
t.Errorf("Decode() returned error %v, want %v", err, io.EOF)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalDupMapKeyToStructWrongType(t *testing.T) {
|
||
|
|
type s struct {
|
||
|
|
A string `cbor:"a"`
|
||
|
|
B string `cbor:"b"`
|
||
|
|
C string `cbor:"c"`
|
||
|
|
D string `cbor:"d"`
|
||
|
|
E string `cbor:"e"`
|
||
|
|
}
|
||
|
|
cborData := hexDecode("a861616141fa47c35000026162614261636143fa47c3500003616161466164614461656145") // {"a": "A", 100000.0:2, "b": "B", "c": "C", 100000.0:3, "a": "F", "d": "D", "e": "E"}
|
||
|
|
|
||
|
|
var s1 s
|
||
|
|
wantS := s{A: "A", B: "B", C: "C", D: "D", E: "E"}
|
||
|
|
wantErrorMsg := "cbor: cannot unmarshal"
|
||
|
|
if err := Unmarshal(cborData, &s1); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error", cborData)
|
||
|
|
} else if _, ok := err.(*UnmarshalTypeError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned wrong error type %T, want (*UnmarshalTypeError)", cborData, err)
|
||
|
|
} else if !strings.Contains(err.Error(), wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing %q", cborData, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(s1, wantS) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %+v (%T), want %+v (%T)", cborData, s1, s1, wantS, wantS)
|
||
|
|
}
|
||
|
|
|
||
|
|
wantS = s{A: "A", B: "B", C: "C"}
|
||
|
|
wantErrorMsg = "cbor: found duplicate map key \"100000\" at map element index 4"
|
||
|
|
dm, _ := DecOptions{DupMapKey: DupMapKeyEnforcedAPF}.DecMode()
|
||
|
|
var s2 s
|
||
|
|
if err := dm.Unmarshal(cborData, &s2); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x, %s) didn't return an error", cborData, reflect.TypeOf(s2))
|
||
|
|
} else if _, ok := err.(*DupMapKeyError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned wrong error type %T, want (*DupMapKeyError)", cborData, err)
|
||
|
|
} else if !strings.Contains(err.Error(), wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing %q", cborData, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(s2, wantS) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %+v (%T), want %+v (%T)", cborData, s2, s2, wantS, wantS)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestStreamDupMapKeyToStructWrongType(t *testing.T) {
|
||
|
|
type s struct {
|
||
|
|
A string `cbor:"a"`
|
||
|
|
B string `cbor:"b"`
|
||
|
|
C string `cbor:"c"`
|
||
|
|
D string `cbor:"d"`
|
||
|
|
E string `cbor:"e"`
|
||
|
|
}
|
||
|
|
cborData := hexDecode("a861616141fa47c35000026162614261636143fa47c3500003616161466164614461656145") // {"a": "A", 100000.0:2, "b": "B", "c": "C", 100000.0:3, "a": "F", "d": "D", "e": "E"}
|
||
|
|
|
||
|
|
var b []byte
|
||
|
|
for i := 0; i < 3; i++ {
|
||
|
|
b = append(b, cborData...)
|
||
|
|
}
|
||
|
|
|
||
|
|
wantS := s{A: "A", B: "B", C: "C", D: "D", E: "E"}
|
||
|
|
wantErrorMsg := "cbor: cannot unmarshal"
|
||
|
|
dec := NewDecoder(bytes.NewReader(b))
|
||
|
|
for i := 0; i < 3; i++ {
|
||
|
|
var s1 s
|
||
|
|
if err := dec.Decode(&s1); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error", cborData)
|
||
|
|
} else if _, ok := err.(*UnmarshalTypeError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned wrong error type %T, want (*UnmarshalTypeError)", cborData, err)
|
||
|
|
} else if !strings.Contains(err.Error(), wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing %q", cborData, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(s1, wantS) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %+v (%T), want %+v (%T)", cborData, s1, s1, wantS, wantS)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var v interface{}
|
||
|
|
if err := dec.Decode(&v); err != io.EOF {
|
||
|
|
t.Errorf("Decode() returned error %v, want %v", err, io.EOF)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Duplicate key triggers error.
|
||
|
|
wantS = s{A: "A", B: "B", C: "C"}
|
||
|
|
wantErrorMsg = "cbor: found duplicate map key \"100000\" at map element index 4"
|
||
|
|
dm, _ := DecOptions{DupMapKey: DupMapKeyEnforcedAPF}.DecMode()
|
||
|
|
dec = dm.NewDecoder(bytes.NewReader(b))
|
||
|
|
for i := 0; i < 3; i++ {
|
||
|
|
var s2 s
|
||
|
|
if err := dec.Decode(&s2); err == nil {
|
||
|
|
t.Errorf("Decode() didn't return an error")
|
||
|
|
} else if _, ok := err.(*DupMapKeyError); !ok {
|
||
|
|
t.Errorf("Decode() returned wrong error type %T, want (*DupMapKeyError)", err)
|
||
|
|
} else if err.Error() != wantErrorMsg {
|
||
|
|
t.Errorf("Decode() returned error %q, want error containing %q", err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(s2, wantS) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %+v (%T), want %+v (%T)", cborData, s2, s2, wantS, wantS)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if err := dec.Decode(&v); err != io.EOF {
|
||
|
|
t.Errorf("Decode() returned error %v, want %v", err, io.EOF)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalDupMapKeyToStructStringParseError(t *testing.T) {
|
||
|
|
type s struct {
|
||
|
|
A string `cbor:"a"`
|
||
|
|
B string `cbor:"b"`
|
||
|
|
C string `cbor:"c"`
|
||
|
|
D string `cbor:"d"`
|
||
|
|
E string `cbor:"e"`
|
||
|
|
}
|
||
|
|
cborData := hexDecode("a661fe6141616261426163614361fe61466164614461656145") // {"\xFE": "A", "b": "B", "c": "C", "\xFE": "F", "d": "D", "e": "E"}
|
||
|
|
wantS := s{A: "", B: "B", C: "C", D: "D", E: "E"}
|
||
|
|
wantErrorMsg := "cbor: invalid UTF-8 string"
|
||
|
|
|
||
|
|
// Duplicate key doesn't overwrite previous value (default).
|
||
|
|
var s1 s
|
||
|
|
if err := Unmarshal(cborData, &s1); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error", cborData)
|
||
|
|
} else if _, ok := err.(*SemanticError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned wrong error type %T, want (*SemanticError)", cborData, err)
|
||
|
|
} else if !strings.Contains(err.Error(), wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing %q", cborData, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(s1, wantS) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %+v (%T), want %+v (%T)", cborData, s1, s1, wantS, wantS)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Duplicate key triggers error.
|
||
|
|
dm, _ := DecOptions{DupMapKey: DupMapKeyEnforcedAPF}.DecMode()
|
||
|
|
var s2 s
|
||
|
|
if err := dm.Unmarshal(cborData, &s2); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x, %s) didn't return an error", cborData, reflect.TypeOf(s2))
|
||
|
|
} else if _, ok := err.(*SemanticError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned wrong error type %T, want (*SemanticError)", cborData, err)
|
||
|
|
} else if !strings.Contains(err.Error(), wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing %q", cborData, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(s2, wantS) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %+v (%T), want %+v (%T)", cborData, s2, s2, wantS, wantS)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalDupMapKeyToStructIntParseError(t *testing.T) {
|
||
|
|
type s struct {
|
||
|
|
A int `cbor:"1,keyasint"`
|
||
|
|
B int `cbor:"3,keyasint"`
|
||
|
|
C int `cbor:"5,keyasint"`
|
||
|
|
}
|
||
|
|
cborData := hexDecode("a43bffffffffffffffff0203043bffffffffffffffff030506") // {-18446744073709551616:2, 3:4, -18446744073709551616:3, 5:6}
|
||
|
|
|
||
|
|
// Duplicate key doesn't overwrite previous value (default).
|
||
|
|
wantS := s{B: 4, C: 6}
|
||
|
|
wantErrorMsg := "cbor: cannot unmarshal"
|
||
|
|
var s1 s
|
||
|
|
if err := Unmarshal(cborData, &s1); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error", cborData)
|
||
|
|
} else if _, ok := err.(*UnmarshalTypeError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned wrong error type %T, want (*UnmarshalTypeError)", cborData, err)
|
||
|
|
} else if !strings.Contains(err.Error(), wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing %q", cborData, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(s1, wantS) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %+v (%T), want %+v (%T)", cborData, s1, s1, wantS, wantS)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Duplicate key triggers error.
|
||
|
|
dm, _ := DecOptions{DupMapKey: DupMapKeyEnforcedAPF}.DecMode()
|
||
|
|
var s2 s
|
||
|
|
if err := dm.Unmarshal(cborData, &s2); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x, %s) didn't return an error", cborData, reflect.TypeOf(s2))
|
||
|
|
} else if _, ok := err.(*UnmarshalTypeError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned wrong error type %T, want (*UnmarshalTypeError)", cborData, err)
|
||
|
|
} else if !strings.Contains(err.Error(), wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing %q", cborData, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(s2, wantS) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %+v (%T), want %+v (%T)", cborData, s2, s2, wantS, wantS)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalDupMapKeyToStructWrongTypeParseError(t *testing.T) {
|
||
|
|
type s struct {
|
||
|
|
A string `cbor:"a"`
|
||
|
|
B string `cbor:"b"`
|
||
|
|
C string `cbor:"c"`
|
||
|
|
D string `cbor:"d"`
|
||
|
|
E string `cbor:"e"`
|
||
|
|
}
|
||
|
|
cborData := hexDecode("a68161fe614161626142616361438161fe61466164614461656145") // {["\xFE"]: "A", "b": "B", "c": "C", ["\xFE"]: "F", "d": "D", "e": "E"}
|
||
|
|
|
||
|
|
// Duplicate key doesn't overwrite previous value (default).
|
||
|
|
wantS := s{A: "", B: "B", C: "C", D: "D", E: "E"}
|
||
|
|
wantErrorMsg := "cbor: cannot unmarshal"
|
||
|
|
var s1 s
|
||
|
|
if err := Unmarshal(cborData, &s1); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error", cborData)
|
||
|
|
} else if _, ok := err.(*UnmarshalTypeError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned wrong error type %T, want (*UnmarshalTypeError)", cborData, err)
|
||
|
|
} else if !strings.Contains(err.Error(), wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing %q", cborData, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(s1, wantS) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %+v (%T), want %+v (%T)", cborData, s1, s1, wantS, wantS)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Duplicate key triggers error.
|
||
|
|
dm, _ := DecOptions{DupMapKey: DupMapKeyEnforcedAPF}.DecMode()
|
||
|
|
var s2 s
|
||
|
|
if err := dm.Unmarshal(cborData, &s2); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x, %s) didn't return an error", cborData, reflect.TypeOf(s2))
|
||
|
|
} else if _, ok := err.(*UnmarshalTypeError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned wrong error type %T, want (*UnmarshalTypeError)", cborData, err)
|
||
|
|
} else if !strings.Contains(err.Error(), wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing %q", cborData, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(s2, wantS) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %+v (%T), want %+v (%T)", cborData, s2, s2, wantS, wantS)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalDupMapKeyToStructWrongTypeUnhashableError(t *testing.T) {
|
||
|
|
type s struct {
|
||
|
|
A string `cbor:"a"`
|
||
|
|
B string `cbor:"b"`
|
||
|
|
C string `cbor:"c"`
|
||
|
|
D string `cbor:"d"`
|
||
|
|
E string `cbor:"e"`
|
||
|
|
}
|
||
|
|
cborData := hexDecode("a6810061416162614261636143810061466164614461656145") // {[0]: "A", "b": "B", "c": "C", [0]: "F", "d": "D", "e": "E"}
|
||
|
|
wantS := s{A: "", B: "B", C: "C", D: "D", E: "E"}
|
||
|
|
|
||
|
|
// Duplicate key doesn't overwrite previous value (default).
|
||
|
|
wantErrorMsg := "cbor: cannot unmarshal"
|
||
|
|
var s1 s
|
||
|
|
if err := Unmarshal(cborData, &s1); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error", cborData)
|
||
|
|
} else if _, ok := err.(*UnmarshalTypeError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned wrong error type %T, want (*UnmarshalTypeError)", cborData, err)
|
||
|
|
} else if !strings.Contains(err.Error(), wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing %q", cborData, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(s1, wantS) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %+v (%T), want %+v (%T)", cborData, s1, s1, wantS, wantS)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Duplicate key triggers error.
|
||
|
|
dm, _ := DecOptions{DupMapKey: DupMapKeyEnforcedAPF}.DecMode()
|
||
|
|
var s2 s
|
||
|
|
if err := dm.Unmarshal(cborData, &s2); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x, %s) didn't return an error", cborData, reflect.TypeOf(s2))
|
||
|
|
} else if _, ok := err.(*UnmarshalTypeError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned wrong error type %T, want (*UnmarshalTypeError)", cborData, err)
|
||
|
|
} else if !strings.Contains(err.Error(), wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing %q", cborData, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(s2, wantS) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %+v (%T), want %+v (%T)", cborData, s2, s2, wantS, wantS)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalDupMapKeyToStructTagTypeError(t *testing.T) {
|
||
|
|
type s struct {
|
||
|
|
A string `cbor:"a"`
|
||
|
|
B string `cbor:"b"`
|
||
|
|
C string `cbor:"c"`
|
||
|
|
D string `cbor:"d"`
|
||
|
|
E string `cbor:"e"`
|
||
|
|
}
|
||
|
|
cborData := hexDecode("a6c24901000000000000000061416162614261636143c24901000000000000000061466164614461656145") // {bignum(18446744073709551616): "A", "b": "B", "c": "C", bignum(18446744073709551616): "F", "d": "D", "e": "E"}
|
||
|
|
wantS := s{A: "", B: "B", C: "C", D: "D", E: "E"}
|
||
|
|
|
||
|
|
// Duplicate key doesn't overwrite previous value (default).
|
||
|
|
wantErrorMsg := "cbor: cannot unmarshal"
|
||
|
|
var s1 s
|
||
|
|
if err := Unmarshal(cborData, &s1); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error", cborData)
|
||
|
|
} else if _, ok := err.(*UnmarshalTypeError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned wrong error type %T, want (*UnmarshalTypeError)", cborData, err)
|
||
|
|
} else if !strings.Contains(err.Error(), wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing %q", cborData, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(s1, wantS) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %+v (%T), want %+v (%T)", cborData, s1, s1, wantS, wantS)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Duplicate key triggers error.
|
||
|
|
dm, _ := DecOptions{DupMapKey: DupMapKeyEnforcedAPF}.DecMode()
|
||
|
|
var s2 s
|
||
|
|
if err := dm.Unmarshal(cborData, &s2); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x, %s) didn't return an error", cborData, reflect.TypeOf(s2))
|
||
|
|
} else if _, ok := err.(*UnmarshalTypeError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned wrong error type %T, want (*UnmarshalTypeError)", cborData, err)
|
||
|
|
} else if !strings.Contains(err.Error(), wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing %q", cborData, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(s2, wantS) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %+v (%T), want %+v (%T)", cborData, s2, s2, wantS, wantS)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestIndefiniteLengthArrayToArray(t *testing.T) {
|
||
|
|
testCases := []struct {
|
||
|
|
name string
|
||
|
|
cborData []byte
|
||
|
|
wantV interface{}
|
||
|
|
}{
|
||
|
|
{
|
||
|
|
name: "CBOR empty array to Go 5 elem array",
|
||
|
|
cborData: hexDecode("9fff"),
|
||
|
|
wantV: [5]byte{},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "CBOR 3 elem array to Go 5 elem array",
|
||
|
|
cborData: hexDecode("9f010203ff"),
|
||
|
|
wantV: [5]byte{1, 2, 3, 0, 0},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "CBOR 10 elem array to Go 5 elem array",
|
||
|
|
cborData: hexDecode("9f0102030405060708090aff"),
|
||
|
|
wantV: [5]byte{1, 2, 3, 4, 5},
|
||
|
|
},
|
||
|
|
}
|
||
|
|
|
||
|
|
for _, tc := range testCases {
|
||
|
|
t.Run(tc.name, func(t *testing.T) {
|
||
|
|
v := reflect.New(reflect.TypeOf(tc.wantV))
|
||
|
|
if err := Unmarshal(tc.cborData, v.Interface()); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", tc.cborData, err)
|
||
|
|
}
|
||
|
|
if !reflect.DeepEqual(v.Elem().Interface(), tc.wantV) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", tc.cborData, v.Elem().Interface(), v.Elem().Interface(), tc.wantV, tc.wantV)
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestExceedMaxArrayElements(t *testing.T) {
|
||
|
|
testCases := []struct {
|
||
|
|
name string
|
||
|
|
opts DecOptions
|
||
|
|
cborData []byte
|
||
|
|
wantErrorMsg string
|
||
|
|
}{
|
||
|
|
{
|
||
|
|
name: "array",
|
||
|
|
opts: DecOptions{MaxArrayElements: 16},
|
||
|
|
cborData: hexDecode("910101010101010101010101010101010101"),
|
||
|
|
wantErrorMsg: "cbor: exceeded max number of elements 16 for CBOR array",
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "indefinite length array",
|
||
|
|
opts: DecOptions{MaxArrayElements: 16},
|
||
|
|
cborData: hexDecode("9f0101010101010101010101010101010101ff"),
|
||
|
|
wantErrorMsg: "cbor: exceeded max number of elements 16 for CBOR array",
|
||
|
|
},
|
||
|
|
}
|
||
|
|
for _, tc := range testCases {
|
||
|
|
t.Run(tc.name, func(t *testing.T) {
|
||
|
|
dm, _ := tc.opts.DecMode()
|
||
|
|
var v interface{}
|
||
|
|
if err := dm.Unmarshal(tc.cborData, &v); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error", tc.cborData)
|
||
|
|
} else if err.Error() != tc.wantErrorMsg {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want %q", tc.cborData, err.Error(), tc.wantErrorMsg)
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestExceedMaxMapPairs(t *testing.T) {
|
||
|
|
testCases := []struct {
|
||
|
|
name string
|
||
|
|
opts DecOptions
|
||
|
|
cborData []byte
|
||
|
|
wantErrorMsg string
|
||
|
|
}{
|
||
|
|
{
|
||
|
|
name: "array",
|
||
|
|
opts: DecOptions{MaxMapPairs: 16},
|
||
|
|
cborData: hexDecode("b101010101010101010101010101010101010101010101010101010101010101010101"),
|
||
|
|
wantErrorMsg: "cbor: exceeded max number of key-value pairs 16 for CBOR map",
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "indefinite length array",
|
||
|
|
opts: DecOptions{MaxMapPairs: 16},
|
||
|
|
cborData: hexDecode("bf01010101010101010101010101010101010101010101010101010101010101010101ff"),
|
||
|
|
wantErrorMsg: "cbor: exceeded max number of key-value pairs 16 for CBOR map",
|
||
|
|
},
|
||
|
|
}
|
||
|
|
for _, tc := range testCases {
|
||
|
|
t.Run(tc.name, func(t *testing.T) {
|
||
|
|
dm, _ := tc.opts.DecMode()
|
||
|
|
var v interface{}
|
||
|
|
if err := dm.Unmarshal(tc.cborData, &v); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error", tc.cborData)
|
||
|
|
} else if err.Error() != tc.wantErrorMsg {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want %q", tc.cborData, err.Error(), tc.wantErrorMsg)
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestDecIndefiniteLengthOption(t *testing.T) {
|
||
|
|
testCases := []struct {
|
||
|
|
name string
|
||
|
|
opts DecOptions
|
||
|
|
cborData []byte
|
||
|
|
wantErrorMsg string
|
||
|
|
}{
|
||
|
|
{
|
||
|
|
name: "byte string",
|
||
|
|
opts: DecOptions{IndefLength: IndefLengthForbidden},
|
||
|
|
cborData: hexDecode("5fff"),
|
||
|
|
wantErrorMsg: "cbor: indefinite-length byte string isn't allowed",
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "text string",
|
||
|
|
opts: DecOptions{IndefLength: IndefLengthForbidden},
|
||
|
|
cborData: hexDecode("7fff"),
|
||
|
|
wantErrorMsg: "cbor: indefinite-length UTF-8 text string isn't allowed",
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "array",
|
||
|
|
opts: DecOptions{IndefLength: IndefLengthForbidden},
|
||
|
|
cborData: hexDecode("9fff"),
|
||
|
|
wantErrorMsg: "cbor: indefinite-length array isn't allowed",
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "indefinite length array",
|
||
|
|
opts: DecOptions{IndefLength: IndefLengthForbidden},
|
||
|
|
cborData: hexDecode("bfff"),
|
||
|
|
wantErrorMsg: "cbor: indefinite-length map isn't allowed",
|
||
|
|
},
|
||
|
|
}
|
||
|
|
for _, tc := range testCases {
|
||
|
|
t.Run(tc.name, func(t *testing.T) {
|
||
|
|
// Default option allows indefinite length items
|
||
|
|
var v interface{}
|
||
|
|
if err := Unmarshal(tc.cborData, &v); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned an error %v", tc.cborData, err)
|
||
|
|
}
|
||
|
|
|
||
|
|
dm, _ := tc.opts.DecMode()
|
||
|
|
if err := dm.Unmarshal(tc.cborData, &v); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error", tc.cborData)
|
||
|
|
} else if err.Error() != tc.wantErrorMsg {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want %q", tc.cborData, err.Error(), tc.wantErrorMsg)
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestDecTagsMdOption(t *testing.T) {
|
||
|
|
cborData := hexDecode("c074323031332d30332d32315432303a30343a30305a")
|
||
|
|
wantErrorMsg := "cbor: CBOR tag isn't allowed"
|
||
|
|
|
||
|
|
// Default option allows CBOR tags
|
||
|
|
var v interface{}
|
||
|
|
if err := Unmarshal(cborData, &v); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned an error %v", cborData, err)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Decoding CBOR tags with TagsForbidden option returns error
|
||
|
|
dm, _ := DecOptions{TagsMd: TagsForbidden}.DecMode()
|
||
|
|
if err := dm.Unmarshal(cborData, &v); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error", cborData)
|
||
|
|
} else if err.Error() != wantErrorMsg {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want %q", cborData, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Create DecMode with TagSet and TagsForbidden option returns error
|
||
|
|
wantErrorMsg = "cbor: cannot create DecMode with TagSet when TagsMd is TagsForbidden"
|
||
|
|
tags := NewTagSet()
|
||
|
|
_, err := DecOptions{TagsMd: TagsForbidden}.DecModeWithTags(tags)
|
||
|
|
if err == nil {
|
||
|
|
t.Errorf("DecModeWithTags() didn't return an error")
|
||
|
|
} else if err.Error() != wantErrorMsg {
|
||
|
|
t.Errorf("DecModeWithTags() returned error %q, want %q", err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
_, err = DecOptions{TagsMd: TagsForbidden}.DecModeWithSharedTags(tags)
|
||
|
|
if err == nil {
|
||
|
|
t.Errorf("DecModeWithSharedTags() didn't return an error")
|
||
|
|
} else if err.Error() != wantErrorMsg {
|
||
|
|
t.Errorf("DecModeWithSharedTags() returned error %q, want %q", err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestDecModeInvalidIntDec(t *testing.T) {
|
||
|
|
wantErrorMsg := "cbor: invalid IntDec 101"
|
||
|
|
_, err := DecOptions{IntDec: 101}.DecMode()
|
||
|
|
if err == nil {
|
||
|
|
t.Errorf("DecMode() didn't return an error")
|
||
|
|
} else if err.Error() != wantErrorMsg {
|
||
|
|
t.Errorf("DecMode() returned error %q, want %q", err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestIntDec(t *testing.T) {
|
||
|
|
dm, err := DecOptions{IntDec: IntDecConvertSigned}.DecMode()
|
||
|
|
if err != nil {
|
||
|
|
t.Errorf("DecMode() returned an error %+v", err)
|
||
|
|
}
|
||
|
|
|
||
|
|
testCases := []struct {
|
||
|
|
name string
|
||
|
|
cborData []byte
|
||
|
|
wantObj interface{}
|
||
|
|
wantErrorMsg string
|
||
|
|
}{
|
||
|
|
{
|
||
|
|
name: "CBOR pos int",
|
||
|
|
cborData: hexDecode("1a000f4240"),
|
||
|
|
wantObj: int64(1000000),
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "CBOR pos int overflows int64",
|
||
|
|
cborData: hexDecode("1bffffffffffffffff"),
|
||
|
|
wantErrorMsg: "18446744073709551615 overflows Go's int64",
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "CBOR neg int",
|
||
|
|
cborData: hexDecode("3903e7"),
|
||
|
|
wantObj: int64(-1000),
|
||
|
|
},
|
||
|
|
}
|
||
|
|
for _, tc := range testCases {
|
||
|
|
t.Run(tc.name, func(t *testing.T) {
|
||
|
|
var v interface{}
|
||
|
|
err := dm.Unmarshal(tc.cborData, &v)
|
||
|
|
if err == nil {
|
||
|
|
if tc.wantErrorMsg != "" {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error, want %q", tc.cborData, tc.wantErrorMsg)
|
||
|
|
} else if !reflect.DeepEqual(v, tc.wantObj) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) return %v (%T), want %v (%T)", tc.cborData, v, v, tc.wantObj, tc.wantObj)
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if tc.wantErrorMsg == "" {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q", tc.cborData, err)
|
||
|
|
} else if !strings.Contains(err.Error(), tc.wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want %q", tc.cborData, err.Error(), tc.wantErrorMsg)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestDecModeInvalidExtraError(t *testing.T) {
|
||
|
|
wantErrorMsg := "cbor: invalid ExtraReturnErrors 3"
|
||
|
|
_, err := DecOptions{ExtraReturnErrors: 3}.DecMode()
|
||
|
|
if err == nil {
|
||
|
|
t.Errorf("DecMode() didn't return an error")
|
||
|
|
} else if err.Error() != wantErrorMsg {
|
||
|
|
t.Errorf("DecMode() returned error %q, want %q", err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestExtraErrorCondUnknowField(t *testing.T) {
|
||
|
|
type s struct {
|
||
|
|
A string
|
||
|
|
B string
|
||
|
|
C string
|
||
|
|
}
|
||
|
|
|
||
|
|
dm, _ := DecOptions{}.DecMode()
|
||
|
|
dmUnknownFieldError, _ := DecOptions{ExtraReturnErrors: ExtraDecErrorUnknownField}.DecMode()
|
||
|
|
|
||
|
|
testCases := []struct {
|
||
|
|
name string
|
||
|
|
cborData []byte
|
||
|
|
dm DecMode
|
||
|
|
wantObj interface{}
|
||
|
|
wantErrorMsg string
|
||
|
|
}{
|
||
|
|
{
|
||
|
|
name: "field by field match",
|
||
|
|
cborData: hexDecode("a3614161616142616261436163"), // map[string]string{"A": "a", "B": "b", "C": "c"}
|
||
|
|
dm: dm,
|
||
|
|
wantObj: s{A: "a", B: "b", C: "c"},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "field by field match with ExtraDecErrorUnknownField",
|
||
|
|
cborData: hexDecode("a3614161616142616261436163"), // map[string]string{"A": "a", "B": "b", "C": "c"}
|
||
|
|
dm: dmUnknownFieldError,
|
||
|
|
wantObj: s{A: "a", B: "b", C: "c"},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "CBOR map less field",
|
||
|
|
cborData: hexDecode("a26141616161426162"), // map[string]string{"A": "a", "B": "b"}
|
||
|
|
dm: dm,
|
||
|
|
wantObj: s{A: "a", B: "b", C: ""},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "CBOR map less field with ExtraDecErrorUnknownField",
|
||
|
|
cborData: hexDecode("a26141616161426162"), // map[string]string{"A": "a", "B": "b"}
|
||
|
|
dm: dmUnknownFieldError,
|
||
|
|
wantObj: s{A: "a", B: "b", C: ""},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "CBOR map unknown field",
|
||
|
|
cborData: hexDecode("a461416161614261626143616361446164"), // map[string]string{"A": "a", "B": "b", "C": "c", "D": "d"}
|
||
|
|
dm: dm,
|
||
|
|
wantObj: s{A: "a", B: "b", C: "c"},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "CBOR map unknown field with ExtraDecErrorUnknownField",
|
||
|
|
cborData: hexDecode("a461416161614261626143616361446164"), // map[string]string{"A": "a", "B": "b", "C": "c", "D": "d"}
|
||
|
|
dm: dmUnknownFieldError,
|
||
|
|
wantErrorMsg: "cbor: found unknown field at map element index 3",
|
||
|
|
},
|
||
|
|
}
|
||
|
|
for _, tc := range testCases {
|
||
|
|
t.Run(tc.name, func(t *testing.T) {
|
||
|
|
var v s
|
||
|
|
err := tc.dm.Unmarshal(tc.cborData, &v)
|
||
|
|
if err == nil {
|
||
|
|
if tc.wantErrorMsg != "" {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error, want %q", tc.cborData, tc.wantErrorMsg)
|
||
|
|
} else if !reflect.DeepEqual(v, tc.wantObj) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) return %v (%T), want %v (%T)", tc.cborData, v, v, tc.wantObj, tc.wantObj)
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if tc.wantErrorMsg == "" {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q", tc.cborData, err)
|
||
|
|
} else if !strings.Contains(err.Error(), tc.wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want %q", tc.cborData, err.Error(), tc.wantErrorMsg)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestStreamExtraErrorCondUnknowField(t *testing.T) {
|
||
|
|
type s struct {
|
||
|
|
A string
|
||
|
|
B string
|
||
|
|
C string
|
||
|
|
}
|
||
|
|
|
||
|
|
cborData := hexDecode("a461416161614461646142616261436163a3614161616142616261436163") // map[string]string{"A": "a", "D": "d", "B": "b", "C": "c"}, map[string]string{"A": "a", "B": "b", "C": "c"}
|
||
|
|
wantErrorMsg := "cbor: found unknown field at map element index 1"
|
||
|
|
wantObj := s{A: "a", B: "b", C: "c"}
|
||
|
|
|
||
|
|
dmUnknownFieldError, _ := DecOptions{ExtraReturnErrors: ExtraDecErrorUnknownField}.DecMode()
|
||
|
|
dec := dmUnknownFieldError.NewDecoder(bytes.NewReader(cborData))
|
||
|
|
|
||
|
|
var v1 s
|
||
|
|
err := dec.Decode(&v1)
|
||
|
|
if err == nil {
|
||
|
|
t.Errorf("Decode() didn't return an error, want %q", wantErrorMsg)
|
||
|
|
} else if !strings.Contains(err.Error(), wantErrorMsg) {
|
||
|
|
t.Errorf("Decode() returned error %q, want %q", err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
|
||
|
|
var v2 s
|
||
|
|
err = dec.Decode(&v2)
|
||
|
|
if err != nil {
|
||
|
|
t.Errorf("Decode() returned an error %v", err)
|
||
|
|
} else if !reflect.DeepEqual(v2, wantObj) {
|
||
|
|
t.Errorf("Decode() return %v (%T), want %v (%T)", v2, v2, wantObj, wantObj)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// TestUnmarshalTagNum55799 is identical to TestUnmarshal,
|
||
|
|
// except that CBOR test data is prefixed with tag number 55799 (0xd9d9f7).
|
||
|
|
func TestUnmarshalTagNum55799(t *testing.T) {
|
||
|
|
tagNum55799 := hexDecode("d9d9f7")
|
||
|
|
|
||
|
|
for _, tc := range unmarshalTests {
|
||
|
|
// Prefix tag number 55799 to CBOR test data
|
||
|
|
cborData := make([]byte, len(tc.cborData)+6)
|
||
|
|
copy(cborData, tagNum55799)
|
||
|
|
copy(cborData[3:], tagNum55799)
|
||
|
|
copy(cborData[6:], tc.cborData)
|
||
|
|
|
||
|
|
// Test unmarshalling CBOR into empty interface.
|
||
|
|
var v interface{}
|
||
|
|
if err := Unmarshal(cborData, &v); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
} else {
|
||
|
|
if tm, ok := tc.emptyInterfaceValue.(time.Time); ok {
|
||
|
|
if vt, ok := v.(time.Time); !ok || !tm.Equal(vt) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", cborData, v, v, tc.emptyInterfaceValue, tc.emptyInterfaceValue)
|
||
|
|
}
|
||
|
|
} else if !reflect.DeepEqual(v, tc.emptyInterfaceValue) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", cborData, v, v, tc.emptyInterfaceValue, tc.emptyInterfaceValue)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test unmarshalling CBOR into RawMessage.
|
||
|
|
var r RawMessage
|
||
|
|
if err := Unmarshal(cborData, &r); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
} else if !bytes.Equal(r, tc.cborData) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned RawMessage %v, want %v", cborData, r, tc.cborData)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test unmarshalling CBOR into compatible data types.
|
||
|
|
for _, value := range tc.values {
|
||
|
|
v := reflect.New(reflect.TypeOf(value))
|
||
|
|
vPtr := v.Interface()
|
||
|
|
if err := Unmarshal(cborData, vPtr); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
} else {
|
||
|
|
if tm, ok := value.(time.Time); ok {
|
||
|
|
if vt, ok := v.Elem().Interface().(time.Time); !ok || !tm.Equal(vt) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", cborData, v.Elem().Interface(), v.Elem().Interface(), value, value)
|
||
|
|
}
|
||
|
|
} else if !reflect.DeepEqual(v.Elem().Interface(), value) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", cborData, v.Elem().Interface(), v.Elem().Interface(), value, value)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test unmarshalling CBOR into incompatible data types.
|
||
|
|
for _, typ := range tc.wrongTypes {
|
||
|
|
v := reflect.New(typ)
|
||
|
|
vPtr := v.Interface()
|
||
|
|
if err := Unmarshal(cborData, vPtr); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x, %s) didn't return an error", cborData, typ.String())
|
||
|
|
} else if _, ok := err.(*UnmarshalTypeError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned wrong error type %T, want (*UnmarshalTypeError)", cborData, err)
|
||
|
|
} else if !strings.Contains(err.Error(), "cannot unmarshal") {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing %q", cborData, err.Error(), "cannot unmarshal")
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// TestUnmarshalFloatWithTagNum55799 is identical to TestUnmarshalFloat,
|
||
|
|
// except that CBOR test data is prefixed with tag number 55799 (0xd9d9f7).
|
||
|
|
func TestUnmarshalFloatWithTagNum55799(t *testing.T) {
|
||
|
|
tagNum55799 := hexDecode("d9d9f7")
|
||
|
|
|
||
|
|
for _, tc := range unmarshalFloatTests {
|
||
|
|
// Prefix tag number 55799 to CBOR test data
|
||
|
|
cborData := make([]byte, len(tc.cborData)+3)
|
||
|
|
copy(cborData, tagNum55799)
|
||
|
|
copy(cborData[3:], tc.cborData)
|
||
|
|
|
||
|
|
// Test unmarshalling CBOR into empty interface.
|
||
|
|
var v interface{}
|
||
|
|
if err := Unmarshal(tc.cborData, &v); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", tc.cborData, err)
|
||
|
|
} else {
|
||
|
|
testFloat(t, tc.cborData, v, tc.emptyInterfaceValue, tc.equalityThreshold)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test unmarshalling CBOR into RawMessage.
|
||
|
|
var r RawMessage
|
||
|
|
if err := Unmarshal(tc.cborData, &r); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", tc.cborData, err)
|
||
|
|
} else if !bytes.Equal(r, tc.cborData) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned RawMessage %v, want %v", tc.cborData, r, tc.cborData)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test unmarshalling CBOR into compatible data types.
|
||
|
|
for _, value := range tc.values {
|
||
|
|
v := reflect.New(reflect.TypeOf(value))
|
||
|
|
vPtr := v.Interface()
|
||
|
|
if err := Unmarshal(tc.cborData, vPtr); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", tc.cborData, err)
|
||
|
|
} else {
|
||
|
|
testFloat(t, tc.cborData, v.Elem().Interface(), value, tc.equalityThreshold)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test unmarshalling CBOR into incompatible data types.
|
||
|
|
for _, typ := range tc.wrongTypes {
|
||
|
|
v := reflect.New(typ)
|
||
|
|
vPtr := v.Interface()
|
||
|
|
if err := Unmarshal(tc.cborData, vPtr); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error", tc.cborData)
|
||
|
|
} else if _, ok := err.(*UnmarshalTypeError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned wrong error type %T, want (*UnmarshalTypeError)", tc.cborData, err)
|
||
|
|
} else if !strings.Contains(err.Error(), "cannot unmarshal") {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing %q", tc.cborData, err.Error(), "cannot unmarshal")
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalTagNum55799AsElement(t *testing.T) {
|
||
|
|
testCases := []struct {
|
||
|
|
name string
|
||
|
|
cborData []byte
|
||
|
|
emptyInterfaceValue interface{}
|
||
|
|
values []interface{}
|
||
|
|
wrongTypes []reflect.Type
|
||
|
|
}{
|
||
|
|
{
|
||
|
|
"array",
|
||
|
|
hexDecode("d9d9f783d9d9f701d9d9f702d9d9f703"), // 55799([55799(1), 55799(2), 55799(3)])
|
||
|
|
[]interface{}{uint64(1), uint64(2), uint64(3)},
|
||
|
|
[]interface{}{[]interface{}{uint64(1), uint64(2), uint64(3)}, []byte{1, 2, 3}, []int{1, 2, 3}, []uint{1, 2, 3}, [0]int{}, [1]int{1}, [3]int{1, 2, 3}, [5]int{1, 2, 3, 0, 0}, []float32{1, 2, 3}, []float64{1, 2, 3}},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeString, typeBool, typeStringSlice, typeMapStringInt, reflect.TypeOf([3]string{}), typeTag, typeRawTag},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
"map",
|
||
|
|
hexDecode("d9d9f7a2d9d9f701d9d9f702d9d9f703d9d9f704"), // 55799({55799(1): 55799(2), 55799(3): 55799(4)})
|
||
|
|
map[interface{}]interface{}{uint64(1): uint64(2), uint64(3): uint64(4)},
|
||
|
|
[]interface{}{map[interface{}]interface{}{uint64(1): uint64(2), uint64(3): uint64(4)}, map[uint]int{1: 2, 3: 4}, map[int]uint{1: 2, 3: 4}},
|
||
|
|
[]reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeByteSlice, typeByteArray, typeString, typeBool, typeIntSlice, typeMapStringInt, typeTag, typeRawTag},
|
||
|
|
},
|
||
|
|
}
|
||
|
|
for _, tc := range testCases {
|
||
|
|
t.Run(tc.name, func(t *testing.T) {
|
||
|
|
// Test unmarshalling CBOR into empty interface.
|
||
|
|
var v interface{}
|
||
|
|
if err := Unmarshal(tc.cborData, &v); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", tc.cborData, err)
|
||
|
|
} else {
|
||
|
|
if tm, ok := tc.emptyInterfaceValue.(time.Time); ok {
|
||
|
|
if vt, ok := v.(time.Time); !ok || !tm.Equal(vt) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", tc.cborData, v, v, tc.emptyInterfaceValue, tc.emptyInterfaceValue)
|
||
|
|
}
|
||
|
|
} else if !reflect.DeepEqual(v, tc.emptyInterfaceValue) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", tc.cborData, v, v, tc.emptyInterfaceValue, tc.emptyInterfaceValue)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test unmarshalling CBOR into compatible data types.
|
||
|
|
for _, value := range tc.values {
|
||
|
|
v := reflect.New(reflect.TypeOf(value))
|
||
|
|
vPtr := v.Interface()
|
||
|
|
if err := Unmarshal(tc.cborData, vPtr); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", tc.cborData, err)
|
||
|
|
} else {
|
||
|
|
if tm, ok := value.(time.Time); ok {
|
||
|
|
if vt, ok := v.Elem().Interface().(time.Time); !ok || !tm.Equal(vt) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", tc.cborData, v.Elem().Interface(), v.Elem().Interface(), value, value)
|
||
|
|
}
|
||
|
|
} else if !reflect.DeepEqual(v.Elem().Interface(), value) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", tc.cborData, v.Elem().Interface(), v.Elem().Interface(), value, value)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Test unmarshalling CBOR into incompatible data types.
|
||
|
|
for _, typ := range tc.wrongTypes {
|
||
|
|
v := reflect.New(typ)
|
||
|
|
vPtr := v.Interface()
|
||
|
|
if err := Unmarshal(tc.cborData, vPtr); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x, %s) didn't return an error", tc.cborData, typ.String())
|
||
|
|
} else if _, ok := err.(*UnmarshalTypeError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned wrong error type %T, want (*UnmarshalTypeError)", tc.cborData, err)
|
||
|
|
} else if !strings.Contains(err.Error(), "cannot unmarshal") {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want error containing %q", tc.cborData, err.Error(), "cannot unmarshal")
|
||
|
|
}
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalTagNum55799ToBinaryUnmarshaler(t *testing.T) {
|
||
|
|
cborData := hexDecode("d9d9f74800000000499602d2") // 55799(h'00000000499602D2')
|
||
|
|
wantObj := number(1234567890)
|
||
|
|
|
||
|
|
var v number
|
||
|
|
if err := Unmarshal(cborData, &v); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
} else if !reflect.DeepEqual(v, wantObj) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", cborData, v, v, wantObj, wantObj)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalTagNum55799ToUnmarshaler(t *testing.T) {
|
||
|
|
cborData := hexDecode("d9d9f7d864a1636e756d01") // 55799(100({"num": 1}))
|
||
|
|
wantObj := number3(1)
|
||
|
|
|
||
|
|
var v number3
|
||
|
|
if err := Unmarshal(cborData, &v); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
} else if !reflect.DeepEqual(v, wantObj) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", cborData, v, v, wantObj, wantObj)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalTagNum55799ToRegisteredGoType(t *testing.T) {
|
||
|
|
type myInt int
|
||
|
|
typ := reflect.TypeOf(myInt(0))
|
||
|
|
|
||
|
|
tags := NewTagSet()
|
||
|
|
if err := tags.Add(TagOptions{EncTag: EncTagRequired, DecTag: DecTagRequired}, typ, 125); err != nil {
|
||
|
|
t.Fatalf("TagSet.Add(%s, %v) returned error %v", typ, 125, err)
|
||
|
|
}
|
||
|
|
|
||
|
|
dm, _ := DecOptions{}.DecModeWithTags(tags)
|
||
|
|
|
||
|
|
cborData := hexDecode("d9d9f7d87d01") // 55799(125(1))
|
||
|
|
wantObj := myInt(1)
|
||
|
|
|
||
|
|
var v myInt
|
||
|
|
if err := dm.Unmarshal(cborData, &v); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
} else if !reflect.DeepEqual(v, wantObj) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", cborData, v, v, wantObj, wantObj)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// TODO: wait for clarification from 7049bis https://github.com/cbor-wg/CBORbis/issues/183
|
||
|
|
// Nested tag number 55799 may be stripeed as well depending on 7049bis clarification.
|
||
|
|
func TestUnmarshalNestedTagNum55799ToEmptyInterface(t *testing.T) {
|
||
|
|
cborData := hexDecode("d864d9d9f701") // 100(55799(1))
|
||
|
|
wantObj := Tag{100, Tag{55799, uint64(1)}}
|
||
|
|
|
||
|
|
var v interface{}
|
||
|
|
if err := Unmarshal(cborData, &v); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
} else if !reflect.DeepEqual(v, wantObj) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", cborData, v, v, wantObj, wantObj)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalNestedTagNum55799ToValue(t *testing.T) {
|
||
|
|
cborData := hexDecode("d864d9d9f701") // 100(55799(1))
|
||
|
|
wantObj := 1
|
||
|
|
|
||
|
|
var v int
|
||
|
|
if err := Unmarshal(cborData, &v); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
} else if !reflect.DeepEqual(v, wantObj) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", cborData, v, v, wantObj, wantObj)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalNestedTagNum55799ToTag(t *testing.T) {
|
||
|
|
cborData := hexDecode("d864d9d9f701") // 100(55799(1))
|
||
|
|
wantObj := Tag{100, Tag{55799, uint64(1)}}
|
||
|
|
|
||
|
|
var v Tag
|
||
|
|
if err := Unmarshal(cborData, &v); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
} else if !reflect.DeepEqual(v, wantObj) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", cborData, v, v, wantObj, wantObj)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalNestedTagNum55799ToTime(t *testing.T) {
|
||
|
|
cborData := hexDecode("c0d9d9f774323031332d30332d32315432303a30343a30305a") // 0(55799("2013-03-21T20:04:00Z"))
|
||
|
|
wantErrorMsg := "tag number 0 must be followed by text string, got tag"
|
||
|
|
|
||
|
|
var v time.Time
|
||
|
|
if err := Unmarshal(cborData, &v); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return error", cborData)
|
||
|
|
} else if !strings.Contains(err.Error(), wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %s, want %s", cborData, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalNestedTagNum55799ToBinaryUnmarshaler(t *testing.T) {
|
||
|
|
cborData := hexDecode("d864d9d9f74800000000499602d2") // 100(55799(h'00000000499602D2'))
|
||
|
|
wantObj := number(1234567890)
|
||
|
|
|
||
|
|
var v number
|
||
|
|
if err := Unmarshal(cborData, &v); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", cborData, err)
|
||
|
|
} else if !reflect.DeepEqual(v, wantObj) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", cborData, v, v, wantObj, wantObj)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalNestedTagNum55799ToUnmarshaler(t *testing.T) {
|
||
|
|
cborData := hexDecode("d864d9d9f7a1636e756d01") // 100(55799({"num": 1}))
|
||
|
|
wantErrorMsg := "wrong tag content type"
|
||
|
|
|
||
|
|
var v number3
|
||
|
|
if err := Unmarshal(cborData, &v); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return error", cborData)
|
||
|
|
} else if !strings.Contains(err.Error(), wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %s, want %s", cborData, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalNestedTagNum55799ToRegisteredGoType(t *testing.T) {
|
||
|
|
type myInt int
|
||
|
|
typ := reflect.TypeOf(myInt(0))
|
||
|
|
|
||
|
|
tags := NewTagSet()
|
||
|
|
if err := tags.Add(TagOptions{EncTag: EncTagRequired, DecTag: DecTagRequired}, typ, 125); err != nil {
|
||
|
|
t.Fatalf("TagSet.Add(%s, %v) returned error %v", typ, 125, err)
|
||
|
|
}
|
||
|
|
|
||
|
|
dm, _ := DecOptions{}.DecModeWithTags(tags)
|
||
|
|
|
||
|
|
cborData := hexDecode("d87dd9d9f701") // 125(55799(1))
|
||
|
|
wantErrorMsg := "cbor: wrong tag number for cbor.myInt, got [125 55799], expected [125]"
|
||
|
|
|
||
|
|
var v myInt
|
||
|
|
if err := dm.Unmarshal(cborData, &v); err == nil {
|
||
|
|
t.Errorf("Unmarshal() didn't return error")
|
||
|
|
} else if !strings.Contains(err.Error(), wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %s, want %s", cborData, err.Error(), wantErrorMsg)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalPosIntToBigInt(t *testing.T) {
|
||
|
|
cborData := hexDecode("1bffffffffffffffff") // 18446744073709551615
|
||
|
|
wantEmptyInterfaceValue := uint64(18446744073709551615)
|
||
|
|
wantBigIntValue := bigIntOrPanic("18446744073709551615")
|
||
|
|
|
||
|
|
var v1 interface{}
|
||
|
|
if err := Unmarshal(cborData, &v1); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %+v", cborData, err)
|
||
|
|
} else if !reflect.DeepEqual(v1, wantEmptyInterfaceValue) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned %v (%T), want %v (%T)", cborData, v1, v1, wantEmptyInterfaceValue, wantEmptyInterfaceValue)
|
||
|
|
}
|
||
|
|
|
||
|
|
var v2 big.Int
|
||
|
|
if err := Unmarshal(cborData, &v2); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %+v", cborData, err)
|
||
|
|
} else if !reflect.DeepEqual(v2, wantBigIntValue) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned %v (%T), want %v (%T)", cborData, v2, v2, wantBigIntValue, wantBigIntValue)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalNegIntToBigInt(t *testing.T) {
|
||
|
|
testCases := []struct {
|
||
|
|
name string
|
||
|
|
cborData []byte
|
||
|
|
wantEmptyInterfaceValue interface{}
|
||
|
|
wantBigIntValue big.Int
|
||
|
|
}{
|
||
|
|
{
|
||
|
|
name: "fit Go int64",
|
||
|
|
cborData: hexDecode("3b7fffffffffffffff"), // -9223372036854775808
|
||
|
|
wantEmptyInterfaceValue: int64(-9223372036854775808),
|
||
|
|
wantBigIntValue: bigIntOrPanic("-9223372036854775808"),
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "overflow Go int64",
|
||
|
|
cborData: hexDecode("3b8000000000000000"), // -9223372036854775809
|
||
|
|
wantEmptyInterfaceValue: bigIntOrPanic("-9223372036854775809"),
|
||
|
|
wantBigIntValue: bigIntOrPanic("-9223372036854775809"),
|
||
|
|
},
|
||
|
|
}
|
||
|
|
for _, tc := range testCases {
|
||
|
|
t.Run(tc.name, func(t *testing.T) {
|
||
|
|
var v1 interface{}
|
||
|
|
if err := Unmarshal(tc.cborData, &v1); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %+v", tc.cborData, err)
|
||
|
|
} else if !reflect.DeepEqual(v1, tc.wantEmptyInterfaceValue) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned %v (%T), want %v (%T)", tc.cborData, v1, v1, tc.wantEmptyInterfaceValue, tc.wantEmptyInterfaceValue)
|
||
|
|
}
|
||
|
|
|
||
|
|
var v2 big.Int
|
||
|
|
if err := Unmarshal(tc.cborData, &v2); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %+v", tc.cborData, err)
|
||
|
|
} else if !reflect.DeepEqual(v2, tc.wantBigIntValue) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned %v (%T), want %v (%T)", tc.cborData, v2, v2, tc.wantBigIntValue, tc.wantBigIntValue)
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalTag2(t *testing.T) {
|
||
|
|
testCases := []struct {
|
||
|
|
name string
|
||
|
|
cborData []byte
|
||
|
|
wantEmptyInterfaceValue interface{}
|
||
|
|
wantValues []interface{}
|
||
|
|
}{
|
||
|
|
{
|
||
|
|
name: "fit Go int64",
|
||
|
|
cborData: hexDecode("c2430f4240"), // 2(1000000)
|
||
|
|
wantEmptyInterfaceValue: bigIntOrPanic("1000000"),
|
||
|
|
wantValues: []interface{}{
|
||
|
|
int64(1000000),
|
||
|
|
uint64(1000000),
|
||
|
|
float32(1000000),
|
||
|
|
float64(1000000),
|
||
|
|
bigIntOrPanic("1000000"),
|
||
|
|
},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "fit Go uint64",
|
||
|
|
cborData: hexDecode("c248ffffffffffffffff"), // 2(18446744073709551615)
|
||
|
|
wantEmptyInterfaceValue: bigIntOrPanic("18446744073709551615"),
|
||
|
|
wantValues: []interface{}{
|
||
|
|
uint64(18446744073709551615),
|
||
|
|
float32(18446744073709551615),
|
||
|
|
float64(18446744073709551615),
|
||
|
|
bigIntOrPanic("18446744073709551615"),
|
||
|
|
},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "fit Go uint64 with leading zeros",
|
||
|
|
cborData: hexDecode("c24900ffffffffffffffff"), // 2(18446744073709551615)
|
||
|
|
wantEmptyInterfaceValue: bigIntOrPanic("18446744073709551615"),
|
||
|
|
wantValues: []interface{}{
|
||
|
|
uint64(18446744073709551615),
|
||
|
|
float32(18446744073709551615),
|
||
|
|
float64(18446744073709551615),
|
||
|
|
bigIntOrPanic("18446744073709551615"),
|
||
|
|
},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "overflow Go uint64",
|
||
|
|
cborData: hexDecode("c249010000000000000000"), // 2(18446744073709551616)
|
||
|
|
wantEmptyInterfaceValue: bigIntOrPanic("18446744073709551616"),
|
||
|
|
wantValues: []interface{}{
|
||
|
|
bigIntOrPanic("18446744073709551616"),
|
||
|
|
},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "overflow Go uint64 with leading zeros",
|
||
|
|
cborData: hexDecode("c24b0000010000000000000000"), // 2(18446744073709551616)
|
||
|
|
wantEmptyInterfaceValue: bigIntOrPanic("18446744073709551616"),
|
||
|
|
wantValues: []interface{}{
|
||
|
|
bigIntOrPanic("18446744073709551616"),
|
||
|
|
},
|
||
|
|
},
|
||
|
|
}
|
||
|
|
for _, tc := range testCases {
|
||
|
|
t.Run(tc.name, func(t *testing.T) {
|
||
|
|
var v1 interface{}
|
||
|
|
if err := Unmarshal(tc.cborData, &v1); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %+v", tc.cborData, err)
|
||
|
|
} else if !reflect.DeepEqual(v1, tc.wantEmptyInterfaceValue) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned %v (%T), want %v (%T)", tc.cborData, v1, v1, tc.wantEmptyInterfaceValue, tc.wantEmptyInterfaceValue)
|
||
|
|
}
|
||
|
|
|
||
|
|
for _, wantValue := range tc.wantValues {
|
||
|
|
v := reflect.New(reflect.TypeOf(wantValue))
|
||
|
|
if err := Unmarshal(tc.cborData, v.Interface()); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %+v", tc.cborData, err)
|
||
|
|
} else if !reflect.DeepEqual(v.Elem().Interface(), wantValue) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned %v (%T), want %v (%T)", tc.cborData, v.Elem().Interface(), v.Elem().Interface(), wantValue, wantValue)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalTag3(t *testing.T) {
|
||
|
|
testCases := []struct {
|
||
|
|
name string
|
||
|
|
cborData []byte
|
||
|
|
wantEmptyInterfaceValue interface{}
|
||
|
|
wantValues []interface{}
|
||
|
|
}{
|
||
|
|
{
|
||
|
|
name: "fit Go int64",
|
||
|
|
cborData: hexDecode("c3487fffffffffffffff"), // 3(-9223372036854775808)
|
||
|
|
wantEmptyInterfaceValue: bigIntOrPanic("-9223372036854775808"),
|
||
|
|
wantValues: []interface{}{
|
||
|
|
int64(-9223372036854775808),
|
||
|
|
float32(-9223372036854775808),
|
||
|
|
float64(-9223372036854775808),
|
||
|
|
bigIntOrPanic("-9223372036854775808"),
|
||
|
|
},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "fit Go int64 with leading zeros",
|
||
|
|
cborData: hexDecode("c349007fffffffffffffff"), // 3(-9223372036854775808)
|
||
|
|
wantEmptyInterfaceValue: bigIntOrPanic("-9223372036854775808"),
|
||
|
|
wantValues: []interface{}{
|
||
|
|
int64(-9223372036854775808),
|
||
|
|
float32(-9223372036854775808),
|
||
|
|
float64(-9223372036854775808),
|
||
|
|
bigIntOrPanic("-9223372036854775808"),
|
||
|
|
},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "overflow Go int64",
|
||
|
|
cborData: hexDecode("c349010000000000000000"), // 3(-18446744073709551617)
|
||
|
|
wantEmptyInterfaceValue: bigIntOrPanic("-18446744073709551617"),
|
||
|
|
wantValues: []interface{}{
|
||
|
|
bigIntOrPanic("-18446744073709551617"),
|
||
|
|
},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "overflow Go int64 with leading zeros",
|
||
|
|
cborData: hexDecode("c34b0000010000000000000000"), // 3(-18446744073709551617)
|
||
|
|
wantEmptyInterfaceValue: bigIntOrPanic("-18446744073709551617"),
|
||
|
|
wantValues: []interface{}{
|
||
|
|
bigIntOrPanic("-18446744073709551617"),
|
||
|
|
},
|
||
|
|
},
|
||
|
|
}
|
||
|
|
for _, tc := range testCases {
|
||
|
|
t.Run(tc.name, func(t *testing.T) {
|
||
|
|
var v1 interface{}
|
||
|
|
if err := Unmarshal(tc.cborData, &v1); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %+v", tc.cborData, err)
|
||
|
|
} else if !reflect.DeepEqual(v1, tc.wantEmptyInterfaceValue) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned %v (%T), want %v (%T)", tc.cborData, v1, v1, tc.wantEmptyInterfaceValue, tc.wantEmptyInterfaceValue)
|
||
|
|
}
|
||
|
|
|
||
|
|
for _, wantValue := range tc.wantValues {
|
||
|
|
v := reflect.New(reflect.TypeOf(wantValue))
|
||
|
|
if err := Unmarshal(tc.cborData, v.Interface()); err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %+v", tc.cborData, err)
|
||
|
|
} else if !reflect.DeepEqual(v.Elem().Interface(), wantValue) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned %v (%T), want %v (%T)", tc.cborData, v.Elem().Interface(), v.Elem().Interface(), wantValue, wantValue)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalInvalidTagBignum(t *testing.T) {
|
||
|
|
typeBigIntSlice := reflect.TypeOf([]big.Int{})
|
||
|
|
|
||
|
|
testCases := []struct {
|
||
|
|
name string
|
||
|
|
cborData []byte
|
||
|
|
decodeToTypes []reflect.Type
|
||
|
|
wantErrorMsg string
|
||
|
|
}{
|
||
|
|
{
|
||
|
|
name: "Tag 2 with string",
|
||
|
|
cborData: hexDecode("c27f657374726561646d696e67ff"),
|
||
|
|
decodeToTypes: []reflect.Type{typeIntf, typeBigInt},
|
||
|
|
wantErrorMsg: "cbor: tag number 2 or 3 must be followed by byte string, got UTF-8 text string",
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "Tag 3 with string",
|
||
|
|
cborData: hexDecode("c37f657374726561646d696e67ff"),
|
||
|
|
decodeToTypes: []reflect.Type{typeIntf, typeBigInt},
|
||
|
|
wantErrorMsg: "cbor: tag number 2 or 3 must be followed by byte string, got UTF-8 text string",
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "Tag 3 with negavtive int",
|
||
|
|
cborData: hexDecode("81C330"), // [3(-17)]
|
||
|
|
decodeToTypes: []reflect.Type{typeIntf, typeBigIntSlice},
|
||
|
|
wantErrorMsg: "cbor: tag number 2 or 3 must be followed by byte string, got negative integer",
|
||
|
|
},
|
||
|
|
}
|
||
|
|
for _, tc := range testCases {
|
||
|
|
for _, decodeToType := range tc.decodeToTypes {
|
||
|
|
t.Run(tc.name+" decode to "+decodeToType.String(), func(t *testing.T) {
|
||
|
|
v := reflect.New(decodeToType)
|
||
|
|
if err := Unmarshal(tc.cborData, v.Interface()); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return error, want error msg %q", tc.cborData, tc.wantErrorMsg)
|
||
|
|
} else if !strings.Contains(err.Error(), tc.wantErrorMsg) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %q, want %q", tc.cborData, err, tc.wantErrorMsg)
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
type Foo interface {
|
||
|
|
Foo() string
|
||
|
|
}
|
||
|
|
|
||
|
|
type UintFoo uint
|
||
|
|
|
||
|
|
func (f *UintFoo) Foo() string {
|
||
|
|
return fmt.Sprint(f)
|
||
|
|
}
|
||
|
|
|
||
|
|
type IntFoo int
|
||
|
|
|
||
|
|
func (f *IntFoo) Foo() string {
|
||
|
|
return fmt.Sprint(*f)
|
||
|
|
}
|
||
|
|
|
||
|
|
type ByteFoo []byte
|
||
|
|
|
||
|
|
func (f *ByteFoo) Foo() string {
|
||
|
|
return fmt.Sprint(*f)
|
||
|
|
}
|
||
|
|
|
||
|
|
type StringFoo string
|
||
|
|
|
||
|
|
func (f *StringFoo) Foo() string {
|
||
|
|
return string(*f)
|
||
|
|
}
|
||
|
|
|
||
|
|
type ArrayFoo []int
|
||
|
|
|
||
|
|
func (f *ArrayFoo) Foo() string {
|
||
|
|
return fmt.Sprint(*f)
|
||
|
|
}
|
||
|
|
|
||
|
|
type MapFoo map[int]int
|
||
|
|
|
||
|
|
func (f *MapFoo) Foo() string {
|
||
|
|
return fmt.Sprint(*f)
|
||
|
|
}
|
||
|
|
|
||
|
|
type StructFoo struct {
|
||
|
|
Value int `cbor:"1,keyasint"`
|
||
|
|
}
|
||
|
|
|
||
|
|
func (f *StructFoo) Foo() string {
|
||
|
|
return fmt.Sprint(*f)
|
||
|
|
}
|
||
|
|
|
||
|
|
type TestExample struct {
|
||
|
|
Message string `cbor:"1,keyasint"`
|
||
|
|
Foo Foo `cbor:"2,keyasint"`
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalToInterface(t *testing.T) {
|
||
|
|
|
||
|
|
uintFoo, uintFoo123 := UintFoo(0), UintFoo(123)
|
||
|
|
intFoo, intFooNeg1 := IntFoo(0), IntFoo(-1)
|
||
|
|
byteFoo, byteFoo123 := ByteFoo(nil), ByteFoo([]byte{1, 2, 3})
|
||
|
|
stringFoo, stringFoo123 := StringFoo(""), StringFoo("123")
|
||
|
|
arrayFoo, arrayFoo123 := ArrayFoo(nil), ArrayFoo([]int{1, 2, 3})
|
||
|
|
mapFoo, mapFoo123 := MapFoo(nil), MapFoo(map[int]int{1: 1, 2: 2, 3: 3})
|
||
|
|
|
||
|
|
em, _ := EncOptions{Sort: SortCanonical}.EncMode()
|
||
|
|
|
||
|
|
testCases := []struct {
|
||
|
|
name string
|
||
|
|
data []byte
|
||
|
|
v *TestExample
|
||
|
|
unmarshalToObj *TestExample
|
||
|
|
}{
|
||
|
|
{
|
||
|
|
name: "uint",
|
||
|
|
data: hexDecode("a2016b736f6d65206d657373676502187b"), // {1: "some messge", 2: 123}
|
||
|
|
v: &TestExample{
|
||
|
|
Message: "some messge",
|
||
|
|
Foo: &uintFoo123,
|
||
|
|
},
|
||
|
|
unmarshalToObj: &TestExample{Foo: &uintFoo},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "int",
|
||
|
|
data: hexDecode("a2016b736f6d65206d65737367650220"), // {1: "some messge", 2: -1}
|
||
|
|
v: &TestExample{
|
||
|
|
Message: "some messge",
|
||
|
|
Foo: &intFooNeg1,
|
||
|
|
},
|
||
|
|
unmarshalToObj: &TestExample{Foo: &intFoo},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "bytes",
|
||
|
|
data: hexDecode("a2016b736f6d65206d65737367650243010203"), // {1: "some messge", 2: [1,2,3]}
|
||
|
|
v: &TestExample{
|
||
|
|
Message: "some messge",
|
||
|
|
Foo: &byteFoo123,
|
||
|
|
},
|
||
|
|
unmarshalToObj: &TestExample{Foo: &byteFoo},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "string",
|
||
|
|
data: hexDecode("a2016b736f6d65206d65737367650263313233"), // {1: "some messge", 2: "123"}
|
||
|
|
v: &TestExample{
|
||
|
|
Message: "some messge",
|
||
|
|
Foo: &stringFoo123,
|
||
|
|
},
|
||
|
|
unmarshalToObj: &TestExample{Foo: &stringFoo},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "array",
|
||
|
|
data: hexDecode("a2016b736f6d65206d65737367650283010203"), // {1: "some messge", 2: []int{1,2,3}}
|
||
|
|
v: &TestExample{
|
||
|
|
Message: "some messge",
|
||
|
|
Foo: &arrayFoo123,
|
||
|
|
},
|
||
|
|
unmarshalToObj: &TestExample{Foo: &arrayFoo},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "map",
|
||
|
|
data: hexDecode("a2016b736f6d65206d657373676502a3010102020303"), // {1: "some messge", 2: map[int]int{1:1,2:2,3:3}}
|
||
|
|
v: &TestExample{
|
||
|
|
Message: "some messge",
|
||
|
|
Foo: &mapFoo123,
|
||
|
|
},
|
||
|
|
unmarshalToObj: &TestExample{Foo: &mapFoo},
|
||
|
|
},
|
||
|
|
{
|
||
|
|
name: "struct",
|
||
|
|
data: hexDecode("a2016b736f6d65206d657373676502a1011901c8"), // {1: "some messge", 2: {1: 456}}
|
||
|
|
v: &TestExample{
|
||
|
|
Message: "some messge",
|
||
|
|
Foo: &StructFoo{Value: 456},
|
||
|
|
},
|
||
|
|
unmarshalToObj: &TestExample{Foo: &StructFoo{}},
|
||
|
|
},
|
||
|
|
}
|
||
|
|
|
||
|
|
for _, tc := range testCases {
|
||
|
|
t.Run(tc.name, func(t *testing.T) {
|
||
|
|
|
||
|
|
data, err := em.Marshal(tc.v)
|
||
|
|
if err != nil {
|
||
|
|
t.Errorf("Marshal(%+v) returned error %v", tc.v, err)
|
||
|
|
} else if !bytes.Equal(data, tc.data) {
|
||
|
|
t.Errorf("Marshal(%+v) = 0x%x, want 0x%x", tc.v, data, tc.v)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Unmarshal to empty interface
|
||
|
|
var einterface TestExample
|
||
|
|
if err = Unmarshal(data, &einterface); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error, want error (*UnmarshalTypeError)", data)
|
||
|
|
} else if _, ok := err.(*UnmarshalTypeError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned wrong type of error %T, want (*UnmarshalTypeError)", data, err)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Unmarshal to interface value
|
||
|
|
err = Unmarshal(data, tc.unmarshalToObj)
|
||
|
|
if err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", data, err)
|
||
|
|
} else if !reflect.DeepEqual(tc.unmarshalToObj, tc.v) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v, want %v", data, tc.unmarshalToObj, tc.v)
|
||
|
|
}
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
type Bar struct {
|
||
|
|
I int
|
||
|
|
}
|
||
|
|
|
||
|
|
func (b *Bar) Foo() string {
|
||
|
|
return fmt.Sprint(*b)
|
||
|
|
}
|
||
|
|
|
||
|
|
type FooStruct struct {
|
||
|
|
Foos []Foo
|
||
|
|
}
|
||
|
|
|
||
|
|
func TestUnmarshalTaggedDataToInterface(t *testing.T) {
|
||
|
|
|
||
|
|
var tags = NewTagSet()
|
||
|
|
err := tags.Add(
|
||
|
|
TagOptions{EncTag: EncTagRequired, DecTag: DecTagRequired},
|
||
|
|
reflect.TypeOf(&Bar{}),
|
||
|
|
4,
|
||
|
|
)
|
||
|
|
if err != nil {
|
||
|
|
t.Error(err)
|
||
|
|
}
|
||
|
|
|
||
|
|
v := &FooStruct{
|
||
|
|
Foos: []Foo{&Bar{1}},
|
||
|
|
}
|
||
|
|
|
||
|
|
want := hexDecode("a164466f6f7381c4a1614901") // {"Foos": [4({"I": 1})]}
|
||
|
|
|
||
|
|
em, _ := EncOptions{}.EncModeWithTags(tags)
|
||
|
|
data, err := em.Marshal(v)
|
||
|
|
if err != nil {
|
||
|
|
t.Errorf("Marshal(%+v) returned error %v", v, err)
|
||
|
|
} else if !bytes.Equal(data, want) {
|
||
|
|
t.Errorf("Marshal(%+v) = 0x%x, want 0x%x", v, data, want)
|
||
|
|
}
|
||
|
|
|
||
|
|
dm, _ := DecOptions{}.DecModeWithTags(tags)
|
||
|
|
|
||
|
|
// Unmarshal to empty interface
|
||
|
|
var v1 Bar
|
||
|
|
if err = dm.Unmarshal(data, &v1); err == nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) didn't return an error, want error (*UnmarshalTypeError)", data)
|
||
|
|
} else if _, ok := err.(*UnmarshalTypeError); !ok {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned wrong type of error %T, want (*UnmarshalTypeError)", data, err)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Unmarshal to interface value
|
||
|
|
v2 := &FooStruct{
|
||
|
|
Foos: []Foo{&Bar{}},
|
||
|
|
}
|
||
|
|
err = dm.Unmarshal(data, v2)
|
||
|
|
if err != nil {
|
||
|
|
t.Errorf("Unmarshal(0x%x) returned error %v", data, err)
|
||
|
|
} else if !reflect.DeepEqual(v2, v) {
|
||
|
|
t.Errorf("Unmarshal(0x%x) = %v, want %v", data, v2, v)
|
||
|
|
}
|
||
|
|
}
|