decode_test.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/json"
	"errors"
	"fmt"
	"io"
	"math"
	"math/big"
	"reflect"
	"strings"
	"testing"
	"time"
)

type namedAny any

var (
	typeBool           = reflect.TypeFor[bool]()
	typeUint8          = reflect.TypeFor[uint8]()
	typeUint16         = reflect.TypeFor[uint16]()
	typeUint32         = reflect.TypeFor[uint32]()
	typeUint64         = reflect.TypeFor[uint64]()
	typeInt8           = reflect.TypeFor[int8]()
	typeInt16          = reflect.TypeFor[int16]()
	typeInt32          = reflect.TypeFor[int32]()
	typeInt64          = reflect.TypeFor[int64]()
	typeFloat32        = reflect.TypeFor[float32]()
	typeFloat64        = reflect.TypeFor[float64]()
	typeByteArray      = reflect.TypeFor[[5]byte]()
	typeIntSlice       = reflect.TypeFor[[]int]()
	typeStringSlice    = reflect.TypeFor[[]string]()
	typeMapNamedAnyAny = reflect.TypeFor[map[namedAny]any]()
	typeMapStringInt   = reflect.TypeFor[map[string]int]()
	typeNamedAny       = reflect.TypeFor[namedAny]()
)

type unmarshalTestCase struct {
	data               []byte
	wantInterfaceValue any
	wantValues         []any
	wrongTypes         []reflect.Type
}

var unmarshalTestCases = []unmarshalTestCase{
	// CBOR test data are from https://tools.ietf.org/html/rfc7049#appendix-A.

	// unsigned integer
	{
		data:               mustHexDecode("00"),
		wantInterfaceValue: uint64(0),
		wantValues: []any{
			uint8(0),
			uint16(0),
			uint32(0),
			uint64(0),
			uint(0),
			int8(0),
			int16(0),
			int32(0),
			int64(0),
			int(0),
			float32(0),
			float64(0),
			mustBigInt("0"),
		},
		wrongTypes: []reflect.Type{
			typeString,
			typeBool,
			typeByteArray,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeByteString,
			typeSimpleValue,
		},
	},
	{
		data:               mustHexDecode("01"),
		wantInterfaceValue: uint64(1),
		wantValues: []any{
			uint8(1),
			uint16(1),
			uint32(1),
			uint64(1),
			uint(1),
			int8(1),
			int16(1),
			int32(1),
			int64(1),
			int(1),
			float32(1),
			float64(1),
			mustBigInt("1"),
		},
		wrongTypes: []reflect.Type{
			typeString,
			typeBool,
			typeByteArray,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeByteString,
			typeSimpleValue,
		},
	},
	{
		data:               mustHexDecode("0a"),
		wantInterfaceValue: uint64(10),
		wantValues: []any{
			uint8(10),
			uint16(10),
			uint32(10),
			uint64(10),
			uint(10),
			int8(10),
			int16(10),
			int32(10),
			int64(10),
			int(10),
			float32(10),
			float64(10),
			mustBigInt("10"),
		},
		wrongTypes: []reflect.Type{
			typeString,
			typeBool,
			typeByteArray,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeByteString,
			typeSimpleValue,
		},
	},
	{
		data:               mustHexDecode("17"),
		wantInterfaceValue: uint64(23),
		wantValues: []any{
			uint8(23),
			uint16(23),
			uint32(23),
			uint64(23),
			uint(23),
			int8(23),
			int16(23),
			int32(23),
			int64(23),
			int(23),
			float32(23),
			float64(23),
			mustBigInt("23"),
		},
		wrongTypes: []reflect.Type{
			typeString,
			typeBool,
			typeByteArray,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeByteString,
			typeSimpleValue,
		},
	},
	{
		data:               mustHexDecode("1818"),
		wantInterfaceValue: uint64(24),
		wantValues: []any{
			uint8(24),
			uint16(24),
			uint32(24),
			uint64(24),
			uint(24),
			int8(24),
			int16(24),
			int32(24),
			int64(24),
			int(24),
			float32(24),
			float64(24),
			mustBigInt("24"),
		},
		wrongTypes: []reflect.Type{
			typeString,
			typeBool,
			typeByteArray,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeByteString,
			typeSimpleValue,
		},
	},
	{
		data:               mustHexDecode("1819"),
		wantInterfaceValue: uint64(25),
		wantValues: []any{
			uint8(25),
			uint16(25),
			uint32(25),
			uint64(25),
			uint(25),
			int8(25),
			int16(25),
			int32(25),
			int64(25),
			int(25),
			float32(25),
			float64(25),
			mustBigInt("25"),
		},
		wrongTypes: []reflect.Type{
			typeString,
			typeBool,
			typeByteArray,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeByteString,
			typeSimpleValue,
		},
	},
	{
		data:               mustHexDecode("1864"),
		wantInterfaceValue: uint64(100),
		wantValues: []any{
			uint8(100),
			uint16(100),
			uint32(100),
			uint64(100),
			uint(100),
			int8(100),
			int16(100),
			int32(100),
			int64(100),
			int(100),
			float32(100),
			float64(100),
			mustBigInt("100"),
		},
		wrongTypes: []reflect.Type{
			typeString,
			typeBool,
			typeByteArray,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeByteString,
			typeSimpleValue,
		},
	},
	{
		data:               mustHexDecode("1903e8"),
		wantInterfaceValue: uint64(1000),
		wantValues: []any{
			uint16(1000),
			uint32(1000),
			uint64(1000),
			uint(1000),
			int16(1000),
			int32(1000),
			int64(1000),
			int(1000),
			float32(1000),
			float64(1000),
			mustBigInt("1000"),
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeInt8,
			typeString,
			typeBool,
			typeByteArray,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeByteString,
			typeSimpleValue,
		},
	},
	{
		data:               mustHexDecode("1a000f4240"),
		wantInterfaceValue: uint64(1000000),
		wantValues: []any{
			uint32(1000000),
			uint64(1000000),
			uint(1000000),
			int32(1000000),
			int64(1000000),
			int(1000000),
			float32(1000000),
			float64(1000000),
			mustBigInt("1000000"),
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeInt8,
			typeInt16,
			typeString,
			typeBool,
			typeByteArray,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeByteString,
			typeSimpleValue,
		},
	},
	{
		data:               mustHexDecode("1b000000e8d4a51000"),
		wantInterfaceValue: uint64(1000000000000),
		wantValues: []any{
			uint64(1000000000000),
			uint(1000000000000),
			int64(1000000000000),
			int(1000000000000),
			float32(1000000000000),
			float64(1000000000000),
			mustBigInt("1000000000000"),
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeInt8,
			typeInt16,
			typeInt32,
			typeString,
			typeBool,
			typeByteArray,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeByteString,
			typeSimpleValue,
		},
	},
	{
		data:               mustHexDecode("1bffffffffffffffff"),
		wantInterfaceValue: uint64(18446744073709551615),
		wantValues: []any{
			uint64(18446744073709551615),
			uint(18446744073709551615),
			float32(18446744073709551615),
			float64(18446744073709551615),
			mustBigInt("18446744073709551615"),
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeInt8,
			typeInt16,
			typeInt32,
			typeString,
			typeBool,
			typeByteArray,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeByteString,
			typeSimpleValue,
		},
	},

	// negative integer
	{
		data:               mustHexDecode("20"),
		wantInterfaceValue: int64(-1),
		wantValues: []any{
			int8(-1),
			int16(-1),
			int32(-1),
			int64(-1),
			int(-1),
			float32(-1),
			float64(-1),
			mustBigInt("-1"),
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeString,
			typeBool,
			typeByteArray,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeByteString,
			typeSimpleValue,
		},
	},
	{
		data:               mustHexDecode("29"),
		wantInterfaceValue: int64(-10),
		wantValues: []any{
			int8(-10),
			int16(-10),
			int32(-10),
			int64(-10),
			int(-10),
			float32(-10),
			float64(-10),
			mustBigInt("-10"),
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeString,
			typeBool,
			typeByteArray,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeByteString,
			typeSimpleValue,
		},
	},
	{
		data:               mustHexDecode("3863"),
		wantInterfaceValue: int64(-100),
		wantValues: []any{
			int8(-100),
			int16(-100),
			int32(-100),
			int64(-100),
			int(-100),
			float32(-100),
			float64(-100),
			mustBigInt("-100"),
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeString,
			typeBool,
			typeByteArray,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeByteString,
			typeSimpleValue,
		},
	},
	{
		data:               mustHexDecode("3903e7"),
		wantInterfaceValue: int64(-1000),
		wantValues: []any{
			int16(-1000),
			int32(-1000),
			int64(-1000),
			int(-1000),
			float32(-1000),
			float64(-1000),
			mustBigInt("-1000"),
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeString,
			typeBool,
			typeByteArray,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeByteString,
			typeSimpleValue,
		},
	},
	{
		data:               mustHexDecode("3bffffffffffffffff"),
		wantInterfaceValue: mustBigInt("-18446744073709551616"),
		wantValues: []any{
			mustBigInt("-18446744073709551616"),
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeString,
			typeBool,
			typeByteArray,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeByteString,
			typeSimpleValue,
		},
	}, // CBOR value -18446744073709551616 overflows Go's int64, see TestNegIntOverflow

	// byte string
	{
		data:               mustHexDecode("40"),
		wantInterfaceValue: []byte{},
		wantValues: []any{
			[]byte{},
			[0]byte{},
			[1]byte{0},
			[5]byte{0, 0, 0, 0, 0},
			ByteString(""),
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeBool,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeBigInt,
			typeSimpleValue,
			typeTime,
		},
	},
	{
		data:               mustHexDecode("4401020304"),
		wantInterfaceValue: []byte{1, 2, 3, 4},
		wantValues: []any{
			[]byte{1, 2, 3, 4},
			[0]byte{},
			[1]byte{1},
			[5]byte{1, 2, 3, 4, 0},
			ByteString("\x01\x02\x03\x04"),
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeBool,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeBigInt,
			typeSimpleValue,
			typeTime,
		},
	},
	{
		data:               mustHexDecode("5f42010243030405ff"),
		wantInterfaceValue: []byte{1, 2, 3, 4, 5},
		wantValues: []any{
			[]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},
			ByteString("\x01\x02\x03\x04\x05"),
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeBool,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeBigInt,
			typeSimpleValue,
			typeTime,
		},
	},

	// text string
	{
		data:               mustHexDecode("60"),
		wantInterfaceValue: "",
		wantValues:         []any{""},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeBool,
			typeByteArray,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeBigInt,
			typeByteString,
			typeSimpleValue,
		},
	},
	{
		data:               mustHexDecode("6161"),
		wantInterfaceValue: "a",
		wantValues:         []any{"a"},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeBool,
			typeByteArray,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeBigInt,
			typeByteString,
			typeSimpleValue,
		},
	},
	{
		data:               mustHexDecode("6449455446"),
		wantInterfaceValue: "IETF",
		wantValues:         []any{"IETF"},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeBool,
			typeByteArray,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeBigInt,
			typeByteString,
			typeSimpleValue,
		},
	},
	{
		data:               mustHexDecode("62225c"),
		wantInterfaceValue: "\"\\",
		wantValues:         []any{"\"\\"},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeBool,
			typeByteArray,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeBigInt,
			typeByteString,
			typeSimpleValue,
		},
	},
	{
		data:               mustHexDecode("62c3bc"),
		wantInterfaceValue: "ü",
		wantValues:         []any{"ü"},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeBool,
			typeByteArray,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeBigInt,
			typeByteString,
			typeSimpleValue,
		},
	},
	{
		data:               mustHexDecode("63e6b0b4"),
		wantInterfaceValue: "水",
		wantValues:         []any{"水"},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeBool,
			typeByteArray,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeBigInt,
			typeByteString,
			typeSimpleValue,
		},
	},
	{
		data:               mustHexDecode("64f0908591"),
		wantInterfaceValue: "𐅑",
		wantValues:         []any{"𐅑"},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeBool,
			typeByteArray,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeBigInt,
			typeByteString,
			typeSimpleValue,
		},
	},
	{
		data:               mustHexDecode("7f657374726561646d696e67ff"),
		wantInterfaceValue: "streaming",
		wantValues:         []any{"streaming"},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeBool,
			typeByteArray,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeBigInt,
			typeByteString,
			typeSimpleValue,
		},
	},

	// array
	{
		data:               mustHexDecode("80"),
		wantInterfaceValue: []any{},
		wantValues: []any{
			[]any{},
			[]byte{},
			[]string{},
			[]int{},
			[0]int{},
			[1]int{0},
			[5]int{0},
			[]float32{},
			[]float64{},
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeString,
			typeBool,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeBigInt,
			typeByteString,
			typeSimpleValue,
			typeTime,
		},
	},
	{
		data:               mustHexDecode("83010203"),
		wantInterfaceValue: []any{uint64(1), uint64(2), uint64(3)},
		wantValues: []any{
			[]any{uint64(1), uint64(2), uint64(3)},
			[]namedAny{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},
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeString,
			typeBool,
			typeStringSlice,
			typeMapStringInt,
			reflect.TypeFor[[3]string](),
			typeTag,
			typeRawTag,
			typeBigInt,
			typeByteString,
			typeSimpleValue,
			typeTime,
		},
	},
	{
		data:               mustHexDecode("8301820203820405"),
		wantInterfaceValue: []any{uint64(1), []any{uint64(2), uint64(3)}, []any{uint64(4), uint64(5)}},
		wantValues: []any{
			[]any{uint64(1), []any{uint64(2), uint64(3)}, []any{uint64(4), uint64(5)}},
			[]namedAny{uint64(1), []any{uint64(2), uint64(3)}, []any{uint64(4), uint64(5)}},
			[...]any{uint64(1), []any{uint64(2), uint64(3)}, []any{uint64(4), uint64(5)}},
			[...]namedAny{uint64(1), []any{uint64(2), uint64(3)}, []any{uint64(4), uint64(5)}},
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeString,
			typeBool,
			typeStringSlice,
			typeMapStringInt,
			reflect.TypeFor[[3]string](),
			typeTag,
			typeRawTag,
			typeBigInt,
			typeByteString,
			typeSimpleValue,
			typeTime,
		},
	},
	{
		data:               mustHexDecode("83018202039f0405ff"),
		wantInterfaceValue: []any{uint64(1), []any{uint64(2), uint64(3)}, []any{uint64(4), uint64(5)}},
		wantValues: []any{
			[]any{uint64(1), []any{uint64(2), uint64(3)}, []any{uint64(4), uint64(5)}},
			[]namedAny{uint64(1), []any{uint64(2), uint64(3)}, []any{uint64(4), uint64(5)}},
			[...]any{uint64(1), []any{uint64(2), uint64(3)}, []any{uint64(4), uint64(5)}},
			[...]namedAny{uint64(1), []any{uint64(2), uint64(3)}, []any{uint64(4), uint64(5)}},
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeString,
			typeBool,
			typeStringSlice,
			typeMapStringInt,
			reflect.TypeFor[[3]string](),
			typeTag,
			typeRawTag,
			typeBigInt,
			typeByteString,
			typeSimpleValue,
			typeTime,
		},
	},
	{
		data:               mustHexDecode("83019f0203ff820405"),
		wantInterfaceValue: []any{uint64(1), []any{uint64(2), uint64(3)}, []any{uint64(4), uint64(5)}},
		wantValues: []any{
			[]any{uint64(1), []any{uint64(2), uint64(3)}, []any{uint64(4), uint64(5)}},
			[]namedAny{uint64(1), []any{uint64(2), uint64(3)}, []any{uint64(4), uint64(5)}},
			[...]any{uint64(1), []any{uint64(2), uint64(3)}, []any{uint64(4), uint64(5)}},
			[...]namedAny{uint64(1), []any{uint64(2), uint64(3)}, []any{uint64(4), uint64(5)}},
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeString,
			typeBool,
			typeStringSlice,
			typeMapStringInt,
			reflect.TypeFor[[3]string](),
			typeTag,
			typeRawTag,
			typeBigInt,
			typeByteString,
			typeSimpleValue,
			typeTime,
		},
	},
	{
		data:               mustHexDecode("98190102030405060708090a0b0c0d0e0f101112131415161718181819"),
		wantInterfaceValue: []any{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)},
		wantValues: []any{
			[]any{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)},
			[]namedAny{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}},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeString,
			typeBool,
			typeStringSlice,
			typeMapStringInt,
			reflect.TypeFor[[3]string](),
			typeTag,
			typeRawTag,
			typeBigInt,
			typeByteString,
			typeSimpleValue,
			typeTime,
		},
	},
	{
		data:               mustHexDecode("9fff"),
		wantInterfaceValue: []any{},
		wantValues: []any{
			[]any{},
			[]byte{},
			[]string{},
			[]int{},
			[0]int{},
			[1]int{0},
			[5]int{0, 0, 0, 0, 0},
			[]float32{},
			[]float64{},
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeString,
			typeBool,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeBigInt,
			typeByteString,
			typeSimpleValue,
			typeTime,
		},
	},
	{
		data:               mustHexDecode("9f018202039f0405ffff"),
		wantInterfaceValue: []any{uint64(1), []any{uint64(2), uint64(3)}, []any{uint64(4), uint64(5)}},
		wantValues: []any{
			[]any{uint64(1), []any{uint64(2), uint64(3)}, []any{uint64(4), uint64(5)}},
			[]namedAny{uint64(1), []any{uint64(2), uint64(3)}, []any{uint64(4), uint64(5)}},
			[...]any{uint64(1), []any{uint64(2), uint64(3)}, []any{uint64(4), uint64(5)}},
			[...]namedAny{uint64(1), []any{uint64(2), uint64(3)}, []any{uint64(4), uint64(5)}},
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeString,
			typeBool,
			typeStringSlice,
			typeMapStringInt,
			reflect.TypeFor[[3]string](),
			typeTag,
			typeRawTag,
			typeBigInt,
			typeByteString,
			typeSimpleValue,
			typeTime,
		},
	},
	{
		data:               mustHexDecode("9f01820203820405ff"),
		wantInterfaceValue: []any{uint64(1), []any{uint64(2), uint64(3)}, []any{uint64(4), uint64(5)}},
		wantValues: []any{
			[]any{uint64(1), []any{uint64(2), uint64(3)}, []any{uint64(4), uint64(5)}},
			[]namedAny{uint64(1), []any{uint64(2), uint64(3)}, []any{uint64(4), uint64(5)}},
			[...]any{uint64(1), []any{uint64(2), uint64(3)}, []any{uint64(4), uint64(5)}},
			[...]namedAny{uint64(1), []any{uint64(2), uint64(3)}, []any{uint64(4), uint64(5)}},
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeString,
			typeBool,
			typeStringSlice,
			typeMapStringInt,
			reflect.TypeFor[[3]string](),
			typeTag,
			typeRawTag,
			typeBigInt,
			typeByteString,
			typeSimpleValue,
			typeTime,
		},
	},
	{
		data:               mustHexDecode("9f0102030405060708090a0b0c0d0e0f101112131415161718181819ff"),
		wantInterfaceValue: []any{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)},
		wantValues: []any{
			[]any{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)},
			[]namedAny{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}},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeString,
			typeBool,
			typeStringSlice,
			typeMapStringInt,
			reflect.TypeFor[[3]string](),
			typeTag,
			typeRawTag,
			typeBigInt,
			typeByteString,
			typeSimpleValue,
			typeTime,
		},
	},
	{
		data:               mustHexDecode("826161a161626163"),
		wantInterfaceValue: []any{"a", map[any]any{"b": "c"}},
		wantValues: []any{
			[]any{"a", map[any]any{"b": "c"}},
			[]namedAny{"a", map[any]any{"b": "c"}},
			[...]any{"a", map[any]any{"b": "c"}},
			[...]namedAny{"a", map[any]any{"b": "c"}},
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeString,
			typeBool,
			typeByteArray,
			typeStringSlice,
			typeMapStringInt,
			reflect.TypeFor[[3]string](),
			typeTag,
			typeRawTag,
			typeBigInt,
			typeByteString,
			typeSimpleValue,
			typeTime,
		},
	},
	{
		data:               mustHexDecode("826161bf61626163ff"),
		wantInterfaceValue: []any{"a", map[any]any{"b": "c"}},
		wantValues: []any{
			[]any{"a", map[any]any{"b": "c"}},
			[]namedAny{"a", map[any]any{"b": "c"}},
			[...]any{"a", map[any]any{"b": "c"}},
			[...]namedAny{"a", map[any]any{"b": "c"}},
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeString,
			typeBool,
			typeByteArray,
			typeStringSlice,
			typeMapStringInt,
			reflect.TypeFor[[3]string](),
			typeTag,
			typeRawTag,
			typeBigInt,
			typeByteString,
			typeSimpleValue,
			typeTime,
		},
	},

	// map
	{
		data:               mustHexDecode("a0"),
		wantInterfaceValue: map[any]any{},
		wantValues: []any{
			map[any]any{},
			map[namedAny]any{},
			map[string]bool{},
			map[string]int{},
			map[int]string{},
			map[int]bool{},
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeByteSlice,
			typeByteArray,
			typeString,
			typeBool,
			typeIntSlice,
			typeTag,
			typeRawTag,
			typeByteString,
			typeSimpleValue,
			typeTime,
		},
	},
	{
		data:               mustHexDecode("a201020304"),
		wantInterfaceValue: map[any]any{uint64(1): uint64(2), uint64(3): uint64(4)},
		wantValues: []any{
			map[any]any{uint64(1): uint64(2), uint64(3): uint64(4)},
			map[namedAny]any{uint64(1): uint64(2), uint64(3): uint64(4)},
			map[uint]int{1: 2, 3: 4}, map[int]uint{1: 2, 3: 4},
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeByteSlice,
			typeByteArray,
			typeString,
			typeBool,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeByteString,
			typeSimpleValue,
			typeTime,
		},
	},
	{
		data:               mustHexDecode("a26161016162820203"),
		wantInterfaceValue: map[any]any{"a": uint64(1), "b": []any{uint64(2), uint64(3)}},
		wantValues: []any{
			map[any]any{"a": uint64(1), "b": []any{uint64(2), uint64(3)}},
			map[namedAny]any{"a": uint64(1), "b": []any{uint64(2), uint64(3)}},
			map[string]any{"a": uint64(1), "b": []any{uint64(2), uint64(3)}},
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeByteSlice,
			typeByteArray,
			typeString,
			typeBool,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeByteString,
			typeSimpleValue,
			typeTime,
		},
	},
	{
		data:               mustHexDecode("a56161614161626142616361436164614461656145"),
		wantInterfaceValue: map[any]any{"a": "A", "b": "B", "c": "C", "d": "D", "e": "E"},
		wantValues: []any{
			map[any]any{"a": "A", "b": "B", "c": "C", "d": "D", "e": "E"},
			map[namedAny]any{"a": "A", "b": "B", "c": "C", "d": "D", "e": "E"},
			map[string]any{"a": "A", "b": "B", "c": "C", "d": "D", "e": "E"},
			map[string]string{"a": "A", "b": "B", "c": "C", "d": "D", "e": "E"},
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeByteSlice,
			typeByteArray,
			typeString,
			typeBool,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeByteString,
			typeSimpleValue,
			typeTime,
		},
	},
	{
		data:               mustHexDecode("bf61610161629f0203ffff"),
		wantInterfaceValue: map[any]any{"a": uint64(1), "b": []any{uint64(2), uint64(3)}},
		wantValues: []any{
			map[any]any{"a": uint64(1), "b": []any{uint64(2), uint64(3)}},
			map[namedAny]any{"a": uint64(1), "b": []any{uint64(2), uint64(3)}},
			map[string]any{"a": uint64(1), "b": []any{uint64(2), uint64(3)}},
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeByteSlice,
			typeByteArray,
			typeString,
			typeBool,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeByteString,
			typeSimpleValue,
			typeTime,
		},
	},
	{
		data:               mustHexDecode("bf6346756ef563416d7421ff"),
		wantInterfaceValue: map[any]any{"Fun": true, "Amt": int64(-2)},
		wantValues: []any{
			map[any]any{"Fun": true, "Amt": int64(-2)},
			map[namedAny]any{"Fun": true, "Amt": int64(-2)},
			map[string]any{"Fun": true, "Amt": int64(-2)},
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeByteSlice,
			typeByteArray,
			typeString,
			typeBool,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeByteString,
			typeSimpleValue,
			typeTime,
		},
	},

	// tag
	{
		data:               mustHexDecode("c074323031332d30332d32315432303a30343a30305a"),
		wantInterfaceValue: time.Date(2013, 3, 21, 20, 4, 0, 0, time.UTC), // 2013-03-21 20:04:00 +0000 UTC
		wantValues: []any{
			"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, mustHexDecode("74323031332d30332d32315432303a30343a30305a")},
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeBool,
			typeByteArray,
			typeIntSlice,
			typeMapStringInt,
			typeBigInt,
			typeByteString,
			typeSimpleValue,
		},
	}, // 0: standard date/time
	{
		data:               mustHexDecode("c11a514b67b0"),
		wantInterfaceValue: time.Date(2013, 3, 21, 20, 4, 0, 0, time.UTC), // 2013-03-21 20:04:00 +0000 UTC
		wantValues: []any{
			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, mustHexDecode("1a514b67b0")},
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeInt8,
			typeInt16,
			typeByteSlice,
			typeString,
			typeBool,
			typeByteArray,
			typeIntSlice,
			typeMapStringInt,
			typeByteString,
			typeSimpleValue,
		},
	}, // 1: epoch-based date/time
	{
		data:               mustHexDecode("c249010000000000000000"),
		wantInterfaceValue: mustBigInt("18446744073709551616"),
		wantValues: []any{
			// 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, mustHexDecode("49010000000000000000")},
			// Decode to big.Int
			mustBigInt("18446744073709551616"),
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeBool,
			typeIntSlice,
			typeMapStringInt,
			typeByteString,
			typeSimpleValue,
		},
	}, // 2: positive bignum: 18446744073709551616
	{
		data:               mustHexDecode("c349010000000000000000"),
		wantInterfaceValue: mustBigInt("-18446744073709551617"),
		wantValues: []any{
			// 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, mustHexDecode("49010000000000000000")},
			// Decode to big.Int
			mustBigInt("-18446744073709551617"),
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeBool,
			typeIntSlice,
			typeMapStringInt,
			typeByteString,
			typeSimpleValue,
		},
	}, // 3: negative bignum: -18446744073709551617
	{
		data:               mustHexDecode("c1fb41d452d9ec200000"),
		wantInterfaceValue: time.Date(2013, 3, 21, 20, 4, 0, 500000000, time.UTC), // 2013-03-21 20:04:00.5 +0000 UTC
		wantValues: []any{
			float32(1363896240.5),
			float64(1363896240.5),
			time.Date(2013, 3, 21, 20, 4, 0, 500000000, time.UTC),
			Tag{1, float64(1363896240.5)},
			RawTag{1, mustHexDecode("fb41d452d9ec200000")},
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeByteSlice,
			typeByteArray,
			typeString,
			typeBool,
			typeIntSlice,
			typeMapStringInt,
			typeBigInt,
			typeByteString,
			typeSimpleValue,
		},
	}, // 1: epoch-based date/time
	{
		data:               mustHexDecode("d74401020304"),
		wantInterfaceValue: Tag{23, []byte{0x01, 0x02, 0x03, 0x04}},
		wantValues: []any{
			[]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, mustHexDecode("4401020304")},
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeBool,
			typeIntSlice,
			typeMapStringInt,
			typeBigInt,
			typeByteString,
			typeSimpleValue,
		},
	}, // 23: expected conversion to base16 encoding
	{
		data:               mustHexDecode("d818456449455446"),
		wantInterfaceValue: Tag{24, []byte{0x64, 0x49, 0x45, 0x54, 0x46}},
		wantValues: []any{
			[]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, mustHexDecode("456449455446")},
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeBool,
			typeIntSlice,
			typeMapStringInt,
			typeBigInt,
			typeByteString,
			typeSimpleValue,
		},
	}, // 24: encoded cborBytes data item
	{
		data:               mustHexDecode("d82076687474703a2f2f7777772e6578616d706c652e636f6d"),
		wantInterfaceValue: Tag{32, "http://www.example.com"},
		wantValues: []any{
			"http://www.example.com",
			Tag{32, "http://www.example.com"},
			RawTag{32, mustHexDecode("76687474703a2f2f7777772e6578616d706c652e636f6d")},
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeBool,
			typeByteArray,
			typeIntSlice,
			typeMapStringInt,
			typeBigInt,
			typeByteString,
			typeSimpleValue,
		},
	}, // 32: URI

	// primitives
	{
		data:               mustHexDecode("f4"),
		wantInterfaceValue: false,
		wantValues: []any{
			false,
			SimpleValue(20),
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeByteArray,
			typeByteSlice,
			typeString,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeBigInt,
			typeByteString,
		},
	},
	{
		data:               mustHexDecode("f5"),
		wantInterfaceValue: true,
		wantValues: []any{
			true,
			SimpleValue(21),
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeByteArray,
			typeByteSlice,
			typeString,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeBigInt,
			typeByteString,
		},
	},
	{
		data:               mustHexDecode("f6"),
		wantInterfaceValue: nil,
		wantValues: []any{
			SimpleValue(22),
			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{},
			mustBigInt("0"),
			Tag{},
			RawTag{},
		},
		wrongTypes: nil,
	},
	{
		data:               mustHexDecode("f7"),
		wantInterfaceValue: nil,
		wantValues: []any{
			SimpleValue(23),
			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{},
			mustBigInt("0"),
			Tag{},
			RawTag{},
		},
		wrongTypes: nil,
	},
	{
		data:               mustHexDecode("f0"),
		wantInterfaceValue: SimpleValue(16),
		wantValues: []any{
			SimpleValue(16),
			uint8(16),
			uint16(16),
			uint32(16),
			uint64(16),
			uint(16),
			int8(16),
			int16(16),
			int32(16),
			int64(16),
			int(16),
			float32(16),
			float64(16),
			mustBigInt("16"),
		},
		wrongTypes: []reflect.Type{
			typeByteSlice,
			typeString,
			typeBool,
			typeByteArray,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeByteString,
		},
	},
	// 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
	// {
	// data: hexDecode("f818"),
	// wantInterfaceValue: uint64(24),
	// wantValues: []any{uint8(24), uint16(24), uint32(24), uint64(24), uint(24), int8(24), int16(24), int32(24), int64(24), int(24), float32(24), float64(24)},
	// wrongTypes: []reflect.Type{typeByteSlice, typeString, typeBool, typeIntSlice, typeMapStringInt},
	// },
	{
		data:               mustHexDecode("f820"),
		wantInterfaceValue: SimpleValue(32),
		wantValues: []any{
			SimpleValue(32),
			uint8(32),
			uint16(32),
			uint32(32),
			uint64(32),
			uint(32),
			int8(32),
			int16(32),
			int32(32),
			int64(32),
			int(32),
			float32(32),
			float64(32),
			mustBigInt("32"),
		},
		wrongTypes: []reflect.Type{
			typeByteSlice,
			typeString,
			typeBool,
			typeByteArray,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeByteString,
		},
	},
	{
		data:               mustHexDecode("f8ff"),
		wantInterfaceValue: SimpleValue(255),
		wantValues: []any{
			SimpleValue(255),
			uint8(255),
			uint16(255),
			uint32(255),
			uint64(255),
			uint(255),
			int16(255),
			int32(255),
			int64(255),
			int(255),
			float32(255),
			float64(255),
			mustBigInt("255"),
		},
		wrongTypes: []reflect.Type{
			typeByteSlice,
			typeString,
			typeBool,
			typeByteArray,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeByteString,
		},
	},

	// More testcases not covered by https://tools.ietf.org/html/rfc7049#appendix-A.
	{
		data:               mustHexDecode("5fff"), // empty indefinite-length byte string
		wantInterfaceValue: []byte{},
		wantValues: []any{
			[]byte{},
			[0]byte{},
			[1]byte{0x00},
			ByteString(""),
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeBool,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeBigInt,
			typeSimpleValue,
		},
	},
	{
		data:               mustHexDecode("7fff"), // empty indefinite-length text string
		wantInterfaceValue: "",
		wantValues:         []any{""},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeBool,
			typeByteArray,
			typeIntSlice,
			typeMapStringInt,
			typeTag,
			typeRawTag,
			typeBigInt,
			typeByteString,
			typeSimpleValue,
		},
	},
	{
		data:               mustHexDecode("bfff"), // empty indefinite-length map
		wantInterfaceValue: map[any]any{},
		wantValues: []any{
			map[any]any{},
			map[string]bool{},
			map[string]int{},
			map[int]string{},
			map[int]bool{},
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeByteArray,
			typeByteSlice,
			typeString,
			typeBool,
			typeIntSlice,
			typeTag,
			typeRawTag,
			typeByteString,
			typeSimpleValue,
		},
	},

	// More test data with tags
	{
		data:               mustHexDecode("c13a0177f2cf"), // 1969-03-21T20:04:00Z, tag 1 with negative integer as epoch time
		wantInterfaceValue: time.Date(1969, 3, 21, 20, 4, 0, 0, time.UTC),
		wantValues: []any{
			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, mustHexDecode("3a0177f2cf")}, mustBigInt("-24638160"),
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeInt8,
			typeInt16,
			typeByteSlice,
			typeString,
			typeBool,
			typeByteArray,
			typeIntSlice,
			typeMapStringInt,
			typeByteString,
			typeSimpleValue,
		},
	},
	{
		data:               mustHexDecode("d83dd183010203"), // 61(17([1, 2, 3])), nested tags 61 and 17
		wantInterfaceValue: Tag{61, Tag{17, []any{uint64(1), uint64(2), uint64(3)}}},
		wantValues: []any{
			[]any{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, []any{uint64(1), uint64(2), uint64(3)}}},
			RawTag{61, mustHexDecode("d183010203")},
		},
		wrongTypes: []reflect.Type{
			typeUint8,
			typeUint16,
			typeUint32,
			typeUint64,
			typeInt8,
			typeInt16,
			typeInt32,
			typeInt64,
			typeFloat32,
			typeFloat64,
			typeString,
			typeBool,
			typeStringSlice,
			typeMapStringInt,
			reflect.TypeFor[[3]string](),
			typeByteString,
			typeSimpleValue,
		},
	},
}

type unmarshalFloatTestCase struct {
	data               []byte
	wantInterfaceValue any
	wantValues         []any
	equalityThreshold  float64 // Not used for +inf, -inf, and NaN.
}

var unmarshalFloatWrongTypes = []reflect.Type{
	typeUint8,
	typeUint16,
	typeUint32,
	typeUint64,
	typeInt8,
	typeInt16,
	typeInt32,
	typeInt64,
	typeByteArray,
	typeByteSlice,
	typeString,
	typeBool,
	typeIntSlice,
	typeMapStringInt,
	typeTag,
	typeRawTag,
	typeBigInt,
	typeByteString,
	typeSimpleValue,
}

