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

use super::*;

/// Error when not enough space is available in a slice
/// to write a packet or header to it.
#[derive(Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct SliceWriteSpaceError {
    /// Expected minimum length conflicting with the
    /// `actual_len` value.
    pub required_len: usize,

    /// Length limiting or exceeding the required length.
    pub len: usize,

    /// Layer in which could not be written to the slice.
    pub layer: Layer,
}

impl core::fmt::Display for SliceWriteSpaceError {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(
            f,
            "Not enough space to write {} to slice. Needed {} byte(s), but only {} byte(s) were available.",
            self.layer,
            self.required_len,
            self.len,
        )
    }
}

impl std::error::Error for SliceWriteSpaceError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        None
    }
}

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

    #[test]
    fn debug_write() {
        let _ = format!(
            "{:?}",
            SliceWriteSpaceError {
                required_len: 1,
                len: 0,
                layer: Layer::SomeipTpHeader
            }
        );
    }

    #[test]
    fn clone_eq_hash_ord() {
        use core::cmp::Ordering;
        use std::collections::hash_map::DefaultHasher;
        use std::hash::{Hash, Hasher};

        let err = SliceWriteSpaceError {
            required_len: 1,
            len: 0,
            layer: Layer::SomeipTpHeader,
        };
        assert_eq!(err, err.clone());
        let hash_a = {
            let mut hasher = DefaultHasher::new();
            err.hash(&mut hasher);
            hasher.finish()
        };
        let hash_b = {
            let mut hasher = DefaultHasher::new();
            err.clone().hash(&mut hasher);
            hasher.finish()
        };
        assert_eq!(hash_a, hash_b);
        assert_eq!(Ordering::Equal, err.cmp(&err));
        assert_eq!(Some(Ordering::Equal), err.partial_cmp(&err));
    }

    #[test]
    fn fmt() {
        assert_eq!(
            format!("{}", SliceWriteSpaceError{ required_len: 4, len: 1, layer: Layer::SomeipTpHeader }),
            "Not enough space to write SOMEIP TP header to slice. Needed 4 byte(s), but only 1 byte(s) were available."
        );
    }

    #[test]
    fn source() {
        use std::error::Error;
        assert!(SliceWriteSpaceError {
            required_len: 4,
            len: 1,
            layer: Layer::SomeipTpHeader
        }
        .source()
        .is_none());
    }
}