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
  84 static void test_parse_mode(void) {
  85         mode_t m;
  86
  87         assert_se(parse_mode("-1", &m) < 0);
  88         assert_se(parse_mode("", &m) < 0);
  89         assert_se(parse_mode("888", &m) < 0);
  90         assert_se(parse_mode("77777", &m) < 0);
  91
  92         assert_se(parse_mode("544", &m) >= 0 && m == 0544);
  93         assert_se(parse_mode("777", &m) >= 0 && m == 0777);
  94         assert_se(parse_mode("7777", &m) >= 0 && m == 07777);
  95         assert_se(parse_mode("0", &m) >= 0 && m == 0);
  96 }
  97
  98 static void test_parse_size(void) {
  99         uint64_t bytes;
 100
 101         assert_se(parse_size("111", 1024, &bytes) == 0);
 102         assert_se(bytes == 111);
 103
 104         assert_se(parse_size("111.4", 1024, &bytes) == 0);
 105         assert_se(bytes == 111);
 106
 107         assert_se(parse_size(" 112 B", 1024, &bytes) == 0);
 108         assert_se(bytes == 112);
 109
 110         assert_se(parse_size(" 112.6 B", 1024, &bytes) == 0);
 111         assert_se(bytes == 112);
 112
 113         assert_se(parse_size("3.5 K", 1024, &bytes) == 0);
 114         assert_se(bytes == 3*1024 + 512);
 115
 116         assert_se(parse_size("3. K", 1024, &bytes) == 0);
 117         assert_se(bytes == 3*1024);
 118
 119         assert_se(parse_size("3.0 K", 1024, &bytes) == 0);
 120         assert_se(bytes == 3*1024);
 121
 122         assert_se(parse_size("3. 0 K", 1024, &bytes) == -EINVAL);
 123
 124         assert_se(parse_size(" 4 M 11.5K", 1024, &bytes) == 0);
 125         assert_se(bytes == 4*1024*1024 + 11 * 1024 + 512);
 126
 127         assert_se(parse_size("3B3.5G", 1024, &bytes) == -EINVAL);
 128
 129         assert_se(parse_size("3.5G3B", 1024, &bytes) == 0);
 130         assert_se(bytes == 3ULL*1024*1024*1024 + 512*1024*1024 + 3);
 131
 132         assert_se(parse_size("3.5G 4B", 1024, &bytes) == 0);
 133         assert_se(bytes == 3ULL*1024*1024*1024 + 512*1024*1024 + 4);
 134
 135         assert_se(parse_size("3B3G4T", 1024, &bytes) == -EINVAL);
 136
 137         assert_se(parse_size("4T3G3B", 1024, &bytes) == 0);
 138         assert_se(bytes == (4ULL*1024 + 3)*1024*1024*1024 + 3);
 139
 140         assert_se(parse_size(" 4 T 3 G 3 B", 1024, &bytes) == 0);
 141         assert_se(bytes == (4ULL*1024 + 3)*1024*1024*1024 + 3);
 142
 143         assert_se(parse_size("12P", 1024, &bytes) == 0);
 144         assert_se(bytes == 12ULL * 1024*1024*1024*1024*1024);
 145
 146         assert_se(parse_size("12P12P", 1024, &bytes) == -EINVAL);
 147
 148         assert_se(parse_size("3E 2P", 1024, &bytes) == 0);
 149         assert_se(bytes == (3 * 1024 + 2ULL) * 1024*1024*1024*1024*1024);
 150
 151         assert_se(parse_size("12X", 1024, &bytes) == -EINVAL);
 152
 153         assert_se(parse_size("12.5X", 1024, &bytes) == -EINVAL);
 154
 155         assert_se(parse_size("12.5e3", 1024, &bytes) == -EINVAL);
 156
 157         assert_se(parse_size("1024E", 1024, &bytes) == -ERANGE);
 158         assert_se(parse_size("-1", 1024, &bytes) == -ERANGE);
 159         assert_se(parse_size("-1024E", 1024, &bytes) == -ERANGE);
 160
 161         assert_se(parse_size("-1024P", 1024, &bytes) == -ERANGE);
 162
 163         assert_se(parse_size("-10B 20K", 1024, &bytes) == -ERANGE);
 164 }
 165
 166 #if 0 /// UNNEEDED by elogind
 167 static void test_parse_range(void) {
 168         unsigned lower, upper;
 169
 170         /* Successful cases */
 171         assert_se(parse_range("111", &lower, &upper) == 0);
 172         assert_se(lower == 111);
 173         assert_se(upper == 111);
 174
 175         assert_se(parse_range("111-123", &lower, &upper) == 0);
 176         assert_se(lower == 111);
 177         assert_se(upper == 123);
 178
 179         assert_se(parse_range("123-111", &lower, &upper) == 0);
 180         assert_se(lower == 123);
 181         assert_se(upper == 111);
 182
 183         assert_se(parse_range("123-123", &lower, &upper) == 0);
 184         assert_se(lower == 123);
 185         assert_se(upper == 123);
 186
 187         assert_se(parse_range("0", &lower, &upper) == 0);
 188         assert_se(lower == 0);
 189         assert_se(upper == 0);
 190
 191         assert_se(parse_range("0-15", &lower, &upper) == 0);
 192         assert_se(lower == 0);
 193         assert_se(upper == 15);
 194
 195         assert_se(parse_range("15-0", &lower, &upper) == 0);
 196         assert_se(lower == 15);
 197         assert_se(upper == 0);
 198
 199         assert_se(parse_range("128-65535", &lower, &upper) == 0);
 200         assert_se(lower == 128);
 201         assert_se(upper == 65535);
 202
 203         assert_se(parse_range("1024-4294967295", &lower, &upper) == 0);
 204         assert_se(lower == 1024);
 205         assert_se(upper == 4294967295);
 206
 207         /* Leading whitespace is acceptable */
 208         assert_se(parse_range(" 111", &lower, &upper) == 0);
 209         assert_se(lower == 111);
 210         assert_se(upper == 111);
 211
 212         assert_se(parse_range(" 111-123", &lower, &upper) == 0);
 213         assert_se(lower == 111);
 214         assert_se(upper == 123);
 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("\t111-\t123", &lower, &upper) == 0);
 221         assert_se(lower == 111);
 222         assert_se(upper == 123);
 223
 224         assert_se(parse_range(" \t 111- \t 123", &lower, &upper) == 0);
 225         assert_se(lower == 111);
 226         assert_se(upper == 123);
 227
 228         /* Error cases, make sure they fail as expected */
 229         lower = upper = 9999;
 230         assert_se(parse_range("111garbage", &lower, &upper) == -EINVAL);
 231         assert_se(lower == 9999);
 232         assert_se(upper == 9999);
 233
 234         assert_se(parse_range("garbage111", &lower, &upper) == -EINVAL);
 235         assert_se(lower == 9999);
 236         assert_se(upper == 9999);
 237
 238         assert_se(parse_range("garbage", &lower, &upper) == -EINVAL);
 239         assert_se(lower == 9999);
 240         assert_se(upper == 9999);
 241
 242         assert_se(parse_range("111-123garbage", &lower, &upper) == -EINVAL);
 243         assert_se(lower == 9999);
 244         assert_se(upper == 9999);
 245
 246         assert_se(parse_range("111garbage-123", &lower, &upper) == -EINVAL);
 247         assert_se(lower == 9999);
 248         assert_se(upper == 9999);
 249
 250         /* Empty string */
 251         lower = upper = 9999;
 252         assert_se(parse_range("", &lower, &upper) == -EINVAL);
 253         assert_se(lower == 9999);
 254         assert_se(upper == 9999);
 255
 256         /* 111--123 will pass -123 to safe_atou which returns -ERANGE for negative */
 257         assert_se(parse_range("111--123", &lower, &upper) == -ERANGE);
 258         assert_se(lower == 9999);
 259         assert_se(upper == 9999);
 260
 261         assert_se(parse_range("-111-123", &lower, &upper) == -EINVAL);
 262         assert_se(lower == 9999);
 263         assert_se(upper == 9999);
 264
 265         assert_se(parse_range("111-123-", &lower, &upper) == -EINVAL);
 266         assert_se(lower == 9999);
 267         assert_se(upper == 9999);
 268
 269         assert_se(parse_range("111.4-123", &lower, &upper) == -EINVAL);
 270         assert_se(lower == 9999);
 271         assert_se(upper == 9999);
 272
 273         assert_se(parse_range("111-123.4", &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         /* Error on trailing dash */
 286         assert_se(parse_range("111-", &lower, &upper) == -EINVAL);
 287         assert_se(lower == 9999);
 288         assert_se(upper == 9999);
 289
 290         assert_se(parse_range("111-123-", &lower, &upper) == -EINVAL);
 291         assert_se(lower == 9999);
 292         assert_se(upper == 9999);
 293
 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- ", &lower, &upper) == -EINVAL);
 299         assert_se(lower == 9999);
 300         assert_se(upper == 9999);
 301
 302         /* Whitespace is not a separator */
 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\t123", &lower, &upper) == -EINVAL);
 308         assert_se(lower == 9999);
 309         assert_se(upper == 9999);
 310
 311         assert_se(parse_range("111 \t 123", &lower, &upper) == -EINVAL);
 312         assert_se(lower == 9999);
 313         assert_se(upper == 9999);
 314
 315         /* Trailing whitespace is invalid (from safe_atou) */
 316         assert_se(parse_range("111 ", &lower, &upper) == -EINVAL);
 317         assert_se(lower == 9999);
 318         assert_se(upper == 9999);
 319
 320         assert_se(parse_range("111-123 ", &lower, &upper) == -EINVAL);
 321         assert_se(lower == 9999);
 322         assert_se(upper == 9999);
 323
 324         assert_se(parse_range("111 -123", &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\t-123\t", &lower, &upper) == -EINVAL);
 333         assert_se(lower == 9999);
 334         assert_se(upper == 9999);
 335
 336         assert_se(parse_range("111 \t -123 \t ", &lower, &upper) == -EINVAL);
 337         assert_se(lower == 9999);
 338         assert_se(upper == 9999);
 339
 340         /* Out of the "unsigned" range, this is 1<<64 */
 341         assert_se(parse_range("0-18446744073709551616", &lower, &upper) == -ERANGE);
 342         assert_se(lower == 9999);
 343         assert_se(upper == 9999);
 344 }
 345 #endif // 0
 346
 347 static void test_safe_atolli(void) {
 348         int r;
 349         long long l;
 350
 351         r = safe_atolli("12345", &l);
 352         assert_se(r == 0);
 353         assert_se(l == 12345);
 354
 355         r = safe_atolli("  12345", &l);
 356         assert_se(r == 0);
 357         assert_se(l == 12345);
 358
 359         r = safe_atolli("-12345", &l);
 360         assert_se(r == 0);
 361         assert_se(l == -12345);
 362
 363         r = safe_atolli("  -12345", &l);
 364         assert_se(r == 0);
 365         assert_se(l == -12345);
 366
 367         r = safe_atolli("12345678901234567890", &l);
 368         assert_se(r == -ERANGE);
 369
 370         r = safe_atolli("-12345678901234567890", &l);
 371         assert_se(r == -ERANGE);
 372
 373         r = safe_atolli("junk", &l);
 374         assert_se(r == -EINVAL);
 375 }
 376
 377 static void test_safe_atou16(void) {
 378         int r;
 379         uint16_t l;
 380
 381         r = safe_atou16("12345", &l);
 382         assert_se(r == 0);
 383         assert_se(l == 12345);
 384
 385         r = safe_atou16("  12345", &l);
 386         assert_se(r == 0);
 387         assert_se(l == 12345);
 388
 389         r = safe_atou16("123456", &l);
 390         assert_se(r == -ERANGE);
 391
 392         r = safe_atou16("-1", &l);
 393         assert_se(r == -ERANGE);
 394
 395         r = safe_atou16("  -1", &l);
 396         assert_se(r == -ERANGE);
 397
 398         r = safe_atou16("junk", &l);
 399         assert_se(r == -EINVAL);
 400
 401         r = safe_atou16("123x", &l);
 402         assert_se(r == -EINVAL);
 403 }
 404
 405 static void test_safe_atoi16(void) {
 406         int r;
 407         int16_t l;
 408
 409         r = safe_atoi16("-12345", &l);
 410         assert_se(r == 0);
 411         assert_se(l == -12345);
 412
 413         r = safe_atoi16("  -12345", &l);
 414         assert_se(r == 0);
 415         assert_se(l == -12345);
 416
 417         r = safe_atoi16("32767", &l);
 418         assert_se(r == 0);
 419         assert_se(l == 32767);
 420
 421         r = safe_atoi16("  32767", &l);
 422         assert_se(r == 0);
 423         assert_se(l == 32767);
 424
 425         r = safe_atoi16("36536", &l);
 426         assert_se(r == -ERANGE);
 427
 428         r = safe_atoi16("-32769", &l);
 429         assert_se(r == -ERANGE);
 430
 431         r = safe_atoi16("junk", &l);
 432         assert_se(r == -EINVAL);
 433
 434         r = safe_atoi16("123x", &l);
 435         assert_se(r == -EINVAL);
 436 }
 437
 438 static void test_safe_atou64(void) {
 439         int r;
 440         uint64_t l;
 441
 442         r = safe_atou64("12345", &l);
 443         assert_se(r == 0);
 444         assert_se(l == 12345);
 445
 446         r = safe_atou64("  12345", &l);
 447         assert_se(r == 0);
 448         assert_se(l == 12345);
 449
 450         r = safe_atou64("18446744073709551617", &l);
 451         assert_se(r == -ERANGE);
 452
 453         r = safe_atou64("-1", &l);
 454         assert_se(r == -ERANGE);
 455
 456         r = safe_atou64("  -1", &l);
 457         assert_se(r == -ERANGE);
 458
 459         r = safe_atou64("junk", &l);
 460         assert_se(r == -EINVAL);
 461
 462         r = safe_atou64("123x", &l);
 463         assert_se(r == -EINVAL);
 464 }
 465
 466 static void test_safe_atoi64(void) {
 467         int r;
 468         int64_t l;
 469
 470         r = safe_atoi64("-12345", &l);
 471         assert_se(r == 0);
 472         assert_se(l == -12345);
 473
 474         r = safe_atoi64("  -12345", &l);
 475         assert_se(r == 0);
 476         assert_se(l == -12345);
 477
 478         r = safe_atoi64("32767", &l);
 479         assert_se(r == 0);
 480         assert_se(l == 32767);
 481
 482         r = safe_atoi64("  32767", &l);
 483         assert_se(r == 0);
 484         assert_se(l == 32767);
 485
 486         r = safe_atoi64("9223372036854775813", &l);
 487         assert_se(r == -ERANGE);
 488
 489         r = safe_atoi64("-9223372036854775813", &l);
 490         assert_se(r == -ERANGE);
 491
 492         r = safe_atoi64("junk", &l);
 493         assert_se(r == -EINVAL);
 494
 495         r = safe_atoi64("123x", &l);
 496         assert_se(r == -EINVAL);
 497 }
 498
 499 static void test_safe_atod(void) {
 500         int r;
 501         double d;
 502         char *e;
 503
 504         r = safe_atod("junk", &d);
 505         assert_se(r == -EINVAL);
 506
 507         r = safe_atod("0.2244", &d);
 508         assert_se(r == 0);
 509         assert_se(fabs(d - 0.2244) < 0.000001);
 510
 511         r = safe_atod("0,5", &d);
 512         assert_se(r == -EINVAL);
 513
 514         errno = 0;
 515         strtod("0,5", &e);
 516         assert_se(*e == ',');
 517
 518         /* Check if this really is locale independent */
 519         if (setlocale(LC_NUMERIC, "de_DE.utf8")) {
 520
 521                 r = safe_atod("0.2244", &d);
 522                 assert_se(r == 0);
 523                 assert_se(fabs(d - 0.2244) < 0.000001);
 524
 525                 r = safe_atod("0,5", &d);
 526                 assert_se(r == -EINVAL);
 527
 528                 errno = 0;
 529                 assert_se(fabs(strtod("0,5", &e) - 0.5) < 0.00001);
 530         }
 531
 532         /* And check again, reset */
 533         assert_se(setlocale(LC_NUMERIC, "C"));
 534
 535         r = safe_atod("0.2244", &d);
 536         assert_se(r == 0);
 537         assert_se(fabs(d - 0.2244) < 0.000001);
 538
 539         r = safe_atod("0,5", &d);
 540         assert_se(r == -EINVAL);
 541
 542         errno = 0;
 543         strtod("0,5", &e);
 544         assert_se(*e == ',');
 545 }
 546
 547 static void test_parse_percent(void) {
 548         assert_se(parse_percent("") == -EINVAL);
 549         assert_se(parse_percent("foo") == -EINVAL);
 550         assert_se(parse_percent("0") == -EINVAL);
 551         assert_se(parse_percent("50") == -EINVAL);
 552         assert_se(parse_percent("100") == -EINVAL);
 553         assert_se(parse_percent("-1") == -EINVAL);
 554         assert_se(parse_percent("0%") == 0);
 555         assert_se(parse_percent("55%") == 55);
 556         assert_se(parse_percent("100%") == 100);
 557         assert_se(parse_percent("-7%") == -ERANGE);
 558         assert_se(parse_percent("107%") == -ERANGE);
 559         assert_se(parse_percent("%") == -EINVAL);
 560         assert_se(parse_percent("%%") == -EINVAL);
 561         assert_se(parse_percent("%1") == -EINVAL);
 562         assert_se(parse_percent("1%%") == -EINVAL);
 563 }
 564
 565 static void test_parse_percent_unbounded(void) {
 566         assert_se(parse_percent_unbounded("101%") == 101);
 567         assert_se(parse_percent_unbounded("400%") == 400);
 568 }
 569
 570 #if 0 /// UNNEEDED by elogind
 571 static void test_parse_nice(void) {
 572         int n;
 573
 574         assert_se(parse_nice("0", &n) >= 0 && n == 0);
 575         assert_se(parse_nice("+0", &n) >= 0 && n == 0);
 576         assert_se(parse_nice("-1", &n) >= 0 && n == -1);
 577         assert_se(parse_nice("-2", &n) >= 0 && n == -2);
 578         assert_se(parse_nice("1", &n) >= 0 && n == 1);
 579         assert_se(parse_nice("2", &n) >= 0 && n == 2);
 580         assert_se(parse_nice("+1", &n) >= 0 && n == 1);
 581         assert_se(parse_nice("+2", &n) >= 0 && n == 2);
 582         assert_se(parse_nice("-20", &n) >= 0 && n == -20);
 583         assert_se(parse_nice("19", &n) >= 0 && n == 19);
 584         assert_se(parse_nice("+19", &n) >= 0 && n == 19);
 585
 586
 587         assert_se(parse_nice("", &n) == -EINVAL);
 588         assert_se(parse_nice("-", &n) == -EINVAL);
 589         assert_se(parse_nice("+", &n) == -EINVAL);
 590         assert_se(parse_nice("xx", &n) == -EINVAL);
 591         assert_se(parse_nice("-50", &n) == -ERANGE);
 592         assert_se(parse_nice("50", &n) == -ERANGE);
 593         assert_se(parse_nice("+50", &n) == -ERANGE);
 594         assert_se(parse_nice("-21", &n) == -ERANGE);
 595         assert_se(parse_nice("20", &n) == -ERANGE);
 596         assert_se(parse_nice("+20", &n) == -ERANGE);
 597 }
 598 #endif // 0
 599
 600 static void test_parse_dev(void) {
 601         dev_t dev;
 602
 603         assert_se(parse_dev("0", &dev) == -EINVAL);
 604         assert_se(parse_dev("5", &dev) == -EINVAL);
 605         assert_se(parse_dev("5:", &dev) == -EINVAL);
 606         assert_se(parse_dev(":5", &dev) == -EINVAL);
 607 #if SIZEOF_DEV_T < 8
 608         assert_se(parse_dev("4294967295:4294967295", &dev) == -EINVAL);
 609 #endif
 610         assert_se(parse_dev("8:11", &dev) >= 0 && major(dev) == 8 && minor(dev) == 11);
 611 }
 612
 613 int main(int argc, char *argv[]) {
 614         log_parse_environment();
 615         log_open();
 616
 617         test_parse_boolean();
 618         test_parse_pid();
 619         test_parse_mode();
 620         test_parse_size();
 621 #if 0 /// UNNEEDED by elogind
 622         test_parse_range();
 623 #endif // 0
 624         test_safe_atolli();
 625         test_safe_atou16();
 626         test_safe_atoi16();
 627         test_safe_atou64();
 628         test_safe_atoi64();
 629         test_safe_atod();
 630         test_parse_percent();
 631         test_parse_percent_unbounded();
 632 #if 0 /// UNNEEDED by elogind
 633         test_parse_nice();
 634 #endif // 0
 635         test_parse_dev();
 636
 637         return 0;
 638 }