src/test/test-strv.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 #include "specifier.h"
  27 #include "strv.h"
  28
  29 static void test_specifier_printf(void) {
  30         char *w;
  31
  32         const Specifier table[] = {
  33                 { 'a', specifier_string, (char*) "AAAA" },
  34                 { 'b', specifier_string, (char*) "BBBB" },
  35                 { 0, NULL, NULL }
  36         };
  37
  38         w = specifier_printf("xxx a=%a b=%b yyy", table, NULL);
  39         printf("<%s>\n", w);
  40         free(w);
  41 }
  42
  43 static void test_strv_find(void) {
  44         const char * const input_table[] = {
  45                 "one",
  46                 "two",
  47                 "three",
  48                 NULL
  49         };
  50
  51         assert_se(strv_find((char **)input_table, "three"));
  52         assert_se(!strv_find((char **)input_table, "four"));
  53 }
  54
  55 static void test_strv_find_prefix(void) {
  56         const char * const input_table[] = {
  57                 "one",
  58                 "two",
  59                 "three",
  60                 NULL
  61         };
  62
  63         assert_se(strv_find_prefix((char **)input_table, "o"));
  64         assert_se(strv_find_prefix((char **)input_table, "one"));
  65         assert_se(strv_find_prefix((char **)input_table, ""));
  66         assert_se(!strv_find_prefix((char **)input_table, "xxx"));
  67         assert_se(!strv_find_prefix((char **)input_table, "onee"));
  68 }
  69
  70 static void test_strv_join(void) {
  71         _cleanup_free_ char *p = NULL, *q = NULL, *r = NULL, *s = NULL, *t = NULL;
  72
  73         const char * const input_table_multiple[] = {
  74                 "one",
  75                 "two",
  76                 "three",
  77                 NULL
  78         };
  79         const char * const input_table_one[] = {
  80                 "one",
  81                 NULL
  82         };
  83         const char * const input_table_none[] = {
  84                 NULL
  85         };
  86
  87         p = strv_join((char **)input_table_multiple, ", ");
  88         assert_se(streq(p, "one, two, three"));
  89
  90         q = strv_join((char **)input_table_multiple, ";");
  91         assert_se(streq(q, "one;two;three"));
  92
  93         r = strv_join((char **)input_table_multiple, NULL);
  94         assert_se(streq(r, "one two three"));
  95
  96         s = strv_join((char **)input_table_one, ", ");
  97         assert_se(streq(s, "one"));
  98
  99         t = strv_join((char **)input_table_none, ", ");
 100         assert_se(streq(t, ""));
 101 }
 102
 103 static void test_strv_parse_nulstr(void) {
 104         _cleanup_strv_free_ char **l = NULL;
 105         const char nulstr[] = "fuck\0fuck2\0fuck3\0\0fuck5\0\0xxx";
 106
 107         l = strv_parse_nulstr(nulstr, sizeof(nulstr)-1);
 108         puts("Parse nulstr:");
 109         strv_print(l);
 110
 111         assert_se(streq(l[0], "fuck"));
 112         assert_se(streq(l[1], "fuck2"));
 113         assert_se(streq(l[2], "fuck3"));
 114         assert_se(streq(l[3], ""));
 115         assert_se(streq(l[4], "fuck5"));
 116         assert_se(streq(l[5], ""));
 117         assert_se(streq(l[6], "xxx"));
 118 }
 119
 120 static void test_strv_overlap(void) {
 121         const char * const input_table[] = {
 122                 "one",
 123                 "two",
 124                 "three",
 125                 NULL
 126         };
 127         const char * const input_table_overlap[] = {
 128                 "two",
 129                 NULL
 130         };
 131         const char * const input_table_unique[] = {
 132                 "four",
 133                 "five",
 134                 "six",
 135                 NULL
 136         };
 137
 138         assert_se(strv_overlap((char **)input_table, (char**)input_table_overlap));
 139         assert_se(!strv_overlap((char **)input_table, (char**)input_table_unique));
 140 }
 141
 142 static void test_strv_sort(void) {
 143         const char * const input_table[] = {
 144                 "durian",
 145                 "apple",
 146                 "citrus",
 147                  "CAPITAL LETTERS FIRST",
 148                 "banana",
 149                 NULL
 150         };
 151
 152         strv_sort((char **)input_table);
 153
 154         assert_se(streq(input_table[0], "CAPITAL LETTERS FIRST"));
 155         assert_se(streq(input_table[1], "apple"));
 156         assert_se(streq(input_table[2], "banana"));
 157         assert_se(streq(input_table[3], "citrus"));
 158         assert_se(streq(input_table[4], "durian"));
 159 }
 160
 161 static void test_strv_merge_concat(void) {
 162          _cleanup_strv_free_ char **a = NULL, **b = NULL, **c = NULL;
 163
 164         a = strv_new("without", "suffix", NULL);
 165         b = strv_new("with", "suffix", NULL);
 166
 167         c = strv_merge_concat(a, b, "_suffix");
 168
 169         assert_se(streq(c[0], "without"));
 170         assert_se(streq(c[1], "suffix"));
 171         assert_se(streq(c[2], "with_suffix"));
 172         assert_se(streq(c[3], "suffix_suffix"));
 173 }
 174
 175 static void test_strv_merge(void) {
 176          _cleanup_strv_free_ char **a = NULL, **b = NULL, **c = NULL;
 177
 178         a = strv_new("abc", "def", "ghi", NULL);
 179         b = strv_new("jkl", "mno", "pqr", NULL);
 180
 181         c = strv_merge(a, b);
 182
 183         assert_se(streq(c[0], "abc"));
 184         assert_se(streq(c[1], "def"));
 185         assert_se(streq(c[2], "ghi"));
 186         assert_se(streq(c[3], "jkl"));
 187         assert_se(streq(c[4], "mno"));
 188         assert_se(streq(c[5], "pqr"));
 189
 190         assert_se(strv_length(c) == 6);
 191 }
 192
 193 static void test_strv_append(void) {
 194         _cleanup_strv_free_ char **a = NULL, **b = NULL, **c = NULL;
 195
 196         a = strv_new("test", "test1", NULL);
 197         b = strv_append(a, "test2");
 198         c = strv_append(NULL, "test3");
 199
 200         assert_se(streq(b[0], "test"));
 201         assert_se(streq(b[1], "test1"));
 202         assert_se(streq(b[2], "test2"));
 203         assert_se(streq(c[0], "test3"));
 204 }
 205
 206 int main(int argc, char *argv[]) {
 207         test_specifier_printf();
 208         test_strv_find();
 209         test_strv_find_prefix();
 210         test_strv_join();
 211         test_strv_parse_nulstr();
 212         test_strv_overlap();
 213         test_strv_sort();
 214         test_strv_merge();
 215         test_strv_merge_concat();
 216         test_strv_append();
 217
 218         return 0;
 219 }