// RFC 8949 Appendix A conformance tests. Each entry is taken verbatim
// from the published `cbor/test-vectors` list. Roundtrip-true entries
// are exercised in both directions (encode-and-compare-bytes plus
// decode-and-compare-value); roundtrip-false entries are decode-only,
// which matches the test-vector flag.
//
// Hex bytes are kept as string literals so the diffs against the RFC
// are obvious when reading the file.
module main

import encoding.cbor
import encoding.hex
import math

fn h(s string) []u8 {
    return hex.decode(s) or { panic('invalid hex: ${s}') }
}

fn bytes_eq(a []u8, b []u8) bool {
    if a.len != b.len {
        return false
    }
    for i in 0 .. a.len {
        if a[i] != b[i] {
            return false
        }
    }
    return true
}

fn assert_encode_uint(v u64, hex_expected string) {
    got := cbor.encode[u64](v, cbor.EncodeOpts{}) or { panic(err) }
    expected := h(hex_expected)
    if !bytes_eq(got, expected) {
        panic('encode u64 ${v}: got ${hex.encode(got)}, want ${hex_expected}')
    }
}

fn assert_encode_int(v i64, hex_expected string) {
    got := cbor.encode[i64](v, cbor.EncodeOpts{}) or { panic(err) }
    expected := h(hex_expected)
    if !bytes_eq(got, expected) {
        panic('encode i64 ${v}: got ${hex.encode(got)}, want ${hex_expected}')
    }
}

// ---------------------------------------------------------------------
// Unsigned integers (major type 0)
// ---------------------------------------------------------------------

fn test_unsigned_zero() {
    assert_encode_uint(0, '00')
}

fn test_unsigned_small() {
    assert_encode_uint(1, '01')
    assert_encode_uint(10, '0a')
    assert_encode_uint(23, '17')
}

fn test_unsigned_one_byte() {
    assert_encode_uint(24, '1818')
    assert_encode_uint(25, '1819')
    assert_encode_uint(100, '1864')
    assert_encode_uint(0xff, '18ff')
}

fn test_unsigned_two_bytes() {
    assert_encode_uint(1000, '1903e8')
    assert_encode_uint(0xffff, '19ffff')
}

fn test_unsigned_four_bytes() {
    assert_encode_uint(1_000_000, '1a000f4240')
    assert_encode_uint(0xffffffff, '1affffffff')
}

fn test_unsigned_eight_bytes() {
    assert_encode_uint(1_000_000_000_000, '1b000000e8d4a51000')
    assert_encode_uint(u64(0xffffffffffffffff), '1bffffffffffffffff')
}

// ---------------------------------------------------------------------
// Negative integers (major type 1)
// ---------------------------------------------------------------------

fn test_negative_small() {
    assert_encode_int(-1, '20')
    assert_encode_int(-10, '29')
}

fn test_negative_one_byte() {
    assert_encode_int(-100, '3863')
}

fn test_negative_two_bytes() {
    assert_encode_int(-1000, '3903e7')
}

fn test_negative_extreme() {
    // -2^63 still fits i64.
    assert_encode_int(-9_223_372_036_854_775_808, '3b7fffffffffffffff')
}

fn test_negative_lower_bound_via_packer() {
    // -2^64 (lower bound of CBOR negative ints) requires the full u64
    // argument and can't be represented as an i64.
    mut p := cbor.new_packer(cbor.EncodeOpts{})
    p.pack_negative_arg(u64(0xffffffffffffffff))
    assert bytes_eq(p.bytes(), h('3bffffffffffffffff'))
}

// ---------------------------------------------------------------------
// Floats — preferred serialisation (RFC 8949 §4.2.2)
// ---------------------------------------------------------------------

fn assert_encode_float(v f64, hex_expected string) {
    got := cbor.encode[f64](v, cbor.EncodeOpts{}) or { panic(err) }
    expected := h(hex_expected)
    if !bytes_eq(got, expected) {
        panic('encode f64 ${v}: got ${hex.encode(got)}, want ${hex_expected}')
    }
}

