]> 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
zsh: add service-log-{level,target} completions for systemctl
[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
5a45a6bb 97TEST(parse_size_iec) {
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
5a45a6bb
JJ		 167TEST(parse_size_si) {
168 uint64_t bytes;
169
170 assert_se(parse_size("", 1000, &bytes) == -EINVAL);
171
172 assert_se(parse_size("111", 1000, &bytes) == 0);
173 assert_se(bytes == 111);
174
175 assert_se(parse_size("111.4", 1000, &bytes) == 0);
176 assert_se(bytes == 111);
177
178 assert_se(parse_size(" 112 B", 1000, &bytes) == 0);
179 assert_se(bytes == 112);
180
181 assert_se(parse_size(" 112.6 B", 1000, &bytes) == 0);
182 assert_se(bytes == 112);
183
184 assert_se(parse_size("3.5 K", 1000, &bytes) == 0);
185 assert_se(bytes == 3*1000 + 500);
186
187 assert_se(parse_size("3. K", 1000, &bytes) == 0);
188 assert_se(bytes == 3*1000);
189
190 assert_se(parse_size("3.0 K", 1000, &bytes) == 0);
191 assert_se(bytes == 3*1000);
192
193 assert_se(parse_size("3. 0 K", 1000, &bytes) == -EINVAL);
194
195 assert_se(parse_size(" 4 M 11.5K", 1000, &bytes) == 0);
196 assert_se(bytes == 4*1000*1000 + 11 * 1000 + 500);
197
198 assert_se(parse_size("3B3.5G", 1000, &bytes) == -EINVAL);
199
200 assert_se(parse_size("3.5G3B", 1000, &bytes) == 0);
201 assert_se(bytes == 3ULL*1000*1000*1000 + 500*1000*1000 + 3);
202
203 assert_se(parse_size("3.5G 4B", 1000, &bytes) == 0);
204 assert_se(bytes == 3ULL*1000*1000*1000 + 500*1000*1000 + 4);
205
206 assert_se(parse_size("3B3G4T", 1000, &bytes) == -EINVAL);
207
208 assert_se(parse_size("4T3G3B", 1000, &bytes) == 0);
209 assert_se(bytes == (4ULL*1000 + 3)*1000*1000*1000 + 3);
210
211 assert_se(parse_size(" 4 T 3 G 3 B", 1000, &bytes) == 0);
212 assert_se(bytes == (4ULL*1000 + 3)*1000*1000*1000 + 3);
213
214 assert_se(parse_size("12P", 1000, &bytes) == 0);
215 assert_se(bytes == 12ULL * 1000*1000*1000*1000*1000);
216
217 assert_se(parse_size("12P12P", 1000, &bytes) == -EINVAL);
218
219 assert_se(parse_size("3E 2P", 1000, &bytes) == 0);
220 assert_se(bytes == (3 * 1000 + 2ULL) * 1000*1000*1000*1000*1000);
221
222 assert_se(parse_size("12X", 1000, &bytes) == -EINVAL);
223
224 assert_se(parse_size("12.5X", 1000, &bytes) == -EINVAL);
225
226 assert_se(parse_size("12.5e3", 1000, &bytes) == -EINVAL);
227
228 assert_se(parse_size("1000E", 1000, &bytes) == -ERANGE);
229 assert_se(parse_size("-1", 1000, &bytes) == -ERANGE);
230 assert_se(parse_size("-1000E", 1000, &bytes) == -ERANGE);
231
232 assert_se(parse_size("-1000P", 1000, &bytes) == -ERANGE);
233
234 assert_se(parse_size("-10B 20K", 1000, &bytes) == -ERANGE);
235}
236
4f7452a8 237TEST(parse_range) {
bb269eed
FB		 238 unsigned lower, upper;
239
240 /* Successful cases */
241 assert_se(parse_range("111", &lower, &upper) == 0);
242 assert_se(lower == 111);
243 assert_se(upper == 111);
244
245 assert_se(parse_range("111-123", &lower, &upper) == 0);
246 assert_se(lower == 111);
247 assert_se(upper == 123);
248
249 assert_se(parse_range("123-111", &lower, &upper) == 0);
250 assert_se(lower == 123);
251 assert_se(upper == 111);
252
253 assert_se(parse_range("123-123", &lower, &upper) == 0);
254 assert_se(lower == 123);
255 assert_se(upper == 123);
256
257 assert_se(parse_range("0", &lower, &upper) == 0);
258 assert_se(lower == 0);
259 assert_se(upper == 0);
260
261 assert_se(parse_range("0-15", &lower, &upper) == 0);
262 assert_se(lower == 0);
263 assert_se(upper == 15);
264
265 assert_se(parse_range("15-0", &lower, &upper) == 0);
266 assert_se(lower == 15);
267 assert_se(upper == 0);
268
269 assert_se(parse_range("128-65535", &lower, &upper) == 0);
270 assert_se(lower == 128);
271 assert_se(upper == 65535);
272
273 assert_se(parse_range("1024-4294967295", &lower, &upper) == 0);
274 assert_se(lower == 1024);
275 assert_se(upper == 4294967295);
276
277 /* Leading whitespace is acceptable */
278 assert_se(parse_range(" 111", &lower, &upper) == 0);
279 assert_se(lower == 111);
280 assert_se(upper == 111);
281
282 assert_se(parse_range(" 111-123", &lower, &upper) == 0);
283 assert_se(lower == 111);
284 assert_se(upper == 123);
285
286 assert_se(parse_range("111- 123", &lower, &upper) == 0);
287 assert_se(lower == 111);
288 assert_se(upper == 123);
289
290 assert_se(parse_range("\t111-\t123", &lower, &upper) == 0);
291 assert_se(lower == 111);
292 assert_se(upper == 123);
293
294 assert_se(parse_range(" \t 111- \t 123", &lower, &upper) == 0);
295 assert_se(lower == 111);
296 assert_se(upper == 123);
297
298 /* Error cases, make sure they fail as expected */
299 lower = upper = 9999;
300 assert_se(parse_range("111garbage", &lower, &upper) == -EINVAL);
301 assert_se(lower == 9999);
302 assert_se(upper == 9999);
303
304 assert_se(parse_range("garbage111", &lower, &upper) == -EINVAL);
305 assert_se(lower == 9999);
306 assert_se(upper == 9999);
307
308 assert_se(parse_range("garbage", &lower, &upper) == -EINVAL);
309 assert_se(lower == 9999);
310 assert_se(upper == 9999);
311
312 assert_se(parse_range("111-123garbage", &lower, &upper) == -EINVAL);
313 assert_se(lower == 9999);
314 assert_se(upper == 9999);
315
316 assert_se(parse_range("111garbage-123", &lower, &upper) == -EINVAL);
317 assert_se(lower == 9999);
318 assert_se(upper == 9999);
319
320 /* Empty string */
321 lower = upper = 9999;
322 assert_se(parse_range("", &lower, &upper) == -EINVAL);
323 assert_se(lower == 9999);
324 assert_se(upper == 9999);
325
326 /* 111--123 will pass -123 to safe_atou which returns -ERANGE for negative */
327 assert_se(parse_range("111--123", &lower, &upper) == -ERANGE);
328 assert_se(lower == 9999);
329 assert_se(upper == 9999);
330
3fcf65c3
YW		 331 assert_se(parse_range("-123", &lower, &upper) == -EINVAL);
332 assert_se(lower == 9999);
333 assert_se(upper == 9999);
334
bb269eed
FB		 335 assert_se(parse_range("-111-123", &lower, &upper) == -EINVAL);
336 assert_se(lower == 9999);
337 assert_se(upper == 9999);
338
339 assert_se(parse_range("111-123-", &lower, &upper) == -EINVAL);
340 assert_se(lower == 9999);
341 assert_se(upper == 9999);
342
343 assert_se(parse_range("111.4-123", &lower, &upper) == -EINVAL);
344 assert_se(lower == 9999);
345 assert_se(upper == 9999);
346
347 assert_se(parse_range("111-123.4", &lower, &upper) == -EINVAL);
348 assert_se(lower == 9999);
349 assert_se(upper == 9999);
350
351 assert_se(parse_range("111,4-123", &lower, &upper) == -EINVAL);
352 assert_se(lower == 9999);
353 assert_se(upper == 9999);
354
355 assert_se(parse_range("111-123,4", &lower, &upper) == -EINVAL);
356 assert_se(lower == 9999);
357 assert_se(upper == 9999);
358
359 /* Error on trailing dash */
360 assert_se(parse_range("111-", &lower, &upper) == -EINVAL);
361 assert_se(lower == 9999);
362 assert_se(upper == 9999);
363
364 assert_se(parse_range("111-123-", &lower, &upper) == -EINVAL);
365 assert_se(lower == 9999);
366 assert_se(upper == 9999);
367
368 assert_se(parse_range("111--", &lower, &upper) == -EINVAL);
369 assert_se(lower == 9999);
370 assert_se(upper == 9999);
371
372 assert_se(parse_range("111- ", &lower, &upper) == -EINVAL);
373 assert_se(lower == 9999);
374 assert_se(upper == 9999);
375
376 /* Whitespace is not a separator */
377 assert_se(parse_range("111 123", &lower, &upper) == -EINVAL);
378 assert_se(lower == 9999);
379 assert_se(upper == 9999);
380
381 assert_se(parse_range("111\t123", &lower, &upper) == -EINVAL);
382 assert_se(lower == 9999);
383 assert_se(upper == 9999);
384
385 assert_se(parse_range("111 \t 123", &lower, &upper) == -EINVAL);
386 assert_se(lower == 9999);
387 assert_se(upper == 9999);
388
389 /* Trailing whitespace is invalid (from safe_atou) */
390 assert_se(parse_range("111 ", &lower, &upper) == -EINVAL);
391 assert_se(lower == 9999);
392 assert_se(upper == 9999);
393
394 assert_se(parse_range("111-123 ", &lower, &upper) == -EINVAL);
395 assert_se(lower == 9999);
396 assert_se(upper == 9999);
397
398 assert_se(parse_range("111 -123", &lower, &upper) == -EINVAL);
399 assert_se(lower == 9999);
400 assert_se(upper == 9999);
401
402 assert_se(parse_range("111 -123 ", &lower, &upper) == -EINVAL);
403 assert_se(lower == 9999);
404 assert_se(upper == 9999);
405
406 assert_se(parse_range("111\t-123\t", &lower, &upper) == -EINVAL);
407 assert_se(lower == 9999);
408 assert_se(upper == 9999);
409
410 assert_se(parse_range("111 \t -123 \t ", &lower, &upper) == -EINVAL);
411 assert_se(lower == 9999);
412 assert_se(upper == 9999);
413
414 /* Out of the "unsigned" range, this is 1<<64 */
415 assert_se(parse_range("0-18446744073709551616", &lower, &upper) == -ERANGE);
416 assert_se(lower == 9999);
417 assert_se(upper == 9999);
418}
419
4f7452a8 420TEST(safe_atolli) {
bb269eed
FB		 421 int r;
422 long long l;
423
424 r = safe_atolli("12345", &l);
425 assert_se(r == 0);
426 assert_se(l == 12345);
427
5c280bcc
MP		 428 r = safe_atolli(" 12345", &l);
429 assert_se(r == 0);
430 assert_se(l == 12345);
431
432 r = safe_atolli("-12345", &l);
433 assert_se(r == 0);
434 assert_se(l == -12345);
435
436 r = safe_atolli(" -12345", &l);
437 assert_se(r == 0);
438 assert_se(l == -12345);
439
53c6db99
LP		 440 r = safe_atolli("0x5", &l);
441 assert_se(r == 0);
442 assert_se(l == 5);
443
444 r = safe_atolli("0o6", &l);
445 assert_se(r == 0);
446 assert_se(l == 6);
447
448 r = safe_atolli("0B101", &l);
449 assert_se(r == 0);
450 assert_se(l == 5);
451
5c280bcc
MP		 452 r = safe_atolli("12345678901234567890", &l);
453 assert_se(r == -ERANGE);
454
455 r = safe_atolli("-12345678901234567890", &l);
456 assert_se(r == -ERANGE);
457
bb269eed
FB		 458 r = safe_atolli("junk", &l);
459 assert_se(r == -EINVAL);
3fcf65c3
YW		 460
461 r = safe_atolli("123x", &l);
462 assert_se(r == -EINVAL);
463
464 r = safe_atolli("12.3", &l);
465 assert_se(r == -EINVAL);
466
467 r = safe_atolli("", &l);
468 assert_se(r == -EINVAL);
bb269eed
FB		 469}
470
4f7452a8 471TEST(safe_atou16) {
bb269eed
FB		 472 int r;
473 uint16_t l;
474
475 r = safe_atou16("12345", &l);
476 assert_se(r == 0);
477 assert_se(l == 12345);
478
5c280bcc
MP		 479 r = safe_atou16(" 12345", &l);
480 assert_se(r == 0);
481 assert_se(l == 12345);
482
8eb491f4
ZJS		 483 r = safe_atou16("+12345", &l);
484 assert_se(r == 0);
485 assert_se(l == 12345);
486
487 r = safe_atou16(" +12345", &l);
488 assert_se(r == 0);
489 assert_se(l == 12345);
490
bb269eed
FB		 491 r = safe_atou16("123456", &l);
492 assert_se(r == -ERANGE);
493
5c280bcc
MP		 494 r = safe_atou16("-1", &l);
495 assert_se(r == -ERANGE);
496
497 r = safe_atou16(" -1", &l);
498 assert_se(r == -ERANGE);
499
bb269eed
FB		 500 r = safe_atou16("junk", &l);
501 assert_se(r == -EINVAL);
bf32e385
ZJS		 502
503 r = safe_atou16("123x", &l);
504 assert_se(r == -EINVAL);
3fcf65c3
YW		 505
506 r = safe_atou16("12.3", &l);
507 assert_se(r == -EINVAL);
508
509 r = safe_atou16("", &l);
510 assert_se(r == -EINVAL);
bb269eed
FB		 511}
512
4f7452a8 513TEST(safe_atoi16) {
bb269eed
FB		 514 int r;
515 int16_t l;
516
517 r = safe_atoi16("-12345", &l);
518 assert_se(r == 0);
519 assert_se(l == -12345);
520
5c280bcc
MP		 521 r = safe_atoi16(" -12345", &l);
522 assert_se(r == 0);
523 assert_se(l == -12345);
524
8eb491f4
ZJS		 525 r = safe_atoi16("+12345", &l);
526 assert_se(r == 0);
527 assert_se(l == 12345);
528
529 r = safe_atoi16(" +12345", &l);
530 assert_se(r == 0);
531 assert_se(l == 12345);
532
5c280bcc
MP		 533 r = safe_atoi16("32767", &l);
534 assert_se(r == 0);
535 assert_se(l == 32767);
536
537 r = safe_atoi16(" 32767", &l);
538 assert_se(r == 0);
539 assert_se(l == 32767);
540
53c6db99
LP		 541 r = safe_atoi16("0o11", &l);
542 assert_se(r == 0);
543 assert_se(l == 9);
544
545 r = safe_atoi16("0B110", &l);
546 assert_se(r == 0);
547 assert_se(l == 6);
548
bb269eed
FB		 549 r = safe_atoi16("36536", &l);
550 assert_se(r == -ERANGE);
551
5c280bcc
MP		 552 r = safe_atoi16("-32769", &l);
553 assert_se(r == -ERANGE);
554
bb269eed
FB		 555 r = safe_atoi16("junk", &l);
556 assert_se(r == -EINVAL);
bf32e385
ZJS		 557
558 r = safe_atoi16("123x", &l);
559 assert_se(r == -EINVAL);
3fcf65c3
YW		 560
561 r = safe_atoi16("12.3", &l);
562 assert_se(r == -EINVAL);
563
564 r = safe_atoi16("", &l);
565 assert_se(r == -EINVAL);
bf32e385
ZJS		 566}
567
4f7452a8 568TEST(safe_atoux16) {
5547c125
PU		 569 int r;
570 uint16_t l;
571
572 r = safe_atoux16("1234", &l);
573 assert_se(r == 0);
574 assert_se(l == 0x1234);
575
576 r = safe_atoux16("abcd", &l);
577 assert_se(r == 0);
578 assert_se(l == 0xabcd);
579
580 r = safe_atoux16(" 1234", &l);
581 assert_se(r == 0);
582 assert_se(l == 0x1234);
583
584 r = safe_atoux16("12345", &l);
585 assert_se(r == -ERANGE);
586
587 r = safe_atoux16("-1", &l);
588 assert_se(r == -ERANGE);
589
590 r = safe_atoux16(" -1", &l);
591 assert_se(r == -ERANGE);
592
53c6db99
LP		 593 r = safe_atoux16("0b1", &l);
594 assert_se(r == 0);
595 assert_se(l == 177);
596
597 r = safe_atoux16("0o70", &l);
598 assert_se(r == -EINVAL);
599
5547c125
PU		 600 r = safe_atoux16("junk", &l);
601 assert_se(r == -EINVAL);
602
603 r = safe_atoux16("123x", &l);
604 assert_se(r == -EINVAL);
605
606 r = safe_atoux16("12.3", &l);
607 assert_se(r == -EINVAL);
608
609 r = safe_atoux16("", &l);
610 assert_se(r == -EINVAL);
611}
612
4f7452a8 613TEST(safe_atou64) {
bf32e385
ZJS		 614 int r;
615 uint64_t l;
616
617 r = safe_atou64("12345", &l);
618 assert_se(r == 0);
619 assert_se(l == 12345);
620
621 r = safe_atou64(" 12345", &l);
622 assert_se(r == 0);
623 assert_se(l == 12345);
624
53c6db99
LP		 625 r = safe_atou64("0o11", &l);
626 assert_se(r == 0);
627 assert_se(l == 9);
628
629 r = safe_atou64("0b11", &l);
630 assert_se(r == 0);
631 assert_se(l == 3);
632
bf32e385
ZJS		 633 r = safe_atou64("18446744073709551617", &l);
634 assert_se(r == -ERANGE);
635
636 r = safe_atou64("-1", &l);
637 assert_se(r == -ERANGE);
638
639 r = safe_atou64(" -1", &l);
640 assert_se(r == -ERANGE);
641
642 r = safe_atou64("junk", &l);
643 assert_se(r == -EINVAL);
644
645 r = safe_atou64("123x", &l);
646 assert_se(r == -EINVAL);
3fcf65c3
YW		 647
648 r = safe_atou64("12.3", &l);
649 assert_se(r == -EINVAL);
650
651 r = safe_atou64("", &l);
652 assert_se(r == -EINVAL);
bf32e385
ZJS		 653}
654
4f7452a8 655TEST(safe_atoi64) {
bf32e385
ZJS		 656 int r;
657 int64_t l;
658
659 r = safe_atoi64("-12345", &l);
660 assert_se(r == 0);
661 assert_se(l == -12345);
662
663 r = safe_atoi64(" -12345", &l);
664 assert_se(r == 0);
665 assert_se(l == -12345);
666
667 r = safe_atoi64("32767", &l);
668 assert_se(r == 0);
669 assert_se(l == 32767);
670
671 r = safe_atoi64(" 32767", &l);
672 assert_se(r == 0);
673 assert_se(l == 32767);
674
53c6db99
LP		 675 r = safe_atoi64(" 0o20", &l);
676 assert_se(r == 0);
677 assert_se(l == 16);
678
679 r = safe_atoi64(" 0b01010", &l);
680 assert_se(r == 0);
681 assert_se(l == 10);
682
bf32e385
ZJS		 683 r = safe_atoi64("9223372036854775813", &l);
684 assert_se(r == -ERANGE);
685
686 r = safe_atoi64("-9223372036854775813", &l);
687 assert_se(r == -ERANGE);
688
689 r = safe_atoi64("junk", &l);
690 assert_se(r == -EINVAL);
691
692 r = safe_atoi64("123x", &l);
693 assert_se(r == -EINVAL);
3fcf65c3
YW		 694
695 r = safe_atoi64("12.3", &l);
696 assert_se(r == -EINVAL);
697
698 r = safe_atoi64("", &l);
699 assert_se(r == -EINVAL);
bb269eed
FB		 700}
701
4f7452a8 702TEST(safe_atoux64) {
ce51632a
ZJS		 703 int r;
704 uint64_t l;
705
706 r = safe_atoux64("12345", &l);
707 assert_se(r == 0);
708 assert_se(l == 0x12345);
709
710 r = safe_atoux64(" 12345", &l);
711 assert_se(r == 0);
712 assert_se(l == 0x12345);
713
714 r = safe_atoux64("0x12345", &l);
715 assert_se(r == 0);
716 assert_se(l == 0x12345);
717
53c6db99
LP		 718 r = safe_atoux64("0b11011", &l);
719 assert_se(r == 0);
720 assert_se(l == 11603985);
721
8eb491f4
ZJS		 722 r = safe_atoux64("+12345", &l);
723 assert_se(r == 0);
724 assert_se(l == 0x12345);
725
726 r = safe_atoux64(" +12345", &l);
727 assert_se(r == 0);
728 assert_se(l == 0x12345);
729
730 r = safe_atoux64("+0x12345", &l);
731 assert_se(r == 0);
732 assert_se(l == 0x12345);
733
734 r = safe_atoux64("+0b11011", &l);
735 assert_se(r == 0);
736 assert_se(l == 11603985);
737
53c6db99
LP		 738 r = safe_atoux64("0o11011", &l);
739 assert_se(r == -EINVAL);
740
ce51632a
ZJS		 741 r = safe_atoux64("18446744073709551617", &l);
742 assert_se(r == -ERANGE);
743
744 r = safe_atoux64("-1", &l);
745 assert_se(r == -ERANGE);
746
747 r = safe_atoux64(" -1", &l);
748 assert_se(r == -ERANGE);
749
750 r = safe_atoux64("junk", &l);
751 assert_se(r == -EINVAL);
752
753 r = safe_atoux64("123x", &l);
754 assert_se(r == -EINVAL);
755
756 r = safe_atoux64("12.3", &l);
757 assert_se(r == -EINVAL);
758
759 r = safe_atoux64("", &l);
760 assert_se(r == -EINVAL);
761}
762
4f7452a8 763TEST(safe_atod) {
bb269eed
FB		 764 int r;
765 double d;
766 char *e;
767
768 r = safe_atod("junk", &d);
769 assert_se(r == -EINVAL);
770
771 r = safe_atod("0.2244", &d);
772 assert_se(r == 0);
773 assert_se(fabs(d - 0.2244) < 0.000001);
774
775 r = safe_atod("0,5", &d);
776 assert_se(r == -EINVAL);
777
778 errno = 0;
779 strtod("0,5", &e);
780 assert_se(*e == ',');
781
3fcf65c3
YW		 782 r = safe_atod("", &d);
783 assert_se(r == -EINVAL);
784
bb269eed
FB		 785 /* Check if this really is locale independent */
786 if (setlocale(LC_NUMERIC, "de_DE.utf8")) {
787
788 r = safe_atod("0.2244", &d);
789 assert_se(r == 0);
790 assert_se(fabs(d - 0.2244) < 0.000001);
791
792 r = safe_atod("0,5", &d);
793 assert_se(r == -EINVAL);
794
795 errno = 0;
796 assert_se(fabs(strtod("0,5", &e) - 0.5) < 0.00001);
3fcf65c3
YW		 797
798 r = safe_atod("", &d);
799 assert_se(r == -EINVAL);
bb269eed
FB		 800 }
801
802 /* And check again, reset */
803 assert_se(setlocale(LC_NUMERIC, "C"));
804
805 r = safe_atod("0.2244", &d);
806 assert_se(r == 0);
807 assert_se(fabs(d - 0.2244) < 0.000001);
808
809 r = safe_atod("0,5", &d);
810 assert_se(r == -EINVAL);
811
812 errno = 0;
813 strtod("0,5", &e);
814 assert_se(*e == ',');
3fcf65c3
YW		 815
816 r = safe_atod("", &d);
817 assert_se(r == -EINVAL);
bb269eed
FB		 818}
819
4f7452a8 820TEST(parse_nice) {
41bf0590
LP		 821 int n;
822
823 assert_se(parse_nice("0", &n) >= 0 && n == 0);
824 assert_se(parse_nice("+0", &n) >= 0 && n == 0);
825 assert_se(parse_nice("-1", &n) >= 0 && n == -1);
826 assert_se(parse_nice("-2", &n) >= 0 && n == -2);
827 assert_se(parse_nice("1", &n) >= 0 && n == 1);
828 assert_se(parse_nice("2", &n) >= 0 && n == 2);
829 assert_se(parse_nice("+1", &n) >= 0 && n == 1);
830 assert_se(parse_nice("+2", &n) >= 0 && n == 2);
831 assert_se(parse_nice("-20", &n) >= 0 && n == -20);
832 assert_se(parse_nice("19", &n) >= 0 && n == 19);
833 assert_se(parse_nice("+19", &n) >= 0 && n == 19);
834
41bf0590
LP		 835 assert_se(parse_nice("", &n) == -EINVAL);
836 assert_se(parse_nice("-", &n) == -EINVAL);
837 assert_se(parse_nice("+", &n) == -EINVAL);
838 assert_se(parse_nice("xx", &n) == -EINVAL);
839 assert_se(parse_nice("-50", &n) == -ERANGE);
840 assert_se(parse_nice("50", &n) == -ERANGE);
841 assert_se(parse_nice("+50", &n) == -ERANGE);
842 assert_se(parse_nice("-21", &n) == -ERANGE);
843 assert_se(parse_nice("20", &n) == -ERANGE);
844 assert_se(parse_nice("+20", &n) == -ERANGE);
845}
846
4f7452a8 847TEST(parse_errno) {
473d2ec3
YW		 848 assert_se(parse_errno("EILSEQ") == EILSEQ);
849 assert_se(parse_errno("EINVAL") == EINVAL);
850 assert_se(parse_errno("0") == 0);
851 assert_se(parse_errno("1") == 1);
852 assert_se(parse_errno("4095") == 4095);
853
854 assert_se(parse_errno("-1") == -ERANGE);
855 assert_se(parse_errno("-3") == -ERANGE);
856 assert_se(parse_errno("4096") == -ERANGE);
857
858 assert_se(parse_errno("") == -EINVAL);
859 assert_se(parse_errno("12.3") == -EINVAL);
860 assert_se(parse_errno("123junk") == -EINVAL);
861 assert_se(parse_errno("junk123") == -EINVAL);
862 assert_se(parse_errno("255EILSEQ") == -EINVAL);
863 assert_se(parse_errno("EINVAL12") == -EINVAL);
864 assert_se(parse_errno("-EINVAL") == -EINVAL);
865 assert_se(parse_errno("EINVALaaa") == -EINVAL);
866}
867
754d8b9c
DT		 868TEST(parse_fd) {
869 assert_se(parse_fd("0") == 0);
870 assert_se(parse_fd("1") == 1);
871
872 assert_se(parse_fd("-1") == -ERANGE);
873 assert_se(parse_fd("-3") == -ERANGE);
874
875 assert_se(parse_fd("") == -EINVAL);
876 assert_se(parse_fd("12.3") == -EINVAL);
877 assert_se(parse_fd("123junk") == -EINVAL);
878 assert_se(parse_fd("junk123") == -EINVAL);
879}
880
4f7452a8 881TEST(parse_mtu) {
f91c6093
LP		 882 uint32_t mtu = 0;
883
884 assert_se(parse_mtu(AF_UNSPEC, "1500", &mtu) >= 0 && mtu == 1500);
885 assert_se(parse_mtu(AF_UNSPEC, "1400", &mtu) >= 0 && mtu == 1400);
886 assert_se(parse_mtu(AF_UNSPEC, "65535", &mtu) >= 0 && mtu == 65535);
887 assert_se(parse_mtu(AF_UNSPEC, "65536", &mtu) >= 0 && mtu == 65536);
888 assert_se(parse_mtu(AF_UNSPEC, "4294967295", &mtu) >= 0 && mtu == 4294967295);
889 assert_se(parse_mtu(AF_UNSPEC, "500", &mtu) >= 0 && mtu == 500);
890 assert_se(parse_mtu(AF_UNSPEC, "1280", &mtu) >= 0 && mtu == 1280);
891 assert_se(parse_mtu(AF_INET6, "1280", &mtu) >= 0 && mtu == 1280);
892 assert_se(parse_mtu(AF_INET6, "1279", &mtu) == -ERANGE);
893 assert_se(parse_mtu(AF_UNSPEC, "4294967296", &mtu) == -ERANGE);
894 assert_se(parse_mtu(AF_INET6, "4294967296", &mtu) == -ERANGE);
895 assert_se(parse_mtu(AF_INET6, "68", &mtu) == -ERANGE);
896 assert_se(parse_mtu(AF_UNSPEC, "68", &mtu) >= 0 && mtu == 68);
897 assert_se(parse_mtu(AF_UNSPEC, "67", &mtu) == -ERANGE);
898 assert_se(parse_mtu(AF_UNSPEC, "0", &mtu) == -ERANGE);
899 assert_se(parse_mtu(AF_UNSPEC, "", &mtu) == -EINVAL);
900}
901
4f7452a8 902TEST(parse_loadavg_fixed_point) {
510ca79c
AZ		 903 loadavg_t fp;
904
905 assert_se(parse_loadavg_fixed_point("1.23", &fp) == 0);
3542da24
LB		 906 assert_se(LOADAVG_INT_SIDE(fp) == 1);
907 assert_se(LOADAVG_DECIMAL_SIDE(fp) == 23);
510ca79c
AZ		 908
909 assert_se(parse_loadavg_fixed_point("1.80", &fp) == 0);
3542da24
LB		 910 assert_se(LOADAVG_INT_SIDE(fp) == 1);
911 assert_se(LOADAVG_DECIMAL_SIDE(fp) == 80);
510ca79c
AZ		 912
913 assert_se(parse_loadavg_fixed_point("0.07", &fp) == 0);
3542da24
LB		 914 assert_se(LOADAVG_INT_SIDE(fp) == 0);
915 assert_se(LOADAVG_DECIMAL_SIDE(fp) == 7);
510ca79c
AZ		 916
917 assert_se(parse_loadavg_fixed_point("0.00", &fp) == 0);
3542da24
LB		 918 assert_se(LOADAVG_INT_SIDE(fp) == 0);
919 assert_se(LOADAVG_DECIMAL_SIDE(fp) == 0);
510ca79c
AZ		 920
921 assert_se(parse_loadavg_fixed_point("4096.57", &fp) == 0);
3542da24
LB		 922 assert_se(LOADAVG_INT_SIDE(fp) == 4096);
923 assert_se(LOADAVG_DECIMAL_SIDE(fp) == 57);
510ca79c
AZ		 924
925 /* Caps out at 2 digit fracs */
926 assert_se(parse_loadavg_fixed_point("1.100", &fp) == -ERANGE);
927
928 assert_se(parse_loadavg_fixed_point("4096.4096", &fp) == -ERANGE);
929 assert_se(parse_loadavg_fixed_point("-4000.5", &fp) == -ERANGE);
930 assert_se(parse_loadavg_fixed_point("18446744073709551615.5", &fp) == -ERANGE);
931 assert_se(parse_loadavg_fixed_point("foobar", &fp) == -EINVAL);
932 assert_se(parse_loadavg_fixed_point("3333", &fp) == -EINVAL);
933 assert_se(parse_loadavg_fixed_point("1.2.3", &fp) == -EINVAL);
934 assert_se(parse_loadavg_fixed_point(".", &fp) == -EINVAL);
935 assert_se(parse_loadavg_fixed_point("", &fp) == -EINVAL);
936}
937
4f7452a8 938DEFINE_TEST_MAIN(LOG_INFO);
Unnamed repository; edit this file 'description' to name the repository.