]>
git.ipfire.org Git - thirdparty/systemd.git/blob - src/test/test-hexdecoct.c
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
5 #include "alloc-util.h"
8 #include "random-util.h"
9 #include "string-util.h"
13 assert_se(hexchar(0xa) == 'a');
14 assert_se(hexchar(0x0) == '0');
18 assert_se(unhexchar('a') == 0xA);
19 assert_se(unhexchar('A') == 0xA);
20 assert_se(unhexchar('0') == 0x0);
24 assert_se(base32hexchar(0) == '0');
25 assert_se(base32hexchar(9) == '9');
26 assert_se(base32hexchar(10) == 'A');
27 assert_se(base32hexchar(31) == 'V');
30 TEST(unbase32hexchar
) {
31 assert_se(unbase32hexchar('0') == 0);
32 assert_se(unbase32hexchar('9') == 9);
33 assert_se(unbase32hexchar('A') == 10);
34 assert_se(unbase32hexchar('V') == 31);
35 assert_se(unbase32hexchar('=') == -EINVAL
);
39 assert_se(base64char(0) == 'A');
40 assert_se(base64char(26) == 'a');
41 assert_se(base64char(63) == '/');
45 assert_se(unbase64char('A') == 0);
46 assert_se(unbase64char('Z') == 25);
47 assert_se(unbase64char('a') == 26);
48 assert_se(unbase64char('z') == 51);
49 assert_se(unbase64char('0') == 52);
50 assert_se(unbase64char('9') == 61);
51 assert_se(unbase64char('+') == 62);
52 assert_se(unbase64char('/') == 63);
53 assert_se(unbase64char('=') == -EINVAL
);
57 assert_se(octchar(00) == '0');
58 assert_se(octchar(07) == '7');
62 assert_se(unoctchar('0') == 00);
63 assert_se(unoctchar('7') == 07);
67 assert_se(decchar(0) == '0');
68 assert_se(decchar(9) == '9');
72 assert_se(undecchar('0') == 0);
73 assert_se(undecchar('9') == 9);
76 static void test_unhexmem_one(const char *s
, size_t l
, int retval
) {
77 _cleanup_free_
char *hex
= NULL
;
78 _cleanup_free_
void *mem
= NULL
;
81 assert_se(unhexmem(s
, l
, &mem
, &len
) == retval
);
88 assert_se(hex
= hexmem(mem
, len
));
89 answer
= strndupa_safe(strempty(s
), l
);
90 assert_se(streq(delete_chars(answer
, WHITESPACE
), hex
));
95 const char *hex
= "efa2149213";
96 const char *hex_space
= " e f a\n 2\r 14\n\r\t9\t2 \n1\r3 \r\r\t";
97 const char *hex_invalid
= "efa214921o";
99 test_unhexmem_one(NULL
, 0, 0);
100 test_unhexmem_one("", 0, 0);
101 test_unhexmem_one("", SIZE_MAX
, 0);
102 test_unhexmem_one(" \n \t\r \t\t \n\n\n", SIZE_MAX
, 0);
103 test_unhexmem_one(hex_invalid
, strlen(hex_invalid
), -EINVAL
);
104 test_unhexmem_one(hex_invalid
, (size_t) - 1, -EINVAL
);
105 test_unhexmem_one(hex
, strlen(hex
) - 1, -EPIPE
);
106 test_unhexmem_one(hex
, strlen(hex
), 0);
107 test_unhexmem_one(hex
, SIZE_MAX
, 0);
108 test_unhexmem_one(hex_space
, strlen(hex_space
), 0);
109 test_unhexmem_one(hex_space
, SIZE_MAX
, 0);
112 /* https://tools.ietf.org/html/rfc4648#section-10 */
116 b32
= base32hexmem("", STRLEN(""), true);
118 assert_se(streq(b32
, ""));
121 b32
= base32hexmem("f", STRLEN("f"), true);
123 assert_se(streq(b32
, "CO======"));
126 b32
= base32hexmem("fo", STRLEN("fo"), true);
128 assert_se(streq(b32
, "CPNG===="));
131 b32
= base32hexmem("foo", STRLEN("foo"), true);
133 assert_se(streq(b32
, "CPNMU==="));
136 b32
= base32hexmem("foob", STRLEN("foob"), true);
138 assert_se(streq(b32
, "CPNMUOG="));
141 b32
= base32hexmem("fooba", STRLEN("fooba"), true);
143 assert_se(streq(b32
, "CPNMUOJ1"));
146 b32
= base32hexmem("foobar", STRLEN("foobar"), true);
148 assert_se(streq(b32
, "CPNMUOJ1E8======"));
151 b32
= base32hexmem("", STRLEN(""), false);
153 assert_se(streq(b32
, ""));
156 b32
= base32hexmem("f", STRLEN("f"), false);
158 assert_se(streq(b32
, "CO"));
161 b32
= base32hexmem("fo", STRLEN("fo"), false);
163 assert_se(streq(b32
, "CPNG"));
166 b32
= base32hexmem("foo", STRLEN("foo"), false);
168 assert_se(streq(b32
, "CPNMU"));
171 b32
= base32hexmem("foob", STRLEN("foob"), false);
173 assert_se(streq(b32
, "CPNMUOG"));
176 b32
= base32hexmem("fooba", STRLEN("fooba"), false);
178 assert_se(streq(b32
, "CPNMUOJ1"));
181 b32
= base32hexmem("foobar", STRLEN("foobar"), false);
183 assert_se(streq(b32
, "CPNMUOJ1E8"));
187 static void test_unbase32hexmem_one(const char *hex
, bool padding
, int retval
, const char *ans
) {
188 _cleanup_free_
void *mem
= NULL
;
191 assert_se(unbase32hexmem(hex
, SIZE_MAX
, padding
, &mem
, &len
) == retval
);
195 str
= strndupa_safe(mem
, len
);
196 assert_se(streq(str
, ans
));
200 TEST(unbase32hexmem
) {
201 test_unbase32hexmem_one("", true, 0, "");
203 test_unbase32hexmem_one("CO======", true, 0, "f");
204 test_unbase32hexmem_one("CPNG====", true, 0, "fo");
205 test_unbase32hexmem_one("CPNMU===", true, 0, "foo");
206 test_unbase32hexmem_one("CPNMUOG=", true, 0, "foob");
207 test_unbase32hexmem_one("CPNMUOJ1", true, 0, "fooba");
208 test_unbase32hexmem_one("CPNMUOJ1E8======", true, 0, "foobar");
210 test_unbase32hexmem_one("A", true, -EINVAL
, NULL
);
211 test_unbase32hexmem_one("A=======", true, -EINVAL
, NULL
);
212 test_unbase32hexmem_one("AAA=====", true, -EINVAL
, NULL
);
213 test_unbase32hexmem_one("AAAAAA==", true, -EINVAL
, NULL
);
214 test_unbase32hexmem_one("AB======", true, -EINVAL
, NULL
);
215 test_unbase32hexmem_one("AAAB====", true, -EINVAL
, NULL
);
216 test_unbase32hexmem_one("AAAAB===", true, -EINVAL
, NULL
);
217 test_unbase32hexmem_one("AAAAAAB=", true, -EINVAL
, NULL
);
219 test_unbase32hexmem_one("XPNMUOJ1", true, -EINVAL
, NULL
);
220 test_unbase32hexmem_one("CXNMUOJ1", true, -EINVAL
, NULL
);
221 test_unbase32hexmem_one("CPXMUOJ1", true, -EINVAL
, NULL
);
222 test_unbase32hexmem_one("CPNXUOJ1", true, -EINVAL
, NULL
);
223 test_unbase32hexmem_one("CPNMXOJ1", true, -EINVAL
, NULL
);
224 test_unbase32hexmem_one("CPNMUXJ1", true, -EINVAL
, NULL
);
225 test_unbase32hexmem_one("CPNMUOX1", true, -EINVAL
, NULL
);
226 test_unbase32hexmem_one("CPNMUOJX", true, -EINVAL
, NULL
);
228 test_unbase32hexmem_one("", false, 0, "");
229 test_unbase32hexmem_one("CO", false, 0, "f");
230 test_unbase32hexmem_one("CPNG", false, 0, "fo");
231 test_unbase32hexmem_one("CPNMU", false, 0, "foo");
232 test_unbase32hexmem_one("CPNMUOG", false, 0, "foob");
233 test_unbase32hexmem_one("CPNMUOJ1", false, 0, "fooba");
234 test_unbase32hexmem_one("CPNMUOJ1E8", false, 0, "foobar");
235 test_unbase32hexmem_one("CPNMUOG=", false, -EINVAL
, NULL
);
236 test_unbase32hexmem_one("CPNMUOJ1E8======", false, -EINVAL
, NULL
);
238 test_unbase32hexmem_one("A", false, -EINVAL
, NULL
);
239 test_unbase32hexmem_one("AAA", false, -EINVAL
, NULL
);
240 test_unbase32hexmem_one("AAAAAA", false, -EINVAL
, NULL
);
241 test_unbase32hexmem_one("AB", false, -EINVAL
, NULL
);
242 test_unbase32hexmem_one("AAAB", false, -EINVAL
, NULL
);
243 test_unbase32hexmem_one("AAAAB", false, -EINVAL
, NULL
);
244 test_unbase32hexmem_one("AAAAAAB", false, -EINVAL
, NULL
);
247 /* https://tools.ietf.org/html/rfc4648#section-10 */
251 assert_se(base64mem("", STRLEN(""), &b64
) == 0);
252 assert_se(streq(b64
, ""));
255 assert_se(base64mem("f", STRLEN("f"), &b64
) == 4);
256 assert_se(streq(b64
, "Zg=="));
259 assert_se(base64mem("fo", STRLEN("fo"), &b64
) == 4);
260 assert_se(streq(b64
, "Zm8="));
263 assert_se(base64mem("foo", STRLEN("foo"), &b64
) == 4);
264 assert_se(streq(b64
, "Zm9v"));
267 assert_se(base64mem("foob", STRLEN("foob"), &b64
) == 8);
268 assert_se(streq(b64
, "Zm9vYg=="));
271 assert_se(base64mem("fooba", STRLEN("fooba"), &b64
) == 8);
272 assert_se(streq(b64
, "Zm9vYmE="));
275 assert_se(base64mem("foobar", STRLEN("foobar"), &b64
) == 8);
276 assert_se(streq(b64
, "Zm9vYmFy"));
280 TEST(base64mem_linebreak
) {
283 for (size_t i
= 0; i
< 20; i
++) {
284 _cleanup_free_
char *encoded
= NULL
;
285 _cleanup_free_
void *decoded
= NULL
;
290 /* Try a bunch of differently sized blobs */
291 n
= random_u64_range(sizeof(data
));
292 random_bytes(data
, n
);
294 /* Break at various different columns */
295 m
= 1 + random_u64_range(n
+ 5);
297 l
= base64mem_full(data
, n
, m
, &encoded
);
300 assert_se((size_t) l
== strlen(encoded
));
302 assert_se(unbase64mem(encoded
, SIZE_MAX
, &decoded
, &decoded_size
) >= 0);
303 assert_se(decoded_size
== n
);
304 assert_se(memcmp(data
, decoded
, n
) == 0);
306 for (size_t j
= 0; j
< (size_t) l
; j
++)
307 assert_se((encoded
[j
] == '\n') == (j
% (m
+ 1) == m
));
311 static void test_unbase64mem_one(const char *input
, const char *output
, int ret
) {
312 _cleanup_free_
void *buffer
= NULL
;
315 assert_se(unbase64mem(input
, SIZE_MAX
, &buffer
, &size
) == ret
);
318 assert_se(size
== strlen(output
));
319 assert_se(memcmp(buffer
, output
, size
) == 0);
320 assert_se(((char*) buffer
)[size
] == 0);
326 test_unbase64mem_one("", "", 0);
327 test_unbase64mem_one("Zg==", "f", 0);
328 test_unbase64mem_one("Zm8=", "fo", 0);
329 test_unbase64mem_one("Zm9v", "foo", 0);
330 test_unbase64mem_one("Zm9vYg==", "foob", 0);
331 test_unbase64mem_one("Zm9vYmE=", "fooba", 0);
332 test_unbase64mem_one("Zm9vYmFy", "foobar", 0);
334 test_unbase64mem_one(" ", "", 0);
335 test_unbase64mem_one(" \n\r ", "", 0);
336 test_unbase64mem_one(" Zg\n== ", "f", 0);
337 test_unbase64mem_one(" Zm 8=\r", "fo", 0);
338 test_unbase64mem_one(" Zm9\n\r\r\nv ", "foo", 0);
339 test_unbase64mem_one(" Z m9vYg==\n\r", "foob", 0);
340 test_unbase64mem_one(" Zm 9vYmE= ", "fooba", 0);
341 test_unbase64mem_one(" Z m9v YmFy ", "foobar", 0);
343 test_unbase64mem_one("A", NULL
, -EPIPE
);
344 test_unbase64mem_one("A====", NULL
, -EINVAL
);
345 test_unbase64mem_one("AAB==", NULL
, -EINVAL
);
346 test_unbase64mem_one(" A A A B = ", NULL
, -EINVAL
);
347 test_unbase64mem_one(" Z m 8 = q u u x ", NULL
, -ENAMETOOLONG
);
354 hexdump(stdout
, NULL
, 0);
355 hexdump(stdout
, "", 0);
356 hexdump(stdout
, "", 1);
357 hexdump(stdout
, "x", 1);
358 hexdump(stdout
, "x", 2);
359 hexdump(stdout
, "foobar", 7);
360 hexdump(stdout
, "f\nobar", 7);
361 hexdump(stdout
, "xxxxxxxxxxxxxxxxxxxxyz", 23);
363 for (i
= 0; i
< ELEMENTSOF(data
); i
++)
366 hexdump(stdout
, data
, sizeof(data
));
369 DEFINE_TEST_MAIN(LOG_INFO
);