breakmancer 0.4.0

#![cfg(test)]

/// Convert bytes to an ASCII string with hex escapes where needed.
///
/// The output is maximally readable for debugging.
///
/// This interprets the input as a sequence of bytes that are either
/// printable ASCII chars (excluding control characters, including
/// newline) or bytes that need to be printed in \xAB format.
pub(crate) fn partial_hexlify(data: &[u8]) -> String {
    data.iter()
        .map(|b| {
            if let 0x20..=0x7E = b {
                char::from(*b).to_string()
            } else {
                format!("\\x{b:02X}")
            }
        })
        .collect()
}

/// Create a mapping of enum variants to expressions, for use in unit tests.
///
/// Input is an enum type along with triples of variant, variant
/// constructor, and expression. All variants of the enum must be
/// listed exactly once, and only tuple-like variants are supported.
///
/// Example:
///
/// ```
/// #[derive(Debug)]
/// enum SomeEnum {
///     A(u8),
///     C(u8, u8),
/// }
///
/// pub fn example() {
///     let by_variant = all_variant_mapping!(
///         SomeEnum => &str:
///         SomeEnum::A = (5) => "a5",
///         SomeEnum::C = (6, 7) => "c67",
///     );
///
///     println!("{:?}", by_variant); // prints [(A(5), "a5"), (C(6, 7), "c67")]
/// }
/// ```
macro_rules! all_variant_mapping {
    (
        $enum_type:path => $expr_type:ty :
        $(
            $variant:path
                = ( $( $constructor:expr ),* )
                => $value:expr,
        )*
    ) => {
        {
            // This function is never called; its only purpose is to
            // hold a match expression that will in turn ensure
            // exhaustiveness over the enum.
            fn _ensure_exhaustive(example: $enum_type) {
                match example {
                    $( $variant (..) => (), )*
                }
            }

            let kvs: Vec<($enum_type, $expr_type)> = vec![
                $( ($variant ( $( $constructor ),* ), $value) ),*
            ];

            kvs
        }
    };
}

pub(crate) use all_variant_mapping;

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

    #[test]
    fn hexlify() {
        assert_eq!(
            partial_hexlify(&[0x00, 0x19, 0x20, 0x38, 0x41, 0x61, 0x7E, 0x7F, 0x80, 0xFF]),
            r"\x00\x19 8Aa~\x7F\x80\xFF"
        );
    }
}