// unmarshalFloatTestCases 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 unmarshalFloatTestCases = []unmarshalFloatTestCase{
	// CBOR test data are from https://tools.ietf.org/html/rfc7049#appendix-A.

	// float16
	{
		data:               mustHexDecode("f90000"),
		wantInterfaceValue: float64(0.0),
		wantValues:         []any{float32(0.0), float64(0.0)},
	},
	{
		data:               mustHexDecode("f98000"),
		wantInterfaceValue: math.Copysign(0, -1),
		wantValues:         []any{float32(math.Copysign(0, -1)), math.Copysign(0, -1)},
	},
	{
		data:               mustHexDecode("f93c00"),
		wantInterfaceValue: float64(1.0),
		wantValues:         []any{float32(1.0), float64(1.0)},
	},
	{
		data:               mustHexDecode("f93e00"),
		wantInterfaceValue: float64(1.5),
		wantValues:         []any{float32(1.5), float64(1.5)},
	},
	{
		data:               mustHexDecode("f97bff"),
		wantInterfaceValue: float64(65504.0),
		wantValues:         []any{float32(65504.0), float64(65504.0)},
	},
	{
		data:               mustHexDecode("f90001"), // float16 subnormal value
		wantInterfaceValue: float64(5.960464477539063e-08),
		wantValues:         []any{float32(5.960464477539063e-08), float64(5.960464477539063e-08)},
		equalityThreshold:  1e-16,
	},
	{
		data:               mustHexDecode("f90400"),
		wantInterfaceValue: float64(6.103515625e-05),
		wantValues:         []any{float32(6.103515625e-05), float64(6.103515625e-05)},
		equalityThreshold:  1e-16,
	},
	{
		data:               mustHexDecode("f9c400"),
		wantInterfaceValue: float64(-4.0),
		wantValues:         []any{float32(-4.0), float64(-4.0)},
	},
	{
		data:               mustHexDecode("f97c00"),
		wantInterfaceValue: math.Inf(1),
		wantValues:         []any{math.Float32frombits(0x7f800000), math.Inf(1)},
	},
	{
		data:               mustHexDecode("f97e00"),
		wantInterfaceValue: math.NaN(),
		wantValues:         []any{math.Float32frombits(0x7fc00000), math.NaN()},
	},
	{
		data:               mustHexDecode("f9fc00"),
		wantInterfaceValue: math.Inf(-1),
		wantValues:         []any{math.Float32frombits(0xff800000), math.Inf(-1)},
	},

	// float32
	{
		data:               mustHexDecode("fa47c35000"),
		wantInterfaceValue: float64(100000.0),
		wantValues:         []any{float32(100000.0), float64(100000.0)},
	},
	{
		data:               mustHexDecode("fa7f7fffff"),
		wantInterfaceValue: float64(3.4028234663852886e+38),
		wantValues:         []any{float32(3.4028234663852886e+38), float64(3.4028234663852886e+38)},
		equalityThreshold:  1e-9,
	},
	{
		data:               mustHexDecode("fa7f800000"),
		wantInterfaceValue: math.Inf(1),
		wantValues:         []any{math.Float32frombits(0x7f800000), math.Inf(1)},
	},
	{
		data:               mustHexDecode("fa7fc00000"),
		wantInterfaceValue: math.NaN(),
		wantValues:         []any{math.Float32frombits(0x7fc00000), math.NaN()},
	},
	{
		data:               mustHexDecode("faff800000"),
		wantInterfaceValue: math.Inf(-1),
		wantValues:         []any{math.Float32frombits(0xff800000), math.Inf(-1)},
	},

	// float64
	{
		data:               mustHexDecode("fb3ff199999999999a"),
		wantInterfaceValue: float64(1.1),
		wantValues:         []any{float32(1.1), float64(1.1)},
	},
	{
		data:               mustHexDecode("fb7e37e43c8800759c"),
		wantInterfaceValue: float64(1.0e+300),
		wantValues:         []any{float64(1.0e+300)},
		equalityThreshold:  1e-9,
	},
	{
		data:               mustHexDecode("fbc010666666666666"),
		wantInterfaceValue: float64(-4.1),
		wantValues:         []any{float32(-4.1), float64(-4.1)},
	},
	{
		data:               mustHexDecode("fb7ff0000000000000"),
		wantInterfaceValue: math.Inf(1),
		wantValues:         []any{math.Float32frombits(0x7f800000), math.Inf(1)},
	},
	{
		data:               mustHexDecode("fb7ff8000000000000"),
		wantInterfaceValue: math.NaN(),
		wantValues:         []any{math.Float32frombits(0x7fc00000), math.NaN()},
	},
	{
		data:               mustHexDecode("fbfff0000000000000"),
		wantInterfaceValue: math.Inf(-1),
		wantValues:         []any{math.Float32frombits(0xff800000), math.Inf(-1)},
	},

	// float16 test data from https://en.wikipedia.org/wiki/Half-precision_floating-point_format
	{
		data:               mustHexDecode("f903ff"),
		wantInterfaceValue: float64(0.000060976),
		wantValues:         []any{float32(0.000060976), float64(0.000060976)},
		equalityThreshold:  1e-9,
	},
	{
		data:               mustHexDecode("f93bff"),
		wantInterfaceValue: float64(0.999511719),
		wantValues:         []any{float32(0.999511719), float64(0.999511719)},
		equalityThreshold:  1e-9,
	},
	{
		data:               mustHexDecode("f93c01"),
		wantInterfaceValue: float64(1.000976563),
		wantValues:         []any{float32(1.000976563), float64(1.000976563)},
		equalityThreshold:  1e-9,
	},
	{
		data:               mustHexDecode("f93555"),
		wantInterfaceValue: float64(0.333251953125),
		wantValues:         []any{float32(0.333251953125), float64(0.333251953125)},
		equalityThreshold:  1e-9,
	},

	// CBOR test data "canonNums" are from https://github.com/cbor-wg/cbor-test-vectors
	{
		data:               mustHexDecode("f9bd00"),
		wantInterfaceValue: float64(-1.25),
		wantValues:         []any{float32(-1.25), float64(-1.25)},
	},
	{
		data:               mustHexDecode("f93e00"),
		wantInterfaceValue: float64(1.5),
		wantValues:         []any{float32(1.5), float64(1.5)},
	},
	{
		data:               mustHexDecode("fb4024333333333333"),
		wantInterfaceValue: float64(10.1),
		wantValues:         []any{float32(10.1), float64(10.1)},
	},
	{
		data:               mustHexDecode("f90001"),
		wantInterfaceValue: float64(5.960464477539063e-8),
		wantValues:         []any{float32(5.960464477539063e-8), float64(5.960464477539063e-8)},
	},
	{
		data:               mustHexDecode("fa7f7fffff"),
		wantInterfaceValue: float64(3.4028234663852886e+38),
		wantValues:         []any{float32(3.4028234663852886e+38), float64(3.4028234663852886e+38)},
	},
	{
		data:               mustHexDecode("f90400"),
		wantInterfaceValue: float64(0.00006103515625),
		wantValues:         []any{float32(0.00006103515625), float64(0.00006103515625)},
	},
	{
		data:               mustHexDecode("f933ff"),
		wantInterfaceValue: float64(0.2498779296875),
		wantValues:         []any{float32(0.2498779296875), float64(0.2498779296875)},
	},
	{
		data:               mustHexDecode("fa33000000"),
		wantInterfaceValue: float64(2.9802322387695312e-8),
		wantValues:         []any{float32(2.9802322387695312e-8), float64(2.9802322387695312e-8)},
	},
	{
		data:               mustHexDecode("fa33333866"),
		wantInterfaceValue: float64(4.1727979294137185e-8),
		wantValues:         []any{float32(4.1727979294137185e-8), float64(4.1727979294137185e-8)},
	},
	{
		data:               mustHexDecode("fa37002000"),
		wantInterfaceValue: float64(0.000007636845111846924),
		wantValues:         []any{float32(0.000007636845111846924), float64(0.000007636845111846924)},
	},
}

const invalidUTF8ErrorMsg = "cbor: invalid UTF-8 string"

func TestUnmarshalToAny(t *testing.T) {
	for _, tc := range unmarshalTestCases {
		t.Run(fmt.Sprintf("0x%x", tc.data), func(t *testing.T) {
			var v any
			err := unmarshal(t, tc.data, &v)
			checkUnmarshalFunc(t, "Unmarshal", v, err, tc.wantInterfaceValue, nonFloatEqual)

			var nv namedAny
			err = unmarshal(t, tc.data, &nv)
			checkUnmarshalFunc(t, "Unmarshal", nv, err, tc.wantInterfaceValue, nonFloatEqual)
		})
	}
}

func TestUnmarshalToRawMessage(t *testing.T) {
	for _, tc := range unmarshalTestCases {
		testUnmarshalToRawMessage(t, tc.data)
	}
}

func testUnmarshalToRawMessage(t *testing.T, data []byte) {
	t.Helper()

	cborNil := isCBORNil(data)

	// Decode to RawMessage
	var r RawMessage
	err := unmarshal(t, data, &r)
	checkUnmarshal(t, "Unmarshal", r, err, RawMessage(data))

	// Decode to *RawMesage (pr is nil)
	var pr *RawMessage
	err = unmarshal(t, data, &pr)
	if cborNil {
		checkUnmarshal(t, "Unmarshal", pr, err, (*RawMessage)(nil))
	} else {
		checkUnmarshal(t, "Unmarshal", derefOrNil(pr), err, RawMessage(data))
	}

	// Decode to *RawMessage (pr is not nil)
	var ir RawMessage
	pr = &ir
	err = unmarshal(t, data, &pr)
	if cborNil {
		checkUnmarshal(t, "Unmarshal", pr, err, (*RawMessage)(nil))
	} else {
		checkUnmarshal(t, "Unmarshal", ir, err, RawMessage(data))
	}
}

func TestUnmarshalToCompatibleTypes(t *testing.T) {
	for _, tc := range unmarshalTestCases {
		for _, wantValue := range tc.wantValues {
			t.Run(fmt.Sprintf("0x%x to %T", tc.data, wantValue), func(t *testing.T) {
				testUnmarshalToCompatibleType(t, tc.data, wantValue, nonFloatEqual)
			})
		}
	}
}

func testUnmarshalToCompatibleType(t *testing.T, data []byte, wantValue any, equal func(got, want any) bool) {
	t.Helper()

	var rv reflect.Value

	cborNil := isCBORNil(data)
	wantType := reflect.TypeOf(wantValue)

	// Decode to wantType, same as:
	//     var v wantType
	//     Unmarshal(tc.data, &v)

	rv = reflect.New(wantType)
	err := unmarshal(t, data, rv.Interface())
	checkUnmarshalFunc(t, "Unmarshal", rv.Elem().Interface(), err, wantValue, equal)

	// Decode to *wantType (pv is nil), same as:
	//     var pv *wantType
	//     Unmarshal(tc.data, &pv)

	rv = reflect.New(reflect.PointerTo(wantType))
	err = unmarshal(t, data, rv.Interface())
	if cborNil {
		checkUnmarshal(t, "Unmarshal", rv.Elem().Interface(), err, reflect.Zero(rv.Elem().Type()).Interface())
	} else {
		checkUnmarshalFunc(t, "Unmarshal", derefOrNil(rv.Elem().Interface()), err, wantValue, equal)
	}

	// Decode to *wantType (pv is not nil), same as:
	//     var v wantType
	//     pv := &v
	//     Unmarshal(tc.data, &pv)

	irv := reflect.New(wantType)
	rv = reflect.New(reflect.PointerTo(wantType))
	rv.Elem().Set(irv)
	err = unmarshal(t, data, rv.Interface())
	if cborNil {
		checkUnmarshal(t, "Unmarshal", rv.Elem().Interface(), err, reflect.Zero(rv.Elem().Type()).Interface())
	} else {
		checkUnmarshalFunc(t, "Unmarshal", derefOrNil(rv.Elem().Interface()), err, wantValue, equal)
	}
}

func TestUnmarshalToIncompatibleTypes(t *testing.T) {
	for _, tc := range unmarshalTestCases {
		for _, wrongType := range tc.wrongTypes {
			testUnmarshalToIncompatibleType(t, tc.data, wrongType)
		}
	}
}

func testUnmarshalToIncompatibleType(t *testing.T, data []byte, wrongType reflect.Type) {
	t.Helper()

	var rv reflect.Value

	// Decode to wrongType, same as:
	//     var v wrongType
	//     Unmarshal(tc.data, &v)

	rv = reflect.New(wrongType)
	err := unmarshal(t, data, rv.Interface())
	checkError[*UnmarshalTypeError](t, "Unmarshal", err, "")

	// Decode to *wrongType (pv is nil), same as:
	//     var pv *wrongType
	//     Unmarshal(tc.data, &pv)

	rv = reflect.New(reflect.PointerTo(wrongType))
	err = unmarshal(t, data, rv.Interface())
	checkError[*UnmarshalTypeError](t, "Unmarshal", err, "")

	// Decode to *wrongType (pv is not nil), same as:
	//     var v wrongType
	//     pv := &v
	//     Unmarshal(tc.data, &pv)

	irv := reflect.New(wrongType)
	rv = reflect.New(reflect.PointerTo(wrongType))
	rv.Elem().Set(irv)

	err = unmarshal(t, data, rv.Interface())
	checkError[*UnmarshalTypeError](t, "Unmarshal", err, "")
}

func TestUnmarshalFloatToEmptyInterface(t *testing.T) {
	for _, tc := range unmarshalFloatTestCases {
		t.Run(fmt.Sprintf("0x%x", tc.data), func(t *testing.T) {
			var v any
			err := unmarshal(t, tc.data, &v)
			checkUnmarshalFunc(t, "Unmarshal", v, err, tc.wantInterfaceValue, floatEqual(tc.equalityThreshold))
		})
	}
}

func TestUnmarshalFloatToRawMessage(t *testing.T) {
	for _, tc := range unmarshalFloatTestCases {
		testUnmarshalToRawMessage(t, tc.data)
	}
}

func TestUnmarshalFloatToCompatibleTypes(t *testing.T) {
	for _, tc := range unmarshalFloatTestCases {
		for _, wantValue := range tc.wantValues {
			t.Run(fmt.Sprintf("0x%x to %T", tc.data, wantValue), func(t *testing.T) {
				testUnmarshalToCompatibleType(t, tc.data, wantValue, floatEqual(tc.equalityThreshold))
			})
		}
	}
}

func TestUnmarshalFloatToIncompatibleTypes(t *testing.T) {
	for _, tc := range unmarshalFloatTestCases {
		for _, wrongType := range unmarshalFloatWrongTypes {
			testUnmarshalToIncompatibleType(t, tc.data, wrongType)
		}
	}
}

func TestNegIntOverflow(t *testing.T) {
	data := mustHexDecode("3bffffffffffffffff") // -18446744073709551616

	// Decode CBOR neg int that overflows Go int64 to a value of type any.
	var v1 any
	wantObj := mustBigInt("-18446744073709551616")
	err := unmarshal(t, data, &v1)
	checkUnmarshal(t, "Unmarshal", v1, err, wantObj)

	// Decode CBOR neg int that overflows Go int64 to big.Int
	var v2 big.Int
	err = unmarshal(t, data, &v2)
	checkUnmarshal(t, "Unmarshal", v2, err, wantObj)

	// Decode CBOR neg int that overflows Go int64 to int64
	var v3 int64
	err = unmarshal(t, data, &v3)
	checkError[*UnmarshalTypeError](t, "Unmarshal", err, "")
}

func TestUnmarshalIntoPtrPrimitives(t *testing.T) {
	cborDataInt := mustHexDecode("1818")                          // 24
	cborDataString := mustHexDecode("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.
	err := unmarshal(t, cborDataInt, &ppi)
	checkUnmarshal(t, "Unmarshal", i, err, wantInt)

	// Unmarshal CBOR integer into a nil pointer.
	err = unmarshal(t, cborDataInt, &p1)
	checkUnmarshal(t, "Unmarshal", derefOrNil(p1), err, wantInt)

	// Unmarshal CBOR string into a non-nil pointer.
	err = unmarshal(t, cborDataString, &pps)
	checkUnmarshal(t, "Unmarshal", s, err, wantString)

	// Unmarshal CBOR string into a nil pointer.
	err = unmarshal(t, cborDataString, &p2)
	checkUnmarshal(t, "Unmarshal", derefOrNil(p2), err, wantString)

	// Unmarshal CBOR string into a non-nil RawMessage.
	err = unmarshal(t, cborDataString, &ppr)
	checkUnmarshal(t, "Unmarshal", r, err, RawMessage(cborDataString))

	// Unmarshal CBOR string into a nil pointer to RawMessage.
	err = unmarshal(t, cborDataString, &p3)
	checkUnmarshal(t, "Unmarshal", derefOrNil(p3), err, RawMessage(cborDataString))
}

func TestUnmarshalIntoPtrArrayPtrElem(t *testing.T) {
	data := mustHexDecode("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.
	err := unmarshal(t, data, &ppslc)
	checkUnmarshal(t, "Unmarshal", **ppslc, err, wantArray)

	// Unmarshal CBOR array into a nil pointer.
	err = unmarshal(t, data, &p)
	checkUnmarshal(t, "Unmarshal", derefOrNil(p), err, wantArray)
}

func TestUnmarshalIntoPtrMapPtrElem(t *testing.T) {
	data := mustHexDecode("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.
	err := unmarshal(t, data, &ppm)
	checkUnmarshal(t, "Unmarshal", **ppm, err, wantMap)

	// Unmarshal CBOR map into a nil pointer.
	err = unmarshal(t, data, &p)
	checkUnmarshal(t, "Unmarshal", derefOrNil(p), err, 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"`
	}

	data := mustHexDecode("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.
	err := unmarshal(t, data, &pps)
	checkUnmarshal(t, "Unmarshal", **pps, err, wantObj)

	// Unmarshal CBOR map into a nil pointer.
	err = unmarshal(t, data, &p)
	checkUnmarshal(t, "Unmarshal", derefOrNil(p), err, wantObj)
}

func TestUnmarshalIntoArray(t *testing.T) {
	data := mustHexDecode("83010203") // []int{1, 2, 3}

	// Unmarshal CBOR array into Go array.
	var arr1 [3]int
	err := unmarshal(t, data, &arr1)
	checkUnmarshal(t, "Unmarshal", arr1, err, [3]int{1, 2, 3})

	// Unmarshal CBOR array into Go array with more elements.
	var arr2 [5]int
	err = unmarshal(t, data, &arr2)
	checkUnmarshal(t, "Unmarshal", arr2, err, [5]int{1, 2, 3, 0, 0})

	// Unmarshal CBOR array into Go array with less elements.
	var arr3 [1]int
	err = unmarshal(t, data, &arr3)
	checkUnmarshal(t, "Unmarshal", arr3, err, [1]int{1})
}

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 TestUnmarshalNull(t *testing.T) {
	type T struct {
		I int
	}

	data := [][]byte{mustHexDecode("f6"), mustHexDecode("f7")} // CBOR null and undefined values

	testCases := []struct {
		name      string
		value     any
		wantValue any
	}{
		// Unmarshaling CBOR null to the following types is a no-op.
		{
			name:      "bool",
			value:     true,
			wantValue: true,
		},
		{
			name:      "int",
			value:     int(-1),
			wantValue: int(-1),
		},
		{
			name:      "int8",
			value:     int8(-2),
			wantValue: int8(-2),
		},
		{
			name:      "int16",
			value:     int16(-3),
			wantValue: int16(-3),
		},
		{
			name:      "int32",
			value:     int32(-4),
			wantValue: int32(-4),
		},
		{
			name:      "int64",
			value:     int64(-5),
			wantValue: int64(-5),
		},
		{
			name:      "uint",
			value:     uint(1),
			wantValue: uint(1),
		},
		{
			name:      "uint8",
			value:     uint8(2),
			wantValue: uint8(2),
		},
		{
			name:      "uint16",
			value:     uint16(3),
			wantValue: uint16(3),
		},
		{
			name:      "uint32",
			value:     uint32(4),
			wantValue: uint32(4),
		},
		{
			name:      "uint64",
			value:     uint64(5),
			wantValue: uint64(5),
		},
		{
			name:      "float32",
			value:     float32(1.23),
			wantValue: float32(1.23),
		},
		{
			name:      "float64",
			value:     float64(4.56),
			wantValue: float64(4.56),
		},
		{
			name:      "string",
			value:     "hello",
			wantValue: "hello",
		},
		{
			name:      "array",
			value:     [3]int{1, 2, 3},
			wantValue: [3]int{1, 2, 3},
		},

		// Unmarshaling CBOR null to slice/map sets Go values to nil.
		{
			name:      "[]byte",
			value:     []byte{1, 2, 3},
			wantValue: []byte(nil),
		},
		{
			name:      "slice",
			value:     []string{"hello", "world"},
			wantValue: []string(nil),
		},
		{
			name:      "map",
			value:     map[string]bool{"hello": true, "goodbye": false},
			wantValue: map[string]bool(nil),
		},

		// Unmarshaling CBOR null to ByteString (string wrapper for []byte) resets ByteString to empty string.
		{
			name:      "cbor.ByteString",
			value:     ByteString("\x01\x02\x03"),
			wantValue: ByteString(""),
		},

		// Unmarshaling CBOR null to time.Time is a no-op.
		{
			name:      "time.Time",
			value:     time.Date(2020, time.January, 2, 3, 4, 5, 6, time.UTC),
			wantValue: time.Date(2020, time.January, 2, 3, 4, 5, 6, time.UTC),
		},

		// Unmarshaling CBOR null to big.Int is a no-op.
		{
			name:      "big.Int",
			value:     mustBigInt("123"),
			wantValue: mustBigInt("123"),
		},

		// Unmarshaling CBOR null to user defined struct types is a no-op.
		{
			name:      "user defined struct",
			value:     T{I: 123},
			wantValue: T{I: 123},
		},

		// Unmarshaling CBOR null to cbor.Tag and cbor.RawTag is a no-op.
		{
			name:      "cbor.RawTag",
			value:     RawTag{123, []byte{4, 5, 6}},
			wantValue: RawTag{123, []byte{4, 5, 6}},
		},
		{
			name:      "cbor.Tag",
			value:     Tag{123, "hello world"},
			wantValue: Tag{123, "hello world"},
		},

		// Unmarshaling to cbor.RawMessage sets cbor.RawMessage to raw CBOR bytes (0xf6 or 0xf7).
		// It's tested in TestUnmarshal().

		// Unmarshaling to types implementing cbor.BinaryUnmarshaler is a no-op.
		{
			name:      "cbor.BinaryUnmarshaler",
			value:     number(456),
			wantValue: number(456),
		},

		// When unmarshaling to types implementing cbor.Unmarshaler,
		{
			name:      "cbor.Unmarshaler",
			value:     nilUnmarshaler("hello world"),
			wantValue: nilUnmarshaler("null"),
		},
	}

	// Unmarshaling to values of specified Go types.
	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			for _, data := range data {
				v := reflect.New(reflect.TypeOf(tc.value))
				v.Elem().Set(reflect.ValueOf(tc.value))

				err := unmarshal(t, data, v.Interface())
				checkUnmarshal(t, "Unmarshal", v.Elem().Interface(), err, tc.wantValue)
			}
		})
	}
}

type myInt int

func (i myInt) String() string { return fmt.Sprintf("myInt %d", int(i)) }

type myMap map[string]int

func (m myMap) String() string { return fmt.Sprintf("myMap %#v", map[string]int(m)) }

type myStringSlice []string

func (ss myStringSlice) String() string { return fmt.Sprintf("myStringSlice %#v", []string(ss)) }

type myByteSlice []byte

func (bs myByteSlice) String() string { return fmt.Sprintf("myByteSlice 0x%x", []byte(bs)) }

func TestUnmarshalNullToInterface(t *testing.T) {
	// Unmarshaling CBOR null/undefined to interface value sets the interface value to nil.
	// Tag number 55799 enclosing null/undefined has no effect (RFC 8949 Section 3.4.6).

	data := [][]byte{
		mustHexDecode("f6"),             // null
		mustHexDecode("f7"),             // undefined
		mustHexDecode("d9d9f7f6"),       // 55799(null)
		mustHexDecode("d9d9f7f7"),       // 55799(undefined)
		mustHexDecode("d9d9f7d9d9f7f6"), // 55799(55799(null))
		mustHexDecode("d9d9f7d9d9f7f7"), // 55799(55799(undefined))
	}

	testCases := []struct {
		name  string
		value func() fmt.Stringer
	}{
		{
			name: "interface is nil",
			value: func() fmt.Stringer {
				var v fmt.Stringer
				return v
			},
		},
		{
			name: "interface value is a pointer to non-nil map",
			value: func() fmt.Stringer {
				var v fmt.Stringer = &myMap{"a": 1}
				return v
			},
		},
		{
			name: "interface value is a nil pointer",
			value: func() fmt.Stringer {
				var v fmt.Stringer = (*myMap)(nil)
				return v
			},
		},
		{
			name: "interface value is non-nil map",
			value: func() fmt.Stringer {
				var v fmt.Stringer = myMap{"a": 1}
				return v
			},
		},
		{
			name: "interface value is nil map",
			value: func() fmt.Stringer {
				var v fmt.Stringer = myMap(nil)
				return v
			},
		},
		{
			name: "interface value is non-nil slice",
			value: func() fmt.Stringer {
				var v fmt.Stringer = myStringSlice{"a"}
				return v
			},
		},
		{
			name: "interface value is nil slice",
			value: func() fmt.Stringer {
				var v fmt.Stringer = myStringSlice(nil)
				return v
			},
		},
		{
			name: "interface value is non-nil byte slice",
			value: func() fmt.Stringer {
				var v fmt.Stringer = myByteSlice{1}
				return v
			},
		},
		{
			name: "interface value is nil byte slice",
			value: func() fmt.Stringer {
				var v fmt.Stringer = myByteSlice(nil)
				return v
			},
		},
		{
			name: "interface value is int",
			value: func() fmt.Stringer {
				var v fmt.Stringer = myInt(1)
				return v
			},
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			for _, data := range data {
				v := tc.value()
				err := unmarshal(t, data, &v)
				checkUnmarshal(t, "Unmarshal", v, err, nil)
			}
		})
	}
}

func TestUnmarshalNullToPointer(t *testing.T) {
	// Unmarshaling CBOR null/undefined to pointer sets the value to nil.
	// Tag number 55799 enclosing null/undefined has no effect (RFC 8949 Section 3.4.6).

	data := [][]byte{
		mustHexDecode("f6"),             // null
		mustHexDecode("f7"),             // undefined
		mustHexDecode("d9d9f7f6"),       // 55799(null)
		mustHexDecode("d9d9f7f7"),       // 55799(undefined)
		mustHexDecode("d9d9f7d9d9f7f6"), // 55799(55799(null))
		mustHexDecode("d9d9f7d9d9f7f7"), // 55799(55799(undefined))
	}

	testCases := []struct {
		name  string
		value func() any
	}{
		{
			name:  "nil pointer",
			value: func() any { return (*int)(nil) },
		},
		{
			name: "non-nil pointer",
			value: func() any {
				i := 1
				return &i
			},
		},
		{
			name: "non-nil pointer to cbor.Unmarshaler",
			value: func() any {
				u := nilUnmarshaler("hello world")
				return &u
			},
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			for _, data := range data {
				t.Run(fmt.Sprintf("0x%x", data), func(t *testing.T) {
					p := tc.value()
					v := reflect.New(reflect.TypeOf(p))
					v.Elem().Set(reflect.ValueOf(p))

					err := unmarshal(t, data, v.Interface())
					checkUnmarshal(t, "Unmarshal", v.Elem().Interface(), err,
						reflect.Zero(v.Elem().Type()).Interface())
				})
			}
		})
	}

	t.Run("empty interface", func(t *testing.T) {
		for _, data := range data {
			t.Run(fmt.Sprintf("0x%x", data), func(t *testing.T) {
				var v any = "hello world"
				err := unmarshal(t, data, &v)
				checkUnmarshal(t, "Unmarshal", v, err, nil)
			})
		}
	})

	t.Run("struct field", func(t *testing.T) {
		for _, data := range [][]byte{
			mustHexDecode("a16150f6"),       // {"P": null}
			mustHexDecode("a16150d9d9f7f6"), // {"P": 55799(null)}
		} {
			t.Run(fmt.Sprintf("0x%x", data), func(t *testing.T) {
				one := 1
				v := struct{ P *int }{P: &one}
				err := unmarshal(t, data, &v)
				checkUnmarshal(t, "Unmarshal", v, err, struct{ P *int }{})
			})
		}
	})
}

var invalidUnmarshalTestCases = []struct {
	name         string
	v            any
	wantErrorMsg string
}{
	{
		name:         "unmarshal into nil",
		v:            nil,
		wantErrorMsg: "cbor: Unmarshal(nil)",
	},
	{
		name:         "unmarshal into non-pointer value",
		v:            5,
		wantErrorMsg: "cbor: Unmarshal(non-pointer int)",
	},
	{
		name:         "unmarshal into nil pointer",
		v:            (*int)(nil),
		wantErrorMsg: "cbor: Unmarshal(nil *int)",
	},
}

func TestInvalidUnmarshal(t *testing.T) {
	data := []byte{0x00}

	for _, tc := range invalidUnmarshalTestCases {
		t.Run(tc.name, func(t *testing.T) {
			err := unmarshal(t, data, tc.v)
			checkError[*InvalidUnmarshalError](t, "Unmarshal", err, tc.wantErrorMsg)
		})
	}
}

