]>
git.ipfire.org Git - thirdparty/systemd.git/blob - src/test/test-parse-util.c
2 This file is part of systemd.
4 Copyright 2010 Lennart Poettering
5 Copyright 2013 Thomas H.P. Andersen
7 systemd is free software; you can redistribute it and/or modify it
8 under the terms of the GNU Lesser General Public License as published by
9 the Free Software Foundation; either version 2.1 of the License, or
10 (at your option) any later version.
12 systemd is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Lesser General Public License for more details.
17 You should have received a copy of the GNU Lesser General Public License
18 along with systemd; If not, see <http://www.gnu.org/licenses/>.
25 #include "parse-util.h"
27 static void test_parse_boolean(void) {
28 assert_se(parse_boolean("1") == 1);
29 assert_se(parse_boolean("y") == 1);
30 assert_se(parse_boolean("Y") == 1);
31 assert_se(parse_boolean("yes") == 1);
32 assert_se(parse_boolean("YES") == 1);
33 assert_se(parse_boolean("true") == 1);
34 assert_se(parse_boolean("TRUE") == 1);
35 assert_se(parse_boolean("on") == 1);
36 assert_se(parse_boolean("ON") == 1);
38 assert_se(parse_boolean("0") == 0);
39 assert_se(parse_boolean("n") == 0);
40 assert_se(parse_boolean("N") == 0);
41 assert_se(parse_boolean("no") == 0);
42 assert_se(parse_boolean("NO") == 0);
43 assert_se(parse_boolean("false") == 0);
44 assert_se(parse_boolean("FALSE") == 0);
45 assert_se(parse_boolean("off") == 0);
46 assert_se(parse_boolean("OFF") == 0);
48 assert_se(parse_boolean("garbage") < 0);
49 assert_se(parse_boolean("") < 0);
50 assert_se(parse_boolean("full") < 0);
53 static void test_parse_pid(void) {
57 r
= parse_pid("100", &pid
);
59 assert_se(pid
== 100);
61 r
= parse_pid("0x7FFFFFFF", &pid
);
63 assert_se(pid
== 2147483647);
65 pid
= 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
66 r
= parse_pid("0", &pid
);
67 assert_se(r
== -ERANGE
);
70 pid
= 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
71 r
= parse_pid("-100", &pid
);
72 assert_se(r
== -ERANGE
);
75 pid
= 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
76 r
= parse_pid("0xFFFFFFFFFFFFFFFFF", &pid
);
77 assert_se(r
== -ERANGE
);
80 r
= parse_pid("junk", &pid
);
81 assert_se(r
== -EINVAL
);
83 r
= parse_pid("", &pid
);
84 assert_se(r
== -EINVAL
);
87 static void test_parse_mode(void) {
90 assert_se(parse_mode("-1", &m
) < 0);
91 assert_se(parse_mode("", &m
) < 0);
92 assert_se(parse_mode("888", &m
) < 0);
93 assert_se(parse_mode("77777", &m
) < 0);
95 assert_se(parse_mode("544", &m
) >= 0 && m
== 0544);
96 assert_se(parse_mode("777", &m
) >= 0 && m
== 0777);
97 assert_se(parse_mode("7777", &m
) >= 0 && m
== 07777);
98 assert_se(parse_mode("0", &m
) >= 0 && m
== 0);
101 static void test_parse_size(void) {
104 assert_se(parse_size("", 1024, &bytes
) == -EINVAL
);
106 assert_se(parse_size("111", 1024, &bytes
) == 0);
107 assert_se(bytes
== 111);
109 assert_se(parse_size("111.4", 1024, &bytes
) == 0);
110 assert_se(bytes
== 111);
112 assert_se(parse_size(" 112 B", 1024, &bytes
) == 0);
113 assert_se(bytes
== 112);
115 assert_se(parse_size(" 112.6 B", 1024, &bytes
) == 0);
116 assert_se(bytes
== 112);
118 assert_se(parse_size("3.5 K", 1024, &bytes
) == 0);
119 assert_se(bytes
== 3*1024 + 512);
121 assert_se(parse_size("3. K", 1024, &bytes
) == 0);
122 assert_se(bytes
== 3*1024);
124 assert_se(parse_size("3.0 K", 1024, &bytes
) == 0);
125 assert_se(bytes
== 3*1024);
127 assert_se(parse_size("3. 0 K", 1024, &bytes
) == -EINVAL
);
129 assert_se(parse_size(" 4 M 11.5K", 1024, &bytes
) == 0);
130 assert_se(bytes
== 4*1024*1024 + 11 * 1024 + 512);
132 assert_se(parse_size("3B3.5G", 1024, &bytes
) == -EINVAL
);
134 assert_se(parse_size("3.5G3B", 1024, &bytes
) == 0);
135 assert_se(bytes
== 3ULL*1024*1024*1024 + 512*1024*1024 + 3);
137 assert_se(parse_size("3.5G 4B", 1024, &bytes
) == 0);
138 assert_se(bytes
== 3ULL*1024*1024*1024 + 512*1024*1024 + 4);
140 assert_se(parse_size("3B3G4T", 1024, &bytes
) == -EINVAL
);
142 assert_se(parse_size("4T3G3B", 1024, &bytes
) == 0);
143 assert_se(bytes
== (4ULL*1024 + 3)*1024*1024*1024 + 3);
145 assert_se(parse_size(" 4 T 3 G 3 B", 1024, &bytes
) == 0);
146 assert_se(bytes
== (4ULL*1024 + 3)*1024*1024*1024 + 3);
148 assert_se(parse_size("12P", 1024, &bytes
) == 0);
149 assert_se(bytes
== 12ULL * 1024*1024*1024*1024*1024);
151 assert_se(parse_size("12P12P", 1024, &bytes
) == -EINVAL
);
153 assert_se(parse_size("3E 2P", 1024, &bytes
) == 0);
154 assert_se(bytes
== (3 * 1024 + 2ULL) * 1024*1024*1024*1024*1024);
156 assert_se(parse_size("12X", 1024, &bytes
) == -EINVAL
);
158 assert_se(parse_size("12.5X", 1024, &bytes
) == -EINVAL
);
160 assert_se(parse_size("12.5e3", 1024, &bytes
) == -EINVAL
);
162 assert_se(parse_size("1024E", 1024, &bytes
) == -ERANGE
);
163 assert_se(parse_size("-1", 1024, &bytes
) == -ERANGE
);
164 assert_se(parse_size("-1024E", 1024, &bytes
) == -ERANGE
);
166 assert_se(parse_size("-1024P", 1024, &bytes
) == -ERANGE
);
168 assert_se(parse_size("-10B 20K", 1024, &bytes
) == -ERANGE
);
171 static void test_parse_range(void) {
172 unsigned lower
, upper
;
174 /* Successful cases */
175 assert_se(parse_range("111", &lower
, &upper
) == 0);
176 assert_se(lower
== 111);
177 assert_se(upper
== 111);
179 assert_se(parse_range("111-123", &lower
, &upper
) == 0);
180 assert_se(lower
== 111);
181 assert_se(upper
== 123);
183 assert_se(parse_range("123-111", &lower
, &upper
) == 0);
184 assert_se(lower
== 123);
185 assert_se(upper
== 111);
187 assert_se(parse_range("123-123", &lower
, &upper
) == 0);
188 assert_se(lower
== 123);
189 assert_se(upper
== 123);
191 assert_se(parse_range("0", &lower
, &upper
) == 0);
192 assert_se(lower
== 0);
193 assert_se(upper
== 0);
195 assert_se(parse_range("0-15", &lower
, &upper
) == 0);
196 assert_se(lower
== 0);
197 assert_se(upper
== 15);
199 assert_se(parse_range("15-0", &lower
, &upper
) == 0);
200 assert_se(lower
== 15);
201 assert_se(upper
== 0);
203 assert_se(parse_range("128-65535", &lower
, &upper
) == 0);
204 assert_se(lower
== 128);
205 assert_se(upper
== 65535);
207 assert_se(parse_range("1024-4294967295", &lower
, &upper
) == 0);
208 assert_se(lower
== 1024);
209 assert_se(upper
== 4294967295);
211 /* Leading whitespace is acceptable */
212 assert_se(parse_range(" 111", &lower
, &upper
) == 0);
213 assert_se(lower
== 111);
214 assert_se(upper
== 111);
216 assert_se(parse_range(" 111-123", &lower
, &upper
) == 0);
217 assert_se(lower
== 111);
218 assert_se(upper
== 123);
220 assert_se(parse_range("111- 123", &lower
, &upper
) == 0);
221 assert_se(lower
== 111);
222 assert_se(upper
== 123);
224 assert_se(parse_range("\t111-\t123", &lower
, &upper
) == 0);
225 assert_se(lower
== 111);
226 assert_se(upper
== 123);
228 assert_se(parse_range(" \t 111- \t 123", &lower
, &upper
) == 0);
229 assert_se(lower
== 111);
230 assert_se(upper
== 123);
232 /* Error cases, make sure they fail as expected */
233 lower
= upper
= 9999;
234 assert_se(parse_range("111garbage", &lower
, &upper
) == -EINVAL
);
235 assert_se(lower
== 9999);
236 assert_se(upper
== 9999);
238 assert_se(parse_range("garbage111", &lower
, &upper
) == -EINVAL
);
239 assert_se(lower
== 9999);
240 assert_se(upper
== 9999);
242 assert_se(parse_range("garbage", &lower
, &upper
) == -EINVAL
);
243 assert_se(lower
== 9999);
244 assert_se(upper
== 9999);
246 assert_se(parse_range("111-123garbage", &lower
, &upper
) == -EINVAL
);
247 assert_se(lower
== 9999);
248 assert_se(upper
== 9999);
250 assert_se(parse_range("111garbage-123", &lower
, &upper
) == -EINVAL
);
251 assert_se(lower
== 9999);
252 assert_se(upper
== 9999);
255 lower
= upper
= 9999;
256 assert_se(parse_range("", &lower
, &upper
) == -EINVAL
);
257 assert_se(lower
== 9999);
258 assert_se(upper
== 9999);
260 /* 111--123 will pass -123 to safe_atou which returns -ERANGE for negative */
261 assert_se(parse_range("111--123", &lower
, &upper
) == -ERANGE
);
262 assert_se(lower
== 9999);
263 assert_se(upper
== 9999);
265 assert_se(parse_range("-123", &lower
, &upper
) == -EINVAL
);
266 assert_se(lower
== 9999);
267 assert_se(upper
== 9999);
269 assert_se(parse_range("-111-123", &lower
, &upper
) == -EINVAL
);
270 assert_se(lower
== 9999);
271 assert_se(upper
== 9999);
273 assert_se(parse_range("111-123-", &lower
, &upper
) == -EINVAL
);
274 assert_se(lower
== 9999);
275 assert_se(upper
== 9999);
277 assert_se(parse_range("111.4-123", &lower
, &upper
) == -EINVAL
);
278 assert_se(lower
== 9999);
279 assert_se(upper
== 9999);
281 assert_se(parse_range("111-123.4", &lower
, &upper
) == -EINVAL
);
282 assert_se(lower
== 9999);
283 assert_se(upper
== 9999);
285 assert_se(parse_range("111,4-123", &lower
, &upper
) == -EINVAL
);
286 assert_se(lower
== 9999);
287 assert_se(upper
== 9999);
289 assert_se(parse_range("111-123,4", &lower
, &upper
) == -EINVAL
);
290 assert_se(lower
== 9999);
291 assert_se(upper
== 9999);
293 /* Error on trailing dash */
294 assert_se(parse_range("111-", &lower
, &upper
) == -EINVAL
);
295 assert_se(lower
== 9999);
296 assert_se(upper
== 9999);
298 assert_se(parse_range("111-123-", &lower
, &upper
) == -EINVAL
);
299 assert_se(lower
== 9999);
300 assert_se(upper
== 9999);
302 assert_se(parse_range("111--", &lower
, &upper
) == -EINVAL
);
303 assert_se(lower
== 9999);
304 assert_se(upper
== 9999);
306 assert_se(parse_range("111- ", &lower
, &upper
) == -EINVAL
);
307 assert_se(lower
== 9999);
308 assert_se(upper
== 9999);
310 /* Whitespace is not a separator */
311 assert_se(parse_range("111 123", &lower
, &upper
) == -EINVAL
);
312 assert_se(lower
== 9999);
313 assert_se(upper
== 9999);
315 assert_se(parse_range("111\t123", &lower
, &upper
) == -EINVAL
);
316 assert_se(lower
== 9999);
317 assert_se(upper
== 9999);
319 assert_se(parse_range("111 \t 123", &lower
, &upper
) == -EINVAL
);
320 assert_se(lower
== 9999);
321 assert_se(upper
== 9999);
323 /* Trailing whitespace is invalid (from safe_atou) */
324 assert_se(parse_range("111 ", &lower
, &upper
) == -EINVAL
);
325 assert_se(lower
== 9999);
326 assert_se(upper
== 9999);
328 assert_se(parse_range("111-123 ", &lower
, &upper
) == -EINVAL
);
329 assert_se(lower
== 9999);
330 assert_se(upper
== 9999);
332 assert_se(parse_range("111 -123", &lower
, &upper
) == -EINVAL
);
333 assert_se(lower
== 9999);
334 assert_se(upper
== 9999);
336 assert_se(parse_range("111 -123 ", &lower
, &upper
) == -EINVAL
);
337 assert_se(lower
== 9999);
338 assert_se(upper
== 9999);
340 assert_se(parse_range("111\t-123\t", &lower
, &upper
) == -EINVAL
);
341 assert_se(lower
== 9999);
342 assert_se(upper
== 9999);
344 assert_se(parse_range("111 \t -123 \t ", &lower
, &upper
) == -EINVAL
);
345 assert_se(lower
== 9999);
346 assert_se(upper
== 9999);
348 /* Out of the "unsigned" range, this is 1<<64 */
349 assert_se(parse_range("0-18446744073709551616", &lower
, &upper
) == -ERANGE
);
350 assert_se(lower
== 9999);
351 assert_se(upper
== 9999);
354 static void test_safe_atolli(void) {
358 r
= safe_atolli("12345", &l
);
360 assert_se(l
== 12345);
362 r
= safe_atolli(" 12345", &l
);
364 assert_se(l
== 12345);
366 r
= safe_atolli("-12345", &l
);
368 assert_se(l
== -12345);
370 r
= safe_atolli(" -12345", &l
);
372 assert_se(l
== -12345);
374 r
= safe_atolli("12345678901234567890", &l
);
375 assert_se(r
== -ERANGE
);
377 r
= safe_atolli("-12345678901234567890", &l
);
378 assert_se(r
== -ERANGE
);
380 r
= safe_atolli("junk", &l
);
381 assert_se(r
== -EINVAL
);
383 r
= safe_atolli("123x", &l
);
384 assert_se(r
== -EINVAL
);
386 r
= safe_atolli("12.3", &l
);
387 assert_se(r
== -EINVAL
);
389 r
= safe_atolli("", &l
);
390 assert_se(r
== -EINVAL
);
393 static void test_safe_atou16(void) {
397 r
= safe_atou16("12345", &l
);
399 assert_se(l
== 12345);
401 r
= safe_atou16(" 12345", &l
);
403 assert_se(l
== 12345);
405 r
= safe_atou16("123456", &l
);
406 assert_se(r
== -ERANGE
);
408 r
= safe_atou16("-1", &l
);
409 assert_se(r
== -ERANGE
);
411 r
= safe_atou16(" -1", &l
);
412 assert_se(r
== -ERANGE
);
414 r
= safe_atou16("junk", &l
);
415 assert_se(r
== -EINVAL
);
417 r
= safe_atou16("123x", &l
);
418 assert_se(r
== -EINVAL
);
420 r
= safe_atou16("12.3", &l
);
421 assert_se(r
== -EINVAL
);
423 r
= safe_atou16("", &l
);
424 assert_se(r
== -EINVAL
);
427 static void test_safe_atoi16(void) {
431 r
= safe_atoi16("-12345", &l
);
433 assert_se(l
== -12345);
435 r
= safe_atoi16(" -12345", &l
);
437 assert_se(l
== -12345);
439 r
= safe_atoi16("32767", &l
);
441 assert_se(l
== 32767);
443 r
= safe_atoi16(" 32767", &l
);
445 assert_se(l
== 32767);
447 r
= safe_atoi16("36536", &l
);
448 assert_se(r
== -ERANGE
);
450 r
= safe_atoi16("-32769", &l
);
451 assert_se(r
== -ERANGE
);
453 r
= safe_atoi16("junk", &l
);
454 assert_se(r
== -EINVAL
);
456 r
= safe_atoi16("123x", &l
);
457 assert_se(r
== -EINVAL
);
459 r
= safe_atoi16("12.3", &l
);
460 assert_se(r
== -EINVAL
);
462 r
= safe_atoi16("", &l
);
463 assert_se(r
== -EINVAL
);
466 static void test_safe_atou64(void) {
470 r
= safe_atou64("12345", &l
);
472 assert_se(l
== 12345);
474 r
= safe_atou64(" 12345", &l
);
476 assert_se(l
== 12345);
478 r
= safe_atou64("18446744073709551617", &l
);
479 assert_se(r
== -ERANGE
);
481 r
= safe_atou64("-1", &l
);
482 assert_se(r
== -ERANGE
);
484 r
= safe_atou64(" -1", &l
);
485 assert_se(r
== -ERANGE
);
487 r
= safe_atou64("junk", &l
);
488 assert_se(r
== -EINVAL
);
490 r
= safe_atou64("123x", &l
);
491 assert_se(r
== -EINVAL
);
493 r
= safe_atou64("12.3", &l
);
494 assert_se(r
== -EINVAL
);
496 r
= safe_atou64("", &l
);
497 assert_se(r
== -EINVAL
);
500 static void test_safe_atoi64(void) {
504 r
= safe_atoi64("-12345", &l
);
506 assert_se(l
== -12345);
508 r
= safe_atoi64(" -12345", &l
);
510 assert_se(l
== -12345);
512 r
= safe_atoi64("32767", &l
);
514 assert_se(l
== 32767);
516 r
= safe_atoi64(" 32767", &l
);
518 assert_se(l
== 32767);
520 r
= safe_atoi64("9223372036854775813", &l
);
521 assert_se(r
== -ERANGE
);
523 r
= safe_atoi64("-9223372036854775813", &l
);
524 assert_se(r
== -ERANGE
);
526 r
= safe_atoi64("junk", &l
);
527 assert_se(r
== -EINVAL
);
529 r
= safe_atoi64("123x", &l
);
530 assert_se(r
== -EINVAL
);
532 r
= safe_atoi64("12.3", &l
);
533 assert_se(r
== -EINVAL
);
535 r
= safe_atoi64("", &l
);
536 assert_se(r
== -EINVAL
);
539 static void test_safe_atod(void) {
544 r
= safe_atod("junk", &d
);
545 assert_se(r
== -EINVAL
);
547 r
= safe_atod("0.2244", &d
);
549 assert_se(fabs(d
- 0.2244) < 0.000001);
551 r
= safe_atod("0,5", &d
);
552 assert_se(r
== -EINVAL
);
556 assert_se(*e
== ',');
558 r
= safe_atod("", &d
);
559 assert_se(r
== -EINVAL
);
561 /* Check if this really is locale independent */
562 if (setlocale(LC_NUMERIC
, "de_DE.utf8")) {
564 r
= safe_atod("0.2244", &d
);
566 assert_se(fabs(d
- 0.2244) < 0.000001);
568 r
= safe_atod("0,5", &d
);
569 assert_se(r
== -EINVAL
);
572 assert_se(fabs(strtod("0,5", &e
) - 0.5) < 0.00001);
574 r
= safe_atod("", &d
);
575 assert_se(r
== -EINVAL
);
578 /* And check again, reset */
579 assert_se(setlocale(LC_NUMERIC
, "C"));
581 r
= safe_atod("0.2244", &d
);
583 assert_se(fabs(d
- 0.2244) < 0.000001);
585 r
= safe_atod("0,5", &d
);
586 assert_se(r
== -EINVAL
);
590 assert_se(*e
== ',');
592 r
= safe_atod("", &d
);
593 assert_se(r
== -EINVAL
);
596 static void test_parse_percent(void) {
597 assert_se(parse_percent("") == -EINVAL
);
598 assert_se(parse_percent("foo") == -EINVAL
);
599 assert_se(parse_percent("0") == -EINVAL
);
600 assert_se(parse_percent("50") == -EINVAL
);
601 assert_se(parse_percent("100") == -EINVAL
);
602 assert_se(parse_percent("-1") == -EINVAL
);
603 assert_se(parse_percent("0%") == 0);
604 assert_se(parse_percent("55%") == 55);
605 assert_se(parse_percent("100%") == 100);
606 assert_se(parse_percent("-7%") == -ERANGE
);
607 assert_se(parse_percent("107%") == -ERANGE
);
608 assert_se(parse_percent("%") == -EINVAL
);
609 assert_se(parse_percent("%%") == -EINVAL
);
610 assert_se(parse_percent("%1") == -EINVAL
);
611 assert_se(parse_percent("1%%") == -EINVAL
);
612 assert_se(parse_percent("3.2%") == -EINVAL
);
615 static void test_parse_percent_unbounded(void) {
616 assert_se(parse_percent_unbounded("101%") == 101);
617 assert_se(parse_percent_unbounded("400%") == 400);
620 static void test_parse_nice(void) {
623 assert_se(parse_nice("0", &n
) >= 0 && n
== 0);
624 assert_se(parse_nice("+0", &n
) >= 0 && n
== 0);
625 assert_se(parse_nice("-1", &n
) >= 0 && n
== -1);
626 assert_se(parse_nice("-2", &n
) >= 0 && n
== -2);
627 assert_se(parse_nice("1", &n
) >= 0 && n
== 1);
628 assert_se(parse_nice("2", &n
) >= 0 && n
== 2);
629 assert_se(parse_nice("+1", &n
) >= 0 && n
== 1);
630 assert_se(parse_nice("+2", &n
) >= 0 && n
== 2);
631 assert_se(parse_nice("-20", &n
) >= 0 && n
== -20);
632 assert_se(parse_nice("19", &n
) >= 0 && n
== 19);
633 assert_se(parse_nice("+19", &n
) >= 0 && n
== 19);
636 assert_se(parse_nice("", &n
) == -EINVAL
);
637 assert_se(parse_nice("-", &n
) == -EINVAL
);
638 assert_se(parse_nice("+", &n
) == -EINVAL
);
639 assert_se(parse_nice("xx", &n
) == -EINVAL
);
640 assert_se(parse_nice("-50", &n
) == -ERANGE
);
641 assert_se(parse_nice("50", &n
) == -ERANGE
);
642 assert_se(parse_nice("+50", &n
) == -ERANGE
);
643 assert_se(parse_nice("-21", &n
) == -ERANGE
);
644 assert_se(parse_nice("20", &n
) == -ERANGE
);
645 assert_se(parse_nice("+20", &n
) == -ERANGE
);
648 static void test_parse_dev(void) {
651 assert_se(parse_dev("", &dev
) == -EINVAL
);
652 assert_se(parse_dev("junk", &dev
) == -EINVAL
);
653 assert_se(parse_dev("0", &dev
) == -EINVAL
);
654 assert_se(parse_dev("5", &dev
) == -EINVAL
);
655 assert_se(parse_dev("5:", &dev
) == -EINVAL
);
656 assert_se(parse_dev(":5", &dev
) == -EINVAL
);
658 assert_se(parse_dev("4294967295:4294967295", &dev
) == -EINVAL
);
660 assert_se(parse_dev("8:11", &dev
) >= 0 && major(dev
) == 8 && minor(dev
) == 11);
663 int main(int argc
, char *argv
[]) {
664 log_parse_environment();
667 test_parse_boolean();
678 test_parse_percent();
679 test_parse_percent_unbounded();