src/test/test-parse-util.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   This file is part of systemd.
   4
   5   Copyright 2010 Lennart Poettering
   6   Copyright 2013 Thomas H.P. Andersen
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <locale.h>
  23 #include <math.h>
  24
  25 #include "alloc-util.h"
  26 #include "errno-list.h"
  27 #include "log.h"
  28 #include "parse-util.h"
  29 #include "string-util.h"
  30
  31 static void test_parse_boolean(void) {
  32         assert_se(parse_boolean("1") == 1);
  33         assert_se(parse_boolean("y") == 1);
  34         assert_se(parse_boolean("Y") == 1);
  35         assert_se(parse_boolean("yes") == 1);
  36         assert_se(parse_boolean("YES") == 1);
  37         assert_se(parse_boolean("true") == 1);
  38         assert_se(parse_boolean("TRUE") == 1);
  39         assert_se(parse_boolean("on") == 1);
  40         assert_se(parse_boolean("ON") == 1);
  41
  42         assert_se(parse_boolean("0") == 0);
  43         assert_se(parse_boolean("n") == 0);
  44         assert_se(parse_boolean("N") == 0);
  45         assert_se(parse_boolean("no") == 0);
  46         assert_se(parse_boolean("NO") == 0);
  47         assert_se(parse_boolean("false") == 0);
  48         assert_se(parse_boolean("FALSE") == 0);
  49         assert_se(parse_boolean("off") == 0);
  50         assert_se(parse_boolean("OFF") == 0);
  51
  52         assert_se(parse_boolean("garbage") < 0);
  53         assert_se(parse_boolean("") < 0);
  54         assert_se(parse_boolean("full") < 0);
  55 }
  56
  57 static void test_parse_pid(void) {
  58         int r;
  59         pid_t pid;
  60
  61         r = parse_pid("100", &pid);
  62         assert_se(r == 0);
  63         assert_se(pid == 100);
  64
  65         r = parse_pid("0x7FFFFFFF", &pid);
  66         assert_se(r == 0);
  67         assert_se(pid == 2147483647);
  68
  69         pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
  70         r = parse_pid("0", &pid);
  71         assert_se(r == -ERANGE);
  72         assert_se(pid == 65);
  73
  74         pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
  75         r = parse_pid("-100", &pid);
  76         assert_se(r == -ERANGE);
  77         assert_se(pid == 65);
  78
  79         pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
  80         r = parse_pid("0xFFFFFFFFFFFFFFFFF", &pid);
  81         assert_se(r == -ERANGE);
  82         assert_se(pid == 65);
  83
  84         r = parse_pid("junk", &pid);
  85         assert_se(r == -EINVAL);
  86
  87         r = parse_pid("", &pid);
  88         assert_se(r == -EINVAL);
  89 }
  90
  91 static void test_parse_mode(void) {
  92         mode_t m;
  93
  94         assert_se(parse_mode("-1", &m) < 0);
  95         assert_se(parse_mode("", &m) < 0);
  96         assert_se(parse_mode("888", &m) < 0);
  97         assert_se(parse_mode("77777", &m) < 0);
  98
  99         assert_se(parse_mode("544", &m) >= 0 && m == 0544);
 100         assert_se(parse_mode("777", &m) >= 0 && m == 0777);
 101         assert_se(parse_mode("7777", &m) >= 0 && m == 07777);
 102         assert_se(parse_mode("0", &m) >= 0 && m == 0);
 103 }
 104
 105 static void test_parse_size(void) {
 106         uint64_t bytes;
 107
 108         assert_se(parse_size("", 1024, &bytes) == -EINVAL);
 109
 110         assert_se(parse_size("111", 1024, &bytes) == 0);
 111         assert_se(bytes == 111);
 112
 113         assert_se(parse_size("111.4", 1024, &bytes) == 0);
 114         assert_se(bytes == 111);
 115
 116         assert_se(parse_size(" 112 B", 1024, &bytes) == 0);
 117         assert_se(bytes == 112);
 118
 119         assert_se(parse_size(" 112.6 B", 1024, &bytes) == 0);
 120         assert_se(bytes == 112);
 121
 122         assert_se(parse_size("3.5 K", 1024, &bytes) == 0);
 123         assert_se(bytes == 3*1024 + 512);
 124
 125         assert_se(parse_size("3. K", 1024, &bytes) == 0);
 126         assert_se(bytes == 3*1024);
 127
 128         assert_se(parse_size("3.0 K", 1024, &bytes) == 0);
 129         assert_se(bytes == 3*1024);
 130
 131         assert_se(parse_size("3. 0 K", 1024, &bytes) == -EINVAL);
 132
 133         assert_se(parse_size(" 4 M 11.5K", 1024, &bytes) == 0);
 134         assert_se(bytes == 4*1024*1024 + 11 * 1024 + 512);
 135
 136         assert_se(parse_size("3B3.5G", 1024, &bytes) == -EINVAL);
 137
 138         assert_se(parse_size("3.5G3B", 1024, &bytes) == 0);
 139         assert_se(bytes == 3ULL*1024*1024*1024 + 512*1024*1024 + 3);
 140
 141         assert_se(parse_size("3.5G 4B", 1024, &bytes) == 0);
 142         assert_se(bytes == 3ULL*1024*1024*1024 + 512*1024*1024 + 4);
 143
 144         assert_se(parse_size("3B3G4T", 1024, &bytes) == -EINVAL);
 145
 146         assert_se(parse_size("4T3G3B", 1024, &bytes) == 0);
 147         assert_se(bytes == (4ULL*1024 + 3)*1024*1024*1024 + 3);
 148
 149         assert_se(parse_size(" 4 T 3 G 3 B", 1024, &bytes) == 0);
 150         assert_se(bytes == (4ULL*1024 + 3)*1024*1024*1024 + 3);
 151
 152         assert_se(parse_size("12P", 1024, &bytes) == 0);
 153         assert_se(bytes == 12ULL * 1024*1024*1024*1024*1024);
 154
 155         assert_se(parse_size("12P12P", 1024, &bytes) == -EINVAL);
 156
 157         assert_se(parse_size("3E 2P", 1024, &bytes) == 0);
 158         assert_se(bytes == (3 * 1024 + 2ULL) * 1024*1024*1024*1024*1024);
 159
 160         assert_se(parse_size("12X", 1024, &bytes) == -EINVAL);
 161
 162         assert_se(parse_size("12.5X", 1024, &bytes) == -EINVAL);
 163
 164         assert_se(parse_size("12.5e3", 1024, &bytes) == -EINVAL);
 165
 166         assert_se(parse_size("1024E", 1024, &bytes) == -ERANGE);
 167         assert_se(parse_size("-1", 1024, &bytes) == -ERANGE);
 168         assert_se(parse_size("-1024E", 1024, &bytes) == -ERANGE);
 169
 170         assert_se(parse_size("-1024P", 1024, &bytes) == -ERANGE);
 171
 172         assert_se(parse_size("-10B 20K", 1024, &bytes) == -ERANGE);
 173 }
 174
 175 static void test_parse_range(void) {
 176         unsigned lower, upper;
 177
 178         /* Successful cases */
 179         assert_se(parse_range("111", &lower, &upper) == 0);
 180         assert_se(lower == 111);
 181         assert_se(upper == 111);
 182
 183         assert_se(parse_range("111-123", &lower, &upper) == 0);
 184         assert_se(lower == 111);
 185         assert_se(upper == 123);
 186
 187         assert_se(parse_range("123-111", &lower, &upper) == 0);
 188         assert_se(lower == 123);
 189         assert_se(upper == 111);
 190
 191         assert_se(parse_range("123-123", &lower, &upper) == 0);
 192         assert_se(lower == 123);
 193         assert_se(upper == 123);
 194
 195         assert_se(parse_range("0", &lower, &upper) == 0);
 196         assert_se(lower == 0);
 197         assert_se(upper == 0);
 198
 199         assert_se(parse_range("0-15", &lower, &upper) == 0);
 200         assert_se(lower == 0);
 201         assert_se(upper == 15);
 202
 203         assert_se(parse_range("15-0", &lower, &upper) == 0);
 204         assert_se(lower == 15);
 205         assert_se(upper == 0);
 206
 207         assert_se(parse_range("128-65535", &lower, &upper) == 0);
 208         assert_se(lower == 128);
 209         assert_se(upper == 65535);
 210
 211         assert_se(parse_range("1024-4294967295", &lower, &upper) == 0);
 212         assert_se(lower == 1024);
 213         assert_se(upper == 4294967295);
 214
 215         /* Leading whitespace is acceptable */
 216         assert_se(parse_range(" 111", &lower, &upper) == 0);
 217         assert_se(lower == 111);
 218         assert_se(upper == 111);
 219
 220         assert_se(parse_range(" 111-123", &lower, &upper) == 0);
 221         assert_se(lower == 111);
 222         assert_se(upper == 123);
 223
 224         assert_se(parse_range("111- 123", &lower, &upper) == 0);
 225         assert_se(lower == 111);
 226         assert_se(upper == 123);
 227
 228         assert_se(parse_range("\t111-\t123", &lower, &upper) == 0);
 229         assert_se(lower == 111);
 230         assert_se(upper == 123);
 231
 232         assert_se(parse_range(" \t 111- \t 123", &lower, &upper) == 0);
 233         assert_se(lower == 111);
 234         assert_se(upper == 123);
 235
 236         /* Error cases, make sure they fail as expected */
 237         lower = upper = 9999;
 238         assert_se(parse_range("111garbage", &lower, &upper) == -EINVAL);
 239         assert_se(lower == 9999);
 240         assert_se(upper == 9999);
 241
 242         assert_se(parse_range("garbage111", &lower, &upper) == -EINVAL);
 243         assert_se(lower == 9999);
 244         assert_se(upper == 9999);
 245
 246         assert_se(parse_range("garbage", &lower, &upper) == -EINVAL);
 247         assert_se(lower == 9999);
 248         assert_se(upper == 9999);
 249
 250         assert_se(parse_range("111-123garbage", &lower, &upper) == -EINVAL);
 251         assert_se(lower == 9999);
 252         assert_se(upper == 9999);
 253
 254         assert_se(parse_range("111garbage-123", &lower, &upper) == -EINVAL);
 255         assert_se(lower == 9999);
 256         assert_se(upper == 9999);
 257
 258         /* Empty string */
 259         lower = upper = 9999;
 260         assert_se(parse_range("", &lower, &upper) == -EINVAL);
 261         assert_se(lower == 9999);
 262         assert_se(upper == 9999);
 263
 264         /* 111--123 will pass -123 to safe_atou which returns -ERANGE for negative */
 265         assert_se(parse_range("111--123", &lower, &upper) == -ERANGE);
 266         assert_se(lower == 9999);
 267         assert_se(upper == 9999);
 268
 269         assert_se(parse_range("-123", &lower, &upper) == -EINVAL);
 270         assert_se(lower == 9999);
 271         assert_se(upper == 9999);
 272
 273         assert_se(parse_range("-111-123", &lower, &upper) == -EINVAL);
 274         assert_se(lower == 9999);
 275         assert_se(upper == 9999);
 276
 277         assert_se(parse_range("111-123-", &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         assert_se(parse_range("111,4-123", &lower, &upper) == -EINVAL);
 290         assert_se(lower == 9999);
 291         assert_se(upper == 9999);
 292
 293         assert_se(parse_range("111-123,4", &lower, &upper) == -EINVAL);
 294         assert_se(lower == 9999);
 295         assert_se(upper == 9999);
 296
 297         /* Error on trailing dash */
 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-123-", &lower, &upper) == -EINVAL);
 303         assert_se(lower == 9999);
 304         assert_se(upper == 9999);
 305
 306         assert_se(parse_range("111--", &lower, &upper) == -EINVAL);
 307         assert_se(lower == 9999);
 308         assert_se(upper == 9999);
 309
 310         assert_se(parse_range("111- ", &lower, &upper) == -EINVAL);
 311         assert_se(lower == 9999);
 312         assert_se(upper == 9999);
 313
 314         /* Whitespace is not a separator */
 315         assert_se(parse_range("111 123", &lower, &upper) == -EINVAL);
 316         assert_se(lower == 9999);
 317         assert_se(upper == 9999);
 318
 319         assert_se(parse_range("111\t123", &lower, &upper) == -EINVAL);
 320         assert_se(lower == 9999);
 321         assert_se(upper == 9999);
 322
 323         assert_se(parse_range("111 \t 123", &lower, &upper) == -EINVAL);
 324         assert_se(lower == 9999);
 325         assert_se(upper == 9999);
 326
 327         /* Trailing whitespace is invalid (from safe_atou) */
 328         assert_se(parse_range("111 ", &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 -123", &lower, &upper) == -EINVAL);
 337         assert_se(lower == 9999);
 338         assert_se(upper == 9999);
 339
 340         assert_se(parse_range("111 -123 ", &lower, &upper) == -EINVAL);
 341         assert_se(lower == 9999);
 342         assert_se(upper == 9999);
 343
 344         assert_se(parse_range("111\t-123\t", &lower, &upper) == -EINVAL);
 345         assert_se(lower == 9999);
 346         assert_se(upper == 9999);
 347
 348         assert_se(parse_range("111 \t -123 \t ", &lower, &upper) == -EINVAL);
 349         assert_se(lower == 9999);
 350         assert_se(upper == 9999);
 351
 352         /* Out of the "unsigned" range, this is 1<<64 */
 353         assert_se(parse_range("0-18446744073709551616", &lower, &upper) == -ERANGE);
 354         assert_se(lower == 9999);
 355         assert_se(upper == 9999);
 356 }
 357
 358 static void test_safe_atolli(void) {
 359         int r;
 360         long long l;
 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
 370         r = safe_atolli("-12345", &l);
 371         assert_se(r == 0);
 372         assert_se(l == -12345);
 373
 374         r = safe_atolli("  -12345", &l);
 375         assert_se(r == 0);
 376         assert_se(l == -12345);
 377
 378         r = safe_atolli("12345678901234567890", &l);
 379         assert_se(r == -ERANGE);
 380
 381         r = safe_atolli("-12345678901234567890", &l);
 382         assert_se(r == -ERANGE);
 383
 384         r = safe_atolli("junk", &l);
 385         assert_se(r == -EINVAL);
 386
 387         r = safe_atolli("123x", &l);
 388         assert_se(r == -EINVAL);
 389
 390         r = safe_atolli("12.3", &l);
 391         assert_se(r == -EINVAL);
 392
 393         r = safe_atolli("", &l);
 394         assert_se(r == -EINVAL);
 395 }
 396
 397 static void test_safe_atou16(void) {
 398         int r;
 399         uint16_t l;
 400
 401         r = safe_atou16("12345", &l);
 402         assert_se(r == 0);
 403         assert_se(l == 12345);
 404
 405         r = safe_atou16("  12345", &l);
 406         assert_se(r == 0);
 407         assert_se(l == 12345);
 408
 409         r = safe_atou16("123456", &l);
 410         assert_se(r == -ERANGE);
 411
 412         r = safe_atou16("-1", &l);
 413         assert_se(r == -ERANGE);
 414
 415         r = safe_atou16("  -1", &l);
 416         assert_se(r == -ERANGE);
 417
 418         r = safe_atou16("junk", &l);
 419         assert_se(r == -EINVAL);
 420
 421         r = safe_atou16("123x", &l);
 422         assert_se(r == -EINVAL);
 423
 424         r = safe_atou16("12.3", &l);
 425         assert_se(r == -EINVAL);
 426
 427         r = safe_atou16("", &l);
 428         assert_se(r == -EINVAL);
 429 }
 430
 431 static void test_safe_atoi16(void) {
 432         int r;
 433         int16_t l;
 434
 435         r = safe_atoi16("-12345", &l);
 436         assert_se(r == 0);
 437         assert_se(l == -12345);
 438
 439         r = safe_atoi16("  -12345", &l);
 440         assert_se(r == 0);
 441         assert_se(l == -12345);
 442
 443         r = safe_atoi16("32767", &l);
 444         assert_se(r == 0);
 445         assert_se(l == 32767);
 446
 447         r = safe_atoi16("  32767", &l);
 448         assert_se(r == 0);
 449         assert_se(l == 32767);
 450
 451         r = safe_atoi16("36536", &l);
 452         assert_se(r == -ERANGE);
 453
 454         r = safe_atoi16("-32769", &l);
 455         assert_se(r == -ERANGE);
 456
 457         r = safe_atoi16("junk", &l);
 458         assert_se(r == -EINVAL);
 459
 460         r = safe_atoi16("123x", &l);
 461         assert_se(r == -EINVAL);
 462
 463         r = safe_atoi16("12.3", &l);
 464         assert_se(r == -EINVAL);
 465
 466         r = safe_atoi16("", &l);
 467         assert_se(r == -EINVAL);
 468 }
 469
 470 static void test_safe_atou64(void) {
 471         int r;
 472         uint64_t l;
 473
 474         r = safe_atou64("12345", &l);
 475         assert_se(r == 0);
 476         assert_se(l == 12345);
 477
 478         r = safe_atou64("  12345", &l);
 479         assert_se(r == 0);
 480         assert_se(l == 12345);
 481
 482         r = safe_atou64("18446744073709551617", &l);
 483         assert_se(r == -ERANGE);
 484
 485         r = safe_atou64("-1", &l);
 486         assert_se(r == -ERANGE);
 487
 488         r = safe_atou64("  -1", &l);
 489         assert_se(r == -ERANGE);
 490
 491         r = safe_atou64("junk", &l);
 492         assert_se(r == -EINVAL);
 493
 494         r = safe_atou64("123x", &l);
 495         assert_se(r == -EINVAL);
 496
 497         r = safe_atou64("12.3", &l);
 498         assert_se(r == -EINVAL);
 499
 500         r = safe_atou64("", &l);
 501         assert_se(r == -EINVAL);
 502 }
 503
 504 static void test_safe_atoi64(void) {
 505         int r;
 506         int64_t l;
 507
 508         r = safe_atoi64("-12345", &l);
 509         assert_se(r == 0);
 510         assert_se(l == -12345);
 511
 512         r = safe_atoi64("  -12345", &l);
 513         assert_se(r == 0);
 514         assert_se(l == -12345);
 515
 516         r = safe_atoi64("32767", &l);
 517         assert_se(r == 0);
 518         assert_se(l == 32767);
 519
 520         r = safe_atoi64("  32767", &l);
 521         assert_se(r == 0);
 522         assert_se(l == 32767);
 523
 524         r = safe_atoi64("9223372036854775813", &l);
 525         assert_se(r == -ERANGE);
 526
 527         r = safe_atoi64("-9223372036854775813", &l);
 528         assert_se(r == -ERANGE);
 529
 530         r = safe_atoi64("junk", &l);
 531         assert_se(r == -EINVAL);
 532
 533         r = safe_atoi64("123x", &l);
 534         assert_se(r == -EINVAL);
 535
 536         r = safe_atoi64("12.3", &l);
 537         assert_se(r == -EINVAL);
 538
 539         r = safe_atoi64("", &l);
 540         assert_se(r == -EINVAL);
 541 }
 542
 543 static void test_safe_atod(void) {
 544         int r;
 545         double d;
 546         char *e;
 547
 548         r = safe_atod("junk", &d);
 549         assert_se(r == -EINVAL);
 550
 551         r = safe_atod("0.2244", &d);
 552         assert_se(r == 0);
 553         assert_se(fabs(d - 0.2244) < 0.000001);
 554
 555         r = safe_atod("0,5", &d);
 556         assert_se(r == -EINVAL);
 557
 558         errno = 0;
 559         strtod("0,5", &e);
 560         assert_se(*e == ',');
 561
 562         r = safe_atod("", &d);
 563         assert_se(r == -EINVAL);
 564
 565         /* Check if this really is locale independent */
 566         if (setlocale(LC_NUMERIC, "de_DE.utf8")) {
 567
 568                 r = safe_atod("0.2244", &d);
 569                 assert_se(r == 0);
 570                 assert_se(fabs(d - 0.2244) < 0.000001);
 571
 572                 r = safe_atod("0,5", &d);
 573                 assert_se(r == -EINVAL);
 574
 575                 errno = 0;
 576                 assert_se(fabs(strtod("0,5", &e) - 0.5) < 0.00001);
 577
 578                 r = safe_atod("", &d);
 579                 assert_se(r == -EINVAL);
 580         }
 581
 582         /* And check again, reset */
 583         assert_se(setlocale(LC_NUMERIC, "C"));
 584
 585         r = safe_atod("0.2244", &d);
 586         assert_se(r == 0);
 587         assert_se(fabs(d - 0.2244) < 0.000001);
 588
 589         r = safe_atod("0,5", &d);
 590         assert_se(r == -EINVAL);
 591
 592         errno = 0;
 593         strtod("0,5", &e);
 594         assert_se(*e == ',');
 595
 596         r = safe_atod("", &d);
 597         assert_se(r == -EINVAL);
 598 }
 599
 600 static void test_parse_percent(void) {
 601         assert_se(parse_percent("") == -EINVAL);
 602         assert_se(parse_percent("foo") == -EINVAL);
 603         assert_se(parse_percent("0") == -EINVAL);
 604         assert_se(parse_percent("50") == -EINVAL);
 605         assert_se(parse_percent("100") == -EINVAL);
 606         assert_se(parse_percent("-1") == -EINVAL);
 607         assert_se(parse_percent("0%") == 0);
 608         assert_se(parse_percent("55%") == 55);
 609         assert_se(parse_percent("100%") == 100);
 610         assert_se(parse_percent("-7%") == -ERANGE);
 611         assert_se(parse_percent("107%") == -ERANGE);
 612         assert_se(parse_percent("%") == -EINVAL);
 613         assert_se(parse_percent("%%") == -EINVAL);
 614         assert_se(parse_percent("%1") == -EINVAL);
 615         assert_se(parse_percent("1%%") == -EINVAL);
 616         assert_se(parse_percent("3.2%") == -EINVAL);
 617 }
 618
 619 static void test_parse_percent_unbounded(void) {
 620         assert_se(parse_percent_unbounded("101%") == 101);
 621         assert_se(parse_percent_unbounded("400%") == 400);
 622 }
 623
 624 static void test_parse_nice(void) {
 625         int n;
 626
 627         assert_se(parse_nice("0", &n) >= 0 && n == 0);
 628         assert_se(parse_nice("+0", &n) >= 0 && n == 0);
 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("1", &n) >= 0 && n == 1);
 632         assert_se(parse_nice("2", &n) >= 0 && n == 2);
 633         assert_se(parse_nice("+1", &n) >= 0 && n == 1);
 634         assert_se(parse_nice("+2", &n) >= 0 && n == 2);
 635         assert_se(parse_nice("-20", &n) >= 0 && n == -20);
 636         assert_se(parse_nice("19", &n) >= 0 && n == 19);
 637         assert_se(parse_nice("+19", &n) >= 0 && n == 19);
 638
 639
 640         assert_se(parse_nice("", &n) == -EINVAL);
 641         assert_se(parse_nice("-", &n) == -EINVAL);
 642         assert_se(parse_nice("+", &n) == -EINVAL);
 643         assert_se(parse_nice("xx", &n) == -EINVAL);
 644         assert_se(parse_nice("-50", &n) == -ERANGE);
 645         assert_se(parse_nice("50", &n) == -ERANGE);
 646         assert_se(parse_nice("+50", &n) == -ERANGE);
 647         assert_se(parse_nice("-21", &n) == -ERANGE);
 648         assert_se(parse_nice("20", &n) == -ERANGE);
 649         assert_se(parse_nice("+20", &n) == -ERANGE);
 650 }
 651
 652 static void test_parse_dev(void) {
 653         dev_t dev;
 654
 655         assert_se(parse_dev("", &dev) == -EINVAL);
 656         assert_se(parse_dev("junk", &dev) == -EINVAL);
 657         assert_se(parse_dev("0", &dev) == -EINVAL);
 658         assert_se(parse_dev("5", &dev) == -EINVAL);
 659         assert_se(parse_dev("5:", &dev) == -EINVAL);
 660         assert_se(parse_dev(":5", &dev) == -EINVAL);
 661 #if SIZEOF_DEV_T < 8
 662         assert_se(parse_dev("4294967295:4294967295", &dev) == -EINVAL);
 663 #endif
 664         assert_se(parse_dev("8:11", &dev) >= 0 && major(dev) == 8 && minor(dev) == 11);
 665 }
 666
 667 static void test_parse_errno(void) {
 668         assert_se(parse_errno("EILSEQ") == EILSEQ);
 669         assert_se(parse_errno("EINVAL") == EINVAL);
 670         assert_se(parse_errno("0") == 0);
 671         assert_se(parse_errno("1") == 1);
 672         assert_se(parse_errno("4095") == 4095);
 673
 674         assert_se(parse_errno("-1") == -ERANGE);
 675         assert_se(parse_errno("-3") == -ERANGE);
 676         assert_se(parse_errno("4096") == -ERANGE);
 677
 678         assert_se(parse_errno("") == -EINVAL);
 679         assert_se(parse_errno("12.3") == -EINVAL);
 680         assert_se(parse_errno("123junk") == -EINVAL);
 681         assert_se(parse_errno("junk123") == -EINVAL);
 682         assert_se(parse_errno("255EILSEQ") == -EINVAL);
 683         assert_se(parse_errno("EINVAL12") == -EINVAL);
 684         assert_se(parse_errno("-EINVAL") == -EINVAL);
 685         assert_se(parse_errno("EINVALaaa") == -EINVAL);
 686 }
 687
 688 static void test_parse_syscall_and_errno(void) {
 689         _cleanup_free_ char *n = NULL;
 690         int e;
 691
 692         assert_se(parse_syscall_and_errno("uname:EILSEQ", &n, &e) >= 0);
 693         assert_se(streq(n, "uname"));
 694         assert_se(e == errno_from_name("EILSEQ") && e >= 0);
 695         n = mfree(n);
 696
 697         assert_se(parse_syscall_and_errno("uname:EINVAL", &n, &e) >= 0);
 698         assert_se(streq(n, "uname"));
 699         assert_se(e == errno_from_name("EINVAL") && e >= 0);
 700         n = mfree(n);
 701
 702         assert_se(parse_syscall_and_errno("@sync:4095", &n, &e) >= 0);
 703         assert_se(streq(n, "@sync"));
 704         assert_se(e == 4095);
 705         n = mfree(n);
 706
 707         /* If errno is omitted, then e is set to -1 */
 708         assert_se(parse_syscall_and_errno("mount", &n, &e) >= 0);
 709         assert_se(streq(n, "mount"));
 710         assert_se(e == -1);
 711         n = mfree(n);
 712
 713         /* parse_syscall_and_errno() does not check the syscall name is valid or not. */
 714         assert_se(parse_syscall_and_errno("hoge:255", &n, &e) >= 0);
 715         assert_se(streq(n, "hoge"));
 716         assert_se(e == 255);
 717         n = mfree(n);
 718
 719         /* The function checks the syscall name is empty or not. */
 720         assert_se(parse_syscall_and_errno("", &n, &e) == -EINVAL);
 721         assert_se(parse_syscall_and_errno(":255", &n, &e) == -EINVAL);
 722
 723         /* errno must be a valid errno name or number between 0 and ERRNO_MAX == 4095 */
 724         assert_se(parse_syscall_and_errno("hoge:4096", &n, &e) == -ERANGE);
 725         assert_se(parse_syscall_and_errno("hoge:-3", &n, &e) == -ERANGE);
 726         assert_se(parse_syscall_and_errno("hoge:12.3", &n, &e) == -EINVAL);
 727         assert_se(parse_syscall_and_errno("hoge:123junk", &n, &e) == -EINVAL);
 728         assert_se(parse_syscall_and_errno("hoge:junk123", &n, &e) == -EINVAL);
 729         assert_se(parse_syscall_and_errno("hoge:255:EILSEQ", &n, &e) == -EINVAL);
 730         assert_se(parse_syscall_and_errno("hoge:-EINVAL", &n, &e) == -EINVAL);
 731         assert_se(parse_syscall_and_errno("hoge:EINVALaaa", &n, &e) == -EINVAL);
 732         assert_se(parse_syscall_and_errno("hoge:", &n, &e) == -EINVAL);
 733 }
 734
 735 int main(int argc, char *argv[]) {
 736         log_parse_environment();
 737         log_open();
 738
 739         test_parse_boolean();
 740         test_parse_pid();
 741         test_parse_mode();
 742         test_parse_size();
 743         test_parse_range();
 744         test_safe_atolli();
 745         test_safe_atou16();
 746         test_safe_atoi16();
 747         test_safe_atou64();
 748         test_safe_atoi64();
 749         test_safe_atod();
 750         test_parse_percent();
 751         test_parse_percent_unbounded();
 752         test_parse_nice();
 753         test_parse_dev();
 754         test_parse_errno();
 755         test_parse_syscall_and_errno();
 756
 757         return 0;
 758 }