devela/data/codec/radix/
base.rs

Help
1// devela::data::codec::radix
2//
3//! Radix-based encodings.
4//
5// TOC
6// - Base struct
7// - type aliases
8// - encoding schemes
9// - implementations
10// - trait impls
11// - helpers
12// - tests
13//
14// TODO:
15// - url safe base64
16// - compare
17//   - https://github.com/jedisct1/rust-ct-codecs/blob/master/src/hex.rs
18//   - https://github.com/jedisct1/rust-ct-codecs/blob/master/src/base64.rs
19
20use crate::{ConstDefault, PhantomData};
21
22/// A compile-time configurable radix-based encoding scheme.
23///
24/// This struct defines the core behavior for various base encodings,
25/// including [`Base16`], [`Base32`] and [`Base64`].
26///
27/// It is configurable via const generics to support different encoding
28/// behaviors, such as lookup tables, padding, and case insensitivity.
29///
30/// # Type Parameters
31/// - `RADIX`: The numeric radix of the encoding (e.g., 16, 32, 64).
32/// - `LUT`: Whether to use a lookup table (`true`) for fast decoding
33///   or a linear search (`false`) using less memory.
34/// - `PAD`: Whether to use padding (`=`) for encoding output (used in Base32/Base64).
35/// - `CASE`: Whether decoding should be case-insensitive (e.g., `true` for Crockford Base32).
36/// - `CODE`: A marker type defining the specific encoding scheme (e.g., [`Rfc4648`], [`Crockford`]).
37#[derive(Clone, Debug, Copy)]
38pub struct Base<
39    const RADIX: usize, // The numeric radix (16, 32, 58, 64, 85)
40    const LUT: bool,    // Whether to use a lookup table for fast decoding.
41    const PAD: bool,    // Whether to use padding for encoding (Base 32/64).
42    const CASE: bool,   // Case-insensitive decoding.
43    CODE,               // Encoding scheme marker type
44> {
45    _code: PhantomData<CODE>,
46}
47
48/* type aliases */
49
50/// `Base16` standard encoding (hex), with linear search. Case-insensitive.
51///
52/// RFC 4648 describes Base16 as "the standard case-insensitive hex encoding".
53pub type Base16 = Base<16, false, false, false, Rfc4648>;
54
55/// `Base32` standard encoding, using LUT decoding. Case-sensitive.
56///
57/// RFC 4648 specifies Base32 as case-insensitive in decoding,
58/// but encoded output is uppercase.
59pub type Base32 = Base<32, true, false, false, Rfc4648>;
60
61/// `Base32` encoding with padding (`=`) enabled, using LUT decoding.
62///
63/// Padding ensures the encoded length is always a multiple of 8 characters
64pub type Base32Padded = Base<32, true, true, false, Rfc4648>;
65
66/// `Base32` `Crockford` encoding. Case-insensitive, remaps `O → 0`, `I/L → 1`.
67///
68/// This variant is human-friendly and eliminates ambiguity in certain characters.
69pub type Base32Crockford = Base<32, true, false, true, Crockford>;
70
71/// `Base32Hex` uses RFC 4648 hex-encoding (`0-9 A-V` instead of `A-Z 2-7`).
72///
73/// Encoded data maintains its sort order when compared bit-wise.
74pub type Base32Hex = Base<32, true, false, false, Rfc4648Hex>;
75
76// /// Base58 standard, with LUT decoding.
77// pub type Base58 = Base<58, true, false, false, false, Base58Std>;
78
79/// `Base64` standard encoding, using LUT decoding. Case-sensitive.
80///
81/// RFC 4648 specifies that Base64 preserves case distinctions in encoding and decoding.
82pub type Base64 = Base<64, true, false, false, Rfc4648>;
83
84/// `Base64` encoding with padding (`=`) enabled, using LUT decoding.
85///
86/// Ensures encoded output length is always a multiple of 4 characters.
87pub type Base64Padded = Base<64, true, true, false, Rfc4648>;
88
89// /// Base85 standard, with LUT decoding.
90// pub type Base85 = Base<85, true, false, false, false, Rfc4648>;
91
92/* encoding schemes */
93
94/// The `RFC 4648` standard encoding, used in [`Base16`], [`Base32`], and [`Base64`].
95#[derive(Clone, Copy)]
96pub struct Rfc4648;
97
98/// The `RFC 4648` hexadecimal-variant encoding, used in [`Base32`].
99#[derive(Clone, Copy)]
100pub struct Rfc4648Hex;
101
102/// The `Crockford` [`Base32`] encoding, case-insensitive, remaps certain characters.
103#[derive(Clone, Copy)]
104pub struct Crockford;
105
106// /// The Bitcoin [`Base58`] encoding, which removes easily confused characters (0OIl).
107// #[derive(Clone, Copy)]
108// pub struct Base58Std;
109
110// ///
111// #[derive(Clone, Copy)]
112// pub struct Ascii85;
113
114/* implementations */
115
116crate::sf! {
117    // Base16
118    impl<const LUT: bool, const PAD: bool, const CASE: bool, CODE>
119        Base<16, LUT, PAD, CASE, CODE> {
120        const ALPHABET: [u8; 16] = *b"0123456789ABCDEF";
121        const fn remap(byte: u8) -> Option<u8> { Some(byte) } }
122    impl<const PAD: bool, const CASE: bool>                  // CODE: Rfc4648
123        Base<16, false, PAD, CASE, Rfc4648> {
124        methods!(16, false, 4, Self); }                                        // LUT: false
125    impl<const PAD: bool, const CASE: bool>
126        Base<16, true, PAD, CASE, Rfc4648> {                                   // LUT: true
127        build_lut!(16, Self::remap, Self::ALPHABET);
128        methods!(16, true, 4, Self); }
129    // impl<const PAD: bool, const CASE: bool>                  // CODE: Rfc4648Hex
130    //     Base<16, false, PAD, CASE, Rfc4648Hex> { // (duplicated)
131    //     methods!(16, false, 4, Self); }                                     // LUT: false
132    // impl<const PAD: bool, const CASE: bool>
133    //     Base<16, true, PAD, CASE, Rfc4648Hex> {                             // LUT: true
134    //     build_lut!(16, Self::remap, Self::ALPHABET);
135    //     methods!(16, true, 4, Self); }
136    #[cfg(feature = "alloc")]
137    impl<const PAD: bool, const CASE: bool>
138        Base<16, false, PAD, CASE, Rfc4648> { methods!(@alloc 4, Self); }
139    #[cfg(feature = "alloc")]
140    impl<const PAD: bool, const CASE: bool>
141        Base<16, true, PAD, CASE, Rfc4648> { methods!(@alloc 4, Self); }
142
143    // # Base32
144    impl<const LUT: bool, const PAD: bool, const CASE: bool>
145        Base<32, LUT, PAD, CASE, Rfc4648> {                                    // CODE: Rfc4648
146        const ALPHABET: [u8; 32] = *b"ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";       // -------------
147        const fn remap(byte: u8) -> Option<u8> { Some(byte) } }
148    impl<const PAD: bool, const CASE: bool>
149        Base<32, false, PAD, CASE, Rfc4648> {                                  // LUT:false
150        methods!(32, false, 5, Self); }
151    impl<const PAD: bool, const CASE: bool>
152        Base<32, true, PAD, CASE, Rfc4648> {                                   // LUT:true
153        build_lut!(32, Self::remap, Self::ALPHABET);
154        methods!(32, true, 5, Self); }
155    #[cfg(feature = "alloc")]
156    impl<const PAD: bool, const CASE: bool>
157        Base<32, false, PAD, CASE, Rfc4648> { methods!(@alloc 5, Self); }
158    #[cfg(feature = "alloc")]
159    impl<const PAD: bool, const CASE: bool>
160        Base<32, true, PAD, CASE, Rfc4648> { methods!(@alloc 5, Self); }
161
162    impl<const LUT: bool, const PAD: bool, const CASE: bool>
163        Base<32, LUT, PAD, CASE, Crockford> {                                  // CODE: Crockford
164        const ALPHABET: [u8; 32] = *b"ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";       // ---------------
165        const fn remap(byte: u8) -> Option<u8> {
166            match byte { b'O' => Some(b'0'), b'I' | b'L' => Some(b'1'), _ => Some(byte) } } }
167    impl<const PAD: bool, const CASE: bool>
168        Base<32, false, PAD, CASE, Crockford> {                                // LUT:false
169        methods!(32, false, 5, Self); }
170    impl<const PAD: bool, const CASE: bool>
171        Base<32, true, PAD, CASE, Crockford> {                                 // LUT:true
172        build_lut!(32, Self::remap, Self::ALPHABET);
173        methods!(32, true, 5, Self); }
174    impl<const LUT: bool, const PAD: bool, const CASE: bool>
175        Base<32, LUT, PAD, CASE, Rfc4648Hex> {                                 // CODE: Rfc4648Hex
176        const ALPHABET: [u8; 32] = *b"0123456789ABCDEFGHIJKLMNOPQRSTUV";       // ----------------
177        const fn remap(byte: u8) -> Option<u8> { Some(byte) } }
178    impl<const PAD: bool, const CASE: bool>
179        Base<32, false, PAD, CASE, Rfc4648Hex> {                               // LUT:false
180        methods!(32, false, 5, Self); }
181    impl<const PAD: bool, const CASE: bool>
182        Base<32, true, PAD, CASE, Rfc4648Hex> {                                // LUT:true
183        build_lut!(32, Self::remap, Self::ALPHABET);
184        methods!(32, true, 5, Self); }
185
186    // // Base58
187    // #[rustfmt::skip] impl<const LUT: bool, const PAD: bool, const CASE: bool, CODE>
188    //     Base<58, LUT, PAD, CASE, CODE> {
189    //     const ALPHABET: [u8; 58] = *b"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"; }
190    // #[rustfmt::skip] impl<const LUT: bool, const PAD: bool, const CASE: bool>
191    //     Base<58, LUT, PAD, CASE, Base58> {
192    //     const fn remap(byte: u8) -> Option<u8> {
193    //         match byte { b'0' | b'O' | b'I' | b'l' => None, _ => Some(byte) } } }
194    // #[rustfmt::skip] impl<const PAD: bool, const CASE: bool>
195    //     Base<58, true, PAD, CASE, Base58> { build_lut!(58, Self::remap, Self::ALPHABET); }
196
197    // Base64
198    impl<const LUT: bool, const PAD: bool, const CASE: bool>
199        Base<64, LUT, PAD, CASE, Rfc4648> {                                    // CODE: Rfc4648
200        const ALPHABET: [u8; 64] =                                             // -------------
201            *b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
202        const fn remap(byte: u8) -> Option<u8> { Some(byte) } }
203    impl<const PAD: bool, const CASE: bool>
204        Base<64, false, PAD, CASE, Rfc4648> {                                  // LUT:false
205        methods!(64, false, 6, Self); }
206    impl<const PAD: bool, const CASE: bool>
207        Base<64, true, PAD, CASE, Rfc4648> {                                   // LUT:true
208        build_lut!(64, Self::remap, Self::ALPHABET);
209        methods!(64, true, 6, Self); }
210    #[cfg(feature = "alloc")]
211    impl<const PAD: bool, const CASE: bool>
212        Base<64, false, PAD, CASE, Rfc4648> { methods!(@alloc 6, Self); }
213    #[cfg(feature = "alloc")]
214    impl<const PAD: bool, const CASE: bool>
215        Base<64, true, PAD, CASE, Rfc4648> { methods!(@alloc 6, Self); }
216
217    // // Base85
218    // #[rustfmt::skip] impl<const LUT: bool, const PAD: bool, const CASE: bool, CODE>
219    //     Base<85, LUT, PAD, CASE, CODE> {
220    //     const ALPHABET: [u8; 85] =
221    //         *b"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!#$%&()*+-;<=>?@^_`{|}~";
222    //     const fn remap(byte: u8) -> Option<u8> { Some(byte) } }
223    // #[rustfmt::skip] impl<const PAD: bool, const CASE: bool, CODE>
224    //     Base<85, true, PAD, CASE, CODE> { build_lut!(58, Self::remap, Self::ALPHABET); }
225}
226
227/// # misc. methods
228#[rustfmt::skip]
229impl<const RADIX: usize, const LUT: bool, const PAD: bool, const CASE: bool, CODE>
230    Base<RADIX, LUT, PAD, CASE, CODE> {
231    /// Returns a new `Base` with the chosen generics.
232    pub const fn new() -> Self {
233        Self { _code: PhantomData }
234    }
235    /// Change the radix while keeping everything else the same.
236    pub const fn with_radix<const NEW_RADIX: usize>(self)
237        -> Base<NEW_RADIX, LUT, PAD, CASE, CODE> { Base { _code: PhantomData }
238    }
239    /// Toggle LUT usage while keeping everything else the same.
240    pub const fn with_lut<const NEW_LUT: bool>(self)
241        -> Base<RADIX, NEW_LUT, PAD, CASE, CODE> { Base { _code: PhantomData }
242    }
243    /// Toggle padding while keeping everything else the same.
244    pub const fn with_pad<const NEW_PAD: bool>(self)
245        -> Base<RADIX, LUT, NEW_PAD, CASE, CODE> { Base { _code: PhantomData }
246    }
247    /// Change the case sensitivity while keeping everything else the same.
248    pub const fn with_case<const NEW_CASE: bool>(self)
249        -> Base<RADIX, LUT, PAD, NEW_CASE, CODE> { Base { _code: PhantomData }
250    }
251    /// Change the encoding scheme while keeping everything else the same.
252    pub const fn with_encoding<NewCode>(self)
253        -> Base<RADIX, LUT, PAD, CASE, NewCode> { Base { _code: PhantomData }
254    }
255}
256
257/* trait impls */
258
259#[rustfmt::skip]
260impl<
261    const RADIX: usize, const LUT: bool, const PAD: bool, const CASE: bool, CODE,
262    > ConstDefault for Base<RADIX, LUT, PAD, CASE, CODE>
263{
264    const DEFAULT: Self = Self::new();
265}
266#[rustfmt::skip]
267impl<
268    const RADIX: usize, const LUT: bool, const PAD: bool, const CASE: bool, CODE,
269    > Default for Base<RADIX, LUT, PAD, CASE, CODE>
270{
271    fn default() -> Self { Self::new() }
272}
273
274/* helpers */
275
276macro_rules! build_lut {
277    ($radix:expr, $remap_fn:expr, $alphabet:expr) => {
278        const LUT_TABLE: [u8; 256] = {
279            let mut table = [255; 256]; // Default: invalid character
280            let mut i = 0;
281            while i < $radix {
282                let base_char = $alphabet[i];
283                // Apply remapping inside the LUT construction
284                if let Some(mapped) = $remap_fn(base_char) {
285                    table[mapped as usize] = i as u8;
286                }
287                // Store both uppercase and lowercase versions if CASE is true
288                table[base_char as usize] = i as u8;
289                if CASE {
290                    table[base_char.to_ascii_lowercase() as usize] = i as u8;
291                }
292                i += 1;
293            }
294            table
295        };
296    };
297}
298use build_lut;
299
300macro_rules! methods {
301    ( // LUT: True
302      $radix:expr, true, $chunk_bits:expr, $Self:ident) => {
303        const fn decode_byte(byte: u8) -> Option<u8> {
304            let decoded = $Self::LUT_TABLE[byte as usize];
305            if decoded == 255 { None } else { Some(decoded) }
306        }
307        methods![@non_alloc $radix, $chunk_bits, $Self];
308    };
309    ( // LUT: False
310      $radix:expr, false, $chunk_bits:expr, $Self:ident) => {
311        const fn decode_byte(byte: u8) -> Option<u8> {
312            let mut i = 0;
313            while i < $radix {
314                let mapped = $Self::remap($Self::ALPHABET[i]);
315                if mapped.is_none() {
316                    i += 1;
317                    continue;
318                } // Skip invalid character
319                if byte == mapped.unwrap()
320                    || (CASE && byte == mapped.unwrap().to_ascii_lowercase()) {
321                    return Some(i as u8);
322                }
323                i += 1;
324            }
325            None
326        }
327        methods![@non_alloc $radix, $chunk_bits, $Self];
328    };
329    (@non_alloc $radix:expr, $chunk_bits:expr, $Self:ident) => {
330        /// Returns the required output buffer size for encoding `input_len` bytes.
331        pub const fn encoded_len(input_len: usize) -> usize {
332            (input_len * 8).div_ceil($chunk_bits)
333        }
334        /// Returns the required output buffer size for encoding `input_len` bytes.
335        pub const fn encoded_len_padded(input_len: usize) -> usize {
336            let base_len = (input_len * 8).div_ceil($chunk_bits);
337            if PAD {
338                base_len.div_ceil(8) * 8 // Round up to nearest multiple of 8
339            } else {
340                base_len
341            }
342        }
343        /// Returns the required output buffer size for decoding `input_len` Base32 characters.
344        pub const fn decoded_len(input_len: usize) -> usize { (input_len * $chunk_bits) / 8 }
345        /// Returns the required output buffer size for decoding `input_len` Base32 characters.
346        ///
347        /// Strips the padding. Otherwise `decoded_len` will calculate for the worst case.
348        pub const fn decoded_len_stripped(input: &[u8]) -> usize {
349            let mut length = input.len();
350            while length > 0 && input[length - 1] == b'=' {
351                length -= 1;
352            }
353            (length * $chunk_bits) / 8
354        }
355
356        /* decode / encode */
357
358        /// Decodes `input` into `output`, returning the number of bytes written.
359        /// Uses a LUT when `DEC_TABLE = true`, otherwise falls back to linear search.
360        ///
361        /// Returns `None` if it finds an invalid byte.
362        /// # Panics
363        /// Panics if `output` is too small.
364        pub const fn decode_from_slice(input: &[u8], output: &mut [u8]) -> Option<usize> {
365            let (mut buffer, mut bits_left, mut index, mut i): (u32, u8, usize, usize) = (0,0,0,0);
366            while i < input.len() {
367                let byte = input[i];
368                if PAD && byte == b'=' { break; } // Ignore padding
369                let Some(value) =  $Self::decode_byte(byte) else { return None };
370                buffer = (buffer << $chunk_bits) | value as u32;
371                bits_left += $chunk_bits;
372                i += 1;
373                while bits_left >= 8 {
374                    output[index] = (buffer >> (bits_left - 8)) as u8;
375                    bits_left -= 8;
376                    index += 1;
377                }
378            }
379            Some(index)
380        }
381
382        /// Encodes `input` into `output`, returning the number of bytes written.
383        /// # Panics
384        /// Panics if `output` is too small.
385        pub const fn encode_to_slice(input: &[u8], output: &mut [u8]) -> usize {
386            let (mut buffer, mut bits_left, mut index, mut i): (u32, u8, usize, usize) = (0,0,0,0);
387            while i < input.len() {
388                buffer = (buffer << 8) | input[i] as u32;
389                bits_left += 8;
390                i += 1;
391                while bits_left >= $chunk_bits as u8 {
392                    let char_index = ((buffer >> (bits_left - $chunk_bits as u8))
393                        & ((1 << $chunk_bits) - 1)) as usize;
394                    output[index] = $Self::ALPHABET[char_index];
395                    bits_left -= $chunk_bits as u8;
396                    index += 1;
397                }
398            }
399            if bits_left > 0 {
400                let char_index = ((buffer << ($chunk_bits as u8 - bits_left))
401                    & ((1 << $chunk_bits) - 1)) as usize;
402                output[index] = $Self::ALPHABET[char_index];
403                index += 1;
404            }
405            if PAD {
406                while index % 8 != 0 {
407                    output[index] = b'=';
408                    index += 1;
409                }
410            }
411            index
412        }
413    };
414    (@alloc $chunk_bits:expr, $Self:ident) => {
415        /// Decodes `input` into a `Vec<u8>`,
416        /// returns `None` if invalid characters are found.
417        #[cfg(feature = "alloc")]
418        #[cfg_attr(feature = "nightly_doc", doc(cfg(feature = "alloc")))]
419        pub fn decode(input: &[u8]) -> Option<$crate::Vec<u8>> {
420            let mut output = $crate::Vec::with_capacity(Self::decoded_len(input.len()));
421            let (mut buffer, mut bits_left) = (0, 0);
422            for &byte in input {
423                if PAD && byte == b'=' { break; } // Ignore padding
424                let value = Self::decode_byte(byte)?;
425                buffer = (buffer << $chunk_bits) | value as u32;
426                bits_left += $chunk_bits;
427                while bits_left >= 8 {
428                    output.push((buffer >> (bits_left - 8)) as u8);
429                    bits_left -= 8;
430                }
431            }
432            Some(output)
433        }
434        /// Encodes `input` into a `String`.
435        #[cfg(feature = "alloc")]
436        #[cfg_attr(feature = "nightly_doc", doc(cfg(feature = "alloc")))]
437        pub fn encode(input: &[u8]) -> $crate::String {
438            let mut output = $crate::String::with_capacity($Self::encoded_len(input.len()));
439            let (mut buffer, mut bits_left) = (0, 0);
440            for &byte in input {
441                buffer = (buffer << 8) | byte as u32;
442                bits_left += 8;
443                while bits_left >= $chunk_bits {
444                    let index = ((buffer >> (bits_left - $chunk_bits))
445                        & ((1 << $chunk_bits) - 1)) as usize;
446                    output.push($Self::ALPHABET[index as usize] as char);
447                    bits_left -= $chunk_bits;
448                }
449            }
450            if bits_left > 0 {
451                let index = ((buffer << ($chunk_bits - bits_left))
452                    & ((1 << $chunk_bits) - 1)) as usize;
453                output.push($Self::ALPHABET[index as usize] as char);
454            }
455            if PAD {
456                while output.len() % (8 * $chunk_bits / 8) != 0 {
457                    output.push('=');
458                }
459            }
460            output
461        }
462    };
463}
464use methods;
465
466#[cfg(test)]
467mod tests_no_std {
468    use super::*;
469
470    #[test]
471    fn base_reconstructors() {
472        let base32 = Base32::new();
473        let _base64 = base32.with_radix::<64>().with_pad::<true>();
474    }
475
476    /* base-16 */
477
478    #[test]
479    fn base16_rfc4648_lut() {
480        pub type Base16 = Base<16, true, false, true, Rfc4648>; // LUT = true
481        let mut encoded_buf = [0u8; 22];
482        let encoded_len = Base16::encode_to_slice(b"hello world", &mut encoded_buf);
483        let encoded = &encoded_buf[..encoded_len];
484        assert_eq![encoded, b"68656C6C6F20776F726C64"];
485        // assert_eq![core::str::from_utf8(encoded).unwrap(), "68656C6C6F20776F726C64"];
486
487        let mut decoded_buf = [0u8; 11];
488        let decoded_len = Base16::decode_from_slice(encoded, &mut decoded_buf).unwrap();
489        let decoded = &decoded_buf[..decoded_len];
490        assert_eq![decoded, b"hello world"];
491        // assert_eq![core::str::from_utf8(decoded).unwrap(), "hello world"];
492    }
493    #[test]
494    fn base16_rfc4648_nolut() {
495        //default
496        let mut encoded_buf = [0u8; 22];
497        let encoded_len = Base16::encode_to_slice(b"hello world", &mut encoded_buf);
498        let encoded = &encoded_buf[..encoded_len];
499        assert_eq![encoded, b"68656C6C6F20776F726C64"];
500        let mut decoded_buf = [0u8; 11];
501        let decoded_len = Base16::decode_from_slice(encoded, &mut decoded_buf).unwrap();
502        let decoded = &decoded_buf[..decoded_len];
503        assert_eq![decoded, b"hello world"];
504    }
505
506    /* base-32 */
507
508    #[test]
509    fn base32_rfc4648_lut() {
510        let mut encoded_buf = [0u8; 18];
511        let encoded_len = Base32::encode_to_slice(b"hello world", &mut encoded_buf);
512        let encoded = &encoded_buf[..encoded_len];
513        assert_eq![encoded, b"NBSWY3DPEB3W64TMMQ"];
514        let mut decoded_buf = [0u8; 11];
515        let decoded_len = Base32::decode_from_slice(encoded, &mut decoded_buf).unwrap();
516        let decoded = &decoded_buf[..decoded_len];
517        assert_eq![decoded, b"hello world"];
518    }
519    #[test]
520    fn base32_rfc4648_nolut() {
521        pub type Base32 = Base<32, false, false, false, Rfc4648>;
522        let mut encoded_buf = [0u8; 18];
523        let encoded_len = Base32::encode_to_slice(b"hello world", &mut encoded_buf);
524        let encoded = &encoded_buf[..encoded_len];
525        assert_eq![encoded, b"NBSWY3DPEB3W64TMMQ"];
526        let mut decoded_buf = [0u8; 11];
527        let decoded_len = Base32::decode_from_slice(encoded, &mut decoded_buf).unwrap();
528        let decoded = &decoded_buf[..decoded_len];
529        assert_eq![decoded, b"hello world"];
530    }
531
532    #[test]
533    fn base32_rfc4648_padded() {
534        pub type Base32 = Base<32, true, true, false, Rfc4648>; // PAD = true
535        const ENC_REFERENCE: &[u8] = b"NBSWY3DPEB3W64TMMQ======";
536        const DEC_LEN_PAD: usize = Base32::decoded_len_stripped(ENC_REFERENCE);
537
538        let mut encoded_buf = [0u8; Base32::encoded_len_padded(b"hello world".len())];
539        let encoded_len = Base32::encode_to_slice(b"hello world", &mut encoded_buf);
540        let encoded = &encoded_buf[..encoded_len];
541        assert_eq![encoded, ENC_REFERENCE];
542
543        let mut decoded_buf = [0u8; DEC_LEN_PAD];
544        let decoded_len = Base32::decode_from_slice(encoded, &mut decoded_buf).unwrap();
545        let decoded = &decoded_buf[..decoded_len];
546        assert_eq![decoded, b"hello world"];
547    }
548
549    #[test]
550    fn base32_rfc4648_case_sensitive() {
551        pub type Base32 = Base<32, true, false, false, Rfc4648>; // CASE = false
552        let encoded_lower = b"nbswy3dpeb3w64tmmq"; // Lowercase should fail
553        let mut decoded_buf = [0u8; 11];
554        let decoded_len = Base32::decode_from_slice(encoded_lower, &mut decoded_buf);
555        assert_eq![decoded_len, None]; // Decoding should fail
556
557        let encoded_lower = b"NBSWY3DPEB3W64TMMQ"; // Uppercase should succeed
558        let mut decoded_buf = [0u8; 11];
559        let decoded_len = Base32::decode_from_slice(encoded_lower, &mut decoded_buf);
560        assert_eq![decoded_len, Some(11)];
561        let decoded = &decoded_buf[..decoded_len.unwrap()];
562        assert_eq![decoded, b"hello world"];
563    }
564    #[test]
565    fn base32_crockford_case_insensitive() {
566        pub type Base32 = Base<32, true, false, true, Crockford>; // CASE = true
567        let encoded = b"NBSWY3DPEB3W64TMMQ"; // Uppercase encoding
568        let mut decoded_buf = [0u8; 11];
569        let decoded_len = Base32::decode_from_slice(encoded, &mut decoded_buf).unwrap();
570        let decoded = &decoded_buf[..decoded_len];
571        assert_eq![decoded, b"hello world"];
572
573        let encoded_lower = b"nbswy3dpeb3w64tmmq"; // Lowercase encoding (should decode the same)
574        let decoded_len = Base32::decode_from_slice(encoded_lower, &mut decoded_buf).unwrap();
575        let decoded = &decoded_buf[..decoded_len];
576        assert_eq![decoded, b"hello world"];
577    }
578
579    #[test]
580    fn base32hex_rfc4648() {
581        pub type Base32H = Base<32, true, false, false, Rfc4648Hex>;
582        let mut encoded_buf = [0u8; 18];
583        let encoded_len = Base32H::encode_to_slice(b"hello world", &mut encoded_buf);
584        let encoded = &encoded_buf[..encoded_len];
585        assert_eq![encoded, b"D1IMOR3F41RMUSJCCG"];
586        let mut decoded_buf = [0u8; 11];
587        let decoded_len = Base32H::decode_from_slice(encoded, &mut decoded_buf).unwrap();
588        let decoded = &decoded_buf[..decoded_len];
589        assert_eq![decoded, b"hello world"];
590    }
591
592    /* base-64 */
593
594    #[test]
595    fn base64_rfc4648_lut() {
596        let mut encoded_buf = [0u8; 18];
597        let encoded_len = Base64::encode_to_slice(b"hello world", &mut encoded_buf);
598        let encoded = &encoded_buf[..encoded_len];
599        assert_eq![encoded, b"aGVsbG8gd29ybGQ"];
600        let mut decoded_buf = [0u8; 11];
601        let decoded_len = Base64::decode_from_slice(encoded, &mut decoded_buf).unwrap();
602        let decoded = &decoded_buf[..decoded_len];
603        assert_eq![decoded, b"hello world"];
604        // assert_eq![core::str::from_utf8(decoded).unwrap(), "hello world"];
605    }
606    #[test]
607    fn base64_rfc4648_nolut() {
608        pub type Base64 = Base<64, false, false, false, Rfc4648>;
609        let mut encoded_buf = [0u8; 18];
610        let encoded_len = Base64::encode_to_slice(b"hello world", &mut encoded_buf);
611        let encoded = &encoded_buf[..encoded_len];
612        assert_eq![encoded, b"aGVsbG8gd29ybGQ"];
613        let mut decoded_buf = [0u8; 11];
614        let decoded_len = Base64::decode_from_slice(encoded, &mut decoded_buf).unwrap();
615        let decoded = &decoded_buf[..decoded_len];
616        assert_eq![decoded, b"hello world"];
617    }
618
619    #[test]
620    fn base64_rfc4648_padded() {
621        pub type Base64 = Base<64, true, true, false, Rfc4648>; // PAD = true
622        const ENC_REFERENCE: &[u8] = b"aGVsbG8gd29ybGQ=";
623        const DEC_LEN_PAD: usize = Base64::decoded_len_stripped(ENC_REFERENCE);
624
625        let mut encoded_buf = [0u8; Base64::encoded_len_padded(b"hello world".len())];
626        let encoded_len = Base64::encode_to_slice(b"hello world", &mut encoded_buf);
627        let encoded = &encoded_buf[..encoded_len];
628        assert_eq![encoded, ENC_REFERENCE];
629
630        let mut decoded_buf = [0u8; DEC_LEN_PAD];
631        let decoded_len = Base64::decode_from_slice(encoded, &mut decoded_buf).unwrap();
632        let decoded = &decoded_buf[..decoded_len];
633        assert_eq![decoded, b"hello world"];
634    }
635}
636
637#[cfg(test)]
638#[cfg(feature = "alloc")]
639mod tests_alloc {
640    use super::*;
641    #[test]
642    fn base32_rfc4648_lut() {
643        let encoded = Base32::encode(b"hello world");
644        assert_eq![encoded.as_bytes(), b"NBSWY3DPEB3W64TMMQ"];
645        let decoded = Base32::decode(encoded.as_bytes()).unwrap();
646        assert_eq![&decoded, b"hello world"];
647    }
648    #[test]
649    fn base32_rfc4648_nolut() {
650        pub type Base32 = Base<32, false, false, false, Rfc4648>;
651        let encoded = Base32::encode(b"hello world");
652        assert_eq![encoded.as_bytes(), b"NBSWY3DPEB3W64TMMQ"];
653        let decoded = Base32::decode(encoded.as_bytes()).unwrap();
654        assert_eq![&decoded, b"hello world"];
655    }
656}
devela/data/codec/radix/base.rs

devela/data/codec/radix/
base.rs
