chiark / gitweb /
core: general cgroup rework
[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
31 static void test_streq_ptr(void) {
32         assert_se(streq_ptr(NULL, NULL));
33         assert_se(!streq_ptr("abc", "cdef"));
34 }
35
36 static void test_first_word(void) {
37         assert_se(first_word("Hello", ""));
38         assert_se(first_word("Hello", "Hello"));
39         assert_se(first_word("Hello world", "Hello"));
40         assert_se(first_word("Hello\tworld", "Hello"));
41         assert_se(first_word("Hello\nworld", "Hello"));
42         assert_se(first_word("Hello\rworld", "Hello"));
43         assert_se(first_word("Hello ", "Hello"));
44
45         assert_se(!first_word("Hello", "Hellooo"));
46         assert_se(!first_word("Hello", "xxxxx"));
47         assert_se(!first_word("Hellooo", "Hello"));
48 }
49
50 static void test_close_many(void) {
51         int fds[3];
52         char name0[] = "/tmp/test-close-many.XXXXXX";
53         char name1[] = "/tmp/test-close-many.XXXXXX";
54         char name2[] = "/tmp/test-close-many.XXXXXX";
55
56         fds[0] = mkstemp(name0);
57         fds[1] = mkstemp(name1);
58         fds[2] = mkstemp(name2);
59
60         close_many(fds, 2);
61
62         assert_se(fcntl(fds[0], F_GETFD) == -1);
63         assert_se(fcntl(fds[1], F_GETFD) == -1);
64         assert_se(fcntl(fds[2], F_GETFD) >= 0);
65
66         close_nointr_nofail(fds[2]);
67
68         unlink(name0);
69         unlink(name1);
70         unlink(name2);
71 }
72
73 static void test_parse_boolean(void) {
74         assert_se(parse_boolean("1") == 1);
75         assert_se(parse_boolean("y") == 1);
76         assert_se(parse_boolean("Y") == 1);
77         assert_se(parse_boolean("yes") == 1);
78         assert_se(parse_boolean("YES") == 1);
79         assert_se(parse_boolean("true") == 1);
80         assert_se(parse_boolean("TRUE") == 1);
81         assert_se(parse_boolean("on") == 1);
82         assert_se(parse_boolean("ON") == 1);
83
84         assert_se(parse_boolean("0") == 0);
85         assert_se(parse_boolean("n") == 0);
86         assert_se(parse_boolean("N") == 0);
87         assert_se(parse_boolean("no") == 0);
88         assert_se(parse_boolean("NO") == 0);
89         assert_se(parse_boolean("false") == 0);
90         assert_se(parse_boolean("FALSE") == 0);
91         assert_se(parse_boolean("off") == 0);
92         assert_se(parse_boolean("OFF") == 0);
93
94         assert_se(parse_boolean("garbage") < 0);
95         assert_se(parse_boolean("") < 0);
96 }
97
98 static void test_parse_pid(void) {
99         int r;
100         pid_t pid;
101
102         r = parse_pid("100", &pid);
103         assert_se(r == 0);
104         assert_se(pid == 100);
105
106         r = parse_pid("0x7FFFFFFF", &pid);
107         assert_se(r == 0);
108         assert_se(pid == 2147483647);
109
110         pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
111         r = parse_pid("0", &pid);
112         assert_se(r == -ERANGE);
113         assert_se(pid == 65);
114
115         pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
116         r = parse_pid("-100", &pid);
117         assert_se(r == -ERANGE);
118         assert_se(pid == 65);
119
120         pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
121         r = parse_pid("0xFFFFFFFFFFFFFFFFF", &pid);
122         assert(r == -ERANGE);
123         assert_se(pid == 65);
124 }
125
126 static void test_parse_uid(void) {
127         int r;
128         uid_t uid;
129
130         r = parse_uid("100", &uid);
131         assert_se(r == 0);
132         assert_se(uid == 100);
133 }
134
135 static void test_safe_atolli(void) {
136         int r;
137         long long l;
138
139         r = safe_atolli("12345", &l);
140         assert_se(r == 0);
141         assert_se(l == 12345);
142
143         r = safe_atolli("junk", &l);
144         assert_se(r == -EINVAL);
145 }
146
147 static void test_safe_atod(void) {
148         int r;
149         double d;
150         char *e;
151
152         r = safe_atod("junk", &d);
153         assert_se(r == -EINVAL);
154
155         r = safe_atod("0.2244", &d);
156         assert_se(r == 0);
157         assert_se(abs(d - 0.2244) < 0.000001);
158
159         r = safe_atod("0,5", &d);
160         assert_se(r == -EINVAL);
161
162         errno = 0;
163         strtod("0,5", &e);
164         assert_se(*e == ',');
165
166         /* Check if this really is locale independent */
167         setlocale(LC_NUMERIC, "de_DE.utf8");
168
169         r = safe_atod("0.2244", &d);
170         assert_se(r == 0);
171         assert_se(abs(d - 0.2244) < 0.000001);
172
173         r = safe_atod("0,5", &d);
174         assert_se(r == -EINVAL);
175
176         errno = 0;
177         assert_se(abs(strtod("0,5", &e) - 0.5) < 0.00001);
178
179         /* And check again, reset */
180         setlocale(LC_NUMERIC, "C");
181
182         r = safe_atod("0.2244", &d);
183         assert_se(r == 0);
184         assert_se(abs(d - 0.2244) < 0.000001);
185
186         r = safe_atod("0,5", &d);
187         assert_se(r == -EINVAL);
188
189         errno = 0;
190         strtod("0,5", &e);
191         assert_se(*e == ',');
192 }
193
194 static void test_strappend(void) {
195        _cleanup_free_ char *t1, *t2, *t3, *t4;
196
197        t1 = strappend(NULL, NULL);
198        assert_se(streq(t1, ""));
199
200        t2 = strappend(NULL, "suf");
201        assert_se(streq(t2, "suf"));
202
203        t3 = strappend("pre", NULL);
204        assert_se(streq(t3, "pre"));
205
206        t4 = strappend("pre", "suf");
207        assert_se(streq(t4, "presuf"));
208 }
209
210 static void test_strstrip(void) {
211        char *r;
212        char input[] = "   hello, waldo.   ";
213
214        r = strstrip(input);
215        assert_se(streq(r, "hello, waldo."));
216
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_foreach_word(void) {
264         char *w, *state;
265         size_t l;
266         int i = 0;
267         const char test[] = "test abc d\te   f   ";
268         const char * const expected[] = {
269                 "test",
270                 "abc",
271                 "d",
272                 "e",
273                 "f",
274                 "",
275                 NULL
276         };
277
278         FOREACH_WORD(w, l, test, state) {
279                 assert_se(strneq(expected[i++], w, l));
280         }
281 }
282
283 static void test_foreach_word_quoted(void) {
284         char *w, *state;
285         size_t l;
286         int i = 0;
287         const char test[] = "test a b c 'd' e '' '' hhh '' '' \"a b c\"";
288         const char * const expected[] = {
289                 "test",
290                 "a",
291                 "b",
292                 "c",
293                 "d",
294                 "e",
295                 "",
296                 "",
297                 "hhh",
298                 "",
299                 "",
300                 "a b c",
301                 NULL
302         };
303
304         printf("<%s>\n", test);
305         FOREACH_WORD_QUOTED(w, l, test, state) {
306                 _cleanup_free_ char *t = NULL;
307
308                 assert_se(t = strndup(w, l));
309                 assert_se(strneq(expected[i++], w, l));
310                 printf("<%s>\n", t);
311         }
312 }
313
314 static void test_default_term_for_tty(void) {
315         puts(default_term_for_tty("/dev/tty23"));
316         puts(default_term_for_tty("/dev/ttyS23"));
317         puts(default_term_for_tty("/dev/tty0"));
318         puts(default_term_for_tty("/dev/pty0"));
319         puts(default_term_for_tty("/dev/pts/0"));
320         puts(default_term_for_tty("/dev/console"));
321         puts(default_term_for_tty("tty23"));
322         puts(default_term_for_tty("ttyS23"));
323         puts(default_term_for_tty("tty0"));
324         puts(default_term_for_tty("pty0"));
325         puts(default_term_for_tty("pts/0"));
326         puts(default_term_for_tty("console"));
327 }
328
329 static void test_memdup_multiply(void) {
330         int org[] = {1, 2, 3};
331         int *dup;
332
333         dup = (int*)memdup_multiply(org, sizeof(int), 3);
334
335         assert_se(dup);
336         assert_se(dup[0] == 1);
337         assert_se(dup[1] == 2);
338         assert_se(dup[2] == 3);
339         free(dup);
340 }
341
342 static void test_bus_path_escape_one(const char *a, const char *b) {
343         _cleanup_free_ char *t = NULL, *x = NULL, *y = NULL;
344
345         assert_se(t = bus_path_escape(a));
346         assert_se(streq(t, b));
347
348         assert_se(x = bus_path_unescape(t));
349         assert_se(streq(a, x));
350
351         assert_se(y = bus_path_unescape(b));
352         assert_se(streq(a, y));
353 }
354
355 static void test_bus_path_escape(void) {
356         test_bus_path_escape_one("foo123bar", "foo123bar");
357         test_bus_path_escape_one("foo.bar", "foo_2ebar");
358         test_bus_path_escape_one("foo_2ebar", "foo_5f2ebar");
359         test_bus_path_escape_one("", "_");
360         test_bus_path_escape_one("_", "_5f");
361         test_bus_path_escape_one("1", "_31");
362         test_bus_path_escape_one(":1", "_3a1");
363 }
364
365 static void test_hostname_is_valid(void) {
366         assert(hostname_is_valid("foobar"));
367         assert(hostname_is_valid("foobar.com"));
368         assert(!hostname_is_valid("fööbar"));
369         assert(!hostname_is_valid(""));
370         assert(!hostname_is_valid("."));
371         assert(!hostname_is_valid(".."));
372         assert(!hostname_is_valid("foobar."));
373         assert(!hostname_is_valid(".foobar"));
374         assert(!hostname_is_valid("foo..bar"));
375         assert(!hostname_is_valid("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"));
376 }
377
378 static void test_u64log2(void) {
379         assert(u64log2(0) == 0);
380         assert(u64log2(8) == 3);
381         assert(u64log2(9) == 3);
382         assert(u64log2(15) == 3);
383         assert(u64log2(16) == 4);
384         assert(u64log2(1024*1024) == 20);
385         assert(u64log2(1024*1024+5) == 20);
386 }
387
388 static void test_get_process_comm(void) {
389         _cleanup_free_ char *a = NULL, *c = NULL, *d = NULL, *f = NULL, *i = NULL;
390         unsigned long long b;
391         pid_t e;
392         uid_t u;
393         gid_t g;
394         dev_t h;
395         int r;
396
397         assert_se(get_process_comm(1, &a) >= 0);
398         log_info("pid1 comm: '%s'", a);
399
400         assert_se(get_starttime_of_pid(1, &b) >= 0);
401         log_info("pid1 starttime: '%llu'", b);
402
403         assert_se(get_process_cmdline(1, 0, true, &c) >= 0);
404         log_info("pid1 cmdline: '%s'", c);
405
406         assert_se(get_process_cmdline(1, 8, false, &d) >= 0);
407         log_info("pid1 cmdline truncated: '%s'", d);
408
409         assert_se(get_parent_of_pid(1, &e) >= 0);
410         log_info("pid1 ppid: '%llu'", (unsigned long long) e);
411         assert_se(e == 0);
412
413         assert_se(is_kernel_thread(1) == 0);
414
415         r = get_process_exe(1, &f);
416         assert_se(r >= 0 || r == -EACCES);
417         log_info("pid1 exe: '%s'", strna(f));
418
419         assert_se(get_process_uid(1, &u) == 0);
420         log_info("pid1 uid: '%llu'", (unsigned long long) u);
421         assert_se(u == 0);
422
423         assert_se(get_process_gid(1, &g) == 0);
424         log_info("pid1 gid: '%llu'", (unsigned long long) g);
425         assert_se(g == 0);
426
427         assert(get_ctty_devnr(1, &h) == -ENOENT);
428
429         getenv_for_pid(1, "PATH", &i);
430         log_info("pid1 $PATH: '%s'", strna(i));
431 }
432
433 static void test_protect_errno(void) {
434         errno = 12;
435         {
436                 PROTECT_ERRNO;
437                 errno = 11;
438         }
439         assert(errno == 12);
440 }
441
442 static void test_parse_bytes(void) {
443         off_t bytes;
444
445         assert_se(parse_bytes("111", &bytes) == 0);
446         assert_se(bytes == 111);
447
448         assert_se(parse_bytes(" 112 B", &bytes) == 0);
449         assert_se(bytes == 112);
450
451         assert_se(parse_bytes("3 K", &bytes) == 0);
452         assert_se(bytes == 3*1024);
453
454         assert_se(parse_bytes(" 4 M 11K", &bytes) == 0);
455         assert_se(bytes == 4*1024*1024 + 11 * 1024);
456
457         assert_se(parse_bytes("3B3G", &bytes) == 0);
458         assert_se(bytes == 3ULL*1024*1024*1024 + 3);
459
460         assert_se(parse_bytes("3B3G4T", &bytes) == 0);
461         assert_se(bytes == (4ULL*1024 + 3)*1024*1024*1024 + 3);
462
463         assert_se(parse_bytes("12P", &bytes) == 0);
464         assert_se(bytes == 12ULL * 1024*1024*1024*1024*1024);
465
466         assert_se(parse_bytes("3E 2P", &bytes) == 0);
467         assert_se(bytes == (3 * 1024 + 2ULL) * 1024*1024*1024*1024*1024);
468
469         assert_se(parse_bytes("12X", &bytes) == -EINVAL);
470
471         assert_se(parse_bytes("1024E", &bytes) == -ERANGE);
472         assert_se(parse_bytes("-1", &bytes) == -ERANGE);
473         assert_se(parse_bytes("-1024E", &bytes) == -ERANGE);
474
475         assert_se(parse_bytes("-1024P", &bytes) == -ERANGE);
476
477         assert_se(parse_bytes("-10B 20K", &bytes) == -ERANGE);
478 }
479
480 int main(int argc, char *argv[]) {
481         test_streq_ptr();
482         test_first_word();
483         test_close_many();
484         test_parse_boolean();
485         test_parse_pid();
486         test_parse_uid();
487         test_safe_atolli();
488         test_safe_atod();
489         test_strappend();
490         test_strstrip();
491         test_delete_chars();
492         test_in_charset();
493         test_hexchar();
494         test_unhexchar();
495         test_octchar();
496         test_unoctchar();
497         test_decchar();
498         test_undecchar();
499         test_foreach_word();
500         test_foreach_word_quoted();
501         test_default_term_for_tty();
502         test_memdup_multiply();
503         test_bus_path_escape();
504         test_hostname_is_valid();
505         test_u64log2();
506         test_get_process_comm();
507         test_protect_errno();
508         test_parse_bytes();
509
510         return 0;
511 }