]>
git.ipfire.org Git - thirdparty/systemd.git/blob - src/test/test-hexdecoct.c
1 /* SPDX-License-Identifier: LGPL-2.1+ */
3 This file is part of systemd.
5 Copyright 2010 Lennart Poettering
10 #include "alloc-util.h"
11 #include "hexdecoct.h"
13 #include "string-util.h"
15 static void test_hexchar(void) {
16 assert_se(hexchar(0xa) == 'a');
17 assert_se(hexchar(0x0) == '0');
20 static void test_unhexchar(void) {
21 assert_se(unhexchar('a') == 0xA);
22 assert_se(unhexchar('A') == 0xA);
23 assert_se(unhexchar('0') == 0x0);
26 static void test_base32hexchar(void) {
27 assert_se(base32hexchar(0) == '0');
28 assert_se(base32hexchar(9) == '9');
29 assert_se(base32hexchar(10) == 'A');
30 assert_se(base32hexchar(31) == 'V');
33 static void test_unbase32hexchar(void) {
34 assert_se(unbase32hexchar('0') == 0);
35 assert_se(unbase32hexchar('9') == 9);
36 assert_se(unbase32hexchar('A') == 10);
37 assert_se(unbase32hexchar('V') == 31);
38 assert_se(unbase32hexchar('=') == -EINVAL
);
41 static void test_base64char(void) {
42 assert_se(base64char(0) == 'A');
43 assert_se(base64char(26) == 'a');
44 assert_se(base64char(63) == '/');
47 static void test_unbase64char(void) {
48 assert_se(unbase64char('A') == 0);
49 assert_se(unbase64char('Z') == 25);
50 assert_se(unbase64char('a') == 26);
51 assert_se(unbase64char('z') == 51);
52 assert_se(unbase64char('0') == 52);
53 assert_se(unbase64char('9') == 61);
54 assert_se(unbase64char('+') == 62);
55 assert_se(unbase64char('/') == 63);
56 assert_se(unbase64char('=') == -EINVAL
);
59 static void test_octchar(void) {
60 assert_se(octchar(00) == '0');
61 assert_se(octchar(07) == '7');
64 static void test_unoctchar(void) {
65 assert_se(unoctchar('0') == 00);
66 assert_se(unoctchar('7') == 07);
69 static void test_decchar(void) {
70 assert_se(decchar(0) == '0');
71 assert_se(decchar(9) == '9');
74 static void test_undecchar(void) {
75 assert_se(undecchar('0') == 0);
76 assert_se(undecchar('9') == 9);
79 static void test_unhexmem_one(const char *s
, size_t l
, int retval
) {
80 _cleanup_free_
char *hex
= NULL
;
81 _cleanup_free_
void *mem
= NULL
;
84 assert_se(unhexmem(s
, l
, &mem
, &len
) == retval
);
88 if (l
== (size_t) - 1)
91 assert_se((hex
= hexmem(mem
, len
)));
92 answer
= strndupa(s
, l
);
93 assert_se(streq(delete_chars(answer
, WHITESPACE
), hex
));
97 static void test_unhexmem(void) {
98 const char *hex
= "efa2149213";
99 const char *hex_space
= " e f a\n 2\r 14\n\r\t9\t2 \n1\r3 \r\r\t";
100 const char *hex_invalid
= "efa214921o";
102 test_unhexmem_one(NULL
, 0, 0);
103 test_unhexmem_one("", 0, 0);
104 test_unhexmem_one("", (size_t) -1, 0);
105 test_unhexmem_one(" \n \t\r \t\t \n\n\n", (size_t) -1, 0);
106 test_unhexmem_one(hex_invalid
, strlen(hex_invalid
), -EINVAL
);
107 test_unhexmem_one(hex_invalid
, (size_t) - 1, -EINVAL
);
108 test_unhexmem_one(hex
, strlen(hex
) - 1, -EPIPE
);
109 test_unhexmem_one(hex
, strlen(hex
), 0);
110 test_unhexmem_one(hex
, (size_t) -1, 0);
111 test_unhexmem_one(hex_space
, strlen(hex_space
), 0);
112 test_unhexmem_one(hex_space
, (size_t) -1, 0);
115 /* https://tools.ietf.org/html/rfc4648#section-10 */
116 static void test_base32hexmem(void) {
119 b32
= base32hexmem("", STRLEN(""), true);
121 assert_se(streq(b32
, ""));
124 b32
= base32hexmem("f", STRLEN("f"), true);
126 assert_se(streq(b32
, "CO======"));
129 b32
= base32hexmem("fo", STRLEN("fo"), true);
131 assert_se(streq(b32
, "CPNG===="));
134 b32
= base32hexmem("foo", STRLEN("foo"), true);
136 assert_se(streq(b32
, "CPNMU==="));
139 b32
= base32hexmem("foob", STRLEN("foob"), true);
141 assert_se(streq(b32
, "CPNMUOG="));
144 b32
= base32hexmem("fooba", STRLEN("fooba"), true);
146 assert_se(streq(b32
, "CPNMUOJ1"));
149 b32
= base32hexmem("foobar", STRLEN("foobar"), true);
151 assert_se(streq(b32
, "CPNMUOJ1E8======"));
154 b32
= base32hexmem("", STRLEN(""), false);
156 assert_se(streq(b32
, ""));
159 b32
= base32hexmem("f", STRLEN("f"), false);
161 assert_se(streq(b32
, "CO"));
164 b32
= base32hexmem("fo", STRLEN("fo"), false);
166 assert_se(streq(b32
, "CPNG"));
169 b32
= base32hexmem("foo", STRLEN("foo"), false);
171 assert_se(streq(b32
, "CPNMU"));
174 b32
= base32hexmem("foob", STRLEN("foob"), false);
176 assert_se(streq(b32
, "CPNMUOG"));
179 b32
= base32hexmem("fooba", STRLEN("fooba"), false);
181 assert_se(streq(b32
, "CPNMUOJ1"));
184 b32
= base32hexmem("foobar", STRLEN("foobar"), false);
186 assert_se(streq(b32
, "CPNMUOJ1E8"));
190 static void test_unbase32hexmem_one(const char *hex
, bool padding
, int retval
, const char *ans
) {
191 _cleanup_free_
void *mem
= NULL
;
194 assert_se(unbase32hexmem(hex
, (size_t) -1, padding
, &mem
, &len
) == retval
);
198 str
= strndupa(mem
, len
);
199 assert_se(streq(str
, ans
));
203 static void test_unbase32hexmem(void) {
204 test_unbase32hexmem_one("", true, 0, "");
206 test_unbase32hexmem_one("CO======", true, 0, "f");
207 test_unbase32hexmem_one("CPNG====", true, 0, "fo");
208 test_unbase32hexmem_one("CPNMU===", true, 0, "foo");
209 test_unbase32hexmem_one("CPNMUOG=", true, 0, "foob");
210 test_unbase32hexmem_one("CPNMUOJ1", true, 0, "fooba");
211 test_unbase32hexmem_one("CPNMUOJ1E8======", true, 0, "foobar");
213 test_unbase32hexmem_one("A", true, -EINVAL
, NULL
);
214 test_unbase32hexmem_one("A=======", true, -EINVAL
, NULL
);
215 test_unbase32hexmem_one("AAA=====", true, -EINVAL
, NULL
);
216 test_unbase32hexmem_one("AAAAAA==", true, -EINVAL
, NULL
);
217 test_unbase32hexmem_one("AB======", true, -EINVAL
, NULL
);
218 test_unbase32hexmem_one("AAAB====", true, -EINVAL
, NULL
);
219 test_unbase32hexmem_one("AAAAB===", true, -EINVAL
, NULL
);
220 test_unbase32hexmem_one("AAAAAAB=", true, -EINVAL
, NULL
);
222 test_unbase32hexmem_one("XPNMUOJ1", true, -EINVAL
, NULL
);
223 test_unbase32hexmem_one("CXNMUOJ1", true, -EINVAL
, NULL
);
224 test_unbase32hexmem_one("CPXMUOJ1", true, -EINVAL
, NULL
);
225 test_unbase32hexmem_one("CPNXUOJ1", true, -EINVAL
, NULL
);
226 test_unbase32hexmem_one("CPNMXOJ1", true, -EINVAL
, NULL
);
227 test_unbase32hexmem_one("CPNMUXJ1", true, -EINVAL
, NULL
);
228 test_unbase32hexmem_one("CPNMUOX1", true, -EINVAL
, NULL
);
229 test_unbase32hexmem_one("CPNMUOJX", true, -EINVAL
, NULL
);
231 test_unbase32hexmem_one("", false, 0, "");
232 test_unbase32hexmem_one("CO", false, 0, "f");
233 test_unbase32hexmem_one("CPNG", false, 0, "fo");
234 test_unbase32hexmem_one("CPNMU", false, 0, "foo");
235 test_unbase32hexmem_one("CPNMUOG", false, 0, "foob");
236 test_unbase32hexmem_one("CPNMUOJ1", false, 0, "fooba");
237 test_unbase32hexmem_one("CPNMUOJ1E8", false, 0, "foobar");
238 test_unbase32hexmem_one("CPNMUOG=", false, -EINVAL
, NULL
);
239 test_unbase32hexmem_one("CPNMUOJ1E8======", false, -EINVAL
, NULL
);
241 test_unbase32hexmem_one("A", false, -EINVAL
, NULL
);
242 test_unbase32hexmem_one("A", false, -EINVAL
, NULL
);
243 test_unbase32hexmem_one("AAA", false, -EINVAL
, NULL
);
244 test_unbase32hexmem_one("AAAAAA", false, -EINVAL
, NULL
);
245 test_unbase32hexmem_one("AB", false, -EINVAL
, NULL
);
246 test_unbase32hexmem_one("AAAB", false, -EINVAL
, NULL
);
247 test_unbase32hexmem_one("AAAAB", false, -EINVAL
, NULL
);
248 test_unbase32hexmem_one("AAAAAAB", false, -EINVAL
, NULL
);
251 /* https://tools.ietf.org/html/rfc4648#section-10 */
252 static void test_base64mem(void) {
255 assert_se(base64mem("", STRLEN(""), &b64
) == 0);
256 assert_se(streq(b64
, ""));
259 assert_se(base64mem("f", STRLEN("f"), &b64
) == 4);
260 assert_se(streq(b64
, "Zg=="));
263 assert_se(base64mem("fo", STRLEN("fo"), &b64
) == 4);
264 assert_se(streq(b64
, "Zm8="));
267 assert_se(base64mem("foo", STRLEN("foo"), &b64
) == 4);
268 assert_se(streq(b64
, "Zm9v"));
271 assert_se(base64mem("foob", STRLEN("foob"), &b64
) == 8);
272 assert_se(streq(b64
, "Zm9vYg=="));
275 assert_se(base64mem("fooba", STRLEN("fooba"), &b64
) == 8);
276 assert_se(streq(b64
, "Zm9vYmE="));
279 assert_se(base64mem("foobar", STRLEN("foobar"), &b64
) == 8);
280 assert_se(streq(b64
, "Zm9vYmFy"));
284 static void test_unbase64mem_one(const char *input
, const char *output
, int ret
) {
285 _cleanup_free_
void *buffer
= NULL
;
288 assert_se(unbase64mem(input
, (size_t) -1, &buffer
, &size
) == ret
);
291 assert_se(size
== strlen(output
));
292 assert_se(memcmp(buffer
, output
, size
) == 0);
293 assert_se(((char*) buffer
)[size
] == 0);
297 static void test_unbase64mem(void) {
299 test_unbase64mem_one("", "", 0);
300 test_unbase64mem_one("Zg==", "f", 0);
301 test_unbase64mem_one("Zm8=", "fo", 0);
302 test_unbase64mem_one("Zm9v", "foo", 0);
303 test_unbase64mem_one("Zm9vYg==", "foob", 0);
304 test_unbase64mem_one("Zm9vYmE=", "fooba", 0);
305 test_unbase64mem_one("Zm9vYmFy", "foobar", 0);
307 test_unbase64mem_one(" ", "", 0);
308 test_unbase64mem_one(" \n\r ", "", 0);
309 test_unbase64mem_one(" Zg\n== ", "f", 0);
310 test_unbase64mem_one(" Zm 8=\r", "fo", 0);
311 test_unbase64mem_one(" Zm9\n\r\r\nv ", "foo", 0);
312 test_unbase64mem_one(" Z m9vYg==\n\r", "foob", 0);
313 test_unbase64mem_one(" Zm 9vYmE= ", "fooba", 0);
314 test_unbase64mem_one(" Z m9v YmFy ", "foobar", 0);
316 test_unbase64mem_one("A", NULL
, -EPIPE
);
317 test_unbase64mem_one("A====", NULL
, -EINVAL
);
318 test_unbase64mem_one("AAB==", NULL
, -EINVAL
);
319 test_unbase64mem_one(" A A A B = ", NULL
, -EINVAL
);
320 test_unbase64mem_one(" Z m 8 = q u u x ", NULL
, -ENAMETOOLONG
);
323 static void test_hexdump(void) {
327 hexdump(stdout
, NULL
, 0);
328 hexdump(stdout
, "", 0);
329 hexdump(stdout
, "", 1);
330 hexdump(stdout
, "x", 1);
331 hexdump(stdout
, "x", 2);
332 hexdump(stdout
, "foobar", 7);
333 hexdump(stdout
, "f\nobar", 7);
334 hexdump(stdout
, "xxxxxxxxxxxxxxxxxxxxyz", 23);
336 for (i
= 0; i
< ELEMENTSOF(data
); i
++)
339 hexdump(stdout
, data
, sizeof(data
));
342 int main(int argc
, char *argv
[]) {
345 test_base32hexchar();
346 test_unbase32hexchar();
355 test_unbase32hexmem();