var invalidCBORUnmarshalTestCases = []struct {
	name         string
	data         []byte
	wantErrorMsg string
}{
	{
		name:         "nil data",
		data:         []byte(nil),
		wantErrorMsg: "EOF",
	},
	{
		name:         "empty data",
		data:         []byte{},
		wantErrorMsg: "EOF",
	},
	{
		name:         "tag number not followed by tag content",
		data:         []byte{0xc0},
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "indefinite-length byte string with tagged chunk",
		data:         mustHexDecode("5fc64401020304ff"),
		wantErrorMsg: "cbor: wrong element type tag for indefinite-length byte string",
	},
	{
		name:         "indefinite-length text string with tagged chunk",
		data:         mustHexDecode("7fc06161ff"),
		wantErrorMsg: "cbor: wrong element type tag for indefinite-length UTF-8 text string",
	},
	{
		name:         "indefinite-length strings with truncated text string",
		data:         mustHexDecode("7f61"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "invalid nested tag number",
		data:         mustHexDecode("d864dc1a514b67b0"),
		wantErrorMsg: "cbor: invalid additional information 28 for type tag",
	},
	// Data from 7049bis G.1
	// Premature end of the input
	{
		name:         "end of input in a head",
		data:         mustHexDecode("18"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "end of input in a head",
		data:         mustHexDecode("19"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "end of input in a head",
		data:         mustHexDecode("1a"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "end of input in a head",
		data:         mustHexDecode("1b"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "end of input in a head",
		data:         mustHexDecode("1901"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "end of input in a head",
		data:         mustHexDecode("1a0102"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "end of input in a head",
		data:         mustHexDecode("1b01020304050607"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "end of input in a head",
		data:         mustHexDecode("38"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "end of input in a head",
		data:         mustHexDecode("58"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "end of input in a head",
		data:         mustHexDecode("78"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "end of input in a head",
		data:         mustHexDecode("98"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "end of input in a head",
		data:         mustHexDecode("9a01ff00"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "end of input in a head",
		data:         mustHexDecode("b8"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "end of input in a head",
		data:         mustHexDecode("d8"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "end of input in a head",
		data:         mustHexDecode("f8"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "end of input in a head",
		data:         mustHexDecode("f900"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "end of input in a head",
		data:         mustHexDecode("fa0000"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "end of input in a head",
		data:         mustHexDecode("fb000000"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "definite-length strings with short data",
		data:         mustHexDecode("41"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "definite-length strings with short data",
		data:         mustHexDecode("61"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "definite-length strings with short data",
		data:         mustHexDecode("5affffffff00"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "definite-length strings with short data",
		data:         mustHexDecode("5bffffffffffffffff010203"),
		wantErrorMsg: "cbor: byte string length 18446744073709551615 is too large, causing integer overflow",
	},
	{
		name:         "definite-length strings with short data",
		data:         mustHexDecode("7affffffff00"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "definite-length strings with short data",
		data:         mustHexDecode("7b7fffffffffffffff010203"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "definite-length maps and arrays not closed with enough items",
		data:         mustHexDecode("81"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "definite-length maps and arrays not closed with enough items",
		data:         mustHexDecode("818181818181818181"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "definite-length maps and arrays not closed with enough items",
		data:         mustHexDecode("8200"),
		wantErrorMsg: "unexpected EOF",
	},

	{
		name:         "definite-length maps and arrays not closed with enough items",
		data:         mustHexDecode("a1"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "definite-length maps and arrays not closed with enough items",
		data:         mustHexDecode("a20102"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "definite-length maps and arrays not closed with enough items",
		data:         mustHexDecode("a100"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "definite-length maps and arrays not closed with enough items",
		data:         mustHexDecode("a2000000"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "indefinite-length strings not closed by a break stop code",
		data:         mustHexDecode("5f4100"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "indefinite-length strings not closed by a break stop code",
		data:         mustHexDecode("7f6100"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "indefinite-length maps and arrays not closed by a break stop code",
		data:         mustHexDecode("9f"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "indefinite-length maps and arrays not closed by a break stop code",
		data:         mustHexDecode("9f0102"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "indefinite-length maps and arrays not closed by a break stop code",
		data:         mustHexDecode("bf"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "indefinite-length maps and arrays not closed by a break stop code",
		data:         mustHexDecode("bf01020102"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "indefinite-length maps and arrays not closed by a break stop code",
		data:         mustHexDecode("819f"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "indefinite-length maps and arrays not closed by a break stop code",
		data:         mustHexDecode("9f8000"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "indefinite-length maps and arrays not closed by a break stop code",
		data:         mustHexDecode("9f9f9f9f9fffffffff"),
		wantErrorMsg: "unexpected EOF",
	},
	{
		name:         "indefinite-length maps and arrays not closed by a break stop code",
		data:         mustHexDecode("9f819f819f9fffffff"),
		wantErrorMsg: "unexpected EOF",
	},
	// Five subkinds of well-formedness error kind 3 (syntax error)
	{
		name:         "reserved additional information values",
		data:         mustHexDecode("3e"),
		wantErrorMsg: "cbor: invalid additional information 30 for type negative integer",
	},
	{
		name:         "reserved additional information values",
		data:         mustHexDecode("5c"),
		wantErrorMsg: "cbor: invalid additional information 28 for type byte string",
	},
	{
		name:         "reserved additional information values",
		data:         mustHexDecode("5d"),
		wantErrorMsg: "cbor: invalid additional information 29 for type byte string",
	},
	{
		name:         "reserved additional information values",
		data:         mustHexDecode("5e"),
		wantErrorMsg: "cbor: invalid additional information 30 for type byte string",
	},
	{
		name:         "reserved additional information values",
		data:         mustHexDecode("7c"),
		wantErrorMsg: "cbor: invalid additional information 28 for type UTF-8 text string",
	},
	{
		name:         "reserved additional information values",
		data:         mustHexDecode("7d"),
		wantErrorMsg: "cbor: invalid additional information 29 for type UTF-8 text string",
	},
	{
		name:         "reserved additional information values",
		data:         mustHexDecode("7e"),
		wantErrorMsg: "cbor: invalid additional information 30 for type UTF-8 text string",
	},
	{
		name:         "reserved additional information values",
		data:         mustHexDecode("9c"),
		wantErrorMsg: "cbor: invalid additional information 28 for type array",
	},
	{
		name:         "reserved additional information values",
		data:         mustHexDecode("9d"),
		wantErrorMsg: "cbor: invalid additional information 29 for type array",
	},
	{
		name:         "reserved additional information values",
		data:         mustHexDecode("9e"),
		wantErrorMsg: "cbor: invalid additional information 30 for type array",
	},
	{
		name:         "reserved additional information values",
		data:         mustHexDecode("bc"),
		wantErrorMsg: "cbor: invalid additional information 28 for type map",
	},
	{
		name:         "reserved additional information values",
		data:         mustHexDecode("bd"),
		wantErrorMsg: "cbor: invalid additional information 29 for type map",
	},
	{
		name:         "reserved additional information values",
		data:         mustHexDecode("be"),
		wantErrorMsg: "cbor: invalid additional information 30 for type map",
	},
	{
		name:         "reserved additional information values",
		data:         mustHexDecode("dc"),
		wantErrorMsg: "cbor: invalid additional information 28 for type tag",
	},
	{
		name:         "reserved additional information values",
		data:         mustHexDecode("dd"),
		wantErrorMsg: "cbor: invalid additional information 29 for type tag",
	},
	{
		name:         "reserved additional information values",
		data:         mustHexDecode("de"),
		wantErrorMsg: "cbor: invalid additional information 30 for type tag",
	},
	{
		name:         "reserved additional information values",
		data:         mustHexDecode("fc"),
		wantErrorMsg: "cbor: invalid additional information 28 for type primitives",
	},
	{
		name:         "reserved additional information values",
		data:         mustHexDecode("fd"),
		wantErrorMsg: "cbor: invalid additional information 29 for type primitives",
	},
	{
		name:         "reserved additional information values",
		data:         mustHexDecode("fe"),
		wantErrorMsg: "cbor: invalid additional information 30 for type primitives",
	},
	{
		name:         "reserved two-byte encodings of simple types",
		data:         mustHexDecode("f800"),
		wantErrorMsg: "cbor: invalid simple value 0 for type primitives",
	},
	{
		name:         "reserved two-byte encodings of simple types",
		data:         mustHexDecode("f801"),
		wantErrorMsg: "cbor: invalid simple value 1 for type primitives",
	},
	{
		name:         "reserved two-byte encodings of simple types",
		data:         mustHexDecode("f818"),
		wantErrorMsg: "cbor: invalid simple value 24 for type primitives",
	},
	{
		name:         "reserved two-byte encodings of simple types",
		data:         mustHexDecode("f81f"),
		wantErrorMsg: "cbor: invalid simple value 31 for type primitives",
	},
	{
		name:         "indefinite-length string chunks not of the correct type",
		data:         mustHexDecode("5f00ff"),
		wantErrorMsg: "cbor: wrong element type positive integer for indefinite-length byte string",
	},
	{
		name:         "indefinite-length string chunks not of the correct type",
		data:         mustHexDecode("5f21ff"),
		wantErrorMsg: "cbor: wrong element type negative integer for indefinite-length byte string",
	},
	{
		name:         "indefinite-length string chunks not of the correct type",
		data:         mustHexDecode("5f6100ff"),
		wantErrorMsg: "cbor: wrong element type UTF-8 text string for indefinite-length byte string",
	},
	{
		name:         "indefinite-length string chunks not of the correct type",
		data:         mustHexDecode("5f80ff"),
		wantErrorMsg: "cbor: wrong element type array for indefinite-length byte string",
	},
	{
		name:         "indefinite-length string chunks not of the correct type",
		data:         mustHexDecode("5fa0ff"),
		wantErrorMsg: "cbor: wrong element type map for indefinite-length byte string",
	},
	{
		name:         "indefinite-length string chunks not of the correct type",
		data:         mustHexDecode("5fc000ff"),
		wantErrorMsg: "cbor: wrong element type tag for indefinite-length byte string",
	},
	{
		name:         "indefinite-length string chunks not of the correct type",
		data:         mustHexDecode("5fe0ff"),
		wantErrorMsg: "cbor: wrong element type primitives for indefinite-length byte string",
	},
	{
		name:         "indefinite-length string chunks not of the correct type",
		data:         mustHexDecode("7f4100ff"),
		wantErrorMsg: "cbor: wrong element type byte string for indefinite-length UTF-8 text string",
	},
	{
		name:         "indefinite-length string chunks not definite length",
		data:         mustHexDecode("5f5f4100ffff"),
		wantErrorMsg: "cbor: indefinite-length byte string chunk is not definite-length",
	},
	{
		name:         "indefinite-length string chunks not definite length",
		data:         mustHexDecode("7f7f6100ffff"),
		wantErrorMsg: "cbor: indefinite-length UTF-8 text string chunk is not definite-length",
	},
	{
		name:         "break occurring on its own outside of an indefinite-length item",
		data:         mustHexDecode("ff"),
		wantErrorMsg: "cbor: unexpected \"break\" code",
	},
	{
		name:         "break occurring in a definite-length array or map or a tag",
		data:         mustHexDecode("81ff"),
		wantErrorMsg: "cbor: unexpected \"break\" code",
	},
	{
		name:         "break occurring in a definite-length array or map or a tag",
		data:         mustHexDecode("8200ff"),
		wantErrorMsg: "cbor: unexpected \"break\" code",
	},
	{
		name:         "break occurring in a definite-length array or map or a tag",
		data:         mustHexDecode("a1ff"),
		wantErrorMsg: "cbor: unexpected \"break\" code",
	},
	{
		name:         "break occurring in a definite-length array or map or a tag",
		data:         mustHexDecode("a1ff00"),
		wantErrorMsg: "cbor: unexpected \"break\" code",
	},
	{
		name:         "break occurring in a definite-length array or map or a tag",
		data:         mustHexDecode("a100ff"),
		wantErrorMsg: "cbor: unexpected \"break\" code",
	},
	{
		name:         "break occurring in a definite-length array or map or a tag",
		data:         mustHexDecode("a20000ff"),
		wantErrorMsg: "cbor: unexpected \"break\" code",
	},
	{
		name:         "break occurring in a definite-length array or map or a tag",
		data:         mustHexDecode("9f81ff"),
		wantErrorMsg: "cbor: unexpected \"break\" code",
	},
	{
		name:         "break occurring in a definite-length array or map or a tag",
		data:         mustHexDecode("9f829f819f9fffffffff"),
		wantErrorMsg: "cbor: unexpected \"break\" code",
	},
	{
		name:         "break in indefinite-length map would lead to odd number of items (break in a value position)",
		data:         mustHexDecode("bf00ff"),
		wantErrorMsg: "cbor: unexpected \"break\" code",
	},
	{
		name:         "break in indefinite-length map would lead to odd number of items (break in a value position)",
		data:         mustHexDecode("bf000000ff"),
		wantErrorMsg: "cbor: unexpected \"break\" code",
	},
	{
		name:         "major type 0 with additional information 31",
		data:         mustHexDecode("1f"),
		wantErrorMsg: "cbor: invalid additional information 31 for type positive integer",
	},
	{
		name:         "major type 1 with additional information 31",
		data:         mustHexDecode("3f"),
		wantErrorMsg: "cbor: invalid additional information 31 for type negative integer",
	},
	{
		name:         "major type 6 with additional information 31",
		data:         mustHexDecode("df"),
		wantErrorMsg: "cbor: invalid additional information 31 for type tag",
	},
	// Extraneous data
	{
		name:         "two ints",
		data:         mustHexDecode("0001"),
		wantErrorMsg: "cbor: 1 bytes of extraneous data starting at index 1",
	},
	{
		name:         "two arrays",
		data:         mustHexDecode("830102038104"),
		wantErrorMsg: "cbor: 2 bytes of extraneous data starting at index 4",
	},
	{
		name:         "int and partial array",
		data:         mustHexDecode("00830102"),
		wantErrorMsg: "cbor: 3 bytes of extraneous data starting at index 1",
	},
	// Indefinite-length map
	{
		name:         "indefinite-length map with one key and no value",
		data:         []byte{0xbf, 0x61, 'a', 0xff},
		wantErrorMsg: `cbor: unexpected "break" code`,
	},
	{
		name:         "indefinite-length map with two keys and one value",
		data:         []byte{0xbf, 0x61, 'a', 0x01, 0x61, 'b', 0xff},
		wantErrorMsg: `cbor: unexpected "break" code`,
	},
}

func TestInvalidCBORUnmarshal(t *testing.T) {
	for _, tc := range invalidCBORUnmarshalTestCases {
		t.Run(tc.name, func(t *testing.T) {
			var i any
			err := unmarshal(t, tc.data, &i)
			checkError[error](t, "Unmarshal", err, tc.wantErrorMsg)

			// Test wellformedHead and tryWellformedSmallHead
			d := &decoder{data: tc.data, dm: defaultDecMode}
			sct, sai, sval, ok := d.tryWellformedSmallHead()
			if ok {
				d = &decoder{data: tc.data, dm: defaultDecMode}
				ct, ai, val, err := d.wellformedHead()
				checkNoError(t, "d.wellformedHead", err)
				if sct != ct || sai != ai || sval != val {
					t.Errorf("d.wellformedHead(0x%x) = (%s, %d, %d), want (%s, %d, %d)", tc.data, ct, ai, val, sct, sai, sval)
				}
			}
		})
	}
}

func TestValidUTF8String(t *testing.T) {
	dmRejectInvalidUTF8 := mustDecMode(t, DecOptions{UTF8: UTF8RejectInvalid})
	dmDecodeInvalidUTF8 := mustDecMode(t, DecOptions{UTF8: UTF8DecodeInvalid})

	testCases := []struct {
		name    string
		data    []byte
		dm      DecMode
		wantObj any
	}{
		{
			name:    "with UTF8RejectInvalid",
			data:    mustHexDecode("6973747265616d696e67"),
			dm:      dmRejectInvalidUTF8,
			wantObj: "streaming",
		},
		{
			name:    "with UTF8DecodeInvalid",
			data:    mustHexDecode("6973747265616d696e67"),
			dm:      dmDecodeInvalidUTF8,
			wantObj: "streaming",
		},
		{
			name:    "indefinite-length with UTF8RejectInvalid",
			data:    mustHexDecode("7f657374726561646d696e67ff"),
			dm:      dmRejectInvalidUTF8,
			wantObj: "streaming",
		},
		{
			name:    "indefinite-length with UTF8DecodeInvalid",
			data:    mustHexDecode("7f657374726561646d696e67ff"),
			dm:      dmDecodeInvalidUTF8,
			wantObj: "streaming",
		},
	}
	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			// Decode to a value of type any.
			var i any
			err := unmarshalWithDM(t, tc.dm, tc.data, &i)
			checkUnmarshal(t, "dm.Unmarshal", i, err, tc.wantObj)

			// Decode to string
			var v string
			err = unmarshalWithDM(t, tc.dm, tc.data, &v)
			checkUnmarshal(t, "dm.Unmarshal", v, err, tc.wantObj)
		})
	}
}

func TestInvalidUTF8String(t *testing.T) {
	dmRejectInvalidUTF8 := mustDecMode(t, DecOptions{UTF8: UTF8RejectInvalid})
	dmDecodeInvalidUTF8 := mustDecMode(t, DecOptions{UTF8: UTF8DecodeInvalid})

	testCases := []struct {
		name         string
		data         []byte
		dm           DecMode
		wantObj      any
		wantErrorMsg string
	}{
		{
			name:         "with UTF8RejectInvalid",
			data:         mustHexDecode("61fe"),
			dm:           dmRejectInvalidUTF8,
			wantErrorMsg: invalidUTF8ErrorMsg,
		},
		{
			name:    "with UTF8DecodeInvalid",
			data:    mustHexDecode("61fe"),
			dm:      dmDecodeInvalidUTF8,
			wantObj: string([]byte{0xfe}),
		},
		{
			name:         "indefinite-length with UTF8RejectInvalid",
			data:         mustHexDecode("7f62e6b061b4ff"),
			dm:           dmRejectInvalidUTF8,
			wantErrorMsg: invalidUTF8ErrorMsg,
		},
		{
			name:    "indefinite-length with UTF8DecodeInvalid",
			data:    mustHexDecode("7f62e6b061b4ff"),
			dm:      dmDecodeInvalidUTF8,
			wantObj: string([]byte{0xe6, 0xb0, 0xb4}),
		},
		{
			name: "indefinite-length invalid UTF-8 in the second chunk with UTF8RejectInvalid",
			data: []byte{
				0x7f,
				0x62, 'a', 'b', // valid UTF-8
				0x62, 0x80, 0x81, // invalid UTF-8
				0x62, 'c', 'd', // valid UTF-8
				0xff,
			},
			dm:           dmRejectInvalidUTF8,
			wantErrorMsg: invalidUTF8ErrorMsg,
		},
		{
			name: "indefinite-length invalid UTF-8 in the second chunk with dmDecodeInvalidUTF8",
			data: []byte{
				0x7f,
				0x62, 'a', 'b', // valid UTF-8
				0x62, 0x80, 0x81, // invalid UTF-8
				0x62, 'c', 'd', // valid UTF-8
				0xff,
			},
			dm:      dmDecodeInvalidUTF8,
			wantObj: string([]byte{'a', 'b', 0x80, 0x81, 'c', 'd'}),
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			// Decode to a value of type any.
			var v any
			err := unmarshalWithDM(t, tc.dm, tc.data, &v)
			checkUnmarshalCase[error](t, "dm.Unmarshal", v, err, tc.wantObj, tc.wantErrorMsg != "", tc.wantErrorMsg)

			// Decode to string
			var s string
			err = unmarshalWithDM(t, tc.dm, tc.data, &s)
			checkUnmarshalCase[error](t, "dm.Unmarshal", s, err, tc.wantObj, tc.wantErrorMsg != "", tc.wantErrorMsg)
		})
	}

	// Test decoding of mixed invalid text string and valid text string
	// with UTF8RejectInvalid option (default)
	data := mustHexDecode("7f62e6b061b4ff7f657374726561646d696e67ff")
	dec := NewDecoder(bytes.NewReader(data))
	var s string
	err := dec.Decode(&s)
	checkUnmarshalErr[error](t, "Decoder.Decode", s, err, "", invalidUTF8ErrorMsg)
	err = dec.Decode(&s)
	checkUnmarshal(t, "Decoder.Decode", s, err, "streaming")

	// Test decoding of mixed invalid text string and valid text string
	// with UTF8DecodeInvalid option
	dec = dmDecodeInvalidUTF8.NewDecoder(bytes.NewReader(data))
	err = dec.Decode(&s)
	checkUnmarshal(t, "Decoder.Decode", s, err, string([]byte{0xe6, 0xb0, 0xb4}))
	err = dec.Decode(&s)
	checkUnmarshal(t, "Decoder.Decode", s, err, "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,
	}

	testCases := []struct {
		name string
		data []byte
		want any
	}{
		{
			name: "case-insensitive field name match",
			data: mustHexDecode("a868696e746669656c64187b6a666c6f61746669656c64fa47c3500069626f6f6c6669656c64f56b537472696e674669656c6464746573746f42797465537472696e674669656c64430103056a41727261794669656c64826568656c6c6f65776f726c64684d61704669656c64a2676d6f726e696e67f56961667465726e6f6f6ef4714e65737465645374727563744669656c64a261581903e861591a000f4240"),
			want: want,
		},
		{
			name: "exact field name match",
			data: mustHexDecode("a868496e744669656c64187b6a466c6f61744669656c64fa47c3500069426f6f6c4669656c64f56b537472696e674669656c6464746573746f42797465537472696e674669656c64430103056a41727261794669656c64826568656c6c6f65776f726c64684d61704669656c64a2676d6f726e696e67f56961667465726e6f6f6ef4714e65737465645374727563744669656c64a261581903e861591a000f4240"),
			want: want,
		},
	}
	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			var v outer
			err := unmarshal(t, tc.data, &v)
			checkUnmarshal(t, "Unmarshal", v, err, 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,
	}

	data := mustHexDecode("a868496e744669656c64187b6a466c6f61744669656c64fa47c3500069426f6f6c4669656c64f56b537472696e674669656c6464746573746f42797465537472696e674669656c64430103056a41727261794669656c64826568656c6c6f65776f726c64684d61704669656c64a2676d6f726e696e67f56961667465726e6f6f6ef4714e65737465645374727563744669656c64a261581903e861591a000f4240")
	wantErrorMsg := "cbor: cannot unmarshal UTF-8 text string into Go struct field cbor.outer2.ArrayField of type int"

	var v outer2
	err := unmarshal(t, data, &v)
	checkUnmarshalErr[*UnmarshalTypeError](t, "Unmarshal", v, err, want, wantErrorMsg)
}

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)
	data := mustHexDecode("a3fa47c35000026161614161fe6142") // {100000.0:2, "a":"A", 0xfe: B}
	wantErrorMsg := "cbor: cannot unmarshal primitives into Go value of type string (map key is of type primitives and cannot be used to match struct field name)"

	v := strc{}
	err := unmarshal(t, data, &v)
	checkUnmarshalErr[*UnmarshalTypeError](t, "Unmarshal", v, err, want, wantErrorMsg)

	// Unmarshal returns first error encountered, which is *cbor.SemanticError (invalid UTF8 string)
	data = mustHexDecode("a361fe6142010261616141") // {0xfe: B, 1:2, "a":"A"}
	v = strc{}
	err = unmarshal(t, data, &v)
	checkUnmarshalErr[*SemanticError](t, "Unmarshal", v, err, want, invalidUTF8ErrorMsg)

	// Unmarshal returns first error encountered, which is *cbor.SemanticError (invalid UTF8 string)
	data = mustHexDecode("a3616261fe010261616141") // {"b": 0xfe, 1:2, "a":"A"}
	v = strc{}
	err = unmarshal(t, data, &v)
	checkUnmarshalErr[*SemanticError](t, "Unmarshal", v, err, want, invalidUTF8ErrorMsg)
}

func TestUnmarshalPrefilledArray(t *testing.T) {
	prefilledArr := []int{1, 2, 3, 4, 5}
	want := []int{10, 11, 3, 4, 5}
	data := mustHexDecode("820a0b") // []int{10, 11}
	err := unmarshal(t, data, &prefilledArr)
	checkUnmarshal(t, "Unmarshal", prefilledArr, err, []int{10, 11})
	if len(prefilledArr) != 2 || cap(prefilledArr) != 5 {
		t.Errorf("Unmarshal(0x%x) = %v (len %d, cap %d), want len == 2, cap == 5", data, prefilledArr, len(prefilledArr), cap(prefilledArr))
	}
	if !reflect.DeepEqual(prefilledArr[:cap(prefilledArr)], want) {
		t.Errorf("Unmarshal(0x%x) = %v (%T), want %v (%T)", data, prefilledArr, prefilledArr, want, want)
	}

	data = mustHexDecode("80") // empty array
	err = unmarshal(t, data, &prefilledArr)
	checkUnmarshal(t, "Unmarshal", prefilledArr, err, []int{})
	if len(prefilledArr) != 0 || cap(prefilledArr) != 0 {
		t.Errorf("Unmarshal(0x%x) = %v (len %d, cap %d), want len == 0, cap == 0", data, 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"}
	data := mustHexDecode("a56161614161626142616361436164614461656145") // map[string]string{"a": "A", "b": "B", "c": "C", "d": "D", "e": "E"}
	err := unmarshal(t, data, &prefilledMap)
	checkUnmarshal(t, "Unmarshal", prefilledMap, err, want)

	prefilledMap = map[string]string{"key": "value"}
	want = map[string]string{"key": "value"}
	data = mustHexDecode("a0") // map[string]string{}
	err = unmarshal(t, data, &prefilledMap)
	checkUnmarshal(t, "Unmarshal", prefilledMap, err, 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}
	data := mustHexDecode("a26161016162820203") // map[string]any {"a": 1, "b": []int{2, 3}}
	err := unmarshal(t, data, &prefilledStruct)
	checkUnmarshal(t, "Unmarshal", prefilledStruct, err, want)
	if len(prefilledStruct.B) != 2 || cap(prefilledStruct.B) != 4 {
		t.Errorf("Unmarshal(0x%x) = %v (len %d, cap %d), want len == 2, cap == 4", data, 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)", data, 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
	data, err := Marshal(struc)
	checkNoError(t, "Marshal", err)

	var struc2 TestStruct
	err = unmarshal(t, data, &struc2)
	checkUnmarshal(t, "Unmarshal", struc2, err, struc)
}

func TestLengthOverflowsInt(t *testing.T) {
	// Data is generating by go-fuzz.
	// string/slice/map length in uint64 cast to int causes integer overflow.
	testCases := []struct {
		name         string
		data         []byte
		wantErrorMsg string
	}{
		{name: "map length", data: mustHexDecode("bbcf30303030303030cfd697829782"), wantErrorMsg: "cbor: map length 14929485748258222128 is too large, it would cause integer overflow"},
		{name: "byte string length", data: mustHexDecode("5bcf30303030303030cfd697829782"), wantErrorMsg: "cbor: byte string length 14929485748258222128 is too large, causing integer overflow"},
	}
	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			var intf any
			err := unmarshal(t, tc.data, &intf)
			checkError[error](t, "Unmarshal", err, tc.wantErrorMsg)
		})
	}
}

func TestMapKeyHashable(t *testing.T) {
	type anyArray [1]any
	type namedAnyArray [1]namedAny
	type anyStruct struct{ X any }
	type namedAnyStruct struct{ X namedAny }

	typeMapAnyArrayAny := reflect.TypeFor[map[anyArray]any]()
	typeMapNamedAnyArrayAny := reflect.TypeFor[map[namedAnyArray]any]()
	typeMapAnyStructAny := reflect.TypeFor[map[anyStruct]any]()
	typeMapNamedAnyStructAny := reflect.TypeFor[map[namedAnyStruct]any]()
	typeMapTagAny := reflect.TypeFor[map[Tag]any]()

	testCases := []struct {
		name          string
		data          []byte
		wantObjs      map[reflect.Type]any
		wantErrorMsgs map[reflect.Type]string
	}{
		{
			name: "[]",
			data: mustHexDecode("a18002"), // {[]: 2}
			wantErrorMsgs: map[reflect.Type]string{
				typeAny:            "cbor: invalid map key type: []interface {}",
				typeMapAnyAny:      "cbor: invalid map key type: []interface {}",
				typeMapNamedAnyAny: "cbor: invalid map key type: []interface {}",
			},
		},
		{
			name: "[1]",
			data: mustHexDecode("a1810102"), // {[1]: 2}
			wantErrorMsgs: map[reflect.Type]string{
				typeAny:            "cbor: invalid map key type: []interface {}",
				typeMapAnyAny:      "cbor: invalid map key type: []interface {}",
				typeMapNamedAnyAny: "cbor: invalid map key type: []interface {}",
			},
			wantObjs: map[reflect.Type]any{
				typeMapAnyArrayAny:      map[anyArray]any{[1]any{uint64(1)}: uint64(2)},
				typeMapNamedAnyArrayAny: map[namedAnyArray]any{[1]namedAny{uint64(1)}: uint64(2)},
			},
		},
		{
			name: "{}",
			data: mustHexDecode("a1a002"), // {{}: 2}
			wantErrorMsgs: map[reflect.Type]string{
				typeAny:            "cbor: invalid map key type: map[interface {}]interface {}",
				typeMapAnyAny:      "cbor: invalid map key type: map[interface {}]interface {}",
				typeMapNamedAnyAny: "cbor: invalid map key type: map[interface {}]interface {}",
			},
		},
		{
			name: "{1:2}",
			data: mustHexDecode("a1a1010203"), // {{1:2}: 2}
			wantErrorMsgs: map[reflect.Type]string{
				typeAny:            "cbor: invalid map key type: map[interface {}]interface {}",
				typeMapAnyAny:      "cbor: invalid map key type: map[interface {}]interface {}",
				typeMapNamedAnyAny: "cbor: invalid map key type: map[interface {}]interface {}",
			},
		},
		{
			name: "big.Int",
			data: mustHexDecode("a13bbd3030303030303030"), // {-13632449055575519281: -17}
			wantErrorMsgs: map[reflect.Type]string{
				typeAny:            "cbor: invalid map key type: big.Int",
				typeMapAnyAny:      "cbor: invalid map key type: big.Int",
				typeMapNamedAnyAny: "cbor: invalid map key type: big.Int",
			},
		},
		{
			name: "tagged positive big.Int",
			data: mustHexDecode("a1c24901000000000000000030"), // {18446744073709551616: -17}
			wantErrorMsgs: map[reflect.Type]string{
				typeAny:            "cbor: invalid map key type: big.Int",
				typeMapAnyAny:      "cbor: invalid map key type: big.Int",
				typeMapNamedAnyAny: "cbor: invalid map key type: big.Int",
			},
		},
		{
			name: "tagged negative big.Int",
			data: mustHexDecode("a1c34901000000000000000030"), // {-18446744073709551617: -17}
			wantErrorMsgs: map[reflect.Type]string{
				typeAny:            "cbor: invalid map key type: big.Int",
				typeMapAnyAny:      "cbor: invalid map key type: big.Int",
				typeMapNamedAnyAny: "cbor: invalid map key type: big.Int",
			},
		},
		{
			name: "tagged time.Time",
			data: mustHexDecode("a1c074323031332d30332d32315432303a30343a30305a01"), // {0("2013-03-21T20:04:00Z"): 1}
			wantObjs: map[reflect.Type]any{
				typeAny:            map[any]any{time.Date(2013, 3, 21, 20, 4, 0, 0, time.UTC): uint64(1)},
				typeMapAnyAny:      map[any]any{time.Date(2013, 3, 21, 20, 4, 0, 0, time.UTC): uint64(1)},
				typeMapNamedAnyAny: map[namedAny]any{time.Date(2013, 3, 21, 20, 4, 0, 0, time.UTC): uint64(1)},
				typeMapTagAny:      map[Tag]any{{Number: 0, Content: "2013-03-21T20:04:00Z"}: uint64(1)},
			},
		},
		{
			name: "[[1]]",
			data: mustHexDecode("a181810102"), // {[[1]]: 2}
			wantErrorMsgs: map[reflect.Type]string{
				typeMapAnyArrayAny:      "cbor: invalid map key type: cbor.anyArray",
				typeMapNamedAnyArrayAny: "cbor: invalid map key type: cbor.namedAnyArray",
			},
		},
		{
			name: "{X: 1}",
			data: mustHexDecode("a1a161580102"), // {{"X": 1}: 2}
			wantObjs: map[reflect.Type]any{
				typeMapAnyStructAny:      map[anyStruct]any{{X: uint64(1)}: uint64(2)},
				typeMapNamedAnyStructAny: map[namedAnyStruct]any{{X: uint64(1)}: uint64(2)},
			},
		},
		{
			name: "{X: [1]}",
			data: mustHexDecode("a1a16158810102"), // {{"X": [1]}: 2}
			wantErrorMsgs: map[reflect.Type]string{
				typeMapAnyStructAny:      "cbor: invalid map key type: cbor.anyStruct",
				typeMapNamedAnyStructAny: "cbor: invalid map key type: cbor.namedAnyStruct",
			},
		},
		{
			name: "139(1)",
			data: mustHexDecode("a1d88b0102"), // {139(1): 2}
			wantObjs: map[reflect.Type]any{
				typeAny:            map[any]any{Tag{Number: 139, Content: uint64(1)}: uint64(2)},
				typeMapAnyAny:      map[any]any{Tag{Number: 139, Content: uint64(1)}: uint64(2)},
				typeMapNamedAnyAny: map[namedAny]any{Tag{Number: 139, Content: uint64(1)}: uint64(2)},
				typeMapTagAny:      map[Tag]any{{Number: 139, Content: uint64(1)}: uint64(2)},
			},
		},
		{
			name: "139([1])",
			data: mustHexDecode("a1d88b810102"), // {139([1]): 2}
			wantErrorMsgs: map[reflect.Type]string{
				typeAny:            "cbor: invalid map key type: cbor.Tag",
				typeMapAnyAny:      "cbor: invalid map key type: cbor.Tag",
				typeMapNamedAnyAny: "cbor: invalid map key type: cbor.Tag",
				typeMapTagAny:      "cbor: invalid map key type: cbor.Tag",
			},
		},
	}

	name := func(typ reflect.Type, tcName string) string {
		if typ.Kind() == reflect.Map {
			return fmt.Sprintf("map key type %s, value %s", typ.Key(), tcName)
		}
		return fmt.Sprintf("destination %s, value %s", typ, tcName)
	}

	for _, tc := range testCases {
		for typ, wantObj := range tc.wantObjs {
			t.Run(name(typ, tc.name), func(t *testing.T) {
				v := reflect.New(typ)
				err := unmarshal(t, tc.data, v.Interface())
				checkUnmarshal(t, "Unmarshal", v.Elem().Interface(), err, wantObj)
			})
		}

		for typ, wantErrorMsg := range tc.wantErrorMsgs {
			t.Run(name(typ, tc.name), func(t *testing.T) {
				v := reflect.New(typ)
				err := unmarshal(t, tc.data, v.Interface())
				checkError[error](t, "Unmarshal", err, wantErrorMsg)
			})
		}
	}
}

func TestRegisteredMapKeyHashable(t *testing.T) {
	type intSlice []int // Type not comparable

	type intArray [1]int     // Type and value comparable
	type sliceArray [1][]int // Type and value not comparable
	type anyArray [1]any     // Type comparable, value maybe comparable

	type intStruct struct{ X int }     // Type and value comparable
	type sliceStruct struct{ X []int } // Type and value not comparable
	type anyStruct struct{ X any }     // Type comparable, value maybe comparable

	type intStructArray [1]intStruct     // Type and value comparable
	type sliceStructArray [1]sliceStruct // Type and value not comparable
	type anyStructArray [1]anyStruct     // Type comparable, value maybe comparable

	type zeroIntArray [0]int                 // Type and value comparable
	type zeroSliceStructArray [0]sliceStruct // Type and value not comparable

	tagOpts := TagOptions{EncTag: EncTagRequired, DecTag: DecTagRequired}
	tags := NewTagSet()
	mustAddTag(t, tags, tagOpts, reflect.TypeFor[intArray](), 128)
	mustAddTag(t, tags, tagOpts, reflect.TypeFor[sliceArray](), 129)
	mustAddTag(t, tags, tagOpts, reflect.TypeFor[anyArray](), 130)
	mustAddTag(t, tags, tagOpts, reflect.TypeFor[intStruct](), 131)
	mustAddTag(t, tags, tagOpts, reflect.TypeFor[sliceStruct](), 132)
	mustAddTag(t, tags, tagOpts, reflect.TypeFor[anyStruct](), 133)
	mustAddTag(t, tags, tagOpts, reflect.TypeFor[intStructArray](), 134)
	mustAddTag(t, tags, tagOpts, reflect.TypeFor[sliceStructArray](), 135)
	mustAddTag(t, tags, tagOpts, reflect.TypeFor[anyStructArray](), 136)
	mustAddTag(t, tags, tagOpts, reflect.TypeFor[zeroIntArray](), 137)
	mustAddTag(t, tags, tagOpts, reflect.TypeFor[zeroSliceStructArray](), 138)
	mustAddTag(t, tags, tagOpts, reflect.TypeFor[intSlice](), 139)

	dm := mustDecModeWithTags(t, DecOptions{}, tags)

	destinationTypes := []reflect.Type{
		typeAny,            // any
		typeMapAnyAny,      // map[any]any
		typeMapNamedAnyAny, // map[namedAny]any
	}

	testCases := []struct {
		name         string
		data         []byte
		wantObjs     map[reflect.Type]any
		wantErrorMsg string
	}{
		{
			name:         "map key type []int",
			data:         mustHexDecode("a1d88b810102"), // {139([1]): 2}
			wantErrorMsg: "cbor: invalid map key type: cbor.intSlice",
		},
		{
			name: "map key type [1]int",
			data: mustHexDecode("a1d880810102"), // {128([1]): 2}
			wantObjs: map[reflect.Type]any{
				typeAny:            map[any]any{intArray([1]int{1}): uint64(2)},
				typeMapAnyAny:      map[any]any{intArray([1]int{1}): uint64(2)},
				typeMapNamedAnyAny: map[namedAny]any{intArray([1]int{1}): uint64(2)},
			},
		},
		{
			name:         "map key type [1][]int",
			data:         mustHexDecode("a1d88181810102"), // {129([[1]]): 2}
			wantErrorMsg: "cbor: invalid map key type: cbor.sliceArray",
		},
		{
			name: "map key type [1]any, value [1]",
			data: mustHexDecode("a1d882810102"), // {130([1]): 2}
			wantObjs: map[reflect.Type]any{
				typeAny:            map[any]any{anyArray([1]any{uint64(1)}): uint64(2)},
				typeMapAnyAny:      map[any]any{anyArray([1]any{uint64(1)}): uint64(2)},
				typeMapNamedAnyAny: map[namedAny]any{anyArray([1]any{uint64(1)}): uint64(2)},
			},
		},
		{
			name:         "map key type [1]any, value [[1]]",
			data:         mustHexDecode("a1d88281810102"), // {130([[1]]): 2}
			wantErrorMsg: "cbor: invalid map key type: cbor.anyArray",
		},
		{
			name: "map key type intStruct",
			data: mustHexDecode("a1d883a161580102"), // {131({"X": 1}): 2}
			wantObjs: map[reflect.Type]any{
				typeAny:            map[any]any{intStruct{X: 1}: uint64(2)},
				typeMapAnyAny:      map[any]any{intStruct{X: 1}: uint64(2)},
				typeMapNamedAnyAny: map[namedAny]any{intStruct{X: 1}: uint64(2)},
			},
		},
		{
			name:         "map key type sliceStruct",
			data:         mustHexDecode("a1d884a16158810102"), // {132({"X": [1]}): 2}
			wantErrorMsg: "cbor: invalid map key type: cbor.sliceStruct",
		},
		{
			name: "map key type anyStruct, value anyStruct{X: 1}",
			data: mustHexDecode("a1d885a161580102"), // {133({"X": 1}): 2}
			wantObjs: map[reflect.Type]any{
				typeAny:            map[any]any{anyStruct{X: uint64(1)}: uint64(2)},
				typeMapAnyAny:      map[any]any{anyStruct{X: uint64(1)}: uint64(2)},
				typeMapNamedAnyAny: map[namedAny]any{anyStruct{X: uint64(1)}: uint64(2)},
			},
		},
		{
			name:         "map key type anyStruct, value anyStruct{X: [1]}",
			data:         mustHexDecode("a1d885a16158810102"), // {133({"X": [1]}): 2}
			wantErrorMsg: "cbor: invalid map key type: cbor.anyStruct",
		},
		{
			name: "map key type intStructArray",
			data: mustHexDecode("a1d88681d883a161580102"), // {134([131({"X": 1})]): 2}
			wantObjs: map[reflect.Type]any{
				typeAny:            map[any]any{intStructArray([1]intStruct{{X: 1}}): uint64(2)},
				typeMapAnyAny:      map[any]any{intStructArray([1]intStruct{{X: 1}}): uint64(2)},
				typeMapNamedAnyAny: map[namedAny]any{intStructArray([1]intStruct{{X: 1}}): uint64(2)},
			},
		},
		{
			name:         "map key type sliceStructArray",
			data:         mustHexDecode("a1d88781d884a16158810102"), // {135([132({"X": [1]})]): 2}
			wantErrorMsg: "cbor: invalid map key type: cbor.sliceStructArray",
		},
		{
			name: "map key type anyStructArray, value [1]anyStruct{X: 1}",
			data: mustHexDecode("a1d88881d885a161580102"), // {136([133({"X": 1})]): 2}
			wantObjs: map[reflect.Type]any{
				typeAny:            map[any]any{anyStructArray([1]anyStruct{{X: uint64(1)}}): uint64(2)},
				typeMapAnyAny:      map[any]any{anyStructArray([1]anyStruct{{X: uint64(1)}}): uint64(2)},
				typeMapNamedAnyAny: map[namedAny]any{anyStructArray([1]anyStruct{{X: uint64(1)}}): uint64(2)},
			},
		},
		{
			name:         "map key type anyStructArray, value [1]anyStruct{X: [1]}",
			data:         mustHexDecode("a1d88881d885a16158810102"), // {136([133({"X": [1]})]): 2}
			wantErrorMsg: "cbor: invalid map key type: cbor.anyStructArray",
		},
		{
			name: "map key type [0]int",
			data: mustHexDecode("a1d8898002"), // {137([]): 2}
			wantObjs: map[reflect.Type]any{
				typeAny:            map[any]any{zeroIntArray([0]int{}): uint64(2)},
				typeMapAnyAny:      map[any]any{zeroIntArray([0]int{}): uint64(2)},
				typeMapNamedAnyAny: map[namedAny]any{zeroIntArray([0]int{}): uint64(2)},
			},
		},
		{
			name:         "map key type [0]sliceStruct",
			data:         mustHexDecode("a1d88a8002"), // {138([]): 2}
			wantErrorMsg: "cbor: invalid map key type: cbor.zeroSliceStructArray",
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			for _, typ := range destinationTypes {
				v := reflect.New(typ)
				err := unmarshalWithDM(t, dm, tc.data, v.Interface())
				checkUnmarshalCase[error](t, "dm.Unmarshal", v.Elem().Interface(), err, tc.wantObjs[typ], tc.wantErrorMsg != "", tc.wantErrorMsg)
			}
		})
	}
}

func TestMapKeyNaN(t *testing.T) {
	// Data is generating by go-fuzz.
	data := mustHexDecode("b0303030303030303030303030303030303038303030faffff30303030303030303030303030") // {-17: -17, NaN: -17}
	var intf any
	err := unmarshal(t, data, &intf)
	checkNoError(t, "Unmarshal", err)

	em := mustEncMode(t, EncOptions{Sort: SortCanonical})
	_, err = em.Marshal(intf)
	checkNoError(t, "em.Marshal", err)
}

func TestUnmarshalUndefinedElement(t *testing.T) {
	// Data is generating by go-fuzz.
	data := mustHexDecode("bfd1a388f730303030303030303030303030ff") // {17({[undefined, -17, -17, -17, -17, -17, -17, -17]: -17, -17: -17}): -17}
	var intf any
	wantErrorMsg := "cbor: invalid map key type: []interface {}"
	err := unmarshal(t, data, &intf)
	checkError[error](t, "Unmarshal", err, wantErrorMsg)
}

func TestMapKeyNil(t *testing.T) {
	for _, tc := range []struct {
		name         string
		data         []byte
		want         any
		decodeToType reflect.Type
	}{
		{
			name:         "decode {null: 1} to any",
			data:         mustHexDecode("a1f601"), // {null: 1}
			want:         map[any]any{nil: uint64(1)},
			decodeToType: typeAny,
		},
		{
			name:         "decode {null: 1} to map[any]any",
			data:         mustHexDecode("a1f601"), // {null: 1}
			want:         map[any]any{nil: uint64(1)},
			decodeToType: typeMapAnyAny,
		},
		{
			name:         "decode {null: 1} to map[int]any",
			data:         mustHexDecode("a1f601"), // {null: 1}
			want:         map[int]any{0: uint64(1)},
			decodeToType: reflect.TypeFor[map[int]any](),
		},
		{
			name:         "decode {null: 1} to map[string]any",
			data:         mustHexDecode("a1f601"), // {null: 1}
			want:         map[string]any{"": uint64(1)},
			decodeToType: reflect.TypeFor[map[string]any](),
		},
		{
			name:         "decode {null: 1, 2: 3} to any",
			data:         mustHexDecode("a2f6010203"), // {null: 1, 2: 3}
			want:         map[any]any{nil: uint64(1), uint64(2): uint64(3)},
			decodeToType: typeAny,
		},
		{
			name:         "decode {null: 1, 2: 3} to map[any]any",
			data:         mustHexDecode("a2f6010203"), // {null: 1, 2: 3}
			want:         map[any]any{nil: uint64(1), uint64(2): uint64(3)},
			decodeToType: typeMapAnyAny,
		},
		{
			name:         "decode {null: 1, 2: 3} to map[int]any",
			data:         mustHexDecode("a2f6010203"), // {null: 1, 2: 3}
			want:         map[int]any{0: uint64(1), int(2): uint64(3)},
			decodeToType: reflect.TypeFor[map[int]any](),
		},
		{
			name:         "decode {null: 1, \"a\": 3} to map[string]any",
			data:         mustHexDecode("a2f601616103"), // {null: 1, "a": 3}
			want:         map[string]any{"": uint64(1), "a": uint64(3)},
			decodeToType: reflect.TypeFor[map[string]any](),
		},
		{
			name:         "decode {2: 3, null: 1} to any",
			data:         mustHexDecode("a20203f601"), // {2: 3, null: 1}
			want:         map[any]any{nil: uint64(1), uint64(2): uint64(3)},
			decodeToType: typeAny,
		},
		{
			name:         "decode {2: 3, null: 1} to map[any]any",
			data:         mustHexDecode("a20203f601"), // {2: 3, null: 1}
			want:         map[any]any{nil: uint64(1), uint64(2): uint64(3)},
			decodeToType: typeMapAnyAny,
		},
		{
			name:         "decode {2: 3, null: 1} to map[int]any",
			data:         mustHexDecode("a20203f601"), // {2: 3, null: 1}
			want:         map[int]any{0: uint64(1), int(2): uint64(3)},
			decodeToType: reflect.TypeFor[map[int]any](),
		},
		{
			name:         "decode {\"a\": 3, null: 1} to map[string]any",
			data:         mustHexDecode("a2616103f601"), // {"a": 3, null: 1}
			want:         map[string]any{"": uint64(1), "a": uint64(3)},
			decodeToType: reflect.TypeFor[map[string]any](),
		},
		{
			name:         "decode {\"a\": 3, 100(null): 1} to map[string]any",
			data:         mustHexDecode("a2616103d864f601"), // {"a": 3, 100(null): 1}
			want:         map[string]any{"": uint64(1), "a": uint64(3)},
			decodeToType: reflect.TypeFor[map[string]any](),
		},
		{
			name:         "decode {\"a\": 3, 55799(null): 1} to map[string]any",
			data:         mustHexDecode("a2616103d9d9f7f601"), // {"a": 3, 55799(null): 1}
			want:         map[string]any{"": uint64(1), "a": uint64(3)},
			decodeToType: reflect.TypeFor[map[string]any](),
		},
	} {
		t.Run(tc.name, func(t *testing.T) {
			v := reflect.New(tc.decodeToType)
			err := unmarshal(t, tc.data, v.Interface())
			checkUnmarshal(t, "Unmarshal", v.Elem().Interface(), err, tc.want)
		})
	}
}

func TestMapKeyDuplicateNil(t *testing.T) {
	for _, tc := range []struct {
		name         string
		data         []byte
		want         any
		wantErrorMsg string
		decodeToType reflect.Type
		opts         DecOptions
	}{
		{
			name:         "decode {null: 1, null: 2} to any with DupMapKeyQuiet",
			data:         mustHexDecode("a2f601f602"), // {null: 1, null: 2}
			want:         map[any]any{nil: uint64(2)},
			decodeToType: typeAny,
			opts: DecOptions{
				DupMapKey: DupMapKeyQuiet,
			},
		},
		{
			name:         "decode {null: 1, null: 2} to any with DupMapKeyEnforcedAPF",
			data:         mustHexDecode("a2f601f602"), // {null: 1, null: 2}
			wantErrorMsg: "cbor: found duplicate map key <nil> at map element index 1",
			decodeToType: typeAny,
			opts: DecOptions{
				DupMapKey: DupMapKeyEnforcedAPF,
			},
		},
		{
			name:         "decode {null: 1, null: 2} to map[any]any with DupMapKeyQuiet",
			data:         mustHexDecode("a2f601f602"), // {null: 1, null: 2}
			want:         map[any]any{nil: uint64(2)},
			decodeToType: typeMapAnyAny,
			opts: DecOptions{
				DupMapKey: DupMapKeyQuiet,
			},
		},
		{
			name:         "decode {null: 1, null: 2} to map[any]any with DupMapKeyEnforcedAPF",
			data:         mustHexDecode("a2f601f602"), // {null: 1, null: 2}
			wantErrorMsg: "cbor: found duplicate map key <nil> at map element index 1",
			decodeToType: typeMapAnyAny,
			opts: DecOptions{
				DupMapKey: DupMapKeyEnforcedAPF,
			},
		},
		{
			name:         "decode {null: 1, null: 2} to map[int]any with DupMapKeyQuiet",
			data:         mustHexDecode("a2f601f602"), // {null: 1, null: 2}
			want:         map[int]any{0: uint64(2)},
			decodeToType: reflect.TypeFor[map[int]any](),
			opts: DecOptions{
				DupMapKey: DupMapKeyQuiet,
			},
		},
		{
			name:         "decode {null: 1, null: 2} to map[int]any with DupMapKeyEnforcedAPF",
			data:         mustHexDecode("a2f601f602"), // {null: 1, null: 2}
			wantErrorMsg: "cbor: found duplicate map key 0 at map element index 1",
			decodeToType: reflect.TypeFor[map[int]any](),
			opts: DecOptions{
				DupMapKey: DupMapKeyEnforcedAPF,
			},
		},
		{
			name:         "decode {null: 1, null: 2} to map[string]any with DupMapKeyQuiet",
			data:         mustHexDecode("a2f601f602"), // {null: 1, null: 2}
			want:         map[string]any{"": uint64(2)},
			decodeToType: reflect.TypeFor[map[string]any](),
			opts: DecOptions{
				DupMapKey: DupMapKeyQuiet,
			},
		},
		{
			name:         "decode {null: 1, null: 2} to map[string]any with DupMapKeyEnforcedAPF",
			data:         mustHexDecode("a2f601f602"), // {null: 1, null: 2}
			wantErrorMsg: "cbor: found duplicate map key \"\" at map element index 1",
			decodeToType: reflect.TypeFor[map[string]any](),
			opts: DecOptions{
				DupMapKey: DupMapKeyEnforcedAPF,
			},
		},
	} {
		t.Run(tc.name, func(t *testing.T) {
			dm := mustDecMode(t, tc.opts)
			v := reflect.New(tc.decodeToType)
			err := unmarshalWithDM(t, dm, tc.data, v.Interface())
			checkUnmarshalCase[*DupMapKeyError](t, "dm.Unmarshal", v.Elem().Interface(), err, tc.want, tc.wantErrorMsg != "", tc.wantErrorMsg)
		})
	}
}

func TestMapValueNil(t *testing.T) {
	for _, tc := range []struct {
		name         string
		data         []byte
		want         any
		decodeToType reflect.Type
	}{
		{
			name:         "decode {1: null} to any",
			data:         mustHexDecode("a101f6"), // {1: null}
			want:         map[any]any{uint64(1): nil},
			decodeToType: typeAny,
		},
		{
			name:         "decode {1: null} to map[any]any",
			data:         mustHexDecode("a101f6"), // {1: null}
			want:         map[any]any{uint64(1): nil},
			decodeToType: typeMapAnyAny,
		},
		{
			name:         "decode {1: null} to map[int]int",
			data:         mustHexDecode("a101f6"), // {1: null}
			want:         map[int]int{1: 0},
			decodeToType: reflect.TypeFor[map[int]int](),
		},
		{
			name:         "decode {1: null, 2: 3} to any",
			data:         mustHexDecode("a201f60203"), // {1: null, 2: 3}
			want:         map[any]any{uint64(1): nil, uint64(2): uint64(3)},
			decodeToType: typeAny,
		},
		{
			name:         "decode {1: null, 2: 3} to map[any]any",
			data:         mustHexDecode("a201f60203"), // {1: null, 2: 3}
			want:         map[any]any{uint64(1): nil, uint64(2): uint64(3)},
			decodeToType: typeMapAnyAny,
		},
		{
			name:         "decode {1: null, 2: 3} to map[int]int",
			data:         mustHexDecode("a201f60203"), // {1: null, 2: 3}
			want:         map[int]int{1: 0, 2: 3},
			decodeToType: reflect.TypeFor[map[int]int](),
		},
		{
			name:         "decode {1: null, 2: \"a\"} to map[int]string",
			data:         mustHexDecode("a201f6026161"), // {1: null, 2: "a"}
			want:         map[int]string{1: "", 2: "a"},
			decodeToType: reflect.TypeFor[map[int]string](),
		},
		{
			name:         "decode {2: 3, 1: null} to any",
			data:         mustHexDecode("a2020301f6"), // {2: 3, 1: null}
			want:         map[any]any{uint64(1): nil, uint64(2): uint64(3)},
			decodeToType: typeAny,
		},
		{
			name:         "decode {2: 3, 1: null} to map[any]any",
			data:         mustHexDecode("a2020301f6"), // {2: 3, 1: null}
			want:         map[any]any{uint64(1): nil, uint64(2): uint64(3)},
			decodeToType: typeMapAnyAny,
		},
		{
			name:         "decode {2: 3, 1: null} to map[int]int",
			data:         mustHexDecode("a2020301f6"), // {2: 3, 1: null}
			want:         map[int]int{1: 0, 2: 3},
			decodeToType: reflect.TypeFor[map[int]int](),
		},
		{
			name:         "decode {2: \"a\", 1: null} to map[int]string",
			data:         mustHexDecode("a202616101f6"), // {2: "a", 1: null}
			want:         map[int]string{1: "", 2: "a"},
			decodeToType: reflect.TypeFor[map[int]string](),
		},
		{
			name:         "decode {\"a\": 3, \"b\": 100(null)} to map[string]int",
			data:         mustHexDecode("a26161036162d864f6"), // {"a": 3, "b": 100(null)}
			want:         map[string]int{"a": 3, "b": 0},
			decodeToType: reflect.TypeFor[map[string]int](),
		},
		{
			name:         "decode {\"a\": 3, \"b\": 55799(null)} to map[string]int",
			data:         mustHexDecode("a26161036162d9d9f7f6"), // {"a": 3, "b": 55799(null)}
			want:         map[string]int{"a": 3, "b": 0},
			decodeToType: reflect.TypeFor[map[string]int](),
		},
	} {
		t.Run(tc.name, func(t *testing.T) {
			v := reflect.New(tc.decodeToType)
			err := unmarshal(t, tc.data, v.Interface())
			checkUnmarshal(t, "Unmarshal", v.Elem().Interface(), err, tc.want)
		})
	}
}

type noopOnEmptyDataUnmarshaler string

func (su *noopOnEmptyDataUnmarshaler) UnmarshalCBOR(data []byte) error {
	var s string
	err := Unmarshal(data, &s)
	if err != nil {
		return err
	}
	if s == "" {
		// No-op on empty data
		return nil
	}
	*su = noopOnEmptyDataUnmarshaler(s)
	return nil
}

func TestMapEntryWithNoOpOnEmptyDataUnmarshaler(t *testing.T) {
	for _, tc := range []struct {
		name         string
		data         []byte
		want         any
		decodeToType reflect.Type
	}{
		{
			name:         "decode {\"a\": 2, \"\": 1} to map[noopOnEmptyDataUnmarshaler]int",
			data:         mustHexDecode("a26161026001"), // {"a": 2, "": 1}
			want:         map[noopOnEmptyDataUnmarshaler]int{noopOnEmptyDataUnmarshaler(""): 1, noopOnEmptyDataUnmarshaler("a"): 2},
			decodeToType: reflect.TypeFor[map[noopOnEmptyDataUnmarshaler]int](),
		},
		{
			name:         "decode {2: \"a\", 1: \"\"} to map[int]noopOnEmptyDataUnmarshaler",
			data:         mustHexDecode("a20261610160"), // {2: "a", 1: ""}
			want:         map[int]noopOnEmptyDataUnmarshaler{1: noopOnEmptyDataUnmarshaler(""), 2: noopOnEmptyDataUnmarshaler("a")},
			decodeToType: reflect.TypeFor[map[int]noopOnEmptyDataUnmarshaler](),
		},
	} {
		t.Run(tc.name, func(t *testing.T) {
			v := reflect.New(tc.decodeToType)
			err := unmarshal(t, tc.data, v.Interface())
			checkUnmarshal(t, "Unmarshal", v.Elem().Interface(), err, tc.want)
		})
	}
}

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",
	}
	data := mustHexDecode("a3616161416162614261636143") // {"a":"A", "b":"B", "c":"C"}

	var v strc
	err := unmarshal(t, data, &v)
	checkUnmarshal(t, "Unmarshal", v, err, 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",
	}
	data := mustHexDecode("a3616161416162614261636143") // {"a":"A", "b":"B", "c":"C"}

	var v strc
	err := unmarshal(t, data, &v)
	checkUnmarshal(t, "Unmarshal", v, err, 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",
	}
	data := mustHexDecode("a36161614161626142617a6143") // {"a":"A", "b":"B", "z":"C"}

	var v strc
	err := unmarshal(t, data, &v)
	checkUnmarshal(t, "Unmarshal", v, err, 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",
	}
	data := mustHexDecode("a3616161416162614261636143") // {"a":"A", "b":"B", "c":"C"}

	var v strc
	err := unmarshal(t, data, &v)
	checkUnmarshal(t, "Unmarshal", v, err, 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 fmt.Appendf(nil, "%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 := []roundTripTestCase{
		{
			name: "primitive obj",
			v:    number(1234567890),
			data: mustHexDecode("4800000000499602d2"),
		},
		{
			name: "struct obj",
			v:    stru{a: "a", b: "b", c: "c"},
			data: mustHexDecode("45612C622C63"),
		},
	}
	em := mustEncMode(t, EncOptions{})
	dm := mustDecMode(t, DecOptions{})
	testRoundTripCases(t, testCases, em, dm)
}

func TestBinaryUnmarshalerError(t *testing.T) { //nolint:dupl
	testCases := []struct {
		name         string
		typ          reflect.Type
		data         []byte
		wantErrorMsg string
	}{
		{
			name:         "primitive type",
			typ:          reflect.TypeFor[number](),
			data:         mustHexDecode("44499602d2"),
			wantErrorMsg: "number:UnmarshalBinary: invalid length",
		},
		{
			name:         "struct type",
			typ:          reflect.TypeFor[stru](),
			data:         mustHexDecode("47612C622C632C64"),
			wantErrorMsg: "stru:UnmarshalBinary: invalid element count",
		},
	}
	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			v := reflect.New(tc.typ)
			err := unmarshal(t, tc.data, v.Interface())
			checkError[error](t, "Unmarshal", err, tc.wantErrorMsg)
		})
	}
}

func TestBinaryMarshalerError(t *testing.T) {
	wantErrorMsg := "MarshalBinary: error"
	v := marshalBinaryError(wantErrorMsg)
	b, err := Marshal(v)
	checkMarshalErr[error](t, "Marshal", b, err, 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 := []roundTripTestCase{
		{
			name: "primitive obj",
			v:    number2(1),
			data: mustHexDecode("a1636e756d01"),
		},
		{
			name: "struct obj",
			v:    stru2{a: "a", b: "b", c: "c"},
			data: mustHexDecode("83616161626163"),
		},
	}
	em := mustEncMode(t, EncOptions{})
	dm := mustDecMode(t, DecOptions{})
	testRoundTripCases(t, testCases, em, dm)
}

func TestUnmarshalerError(t *testing.T) { //nolint:dupl
	testCases := []struct {
		name         string
		typ          reflect.Type
		data         []byte
		wantErrorMsg string
	}{
		{
			name:         "primitive type",
			typ:          reflect.TypeFor[number2](),
			data:         mustHexDecode("44499602d2"),
			wantErrorMsg: "cbor: cannot unmarshal byte string into Go value of type map[string]uint64",
		},
		{
			name:         "struct type",
			typ:          reflect.TypeFor[stru2](),
			data:         mustHexDecode("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)
			err := unmarshal(t, tc.data, v.Interface())
			checkError[error](t, "Unmarshal", err, tc.wantErrorMsg)
		})
	}
}

func TestMarshalerError(t *testing.T) {
	wantErrorMsg := "MarshalCBOR: error"
	v := marshalCBORError(wantErrorMsg)
	b, err := Marshal(v)
	checkMarshalErr[error](t, "Marshal", b, err, wantErrorMsg)
}

// Found at https://github.com/oasislabs/oasis-core/blob/master/go/common/cbor/cbor_test.go
func TestOutOfMem1(t *testing.T) {
	data := []byte("\x9b\x00\x00000000")
	var f []byte
	err := unmarshal(t, data, &f)
	checkUnmarshalErr[error](t, "Unmarshal", f, err, []byte(nil), "")
}

// Found at https://github.com/oasislabs/oasis-core/blob/master/go/common/cbor/cbor_test.go
func TestOutOfMem2(t *testing.T) {
	data := []byte("\x9b\x00\x00\x81112233")
	var f []byte
	err := unmarshal(t, data, &f)
	checkUnmarshalErr[error](t, "Unmarshal", f, err, []byte(nil), "")
}

// Found at https://github.com/cose-wg/Examples/tree/master/RFC8152
func TestCOSEExamples(t *testing.T) {
	data := [][]byte{
		mustHexDecode("D8608443A10101A1054C02D1F7E6F26C43D4868D87CE582464F84D913BA60A76070A9A48F26E97E863E2852948658F0811139868826E89218A75715B818440A101225818DBD43C4E9D719C27C6275C67D628D493F090593DB8218F11818344A1013818A220A401022001215820B2ADD44368EA6D641F9CA9AF308B4079AEB519F11E9B8A55A600B21233E86E6822F40458246D65726961646F632E6272616E64796275636B406275636B6C616E642E6578616D706C6540"),
		mustHexDecode("D8628440A054546869732069732074686520636F6E74656E742E818343A10126A1044231315840E2AEAFD40D69D19DFE6E52077C5D7FF4E408282CBEFB5D06CBF414AF2E19D982AC45AC98B8544C908B4507DE1E90B717C3D34816FE926A2B98F53AFD2FA0F30A"),
		mustHexDecode("D8628440A054546869732069732074686520636F6E74656E742E828343A10126A1044231315840E2AEAFD40D69D19DFE6E52077C5D7FF4E408282CBEFB5D06CBF414AF2E19D982AC45AC98B8544C908B4507DE1E90B717C3D34816FE926A2B98F53AFD2FA0F30A8344A1013823A104581E62696C626F2E62616767696E7340686F626269746F6E2E6578616D706C65588400A2D28A7C2BDB1587877420F65ADF7D0B9A06635DD1DE64BB62974C863F0B160DD2163734034E6AC003B01E8705524C5C4CA479A952F0247EE8CB0B4FB7397BA08D009E0C8BF482270CC5771AA143966E5A469A09F613488030C5B07EC6D722E3835ADB5B2D8C44E95FFB13877DD2582866883535DE3BB03D01753F83AB87BB4F7A0297"),
		mustHexDecode("D8628440A1078343A10126A10442313158405AC05E289D5D0E1B0A7F048A5D2B643813DED50BC9E49220F4F7278F85F19D4A77D655C9D3B51E805A74B099E1E085AACD97FC29D72F887E8802BB6650CCEB2C54546869732069732074686520636F6E74656E742E818343A10126A1044231315840E2AEAFD40D69D19DFE6E52077C5D7FF4E408282CBEFB5D06CBF414AF2E19D982AC45AC98B8544C908B4507DE1E90B717C3D34816FE926A2B98F53AFD2FA0F30A"),
		mustHexDecode("D8628456A2687265736572766564F40281687265736572766564A054546869732069732074686520636F6E74656E742E818343A10126A10442313158403FC54702AA56E1B2CB20284294C9106A63F91BAC658D69351210A031D8FC7C5FF3E4BE39445B1A3E83E1510D1ACA2F2E8A7C081C7645042B18ABA9D1FAD1BD9C"),
		mustHexDecode("D28443A10126A10442313154546869732069732074686520636F6E74656E742E58408EB33E4CA31D1C465AB05AAC34CC6B23D58FEF5C083106C4D25A91AEF0B0117E2AF9A291AA32E14AB834DC56ED2A223444547E01F11D3B0916E5A4C345CACB36"),
		mustHexDecode("D8608443A10101A1054CC9CF4DF2FE6C632BF788641358247ADBE2709CA818FB415F1E5DF66F4E1A51053BA6D65A1A0C52A357DA7A644B8070A151B0818344A1013818A220A40102200121582098F50A4FF6C05861C8860D13A638EA56C3F5AD7590BBFBF054E1C7B4D91D628022F50458246D65726961646F632E6272616E64796275636B406275636B6C616E642E6578616D706C6540"),
		mustHexDecode("D8608443A1010AA1054D89F52F65A1C580933B5261A76C581C753548A19B1307084CA7B2056924ED95F2E3B17006DFE931B687B847818343A10129A2335061616262636364646565666667676868044A6F75722D73656372657440"),
		mustHexDecode("D8608443A10101A2054CC9CF4DF2FE6C632BF7886413078344A1013823A104581E62696C626F2E62616767696E7340686F626269746F6E2E6578616D706C65588400929663C8789BB28177AE28467E66377DA12302D7F9594D2999AFA5DFA531294F8896F2B6CDF1740014F4C7F1A358E3A6CF57F4ED6FB02FCF8F7AA989F5DFD07F0700A3A7D8F3C604BA70FA9411BD10C2591B483E1D2C31DE003183E434D8FBA18F17A4C7E3DFA003AC1CF3D30D44D2533C4989D3AC38C38B71481CC3430C9D65E7DDFF58247ADBE2709CA818FB415F1E5DF66F4E1A51053BA6D65A1A0C52A357DA7A644B8070A151B0818344A1013818A220A40102200121582098F50A4FF6C05861C8860D13A638EA56C3F5AD7590BBFBF054E1C7B4D91D628022F50458246D65726961646F632E6272616E64796275636B406275636B6C616E642E6578616D706C6540"),
		mustHexDecode("D8608443A10101A1054C02D1F7E6F26C43D4868D87CE582464F84D913BA60A76070A9A48F26E97E863E28529D8F5335E5F0165EEE976B4A5F6C6F09D818344A101381FA3225821706572656772696E2E746F6F6B407475636B626F726F7567682E6578616D706C650458246D65726961646F632E6272616E64796275636B406275636B6C616E642E6578616D706C6535420101581841E0D76F579DBD0D936A662D54D8582037DE2E366FDE1C62"),
		mustHexDecode("D08343A1010AA1054D89F52F65A1C580933B5261A78C581C5974E1B99A3A4CC09A659AA2E9E7FFF161D38CE71CB45CE460FFB569"),
		mustHexDecode("D08343A1010AA1064261A7581C252A8911D465C125B6764739700F0141ED09192DE139E053BD09ABCA"),
		mustHexDecode("D8618543A1010FA054546869732069732074686520636F6E74656E742E489E1226BA1F81B848818340A20125044A6F75722D73656372657440"),
		mustHexDecode("D8618543A10105A054546869732069732074686520636F6E74656E742E582081A03448ACD3D305376EAA11FB3FE416A955BE2CBE7EC96F012C994BC3F16A41818344A101381AA3225821706572656772696E2E746F6F6B407475636B626F726F7567682E6578616D706C650458246D65726961646F632E6272616E64796275636B406275636B6C616E642E6578616D706C653558404D8553E7E74F3C6A3A9DD3EF286A8195CBF8A23D19558CCFEC7D34B824F42D92BD06BD2C7F0271F0214E141FB779AE2856ABF585A58368B017E7F2A9E5CE4DB540"),
		mustHexDecode("D8618543A1010EA054546869732069732074686520636F6E74656E742E4836F5AFAF0BAB5D43818340A2012404582430313863306165352D346439622D343731622D626664362D6565663331346263373033375818711AB0DC2FC4585DCE27EFFA6781C8093EBA906F227B6EB0"),
		mustHexDecode("D8618543A10105A054546869732069732074686520636F6E74656E742E5820BF48235E809B5C42E995F2B7D5FA13620E7ED834E337F6AA43DF161E49E9323E828344A101381CA220A4010220032158420043B12669ACAC3FD27898FFBA0BCD2E6C366D53BC4DB71F909A759304ACFB5E18CDC7BA0B13FF8C7636271A6924B1AC63C02688075B55EF2D613574E7DC242F79C322F504581E62696C626F2E62616767696E7340686F626269746F6E2E6578616D706C655828339BC4F79984CDC6B3E6CE5F315A4C7D2B0AC466FCEA69E8C07DFBCA5BB1F661BC5F8E0DF9E3EFF58340A2012404582430313863306165352D346439622D343731622D626664362D65656633313462633730333758280B2C7CFCE04E98276342D6476A7723C090DFDD15F9A518E7736549E998370695E6D6A83B4AE507BB"),
		mustHexDecode("D18443A1010FA054546869732069732074686520636F6E74656E742E48726043745027214F"),
	}
	for _, d := range data {
		var v any
		err := unmarshal(t, d, &v)
		checkNoError(t, "Unmarshal", err)
	}
}

func TestUnmarshalStructKeyAsIntError(t *testing.T) {
	type T1 struct {
		F1 int `cbor:"1,keyasint"`
	}
	data := mustHexDecode("a13bffffffffffffffff01") // {1: -18446744073709551616}
	var v T1
	err := unmarshal(t, data, &v)
	checkError[*UnmarshalTypeError](t, "Unmarshal", err, "")
}

func TestUnmarshalArrayToStruct(t *testing.T) {
	type T struct {
		_ struct{} `cbor:",toarray"`
		A int
		B int
		C int
	}
	testCases := []struct {
		name string
		data []byte
	}{
		{
			name: "definite-length array",
			data: mustHexDecode("83010203"),
		},
		{
			name: "indefinite-length array",
			data: mustHexDecode("9f010203ff"),
		},
	}
	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			var v T
			err := unmarshal(t, tc.data, &v)
			checkNoError(t, "Unmarshal", err)
		})
	}
}

func TestUnmarshalArrayToStructNoToArrayOptionError(t *testing.T) {
	type T struct {
		A int
		B int
		C int
	}
	data := mustHexDecode("8301020383010203")
	var v1 T
	wantT := T{}
	dec := NewDecoder(bytes.NewReader(data))
	err := dec.Decode(&v1)
	checkUnmarshalErr[*UnmarshalTypeError](t, "Decoder.Decode", v1, err, wantT, "")

	var v2 []int
	want := []int{1, 2, 3}
	err = dec.Decode(&v2)
	checkUnmarshal(t, "Decoder.Decode", v2, err, want)
}

func TestUnmarshalNonArrayDataToStructToArray(t *testing.T) {
	type T struct {
		_ struct{} `cbor:",toarray"`
		A int
		B int
		C int
	}
	testCases := []struct {
		name string
		data []byte
	}{
		{
			name: "CBOR positive int",
			data: mustHexDecode("00"),
		}, // 0
		{
			name: "CBOR negative int",
			data: mustHexDecode("20"),
		}, // -1
		{
			name: "CBOR byte string",
			data: mustHexDecode("4401020304"),
		}, // h`01020304`
		{
			name: "CBOR text string",
			data: mustHexDecode("7f657374726561646d696e67ff"),
		}, // streaming
		{
			name: "CBOR map",
			data: mustHexDecode("a3614101614202614303"),
		}, // {"A": 1, "B": 2, "C": 3}
		{
			name: "CBOR bool",
			data: mustHexDecode("f5"),
		}, // true
		{
			name: "CBOR float",
			data: mustHexDecode("fa7f7fffff"),
		}, // 3.4028234663852886e+38
	}
	wantT := T{}
	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			var v T
			err := unmarshal(t, tc.data, &v)
			checkUnmarshalErr[*UnmarshalTypeError](t, "Unmarshal", v, err, wantT, "")
		})
	}
}

func TestUnmarshalArrayToStructWrongSizeError(t *testing.T) {
	type T struct {
		_ struct{} `cbor:",toarray"`
		A int
		B int
	}
	data := mustHexDecode("8301020383010203")
	var v1 T
	wantT := T{}
	dec := NewDecoder(bytes.NewReader(data))
	err := dec.Decode(&v1)
	checkUnmarshalErr[*UnmarshalTypeError](t, "Decoder.Decode", v1, err, wantT, "")

	var v2 []int
	want := []int{1, 2, 3}
	err = dec.Decode(&v2)
	checkUnmarshal(t, "Decoder.Decode", v2, err, want)
}

func TestUnmarshalArrayToStructWrongFieldTypeError(t *testing.T) {
	type T struct {
		_ struct{} `cbor:",toarray"`
		A int
		B string
		C int
	}
	testCases := []struct {
		name         string
		data         []byte
		wantErrorMsg string
		wantV        any
	}{
		// [1, 2, 3]
		{
			name:         "wrong field type",
			data:         mustHexDecode("83010203"),
			wantErrorMsg: "cbor: cannot unmarshal positive integer into Go struct field cbor.T.B of type string",
			wantV:        T{A: 1, C: 3},
		},
		// [1, 0xfe, 3]
		{
			name:         "invalid UTF-8 string",
			data:         mustHexDecode("830161fe03"),
			wantErrorMsg: invalidUTF8ErrorMsg,
			wantV:        T{A: 1, C: 3},
		},
	}
	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			var v T
			err := unmarshal(t, tc.data, &v)
			checkUnmarshalErr[error](t, "Unmarshal", v, err, tc.wantV, tc.wantErrorMsg)
		})
	}
}

func TestUnmarshalArrayToStructCannotSetEmbeddedPointerError(t *testing.T) {
	type (
		s1 struct {
			x int //nolint:unused
			X int
		}
		S2 struct {
			y int //nolint:unused
			Y int
		}
		S struct {
			_ struct{} `cbor:",toarray"`
			*s1
			*S2
		}
	)
	data := []byte{0x82, 0x02, 0x04} // [2, 4]
	const wantErrorMsg = "cbor: cannot set embedded pointer to unexported struct: *cbor.s1"
	wantV := S{S2: &S2{Y: 4}}
	var v S
	err := unmarshal(t, data, &v)
	checkUnmarshalErr[error](t, "Unmarshal", v, err, wantV, wantErrorMsg)
}

func TestUnmarshalIntoSliceError(t *testing.T) {
	data := []byte{0x83, 0x61, 0x61, 0x61, 0xfe, 0x61, 0x62} // ["a", 0xfe, "b"]
	wantErrorMsg := invalidUTF8ErrorMsg
	var want any

	// Unmarshal CBOR array into a value of type any.
	var v1 any
	want = []any{"a", any(nil), "b"}
	err := unmarshal(t, data, &v1)
	checkUnmarshalErr[error](t, "Unmarshal", v1, err, want, wantErrorMsg)

	// Unmarshal CBOR array into Go slice.
	var v2 []string
	want = []string{"a", "", "b"}
	err = unmarshal(t, data, &v2)
	checkUnmarshalErr[error](t, "Unmarshal", v2, err, want, wantErrorMsg)

	// Unmarshal CBOR array into Go array.
	var v3 [3]string
	want = [3]string{"a", "", "b"}
	err = unmarshal(t, data, &v3)
	checkUnmarshalErr[error](t, "Unmarshal", v3, err, want, wantErrorMsg)

	// Unmarshal CBOR array into populated Go slice.
	v4 := []string{"hello", "to", "you"}
	want = []string{"a", "to", "b"}
	err = unmarshal(t, data, &v4)
	checkUnmarshalErr[error](t, "Unmarshal", v4, err, want, wantErrorMsg)
}

func TestUnmarshalIntoMapError(t *testing.T) {
	data := [][]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 any

	for _, data := range data {
		// Unmarshal CBOR map into a value of type any.
		var v1 any
		want = map[any]any{"a": "A", "b": "B"}
		err := unmarshal(t, data, &v1)
		checkUnmarshalErr[error](t, "Unmarshal", v1, err, want, wantErrorMsg)

		// Unmarshal CBOR map into Go map[any]any.
		var v2 map[any]any
		want = map[any]any{"a": "A", "b": "B"}
		err = unmarshal(t, data, &v2)
		checkUnmarshalErr[error](t, "Unmarshal", v2, err, want, wantErrorMsg)

		// Unmarshal CBOR array into Go map[string]string.
		var v3 map[string]string
		want = map[string]string{"a": "A", "b": "B"}
		err = unmarshal(t, data, &v3)
		checkUnmarshalErr[error](t, "Unmarshal", v3, err, want, wantErrorMsg)

		// 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"}
		err = unmarshal(t, data, &v4)
		checkUnmarshalErr[error](t, "Unmarshal", v4, err, want, wantErrorMsg)
	}
}

func TestUnmarshalDeepNesting(t *testing.T) {
	// Construct this object rather than embed such a large constant in the code
	type TestNode struct {
		Value int
		Child *TestNode
	}
	n := &TestNode{Value: 0}
	root := n
	for i := range 65534 {
		child := &TestNode{Value: i}
		n.Child = child
		n = child
	}
	em := mustEncMode(t, EncOptions{})
	data, err := em.Marshal(root)
	checkNoError(t, "em.Marshal", err)

	// Try unmarshal it
	dm := mustDecMode(t, DecOptions{MaxNestedLevels: 65535})
	var readback TestNode
	err = unmarshalWithDM(t, dm, data, &readback)
	checkUnmarshal(t, "dm.Unmarshal", readback, err, *root)
}

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 {
		data         []byte
		wantErrorMsg string
	}{
		// [-17, [-17, -17], -17]
		{mustHexDecode("9f3082303030ff"), "cbor: cannot unmarshal negative integer into Go struct field cbor.nestedCWT.Protected of type []uint8"},
		// [[], [], ["\x930000", -17]]
		{mustHexDecode("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
		err := unmarshal(t, tc.data, &v)
		checkError[error](t, "Unmarshal", err, 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"`
	}
	data := mustHexDecode("bf0783e662f03030ff") // {7: [simple(6), "\xF00", -17]}
	wantErrorMsg := invalidUTF8ErrorMsg
	wantV := claims{Cti: []byte{6, 0, 0}}
	var v claims
	err := unmarshal(t, data, &v)
	checkUnmarshalErr[error](t, "Unmarshal", v, err, wantV, wantErrorMsg)
}

func TestUnmarshalToNotNilInterface(t *testing.T) {
	data := mustHexDecode("83010203") // []uint64{1, 2, 3}
	s := "hello"
	var v any = s // Unmarshal() sees v as a value of type any and sets CBOR data as default Go type.  s is unmodified.  Same behavior as encoding/json.
	wantV := []any{uint64(1), uint64(2), uint64(3)}
	err := unmarshal(t, data, &v)
	checkUnmarshal(t, "Unmarshal", v, err, wantV)
	if s != "hello" {
		t.Errorf("after Unmarshal(0x%x), s = %q, want \"hello\"", data, s)
	}
}

func TestUnmarshalStructKeyAsIntNumError(t *testing.T) {
	type T1 struct {
		F1 int `cbor:"a,keyasint"`
	}
	type T2 struct {
		F1 int `cbor:"-18446744073709551616,keyasint"`
	}
	type T3 struct {
		F1 int `cbor:"99999999999999999999,keyasint"`
	}
	testCases := []struct {
		name         string
		data         []byte
		obj          any
		wantErrorMsg string
	}{
		{
			name:         "string as key",
			data:         mustHexDecode("a1616101"),
			obj:          T1{},
			wantErrorMsg: "cbor: failed to parse field name \"a\" to int (strconv.Atoi: parsing \"a\": invalid syntax)",
		},
		{
			name:         "int key < math.MinInt",
			data:         mustHexDecode("a13bffffffffffffffff01"),
			obj:          T2{},
			wantErrorMsg: "cbor: failed to parse field name \"-18446744073709551616\" to int (strconv.Atoi: parsing \"-18446744073709551616\": value out of range)",
		},
		{
			name:         "int key > math.MaxInt",
			data:         mustHexDecode("a10001"),
			obj:          T3{},
			wantErrorMsg: "cbor: failed to parse field name \"99999999999999999999\" to int (strconv.Atoi: parsing \"99999999999999999999\": value out of range)",
		},
		{
			name:         "CBOR array to struct",
			data:         mustHexDecode("8101"), // [1]
			obj:          T1{},
			wantErrorMsg: "cbor: failed to parse field name \"a\" to int (strconv.Atoi: parsing \"a\": invalid syntax)",
		},
	}
	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			v := reflect.New(reflect.TypeOf(tc.obj))
			err := unmarshal(t, tc.data, v.Interface())
			checkError[error](t, "Unmarshal", err, tc.wantErrorMsg)
		})
	}
}

func TestUnmarshalEmptyMapWithDupMapKeyOpt(t *testing.T) {
	testCases := []struct {
		name  string
		data  []byte
		wantV any
	}{
		{
			name:  "empty map",
			data:  mustHexDecode("a0"),
			wantV: map[any]any{},
		},
		{
			name:  "indefinite empty map",
			data:  mustHexDecode("bfff"),
			wantV: map[any]any{},
		},
	}

	dm := mustDecMode(t, DecOptions{DupMapKey: DupMapKeyEnforcedAPF})

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			var v any
			err := unmarshalWithDM(t, dm, tc.data, &v)
			checkUnmarshal(t, "dm.Unmarshal", v, err, tc.wantV)
		})
	}
}

func TestUnmarshalDupMapKeyToEmptyInterface(t *testing.T) {
	data := mustHexDecode("a6616161416162614261636143616161466164614461656145") // {"a": "A", "b": "B", "c": "C", "a": "F", "d": "D", "e": "E"}

	// Duplicate key overwrites previous value (default).
	wantV := map[any]any{"a": "F", "b": "B", "c": "C", "d": "D", "e": "E"}
	var v any
	err := unmarshal(t, data, &v)
	checkUnmarshal(t, "dm.Unmarshal", v, err, wantV)

	// Duplicate key triggers error.
	wantV = map[any]any{"a": nil, "b": "B", "c": "C"}
	wantErrorMsg := "cbor: found duplicate map key \"a\" at map element index 3"
	dm := mustDecMode(t, DecOptions{DupMapKey: DupMapKeyEnforcedAPF})
	var v2 any
	err = unmarshalWithDM(t, dm, data, &v2)
	checkUnmarshalErr[*DupMapKeyError](t, "dm.Unmarshal", v2, err, wantV, wantErrorMsg)
}

func TestStreamDupMapKeyToEmptyInterface(t *testing.T) {
	data := mustHexDecode("a6616161416162614261636143616161466164614461656145") // map with duplicate key "c": {"a": "A", "b": "B", "c": "C", "a": "F", "d": "D", "e": "E"}

	var b []byte
	for range 3 {
		b = append(b, data...)
	}

	// Duplicate key overwrites previous value (default).
	wantV := map[any]any{"a": "F", "b": "B", "c": "C", "d": "D", "e": "E"}
	dec := NewDecoder(bytes.NewReader(b))
	for range 3 {
		var v1 any
		err := dec.Decode(&v1)
		checkUnmarshal(t, "Decoder.Decode", v1, err, wantV)
	}
	testDecoderEOF(t, dec)

	// Duplicate key triggers error.
	wantV = map[any]any{"a": nil, "b": "B", "c": "C"}
	wantErrorMsg := "cbor: found duplicate map key \"a\" at map element index 3"
	dm := mustDecMode(t, DecOptions{DupMapKey: DupMapKeyEnforcedAPF})
	dec = dm.NewDecoder(bytes.NewReader(b))
	for range 3 {
		var v2 any
		err := dec.Decode(&v2)
		checkUnmarshalErr[*DupMapKeyError](t, "Decoder.Decode", v2, err, wantV, wantErrorMsg)
	}
	testDecoderEOF(t, dec)
}

func TestUnmarshalDupMapKeyToEmptyMap(t *testing.T) {
	data := mustHexDecode("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
	err := unmarshal(t, data, &m)
	checkUnmarshal(t, "Unmarshal", m, err, 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 := mustDecMode(t, DecOptions{DupMapKey: DupMapKeyEnforcedAPF})
	var m2 map[string]string
	err = unmarshalWithDM(t, dm, data, &m2)
	checkUnmarshalErr[*DupMapKeyError](t, "Unmarshal", m2, err, wantM, wantErrorMsg)
}

func TestStreamDupMapKeyToEmptyMap(t *testing.T) {
	data := mustHexDecode("a6616161416162614261636143616161466164614461656145") // {"a": "A", "b": "B", "c": "C", "a": "F", "d": "D", "e": "E"}

	var b []byte
	for range 3 {
		b = append(b, data...)
	}

	// 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 range 3 {
		var m1 map[string]string
		err := dec.Decode(&m1)
		checkUnmarshal(t, "Decoder.Decode", m1, err, wantM)
	}
	testDecoderEOF(t, dec)

	// 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 := mustDecMode(t, DecOptions{DupMapKey: DupMapKeyEnforcedAPF})
	dec = dm.NewDecoder(bytes.NewReader(b))
	for range 3 {
		var m2 map[string]string
		err := dec.Decode(&m2)
		checkUnmarshalErr[*DupMapKeyError](t, "Decoder.Decode", m2, err, wantM, wantErrorMsg)
	}
	testDecoderEOF(t, dec)
}

func TestUnmarshalDupMapKeyToNotEmptyMap(t *testing.T) {
	data := mustHexDecode("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"}
	err := unmarshal(t, data, &m)
	checkUnmarshal(t, "Unmarshal", m, err, 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 := mustDecMode(t, DecOptions{DupMapKey: DupMapKeyEnforcedAPF})
	err = unmarshalWithDM(t, dm, data, &m2)
	checkUnmarshalErr[*DupMapKeyError](t, "dm.Unmarshal", m2, err, wantM, wantErrorMsg)
}

func TestStreamDupMapKeyToNotEmptyMap(t *testing.T) {
	data := mustHexDecode("a6616161416162614261636143616161466164614461656145") // {"a": "A", "b": "B", "c": "C", "a": "F", "d": "D", "e": "E"}

	var b []byte
	for range 3 {
		b = append(b, data...)
	}

	// 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 range 3 {
		m1 := map[string]string{"a": "Z", "b": "Z", "c": "Z", "d": "Z", "e": "Z", "f": "Z"}
		err := dec.Decode(&m1)
		checkUnmarshal(t, "Decoder.Decode", m1, err, wantM)
	}
	testDecoderEOF(t, dec)

	// 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 := mustDecMode(t, DecOptions{DupMapKey: DupMapKeyEnforcedAPF})
	dec = dm.NewDecoder(bytes.NewReader(b))
	for range 3 {
		m2 := map[string]string{"a": "Z", "b": "Z", "c": "Z", "d": "Z", "e": "Z", "f": "Z"}
		err := dec.Decode(&m2)
		checkUnmarshalErr[*DupMapKeyError](t, "Decoder.Decode", m2, err, wantM, wantErrorMsg)
	}
	testDecoderEOF(t, dec)
}

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"`

		I string `cbor:"1,keyasint"`
	}

	for _, tc := range []struct {
		name         string
		opts         DecOptions
		data         []byte
		want         s
		wantErrorMsg string
	}{
		{
			name: "duplicate key does not overwrite previous value",
			data: mustHexDecode("a6616161416162614261636143616161466164614461656145"), // {"a": "A", "b": "B", "c": "C", "a": "F", "d": "D", "e": "E"}
			want: s{A: "A", B: "B", C: "C", D: "D", E: "E"},
		},
		{
			name:         "duplicate key triggers error",
			opts:         DecOptions{DupMapKey: DupMapKeyEnforcedAPF},
			data:         mustHexDecode("a6616161416162614261636143616161466164614461656145"), // {"a": "A", "b": "B", "c": "C", "a": "F", "d": "D", "e": "E"}
			want:         s{A: "A", B: "B", C: "C"},
			wantErrorMsg: (&DupMapKeyError{Key: "a", Index: 3}).Error(),
		},
		{
			name:         "duplicate keys of comparable but disallowed cbor types skips remaining entries and returns error",
			opts:         DecOptions{DupMapKey: DupMapKeyEnforcedAPF},
			data:         mustHexDecode("a7616161416162614261636143d903e70100d903e701016164614461656145"), // {"a": "A", "b": "B", "c": "C", 999(1): 0, 999(1): 1, "d": "D", "e": "E"}
			want:         s{A: "A", B: "B", C: "C"},
			wantErrorMsg: (&DupMapKeyError{Key: Tag{Number: 999, Content: uint64(1)}, Index: 4}).Error(),
		},
		{
			name: "mixed-case duplicate key does not overwrite previous value",
			data: mustHexDecode("a6616161416162614261636143614161466164614461656145"), // {"a": "A", "b": "B", "c": "C", "A": "F", "d": "D", "e": "E"}
			want: s{A: "A", B: "B", C: "C", D: "D", E: "E"},
		},
		{
			name:         "mixed-case duplicate key triggers error",
			opts:         DecOptions{DupMapKey: DupMapKeyEnforcedAPF},
			data:         mustHexDecode("a6616161416162614261636143614161466164614461656145"), // {"a": "A", "b": "B", "c": "C", "A": "F", "d": "D", "e": "E"}
			want:         s{A: "A", B: "B", C: "C"},
			wantErrorMsg: (&DupMapKeyError{Key: "A", Index: 3}).Error(),
		},
		{
			name: "keyasint duplicate key does not overwrite previous value",
			data: mustHexDecode("a301616901614961616141"), // {1: "i", 1: "I", "a": "A"}
			want: s{I: "i", A: "A"},
		},
		{
			name:         "keyasint duplicate key triggers error",
			opts:         DecOptions{DupMapKey: DupMapKeyEnforcedAPF},
			data:         mustHexDecode("a301616901614961616141"), // {1: "i", 1: "I", "a": "A"}
			want:         s{I: "i"},
			wantErrorMsg: (&DupMapKeyError{Key: int64(1), Index: 1}).Error(),
		},
	} {
		t.Run(tc.name, func(t *testing.T) {
			dm := mustDecMode(t, tc.opts)
			var s1 s
			err := unmarshalWithDM(t, dm, tc.data, &s1)
			if tc.wantErrorMsg != "" {
				checkUnmarshalErr[*DupMapKeyError](t, "dm.Unmarshal", s1, err, tc.want, tc.wantErrorMsg)
			} else {
				checkUnmarshal(t, "dm.Unmarshal", s1, err, tc.want)
			}
		})
	}
}

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"`
	}
	data := mustHexDecode("a6616161416162614261636143616161466164614461656145") // {"a": "A", "b": "B", "c": "C", "a": "F", "d": "D", "e": "E"}

	var b []byte
	for range 3 {
		b = append(b, data...)
	}

	// Duplicate key overwrites previous value (default).
	wantS := s{A: "A", B: "B", C: "C", D: "D", E: "E"}
	dec := NewDecoder(bytes.NewReader(b))
	for range 3 {
		var s1 s
		err := dec.Decode(&s1)
		checkUnmarshal(t, "Decoder.Decode", s1, err, wantS)
	}
	testDecoderEOF(t, dec)

	// 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 := mustDecMode(t, DecOptions{DupMapKey: DupMapKeyEnforcedAPF})
	dec = dm.NewDecoder(bytes.NewReader(b))
	for range 3 {
		var s2 s
		err := dec.Decode(&s2)
		checkUnmarshalErr[*DupMapKeyError](t, "Decoder.Decode", s2, err, wantS, wantErrorMsg)
	}
	testDecoderEOF(t, dec)
}

// 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"`
	}
	data := mustHexDecode("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
	err := unmarshal(t, data, &s1)
	checkUnmarshal(t, "Unmarshal", s1, err, wantS)

	// Duplicate key triggers error.
	wantS = s{A: 2, B: 4}
	wantErrorMsg := "cbor: found duplicate map key 1 at map element index 2"
	dm := mustDecMode(t, DecOptions{DupMapKey: DupMapKeyEnforcedAPF})
	var s2 s
	err = unmarshalWithDM(t, dm, data, &s2)
	checkUnmarshalErr[*DupMapKeyError](t, "dm.Unmarshal", s2, err, wantS, wantErrorMsg)
}

func TestStreamDupMapKeyToStructKeyAsInt(t *testing.T) {
	type s struct {
		A int `cbor:"1,keyasint"`
		B int `cbor:"3,keyasint"`
		C int `cbor:"5,keyasint"`
	}
	data := mustHexDecode("a40102030401030506") // {1:2, 3:4, 1:3, 5:6}

	var b []byte
	for range 3 {
		b = append(b, data...)
	}

	// Duplicate key overwrites previous value (default).
	wantS := s{A: 2, B: 4, C: 6}
	dec := NewDecoder(bytes.NewReader(b))
	for range 3 {
		var s1 s
		err := dec.Decode(&s1)
		checkUnmarshal(t, "Decoder.Decode", s1, err, wantS)
	}
	testDecoderEOF(t, dec)

	// Duplicate key triggers error.
	wantS = s{A: 2, B: 4}
	wantErrorMsg := "cbor: found duplicate map key 1 at map element index 2"
	dm := mustDecMode(t, DecOptions{DupMapKey: DupMapKeyEnforcedAPF})
	dec = dm.NewDecoder(bytes.NewReader(b))
	for range 3 {
		var s2 s
		err := dec.Decode(&s2)
		checkUnmarshalErr[*DupMapKeyError](t, "Decoder.Decode", s2, err, wantS, wantErrorMsg)
	}
	testDecoderEOF(t, dec)
}

func TestUnmarshalDupMapKeyToStructNoMatchingField(t *testing.T) {
	type s struct {
		B string `cbor:"b"`
		C string `cbor:"c"`
		D string `cbor:"d"`
		E string `cbor:"e"`
	}
	data := mustHexDecode("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
	err := unmarshal(t, data, &s1)
	checkUnmarshal(t, "Unmarshal", s1, err, 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 := mustDecMode(t, DecOptions{DupMapKey: DupMapKeyEnforcedAPF})
	var s2 s
	err = unmarshalWithDM(t, dm, data, &s2)
	checkUnmarshalErr[*DupMapKeyError](t, "dm.Unmarshal", s2, err, wantS, wantErrorMsg)
}

func TestStreamDupMapKeyToStructNoMatchingField(t *testing.T) {
	type s struct {
		B string `cbor:"b"`
		C string `cbor:"c"`
		D string `cbor:"d"`
		E string `cbor:"e"`
	}
	data := mustHexDecode("a6616161416162614261636143616161466164614461656145") // {"a": "A", "b": "B", "c": "C", "a": "F", "d": "D", "e": "E"}

	var b []byte
	for range 3 {
		b = append(b, data...)
	}

	// Duplicate key overwrites previous value (default).
	wantS := s{B: "B", C: "C", D: "D", E: "E"}
	dec := NewDecoder(bytes.NewReader(b))
	for range 3 {
		var s1 s
		err := dec.Decode(&s1)
		checkUnmarshal(t, "Decoder.Decode", s1, err, wantS)
	}
	testDecoderEOF(t, dec)

	// Duplicate key triggers error.
	wantS = s{B: "B", C: "C"}
	wantErrorMsg := "cbor: found duplicate map key \"a\" at map element index 3"
	dm := mustDecMode(t, DecOptions{DupMapKey: DupMapKeyEnforcedAPF})
	dec = dm.NewDecoder(bytes.NewReader(b))
	for range 3 {
		var s2 s
		err := dec.Decode(&s2)
		checkUnmarshalErr[*DupMapKeyError](t, "Decoder.Decode", s2, err, wantS, wantErrorMsg)
	}
	testDecoderEOF(t, dec)
}

func TestUnmarshalDupMapKeyToStructKeyAsIntNoMatchingField(t *testing.T) {
	type s struct {
		B int `cbor:"3,keyasint"`
		C int `cbor:"5,keyasint"`
	}
	data := mustHexDecode("a40102030401030506") // {1:2, 3:4, 1:3, 5:6}

	wantS := s{B: 4, C: 6}
	var s1 s
	err := unmarshal(t, data, &s1)
	checkUnmarshal(t, "Unmarshal", s1, err, 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 := mustDecMode(t, DecOptions{DupMapKey: DupMapKeyEnforcedAPF})
	var s2 s
	err = unmarshalWithDM(t, dm, data, &s2)
	checkUnmarshalErr[*DupMapKeyError](t, "dm.Unmarshal", s2, err, wantS, wantErrorMsg)
}

func TestStreamDupMapKeyToStructKeyAsIntNoMatchingField(t *testing.T) {
	type s struct {
		B int `cbor:"3,keyasint"`
		C int `cbor:"5,keyasint"`
	}
	data := mustHexDecode("a40102030401030506") // {1:2, 3:4, 1:3, 5:6}

	var b []byte
	for range 3 {
		b = append(b, data...)
	}

	// Duplicate key overwrites previous value (default).
	wantS := s{B: 4, C: 6}
	dec := NewDecoder(bytes.NewReader(b))
	for range 3 {
		var s1 s
		err := dec.Decode(&s1)
		checkUnmarshal(t, "Decoder.Decode", s1, err, wantS)
	}
	testDecoderEOF(t, dec)

	// Duplicate key triggers error.
	wantS = s{B: 4}
	wantErrorMsg := "cbor: found duplicate map key 1 at map element index 2"
	dm := mustDecMode(t, DecOptions{DupMapKey: DupMapKeyEnforcedAPF})
	dec = dm.NewDecoder(bytes.NewReader(b))
	for range 3 {
		var s2 s
		err := dec.Decode(&s2)
		checkUnmarshalErr[*DupMapKeyError](t, "Decoder.Decode", s2, err, wantS, wantErrorMsg)
	}
	testDecoderEOF(t, dec)
}

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"`
	}
	data := mustHexDecode("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"}
	err := unmarshal(t, data, &s1)
	checkUnmarshalErr[*UnmarshalTypeError](t, "Unmarshal", s1, err, wantS, "")

	wantS = s{A: "A", B: "B", C: "C"}
	wantErrorMsg := "cbor: found duplicate map key 100000 at map element index 4"
	dm := mustDecMode(t, DecOptions{DupMapKey: DupMapKeyEnforcedAPF})
	var s2 s
	err = unmarshalWithDM(t, dm, data, &s2)
	checkUnmarshalErr[*DupMapKeyError](t, "Unmarshal", s2, err, wantS, wantErrorMsg)
}

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"`
	}
	data := mustHexDecode("a861616141fa47c35000026162614261636143fa47c3500003616161466164614461656145") // {"a": "A", 100000.0:2, "b": "B", "c": "C", 100000.0:3, "a": "F", "d": "D", "e": "E"}

	var b []byte
	for range 3 {
		b = append(b, data...)
	}

	wantS := s{A: "A", B: "B", C: "C", D: "D", E: "E"}
	dec := NewDecoder(bytes.NewReader(b))
	for range 3 {
		var s1 s
		err := dec.Decode(&s1)
		checkUnmarshalErr[*UnmarshalTypeError](t, "Decoder.Decode", s1, err, wantS, "")
	}
	testDecoderEOF(t, dec)

	// 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 := mustDecMode(t, DecOptions{DupMapKey: DupMapKeyEnforcedAPF})
	dec = dm.NewDecoder(bytes.NewReader(b))
	for range 3 {
		var s2 s
		err := dec.Decode(&s2)
		checkUnmarshalErr[*DupMapKeyError](t, "Decoder.Decode", s2, err, wantS, wantErrorMsg)
	}
	testDecoderEOF(t, dec)
}

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"`
	}
	data := mustHexDecode("a661fe6141616261426163614361fe61466164614461656145") // {"\xFE": "A", "b": "B", "c": "C", "\xFE": "F", "d": "D", "e": "E"}
	wantS := s{A: "", B: "B", C: "C", D: "D", E: "E"}

	// Duplicate key doesn't overwrite previous value (default).
	var s1 s
	err := unmarshal(t, data, &s1)
	checkUnmarshalErr[*SemanticError](t, "Decoder.Decode", s1, err, wantS, invalidUTF8ErrorMsg)

	// Duplicate key triggers error.
	dm := mustDecMode(t, DecOptions{DupMapKey: DupMapKeyEnforcedAPF})
	var s2 s
	err = unmarshalWithDM(t, dm, data, &s2)
	checkUnmarshalErr[*SemanticError](t, "Decoder.Decode", s2, err, wantS, invalidUTF8ErrorMsg)
}

func TestUnmarshalDupMapKeyToStructIntParseError(t *testing.T) {
	type s struct {
		A int `cbor:"1,keyasint"`
		B int `cbor:"3,keyasint"`
		C int `cbor:"5,keyasint"`
	}
	data := mustHexDecode("a43bffffffffffffffff0203043bffffffffffffffff030506") // {-18446744073709551616:2, 3:4, -18446744073709551616:3, 5:6}

	// Duplicate key doesn't overwrite previous value (default).
	wantS := s{B: 4, C: 6}
	var s1 s
	err := unmarshal(t, data, &s1)
	checkUnmarshalErr[*UnmarshalTypeError](t, "Unmarshal", s1, err, wantS, "")

	// Duplicate key triggers error.
	dm := mustDecMode(t, DecOptions{DupMapKey: DupMapKeyEnforcedAPF})
	var s2 s
	err = unmarshalWithDM(t, dm, data, &s2)
	checkUnmarshalErr[*UnmarshalTypeError](t, "dm.Unmarshal", s2, err, 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"`
	}
	data := mustHexDecode("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"}
	var s1 s
	err := unmarshal(t, data, &s1)
	checkUnmarshalErr[*UnmarshalTypeError](t, "Unmarshal", s1, err, wantS, "")

	// Duplicate key triggers error.
	dm := mustDecMode(t, DecOptions{DupMapKey: DupMapKeyEnforcedAPF})
	var s2 s
	err = unmarshalWithDM(t, dm, data, &s2)
	checkUnmarshalErr[*UnmarshalTypeError](t, "dm.Unmarshal", s2, err, 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"`
	}
	data := mustHexDecode("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).
	var s1 s
	err := unmarshal(t, data, &s1)
	checkUnmarshalErr[*UnmarshalTypeError](t, "Unmarshal", s1, err, wantS, "")

	// Duplicate key triggers error.
	dm := mustDecMode(t, DecOptions{DupMapKey: DupMapKeyEnforcedAPF})
	var s2 s
	err = unmarshalWithDM(t, dm, data, &s2)
	checkUnmarshalErr[*UnmarshalTypeError](t, "dm.Unmarshal", s2, err, 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"`
	}
	data := mustHexDecode("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).
	var s1 s
	err := unmarshal(t, data, &s1)
	checkUnmarshalErr[*UnmarshalTypeError](t, "Unmarshal", s1, err, wantS, "")

	// Duplicate key triggers error.
	dm := mustDecMode(t, DecOptions{DupMapKey: DupMapKeyEnforcedAPF})
	var s2 s
	err = unmarshalWithDM(t, dm, data, &s2)
	checkUnmarshalErr[*UnmarshalTypeError](t, "dm.Unmarshal", s2, err, wantS, "")
}

func TestIndefiniteLengthArrayToArray(t *testing.T) {
	testCases := []struct {
		name  string
		data  []byte
		wantV any
	}{
		{
			name:  "CBOR empty array to Go 5 elem array",
			data:  mustHexDecode("9fff"),
			wantV: [5]byte{},
		},
		{
			name:  "CBOR 3 elem array to Go 5 elem array",
			data:  mustHexDecode("9f010203ff"),
			wantV: [5]byte{1, 2, 3, 0, 0},
		},
		{
			name:  "CBOR 10 elem array to Go 5 elem array",
			data:  mustHexDecode("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))
			err := unmarshal(t, tc.data, v.Interface())
			checkUnmarshal(t, "Unmarshal", v.Elem().Interface(), err, tc.wantV)
		})
	}
}

func TestExceedMaxArrayElements(t *testing.T) {
	testCases := []struct {
		name         string
		opts         DecOptions
		data         []byte
		wantErrorMsg string
	}{
		{
			name:         "array",
			opts:         DecOptions{MaxArrayElements: 16},
			data:         mustHexDecode("910101010101010101010101010101010101"),
			wantErrorMsg: "cbor: exceeded max number of elements 16 for CBOR array",
		},
		{
			name:         "indefinite-length array",
			opts:         DecOptions{MaxArrayElements: 16},
			data:         mustHexDecode("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 := mustDecMode(t, tc.opts)
			var v any
			err := unmarshalWithDM(t, dm, tc.data, &v)
			checkError[error](t, "dm.Unmarshal", err, tc.wantErrorMsg)
		})
	}
}

func TestExceedMaxMapPairs(t *testing.T) {
	testCases := []struct {
		name         string
		opts         DecOptions
		data         []byte
		wantErrorMsg string
	}{
		{
			name:         "map",
			opts:         DecOptions{MaxMapPairs: 16},
			data:         mustHexDecode("b101010101010101010101010101010101010101010101010101010101010101010101"),
			wantErrorMsg: "cbor: exceeded max number of key-value pairs 16 for CBOR map",
		},
		{
			name:         "indefinite-length map",
			opts:         DecOptions{MaxMapPairs: 16},
			data:         mustHexDecode("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 := mustDecMode(t, tc.opts)
			var v any
			err := unmarshalWithDM(t, dm, tc.data, &v)
			checkError[error](t, "dm.Unmarshal", err, tc.wantErrorMsg)
		})
	}
}

func TestDecIndefiniteLengthOption(t *testing.T) {
	testCases := []struct {
		name         string
		opts         DecOptions
		data         []byte
		wantErrorMsg string
	}{
		{
			name:         "byte string",
			opts:         DecOptions{IndefLength: IndefLengthForbidden},
			data:         mustHexDecode("5fff"),
			wantErrorMsg: "cbor: indefinite-length byte string isn't allowed",
		},
		{
			name:         "text string",
			opts:         DecOptions{IndefLength: IndefLengthForbidden},
			data:         mustHexDecode("7fff"),
			wantErrorMsg: "cbor: indefinite-length UTF-8 text string isn't allowed",
		},
		{
			name:         "array",
			opts:         DecOptions{IndefLength: IndefLengthForbidden},
			data:         mustHexDecode("9fff"),
			wantErrorMsg: "cbor: indefinite-length array isn't allowed",
		},
		{
			name:         "indefinite-length array",
			opts:         DecOptions{IndefLength: IndefLengthForbidden},
			data:         mustHexDecode("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 any
			err := unmarshal(t, tc.data, &v)
			checkNoError(t, "Unmarshal", err)

			dm := mustDecMode(t, tc.opts)
			err = unmarshalWithDM(t, dm, tc.data, &v)
			checkError[error](t, "dm.Unmarshal", err, tc.wantErrorMsg)
		})
	}
}

func TestDecTagsMdOption(t *testing.T) {
	data := mustHexDecode("c074323031332d30332d32315432303a30343a30305a")
	wantErrorMsg := "cbor: CBOR tag isn't allowed"

	// Default option allows CBOR tags
	var v any
	err := unmarshal(t, data, &v)
	checkNoError(t, "Unmarshal", err)

	// Decoding CBOR tags with TagsForbidden option returns error
	dm := mustDecMode(t, DecOptions{TagsMd: TagsForbidden})
	err = unmarshalWithDM(t, dm, data, &v)
	checkError[error](t, "dm.Unmarshal", err, 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)
	checkError[error](t, "DecModeWithTags", err, wantErrorMsg)
	_, err = DecOptions{TagsMd: TagsForbidden}.DecModeWithSharedTags(tags)
	checkError[error](t, "DecModeWithSharedTags", err, wantErrorMsg)
}

func TestIntDecConvertNone(t *testing.T) {
	dm := mustDecMode(t, DecOptions{IntDec: IntDecConvertNone, BigIntDec: BigIntDecodePointer})

	testCases := []struct {
		name    string
		data    []byte
		wantObj any
	}{
		{
			name:    "CBOR pos int",
			data:    mustHexDecode("1a000f4240"),
			wantObj: uint64(1000000),
		},
		{
			name:    "CBOR pos int overflows int64",
			data:    mustHexDecode("1b8000000000000000"), // math.MaxInt64+1
			wantObj: uint64(math.MaxInt64 + 1),
		},
		{
			name:    "CBOR neg int",
			data:    mustHexDecode("3903e7"),
			wantObj: int64(-1000),
		},
		{
			name:    "CBOR neg int overflows int64",
			data:    mustHexDecode("3b8000000000000000"), // math.MinInt64-1
			wantObj: new(big.Int).Sub(big.NewInt(math.MinInt64), big.NewInt(1)),
		},
	}
	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			var v any
			err := unmarshalWithDM(t, dm, tc.data, &v)
			checkUnmarshal(t, "Unmarshal", v, err, tc.wantObj)
		})
	}
}

func TestIntDecConvertSigned(t *testing.T) {
	dm := mustDecMode(t, DecOptions{IntDec: IntDecConvertSigned, BigIntDec: BigIntDecodePointer})

	testCases := []struct {
		name         string
		data         []byte
		wantObj      any
		wantErrorMsg string
	}{
		{
			name:    "CBOR pos int",
			data:    mustHexDecode("1a000f4240"),
			wantObj: int64(1000000),
		},
		{
			name:         "CBOR pos int overflows int64",
			data:         mustHexDecode("1b8000000000000000"), // math.MaxInt64+1
			wantErrorMsg: "cbor: cannot unmarshal positive integer into Go value of type int64 (9223372036854775808 overflows Go's int64)",
		},
		{
			name:    "CBOR neg int",
			data:    mustHexDecode("3903e7"),
			wantObj: int64(-1000),
		},
		{
			name:    "CBOR neg int overflows int64",
			data:    mustHexDecode("3b8000000000000000"), // math.MinInt64-1
			wantObj: new(big.Int).Sub(big.NewInt(math.MinInt64), big.NewInt(1)),
		},
	}
	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			var v any
			err := unmarshalWithDM(t, dm, tc.data, &v)
			checkUnmarshalCase[error](t, "dm.Unmarshal", v, err, tc.wantObj, tc.wantErrorMsg != "", tc.wantErrorMsg)
		})
	}
}

func TestIntDecConvertSignedOrBigInt(t *testing.T) {
	dm := mustDecMode(t, DecOptions{IntDec: IntDecConvertSignedOrBigInt, BigIntDec: BigIntDecodePointer})

	testCases := []struct {
		name    string
		data    []byte
		wantObj any
	}{
		{
			name:    "CBOR pos int",
			data:    mustHexDecode("1a000f4240"),
			wantObj: int64(1000000),
		},
		{
			name:    "CBOR pos int overflows int64",
			data:    mustHexDecode("1b8000000000000000"),
			wantObj: new(big.Int).Add(big.NewInt(math.MaxInt64), big.NewInt(1)),
		},
		{
			name:    "CBOR neg int",
			data:    mustHexDecode("3903e7"),
			wantObj: int64(-1000),
		},
		{
			name:    "CBOR neg int overflows int64",
			data:    mustHexDecode("3b8000000000000000"),
			wantObj: new(big.Int).Sub(big.NewInt(math.MinInt64), big.NewInt(1)),
		},
	}
	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			var v any
			err := unmarshalWithDM(t, dm, tc.data, &v)
			checkUnmarshal(t, "dm.Unmarshal", v, err, tc.wantObj)
		})
	}
}

func TestIntDecConvertSignedOrError(t *testing.T) {
	dm := mustDecMode(t, DecOptions{IntDec: IntDecConvertSignedOrFail, BigIntDec: BigIntDecodePointer})

	testCases := []struct {
		name         string
		data         []byte
		wantObj      any
		wantErrorMsg string
	}{
		{
			name:    "CBOR pos int",
			data:    mustHexDecode("1a000f4240"),
			wantObj: int64(1000000),
		},
		{
			name:         "CBOR pos int overflows int64",
			data:         mustHexDecode("1b8000000000000000"), // math.MaxInt64+1
			wantErrorMsg: "cbor: cannot unmarshal positive integer into Go value of type int64 (9223372036854775808 overflows Go's int64)",
		},
		{
			name:    "CBOR neg int",
			data:    mustHexDecode("3903e7"),
			wantObj: int64(-1000),
		},
		{
			name:         "CBOR neg int overflows int64",
			data:         mustHexDecode("3b8000000000000000"), // math.MinInt64-1
			wantErrorMsg: "cbor: cannot unmarshal negative integer into Go value of type int64 (-9223372036854775809 overflows Go's int64)",
		},
	}
	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			var v any
			err := unmarshalWithDM(t, dm, tc.data, &v)
			checkUnmarshalCase[error](t, "dm.Unmarshal", v, err, tc.wantObj, tc.wantErrorMsg != "", tc.wantErrorMsg)
		})
	}
}

