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_atoux16(void) {
 472         int r;
 473         uint16_t l;
 474
 475         r = safe_atoux16("1234", &l);
 476         assert_se(r == 0);
 477         assert_se(l == 0x1234);
 478
 479         r = safe_atoux16("abcd", &l);
 480         assert_se(r == 0);
 481         assert_se(l == 0xabcd);
 482
 483         r = safe_atoux16("  1234", &l);
 484         assert_se(r == 0);
 485         assert_se(l == 0x1234);
 486
 487         r = safe_atoux16("12345", &l);
 488         assert_se(r == -ERANGE);
 489
 490         r = safe_atoux16("-1", &l);
 491         assert_se(r == -ERANGE);
 492
 493         r = safe_atoux16("  -1", &l);
 494         assert_se(r == -ERANGE);
 495
 496         r = safe_atoux16("junk", &l);
 497         assert_se(r == -EINVAL);
 498
 499         r = safe_atoux16("123x", &l);
 500         assert_se(r == -EINVAL);
 501
 502         r = safe_atoux16("12.3", &l);
 503         assert_se(r == -EINVAL);
 504
 505         r = safe_atoux16("", &l);
 506         assert_se(r == -EINVAL);
 507 }
 508
 509 static void test_safe_atou64(void) {
 510         int r;
 511         uint64_t l;
 512
 513         r = safe_atou64("12345", &l);
 514         assert_se(r == 0);
 515         assert_se(l == 12345);
 516
 517         r = safe_atou64("  12345", &l);
 518         assert_se(r == 0);
 519         assert_se(l == 12345);
 520
 521         r = safe_atou64("18446744073709551617", &l);
 522         assert_se(r == -ERANGE);
 523
 524         r = safe_atou64("-1", &l);
 525         assert_se(r == -ERANGE);
 526
 527         r = safe_atou64("  -1", &l);
 528         assert_se(r == -ERANGE);
 529
 530         r = safe_atou64("junk", &l);
 531         assert_se(r == -EINVAL);
 532
 533         r = safe_atou64("123x", &l);
 534         assert_se(r == -EINVAL);
 535
 536         r = safe_atou64("12.3", &l);
 537         assert_se(r == -EINVAL);
 538
 539         r = safe_atou64("", &l);
 540         assert_se(r == -EINVAL);
 541 }
 542
 543 static void test_safe_atoi64(void) {
 544         int r;
 545         int64_t l;
 546
 547         r = safe_atoi64("-12345", &l);
 548         assert_se(r == 0);
 549         assert_se(l == -12345);
 550
 551         r = safe_atoi64("  -12345", &l);
 552         assert_se(r == 0);
 553         assert_se(l == -12345);
 554
 555         r = safe_atoi64("32767", &l);
 556         assert_se(r == 0);
 557         assert_se(l == 32767);
 558
 559         r = safe_atoi64("  32767", &l);
 560         assert_se(r == 0);
 561         assert_se(l == 32767);
 562
 563         r = safe_atoi64("9223372036854775813", &l);
 564         assert_se(r == -ERANGE);
 565
 566         r = safe_atoi64("-9223372036854775813", &l);
 567         assert_se(r == -ERANGE);
 568
 569         r = safe_atoi64("junk", &l);
 570         assert_se(r == -EINVAL);
 571
 572         r = safe_atoi64("123x", &l);
 573         assert_se(r == -EINVAL);
 574
 575         r = safe_atoi64("12.3", &l);
 576         assert_se(r == -EINVAL);
 577
 578         r = safe_atoi64("", &l);
 579         assert_se(r == -EINVAL);
 580 }
 581
 582 static void test_safe_atod(void) {
 583         int r;
 584         double d;
 585         char *e;
 586
 587         r = safe_atod("junk", &d);
 588         assert_se(r == -EINVAL);
 589
 590         r = safe_atod("0.2244", &d);
 591         assert_se(r == 0);
 592         assert_se(fabs(d - 0.2244) < 0.000001);
 593
 594         r = safe_atod("0,5", &d);
 595         assert_se(r == -EINVAL);
 596
 597         errno = 0;
 598         strtod("0,5", &e);
 599         assert_se(*e == ',');
 600
 601         r = safe_atod("", &d);
 602         assert_se(r == -EINVAL);
 603
 604         /* Check if this really is locale independent */
 605         if (setlocale(LC_NUMERIC, "de_DE.utf8")) {
 606
 607                 r = safe_atod("0.2244", &d);
 608                 assert_se(r == 0);
 609                 assert_se(fabs(d - 0.2244) < 0.000001);
 610
 611                 r = safe_atod("0,5", &d);
 612                 assert_se(r == -EINVAL);
 613
 614                 errno = 0;
 615                 assert_se(fabs(strtod("0,5", &e) - 0.5) < 0.00001);
 616
 617                 r = safe_atod("", &d);
 618                 assert_se(r == -EINVAL);
 619         }
 620
 621         /* And check again, reset */
 622         assert_se(setlocale(LC_NUMERIC, "C"));
 623
 624         r = safe_atod("0.2244", &d);
 625         assert_se(r == 0);
 626         assert_se(fabs(d - 0.2244) < 0.000001);
 627
 628         r = safe_atod("0,5", &d);
 629         assert_se(r == -EINVAL);
 630
 631         errno = 0;
 632         strtod("0,5", &e);
 633         assert_se(*e == ',');
 634
 635         r = safe_atod("", &d);
 636         assert_se(r == -EINVAL);
 637 }
 638
 639 static void test_parse_percent(void) {
 640         assert_se(parse_percent("") == -EINVAL);
 641         assert_se(parse_percent("foo") == -EINVAL);
 642         assert_se(parse_percent("0") == -EINVAL);
 643         assert_se(parse_percent("50") == -EINVAL);
 644         assert_se(parse_percent("100") == -EINVAL);
 645         assert_se(parse_percent("-1") == -EINVAL);
 646         assert_se(parse_percent("0%") == 0);
 647         assert_se(parse_percent("55%") == 55);
 648         assert_se(parse_percent("100%") == 100);
 649         assert_se(parse_percent("-7%") == -ERANGE);
 650         assert_se(parse_percent("107%") == -ERANGE);
 651         assert_se(parse_percent("%") == -EINVAL);
 652         assert_se(parse_percent("%%") == -EINVAL);
 653         assert_se(parse_percent("%1") == -EINVAL);
 654         assert_se(parse_percent("1%%") == -EINVAL);
 655         assert_se(parse_percent("3.2%") == -EINVAL);
 656 }
 657
 658 static void test_parse_percent_unbounded(void) {
 659         assert_se(parse_percent_unbounded("101%") == 101);
 660         assert_se(parse_percent_unbounded("400%") == 400);
 661 }
 662
 663 static void test_parse_nice(void) {
 664         int n;
 665
 666         assert_se(parse_nice("0", &n) >= 0 && n == 0);
 667         assert_se(parse_nice("+0", &n) >= 0 && n == 0);
 668         assert_se(parse_nice("-1", &n) >= 0 && n == -1);
 669         assert_se(parse_nice("-2", &n) >= 0 && n == -2);
 670         assert_se(parse_nice("1", &n) >= 0 && n == 1);
 671         assert_se(parse_nice("2", &n) >= 0 && n == 2);
 672         assert_se(parse_nice("+1", &n) >= 0 && n == 1);
 673         assert_se(parse_nice("+2", &n) >= 0 && n == 2);
 674         assert_se(parse_nice("-20", &n) >= 0 && n == -20);
 675         assert_se(parse_nice("19", &n) >= 0 && n == 19);
 676         assert_se(parse_nice("+19", &n) >= 0 && n == 19);
 677
 678
 679         assert_se(parse_nice("", &n) == -EINVAL);
 680         assert_se(parse_nice("-", &n) == -EINVAL);
 681         assert_se(parse_nice("+", &n) == -EINVAL);
 682         assert_se(parse_nice("xx", &n) == -EINVAL);
 683         assert_se(parse_nice("-50", &n) == -ERANGE);
 684         assert_se(parse_nice("50", &n) == -ERANGE);
 685         assert_se(parse_nice("+50", &n) == -ERANGE);
 686         assert_se(parse_nice("-21", &n) == -ERANGE);
 687         assert_se(parse_nice("20", &n) == -ERANGE);
 688         assert_se(parse_nice("+20", &n) == -ERANGE);
 689 }
 690
 691 static void test_parse_dev(void) {
 692         dev_t dev;
 693
 694         assert_se(parse_dev("", &dev) == -EINVAL);
 695         assert_se(parse_dev("junk", &dev) == -EINVAL);
 696         assert_se(parse_dev("0", &dev) == -EINVAL);
 697         assert_se(parse_dev("5", &dev) == -EINVAL);
 698         assert_se(parse_dev("5:", &dev) == -EINVAL);
 699         assert_se(parse_dev(":5", &dev) == -EINVAL);
 700 #if SIZEOF_DEV_T < 8
 701         assert_se(parse_dev("4294967295:4294967295", &dev) == -EINVAL);
 702 #endif
 703         assert_se(parse_dev("8:11", &dev) >= 0 && major(dev) == 8 && minor(dev) == 11);
 704 }
 705
 706 static void test_parse_errno(void) {
 707         assert_se(parse_errno("EILSEQ") == EILSEQ);
 708         assert_se(parse_errno("EINVAL") == EINVAL);
 709         assert_se(parse_errno("0") == 0);
 710         assert_se(parse_errno("1") == 1);
 711         assert_se(parse_errno("4095") == 4095);
 712
 713         assert_se(parse_errno("-1") == -ERANGE);
 714         assert_se(parse_errno("-3") == -ERANGE);
 715         assert_se(parse_errno("4096") == -ERANGE);
 716
 717         assert_se(parse_errno("") == -EINVAL);
 718         assert_se(parse_errno("12.3") == -EINVAL);
 719         assert_se(parse_errno("123junk") == -EINVAL);
 720         assert_se(parse_errno("junk123") == -EINVAL);
 721         assert_se(parse_errno("255EILSEQ") == -EINVAL);
 722         assert_se(parse_errno("EINVAL12") == -EINVAL);
 723         assert_se(parse_errno("-EINVAL") == -EINVAL);
 724         assert_se(parse_errno("EINVALaaa") == -EINVAL);
 725 }
 726
 727 static void test_parse_syscall_and_errno(void) {
 728         _cleanup_free_ char *n = NULL;
 729         int e;
 730
 731         assert_se(parse_syscall_and_errno("uname:EILSEQ", &n, &e) >= 0);
 732         assert_se(streq(n, "uname"));
 733         assert_se(e == errno_from_name("EILSEQ") && e >= 0);
 734         n = mfree(n);
 735
 736         assert_se(parse_syscall_and_errno("uname:EINVAL", &n, &e) >= 0);
 737         assert_se(streq(n, "uname"));
 738         assert_se(e == errno_from_name("EINVAL") && e >= 0);
 739         n = mfree(n);
 740
 741         assert_se(parse_syscall_and_errno("@sync:4095", &n, &e) >= 0);
 742         assert_se(streq(n, "@sync"));
 743         assert_se(e == 4095);
 744         n = mfree(n);
 745
 746         /* If errno is omitted, then e is set to -1 */
 747         assert_se(parse_syscall_and_errno("mount", &n, &e) >= 0);
 748         assert_se(streq(n, "mount"));
 749         assert_se(e == -1);
 750         n = mfree(n);
 751
 752         /* parse_syscall_and_errno() does not check the syscall name is valid or not. */
 753         assert_se(parse_syscall_and_errno("hoge:255", &n, &e) >= 0);
 754         assert_se(streq(n, "hoge"));
 755         assert_se(e == 255);
 756         n = mfree(n);
 757
 758         /* The function checks the syscall name is empty or not. */
 759         assert_se(parse_syscall_and_errno("", &n, &e) == -EINVAL);
 760         assert_se(parse_syscall_and_errno(":255", &n, &e) == -EINVAL);
 761
 762         /* errno must be a valid errno name or number between 0 and ERRNO_MAX == 4095 */
 763         assert_se(parse_syscall_and_errno("hoge:4096", &n, &e) == -ERANGE);
 764         assert_se(parse_syscall_and_errno("hoge:-3", &n, &e) == -ERANGE);
 765         assert_se(parse_syscall_and_errno("hoge:12.3", &n, &e) == -EINVAL);
 766         assert_se(parse_syscall_and_errno("hoge:123junk", &n, &e) == -EINVAL);
 767         assert_se(parse_syscall_and_errno("hoge:junk123", &n, &e) == -EINVAL);
 768         assert_se(parse_syscall_and_errno("hoge:255:EILSEQ", &n, &e) == -EINVAL);
 769         assert_se(parse_syscall_and_errno("hoge:-EINVAL", &n, &e) == -EINVAL);
 770         assert_se(parse_syscall_and_errno("hoge:EINVALaaa", &n, &e) == -EINVAL);
 771         assert_se(parse_syscall_and_errno("hoge:", &n, &e) == -EINVAL);
 772 }
 773
 774 int main(int argc, char *argv[]) {
 775         log_parse_environment();
 776         log_open();
 777
 778         test_parse_boolean();
 779         test_parse_pid();
 780         test_parse_mode();
 781         test_parse_size();
 782         test_parse_range();
 783         test_safe_atolli();
 784         test_safe_atou16();
 785         test_safe_atoi16();
 786         test_safe_atoux16();
 787         test_safe_atou64();
 788         test_safe_atoi64();
 789         test_safe_atod();
 790         test_parse_percent();
 791         test_parse_percent_unbounded();
 792         test_parse_nice();
 793         test_parse_dev();
 794         test_parse_errno();
 795         test_parse_syscall_and_errno();
 796
 797         return 0;
 798 }