fast32 1.0.3

Base32 and base64 encoding in Rust. Primarily for integer (u64, u128) and UUID identifiers, as well as arbitrary byte arrays.
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
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203

mod base32 {
    use fast32::base32::{
        capacity_decode, capacity_encode, capacity_encode_u128, capacity_encode_u64,
    };

    #[test]
    fn test_capacity_encode() {
        assert_eq!(capacity_encode(&vec![0u8; 0]), 0);

        assert_eq!(capacity_encode(&vec![0u8; 1]), 2);
        assert_eq!(capacity_encode(&vec![0u8; 2]), 4);
        assert_eq!(capacity_encode(&vec![0u8; 3]), 5);
        assert_eq!(capacity_encode(&vec![0u8; 4]), 7);
        assert_eq!(capacity_encode(&vec![0u8; 5]), 8);

        assert_eq!(capacity_encode(&vec![0u8; 6]), 10);
        assert_eq!(capacity_encode(&vec![0u8; 7]), 12);
        assert_eq!(capacity_encode(&vec![0u8; 8]), 13);
        assert_eq!(capacity_encode(&vec![0u8; 9]), 15);
        assert_eq!(capacity_encode(&vec![0u8; 10]), 16);
    }

    #[test]
    fn test_capacity_decode() {
        assert_eq!(capacity_decode(&vec![0u8; 0]), 0);

        // Note that a 1 byte array would not be valid encoded base32, and similarly for other lengths

        assert_eq!(capacity_decode(&vec![0u8; 2]), 1);
        assert_eq!(capacity_decode(&vec![0u8; 4]), 2);
        assert_eq!(capacity_decode(&vec![0u8; 5]), 3);
        assert_eq!(capacity_decode(&vec![0u8; 7]), 4);
        assert_eq!(capacity_decode(&vec![0u8; 8]), 5);

        assert_eq!(capacity_decode(&vec![0u8; 10]), 6);
        assert_eq!(capacity_decode(&vec![0u8; 12]), 7);
        assert_eq!(capacity_decode(&vec![0u8; 13]), 8);
        assert_eq!(capacity_decode(&vec![0u8; 15]), 9);
        assert_eq!(capacity_decode(&vec![0u8; 16]), 10);
    }

    #[test]
    fn test_capacity_encode_u64() {
        assert_eq!(capacity_encode_u64(0), 1);
        assert_eq!(capacity_encode_u64(1), 1);
        assert_eq!(capacity_encode_u64(2), 1);

        assert_eq!(capacity_encode_u64(31), 1);
        assert_eq!(capacity_encode_u64(32), 2);
        assert_eq!(capacity_encode_u64(33), 2);

        assert_eq!(capacity_encode_u64(63), 2);
        assert_eq!(capacity_encode_u64(64), 2);
        assert_eq!(capacity_encode_u64(65), 2);

        assert_eq!(capacity_encode_u64(32 * 32 - 1), 2);
        assert_eq!(capacity_encode_u64(32 * 32), 3);
        assert_eq!(capacity_encode_u64(32 * 32 + 1), 3);

        assert_eq!(capacity_encode_u64(64 * 64 - 1), 3);
        assert_eq!(capacity_encode_u64(64 * 64), 3);
        assert_eq!(capacity_encode_u64(64 * 64 + 1), 3);

        // 32^6 == 64^5
        assert_eq!(capacity_encode_u64(32 * 32 * 32 * 32 * 32 * 32 - 1), 6);
        assert_eq!(capacity_encode_u64(32 * 32 * 32 * 32 * 32 * 32), 7);
        assert_eq!(capacity_encode_u64(32 * 32 * 32 * 32 * 32 * 32 + 1), 7);

        assert_eq!(capacity_encode_u64(u64::MAX), 13);
    }

    #[test]
    fn test_capacity_encode_u128() {
        assert_eq!(capacity_encode_u128(0), 1);
        assert_eq!(capacity_encode_u128(1), 1);
        assert_eq!(capacity_encode_u128(2), 1);

        assert_eq!(capacity_encode_u128(31), 1);
        assert_eq!(capacity_encode_u128(32), 2);
        assert_eq!(capacity_encode_u128(33), 2);

        assert_eq!(capacity_encode_u128(63), 2);
        assert_eq!(capacity_encode_u128(64), 2);
        assert_eq!(capacity_encode_u128(65), 2);

        assert_eq!(capacity_encode_u128(32 * 32 - 1), 2);
        assert_eq!(capacity_encode_u128(32 * 32), 3);
        assert_eq!(capacity_encode_u128(32 * 32 + 1), 3);

        assert_eq!(capacity_encode_u128(64 * 64 - 1), 3);
        assert_eq!(capacity_encode_u128(64 * 64), 3);
        assert_eq!(capacity_encode_u128(64 * 64 + 1), 3);

        // 32^6 == 64^5
        assert_eq!(capacity_encode_u128(32 * 32 * 32 * 32 * 32 * 32 - 1), 6);
        assert_eq!(capacity_encode_u128(32 * 32 * 32 * 32 * 32 * 32), 7);
        assert_eq!(capacity_encode_u128(32 * 32 * 32 * 32 * 32 * 32 + 1), 7);

        assert_eq!(capacity_encode_u128(u128::MAX), 26);
    }
}