func TestMapKeyByteString(t *testing.T) {
	dmBSForbidden := mustDecMode(t, DecOptions{MapKeyByteString: MapKeyByteStringForbidden})
	dmBSAllowed := mustDecMode(t, DecOptions{MapKeyByteString: MapKeyByteStringAllowed})

	typeMapTagAny := reflect.TypeFor[map[Tag]any]()

	testCases := []struct {
		name          string
		data          []byte
		wantObjs      map[reflect.Type]any
		wantErrorMsgs map[reflect.Type]string
		dm            DecMode
	}{
		{
			name: "byte string map key with MapKeyByteStringForbidden",
			data: mustHexDecode("a143abcdef187b"),
			wantErrorMsgs: map[reflect.Type]string{
				typeAny:       "cbor: invalid map key type: []uint8",
				typeMapAnyAny: "cbor: invalid map key type: []uint8",
			},
			dm: dmBSForbidden,
		},
		{
			name: "tagged byte string map key with MapKeyByteStringForbidden",
			data: mustHexDecode("a1d86443abcdef187b"),
			wantErrorMsgs: map[reflect.Type]string{
				typeAny:       "cbor: invalid map key type: cbor.Tag",
				typeMapAnyAny: "cbor: invalid map key type: cbor.Tag",
			},
			dm: dmBSForbidden,
		},
		{
			name: "nested tagged byte string map key with MapKeyByteStringForbidden",
			data: mustHexDecode("a1d865d86443abcdef187b"),
			wantErrorMsgs: map[reflect.Type]string{
				typeAny:       "cbor: invalid map key type: cbor.Tag",
				typeMapAnyAny: "cbor: invalid map key type: cbor.Tag",
			},
			dm: dmBSForbidden,
		},
		{
			name: "byte string map key with MapKeyByteStringAllowed",
			data: mustHexDecode("a143abcdef187b"),
			wantObjs: map[reflect.Type]any{
				typeAny: map[any]any{
					ByteString("\xab\xcd\xef"): uint64(123),
				},
				typeMapAnyAny: map[any]any{
					ByteString("\xab\xcd\xef"): uint64(123),
				},
			},
			dm: dmBSAllowed,
		},
		{
			name: "tagged byte string map key with MapKeyByteStringAllowed",
			data: mustHexDecode("a1d86443abcdef187b"),
			wantObjs: map[reflect.Type]any{
				typeAny: map[any]any{
					Tag{Number: 100, Content: ByteString("\xab\xcd\xef")}: uint64(123),
				},
				typeMapAnyAny: map[any]any{
					Tag{Number: 100, Content: ByteString("\xab\xcd\xef")}: uint64(123),
				},
				typeMapTagAny: map[Tag]any{
					{Number: 100, Content: ByteString("\xab\xcd\xef")}: uint64(123),
				},
			},
			dm: dmBSAllowed,
		},
		{
			name: "nested tagged byte string map key with MapKeyByteStringAllowed",
			data: mustHexDecode("a1d865d86443abcdef187b"),
			wantObjs: map[reflect.Type]any{
				typeAny: map[any]any{
					Tag{Number: 101, Content: Tag{Number: 100, Content: ByteString("\xab\xcd\xef")}}: uint64(123),
				},
				typeMapAnyAny: map[any]any{
					Tag{Number: 101, Content: Tag{Number: 100, Content: ByteString("\xab\xcd\xef")}}: uint64(123),
				},
				typeMapTagAny: map[Tag]any{
					{Number: 101, Content: Tag{Number: 100, Content: ByteString("\xab\xcd\xef")}}: uint64(123),
				},
			},
			dm: dmBSAllowed,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			for typ, wantObj := range tc.wantObjs {
				v := reflect.New(typ)
				vPtr := v.Interface()
				err := unmarshalWithDM(t, tc.dm, tc.data, vPtr)
				checkUnmarshal(t, "dm.Unmarshal", v.Elem().Interface(), err, wantObj)
			}

			for typ, wantErrorMsg := range tc.wantErrorMsgs {
				v := reflect.New(typ)
				vPtr := v.Interface()
				err := unmarshalWithDM(t, tc.dm, tc.data, vPtr)
				checkError[error](t, "dm.Unmarshal", err, wantErrorMsg)
			}
		})
	}
}

