Misunderstanding Enum `id_pat` and `id` ?

[redeexpressos]

use deku::prelude::*;

use crate::common::U8B;

#[derive(Debug, PartialEq, DekuRead, DekuWrite)]
#[deku(id_type = "u8", bits = 4, endian = "big")]
pub enum MyEnum {
    #[deku(id = 0)]
    A,

    #[deku(id = 1)]
    B,

    #[deku(id = 2)]
    C,

    /// [3..254] - Reserved
    #[deku(id_pat = "_")]
    Reserved(U8B),
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_read() {
        let tests = vec![
            (0b0000_0000, MyEnum::A),
            (0b0001_0000, MyEnum::B),
            (0b0010_0000, MyEnum::C),
            (0b1000_0000, MyEnum::Reserved(1)),
            (0b1000_0000, MyEnum::Reserved(8)),
            (0b1111_0000, MyEnum::Reserved(15)),
        ];

        for (byte_val, expected_t) in tests {
            let data: Vec<u8> = vec![byte_val];
            let (_rest, t) = MyEnum::from_bytes((data.as_ref(), 0)).unwrap();
            assert_eq!(t, expected_t);
        }
    }

    #[test]
    fn test_write() {
        let tests = vec![
            (MyEnum::A, 0b0000_0000),
            (MyEnum::B, 0b0001_0000),
            (MyEnum::C, 0b0010_0000),
            (MyEnum::Reserved(9), 0b1001_0000),
            (MyEnum::Reserved(15), 0b1111_0000),
        ];

        for (t, expected_byte_val) in tests {
            let data_out = t.to_bytes().unwrap();
            assert_eq!(data_out, vec![expected_byte_val],);
        }
    }

    fn test_round_trip() {
        let tests = vec![
            MyEnum::A,
            MyEnum::B,
            MyEnum::C,
            MyEnum::Reserved(8),
            MyEnum::Reserved(1),
        ];

        for t in tests {
            let bytes = t.to_bytes().unwrap();
            let (_rest, decoded_t) = MyEnum::from_bytes((bytes.as_ref(), 0)).unwrap();
            assert_eq!(t, decoded_t);
        }
    }
}

The tests are failing. Am I doing something wrong?

thread 'common::test::tests::test_read' panicked at src/common/test.rs:40:13:
assertion `left == right` failed
  left: Reserved(8)
 right: Reserved(1)

[redeexpressos]

Is it because it will interpret the internal value of Reserved? (so Reserved(0) will be A.

[sharksforarms]

Enums work by reading a given identifier (id) and matching it to an enum variant. It generates a match statement under the hood.

Here, you're specifying id_type = u8 and bits = 4. So, it'll read 4 bits (MSB by default) and match it against a variant (where specified with id = 0, 1, 2. We also have a id_pat = _, so let's say the value is 1000 -> 8, that will match _ since there's nothing explicitly matching 8. So, the value itself will be stored in the first field of the enum (deku does this, as it needs to know what to write! vs in the id= case, we know ahead of time.)

You can run cargo expand and see the codegen for this:

        let __deku_variant_id = <u8>::from_reader_with_ctx(
            __deku_reader,
            (::deku::ctx::Endian::Big, ::deku::ctx::BitSize(4)),
        )?;
        let __deku_value = match &__deku_variant_id {
            0 => Self::A,
            1 => Self::B,
            2 => Self::C,
            _ => {
                let __deku___field_0 = {
                    let __deku_value = __deku_variant_id;
                    let __deku_value: u8 =
                        core::result::Result::<_, ::deku::DekuError>::Ok(__deku_value)?;
                    __deku_value
                };
                let field_0 = &__deku___field_0;
                Self::Reserved(__deku___field_0)
            }
        };