]> git.proxmox.com Git - systemd.git/blame - src/test/test-util.c
projects / systemd.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Imported Upstream version 214
[systemd.git] / src / test / test-util.c
CommitLineData
663996b3
MS		 1/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3/***
4 This file is part of systemd.
5
6 Copyright 2010 Lennart Poettering
7 Copyright 2013 Thomas H.P. Andersen
8
9 systemd is free software; you can redistribute it and/or modify it
10 under the terms of the GNU Lesser General Public License as published by
11 the Free Software Foundation; either version 2.1 of the License, or
12 (at your option) any later version.
13
14 systemd is distributed in the hope that it will be useful, but
15 WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 Lesser General Public License for more details.
18
19 You should have received a copy of the GNU Lesser General Public License
20 along with systemd; If not, see <http://www.gnu.org/licenses/>.
21***/
22
23#include <string.h>
24#include <unistd.h>
25#include <fcntl.h>
26#include <locale.h>
27#include <errno.h>
28
29#include "util.h"
14228c0d 30#include "strv.h"
60f067b4
JS		 31#include "def.h"
32#include "fileio.h"
33#include "conf-parser.h"
663996b3
MS		 34
35static void test_streq_ptr(void) {
36 assert_se(streq_ptr(NULL, NULL));
37 assert_se(!streq_ptr("abc", "cdef"));
38}
39
60f067b4
JS		 40static void test_align_power2(void) {
41 unsigned long i, p2;
42
43 assert_se(ALIGN_POWER2(0) == 0);
44 assert_se(ALIGN_POWER2(1) == 1);
45 assert_se(ALIGN_POWER2(2) == 2);
46 assert_se(ALIGN_POWER2(3) == 4);
47 assert_se(ALIGN_POWER2(12) == 16);
48
49 assert_se(ALIGN_POWER2(ULONG_MAX) == 0);
50 assert_se(ALIGN_POWER2(ULONG_MAX - 1) == 0);
51 assert_se(ALIGN_POWER2(ULONG_MAX - 1024) == 0);
52 assert_se(ALIGN_POWER2(ULONG_MAX / 2) == ULONG_MAX / 2 + 1);
53 assert_se(ALIGN_POWER2(ULONG_MAX + 1) == 0);
54
55 for (i = 1; i < 131071; ++i) {
56 for (p2 = 1; p2 < i; p2 <<= 1)
57 /* empty */ ;
58
59 assert_se(ALIGN_POWER2(i) == p2);
60 }
61
62 for (i = ULONG_MAX - 1024; i < ULONG_MAX; ++i) {
63 for (p2 = 1; p2 && p2 < i; p2 <<= 1)
64 /* empty */ ;
65
66 assert_se(ALIGN_POWER2(i) == p2);
67 }
68}
69
663996b3
MS		 70static void test_first_word(void) {
71 assert_se(first_word("Hello", ""));
72 assert_se(first_word("Hello", "Hello"));
73 assert_se(first_word("Hello world", "Hello"));
74 assert_se(first_word("Hello\tworld", "Hello"));
75 assert_se(first_word("Hello\nworld", "Hello"));
76 assert_se(first_word("Hello\rworld", "Hello"));
77 assert_se(first_word("Hello ", "Hello"));
78
79 assert_se(!first_word("Hello", "Hellooo"));
80 assert_se(!first_word("Hello", "xxxxx"));
81 assert_se(!first_word("Hellooo", "Hello"));
82}
83
84static void test_close_many(void) {
85 int fds[3];
86 char name0[] = "/tmp/test-close-many.XXXXXX";
87 char name1[] = "/tmp/test-close-many.XXXXXX";
88 char name2[] = "/tmp/test-close-many.XXXXXX";
89
60f067b4
JS		 90 fds[0] = mkostemp_safe(name0, O_RDWR|O_CLOEXEC);
91 fds[1] = mkostemp_safe(name1, O_RDWR|O_CLOEXEC);
92 fds[2] = mkostemp_safe(name2, O_RDWR|O_CLOEXEC);
663996b3
MS		 93
94 close_many(fds, 2);
95
96 assert_se(fcntl(fds[0], F_GETFD) == -1);
97 assert_se(fcntl(fds[1], F_GETFD) == -1);
98 assert_se(fcntl(fds[2], F_GETFD) >= 0);
99
60f067b4 100 safe_close(fds[2]);
663996b3
MS		 101
102 unlink(name0);
103 unlink(name1);
104 unlink(name2);
105}
106
107static void test_parse_boolean(void) {
108 assert_se(parse_boolean("1") == 1);
109 assert_se(parse_boolean("y") == 1);
110 assert_se(parse_boolean("Y") == 1);
111 assert_se(parse_boolean("yes") == 1);
112 assert_se(parse_boolean("YES") == 1);
113 assert_se(parse_boolean("true") == 1);
114 assert_se(parse_boolean("TRUE") == 1);
115 assert_se(parse_boolean("on") == 1);
116 assert_se(parse_boolean("ON") == 1);
117
118 assert_se(parse_boolean("0") == 0);
119 assert_se(parse_boolean("n") == 0);
120 assert_se(parse_boolean("N") == 0);
121 assert_se(parse_boolean("no") == 0);
122 assert_se(parse_boolean("NO") == 0);
123 assert_se(parse_boolean("false") == 0);
124 assert_se(parse_boolean("FALSE") == 0);
125 assert_se(parse_boolean("off") == 0);
126 assert_se(parse_boolean("OFF") == 0);
127
128 assert_se(parse_boolean("garbage") < 0);
129 assert_se(parse_boolean("") < 0);
130}
131
132static void test_parse_pid(void) {
133 int r;
134 pid_t pid;
135
136 r = parse_pid("100", &pid);
137 assert_se(r == 0);
138 assert_se(pid == 100);
139
140 r = parse_pid("0x7FFFFFFF", &pid);
141 assert_se(r == 0);
142 assert_se(pid == 2147483647);
143
144 pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
145 r = parse_pid("0", &pid);
146 assert_se(r == -ERANGE);
147 assert_se(pid == 65);
148
149 pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
150 r = parse_pid("-100", &pid);
151 assert_se(r == -ERANGE);
152 assert_se(pid == 65);
153
154 pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
155 r = parse_pid("0xFFFFFFFFFFFFFFFFF", &pid);
156 assert(r == -ERANGE);
157 assert_se(pid == 65);
158}
159
160static void test_parse_uid(void) {
161 int r;
162 uid_t uid;
163
164 r = parse_uid("100", &uid);
165 assert_se(r == 0);
166 assert_se(uid == 100);
167}
168
169static void test_safe_atolli(void) {
170 int r;
171 long long l;
172
173 r = safe_atolli("12345", &l);
174 assert_se(r == 0);
175 assert_se(l == 12345);
176
177 r = safe_atolli("junk", &l);
178 assert_se(r == -EINVAL);
179}
180
181static void test_safe_atod(void) {
182 int r;
183 double d;
184 char *e;
185
186 r = safe_atod("junk", &d);
187 assert_se(r == -EINVAL);
188
189 r = safe_atod("0.2244", &d);
190 assert_se(r == 0);
191 assert_se(abs(d - 0.2244) < 0.000001);
192
193 r = safe_atod("0,5", &d);
194 assert_se(r == -EINVAL);
195
196 errno = 0;
197 strtod("0,5", &e);
198 assert_se(*e == ',');
199
200 /* Check if this really is locale independent */
201 setlocale(LC_NUMERIC, "de_DE.utf8");
202
203 r = safe_atod("0.2244", &d);
204 assert_se(r == 0);
205 assert_se(abs(d - 0.2244) < 0.000001);
206
207 r = safe_atod("0,5", &d);
208 assert_se(r == -EINVAL);
209
210 errno = 0;
211 assert_se(abs(strtod("0,5", &e) - 0.5) < 0.00001);
212
213 /* And check again, reset */
214 setlocale(LC_NUMERIC, "C");
215
216 r = safe_atod("0.2244", &d);
217 assert_se(r == 0);
218 assert_se(abs(d - 0.2244) < 0.000001);
219
220 r = safe_atod("0,5", &d);
221 assert_se(r == -EINVAL);
222
223 errno = 0;
224 strtod("0,5", &e);
225 assert_se(*e == ',');
226}
227
228static void test_strappend(void) {
14228c0d 229 _cleanup_free_ char *t1, *t2, *t3, *t4;
663996b3 230
14228c0d
MB		 231 t1 = strappend(NULL, NULL);
232 assert_se(streq(t1, ""));
663996b3 233
14228c0d
MB		 234 t2 = strappend(NULL, "suf");
235 assert_se(streq(t2, "suf"));
663996b3 236
14228c0d
MB		 237 t3 = strappend("pre", NULL);
238 assert_se(streq(t3, "pre"));
663996b3 239
14228c0d
MB		 240 t4 = strappend("pre", "suf");
241 assert_se(streq(t4, "presuf"));
663996b3
MS		 242}
243
244static void test_strstrip(void) {
14228c0d
MB		 245 char *r;
246 char input[] = " hello, waldo. ";
663996b3 247
14228c0d
MB		 248 r = strstrip(input);
249 assert_se(streq(r, "hello, waldo."));
663996b3
MS		 250}
251
252static void test_delete_chars(void) {
14228c0d
MB		 253 char *r;
254 char input[] = " hello, waldo. abc";
663996b3 255
14228c0d
MB		 256 r = delete_chars(input, WHITESPACE);
257 assert_se(streq(r, "hello,waldo.abc"));
663996b3
MS		 258}
259
260static void test_in_charset(void) {
14228c0d
MB		 261 assert_se(in_charset("dddaaabbbcccc", "abcd"));
262 assert_se(!in_charset("dddaaabbbcccc", "abc f"));
663996b3
MS		 263}
264
265static void test_hexchar(void) {
266 assert_se(hexchar(0xa) == 'a');
267 assert_se(hexchar(0x0) == '0');
268}
269
270static void test_unhexchar(void) {
271 assert_se(unhexchar('a') == 0xA);
272 assert_se(unhexchar('A') == 0xA);
273 assert_se(unhexchar('0') == 0x0);
274}
275
276static void test_octchar(void) {
277 assert_se(octchar(00) == '0');
278 assert_se(octchar(07) == '7');
279}
280
281static void test_unoctchar(void) {
282 assert_se(unoctchar('0') == 00);
283 assert_se(unoctchar('7') == 07);
284}
285
286static void test_decchar(void) {
287 assert_se(decchar(0) == '0');
288 assert_se(decchar(9) == '9');
289}
290
291static void test_undecchar(void) {
292 assert_se(undecchar('0') == 0);
293 assert_se(undecchar('9') == 9);
294}
295
14228c0d
MB		 296static void test_cescape(void) {
297 _cleanup_free_ char *escaped;
298 escaped = cescape("abc\\\"\b\f\n\r\t\v\003\177\234\313");
299 assert_se(streq(escaped, "abc\\\\\\\"\\b\\f\\n\\r\\t\\v\\003\\177\\234\\313"));
300}
301
302static void test_cunescape(void) {
303 _cleanup_free_ char *unescaped;
304 unescaped = cunescape("abc\\\\\\\"\\b\\f\\n\\r\\t\\v\\003\\177\\234\\313");
305 assert_se(streq(unescaped, "abc\\\"\b\f\n\r\t\v\003\177\234\313"));
306}
307
663996b3
MS		 308static void test_foreach_word(void) {
309 char *w, *state;
310 size_t l;
311 int i = 0;
312 const char test[] = "test abc d\te f ";
313 const char * const expected[] = {
314 "test",
315 "abc",
316 "d",
317 "e",
318 "f",
319 "",
320 NULL
321 };
322
323 FOREACH_WORD(w, l, test, state) {
324 assert_se(strneq(expected[i++], w, l));
325 }
326}
327
328static void test_foreach_word_quoted(void) {
329 char *w, *state;
330 size_t l;
331 int i = 0;
332 const char test[] = "test a b c 'd' e '' '' hhh '' '' \"a b c\"";
333 const char * const expected[] = {
334 "test",
335 "a",
336 "b",
337 "c",
338 "d",
339 "e",
340 "",
341 "",
342 "hhh",
343 "",
344 "",
345 "a b c",
346 NULL
347 };
348
349 printf("<%s>\n", test);
350 FOREACH_WORD_QUOTED(w, l, test, state) {
351 _cleanup_free_ char *t = NULL;
352
353 assert_se(t = strndup(w, l));
354 assert_se(strneq(expected[i++], w, l));
355 printf("<%s>\n", t);
356 }
357}
358
359static void test_default_term_for_tty(void) {
360 puts(default_term_for_tty("/dev/tty23"));
361 puts(default_term_for_tty("/dev/ttyS23"));
362 puts(default_term_for_tty("/dev/tty0"));
363 puts(default_term_for_tty("/dev/pty0"));
364 puts(default_term_for_tty("/dev/pts/0"));
365 puts(default_term_for_tty("/dev/console"));
366 puts(default_term_for_tty("tty23"));
367 puts(default_term_for_tty("ttyS23"));
368 puts(default_term_for_tty("tty0"));
369 puts(default_term_for_tty("pty0"));
370 puts(default_term_for_tty("pts/0"));
371 puts(default_term_for_tty("console"));
372}
373
374static void test_memdup_multiply(void) {
375 int org[] = {1, 2, 3};
376 int *dup;
377
378 dup = (int*)memdup_multiply(org, sizeof(int), 3);
379
380 assert_se(dup);
381 assert_se(dup[0] == 1);
382 assert_se(dup[1] == 2);
383 assert_se(dup[2] == 3);
384 free(dup);
385}
386
663996b3
MS		 387static void test_hostname_is_valid(void) {
388 assert(hostname_is_valid("foobar"));
389 assert(hostname_is_valid("foobar.com"));
390 assert(!hostname_is_valid("fööbar"));
391 assert(!hostname_is_valid(""));
392 assert(!hostname_is_valid("."));
393 assert(!hostname_is_valid(".."));
394 assert(!hostname_is_valid("foobar."));
395 assert(!hostname_is_valid(".foobar"));
396 assert(!hostname_is_valid("foo..bar"));
397 assert(!hostname_is_valid("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"));
398}
399
400static void test_u64log2(void) {
401 assert(u64log2(0) == 0);
402 assert(u64log2(8) == 3);
403 assert(u64log2(9) == 3);
404 assert(u64log2(15) == 3);
405 assert(u64log2(16) == 4);
406 assert(u64log2(1024*1024) == 20);
407 assert(u64log2(1024*1024+5) == 20);
408}
409
410static void test_get_process_comm(void) {
14228c0d 411 struct stat st;
663996b3
MS		 412 _cleanup_free_ char *a = NULL, *c = NULL, *d = NULL, *f = NULL, *i = NULL;
413 unsigned long long b;
414 pid_t e;
415 uid_t u;
416 gid_t g;
417 dev_t h;
418 int r;
419
14228c0d
MB		 420 if (stat("/proc/1/comm", &st) == 0) {
421 assert_se(get_process_comm(1, &a) >= 0);
422 log_info("pid1 comm: '%s'", a);
423 } else {
424 log_warning("/proc/1/comm does not exist.");
425 }
663996b3
MS		 426
427 assert_se(get_starttime_of_pid(1, &b) >= 0);
428 log_info("pid1 starttime: '%llu'", b);
429
430 assert_se(get_process_cmdline(1, 0, true, &c) >= 0);
431 log_info("pid1 cmdline: '%s'", c);
432
433 assert_se(get_process_cmdline(1, 8, false, &d) >= 0);
434 log_info("pid1 cmdline truncated: '%s'", d);
435
436 assert_se(get_parent_of_pid(1, &e) >= 0);
60f067b4 437 log_info("pid1 ppid: "PID_FMT, e);
663996b3
MS		 438 assert_se(e == 0);
439
440 assert_se(is_kernel_thread(1) == 0);
441
442 r = get_process_exe(1, &f);
443 assert_se(r >= 0 || r == -EACCES);
444 log_info("pid1 exe: '%s'", strna(f));
445
446 assert_se(get_process_uid(1, &u) == 0);
60f067b4 447 log_info("pid1 uid: "UID_FMT, u);
663996b3
MS		 448 assert_se(u == 0);
449
450 assert_se(get_process_gid(1, &g) == 0);
60f067b4 451 log_info("pid1 gid: "GID_FMT, g);
663996b3
MS		 452 assert_se(g == 0);
453
454 assert(get_ctty_devnr(1, &h) == -ENOENT);
455
456 getenv_for_pid(1, "PATH", &i);
457 log_info("pid1 $PATH: '%s'", strna(i));
458}
459
460static void test_protect_errno(void) {
461 errno = 12;
462 {
463 PROTECT_ERRNO;
464 errno = 11;
465 }
466 assert(errno == 12);
467}
468
60f067b4 469static void test_parse_size(void) {
14228c0d
MB		 470 off_t bytes;
471
60f067b4
JS		 472 assert_se(parse_size("111", 1024, &bytes) == 0);
473 assert_se(bytes == 111);
474
475 assert_se(parse_size("111.4", 1024, &bytes) == 0);
14228c0d
MB		 476 assert_se(bytes == 111);
477
60f067b4
JS		 478 assert_se(parse_size(" 112 B", 1024, &bytes) == 0);
479 assert_se(bytes == 112);
480
481 assert_se(parse_size(" 112.6 B", 1024, &bytes) == 0);
14228c0d
MB		 482 assert_se(bytes == 112);
483
60f067b4
JS		 484 assert_se(parse_size("3.5 K", 1024, &bytes) == 0);
485 assert_se(bytes == 3*1024 + 512);
486
487 assert_se(parse_size("3. K", 1024, &bytes) == 0);
488 assert_se(bytes == 3*1024);
489
490 assert_se(parse_size("3.0 K", 1024, &bytes) == 0);
14228c0d
MB		 491 assert_se(bytes == 3*1024);
492
60f067b4 493 assert_se(parse_size("3. 0 K", 1024, &bytes) == -EINVAL);
14228c0d 494
60f067b4
JS		 495 assert_se(parse_size(" 4 M 11.5K", 1024, &bytes) == 0);
496 assert_se(bytes == 4*1024*1024 + 11 * 1024 + 512);
14228c0d 497
60f067b4
JS		 498 assert_se(parse_size("3B3.5G", 1024, &bytes) == -EINVAL);
499
500 assert_se(parse_size("3.5G3B", 1024, &bytes) == 0);
501 assert_se(bytes == 3ULL*1024*1024*1024 + 512*1024*1024 + 3);
502
503 assert_se(parse_size("3.5G 4B", 1024, &bytes) == 0);
504 assert_se(bytes == 3ULL*1024*1024*1024 + 512*1024*1024 + 4);
505
506 assert_se(parse_size("3B3G4T", 1024, &bytes) == -EINVAL);
507
508 assert_se(parse_size("4T3G3B", 1024, &bytes) == 0);
14228c0d
MB		 509 assert_se(bytes == (4ULL*1024 + 3)*1024*1024*1024 + 3);
510
60f067b4
JS		 511 assert_se(parse_size(" 4 T 3 G 3 B", 1024, &bytes) == 0);
512 assert_se(bytes == (4ULL*1024 + 3)*1024*1024*1024 + 3);
513
514 assert_se(parse_size("12P", 1024, &bytes) == 0);
14228c0d
MB		 515 assert_se(bytes == 12ULL * 1024*1024*1024*1024*1024);
516
60f067b4
JS		 517 assert_se(parse_size("12P12P", 1024, &bytes) == -EINVAL);
518
519 assert_se(parse_size("3E 2P", 1024, &bytes) == 0);
14228c0d
MB		 520 assert_se(bytes == (3 * 1024 + 2ULL) * 1024*1024*1024*1024*1024);
521
60f067b4
JS		 522 assert_se(parse_size("12X", 1024, &bytes) == -EINVAL);
523
524 assert_se(parse_size("12.5X", 1024, &bytes) == -EINVAL);
14228c0d 525
60f067b4 526 assert_se(parse_size("12.5e3", 1024, &bytes) == -EINVAL);
14228c0d 527
60f067b4
JS		 528 assert_se(parse_size("1024E", 1024, &bytes) == -ERANGE);
529 assert_se(parse_size("-1", 1024, &bytes) == -ERANGE);
530 assert_se(parse_size("-1024E", 1024, &bytes) == -ERANGE);
14228c0d 531
60f067b4
JS		 532 assert_se(parse_size("-1024P", 1024, &bytes) == -ERANGE);
533
534 assert_se(parse_size("-10B 20K", 1024, &bytes) == -ERANGE);
535}
536
537static void test_config_parse_iec_off(void) {
538 off_t offset = 0;
539 assert_se(config_parse_iec_off(NULL, "/this/file", 11, "Section", 22, "Size", 0, "4M", &offset, NULL) == 0);
540 assert_se(offset == 4 * 1024 * 1024);
541
542 assert_se(config_parse_iec_off(NULL, "/this/file", 11, "Section", 22, "Size", 0, "4.5M", &offset, NULL) == 0);
14228c0d
MB		 543}
544
545static void test_strextend(void) {
546 _cleanup_free_ char *str = strdup("0123");
547 strextend(&str, "456", "78", "9", NULL);
548 assert_se(streq(str, "0123456789"));
549}
550
551static void test_strrep(void) {
552 _cleanup_free_ char *one, *three, *zero;
553 one = strrep("waldo", 1);
554 three = strrep("waldo", 3);
555 zero = strrep("waldo", 0);
556
557 assert_se(streq(one, "waldo"));
558 assert_se(streq(three, "waldowaldowaldo"));
559 assert_se(streq(zero, ""));
560}
561
14228c0d
MB		 562static void test_split_pair(void) {
563 _cleanup_free_ char *a = NULL, *b = NULL;
564
565 assert_se(split_pair("", "", &a, &b) == -EINVAL);
566 assert_se(split_pair("foo=bar", "", &a, &b) == -EINVAL);
567 assert_se(split_pair("", "=", &a, &b) == -EINVAL);
568 assert_se(split_pair("foo=bar", "=", &a, &b) >= 0);
569 assert_se(streq(a, "foo"));
570 assert_se(streq(b, "bar"));
571 free(a);
572 free(b);
573 assert_se(split_pair("==", "==", &a, &b) >= 0);
574 assert_se(streq(a, ""));
575 assert_se(streq(b, ""));
576 free(a);
577 free(b);
578
579 assert_se(split_pair("===", "==", &a, &b) >= 0);
580 assert_se(streq(a, ""));
581 assert_se(streq(b, "="));
582}
583
584static void test_fstab_node_to_udev_node(void) {
585 char *n;
586
587 n = fstab_node_to_udev_node("LABEL=applé/jack");
588 puts(n);
589 assert_se(streq(n, "/dev/disk/by-label/applé\\x2fjack"));
590 free(n);
591
592 n = fstab_node_to_udev_node("PARTLABEL=pinkié pie");
593 puts(n);
594 assert_se(streq(n, "/dev/disk/by-partlabel/pinkié\\x20pie"));
595 free(n);
596
597 n = fstab_node_to_udev_node("UUID=037b9d94-148e-4ee4-8d38-67bfe15bb535");
598 puts(n);
599 assert_se(streq(n, "/dev/disk/by-uuid/037b9d94-148e-4ee4-8d38-67bfe15bb535"));
600 free(n);
601
602 n = fstab_node_to_udev_node("PARTUUID=037b9d94-148e-4ee4-8d38-67bfe15bb535");
603 puts(n);
604 assert_se(streq(n, "/dev/disk/by-partuuid/037b9d94-148e-4ee4-8d38-67bfe15bb535"));
605 free(n);
606
14228c0d
MB		 607 n = fstab_node_to_udev_node("PONIES=awesome");
608 puts(n);
609 assert_se(streq(n, "PONIES=awesome"));
610 free(n);
611
612 n = fstab_node_to_udev_node("/dev/xda1");
613 puts(n);
614 assert_se(streq(n, "/dev/xda1"));
615 free(n);
616}
617
618static void test_get_files_in_directory(void) {
619 _cleanup_strv_free_ char **l = NULL, **t = NULL;
620
621 assert_se(get_files_in_directory("/tmp", &l) >= 0);
60f067b4 622 assert_se(get_files_in_directory(".", &t) >= 0);
14228c0d
MB		 623 assert_se(get_files_in_directory(".", NULL) >= 0);
624}
625
60f067b4
JS		 626static void test_in_set(void) {
627 assert_se(IN_SET(1, 1));
628 assert_se(IN_SET(1, 1, 2, 3, 4));
629 assert_se(IN_SET(2, 1, 2, 3, 4));
630 assert_se(IN_SET(3, 1, 2, 3, 4));
631 assert_se(IN_SET(4, 1, 2, 3, 4));
632 assert_se(!IN_SET(0, 1));
633 assert_se(!IN_SET(0, 1, 2, 3, 4));
634}
635
636static void test_writing_tmpfile(void) {
637 char name[] = "/tmp/test-systemd_writing_tmpfile.XXXXXX";
638 _cleanup_free_ char *contents = NULL;
639 size_t size;
640 int fd, r;
641 struct iovec iov[3];
642
643 IOVEC_SET_STRING(iov[0], "abc\n");
644 IOVEC_SET_STRING(iov[1], ALPHANUMERICAL "\n");
645 IOVEC_SET_STRING(iov[2], "");
646
647 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
648 printf("tmpfile: %s", name);
649
650 r = writev(fd, iov, 3);
651 assert(r >= 0);
652
653 r = read_full_file(name, &contents, &size);
654 assert(r == 0);
655 printf("contents: %s", contents);
656 assert(streq(contents, "abc\n" ALPHANUMERICAL "\n"));
657}
658
659static void test_hexdump(void) {
660 uint8_t data[146];
661 unsigned i;
662
663 hexdump(stdout, NULL, 0);
664 hexdump(stdout, "", 0);
665 hexdump(stdout, "", 1);
666 hexdump(stdout, "x", 1);
667 hexdump(stdout, "x", 2);
668 hexdump(stdout, "foobar", 7);
669 hexdump(stdout, "f\nobar", 7);
670 hexdump(stdout, "xxxxxxxxxxxxxxxxxxxxyz", 23);
671
672 for (i = 0; i < ELEMENTSOF(data); i++)
673 data[i] = i*2;
674
675 hexdump(stdout, data, sizeof(data));
676}
677
678static void test_log2i(void) {
679 assert_se(log2i(1) == 0);
680 assert_se(log2i(2) == 1);
681 assert_se(log2i(3) == 1);
682 assert_se(log2i(4) == 2);
683 assert_se(log2i(32) == 5);
684 assert_se(log2i(33) == 5);
685 assert_se(log2i(63) == 5);
686 assert_se(log2i(INT_MAX) == sizeof(int)*8-2);
687}
688
689static void test_foreach_string(void) {
690 const char * const t[] = {
691 "foo",
692 "bar",
693 "waldo",
694 NULL
695 };
696 const char *x;
697 unsigned i = 0;
698
699 FOREACH_STRING(x, "foo", "bar", "waldo")
700 assert_se(streq_ptr(t[i++], x));
701
702 assert_se(i == 3);
703
704 FOREACH_STRING(x, "zzz")
705 assert_se(streq(x, "zzz"));
706}
707
663996b3 708int main(int argc, char *argv[]) {
60f067b4
JS		 709 log_parse_environment();
710 log_open();
711
663996b3 712 test_streq_ptr();
60f067b4 713 test_align_power2();
663996b3
MS		 714 test_first_word();
715 test_close_many();
716 test_parse_boolean();
717 test_parse_pid();
718 test_parse_uid();
719 test_safe_atolli();
720 test_safe_atod();
721 test_strappend();
722 test_strstrip();
723 test_delete_chars();
724 test_in_charset();
725 test_hexchar();
726 test_unhexchar();
727 test_octchar();
728 test_unoctchar();
729 test_decchar();
730 test_undecchar();
14228c0d
MB		 731 test_cescape();
732 test_cunescape();
663996b3
MS		 733 test_foreach_word();
734 test_foreach_word_quoted();
735 test_default_term_for_tty();
736 test_memdup_multiply();
663996b3
MS		 737 test_hostname_is_valid();
738 test_u64log2();
739 test_get_process_comm();
740 test_protect_errno();
60f067b4
JS		 741 test_parse_size();
742 test_config_parse_iec_off();
14228c0d
MB		 743 test_strextend();
744 test_strrep();
14228c0d
MB		 745 test_split_pair();
746 test_fstab_node_to_udev_node();
747 test_get_files_in_directory();
60f067b4
JS		 748 test_in_set();
749 test_writing_tmpfile();
750 test_hexdump();
751 test_log2i();
752 test_foreach_string();
663996b3
MS		 753
754 return 0;
755}
systemd for Proxmox projects