func TestExtraErrorCondUnknownField(t *testing.T) {
	type s struct {
		A string
		B string
		C string
	}

	dm := mustDecMode(t, DecOptions{})
	dmUnknownFieldError := mustDecMode(t, DecOptions{ExtraReturnErrors: ExtraDecErrorUnknownField})

	testCases := []struct {
		name         string
		data         []byte
		dm           DecMode
		wantObj      any
		wantErrorMsg string
	}{
		{
			name:    "field by field match",
			data:    mustHexDecode("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",
			data:    mustHexDecode("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",
			data:    mustHexDecode("a26141616161426162"), // map[string]string{"A": "a", "B": "b"}
			dm:      dm,
			wantObj: s{A: "a", B: "b", C: ""},
		},
		{
			name:    "CBOR map less field with ExtraDecErrorUnknownField",
			data:    mustHexDecode("a26141616161426162"), // map[string]string{"A": "a", "B": "b"}
			dm:      dmUnknownFieldError,
			wantObj: s{A: "a", B: "b", C: ""},
		},
		{
			name:    "duplicate map keys matching known field with ExtraDecErrorUnknownField",
			data:    mustHexDecode("a26141616161416141"), // map[string]string{"A": "a", "A": "A"}
			dm:      dmUnknownFieldError,
			wantObj: s{A: "a"},
		},
		{
			name:    "CBOR map unknown field",
			data:    mustHexDecode("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",
			data:         mustHexDecode("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 := unmarshalWithDM(t, tc.dm, tc.data, &v)
			checkUnmarshalCase[error](t, "dm.Unmarshal", v, err, tc.wantObj, tc.wantErrorMsg != "", tc.wantErrorMsg)
		})
	}
}

func TestStreamExtraErrorCondUnknownField(t *testing.T) {
	type s struct {
		A string
		B string
		C string
	}

	data := mustHexDecode("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 := mustDecMode(t, DecOptions{ExtraReturnErrors: ExtraDecErrorUnknownField})
	dec := dmUnknownFieldError.NewDecoder(bytes.NewReader(data))

	var v1 s
	err := dec.Decode(&v1)
	checkError[error](t, "Decoder.Decode", err, wantErrorMsg)

	var v2 s
	err = dec.Decode(&v2)
	checkUnmarshal(t, "Decoder.Decode", v2, err, wantObj)
}

// TestUnmarshalTagNum55799 is identical to TestUnmarshal,
// except that CBOR test data is prefixed with tag number 55799 (0xd9d9f7).
func TestUnmarshalTagNum55799(t *testing.T) {
	tagNum55799 := mustHexDecode("d9d9f7")

	for _, tc := range unmarshalTestCases {
		t.Run(fmt.Sprintf("0x%x", tc.data), func(t *testing.T) {
			// Prefix tag number 55799 to CBOR test data
			data := make([]byte, len(tc.data)+6)
			copy(data, tagNum55799)
			copy(data[3:], tagNum55799)
			copy(data[6:], tc.data)

			// Test unmarshaling CBOR into a value of type any.
			var v any
			err := unmarshal(t, data, &v)
			checkUnmarshalFunc(t, "Unmarshal", v, err, tc.wantInterfaceValue, nonFloatEqual)

			// Test unmarshaling CBOR into RawMessage.
			var r RawMessage
			err = unmarshal(t, data, &r)
			checkUnmarshal(t, "Unmarshal", r, err, RawMessage(tc.data))

			// Test unmarshaling CBOR into compatible data types.
			for _, value := range tc.wantValues {
				t.Run(fmt.Sprintf("%T", value), func(t *testing.T) {
					v := reflect.New(reflect.TypeOf(value))
					vPtr := v.Interface()
					err := unmarshal(t, data, vPtr)
					checkUnmarshalFunc(t, "Unmarshal", v.Elem().Interface(), err, value, nonFloatEqual)
				})
			}

			// Test unmarshaling CBOR into incompatible data types.
			for _, typ := range tc.wrongTypes {
				v := reflect.New(typ)
				vPtr := v.Interface()
				err := unmarshal(t, data, vPtr)
				checkError[*UnmarshalTypeError](t, "Unmarshal", err, "")
			}
		})
	}
}

// TestUnmarshalFloatWithTagNum55799 is identical to TestUnmarshalFloat,
// except that CBOR test data is prefixed with tag number 55799 (0xd9d9f7).
func TestUnmarshalFloatWithTagNum55799(t *testing.T) {
	tagNum55799 := mustHexDecode("d9d9f7")

	for _, tc := range unmarshalFloatTestCases {
		t.Run(fmt.Sprintf("0x%x", tc.data), func(t *testing.T) {
			// Prefix tag number 55799 to CBOR test data
			data := make([]byte, len(tc.data)+3)
			copy(data, tagNum55799)
			copy(data[3:], tc.data)

			// Test unmarshaling CBOR into a value of type any.
			var v any
			err := unmarshal(t, data, &v)
			checkUnmarshalFunc(t, "Unmarshal", v, err, tc.wantInterfaceValue, floatEqual(tc.equalityThreshold))

			// Test unmarshaling CBOR into RawMessage.
			var r RawMessage
			err = unmarshal(t, data, &r)
			checkUnmarshal(t, "Unmarshal", r, err, RawMessage(tc.data))

			// Test unmarshaling CBOR into compatible data types.
			for _, value := range tc.wantValues {
				t.Run(fmt.Sprintf("%T", value), func(t *testing.T) {
					v := reflect.New(reflect.TypeOf(value))
					vPtr := v.Interface()
					err := unmarshal(t, data, vPtr)
					checkUnmarshalFunc(t, "Unmarshal", v.Elem().Interface(), err, value, floatEqual(tc.equalityThreshold))
				})
			}

			// Test unmarshaling CBOR into incompatible data types.
			for _, typ := range unmarshalFloatWrongTypes {
				v := reflect.New(typ)
				vPtr := v.Interface()
				err := unmarshal(t, data, vPtr)
				checkError[*UnmarshalTypeError](t, "Unmarshal", err, "")
			}
		})
	}
}

func TestUnmarshalTagNum55799AsElement(t *testing.T) {
	testCases := []struct {
		name                string
		data                []byte
		emptyInterfaceValue any
		values              []any
		wrongTypes          []reflect.Type
	}{
		{
			name:                "array",
			data:                mustHexDecode("d9d9f783d9d9f701d9d9f702d9d9f703"), // 55799([55799(1), 55799(2), 55799(3)])
			emptyInterfaceValue: []any{uint64(1), uint64(2), uint64(3)},
			values:              []any{[]any{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}},
			wrongTypes:          []reflect.Type{typeUint8, typeUint16, typeUint32, typeUint64, typeInt8, typeInt16, typeInt32, typeInt64, typeFloat32, typeFloat64, typeString, typeBool, typeStringSlice, typeMapStringInt, reflect.TypeFor[[3]string](), typeTag, typeRawTag},
		},
		{
			name:                "map",
			data:                mustHexDecode("d9d9f7a2d9d9f701d9d9f702d9d9f703d9d9f704"), // 55799({55799(1): 55799(2), 55799(3): 55799(4)})
			emptyInterfaceValue: map[any]any{uint64(1): uint64(2), uint64(3): uint64(4)},
			values:              []any{map[any]any{uint64(1): uint64(2), uint64(3): uint64(4)}, map[uint]int{1: 2, 3: 4}, map[int]uint{1: 2, 3: 4}},
			wrongTypes:          []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 unmarshaling CBOR into a value of type any.
			var v any
			err := unmarshal(t, tc.data, &v)
			checkUnmarshalFunc(t, "Unmarshal", v, err, tc.emptyInterfaceValue, nonFloatEqual)

			// Test unmarshaling CBOR into compatible data types.
			for _, value := range tc.values {
				v := reflect.New(reflect.TypeOf(value))
				vPtr := v.Interface()
				err := unmarshal(t, tc.data, vPtr)
				checkUnmarshalFunc(t, "Unmarshal", v.Elem().Interface(), err, value, nonFloatEqual)
			}

			// Test unmarshaling CBOR into incompatible data types.
			for _, typ := range tc.wrongTypes {
				v := reflect.New(typ)
				vPtr := v.Interface()
				err := unmarshal(t, tc.data, vPtr)
				checkError[*UnmarshalTypeError](t, "Unmarshal", err, "")
			}
		})
	}
}

func TestUnmarshalTagNum55799EnclosingRegisteredTagToInterface(t *testing.T) {
	// Tag number 55799 enclosing a registered tag has no effect when decoding to an
	// interface implemented by the registered type (RFC 8949 Section 3.4.6).
	tags := NewTagSet()
	mustAddTag(t, tags, TagOptions{DecTag: DecTagRequired}, reflect.TypeFor[StringFoo](), 100)
	dm := mustDecModeWithTags(t, DecOptions{}, tags)

	for _, data := range [][]byte{
		mustHexDecode("d8646161"),       // 100("a")
		mustHexDecode("d9d9f7d8646161"), // 55799(100("a"))
	} {
		t.Run(fmt.Sprintf("0x%x to provided interface", data), func(t *testing.T) {
			want := StringFoo("a")
			var v Foo
			err := unmarshalWithDM(t, dm, data, &v)
			checkUnmarshal(t, "dm.Unmarshal", v, err, &want)
		})

		t.Run(fmt.Sprintf("0x%x to empty interface", data), func(t *testing.T) {
			want := StringFoo("a")
			var v any
			err := unmarshalWithDM(t, dm, data, &v)
			checkUnmarshal(t, "dm.Unmarshal", v, err, want)
		})
	}
}

func TestUnmarshalTagNum55799ToBinaryUnmarshaler(t *testing.T) {
	data := mustHexDecode("d9d9f74800000000499602d2") // 55799(h'00000000499602D2')
	wantObj := number(1234567890)

	var v number
	err := unmarshal(t, data, &v)
	checkUnmarshal(t, "Unmarshal", v, err, wantObj)
}

func TestUnmarshalTagNum55799ToUnmarshaler(t *testing.T) {
	data := mustHexDecode("d9d9f7d864a1636e756d01") // 55799(100({"num": 1}))
	wantObj := number3(1)

	var v number3
	err := unmarshal(t, data, &v)
	checkUnmarshal(t, "Unmarshal", v, err, wantObj)
}

func TestUnmarshalTagNum55799ToRegisteredGoType(t *testing.T) {
	type myInt int
	typ := reflect.TypeFor[myInt]()

	tags := NewTagSet()
	mustAddTag(t, tags, TagOptions{EncTag: EncTagRequired, DecTag: DecTagRequired}, typ, 125)

	dm := mustDecModeWithTags(t, DecOptions{}, tags)

	data := mustHexDecode("d9d9f7d87d01") // 55799(125(1))
	wantObj := myInt(1)

	var v myInt
	err := unmarshalWithDM(t, dm, data, &v)
	checkUnmarshal(t, "dm.Unmarshal", v, err, 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) {
	data := mustHexDecode("d864d9d9f701") // 100(55799(1))
	wantObj := Tag{100, Tag{55799, uint64(1)}}

	var v any
	err := unmarshal(t, data, &v)
	checkUnmarshal(t, "Unmarshal", v, err, wantObj)
}

func TestUnmarshalNestedTagNum55799ToValue(t *testing.T) {
	data := mustHexDecode("d864d9d9f701") // 100(55799(1))
	wantObj := 1

	var v int
	err := unmarshal(t, data, &v)
	checkUnmarshal(t, "Unmarshal", v, err, wantObj)
}

func TestUnmarshalNestedTagNum55799ToTag(t *testing.T) {
	data := mustHexDecode("d864d9d9f701") // 100(55799(1))
	wantObj := Tag{100, Tag{55799, uint64(1)}}

	var v Tag
	err := unmarshal(t, data, &v)
	checkUnmarshal(t, "Unmarshal", v, err, wantObj)
}

func TestUnmarshalNestedTagNum55799ToTime(t *testing.T) {
	data := mustHexDecode("c0d9d9f774323031332d30332d32315432303a30343a30305a") // 0(55799("2013-03-21T20:04:00Z"))
	wantErrorMsg := "cbor: tag number 0 must be followed by text string, got tag"

	var v time.Time
	err := unmarshal(t, data, &v)
	checkError[error](t, "Unmarshal", err, wantErrorMsg)
}

func TestUnmarshalNestedTagNum55799ToBinaryUnmarshaler(t *testing.T) {
	data := mustHexDecode("d864d9d9f74800000000499602d2") // 100(55799(h'00000000499602D2'))
	wantObj := number(1234567890)

	var v number
	err := unmarshal(t, data, &v)
	checkUnmarshal(t, "Unmarshal", v, err, wantObj)
}

func TestUnmarshalNestedTagNum55799ToUnmarshaler(t *testing.T) {
	data := mustHexDecode("d864d9d9f7a1636e756d01") // 100(55799({"num": 1}))
	wantErrorMsg := "wrong tag content type, want map"

	var v number3
	err := unmarshal(t, data, &v)
	checkError[error](t, "Unmarshal", err, wantErrorMsg)
}

func TestUnmarshalNestedTagNum55799ToRegisteredGoType(t *testing.T) {
	type myInt int
	typ := reflect.TypeFor[myInt]()

	tags := NewTagSet()
	mustAddTag(t, tags, TagOptions{EncTag: EncTagRequired, DecTag: DecTagRequired}, typ, 125)

	dm := mustDecModeWithTags(t, DecOptions{}, tags)

	data := mustHexDecode("d87dd9d9f701") // 125(55799(1))
	wantErrorMsg := "cbor: wrong tag number for cbor.myInt, got [125 55799], expected [125]"

	var v myInt
	err := unmarshalWithDM(t, dm, data, &v)
	checkError[error](t, "Unmarshal", err, wantErrorMsg)
}

func TestUnmarshalPosIntToBigInt(t *testing.T) {
	data := mustHexDecode("1bffffffffffffffff") // 18446744073709551615
	wantEmptyInterfaceValue := uint64(18446744073709551615)
	wantBigIntValue := mustBigInt("18446744073709551615")

	var v1 any
	err := unmarshal(t, data, &v1)
	checkUnmarshal(t, "Unmarshal", v1, err, wantEmptyInterfaceValue)

	var v2 big.Int
	err = unmarshal(t, data, &v2)
	checkUnmarshal(t, "Unmarshal", v2, err, wantBigIntValue)
}

func TestUnmarshalNegIntToBigInt(t *testing.T) {
	testCases := []struct {
		name                    string
		data                    []byte
		wantEmptyInterfaceValue any
		wantBigIntValue         big.Int
	}{
		{
			name:                    "fit Go int64",
			data:                    mustHexDecode("3b7fffffffffffffff"), // -9223372036854775808
			wantEmptyInterfaceValue: int64(-9223372036854775808),
			wantBigIntValue:         mustBigInt("-9223372036854775808"),
		},
		{
			name:                    "overflow Go int64",
			data:                    mustHexDecode("3b8000000000000000"), // -9223372036854775809
			wantEmptyInterfaceValue: mustBigInt("-9223372036854775809"),
			wantBigIntValue:         mustBigInt("-9223372036854775809"),
		},
	}
	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			var v1 any
			err := unmarshal(t, tc.data, &v1)
			checkUnmarshal(t, "Unmarshal", v1, err, tc.wantEmptyInterfaceValue)

			var v2 big.Int
			err = unmarshal(t, tc.data, &v2)
			checkUnmarshal(t, "Unmarshal", v2, err, tc.wantBigIntValue)
		})
	}
}

func TestUnmarshalTag2(t *testing.T) {
	testCases := []struct {
		name                    string
		data                    []byte
		wantEmptyInterfaceValue any
		wantValues              []any
	}{
		{
			name:                    "fit Go int64",
			data:                    mustHexDecode("c2430f4240"), // 2(1000000)
			wantEmptyInterfaceValue: mustBigInt("1000000"),
			wantValues: []any{
				int64(1000000),
				uint64(1000000),
				float32(1000000),
				float64(1000000),
				mustBigInt("1000000"),
			},
		},
		{
			name:                    "fit Go uint64",
			data:                    mustHexDecode("c248ffffffffffffffff"), // 2(18446744073709551615)
			wantEmptyInterfaceValue: mustBigInt("18446744073709551615"),
			wantValues: []any{
				uint64(18446744073709551615),
				float32(18446744073709551615),
				float64(18446744073709551615),
				mustBigInt("18446744073709551615"),
			},
		},
		{
			name:                    "fit Go uint64 with leading zeros",
			data:                    mustHexDecode("c24900ffffffffffffffff"), // 2(18446744073709551615)
			wantEmptyInterfaceValue: mustBigInt("18446744073709551615"),
			wantValues: []any{
				uint64(18446744073709551615),
				float32(18446744073709551615),
				float64(18446744073709551615),
				mustBigInt("18446744073709551615"),
			},
		},
		{
			name:                    "overflow Go uint64",
			data:                    mustHexDecode("c249010000000000000000"), // 2(18446744073709551616)
			wantEmptyInterfaceValue: mustBigInt("18446744073709551616"),
			wantValues: []any{
				mustBigInt("18446744073709551616"),
			},
		},
		{
			name:                    "overflow Go uint64 with leading zeros",
			data:                    mustHexDecode("c24b0000010000000000000000"), // 2(18446744073709551616)
			wantEmptyInterfaceValue: mustBigInt("18446744073709551616"),
			wantValues: []any{
				mustBigInt("18446744073709551616"),
			},
		},
	}
	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			var v1 any
			err := unmarshal(t, tc.data, &v1)
			checkUnmarshal(t, "Unmarshal", v1, err, tc.wantEmptyInterfaceValue)

			for _, wantValue := range tc.wantValues {
				v := reflect.New(reflect.TypeOf(wantValue))
				err := unmarshal(t, tc.data, v.Interface())
				checkUnmarshal(t, "Unmarshal", v.Elem().Interface(), err, wantValue)
			}
		})
	}
}

