]> git.ipfire.org Git - thirdparty/systemd.git/blame - src/test/test-hexdecoct.c
projects / thirdparty / systemd.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
log: minimize includes in log.h
[thirdparty/systemd.git] / src / test / test-hexdecoct.c
CommitLineData
53e1b683 1/* SPDX-License-Identifier: LGPL-2.1+ */
13471436
RC		 2/***
3 This file is part of systemd.
4
5 Copyright 2010 Lennart Poettering
6
7 systemd is free software; you can redistribute it and/or modify it
8 under the terms of the GNU Lesser General Public License as published by
9 the Free Software Foundation; either version 2.1 of the License, or
10 (at your option) any later version.
11
12 systemd is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Lesser General Public License for more details.
16
17 You should have received a copy of the GNU Lesser General Public License
18 along with systemd; If not, see <http://www.gnu.org/licenses/>.
19***/
20
dccca82b
LP		 21#include <errno.h>
22
13471436
RC		 23#include "alloc-util.h"
24#include "hexdecoct.h"
25#include "macro.h"
26#include "string-util.h"
27
28static void test_hexchar(void) {
29 assert_se(hexchar(0xa) == 'a');
30 assert_se(hexchar(0x0) == '0');
31}
32
33static void test_unhexchar(void) {
34 assert_se(unhexchar('a') == 0xA);
35 assert_se(unhexchar('A') == 0xA);
36 assert_se(unhexchar('0') == 0x0);
37}
38
39static void test_base32hexchar(void) {
40 assert_se(base32hexchar(0) == '0');
41 assert_se(base32hexchar(9) == '9');
42 assert_se(base32hexchar(10) == 'A');
43 assert_se(base32hexchar(31) == 'V');
44}
45
46static void test_unbase32hexchar(void) {
47 assert_se(unbase32hexchar('0') == 0);
48 assert_se(unbase32hexchar('9') == 9);
49 assert_se(unbase32hexchar('A') == 10);
50 assert_se(unbase32hexchar('V') == 31);
51 assert_se(unbase32hexchar('=') == -EINVAL);
52}
53
54static void test_base64char(void) {
55 assert_se(base64char(0) == 'A');
56 assert_se(base64char(26) == 'a');
57 assert_se(base64char(63) == '/');
58}
59
60static void test_unbase64char(void) {
61 assert_se(unbase64char('A') == 0);
62 assert_se(unbase64char('Z') == 25);
63 assert_se(unbase64char('a') == 26);
64 assert_se(unbase64char('z') == 51);
65 assert_se(unbase64char('0') == 52);
66 assert_se(unbase64char('9') == 61);
67 assert_se(unbase64char('+') == 62);
68 assert_se(unbase64char('/') == 63);
69 assert_se(unbase64char('=') == -EINVAL);
70}
71
72static void test_octchar(void) {
73 assert_se(octchar(00) == '0');
74 assert_se(octchar(07) == '7');
75}
76
77static void test_unoctchar(void) {
78 assert_se(unoctchar('0') == 00);
79 assert_se(unoctchar('7') == 07);
80}
81
82static void test_decchar(void) {
83 assert_se(decchar(0) == '0');
84 assert_se(decchar(9) == '9');
85}
86
87static void test_undecchar(void) {
88 assert_se(undecchar('0') == 0);
89 assert_se(undecchar('9') == 9);
90}
91
92static void test_unhexmem(void) {
a93c4776 93 const char *hex = "efa2149213";
13471436
RC		 94 const char *hex_invalid = "efa214921o";
95 _cleanup_free_ char *hex2 = NULL;
96 _cleanup_free_ void *mem = NULL;
97 size_t len;
98
13471436 99 assert_se(unhexmem(hex_invalid, strlen(hex_invalid), &mem, &len) == -EINVAL);
a93c4776
LP		 100 assert_se(unhexmem(hex, strlen(hex) + 1, &mem, &len) == -EINVAL);
101 assert_se(unhexmem(hex, strlen(hex) - 1, &mem, &len) == -EINVAL);
102 assert_se(unhexmem(hex, strlen(hex), &mem, &len) == 0);
13471436
RC		 103
104 assert_se((hex2 = hexmem(mem, len)));
a93c4776 105 assert_se(streq(hex, hex2));
13471436
RC		 106}
107
108/* https://tools.ietf.org/html/rfc4648#section-10 */
109static void test_base32hexmem(void) {
110 char *b32;
111
fbd0b64f 112 b32 = base32hexmem("", STRLEN(""), true);
13471436
RC		 113 assert_se(b32);
114 assert_se(streq(b32, ""));
115 free(b32);
116
fbd0b64f 117 b32 = base32hexmem("f", STRLEN("f"), true);
13471436
RC		 118 assert_se(b32);
119 assert_se(streq(b32, "CO======"));
120 free(b32);
121
fbd0b64f 122 b32 = base32hexmem("fo", STRLEN("fo"), true);
13471436
RC		 123 assert_se(b32);
124 assert_se(streq(b32, "CPNG===="));
125 free(b32);
126
fbd0b64f 127 b32 = base32hexmem("foo", STRLEN("foo"), true);
13471436
RC		 128 assert_se(b32);
129 assert_se(streq(b32, "CPNMU==="));
130 free(b32);
131
fbd0b64f 132 b32 = base32hexmem("foob", STRLEN("foob"), true);
13471436
RC		 133 assert_se(b32);
134 assert_se(streq(b32, "CPNMUOG="));
135 free(b32);
136
fbd0b64f 137 b32 = base32hexmem("fooba", STRLEN("fooba"), true);
13471436
RC		 138 assert_se(b32);
139 assert_se(streq(b32, "CPNMUOJ1"));
140 free(b32);
141
fbd0b64f 142 b32 = base32hexmem("foobar", STRLEN("foobar"), true);
13471436
RC		 143 assert_se(b32);
144 assert_se(streq(b32, "CPNMUOJ1E8======"));
145 free(b32);
146
fbd0b64f 147 b32 = base32hexmem("", STRLEN(""), false);
13471436
RC		 148 assert_se(b32);
149 assert_se(streq(b32, ""));
150 free(b32);
151
fbd0b64f 152 b32 = base32hexmem("f", STRLEN("f"), false);
13471436
RC		 153 assert_se(b32);
154 assert_se(streq(b32, "CO"));
155 free(b32);
156
fbd0b64f 157 b32 = base32hexmem("fo", STRLEN("fo"), false);
13471436
RC		 158 assert_se(b32);
159 assert_se(streq(b32, "CPNG"));
160 free(b32);
161
fbd0b64f 162 b32 = base32hexmem("foo", STRLEN("foo"), false);
13471436
RC		 163 assert_se(b32);
164 assert_se(streq(b32, "CPNMU"));
165 free(b32);
166
fbd0b64f 167 b32 = base32hexmem("foob", STRLEN("foob"), false);
13471436
RC		 168 assert_se(b32);
169 assert_se(streq(b32, "CPNMUOG"));
170 free(b32);
171
fbd0b64f 172 b32 = base32hexmem("fooba", STRLEN("fooba"), false);
13471436
RC		 173 assert_se(b32);
174 assert_se(streq(b32, "CPNMUOJ1"));
175 free(b32);
176
fbd0b64f 177 b32 = base32hexmem("foobar", STRLEN("foobar"), false);
13471436
RC		 178 assert_se(b32);
179 assert_se(streq(b32, "CPNMUOJ1E8"));
180 free(b32);
181}
182
183static void test_unbase32hexmem(void) {
184 void *mem;
185 size_t len;
186
fbd0b64f 187 assert_se(unbase32hexmem("", STRLEN(""), true, &mem, &len) == 0);
13471436
RC		 188 assert_se(streq(strndupa(mem, len), ""));
189 free(mem);
190
fbd0b64f 191 assert_se(unbase32hexmem("CO======", STRLEN("CO======"), true, &mem, &len) == 0);
13471436
RC		 192 assert_se(streq(strndupa(mem, len), "f"));
193 free(mem);
194
fbd0b64f 195 assert_se(unbase32hexmem("CPNG====", STRLEN("CPNG===="), true, &mem, &len) == 0);
13471436
RC		 196 assert_se(streq(strndupa(mem, len), "fo"));
197 free(mem);
198
fbd0b64f 199 assert_se(unbase32hexmem("CPNMU===", STRLEN("CPNMU==="), true, &mem, &len) == 0);
13471436
RC		 200 assert_se(streq(strndupa(mem, len), "foo"));
201 free(mem);
202
fbd0b64f 203 assert_se(unbase32hexmem("CPNMUOG=", STRLEN("CPNMUOG="), true, &mem, &len) == 0);
13471436
RC		 204 assert_se(streq(strndupa(mem, len), "foob"));
205 free(mem);
206
fbd0b64f 207 assert_se(unbase32hexmem("CPNMUOJ1", STRLEN("CPNMUOJ1"), true, &mem, &len) == 0);
13471436
RC		 208 assert_se(streq(strndupa(mem, len), "fooba"));
209 free(mem);
210
fbd0b64f 211 assert_se(unbase32hexmem("CPNMUOJ1E8======", STRLEN("CPNMUOJ1E8======"), true, &mem, &len) == 0);
13471436
RC		 212 assert_se(streq(strndupa(mem, len), "foobar"));
213 free(mem);
214
fbd0b64f
LP		 215 assert_se(unbase32hexmem("A", STRLEN("A"), true, &mem, &len) == -EINVAL);
216 assert_se(unbase32hexmem("A=======", STRLEN("A======="), true, &mem, &len) == -EINVAL);
217 assert_se(unbase32hexmem("AAA=====", STRLEN("AAA====="), true, &mem, &len) == -EINVAL);
218 assert_se(unbase32hexmem("AAAAAA==", STRLEN("AAAAAA=="), true, &mem, &len) == -EINVAL);
219 assert_se(unbase32hexmem("AB======", STRLEN("AB======"), true, &mem, &len) == -EINVAL);
220 assert_se(unbase32hexmem("AAAB====", STRLEN("AAAB===="), true, &mem, &len) == -EINVAL);
221 assert_se(unbase32hexmem("AAAAB===", STRLEN("AAAAB==="), true, &mem, &len) == -EINVAL);
222 assert_se(unbase32hexmem("AAAAAAB=", STRLEN("AAAAAAB="), true, &mem, &len) == -EINVAL);
223
224 assert_se(unbase32hexmem("XPNMUOJ1", STRLEN("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
225 assert_se(unbase32hexmem("CXNMUOJ1", STRLEN("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
226 assert_se(unbase32hexmem("CPXMUOJ1", STRLEN("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
227 assert_se(unbase32hexmem("CPNXUOJ1", STRLEN("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
228 assert_se(unbase32hexmem("CPNMXOJ1", STRLEN("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
229 assert_se(unbase32hexmem("CPNMUXJ1", STRLEN("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
230 assert_se(unbase32hexmem("CPNMUOX1", STRLEN("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
231 assert_se(unbase32hexmem("CPNMUOJX", STRLEN("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
232
233 assert_se(unbase32hexmem("", STRLEN(""), false, &mem, &len) == 0);
13471436
RC		 234 assert_se(streq(strndupa(mem, len), ""));
235 free(mem);
236
fbd0b64f 237 assert_se(unbase32hexmem("CO", STRLEN("CO"), false, &mem, &len) == 0);
13471436
RC		 238 assert_se(streq(strndupa(mem, len), "f"));
239 free(mem);
240
fbd0b64f 241 assert_se(unbase32hexmem("CPNG", STRLEN("CPNG"), false, &mem, &len) == 0);
13471436
RC		 242 assert_se(streq(strndupa(mem, len), "fo"));
243 free(mem);
244
fbd0b64f 245 assert_se(unbase32hexmem("CPNMU", STRLEN("CPNMU"), false, &mem, &len) == 0);
13471436
RC		 246 assert_se(streq(strndupa(mem, len), "foo"));
247 free(mem);
248
fbd0b64f 249 assert_se(unbase32hexmem("CPNMUOG", STRLEN("CPNMUOG"), false, &mem, &len) == 0);
13471436
RC		 250 assert_se(streq(strndupa(mem, len), "foob"));
251 free(mem);
252
fbd0b64f 253 assert_se(unbase32hexmem("CPNMUOJ1", STRLEN("CPNMUOJ1"), false, &mem, &len) == 0);
13471436
RC		 254 assert_se(streq(strndupa(mem, len), "fooba"));
255 free(mem);
256
fbd0b64f 257 assert_se(unbase32hexmem("CPNMUOJ1E8", STRLEN("CPNMUOJ1E8"), false, &mem, &len) == 0);
13471436
RC		 258 assert_se(streq(strndupa(mem, len), "foobar"));
259 free(mem);
260
fbd0b64f
LP		 261 assert_se(unbase32hexmem("CPNMUOG=", STRLEN("CPNMUOG="), false, &mem, &len) == -EINVAL);
262 assert_se(unbase32hexmem("CPNMUOJ1E8======", STRLEN("CPNMUOJ1E8======"), false, &mem, &len) == -EINVAL);
263 assert_se(unbase32hexmem("A", STRLEN("A"), false, &mem, &len) == -EINVAL);
264 assert_se(unbase32hexmem("A", STRLEN("A"), false, &mem, &len) == -EINVAL);
265 assert_se(unbase32hexmem("AAA", STRLEN("AAA"), false, &mem, &len) == -EINVAL);
266 assert_se(unbase32hexmem("AAAAAA", STRLEN("AAAAAA"), false, &mem, &len) == -EINVAL);
267 assert_se(unbase32hexmem("AB", STRLEN("AB"), false, &mem, &len) == -EINVAL);
268 assert_se(unbase32hexmem("AAAB", STRLEN("AAAB"), false, &mem, &len) == -EINVAL);
269 assert_se(unbase32hexmem("AAAAB", STRLEN("AAAAB"), false, &mem, &len) == -EINVAL);
270 assert_se(unbase32hexmem("AAAAAAB", STRLEN("AAAAAAB"), false, &mem, &len) == -EINVAL);
13471436
RC		 271}
272
273/* https://tools.ietf.org/html/rfc4648#section-10 */
274static void test_base64mem(void) {
275 char *b64;
276
fbd0b64f 277 assert_se(base64mem("", STRLEN(""), &b64) == 0);
13471436
RC		 278 assert_se(streq(b64, ""));
279 free(b64);
280
fbd0b64f 281 assert_se(base64mem("f", STRLEN("f"), &b64) == 4);
13471436
RC		 282 assert_se(streq(b64, "Zg=="));
283 free(b64);
284
fbd0b64f 285 assert_se(base64mem("fo", STRLEN("fo"), &b64) == 4);
13471436
RC		 286 assert_se(streq(b64, "Zm8="));
287 free(b64);
288
fbd0b64f 289 assert_se(base64mem("foo", STRLEN("foo"), &b64) == 4);
13471436
RC		 290 assert_se(streq(b64, "Zm9v"));
291 free(b64);
292
fbd0b64f 293 assert_se(base64mem("foob", STRLEN("foob"), &b64) == 8);
13471436
RC		 294 assert_se(streq(b64, "Zm9vYg=="));
295 free(b64);
296
fbd0b64f 297 assert_se(base64mem("fooba", STRLEN("fooba"), &b64) == 8);
13471436
RC		 298 assert_se(streq(b64, "Zm9vYmE="));
299 free(b64);
300
fbd0b64f 301 assert_se(base64mem("foobar", STRLEN("foobar"), &b64) == 8);
13471436
RC		 302 assert_se(streq(b64, "Zm9vYmFy"));
303 free(b64);
304}
305
081f36d8
LP		 306static void test_unbase64mem_one(const char *input, const char *output, int ret) {
307 _cleanup_free_ void *buffer = NULL;
308 size_t size = 0;
13471436 309
081f36d8 310 assert_se(unbase64mem(input, (size_t) -1, &buffer, &size) == ret);
13471436 311
081f36d8
LP		 312 if (ret >= 0) {
313 assert_se(size == strlen(output));
314 assert_se(memcmp(buffer, output, size) == 0);
315 assert_se(((char*) buffer)[size] == 0);
316 }
317}
13471436 318
081f36d8 319static void test_unbase64mem(void) {
13471436 320
081f36d8
LP		 321 test_unbase64mem_one("", "", 0);
322 test_unbase64mem_one("Zg==", "f", 0);
323 test_unbase64mem_one("Zm8=", "fo", 0);
324 test_unbase64mem_one("Zm9v", "foo", 0);
325 test_unbase64mem_one("Zm9vYg==", "foob", 0);
326 test_unbase64mem_one("Zm9vYmE=", "fooba", 0);
327 test_unbase64mem_one("Zm9vYmFy", "foobar", 0);
328
329 test_unbase64mem_one(" ", "", 0);
330 test_unbase64mem_one(" \n\r ", "", 0);
331 test_unbase64mem_one(" Zg\n== ", "f", 0);
332 test_unbase64mem_one(" Zm 8=\r", "fo", 0);
333 test_unbase64mem_one(" Zm9\n\r\r\nv ", "foo", 0);
334 test_unbase64mem_one(" Z m9vYg==\n\r", "foob", 0);
335 test_unbase64mem_one(" Zm 9vYmE= ", "fooba", 0);
336 test_unbase64mem_one(" Z m9v YmFy ", "foobar", 0);
337
338 test_unbase64mem_one("A", NULL, -EPIPE);
339 test_unbase64mem_one("A====", NULL, -EINVAL);
340 test_unbase64mem_one("AAB==", NULL, -EINVAL);
341 test_unbase64mem_one(" A A A B = ", NULL, -EINVAL);
342 test_unbase64mem_one(" Z m 8 = q u u x ", NULL, -ENAMETOOLONG);
13471436
RC		 343}
344
345static void test_hexdump(void) {
346 uint8_t data[146];
347 unsigned i;
348
349 hexdump(stdout, NULL, 0);
350 hexdump(stdout, "", 0);
351 hexdump(stdout, "", 1);
352 hexdump(stdout, "x", 1);
353 hexdump(stdout, "x", 2);
354 hexdump(stdout, "foobar", 7);
355 hexdump(stdout, "f\nobar", 7);
356 hexdump(stdout, "xxxxxxxxxxxxxxxxxxxxyz", 23);
357
358 for (i = 0; i < ELEMENTSOF(data); i++)
359 data[i] = i*2;
360
361 hexdump(stdout, data, sizeof(data));
362}
363
364int main(int argc, char *argv[]) {
365 test_hexchar();
366 test_unhexchar();
367 test_base32hexchar();
368 test_unbase32hexchar();
369 test_base64char();
370 test_unbase64char();
371 test_octchar();
372 test_unoctchar();
373 test_decchar();
374 test_undecchar();
375 test_unhexmem();
376 test_base32hexmem();
377 test_unbase32hexmem();
378 test_base64mem();
379 test_unbase64mem();
380 test_hexdump();
381
382 return 0;
383}
Unnamed repository; edit this file 'description' to name the repository.