]>
git.ipfire.org Git - thirdparty/systemd.git/blob - src/test/test-parse-util.c
1 /* SPDX-License-Identifier: LGPL-2.1+ */
3 This file is part of systemd.
5 Copyright 2010 Lennart Poettering
6 Copyright 2013 Thomas H.P. Andersen
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
25 #include "alloc-util.h"
26 #include "errno-list.h"
28 #include "parse-util.h"
29 #include "string-util.h"
31 static void test_parse_boolean(void) {
32 assert_se(parse_boolean("1") == 1);
33 assert_se(parse_boolean("y") == 1);
34 assert_se(parse_boolean("Y") == 1);
35 assert_se(parse_boolean("yes") == 1);
36 assert_se(parse_boolean("YES") == 1);
37 assert_se(parse_boolean("true") == 1);
38 assert_se(parse_boolean("TRUE") == 1);
39 assert_se(parse_boolean("on") == 1);
40 assert_se(parse_boolean("ON") == 1);
42 assert_se(parse_boolean("0") == 0);
43 assert_se(parse_boolean("n") == 0);
44 assert_se(parse_boolean("N") == 0);
45 assert_se(parse_boolean("no") == 0);
46 assert_se(parse_boolean("NO") == 0);
47 assert_se(parse_boolean("false") == 0);
48 assert_se(parse_boolean("FALSE") == 0);
49 assert_se(parse_boolean("off") == 0);
50 assert_se(parse_boolean("OFF") == 0);
52 assert_se(parse_boolean("garbage") < 0);
53 assert_se(parse_boolean("") < 0);
54 assert_se(parse_boolean("full") < 0);
57 static void test_parse_pid(void) {
61 r
= parse_pid("100", &pid
);
63 assert_se(pid
== 100);
65 r
= parse_pid("0x7FFFFFFF", &pid
);
67 assert_se(pid
== 2147483647);
69 pid
= 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
70 r
= parse_pid("0", &pid
);
71 assert_se(r
== -ERANGE
);
74 pid
= 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
75 r
= parse_pid("-100", &pid
);
76 assert_se(r
== -ERANGE
);
79 pid
= 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
80 r
= parse_pid("0xFFFFFFFFFFFFFFFFF", &pid
);
81 assert_se(r
== -ERANGE
);
84 r
= parse_pid("junk", &pid
);
85 assert_se(r
== -EINVAL
);
87 r
= parse_pid("", &pid
);
88 assert_se(r
== -EINVAL
);
91 static void test_parse_mode(void) {
94 assert_se(parse_mode("-1", &m
) < 0);
95 assert_se(parse_mode("", &m
) < 0);
96 assert_se(parse_mode("888", &m
) < 0);
97 assert_se(parse_mode("77777", &m
) < 0);
99 assert_se(parse_mode("544", &m
) >= 0 && m
== 0544);
100 assert_se(parse_mode("777", &m
) >= 0 && m
== 0777);
101 assert_se(parse_mode("7777", &m
) >= 0 && m
== 07777);
102 assert_se(parse_mode("0", &m
) >= 0 && m
== 0);
105 static void test_parse_size(void) {
108 assert_se(parse_size("", 1024, &bytes
) == -EINVAL
);
110 assert_se(parse_size("111", 1024, &bytes
) == 0);
111 assert_se(bytes
== 111);
113 assert_se(parse_size("111.4", 1024, &bytes
) == 0);
114 assert_se(bytes
== 111);
116 assert_se(parse_size(" 112 B", 1024, &bytes
) == 0);
117 assert_se(bytes
== 112);
119 assert_se(parse_size(" 112.6 B", 1024, &bytes
) == 0);
120 assert_se(bytes
== 112);
122 assert_se(parse_size("3.5 K", 1024, &bytes
) == 0);
123 assert_se(bytes
== 3*1024 + 512);
125 assert_se(parse_size("3. K", 1024, &bytes
) == 0);
126 assert_se(bytes
== 3*1024);
128 assert_se(parse_size("3.0 K", 1024, &bytes
) == 0);
129 assert_se(bytes
== 3*1024);
131 assert_se(parse_size("3. 0 K", 1024, &bytes
) == -EINVAL
);
133 assert_se(parse_size(" 4 M 11.5K", 1024, &bytes
) == 0);
134 assert_se(bytes
== 4*1024*1024 + 11 * 1024 + 512);
136 assert_se(parse_size("3B3.5G", 1024, &bytes
) == -EINVAL
);
138 assert_se(parse_size("3.5G3B", 1024, &bytes
) == 0);
139 assert_se(bytes
== 3ULL*1024*1024*1024 + 512*1024*1024 + 3);
141 assert_se(parse_size("3.5G 4B", 1024, &bytes
) == 0);
142 assert_se(bytes
== 3ULL*1024*1024*1024 + 512*1024*1024 + 4);
144 assert_se(parse_size("3B3G4T", 1024, &bytes
) == -EINVAL
);
146 assert_se(parse_size("4T3G3B", 1024, &bytes
) == 0);
147 assert_se(bytes
== (4ULL*1024 + 3)*1024*1024*1024 + 3);
149 assert_se(parse_size(" 4 T 3 G 3 B", 1024, &bytes
) == 0);
150 assert_se(bytes
== (4ULL*1024 + 3)*1024*1024*1024 + 3);
152 assert_se(parse_size("12P", 1024, &bytes
) == 0);
153 assert_se(bytes
== 12ULL * 1024*1024*1024*1024*1024);
155 assert_se(parse_size("12P12P", 1024, &bytes
) == -EINVAL
);
157 assert_se(parse_size("3E 2P", 1024, &bytes
) == 0);
158 assert_se(bytes
== (3 * 1024 + 2ULL) * 1024*1024*1024*1024*1024);
160 assert_se(parse_size("12X", 1024, &bytes
) == -EINVAL
);
162 assert_se(parse_size("12.5X", 1024, &bytes
) == -EINVAL
);
164 assert_se(parse_size("12.5e3", 1024, &bytes
) == -EINVAL
);
166 assert_se(parse_size("1024E", 1024, &bytes
) == -ERANGE
);
167 assert_se(parse_size("-1", 1024, &bytes
) == -ERANGE
);
168 assert_se(parse_size("-1024E", 1024, &bytes
) == -ERANGE
);
170 assert_se(parse_size("-1024P", 1024, &bytes
) == -ERANGE
);
172 assert_se(parse_size("-10B 20K", 1024, &bytes
) == -ERANGE
);
175 static void test_parse_range(void) {
176 unsigned lower
, upper
;
178 /* Successful cases */
179 assert_se(parse_range("111", &lower
, &upper
) == 0);
180 assert_se(lower
== 111);
181 assert_se(upper
== 111);
183 assert_se(parse_range("111-123", &lower
, &upper
) == 0);
184 assert_se(lower
== 111);
185 assert_se(upper
== 123);
187 assert_se(parse_range("123-111", &lower
, &upper
) == 0);
188 assert_se(lower
== 123);
189 assert_se(upper
== 111);
191 assert_se(parse_range("123-123", &lower
, &upper
) == 0);
192 assert_se(lower
== 123);
193 assert_se(upper
== 123);
195 assert_se(parse_range("0", &lower
, &upper
) == 0);
196 assert_se(lower
== 0);
197 assert_se(upper
== 0);
199 assert_se(parse_range("0-15", &lower
, &upper
) == 0);
200 assert_se(lower
== 0);
201 assert_se(upper
== 15);
203 assert_se(parse_range("15-0", &lower
, &upper
) == 0);
204 assert_se(lower
== 15);
205 assert_se(upper
== 0);
207 assert_se(parse_range("128-65535", &lower
, &upper
) == 0);
208 assert_se(lower
== 128);
209 assert_se(upper
== 65535);
211 assert_se(parse_range("1024-4294967295", &lower
, &upper
) == 0);
212 assert_se(lower
== 1024);
213 assert_se(upper
== 4294967295);
215 /* Leading whitespace is acceptable */
216 assert_se(parse_range(" 111", &lower
, &upper
) == 0);
217 assert_se(lower
== 111);
218 assert_se(upper
== 111);
220 assert_se(parse_range(" 111-123", &lower
, &upper
) == 0);
221 assert_se(lower
== 111);
222 assert_se(upper
== 123);
224 assert_se(parse_range("111- 123", &lower
, &upper
) == 0);
225 assert_se(lower
== 111);
226 assert_se(upper
== 123);
228 assert_se(parse_range("\t111-\t123", &lower
, &upper
) == 0);
229 assert_se(lower
== 111);
230 assert_se(upper
== 123);
232 assert_se(parse_range(" \t 111- \t 123", &lower
, &upper
) == 0);
233 assert_se(lower
== 111);
234 assert_se(upper
== 123);
236 /* Error cases, make sure they fail as expected */
237 lower
= upper
= 9999;
238 assert_se(parse_range("111garbage", &lower
, &upper
) == -EINVAL
);
239 assert_se(lower
== 9999);
240 assert_se(upper
== 9999);
242 assert_se(parse_range("garbage111", &lower
, &upper
) == -EINVAL
);
243 assert_se(lower
== 9999);
244 assert_se(upper
== 9999);
246 assert_se(parse_range("garbage", &lower
, &upper
) == -EINVAL
);
247 assert_se(lower
== 9999);
248 assert_se(upper
== 9999);
250 assert_se(parse_range("111-123garbage", &lower
, &upper
) == -EINVAL
);
251 assert_se(lower
== 9999);
252 assert_se(upper
== 9999);
254 assert_se(parse_range("111garbage-123", &lower
, &upper
) == -EINVAL
);
255 assert_se(lower
== 9999);
256 assert_se(upper
== 9999);
259 lower
= upper
= 9999;
260 assert_se(parse_range("", &lower
, &upper
) == -EINVAL
);
261 assert_se(lower
== 9999);
262 assert_se(upper
== 9999);
264 /* 111--123 will pass -123 to safe_atou which returns -ERANGE for negative */
265 assert_se(parse_range("111--123", &lower
, &upper
) == -ERANGE
);
266 assert_se(lower
== 9999);
267 assert_se(upper
== 9999);
269 assert_se(parse_range("-123", &lower
, &upper
) == -EINVAL
);
270 assert_se(lower
== 9999);
271 assert_se(upper
== 9999);
273 assert_se(parse_range("-111-123", &lower
, &upper
) == -EINVAL
);
274 assert_se(lower
== 9999);
275 assert_se(upper
== 9999);
277 assert_se(parse_range("111-123-", &lower
, &upper
) == -EINVAL
);
278 assert_se(lower
== 9999);
279 assert_se(upper
== 9999);
281 assert_se(parse_range("111.4-123", &lower
, &upper
) == -EINVAL
);
282 assert_se(lower
== 9999);
283 assert_se(upper
== 9999);
285 assert_se(parse_range("111-123.4", &lower
, &upper
) == -EINVAL
);
286 assert_se(lower
== 9999);
287 assert_se(upper
== 9999);
289 assert_se(parse_range("111,4-123", &lower
, &upper
) == -EINVAL
);
290 assert_se(lower
== 9999);
291 assert_se(upper
== 9999);
293 assert_se(parse_range("111-123,4", &lower
, &upper
) == -EINVAL
);
294 assert_se(lower
== 9999);
295 assert_se(upper
== 9999);
297 /* Error on trailing dash */
298 assert_se(parse_range("111-", &lower
, &upper
) == -EINVAL
);
299 assert_se(lower
== 9999);
300 assert_se(upper
== 9999);
302 assert_se(parse_range("111-123-", &lower
, &upper
) == -EINVAL
);
303 assert_se(lower
== 9999);
304 assert_se(upper
== 9999);
306 assert_se(parse_range("111--", &lower
, &upper
) == -EINVAL
);
307 assert_se(lower
== 9999);
308 assert_se(upper
== 9999);
310 assert_se(parse_range("111- ", &lower
, &upper
) == -EINVAL
);
311 assert_se(lower
== 9999);
312 assert_se(upper
== 9999);
314 /* Whitespace is not a separator */
315 assert_se(parse_range("111 123", &lower
, &upper
) == -EINVAL
);
316 assert_se(lower
== 9999);
317 assert_se(upper
== 9999);
319 assert_se(parse_range("111\t123", &lower
, &upper
) == -EINVAL
);
320 assert_se(lower
== 9999);
321 assert_se(upper
== 9999);
323 assert_se(parse_range("111 \t 123", &lower
, &upper
) == -EINVAL
);
324 assert_se(lower
== 9999);
325 assert_se(upper
== 9999);
327 /* Trailing whitespace is invalid (from safe_atou) */
328 assert_se(parse_range("111 ", &lower
, &upper
) == -EINVAL
);
329 assert_se(lower
== 9999);
330 assert_se(upper
== 9999);
332 assert_se(parse_range("111-123 ", &lower
, &upper
) == -EINVAL
);
333 assert_se(lower
== 9999);
334 assert_se(upper
== 9999);
336 assert_se(parse_range("111 -123", &lower
, &upper
) == -EINVAL
);
337 assert_se(lower
== 9999);
338 assert_se(upper
== 9999);
340 assert_se(parse_range("111 -123 ", &lower
, &upper
) == -EINVAL
);
341 assert_se(lower
== 9999);
342 assert_se(upper
== 9999);
344 assert_se(parse_range("111\t-123\t", &lower
, &upper
) == -EINVAL
);
345 assert_se(lower
== 9999);
346 assert_se(upper
== 9999);
348 assert_se(parse_range("111 \t -123 \t ", &lower
, &upper
) == -EINVAL
);
349 assert_se(lower
== 9999);
350 assert_se(upper
== 9999);
352 /* Out of the "unsigned" range, this is 1<<64 */
353 assert_se(parse_range("0-18446744073709551616", &lower
, &upper
) == -ERANGE
);
354 assert_se(lower
== 9999);
355 assert_se(upper
== 9999);
358 static void test_safe_atolli(void) {
362 r
= safe_atolli("12345", &l
);
364 assert_se(l
== 12345);
366 r
= safe_atolli(" 12345", &l
);
368 assert_se(l
== 12345);
370 r
= safe_atolli("-12345", &l
);
372 assert_se(l
== -12345);
374 r
= safe_atolli(" -12345", &l
);
376 assert_se(l
== -12345);
378 r
= safe_atolli("12345678901234567890", &l
);
379 assert_se(r
== -ERANGE
);
381 r
= safe_atolli("-12345678901234567890", &l
);
382 assert_se(r
== -ERANGE
);
384 r
= safe_atolli("junk", &l
);
385 assert_se(r
== -EINVAL
);
387 r
= safe_atolli("123x", &l
);
388 assert_se(r
== -EINVAL
);
390 r
= safe_atolli("12.3", &l
);
391 assert_se(r
== -EINVAL
);
393 r
= safe_atolli("", &l
);
394 assert_se(r
== -EINVAL
);
397 static void test_safe_atou16(void) {
401 r
= safe_atou16("12345", &l
);
403 assert_se(l
== 12345);
405 r
= safe_atou16(" 12345", &l
);
407 assert_se(l
== 12345);
409 r
= safe_atou16("123456", &l
);
410 assert_se(r
== -ERANGE
);
412 r
= safe_atou16("-1", &l
);
413 assert_se(r
== -ERANGE
);
415 r
= safe_atou16(" -1", &l
);
416 assert_se(r
== -ERANGE
);
418 r
= safe_atou16("junk", &l
);
419 assert_se(r
== -EINVAL
);
421 r
= safe_atou16("123x", &l
);
422 assert_se(r
== -EINVAL
);
424 r
= safe_atou16("12.3", &l
);
425 assert_se(r
== -EINVAL
);
427 r
= safe_atou16("", &l
);
428 assert_se(r
== -EINVAL
);
431 static void test_safe_atoi16(void) {
435 r
= safe_atoi16("-12345", &l
);
437 assert_se(l
== -12345);
439 r
= safe_atoi16(" -12345", &l
);
441 assert_se(l
== -12345);
443 r
= safe_atoi16("32767", &l
);
445 assert_se(l
== 32767);
447 r
= safe_atoi16(" 32767", &l
);
449 assert_se(l
== 32767);
451 r
= safe_atoi16("36536", &l
);
452 assert_se(r
== -ERANGE
);
454 r
= safe_atoi16("-32769", &l
);
455 assert_se(r
== -ERANGE
);
457 r
= safe_atoi16("junk", &l
);
458 assert_se(r
== -EINVAL
);
460 r
= safe_atoi16("123x", &l
);
461 assert_se(r
== -EINVAL
);
463 r
= safe_atoi16("12.3", &l
);
464 assert_se(r
== -EINVAL
);
466 r
= safe_atoi16("", &l
);
467 assert_se(r
== -EINVAL
);
470 static void test_safe_atou64(void) {
474 r
= safe_atou64("12345", &l
);
476 assert_se(l
== 12345);
478 r
= safe_atou64(" 12345", &l
);
480 assert_se(l
== 12345);
482 r
= safe_atou64("18446744073709551617", &l
);
483 assert_se(r
== -ERANGE
);
485 r
= safe_atou64("-1", &l
);
486 assert_se(r
== -ERANGE
);
488 r
= safe_atou64(" -1", &l
);
489 assert_se(r
== -ERANGE
);
491 r
= safe_atou64("junk", &l
);
492 assert_se(r
== -EINVAL
);
494 r
= safe_atou64("123x", &l
);
495 assert_se(r
== -EINVAL
);
497 r
= safe_atou64("12.3", &l
);
498 assert_se(r
== -EINVAL
);
500 r
= safe_atou64("", &l
);
501 assert_se(r
== -EINVAL
);
504 static void test_safe_atoi64(void) {
508 r
= safe_atoi64("-12345", &l
);
510 assert_se(l
== -12345);
512 r
= safe_atoi64(" -12345", &l
);
514 assert_se(l
== -12345);
516 r
= safe_atoi64("32767", &l
);
518 assert_se(l
== 32767);
520 r
= safe_atoi64(" 32767", &l
);
522 assert_se(l
== 32767);
524 r
= safe_atoi64("9223372036854775813", &l
);
525 assert_se(r
== -ERANGE
);
527 r
= safe_atoi64("-9223372036854775813", &l
);
528 assert_se(r
== -ERANGE
);
530 r
= safe_atoi64("junk", &l
);
531 assert_se(r
== -EINVAL
);
533 r
= safe_atoi64("123x", &l
);
534 assert_se(r
== -EINVAL
);
536 r
= safe_atoi64("12.3", &l
);
537 assert_se(r
== -EINVAL
);
539 r
= safe_atoi64("", &l
);
540 assert_se(r
== -EINVAL
);
543 static void test_safe_atod(void) {
548 r
= safe_atod("junk", &d
);
549 assert_se(r
== -EINVAL
);
551 r
= safe_atod("0.2244", &d
);
553 assert_se(fabs(d
- 0.2244) < 0.000001);
555 r
= safe_atod("0,5", &d
);
556 assert_se(r
== -EINVAL
);
560 assert_se(*e
== ',');
562 r
= safe_atod("", &d
);
563 assert_se(r
== -EINVAL
);
565 /* Check if this really is locale independent */
566 if (setlocale(LC_NUMERIC
, "de_DE.utf8")) {
568 r
= safe_atod("0.2244", &d
);
570 assert_se(fabs(d
- 0.2244) < 0.000001);
572 r
= safe_atod("0,5", &d
);
573 assert_se(r
== -EINVAL
);
576 assert_se(fabs(strtod("0,5", &e
) - 0.5) < 0.00001);
578 r
= safe_atod("", &d
);
579 assert_se(r
== -EINVAL
);
582 /* And check again, reset */
583 assert_se(setlocale(LC_NUMERIC
, "C"));
585 r
= safe_atod("0.2244", &d
);
587 assert_se(fabs(d
- 0.2244) < 0.000001);
589 r
= safe_atod("0,5", &d
);
590 assert_se(r
== -EINVAL
);
594 assert_se(*e
== ',');
596 r
= safe_atod("", &d
);
597 assert_se(r
== -EINVAL
);
600 static void test_parse_percent(void) {
601 assert_se(parse_percent("") == -EINVAL
);
602 assert_se(parse_percent("foo") == -EINVAL
);
603 assert_se(parse_percent("0") == -EINVAL
);
604 assert_se(parse_percent("50") == -EINVAL
);
605 assert_se(parse_percent("100") == -EINVAL
);
606 assert_se(parse_percent("-1") == -EINVAL
);
607 assert_se(parse_percent("0%") == 0);
608 assert_se(parse_percent("55%") == 55);
609 assert_se(parse_percent("100%") == 100);
610 assert_se(parse_percent("-7%") == -ERANGE
);
611 assert_se(parse_percent("107%") == -ERANGE
);
612 assert_se(parse_percent("%") == -EINVAL
);
613 assert_se(parse_percent("%%") == -EINVAL
);
614 assert_se(parse_percent("%1") == -EINVAL
);
615 assert_se(parse_percent("1%%") == -EINVAL
);
616 assert_se(parse_percent("3.2%") == -EINVAL
);
619 static void test_parse_percent_unbounded(void) {
620 assert_se(parse_percent_unbounded("101%") == 101);
621 assert_se(parse_percent_unbounded("400%") == 400);
624 static void test_parse_nice(void) {
627 assert_se(parse_nice("0", &n
) >= 0 && n
== 0);
628 assert_se(parse_nice("+0", &n
) >= 0 && n
== 0);
629 assert_se(parse_nice("-1", &n
) >= 0 && n
== -1);
630 assert_se(parse_nice("-2", &n
) >= 0 && n
== -2);
631 assert_se(parse_nice("1", &n
) >= 0 && n
== 1);
632 assert_se(parse_nice("2", &n
) >= 0 && n
== 2);
633 assert_se(parse_nice("+1", &n
) >= 0 && n
== 1);
634 assert_se(parse_nice("+2", &n
) >= 0 && n
== 2);
635 assert_se(parse_nice("-20", &n
) >= 0 && n
== -20);
636 assert_se(parse_nice("19", &n
) >= 0 && n
== 19);
637 assert_se(parse_nice("+19", &n
) >= 0 && n
== 19);
640 assert_se(parse_nice("", &n
) == -EINVAL
);
641 assert_se(parse_nice("-", &n
) == -EINVAL
);
642 assert_se(parse_nice("+", &n
) == -EINVAL
);
643 assert_se(parse_nice("xx", &n
) == -EINVAL
);
644 assert_se(parse_nice("-50", &n
) == -ERANGE
);
645 assert_se(parse_nice("50", &n
) == -ERANGE
);
646 assert_se(parse_nice("+50", &n
) == -ERANGE
);
647 assert_se(parse_nice("-21", &n
) == -ERANGE
);
648 assert_se(parse_nice("20", &n
) == -ERANGE
);
649 assert_se(parse_nice("+20", &n
) == -ERANGE
);
652 static void test_parse_dev(void) {
655 assert_se(parse_dev("", &dev
) == -EINVAL
);
656 assert_se(parse_dev("junk", &dev
) == -EINVAL
);
657 assert_se(parse_dev("0", &dev
) == -EINVAL
);
658 assert_se(parse_dev("5", &dev
) == -EINVAL
);
659 assert_se(parse_dev("5:", &dev
) == -EINVAL
);
660 assert_se(parse_dev(":5", &dev
) == -EINVAL
);
662 assert_se(parse_dev("4294967295:4294967295", &dev
) == -EINVAL
);
664 assert_se(parse_dev("8:11", &dev
) >= 0 && major(dev
) == 8 && minor(dev
) == 11);
667 static void test_parse_errno(void) {
668 assert_se(parse_errno("EILSEQ") == EILSEQ
);
669 assert_se(parse_errno("EINVAL") == EINVAL
);
670 assert_se(parse_errno("0") == 0);
671 assert_se(parse_errno("1") == 1);
672 assert_se(parse_errno("4095") == 4095);
674 assert_se(parse_errno("-1") == -ERANGE
);
675 assert_se(parse_errno("-3") == -ERANGE
);
676 assert_se(parse_errno("4096") == -ERANGE
);
678 assert_se(parse_errno("") == -EINVAL
);
679 assert_se(parse_errno("12.3") == -EINVAL
);
680 assert_se(parse_errno("123junk") == -EINVAL
);
681 assert_se(parse_errno("junk123") == -EINVAL
);
682 assert_se(parse_errno("255EILSEQ") == -EINVAL
);
683 assert_se(parse_errno("EINVAL12") == -EINVAL
);
684 assert_se(parse_errno("-EINVAL") == -EINVAL
);
685 assert_se(parse_errno("EINVALaaa") == -EINVAL
);
688 static void test_parse_syscall_and_errno(void) {
689 _cleanup_free_
char *n
= NULL
;
692 assert_se(parse_syscall_and_errno("uname:EILSEQ", &n
, &e
) >= 0);
693 assert_se(streq(n
, "uname"));
694 assert_se(e
== errno_from_name("EILSEQ") && e
>= 0);
697 assert_se(parse_syscall_and_errno("uname:EINVAL", &n
, &e
) >= 0);
698 assert_se(streq(n
, "uname"));
699 assert_se(e
== errno_from_name("EINVAL") && e
>= 0);
702 assert_se(parse_syscall_and_errno("@sync:4095", &n
, &e
) >= 0);
703 assert_se(streq(n
, "@sync"));
704 assert_se(e
== 4095);
707 /* If errno is omitted, then e is set to -1 */
708 assert_se(parse_syscall_and_errno("mount", &n
, &e
) >= 0);
709 assert_se(streq(n
, "mount"));
713 /* parse_syscall_and_errno() does not check the syscall name is valid or not. */
714 assert_se(parse_syscall_and_errno("hoge:255", &n
, &e
) >= 0);
715 assert_se(streq(n
, "hoge"));
719 /* The function checks the syscall name is empty or not. */
720 assert_se(parse_syscall_and_errno("", &n
, &e
) == -EINVAL
);
721 assert_se(parse_syscall_and_errno(":255", &n
, &e
) == -EINVAL
);
723 /* errno must be a valid errno name or number between 0 and ERRNO_MAX == 4095 */
724 assert_se(parse_syscall_and_errno("hoge:4096", &n
, &e
) == -ERANGE
);
725 assert_se(parse_syscall_and_errno("hoge:-3", &n
, &e
) == -ERANGE
);
726 assert_se(parse_syscall_and_errno("hoge:12.3", &n
, &e
) == -EINVAL
);
727 assert_se(parse_syscall_and_errno("hoge:123junk", &n
, &e
) == -EINVAL
);
728 assert_se(parse_syscall_and_errno("hoge:junk123", &n
, &e
) == -EINVAL
);
729 assert_se(parse_syscall_and_errno("hoge:255:EILSEQ", &n
, &e
) == -EINVAL
);
730 assert_se(parse_syscall_and_errno("hoge:-EINVAL", &n
, &e
) == -EINVAL
);
731 assert_se(parse_syscall_and_errno("hoge:EINVALaaa", &n
, &e
) == -EINVAL
);
732 assert_se(parse_syscall_and_errno("hoge:", &n
, &e
) == -EINVAL
);
735 int main(int argc
, char *argv
[]) {
736 log_parse_environment();
739 test_parse_boolean();
750 test_parse_percent();
751 test_parse_percent_unbounded();
755 test_parse_syscall_and_errno();