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_foreach_word(void) {
 155         char *w, *state;
 156         size_t l;
 157         int i = 0;
 158         const char test[] = "test abc d\te   f   ";
 159         const char * const expected[] = {
 160                 "test",
 161                 "abc",
 162                 "d",
 163                 "e",
 164                 "f",
 165                 "",
 166                 NULL
 167         };
 168
 169         FOREACH_WORD(w, l, test, state) {
 170                 assert_se(strneq(expected[i++], w, l));
 171         }
 172 }
 173
 174 static void test_foreach_word_quoted(void) {
 175         char *w, *state;
 176         size_t l;
 177         int i = 0;
 178         const char test[] = "test a b c 'd' e '' '' hhh '' '' \"a b c\"";
 179         const char * const expected[] = {
 180                 "test",
 181                 "a",
 182                 "b",
 183                 "c",
 184                 "d",
 185                 "e",
 186                 "",
 187                 "",
 188                 "hhh",
 189                 "",
 190                 "",
 191                 "a b c",
 192                 NULL
 193         };
 194
 195         printf("<%s>\n", test);
 196         FOREACH_WORD_QUOTED(w, l, test, state) {
 197                 _cleanup_free_ char *t = NULL;
 198
 199                 assert_se(t = strndup(w, l));
 200                 assert_se(strneq(expected[i++], w, l));
 201                 printf("<%s>\n", t);
 202         }
 203 }
 204
 205 static void test_default_term_for_tty(void) {
 206         puts(default_term_for_tty("/dev/tty23"));
 207         puts(default_term_for_tty("/dev/ttyS23"));
 208         puts(default_term_for_tty("/dev/tty0"));
 209         puts(default_term_for_tty("/dev/pty0"));
 210         puts(default_term_for_tty("/dev/pts/0"));
 211         puts(default_term_for_tty("/dev/console"));
 212         puts(default_term_for_tty("tty23"));
 213         puts(default_term_for_tty("ttyS23"));
 214         puts(default_term_for_tty("tty0"));
 215         puts(default_term_for_tty("pty0"));
 216         puts(default_term_for_tty("pts/0"));
 217         puts(default_term_for_tty("console"));
 218 }
 219
 220 static void test_memdup_multiply(void) {
 221         int org[] = {1, 2, 3};
 222         int *dup;
 223
 224         dup = (int*)memdup_multiply(org, sizeof(int), 3);
 225
 226         assert_se(dup);
 227         assert_se(dup[0] == 1);
 228         assert_se(dup[1] == 2);
 229         assert_se(dup[2] == 3);
 230         free(dup);
 231 }
 232
 233 int main(int argc, char *argv[]) {
 234         test_streq_ptr();
 235         test_first_word();
 236         test_parse_boolean();
 237         test_parse_pid();
 238         test_parse_uid();
 239         test_safe_atolli();
 240         test_safe_atod();
 241         test_strstrip();
 242         test_delete_chars();
 243         test_in_charset();
 244         test_foreach_word();
 245         test_foreach_word_quoted();
 246         test_default_term_for_tty();
 247         test_memdup_multiply();
 248
 249         return 0;
 250 }