devela 0.27.0

A development layer of coherence.
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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167

// devela::data::codec::radix::tests

use super::*;

#[test]
fn base_reconstructors() {
    let base32 = Base32::new();
    let _base64 = base32.with_radix::<64>().with_pad::<true>();
}

/* base-16 */

#[test]
fn base16_rfc4648_lut() {
    pub type Base16 = Base<16, true, false, true, Rfc4648>; // LUT = true
    let mut encoded_buf = [0u8; 22];
    let encoded_len = Base16::encode_to_slice(b"hello world", &mut encoded_buf);
    let encoded = &encoded_buf[..encoded_len];
    assert_eq![encoded, b"68656C6C6F20776F726C64"];

    let mut decoded_buf = [0u8; 11];
    let decoded_len = Base16::decode_from_slice(encoded, &mut decoded_buf).unwrap();
    let decoded = &decoded_buf[..decoded_len];
    assert_eq![decoded, b"hello world"];
}
#[test]
fn base16_rfc4648_nolut() {
    //default
    let mut encoded_buf = [0u8; 22];
    let encoded_len = Base16::encode_to_slice(b"hello world", &mut encoded_buf);
    let encoded = &encoded_buf[..encoded_len];
    assert_eq![encoded, b"68656C6C6F20776F726C64"];
    let mut decoded_buf = [0u8; 11];
    let decoded_len = Base16::decode_from_slice(encoded, &mut decoded_buf).unwrap();
    let decoded = &decoded_buf[..decoded_len];
    assert_eq![decoded, b"hello world"];
}

/* base-32 */

#[test]
fn base32_rfc4648_lut() {
    let mut encoded_buf = [0u8; 18];
    let encoded_len = Base32::encode_to_slice(b"hello world", &mut encoded_buf);
    let encoded = &encoded_buf[..encoded_len];
    assert_eq![encoded, b"NBSWY3DPEB3W64TMMQ"];
    let mut decoded_buf = [0u8; 11];
    let decoded_len = Base32::decode_from_slice(encoded, &mut decoded_buf).unwrap();
    let decoded = &decoded_buf[..decoded_len];
    assert_eq![decoded, b"hello world"];
}
#[test]
fn base32_rfc4648_nolut() {
    pub type Base32 = Base<32, false, false, false, Rfc4648>;
    let mut encoded_buf = [0u8; 18];
    let encoded_len = Base32::encode_to_slice(b"hello world", &mut encoded_buf);
    let encoded = &encoded_buf[..encoded_len];
    assert_eq![encoded, b"NBSWY3DPEB3W64TMMQ"];
    let mut decoded_buf = [0u8; 11];
    let decoded_len = Base32::decode_from_slice(encoded, &mut decoded_buf).unwrap();
    let decoded = &decoded_buf[..decoded_len];
    assert_eq![decoded, b"hello world"];
}

#[test]
fn base32_rfc4648_padded() {
    pub type Base32 = Base<32, true, true, false, Rfc4648>; // PAD = true
    const ENC_REFERENCE: &[u8] = b"NBSWY3DPEB3W64TMMQ======";
    const DEC_LEN_PAD: usize = Base32::decoded_len_stripped(ENC_REFERENCE);

    let mut encoded_buf = [0u8; Base32::encoded_len_padded(b"hello world".len())];
    let encoded_len = Base32::encode_to_slice(b"hello world", &mut encoded_buf);
    let encoded = &encoded_buf[..encoded_len];
    assert_eq![encoded, ENC_REFERENCE];

    let mut decoded_buf = [0u8; DEC_LEN_PAD];
    let decoded_len = Base32::decode_from_slice(encoded, &mut decoded_buf).unwrap();
    let decoded = &decoded_buf[..decoded_len];
    assert_eq![decoded, b"hello world"];
}

