src/test/test-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 <string.h>
  24
  25 #include "util.h"
  26
  27 static void test_streq_ptr(void) {
  28         assert_se(streq_ptr(NULL, NULL));
  29         assert_se(!streq_ptr("abc", "cdef"));
  30 }
  31
  32 static void test_first_word(void) {
  33         assert_se(first_word("Hello", ""));
  34         assert_se(first_word("Hello", "Hello"));
  35         assert_se(first_word("Hello world", "Hello"));
  36         assert_se(first_word("Hello\tworld", "Hello"));
  37         assert_se(first_word("Hello\nworld", "Hello"));
  38         assert_se(first_word("Hello\rworld", "Hello"));
  39         assert_se(first_word("Hello ", "Hello"));
  40
  41         assert_se(!first_word("Hello", "Hellooo"));
  42         assert_se(!first_word("Hello", "xxxxx"));
  43         assert_se(!first_word("Hellooo", "Hello"));
  44 }
  45
  46 static void test_parse_boolean(void) {
  47         assert_se(parse_boolean("1") == 1);
  48         assert_se(parse_boolean("y") == 1);
  49         assert_se(parse_boolean("Y") == 1);
  50         assert_se(parse_boolean("yes") == 1);
  51         assert_se(parse_boolean("YES") == 1);
  52         assert_se(parse_boolean("true") == 1);
  53         assert_se(parse_boolean("TRUE") == 1);
  54         assert_se(parse_boolean("on") == 1);
  55         assert_se(parse_boolean("ON") == 1);
  56
  57         assert_se(parse_boolean("0") == 0);
  58         assert_se(parse_boolean("n") == 0);
  59         assert_se(parse_boolean("N") == 0);
  60         assert_se(parse_boolean("no") == 0);
  61         assert_se(parse_boolean("NO") == 0);
  62         assert_se(parse_boolean("false") == 0);
  63         assert_se(parse_boolean("FALSE") == 0);
  64         assert_se(parse_boolean("off") == 0);
  65         assert_se(parse_boolean("OFF") == 0);
  66
  67         assert_se(parse_boolean("garbage") < 0);
  68         assert_se(parse_boolean("") < 0);
  69 }
  70
  71 static void test_parse_pid(void) {
  72         int r;
  73         pid_t pid;
  74
  75         r = parse_pid("100", &pid);
  76         assert_se(r == 0);
  77         assert_se(pid == 100);
  78
  79         r = parse_pid("0x7FFFFFFF", &pid);
  80         assert_se(r == 0);
  81         assert_se(pid == 2147483647);
  82
  83         pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
  84         r = parse_pid("0", &pid);
  85         assert_se(r == -ERANGE);
  86         assert_se(pid == 65);
  87
  88         pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
  89         r = parse_pid("-100", &pid);
  90         assert_se(r == -ERANGE);
  91         assert_se(pid == 65);
  92
  93         pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
  94         r = parse_pid("0xFFFFFFFFFFFFFFFFF", &pid);
  95         assert(r == -ERANGE);
  96         assert_se(pid == 65);
  97 }
  98
  99 static void test_parse_uid(void) {
 100         int r;
 101         uid_t uid;
 102
 103         r = parse_uid("100", &uid);
 104         assert_se(r == 0);
 105         assert_se(uid == 100);
 106 }
 107
 108 static void test_safe_atolli(void) {
 109         int r;
 110         long long l;
 111
 112         r = safe_atolli("12345", &l);
 113         assert_se(r == 0);
 114         assert_se(l == 12345);
 115
 116         r = safe_atolli("junk", &l);
 117         assert_se(r == -EINVAL);
 118 }
 119
 120 static void test_safe_atod(void) {
 121         int r;
 122         double d;
 123
 124         r = safe_atod("0.2244", &d);
 125         assert_se(r == 0);
 126         assert_se(abs(d - 0.2244) < 0.000001);
 127
 128         r = safe_atod("junk", &d);
 129         assert_se(r == -EINVAL);
 130 }
 131
 132 static void test_strstrip(void) {
 133        char *r;
 134        char input[] = "   hello, waldo.   ";
 135
 136        r = strstrip(input);
 137        assert_se(streq(r, "hello, waldo."));
 138
 139 }
 140
 141 static void test_delete_chars(void) {
 142        char *r;
 143        char input[] = "   hello, waldo.   abc";
 144
 145        r = delete_chars(input, WHITESPACE);
 146        assert_se(streq(r, "hello,waldo.abc"));
 147 }
 148
 149 static void test_in_charset(void) {
 150       assert_se(in_charset("dddaaabbbcccc", "abcd"));
 151       assert_se(!in_charset("dddaaabbbcccc", "abc f"));
 152 }
 153
 154 static void test_hexchar(void) {
 155         assert_se(hexchar(0xa) == 'a');
 156         assert_se(hexchar(0x0) == '0');
 157 }
 158
 159 static void test_unhexchar(void) {
 160         assert_se(unhexchar('a') == 0xA);
 161         assert_se(unhexchar('A') == 0xA);
 162         assert_se(unhexchar('0') == 0x0);
 163 }
 164
 165 static void test_octchar(void) {
 166         assert_se(octchar(00) == '0');
 167         assert_se(octchar(07) == '7');
 168 }
 169
 170 static void test_unoctchar(void) {
 171         assert_se(unoctchar('0') == 00);
 172         assert_se(unoctchar('7') == 07);
 173 }
 174
 175 static void test_decchar(void) {
 176         assert_se(decchar(0) == '0');
 177         assert_se(decchar(9) == '9');
 178 }
 179
 180 static void test_undecchar(void) {
 181         assert_se(undecchar('0') == 0);
 182         assert_se(undecchar('9') == 9);
 183 }
 184
 185 static void test_foreach_word(void) {
 186         char *w, *state;
 187         size_t l;
 188         int i = 0;
 189         const char test[] = "test abc d\te   f   ";
 190         const char * const expected[] = {
 191                 "test",
 192                 "abc",
 193                 "d",
 194                 "e",
 195                 "f",
 196                 "",
 197                 NULL
 198         };
 199
 200         FOREACH_WORD(w, l, test, state) {
 201                 assert_se(strneq(expected[i++], w, l));
 202         }
 203 }
 204
 205 static void test_foreach_word_quoted(void) {
 206         char *w, *state;
 207         size_t l;
 208         int i = 0;
 209         const char test[] = "test a b c 'd' e '' '' hhh '' '' \"a b c\"";
 210         const char * const expected[] = {
 211                 "test",
 212                 "a",
 213                 "b",
 214                 "c",
 215                 "d",
 216                 "e",
 217                 "",
 218                 "",
 219                 "hhh",
 220                 "",
 221                 "",
 222                 "a b c",
 223                 NULL
 224         };
 225
 226         printf("<%s>\n", test);
 227         FOREACH_WORD_QUOTED(w, l, test, state) {
 228                 _cleanup_free_ char *t = NULL;
 229
 230                 assert_se(t = strndup(w, l));
 231                 assert_se(strneq(expected[i++], w, l));
 232                 printf("<%s>\n", t);
 233         }
 234 }
 235
 236 static void test_default_term_for_tty(void) {
 237         puts(default_term_for_tty("/dev/tty23"));
 238         puts(default_term_for_tty("/dev/ttyS23"));
 239         puts(default_term_for_tty("/dev/tty0"));
 240         puts(default_term_for_tty("/dev/pty0"));
 241         puts(default_term_for_tty("/dev/pts/0"));
 242         puts(default_term_for_tty("/dev/console"));
 243         puts(default_term_for_tty("tty23"));
 244         puts(default_term_for_tty("ttyS23"));
 245         puts(default_term_for_tty("tty0"));
 246         puts(default_term_for_tty("pty0"));
 247         puts(default_term_for_tty("pts/0"));
 248         puts(default_term_for_tty("console"));
 249 }
 250
 251 static void test_memdup_multiply(void) {
 252         int org[] = {1, 2, 3};
 253         int *dup;
 254
 255         dup = (int*)memdup_multiply(org, sizeof(int), 3);
 256
 257         assert_se(dup);
 258         assert_se(dup[0] == 1);
 259         assert_se(dup[1] == 2);
 260         assert_se(dup[2] == 3);
 261         free(dup);
 262 }
 263
 264 static void test_bus_path_escape_one(const char *a, const char *b) {
 265         _cleanup_free_ char *t = NULL, *x = NULL, *y = NULL;
 266
 267         assert_se(t = bus_path_escape(a));
 268         assert_se(streq(t, b));
 269
 270         assert_se(x = bus_path_unescape(t));
 271         assert_se(streq(a, x));
 272
 273         assert_se(y = bus_path_unescape(b));
 274         assert_se(streq(a, y));
 275 }
 276
 277 static void test_bus_path_escape(void) {
 278         test_bus_path_escape_one("foo123bar", "foo123bar");
 279         test_bus_path_escape_one("foo.bar", "foo_2ebar");
 280         test_bus_path_escape_one("foo_2ebar", "foo_5f2ebar");
 281         test_bus_path_escape_one("", "_");
 282         test_bus_path_escape_one("_", "_5f");
 283         test_bus_path_escape_one("1", "_31");
 284         test_bus_path_escape_one(":1", "_3a1");
 285 }
 286
 287 int main(int argc, char *argv[]) {
 288         test_streq_ptr();
 289         test_first_word();
 290         test_parse_boolean();
 291         test_parse_pid();
 292         test_parse_uid();
 293         test_safe_atolli();
 294         test_safe_atod();
 295         test_strstrip();
 296         test_delete_chars();
 297         test_in_charset();
 298         test_hexchar();
 299         test_unhexchar();
 300         test_octchar();
 301         test_unoctchar();
 302         test_decchar();
 303         test_undecchar();
 304         test_foreach_word();
 305         test_foreach_word_quoted();
 306         test_default_term_for_tty();
 307         test_memdup_multiply();
 308         test_bus_path_escape();
 309
 310         return 0;
 311 }