mod base64 {
    use fast32::base64::{
        capacity_decode, capacity_encode, capacity_encode_u128, capacity_encode_u64,
    };

    #[test]
    fn test_capacity_encode() {
        assert_eq!(capacity_encode(&vec![0u8; 0]), 0);

        assert_eq!(capacity_encode(&vec![0u8; 1]), 2);
        assert_eq!(capacity_encode(&vec![0u8; 2]), 3);
        assert_eq!(capacity_encode(&vec![0u8; 3]), 4);

        assert_eq!(capacity_encode(&vec![0u8; 4]), 6);
        assert_eq!(capacity_encode(&vec![0u8; 5]), 7);
        assert_eq!(capacity_encode(&vec![0u8; 6]), 8);

        assert_eq!(capacity_encode(&vec![0u8; 7]), 10);
        assert_eq!(capacity_encode(&vec![0u8; 8]), 11);
        assert_eq!(capacity_encode(&vec![0u8; 9]), 12);
    }

    #[test]
    fn test_capacity_decode() {
        assert_eq!(capacity_decode(&vec![0u8; 0]), 0);

        // Note that a 1 byte array would not be valid encoded base64, and similarly for other lengths

        assert_eq!(capacity_decode(&vec![0u8; 2]), 1);
        assert_eq!(capacity_decode(&vec![0u8; 3]), 2);
        assert_eq!(capacity_decode(&vec![0u8; 4]), 3);

        assert_eq!(capacity_decode(&vec![0u8; 6]), 4);
        assert_eq!(capacity_decode(&vec![0u8; 7]), 5);
        assert_eq!(capacity_decode(&vec![0u8; 8]), 6);

        assert_eq!(capacity_decode(&vec![0u8; 10]), 7);
        assert_eq!(capacity_decode(&vec![0u8; 11]), 8);
        assert_eq!(capacity_decode(&vec![0u8; 12]), 9);
    }

    #[test]
    fn test_capacity_encode_u64() {
        assert_eq!(capacity_encode_u64(0), 1);
        assert_eq!(capacity_encode_u64(1), 1);
        assert_eq!(capacity_encode_u64(2), 1);

        assert_eq!(capacity_encode_u64(31), 1);
        assert_eq!(capacity_encode_u64(32), 1);
        assert_eq!(capacity_encode_u64(33), 1);

        assert_eq!(capacity_encode_u64(63), 1);
        assert_eq!(capacity_encode_u64(64), 2);
        assert_eq!(capacity_encode_u64(65), 2);

        assert_eq!(capacity_encode_u64(32 * 32 - 1), 2);
        assert_eq!(capacity_encode_u64(32 * 32), 2);
        assert_eq!(capacity_encode_u64(32 * 32 + 1), 2);

        assert_eq!(capacity_encode_u64(64 * 64 - 1), 2);
        assert_eq!(capacity_encode_u64(64 * 64), 3);
        assert_eq!(capacity_encode_u64(64 * 64 + 1), 3);

        // 32^6 == 64^5
        assert_eq!(capacity_encode_u64(64 * 64 * 64 * 64 * 64 - 1), 5);
        assert_eq!(capacity_encode_u64(64 * 64 * 64 * 64 * 64), 6);
        assert_eq!(capacity_encode_u64(64 * 64 * 64 * 64 * 64 + 1), 6);

        assert_eq!(capacity_encode_u64(u64::MAX), 11);
    }

    #[test]
    fn test_capacity_encode_u128() {
        assert_eq!(capacity_encode_u128(0), 1);
        assert_eq!(capacity_encode_u128(1), 1);
        assert_eq!(capacity_encode_u128(2), 1);

        assert_eq!(capacity_encode_u128(31), 1);
        assert_eq!(capacity_encode_u128(32), 1);
        assert_eq!(capacity_encode_u128(33), 1);

        assert_eq!(capacity_encode_u128(63), 1);
        assert_eq!(capacity_encode_u128(64), 2);
        assert_eq!(capacity_encode_u128(65), 2);

        assert_eq!(capacity_encode_u128(32 * 32 - 1), 2);
        assert_eq!(capacity_encode_u128(32 * 32), 2);
        assert_eq!(capacity_encode_u128(32 * 32 + 1), 2);

        assert_eq!(capacity_encode_u128(64 * 64 - 1), 2);
        assert_eq!(capacity_encode_u128(64 * 64), 3);
        assert_eq!(capacity_encode_u128(64 * 64 + 1), 3);

        // 32^6 == 64^5
        assert_eq!(capacity_encode_u128(64 * 64 * 64 * 64 * 64 - 1), 5);
        assert_eq!(capacity_encode_u128(64 * 64 * 64 * 64 * 64), 6);
        assert_eq!(capacity_encode_u128(64 * 64 * 64 * 64 * 64 + 1), 6);

        assert_eq!(capacity_encode_u128(u128::MAX), 22);
    }
}