hxd 0.1.3

A simple, configurable and dependency-free hexdump library
Documentation 
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use hxd::{
    options::{HexdOptions, HexdOptionsBuilder},
    IntoHexd,
};

#[allow(dead_code)]
pub struct IntRenderTestCase<T: Copy> {
    pub input: Vec<T>,
    pub output: &'static str,
    pub endianness: hxd::options::Endianness,
}

pub struct ValSequence<T: Copy> {
    pub ranges: Vec<(T, usize)>,
    pub range_index: usize,
    pub elt_index: usize,
}

impl<T: Copy> ValSequence<T> {
    #[allow(dead_code)]
    fn new(ranges: Vec<(T, usize)>) -> Self {
        Self {
            ranges,
            range_index: 0,
            elt_index: 0,
        }
    }
    #[allow(dead_code)]
    fn single(val: T, count: usize) -> Self {
        Self::new(vec![(val, count)])
    }
}

impl<T: Copy> Iterator for ValSequence<T> {
    type Item = T;
    fn next(&mut self) -> Option<Self::Item> {
        if self.range_index >= self.ranges.len() {
            return None;
        }
        let (b, len) = self.ranges[self.range_index];
        if self.elt_index >= len {
            self.range_index += 1;
            self.elt_index = 0;
            return self.next();
        }
        self.elt_index += 1;
        Some(b)
    }
    fn size_hint(&self) -> (usize, Option<usize>) {
        let sh = self.ranges.iter().map(|(_, len)| len).sum();
        (sh, Some(sh))
    }
}

#[allow(dead_code)]
pub struct RenderTestCase<T> {
    pub input: T,
    pub output: &'static str,
    pub options: HexdOptions,
}

pub struct ByteSequence {
    pub ranges: Vec<(u8, usize)>,
    pub range_index: usize,
    pub elt_index: usize,
}

impl ByteSequence {
    #[allow(dead_code)]
    pub fn new(ranges: Vec<(u8, usize)>) -> Self {
        Self {
            ranges,
            range_index: 0,
            elt_index: 0,
        }
    }
}

impl Iterator for ByteSequence {
    type Item = u8;
    fn next(&mut self) -> Option<Self::Item> {
        if self.range_index >= self.ranges.len() {
            return None;
        }
        let (b, len) = self.ranges[self.range_index];
        if self.elt_index >= len {
            self.range_index += 1;
            self.elt_index = 0;
            return self.next();
        }
        self.elt_index += 1;
        Some(b)
    }
    fn size_hint(&self) -> (usize, Option<usize>) {
        let sh = self.ranges.iter().map(|(_, len)| len).sum();
        (sh, Some(sh))
    }
}

#[allow(dead_code)]
pub fn test_byte_case(test: RenderTestCase<ByteSequence>) -> anyhow::Result<()> {
    // Given
    let RenderTestCase {
        input,
        output,
        options,
    } = test;

    // When
    let dump_lines = input.hexd().with_options(options).dump_to::<Vec<String>>();
    let dump = dump_lines.join("");

    // Then
    similar_asserts::assert_eq!(output, &dump, "hexdump output did not equal expected value");
    Ok(())
}

#[macro_export]
macro_rules! byte_tests {
    ($($name:ident: $value:expr,)*) => {
    $(
        #[test]
        fn $name() -> anyhow::Result<()> {
            crate::common::test_byte_case($value)
        }
    )*
    };
}