fn test_float_zero() {
    assert_encode_float(0.0, 'f90000')
    // -0.0 — distinct bit pattern from +0.0.
    neg_zero := math.f64_from_bits(u64(0x8000000000000000))
    assert_encode_float(neg_zero, 'f98000')
}

fn test_float_simple_values() {
    assert_encode_float(1.0, 'f93c00')
    assert_encode_float(1.5, 'f93e00')
    assert_encode_float(65504.0, 'f97bff')
    assert_encode_float(-4.0, 'f9c400')
}

fn test_float_subnormal_half() {
    // 2^-24 — smallest positive half subnormal (preserved exactly in f32/f64).
    assert_encode_float(5.960464477539063e-08, 'f90001')
    // 2^-14 — smallest positive normal half.
    assert_encode_float(6.103515625e-05, 'f90400')
}

fn test_float_single() {
    assert_encode_float(100000.0, 'fa47c35000')
    assert_encode_float(3.4028234663852886e+38, 'fa7f7fffff')
}

fn test_float_double() {
    assert_encode_float(1.1, 'fb3ff199999999999a')
    assert_encode_float(1.0e+300, 'fb7e37e43c8800759c')
    assert_encode_float(-4.1, 'fbc010666666666666')
}

fn test_float_special_values() {
    assert_encode_float(math.inf(1), 'f97c00')
    assert_encode_float(math.inf(-1), 'f9fc00')
    // NaN — encoder collapses to the canonical quiet NaN.
    got := cbor.encode[f64](math.nan(), cbor.EncodeOpts{}) or { panic(err) }
    assert bytes_eq(got, h('f97e00')), 'NaN encoded as ${hex.encode(got)}, want f97e00'
}

// ---------------------------------------------------------------------
// Booleans, null, undefined
// ---------------------------------------------------------------------

fn test_bool_false() {
    got := cbor.encode[bool](false, cbor.EncodeOpts{}) or { panic(err) }
    assert bytes_eq(got, [u8(0xf4)])
}

fn test_bool_true() {
    got := cbor.encode[bool](true, cbor.EncodeOpts{}) or { panic(err) }
    assert bytes_eq(got, [u8(0xf5)])
}

fn test_null_via_packer() {
    mut p := cbor.new_packer(cbor.EncodeOpts{})
    p.pack_null()
    assert bytes_eq(p.bytes(), [u8(0xf6)])
}

fn test_undefined_via_packer() {
    mut p := cbor.new_packer(cbor.EncodeOpts{})
    p.pack_undefined()
    assert bytes_eq(p.bytes(), [u8(0xf7)])
}

fn test_simple_values() {
    mut p := cbor.new_packer(cbor.EncodeOpts{})
    p.pack_simple(16) or { panic(err) }
    assert bytes_eq(p.bytes(), h('f0'))

    mut p3 := cbor.new_packer(cbor.EncodeOpts{})
    p3.pack_simple(255) or { panic(err) }
    assert bytes_eq(p3.bytes(), h('f8ff'))
}

// RFC 8949 §3.3: encoder MUST NOT issue two-byte sequences starting
// with 0xf8 and continuing with a byte < 0x20. We refuse to emit such a
// value, and the decoder rejects them on input.
fn test_simple_values_rfc8949_strictness() {
    // Encoding side: pack_simple(24..31) returns an error.
    mut p := cbor.new_packer(cbor.EncodeOpts{})
    if _ := p.pack_simple(24) {
        assert false, 'expected pack_simple(24) to fail'
    }
    if _ := p.pack_simple(31) {
        assert false, 'expected pack_simple(31) to fail'
    }
    // Decoder side: f818 (simple(24) two-byte form) is malformed.
    cbor.decode[cbor.Value](h('f818'), cbor.DecodeOpts{}) or {
        assert err.msg().contains('1-byte form'), 'unexpected: ${err.msg()}'
        return
    }
    assert false, 'expected decoder to reject simple(24) two-byte form'
}

