]> 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
Merge pull request #20768 from pdmorrow/shutdown_cgroup_ctrl
[thirdparty/systemd.git] / src / test / test-parse-util.c
CommitLineData
db9ecf05 1/* SPDX-License-Identifier: LGPL-2.1-or-later */
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);
53c6db99 78 assert_se(parse_mode("+1", &m) < 0);
bb269eed
FB		 79 assert_se(parse_mode("", &m) < 0);
80 assert_se(parse_mode("888", &m) < 0);
81 assert_se(parse_mode("77777", &m) < 0);
82
83 assert_se(parse_mode("544", &m) >= 0 && m == 0544);
53c6db99
LP		 84 assert_se(parse_mode("0544", &m) >= 0 && m == 0544);
85 assert_se(parse_mode("00544", &m) >= 0 && m == 0544);
bb269eed 86 assert_se(parse_mode("777", &m) >= 0 && m == 0777);
53c6db99
LP		 87 assert_se(parse_mode("0777", &m) >= 0 && m == 0777);
88 assert_se(parse_mode("00777", &m) >= 0 && m == 0777);
bb269eed 89 assert_se(parse_mode("7777", &m) >= 0 && m == 07777);
53c6db99
LP		 90 assert_se(parse_mode("07777", &m) >= 0 && m == 07777);
91 assert_se(parse_mode("007777", &m) >= 0 && m == 07777);
bb269eed 92 assert_se(parse_mode("0", &m) >= 0 && m == 0);
53c6db99 93 assert_se(parse_mode(" 1", &m) >= 0 && m == 1);
bb269eed
FB		 94}
95
96static void test_parse_size(void) {
97 uint64_t bytes;
98
3fcf65c3
YW		 99 assert_se(parse_size("", 1024, &bytes) == -EINVAL);
100
bb269eed
FB		 101 assert_se(parse_size("111", 1024, &bytes) == 0);
102 assert_se(bytes == 111);
103
104 assert_se(parse_size("111.4", 1024, &bytes) == 0);
105 assert_se(bytes == 111);
106
107 assert_se(parse_size(" 112 B", 1024, &bytes) == 0);
108 assert_se(bytes == 112);
109
110 assert_se(parse_size(" 112.6 B", 1024, &bytes) == 0);
111 assert_se(bytes == 112);
112
113 assert_se(parse_size("3.5 K", 1024, &bytes) == 0);
114 assert_se(bytes == 3*1024 + 512);
115
116 assert_se(parse_size("3. K", 1024, &bytes) == 0);
117 assert_se(bytes == 3*1024);
118
119 assert_se(parse_size("3.0 K", 1024, &bytes) == 0);
120 assert_se(bytes == 3*1024);
121
122 assert_se(parse_size("3. 0 K", 1024, &bytes) == -EINVAL);
123
124 assert_se(parse_size(" 4 M 11.5K", 1024, &bytes) == 0);
125 assert_se(bytes == 4*1024*1024 + 11 * 1024 + 512);
126
127 assert_se(parse_size("3B3.5G", 1024, &bytes) == -EINVAL);
128
129 assert_se(parse_size("3.5G3B", 1024, &bytes) == 0);
130 assert_se(bytes == 3ULL*1024*1024*1024 + 512*1024*1024 + 3);
131
132 assert_se(parse_size("3.5G 4B", 1024, &bytes) == 0);
133 assert_se(bytes == 3ULL*1024*1024*1024 + 512*1024*1024 + 4);
134
135 assert_se(parse_size("3B3G4T", 1024, &bytes) == -EINVAL);
136
137 assert_se(parse_size("4T3G3B", 1024, &bytes) == 0);
138 assert_se(bytes == (4ULL*1024 + 3)*1024*1024*1024 + 3);
139
140 assert_se(parse_size(" 4 T 3 G 3 B", 1024, &bytes) == 0);
141 assert_se(bytes == (4ULL*1024 + 3)*1024*1024*1024 + 3);
142
143 assert_se(parse_size("12P", 1024, &bytes) == 0);
144 assert_se(bytes == 12ULL * 1024*1024*1024*1024*1024);
145
146 assert_se(parse_size("12P12P", 1024, &bytes) == -EINVAL);
147
148 assert_se(parse_size("3E 2P", 1024, &bytes) == 0);
149 assert_se(bytes == (3 * 1024 + 2ULL) * 1024*1024*1024*1024*1024);
150
151 assert_se(parse_size("12X", 1024, &bytes) == -EINVAL);
152
153 assert_se(parse_size("12.5X", 1024, &bytes) == -EINVAL);
154
155 assert_se(parse_size("12.5e3", 1024, &bytes) == -EINVAL);
156
157 assert_se(parse_size("1024E", 1024, &bytes) == -ERANGE);
158 assert_se(parse_size("-1", 1024, &bytes) == -ERANGE);
159 assert_se(parse_size("-1024E", 1024, &bytes) == -ERANGE);
160
161 assert_se(parse_size("-1024P", 1024, &bytes) == -ERANGE);
162
163 assert_se(parse_size("-10B 20K", 1024, &bytes) == -ERANGE);
164}
165
166static void test_parse_range(void) {
167 unsigned lower, upper;
168
169 /* Successful cases */
170 assert_se(parse_range("111", &lower, &upper) == 0);
171 assert_se(lower == 111);
172 assert_se(upper == 111);
173
174 assert_se(parse_range("111-123", &lower, &upper) == 0);
175 assert_se(lower == 111);
176 assert_se(upper == 123);
177
178 assert_se(parse_range("123-111", &lower, &upper) == 0);
179 assert_se(lower == 123);
180 assert_se(upper == 111);
181
182 assert_se(parse_range("123-123", &lower, &upper) == 0);
183 assert_se(lower == 123);
184 assert_se(upper == 123);
185
186 assert_se(parse_range("0", &lower, &upper) == 0);
187 assert_se(lower == 0);
188 assert_se(upper == 0);
189
190 assert_se(parse_range("0-15", &lower, &upper) == 0);
191 assert_se(lower == 0);
192 assert_se(upper == 15);
193
194 assert_se(parse_range("15-0", &lower, &upper) == 0);
195 assert_se(lower == 15);
196 assert_se(upper == 0);
197
198 assert_se(parse_range("128-65535", &lower, &upper) == 0);
199 assert_se(lower == 128);
200 assert_se(upper == 65535);
201
202 assert_se(parse_range("1024-4294967295", &lower, &upper) == 0);
203 assert_se(lower == 1024);
204 assert_se(upper == 4294967295);
205
206 /* Leading whitespace is acceptable */
207 assert_se(parse_range(" 111", &lower, &upper) == 0);
208 assert_se(lower == 111);
209 assert_se(upper == 111);
210
211 assert_se(parse_range(" 111-123", &lower, &upper) == 0);
212 assert_se(lower == 111);
213 assert_se(upper == 123);
214
215 assert_se(parse_range("111- 123", &lower, &upper) == 0);
216 assert_se(lower == 111);
217 assert_se(upper == 123);
218
219 assert_se(parse_range("\t111-\t123", &lower, &upper) == 0);
220 assert_se(lower == 111);
221 assert_se(upper == 123);
222
223 assert_se(parse_range(" \t 111- \t 123", &lower, &upper) == 0);
224 assert_se(lower == 111);
225 assert_se(upper == 123);
226
227 /* Error cases, make sure they fail as expected */
228 lower = upper = 9999;
229 assert_se(parse_range("111garbage", &lower, &upper) == -EINVAL);
230 assert_se(lower == 9999);
231 assert_se(upper == 9999);
232
233 assert_se(parse_range("garbage111", &lower, &upper) == -EINVAL);
234 assert_se(lower == 9999);
235 assert_se(upper == 9999);
236
237 assert_se(parse_range("garbage", &lower, &upper) == -EINVAL);
238 assert_se(lower == 9999);
239 assert_se(upper == 9999);
240
241 assert_se(parse_range("111-123garbage", &lower, &upper) == -EINVAL);
242 assert_se(lower == 9999);
243 assert_se(upper == 9999);
244
245 assert_se(parse_range("111garbage-123", &lower, &upper) == -EINVAL);
246 assert_se(lower == 9999);
247 assert_se(upper == 9999);
248
249 /* Empty string */
250 lower = upper = 9999;
251 assert_se(parse_range("", &lower, &upper) == -EINVAL);
252 assert_se(lower == 9999);
253 assert_se(upper == 9999);
254
255 /* 111--123 will pass -123 to safe_atou which returns -ERANGE for negative */
256 assert_se(parse_range("111--123", &lower, &upper) == -ERANGE);
257 assert_se(lower == 9999);
258 assert_se(upper == 9999);
259
3fcf65c3
YW		 260 assert_se(parse_range("-123", &lower, &upper) == -EINVAL);
261 assert_se(lower == 9999);
262 assert_se(upper == 9999);
263
bb269eed
FB		 264 assert_se(parse_range("-111-123", &lower, &upper) == -EINVAL);
265 assert_se(lower == 9999);
266 assert_se(upper == 9999);
267
268 assert_se(parse_range("111-123-", &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 assert_se(parse_range("111,4-123", &lower, &upper) == -EINVAL);
281 assert_se(lower == 9999);
282 assert_se(upper == 9999);
283
284 assert_se(parse_range("111-123,4", &lower, &upper) == -EINVAL);
285 assert_se(lower == 9999);
286 assert_se(upper == 9999);
287
288 /* Error on trailing dash */
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-123-", &lower, &upper) == -EINVAL);
294 assert_se(lower == 9999);
295 assert_se(upper == 9999);
296
297 assert_se(parse_range("111--", &lower, &upper) == -EINVAL);
298 assert_se(lower == 9999);
299 assert_se(upper == 9999);
300
301 assert_se(parse_range("111- ", &lower, &upper) == -EINVAL);
302 assert_se(lower == 9999);
303 assert_se(upper == 9999);
304
305 /* Whitespace is not a separator */
306 assert_se(parse_range("111 123", &lower, &upper) == -EINVAL);
307 assert_se(lower == 9999);
308 assert_se(upper == 9999);
309
310 assert_se(parse_range("111\t123", &lower, &upper) == -EINVAL);
311 assert_se(lower == 9999);
312 assert_se(upper == 9999);
313
314 assert_se(parse_range("111 \t 123", &lower, &upper) == -EINVAL);
315 assert_se(lower == 9999);
316 assert_se(upper == 9999);
317
318 /* Trailing whitespace is invalid (from safe_atou) */
319 assert_se(parse_range("111 ", &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 -123", &lower, &upper) == -EINVAL);
328 assert_se(lower == 9999);
329 assert_se(upper == 9999);
330
331 assert_se(parse_range("111 -123 ", &lower, &upper) == -EINVAL);
332 assert_se(lower == 9999);
333 assert_se(upper == 9999);
334
335 assert_se(parse_range("111\t-123\t", &lower, &upper) == -EINVAL);
336 assert_se(lower == 9999);
337 assert_se(upper == 9999);
338
339 assert_se(parse_range("111 \t -123 \t ", &lower, &upper) == -EINVAL);
340 assert_se(lower == 9999);
341 assert_se(upper == 9999);
342
343 /* Out of the "unsigned" range, this is 1<<64 */
344 assert_se(parse_range("0-18446744073709551616", &lower, &upper) == -ERANGE);
345 assert_se(lower == 9999);
346 assert_se(upper == 9999);
347}
348
349static void test_safe_atolli(void) {
350 int r;
351 long long l;
352
353 r = safe_atolli("12345", &l);
354 assert_se(r == 0);
355 assert_se(l == 12345);
356
5c280bcc
MP		 357 r = safe_atolli(" 12345", &l);
358 assert_se(r == 0);
359 assert_se(l == 12345);
360
361 r = safe_atolli("-12345", &l);
362 assert_se(r == 0);
363 assert_se(l == -12345);
364
365 r = safe_atolli(" -12345", &l);
366 assert_se(r == 0);
367 assert_se(l == -12345);
368
53c6db99
LP		 369 r = safe_atolli("0x5", &l);
370 assert_se(r == 0);
371 assert_se(l == 5);
372
373 r = safe_atolli("0o6", &l);
374 assert_se(r == 0);
375 assert_se(l == 6);
376
377 r = safe_atolli("0B101", &l);
378 assert_se(r == 0);
379 assert_se(l == 5);
380
5c280bcc
MP		 381 r = safe_atolli("12345678901234567890", &l);
382 assert_se(r == -ERANGE);
383
384 r = safe_atolli("-12345678901234567890", &l);
385 assert_se(r == -ERANGE);
386
bb269eed
FB		 387 r = safe_atolli("junk", &l);
388 assert_se(r == -EINVAL);
3fcf65c3
YW		 389
390 r = safe_atolli("123x", &l);
391 assert_se(r == -EINVAL);
392
393 r = safe_atolli("12.3", &l);
394 assert_se(r == -EINVAL);
395
396 r = safe_atolli("", &l);
397 assert_se(r == -EINVAL);
bb269eed
FB		 398}
399
400static void test_safe_atou16(void) {
401 int r;
402 uint16_t l;
403
404 r = safe_atou16("12345", &l);
405 assert_se(r == 0);
406 assert_se(l == 12345);
407
5c280bcc
MP		 408 r = safe_atou16(" 12345", &l);
409 assert_se(r == 0);
410 assert_se(l == 12345);
411
bb269eed
FB		 412 r = safe_atou16("123456", &l);
413 assert_se(r == -ERANGE);
414
5c280bcc
MP		 415 r = safe_atou16("-1", &l);
416 assert_se(r == -ERANGE);
417
418 r = safe_atou16(" -1", &l);
419 assert_se(r == -ERANGE);
420
bb269eed
FB		 421 r = safe_atou16("junk", &l);
422 assert_se(r == -EINVAL);
bf32e385
ZJS		 423
424 r = safe_atou16("123x", &l);
425 assert_se(r == -EINVAL);
3fcf65c3
YW		 426
427 r = safe_atou16("12.3", &l);
428 assert_se(r == -EINVAL);
429
430 r = safe_atou16("", &l);
431 assert_se(r == -EINVAL);
bb269eed
FB		 432}
433
434static void test_safe_atoi16(void) {
435 int r;
436 int16_t l;
437
438 r = safe_atoi16("-12345", &l);
439 assert_se(r == 0);
440 assert_se(l == -12345);
441
5c280bcc
MP		 442 r = safe_atoi16(" -12345", &l);
443 assert_se(r == 0);
444 assert_se(l == -12345);
445
446 r = safe_atoi16("32767", &l);
447 assert_se(r == 0);
448 assert_se(l == 32767);
449
450 r = safe_atoi16(" 32767", &l);
451 assert_se(r == 0);
452 assert_se(l == 32767);
453
53c6db99
LP		 454 r = safe_atoi16("0o11", &l);
455 assert_se(r == 0);
456 assert_se(l == 9);
457
458 r = safe_atoi16("0B110", &l);
459 assert_se(r == 0);
460 assert_se(l == 6);
461
bb269eed
FB		 462 r = safe_atoi16("36536", &l);
463 assert_se(r == -ERANGE);
464
5c280bcc
MP		 465 r = safe_atoi16("-32769", &l);
466 assert_se(r == -ERANGE);
467
bb269eed
FB		 468 r = safe_atoi16("junk", &l);
469 assert_se(r == -EINVAL);
bf32e385
ZJS		 470
471 r = safe_atoi16("123x", &l);
472 assert_se(r == -EINVAL);
3fcf65c3
YW		 473
474 r = safe_atoi16("12.3", &l);
475 assert_se(r == -EINVAL);
476
477 r = safe_atoi16("", &l);
478 assert_se(r == -EINVAL);
bf32e385
ZJS		 479}
480
5547c125
PU		 481static void test_safe_atoux16(void) {
482 int r;
483 uint16_t l;
484
485 r = safe_atoux16("1234", &l);
486 assert_se(r == 0);
487 assert_se(l == 0x1234);
488
489 r = safe_atoux16("abcd", &l);
490 assert_se(r == 0);
491 assert_se(l == 0xabcd);
492
493 r = safe_atoux16(" 1234", &l);
494 assert_se(r == 0);
495 assert_se(l == 0x1234);
496
497 r = safe_atoux16("12345", &l);
498 assert_se(r == -ERANGE);
499
500 r = safe_atoux16("-1", &l);
501 assert_se(r == -ERANGE);
502
503 r = safe_atoux16(" -1", &l);
504 assert_se(r == -ERANGE);
505
53c6db99
LP		 506 r = safe_atoux16("0b1", &l);
507 assert_se(r == 0);
508 assert_se(l == 177);
509
510 r = safe_atoux16("0o70", &l);
511 assert_se(r == -EINVAL);
512
5547c125
PU		 513 r = safe_atoux16("junk", &l);
514 assert_se(r == -EINVAL);
515
516 r = safe_atoux16("123x", &l);
517 assert_se(r == -EINVAL);
518
519 r = safe_atoux16("12.3", &l);
520 assert_se(r == -EINVAL);
521
522 r = safe_atoux16("", &l);
523 assert_se(r == -EINVAL);
524}
525
bf32e385
ZJS		 526static void test_safe_atou64(void) {
527 int r;
528 uint64_t l;
529
530 r = safe_atou64("12345", &l);
531 assert_se(r == 0);
532 assert_se(l == 12345);
533
534 r = safe_atou64(" 12345", &l);
535 assert_se(r == 0);
536 assert_se(l == 12345);
537
53c6db99
LP		 538 r = safe_atou64("0o11", &l);
539 assert_se(r == 0);
540 assert_se(l == 9);
541
542 r = safe_atou64("0b11", &l);
543 assert_se(r == 0);
544 assert_se(l == 3);
545
bf32e385
ZJS		 546 r = safe_atou64("18446744073709551617", &l);
547 assert_se(r == -ERANGE);
548
549 r = safe_atou64("-1", &l);
550 assert_se(r == -ERANGE);
551
552 r = safe_atou64(" -1", &l);
553 assert_se(r == -ERANGE);
554
555 r = safe_atou64("junk", &l);
556 assert_se(r == -EINVAL);
557
558 r = safe_atou64("123x", &l);
559 assert_se(r == -EINVAL);
3fcf65c3
YW		 560
561 r = safe_atou64("12.3", &l);
562 assert_se(r == -EINVAL);
563
564 r = safe_atou64("", &l);
565 assert_se(r == -EINVAL);
bf32e385
ZJS		 566}
567
568static void test_safe_atoi64(void) {
569 int r;
570 int64_t l;
571
572 r = safe_atoi64("-12345", &l);
573 assert_se(r == 0);
574 assert_se(l == -12345);
575
576 r = safe_atoi64(" -12345", &l);
577 assert_se(r == 0);
578 assert_se(l == -12345);
579
580 r = safe_atoi64("32767", &l);
581 assert_se(r == 0);
582 assert_se(l == 32767);
583
584 r = safe_atoi64(" 32767", &l);
585 assert_se(r == 0);
586 assert_se(l == 32767);
587
53c6db99
LP		 588 r = safe_atoi64(" 0o20", &l);
589 assert_se(r == 0);
590 assert_se(l == 16);
591
592 r = safe_atoi64(" 0b01010", &l);
593 assert_se(r == 0);
594 assert_se(l == 10);
595
bf32e385
ZJS		 596 r = safe_atoi64("9223372036854775813", &l);
597 assert_se(r == -ERANGE);
598
599 r = safe_atoi64("-9223372036854775813", &l);
600 assert_se(r == -ERANGE);
601
602 r = safe_atoi64("junk", &l);
603 assert_se(r == -EINVAL);
604
605 r = safe_atoi64("123x", &l);
606 assert_se(r == -EINVAL);
3fcf65c3
YW		 607
608 r = safe_atoi64("12.3", &l);
609 assert_se(r == -EINVAL);
610
611 r = safe_atoi64("", &l);
612 assert_se(r == -EINVAL);
bb269eed
FB		 613}
614
ce51632a
ZJS		 615static void test_safe_atoux64(void) {
616 int r;
617 uint64_t l;
618
619 r = safe_atoux64("12345", &l);
620 assert_se(r == 0);
621 assert_se(l == 0x12345);
622
623 r = safe_atoux64(" 12345", &l);
624 assert_se(r == 0);
625 assert_se(l == 0x12345);
626
627 r = safe_atoux64("0x12345", &l);
628 assert_se(r == 0);
629 assert_se(l == 0x12345);
630
53c6db99
LP		 631 r = safe_atoux64("0b11011", &l);
632 assert_se(r == 0);
633 assert_se(l == 11603985);
634
635 r = safe_atoux64("0o11011", &l);
636 assert_se(r == -EINVAL);
637
ce51632a
ZJS		 638 r = safe_atoux64("18446744073709551617", &l);
639 assert_se(r == -ERANGE);
640
641 r = safe_atoux64("-1", &l);
642 assert_se(r == -ERANGE);
643
644 r = safe_atoux64(" -1", &l);
645 assert_se(r == -ERANGE);
646
647 r = safe_atoux64("junk", &l);
648 assert_se(r == -EINVAL);
649
650 r = safe_atoux64("123x", &l);
651 assert_se(r == -EINVAL);
652
653 r = safe_atoux64("12.3", &l);
654 assert_se(r == -EINVAL);
655
656 r = safe_atoux64("", &l);
657 assert_se(r == -EINVAL);
658}
659
bb269eed
FB		 660static void test_safe_atod(void) {
661 int r;
662 double d;
663 char *e;
664
665 r = safe_atod("junk", &d);
666 assert_se(r == -EINVAL);
667
668 r = safe_atod("0.2244", &d);
669 assert_se(r == 0);
670 assert_se(fabs(d - 0.2244) < 0.000001);
671
672 r = safe_atod("0,5", &d);
673 assert_se(r == -EINVAL);
674
675 errno = 0;
676 strtod("0,5", &e);
677 assert_se(*e == ',');
678
3fcf65c3
YW		 679 r = safe_atod("", &d);
680 assert_se(r == -EINVAL);
681
bb269eed
FB		 682 /* Check if this really is locale independent */
683 if (setlocale(LC_NUMERIC, "de_DE.utf8")) {
684
685 r = safe_atod("0.2244", &d);
686 assert_se(r == 0);
687 assert_se(fabs(d - 0.2244) < 0.000001);
688
689 r = safe_atod("0,5", &d);
690 assert_se(r == -EINVAL);
691
692 errno = 0;
693 assert_se(fabs(strtod("0,5", &e) - 0.5) < 0.00001);
3fcf65c3
YW		 694
695 r = safe_atod("", &d);
696 assert_se(r == -EINVAL);
bb269eed
FB		 697 }
698
699 /* And check again, reset */
700 assert_se(setlocale(LC_NUMERIC, "C"));
701
702 r = safe_atod("0.2244", &d);
703 assert_se(r == 0);
704 assert_se(fabs(d - 0.2244) < 0.000001);
705
706 r = safe_atod("0,5", &d);
707 assert_se(r == -EINVAL);
708
709 errno = 0;
710 strtod("0,5", &e);
711 assert_se(*e == ',');
3fcf65c3
YW		 712
713 r = safe_atod("", &d);
714 assert_se(r == -EINVAL);
bb269eed
FB		 715}
716
41bf0590
LP		 717static void test_parse_nice(void) {
718 int n;
719
720 assert_se(parse_nice("0", &n) >= 0 && n == 0);
721 assert_se(parse_nice("+0", &n) >= 0 && n == 0);
722 assert_se(parse_nice("-1", &n) >= 0 && n == -1);
723 assert_se(parse_nice("-2", &n) >= 0 && n == -2);
724 assert_se(parse_nice("1", &n) >= 0 && n == 1);
725 assert_se(parse_nice("2", &n) >= 0 && n == 2);
726 assert_se(parse_nice("+1", &n) >= 0 && n == 1);
727 assert_se(parse_nice("+2", &n) >= 0 && n == 2);
728 assert_se(parse_nice("-20", &n) >= 0 && n == -20);
729 assert_se(parse_nice("19", &n) >= 0 && n == 19);
730 assert_se(parse_nice("+19", &n) >= 0 && n == 19);
731
41bf0590
LP		 732 assert_se(parse_nice("", &n) == -EINVAL);
733 assert_se(parse_nice("-", &n) == -EINVAL);
734 assert_se(parse_nice("+", &n) == -EINVAL);
735 assert_se(parse_nice("xx", &n) == -EINVAL);
736 assert_se(parse_nice("-50", &n) == -ERANGE);
737 assert_se(parse_nice("50", &n) == -ERANGE);
738 assert_se(parse_nice("+50", &n) == -ERANGE);
739 assert_se(parse_nice("-21", &n) == -ERANGE);
740 assert_se(parse_nice("20", &n) == -ERANGE);
741 assert_se(parse_nice("+20", &n) == -ERANGE);
742}
743
fbcc7f41
FB		 744static void test_parse_dev(void) {
745 dev_t dev;
746
3fcf65c3
YW		 747 assert_se(parse_dev("", &dev) == -EINVAL);
748 assert_se(parse_dev("junk", &dev) == -EINVAL);
fbcc7f41
FB		 749 assert_se(parse_dev("0", &dev) == -EINVAL);
750 assert_se(parse_dev("5", &dev) == -EINVAL);
751 assert_se(parse_dev("5:", &dev) == -EINVAL);
752 assert_se(parse_dev(":5", &dev) == -EINVAL);
de06c0cf 753 assert_se(parse_dev("-1:-1", &dev) == -EINVAL);
fbcc7f41
FB		 754#if SIZEOF_DEV_T < 8
755 assert_se(parse_dev("4294967295:4294967295", &dev) == -EINVAL);
756#endif
757 assert_se(parse_dev("8:11", &dev) >= 0 && major(dev) == 8 && minor(dev) == 11);
de06c0cf 758 assert_se(parse_dev("0:0", &dev) >= 0 && major(dev) == 0 && minor(dev) == 0);
fbcc7f41
FB		 759}
760
473d2ec3
YW		 761static void test_parse_errno(void) {
762 assert_se(parse_errno("EILSEQ") == EILSEQ);
763 assert_se(parse_errno("EINVAL") == EINVAL);
764 assert_se(parse_errno("0") == 0);
765 assert_se(parse_errno("1") == 1);
766 assert_se(parse_errno("4095") == 4095);
767
768 assert_se(parse_errno("-1") == -ERANGE);
769 assert_se(parse_errno("-3") == -ERANGE);
770 assert_se(parse_errno("4096") == -ERANGE);
771
772 assert_se(parse_errno("") == -EINVAL);
773 assert_se(parse_errno("12.3") == -EINVAL);
774 assert_se(parse_errno("123junk") == -EINVAL);
775 assert_se(parse_errno("junk123") == -EINVAL);
776 assert_se(parse_errno("255EILSEQ") == -EINVAL);
777 assert_se(parse_errno("EINVAL12") == -EINVAL);
778 assert_se(parse_errno("-EINVAL") == -EINVAL);
779 assert_se(parse_errno("EINVALaaa") == -EINVAL);
780}
781
f91c6093
LP		 782static void test_parse_mtu(void) {
783 uint32_t mtu = 0;
784
785 assert_se(parse_mtu(AF_UNSPEC, "1500", &mtu) >= 0 && mtu == 1500);
786 assert_se(parse_mtu(AF_UNSPEC, "1400", &mtu) >= 0 && mtu == 1400);
787 assert_se(parse_mtu(AF_UNSPEC, "65535", &mtu) >= 0 && mtu == 65535);
788 assert_se(parse_mtu(AF_UNSPEC, "65536", &mtu) >= 0 && mtu == 65536);
789 assert_se(parse_mtu(AF_UNSPEC, "4294967295", &mtu) >= 0 && mtu == 4294967295);
790 assert_se(parse_mtu(AF_UNSPEC, "500", &mtu) >= 0 && mtu == 500);
791 assert_se(parse_mtu(AF_UNSPEC, "1280", &mtu) >= 0 && mtu == 1280);
792 assert_se(parse_mtu(AF_INET6, "1280", &mtu) >= 0 && mtu == 1280);
793 assert_se(parse_mtu(AF_INET6, "1279", &mtu) == -ERANGE);
794 assert_se(parse_mtu(AF_UNSPEC, "4294967296", &mtu) == -ERANGE);
795 assert_se(parse_mtu(AF_INET6, "4294967296", &mtu) == -ERANGE);
796 assert_se(parse_mtu(AF_INET6, "68", &mtu) == -ERANGE);
797 assert_se(parse_mtu(AF_UNSPEC, "68", &mtu) >= 0 && mtu == 68);
798 assert_se(parse_mtu(AF_UNSPEC, "67", &mtu) == -ERANGE);
799 assert_se(parse_mtu(AF_UNSPEC, "0", &mtu) == -ERANGE);
800 assert_se(parse_mtu(AF_UNSPEC, "", &mtu) == -EINVAL);
801}
802
510ca79c
AZ		 803static void test_parse_loadavg_fixed_point(void) {
804 loadavg_t fp;
805
806 assert_se(parse_loadavg_fixed_point("1.23", &fp) == 0);
f0e2cfc6
LB		 807 assert_se(INT_SIDE(fp) == 1);
808 assert_se(DECIMAL_SIDE(fp) == 23);
510ca79c
AZ		 809
810 assert_se(parse_loadavg_fixed_point("1.80", &fp) == 0);
f0e2cfc6
LB		 811 assert_se(INT_SIDE(fp) == 1);
812 assert_se(DECIMAL_SIDE(fp) == 80);
510ca79c
AZ		 813
814 assert_se(parse_loadavg_fixed_point("0.07", &fp) == 0);
f0e2cfc6
LB		 815 assert_se(INT_SIDE(fp) == 0);
816 assert_se(DECIMAL_SIDE(fp) == 7);
510ca79c
AZ		 817
818 assert_se(parse_loadavg_fixed_point("0.00", &fp) == 0);
f0e2cfc6
LB		 819 assert_se(INT_SIDE(fp) == 0);
820 assert_se(DECIMAL_SIDE(fp) == 0);
510ca79c
AZ		 821
822 assert_se(parse_loadavg_fixed_point("4096.57", &fp) == 0);
f0e2cfc6
LB		 823 assert_se(INT_SIDE(fp) == 4096);
824 assert_se(DECIMAL_SIDE(fp) == 57);
510ca79c
AZ		 825
826 /* Caps out at 2 digit fracs */
827 assert_se(parse_loadavg_fixed_point("1.100", &fp) == -ERANGE);
828
829 assert_se(parse_loadavg_fixed_point("4096.4096", &fp) == -ERANGE);
830 assert_se(parse_loadavg_fixed_point("-4000.5", &fp) == -ERANGE);
831 assert_se(parse_loadavg_fixed_point("18446744073709551615.5", &fp) == -ERANGE);
832 assert_se(parse_loadavg_fixed_point("foobar", &fp) == -EINVAL);
833 assert_se(parse_loadavg_fixed_point("3333", &fp) == -EINVAL);
834 assert_se(parse_loadavg_fixed_point("1.2.3", &fp) == -EINVAL);
835 assert_se(parse_loadavg_fixed_point(".", &fp) == -EINVAL);
836 assert_se(parse_loadavg_fixed_point("", &fp) == -EINVAL);
837}
838
bb269eed
FB		 839int main(int argc, char *argv[]) {
840 log_parse_environment();
841 log_open();
842
843 test_parse_boolean();
844 test_parse_pid();
845 test_parse_mode();
846 test_parse_size();
847 test_parse_range();
848 test_safe_atolli();
849 test_safe_atou16();
850 test_safe_atoi16();
5547c125 851 test_safe_atoux16();
bf32e385
ZJS		 852 test_safe_atou64();
853 test_safe_atoi64();
ce51632a 854 test_safe_atoux64();
bb269eed 855 test_safe_atod();
41bf0590 856 test_parse_nice();
fbcc7f41 857 test_parse_dev();
473d2ec3 858 test_parse_errno();
f91c6093 859 test_parse_mtu();
510ca79c 860 test_parse_loadavg_fixed_point();
bb269eed
FB		 861
862 return 0;
863}
Unnamed repository; edit this file 'description' to name the repository.