]>
Commit | Line | Data |
---|---|---|
db9ecf05 | 1 | /* SPDX-License-Identifier: LGPL-2.1-or-later */ |
13471436 | 2 | |
dccca82b LP |
3 | #include <errno.h> |
4 | ||
13471436 RC |
5 | #include "alloc-util.h" |
6 | #include "hexdecoct.h" | |
7 | #include "macro.h" | |
82b4ec44 | 8 | #include "random-util.h" |
13471436 | 9 | #include "string-util.h" |
4f7452a8 | 10 | #include "tests.h" |
13471436 | 11 | |
4f7452a8 | 12 | TEST(hexchar) { |
13471436 RC |
13 | assert_se(hexchar(0xa) == 'a'); |
14 | assert_se(hexchar(0x0) == '0'); | |
15 | } | |
16 | ||
4f7452a8 | 17 | TEST(unhexchar) { |
13471436 RC |
18 | assert_se(unhexchar('a') == 0xA); |
19 | assert_se(unhexchar('A') == 0xA); | |
20 | assert_se(unhexchar('0') == 0x0); | |
21 | } | |
22 | ||
4f7452a8 | 23 | TEST(base32hexchar) { |
13471436 RC |
24 | assert_se(base32hexchar(0) == '0'); |
25 | assert_se(base32hexchar(9) == '9'); | |
26 | assert_se(base32hexchar(10) == 'A'); | |
27 | assert_se(base32hexchar(31) == 'V'); | |
28 | } | |
29 | ||
4f7452a8 | 30 | TEST(unbase32hexchar) { |
13471436 RC |
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); | |
36 | } | |
37 | ||
4f7452a8 | 38 | TEST(base64char) { |
13471436 RC |
39 | assert_se(base64char(0) == 'A'); |
40 | assert_se(base64char(26) == 'a'); | |
41 | assert_se(base64char(63) == '/'); | |
42 | } | |
43 | ||
4f7452a8 | 44 | TEST(unbase64char) { |
13471436 RC |
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); | |
54 | } | |
55 | ||
4f7452a8 | 56 | TEST(octchar) { |
13471436 RC |
57 | assert_se(octchar(00) == '0'); |
58 | assert_se(octchar(07) == '7'); | |
59 | } | |
60 | ||
4f7452a8 | 61 | TEST(unoctchar) { |
13471436 RC |
62 | assert_se(unoctchar('0') == 00); |
63 | assert_se(unoctchar('7') == 07); | |
64 | } | |
65 | ||
4f7452a8 | 66 | TEST(decchar) { |
13471436 RC |
67 | assert_se(decchar(0) == '0'); |
68 | assert_se(decchar(9) == '9'); | |
69 | } | |
70 | ||
4f7452a8 | 71 | TEST(undecchar) { |
13471436 RC |
72 | assert_se(undecchar('0') == 0); |
73 | assert_se(undecchar('9') == 9); | |
74 | } | |
75 | ||
7d345674 YW |
76 | static void test_hexmem_one(const char *in, const char *expected) { |
77 | _cleanup_free_ char *result = NULL; | |
78 | _cleanup_free_ void *mem = NULL; | |
79 | size_t len; | |
80 | ||
81 | assert_se(result = hexmem(in, strlen_ptr(in))); | |
82 | log_debug("hexmem(\"%s\") → \"%s\" (expected: \"%s\")", strnull(in), result, expected); | |
83 | assert_se(streq(result, expected)); | |
84 | ||
85 | assert_se(unhexmem(result, SIZE_MAX, &mem, &len) >= 0); | |
86 | assert_se(memcmp_safe(mem, in, len) == 0); | |
87 | } | |
88 | ||
89 | TEST(hexmem) { | |
90 | test_hexmem_one(NULL, ""); | |
91 | test_hexmem_one("", ""); | |
92 | test_hexmem_one("foo", "666f6f"); | |
93 | } | |
94 | ||
4937b81a YW |
95 | static void test_unhexmem_one(const char *s, size_t l, int retval) { |
96 | _cleanup_free_ char *hex = NULL; | |
13471436 RC |
97 | _cleanup_free_ void *mem = NULL; |
98 | size_t len; | |
99 | ||
4937b81a YW |
100 | assert_se(unhexmem(s, l, &mem, &len) == retval); |
101 | if (retval == 0) { | |
102 | char *answer; | |
103 | ||
f5fbe71d | 104 | if (l == SIZE_MAX) |
4937b81a YW |
105 | l = strlen(s); |
106 | ||
dcd6361e | 107 | assert_se(hex = hexmem(mem, len)); |
2f82562b | 108 | answer = strndupa_safe(strempty(s), l); |
4937b81a YW |
109 | assert_se(streq(delete_chars(answer, WHITESPACE), hex)); |
110 | } | |
111 | } | |
112 | ||
4f7452a8 | 113 | TEST(unhexmem) { |
4937b81a YW |
114 | const char *hex = "efa2149213"; |
115 | const char *hex_space = " e f a\n 2\r 14\n\r\t9\t2 \n1\r3 \r\r\t"; | |
116 | const char *hex_invalid = "efa214921o"; | |
13471436 | 117 | |
4937b81a YW |
118 | test_unhexmem_one(NULL, 0, 0); |
119 | test_unhexmem_one("", 0, 0); | |
f5fbe71d YW |
120 | test_unhexmem_one("", SIZE_MAX, 0); |
121 | test_unhexmem_one(" \n \t\r \t\t \n\n\n", SIZE_MAX, 0); | |
4937b81a YW |
122 | test_unhexmem_one(hex_invalid, strlen(hex_invalid), -EINVAL); |
123 | test_unhexmem_one(hex_invalid, (size_t) - 1, -EINVAL); | |
124 | test_unhexmem_one(hex, strlen(hex) - 1, -EPIPE); | |
125 | test_unhexmem_one(hex, strlen(hex), 0); | |
f5fbe71d | 126 | test_unhexmem_one(hex, SIZE_MAX, 0); |
4937b81a | 127 | test_unhexmem_one(hex_space, strlen(hex_space), 0); |
f5fbe71d | 128 | test_unhexmem_one(hex_space, SIZE_MAX, 0); |
13471436 RC |
129 | } |
130 | ||
131 | /* https://tools.ietf.org/html/rfc4648#section-10 */ | |
4f7452a8 | 132 | TEST(base32hexmem) { |
13471436 RC |
133 | char *b32; |
134 | ||
fbd0b64f | 135 | b32 = base32hexmem("", STRLEN(""), true); |
13471436 RC |
136 | assert_se(b32); |
137 | assert_se(streq(b32, "")); | |
138 | free(b32); | |
139 | ||
fbd0b64f | 140 | b32 = base32hexmem("f", STRLEN("f"), true); |
13471436 RC |
141 | assert_se(b32); |
142 | assert_se(streq(b32, "CO======")); | |
143 | free(b32); | |
144 | ||
fbd0b64f | 145 | b32 = base32hexmem("fo", STRLEN("fo"), true); |
13471436 RC |
146 | assert_se(b32); |
147 | assert_se(streq(b32, "CPNG====")); | |
148 | free(b32); | |
149 | ||
fbd0b64f | 150 | b32 = base32hexmem("foo", STRLEN("foo"), true); |
13471436 RC |
151 | assert_se(b32); |
152 | assert_se(streq(b32, "CPNMU===")); | |
153 | free(b32); | |
154 | ||
fbd0b64f | 155 | b32 = base32hexmem("foob", STRLEN("foob"), true); |
13471436 RC |
156 | assert_se(b32); |
157 | assert_se(streq(b32, "CPNMUOG=")); | |
158 | free(b32); | |
159 | ||
fbd0b64f | 160 | b32 = base32hexmem("fooba", STRLEN("fooba"), true); |
13471436 RC |
161 | assert_se(b32); |
162 | assert_se(streq(b32, "CPNMUOJ1")); | |
163 | free(b32); | |
164 | ||
fbd0b64f | 165 | b32 = base32hexmem("foobar", STRLEN("foobar"), true); |
13471436 RC |
166 | assert_se(b32); |
167 | assert_se(streq(b32, "CPNMUOJ1E8======")); | |
168 | free(b32); | |
169 | ||
fbd0b64f | 170 | b32 = base32hexmem("", STRLEN(""), false); |
13471436 RC |
171 | assert_se(b32); |
172 | assert_se(streq(b32, "")); | |
173 | free(b32); | |
174 | ||
fbd0b64f | 175 | b32 = base32hexmem("f", STRLEN("f"), false); |
13471436 RC |
176 | assert_se(b32); |
177 | assert_se(streq(b32, "CO")); | |
178 | free(b32); | |
179 | ||
fbd0b64f | 180 | b32 = base32hexmem("fo", STRLEN("fo"), false); |
13471436 RC |
181 | assert_se(b32); |
182 | assert_se(streq(b32, "CPNG")); | |
183 | free(b32); | |
184 | ||
fbd0b64f | 185 | b32 = base32hexmem("foo", STRLEN("foo"), false); |
13471436 RC |
186 | assert_se(b32); |
187 | assert_se(streq(b32, "CPNMU")); | |
188 | free(b32); | |
189 | ||
fbd0b64f | 190 | b32 = base32hexmem("foob", STRLEN("foob"), false); |
13471436 RC |
191 | assert_se(b32); |
192 | assert_se(streq(b32, "CPNMUOG")); | |
193 | free(b32); | |
194 | ||
fbd0b64f | 195 | b32 = base32hexmem("fooba", STRLEN("fooba"), false); |
13471436 RC |
196 | assert_se(b32); |
197 | assert_se(streq(b32, "CPNMUOJ1")); | |
198 | free(b32); | |
199 | ||
fbd0b64f | 200 | b32 = base32hexmem("foobar", STRLEN("foobar"), false); |
13471436 RC |
201 | assert_se(b32); |
202 | assert_se(streq(b32, "CPNMUOJ1E8")); | |
203 | free(b32); | |
204 | } | |
205 | ||
2d2c21af YW |
206 | static void test_unbase32hexmem_one(const char *hex, bool padding, int retval, const char *ans) { |
207 | _cleanup_free_ void *mem = NULL; | |
13471436 RC |
208 | size_t len; |
209 | ||
f5fbe71d | 210 | assert_se(unbase32hexmem(hex, SIZE_MAX, padding, &mem, &len) == retval); |
2d2c21af YW |
211 | if (retval == 0) { |
212 | char *str; | |
213 | ||
2f82562b | 214 | str = strndupa_safe(mem, len); |
2d2c21af YW |
215 | assert_se(streq(str, ans)); |
216 | } | |
217 | } | |
218 | ||
4f7452a8 | 219 | TEST(unbase32hexmem) { |
2d2c21af YW |
220 | test_unbase32hexmem_one("", true, 0, ""); |
221 | ||
222 | test_unbase32hexmem_one("CO======", true, 0, "f"); | |
223 | test_unbase32hexmem_one("CPNG====", true, 0, "fo"); | |
224 | test_unbase32hexmem_one("CPNMU===", true, 0, "foo"); | |
225 | test_unbase32hexmem_one("CPNMUOG=", true, 0, "foob"); | |
226 | test_unbase32hexmem_one("CPNMUOJ1", true, 0, "fooba"); | |
227 | test_unbase32hexmem_one("CPNMUOJ1E8======", true, 0, "foobar"); | |
228 | ||
229 | test_unbase32hexmem_one("A", true, -EINVAL, NULL); | |
230 | test_unbase32hexmem_one("A=======", true, -EINVAL, NULL); | |
231 | test_unbase32hexmem_one("AAA=====", true, -EINVAL, NULL); | |
232 | test_unbase32hexmem_one("AAAAAA==", true, -EINVAL, NULL); | |
233 | test_unbase32hexmem_one("AB======", true, -EINVAL, NULL); | |
234 | test_unbase32hexmem_one("AAAB====", true, -EINVAL, NULL); | |
235 | test_unbase32hexmem_one("AAAAB===", true, -EINVAL, NULL); | |
236 | test_unbase32hexmem_one("AAAAAAB=", true, -EINVAL, NULL); | |
237 | ||
238 | test_unbase32hexmem_one("XPNMUOJ1", true, -EINVAL, NULL); | |
239 | test_unbase32hexmem_one("CXNMUOJ1", true, -EINVAL, NULL); | |
240 | test_unbase32hexmem_one("CPXMUOJ1", true, -EINVAL, NULL); | |
241 | test_unbase32hexmem_one("CPNXUOJ1", true, -EINVAL, NULL); | |
242 | test_unbase32hexmem_one("CPNMXOJ1", true, -EINVAL, NULL); | |
243 | test_unbase32hexmem_one("CPNMUXJ1", true, -EINVAL, NULL); | |
244 | test_unbase32hexmem_one("CPNMUOX1", true, -EINVAL, NULL); | |
245 | test_unbase32hexmem_one("CPNMUOJX", true, -EINVAL, NULL); | |
246 | ||
247 | test_unbase32hexmem_one("", false, 0, ""); | |
248 | test_unbase32hexmem_one("CO", false, 0, "f"); | |
249 | test_unbase32hexmem_one("CPNG", false, 0, "fo"); | |
250 | test_unbase32hexmem_one("CPNMU", false, 0, "foo"); | |
251 | test_unbase32hexmem_one("CPNMUOG", false, 0, "foob"); | |
252 | test_unbase32hexmem_one("CPNMUOJ1", false, 0, "fooba"); | |
253 | test_unbase32hexmem_one("CPNMUOJ1E8", false, 0, "foobar"); | |
254 | test_unbase32hexmem_one("CPNMUOG=", false, -EINVAL, NULL); | |
255 | test_unbase32hexmem_one("CPNMUOJ1E8======", false, -EINVAL, NULL); | |
256 | ||
2d2c21af YW |
257 | test_unbase32hexmem_one("A", false, -EINVAL, NULL); |
258 | test_unbase32hexmem_one("AAA", false, -EINVAL, NULL); | |
259 | test_unbase32hexmem_one("AAAAAA", false, -EINVAL, NULL); | |
260 | test_unbase32hexmem_one("AB", false, -EINVAL, NULL); | |
261 | test_unbase32hexmem_one("AAAB", false, -EINVAL, NULL); | |
262 | test_unbase32hexmem_one("AAAAB", false, -EINVAL, NULL); | |
263 | test_unbase32hexmem_one("AAAAAAB", false, -EINVAL, NULL); | |
13471436 RC |
264 | } |
265 | ||
266 | /* https://tools.ietf.org/html/rfc4648#section-10 */ | |
4f7452a8 | 267 | TEST(base64mem) { |
13471436 RC |
268 | char *b64; |
269 | ||
fbd0b64f | 270 | assert_se(base64mem("", STRLEN(""), &b64) == 0); |
13471436 RC |
271 | assert_se(streq(b64, "")); |
272 | free(b64); | |
273 | ||
fbd0b64f | 274 | assert_se(base64mem("f", STRLEN("f"), &b64) == 4); |
13471436 RC |
275 | assert_se(streq(b64, "Zg==")); |
276 | free(b64); | |
277 | ||
fbd0b64f | 278 | assert_se(base64mem("fo", STRLEN("fo"), &b64) == 4); |
13471436 RC |
279 | assert_se(streq(b64, "Zm8=")); |
280 | free(b64); | |
281 | ||
fbd0b64f | 282 | assert_se(base64mem("foo", STRLEN("foo"), &b64) == 4); |
13471436 RC |
283 | assert_se(streq(b64, "Zm9v")); |
284 | free(b64); | |
285 | ||
fbd0b64f | 286 | assert_se(base64mem("foob", STRLEN("foob"), &b64) == 8); |
13471436 RC |
287 | assert_se(streq(b64, "Zm9vYg==")); |
288 | free(b64); | |
289 | ||
fbd0b64f | 290 | assert_se(base64mem("fooba", STRLEN("fooba"), &b64) == 8); |
13471436 RC |
291 | assert_se(streq(b64, "Zm9vYmE=")); |
292 | free(b64); | |
293 | ||
fbd0b64f | 294 | assert_se(base64mem("foobar", STRLEN("foobar"), &b64) == 8); |
13471436 RC |
295 | assert_se(streq(b64, "Zm9vYmFy")); |
296 | free(b64); | |
297 | } | |
298 | ||
4f7452a8 | 299 | TEST(base64mem_linebreak) { |
82b4ec44 LP |
300 | uint8_t data[4096]; |
301 | ||
302 | for (size_t i = 0; i < 20; i++) { | |
303 | _cleanup_free_ char *encoded = NULL; | |
304 | _cleanup_free_ void *decoded = NULL; | |
305 | size_t decoded_size; | |
306 | uint64_t n, m; | |
307 | ssize_t l; | |
308 | ||
309 | /* Try a bunch of differently sized blobs */ | |
310 | n = random_u64_range(sizeof(data)); | |
311 | random_bytes(data, n); | |
312 | ||
313 | /* Break at various different columns */ | |
314 | m = 1 + random_u64_range(n + 5); | |
315 | ||
316 | l = base64mem_full(data, n, m, &encoded); | |
317 | assert_se(l >= 0); | |
318 | assert_se(encoded); | |
319 | assert_se((size_t) l == strlen(encoded)); | |
320 | ||
321 | assert_se(unbase64mem(encoded, SIZE_MAX, &decoded, &decoded_size) >= 0); | |
322 | assert_se(decoded_size == n); | |
323 | assert_se(memcmp(data, decoded, n) == 0); | |
324 | ||
5040b2cf LP |
325 | /* Also try in secure mode */ |
326 | decoded = mfree(decoded); | |
327 | decoded_size = 0; | |
328 | assert_se(unbase64mem_full(encoded, SIZE_MAX, /* secure= */ true, &decoded, &decoded_size) >= 0); | |
329 | assert_se(decoded_size == n); | |
330 | assert_se(memcmp(data, decoded, n) == 0); | |
331 | ||
82b4ec44 LP |
332 | for (size_t j = 0; j < (size_t) l; j++) |
333 | assert_se((encoded[j] == '\n') == (j % (m + 1) == m)); | |
334 | } | |
335 | } | |
336 | ||
6b0df52e YW |
337 | static void test_base64_append_one(char **buf, size_t *len, const char *in, const char *expected) { |
338 | ssize_t new_len; | |
339 | ||
340 | new_len = base64_append(buf, *len, in, strlen_ptr(in), 8, 12); | |
341 | assert_se(new_len >= 0); | |
342 | log_debug("base64_append_one(\"%s\")\nresult:\n%s\nexpected:\n%s", in, strnull(*buf), strnull(expected)); | |
343 | assert_se((size_t) new_len == strlen_ptr(*buf)); | |
344 | assert_se(streq_ptr(*buf, expected)); | |
345 | *len = new_len; | |
346 | } | |
347 | ||
348 | TEST(base64_append) { | |
349 | _cleanup_free_ char *buf = NULL; | |
350 | size_t len = 0; | |
351 | ||
352 | test_base64_append_one(&buf, &len, "", NULL); | |
353 | test_base64_append_one(&buf, &len, "f", | |
354 | "Zg=="); | |
355 | test_base64_append_one(&buf, &len, "fo", | |
356 | "Zg== Zm8="); | |
357 | test_base64_append_one(&buf, &len, "foo", | |
358 | "Zg== Zm8=\n" | |
359 | " Zm9v"); | |
360 | test_base64_append_one(&buf, &len, "foob", | |
361 | "Zg== Zm8=\n" | |
362 | " Zm9v\n" | |
363 | " Zm9v\n" | |
364 | " Yg=="); | |
365 | test_base64_append_one(&buf, &len, "fooba", | |
366 | "Zg== Zm8=\n" | |
367 | " Zm9v\n" | |
368 | " Zm9v\n" | |
369 | " Yg==\n" | |
370 | " Zm9v\n" | |
371 | " YmE="); | |
372 | test_base64_append_one(&buf, &len, "foobar", | |
373 | "Zg== Zm8=\n" | |
374 | " Zm9v\n" | |
375 | " Zm9v\n" | |
376 | " Yg==\n" | |
377 | " Zm9v\n" | |
378 | " YmE=\n" | |
379 | " Zm9v\n" | |
380 | " YmFy"); | |
381 | ||
382 | assert_se(free_and_strdup(&buf, "hogehogehogehoge") >= 0); | |
383 | len = strlen(buf); | |
384 | ||
385 | test_base64_append_one(&buf, &len, "", | |
386 | "hogehogehogehoge"); | |
387 | test_base64_append_one(&buf, &len, "f", | |
388 | "hogehogehogehoge\n" | |
389 | " Zg=="); | |
390 | test_base64_append_one(&buf, &len, "fo", | |
391 | "hogehogehogehoge\n" | |
392 | " Zg==\n" | |
393 | " Zm8="); | |
394 | test_base64_append_one(&buf, &len, "foo", | |
395 | "hogehogehogehoge\n" | |
396 | " Zg==\n" | |
397 | " Zm8=\n" | |
398 | " Zm9v"); | |
399 | test_base64_append_one(&buf, &len, "foob", | |
400 | "hogehogehogehoge\n" | |
401 | " Zg==\n" | |
402 | " Zm8=\n" | |
403 | " Zm9v\n" | |
404 | " Zm9v\n" | |
405 | " Yg=="); | |
406 | test_base64_append_one(&buf, &len, "fooba", | |
407 | "hogehogehogehoge\n" | |
408 | " Zg==\n" | |
409 | " Zm8=\n" | |
410 | " Zm9v\n" | |
411 | " Zm9v\n" | |
412 | " Yg==\n" | |
413 | " Zm9v\n" | |
414 | " YmE="); | |
415 | test_base64_append_one(&buf, &len, "foobar", | |
416 | "hogehogehogehoge\n" | |
417 | " Zg==\n" | |
418 | " Zm8=\n" | |
419 | " Zm9v\n" | |
420 | " Zm9v\n" | |
421 | " Yg==\n" | |
422 | " Zm9v\n" | |
423 | " YmE=\n" | |
424 | " Zm9v\n" | |
425 | " YmFy"); | |
426 | ||
427 | assert_se(free_and_strdup(&buf, "hogehogehogehoge") >= 0); | |
428 | len = strlen(buf); | |
429 | ||
430 | test_base64_append_one(&buf, &len, "foobarfoobarfoobarfoobar", | |
431 | "hogehogehogehoge\n" | |
432 | " Zm9v\n" | |
433 | " YmFy\n" | |
434 | " Zm9v\n" | |
435 | " YmFy\n" | |
436 | " Zm9v\n" | |
437 | " YmFy\n" | |
438 | " Zm9v\n" | |
439 | " YmFy"); | |
440 | ||
441 | assert_se(free_and_strdup(&buf, "aaa") >= 0); | |
442 | len = strlen(buf); | |
443 | ||
444 | test_base64_append_one(&buf, &len, "foobarfoobarfoobarfoobar", | |
445 | "aaa Zm9vYmFy\n" | |
446 | " Zm9vYmFy\n" | |
447 | " Zm9vYmFy\n" | |
448 | " Zm9vYmFy"); | |
449 | } | |
450 | ||
081f36d8 LP |
451 | static void test_unbase64mem_one(const char *input, const char *output, int ret) { |
452 | _cleanup_free_ void *buffer = NULL; | |
453 | size_t size = 0; | |
13471436 | 454 | |
f5fbe71d | 455 | assert_se(unbase64mem(input, SIZE_MAX, &buffer, &size) == ret); |
5040b2cf LP |
456 | if (ret >= 0) { |
457 | assert_se(size == strlen(output)); | |
458 | assert_se(memcmp(buffer, output, size) == 0); | |
459 | assert_se(((char*) buffer)[size] == 0); | |
460 | } | |
461 | ||
462 | /* also try in secure mode */ | |
463 | buffer = mfree(buffer); | |
464 | size = 0; | |
13471436 | 465 | |
5040b2cf | 466 | assert_se(unbase64mem_full(input, SIZE_MAX, /* secure=*/ true, &buffer, &size) == ret); |
081f36d8 LP |
467 | if (ret >= 0) { |
468 | assert_se(size == strlen(output)); | |
469 | assert_se(memcmp(buffer, output, size) == 0); | |
470 | assert_se(((char*) buffer)[size] == 0); | |
471 | } | |
472 | } | |
13471436 | 473 | |
4f7452a8 | 474 | TEST(unbase64mem) { |
13471436 | 475 | |
081f36d8 LP |
476 | test_unbase64mem_one("", "", 0); |
477 | test_unbase64mem_one("Zg==", "f", 0); | |
478 | test_unbase64mem_one("Zm8=", "fo", 0); | |
479 | test_unbase64mem_one("Zm9v", "foo", 0); | |
480 | test_unbase64mem_one("Zm9vYg==", "foob", 0); | |
481 | test_unbase64mem_one("Zm9vYmE=", "fooba", 0); | |
482 | test_unbase64mem_one("Zm9vYmFy", "foobar", 0); | |
483 | ||
484 | test_unbase64mem_one(" ", "", 0); | |
485 | test_unbase64mem_one(" \n\r ", "", 0); | |
486 | test_unbase64mem_one(" Zg\n== ", "f", 0); | |
487 | test_unbase64mem_one(" Zm 8=\r", "fo", 0); | |
488 | test_unbase64mem_one(" Zm9\n\r\r\nv ", "foo", 0); | |
489 | test_unbase64mem_one(" Z m9vYg==\n\r", "foob", 0); | |
490 | test_unbase64mem_one(" Zm 9vYmE= ", "fooba", 0); | |
491 | test_unbase64mem_one(" Z m9v YmFy ", "foobar", 0); | |
492 | ||
493 | test_unbase64mem_one("A", NULL, -EPIPE); | |
494 | test_unbase64mem_one("A====", NULL, -EINVAL); | |
495 | test_unbase64mem_one("AAB==", NULL, -EINVAL); | |
496 | test_unbase64mem_one(" A A A B = ", NULL, -EINVAL); | |
497 | test_unbase64mem_one(" Z m 8 = q u u x ", NULL, -ENAMETOOLONG); | |
13471436 RC |
498 | } |
499 | ||
4f7452a8 | 500 | TEST(hexdump) { |
13471436 RC |
501 | uint8_t data[146]; |
502 | unsigned i; | |
503 | ||
504 | hexdump(stdout, NULL, 0); | |
505 | hexdump(stdout, "", 0); | |
506 | hexdump(stdout, "", 1); | |
507 | hexdump(stdout, "x", 1); | |
508 | hexdump(stdout, "x", 2); | |
509 | hexdump(stdout, "foobar", 7); | |
510 | hexdump(stdout, "f\nobar", 7); | |
511 | hexdump(stdout, "xxxxxxxxxxxxxxxxxxxxyz", 23); | |
512 | ||
513 | for (i = 0; i < ELEMENTSOF(data); i++) | |
514 | data[i] = i*2; | |
515 | ||
516 | hexdump(stdout, data, sizeof(data)); | |
517 | } | |
518 | ||
4f7452a8 | 519 | DEFINE_TEST_MAIN(LOG_INFO); |