// ---------------------------------------------------------------------
// Byte and text strings
// ---------------------------------------------------------------------

fn test_empty_byte_string() {
    got := cbor.encode[[]u8]([]u8{}, cbor.EncodeOpts{}) or { panic(err) }
    assert bytes_eq(got, h('40'))
}

fn test_byte_string_4() {
    got := cbor.encode[[]u8]([u8(0x01), 0x02, 0x03, 0x04], cbor.EncodeOpts{}) or { panic(err) }
    assert bytes_eq(got, h('4401020304'))
}

fn test_empty_text_string() {
    got := cbor.encode[string]('', cbor.EncodeOpts{}) or { panic(err) }
    assert bytes_eq(got, h('60'))
}

fn test_text_a() {
    got := cbor.encode[string]('a', cbor.EncodeOpts{}) or { panic(err) }
    assert bytes_eq(got, h('6161'))
}

fn test_text_ietf() {
    got := cbor.encode[string]('IETF', cbor.EncodeOpts{}) or { panic(err) }
    assert bytes_eq(got, h('6449455446'))
}

fn test_text_escaped() {
    got := cbor.encode[string]('"\\', cbor.EncodeOpts{}) or { panic(err) }
    assert bytes_eq(got, h('62225c'))
}

fn test_text_utf8_2byte() {
    got := cbor.encode[string]('ü', cbor.EncodeOpts{}) or { panic(err) }
    assert bytes_eq(got, h('62c3bc'))
}

fn test_text_utf8_3byte() {
    got := cbor.encode[string]('水', cbor.EncodeOpts{}) or { panic(err) }
    assert bytes_eq(got, h('63e6b0b4'))
}

fn test_text_utf8_4byte() {
    got := cbor.encode[string]('𐅑', cbor.EncodeOpts{}) or { panic(err) }
    assert bytes_eq(got, h('64f0908591'))
}

// ---------------------------------------------------------------------
// Arrays
// ---------------------------------------------------------------------

fn test_empty_array() {
    got := cbor.encode[[]int]([]int{}, cbor.EncodeOpts{}) or { panic(err) }
    assert bytes_eq(got, h('80'))
}

fn test_array_3() {
    got := cbor.encode[[]int]([1, 2, 3], cbor.EncodeOpts{}) or { panic(err) }
    assert bytes_eq(got, h('83010203'))
}

fn test_array_nested_via_value() {
    v := cbor.Value(cbor.Array{
        elements: [
            cbor.Value(cbor.new_uint(1)),
            cbor.Value(cbor.Array{
                elements: [cbor.Value(cbor.new_uint(2)), cbor.Value(cbor.new_uint(3))]
            }),
            cbor.Value(cbor.Array{
                elements: [cbor.Value(cbor.new_uint(4)), cbor.Value(cbor.new_uint(5))]
            }),
        ]
    })
    got := cbor.encode_value(v, cbor.EncodeOpts{})!
    assert bytes_eq(got, h('8301820203820405'))
}

fn test_array_25_items() {
    mut elements := []u64{cap: 25}
    for i in 0 .. 25 {
        elements << u64(i + 1)
    }
    got := cbor.encode[[]u64](elements, cbor.EncodeOpts{}) or { panic(err) }
    want := '98190102030405060708090a0b0c0d0e0f101112131415161718181819'
    assert bytes_eq(got, h(want))
}

// ---------------------------------------------------------------------
// Maps
// ---------------------------------------------------------------------

fn test_empty_map() {
    got := cbor.encode[map[string]int](map[string]int{}, cbor.EncodeOpts{}) or { panic(err) }
    assert bytes_eq(got, h('a0'))
}

fn test_int_key_map_via_packer() {
    mut p := cbor.new_packer(cbor.EncodeOpts{})
    p.pack_map_header(2)
    p.pack_int(1)
    p.pack_int(2)
    p.pack_int(3)
    p.pack_int(4)
    assert bytes_eq(p.bytes(), h('a201020304'))
}