func TestUnmarshalTag3(t *testing.T) {
	testCases := []struct {
		name                    string
		data                    []byte
		wantEmptyInterfaceValue any
		wantValues              []any
	}{
		{
			name:                    "fit Go int64",
			data:                    mustHexDecode("c3487fffffffffffffff"), // 3(-9223372036854775808)
			wantEmptyInterfaceValue: mustBigInt("-9223372036854775808"),
			wantValues: []any{
				int64(-9223372036854775808),
				float32(-9223372036854775808),
				float64(-9223372036854775808),
				mustBigInt("-9223372036854775808"),
			},
		},
		{
			name:                    "fit Go int64 with leading zeros",
			data:                    mustHexDecode("c349007fffffffffffffff"), // 3(-9223372036854775808)
			wantEmptyInterfaceValue: mustBigInt("-9223372036854775808"),
			wantValues: []any{
				int64(-9223372036854775808),
				float32(-9223372036854775808),
				float64(-9223372036854775808),
				mustBigInt("-9223372036854775808"),
			},
		},
		{
			name:                    "overflow Go int64",
			data:                    mustHexDecode("c349010000000000000000"), // 3(-18446744073709551617)
			wantEmptyInterfaceValue: mustBigInt("-18446744073709551617"),
			wantValues: []any{
				mustBigInt("-18446744073709551617"),
			},
		},
		{
			name:                    "overflow Go int64 with leading zeros",
			data:                    mustHexDecode("c34b0000010000000000000000"), // 3(-18446744073709551617)
			wantEmptyInterfaceValue: mustBigInt("-18446744073709551617"),
			wantValues: []any{
				mustBigInt("-18446744073709551617"),
			},
		},
	}
	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			var v1 any
			err := unmarshal(t, tc.data, &v1)
			checkUnmarshal(t, "Unmarshal", v1, err, tc.wantEmptyInterfaceValue)

			for _, wantValue := range tc.wantValues {
				v := reflect.New(reflect.TypeOf(wantValue))
				err = unmarshal(t, tc.data, v.Interface())
				checkUnmarshal(t, "Unmarshal", v.Elem().Interface(), err, wantValue)
			}
		})
	}
}