#[test]
fn base32_rfc4648_case_sensitive() {
    pub type Base32 = Base<32, true, false, false, Rfc4648>; // CASE = false
    let encoded_lower = b"nbswy3dpeb3w64tmmq"; // Lowercase should fail
    let mut decoded_buf = [0u8; 11];
    let decoded_len = Base32::decode_from_slice(encoded_lower, &mut decoded_buf);
    assert_eq![decoded_len, None]; // Decoding should fail

    let encoded_lower = b"NBSWY3DPEB3W64TMMQ"; // Uppercase should succeed
    let mut decoded_buf = [0u8; 11];
    let decoded_len = Base32::decode_from_slice(encoded_lower, &mut decoded_buf);
    assert_eq![decoded_len, Some(11)];
    let decoded = &decoded_buf[..decoded_len.unwrap()];
    assert_eq![decoded, b"hello world"];
}
#[test]
fn base32_crockford_case_insensitive() {
    pub type Base32 = Base<32, true, false, true, Crockford>; // CASE = true
    let encoded = b"NBSWY3DPEB3W64TMMQ"; // Uppercase encoding
    let mut decoded_buf = [0u8; 11];
    let decoded_len = Base32::decode_from_slice(encoded, &mut decoded_buf).unwrap();
    let decoded = &decoded_buf[..decoded_len];
    assert_eq![decoded, b"hello world"];

    let encoded_lower = b"nbswy3dpeb3w64tmmq"; // Lowercase encoding (should decode the same)
    let decoded_len = Base32::decode_from_slice(encoded_lower, &mut decoded_buf).unwrap();
    let decoded = &decoded_buf[..decoded_len];
    assert_eq![decoded, b"hello world"];
}

#[test]
fn base32hex_rfc4648() {
    pub type Base32H = Base<32, true, false, false, Rfc4648Hex>;
    let mut encoded_buf = [0u8; 18];
    let encoded_len = Base32H::encode_to_slice(b"hello world", &mut encoded_buf);
    let encoded = &encoded_buf[..encoded_len];
    assert_eq![encoded, b"D1IMOR3F41RMUSJCCG"];
    let mut decoded_buf = [0u8; 11];
    let decoded_len = Base32H::decode_from_slice(encoded, &mut decoded_buf).unwrap();
    let decoded = &decoded_buf[..decoded_len];
    assert_eq![decoded, b"hello world"];
}

/* base-64 */

#[test]
fn base64_rfc4648_lut() {
    let mut encoded_buf = [0u8; 18];
    let encoded_len = Base64::encode_to_slice(b"hello world", &mut encoded_buf);
    let encoded = &encoded_buf[..encoded_len];
    assert_eq![encoded, b"aGVsbG8gd29ybGQ"];
    let mut decoded_buf = [0u8; 11];
    let decoded_len = Base64::decode_from_slice(encoded, &mut decoded_buf).unwrap();
    let decoded = &decoded_buf[..decoded_len];
    assert_eq![decoded, b"hello world"];
    // assert_eq![core::str::from_utf8(decoded).unwrap(), "hello world"];
}
#[test]
fn base64_rfc4648_nolut() {
    pub type Base64 = Base<64, false, false, false, Rfc4648>;
    let mut encoded_buf = [0u8; 18];
    let encoded_len = Base64::encode_to_slice(b"hello world", &mut encoded_buf);
    let encoded = &encoded_buf[..encoded_len];
    assert_eq![encoded, b"aGVsbG8gd29ybGQ"];
    let mut decoded_buf = [0u8; 11];
    let decoded_len = Base64::decode_from_slice(encoded, &mut decoded_buf).unwrap();
    let decoded = &decoded_buf[..decoded_len];
    assert_eq![decoded, b"hello world"];
}

#[test]
fn base64_rfc4648_padded() {
    pub type Base64 = Base<64, true, true, false, Rfc4648>; // PAD = true
    const ENC_REFERENCE: &[u8] = b"aGVsbG8gd29ybGQ=";
    const DEC_LEN_PAD: usize = Base64::decoded_len_stripped(ENC_REFERENCE);

    let mut encoded_buf = [0u8; Base64::encoded_len_padded(b"hello world".len())];
    let encoded_len = Base64::encode_to_slice(b"hello world", &mut encoded_buf);
    let encoded = &encoded_buf[..encoded_len];
    assert_eq![encoded, ENC_REFERENCE];

    let mut decoded_buf = [0u8; DEC_LEN_PAD];
    let decoded_len = Base64::decode_from_slice(encoded, &mut decoded_buf).unwrap();
    let decoded = &decoded_buf[..decoded_len];
    assert_eq![decoded, b"hello world"];
}