fn test_string_key_map_with_array_value() {
    v := cbor.Value(cbor.Map{
        pairs: [
            cbor.MapPair{
                key:   cbor.Value(cbor.Text{
                    value: 'a'
                })
                value: cbor.Value(cbor.new_uint(1))
            },
            cbor.MapPair{
                key:   cbor.Value(cbor.Text{
                    value: 'b'
                })
                value: cbor.Value(cbor.Array{
                    elements: [cbor.Value(cbor.new_uint(2)), cbor.Value(cbor.new_uint(3))]
                })
            },
        ]
    })
    got := cbor.encode_value(v, cbor.EncodeOpts{})!
    assert bytes_eq(got, h('a26161016162820203'))
}

fn test_array_with_map_inside() {
    v := cbor.Value(cbor.Array{
        elements: [
            cbor.Value(cbor.Text{
                value: 'a'
            }),
            cbor.Value(cbor.Map{
                pairs: [
                    cbor.MapPair{
                        key:   cbor.Value(cbor.Text{
                            value: 'b'
                        })
                        value: cbor.Value(cbor.Text{
                            value: 'c'
                        })
                    },
                ]
            }),
        ]
    })
    got := cbor.encode_value(v, cbor.EncodeOpts{})!
    assert bytes_eq(got, h('826161a161626163'))
}

// ---------------------------------------------------------------------
// Tags
// ---------------------------------------------------------------------

fn test_tag_date_time() {
    mut p := cbor.new_packer(cbor.EncodeOpts{})
    p.pack_tag(0)
    p.pack_text('2013-03-21T20:04:00Z')
    assert bytes_eq(p.bytes(), h('c074323031332d30332d32315432303a30343a30305a'))
}

fn test_tag_epoch_int() {
    mut p := cbor.new_packer(cbor.EncodeOpts{})
    p.pack_tag(1)
    p.pack_int(1363896240)
    assert bytes_eq(p.bytes(), h('c11a514b67b0'))
}

fn test_tag_epoch_float() {
    mut p := cbor.new_packer(cbor.EncodeOpts{})
    p.pack_tag(1)
    p.pack_float64(1363896240.5)
    assert bytes_eq(p.bytes(), h('c1fb41d452d9ec200000'))
}

fn test_tag_uri() {
    mut p := cbor.new_packer(cbor.EncodeOpts{})
    p.pack_tag(32)
    p.pack_text('http://www.example.com')
    assert bytes_eq(p.bytes(), h('d82076687474703a2f2f7777772e6578616d706c652e636f6d'))
}

