chiark / gitweb /
build-sys: add sd_j_open_container manpage alias
[elogind.git] / src / test / test-util.c
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"
30 #include "strv.h"
31
32 static void test_streq_ptr(void) {
33         assert_se(streq_ptr(NULL, NULL));
34         assert_se(!streq_ptr("abc", "cdef"));
35 }
36
37 static void test_first_word(void) {
38         assert_se(first_word("Hello", ""));
39         assert_se(first_word("Hello", "Hello"));
40         assert_se(first_word("Hello world", "Hello"));
41         assert_se(first_word("Hello\tworld", "Hello"));
42         assert_se(first_word("Hello\nworld", "Hello"));
43         assert_se(first_word("Hello\rworld", "Hello"));
44         assert_se(first_word("Hello ", "Hello"));
45
46         assert_se(!first_word("Hello", "Hellooo"));
47         assert_se(!first_word("Hello", "xxxxx"));
48         assert_se(!first_word("Hellooo", "Hello"));
49 }
50
51 static void test_close_many(void) {
52         int fds[3];
53         char name0[] = "/tmp/test-close-many.XXXXXX";
54         char name1[] = "/tmp/test-close-many.XXXXXX";
55         char name2[] = "/tmp/test-close-many.XXXXXX";
56
57         fds[0] = mkstemp(name0);
58         fds[1] = mkstemp(name1);
59         fds[2] = mkstemp(name2);
60
61         close_many(fds, 2);
62
63         assert_se(fcntl(fds[0], F_GETFD) == -1);
64         assert_se(fcntl(fds[1], F_GETFD) == -1);
65         assert_se(fcntl(fds[2], F_GETFD) >= 0);
66
67         close_nointr_nofail(fds[2]);
68
69         unlink(name0);
70         unlink(name1);
71         unlink(name2);
72 }
73
74 static void test_parse_boolean(void) {
75         assert_se(parse_boolean("1") == 1);
76         assert_se(parse_boolean("y") == 1);
77         assert_se(parse_boolean("Y") == 1);
78         assert_se(parse_boolean("yes") == 1);
79         assert_se(parse_boolean("YES") == 1);
80         assert_se(parse_boolean("true") == 1);
81         assert_se(parse_boolean("TRUE") == 1);
82         assert_se(parse_boolean("on") == 1);
83         assert_se(parse_boolean("ON") == 1);
84
85         assert_se(parse_boolean("0") == 0);
86         assert_se(parse_boolean("n") == 0);
87         assert_se(parse_boolean("N") == 0);
88         assert_se(parse_boolean("no") == 0);
89         assert_se(parse_boolean("NO") == 0);
90         assert_se(parse_boolean("false") == 0);
91         assert_se(parse_boolean("FALSE") == 0);
92         assert_se(parse_boolean("off") == 0);
93         assert_se(parse_boolean("OFF") == 0);
94
95         assert_se(parse_boolean("garbage") < 0);
96         assert_se(parse_boolean("") < 0);
97 }
98
99 static void test_parse_pid(void) {
100         int r;
101         pid_t pid;
102
103         r = parse_pid("100", &pid);
104         assert_se(r == 0);
105         assert_se(pid == 100);
106
107         r = parse_pid("0x7FFFFFFF", &pid);
108         assert_se(r == 0);
109         assert_se(pid == 2147483647);
110
111         pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
112         r = parse_pid("0", &pid);
113         assert_se(r == -ERANGE);
114         assert_se(pid == 65);
115
116         pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
117         r = parse_pid("-100", &pid);
118         assert_se(r == -ERANGE);
119         assert_se(pid == 65);
120
121         pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
122         r = parse_pid("0xFFFFFFFFFFFFFFFFF", &pid);
123         assert(r == -ERANGE);
124         assert_se(pid == 65);
125 }
126
127 static void test_parse_uid(void) {
128         int r;
129         uid_t uid;
130
131         r = parse_uid("100", &uid);
132         assert_se(r == 0);
133         assert_se(uid == 100);
134 }
135
136 static void test_safe_atolli(void) {
137         int r;
138         long long l;
139
140         r = safe_atolli("12345", &l);
141         assert_se(r == 0);
142         assert_se(l == 12345);
143
144         r = safe_atolli("junk", &l);
145         assert_se(r == -EINVAL);
146 }
147
148 static void test_safe_atod(void) {
149         int r;
150         double d;
151         char *e;
152
153         r = safe_atod("junk", &d);
154         assert_se(r == -EINVAL);
155
156         r = safe_atod("0.2244", &d);
157         assert_se(r == 0);
158         assert_se(abs(d - 0.2244) < 0.000001);
159
160         r = safe_atod("0,5", &d);
161         assert_se(r == -EINVAL);
162
163         errno = 0;
164         strtod("0,5", &e);
165         assert_se(*e == ',');
166
167         /* Check if this really is locale independent */
168         setlocale(LC_NUMERIC, "de_DE.utf8");
169
170         r = safe_atod("0.2244", &d);
171         assert_se(r == 0);
172         assert_se(abs(d - 0.2244) < 0.000001);
173
174         r = safe_atod("0,5", &d);
175         assert_se(r == -EINVAL);
176
177         errno = 0;
178         assert_se(abs(strtod("0,5", &e) - 0.5) < 0.00001);
179
180         /* And check again, reset */
181         setlocale(LC_NUMERIC, "C");
182
183         r = safe_atod("0.2244", &d);
184         assert_se(r == 0);
185         assert_se(abs(d - 0.2244) < 0.000001);
186
187         r = safe_atod("0,5", &d);
188         assert_se(r == -EINVAL);
189
190         errno = 0;
191         strtod("0,5", &e);
192         assert_se(*e == ',');
193 }
194
195 static void test_strappend(void) {
196         _cleanup_free_ char *t1, *t2, *t3, *t4;
197
198         t1 = strappend(NULL, NULL);
199         assert_se(streq(t1, ""));
200
201         t2 = strappend(NULL, "suf");
202         assert_se(streq(t2, "suf"));
203
204         t3 = strappend("pre", NULL);
205         assert_se(streq(t3, "pre"));
206
207         t4 = strappend("pre", "suf");
208         assert_se(streq(t4, "presuf"));
209 }
210
211 static void test_strstrip(void) {
212         char *r;
213         char input[] = "   hello, waldo.   ";
214
215         r = strstrip(input);
216         assert_se(streq(r, "hello, waldo."));
217 }
218
219 static void test_delete_chars(void) {
220         char *r;
221         char input[] = "   hello, waldo.   abc";
222
223         r = delete_chars(input, WHITESPACE);
224         assert_se(streq(r, "hello,waldo.abc"));
225 }
226
227 static void test_in_charset(void) {
228         assert_se(in_charset("dddaaabbbcccc", "abcd"));
229         assert_se(!in_charset("dddaaabbbcccc", "abc f"));
230 }
231
232 static void test_hexchar(void) {
233         assert_se(hexchar(0xa) == 'a');
234         assert_se(hexchar(0x0) == '0');
235 }
236
237 static void test_unhexchar(void) {
238         assert_se(unhexchar('a') == 0xA);
239         assert_se(unhexchar('A') == 0xA);
240         assert_se(unhexchar('0') == 0x0);
241 }
242
243 static void test_octchar(void) {
244         assert_se(octchar(00) == '0');
245         assert_se(octchar(07) == '7');
246 }
247
248 static void test_unoctchar(void) {
249         assert_se(unoctchar('0') == 00);
250         assert_se(unoctchar('7') == 07);
251 }
252
253 static void test_decchar(void) {
254         assert_se(decchar(0) == '0');
255         assert_se(decchar(9) == '9');
256 }
257
258 static void test_undecchar(void) {
259         assert_se(undecchar('0') == 0);
260         assert_se(undecchar('9') == 9);
261 }
262
263 static void test_cescape(void) {
264         _cleanup_free_ char *escaped;
265         escaped = cescape("abc\\\"\b\f\n\r\t\v\003\177\234\313");
266         assert_se(streq(escaped, "abc\\\\\\\"\\b\\f\\n\\r\\t\\v\\003\\177\\234\\313"));
267 }
268
269 static void test_cunescape(void) {
270         _cleanup_free_ char *unescaped;
271         unescaped = cunescape("abc\\\\\\\"\\b\\f\\n\\r\\t\\v\\003\\177\\234\\313");
272         assert_se(streq(unescaped, "abc\\\"\b\f\n\r\t\v\003\177\234\313"));
273 }
274
275 static void test_foreach_word(void) {
276         char *w, *state;
277         size_t l;
278         int i = 0;
279         const char test[] = "test abc d\te   f   ";
280         const char * const expected[] = {
281                 "test",
282                 "abc",
283                 "d",
284                 "e",
285                 "f",
286                 "",
287                 NULL
288         };
289
290         FOREACH_WORD(w, l, test, state) {
291                 assert_se(strneq(expected[i++], w, l));
292         }
293 }
294
295 static void test_foreach_word_quoted(void) {
296         char *w, *state;
297         size_t l;
298         int i = 0;
299         const char test[] = "test a b c 'd' e '' '' hhh '' '' \"a b c\"";
300         const char * const expected[] = {
301                 "test",
302                 "a",
303                 "b",
304                 "c",
305                 "d",
306                 "e",
307                 "",
308                 "",
309                 "hhh",
310                 "",
311                 "",
312                 "a b c",
313                 NULL
314         };
315
316         printf("<%s>\n", test);
317         FOREACH_WORD_QUOTED(w, l, test, state) {
318                 _cleanup_free_ char *t = NULL;
319
320                 assert_se(t = strndup(w, l));
321                 assert_se(strneq(expected[i++], w, l));
322                 printf("<%s>\n", t);
323         }
324 }
325
326 static void test_default_term_for_tty(void) {
327         puts(default_term_for_tty("/dev/tty23"));
328         puts(default_term_for_tty("/dev/ttyS23"));
329         puts(default_term_for_tty("/dev/tty0"));
330         puts(default_term_for_tty("/dev/pty0"));
331         puts(default_term_for_tty("/dev/pts/0"));
332         puts(default_term_for_tty("/dev/console"));
333         puts(default_term_for_tty("tty23"));
334         puts(default_term_for_tty("ttyS23"));
335         puts(default_term_for_tty("tty0"));
336         puts(default_term_for_tty("pty0"));
337         puts(default_term_for_tty("pts/0"));
338         puts(default_term_for_tty("console"));
339 }
340
341 static void test_memdup_multiply(void) {
342         int org[] = {1, 2, 3};
343         int *dup;
344
345         dup = (int*)memdup_multiply(org, sizeof(int), 3);
346
347         assert_se(dup);
348         assert_se(dup[0] == 1);
349         assert_se(dup[1] == 2);
350         assert_se(dup[2] == 3);
351         free(dup);
352 }
353
354 static void test_hostname_is_valid(void) {
355         assert(hostname_is_valid("foobar"));
356         assert(hostname_is_valid("foobar.com"));
357         assert(!hostname_is_valid("fööbar"));
358         assert(!hostname_is_valid(""));
359         assert(!hostname_is_valid("."));
360         assert(!hostname_is_valid(".."));
361         assert(!hostname_is_valid("foobar."));
362         assert(!hostname_is_valid(".foobar"));
363         assert(!hostname_is_valid("foo..bar"));
364         assert(!hostname_is_valid("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"));
365 }
366
367 static void test_u64log2(void) {
368         assert(u64log2(0) == 0);
369         assert(u64log2(8) == 3);
370         assert(u64log2(9) == 3);
371         assert(u64log2(15) == 3);
372         assert(u64log2(16) == 4);
373         assert(u64log2(1024*1024) == 20);
374         assert(u64log2(1024*1024+5) == 20);
375 }
376
377 static void test_get_process_comm(void) {
378         struct stat st;
379         _cleanup_free_ char *a = NULL, *c = NULL, *d = NULL, *f = NULL, *i = NULL;
380         unsigned long long b;
381         pid_t e;
382         uid_t u;
383         gid_t g;
384         dev_t h;
385         int r;
386
387         if (stat("/proc/1/comm", &st) == 0) {
388                 assert_se(get_process_comm(1, &a) >= 0);
389                 log_info("pid1 comm: '%s'", a);
390         } else {
391                 log_warning("/proc/1/comm does not exist.");
392         }
393
394         assert_se(get_starttime_of_pid(1, &b) >= 0);
395         log_info("pid1 starttime: '%llu'", b);
396
397         assert_se(get_process_cmdline(1, 0, true, &c) >= 0);
398         log_info("pid1 cmdline: '%s'", c);
399
400         assert_se(get_process_cmdline(1, 8, false, &d) >= 0);
401         log_info("pid1 cmdline truncated: '%s'", d);
402
403         assert_se(get_parent_of_pid(1, &e) >= 0);
404         log_info("pid1 ppid: '%llu'", (unsigned long long) e);
405         assert_se(e == 0);
406
407         assert_se(is_kernel_thread(1) == 0);
408
409         r = get_process_exe(1, &f);
410         assert_se(r >= 0 || r == -EACCES);
411         log_info("pid1 exe: '%s'", strna(f));
412
413         assert_se(get_process_uid(1, &u) == 0);
414         log_info("pid1 uid: '%llu'", (unsigned long long) u);
415         assert_se(u == 0);
416
417         assert_se(get_process_gid(1, &g) == 0);
418         log_info("pid1 gid: '%llu'", (unsigned long long) g);
419         assert_se(g == 0);
420
421         assert(get_ctty_devnr(1, &h) == -ENOENT);
422
423         getenv_for_pid(1, "PATH", &i);
424         log_info("pid1 $PATH: '%s'", strna(i));
425 }
426
427 static void test_protect_errno(void) {
428         errno = 12;
429         {
430                 PROTECT_ERRNO;
431                 errno = 11;
432         }
433         assert(errno == 12);
434 }
435
436 static void test_parse_bytes(void) {
437         off_t bytes;
438
439         assert_se(parse_bytes("111", &bytes) == 0);
440         assert_se(bytes == 111);
441
442         assert_se(parse_bytes(" 112 B", &bytes) == 0);
443         assert_se(bytes == 112);
444
445         assert_se(parse_bytes("3 K", &bytes) == 0);
446         assert_se(bytes == 3*1024);
447
448         assert_se(parse_bytes(" 4 M 11K", &bytes) == 0);
449         assert_se(bytes == 4*1024*1024 + 11 * 1024);
450
451         assert_se(parse_bytes("3B3G", &bytes) == 0);
452         assert_se(bytes == 3ULL*1024*1024*1024 + 3);
453
454         assert_se(parse_bytes("3B3G4T", &bytes) == 0);
455         assert_se(bytes == (4ULL*1024 + 3)*1024*1024*1024 + 3);
456
457         assert_se(parse_bytes("12P", &bytes) == 0);
458         assert_se(bytes == 12ULL * 1024*1024*1024*1024*1024);
459
460         assert_se(parse_bytes("3E 2P", &bytes) == 0);
461         assert_se(bytes == (3 * 1024 + 2ULL) * 1024*1024*1024*1024*1024);
462
463         assert_se(parse_bytes("12X", &bytes) == -EINVAL);
464
465         assert_se(parse_bytes("1024E", &bytes) == -ERANGE);
466         assert_se(parse_bytes("-1", &bytes) == -ERANGE);
467         assert_se(parse_bytes("-1024E", &bytes) == -ERANGE);
468
469         assert_se(parse_bytes("-1024P", &bytes) == -ERANGE);
470
471         assert_se(parse_bytes("-10B 20K", &bytes) == -ERANGE);
472 }
473
474 static void test_strextend(void) {
475         _cleanup_free_ char *str = strdup("0123");
476         strextend(&str, "456", "78", "9", NULL);
477         assert_se(streq(str, "0123456789"));
478 }
479
480 static void test_strrep(void) {
481         _cleanup_free_ char *one, *three, *zero;
482         one = strrep("waldo", 1);
483         three = strrep("waldo", 3);
484         zero = strrep("waldo", 0);
485
486         assert_se(streq(one, "waldo"));
487         assert_se(streq(three, "waldowaldowaldo"));
488         assert_se(streq(zero, ""));
489 }
490
491 static void test_parse_user_at_host(void) {
492         _cleanup_free_ char *both = strdup("waldo@waldoscomputer");
493         _cleanup_free_ char *onlyhost = strdup("mikescomputer");
494         char *user = NULL, *host = NULL;
495
496         parse_user_at_host(both, &user, &host);
497         assert_se(streq(user, "waldo"));
498         assert_se(streq(host, "waldoscomputer"));
499
500         user = host = NULL;
501         parse_user_at_host(onlyhost, &user, &host);
502         assert_se(user == NULL);
503         assert_se(streq(host, "mikescomputer"));
504 }
505
506 static void test_split_pair(void) {
507         _cleanup_free_ char *a = NULL, *b = NULL;
508
509         assert_se(split_pair("", "", &a, &b) == -EINVAL);
510         assert_se(split_pair("foo=bar", "", &a, &b) == -EINVAL);
511         assert_se(split_pair("", "=", &a, &b) == -EINVAL);
512         assert_se(split_pair("foo=bar", "=", &a, &b) >= 0);
513         assert_se(streq(a, "foo"));
514         assert_se(streq(b, "bar"));
515         free(a);
516         free(b);
517         assert_se(split_pair("==", "==", &a, &b) >= 0);
518         assert_se(streq(a, ""));
519         assert_se(streq(b, ""));
520         free(a);
521         free(b);
522
523         assert_se(split_pair("===", "==", &a, &b) >= 0);
524         assert_se(streq(a, ""));
525         assert_se(streq(b, "="));
526 }
527
528 static void test_fstab_node_to_udev_node(void) {
529         char *n;
530
531         n = fstab_node_to_udev_node("LABEL=applé/jack");
532         puts(n);
533         assert_se(streq(n, "/dev/disk/by-label/applé\\x2fjack"));
534         free(n);
535
536         n = fstab_node_to_udev_node("PARTLABEL=pinkié pie");
537         puts(n);
538         assert_se(streq(n, "/dev/disk/by-partlabel/pinkié\\x20pie"));
539         free(n);
540
541         n = fstab_node_to_udev_node("UUID=037b9d94-148e-4ee4-8d38-67bfe15bb535");
542         puts(n);
543         assert_se(streq(n, "/dev/disk/by-uuid/037b9d94-148e-4ee4-8d38-67bfe15bb535"));
544         free(n);
545
546         n = fstab_node_to_udev_node("PARTUUID=037b9d94-148e-4ee4-8d38-67bfe15bb535");
547         puts(n);
548         assert_se(streq(n, "/dev/disk/by-partuuid/037b9d94-148e-4ee4-8d38-67bfe15bb535"));
549         free(n);
550
551
552         n = fstab_node_to_udev_node("PONIES=awesome");
553         puts(n);
554         assert_se(streq(n, "PONIES=awesome"));
555         free(n);
556
557         n = fstab_node_to_udev_node("/dev/xda1");
558         puts(n);
559         assert_se(streq(n, "/dev/xda1"));
560         free(n);
561 }
562
563 static void test_get_files_in_directory(void) {
564         _cleanup_strv_free_ char **l = NULL, **t = NULL;
565
566         assert_se(get_files_in_directory("/tmp", &l) >= 0);
567         assert_se(get_files_in_directory(".", &t) >= 0);
568         assert_se(get_files_in_directory(".", NULL) >= 0);
569 }
570
571 static void test_in_set(void) {
572         assert_se(IN_SET(1, 1));
573         assert_se(IN_SET(1, 1, 2, 3, 4));
574         assert_se(IN_SET(2, 1, 2, 3, 4));
575         assert_se(IN_SET(3, 1, 2, 3, 4));
576         assert_se(IN_SET(4, 1, 2, 3, 4));
577         assert_se(!IN_SET(0, 1));
578         assert_se(!IN_SET(0, 1, 2, 3, 4));
579 }
580
581 int main(int argc, char *argv[]) {
582         test_streq_ptr();
583         test_first_word();
584         test_close_many();
585         test_parse_boolean();
586         test_parse_pid();
587         test_parse_uid();
588         test_safe_atolli();
589         test_safe_atod();
590         test_strappend();
591         test_strstrip();
592         test_delete_chars();
593         test_in_charset();
594         test_hexchar();
595         test_unhexchar();
596         test_octchar();
597         test_unoctchar();
598         test_decchar();
599         test_undecchar();
600         test_cescape();
601         test_cunescape();
602         test_foreach_word();
603         test_foreach_word_quoted();
604         test_default_term_for_tty();
605         test_memdup_multiply();
606         test_hostname_is_valid();
607         test_u64log2();
608         test_get_process_comm();
609         test_protect_errno();
610         test_parse_bytes();
611         test_strextend();
612         test_strrep();
613         test_parse_user_at_host();
614         test_split_pair();
615         test_fstab_node_to_udev_node();
616         test_get_files_in_directory();
617         test_in_set();
618
619         return 0;
620 }