]> git.ipfire.org Git - thirdparty/systemd.git/blame - src/test/test-parse-util.c
projects / thirdparty / systemd.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
parse-util: also parse integers prefixed with 0b and 0o
[thirdparty/systemd.git] / src / test / test-parse-util.c
CommitLineData
53e1b683 1/* SPDX-License-Identifier: LGPL-2.1+ */
bb269eed 2
dccca82b 3#include <errno.h>
bb269eed
FB		 4#include <locale.h>
5#include <math.h>
f91c6093 6#include <sys/socket.h>
bb269eed 7
473d2ec3
YW		 8#include "alloc-util.h"
9#include "errno-list.h"
bb269eed
FB		 10#include "log.h"
11#include "parse-util.h"
473d2ec3 12#include "string-util.h"
bb269eed
FB		 13
14static void test_parse_boolean(void) {
15 assert_se(parse_boolean("1") == 1);
16 assert_se(parse_boolean("y") == 1);
17 assert_se(parse_boolean("Y") == 1);
18 assert_se(parse_boolean("yes") == 1);
19 assert_se(parse_boolean("YES") == 1);
20 assert_se(parse_boolean("true") == 1);
21 assert_se(parse_boolean("TRUE") == 1);
22 assert_se(parse_boolean("on") == 1);
23 assert_se(parse_boolean("ON") == 1);
24
25 assert_se(parse_boolean("0") == 0);
26 assert_se(parse_boolean("n") == 0);
27 assert_se(parse_boolean("N") == 0);
28 assert_se(parse_boolean("no") == 0);
29 assert_se(parse_boolean("NO") == 0);
30 assert_se(parse_boolean("false") == 0);
31 assert_se(parse_boolean("FALSE") == 0);
32 assert_se(parse_boolean("off") == 0);
33 assert_se(parse_boolean("OFF") == 0);
34
35 assert_se(parse_boolean("garbage") < 0);
36 assert_se(parse_boolean("") < 0);
37 assert_se(parse_boolean("full") < 0);
38}
39
40static void test_parse_pid(void) {
41 int r;
42 pid_t pid;
43
44 r = parse_pid("100", &pid);
45 assert_se(r == 0);
46 assert_se(pid == 100);
47
48 r = parse_pid("0x7FFFFFFF", &pid);
49 assert_se(r == 0);
50 assert_se(pid == 2147483647);
51
52 pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
53 r = parse_pid("0", &pid);
54 assert_se(r == -ERANGE);
55 assert_se(pid == 65);
56
57 pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
58 r = parse_pid("-100", &pid);
59 assert_se(r == -ERANGE);
60 assert_se(pid == 65);
61
62 pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
63 r = parse_pid("0xFFFFFFFFFFFFFFFFF", &pid);
64 assert_se(r == -ERANGE);
65 assert_se(pid == 65);
66
67 r = parse_pid("junk", &pid);
68 assert_se(r == -EINVAL);
3fcf65c3
YW		 69
70 r = parse_pid("", &pid);
71 assert_se(r == -EINVAL);
bb269eed
FB		 72}
73
74static void test_parse_mode(void) {
75 mode_t m;
76
77 assert_se(parse_mode("-1", &m) < 0);
78 assert_se(parse_mode("", &m) < 0);
79 assert_se(parse_mode("888", &m) < 0);
80 assert_se(parse_mode("77777", &m) < 0);
81
82 assert_se(parse_mode("544", &m) >= 0 && m == 0544);
83 assert_se(parse_mode("777", &m) >= 0 && m == 0777);
84 assert_se(parse_mode("7777", &m) >= 0 && m == 07777);
85 assert_se(parse_mode("0", &m) >= 0 && m == 0);
86}
87
88static void test_parse_size(void) {
89 uint64_t bytes;
90
3fcf65c3
YW		 91 assert_se(parse_size("", 1024, &bytes) == -EINVAL);
92
bb269eed
FB		 93 assert_se(parse_size("111", 1024, &bytes) == 0);
94 assert_se(bytes == 111);
95
96 assert_se(parse_size("111.4", 1024, &bytes) == 0);
97 assert_se(bytes == 111);
98
99 assert_se(parse_size(" 112 B", 1024, &bytes) == 0);
100 assert_se(bytes == 112);
101
102 assert_se(parse_size(" 112.6 B", 1024, &bytes) == 0);
103 assert_se(bytes == 112);
104
105 assert_se(parse_size("3.5 K", 1024, &bytes) == 0);
106 assert_se(bytes == 3*1024 + 512);
107
108 assert_se(parse_size("3. K", 1024, &bytes) == 0);
109 assert_se(bytes == 3*1024);
110
111 assert_se(parse_size("3.0 K", 1024, &bytes) == 0);
112 assert_se(bytes == 3*1024);
113
114 assert_se(parse_size("3. 0 K", 1024, &bytes) == -EINVAL);
115
116 assert_se(parse_size(" 4 M 11.5K", 1024, &bytes) == 0);
117 assert_se(bytes == 4*1024*1024 + 11 * 1024 + 512);
118
119 assert_se(parse_size("3B3.5G", 1024, &bytes) == -EINVAL);
120
121 assert_se(parse_size("3.5G3B", 1024, &bytes) == 0);
122 assert_se(bytes == 3ULL*1024*1024*1024 + 512*1024*1024 + 3);
123
124 assert_se(parse_size("3.5G 4B", 1024, &bytes) == 0);
125 assert_se(bytes == 3ULL*1024*1024*1024 + 512*1024*1024 + 4);
126
127 assert_se(parse_size("3B3G4T", 1024, &bytes) == -EINVAL);
128
129 assert_se(parse_size("4T3G3B", 1024, &bytes) == 0);
130 assert_se(bytes == (4ULL*1024 + 3)*1024*1024*1024 + 3);
131
132 assert_se(parse_size(" 4 T 3 G 3 B", 1024, &bytes) == 0);
133 assert_se(bytes == (4ULL*1024 + 3)*1024*1024*1024 + 3);
134
135 assert_se(parse_size("12P", 1024, &bytes) == 0);
136 assert_se(bytes == 12ULL * 1024*1024*1024*1024*1024);
137
138 assert_se(parse_size("12P12P", 1024, &bytes) == -EINVAL);
139
140 assert_se(parse_size("3E 2P", 1024, &bytes) == 0);
141 assert_se(bytes == (3 * 1024 + 2ULL) * 1024*1024*1024*1024*1024);
142
143 assert_se(parse_size("12X", 1024, &bytes) == -EINVAL);
144
145 assert_se(parse_size("12.5X", 1024, &bytes) == -EINVAL);
146
147 assert_se(parse_size("12.5e3", 1024, &bytes) == -EINVAL);
148
149 assert_se(parse_size("1024E", 1024, &bytes) == -ERANGE);
150 assert_se(parse_size("-1", 1024, &bytes) == -ERANGE);
151 assert_se(parse_size("-1024E", 1024, &bytes) == -ERANGE);
152
153 assert_se(parse_size("-1024P", 1024, &bytes) == -ERANGE);
154
155 assert_se(parse_size("-10B 20K", 1024, &bytes) == -ERANGE);
156}
157
158static void test_parse_range(void) {
159 unsigned lower, upper;
160
161 /* Successful cases */
162 assert_se(parse_range("111", &lower, &upper) == 0);
163 assert_se(lower == 111);
164 assert_se(upper == 111);
165
166 assert_se(parse_range("111-123", &lower, &upper) == 0);
167 assert_se(lower == 111);
168 assert_se(upper == 123);
169
170 assert_se(parse_range("123-111", &lower, &upper) == 0);
171 assert_se(lower == 123);
172 assert_se(upper == 111);
173
174 assert_se(parse_range("123-123", &lower, &upper) == 0);
175 assert_se(lower == 123);
176 assert_se(upper == 123);
177
178 assert_se(parse_range("0", &lower, &upper) == 0);
179 assert_se(lower == 0);
180 assert_se(upper == 0);
181
182 assert_se(parse_range("0-15", &lower, &upper) == 0);
183 assert_se(lower == 0);
184 assert_se(upper == 15);
185
186 assert_se(parse_range("15-0", &lower, &upper) == 0);
187 assert_se(lower == 15);
188 assert_se(upper == 0);
189
190 assert_se(parse_range("128-65535", &lower, &upper) == 0);
191 assert_se(lower == 128);
192 assert_se(upper == 65535);
193
194 assert_se(parse_range("1024-4294967295", &lower, &upper) == 0);
195 assert_se(lower == 1024);
196 assert_se(upper == 4294967295);
197
198 /* Leading whitespace is acceptable */
199 assert_se(parse_range(" 111", &lower, &upper) == 0);
200 assert_se(lower == 111);
201 assert_se(upper == 111);
202
203 assert_se(parse_range(" 111-123", &lower, &upper) == 0);
204 assert_se(lower == 111);
205 assert_se(upper == 123);
206
207 assert_se(parse_range("111- 123", &lower, &upper) == 0);
208 assert_se(lower == 111);
209 assert_se(upper == 123);
210
211 assert_se(parse_range("\t111-\t123", &lower, &upper) == 0);
212 assert_se(lower == 111);
213 assert_se(upper == 123);
214
215 assert_se(parse_range(" \t 111- \t 123", &lower, &upper) == 0);
216 assert_se(lower == 111);
217 assert_se(upper == 123);
218
219 /* Error cases, make sure they fail as expected */
220 lower = upper = 9999;
221 assert_se(parse_range("111garbage", &lower, &upper) == -EINVAL);
222 assert_se(lower == 9999);
223 assert_se(upper == 9999);
224
225 assert_se(parse_range("garbage111", &lower, &upper) == -EINVAL);
226 assert_se(lower == 9999);
227 assert_se(upper == 9999);
228
229 assert_se(parse_range("garbage", &lower, &upper) == -EINVAL);
230 assert_se(lower == 9999);
231 assert_se(upper == 9999);
232
233 assert_se(parse_range("111-123garbage", &lower, &upper) == -EINVAL);
234 assert_se(lower == 9999);
235 assert_se(upper == 9999);
236
237 assert_se(parse_range("111garbage-123", &lower, &upper) == -EINVAL);
238 assert_se(lower == 9999);
239 assert_se(upper == 9999);
240
241 /* Empty string */
242 lower = upper = 9999;
243 assert_se(parse_range("", &lower, &upper) == -EINVAL);
244 assert_se(lower == 9999);
245 assert_se(upper == 9999);
246
247 /* 111--123 will pass -123 to safe_atou which returns -ERANGE for negative */
248 assert_se(parse_range("111--123", &lower, &upper) == -ERANGE);
249 assert_se(lower == 9999);
250 assert_se(upper == 9999);
251
3fcf65c3
YW		 252 assert_se(parse_range("-123", &lower, &upper) == -EINVAL);
253 assert_se(lower == 9999);
254 assert_se(upper == 9999);
255
bb269eed
FB		 256 assert_se(parse_range("-111-123", &lower, &upper) == -EINVAL);
257 assert_se(lower == 9999);
258 assert_se(upper == 9999);
259
260 assert_se(parse_range("111-123-", &lower, &upper) == -EINVAL);
261 assert_se(lower == 9999);
262 assert_se(upper == 9999);
263
264 assert_se(parse_range("111.4-123", &lower, &upper) == -EINVAL);
265 assert_se(lower == 9999);
266 assert_se(upper == 9999);
267
268 assert_se(parse_range("111-123.4", &lower, &upper) == -EINVAL);
269 assert_se(lower == 9999);
270 assert_se(upper == 9999);
271
272 assert_se(parse_range("111,4-123", &lower, &upper) == -EINVAL);
273 assert_se(lower == 9999);
274 assert_se(upper == 9999);
275
276 assert_se(parse_range("111-123,4", &lower, &upper) == -EINVAL);
277 assert_se(lower == 9999);
278 assert_se(upper == 9999);
279
280 /* Error on trailing dash */
281 assert_se(parse_range("111-", &lower, &upper) == -EINVAL);
282 assert_se(lower == 9999);
283 assert_se(upper == 9999);
284
285 assert_se(parse_range("111-123-", &lower, &upper) == -EINVAL);
286 assert_se(lower == 9999);
287 assert_se(upper == 9999);
288
289 assert_se(parse_range("111--", &lower, &upper) == -EINVAL);
290 assert_se(lower == 9999);
291 assert_se(upper == 9999);
292
293 assert_se(parse_range("111- ", &lower, &upper) == -EINVAL);
294 assert_se(lower == 9999);
295 assert_se(upper == 9999);
296
297 /* Whitespace is not a separator */
298 assert_se(parse_range("111 123", &lower, &upper) == -EINVAL);
299 assert_se(lower == 9999);
300 assert_se(upper == 9999);
301
302 assert_se(parse_range("111\t123", &lower, &upper) == -EINVAL);
303 assert_se(lower == 9999);
304 assert_se(upper == 9999);
305
306 assert_se(parse_range("111 \t 123", &lower, &upper) == -EINVAL);
307 assert_se(lower == 9999);
308 assert_se(upper == 9999);
309
310 /* Trailing whitespace is invalid (from safe_atou) */
311 assert_se(parse_range("111 ", &lower, &upper) == -EINVAL);
312 assert_se(lower == 9999);
313 assert_se(upper == 9999);
314
315 assert_se(parse_range("111-123 ", &lower, &upper) == -EINVAL);
316 assert_se(lower == 9999);
317 assert_se(upper == 9999);
318
319 assert_se(parse_range("111 -123", &lower, &upper) == -EINVAL);
320 assert_se(lower == 9999);
321 assert_se(upper == 9999);
322
323 assert_se(parse_range("111 -123 ", &lower, &upper) == -EINVAL);
324 assert_se(lower == 9999);
325 assert_se(upper == 9999);
326
327 assert_se(parse_range("111\t-123\t", &lower, &upper) == -EINVAL);
328 assert_se(lower == 9999);
329 assert_se(upper == 9999);
330
331 assert_se(parse_range("111 \t -123 \t ", &lower, &upper) == -EINVAL);
332 assert_se(lower == 9999);
333 assert_se(upper == 9999);
334
335 /* Out of the "unsigned" range, this is 1<<64 */
336 assert_se(parse_range("0-18446744073709551616", &lower, &upper) == -ERANGE);
337 assert_se(lower == 9999);
338 assert_se(upper == 9999);
339}
340
341static void test_safe_atolli(void) {
342 int r;
343 long long l;
344
345 r = safe_atolli("12345", &l);
346 assert_se(r == 0);
347 assert_se(l == 12345);
348
5c280bcc
MP		 349 r = safe_atolli(" 12345", &l);
350 assert_se(r == 0);
351 assert_se(l == 12345);
352
353 r = safe_atolli("-12345", &l);
354 assert_se(r == 0);
355 assert_se(l == -12345);
356
357 r = safe_atolli(" -12345", &l);
358 assert_se(r == 0);
359 assert_se(l == -12345);
360
361 r = safe_atolli("12345678901234567890", &l);
362 assert_se(r == -ERANGE);
363
364 r = safe_atolli("-12345678901234567890", &l);
365 assert_se(r == -ERANGE);
366
bb269eed
FB		 367 r = safe_atolli("junk", &l);
368 assert_se(r == -EINVAL);
3fcf65c3
YW		 369
370 r = safe_atolli("123x", &l);
371 assert_se(r == -EINVAL);
372
373 r = safe_atolli("12.3", &l);
374 assert_se(r == -EINVAL);
375
376 r = safe_atolli("", &l);
377 assert_se(r == -EINVAL);
bb269eed
FB		 378}
379
380static void test_safe_atou16(void) {
381 int r;
382 uint16_t l;
383
384 r = safe_atou16("12345", &l);
385 assert_se(r == 0);
386 assert_se(l == 12345);
387
5c280bcc
MP		 388 r = safe_atou16(" 12345", &l);
389 assert_se(r == 0);
390 assert_se(l == 12345);
391
bb269eed
FB		 392 r = safe_atou16("123456", &l);
393 assert_se(r == -ERANGE);
394
5c280bcc
MP		 395 r = safe_atou16("-1", &l);
396 assert_se(r == -ERANGE);
397
398 r = safe_atou16(" -1", &l);
399 assert_se(r == -ERANGE);
400
bb269eed
FB		 401 r = safe_atou16("junk", &l);
402 assert_se(r == -EINVAL);
bf32e385
ZJS		 403
404 r = safe_atou16("123x", &l);
405 assert_se(r == -EINVAL);
3fcf65c3
YW		 406
407 r = safe_atou16("12.3", &l);
408 assert_se(r == -EINVAL);
409
410 r = safe_atou16("", &l);
411 assert_se(r == -EINVAL);
bb269eed
FB		 412}
413
414static void test_safe_atoi16(void) {
415 int r;
416 int16_t l;
417
418 r = safe_atoi16("-12345", &l);
419 assert_se(r == 0);
420 assert_se(l == -12345);
421
5c280bcc
MP		 422 r = safe_atoi16(" -12345", &l);
423 assert_se(r == 0);
424 assert_se(l == -12345);
425
426 r = safe_atoi16("32767", &l);
427 assert_se(r == 0);
428 assert_se(l == 32767);
429
430 r = safe_atoi16(" 32767", &l);
431 assert_se(r == 0);
432 assert_se(l == 32767);
433
bb269eed
FB		 434 r = safe_atoi16("36536", &l);
435 assert_se(r == -ERANGE);
436
5c280bcc
MP		 437 r = safe_atoi16("-32769", &l);
438 assert_se(r == -ERANGE);
439
bb269eed
FB		 440 r = safe_atoi16("junk", &l);
441 assert_se(r == -EINVAL);
bf32e385
ZJS		 442
443 r = safe_atoi16("123x", &l);
444 assert_se(r == -EINVAL);
3fcf65c3
YW		 445
446 r = safe_atoi16("12.3", &l);
447 assert_se(r == -EINVAL);
448
449 r = safe_atoi16("", &l);
450 assert_se(r == -EINVAL);
bf32e385
ZJS		 451}
452
5547c125
PU		 453static void test_safe_atoux16(void) {
454 int r;
455 uint16_t l;
456
457 r = safe_atoux16("1234", &l);
458 assert_se(r == 0);
459 assert_se(l == 0x1234);
460
461 r = safe_atoux16("abcd", &l);
462 assert_se(r == 0);
463 assert_se(l == 0xabcd);
464
465 r = safe_atoux16(" 1234", &l);
466 assert_se(r == 0);
467 assert_se(l == 0x1234);
468
469 r = safe_atoux16("12345", &l);
470 assert_se(r == -ERANGE);
471
472 r = safe_atoux16("-1", &l);
473 assert_se(r == -ERANGE);
474
475 r = safe_atoux16(" -1", &l);
476 assert_se(r == -ERANGE);
477
478 r = safe_atoux16("junk", &l);
479 assert_se(r == -EINVAL);
480
481 r = safe_atoux16("123x", &l);
482 assert_se(r == -EINVAL);
483
484 r = safe_atoux16("12.3", &l);
485 assert_se(r == -EINVAL);
486
487 r = safe_atoux16("", &l);
488 assert_se(r == -EINVAL);
489}
490
bf32e385
ZJS		 491static void test_safe_atou64(void) {
492 int r;
493 uint64_t l;
494
495 r = safe_atou64("12345", &l);
496 assert_se(r == 0);
497 assert_se(l == 12345);
498
499 r = safe_atou64(" 12345", &l);
500 assert_se(r == 0);
501 assert_se(l == 12345);
502
503 r = safe_atou64("18446744073709551617", &l);
504 assert_se(r == -ERANGE);
505
506 r = safe_atou64("-1", &l);
507 assert_se(r == -ERANGE);
508
509 r = safe_atou64(" -1", &l);
510 assert_se(r == -ERANGE);
511
512 r = safe_atou64("junk", &l);
513 assert_se(r == -EINVAL);
514
515 r = safe_atou64("123x", &l);
516 assert_se(r == -EINVAL);
3fcf65c3
YW		 517
518 r = safe_atou64("12.3", &l);
519 assert_se(r == -EINVAL);
520
521 r = safe_atou64("", &l);
522 assert_se(r == -EINVAL);
bf32e385
ZJS		 523}
524
525static void test_safe_atoi64(void) {
526 int r;
527 int64_t l;
528
529 r = safe_atoi64("-12345", &l);
530 assert_se(r == 0);
531 assert_se(l == -12345);
532
533 r = safe_atoi64(" -12345", &l);
534 assert_se(r == 0);
535 assert_se(l == -12345);
536
537 r = safe_atoi64("32767", &l);
538 assert_se(r == 0);
539 assert_se(l == 32767);
540
541 r = safe_atoi64(" 32767", &l);
542 assert_se(r == 0);
543 assert_se(l == 32767);
544
545 r = safe_atoi64("9223372036854775813", &l);
546 assert_se(r == -ERANGE);
547
548 r = safe_atoi64("-9223372036854775813", &l);
549 assert_se(r == -ERANGE);
550
551 r = safe_atoi64("junk", &l);
552 assert_se(r == -EINVAL);
553
554 r = safe_atoi64("123x", &l);
555 assert_se(r == -EINVAL);
3fcf65c3
YW		 556
557 r = safe_atoi64("12.3", &l);
558 assert_se(r == -EINVAL);
559
560 r = safe_atoi64("", &l);
561 assert_se(r == -EINVAL);
bb269eed
FB		 562}
563
ce51632a
ZJS		 564static void test_safe_atoux64(void) {
565 int r;
566 uint64_t l;
567
568 r = safe_atoux64("12345", &l);
569 assert_se(r == 0);
570 assert_se(l == 0x12345);
571
572 r = safe_atoux64(" 12345", &l);
573 assert_se(r == 0);
574 assert_se(l == 0x12345);
575
576 r = safe_atoux64("0x12345", &l);
577 assert_se(r == 0);
578 assert_se(l == 0x12345);
579
580 r = safe_atoux64("18446744073709551617", &l);
581 assert_se(r == -ERANGE);
582
583 r = safe_atoux64("-1", &l);
584 assert_se(r == -ERANGE);
585
586 r = safe_atoux64(" -1", &l);
587 assert_se(r == -ERANGE);
588
589 r = safe_atoux64("junk", &l);
590 assert_se(r == -EINVAL);
591
592 r = safe_atoux64("123x", &l);
593 assert_se(r == -EINVAL);
594
595 r = safe_atoux64("12.3", &l);
596 assert_se(r == -EINVAL);
597
598 r = safe_atoux64("", &l);
599 assert_se(r == -EINVAL);
600}
601
bb269eed
FB		 602static void test_safe_atod(void) {
603 int r;
604 double d;
605 char *e;
606
607 r = safe_atod("junk", &d);
608 assert_se(r == -EINVAL);
609
610 r = safe_atod("0.2244", &d);
611 assert_se(r == 0);
612 assert_se(fabs(d - 0.2244) < 0.000001);
613
614 r = safe_atod("0,5", &d);
615 assert_se(r == -EINVAL);
616
617 errno = 0;
618 strtod("0,5", &e);
619 assert_se(*e == ',');
620
3fcf65c3
YW		 621 r = safe_atod("", &d);
622 assert_se(r == -EINVAL);
623
bb269eed
FB		 624 /* Check if this really is locale independent */
625 if (setlocale(LC_NUMERIC, "de_DE.utf8")) {
626
627 r = safe_atod("0.2244", &d);
628 assert_se(r == 0);
629 assert_se(fabs(d - 0.2244) < 0.000001);
630
631 r = safe_atod("0,5", &d);
632 assert_se(r == -EINVAL);
633
634 errno = 0;
635 assert_se(fabs(strtod("0,5", &e) - 0.5) < 0.00001);
3fcf65c3
YW		 636
637 r = safe_atod("", &d);
638 assert_se(r == -EINVAL);
bb269eed
FB		 639 }
640
641 /* And check again, reset */
642 assert_se(setlocale(LC_NUMERIC, "C"));
643
644 r = safe_atod("0.2244", &d);
645 assert_se(r == 0);
646 assert_se(fabs(d - 0.2244) < 0.000001);
647
648 r = safe_atod("0,5", &d);
649 assert_se(r == -EINVAL);
650
651 errno = 0;
652 strtod("0,5", &e);
653 assert_se(*e == ',');
3fcf65c3
YW		 654
655 r = safe_atod("", &d);
656 assert_se(r == -EINVAL);
bb269eed
FB		 657}
658
9184ca48
LP		 659static void test_parse_percent(void) {
660 assert_se(parse_percent("") == -EINVAL);
661 assert_se(parse_percent("foo") == -EINVAL);
662 assert_se(parse_percent("0") == -EINVAL);
663 assert_se(parse_percent("50") == -EINVAL);
664 assert_se(parse_percent("100") == -EINVAL);
665 assert_se(parse_percent("-1") == -EINVAL);
666 assert_se(parse_percent("0%") == 0);
667 assert_se(parse_percent("55%") == 55);
668 assert_se(parse_percent("100%") == 100);
669 assert_se(parse_percent("-7%") == -ERANGE);
670 assert_se(parse_percent("107%") == -ERANGE);
671 assert_se(parse_percent("%") == -EINVAL);
672 assert_se(parse_percent("%%") == -EINVAL);
673 assert_se(parse_percent("%1") == -EINVAL);
674 assert_se(parse_percent("1%%") == -EINVAL);
3fcf65c3 675 assert_se(parse_percent("3.2%") == -EINVAL);
9184ca48
LP		 676}
677
1898a1a5
JB		 678static void test_parse_percent_unbounded(void) {
679 assert_se(parse_percent_unbounded("101%") == 101);
680 assert_se(parse_percent_unbounded("400%") == 400);
681}
682
958acea1
MKB		 683static void test_parse_permille(void) {
684 assert_se(parse_permille("") == -EINVAL);
685 assert_se(parse_permille("foo") == -EINVAL);
686 assert_se(parse_permille("0") == -EINVAL);
687 assert_se(parse_permille("50") == -EINVAL);
688 assert_se(parse_permille("100") == -EINVAL);
689 assert_se(parse_permille("-1") == -EINVAL);
690
691 assert_se(parse_permille("0‰") == 0);
692 assert_se(parse_permille("555‰") == 555);
693 assert_se(parse_permille("1000‰") == 1000);
694 assert_se(parse_permille("-7‰") == -ERANGE);
695 assert_se(parse_permille("1007‰") == -ERANGE);
696 assert_se(parse_permille("‰") == -EINVAL);
697 assert_se(parse_permille("‰‰") == -EINVAL);
698 assert_se(parse_permille("‰1") == -EINVAL);
699 assert_se(parse_permille("1‰‰") == -EINVAL);
700 assert_se(parse_permille("3.2‰") == -EINVAL);
701
702 assert_se(parse_permille("0%") == 0);
703 assert_se(parse_permille("55%") == 550);
704 assert_se(parse_permille("55.5%") == 555);
705 assert_se(parse_permille("100%") == 1000);
706 assert_se(parse_permille("-7%") == -ERANGE);
707 assert_se(parse_permille("107%") == -ERANGE);
708 assert_se(parse_permille("%") == -EINVAL);
709 assert_se(parse_permille("%%") == -EINVAL);
710 assert_se(parse_permille("%1") == -EINVAL);
711 assert_se(parse_permille("1%%") == -EINVAL);
712 assert_se(parse_permille("3.21%") == -EINVAL);
713}
714
715static void test_parse_permille_unbounded(void) {
716 assert_se(parse_permille_unbounded("1001‰") == 1001);
717 assert_se(parse_permille_unbounded("4000‰") == 4000);
718 assert_se(parse_permille_unbounded("2147483647‰") == 2147483647);
719 assert_se(parse_permille_unbounded("2147483648‰") == -ERANGE);
720 assert_se(parse_permille_unbounded("4294967295‰") == -ERANGE);
721 assert_se(parse_permille_unbounded("4294967296‰") == -ERANGE);
722
723 assert_se(parse_permille_unbounded("101%") == 1010);
724 assert_se(parse_permille_unbounded("400%") == 4000);
725 assert_se(parse_permille_unbounded("214748364.7%") == 2147483647);
726 assert_se(parse_permille_unbounded("214748364.8%") == -ERANGE);
727 assert_se(parse_permille_unbounded("429496729.5%") == -ERANGE);
728 assert_se(parse_permille_unbounded("429496729.6%") == -ERANGE);
729}
730
41bf0590
LP		 731static void test_parse_nice(void) {
732 int n;
733
734 assert_se(parse_nice("0", &n) >= 0 && n == 0);
735 assert_se(parse_nice("+0", &n) >= 0 && n == 0);
736 assert_se(parse_nice("-1", &n) >= 0 && n == -1);
737 assert_se(parse_nice("-2", &n) >= 0 && n == -2);
738 assert_se(parse_nice("1", &n) >= 0 && n == 1);
739 assert_se(parse_nice("2", &n) >= 0 && n == 2);
740 assert_se(parse_nice("+1", &n) >= 0 && n == 1);
741 assert_se(parse_nice("+2", &n) >= 0 && n == 2);
742 assert_se(parse_nice("-20", &n) >= 0 && n == -20);
743 assert_se(parse_nice("19", &n) >= 0 && n == 19);
744 assert_se(parse_nice("+19", &n) >= 0 && n == 19);
745
41bf0590
LP		 746 assert_se(parse_nice("", &n) == -EINVAL);
747 assert_se(parse_nice("-", &n) == -EINVAL);
748 assert_se(parse_nice("+", &n) == -EINVAL);
749 assert_se(parse_nice("xx", &n) == -EINVAL);
750 assert_se(parse_nice("-50", &n) == -ERANGE);
751 assert_se(parse_nice("50", &n) == -ERANGE);
752 assert_se(parse_nice("+50", &n) == -ERANGE);
753 assert_se(parse_nice("-21", &n) == -ERANGE);
754 assert_se(parse_nice("20", &n) == -ERANGE);
755 assert_se(parse_nice("+20", &n) == -ERANGE);
756}
757
fbcc7f41
FB		 758static void test_parse_dev(void) {
759 dev_t dev;
760
3fcf65c3
YW		 761 assert_se(parse_dev("", &dev) == -EINVAL);
762 assert_se(parse_dev("junk", &dev) == -EINVAL);
fbcc7f41
FB		 763 assert_se(parse_dev("0", &dev) == -EINVAL);
764 assert_se(parse_dev("5", &dev) == -EINVAL);
765 assert_se(parse_dev("5:", &dev) == -EINVAL);
766 assert_se(parse_dev(":5", &dev) == -EINVAL);
de06c0cf 767 assert_se(parse_dev("-1:-1", &dev) == -EINVAL);
fbcc7f41
FB		 768#if SIZEOF_DEV_T < 8
769 assert_se(parse_dev("4294967295:4294967295", &dev) == -EINVAL);
770#endif
771 assert_se(parse_dev("8:11", &dev) >= 0 && major(dev) == 8 && minor(dev) == 11);
de06c0cf 772 assert_se(parse_dev("0:0", &dev) >= 0 && major(dev) == 0 && minor(dev) == 0);
fbcc7f41
FB		 773}
774
473d2ec3
YW		 775static void test_parse_errno(void) {
776 assert_se(parse_errno("EILSEQ") == EILSEQ);
777 assert_se(parse_errno("EINVAL") == EINVAL);
778 assert_se(parse_errno("0") == 0);
779 assert_se(parse_errno("1") == 1);
780 assert_se(parse_errno("4095") == 4095);
781
782 assert_se(parse_errno("-1") == -ERANGE);
783 assert_se(parse_errno("-3") == -ERANGE);
784 assert_se(parse_errno("4096") == -ERANGE);
785
786 assert_se(parse_errno("") == -EINVAL);
787 assert_se(parse_errno("12.3") == -EINVAL);
788 assert_se(parse_errno("123junk") == -EINVAL);
789 assert_se(parse_errno("junk123") == -EINVAL);
790 assert_se(parse_errno("255EILSEQ") == -EINVAL);
791 assert_se(parse_errno("EINVAL12") == -EINVAL);
792 assert_se(parse_errno("-EINVAL") == -EINVAL);
793 assert_se(parse_errno("EINVALaaa") == -EINVAL);
794}
795
796static void test_parse_syscall_and_errno(void) {
797 _cleanup_free_ char *n = NULL;
798 int e;
799
800 assert_se(parse_syscall_and_errno("uname:EILSEQ", &n, &e) >= 0);
801 assert_se(streq(n, "uname"));
802 assert_se(e == errno_from_name("EILSEQ") && e >= 0);
803 n = mfree(n);
804
805 assert_se(parse_syscall_and_errno("uname:EINVAL", &n, &e) >= 0);
806 assert_se(streq(n, "uname"));
807 assert_se(e == errno_from_name("EINVAL") && e >= 0);
808 n = mfree(n);
809
810 assert_se(parse_syscall_and_errno("@sync:4095", &n, &e) >= 0);
811 assert_se(streq(n, "@sync"));
812 assert_se(e == 4095);
813 n = mfree(n);
814
815 /* If errno is omitted, then e is set to -1 */
816 assert_se(parse_syscall_and_errno("mount", &n, &e) >= 0);
817 assert_se(streq(n, "mount"));
818 assert_se(e == -1);
819 n = mfree(n);
820
821 /* parse_syscall_and_errno() does not check the syscall name is valid or not. */
822 assert_se(parse_syscall_and_errno("hoge:255", &n, &e) >= 0);
823 assert_se(streq(n, "hoge"));
824 assert_se(e == 255);
825 n = mfree(n);
826
827 /* The function checks the syscall name is empty or not. */
828 assert_se(parse_syscall_and_errno("", &n, &e) == -EINVAL);
829 assert_se(parse_syscall_and_errno(":255", &n, &e) == -EINVAL);
830
831 /* errno must be a valid errno name or number between 0 and ERRNO_MAX == 4095 */
832 assert_se(parse_syscall_and_errno("hoge:4096", &n, &e) == -ERANGE);
833 assert_se(parse_syscall_and_errno("hoge:-3", &n, &e) == -ERANGE);
834 assert_se(parse_syscall_and_errno("hoge:12.3", &n, &e) == -EINVAL);
835 assert_se(parse_syscall_and_errno("hoge:123junk", &n, &e) == -EINVAL);
836 assert_se(parse_syscall_and_errno("hoge:junk123", &n, &e) == -EINVAL);
837 assert_se(parse_syscall_and_errno("hoge:255:EILSEQ", &n, &e) == -EINVAL);
838 assert_se(parse_syscall_and_errno("hoge:-EINVAL", &n, &e) == -EINVAL);
839 assert_se(parse_syscall_and_errno("hoge:EINVALaaa", &n, &e) == -EINVAL);
840 assert_se(parse_syscall_and_errno("hoge:", &n, &e) == -EINVAL);
841}
842
f91c6093
LP		 843static void test_parse_mtu(void) {
844 uint32_t mtu = 0;
845
846 assert_se(parse_mtu(AF_UNSPEC, "1500", &mtu) >= 0 && mtu == 1500);
847 assert_se(parse_mtu(AF_UNSPEC, "1400", &mtu) >= 0 && mtu == 1400);
848 assert_se(parse_mtu(AF_UNSPEC, "65535", &mtu) >= 0 && mtu == 65535);
849 assert_se(parse_mtu(AF_UNSPEC, "65536", &mtu) >= 0 && mtu == 65536);
850 assert_se(parse_mtu(AF_UNSPEC, "4294967295", &mtu) >= 0 && mtu == 4294967295);
851 assert_se(parse_mtu(AF_UNSPEC, "500", &mtu) >= 0 && mtu == 500);
852 assert_se(parse_mtu(AF_UNSPEC, "1280", &mtu) >= 0 && mtu == 1280);
853 assert_se(parse_mtu(AF_INET6, "1280", &mtu) >= 0 && mtu == 1280);
854 assert_se(parse_mtu(AF_INET6, "1279", &mtu) == -ERANGE);
855 assert_se(parse_mtu(AF_UNSPEC, "4294967296", &mtu) == -ERANGE);
856 assert_se(parse_mtu(AF_INET6, "4294967296", &mtu) == -ERANGE);
857 assert_se(parse_mtu(AF_INET6, "68", &mtu) == -ERANGE);
858 assert_se(parse_mtu(AF_UNSPEC, "68", &mtu) >= 0 && mtu == 68);
859 assert_se(parse_mtu(AF_UNSPEC, "67", &mtu) == -ERANGE);
860 assert_se(parse_mtu(AF_UNSPEC, "0", &mtu) == -ERANGE);
861 assert_se(parse_mtu(AF_UNSPEC, "", &mtu) == -EINVAL);
862}
863
bb269eed
FB		 864int main(int argc, char *argv[]) {
865 log_parse_environment();
866 log_open();
867
868 test_parse_boolean();
869 test_parse_pid();
870 test_parse_mode();
871 test_parse_size();
872 test_parse_range();
873 test_safe_atolli();
874 test_safe_atou16();
875 test_safe_atoi16();
5547c125 876 test_safe_atoux16();
bf32e385
ZJS		 877 test_safe_atou64();
878 test_safe_atoi64();
ce51632a 879 test_safe_atoux64();
bb269eed 880 test_safe_atod();
9184ca48 881 test_parse_percent();
1898a1a5 882 test_parse_percent_unbounded();
958acea1
MKB		 883 test_parse_permille();
884 test_parse_permille_unbounded();
41bf0590 885 test_parse_nice();
fbcc7f41 886 test_parse_dev();
473d2ec3
YW		 887 test_parse_errno();
888 test_parse_syscall_and_errno();
f91c6093 889 test_parse_mtu();
bb269eed
FB		 890
891 return 0;
892}
Unnamed repository; edit this file 'description' to name the repository.