base64id 0.4.1

Efficiently represent 64, 32 and 16 bit integers as base64url strings
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

macro_rules! generate_derive_test_suite {
    ($test_suite:ident, $struct_type:ident, $int_type:ident, $int_value:literal, $int_type_alt:ident, $int_value_alt:literal, $struct_str:expr) => {
        #[cfg(test)]
        mod $test_suite {
            use base64id::{Base64Id, Error};
            use core::str::FromStr;

            #[derive(Base64Id, Debug)]
            #[base64id(Serialize, Deserialize)]
            struct $struct_type($int_type);

            #[test]
            fn str_from_struct() {
                let id = $struct_type(0);
                assert_eq!($struct_str, format!("{id}"));
            }

            #[test]
            fn struct_from_str() {
                let _id = $struct_type::from_str($struct_str)
                    .expect("failed to convert str to struct via FromStr trait");
            }

            #[test]
            fn int_from_struct() {
                let int = $int_type::from($struct_type($int_value));
                assert_eq!(int, $int_value);
            }

            #[test]
            fn struct_from_int() {
                let id = $struct_type::from($int_value);
                assert!(matches!(id, $struct_type($int_value)));
            }

            #[test]
            fn int_from_struct_u() {
                let int_u = $int_type_alt::from($struct_type($int_value));
                assert_eq!(int_u, $int_value_alt);
            }

            #[test]
            fn struct_from_int_u() {
                let id = $struct_type::from($int_value_alt);
                assert!(matches!(id, $struct_type($int_value)));
            }

            #[test]
            fn min_const() {
                assert_eq!(
                    $int_type::from($struct_type::MIN).to_be_bytes(),
                    $int_type_alt::from($struct_type::MIN).to_be_bytes()
                );
            }

            #[test]
            fn max_const() {
                assert_eq!(
                    $int_type::from($struct_type::MAX).to_be_bytes(),
                    $int_type_alt::from($struct_type::MAX).to_be_bytes()
                );
            }

            #[test]
            fn partial_eq() {
                assert_eq!($struct_type($int_value), $struct_type($int_value));
            }

            #[test]
            fn min_max_ord() {
                assert!($struct_type::MIN < $struct_type::MAX);
            }

            #[test]
            fn error_bad_char() {
                let err = $struct_type::from_str("A").expect_err("failed to get an error");
                assert_eq!(Error::InvalidLength, err);
            }

            #[test]
            fn serde_serialize() {
                let id = $struct_type($int_value);
                let serialized_id = serde_json::to_string(&id).expect("failed to serialize value");

                assert_eq!(serialized_id, format!("\"{}\"", $struct_str));
            }

            #[test]
            fn serde_deserialize() {
                let string = $struct_str;
                let id = serde_json::from_str(format!("\"{string}\"").as_str())
                    .expect("failed to deserialize value");

                assert_eq!($struct_type($int_value), id);
            }

            /// Ensure deserialize impl works without use of external FromStr import
            mod can_deserialize_without_use_from_str {
                use base64id::Base64Id;

                #[derive(Base64Id)]
                #[base64id(Deserialize)]
                struct $struct_type($int_type);
            }
        }
    };
}

generate_derive_test_suite!(derive_64_i, MyIdi64, i64, 0i64, u64, 0u64, "AAAAAAAAAAA");
generate_derive_test_suite!(derive_64_u, MyIdu64, u64, 0u64, i64, 0i64, "AAAAAAAAAAA");

generate_derive_test_suite!(derive_32_i, MyIdi32, i32, 0i32, u32, 0u32, "AAAAAA");
generate_derive_test_suite!(derive_32_u, MyIdu32, u32, 0u32, i32, 0i32, "AAAAAA");

generate_derive_test_suite!(derive_16_i, MyIdi16, i16, 0i16, u16, 0u16, "AAA");
generate_derive_test_suite!(derive_16_u, MyIdu16, u16, 0u16, i16, 0i16, "AAA");