fn test_tag_unsigned_bignum() {
    // Tag 2 + 9-byte big-endian magnitude for 18446744073709551616 = 2^64.
    mut p := cbor.new_packer(cbor.EncodeOpts{})
    p.pack_tag(2)
    p.pack_bytes([u8(0x01), 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
    assert bytes_eq(p.bytes(), h('c249010000000000000000'))
}

// ---------------------------------------------------------------------
// Indefinite-length items
// ---------------------------------------------------------------------

fn test_indefinite_byte_string() {
    mut p := cbor.new_packer(cbor.EncodeOpts{})
    p.pack_bytes_indef()!
    p.pack_bytes([u8(0x01), 0x02])
    p.pack_bytes([u8(0x03), 0x04, 0x05])
    p.pack_break()!
    assert bytes_eq(p.bytes(), h('5f42010243030405ff'))
}

fn test_indefinite_text_string() {
    mut p := cbor.new_packer(cbor.EncodeOpts{})
    p.pack_text_indef()!
    p.pack_text('strea')
    p.pack_text('ming')
    p.pack_break()!
    assert bytes_eq(p.bytes(), h('7f657374726561646d696e67ff'))
}

fn test_indefinite_array() {
    mut p := cbor.new_packer(cbor.EncodeOpts{})
    p.pack_array_indef()!
    p.pack_break()!
    assert bytes_eq(p.bytes(), h('9fff'))
}

fn test_indefinite_array_with_definite_inside() {
    // [_ 1, [2, 3], [_ 4, 5]]
    mut p := cbor.new_packer(cbor.EncodeOpts{})
    p.pack_array_indef()!
    p.pack_int(1)
    p.pack_array_header(2)
    p.pack_int(2)
    p.pack_int(3)
    p.pack_array_indef()!
    p.pack_int(4)
    p.pack_int(5)
    p.pack_break()!
    p.pack_break()!
    assert bytes_eq(p.bytes(), h('9f018202039f0405ffff'))
}

fn test_indefinite_map() {
    // {_ "a": 1, "b": [_ 2, 3]}
    mut p := cbor.new_packer(cbor.EncodeOpts{})
    p.pack_map_indef()!
    p.pack_text('a')
    p.pack_int(1)
    p.pack_text('b')
    p.pack_array_indef()!
    p.pack_int(2)
    p.pack_int(3)
    p.pack_break()!
    p.pack_break()!
    assert bytes_eq(p.bytes(), h('bf61610161629f0203ffff'))
}

// ---------------------------------------------------------------------
// Decode side: every Appendix A vector decodes to the right value
// ---------------------------------------------------------------------

struct UintCase {
    hex string
    val u64
}

struct IntCase {
    hex string
    val i64
}

fn test_decode_unsigned() {
    for pair in [
        UintCase{
            hex: '00'
            val: 0
        },
        UintCase{
            hex: '17'
            val: 23
        },
        UintCase{
            hex: '1818'
            val: 24
        },
        UintCase{
            hex: '1864'
            val: 100
        },
        UintCase{
            hex: '1903e8'
            val: 1000
        },
        UintCase{
            hex: '1a000f4240'
            val: 1_000_000
        },
        UintCase{
            hex: '1b000000e8d4a51000'
            val: 1_000_000_000_000
        },
        UintCase{
            hex: '1bffffffffffffffff'
            val: u64(0xffffffffffffffff)
        },
    ] {
        v := cbor.decode[u64](h(pair.hex), cbor.DecodeOpts{}) or {
            panic('decode ${pair.hex}: ${err}')
        }
        assert v == pair.val, 'decoded ${pair.hex}: got ${v}, want ${pair.val}'
    }
}

fn test_decode_negative() {
    for pair in [
        IntCase{
            hex: '20'
            val: -1
        },
        IntCase{
            hex: '29'
            val: -10
        },
        IntCase{
            hex: '3863'
            val: -100
        },
        IntCase{
            hex: '3903e7'
            val: -1000
        },
        IntCase{
            hex: '3b7fffffffffffffff'
            val: i64(-9_223_372_036_854_775_808)
        },
    ] {
        v := cbor.decode[i64](h(pair.hex), cbor.DecodeOpts{}) or {
            panic('decode ${pair.hex}: ${err}')
        }
        assert v == pair.val, 'decoded ${pair.hex}: got ${v}, want ${pair.val}'
    }
}

fn test_decode_floats() {
    // Half precision.
    v := cbor.decode[f64](h('f93c00'), cbor.DecodeOpts{}) or { panic(err) }
    assert v == 1.0
    v2 := cbor.decode[f64](h('f93e00'), cbor.DecodeOpts{}) or { panic(err) }
    assert v2 == 1.5
    v3 := cbor.decode[f64](h('f97bff'), cbor.DecodeOpts{}) or { panic(err) }
    assert v3 == 65504.0
    // Subnormal half.
    v4 := cbor.decode[f64](h('f90001'), cbor.DecodeOpts{}) or { panic(err) }
    assert v4 == 5.960464477539063e-08, 'subnormal half: ${v4}'
    // f32 / f64.
    v5 := cbor.decode[f64](h('fa47c35000'), cbor.DecodeOpts{}) or { panic(err) }
    assert v5 == 100000.0
    v6 := cbor.decode[f64](h('fb3ff199999999999a'), cbor.DecodeOpts{}) or { panic(err) }
    assert v6 == 1.1
    // Inf / -Inf.
    v7 := cbor.decode[f64](h('f97c00'), cbor.DecodeOpts{}) or { panic(err) }
    assert math.is_inf(v7, 1)
    v8 := cbor.decode[f64](h('f9fc00'), cbor.DecodeOpts{}) or { panic(err) }
    assert math.is_inf(v8, -1)
    // NaN.
    v9 := cbor.decode[f64](h('f97e00'), cbor.DecodeOpts{}) or { panic(err) }
    assert math.is_nan(v9)
    // Alternate non-canonical encodings (roundtrip=false but must decode).
    for hex_str in ['fa7f800000', 'fb7ff0000000000000'] {
        val := cbor.decode[f64](h(hex_str), cbor.DecodeOpts{}) or { panic(err) }
        assert math.is_inf(val, 1), '${hex_str} → ${val}'
    }
    for hex_str in ['faff800000', 'fbfff0000000000000'] {
        val := cbor.decode[f64](h(hex_str), cbor.DecodeOpts{}) or { panic(err) }
        assert math.is_inf(val, -1), '${hex_str} → ${val}'
    }
    for hex_str in ['fa7fc00000', 'fb7ff8000000000000'] {
        val := cbor.decode[f64](h(hex_str), cbor.DecodeOpts{}) or { panic(err) }
        assert math.is_nan(val), '${hex_str} → ${val}'
    }
}

fn test_decode_bool_null() {
    bf := cbor.decode[bool](h('f4'), cbor.DecodeOpts{}) or { panic(err) }
    assert bf == false
    bt := cbor.decode[bool](h('f5'), cbor.DecodeOpts{}) or { panic(err) }
    assert bt == true
    v := cbor.decode[cbor.Value](h('f6'), cbor.DecodeOpts{}) or { panic(err) }
    assert v.is_nil()
    u := cbor.decode[cbor.Value](h('f7'), cbor.DecodeOpts{}) or { panic(err) }
    assert u.is_undefined()
}

fn test_decode_simple_extended() {
    // Inline form for simple(16).
    v0 := cbor.decode[cbor.Value](h('f0'), cbor.DecodeOpts{}) or { panic(err) }
    assert v0 is cbor.Simple
    if v0 is cbor.Simple {
        assert v0.value == 16
    }
    // 1-byte form for simple(32) — first valid two-byte simple value.
    mut p := cbor.new_packer(cbor.EncodeOpts{})
    p.pack_simple(32) or { panic(err) }
    v32 := cbor.decode[cbor.Value](p.bytes(), cbor.DecodeOpts{}) or { panic(err) }
    assert v32 is cbor.Simple
    if v32 is cbor.Simple {
        assert v32.value == 32
    }
    // Top of the range.
    v2 := cbor.decode[cbor.Value](h('f8ff'), cbor.DecodeOpts{}) or { panic(err) }
    if v2 is cbor.Simple {
        assert v2.value == 255
    }
}

fn test_decode_strings() {
    a := cbor.decode[string](h('60'), cbor.DecodeOpts{}) or { panic(err) }
    assert a == ''
    b := cbor.decode[string](h('6161'), cbor.DecodeOpts{}) or { panic(err) }
    assert b == 'a'
    c := cbor.decode[string](h('6449455446'), cbor.DecodeOpts{}) or { panic(err) }
    assert c == 'IETF'
    d := cbor.decode[string](h('62c3bc'), cbor.DecodeOpts{}) or { panic(err) }
    assert d == 'ü'
    e := cbor.decode[string](h('63e6b0b4'), cbor.DecodeOpts{}) or { panic(err) }
    assert e == '水'
    f := cbor.decode[string](h('64f0908591'), cbor.DecodeOpts{}) or { panic(err) }
    assert f == '𐅑'
}

fn test_decode_array() {
    v := cbor.decode[[]int](h('83010203'), cbor.DecodeOpts{}) or { panic(err) }
    assert v == [1, 2, 3]
}

fn test_decode_map() {
    v := cbor.decode[map[string]int](h('a26161016162820203'), cbor.DecodeOpts{}) or {
        // This vector has b → [2,3], not int — so this decode should fail.
        assert err.msg().contains('mismatch') || err.msg().contains('overflow')
        return
    }
    _ = v
    assert false, 'expected type mismatch on map[string]int decode of array value'
}

fn test_decode_indefinite_text() {
    // "stream"+"ing"
    v := cbor.decode[string](h('7f657374726561646d696e67ff'), cbor.DecodeOpts{}) or { panic(err) }
    assert v == 'streaming'
}

fn test_decode_indefinite_array() {
    v := cbor.decode[[]int](h('9fff'), cbor.DecodeOpts{}) or { panic(err) }
    assert v == []int{}
    v2 := cbor.decode[[]int](h('9f0102030405060708090a0b0c0d0e0f101112131415161718181819ff'), cbor.DecodeOpts{}) or {
        panic(err)
    }
    mut want := []int{cap: 25}
    for i in 0 .. 25 {
        want << i + 1
    }
    assert v2 == want
}

fn test_decode_indefinite_bytes() {
    v := cbor.decode[[]u8](h('5f42010243030405ff'), cbor.DecodeOpts{}) or { panic(err) }
    assert bytes_eq(v, [u8(0x01), 0x02, 0x03, 0x04, 0x05])
}

// ---------------------------------------------------------------------
// Round-trip for every roundtrip=true vector via the Value tree
// ---------------------------------------------------------------------

const roundtrip_vectors = [
    '00',
    '01',
    '0a',
    '17',
    '1818',
    '1819',
    '1864',
    '1903e8',
    '1a000f4240',
    '1b000000e8d4a51000',
    '1bffffffffffffffff',
    '3bffffffffffffffff',
    '20',
    '29',
    '3863',
    '3903e7',
    'f90000',
    'f98000',
    'f93c00',
    'fb3ff199999999999a',
    'f93e00',
    'f97bff',
    'fa47c35000',
    'fa7f7fffff',
    'fb7e37e43c8800759c',
    'f90001',
    'f90400',
    'f9c400',
    'fbc010666666666666',
    'f97c00',
    'f97e00',
    'f9fc00',
    'f4',
    'f5',
    'f6',
    'f7',
    'f0',
    'f8ff',
    '40',
    '4401020304',
    '60',
    '6161',
    '6449455446',
    '62225c',
    '62c3bc',
    '63e6b0b4',
    '64f0908591',
    '80',
    '83010203',
    '8301820203820405',
    '98190102030405060708090a0b0c0d0e0f101112131415161718181819',
    'a0',
    'a201020304',
    'a26161016162820203',
    '826161a161626163',
    'a56161614161626142616361436164614461656145',
]

fn test_value_roundtrip_all_canonical_vectors() {
    for hex_str in roundtrip_vectors {
        input := h(hex_str)
        decoded := cbor.decode[cbor.Value](input, cbor.DecodeOpts{}) or {
            panic('decode ${hex_str}: ${err}')
        }
        got := cbor.encode_value(decoded, cbor.EncodeOpts{})!
        assert bytes_eq(got, input), 'roundtrip ${hex_str}: got ${hex.encode(got)}'
    }
}

// Tag-bearing vectors round-trip via the Value tree as well.
fn test_value_roundtrip_tag_vectors() {
    for hex_str in [
        'c074323031332d30332d32315432303a30343a30305a',
        'c11a514b67b0',
        'c1fb41d452d9ec200000',
        'd74401020304',
        'd818456449455446',
        'd82076687474703a2f2f7777772e6578616d706c652e636f6d',
        'c249010000000000000000',
        'c349010000000000000000',
    ] {
        input := h(hex_str)
        decoded := cbor.decode[cbor.Value](input, cbor.DecodeOpts{}) or {
            panic('decode ${hex_str}: ${err}')
        }
        got := cbor.encode_value(decoded, cbor.EncodeOpts{})!
        assert bytes_eq(got, input), 'tag roundtrip ${hex_str}: got ${hex.encode(got)}'
    }
}