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
 400 static void test_safe_atoi16(void) {
 401         int r;
 402         int16_t l;
 403
 404         r = safe_atoi16("-12345", &l);
 405         assert_se(r == 0);
 406         assert_se(l == -12345);
 407
 408         r = safe_atoi16("  -12345", &l);
 409         assert_se(r == 0);
 410         assert_se(l == -12345);
 411
 412         r = safe_atoi16("32767", &l);
 413         assert_se(r == 0);
 414         assert_se(l == 32767);
 415
 416         r = safe_atoi16("  32767", &l);
 417         assert_se(r == 0);
 418         assert_se(l == 32767);
 419
 420         r = safe_atoi16("36536", &l);
 421         assert_se(r == -ERANGE);
 422
 423         r = safe_atoi16("-32769", &l);
 424         assert_se(r == -ERANGE);
 425
 426         r = safe_atoi16("junk", &l);
 427         assert_se(r == -EINVAL);
 428 }
 429
 430 static void test_safe_atod(void) {
 431         int r;
 432         double d;
 433         char *e;
 434
 435         r = safe_atod("junk", &d);
 436         assert_se(r == -EINVAL);
 437
 438         r = safe_atod("0.2244", &d);
 439         assert_se(r == 0);
 440         assert_se(fabs(d - 0.2244) < 0.000001);
 441
 442         r = safe_atod("0,5", &d);
 443         assert_se(r == -EINVAL);
 444
 445         errno = 0;
 446         strtod("0,5", &e);
 447         assert_se(*e == ',');
 448
 449         /* Check if this really is locale independent */
 450         if (setlocale(LC_NUMERIC, "de_DE.utf8")) {
 451
 452                 r = safe_atod("0.2244", &d);
 453                 assert_se(r == 0);
 454                 assert_se(fabs(d - 0.2244) < 0.000001);
 455
 456                 r = safe_atod("0,5", &d);
 457                 assert_se(r == -EINVAL);
 458
 459                 errno = 0;
 460                 assert_se(fabs(strtod("0,5", &e) - 0.5) < 0.00001);
 461         }
 462
 463         /* And check again, reset */
 464         assert_se(setlocale(LC_NUMERIC, "C"));
 465
 466         r = safe_atod("0.2244", &d);
 467         assert_se(r == 0);
 468         assert_se(fabs(d - 0.2244) < 0.000001);
 469
 470         r = safe_atod("0,5", &d);
 471         assert_se(r == -EINVAL);
 472
 473         errno = 0;
 474         strtod("0,5", &e);
 475         assert_se(*e == ',');
 476 }
 477
 478 static void test_parse_percent(void) {
 479         assert_se(parse_percent("") == -EINVAL);
 480         assert_se(parse_percent("foo") == -EINVAL);
 481         assert_se(parse_percent("0") == -EINVAL);
 482         assert_se(parse_percent("50") == -EINVAL);
 483         assert_se(parse_percent("100") == -EINVAL);
 484         assert_se(parse_percent("-1") == -EINVAL);
 485         assert_se(parse_percent("0%") == 0);
 486         assert_se(parse_percent("55%") == 55);
 487         assert_se(parse_percent("100%") == 100);
 488         assert_se(parse_percent("-7%") == -ERANGE);
 489         assert_se(parse_percent("107%") == -ERANGE);
 490         assert_se(parse_percent("%") == -EINVAL);
 491         assert_se(parse_percent("%%") == -EINVAL);
 492         assert_se(parse_percent("%1") == -EINVAL);
 493         assert_se(parse_percent("1%%") == -EINVAL);
 494 }
 495
 496 int main(int argc, char *argv[]) {
 497         log_parse_environment();
 498         log_open();
 499
 500         test_parse_boolean();
 501         test_parse_pid();
 502         test_parse_mode();
 503         test_parse_size();
 504         test_parse_range();
 505         test_safe_atolli();
 506         test_safe_atou16();
 507         test_safe_atoi16();
 508         test_safe_atod();
 509         test_parse_percent();
 510
 511         return 0;
 512 }