src/test/test-parse-util.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010 Lennart Poettering
   7   Copyright 2013 Thomas H.P. Andersen
   8
   9   systemd is free software; you can redistribute it and/or modify it
  10   under the terms of the GNU Lesser General Public License as published by
  11   the Free Software Foundation; either version 2.1 of the License, or
  12   (at your option) any later version.
  13
  14   systemd is distributed in the hope that it will be useful, but
  15   WITHOUT ANY WARRANTY; without even the implied warranty of
  16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  17   Lesser General Public License for more details.
  18
  19   You should have received a copy of the GNU Lesser General Public License
  20   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  21 ***/
  22
  23 #include <locale.h>
  24 #include <math.h>
  25
  26 #include "log.h"
  27 #include "parse-util.h"
  28
  29 static void test_parse_boolean(void) {
  30         assert_se(parse_boolean("1") == 1);
  31         assert_se(parse_boolean("y") == 1);
  32         assert_se(parse_boolean("Y") == 1);
  33         assert_se(parse_boolean("yes") == 1);
  34         assert_se(parse_boolean("YES") == 1);
  35         assert_se(parse_boolean("true") == 1);
  36         assert_se(parse_boolean("TRUE") == 1);
  37         assert_se(parse_boolean("on") == 1);
  38         assert_se(parse_boolean("ON") == 1);
  39
  40         assert_se(parse_boolean("0") == 0);
  41         assert_se(parse_boolean("n") == 0);
  42         assert_se(parse_boolean("N") == 0);
  43         assert_se(parse_boolean("no") == 0);
  44         assert_se(parse_boolean("NO") == 0);
  45         assert_se(parse_boolean("false") == 0);
  46         assert_se(parse_boolean("FALSE") == 0);
  47         assert_se(parse_boolean("off") == 0);
  48         assert_se(parse_boolean("OFF") == 0);
  49
  50         assert_se(parse_boolean("garbage") < 0);
  51         assert_se(parse_boolean("") < 0);
  52         assert_se(parse_boolean("full") < 0);
  53 }
  54
  55 static void test_parse_pid(void) {
  56         int r;
  57         pid_t pid;
  58
  59         r = parse_pid("100", &pid);
  60         assert_se(r == 0);
  61         assert_se(pid == 100);
  62
  63         r = parse_pid("0x7FFFFFFF", &pid);
  64         assert_se(r == 0);
  65         assert_se(pid == 2147483647);
  66
  67         pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
  68         r = parse_pid("0", &pid);
  69         assert_se(r == -ERANGE);
  70         assert_se(pid == 65);
  71
  72         pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
  73         r = parse_pid("-100", &pid);
  74         assert_se(r == -ERANGE);
  75         assert_se(pid == 65);
  76
  77         pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
  78         r = parse_pid("0xFFFFFFFFFFFFFFFFF", &pid);
  79         assert_se(r == -ERANGE);
  80         assert_se(pid == 65);
  81
  82         r = parse_pid("junk", &pid);
  83         assert_se(r == -EINVAL);
  84 }
  85
  86 static void test_parse_mode(void) {
  87         mode_t m;
  88
  89         assert_se(parse_mode("-1", &m) < 0);
  90         assert_se(parse_mode("", &m) < 0);
  91         assert_se(parse_mode("888", &m) < 0);
  92         assert_se(parse_mode("77777", &m) < 0);
  93
  94         assert_se(parse_mode("544", &m) >= 0 && m == 0544);
  95         assert_se(parse_mode("777", &m) >= 0 && m == 0777);
  96         assert_se(parse_mode("7777", &m) >= 0 && m == 07777);
  97         assert_se(parse_mode("0", &m) >= 0 && m == 0);
  98 }
  99
 100 static void test_parse_size(void) {
 101         uint64_t bytes;
 102
 103         assert_se(parse_size("111", 1024, &bytes) == 0);
 104         assert_se(bytes == 111);
 105
 106         assert_se(parse_size("111.4", 1024, &bytes) == 0);
 107         assert_se(bytes == 111);
 108
 109         assert_se(parse_size(" 112 B", 1024, &bytes) == 0);
 110         assert_se(bytes == 112);
 111
 112         assert_se(parse_size(" 112.6 B", 1024, &bytes) == 0);
 113         assert_se(bytes == 112);
 114
 115         assert_se(parse_size("3.5 K", 1024, &bytes) == 0);
 116         assert_se(bytes == 3*1024 + 512);
 117
 118         assert_se(parse_size("3. K", 1024, &bytes) == 0);
 119         assert_se(bytes == 3*1024);
 120
 121         assert_se(parse_size("3.0 K", 1024, &bytes) == 0);
 122         assert_se(bytes == 3*1024);
 123
 124         assert_se(parse_size("3. 0 K", 1024, &bytes) == -EINVAL);
 125
 126         assert_se(parse_size(" 4 M 11.5K", 1024, &bytes) == 0);
 127         assert_se(bytes == 4*1024*1024 + 11 * 1024 + 512);
 128
 129         assert_se(parse_size("3B3.5G", 1024, &bytes) == -EINVAL);
 130
 131         assert_se(parse_size("3.5G3B", 1024, &bytes) == 0);
 132         assert_se(bytes == 3ULL*1024*1024*1024 + 512*1024*1024 + 3);
 133
 134         assert_se(parse_size("3.5G 4B", 1024, &bytes) == 0);
 135         assert_se(bytes == 3ULL*1024*1024*1024 + 512*1024*1024 + 4);
 136
 137         assert_se(parse_size("3B3G4T", 1024, &bytes) == -EINVAL);
 138
 139         assert_se(parse_size("4T3G3B", 1024, &bytes) == 0);
 140         assert_se(bytes == (4ULL*1024 + 3)*1024*1024*1024 + 3);
 141
 142         assert_se(parse_size(" 4 T 3 G 3 B", 1024, &bytes) == 0);
 143         assert_se(bytes == (4ULL*1024 + 3)*1024*1024*1024 + 3);
 144
 145         assert_se(parse_size("12P", 1024, &bytes) == 0);
 146         assert_se(bytes == 12ULL * 1024*1024*1024*1024*1024);
 147
 148         assert_se(parse_size("12P12P", 1024, &bytes) == -EINVAL);
 149
 150         assert_se(parse_size("3E 2P", 1024, &bytes) == 0);
 151         assert_se(bytes == (3 * 1024 + 2ULL) * 1024*1024*1024*1024*1024);
 152
 153         assert_se(parse_size("12X", 1024, &bytes) == -EINVAL);
 154
 155         assert_se(parse_size("12.5X", 1024, &bytes) == -EINVAL);
 156
 157         assert_se(parse_size("12.5e3", 1024, &bytes) == -EINVAL);
 158
 159         assert_se(parse_size("1024E", 1024, &bytes) == -ERANGE);
 160         assert_se(parse_size("-1", 1024, &bytes) == -ERANGE);
 161         assert_se(parse_size("-1024E", 1024, &bytes) == -ERANGE);
 162
 163         assert_se(parse_size("-1024P", 1024, &bytes) == -ERANGE);
 164
 165         assert_se(parse_size("-10B 20K", 1024, &bytes) == -ERANGE);
 166 }
 167
 168 static void test_parse_range(void) {
 169         unsigned lower, upper;
 170
 171         /* Successful cases */
 172         assert_se(parse_range("111", &lower, &upper) == 0);
 173         assert_se(lower == 111);
 174         assert_se(upper == 111);
 175
 176         assert_se(parse_range("111-123", &lower, &upper) == 0);
 177         assert_se(lower == 111);
 178         assert_se(upper == 123);
 179
 180         assert_se(parse_range("123-111", &lower, &upper) == 0);
 181         assert_se(lower == 123);
 182         assert_se(upper == 111);
 183
 184         assert_se(parse_range("123-123", &lower, &upper) == 0);
 185         assert_se(lower == 123);
 186         assert_se(upper == 123);
 187
 188         assert_se(parse_range("0", &lower, &upper) == 0);
 189         assert_se(lower == 0);
 190         assert_se(upper == 0);
 191
 192         assert_se(parse_range("0-15", &lower, &upper) == 0);
 193         assert_se(lower == 0);
 194         assert_se(upper == 15);
 195
 196         assert_se(parse_range("15-0", &lower, &upper) == 0);
 197         assert_se(lower == 15);
 198         assert_se(upper == 0);
 199
 200         assert_se(parse_range("128-65535", &lower, &upper) == 0);
 201         assert_se(lower == 128);
 202         assert_se(upper == 65535);
 203
 204         assert_se(parse_range("1024-4294967295", &lower, &upper) == 0);
 205         assert_se(lower == 1024);
 206         assert_se(upper == 4294967295);
 207
 208         /* Leading whitespace is acceptable */
 209         assert_se(parse_range(" 111", &lower, &upper) == 0);
 210         assert_se(lower == 111);
 211         assert_se(upper == 111);
 212
 213         assert_se(parse_range(" 111-123", &lower, &upper) == 0);
 214         assert_se(lower == 111);
 215         assert_se(upper == 123);
 216
 217         assert_se(parse_range("111- 123", &lower, &upper) == 0);
 218         assert_se(lower == 111);
 219         assert_se(upper == 123);
 220
 221         assert_se(parse_range("\t111-\t123", &lower, &upper) == 0);
 222         assert_se(lower == 111);
 223         assert_se(upper == 123);
 224
 225         assert_se(parse_range(" \t 111- \t 123", &lower, &upper) == 0);
 226         assert_se(lower == 111);
 227         assert_se(upper == 123);
 228
 229         /* Error cases, make sure they fail as expected */
 230         lower = upper = 9999;
 231         assert_se(parse_range("111garbage", &lower, &upper) == -EINVAL);
 232         assert_se(lower == 9999);
 233         assert_se(upper == 9999);
 234
 235         assert_se(parse_range("garbage111", &lower, &upper) == -EINVAL);
 236         assert_se(lower == 9999);
 237         assert_se(upper == 9999);
 238
 239         assert_se(parse_range("garbage", &lower, &upper) == -EINVAL);
 240         assert_se(lower == 9999);
 241         assert_se(upper == 9999);
 242
 243         assert_se(parse_range("111-123garbage", &lower, &upper) == -EINVAL);
 244         assert_se(lower == 9999);
 245         assert_se(upper == 9999);
 246
 247         assert_se(parse_range("111garbage-123", &lower, &upper) == -EINVAL);
 248         assert_se(lower == 9999);
 249         assert_se(upper == 9999);
 250
 251         /* Empty string */
 252         lower = upper = 9999;
 253         assert_se(parse_range("", &lower, &upper) == -EINVAL);
 254         assert_se(lower == 9999);
 255         assert_se(upper == 9999);
 256
 257         /* 111--123 will pass -123 to safe_atou which returns -ERANGE for negative */
 258         assert_se(parse_range("111--123", &lower, &upper) == -ERANGE);
 259         assert_se(lower == 9999);
 260         assert_se(upper == 9999);
 261
 262         assert_se(parse_range("-111-123", &lower, &upper) == -EINVAL);
 263         assert_se(lower == 9999);
 264         assert_se(upper == 9999);
 265
 266         assert_se(parse_range("111-123-", &lower, &upper) == -EINVAL);
 267         assert_se(lower == 9999);
 268         assert_se(upper == 9999);
 269
 270         assert_se(parse_range("111.4-123", &lower, &upper) == -EINVAL);
 271         assert_se(lower == 9999);
 272         assert_se(upper == 9999);
 273
 274         assert_se(parse_range("111-123.4", &lower, &upper) == -EINVAL);
 275         assert_se(lower == 9999);
 276         assert_se(upper == 9999);
 277
 278         assert_se(parse_range("111,4-123", &lower, &upper) == -EINVAL);
 279         assert_se(lower == 9999);
 280         assert_se(upper == 9999);
 281
 282         assert_se(parse_range("111-123,4", &lower, &upper) == -EINVAL);
 283         assert_se(lower == 9999);
 284         assert_se(upper == 9999);
 285
 286         /* Error on trailing dash */
 287         assert_se(parse_range("111-", &lower, &upper) == -EINVAL);
 288         assert_se(lower == 9999);
 289         assert_se(upper == 9999);
 290
 291         assert_se(parse_range("111-123-", &lower, &upper) == -EINVAL);
 292         assert_se(lower == 9999);
 293         assert_se(upper == 9999);
 294
 295         assert_se(parse_range("111--", &lower, &upper) == -EINVAL);
 296         assert_se(lower == 9999);
 297         assert_se(upper == 9999);
 298
 299         assert_se(parse_range("111- ", &lower, &upper) == -EINVAL);
 300         assert_se(lower == 9999);
 301         assert_se(upper == 9999);
 302
 303         /* Whitespace is not a separator */
 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\t123", &lower, &upper) == -EINVAL);
 309         assert_se(lower == 9999);
 310         assert_se(upper == 9999);
 311
 312         assert_se(parse_range("111 \t 123", &lower, &upper) == -EINVAL);
 313         assert_se(lower == 9999);
 314         assert_se(upper == 9999);
 315
 316         /* Trailing whitespace is invalid (from safe_atou) */
 317         assert_se(parse_range("111 ", &lower, &upper) == -EINVAL);
 318         assert_se(lower == 9999);
 319         assert_se(upper == 9999);
 320
 321         assert_se(parse_range("111-123 ", &lower, &upper) == -EINVAL);
 322         assert_se(lower == 9999);
 323         assert_se(upper == 9999);
 324
 325         assert_se(parse_range("111 -123", &lower, &upper) == -EINVAL);
 326         assert_se(lower == 9999);
 327         assert_se(upper == 9999);
 328
 329         assert_se(parse_range("111 -123 ", &lower, &upper) == -EINVAL);
 330         assert_se(lower == 9999);
 331         assert_se(upper == 9999);
 332
 333         assert_se(parse_range("111\t-123\t", &lower, &upper) == -EINVAL);
 334         assert_se(lower == 9999);
 335         assert_se(upper == 9999);
 336
 337         assert_se(parse_range("111 \t -123 \t ", &lower, &upper) == -EINVAL);
 338         assert_se(lower == 9999);
 339         assert_se(upper == 9999);
 340
 341         /* Out of the "unsigned" range, this is 1<<64 */
 342         assert_se(parse_range("0-18446744073709551616", &lower, &upper) == -ERANGE);
 343         assert_se(lower == 9999);
 344         assert_se(upper == 9999);
 345 }
 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("junk", &l);
 356         assert_se(r == -EINVAL);
 357 }
 358
 359 static void test_safe_atou16(void) {
 360         int r;
 361         uint16_t l;
 362
 363         r = safe_atou16("12345", &l);
 364         assert_se(r == 0);
 365         assert_se(l == 12345);
 366
 367         r = safe_atou16("123456", &l);
 368         assert_se(r == -ERANGE);
 369
 370         r = safe_atou16("junk", &l);
 371         assert_se(r == -EINVAL);
 372 }
 373
 374 static void test_safe_atoi16(void) {
 375         int r;
 376         int16_t l;
 377
 378         r = safe_atoi16("-12345", &l);
 379         assert_se(r == 0);
 380         assert_se(l == -12345);
 381
 382         r = safe_atoi16("36536", &l);
 383         assert_se(r == -ERANGE);
 384
 385         r = safe_atoi16("junk", &l);
 386         assert_se(r == -EINVAL);
 387 }
 388
 389 static void test_safe_atod(void) {
 390         int r;
 391         double d;
 392         char *e;
 393
 394         r = safe_atod("junk", &d);
 395         assert_se(r == -EINVAL);
 396
 397         r = safe_atod("0.2244", &d);
 398         assert_se(r == 0);
 399         assert_se(fabs(d - 0.2244) < 0.000001);
 400
 401         r = safe_atod("0,5", &d);
 402         assert_se(r == -EINVAL);
 403
 404         errno = 0;
 405         strtod("0,5", &e);
 406         assert_se(*e == ',');
 407
 408         /* Check if this really is locale independent */
 409         if (setlocale(LC_NUMERIC, "de_DE.utf8")) {
 410
 411                 r = safe_atod("0.2244", &d);
 412                 assert_se(r == 0);
 413                 assert_se(fabs(d - 0.2244) < 0.000001);
 414
 415                 r = safe_atod("0,5", &d);
 416                 assert_se(r == -EINVAL);
 417
 418                 errno = 0;
 419                 assert_se(fabs(strtod("0,5", &e) - 0.5) < 0.00001);
 420         }
 421
 422         /* And check again, reset */
 423         assert_se(setlocale(LC_NUMERIC, "C"));
 424
 425         r = safe_atod("0.2244", &d);
 426         assert_se(r == 0);
 427         assert_se(fabs(d - 0.2244) < 0.000001);
 428
 429         r = safe_atod("0,5", &d);
 430         assert_se(r == -EINVAL);
 431
 432         errno = 0;
 433         strtod("0,5", &e);
 434         assert_se(*e == ',');
 435 }
 436
 437 int main(int argc, char *argv[]) {
 438         log_parse_environment();
 439         log_open();
 440
 441         test_parse_boolean();
 442         test_parse_pid();
 443         test_parse_mode();
 444         test_parse_size();
 445         test_parse_range();
 446         test_safe_atolli();
 447         test_safe_atou16();
 448         test_safe_atoi16();
 449         test_safe_atod();
 450
 451         return 0;
 452 }