src/test/test-parse-util.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright 2010 Lennart Poettering
   5   Copyright 2013 Thomas H.P. Andersen
   6
   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.
  11
  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.
  16
  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/>.
  19 ***/
  20
  21 #include <locale.h>
  22 #include <math.h>
  23
  24 #include "log.h"
  25 #include "parse-util.h"
  26
  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);
  37
  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);
  47
  48         assert_se(parse_boolean("garbage") < 0);
  49         assert_se(parse_boolean("") < 0);
  50         assert_se(parse_boolean("full") < 0);
  51 }
  52
  53 static void test_parse_pid(void) {
  54         int r;
  55         pid_t pid;
  56
  57         r = parse_pid("100", &pid);
  58         assert_se(r == 0);
  59         assert_se(pid == 100);
  60
  61         r = parse_pid("0x7FFFFFFF", &pid);
  62         assert_se(r == 0);
  63         assert_se(pid == 2147483647);
  64
  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);
  68         assert_se(pid == 65);
  69
  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);
  73         assert_se(pid == 65);
  74
  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);
  78         assert_se(pid == 65);
  79
  80         r = parse_pid("junk", &pid);
  81         assert_se(r == -EINVAL);
  82
  83         r = parse_pid("", &pid);
  84         assert_se(r == -EINVAL);
  85 }
  86
  87 static void test_parse_mode(void) {
  88         mode_t m;
  89
  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);
  94
  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);
  99 }
 100
 101 static void test_parse_size(void) {
 102         uint64_t bytes;
 103
 104         assert_se(parse_size("", 1024, &bytes) == -EINVAL);
 105
 106         assert_se(parse_size("111", 1024, &bytes) == 0);
 107         assert_se(bytes == 111);
 108
 109         assert_se(parse_size("111.4", 1024, &bytes) == 0);
 110         assert_se(bytes == 111);
 111
 112         assert_se(parse_size(" 112 B", 1024, &bytes) == 0);
 113         assert_se(bytes == 112);
 114
 115         assert_se(parse_size(" 112.6 B", 1024, &bytes) == 0);
 116         assert_se(bytes == 112);
 117
 118         assert_se(parse_size("3.5 K", 1024, &bytes) == 0);
 119         assert_se(bytes == 3*1024 + 512);
 120
 121         assert_se(parse_size("3. K", 1024, &bytes) == 0);
 122         assert_se(bytes == 3*1024);
 123
 124         assert_se(parse_size("3.0 K", 1024, &bytes) == 0);
 125         assert_se(bytes == 3*1024);
 126
 127         assert_se(parse_size("3. 0 K", 1024, &bytes) == -EINVAL);
 128
 129         assert_se(parse_size(" 4 M 11.5K", 1024, &bytes) == 0);
 130         assert_se(bytes == 4*1024*1024 + 11 * 1024 + 512);
 131
 132         assert_se(parse_size("3B3.5G", 1024, &bytes) == -EINVAL);
 133
 134         assert_se(parse_size("3.5G3B", 1024, &bytes) == 0);
 135         assert_se(bytes == 3ULL*1024*1024*1024 + 512*1024*1024 + 3);
 136
 137         assert_se(parse_size("3.5G 4B", 1024, &bytes) == 0);
 138         assert_se(bytes == 3ULL*1024*1024*1024 + 512*1024*1024 + 4);
 139
 140         assert_se(parse_size("3B3G4T", 1024, &bytes) == -EINVAL);
 141
 142         assert_se(parse_size("4T3G3B", 1024, &bytes) == 0);
 143         assert_se(bytes == (4ULL*1024 + 3)*1024*1024*1024 + 3);
 144
 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);
 147
 148         assert_se(parse_size("12P", 1024, &bytes) == 0);
 149         assert_se(bytes == 12ULL * 1024*1024*1024*1024*1024);
 150
 151         assert_se(parse_size("12P12P", 1024, &bytes) == -EINVAL);
 152
 153         assert_se(parse_size("3E 2P", 1024, &bytes) == 0);
 154         assert_se(bytes == (3 * 1024 + 2ULL) * 1024*1024*1024*1024*1024);
 155
 156         assert_se(parse_size("12X", 1024, &bytes) == -EINVAL);
 157
 158         assert_se(parse_size("12.5X", 1024, &bytes) == -EINVAL);
 159
 160         assert_se(parse_size("12.5e3", 1024, &bytes) == -EINVAL);
 161
 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);
 165
 166         assert_se(parse_size("-1024P", 1024, &bytes) == -ERANGE);
 167
 168         assert_se(parse_size("-10B 20K", 1024, &bytes) == -ERANGE);
 169 }
 170
 171 static void test_parse_range(void) {
 172         unsigned lower, upper;
 173
 174         /* Successful cases */
 175         assert_se(parse_range("111", &lower, &upper) == 0);
 176         assert_se(lower == 111);
 177         assert_se(upper == 111);
 178
 179         assert_se(parse_range("111-123", &lower, &upper) == 0);
 180         assert_se(lower == 111);
 181         assert_se(upper == 123);
 182
 183         assert_se(parse_range("123-111", &lower, &upper) == 0);
 184         assert_se(lower == 123);
 185         assert_se(upper == 111);
 186
 187         assert_se(parse_range("123-123", &lower, &upper) == 0);
 188         assert_se(lower == 123);
 189         assert_se(upper == 123);
 190
 191         assert_se(parse_range("0", &lower, &upper) == 0);
 192         assert_se(lower == 0);
 193         assert_se(upper == 0);
 194
 195         assert_se(parse_range("0-15", &lower, &upper) == 0);
 196         assert_se(lower == 0);
 197         assert_se(upper == 15);
 198
 199         assert_se(parse_range("15-0", &lower, &upper) == 0);
 200         assert_se(lower == 15);
 201         assert_se(upper == 0);
 202
 203         assert_se(parse_range("128-65535", &lower, &upper) == 0);
 204         assert_se(lower == 128);
 205         assert_se(upper == 65535);
 206
 207         assert_se(parse_range("1024-4294967295", &lower, &upper) == 0);
 208         assert_se(lower == 1024);
 209         assert_se(upper == 4294967295);
 210
 211         /* Leading whitespace is acceptable */
 212         assert_se(parse_range(" 111", &lower, &upper) == 0);
 213         assert_se(lower == 111);
 214         assert_se(upper == 111);
 215
 216         assert_se(parse_range(" 111-123", &lower, &upper) == 0);
 217         assert_se(lower == 111);
 218         assert_se(upper == 123);
 219
 220         assert_se(parse_range("111- 123", &lower, &upper) == 0);
 221         assert_se(lower == 111);
 222         assert_se(upper == 123);
 223
 224         assert_se(parse_range("\t111-\t123", &lower, &upper) == 0);
 225         assert_se(lower == 111);
 226         assert_se(upper == 123);
 227
 228         assert_se(parse_range(" \t 111- \t 123", &lower, &upper) == 0);
 229         assert_se(lower == 111);
 230         assert_se(upper == 123);
 231
 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);
 237
 238         assert_se(parse_range("garbage111", &lower, &upper) == -EINVAL);
 239         assert_se(lower == 9999);
 240         assert_se(upper == 9999);
 241
 242         assert_se(parse_range("garbage", &lower, &upper) == -EINVAL);
 243         assert_se(lower == 9999);
 244         assert_se(upper == 9999);
 245
 246         assert_se(parse_range("111-123garbage", &lower, &upper) == -EINVAL);
 247         assert_se(lower == 9999);
 248         assert_se(upper == 9999);
 249
 250         assert_se(parse_range("111garbage-123", &lower, &upper) == -EINVAL);
 251         assert_se(lower == 9999);
 252         assert_se(upper == 9999);
 253
 254         /* Empty string */
 255         lower = upper = 9999;
 256         assert_se(parse_range("", &lower, &upper) == -EINVAL);
 257         assert_se(lower == 9999);
 258         assert_se(upper == 9999);
 259
 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);
 264
 265         assert_se(parse_range("-123", &lower, &upper) == -EINVAL);
 266         assert_se(lower == 9999);
 267         assert_se(upper == 9999);
 268
 269         assert_se(parse_range("-111-123", &lower, &upper) == -EINVAL);
 270         assert_se(lower == 9999);
 271         assert_se(upper == 9999);
 272
 273         assert_se(parse_range("111-123-", &lower, &upper) == -EINVAL);
 274         assert_se(lower == 9999);
 275         assert_se(upper == 9999);
 276
 277         assert_se(parse_range("111.4-123", &lower, &upper) == -EINVAL);
 278         assert_se(lower == 9999);
 279         assert_se(upper == 9999);
 280
 281         assert_se(parse_range("111-123.4", &lower, &upper) == -EINVAL);
 282         assert_se(lower == 9999);
 283         assert_se(upper == 9999);
 284
 285         assert_se(parse_range("111,4-123", &lower, &upper) == -EINVAL);
 286         assert_se(lower == 9999);
 287         assert_se(upper == 9999);
 288
 289         assert_se(parse_range("111-123,4", &lower, &upper) == -EINVAL);
 290         assert_se(lower == 9999);
 291         assert_se(upper == 9999);
 292
 293         /* Error on trailing dash */
 294         assert_se(parse_range("111-", &lower, &upper) == -EINVAL);
 295         assert_se(lower == 9999);
 296         assert_se(upper == 9999);
 297
 298         assert_se(parse_range("111-123-", &lower, &upper) == -EINVAL);
 299         assert_se(lower == 9999);
 300         assert_se(upper == 9999);
 301
 302         assert_se(parse_range("111--", &lower, &upper) == -EINVAL);
 303         assert_se(lower == 9999);
 304         assert_se(upper == 9999);
 305
 306         assert_se(parse_range("111- ", &lower, &upper) == -EINVAL);
 307         assert_se(lower == 9999);
 308         assert_se(upper == 9999);
 309
 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);
 314
 315         assert_se(parse_range("111\t123", &lower, &upper) == -EINVAL);
 316         assert_se(lower == 9999);
 317         assert_se(upper == 9999);
 318
 319         assert_se(parse_range("111 \t 123", &lower, &upper) == -EINVAL);
 320         assert_se(lower == 9999);
 321         assert_se(upper == 9999);
 322
 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);
 327
 328         assert_se(parse_range("111-123 ", &lower, &upper) == -EINVAL);
 329         assert_se(lower == 9999);
 330         assert_se(upper == 9999);
 331
 332         assert_se(parse_range("111 -123", &lower, &upper) == -EINVAL);
 333         assert_se(lower == 9999);
 334         assert_se(upper == 9999);
 335
 336         assert_se(parse_range("111 -123 ", &lower, &upper) == -EINVAL);
 337         assert_se(lower == 9999);
 338         assert_se(upper == 9999);
 339
 340         assert_se(parse_range("111\t-123\t", &lower, &upper) == -EINVAL);
 341         assert_se(lower == 9999);
 342         assert_se(upper == 9999);
 343
 344         assert_se(parse_range("111 \t -123 \t ", &lower, &upper) == -EINVAL);
 345         assert_se(lower == 9999);
 346         assert_se(upper == 9999);
 347
 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);
 352 }
 353
 354 static void test_safe_atolli(void) {
 355         int r;
 356         long long l;
 357
 358         r = safe_atolli("12345", &l);
 359         assert_se(r == 0);
 360         assert_se(l == 12345);
 361
 362         r = safe_atolli("  12345", &l);
 363         assert_se(r == 0);
 364         assert_se(l == 12345);
 365
 366         r = safe_atolli("-12345", &l);
 367         assert_se(r == 0);
 368         assert_se(l == -12345);
 369
 370         r = safe_atolli("  -12345", &l);
 371         assert_se(r == 0);
 372         assert_se(l == -12345);
 373
 374         r = safe_atolli("12345678901234567890", &l);
 375         assert_se(r == -ERANGE);
 376
 377         r = safe_atolli("-12345678901234567890", &l);
 378         assert_se(r == -ERANGE);
 379
 380         r = safe_atolli("junk", &l);
 381         assert_se(r == -EINVAL);
 382
 383         r = safe_atolli("123x", &l);
 384         assert_se(r == -EINVAL);
 385
 386         r = safe_atolli("12.3", &l);
 387         assert_se(r == -EINVAL);
 388
 389         r = safe_atolli("", &l);
 390         assert_se(r == -EINVAL);
 391 }
 392
 393 static void test_safe_atou16(void) {
 394         int r;
 395         uint16_t l;
 396
 397         r = safe_atou16("12345", &l);
 398         assert_se(r == 0);
 399         assert_se(l == 12345);
 400
 401         r = safe_atou16("  12345", &l);
 402         assert_se(r == 0);
 403         assert_se(l == 12345);
 404
 405         r = safe_atou16("123456", &l);
 406         assert_se(r == -ERANGE);
 407
 408         r = safe_atou16("-1", &l);
 409         assert_se(r == -ERANGE);
 410
 411         r = safe_atou16("  -1", &l);
 412         assert_se(r == -ERANGE);
 413
 414         r = safe_atou16("junk", &l);
 415         assert_se(r == -EINVAL);
 416
 417         r = safe_atou16("123x", &l);
 418         assert_se(r == -EINVAL);
 419
 420         r = safe_atou16("12.3", &l);
 421         assert_se(r == -EINVAL);
 422
 423         r = safe_atou16("", &l);
 424         assert_se(r == -EINVAL);
 425 }
 426
 427 static void test_safe_atoi16(void) {
 428         int r;
 429         int16_t l;
 430
 431         r = safe_atoi16("-12345", &l);
 432         assert_se(r == 0);
 433         assert_se(l == -12345);
 434
 435         r = safe_atoi16("  -12345", &l);
 436         assert_se(r == 0);
 437         assert_se(l == -12345);
 438
 439         r = safe_atoi16("32767", &l);
 440         assert_se(r == 0);
 441         assert_se(l == 32767);
 442
 443         r = safe_atoi16("  32767", &l);
 444         assert_se(r == 0);
 445         assert_se(l == 32767);
 446
 447         r = safe_atoi16("36536", &l);
 448         assert_se(r == -ERANGE);
 449
 450         r = safe_atoi16("-32769", &l);
 451         assert_se(r == -ERANGE);
 452
 453         r = safe_atoi16("junk", &l);
 454         assert_se(r == -EINVAL);
 455
 456         r = safe_atoi16("123x", &l);
 457         assert_se(r == -EINVAL);
 458
 459         r = safe_atoi16("12.3", &l);
 460         assert_se(r == -EINVAL);
 461
 462         r = safe_atoi16("", &l);
 463         assert_se(r == -EINVAL);
 464 }
 465
 466 static void test_safe_atou64(void) {
 467         int r;
 468         uint64_t l;
 469
 470         r = safe_atou64("12345", &l);
 471         assert_se(r == 0);
 472         assert_se(l == 12345);
 473
 474         r = safe_atou64("  12345", &l);
 475         assert_se(r == 0);
 476         assert_se(l == 12345);
 477
 478         r = safe_atou64("18446744073709551617", &l);
 479         assert_se(r == -ERANGE);
 480
 481         r = safe_atou64("-1", &l);
 482         assert_se(r == -ERANGE);
 483
 484         r = safe_atou64("  -1", &l);
 485         assert_se(r == -ERANGE);
 486
 487         r = safe_atou64("junk", &l);
 488         assert_se(r == -EINVAL);
 489
 490         r = safe_atou64("123x", &l);
 491         assert_se(r == -EINVAL);
 492
 493         r = safe_atou64("12.3", &l);
 494         assert_se(r == -EINVAL);
 495
 496         r = safe_atou64("", &l);
 497         assert_se(r == -EINVAL);
 498 }
 499
 500 static void test_safe_atoi64(void) {
 501         int r;
 502         int64_t l;
 503
 504         r = safe_atoi64("-12345", &l);
 505         assert_se(r == 0);
 506         assert_se(l == -12345);
 507
 508         r = safe_atoi64("  -12345", &l);
 509         assert_se(r == 0);
 510         assert_se(l == -12345);
 511
 512         r = safe_atoi64("32767", &l);
 513         assert_se(r == 0);
 514         assert_se(l == 32767);
 515
 516         r = safe_atoi64("  32767", &l);
 517         assert_se(r == 0);
 518         assert_se(l == 32767);
 519
 520         r = safe_atoi64("9223372036854775813", &l);
 521         assert_se(r == -ERANGE);
 522
 523         r = safe_atoi64("-9223372036854775813", &l);
 524         assert_se(r == -ERANGE);
 525
 526         r = safe_atoi64("junk", &l);
 527         assert_se(r == -EINVAL);
 528
 529         r = safe_atoi64("123x", &l);
 530         assert_se(r == -EINVAL);
 531
 532         r = safe_atoi64("12.3", &l);
 533         assert_se(r == -EINVAL);
 534
 535         r = safe_atoi64("", &l);
 536         assert_se(r == -EINVAL);
 537 }
 538
 539 static void test_safe_atod(void) {
 540         int r;
 541         double d;
 542         char *e;
 543
 544         r = safe_atod("junk", &d);
 545         assert_se(r == -EINVAL);
 546
 547         r = safe_atod("0.2244", &d);
 548         assert_se(r == 0);
 549         assert_se(fabs(d - 0.2244) < 0.000001);
 550
 551         r = safe_atod("0,5", &d);
 552         assert_se(r == -EINVAL);
 553
 554         errno = 0;
 555         strtod("0,5", &e);
 556         assert_se(*e == ',');
 557
 558         r = safe_atod("", &d);
 559         assert_se(r == -EINVAL);
 560
 561         /* Check if this really is locale independent */
 562         if (setlocale(LC_NUMERIC, "de_DE.utf8")) {
 563
 564                 r = safe_atod("0.2244", &d);
 565                 assert_se(r == 0);
 566                 assert_se(fabs(d - 0.2244) < 0.000001);
 567
 568                 r = safe_atod("0,5", &d);
 569                 assert_se(r == -EINVAL);
 570
 571                 errno = 0;
 572                 assert_se(fabs(strtod("0,5", &e) - 0.5) < 0.00001);
 573
 574                 r = safe_atod("", &d);
 575                 assert_se(r == -EINVAL);
 576         }
 577
 578         /* And check again, reset */
 579         assert_se(setlocale(LC_NUMERIC, "C"));
 580
 581         r = safe_atod("0.2244", &d);
 582         assert_se(r == 0);
 583         assert_se(fabs(d - 0.2244) < 0.000001);
 584
 585         r = safe_atod("0,5", &d);
 586         assert_se(r == -EINVAL);
 587
 588         errno = 0;
 589         strtod("0,5", &e);
 590         assert_se(*e == ',');
 591
 592         r = safe_atod("", &d);
 593         assert_se(r == -EINVAL);
 594 }
 595
 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);
 613 }
 614
 615 static void test_parse_percent_unbounded(void) {
 616         assert_se(parse_percent_unbounded("101%") == 101);
 617         assert_se(parse_percent_unbounded("400%") == 400);
 618 }
 619
 620 static void test_parse_nice(void) {
 621         int n;
 622
 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);
 634
 635
 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);
 646 }
 647
 648 static void test_parse_dev(void) {
 649         dev_t dev;
 650
 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);
 657 #if SIZEOF_DEV_T < 8
 658         assert_se(parse_dev("4294967295:4294967295", &dev) == -EINVAL);
 659 #endif
 660         assert_se(parse_dev("8:11", &dev) >= 0 && major(dev) == 8 && minor(dev) == 11);
 661 }
 662
 663 int main(int argc, char *argv[]) {
 664         log_parse_environment();
 665         log_open();
 666
 667         test_parse_boolean();
 668         test_parse_pid();
 669         test_parse_mode();
 670         test_parse_size();
 671         test_parse_range();
 672         test_safe_atolli();
 673         test_safe_atou16();
 674         test_safe_atoi16();
 675         test_safe_atou64();
 676         test_safe_atoi64();
 677         test_safe_atod();
 678         test_parse_percent();
 679         test_parse_percent_unbounded();
 680         test_parse_nice();
 681         test_parse_dev();
 682
 683         return 0;
 684 }