func TestUnmarshalInvalidTagBignum(t *testing.T) {
	typeBigIntSlice := reflect.TypeFor[[]big.Int]()

	testCases := []struct {
		name          string
		data          []byte
		decodeToTypes []reflect.Type
		wantErrorMsg  string
	}{
		{
			name:          "tag 2 with string",
			data:          mustHexDecode("c27f657374726561646d696e67ff"),
			decodeToTypes: []reflect.Type{typeAny, typeBigInt},
			wantErrorMsg:  "cbor: tag number 2 or 3 must be followed by byte string, got UTF-8 text string",
		},
		{
			name:          "tag 3 with string",
			data:          mustHexDecode("c37f657374726561646d696e67ff"),
			decodeToTypes: []reflect.Type{typeAny, typeBigInt},
			wantErrorMsg:  "cbor: tag number 2 or 3 must be followed by byte string, got UTF-8 text string",
		},
		{
			name:          "tag 3 with negative integer",
			data:          mustHexDecode("81C330"), // [3(-17)]
			decodeToTypes: []reflect.Type{typeAny, 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)
				err := unmarshal(t, tc.data, v.Interface())
				checkError[error](t, "unmarshal", 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 string(*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 := mustEncMode(t, EncOptions{Sort: SortCanonical})

	testCases := []struct {
		name           string
		data           []byte
		v              *TestExample
		unmarshalToObj *TestExample
	}{
		{
			name: "uint",
			data: mustHexDecode("a2016c736f6d65206d65737361676502187b"), // {1: "some message", 2: 123}
			v: &TestExample{
				Message: "some message",
				Foo:     &uintFoo123,
			},
			unmarshalToObj: &TestExample{Foo: &uintFoo},
		},
		{
			name: "int",
			data: mustHexDecode("a2016c736f6d65206d6573736167650220"), // {1: "some message", 2: -1}
			v: &TestExample{
				Message: "some message",
				Foo:     &intFooNeg1,
			},
			unmarshalToObj: &TestExample{Foo: &intFoo},
		},
		{
			name: "bytes",
			data: mustHexDecode("a2016c736f6d65206d6573736167650243010203"), // {1: "some message", 2: [1,2,3]}
			v: &TestExample{
				Message: "some message",
				Foo:     &byteFoo123,
			},
			unmarshalToObj: &TestExample{Foo: &byteFoo},
		},
		{
			name: "string",
			data: mustHexDecode("a2016c736f6d65206d6573736167650263313233"), // {1: "some message", 2: "123"}
			v: &TestExample{
				Message: "some message",
				Foo:     &stringFoo123,
			},
			unmarshalToObj: &TestExample{Foo: &stringFoo},
		},
		{
			name: "array",
			data: mustHexDecode("a2016c736f6d65206d6573736167650283010203"), // {1: "some message", 2: []int{1,2,3}}
			v: &TestExample{
				Message: "some message",
				Foo:     &arrayFoo123,
			},
			unmarshalToObj: &TestExample{Foo: &arrayFoo},
		},
		{
			name: "map",
			data: mustHexDecode("a2016c736f6d65206d65737361676502a3010102020303"), // {1: "some message", 2: map[int]int{1:1,2:2,3:3}}
			v: &TestExample{
				Message: "some message",
				Foo:     &mapFoo123,
			},
			unmarshalToObj: &TestExample{Foo: &mapFoo},
		},
		{
			name: "struct",
			data: mustHexDecode("a2016c736f6d65206d65737361676502a1011901c8"), // {1: "some message", 2: {1: 456}}
			v: &TestExample{
				Message: "some message",
				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)
			checkMarshal(t, "em.Marshal", data, err, tc.data)

			// Unmarshal to a value of type TestExample with uninitialized Foo interface.
			var einterface TestExample
			err = unmarshal(t, data, &einterface)
			checkError[*UnmarshalTypeError](t, "Unmarshal", err, "")

			// Unmarshal to interface value
			err = unmarshal(t, data, tc.unmarshalToObj)
			checkUnmarshal(t, "Unmarshal", tc.unmarshalToObj, err, 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()
	mustAddTag(t, tags,
		TagOptions{EncTag: EncTagRequired, DecTag: DecTagRequired},
		reflect.TypeFor[*Bar](),
		4,
	)

	v := &FooStruct{
		Foos: []Foo{&Bar{1}},
	}

	want := mustHexDecode("a164466f6f7381c4a1614901") // {"Foos": [4({"I": 1})]}

	em := mustEncModeWithTags(t, EncOptions{}, tags)
	data, err := em.Marshal(v)
	checkMarshal(t, "em.Marshal", data, err, want)

	dm := mustDecModeWithTags(t, DecOptions{}, tags)

	// Unmarshal to wrong type.
	var v1 Bar
	err = unmarshalWithDM(t, dm, data, &v1)
	checkError[*UnmarshalTypeError](t, "dm.Unmarshal", err, "")

	// Unmarshal to interface value
	v2 := &FooStruct{
		Foos: []Foo{&Bar{}},
	}
	err = unmarshalWithDM(t, dm, data, v2)
	checkUnmarshal(t, "dm.Unmarshal", v2, err, v)
}

type B interface {
	Foo()
}

type C struct {
	Field int
}

func (c *C) Foo() {}

type D struct {
	Field string
}

func (d *D) Foo() {}

type A1 struct {
	Field B
}

type A2 struct {
	Fields []B
}

func TestUnmarshalRegisteredTagToInterface(t *testing.T) {
	tags := NewTagSet()
	mustAddTag(t, tags, TagOptions{EncTag: EncTagRequired, DecTag: DecTagRequired}, reflect.TypeFor[C](), 279)
	mustAddTag(t, tags, TagOptions{EncTag: EncTagRequired, DecTag: DecTagRequired}, reflect.TypeFor[D](), 280)

	em := mustEncModeWithTags(t, PreferredUnsortedEncOptions(), tags)
	dm := mustDecModeWithTags(t, DecOptions{}, tags)

	v1 := A1{Field: &C{Field: 5}}
	data1, err := em.Marshal(v1)
	checkNoError(t, "em.Marshal", err)

	v2 := A2{Fields: []B{&C{Field: 5}, &D{Field: "a"}}}
	data2, err := em.Marshal(v2)
	checkNoError(t, "em.Marshal", err)

	testCases := []struct {
		name           string
		data           []byte
		unmarshalToObj any
		wantValue      any
	}{
		{
			name:           "interface type",
			data:           data1,
			unmarshalToObj: &A1{},
			wantValue:      &v1,
		},
		{
			name:           "concrete type",
			data:           data1,
			unmarshalToObj: &A1{Field: &C{}},
			wantValue:      &v1,
		},
		{
			name:           "slice of interface type",
			data:           data2,
			unmarshalToObj: &A2{},
			wantValue:      &v2,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			err = unmarshalWithDM(t, dm, tc.data, tc.unmarshalToObj)
			checkUnmarshal(t, "dm.Unmarshal", tc.unmarshalToObj, err, tc.wantValue)
		})
	}
}

func TestUnmarshalToDefaultMapType(t *testing.T) {

	cborDataMapIntInt := mustHexDecode("a201020304")                                             // {1: 2, 3: 4}
	cborDataMapStringInt := mustHexDecode("a2616101616202")                                      // {"a": 1, "b": 2}
	cborDataArrayOfMapStringint := mustHexDecode("82a2616101616202a2616303616404")               // [{"a": 1, "b": 2}, {"c": 3, "d": 4}]
	cborDataNestedMap := mustHexDecode("a268496e744669656c6401684d61704669656c64a2616101616202") // {"IntField": 1, "MapField": {"a": 1, "b": 2}}

	decOptionsDefault := DecOptions{}
	decOptionsMapAnyAnyType := DecOptions{DefaultMapType: reflect.TypeFor[map[any]any]()}
	decOptionsMapStringIntType := DecOptions{DefaultMapType: reflect.TypeFor[map[string]int]()}
	decOptionsMapStringAnyType := DecOptions{DefaultMapType: reflect.TypeFor[map[string]any]()}

	testCases := []struct {
		name         string
		opts         DecOptions
		data         []byte
		wantValue    any
		wantErrorMsg string
	}{
		// Decode CBOR map to map[any]any using default options
		{
			name:      "decode CBOR map[int]int to Go map[any]any (default)",
			opts:      decOptionsDefault,
			data:      cborDataMapIntInt,
			wantValue: map[any]any{uint64(1): uint64(2), uint64(3): uint64(4)},
		},
		{
			name:      "decode CBOR map[string]int to Go map[any]any (default)",
			opts:      decOptionsDefault,
			data:      cborDataMapStringInt,
			wantValue: map[any]any{"a": uint64(1), "b": uint64(2)},
		},
		{
			name: "decode CBOR array of map[string]int to Go []map[any]any (default)",
			opts: decOptionsDefault,
			data: cborDataArrayOfMapStringint,
			wantValue: []any{
				map[any]any{"a": uint64(1), "b": uint64(2)},
				map[any]any{"c": uint64(3), "d": uint64(4)},
			},
		},
		{
			name: "decode CBOR nested map to Go map[any]any (default)",
			opts: decOptionsDefault,
			data: cborDataNestedMap,
			wantValue: map[any]any{
				"IntField": uint64(1),
				"MapField": map[any]any{"a": uint64(1), "b": uint64(2)},
			},
		},
		// Decode CBOR map to map[any]any using default map type option
		{
			name:      "decode CBOR map[int]int to Go map[any]any",
			opts:      decOptionsMapAnyAnyType,
			data:      cborDataMapIntInt,
			wantValue: map[any]any{uint64(1): uint64(2), uint64(3): uint64(4)},
		},
		{
			name:      "decode CBOR map[string]int to Go map[any]any",
			opts:      decOptionsMapAnyAnyType,
			data:      cborDataMapStringInt,
			wantValue: map[any]any{"a": uint64(1), "b": uint64(2)},
		},
		{
			name: "decode CBOR array of map[string]int to Go []map[any]any",
			opts: decOptionsMapAnyAnyType,
			data: cborDataArrayOfMapStringint,
			wantValue: []any{
				map[any]any{"a": uint64(1), "b": uint64(2)},
				map[any]any{"c": uint64(3), "d": uint64(4)},
			},
		},
		{
			name: "decode CBOR nested map to Go map[any]any",
			opts: decOptionsMapAnyAnyType,
			data: cborDataNestedMap,
			wantValue: map[any]any{
				"IntField": uint64(1),
				"MapField": map[any]any{"a": uint64(1), "b": uint64(2)},
			},
		},
		// Decode CBOR map to map[string]any using default map type option
		{
			name:         "decode CBOR map[int]int to Go map[string]any",
			opts:         decOptionsMapStringAnyType,
			data:         cborDataMapIntInt,
			wantErrorMsg: "cbor: cannot unmarshal positive integer into Go value of type string",
		},
		{
			name:      "decode CBOR map[string]int to Go map[string]any",
			opts:      decOptionsMapStringAnyType,
			data:      cborDataMapStringInt,
			wantValue: map[string]any{"a": uint64(1), "b": uint64(2)},
		},
		{
			name: "decode CBOR array of map[string]int to Go []map[string]any",
			opts: decOptionsMapStringAnyType,
			data: cborDataArrayOfMapStringint,
			wantValue: []any{
				map[string]any{"a": uint64(1), "b": uint64(2)},
				map[string]any{"c": uint64(3), "d": uint64(4)},
			},
		},
		{
			name: "decode CBOR nested map to Go map[string]any",
			opts: decOptionsMapStringAnyType,
			data: cborDataNestedMap,
			wantValue: map[string]any{
				"IntField": uint64(1),
				"MapField": map[string]any{"a": uint64(1), "b": uint64(2)},
			},
		},
		// Decode CBOR map to map[string]int using default map type option
		{
			name:         "decode CBOR map[int]int to Go map[string]int",
			opts:         decOptionsMapStringIntType,
			data:         cborDataMapIntInt,
			wantErrorMsg: "cbor: cannot unmarshal positive integer into Go value of type string",
		},
		{
			name:      "decode CBOR map[string]int to Go map[string]int",
			opts:      decOptionsMapStringIntType,
			data:      cborDataMapStringInt,
			wantValue: map[string]int{"a": 1, "b": 2},
		},
		{
			name: "decode CBOR array of map[string]int to Go []map[string]int",
			opts: decOptionsMapStringIntType,
			data: cborDataArrayOfMapStringint,
			wantValue: []any{
				map[string]int{"a": 1, "b": 2},
				map[string]int{"c": 3, "d": 4},
			},
		},
		{
			name:         "decode CBOR nested map to Go map[string]int",
			opts:         decOptionsMapStringIntType,
			data:         cborDataNestedMap,
			wantErrorMsg: "cbor: cannot unmarshal map into Go value of type int",
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			dm := mustDecMode(t, tc.opts)
			var v any
			err := unmarshalWithDM(t, dm, tc.data, &v)
			checkUnmarshalCase[error](t, "dm.Unmarshal", v, err, tc.wantValue, tc.wantErrorMsg != "", tc.wantErrorMsg)
		})
	}
}

func TestUnmarshalFirstNoTrailing(t *testing.T) {
	for _, tc := range unmarshalTestCases {
		var v any
		rest, err := UnmarshalFirst(tc.data, &v)
		checkUnmarshalFunc(t, "UnmarshalFirst", v, err, tc.wantInterfaceValue, nonFloatEqual)
		if len(rest) != 0 {
			t.Errorf("UnmarshalFirst(0x%x) rest = 0x%x, want empty", tc.data, rest)
		}
	}
}

func TestUnmarshalfirstTrailing(t *testing.T) {
	// Random trailing data
	trailingData := mustHexDecode("4a6b0f4718c73f391091ea1c")
	for _, tc := range unmarshalTestCases {
		data := make([]byte, 0, len(tc.data)+len(trailingData))
		data = append(data, tc.data...)
		data = append(data, trailingData...)
		var v any
		rest, err := UnmarshalFirst(data, &v)
		checkUnmarshalFunc(t, "UnmarshalFirst", v, err, tc.wantInterfaceValue, nonFloatEqual)
		if !bytes.Equal(trailingData, rest) {
			t.Errorf("UnmarshalFirst(0x%x) rest = 0x%x, want 0x%x", data, rest, trailingData)
		}
	}
}

func TestUnmarshalFirstInvalidItem(t *testing.T) {
	// UnmarshalFirst should not return "rest" if the item was not well-formed
	invalidCBOR := mustHexDecode("83FF20030102")
	var v any
	rest, err := UnmarshalFirst(invalidCBOR, &v)
	checkError[error](t, "UnmarshalFirst", err, "")
	if rest != nil {
		t.Errorf("UnmarshalFirst(0x%x) rest = 0x%x, want nil", invalidCBOR, rest)
	}
}

func TestDecodeFieldNameMatching(t *testing.T) {
	type s struct {
		LowerA int `cbor:"a"`
		UpperB int `cbor:"B"`
		LowerB int `cbor:"b"`
	}

	testCases := []struct {
		name      string
		opts      DecOptions
		data      []byte
		wantValue s
	}{
		{
			name:      "case-insensitive match",
			data:      mustHexDecode("a1614101"), // {"A": 1}
			wantValue: s{LowerA: 1},
		},
		{
			name:      "ignore case-insensitive match",
			opts:      DecOptions{FieldNameMatching: FieldNameMatchingCaseSensitive},
			data:      mustHexDecode("a1614101"), // {"A": 1}
			wantValue: s{},
		},
		{
			name:      "exact match before case-insensitive match",
			data:      mustHexDecode("a2616101614102"), // {"a": 1, "A": 2}
			wantValue: s{LowerA: 1},
		},
		{
			name:      "case-insensitive match before exact match",
			data:      mustHexDecode("a2614101616102"), // {"A": 1, "a": 2}
			wantValue: s{LowerA: 1},
		},
		{
			name:      "ignore case-insensitive match before exact match",
			opts:      DecOptions{FieldNameMatching: FieldNameMatchingCaseSensitive},
			data:      mustHexDecode("a2614101616102"), // {"A": 1, "a": 2}
			wantValue: s{LowerA: 2},
		},
		{
			name:      "earliest exact match wins",
			opts:      DecOptions{FieldNameMatching: FieldNameMatchingCaseSensitive},
			data:      mustHexDecode("a2616101616102"), // {"a": 1, "a": 2} (invalid)
			wantValue: s{LowerA: 1},
		},
		{
			// the field tags themselves are case-insensitive matches for each other
			name:      "duplicate key does not fall back to case-insensitive match",
			data:      mustHexDecode("a2614201614202"), // {"B": 1, "B": 2} (invalid)
			wantValue: s{UpperB: 1},
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			dm := mustDecMode(t, tc.opts)
			var dst s
			err := unmarshalWithDM(t, dm, tc.data, &dst)
			checkUnmarshal(t, "dm.Unmarshal", dst, err, tc.wantValue)
		})
	}
}

func TestDecodeBignumToEmptyInterface(t *testing.T) {
	decOptionsDecodeToBigIntValue := DecOptions{BigIntDec: BigIntDecodeValue}
	decOptionsDecodeToBigIntPointer := DecOptions{BigIntDec: BigIntDecodePointer}

	cborDataPositiveBignum := mustHexDecode("c249010000000000000000") // positive bignum: 18446744073709551616
	pbn, _ := new(big.Int).SetString("18446744073709551616", 10)

	cborDataNegativeBignum := mustHexDecode("c349010000000000000000") // negative bignum: -18446744073709551617
	nbn, _ := new(big.Int).SetString("-18446744073709551617", 10)

	cborDataLargeNegativeInt := mustHexDecode("3bffffffffffffffff") // -18446744073709551616
	ni, _ := new(big.Int).SetString("-18446744073709551616", 10)

	testCases := []struct {
		name      string
		opts      DecOptions
		data      []byte
		wantValue any
	}{
		{
			name:      "decode positive bignum to big.Int",
			opts:      decOptionsDecodeToBigIntValue,
			data:      cborDataPositiveBignum,
			wantValue: *pbn,
		},
		{
			name:      "decode negative bignum to big.Int",
			opts:      decOptionsDecodeToBigIntValue,
			data:      cborDataNegativeBignum,
			wantValue: *nbn,
		},
		{
			name:      "decode large negative int to big.Int",
			opts:      decOptionsDecodeToBigIntValue,
			data:      cborDataLargeNegativeInt,
			wantValue: *ni,
		},
		{
			name:      "decode positive bignum to *big.Int",
			opts:      decOptionsDecodeToBigIntPointer,
			data:      cborDataPositiveBignum,
			wantValue: pbn,
		},
		{
			name:      "decode negative bignum to *big.Int",
			opts:      decOptionsDecodeToBigIntPointer,
			data:      cborDataNegativeBignum,
			wantValue: nbn,
		},
		{
			name:      "decode large negative int to *big.Int",
			opts:      decOptionsDecodeToBigIntPointer,
			data:      cborDataLargeNegativeInt,
			wantValue: ni,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			dm := mustDecMode(t, tc.opts)
			var v any
			err := unmarshalWithDM(t, dm, tc.data, &v)
			checkUnmarshal(t, "dm.Unmarshal", v, err, tc.wantValue)
		})
	}
}

func TestUnmarshalDefaultByteStringType(t *testing.T) {
	type namedByteSliceType []byte

	for _, tc := range []struct {
		name string
		opts DecOptions
		data []byte
		want any
	}{
		{
			name: "default to []byte",
			opts: DecOptions{},
			data: mustHexDecode("43414243"),
			want: []byte("ABC"),
		},
		{
			name: "explicitly []byte",
			opts: DecOptions{DefaultByteStringType: reflect.TypeFor[[]byte]()},
			data: mustHexDecode("43414243"),
			want: []byte("ABC"),
		},
		{
			name: "string",
			opts: DecOptions{DefaultByteStringType: reflect.TypeFor[string]()},
			data: mustHexDecode("43414243"),
			want: "ABC",
		},
		{
			name: "ByteString",
			opts: DecOptions{DefaultByteStringType: reflect.TypeFor[ByteString]()},
			data: mustHexDecode("43414243"),
			want: ByteString("ABC"),
		},
		{
			name: "named []byte type",
			opts: DecOptions{DefaultByteStringType: reflect.TypeFor[namedByteSliceType]()},
			data: mustHexDecode("43414243"),
			want: namedByteSliceType("ABC"),
		},
	} {
		t.Run(tc.name, func(t *testing.T) {
			dm := mustDecMode(t, tc.opts)
			var got any
			err := unmarshalWithDM(t, dm, tc.data, &got)
			checkUnmarshal(t, "dm.Unmarshal", got, err, tc.want)
		})
	}
}

func TestUnmarshalByteStringToString(t *testing.T) {
	var s string

	dmForbidden := mustDecMode(t, DecOptions{ByteStringToString: ByteStringToStringForbidden})
	err := unmarshalWithDM(t, dmForbidden, mustHexDecode("43414243"), &s)
	checkUnmarshalErr[error](t, "dm.Unmarshal", s, err, "", "")

	dmAllowed := mustDecMode(t, DecOptions{ByteStringToString: ByteStringToStringAllowed})
	err = unmarshalWithDM(t, dmAllowed, mustHexDecode("43414243"), &s)
	checkUnmarshal(t, "dm.Unmarshal", s, err, "ABC")
}

func TestUnmarshalFieldNameByteString(t *testing.T) {
	dmAllowed := mustDecMode(t, DecOptions{FieldNameByteString: FieldNameByteStringAllowed})

	type S struct {
		F int64 `json:"f"`
	}

	var s S
	err := unmarshalWithDM(t, dmAllowed, mustHexDecode("a1414601"), &s) // {h'46': 1}
	checkUnmarshal(t, "dm.Unmarshal", s, err, S{F: 1})

	dmForbidden := mustDecMode(t, DecOptions{FieldNameByteString: FieldNameByteStringForbidden})

	const wantMsg = "cbor: cannot unmarshal byte string into Go value of type string (map key is of type byte string and cannot be used to match struct field name)"
	err = unmarshalWithDM(t, dmForbidden, mustHexDecode("a1414601"), &s)
	checkError[error](t, "dm.Unmarshal", err, wantMsg)
}

func TestUnmarshalWithUnrecognizedTagToAnyMode(t *testing.T) {
	for _, tc := range []struct {
		name string
		opts DecOptions
		data []byte
		want any
	}{
		{
			name: "default to value of type Tag",
			opts: DecOptions{},
			data: mustHexDecode("d8ff00"),
			want: Tag{Number: uint64(255), Content: uint64(0)},
		},
		{
			name: "Tag's content",
			opts: DecOptions{UnrecognizedTagToAny: UnrecognizedTagContentToAny},
			data: mustHexDecode("d8ff00"),
			want: uint64(0),
		},
	} {
		t.Run(tc.name, func(t *testing.T) {
			dm := mustDecMode(t, tc.opts)
			var got any
			err := unmarshalWithDM(t, dm, tc.data, &got)
			checkUnmarshal(t, "dm.Unmarshal", got, err, tc.want)
		})
	}
}

func TestUnmarshalWithUnrecognizedTagToAnyModeForSupportedTags(t *testing.T) {
	for _, tc := range []struct {
		name string
		opts DecOptions
		data []byte
		want any
	}{
		{
			name: "Unmarshal with tag number 0 when UnrecognizedTagContentToAny option is not set",
			opts: DecOptions{},
			data: mustHexDecode("c074323031332d30332d32315432303a30343a30305a"),
			want: time.Date(2013, 3, 21, 20, 4, 0, 0, time.UTC),
		},
		{
			name: "Unmarshal with tag number 0 when UnrecognizedTagContentToAny option is set",
			opts: DecOptions{UnrecognizedTagToAny: UnrecognizedTagContentToAny},
			data: mustHexDecode("c074323031332d30332d32315432303a30343a30305a"),
			want: time.Date(2013, 3, 21, 20, 4, 0, 0, time.UTC),
		},
		{
			name: "Unmarshal with tag number 1 when UnrecognizedTagContentToAny option is not set",
			opts: DecOptions{},
			data: mustHexDecode("c11a514b67b0"),
			want: time.Date(2013, 3, 21, 20, 4, 0, 0, time.UTC),
		},
		{
			name: "Unmarshal with tag number 1 when UnrecognizedTagContentToAny option is set",
			opts: DecOptions{UnrecognizedTagToAny: UnrecognizedTagContentToAny},
			data: mustHexDecode("c11a514b67b0"),
			want: time.Date(2013, 3, 21, 20, 4, 0, 0, time.UTC),
		},
		{
			name: "Unmarshal with tag number 2 when UnrecognizedTagContentToAny option is not set",
			opts: DecOptions{},
			data: mustHexDecode("c249010000000000000000"),
			want: mustBigInt("18446744073709551616"),
		},
		{
			name: "Unmarshal with tag number 2 when UnrecognizedTagContentToAny option is set",
			opts: DecOptions{UnrecognizedTagToAny: UnrecognizedTagContentToAny},
			data: mustHexDecode("c249010000000000000000"),
			want: mustBigInt("18446744073709551616"),
		},
		{
			name: "Unmarshal with tag number 3 when UnrecognizedTagContentToAny option is not set",
			opts: DecOptions{},
			data: mustHexDecode("c349010000000000000000"),
			want: mustBigInt("-18446744073709551617"),
		},
		{
			name: "Unmarshal with tag number 3 when UnrecognizedTagContentToAny option is set",
			opts: DecOptions{UnrecognizedTagToAny: UnrecognizedTagContentToAny},
			data: mustHexDecode("c349010000000000000000"),
			want: mustBigInt("-18446744073709551617"),
		},
	} {
		t.Run(tc.name, func(t *testing.T) {
			dm := mustDecMode(t, tc.opts)
			var got any
			err := unmarshalWithDM(t, dm, tc.data, &got)
			checkUnmarshalFunc(t, "dm.Unmarshal", got, err, tc.want, nonFloatEqual)
		})
	}
}

func TestUnmarshalWithUnrecognizedTagToAnyModeForSharedTag(t *testing.T) {

	type myInt int
	typ := reflect.TypeFor[myInt]()

	tags := NewTagSet()
	mustAddTag(t, tags, TagOptions{EncTag: EncTagRequired, DecTag: DecTagRequired}, typ, 125)

	for _, tc := range []struct {
		name string
		opts DecOptions
		data []byte
		want any
	}{
		{
			name: "Unmarshal with a shared tag when UnrecognizedTagContentToAny option is not set",
			opts: DecOptions{},
			data: mustHexDecode("d9d9f7d87d01"), // 55799(125(1))
			want: myInt(1),
		},
		{
			name: "Unmarshal with a shared tag when UnrecognizedTagContentToAny option is set",
			opts: DecOptions{UnrecognizedTagToAny: UnrecognizedTagContentToAny},
			data: mustHexDecode("d9d9f7d87d01"), // 55799(125(1))
			want: myInt(1),
		},
	} {
		t.Run(tc.name, func(t *testing.T) {
			dm := mustDecModeWithTags(t, tc.opts, tags)
			var got any
			err := unmarshalWithDM(t, dm, tc.data, &got)
			checkUnmarshalFunc(t, "dm.Unmarshal", got, err, tc.want, nonFloatEqual)
		})
	}
}

func TestNewSimpleValueRegistry(t *testing.T) {
	for _, tc := range []struct {
		name         string
		opts         []func(*SimpleValueRegistry) error
		wantErrorMsg string
	}{
		{
			name:         "min reserved",
			opts:         []func(*SimpleValueRegistry) error{WithRejectedSimpleValue(24)},
			wantErrorMsg: "cbor: cannot set analog for reserved simple value 24",
		},
		{
			name:         "max reserved",
			opts:         []func(*SimpleValueRegistry) error{WithRejectedSimpleValue(31)},
			wantErrorMsg: "cbor: cannot set analog for reserved simple value 31",
		},
	} {
		t.Run(tc.name, func(t *testing.T) {
			_, err := NewSimpleValueRegistryFromDefaults(tc.opts...)
			checkError[error](t, "NewSimpleValueRegistryFromDefaults", err, tc.wantErrorMsg)
		})
	}
}

func TestUnmarshalSimpleValues(t *testing.T) {
	for _, tc := range []struct {
		name         string
		fns          []func(*SimpleValueRegistry) error
		data         []byte
		into         reflect.Type
		want         any
		wantErrorMsg string
	}{
		{
			name: "default false into any",
			fns:  nil,
			data: []byte{0xf4},
			into: typeAny,
			want: false,
		},
		{
			name: "default false into bool",
			fns:  nil,
			data: []byte{0xf4},
			into: typeBool,
			want: false,
		},
		{
			name: "default true into any",
			fns:  nil,
			data: []byte{0xf5},
			into: typeAny,
			want: true,
		},
		{
			name: "default true into bool",
			fns:  nil,
			data: []byte{0xf5},
			into: typeBool,
			want: true,
		},
		{
			name: "default null into any",
			fns:  nil,
			data: []byte{0xf6},
			into: typeAny,
			want: nil,
		},
		{
			name: "default undefined into any",
			fns:  nil,
			data: []byte{0xf7},
			into: typeAny,
			want: nil,
		},
		{
			name: "reject undefined into any",
			fns:  []func(*SimpleValueRegistry) error{WithRejectedSimpleValue(23)},
			data: []byte{0xf7},
			into: typeAny,
			want: nil,
			wantErrorMsg: UnacceptableDataItemError{
				CBORType: "primitives",
				Message:  "simple value 23 is not recognized",
			}.Error(),
		},
		{
			name: "reject true into bool",
			fns:  []func(*SimpleValueRegistry) error{WithRejectedSimpleValue(21)},
			data: []byte{0xf5},
			into: typeBool,
			want: false,
			wantErrorMsg: UnacceptableDataItemError{
				CBORType: "primitives",
				Message:  "simple value 21 is not recognized",
			}.Error(),
		},
		{
			name: "reject true into a slice",
			fns:  []func(*SimpleValueRegistry) error{WithRejectedSimpleValue(21)},
			data: []byte{0x81, 0xf5},
			into: reflect.TypeFor[[]bool](),
			want: []bool(nil),
			wantErrorMsg: UnacceptableDataItemError{
				CBORType: "primitives",
				Message:  "simple value 21 is not recognized",
			}.Error(),
		},
		{
			name: "default unrecognized into uint64",
			fns:  nil,
			data: []byte{0xf8, 0xc8},
			into: typeUint64,
			want: uint64(200),
		},
	} {
		t.Run(tc.name, func(t *testing.T) {
			r, err := NewSimpleValueRegistryFromDefaults(tc.fns...)
			checkNoError(t, "NewSimpleValueRegistryFromDefaults", err)

			dm := mustDecMode(t, DecOptions{SimpleValues: r})

			dst := reflect.New(tc.into)
			err = unmarshalWithDM(t, dm, tc.data, dst.Interface())
			if tc.wantErrorMsg != "" {
				checkUnmarshalErr[*UnacceptableDataItemError](t, "dm.Unmarshal", dst.Elem().Interface(), err, tc.want, tc.wantErrorMsg)
			} else {
				checkUnmarshal(t, "dm.Unmarshal", dst.Elem().Interface(), err, tc.want)
			}
		})
	}
}

func TestNaNDecMode(t *testing.T) {
	for _, tc := range []struct {
		opt    NaNMode
		src    []byte
		dst    any
		reject bool
	}{
		{
			opt:    NaNDecodeForbidden,
			src:    mustHexDecode("197e00"),
			dst:    new(any),
			reject: false,
		},
		{
			opt:    NaNDecodeForbidden,
			src:    mustHexDecode("1a7fc00000"),
			dst:    new(any),
			reject: false,
		},
		{
			opt:    NaNDecodeForbidden,
			src:    mustHexDecode("1b7ff8000000000000"),
			dst:    new(any),
			reject: false,
		},
		{
			opt:    NaNDecodeForbidden,
			src:    mustHexDecode("f90000"), // 0.0
			dst:    new(any),
			reject: false,
		},
		{
			opt:    NaNDecodeForbidden,
			src:    mustHexDecode("f90000"), // 0.0
			dst:    new(float32),
			reject: false,
		},
		{
			opt:    NaNDecodeForbidden,
			src:    mustHexDecode("f90000"), // 0.0
			dst:    new(float64),
			reject: false,
		},
		{
			opt:    NaNDecodeForbidden,
			src:    mustHexDecode("f90000"), // 0.0
			dst:    new(time.Time),
			reject: false,
		},
		{
			opt:    NaNDecodeForbidden,
			src:    mustHexDecode("fa47c35000"), // 100000.0
			dst:    new(any),
			reject: false,
		},
		{
			opt:    NaNDecodeForbidden,
			src:    mustHexDecode("fa47c35000"), // 100000.0
			dst:    new(float32),
			reject: false,
		},
		{
			opt:    NaNDecodeForbidden,
			src:    mustHexDecode("fa47c35000"), // 100000.0
			dst:    new(float64),
			reject: false,
		},
		{
			opt:    NaNDecodeForbidden,
			src:    mustHexDecode("fa47c35000"), // 100000.0
			dst:    new(time.Time),
			reject: false,
		},
		{
			opt:    NaNDecodeForbidden,
			src:    mustHexDecode("fb3ff199999999999a"), // 1.1
			dst:    new(any),
			reject: false,
		},
		{
			opt:    NaNDecodeForbidden,
			src:    mustHexDecode("fb3ff199999999999a"), // 1.1
			dst:    new(float32),
			reject: false,
		},
		{
			opt:    NaNDecodeForbidden,
			src:    mustHexDecode("fb3ff199999999999a"), // 1.1
			dst:    new(float64),
			reject: false,
		},
		{
			opt:    NaNDecodeForbidden,
			src:    mustHexDecode("fb3ff199999999999a"), // 1.1
			dst:    new(time.Time),
			reject: false,
		},
		{
			opt:    NaNDecodeForbidden,
			src:    mustHexDecode("f97e00"),
			dst:    new(any),
			reject: true,
		},
		{
			opt:    NaNDecodeForbidden,
			src:    mustHexDecode("f97e00"),
			dst:    new(float32),
			reject: true,
		},
		{
			opt:    NaNDecodeForbidden,
			src:    mustHexDecode("f97e00"),
			dst:    new(float64),
			reject: true,
		},
		{
			opt:    NaNDecodeForbidden,
			src:    mustHexDecode("f97e00"),
			dst:    new(time.Time),
			reject: true,
		},
		{
			opt:    NaNDecodeForbidden,
			src:    mustHexDecode("fa7fc00000"),
			dst:    new(any),
			reject: true,
		},
		{
			opt:    NaNDecodeForbidden,
			src:    mustHexDecode("fa7fc00000"),
			dst:    new(float32),
			reject: true,
		},
		{
			opt:    NaNDecodeForbidden,
			src:    mustHexDecode("fa7fc00000"),
			dst:    new(float64),
			reject: true,
		},
		{
			opt:    NaNDecodeForbidden,
			src:    mustHexDecode("fa7fc00000"),
			dst:    new(time.Time),
			reject: true,
		},
		{
			opt:    NaNDecodeForbidden,
			src:    mustHexDecode("fb7ff8000000000000"),
			dst:    new(any),
			reject: true,
		},
		{
			opt:    NaNDecodeForbidden,
			src:    mustHexDecode("fb7ff8000000000000"),
			dst:    new(float32),
			reject: true,
		},
		{
			opt:    NaNDecodeForbidden,
			src:    mustHexDecode("fb7ff8000000000000"),
			dst:    new(float64),
			reject: true,
		},
		{
			opt:    NaNDecodeForbidden,
			src:    mustHexDecode("fb7ff8000000000000"),
			dst:    new(time.Time),
			reject: true,
		},
	} {
		t.Run(fmt.Sprintf("mode=%d/0x%x into %s", tc.opt, tc.src, reflect.TypeOf(tc.dst).String()), func(t *testing.T) {
			dm := mustDecMode(t, DecOptions{NaN: tc.opt})
			want := &UnacceptableDataItemError{
				CBORType: cborTypePrimitives.String(),
				Message:  "floating-point NaN",
			}
			err := unmarshalWithDM(t, dm, tc.src, tc.dst)
			checkErrorCase[*UnacceptableDataItemError](t, "dm.Unmarshal", err, tc.reject, want.Error())
		})
	}
}

func TestInfDecMode(t *testing.T) {
	for _, tc := range []struct {
		opt    InfMode
		src    []byte
		dst    any
		reject bool
	}{
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("197c00"),
			dst:    new(any),
			reject: false,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("1a7f800000"), // Infinity
			dst:    new(any),
			reject: false,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("1b7ff0000000000000"), // Infinity
			dst:    new(any),
			reject: false,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("f90000"), // 0.0
			dst:    new(any),
			reject: false,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("f90000"), // 0.0
			dst:    new(float32),
			reject: false,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("f90000"), // 0.0
			dst:    new(float64),
			reject: false,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("f90000"), // 0.0
			dst:    new(time.Time),
			reject: false,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("fa47c35000"), // 100000.0
			dst:    new(any),
			reject: false,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("fa47c35000"), // 100000.0
			dst:    new(float32),
			reject: false,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("fa47c35000"), // 100000.0
			dst:    new(float64),
			reject: false,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("fa47c35000"), // 100000.0
			dst:    new(time.Time),
			reject: false,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("fb3ff199999999999a"), // 1.1
			dst:    new(any),
			reject: false,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("fb3ff199999999999a"), // 1.1
			dst:    new(float32),
			reject: false,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("fb3ff199999999999a"), // 1.1
			dst:    new(float64),
			reject: false,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("fb3ff199999999999a"), // 1.1
			dst:    new(time.Time),
			reject: false,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("f97c00"), // Infinity
			dst:    new(any),
			reject: true,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("f97c00"), // Infinity
			dst:    new(float32),
			reject: true,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("f97c00"), // Infinity
			dst:    new(float64),
			reject: true,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("f97c00"), // Infinity
			dst:    new(time.Time),
			reject: true,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("f9fc00"), // -Infinity
			dst:    new(any),
			reject: true,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("f9fc00"), // -Infinity
			dst:    new(float32),
			reject: true,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("f9fc00"), // -Infinity
			dst:    new(float64),
			reject: true,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("f9fc00"), // -Infinity
			dst:    new(time.Time),
			reject: true,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("fa7f800000"), // Infinity
			dst:    new(any),
			reject: true,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("fa7f800000"), // Infinity
			dst:    new(float32),
			reject: true,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("fa7f800000"), // Infinity
			dst:    new(float64),
			reject: true,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("fa7f800000"), // Infinity
			dst:    new(time.Time),
			reject: true,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("faff800000"), // -Infinity
			dst:    new(any),
			reject: true,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("faff800000"), // -Infinity
			dst:    new(float32),
			reject: true,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("faff800000"), // -Infinity
			dst:    new(float64),
			reject: true,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("faff800000"), // -Infinity
			dst:    new(time.Time),
			reject: true,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("fb7ff0000000000000"), // Infinity
			dst:    new(any),
			reject: true,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("fb7ff0000000000000"), // Infinity
			dst:    new(float32),
			reject: true,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("fb7ff0000000000000"), // Infinity
			dst:    new(float64),
			reject: true,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("fb7ff0000000000000"), // Infinity
			dst:    new(time.Time),
			reject: true,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("fbfff0000000000000"), // -Infinity
			dst:    new(any),
			reject: true,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("fbfff0000000000000"), // -Infinity
			dst:    new(float32),
			reject: true,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("fbfff0000000000000"), // -Infinity
			dst:    new(float64),
			reject: true,
		},
		{
			opt:    InfDecodeForbidden,
			src:    mustHexDecode("fbfff0000000000000"), // -Infinity
			dst:    new(time.Time),
			reject: true,
		},
	} {
		t.Run(fmt.Sprintf("mode=%d/0x%x into %s", tc.opt, tc.src, tc.dst), func(t *testing.T) {
			dm := mustDecMode(t, DecOptions{Inf: tc.opt})
			want := &UnacceptableDataItemError{
				CBORType: cborTypePrimitives.String(),
				Message:  "floating-point infinity",
			}
			err := unmarshalWithDM(t, dm, tc.src, tc.dst)
			checkErrorCase[*UnacceptableDataItemError](t, "dm.Unmarshal", err, tc.reject, want.Error())
		})
	}
}

func TestUnmarshalByteStringTextConversionError(t *testing.T) {
	for _, tc := range []struct {
		name         string
		opts         DecOptions
		dstType      reflect.Type
		data         []byte
		wantErrorMsg string
	}{
		{
			name:         "reject untagged byte string containing invalid base64url",
			opts:         DecOptions{ByteStringExpectedFormat: ByteStringExpectedBase64URL},
			dstType:      reflect.TypeFor[[]byte](),
			data:         []byte{0x41, 0x00},
			wantErrorMsg: "cbor: failed to decode base64url from byte string: illegal base64 data at input byte 0",
		},
		{
			name:         "reject untagged byte string containing invalid base64url",
			opts:         DecOptions{ByteStringExpectedFormat: ByteStringExpectedBase64},
			dstType:      reflect.TypeFor[[]byte](),
			data:         []byte{0x41, 0x00},
			wantErrorMsg: "cbor: failed to decode base64 from byte string: illegal base64 data at input byte 0",
		},
		{
			name:         "reject untagged byte string containing invalid base16",
			opts:         DecOptions{ByteStringExpectedFormat: ByteStringExpectedBase16},
			dstType:      reflect.TypeFor[[]byte](),
			data:         []byte{0x41, 0x00},
			wantErrorMsg: "cbor: failed to decode hex from byte string: encoding/hex: invalid byte: U+0000",
		},
		{
			name:         "accept tagged byte string containing invalid base64url",
			opts:         DecOptions{ByteStringExpectedFormat: ByteStringExpectedBase64URL},
			dstType:      reflect.TypeFor[[]byte](),
			data:         []byte{0xd5, 0x41, 0x00},
			wantErrorMsg: "",
		},
		{
			name:         "accept tagged byte string containing invalid base64url",
			opts:         DecOptions{ByteStringExpectedFormat: ByteStringExpectedBase64},
			dstType:      reflect.TypeFor[[]byte](),
			data:         []byte{0xd5, 0x41, 0x00},
			wantErrorMsg: "",
		},
		{
			name:         "accept tagged byte string containing invalid base16",
			opts:         DecOptions{ByteStringExpectedFormat: ByteStringExpectedBase16},
			dstType:      reflect.TypeFor[[]byte](),
			data:         []byte{0xd5, 0x41, 0x00},
			wantErrorMsg: "",
		},
	} {
		t.Run(tc.name, func(t *testing.T) {
			dm := mustDecMode(t, tc.opts)
			err := unmarshalWithDM(t, dm, tc.data, reflect.New(tc.dstType).Interface())
			checkErrorCase[error](t, "dm.Unmarshal", err, tc.wantErrorMsg != "", tc.wantErrorMsg)
		})
	}
}

func TestUnmarshalByteStringTextConversion(t *testing.T) {
	for _, tc := range []struct {
		name    string
		opts    DecOptions
		dstType reflect.Type
		data    []byte
		want    any
	}{
		{
			name: "untagged into string",
			opts: DecOptions{
				ByteStringToString: ByteStringToStringAllowedWithExpectedLaterEncoding,
			},
			dstType: reflect.TypeFor[string](),
			data:    []byte{0x41, 0xff}, // h'ff'
			want:    "\xff",
		},
		{
			name: "tagged base64url into string",
			opts: DecOptions{
				ByteStringToString: ByteStringToStringAllowedWithExpectedLaterEncoding,
			},
			dstType: reflect.TypeFor[string](),
			data:    []byte{0xd5, 0x41, 0xff}, // 21(h'ff')
			want:    "_w",
		},
		{
			name: "indirectly tagged base64url into string",
			opts: DecOptions{
				ByteStringToString: ByteStringToStringAllowedWithExpectedLaterEncoding,
			},
			dstType: reflect.TypeFor[string](),
			data:    []byte{0xd5, 0xd9, 0xd9, 0xf7, 0x41, 0xff}, // 21(55799(h'ff'))
			want:    "_w",
		},
		{
			name: "tagged base64url into string tags ignored",
			opts: DecOptions{
				ByteStringToString: ByteStringToStringAllowed,
			},
			dstType: reflect.TypeFor[string](),
			data:    []byte{0xd5, 0x41, 0xff}, // 21(h'ff')
			want:    "\xff",
		},
		{
			name: "tagged into []byte with default encoding base64url",
			opts: DecOptions{
				ByteStringExpectedFormat: ByteStringExpectedBase64URL,
			},
			dstType: reflect.TypeFor[[]byte](),
			data:    []byte{0xd5, 0x41, 0xff}, // 21(h'ff')
			want:    []byte{0xff},
		},
		{
			name: "indirectly tagged into []byte with default encoding base64url",
			opts: DecOptions{
				ByteStringExpectedFormat: ByteStringExpectedBase64URL,
			},
			dstType: reflect.TypeFor[[]byte](),
			data:    []byte{0xd5, 0xd9, 0xd9, 0xf7, 0x41, 0xff}, // 21(55799(h'ff'))
			want:    []byte{0xff},
		},
		{
			name: "untagged base64url into []byte with default encoding base64url",
			opts: DecOptions{
				ByteStringExpectedFormat: ByteStringExpectedBase64URL,
			},
			dstType: reflect.TypeFor[[]byte](),
			data:    []byte{0x42, '_', 'w'}, // '_w'
			want:    []byte{0xff},
		},
		{
			name: "tagged base64 into string",
			opts: DecOptions{
				ByteStringToString: ByteStringToStringAllowedWithExpectedLaterEncoding,
			},
			dstType: reflect.TypeFor[string](),
			data:    []byte{0xd6, 0x41, 0xff}, // 22(h'ff')
			want:    "/w==",
		},
		{
			name: "indirectly tagged base64 into string",
			opts: DecOptions{
				ByteStringToString: ByteStringToStringAllowedWithExpectedLaterEncoding,
			},
			dstType: reflect.TypeFor[string](),
			data:    []byte{0xd6, 0xd9, 0xd9, 0xf7, 0x41, 0xff}, // 22(55799(h'ff'))
			want:    "/w==",
		},
		{
			name: "tagged base64 into string tags ignored",
			opts: DecOptions{
				ByteStringToString: ByteStringToStringAllowed,
			},
			dstType: reflect.TypeFor[string](),
			data:    []byte{0xd6, 0x41, 0xff}, // 22(h'ff')
			want:    "\xff",
		},
		{
			name: "tagged into []byte with default encoding base64",
			opts: DecOptions{
				ByteStringExpectedFormat: ByteStringExpectedBase64,
			},
			dstType: reflect.TypeFor[[]byte](),
			data:    []byte{0xd6, 0x41, 0xff}, // 22(h'ff')
			want:    []byte{0xff},
		},
		{
			name: "indirectly tagged into []byte with default encoding base64",
			opts: DecOptions{
				ByteStringExpectedFormat: ByteStringExpectedBase64,
			},
			dstType: reflect.TypeFor[[]byte](),
			data:    []byte{0xd6, 0xd9, 0xd9, 0xf7, 0x41, 0xff}, // 22(55799(h'ff'))
			want:    []byte{0xff},
		},
		{
			name: "untagged base64 into []byte with default encoding base64",
			opts: DecOptions{
				ByteStringExpectedFormat: ByteStringExpectedBase64,
			},
			dstType: reflect.TypeFor[[]byte](),
			data:    []byte{0x44, '/', 'w', '=', '='}, // '/w=='
			want:    []byte{0xff},
		},
		{
			name: "tagged base16 into string",
			opts: DecOptions{
				ByteStringToString: ByteStringToStringAllowedWithExpectedLaterEncoding,
			},
			dstType: reflect.TypeFor[string](),
			data:    []byte{0xd7, 0x41, 0xff}, // 23(h'ff')
			want:    "ff",
		},
		{
			name: "indirectly tagged base16 into string",
			opts: DecOptions{
				ByteStringToString: ByteStringToStringAllowedWithExpectedLaterEncoding,
			},
			dstType: reflect.TypeFor[string](),
			data:    []byte{0xd7, 0xd9, 0xd9, 0xf7, 0x41, 0xff}, // 23(55799(h'ff'))
			want:    "ff",
		},
		{
			name: "tagged base16 into string tags ignored",
			opts: DecOptions{
				ByteStringToString: ByteStringToStringAllowed,
			},
			dstType: reflect.TypeFor[string](),
			data:    []byte{0xd7, 0x41, 0xff}, // 23(h'ff')
			want:    "\xff",
		},
		{
			name: "tagged into []byte with default encoding base16",
			opts: DecOptions{
				ByteStringExpectedFormat: ByteStringExpectedBase16,
			},
			dstType: reflect.TypeFor[[]byte](),
			data:    []byte{0xd7, 0x41, 0xff}, // 23(h'ff')
			want:    []byte{0xff},
		},
		{
			name: "indirectly tagged into []byte with default encoding base16",
			opts: DecOptions{
				ByteStringExpectedFormat: ByteStringExpectedBase16,
			},
			dstType: reflect.TypeFor[[]byte](),
			data:    []byte{0xd7, 0xd9, 0xd9, 0xf7, 0x41, 0xff}, // 23(55799(h'ff'))
			want:    []byte{0xff},
		},
		{
			name: "untagged base16 into []byte with default encoding base16",
			opts: DecOptions{
				ByteStringExpectedFormat: ByteStringExpectedBase16,
			},
			dstType: reflect.TypeFor[[]byte](),
			data:    []byte{0x42, 'f', 'f'},
			want:    []byte{0xff},
		},
		{
			name: "tag 21 wrapping tag 22",
			opts: DecOptions{
				ByteStringToString: ByteStringToStringAllowedWithExpectedLaterEncoding,
			},
			dstType: reflect.TypeFor[string](),
			data:    []byte{0xd5, 0xd6, 0x42, 0x01, 0x02}, // 21(22(h'0102'))
			want:    "AQI=",                               // base64 of [0x01, 0x02] with padding
		},
		{
			name: "tag 22 wrapping tag 21",
			opts: DecOptions{
				ByteStringToString: ByteStringToStringAllowedWithExpectedLaterEncoding,
			},
			dstType: reflect.TypeFor[string](),
			data:    []byte{0xd6, 0xd5, 0x42, 0x01, 0x02}, // 22(21(h'0102'))
			want:    "AQI",                                // base64 of [0x01, 0x02] without padding
		},
	} {
		t.Run(tc.name, func(t *testing.T) {
			dm := mustDecMode(t, tc.opts)
			dstVal := reflect.New(tc.dstType)
			err := unmarshalWithDM(t, dm, tc.data, dstVal.Interface())
			checkUnmarshal(t, "dm.Unmarshal", dstVal.Elem().Interface(), err, tc.want)
		})
	}
}

type testBinaryUnmarshaler []byte

func (bu *testBinaryUnmarshaler) UnmarshalBinary(_ []byte) error {
	*bu = []byte("UnmarshalBinary")
	return nil
}

func TestBinaryUnmarshalerMode(t *testing.T) {
	for _, tc := range []struct {
		name string
		opts DecOptions
		data []byte
		want any
	}{
		{
			name: "UnmarshalBinary is called by default",
			opts: DecOptions{},
			data: []byte("\x45hello"), // 'hello'
			want: testBinaryUnmarshaler("UnmarshalBinary"),
		},
		{
			name: "UnmarshalBinary is called with BinaryUnmarshalerByteString",
			opts: DecOptions{BinaryUnmarshaler: BinaryUnmarshalerByteString},
			data: []byte("\x45hello"), // 'hello'
			want: testBinaryUnmarshaler("UnmarshalBinary"),
		},
		{
			name: "default byte slice unmarshaling behavior is used with BinaryUnmarshalerNone",
			opts: DecOptions{BinaryUnmarshaler: BinaryUnmarshalerNone},
			data: []byte("\x45hello"), // 'hello'
			want: testBinaryUnmarshaler("hello"),
		},
	} {
		t.Run(tc.name, func(t *testing.T) {
			dm := mustDecMode(t, tc.opts)
			gotrv := reflect.New(reflect.TypeOf(tc.want))
			err := unmarshalWithDM(t, dm, tc.data, gotrv.Interface())
			checkUnmarshal(t, "dm.Unmarshal", gotrv.Elem().Interface(), err, tc.want)
		})
	}
}

func TestBignumTagMode(t *testing.T) {
	for _, tc := range []struct {
		name         string
		opts         DecOptions
		input        []byte
		wantErrorMsg string // if "" then expect nil error
	}{
		{
			name:  "default options decode unsigned bignum without error",
			opts:  DecOptions{},
			input: mustHexDecode("c240"), // 2(0) i.e. unsigned bignum 0
		},
		{
			name:  "default options decode negative bignum without error",
			opts:  DecOptions{},
			input: mustHexDecode("c340"), // 3(0) i.e. negative bignum -1
		},
		{
			name:         "BignumTagForbidden returns UnacceptableDataItemError on unsigned bignum",
			opts:         DecOptions{BignumTag: BignumTagForbidden},
			input:        mustHexDecode("c240"), // 2(0) i.e. unsigned bignum 0
			wantErrorMsg: "cbor: data item of cbor type tag is not accepted by protocol: bignum",
		},
		{
			name:         "BignumTagForbidden returns UnacceptableDataItemError on negative bignum",
			opts:         DecOptions{BignumTag: BignumTagForbidden},
			input:        mustHexDecode("c340"), // 3(0) i.e. negative bignum -1
			wantErrorMsg: "cbor: data item of cbor type tag is not accepted by protocol: bignum",
		},
	} {
		t.Run(tc.name, func(t *testing.T) {
			dm := mustDecMode(t, tc.opts)
			for _, dstType := range []reflect.Type{
				typeInt64,
				typeFloat64,
				typeByteArray,
				typeByteSlice,
				typeBigInt,
				typeAny,
			} {
				t.Run(dstType.String(), func(t *testing.T) {
					dstv := reflect.New(dstType)
					err := unmarshalWithDM(t, dm, tc.input, dstv.Interface())
					checkErrorCase[error](t, "dm.Unmarshal", err, tc.wantErrorMsg != "", tc.wantErrorMsg)
				})
			}
		})
	}
}

type testTextUnmarshaler string

func (tu *testTextUnmarshaler) UnmarshalText(_ []byte) error {
	*tu = "UnmarshalText"
	return nil
}

func TestTextUnmarshalerMode(t *testing.T) {
	for _, tc := range []struct {
		name string
		opts DecOptions
		data []byte
		want any
	}{
		{
			name: "UnmarshalText is not called by default",
			opts: DecOptions{},
			data: []byte("\x65hello"), // "hello"
			want: testTextUnmarshaler("hello"),
		},
		{
			name: "UnmarshalText is called with TextUnmarshalerTextString",
			opts: DecOptions{TextUnmarshaler: TextUnmarshalerTextString},
			data: []byte("\x65hello"), // "hello"
			want: testTextUnmarshaler("UnmarshalText"),
		},
		{
			name: "default text string unmarshaling behavior is used with TextUnmarshalerNone",
			opts: DecOptions{TextUnmarshaler: TextUnmarshalerNone},
			data: []byte("\x65hello"), // "hello"
			want: testTextUnmarshaler("hello"),
		},
		{
			name: "UnmarshalText is called for byte string with TextUnmarshalerTextString and ByteStringToStringAllowed",
			opts: DecOptions{
				TextUnmarshaler:    TextUnmarshalerTextString,
				ByteStringToString: ByteStringToStringAllowed,
			},
			data: []byte("\x45hello"), // 'hello'
			want: testTextUnmarshaler("UnmarshalText"),
		},
	} {
		t.Run(tc.name, func(t *testing.T) {
			dm := mustDecMode(t, tc.opts)
			gotrv := reflect.New(reflect.TypeOf(tc.want))
			err := unmarshalWithDM(t, dm, tc.data, gotrv.Interface())
			checkUnmarshal(t, "dm.Unmarshal", gotrv.Elem().Interface(), err, tc.want)
		})
	}
}

type errorTextUnmarshaler struct{}

func (u *errorTextUnmarshaler) UnmarshalText([]byte) error {
	return errors.New("test")
}

func TestTextUnmarshalerModeError(t *testing.T) {
	dm := mustDecMode(t, DecOptions{TextUnmarshaler: TextUnmarshalerTextString})
	err := unmarshalWithDM(t, dm, []byte{0x61, 'a'}, new(errorTextUnmarshaler))
	checkError[error](t, "dm.Unmarshal", err, "cbor: cannot unmarshal text for *cbor.errorTextUnmarshaler: test")
}

func TestJSONUnmarshalerTranscoder(t *testing.T) {
	for _, tc := range []struct {
		name string
		data []byte

		transcodeInput  []byte
		transcodeOutput []byte
		transcodeError  error

		want         any
		wantErrorMsg string
	}{
		{
			name: "successful transcode",
			data: []byte{0xf5},

			transcodeInput:  []byte{0xf5},
			transcodeOutput: []byte("true"),

			want: json.RawMessage("true"),
		},
		{
			name: "transcode returns non-nil error",
			data: []byte{0xf5},

			transcodeInput: []byte{0xf5},
			transcodeError: errors.New("test"),

			want: json.RawMessage("true"),
			wantErrorMsg: TranscodeError{
				err:          errors.New("test"),
				rtype:        reflect.TypeFor[*json.RawMessage](),
				sourceFormat: "cbor",
				targetFormat: "json",
			}.Error(),
		},
	} {
		t.Run(tc.name, func(t *testing.T) {
			dm := mustDecMode(t, DecOptions{
				JSONUnmarshalerTranscoder: transcodeFunc(func(w io.Writer, r io.Reader) error {
					source, err := io.ReadAll(r)
					checkNoError(t, "io.ReadAll", err)
					if got := string(source); got != string(tc.transcodeInput) {
						t.Errorf("transcoder got input %q, want %q", got, string(tc.transcodeInput))
					}

					if tc.transcodeError != nil {
						return tc.transcodeError
					}

					_, err = w.Write(tc.transcodeOutput)
					return err

				}),
			})

			gotrv := reflect.New(reflect.TypeOf(tc.want))
			err := unmarshalWithDM(t, dm, tc.data, gotrv.Interface())
			checkUnmarshalCase[error](t, "dm.Unmarshal", gotrv.Elem().Interface(), err, tc.want, tc.wantErrorMsg != "", tc.wantErrorMsg)
		})
	}
}

// TestKeyAsIntTextKeyDoesNotMatchKeyAsIntField verifies that a CBOR text string
// key does not match a struct field with the keyasint tag option, even if the
// text content is the string representation of the integer key.
func TestKeyAsIntTextKeyDoesNotMatchKeyAsIntField(t *testing.T) {
	type s struct {
		ID int `cbor:"1,keyasint"`
	}

	testCases := []struct {
		name         string
		opts         DecOptions
		data         []byte
		want         any
		wantErrorMsg string
	}{
		{
			name: "default options",
			opts: defaultDecMode.DecOptions(),
			data: mustHexDecode("a1613101"), // {"1": 1}
			want: s{},
		},
		{
			name:         "unknown field error options",
			opts:         DecOptions{ExtraReturnErrors: ExtraDecErrorUnknownField},
			data:         mustHexDecode("a1613101"), // {"1": 1}
			want:         s{},
			wantErrorMsg: (&UnknownFieldError{Index: 0}).Error(),
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			dm := mustDecMode(t, tc.opts)
			var v s
			err := unmarshalWithDM(t, dm, tc.data, &v)
			if tc.wantErrorMsg != "" {
				checkUnmarshalErr[*UnknownFieldError](t, "dm.Unmarshal", v, err, tc.want, tc.wantErrorMsg)
			} else {
				checkUnmarshal(t, "dm.Unmarshal", v, err, tc.want)
			}
		})
	}
}

// TestKeyAsIntNormalizedDuplicateFields verifies that struct fields with
// keyasint tag values that are identical after integer normalization (e.g., "01"
// and "1") are eliminated during field deduplication, matching the behavior of
// two string-keyed fields with the same name.
func TestKeyAsIntNormalizedDuplicateFields(t *testing.T) {
	type s struct {
		ID  int `cbor:"01,keyasint"`
		ID2 int `cbor:"1,keyasint"`
		ID3 int `cbor:"+1,keyasint"`
	}

	testCases := []struct {
		name         string
		opts         DecOptions
		data         []byte
		want         any
		wantErrorMsg string
	}{
		{
			name: "default options",
			opts: defaultDecMode.DecOptions(),
			data: mustHexDecode("a10101"), // {1: 1}
			want: s{},
		},
		{
			name:         "unknown field error options",
			opts:         DecOptions{ExtraReturnErrors: ExtraDecErrorUnknownField},
			data:         mustHexDecode("a10101"), // {1: 1}
			want:         s{},
			wantErrorMsg: (&UnknownFieldError{Index: 0}).Error(),
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			dm := mustDecMode(t, tc.opts)
			var v s
			err := unmarshalWithDM(t, dm, tc.data, &v)
			if tc.wantErrorMsg != "" {
				checkUnmarshalErr[*UnknownFieldError](t, "dm.Unmarshal", v, err, tc.want, tc.wantErrorMsg)
			} else {
				checkUnmarshal(t, "dm.Unmarshal", v, err, tc.want)
			}
		})
	}

	v := s{ID: 1, ID2: 2, ID3: 3}
	want := mustHexDecode("a0")

	b, err := Marshal(v)
	checkMarshal(t, "Marshal", b, err, want)
}

