chiark / gitweb /
util: properly escape corner cases in bus_path_escape(), too
[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
25 #include "util.h"
26
27 static void test_streq_ptr(void) {
28         assert_se(streq_ptr(NULL, NULL));
29         assert_se(!streq_ptr("abc", "cdef"));
30 }
31
32 static void test_first_word(void) {
33         assert_se(first_word("Hello", ""));
34         assert_se(first_word("Hello", "Hello"));
35         assert_se(first_word("Hello world", "Hello"));
36         assert_se(first_word("Hello\tworld", "Hello"));
37         assert_se(first_word("Hello\nworld", "Hello"));
38         assert_se(first_word("Hello\rworld", "Hello"));
39         assert_se(first_word("Hello ", "Hello"));
40
41         assert_se(!first_word("Hello", "Hellooo"));
42         assert_se(!first_word("Hello", "xxxxx"));
43         assert_se(!first_word("Hellooo", "Hello"));
44 }
45
46 static void test_parse_boolean(void) {
47         assert_se(parse_boolean("1") == 1);
48         assert_se(parse_boolean("y") == 1);
49         assert_se(parse_boolean("Y") == 1);
50         assert_se(parse_boolean("yes") == 1);
51         assert_se(parse_boolean("YES") == 1);
52         assert_se(parse_boolean("true") == 1);
53         assert_se(parse_boolean("TRUE") == 1);
54         assert_se(parse_boolean("on") == 1);
55         assert_se(parse_boolean("ON") == 1);
56
57         assert_se(parse_boolean("0") == 0);
58         assert_se(parse_boolean("n") == 0);
59         assert_se(parse_boolean("N") == 0);
60         assert_se(parse_boolean("no") == 0);
61         assert_se(parse_boolean("NO") == 0);
62         assert_se(parse_boolean("false") == 0);
63         assert_se(parse_boolean("FALSE") == 0);
64         assert_se(parse_boolean("off") == 0);
65         assert_se(parse_boolean("OFF") == 0);
66
67         assert_se(parse_boolean("garbage") < 0);
68         assert_se(parse_boolean("") < 0);
69 }
70
71 static void test_parse_pid(void) {
72         int r;
73         pid_t pid;
74
75         r = parse_pid("100", &pid);
76         assert_se(r == 0);
77         assert_se(pid == 100);
78
79         r = parse_pid("0x7FFFFFFF", &pid);
80         assert_se(r == 0);
81         assert_se(pid == 2147483647);
82
83         pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
84         r = parse_pid("0", &pid);
85         assert_se(r == -ERANGE);
86         assert_se(pid == 65);
87
88         pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
89         r = parse_pid("-100", &pid);
90         assert_se(r == -ERANGE);
91         assert_se(pid == 65);
92
93         pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
94         r = parse_pid("0xFFFFFFFFFFFFFFFFF", &pid);
95         assert(r == -ERANGE);
96         assert_se(pid == 65);
97 }
98
99 static void test_parse_uid(void) {
100         int r;
101         uid_t uid;
102
103         r = parse_uid("100", &uid);
104         assert_se(r == 0);
105         assert_se(uid == 100);
106 }
107
108 static void test_safe_atolli(void) {
109         int r;
110         long long l;
111
112         r = safe_atolli("12345", &l);
113         assert_se(r == 0);
114         assert_se(l == 12345);
115
116         r = safe_atolli("junk", &l);
117         assert_se(r == -EINVAL);
118 }
119
120 static void test_safe_atod(void) {
121         int r;
122         double d;
123
124         r = safe_atod("0.2244", &d);
125         assert_se(r == 0);
126         assert_se(abs(d - 0.2244) < 0.000001);
127
128         r = safe_atod("junk", &d);
129         assert_se(r == -EINVAL);
130 }
131
132 static void test_strstrip(void) {
133        char *r;
134        char input[] = "   hello, waldo.   ";
135
136        r = strstrip(input);
137        assert_se(streq(r, "hello, waldo."));
138
139 }
140
141 static void test_delete_chars(void) {
142        char *r;
143        char input[] = "   hello, waldo.   abc";
144
145        r = delete_chars(input, WHITESPACE);
146        assert_se(streq(r, "hello,waldo.abc"));
147 }
148
149 static void test_in_charset(void) {
150       assert_se(in_charset("dddaaabbbcccc", "abcd"));
151       assert_se(!in_charset("dddaaabbbcccc", "abc f"));
152 }
153
154 static void test_hexchar(void) {
155         assert_se(hexchar(0xa) == 'a');
156         assert_se(hexchar(0x0) == '0');
157 }
158
159 static void test_unhexchar(void) {
160         assert_se(unhexchar('a') == 0xA);
161         assert_se(unhexchar('A') == 0xA);
162         assert_se(unhexchar('0') == 0x0);
163 }
164
165 static void test_octchar(void) {
166         assert_se(octchar(00) == '0');
167         assert_se(octchar(07) == '7');
168 }
169
170 static void test_unoctchar(void) {
171         assert_se(unoctchar('0') == 00);
172         assert_se(unoctchar('7') == 07);
173 }
174
175 static void test_decchar(void) {
176         assert_se(decchar(0) == '0');
177         assert_se(decchar(9) == '9');
178 }
179
180 static void test_undecchar(void) {
181         assert_se(undecchar('0') == 0);
182         assert_se(undecchar('9') == 9);
183 }
184
185 static void test_foreach_word(void) {
186         char *w, *state;
187         size_t l;
188         int i = 0;
189         const char test[] = "test abc d\te   f   ";
190         const char * const expected[] = {
191                 "test",
192                 "abc",
193                 "d",
194                 "e",
195                 "f",
196                 "",
197                 NULL
198         };
199
200         FOREACH_WORD(w, l, test, state) {
201                 assert_se(strneq(expected[i++], w, l));
202         }
203 }
204
205 static void test_foreach_word_quoted(void) {
206         char *w, *state;
207         size_t l;
208         int i = 0;
209         const char test[] = "test a b c 'd' e '' '' hhh '' '' \"a b c\"";
210         const char * const expected[] = {
211                 "test",
212                 "a",
213                 "b",
214                 "c",
215                 "d",
216                 "e",
217                 "",
218                 "",
219                 "hhh",
220                 "",
221                 "",
222                 "a b c",
223                 NULL
224         };
225
226         printf("<%s>\n", test);
227         FOREACH_WORD_QUOTED(w, l, test, state) {
228                 _cleanup_free_ char *t = NULL;
229
230                 assert_se(t = strndup(w, l));
231                 assert_se(strneq(expected[i++], w, l));
232                 printf("<%s>\n", t);
233         }
234 }
235
236 static void test_default_term_for_tty(void) {
237         puts(default_term_for_tty("/dev/tty23"));
238         puts(default_term_for_tty("/dev/ttyS23"));
239         puts(default_term_for_tty("/dev/tty0"));
240         puts(default_term_for_tty("/dev/pty0"));
241         puts(default_term_for_tty("/dev/pts/0"));
242         puts(default_term_for_tty("/dev/console"));
243         puts(default_term_for_tty("tty23"));
244         puts(default_term_for_tty("ttyS23"));
245         puts(default_term_for_tty("tty0"));
246         puts(default_term_for_tty("pty0"));
247         puts(default_term_for_tty("pts/0"));
248         puts(default_term_for_tty("console"));
249 }
250
251 static void test_memdup_multiply(void) {
252         int org[] = {1, 2, 3};
253         int *dup;
254
255         dup = (int*)memdup_multiply(org, sizeof(int), 3);
256
257         assert_se(dup);
258         assert_se(dup[0] == 1);
259         assert_se(dup[1] == 2);
260         assert_se(dup[2] == 3);
261         free(dup);
262 }
263
264 static void test_bus_path_escape_one(const char *a, const char *b) {
265         _cleanup_free_ char *t = NULL, *x = NULL, *y = NULL;
266
267         assert_se(t = bus_path_escape(a));
268         assert_se(streq(t, b));
269
270         assert_se(x = bus_path_unescape(t));
271         assert_se(streq(a, x));
272
273         assert_se(y = bus_path_unescape(b));
274         assert_se(streq(a, y));
275 }
276
277 static void test_bus_path_escape(void) {
278         test_bus_path_escape_one("foo123bar", "foo123bar");
279         test_bus_path_escape_one("foo.bar", "foo_2ebar");
280         test_bus_path_escape_one("foo_2ebar", "foo_5f2ebar");
281         test_bus_path_escape_one("", "_");
282         test_bus_path_escape_one("_", "_5f");
283         test_bus_path_escape_one("1", "_31");
284         test_bus_path_escape_one(":1", "_3a1");
285 }
286
287 int main(int argc, char *argv[]) {
288         test_streq_ptr();
289         test_first_word();
290         test_parse_boolean();
291         test_parse_pid();
292         test_parse_uid();
293         test_safe_atolli();
294         test_safe_atod();
295         test_strstrip();
296         test_delete_chars();
297         test_in_charset();
298         test_hexchar();
299         test_unhexchar();
300         test_octchar();
301         test_unoctchar();
302         test_decchar();
303         test_undecchar();
304         test_foreach_word();
305         test_foreach_word_quoted();
306         test_default_term_for_tty();
307         test_memdup_multiply();
308         test_bus_path_escape();
309
310         return 0;
311 }