]>
git.ipfire.org Git - thirdparty/systemd.git/blob - src/test/test-hexdecoct.c
1 /* SPDX-License-Identifier: LGPL-2.1+ */
5 #include "alloc-util.h"
8 #include "string-util.h"
10 static void test_hexchar(void) {
11 assert_se(hexchar(0xa) == 'a');
12 assert_se(hexchar(0x0) == '0');
15 static void test_unhexchar(void) {
16 assert_se(unhexchar('a') == 0xA);
17 assert_se(unhexchar('A') == 0xA);
18 assert_se(unhexchar('0') == 0x0);
21 static void test_base32hexchar(void) {
22 assert_se(base32hexchar(0) == '0');
23 assert_se(base32hexchar(9) == '9');
24 assert_se(base32hexchar(10) == 'A');
25 assert_se(base32hexchar(31) == 'V');
28 static void test_unbase32hexchar(void) {
29 assert_se(unbase32hexchar('0') == 0);
30 assert_se(unbase32hexchar('9') == 9);
31 assert_se(unbase32hexchar('A') == 10);
32 assert_se(unbase32hexchar('V') == 31);
33 assert_se(unbase32hexchar('=') == -EINVAL
);
36 static void test_base64char(void) {
37 assert_se(base64char(0) == 'A');
38 assert_se(base64char(26) == 'a');
39 assert_se(base64char(63) == '/');
42 static void test_unbase64char(void) {
43 assert_se(unbase64char('A') == 0);
44 assert_se(unbase64char('Z') == 25);
45 assert_se(unbase64char('a') == 26);
46 assert_se(unbase64char('z') == 51);
47 assert_se(unbase64char('0') == 52);
48 assert_se(unbase64char('9') == 61);
49 assert_se(unbase64char('+') == 62);
50 assert_se(unbase64char('/') == 63);
51 assert_se(unbase64char('=') == -EINVAL
);
54 static void test_octchar(void) {
55 assert_se(octchar(00) == '0');
56 assert_se(octchar(07) == '7');
59 static void test_unoctchar(void) {
60 assert_se(unoctchar('0') == 00);
61 assert_se(unoctchar('7') == 07);
64 static void test_decchar(void) {
65 assert_se(decchar(0) == '0');
66 assert_se(decchar(9) == '9');
69 static void test_undecchar(void) {
70 assert_se(undecchar('0') == 0);
71 assert_se(undecchar('9') == 9);
74 static void test_unhexmem_one(const char *s
, size_t l
, int retval
) {
75 _cleanup_free_
char *hex
= NULL
;
76 _cleanup_free_
void *mem
= NULL
;
79 assert_se(unhexmem(s
, l
, &mem
, &len
) == retval
);
86 assert_se(hex
= hexmem(mem
, len
));
87 answer
= strndupa(s
, l
);
88 assert_se(streq(delete_chars(answer
, WHITESPACE
), hex
));
92 static void test_unhexmem(void) {
93 const char *hex
= "efa2149213";
94 const char *hex_space
= " e f a\n 2\r 14\n\r\t9\t2 \n1\r3 \r\r\t";
95 const char *hex_invalid
= "efa214921o";
97 test_unhexmem_one(NULL
, 0, 0);
98 test_unhexmem_one("", 0, 0);
99 test_unhexmem_one("", (size_t) -1, 0);
100 test_unhexmem_one(" \n \t\r \t\t \n\n\n", (size_t) -1, 0);
101 test_unhexmem_one(hex_invalid
, strlen(hex_invalid
), -EINVAL
);
102 test_unhexmem_one(hex_invalid
, (size_t) - 1, -EINVAL
);
103 test_unhexmem_one(hex
, strlen(hex
) - 1, -EPIPE
);
104 test_unhexmem_one(hex
, strlen(hex
), 0);
105 test_unhexmem_one(hex
, (size_t) -1, 0);
106 test_unhexmem_one(hex_space
, strlen(hex_space
), 0);
107 test_unhexmem_one(hex_space
, (size_t) -1, 0);
110 /* https://tools.ietf.org/html/rfc4648#section-10 */
111 static void test_base32hexmem(void) {
114 b32
= base32hexmem("", STRLEN(""), true);
116 assert_se(streq(b32
, ""));
119 b32
= base32hexmem("f", STRLEN("f"), true);
121 assert_se(streq(b32
, "CO======"));
124 b32
= base32hexmem("fo", STRLEN("fo"), true);
126 assert_se(streq(b32
, "CPNG===="));
129 b32
= base32hexmem("foo", STRLEN("foo"), true);
131 assert_se(streq(b32
, "CPNMU==="));
134 b32
= base32hexmem("foob", STRLEN("foob"), true);
136 assert_se(streq(b32
, "CPNMUOG="));
139 b32
= base32hexmem("fooba", STRLEN("fooba"), true);
141 assert_se(streq(b32
, "CPNMUOJ1"));
144 b32
= base32hexmem("foobar", STRLEN("foobar"), true);
146 assert_se(streq(b32
, "CPNMUOJ1E8======"));
149 b32
= base32hexmem("", STRLEN(""), false);
151 assert_se(streq(b32
, ""));
154 b32
= base32hexmem("f", STRLEN("f"), false);
156 assert_se(streq(b32
, "CO"));
159 b32
= base32hexmem("fo", STRLEN("fo"), false);
161 assert_se(streq(b32
, "CPNG"));
164 b32
= base32hexmem("foo", STRLEN("foo"), false);
166 assert_se(streq(b32
, "CPNMU"));
169 b32
= base32hexmem("foob", STRLEN("foob"), false);
171 assert_se(streq(b32
, "CPNMUOG"));
174 b32
= base32hexmem("fooba", STRLEN("fooba"), false);
176 assert_se(streq(b32
, "CPNMUOJ1"));
179 b32
= base32hexmem("foobar", STRLEN("foobar"), false);
181 assert_se(streq(b32
, "CPNMUOJ1E8"));
185 static void test_unbase32hexmem_one(const char *hex
, bool padding
, int retval
, const char *ans
) {
186 _cleanup_free_
void *mem
= NULL
;
189 assert_se(unbase32hexmem(hex
, (size_t) -1, padding
, &mem
, &len
) == retval
);
193 str
= strndupa(mem
, len
);
194 assert_se(streq(str
, ans
));
198 static void test_unbase32hexmem(void) {
199 test_unbase32hexmem_one("", true, 0, "");
201 test_unbase32hexmem_one("CO======", true, 0, "f");
202 test_unbase32hexmem_one("CPNG====", true, 0, "fo");
203 test_unbase32hexmem_one("CPNMU===", true, 0, "foo");
204 test_unbase32hexmem_one("CPNMUOG=", true, 0, "foob");
205 test_unbase32hexmem_one("CPNMUOJ1", true, 0, "fooba");
206 test_unbase32hexmem_one("CPNMUOJ1E8======", true, 0, "foobar");
208 test_unbase32hexmem_one("A", true, -EINVAL
, NULL
);
209 test_unbase32hexmem_one("A=======", true, -EINVAL
, NULL
);
210 test_unbase32hexmem_one("AAA=====", true, -EINVAL
, NULL
);
211 test_unbase32hexmem_one("AAAAAA==", true, -EINVAL
, NULL
);
212 test_unbase32hexmem_one("AB======", true, -EINVAL
, NULL
);
213 test_unbase32hexmem_one("AAAB====", true, -EINVAL
, NULL
);
214 test_unbase32hexmem_one("AAAAB===", true, -EINVAL
, NULL
);
215 test_unbase32hexmem_one("AAAAAAB=", true, -EINVAL
, NULL
);
217 test_unbase32hexmem_one("XPNMUOJ1", true, -EINVAL
, NULL
);
218 test_unbase32hexmem_one("CXNMUOJ1", true, -EINVAL
, NULL
);
219 test_unbase32hexmem_one("CPXMUOJ1", true, -EINVAL
, NULL
);
220 test_unbase32hexmem_one("CPNXUOJ1", true, -EINVAL
, NULL
);
221 test_unbase32hexmem_one("CPNMXOJ1", true, -EINVAL
, NULL
);
222 test_unbase32hexmem_one("CPNMUXJ1", true, -EINVAL
, NULL
);
223 test_unbase32hexmem_one("CPNMUOX1", true, -EINVAL
, NULL
);
224 test_unbase32hexmem_one("CPNMUOJX", true, -EINVAL
, NULL
);
226 test_unbase32hexmem_one("", false, 0, "");
227 test_unbase32hexmem_one("CO", false, 0, "f");
228 test_unbase32hexmem_one("CPNG", false, 0, "fo");
229 test_unbase32hexmem_one("CPNMU", false, 0, "foo");
230 test_unbase32hexmem_one("CPNMUOG", false, 0, "foob");
231 test_unbase32hexmem_one("CPNMUOJ1", false, 0, "fooba");
232 test_unbase32hexmem_one("CPNMUOJ1E8", false, 0, "foobar");
233 test_unbase32hexmem_one("CPNMUOG=", false, -EINVAL
, NULL
);
234 test_unbase32hexmem_one("CPNMUOJ1E8======", false, -EINVAL
, NULL
);
236 test_unbase32hexmem_one("A", false, -EINVAL
, NULL
);
237 test_unbase32hexmem_one("A", false, -EINVAL
, NULL
);
238 test_unbase32hexmem_one("AAA", false, -EINVAL
, NULL
);
239 test_unbase32hexmem_one("AAAAAA", false, -EINVAL
, NULL
);
240 test_unbase32hexmem_one("AB", false, -EINVAL
, NULL
);
241 test_unbase32hexmem_one("AAAB", false, -EINVAL
, NULL
);
242 test_unbase32hexmem_one("AAAAB", false, -EINVAL
, NULL
);
243 test_unbase32hexmem_one("AAAAAAB", false, -EINVAL
, NULL
);
246 /* https://tools.ietf.org/html/rfc4648#section-10 */
247 static void test_base64mem(void) {
250 assert_se(base64mem("", STRLEN(""), &b64
) == 0);
251 assert_se(streq(b64
, ""));
254 assert_se(base64mem("f", STRLEN("f"), &b64
) == 4);
255 assert_se(streq(b64
, "Zg=="));
258 assert_se(base64mem("fo", STRLEN("fo"), &b64
) == 4);
259 assert_se(streq(b64
, "Zm8="));
262 assert_se(base64mem("foo", STRLEN("foo"), &b64
) == 4);
263 assert_se(streq(b64
, "Zm9v"));
266 assert_se(base64mem("foob", STRLEN("foob"), &b64
) == 8);
267 assert_se(streq(b64
, "Zm9vYg=="));
270 assert_se(base64mem("fooba", STRLEN("fooba"), &b64
) == 8);
271 assert_se(streq(b64
, "Zm9vYmE="));
274 assert_se(base64mem("foobar", STRLEN("foobar"), &b64
) == 8);
275 assert_se(streq(b64
, "Zm9vYmFy"));
279 static void test_unbase64mem_one(const char *input
, const char *output
, int ret
) {
280 _cleanup_free_
void *buffer
= NULL
;
283 assert_se(unbase64mem(input
, (size_t) -1, &buffer
, &size
) == ret
);
286 assert_se(size
== strlen(output
));
287 assert_se(memcmp(buffer
, output
, size
) == 0);
288 assert_se(((char*) buffer
)[size
] == 0);
292 static void test_unbase64mem(void) {
294 test_unbase64mem_one("", "", 0);
295 test_unbase64mem_one("Zg==", "f", 0);
296 test_unbase64mem_one("Zm8=", "fo", 0);
297 test_unbase64mem_one("Zm9v", "foo", 0);
298 test_unbase64mem_one("Zm9vYg==", "foob", 0);
299 test_unbase64mem_one("Zm9vYmE=", "fooba", 0);
300 test_unbase64mem_one("Zm9vYmFy", "foobar", 0);
302 test_unbase64mem_one(" ", "", 0);
303 test_unbase64mem_one(" \n\r ", "", 0);
304 test_unbase64mem_one(" Zg\n== ", "f", 0);
305 test_unbase64mem_one(" Zm 8=\r", "fo", 0);
306 test_unbase64mem_one(" Zm9\n\r\r\nv ", "foo", 0);
307 test_unbase64mem_one(" Z m9vYg==\n\r", "foob", 0);
308 test_unbase64mem_one(" Zm 9vYmE= ", "fooba", 0);
309 test_unbase64mem_one(" Z m9v YmFy ", "foobar", 0);
311 test_unbase64mem_one("A", NULL
, -EPIPE
);
312 test_unbase64mem_one("A====", NULL
, -EINVAL
);
313 test_unbase64mem_one("AAB==", NULL
, -EINVAL
);
314 test_unbase64mem_one(" A A A B = ", NULL
, -EINVAL
);
315 test_unbase64mem_one(" Z m 8 = q u u x ", NULL
, -ENAMETOOLONG
);
318 static void test_hexdump(void) {
322 hexdump(stdout
, NULL
, 0);
323 hexdump(stdout
, "", 0);
324 hexdump(stdout
, "", 1);
325 hexdump(stdout
, "x", 1);
326 hexdump(stdout
, "x", 2);
327 hexdump(stdout
, "foobar", 7);
328 hexdump(stdout
, "f\nobar", 7);
329 hexdump(stdout
, "xxxxxxxxxxxxxxxxxxxxyz", 23);
331 for (i
= 0; i
< ELEMENTSOF(data
); i
++)
334 hexdump(stdout
, data
, sizeof(data
));
337 int main(int argc
, char *argv
[]) {
340 test_base32hexchar();
341 test_unbase32hexchar();
350 test_unbase32hexmem();