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