// TestKeyAsIntAndStringFieldsWithSameName verifies that a struct with both a
// keyasint field and a string-keyed field with the same tag name (e.g.
// cbor:"1,keyasint" and cbor:"1") can decode CBOR maps with integer and text
// keys independently.
func TestKeyAsIntAndStringFieldsWithSameName(t *testing.T) {
	type s struct {
		ID        int `cbor:"1,keyasint"`
		AnotherID int `cbor:"1"`
	}

	data := mustHexDecode("a20101613102") // {1: 1, "1": 2}
	want := s{
		ID:        1,
		AnotherID: 2,
	}

	var v s
	err := unmarshal(t, data, &v)
	checkUnmarshal(t, "Unmarshal", v, err, want)

	// Roundtrip
	b, err := Marshal(want)
	checkMarshal(t, "Marshal", b, err, data)
}

func TestKeyAsIntAndStringFieldsWithSameNameAndEmbeddedField(t *testing.T) {
	type inner struct {
		A int `cbor:"1,keyasint"`
	}
	type s struct {
		ID        int `cbor:"1,keyasint"`
		AnotherID int `cbor:"1"`
		inner
	}

	data := mustHexDecode("a20101613102") // {1: 1, "1": 2}
	want := s{
		ID:        1,
		AnotherID: 2,
	}

	var v s
	err := unmarshal(t, data, &v)
	checkUnmarshal(t, "Unmarshal", v, err, want)

	// Roundtrip
	b, err := Marshal(want)
	checkMarshal(t, "Marshal", b, err, data)
}

// TestMapKeyOverflowStructKeyAsInt verifies that a CBOR integer map
// key that is outside the range of math.MinInt64 and math.MaxInt64
// is rejected with an UnmarshalTypeError.
func TestMapKeyOverflowStructKeyAsInt(t *testing.T) {
	type s struct {
		ID int `cbor:"-1,keyasint"`
	}

	testCases := []struct {
		name         string
		data         []byte
		wantErrorMsg string
	}{
		{
			name: "map key < math.MinInt64",
			data: mustHexDecode("a13bffffffffffffffff01"), // {-18446744073709551616: 1}
			wantErrorMsg: (&UnmarshalTypeError{
				CBORType: cborTypeNegativeInt.String(),
				GoType:   "int64",
				errorMsg: "-1-18446744073709551615 overflows Go's int64",
			}).Error(),
		},
		{
			name: "map key > math.MaxInt64",
			data: mustHexDecode("a11bffffffffffffffff01"), // {18446744073709551615: 1}
			wantErrorMsg: (&UnmarshalTypeError{
				CBORType: cborTypePositiveInt.String(),
				GoType:   "int64",
				errorMsg: "18446744073709551615 overflows Go's int64",
			}).Error(),
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			var v s
			err := unmarshal(t, tc.data, &v)
			checkError[*UnmarshalTypeError](t, "Unmarshal", err, tc.wantErrorMsg)
		})
	}
}

func TestByteStringExpectedFormatErrorUnwrap(t *testing.T) {
	innerErr := errors.New("test error")
	err := newByteStringExpectedFormatError(ByteStringExpectedBase64URL, innerErr)
	if unwrapped := err.Unwrap(); unwrapped != innerErr {
		t.Errorf("Unwrap() = %v, want %v", unwrapped, innerErr)
	}
}

func TestByteStringExpectedFormatErrorDefaultCase(t *testing.T) {
	innerErr := errors.New("test error")
	err := &ByteStringExpectedFormatError{expectedFormatOption: 99, err: innerErr}
	got := err.Error()
	want := "cbor: failed to decode byte string in expected format 99: test error"
	if got != want {
		t.Errorf("Error() = %q, want %q", got, want)
	}
}

func TestUnmarshalMapWithLargeStringKey(t *testing.T) {
	type t1 struct {
		A int `cbor:"aaaaaaaaaaaaaaaaaaaaaaa"`
		B int `cbor:"bbbbbbbbbbbbbbbbbbbbbbbb"`
	}

	key1 := "aaaaaaaaaaaaaaaaaaaaaaa"
	key2 := "bbbbbbbbbbbbbbbbbbbbbbbb"

	data := mustHexDecode("a277616161616161616161616161616161616161616161616101781862626262626262626262626262626262626262626262626202") // {"aaaaaaaaaaaaaaaaaaaaaaa": 1, "bbbbbbbbbbbbbbbbbbbbbbbb": 2}

	testCases := []struct {
		name      string
		value     any
		wantValue any
		equalFunc func(any) bool
	}{
		{
			name:  "to map with string key",
			value: map[string]int{},
			wantValue: map[string]int{
				"aaaaaaaaaaaaaaaaaaaaaaa":  1,
				"bbbbbbbbbbbbbbbbbbbbbbbb": 2,
			},
		},
		{
			name:  "to map with *string key",
			value: map[*string]int{},
			wantValue: map[*string]int{
				&key1: 1,
				&key2: 2,
			},
			equalFunc: func(v any) bool {
				m, ok := v.(map[*string]int)
				if !ok {
					return false
				}
				if len(m) != 2 {
					return false
				}
				for key, value := range m {
					if key == nil {
						return false
					}
					switch *key {
					case key1:
						if value != 1 {
							return false
						}
					case key2:
						if value != 2 {
							return false
						}
					default:
						return false
					}
				}
				return true
			},
		},
		{
			name:  "to struct",
			value: t1{},
			wantValue: t1{
				A: 1,
				B: 2,
			},
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			v := reflect.New(reflect.TypeOf(tc.value))
			v.Elem().Set(reflect.ValueOf(tc.value))

			err := unmarshal(t, data, v.Interface())
			checkUnmarshalFunc(t, "Unmarshal", v.Elem().Interface(), err, tc.wantValue, func(got, want any) bool {
				if tc.equalFunc != nil {
					return tc.equalFunc(got)
				}
				return reflect.DeepEqual(got, want)
			})
		})
	}
}

func TestNeedsHashableValueCheck(t *testing.T) {
	type intStruct struct{ X int }     // Type and value comparable
	type sliceStruct struct{ X []int } // Type and value not comparable
	type anyStruct struct{ X any }     // Type comparable, value maybe comparable

	type nestedIntStruct struct{ Y intStruct }
	type nestedSliceStruct struct{ Y sliceStruct }
	type nestedAnyStruct struct{ Y anyStruct }

	type appender interface{ append([]byte) []byte }

	testCases := []struct {
		name string
		typ  reflect.Type
		want bool
	}{
		// Built-in primitives
		{
			name: "bool",
			typ:  typeBool,
			want: false,
		},
		{
			name: "uint64",
			typ:  typeUint64,
			want: false,
		},
		{
			name: "int64",
			typ:  typeInt64,
			want: false,
		},
		{
			name: "[]byte",
			typ:  typeByteSlice,
			want: false,
		},
		{
			name: "string",
			typ:  typeString,
			want: false,
		},
		{
			name: "float64",
			typ:  typeFloat64,
			want: false,
		},
		// Interfaces
		{
			name: "any",
			typ:  typeAny,
			want: true,
		},
		{
			name: "namedAny",
			typ:  typeNamedAny,
			want: true,
		},
		{
			name: "appender",
			typ:  reflect.TypeFor[appender](),
			want: true,
		},
		// Arrays
		{
			name: "[0]int",
			typ:  reflect.TypeFor[[0]int](),
			want: false,
		},
		{
			name: "[1]int",
			typ:  reflect.TypeFor[[1]int](),
			want: false,
		},
		{
			name: "[0][]int",
			typ:  reflect.TypeFor[[0][]int](),
			want: false,
		},
		{
			name: "[1][]int",
			typ:  reflect.TypeFor[[1][]int](),
			want: false,
		},
		{
			name: "[0]any",
			typ:  reflect.TypeFor[[0]any](),
			want: true,
		},
		{
			name: "[1]any",
			typ:  reflect.TypeFor[[1]any](),
			want: true,
		},
		{
			name: "[0]namedAny",
			typ:  reflect.TypeFor[[0]namedAny](),
			want: true,
		},
		{
			name: "[1]namedAny",
			typ:  reflect.TypeFor[[1]namedAny](),
			want: true,
		},
		{
			name: "[0]appender",
			typ:  reflect.TypeFor[[0]appender](),
			want: true,
		},
		{
			name: "[1]appender",
			typ:  reflect.TypeFor[[1]appender](),
			want: true,
		},
		{
			name: "[0]intStruct",
			typ:  reflect.TypeFor[[0]intStruct](),
			want: false,
		},
		{
			name: "[1]intStruct",
			typ:  reflect.TypeFor[[1]intStruct](),
			want: false,
		},
		{
			name: "[0]sliceStruct",
			typ:  reflect.TypeFor[[0]sliceStruct](),
			want: false,
		},
		{
			name: "[1]sliceStruct",
			typ:  reflect.TypeFor[[1]sliceStruct](),
			want: false,
		},
		{
			name: "[0]anyStruct",
			typ:  reflect.TypeFor[[0]anyStruct](),
			want: true,
		},
		{
			name: "[1]anyStruct",
			typ:  reflect.TypeFor[[1]anyStruct](),
			want: true,
		},
		// Structs
		{
			name: "time",
			typ:  typeTime,
			want: false,
		},
		{
			name: "big.Int",
			typ:  typeBigInt,
			want: false,
		},
		{
			name: "Tag",
			typ:  typeTag,
			want: true,
		},
		{
			name: "intStruct",
			typ:  reflect.TypeFor[intStruct](),
			want: false,
		},
		{
			name: "sliceStruct",
			typ:  reflect.TypeFor[sliceStruct](),
			want: false,
		},
		{
			name: "anyStruct",
			typ:  reflect.TypeFor[anyStruct](),
			want: true,
		},
		{
			name: "nestedIntStruct",
			typ:  reflect.TypeFor[nestedIntStruct](),
			want: false,
		},
		{
			name: "nestedSliceStruct",
			typ:  reflect.TypeFor[nestedSliceStruct](),
			want: false,
		},
		{
			name: "nestedAnyStruct",
			typ:  reflect.TypeFor[nestedAnyStruct](),
			want: true,
		},
		// Others
		{
			name: "*any",
			typ:  reflect.TypeFor[*any](),
			want: false,
		},
		{
			name: "chan any",
			typ:  reflect.TypeFor[chan any](),
			want: false,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			if got := needsHashableValueCheck(tc.typ); got != tc.want {
				t.Errorf("needsHashableValueCheck(%s) = %t, want %t", tc.typ.String(), got, tc.want)
			}
		})
	}
}

type myArray [2]int

func (a myArray) String() string { return fmt.Sprintf("myArray %#v", [2]int(a)) }

type stringerWrapper struct {
	Value fmt.Stringer
	Msg   string
}

func TestUnmarshalToUnaddressableValue(t *testing.T) {
	testCases := []struct {
		name  string
		data  []byte
		value func() any
		want  any
	}{
		{
			name: "struct field interface value is int",
			data: []byte{0xa2, 0x65, 'V', 'a', 'l', 'u', 'e', 0x01, 0x63, 'M', 's', 'g', 0x61, 0x61}, // {"Value": 1, "Msg": "a"}
			value: func() any {
				return &stringerWrapper{Value: myInt(20)}
			},
			want: &stringerWrapper{Value: myInt(20), Msg: "a"},
		},
		{
			name: "struct field interface value is nil pointer",
			data: []byte{0xa1, 0x65, 'V', 'a', 'l', 'u', 'e', 0x01}, // {"Value": 1}
			value: func() any {
				return &stringerWrapper{Value: (*myInt)(nil)}
			},
		},
		{
			name: "interface value is nil map",
			data: []byte{0xa1, 0x61, 0x61, 0x01}, // {"a": 1}
			value: func() any {
				var v fmt.Stringer = myMap(nil)
				return &v
			},
		},
		{
			name: "interface value is empty map",
			data: []byte{0xa1, 0x61, 0x61, 0x01}, // {"a": 1}
			value: func() any {
				var v fmt.Stringer = myMap{}
				return &v
			},
		},
		{
			name: "interface value is map",
			data: []byte{0xa1, 0x61, 0x61, 0x01}, // {"a": 1}
			value: func() any {
				var v fmt.Stringer = myMap{"b": 2}
				return &v
			},
		},
		{
			name: "interface value is nil slice",
			data: []byte{0x81, 0x61, 0x61}, // ["a"]
			value: func() any {
				var v fmt.Stringer = myStringSlice(nil)
				return &v
			},
		},
		{
			name: "interface value is empty slice",
			data: []byte{0x81, 0x61, 0x61}, // ["a"]
			value: func() any {
				var v fmt.Stringer = myStringSlice{}
				return &v
			},
		},
		{
			name: "interface value is slice",
			data: []byte{0x81, 0x61, 0x61}, // ["a"]
			value: func() any {
				var v fmt.Stringer = myStringSlice{"b"}
				return &v
			},
		},
		{
			name: "interface value is array",
			data: []byte{0x81, 0x01}, // [1]
			value: func() any {
				var v fmt.Stringer = myArray{}
				return &v
			},
		},
		{
			name: "interface value is nil byte slice",
			data: []byte{0x41, 0x01}, // h'01'
			value: func() any {
				var v fmt.Stringer = myByteSlice(nil)
				return &v
			},
		},
		{
			name: "interface value is empty byte slice",
			data: []byte{0x41, 0x01}, // h'01'
			value: func() any {
				var v fmt.Stringer = myByteSlice{}
				return &v
			},
		},
		{
			name: "interface value is byte slice",
			data: []byte{0x41, 0x01}, // h'01'
			value: func() any {
				var v fmt.Stringer = myByteSlice{0x00}
				return &v
			},
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			v := tc.value()
			err := unmarshal(t, tc.data, v)
			checkUnmarshalErrFunc[*UnmarshalTypeError](t, "Unmarshal", v, err, tc.want, "", func(got, want any) bool {
				return want == nil || reflect.DeepEqual(got, want)
			})
		})
	}
}

type selfRefSlice []selfRefSlice
type selfRefSliceWithP []*selfRefSliceWithP
type selfRefMap map[string]selfRefMap
type sliceWithSelfRefMap []selfRefMap
type mapWithSelfRefSlice map[string]selfRefSlice
type mutualRefSlice []mutualRefMap
type mutualRefMap map[string]mutualRefSlice

func TestUnmarshalToSelfReferenceDataTypes(t *testing.T) {

	testCases := []struct {
		name string
		data []byte
		val  func() any
		want any
	}{
		{
			name: "self-ref slice type",
			data: []byte{0x81, 0x80},
			val: func() any {
				v := selfRefSlice{}
				return &v
			},
			want: selfRefSlice{selfRefSlice{}},
		},
		{
			name: "self-ref slice type with pointer",
			data: []byte{0x81, 0x80},
			val: func() any {
				v := selfRefSliceWithP{}
				return &v
			},
			want: selfRefSliceWithP{&selfRefSliceWithP{}},
		},
		{
			name: "slice type with self-ref map",
			data: []byte{0x81, 0xa1, 0x61, 0x61, 0xa0},
			val: func() any {
				v := sliceWithSelfRefMap{}
				return &v
			},
			want: sliceWithSelfRefMap{selfRefMap{"a": selfRefMap{}}},
		},
		{
			name: "self-ref map type",
			data: []byte{0xa1, 0x61, 0x61, 0xa0},
			val: func() any {
				v := selfRefMap{}
				return &v
			},
			want: selfRefMap{"a": selfRefMap{}},
		},
		{
			name: "map type with self-ref slice",
			data: []byte{0xa1, 0x61, 0x61, 0x81, 0x80},
			val: func() any {
				v := mapWithSelfRefSlice{}
				return &v
			},
			want: mapWithSelfRefSlice{"a": selfRefSlice{selfRefSlice{}}},
		},
		{
			name: "mutual-ref map and slice types",
			data: []byte{0xa1, 0x61, 0x61, 0x80},
			val: func() any {
				v := mutualRefMap{}
				return &v
			},
			want: mutualRefMap{"a": mutualRefSlice{}},
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			v := tc.val()
			err := Unmarshal(tc.data, v)
			checkUnmarshal(t, "Unmarshal", reflect.ValueOf(v).Elem().Interface(), err, tc.want)
		})
	}
}