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 static void test_parse_range(void) {
 167         unsigned lower, upper;
 168
 169         /* Successful cases */
 170         assert_se(parse_range("111", &lower, &upper) == 0);
 171         assert_se(lower == 111);
 172         assert_se(upper == 111);
 173
 174         assert_se(parse_range("111-123", &lower, &upper) == 0);
 175         assert_se(lower == 111);
 176         assert_se(upper == 123);
 177
 178         assert_se(parse_range("123-111", &lower, &upper) == 0);
 179         assert_se(lower == 123);
 180         assert_se(upper == 111);
 181
 182         assert_se(parse_range("123-123", &lower, &upper) == 0);
 183         assert_se(lower == 123);
 184         assert_se(upper == 123);
 185
 186         assert_se(parse_range("0", &lower, &upper) == 0);
 187         assert_se(lower == 0);
 188         assert_se(upper == 0);
 189
 190         assert_se(parse_range("0-15", &lower, &upper) == 0);
 191         assert_se(lower == 0);
 192         assert_se(upper == 15);
 193
 194         assert_se(parse_range("15-0", &lower, &upper) == 0);
 195         assert_se(lower == 15);
 196         assert_se(upper == 0);
 197
 198         assert_se(parse_range("128-65535", &lower, &upper) == 0);
 199         assert_se(lower == 128);
 200         assert_se(upper == 65535);
 201
 202         assert_se(parse_range("1024-4294967295", &lower, &upper) == 0);
 203         assert_se(lower == 1024);
 204         assert_se(upper == 4294967295);
 205
 206         /* Leading whitespace is acceptable */
 207         assert_se(parse_range(" 111", &lower, &upper) == 0);
 208         assert_se(lower == 111);
 209         assert_se(upper == 111);
 210
 211         assert_se(parse_range(" 111-123", &lower, &upper) == 0);
 212         assert_se(lower == 111);
 213         assert_se(upper == 123);
 214
 215         assert_se(parse_range("111- 123", &lower, &upper) == 0);
 216         assert_se(lower == 111);
 217         assert_se(upper == 123);
 218
 219         assert_se(parse_range("\t111-\t123", &lower, &upper) == 0);
 220         assert_se(lower == 111);
 221         assert_se(upper == 123);
 222
 223         assert_se(parse_range(" \t 111- \t 123", &lower, &upper) == 0);
 224         assert_se(lower == 111);
 225         assert_se(upper == 123);
 226
 227         /* Error cases, make sure they fail as expected */
 228         lower = upper = 9999;
 229         assert_se(parse_range("111garbage", &lower, &upper) == -EINVAL);
 230         assert_se(lower == 9999);
 231         assert_se(upper == 9999);
 232
 233         assert_se(parse_range("garbage111", &lower, &upper) == -EINVAL);
 234         assert_se(lower == 9999);
 235         assert_se(upper == 9999);
 236
 237         assert_se(parse_range("garbage", &lower, &upper) == -EINVAL);
 238         assert_se(lower == 9999);
 239         assert_se(upper == 9999);
 240
 241         assert_se(parse_range("111-123garbage", &lower, &upper) == -EINVAL);
 242         assert_se(lower == 9999);
 243         assert_se(upper == 9999);
 244
 245         assert_se(parse_range("111garbage-123", &lower, &upper) == -EINVAL);
 246         assert_se(lower == 9999);
 247         assert_se(upper == 9999);
 248
 249         /* Empty string */
 250         lower = upper = 9999;
 251         assert_se(parse_range("", &lower, &upper) == -EINVAL);
 252         assert_se(lower == 9999);
 253         assert_se(upper == 9999);
 254
 255         /* 111--123 will pass -123 to safe_atou which returns -ERANGE for negative */
 256         assert_se(parse_range("111--123", &lower, &upper) == -ERANGE);
 257         assert_se(lower == 9999);
 258         assert_se(upper == 9999);
 259
 260         assert_se(parse_range("-111-123", &lower, &upper) == -EINVAL);
 261         assert_se(lower == 9999);
 262         assert_se(upper == 9999);
 263
 264         assert_se(parse_range("111-123-", &lower, &upper) == -EINVAL);
 265         assert_se(lower == 9999);
 266         assert_se(upper == 9999);
 267
 268         assert_se(parse_range("111.4-123", &lower, &upper) == -EINVAL);
 269         assert_se(lower == 9999);
 270         assert_se(upper == 9999);
 271
 272         assert_se(parse_range("111-123.4", &lower, &upper) == -EINVAL);
 273         assert_se(lower == 9999);
 274         assert_se(upper == 9999);
 275
 276         assert_se(parse_range("111,4-123", &lower, &upper) == -EINVAL);
 277         assert_se(lower == 9999);
 278         assert_se(upper == 9999);
 279
 280         assert_se(parse_range("111-123,4", &lower, &upper) == -EINVAL);
 281         assert_se(lower == 9999);
 282         assert_se(upper == 9999);
 283
 284         /* Error on trailing dash */
 285         assert_se(parse_range("111-", &lower, &upper) == -EINVAL);
 286         assert_se(lower == 9999);
 287         assert_se(upper == 9999);
 288
 289         assert_se(parse_range("111-123-", &lower, &upper) == -EINVAL);
 290         assert_se(lower == 9999);
 291         assert_se(upper == 9999);
 292
 293         assert_se(parse_range("111--", &lower, &upper) == -EINVAL);
 294         assert_se(lower == 9999);
 295         assert_se(upper == 9999);
 296
 297         assert_se(parse_range("111- ", &lower, &upper) == -EINVAL);
 298         assert_se(lower == 9999);
 299         assert_se(upper == 9999);
 300
 301         /* Whitespace is not a separator */
 302         assert_se(parse_range("111 123", &lower, &upper) == -EINVAL);
 303         assert_se(lower == 9999);
 304         assert_se(upper == 9999);
 305
 306         assert_se(parse_range("111\t123", &lower, &upper) == -EINVAL);
 307         assert_se(lower == 9999);
 308         assert_se(upper == 9999);
 309
 310         assert_se(parse_range("111 \t 123", &lower, &upper) == -EINVAL);
 311         assert_se(lower == 9999);
 312         assert_se(upper == 9999);
 313
 314         /* Trailing whitespace is invalid (from safe_atou) */
 315         assert_se(parse_range("111 ", &lower, &upper) == -EINVAL);
 316         assert_se(lower == 9999);
 317         assert_se(upper == 9999);
 318
 319         assert_se(parse_range("111-123 ", &lower, &upper) == -EINVAL);
 320         assert_se(lower == 9999);
 321         assert_se(upper == 9999);
 322
 323         assert_se(parse_range("111 -123", &lower, &upper) == -EINVAL);
 324         assert_se(lower == 9999);
 325         assert_se(upper == 9999);
 326
 327         assert_se(parse_range("111 -123 ", &lower, &upper) == -EINVAL);
 328         assert_se(lower == 9999);
 329         assert_se(upper == 9999);
 330
 331         assert_se(parse_range("111\t-123\t", &lower, &upper) == -EINVAL);
 332         assert_se(lower == 9999);
 333         assert_se(upper == 9999);
 334
 335         assert_se(parse_range("111 \t -123 \t ", &lower, &upper) == -EINVAL);
 336         assert_se(lower == 9999);
 337         assert_se(upper == 9999);
 338
 339         /* Out of the "unsigned" range, this is 1<<64 */
 340         assert_se(parse_range("0-18446744073709551616", &lower, &upper) == -ERANGE);
 341         assert_se(lower == 9999);
 342         assert_se(upper == 9999);
 343 }
 344
 345 static void test_safe_atolli(void) {
 346         int r;
 347         long long l;
 348
 349         r = safe_atolli("12345", &l);
 350         assert_se(r == 0);
 351         assert_se(l == 12345);
 352
 353         r = safe_atolli("  12345", &l);
 354         assert_se(r == 0);
 355         assert_se(l == 12345);
 356
 357         r = safe_atolli("-12345", &l);
 358         assert_se(r == 0);
 359         assert_se(l == -12345);
 360
 361         r = safe_atolli("  -12345", &l);
 362         assert_se(r == 0);
 363         assert_se(l == -12345);
 364
 365         r = safe_atolli("12345678901234567890", &l);
 366         assert_se(r == -ERANGE);
 367
 368         r = safe_atolli("-12345678901234567890", &l);
 369         assert_se(r == -ERANGE);
 370
 371         r = safe_atolli("junk", &l);
 372         assert_se(r == -EINVAL);
 373 }
 374
 375 static void test_safe_atou16(void) {
 376         int r;
 377         uint16_t l;
 378
 379         r = safe_atou16("12345", &l);
 380         assert_se(r == 0);
 381         assert_se(l == 12345);
 382
 383         r = safe_atou16("  12345", &l);
 384         assert_se(r == 0);
 385         assert_se(l == 12345);
 386
 387         r = safe_atou16("123456", &l);
 388         assert_se(r == -ERANGE);
 389
 390         r = safe_atou16("-1", &l);
 391         assert_se(r == -ERANGE);
 392
 393         r = safe_atou16("  -1", &l);
 394         assert_se(r == -ERANGE);
 395
 396         r = safe_atou16("junk", &l);
 397         assert_se(r == -EINVAL);
 398
 399         r = safe_atou16("123x", &l);
 400         assert_se(r == -EINVAL);
 401 }
 402
 403 static void test_safe_atoi16(void) {
 404         int r;
 405         int16_t l;
 406
 407         r = safe_atoi16("-12345", &l);
 408         assert_se(r == 0);
 409         assert_se(l == -12345);
 410
 411         r = safe_atoi16("  -12345", &l);
 412         assert_se(r == 0);
 413         assert_se(l == -12345);
 414
 415         r = safe_atoi16("32767", &l);
 416         assert_se(r == 0);
 417         assert_se(l == 32767);
 418
 419         r = safe_atoi16("  32767", &l);
 420         assert_se(r == 0);
 421         assert_se(l == 32767);
 422
 423         r = safe_atoi16("36536", &l);
 424         assert_se(r == -ERANGE);
 425
 426         r = safe_atoi16("-32769", &l);
 427         assert_se(r == -ERANGE);
 428
 429         r = safe_atoi16("junk", &l);
 430         assert_se(r == -EINVAL);
 431
 432         r = safe_atoi16("123x", &l);
 433         assert_se(r == -EINVAL);
 434 }
 435
 436 static void test_safe_atou64(void) {
 437         int r;
 438         uint64_t l;
 439
 440         r = safe_atou64("12345", &l);
 441         assert_se(r == 0);
 442         assert_se(l == 12345);
 443
 444         r = safe_atou64("  12345", &l);
 445         assert_se(r == 0);
 446         assert_se(l == 12345);
 447
 448         r = safe_atou64("18446744073709551617", &l);
 449         assert_se(r == -ERANGE);
 450
 451         r = safe_atou64("-1", &l);
 452         assert_se(r == -ERANGE);
 453
 454         r = safe_atou64("  -1", &l);
 455         assert_se(r == -ERANGE);
 456
 457         r = safe_atou64("junk", &l);
 458         assert_se(r == -EINVAL);
 459
 460         r = safe_atou64("123x", &l);
 461         assert_se(r == -EINVAL);
 462 }
 463
 464 static void test_safe_atoi64(void) {
 465         int r;
 466         int64_t l;
 467
 468         r = safe_atoi64("-12345", &l);
 469         assert_se(r == 0);
 470         assert_se(l == -12345);
 471
 472         r = safe_atoi64("  -12345", &l);
 473         assert_se(r == 0);
 474         assert_se(l == -12345);
 475
 476         r = safe_atoi64("32767", &l);
 477         assert_se(r == 0);
 478         assert_se(l == 32767);
 479
 480         r = safe_atoi64("  32767", &l);
 481         assert_se(r == 0);
 482         assert_se(l == 32767);
 483
 484         r = safe_atoi64("9223372036854775813", &l);
 485         assert_se(r == -ERANGE);
 486
 487         r = safe_atoi64("-9223372036854775813", &l);
 488         assert_se(r == -ERANGE);
 489
 490         r = safe_atoi64("junk", &l);
 491         assert_se(r == -EINVAL);
 492
 493         r = safe_atoi64("123x", &l);
 494         assert_se(r == -EINVAL);
 495 }
 496
 497 static void test_safe_atod(void) {
 498         int r;
 499         double d;
 500         char *e;
 501
 502         r = safe_atod("junk", &d);
 503         assert_se(r == -EINVAL);
 504
 505         r = safe_atod("0.2244", &d);
 506         assert_se(r == 0);
 507         assert_se(fabs(d - 0.2244) < 0.000001);
 508
 509         r = safe_atod("0,5", &d);
 510         assert_se(r == -EINVAL);
 511
 512         errno = 0;
 513         strtod("0,5", &e);
 514         assert_se(*e == ',');
 515
 516         /* Check if this really is locale independent */
 517         if (setlocale(LC_NUMERIC, "de_DE.utf8")) {
 518
 519                 r = safe_atod("0.2244", &d);
 520                 assert_se(r == 0);
 521                 assert_se(fabs(d - 0.2244) < 0.000001);
 522
 523                 r = safe_atod("0,5", &d);
 524                 assert_se(r == -EINVAL);
 525
 526                 errno = 0;
 527                 assert_se(fabs(strtod("0,5", &e) - 0.5) < 0.00001);
 528         }
 529
 530         /* And check again, reset */
 531         assert_se(setlocale(LC_NUMERIC, "C"));
 532
 533         r = safe_atod("0.2244", &d);
 534         assert_se(r == 0);
 535         assert_se(fabs(d - 0.2244) < 0.000001);
 536
 537         r = safe_atod("0,5", &d);
 538         assert_se(r == -EINVAL);
 539
 540         errno = 0;
 541         strtod("0,5", &e);
 542         assert_se(*e == ',');
 543 }
 544
 545 static void test_parse_percent(void) {
 546         assert_se(parse_percent("") == -EINVAL);
 547         assert_se(parse_percent("foo") == -EINVAL);
 548         assert_se(parse_percent("0") == -EINVAL);
 549         assert_se(parse_percent("50") == -EINVAL);
 550         assert_se(parse_percent("100") == -EINVAL);
 551         assert_se(parse_percent("-1") == -EINVAL);
 552         assert_se(parse_percent("0%") == 0);
 553         assert_se(parse_percent("55%") == 55);
 554         assert_se(parse_percent("100%") == 100);
 555         assert_se(parse_percent("-7%") == -ERANGE);
 556         assert_se(parse_percent("107%") == -ERANGE);
 557         assert_se(parse_percent("%") == -EINVAL);
 558         assert_se(parse_percent("%%") == -EINVAL);
 559         assert_se(parse_percent("%1") == -EINVAL);
 560         assert_se(parse_percent("1%%") == -EINVAL);
 561 }
 562
 563 static void test_parse_percent_unbounded(void) {
 564         assert_se(parse_percent_unbounded("101%") == 101);
 565         assert_se(parse_percent_unbounded("400%") == 400);
 566 }
 567
 568 static void test_parse_nice(void) {
 569         int n;
 570
 571         assert_se(parse_nice("0", &n) >= 0 && n == 0);
 572         assert_se(parse_nice("+0", &n) >= 0 && n == 0);
 573         assert_se(parse_nice("-1", &n) >= 0 && n == -1);
 574         assert_se(parse_nice("-2", &n) >= 0 && n == -2);
 575         assert_se(parse_nice("1", &n) >= 0 && n == 1);
 576         assert_se(parse_nice("2", &n) >= 0 && n == 2);
 577         assert_se(parse_nice("+1", &n) >= 0 && n == 1);
 578         assert_se(parse_nice("+2", &n) >= 0 && n == 2);
 579         assert_se(parse_nice("-20", &n) >= 0 && n == -20);
 580         assert_se(parse_nice("19", &n) >= 0 && n == 19);
 581         assert_se(parse_nice("+19", &n) >= 0 && n == 19);
 582
 583
 584         assert_se(parse_nice("", &n) == -EINVAL);
 585         assert_se(parse_nice("-", &n) == -EINVAL);
 586         assert_se(parse_nice("+", &n) == -EINVAL);
 587         assert_se(parse_nice("xx", &n) == -EINVAL);
 588         assert_se(parse_nice("-50", &n) == -ERANGE);
 589         assert_se(parse_nice("50", &n) == -ERANGE);
 590         assert_se(parse_nice("+50", &n) == -ERANGE);
 591         assert_se(parse_nice("-21", &n) == -ERANGE);
 592         assert_se(parse_nice("20", &n) == -ERANGE);
 593         assert_se(parse_nice("+20", &n) == -ERANGE);
 594 }
 595
 596 static void test_parse_dev(void) {
 597         dev_t dev;
 598
 599         assert_se(parse_dev("0", &dev) == -EINVAL);
 600         assert_se(parse_dev("5", &dev) == -EINVAL);
 601         assert_se(parse_dev("5:", &dev) == -EINVAL);
 602         assert_se(parse_dev(":5", &dev) == -EINVAL);
 603 #if SIZEOF_DEV_T < 8
 604         assert_se(parse_dev("4294967295:4294967295", &dev) == -EINVAL);
 605 #endif
 606         assert_se(parse_dev("8:11", &dev) >= 0 && major(dev) == 8 && minor(dev) == 11);
 607 }
 608
 609 int main(int argc, char *argv[]) {
 610         log_parse_environment();
 611         log_open();
 612
 613         test_parse_boolean();
 614         test_parse_pid();
 615         test_parse_mode();
 616         test_parse_size();
 617         test_parse_range();
 618         test_safe_atolli();
 619         test_safe_atou16();
 620         test_safe_atoi16();
 621         test_safe_atou64();
 622         test_safe_atoi64();
 623         test_safe_atod();
 624         test_parse_percent();
 625         test_parse_percent_unbounded();
 626         test_parse_nice();
 627         test_parse_dev();
 628
 629         return 0;
 630 }