]> 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 #30284 from YHNdnzj/fstab-wantedby-defaultdeps
[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
3b6cabd8
ZJS		 420TEST(safe_atou_bounded) {
421 int r;
422 unsigned x;
423
424 r = safe_atou_bounded("12345", 12, 20000, &x);
425 assert_se(r == 0);
426 assert_se(x == 12345);
427
428 r = safe_atou_bounded("12", 12, 20000, &x);
429 assert_se(r == 0);
430 assert_se(x == 12);
431
432 r = safe_atou_bounded("20000", 12, 20000, &x);
433 assert_se(r == 0);
434 assert_se(x == 20000);
435
436 r = safe_atou_bounded("-1", 12, 20000, &x);
437 assert_se(r == -ERANGE);
438
439 r = safe_atou_bounded("11", 12, 20000, &x);
440 assert_se(r == -ERANGE);
441
442 r = safe_atou_bounded("20001", 12, 20000, &x);
443 assert_se(r == -ERANGE);
444}
445
4f7452a8 446TEST(safe_atolli) {
bb269eed
FB		 447 int r;
448 long long l;
449
450 r = safe_atolli("12345", &l);
451 assert_se(r == 0);
452 assert_se(l == 12345);
453
5c280bcc
MP		 454 r = safe_atolli(" 12345", &l);
455 assert_se(r == 0);
456 assert_se(l == 12345);
457
458 r = safe_atolli("-12345", &l);
459 assert_se(r == 0);
460 assert_se(l == -12345);
461
462 r = safe_atolli(" -12345", &l);
463 assert_se(r == 0);
464 assert_se(l == -12345);
465
53c6db99
LP		 466 r = safe_atolli("0x5", &l);
467 assert_se(r == 0);
468 assert_se(l == 5);
469
470 r = safe_atolli("0o6", &l);
471 assert_se(r == 0);
472 assert_se(l == 6);
473
474 r = safe_atolli("0B101", &l);
475 assert_se(r == 0);
476 assert_se(l == 5);
477
5c280bcc
MP		 478 r = safe_atolli("12345678901234567890", &l);
479 assert_se(r == -ERANGE);
480
481 r = safe_atolli("-12345678901234567890", &l);
482 assert_se(r == -ERANGE);
483
bb269eed
FB		 484 r = safe_atolli("junk", &l);
485 assert_se(r == -EINVAL);
3fcf65c3
YW		 486
487 r = safe_atolli("123x", &l);
488 assert_se(r == -EINVAL);
489
490 r = safe_atolli("12.3", &l);
491 assert_se(r == -EINVAL);
492
493 r = safe_atolli("", &l);
494 assert_se(r == -EINVAL);
bb269eed
FB		 495}
496
4f7452a8 497TEST(safe_atou16) {
bb269eed
FB		 498 int r;
499 uint16_t l;
500
501 r = safe_atou16("12345", &l);
502 assert_se(r == 0);
503 assert_se(l == 12345);
504
5c280bcc
MP		 505 r = safe_atou16(" 12345", &l);
506 assert_se(r == 0);
507 assert_se(l == 12345);
508
8eb491f4
ZJS		 509 r = safe_atou16("+12345", &l);
510 assert_se(r == 0);
511 assert_se(l == 12345);
512
513 r = safe_atou16(" +12345", &l);
514 assert_se(r == 0);
515 assert_se(l == 12345);
516
bb269eed
FB		 517 r = safe_atou16("123456", &l);
518 assert_se(r == -ERANGE);
519
5c280bcc
MP		 520 r = safe_atou16("-1", &l);
521 assert_se(r == -ERANGE);
522
523 r = safe_atou16(" -1", &l);
524 assert_se(r == -ERANGE);
525
bb269eed
FB		 526 r = safe_atou16("junk", &l);
527 assert_se(r == -EINVAL);
bf32e385
ZJS		 528
529 r = safe_atou16("123x", &l);
530 assert_se(r == -EINVAL);
3fcf65c3
YW		 531
532 r = safe_atou16("12.3", &l);
533 assert_se(r == -EINVAL);
534
535 r = safe_atou16("", &l);
536 assert_se(r == -EINVAL);
bb269eed
FB		 537}
538
4f7452a8 539TEST(safe_atoi16) {
bb269eed
FB		 540 int r;
541 int16_t l;
542
543 r = safe_atoi16("-12345", &l);
544 assert_se(r == 0);
545 assert_se(l == -12345);
546
5c280bcc
MP		 547 r = safe_atoi16(" -12345", &l);
548 assert_se(r == 0);
549 assert_se(l == -12345);
550
8eb491f4
ZJS		 551 r = safe_atoi16("+12345", &l);
552 assert_se(r == 0);
553 assert_se(l == 12345);
554
555 r = safe_atoi16(" +12345", &l);
556 assert_se(r == 0);
557 assert_se(l == 12345);
558
5c280bcc
MP		 559 r = safe_atoi16("32767", &l);
560 assert_se(r == 0);
561 assert_se(l == 32767);
562
563 r = safe_atoi16(" 32767", &l);
564 assert_se(r == 0);
565 assert_se(l == 32767);
566
53c6db99
LP		 567 r = safe_atoi16("0o11", &l);
568 assert_se(r == 0);
569 assert_se(l == 9);
570
571 r = safe_atoi16("0B110", &l);
572 assert_se(r == 0);
573 assert_se(l == 6);
574
bb269eed
FB		 575 r = safe_atoi16("36536", &l);
576 assert_se(r == -ERANGE);
577
5c280bcc
MP		 578 r = safe_atoi16("-32769", &l);
579 assert_se(r == -ERANGE);
580
bb269eed
FB		 581 r = safe_atoi16("junk", &l);
582 assert_se(r == -EINVAL);
bf32e385
ZJS		 583
584 r = safe_atoi16("123x", &l);
585 assert_se(r == -EINVAL);
3fcf65c3
YW		 586
587 r = safe_atoi16("12.3", &l);
588 assert_se(r == -EINVAL);
589
590 r = safe_atoi16("", &l);
591 assert_se(r == -EINVAL);
bf32e385
ZJS		 592}
593
4f7452a8 594TEST(safe_atoux16) {
5547c125
PU		 595 int r;
596 uint16_t l;
597
598 r = safe_atoux16("1234", &l);
599 assert_se(r == 0);
600 assert_se(l == 0x1234);
601
602 r = safe_atoux16("abcd", &l);
603 assert_se(r == 0);
604 assert_se(l == 0xabcd);
605
606 r = safe_atoux16(" 1234", &l);
607 assert_se(r == 0);
608 assert_se(l == 0x1234);
609
610 r = safe_atoux16("12345", &l);
611 assert_se(r == -ERANGE);
612
613 r = safe_atoux16("-1", &l);
614 assert_se(r == -ERANGE);
615
616 r = safe_atoux16(" -1", &l);
617 assert_se(r == -ERANGE);
618
53c6db99
LP		 619 r = safe_atoux16("0b1", &l);
620 assert_se(r == 0);
621 assert_se(l == 177);
622
623 r = safe_atoux16("0o70", &l);
624 assert_se(r == -EINVAL);
625
5547c125
PU		 626 r = safe_atoux16("junk", &l);
627 assert_se(r == -EINVAL);
628
629 r = safe_atoux16("123x", &l);
630 assert_se(r == -EINVAL);
631
632 r = safe_atoux16("12.3", &l);
633 assert_se(r == -EINVAL);
634
635 r = safe_atoux16("", &l);
636 assert_se(r == -EINVAL);
637}
638
4f7452a8 639TEST(safe_atou64) {
bf32e385
ZJS		 640 int r;
641 uint64_t l;
642
643 r = safe_atou64("12345", &l);
644 assert_se(r == 0);
645 assert_se(l == 12345);
646
647 r = safe_atou64(" 12345", &l);
648 assert_se(r == 0);
649 assert_se(l == 12345);
650
53c6db99
LP		 651 r = safe_atou64("0o11", &l);
652 assert_se(r == 0);
653 assert_se(l == 9);
654
655 r = safe_atou64("0b11", &l);
656 assert_se(r == 0);
657 assert_se(l == 3);
658
bf32e385
ZJS		 659 r = safe_atou64("18446744073709551617", &l);
660 assert_se(r == -ERANGE);
661
662 r = safe_atou64("-1", &l);
663 assert_se(r == -ERANGE);
664
665 r = safe_atou64(" -1", &l);
666 assert_se(r == -ERANGE);
667
668 r = safe_atou64("junk", &l);
669 assert_se(r == -EINVAL);
670
671 r = safe_atou64("123x", &l);
672 assert_se(r == -EINVAL);
3fcf65c3
YW		 673
674 r = safe_atou64("12.3", &l);
675 assert_se(r == -EINVAL);
676
677 r = safe_atou64("", &l);
678 assert_se(r == -EINVAL);
bf32e385
ZJS		 679}
680
4f7452a8 681TEST(safe_atoi64) {
bf32e385
ZJS		 682 int r;
683 int64_t l;
684
685 r = safe_atoi64("-12345", &l);
686 assert_se(r == 0);
687 assert_se(l == -12345);
688
689 r = safe_atoi64(" -12345", &l);
690 assert_se(r == 0);
691 assert_se(l == -12345);
692
693 r = safe_atoi64("32767", &l);
694 assert_se(r == 0);
695 assert_se(l == 32767);
696
697 r = safe_atoi64(" 32767", &l);
698 assert_se(r == 0);
699 assert_se(l == 32767);
700
53c6db99
LP		 701 r = safe_atoi64(" 0o20", &l);
702 assert_se(r == 0);
703 assert_se(l == 16);
704
705 r = safe_atoi64(" 0b01010", &l);
706 assert_se(r == 0);
707 assert_se(l == 10);
708
bf32e385
ZJS		 709 r = safe_atoi64("9223372036854775813", &l);
710 assert_se(r == -ERANGE);
711
712 r = safe_atoi64("-9223372036854775813", &l);
713 assert_se(r == -ERANGE);
714
715 r = safe_atoi64("junk", &l);
716 assert_se(r == -EINVAL);
717
718 r = safe_atoi64("123x", &l);
719 assert_se(r == -EINVAL);
3fcf65c3
YW		 720
721 r = safe_atoi64("12.3", &l);
722 assert_se(r == -EINVAL);
723
724 r = safe_atoi64("", &l);
725 assert_se(r == -EINVAL);
bb269eed
FB		 726}
727
4f7452a8 728TEST(safe_atoux64) {
ce51632a
ZJS		 729 int r;
730 uint64_t l;
731
732 r = safe_atoux64("12345", &l);
733 assert_se(r == 0);
734 assert_se(l == 0x12345);
735
736 r = safe_atoux64(" 12345", &l);
737 assert_se(r == 0);
738 assert_se(l == 0x12345);
739
740 r = safe_atoux64("0x12345", &l);
741 assert_se(r == 0);
742 assert_se(l == 0x12345);
743
53c6db99
LP		 744 r = safe_atoux64("0b11011", &l);
745 assert_se(r == 0);
746 assert_se(l == 11603985);
747
8eb491f4
ZJS		 748 r = safe_atoux64("+12345", &l);
749 assert_se(r == 0);
750 assert_se(l == 0x12345);
751
752 r = safe_atoux64(" +12345", &l);
753 assert_se(r == 0);
754 assert_se(l == 0x12345);
755
756 r = safe_atoux64("+0x12345", &l);
757 assert_se(r == 0);
758 assert_se(l == 0x12345);
759
760 r = safe_atoux64("+0b11011", &l);
761 assert_se(r == 0);
762 assert_se(l == 11603985);
763
53c6db99
LP		 764 r = safe_atoux64("0o11011", &l);
765 assert_se(r == -EINVAL);
766
ce51632a
ZJS		 767 r = safe_atoux64("18446744073709551617", &l);
768 assert_se(r == -ERANGE);
769
770 r = safe_atoux64("-1", &l);
771 assert_se(r == -ERANGE);
772
773 r = safe_atoux64(" -1", &l);
774 assert_se(r == -ERANGE);
775
776 r = safe_atoux64("junk", &l);
777 assert_se(r == -EINVAL);
778
779 r = safe_atoux64("123x", &l);
780 assert_se(r == -EINVAL);
781
782 r = safe_atoux64("12.3", &l);
783 assert_se(r == -EINVAL);
784
785 r = safe_atoux64("", &l);
786 assert_se(r == -EINVAL);
787}
788
4f7452a8 789TEST(safe_atod) {
bb269eed
FB		 790 int r;
791 double d;
792 char *e;
793
794 r = safe_atod("junk", &d);
795 assert_se(r == -EINVAL);
796
797 r = safe_atod("0.2244", &d);
798 assert_se(r == 0);
799 assert_se(fabs(d - 0.2244) < 0.000001);
800
801 r = safe_atod("0,5", &d);
802 assert_se(r == -EINVAL);
803
804 errno = 0;
805 strtod("0,5", &e);
806 assert_se(*e == ',');
807
3fcf65c3
YW		 808 r = safe_atod("", &d);
809 assert_se(r == -EINVAL);
810
bb269eed
FB		 811 /* Check if this really is locale independent */
812 if (setlocale(LC_NUMERIC, "de_DE.utf8")) {
813
814 r = safe_atod("0.2244", &d);
815 assert_se(r == 0);
816 assert_se(fabs(d - 0.2244) < 0.000001);
817
818 r = safe_atod("0,5", &d);
819 assert_se(r == -EINVAL);
820
821 errno = 0;
822 assert_se(fabs(strtod("0,5", &e) - 0.5) < 0.00001);
3fcf65c3
YW		 823
824 r = safe_atod("", &d);
825 assert_se(r == -EINVAL);
bb269eed
FB		 826 }
827
828 /* And check again, reset */
829 assert_se(setlocale(LC_NUMERIC, "C"));
830
831 r = safe_atod("0.2244", &d);
832 assert_se(r == 0);
833 assert_se(fabs(d - 0.2244) < 0.000001);
834
835 r = safe_atod("0,5", &d);
836 assert_se(r == -EINVAL);
837
838 errno = 0;
839 strtod("0,5", &e);
840 assert_se(*e == ',');
3fcf65c3
YW		 841
842 r = safe_atod("", &d);
843 assert_se(r == -EINVAL);
bb269eed
FB		 844}
845
4f7452a8 846TEST(parse_nice) {
41bf0590
LP		 847 int n;
848
849 assert_se(parse_nice("0", &n) >= 0 && n == 0);
850 assert_se(parse_nice("+0", &n) >= 0 && n == 0);
851 assert_se(parse_nice("-1", &n) >= 0 && n == -1);
852 assert_se(parse_nice("-2", &n) >= 0 && n == -2);
853 assert_se(parse_nice("1", &n) >= 0 && n == 1);
854 assert_se(parse_nice("2", &n) >= 0 && n == 2);
855 assert_se(parse_nice("+1", &n) >= 0 && n == 1);
856 assert_se(parse_nice("+2", &n) >= 0 && n == 2);
857 assert_se(parse_nice("-20", &n) >= 0 && n == -20);
858 assert_se(parse_nice("19", &n) >= 0 && n == 19);
859 assert_se(parse_nice("+19", &n) >= 0 && n == 19);
860
41bf0590
LP		 861 assert_se(parse_nice("", &n) == -EINVAL);
862 assert_se(parse_nice("-", &n) == -EINVAL);
863 assert_se(parse_nice("+", &n) == -EINVAL);
864 assert_se(parse_nice("xx", &n) == -EINVAL);
865 assert_se(parse_nice("-50", &n) == -ERANGE);
866 assert_se(parse_nice("50", &n) == -ERANGE);
867 assert_se(parse_nice("+50", &n) == -ERANGE);
868 assert_se(parse_nice("-21", &n) == -ERANGE);
869 assert_se(parse_nice("20", &n) == -ERANGE);
870 assert_se(parse_nice("+20", &n) == -ERANGE);
871}
872
4f7452a8 873TEST(parse_errno) {
473d2ec3
YW		 874 assert_se(parse_errno("EILSEQ") == EILSEQ);
875 assert_se(parse_errno("EINVAL") == EINVAL);
876 assert_se(parse_errno("0") == 0);
877 assert_se(parse_errno("1") == 1);
878 assert_se(parse_errno("4095") == 4095);
879
880 assert_se(parse_errno("-1") == -ERANGE);
881 assert_se(parse_errno("-3") == -ERANGE);
882 assert_se(parse_errno("4096") == -ERANGE);
883
884 assert_se(parse_errno("") == -EINVAL);
885 assert_se(parse_errno("12.3") == -EINVAL);
886 assert_se(parse_errno("123junk") == -EINVAL);
887 assert_se(parse_errno("junk123") == -EINVAL);
888 assert_se(parse_errno("255EILSEQ") == -EINVAL);
889 assert_se(parse_errno("EINVAL12") == -EINVAL);
890 assert_se(parse_errno("-EINVAL") == -EINVAL);
891 assert_se(parse_errno("EINVALaaa") == -EINVAL);
892}
893
754d8b9c
DT		 894TEST(parse_fd) {
895 assert_se(parse_fd("0") == 0);
896 assert_se(parse_fd("1") == 1);
897
d2132d3d
YW		 898 assert_se(parse_fd("-1") == -EBADF);
899 assert_se(parse_fd("-3") == -EBADF);
754d8b9c
DT		 900
901 assert_se(parse_fd("") == -EINVAL);
902 assert_se(parse_fd("12.3") == -EINVAL);
903 assert_se(parse_fd("123junk") == -EINVAL);
904 assert_se(parse_fd("junk123") == -EINVAL);
905}
906
4f7452a8 907TEST(parse_mtu) {
f91c6093
LP		 908 uint32_t mtu = 0;
909
910 assert_se(parse_mtu(AF_UNSPEC, "1500", &mtu) >= 0 && mtu == 1500);
911 assert_se(parse_mtu(AF_UNSPEC, "1400", &mtu) >= 0 && mtu == 1400);
912 assert_se(parse_mtu(AF_UNSPEC, "65535", &mtu) >= 0 && mtu == 65535);
913 assert_se(parse_mtu(AF_UNSPEC, "65536", &mtu) >= 0 && mtu == 65536);
914 assert_se(parse_mtu(AF_UNSPEC, "4294967295", &mtu) >= 0 && mtu == 4294967295);
915 assert_se(parse_mtu(AF_UNSPEC, "500", &mtu) >= 0 && mtu == 500);
916 assert_se(parse_mtu(AF_UNSPEC, "1280", &mtu) >= 0 && mtu == 1280);
a0460dfe
YW		 917 assert_se(parse_mtu(AF_UNSPEC, "4294967296", &mtu) == -ERANGE);
918 assert_se(parse_mtu(AF_UNSPEC, "68", &mtu) >= 0 && mtu == 68);
919 assert_se(parse_mtu(AF_UNSPEC, "67", &mtu) >= 0 && mtu == 67);
920 assert_se(parse_mtu(AF_UNSPEC, "0", &mtu) >= 0 && mtu == 0);
921 assert_se(parse_mtu(AF_UNSPEC, "", &mtu) == -EINVAL);
922
923 assert_se(parse_mtu(AF_INET, "1500", &mtu) >= 0 && mtu == 1500);
924 assert_se(parse_mtu(AF_INET, "1400", &mtu) >= 0 && mtu == 1400);
925 assert_se(parse_mtu(AF_INET, "65535", &mtu) >= 0 && mtu == 65535);
926 assert_se(parse_mtu(AF_INET, "65536", &mtu) >= 0 && mtu == 65536);
927 assert_se(parse_mtu(AF_INET, "4294967295", &mtu) >= 0 && mtu == 4294967295);
928 assert_se(parse_mtu(AF_INET, "500", &mtu) >= 0 && mtu == 500);
929 assert_se(parse_mtu(AF_INET, "1280", &mtu) >= 0 && mtu == 1280);
930 assert_se(parse_mtu(AF_INET, "4294967296", &mtu) == -ERANGE);
931 assert_se(parse_mtu(AF_INET, "68", &mtu) >= 0 && mtu == 68);
932 assert_se(parse_mtu(AF_INET, "67", &mtu) == -ERANGE);
933 assert_se(parse_mtu(AF_INET, "0", &mtu) == -ERANGE);
934 assert_se(parse_mtu(AF_INET, "", &mtu) == -EINVAL);
935
f91c6093
LP		 936 assert_se(parse_mtu(AF_INET6, "1280", &mtu) >= 0 && mtu == 1280);
937 assert_se(parse_mtu(AF_INET6, "1279", &mtu) == -ERANGE);
f91c6093
LP		 938 assert_se(parse_mtu(AF_INET6, "4294967296", &mtu) == -ERANGE);
939 assert_se(parse_mtu(AF_INET6, "68", &mtu) == -ERANGE);
a0460dfe 940 assert_se(parse_mtu(AF_INET6, "", &mtu) == -EINVAL);
f91c6093
LP		 941}
942
4f7452a8 943TEST(parse_loadavg_fixed_point) {
510ca79c
AZ		 944 loadavg_t fp;
945
946 assert_se(parse_loadavg_fixed_point("1.23", &fp) == 0);
3542da24
LB		 947 assert_se(LOADAVG_INT_SIDE(fp) == 1);
948 assert_se(LOADAVG_DECIMAL_SIDE(fp) == 23);
510ca79c
AZ		 949
950 assert_se(parse_loadavg_fixed_point("1.80", &fp) == 0);
3542da24
LB		 951 assert_se(LOADAVG_INT_SIDE(fp) == 1);
952 assert_se(LOADAVG_DECIMAL_SIDE(fp) == 80);
510ca79c
AZ		 953
954 assert_se(parse_loadavg_fixed_point("0.07", &fp) == 0);
3542da24
LB		 955 assert_se(LOADAVG_INT_SIDE(fp) == 0);
956 assert_se(LOADAVG_DECIMAL_SIDE(fp) == 7);
510ca79c
AZ		 957
958 assert_se(parse_loadavg_fixed_point("0.00", &fp) == 0);
3542da24
LB		 959 assert_se(LOADAVG_INT_SIDE(fp) == 0);
960 assert_se(LOADAVG_DECIMAL_SIDE(fp) == 0);
510ca79c
AZ		 961
962 assert_se(parse_loadavg_fixed_point("4096.57", &fp) == 0);
3542da24
LB		 963 assert_se(LOADAVG_INT_SIDE(fp) == 4096);
964 assert_se(LOADAVG_DECIMAL_SIDE(fp) == 57);
510ca79c
AZ		 965
966 /* Caps out at 2 digit fracs */
967 assert_se(parse_loadavg_fixed_point("1.100", &fp) == -ERANGE);
968
969 assert_se(parse_loadavg_fixed_point("4096.4096", &fp) == -ERANGE);
970 assert_se(parse_loadavg_fixed_point("-4000.5", &fp) == -ERANGE);
971 assert_se(parse_loadavg_fixed_point("18446744073709551615.5", &fp) == -ERANGE);
972 assert_se(parse_loadavg_fixed_point("foobar", &fp) == -EINVAL);
973 assert_se(parse_loadavg_fixed_point("3333", &fp) == -EINVAL);
974 assert_se(parse_loadavg_fixed_point("1.2.3", &fp) == -EINVAL);
975 assert_se(parse_loadavg_fixed_point(".", &fp) == -EINVAL);
976 assert_se(parse_loadavg_fixed_point("", &fp) == -EINVAL);
977}
978
4f7452a8 979DEFINE_TEST_MAIN(LOG_INFO);
Unnamed repository; edit this file 'description' to name the repository.