Function assert_encode

libs/@local/harpc/wire-protocol/src/codec/encode.rs:116–166

(value: &T, expected: Expect)

    #[track_caller]
    #[expect(clippy::needless_pass_by_value)]
    pub(crate) fn assert_encode<T>(value: &T, expected: Expect)
    where
        T: Encode + Sync,
    {
        let buffer = encode_value(value);

        // every line has 16 bytes, each byte at most is represented by 5 characters. With an
        // additional newline.
        let lines = buffer.len().div_ceil(16);
        let capacity = (lines * (16 * 5)) + lines;

        let mut output = String::with_capacity(capacity);

        // first section into lines (of size 16)
        let chunks = buffer.chunks(16);

        for chunk in chunks {
            for (index, &byte) in chunk.iter().enumerate() {
                if index > 0 {
                    output.push(' ');
                }

                if byte.is_ascii_graphic() || byte.is_ascii_whitespace() {
                    // at most is 4 characters, align to the right
                    let escaped = byte.escape_ascii();
                    // we never generate \xNN and never an empty string
                    assert!(escaped.len() <= 2 && escaped.len() > 0);

                    let padding = 2 - escaped.len();

                    match padding {
                        0 => {}
                        1 => output.push('b'),
                        _ => unreachable!(),
                    }

                    output.push('\'');
                    for char in escaped {
                        output.push(char as char);
                    }
                    output.push('\'');
                } else {
                    write!(output, "{byte:#04X}").expect("infallible");
                }
            }

            output.push('\n');
        }

        expected.assert_eq(&output);
    }

    #[track_caller]
    pub(crate) fn assert_encode_error<T>(value: &T, expected: &T::Error)