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 #if 0 /// UNNEEDED by elogind
 177 static void test_parse_range(void) {
 178         unsigned lower, upper;
 179
 180         /* Successful cases */
 181         assert_se(parse_range("111", &lower, &upper) == 0);
 182         assert_se(lower == 111);
 183         assert_se(upper == 111);
 184
 185         assert_se(parse_range("111-123", &lower, &upper) == 0);
 186         assert_se(lower == 111);
 187         assert_se(upper == 123);
 188
 189         assert_se(parse_range("123-111", &lower, &upper) == 0);
 190         assert_se(lower == 123);
 191         assert_se(upper == 111);
 192
 193         assert_se(parse_range("123-123", &lower, &upper) == 0);
 194         assert_se(lower == 123);
 195         assert_se(upper == 123);
 196
 197         assert_se(parse_range("0", &lower, &upper) == 0);
 198         assert_se(lower == 0);
 199         assert_se(upper == 0);
 200
 201         assert_se(parse_range("0-15", &lower, &upper) == 0);
 202         assert_se(lower == 0);
 203         assert_se(upper == 15);
 204
 205         assert_se(parse_range("15-0", &lower, &upper) == 0);
 206         assert_se(lower == 15);
 207         assert_se(upper == 0);
 208
 209         assert_se(parse_range("128-65535", &lower, &upper) == 0);
 210         assert_se(lower == 128);
 211         assert_se(upper == 65535);
 212
 213         assert_se(parse_range("1024-4294967295", &lower, &upper) == 0);
 214         assert_se(lower == 1024);
 215         assert_se(upper == 4294967295);
 216
 217         /* Leading whitespace is acceptable */
 218         assert_se(parse_range(" 111", &lower, &upper) == 0);
 219         assert_se(lower == 111);
 220         assert_se(upper == 111);
 221
 222         assert_se(parse_range(" 111-123", &lower, &upper) == 0);
 223         assert_se(lower == 111);
 224         assert_se(upper == 123);
 225
 226         assert_se(parse_range("111- 123", &lower, &upper) == 0);
 227         assert_se(lower == 111);
 228         assert_se(upper == 123);
 229
 230         assert_se(parse_range("\t111-\t123", &lower, &upper) == 0);
 231         assert_se(lower == 111);
 232         assert_se(upper == 123);
 233
 234         assert_se(parse_range(" \t 111- \t 123", &lower, &upper) == 0);
 235         assert_se(lower == 111);
 236         assert_se(upper == 123);
 237
 238         /* Error cases, make sure they fail as expected */
 239         lower = upper = 9999;
 240         assert_se(parse_range("111garbage", &lower, &upper) == -EINVAL);
 241         assert_se(lower == 9999);
 242         assert_se(upper == 9999);
 243
 244         assert_se(parse_range("garbage111", &lower, &upper) == -EINVAL);
 245         assert_se(lower == 9999);
 246         assert_se(upper == 9999);
 247
 248         assert_se(parse_range("garbage", &lower, &upper) == -EINVAL);
 249         assert_se(lower == 9999);
 250         assert_se(upper == 9999);
 251
 252         assert_se(parse_range("111-123garbage", &lower, &upper) == -EINVAL);
 253         assert_se(lower == 9999);
 254         assert_se(upper == 9999);
 255
 256         assert_se(parse_range("111garbage-123", &lower, &upper) == -EINVAL);
 257         assert_se(lower == 9999);
 258         assert_se(upper == 9999);
 259
 260         /* Empty string */
 261         lower = upper = 9999;
 262         assert_se(parse_range("", &lower, &upper) == -EINVAL);
 263         assert_se(lower == 9999);
 264         assert_se(upper == 9999);
 265
 266         /* 111--123 will pass -123 to safe_atou which returns -ERANGE for negative */
 267         assert_se(parse_range("111--123", &lower, &upper) == -ERANGE);
 268         assert_se(lower == 9999);
 269         assert_se(upper == 9999);
 270
 271         assert_se(parse_range("-123", &lower, &upper) == -EINVAL);
 272         assert_se(lower == 9999);
 273         assert_se(upper == 9999);
 274
 275         assert_se(parse_range("-111-123", &lower, &upper) == -EINVAL);
 276         assert_se(lower == 9999);
 277         assert_se(upper == 9999);
 278
 279         assert_se(parse_range("111-123-", &lower, &upper) == -EINVAL);
 280         assert_se(lower == 9999);
 281         assert_se(upper == 9999);
 282
 283         assert_se(parse_range("111.4-123", &lower, &upper) == -EINVAL);
 284         assert_se(lower == 9999);
 285         assert_se(upper == 9999);
 286
 287         assert_se(parse_range("111-123.4", &lower, &upper) == -EINVAL);
 288         assert_se(lower == 9999);
 289         assert_se(upper == 9999);
 290
 291         assert_se(parse_range("111,4-123", &lower, &upper) == -EINVAL);
 292         assert_se(lower == 9999);
 293         assert_se(upper == 9999);
 294
 295         assert_se(parse_range("111-123,4", &lower, &upper) == -EINVAL);
 296         assert_se(lower == 9999);
 297         assert_se(upper == 9999);
 298
 299         /* Error on trailing dash */
 300         assert_se(parse_range("111-", &lower, &upper) == -EINVAL);
 301         assert_se(lower == 9999);
 302         assert_se(upper == 9999);
 303
 304         assert_se(parse_range("111-123-", &lower, &upper) == -EINVAL);
 305         assert_se(lower == 9999);
 306         assert_se(upper == 9999);
 307
 308         assert_se(parse_range("111--", &lower, &upper) == -EINVAL);
 309         assert_se(lower == 9999);
 310         assert_se(upper == 9999);
 311
 312         assert_se(parse_range("111- ", &lower, &upper) == -EINVAL);
 313         assert_se(lower == 9999);
 314         assert_se(upper == 9999);
 315
 316         /* Whitespace is not a separator */
 317         assert_se(parse_range("111 123", &lower, &upper) == -EINVAL);
 318         assert_se(lower == 9999);
 319         assert_se(upper == 9999);
 320
 321         assert_se(parse_range("111\t123", &lower, &upper) == -EINVAL);
 322         assert_se(lower == 9999);
 323         assert_se(upper == 9999);
 324
 325         assert_se(parse_range("111 \t 123", &lower, &upper) == -EINVAL);
 326         assert_se(lower == 9999);
 327         assert_se(upper == 9999);
 328
 329         /* Trailing whitespace is invalid (from safe_atou) */
 330         assert_se(parse_range("111 ", &lower, &upper) == -EINVAL);
 331         assert_se(lower == 9999);
 332         assert_se(upper == 9999);
 333
 334         assert_se(parse_range("111-123 ", &lower, &upper) == -EINVAL);
 335         assert_se(lower == 9999);
 336         assert_se(upper == 9999);
 337
 338         assert_se(parse_range("111 -123", &lower, &upper) == -EINVAL);
 339         assert_se(lower == 9999);
 340         assert_se(upper == 9999);
 341
 342         assert_se(parse_range("111 -123 ", &lower, &upper) == -EINVAL);
 343         assert_se(lower == 9999);
 344         assert_se(upper == 9999);
 345
 346         assert_se(parse_range("111\t-123\t", &lower, &upper) == -EINVAL);
 347         assert_se(lower == 9999);
 348         assert_se(upper == 9999);
 349
 350         assert_se(parse_range("111 \t -123 \t ", &lower, &upper) == -EINVAL);
 351         assert_se(lower == 9999);
 352         assert_se(upper == 9999);
 353
 354         /* Out of the "unsigned" range, this is 1<<64 */
 355         assert_se(parse_range("0-18446744073709551616", &lower, &upper) == -ERANGE);
 356         assert_se(lower == 9999);
 357         assert_se(upper == 9999);
 358 }
 359 #endif // 0
 360
 361 static void test_safe_atolli(void) {
 362         int r;
 363         long long l;
 364
 365         r = safe_atolli("12345", &l);
 366         assert_se(r == 0);
 367         assert_se(l == 12345);
 368
 369         r = safe_atolli("  12345", &l);
 370         assert_se(r == 0);
 371         assert_se(l == 12345);
 372
 373         r = safe_atolli("-12345", &l);
 374         assert_se(r == 0);
 375         assert_se(l == -12345);
 376
 377         r = safe_atolli("  -12345", &l);
 378         assert_se(r == 0);
 379         assert_se(l == -12345);
 380
 381         r = safe_atolli("12345678901234567890", &l);
 382         assert_se(r == -ERANGE);
 383
 384         r = safe_atolli("-12345678901234567890", &l);
 385         assert_se(r == -ERANGE);
 386
 387         r = safe_atolli("junk", &l);
 388         assert_se(r == -EINVAL);
 389
 390         r = safe_atolli("123x", &l);
 391         assert_se(r == -EINVAL);
 392
 393         r = safe_atolli("12.3", &l);
 394         assert_se(r == -EINVAL);
 395
 396         r = safe_atolli("", &l);
 397         assert_se(r == -EINVAL);
 398 }
 399
 400 static void test_safe_atou16(void) {
 401         int r;
 402         uint16_t l;
 403
 404         r = safe_atou16("12345", &l);
 405         assert_se(r == 0);
 406         assert_se(l == 12345);
 407
 408         r = safe_atou16("  12345", &l);
 409         assert_se(r == 0);
 410         assert_se(l == 12345);
 411
 412         r = safe_atou16("123456", &l);
 413         assert_se(r == -ERANGE);
 414
 415         r = safe_atou16("-1", &l);
 416         assert_se(r == -ERANGE);
 417
 418         r = safe_atou16("  -1", &l);
 419         assert_se(r == -ERANGE);
 420
 421         r = safe_atou16("junk", &l);
 422         assert_se(r == -EINVAL);
 423
 424         r = safe_atou16("123x", &l);
 425         assert_se(r == -EINVAL);
 426
 427         r = safe_atou16("12.3", &l);
 428         assert_se(r == -EINVAL);
 429
 430         r = safe_atou16("", &l);
 431         assert_se(r == -EINVAL);
 432 }
 433
 434 static void test_safe_atoi16(void) {
 435         int r;
 436         int16_t l;
 437
 438         r = safe_atoi16("-12345", &l);
 439         assert_se(r == 0);
 440         assert_se(l == -12345);
 441
 442         r = safe_atoi16("  -12345", &l);
 443         assert_se(r == 0);
 444         assert_se(l == -12345);
 445
 446         r = safe_atoi16("32767", &l);
 447         assert_se(r == 0);
 448         assert_se(l == 32767);
 449
 450         r = safe_atoi16("  32767", &l);
 451         assert_se(r == 0);
 452         assert_se(l == 32767);
 453
 454         r = safe_atoi16("36536", &l);
 455         assert_se(r == -ERANGE);
 456
 457         r = safe_atoi16("-32769", &l);
 458         assert_se(r == -ERANGE);
 459
 460         r = safe_atoi16("junk", &l);
 461         assert_se(r == -EINVAL);
 462
 463         r = safe_atoi16("123x", &l);
 464         assert_se(r == -EINVAL);
 465
 466         r = safe_atoi16("12.3", &l);
 467         assert_se(r == -EINVAL);
 468
 469         r = safe_atoi16("", &l);
 470         assert_se(r == -EINVAL);
 471 }
 472
 473 static void test_safe_atoux16(void) {
 474         int r;
 475         uint16_t l;
 476
 477         r = safe_atoux16("1234", &l);
 478         assert_se(r == 0);
 479         assert_se(l == 0x1234);
 480
 481         r = safe_atoux16("abcd", &l);
 482         assert_se(r == 0);
 483         assert_se(l == 0xabcd);
 484
 485         r = safe_atoux16("  1234", &l);
 486         assert_se(r == 0);
 487         assert_se(l == 0x1234);
 488
 489         r = safe_atoux16("12345", &l);
 490         assert_se(r == -ERANGE);
 491
 492         r = safe_atoux16("-1", &l);
 493         assert_se(r == -ERANGE);
 494
 495         r = safe_atoux16("  -1", &l);
 496         assert_se(r == -ERANGE);
 497
 498         r = safe_atoux16("junk", &l);
 499         assert_se(r == -EINVAL);
 500
 501         r = safe_atoux16("123x", &l);
 502         assert_se(r == -EINVAL);
 503
 504         r = safe_atoux16("12.3", &l);
 505         assert_se(r == -EINVAL);
 506
 507         r = safe_atoux16("", &l);
 508         assert_se(r == -EINVAL);
 509 }
 510
 511 static void test_safe_atou64(void) {
 512         int r;
 513         uint64_t l;
 514
 515         r = safe_atou64("12345", &l);
 516         assert_se(r == 0);
 517         assert_se(l == 12345);
 518
 519         r = safe_atou64("  12345", &l);
 520         assert_se(r == 0);
 521         assert_se(l == 12345);
 522
 523         r = safe_atou64("18446744073709551617", &l);
 524         assert_se(r == -ERANGE);
 525
 526         r = safe_atou64("-1", &l);
 527         assert_se(r == -ERANGE);
 528
 529         r = safe_atou64("  -1", &l);
 530         assert_se(r == -ERANGE);
 531
 532         r = safe_atou64("junk", &l);
 533         assert_se(r == -EINVAL);
 534
 535         r = safe_atou64("123x", &l);
 536         assert_se(r == -EINVAL);
 537
 538         r = safe_atou64("12.3", &l);
 539         assert_se(r == -EINVAL);
 540
 541         r = safe_atou64("", &l);
 542         assert_se(r == -EINVAL);
 543 }
 544
 545 static void test_safe_atoi64(void) {
 546         int r;
 547         int64_t l;
 548
 549         r = safe_atoi64("-12345", &l);
 550         assert_se(r == 0);
 551         assert_se(l == -12345);
 552
 553         r = safe_atoi64("  -12345", &l);
 554         assert_se(r == 0);
 555         assert_se(l == -12345);
 556
 557         r = safe_atoi64("32767", &l);
 558         assert_se(r == 0);
 559         assert_se(l == 32767);
 560
 561         r = safe_atoi64("  32767", &l);
 562         assert_se(r == 0);
 563         assert_se(l == 32767);
 564
 565         r = safe_atoi64("9223372036854775813", &l);
 566         assert_se(r == -ERANGE);
 567
 568         r = safe_atoi64("-9223372036854775813", &l);
 569         assert_se(r == -ERANGE);
 570
 571         r = safe_atoi64("junk", &l);
 572         assert_se(r == -EINVAL);
 573
 574         r = safe_atoi64("123x", &l);
 575         assert_se(r == -EINVAL);
 576
 577         r = safe_atoi64("12.3", &l);
 578         assert_se(r == -EINVAL);
 579
 580         r = safe_atoi64("", &l);
 581         assert_se(r == -EINVAL);
 582 }
 583
 584 static void test_safe_atod(void) {
 585         int r;
 586         double d;
 587         char *e;
 588
 589         r = safe_atod("junk", &d);
 590         assert_se(r == -EINVAL);
 591
 592         r = safe_atod("0.2244", &d);
 593         assert_se(r == 0);
 594         assert_se(fabs(d - 0.2244) < 0.000001);
 595
 596         r = safe_atod("0,5", &d);
 597         assert_se(r == -EINVAL);
 598
 599         errno = 0;
 600         strtod("0,5", &e);
 601         assert_se(*e == ',');
 602
 603         r = safe_atod("", &d);
 604         assert_se(r == -EINVAL);
 605
 606         /* Check if this really is locale independent */
 607         if (setlocale(LC_NUMERIC, "de_DE.utf8")) {
 608
 609                 r = safe_atod("0.2244", &d);
 610                 assert_se(r == 0);
 611                 assert_se(fabs(d - 0.2244) < 0.000001);
 612
 613                 r = safe_atod("0,5", &d);
 614                 assert_se(r == -EINVAL);
 615
 616                 errno = 0;
 617 /// elogind supports musl_libc, and their strtod doesn't seem to use the set locale.
 618 #if defined(__GLIBC__)
 619                 assert_se(fabs(strtod("0,5", &e) - 0.5) < 0.00001);
 620 #endif // __GLIBC__
 621
 622                 r = safe_atod("", &d);
 623                 assert_se(r == -EINVAL);
 624         }
 625
 626         /* And check again, reset */
 627         assert_se(setlocale(LC_NUMERIC, "C"));
 628
 629         r = safe_atod("0.2244", &d);
 630         assert_se(r == 0);
 631         assert_se(fabs(d - 0.2244) < 0.000001);
 632
 633         r = safe_atod("0,5", &d);
 634         assert_se(r == -EINVAL);
 635
 636         errno = 0;
 637         strtod("0,5", &e);
 638         assert_se(*e == ',');
 639
 640         r = safe_atod("", &d);
 641         assert_se(r == -EINVAL);
 642 }
 643
 644 static void test_parse_percent(void) {
 645         assert_se(parse_percent("") == -EINVAL);
 646         assert_se(parse_percent("foo") == -EINVAL);
 647         assert_se(parse_percent("0") == -EINVAL);
 648         assert_se(parse_percent("50") == -EINVAL);
 649         assert_se(parse_percent("100") == -EINVAL);
 650         assert_se(parse_percent("-1") == -EINVAL);
 651         assert_se(parse_percent("0%") == 0);
 652         assert_se(parse_percent("55%") == 55);
 653         assert_se(parse_percent("100%") == 100);
 654         assert_se(parse_percent("-7%") == -ERANGE);
 655         assert_se(parse_percent("107%") == -ERANGE);
 656         assert_se(parse_percent("%") == -EINVAL);
 657         assert_se(parse_percent("%%") == -EINVAL);
 658         assert_se(parse_percent("%1") == -EINVAL);
 659         assert_se(parse_percent("1%%") == -EINVAL);
 660         assert_se(parse_percent("3.2%") == -EINVAL);
 661 }
 662
 663 static void test_parse_percent_unbounded(void) {
 664         assert_se(parse_percent_unbounded("101%") == 101);
 665         assert_se(parse_percent_unbounded("400%") == 400);
 666 }
 667
 668 #if 0 /// UNNEEDED by elogind
 669 static void test_parse_nice(void) {
 670         int n;
 671
 672         assert_se(parse_nice("0", &n) >= 0 && n == 0);
 673         assert_se(parse_nice("+0", &n) >= 0 && n == 0);
 674         assert_se(parse_nice("-1", &n) >= 0 && n == -1);
 675         assert_se(parse_nice("-2", &n) >= 0 && n == -2);
 676         assert_se(parse_nice("1", &n) >= 0 && n == 1);
 677         assert_se(parse_nice("2", &n) >= 0 && n == 2);
 678         assert_se(parse_nice("+1", &n) >= 0 && n == 1);
 679         assert_se(parse_nice("+2", &n) >= 0 && n == 2);
 680         assert_se(parse_nice("-20", &n) >= 0 && n == -20);
 681         assert_se(parse_nice("19", &n) >= 0 && n == 19);
 682         assert_se(parse_nice("+19", &n) >= 0 && n == 19);
 683
 684
 685         assert_se(parse_nice("", &n) == -EINVAL);
 686         assert_se(parse_nice("-", &n) == -EINVAL);
 687         assert_se(parse_nice("+", &n) == -EINVAL);
 688         assert_se(parse_nice("xx", &n) == -EINVAL);
 689         assert_se(parse_nice("-50", &n) == -ERANGE);
 690         assert_se(parse_nice("50", &n) == -ERANGE);
 691         assert_se(parse_nice("+50", &n) == -ERANGE);
 692         assert_se(parse_nice("-21", &n) == -ERANGE);
 693         assert_se(parse_nice("20", &n) == -ERANGE);
 694         assert_se(parse_nice("+20", &n) == -ERANGE);
 695 }
 696 #endif // 0
 697
 698 static void test_parse_dev(void) {
 699         dev_t dev;
 700
 701         assert_se(parse_dev("", &dev) == -EINVAL);
 702         assert_se(parse_dev("junk", &dev) == -EINVAL);
 703         assert_se(parse_dev("0", &dev) == -EINVAL);
 704         assert_se(parse_dev("5", &dev) == -EINVAL);
 705         assert_se(parse_dev("5:", &dev) == -EINVAL);
 706         assert_se(parse_dev(":5", &dev) == -EINVAL);
 707 #if SIZEOF_DEV_T < 8
 708         assert_se(parse_dev("4294967295:4294967295", &dev) == -EINVAL);
 709 #endif
 710         assert_se(parse_dev("8:11", &dev) >= 0 && major(dev) == 8 && minor(dev) == 11);
 711 }
 712
 713 static void test_parse_errno(void) {
 714         assert_se(parse_errno("EILSEQ") == EILSEQ);
 715         assert_se(parse_errno("EINVAL") == EINVAL);
 716         assert_se(parse_errno("0") == 0);
 717         assert_se(parse_errno("1") == 1);
 718         assert_se(parse_errno("4095") == 4095);
 719
 720         assert_se(parse_errno("-1") == -ERANGE);
 721         assert_se(parse_errno("-3") == -ERANGE);
 722         assert_se(parse_errno("4096") == -ERANGE);
 723
 724         assert_se(parse_errno("") == -EINVAL);
 725         assert_se(parse_errno("12.3") == -EINVAL);
 726         assert_se(parse_errno("123junk") == -EINVAL);
 727         assert_se(parse_errno("junk123") == -EINVAL);
 728         assert_se(parse_errno("255EILSEQ") == -EINVAL);
 729         assert_se(parse_errno("EINVAL12") == -EINVAL);
 730         assert_se(parse_errno("-EINVAL") == -EINVAL);
 731         assert_se(parse_errno("EINVALaaa") == -EINVAL);
 732 }
 733
 734 static void test_parse_syscall_and_errno(void) {
 735         _cleanup_free_ char *n = NULL;
 736         int e;
 737
 738         assert_se(parse_syscall_and_errno("uname:EILSEQ", &n, &e) >= 0);
 739         assert_se(streq(n, "uname"));
 740         assert_se(e == errno_from_name("EILSEQ") && e >= 0);
 741         n = mfree(n);
 742
 743         assert_se(parse_syscall_and_errno("uname:EINVAL", &n, &e) >= 0);
 744         assert_se(streq(n, "uname"));
 745         assert_se(e == errno_from_name("EINVAL") && e >= 0);
 746         n = mfree(n);
 747
 748         assert_se(parse_syscall_and_errno("@sync:4095", &n, &e) >= 0);
 749         assert_se(streq(n, "@sync"));
 750         assert_se(e == 4095);
 751         n = mfree(n);
 752
 753         /* If errno is omitted, then e is set to -1 */
 754         assert_se(parse_syscall_and_errno("mount", &n, &e) >= 0);
 755         assert_se(streq(n, "mount"));
 756         assert_se(e == -1);
 757         n = mfree(n);
 758
 759         /* parse_syscall_and_errno() does not check the syscall name is valid or not. */
 760         assert_se(parse_syscall_and_errno("hoge:255", &n, &e) >= 0);
 761         assert_se(streq(n, "hoge"));
 762         assert_se(e == 255);
 763         n = mfree(n);
 764
 765         /* The function checks the syscall name is empty or not. */
 766         assert_se(parse_syscall_and_errno("", &n, &e) == -EINVAL);
 767         assert_se(parse_syscall_and_errno(":255", &n, &e) == -EINVAL);
 768
 769         /* errno must be a valid errno name or number between 0 and ERRNO_MAX == 4095 */
 770         assert_se(parse_syscall_and_errno("hoge:4096", &n, &e) == -ERANGE);
 771         assert_se(parse_syscall_and_errno("hoge:-3", &n, &e) == -ERANGE);
 772         assert_se(parse_syscall_and_errno("hoge:12.3", &n, &e) == -EINVAL);
 773         assert_se(parse_syscall_and_errno("hoge:123junk", &n, &e) == -EINVAL);
 774         assert_se(parse_syscall_and_errno("hoge:junk123", &n, &e) == -EINVAL);
 775         assert_se(parse_syscall_and_errno("hoge:255:EILSEQ", &n, &e) == -EINVAL);
 776         assert_se(parse_syscall_and_errno("hoge:-EINVAL", &n, &e) == -EINVAL);
 777         assert_se(parse_syscall_and_errno("hoge:EINVALaaa", &n, &e) == -EINVAL);
 778         assert_se(parse_syscall_and_errno("hoge:", &n, &e) == -EINVAL);
 779 }
 780
 781 int main(int argc, char *argv[]) {
 782         log_parse_environment();
 783         log_open();
 784
 785         test_parse_boolean();
 786         test_parse_pid();
 787         test_parse_mode();
 788         test_parse_size();
 789 #if 0 /// UNNEEDED by elogind
 790         test_parse_range();
 791 #endif // 0
 792         test_safe_atolli();
 793         test_safe_atou16();
 794         test_safe_atoi16();
 795         test_safe_atoux16();
 796         test_safe_atou64();
 797         test_safe_atoi64();
 798         test_safe_atod();
 799         test_parse_percent();
 800         test_parse_percent_unbounded();
 801 #if 0 /// UNNEEDED by elogind
 802         test_parse_nice();
 803 #endif // 0
 804         test_parse_dev();
 805         test_parse_errno();
 806         test_parse_syscall_and_errno();
 807
 808         return 0;
 809 }