cesr-rs 0.6.0

CESR + KERI primitives for Rust as a single feature-gated, no_std-capable crate
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142

#[cfg(feature = "alloc")]
#[allow(
    unused_imports,
    reason = "alloc prelude items; subset used per cfg/feature combination"
)]
use alloc::{format, string::ToString, vec, vec::Vec};
use thiserror::Error as ThisError;

/// Errors from CESR Base64 encode/decode operations.
#[derive(Debug, ThisError, PartialEq, Eq)]
pub enum Error {
    /// The decoded Base64 value exceeds the target integer type's maximum.
    #[error(
        "Integer Overflow: The decoded Base64 value exceeds the maximum size for the target integer type."
    )]
    IntegerOverflow,
    /// A character was encountered that is not in the URL-safe Base64 alphabet.
    #[error(
        "Invalid Base64 Character: Encountered '{0}', which is not part of the URL-safe Base64 character set."
    )]
    InvalidBase64Char(char),
    /// A numeric Base64 value (0–63) was out of bounds.
    #[error(
        "Invalid Base64 Value: The value {0} is out of bounds for the Base64 character set (0-63)."
    )]
    InvalidBase64Value(u8),

    /// The input stream ended before enough bytes were available.
    #[error(
        "Short Binary Stream: More bytes were expected to complete the parsing operation, but the stream ended."
    )]
    ShortBinaryStream,
}

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

    // --- Display formatting ---

    #[test]
    fn integer_overflow_display() {
        let err = Error::IntegerOverflow;
        let msg = err.to_string();
        assert!(
            msg.contains("Integer Overflow"),
            "expected 'Integer Overflow' in: {msg}"
        );
    }

    #[test]
    fn invalid_base64_char_display_contains_char() {
        let err = Error::InvalidBase64Char('+');
        let msg = err.to_string();
        assert!(msg.contains('+'), "expected '+' in: {msg}");
    }

    #[test]
    fn invalid_base64_char_display_contains_label() {
        let err = Error::InvalidBase64Char('!');
        let msg = err.to_string();
        assert!(
            msg.contains("Invalid Base64 Character"),
            "expected 'Invalid Base64 Character' in: {msg}"
        );
    }

    #[test]
    fn invalid_base64_value_display_contains_value() {
        let err = Error::InvalidBase64Value(65);
        let msg = err.to_string();
        assert!(msg.contains("65"), "expected '65' in: {msg}");
    }

    #[test]
    fn invalid_base64_value_display_contains_label() {
        let err = Error::InvalidBase64Value(99);
        let msg = err.to_string();
        assert!(
            msg.contains("Invalid Base64 Value"),
            "expected 'Invalid Base64 Value' in: {msg}"
        );
    }

    #[test]
    fn short_binary_stream_display() {
        let err = Error::ShortBinaryStream;
        let msg = err.to_string();
        assert!(
            msg.contains("Short Binary Stream"),
            "expected 'Short Binary Stream' in: {msg}"
        );
    }

    // --- PartialEq / Eq ---

    #[test]
    fn same_variants_are_equal() {
        assert_eq!(Error::IntegerOverflow, Error::IntegerOverflow);
        assert_eq!(Error::ShortBinaryStream, Error::ShortBinaryStream);
        assert_eq!(Error::InvalidBase64Char('x'), Error::InvalidBase64Char('x'));
        assert_eq!(Error::InvalidBase64Value(10), Error::InvalidBase64Value(10));
    }

    #[test]
    fn different_payloads_are_not_equal() {
        assert_ne!(Error::InvalidBase64Char('x'), Error::InvalidBase64Char('y'));
        assert_ne!(Error::InvalidBase64Value(10), Error::InvalidBase64Value(11));
    }

    #[test]
    fn different_variants_are_not_equal() {
        assert_ne!(Error::IntegerOverflow, Error::ShortBinaryStream);
    }

    // --- Debug ---

    #[test]
    fn error_debug_contains_variant_name() {
        let cases: Vec<(&str, Error)> = vec![
            ("IntegerOverflow", Error::IntegerOverflow),
            ("InvalidBase64Char", Error::InvalidBase64Char('!')),
            ("InvalidBase64Value", Error::InvalidBase64Value(99)),
            ("ShortBinaryStream", Error::ShortBinaryStream),
        ];
        for (expected_name, err) in cases {
            let debug = format!("{err:?}");
            assert!(
                debug.contains(expected_name),
                "expected '{expected_name}' in debug output: {debug}"
            );
        }
    }

    // --- core::error::Error trait ---

    #[test]
    fn error_implements_std_error() {
        fn assert_std_error<T: core::error::Error>() {}
        assert_std_error::<Error>();
    }
}