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