lib/util/tests/strlist.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    util_strlist testing
   5
   6    Copyright (C) Jelmer Vernooij 2005
   7    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2009
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21 */
  22
  23 #include "includes.h"
  24 #include "torture/torture.h"
  25
  26 struct test_list_element {
  27         const char *list_as_string;
  28         const char *seperators;
  29         const char *list[5];
  30 };
  31
  32 struct test_list_element test_lists_strings[] = {
  33         {
  34                 .list_as_string = "",
  35                 .list = { NULL }
  36         },
  37         {
  38                 .list_as_string = "foo",
  39                 .list = { "foo", NULL }
  40         },
  41         {
  42                 .list_as_string = "foo bar",
  43                 .list = { "foo", "bar", NULL }
  44         },
  45         {
  46                 .list_as_string = "foo bar",
  47                 .list = { "foo bar", NULL },
  48                 .seperators = ";"
  49         },
  50         {
  51                 .list_as_string = "\"foo bar\"",
  52                 .list = { "\"foo", "bar\"", NULL }
  53         },
  54         {
  55                 .list_as_string = "\"foo bar\",comma\ttab",
  56                 .list = { "\"foo", "bar\"", "comma", "tab", NULL }
  57         },
  58         {
  59                 .list_as_string = "\"foo bar\",comma;semicolon",
  60                 .list = { "\"foo bar\",comma", "semicolon", NULL },
  61                 .seperators = ";"
  62         }
  63 };
  64
  65 struct test_list_element test_lists_shell_strings[] = {
  66         {
  67                 .list_as_string = "",
  68                 .list = { NULL }
  69         },
  70         {
  71                 .list_as_string = "foo",
  72                 .list = { "foo", NULL }
  73         },
  74         {
  75                 .list_as_string = "foo bar",
  76                 .list = { "foo", "bar", NULL }
  77         },
  78         {
  79                 .list_as_string = "foo bar",
  80                 .list = { "foo bar", NULL },
  81                 .seperators = ";"
  82         },
  83         {
  84                 .list_as_string = "\"foo bar\"",
  85                 .list = { "foo bar", NULL }
  86         },
  87         {
  88                 .list_as_string = "foo bar \"bla \"",
  89                 .list = { "foo", "bar", "bla ", NULL }
  90         },
  91         {
  92                 .list_as_string = "foo \"\" bla",
  93                 .list = { "foo", "", "bla", NULL },
  94         },
  95         {
  96                 .list_as_string = "bla \"\"\"\" blie",
  97                 .list = { "bla", "", "", "blie", NULL },
  98         }
  99 };
 100
 101 static bool test_lists_shell(struct torture_context *tctx,
 102                              const void *data)
 103 {
 104         const struct test_list_element *element = data;
 105         const char **ret1, **ret2, *tmp;
 106         bool match = true;
 107         TALLOC_CTX *mem_ctx = tctx;
 108
 109         ret1 = str_list_make_shell(mem_ctx, element->list_as_string, element->seperators);
 110
 111         torture_assert(tctx, ret1, "str_list_make_shell() must not return NULL");
 112         tmp = str_list_join_shell(mem_ctx, ret1, element->seperators ? *element->seperators : ' ');
 113         ret2 = str_list_make_shell(mem_ctx, tmp, element->seperators);
 114
 115         if ((ret1 == NULL || ret2 == NULL) && ret2 != ret1) {
 116                 match = false;
 117         } else {
 118                 int j;
 119                 for (j = 0; ret1[j] && ret2[j]; j++) {
 120                         if (strcmp(ret1[j], ret2[j]) != 0) {
 121                                 match = false;
 122                                 break;
 123                         }
 124                 }
 125
 126                 if (ret1[j] || ret2[j])
 127                         match = false;
 128         }
 129
 130         torture_assert(tctx, match, talloc_asprintf(tctx,
 131                 "str_list_{make,join}_shell: Error double parsing, first run:\n%s\nSecond run: \n%s", element->list_as_string, tmp));
 132         torture_assert(tctx, str_list_equal(ret1, element->list),
 133                        talloc_asprintf(tctx,
 134                                        "str_list_make_shell(%s) failed to create correct list",
 135                                        element->list_as_string));
 136
 137         return true;
 138 }
 139
 140 static bool test_list_make(struct torture_context *tctx, const void *data)
 141 {
 142         const struct test_list_element *element = data;
 143         char **result;
 144         result = str_list_make(tctx, element->list_as_string, element->seperators);
 145         torture_assert(tctx, result, "str_list_make() must not return NULL");
 146         torture_assert(tctx, str_list_equal((const char **)result, element->list),
 147                        talloc_asprintf(tctx,
 148                                        "str_list_make(%s) failed to create correct list",
 149                                        element->list_as_string));
 150         return true;
 151 }
 152
 153 static bool test_list_copy(struct torture_context *tctx)
 154 {
 155         const char **result;
 156         const char *list[] = { "foo", "bar", NULL };
 157         const char *empty_list[] = { NULL };
 158         const char **null_list = NULL;
 159
 160         result = (const char **)str_list_copy(tctx, list);
 161         torture_assert_int_equal(tctx, str_list_length(result), 2, "list length");
 162         torture_assert_str_equal(tctx, result[0], "foo", "element 0");
 163         torture_assert_str_equal(tctx, result[1], "bar", "element 1");
 164         torture_assert_str_equal(tctx, result[2], NULL, "element 2");
 165
 166         result = (const char **)str_list_copy(tctx, empty_list);
 167         torture_assert_int_equal(tctx, str_list_length(result), 0, "list length");
 168         torture_assert_str_equal(tctx, result[0], NULL, "element 0");
 169
 170         result = (const char **)str_list_copy(tctx, null_list);
 171         torture_assert(tctx, result == NULL, "result NULL");
 172
 173         return true;
 174 }
 175
 176 static bool test_list_make_empty(struct torture_context *tctx)
 177 {
 178         char **result;
 179
 180         result = str_list_make_empty(tctx);
 181         torture_assert(tctx, result, "str_list_make_empty() must not return NULL");
 182         torture_assert(tctx, result[0] == NULL, "first element in str_list_make_empty() result must be NULL");
 183
 184         result = str_list_make(tctx, NULL, NULL);
 185         torture_assert(tctx, result, "str_list_make() must not return NULL");
 186         torture_assert(tctx, result[0] == NULL, "first element in str_list_make(ctx, NULL, NULL) result must be NULL");
 187
 188         result = str_list_make(tctx, "", NULL);
 189         torture_assert(tctx, result, "str_list_make() must not return NULL");
 190         torture_assert(tctx, result[0] == NULL, "first element in str_list_make(ctx, "", NULL) result must be NULL");
 191
 192         return true;
 193 }
 194
 195 static bool test_list_make_single(struct torture_context *tctx)
 196 {
 197         char **result;
 198
 199         result = str_list_make_single(tctx, "foo");
 200
 201         torture_assert(tctx, result, "str_list_make_single() must not return NULL");
 202         torture_assert_str_equal(tctx, result[0], "foo", "element 0");
 203         torture_assert(tctx, result[1] == NULL, "second element in result must be NULL");
 204
 205         return true;
 206 }
 207
 208 static bool test_list_copy_const(struct torture_context *tctx)
 209 {
 210         const char **result;
 211         const char *list[] = {
 212                 "element_0",
 213                 "element_1",
 214                 "element_2",
 215                 "element_3",
 216                 NULL
 217         };
 218         result = str_list_copy_const(tctx, list);
 219         torture_assert(tctx, result, "str_list_copy() must not return NULL");
 220         torture_assert(tctx, str_list_equal(result, list),
 221                        "str_list_copy() failed");
 222
 223         return true;
 224 }
 225
 226 static bool test_list_length(struct torture_context *tctx)
 227 {
 228         const char *list[] = {
 229                 "element_0",
 230                 "element_1",
 231                 "element_2",
 232                 "element_3",
 233                 NULL
 234         };
 235         const char *list2[] = {
 236                 NULL
 237         };
 238         torture_assert_int_equal(tctx, str_list_length(list), 4,
 239                        "str_list_length() failed");
 240
 241         torture_assert_int_equal(tctx, str_list_length(list2), 0,
 242                        "str_list_length() failed");
 243
 244         torture_assert_int_equal(tctx, str_list_length(NULL), 0,
 245                        "str_list_length() failed");
 246
 247         return true;
 248 }
 249
 250 static bool test_list_add(struct torture_context *tctx)
 251 {
 252         char **result, **result2;
 253         const char *list[] = {
 254                 "element_0",
 255                 "element_1",
 256                 "element_2",
 257                 "element_3",
 258                 NULL
 259         };
 260         result = str_list_make(tctx, "element_0, element_1, element_2", NULL);
 261         torture_assert(tctx, result, "str_list_make() must not return NULL");
 262         result2 = str_list_add(result, "element_3");
 263         torture_assert(tctx, result2, "str_list_add() must not return NULL");
 264         torture_assert(tctx, str_list_equal(result2, list),
 265                        "str_list_add() failed");
 266
 267         return true;
 268 }
 269
 270 static bool test_list_add_const(struct torture_context *tctx)
 271 {
 272         char **result, **result2;
 273         const char *list[] = {
 274                 "element_0",
 275                 "element_1",
 276                 "element_2",
 277                 "element_3",
 278                 NULL
 279         };
 280         result = str_list_make(tctx, "element_0, element_1, element_2", NULL);
 281         torture_assert(tctx, result, "str_list_make() must not return NULL");
 282         result2 = str_list_add_const(result, "element_3");
 283         torture_assert(tctx, result2, "str_list_add_const() must not return NULL");
 284         torture_assert(tctx, str_list_equal(result2, list),
 285                        "str_list_add() failed");
 286
 287         return true;
 288 }
 289
 290 static bool test_list_remove(struct torture_context *tctx)
 291 {
 292         char **result;
 293         const char *list[] = {
 294                 "element_0",
 295                 "element_1",
 296                 "element_3",
 297                 NULL
 298         };
 299         result = str_list_make(tctx, "element_0, element_1, element_2, element_3", NULL);
 300         torture_assert(tctx, result, "str_list_make() must not return NULL");
 301         str_list_remove(result, "element_2");
 302         torture_assert(tctx, str_list_equal(result, list),
 303                        "str_list_remove() failed");
 304
 305         return true;
 306 }
 307
 308 static bool test_list_check(struct torture_context *tctx)
 309 {
 310         const char *list[] = {
 311                 "element_0",
 312                 "element_1",
 313                 "element_2",
 314                 NULL
 315         };
 316         torture_assert(tctx, str_list_check(list, "element_1"),
 317                        "str_list_check() failed");
 318
 319         return true;
 320 }
 321
 322 static bool test_list_check_ci(struct torture_context *tctx)
 323 {
 324         const char *list[] = {
 325                 "element_0",
 326                 "element_1",
 327                 "element_2",
 328                 NULL
 329         };
 330         torture_assert(tctx, str_list_check_ci(list, "ELEMENT_1"),
 331                        "str_list_check_ci() failed");
 332
 333         return true;
 334 }
 335
 336 static bool test_list_unique(struct torture_context *tctx)
 337 {
 338         char **result;
 339         const char *list[] = {
 340                 "element_0",
 341                 "element_1",
 342                 "element_2",
 343                 NULL
 344         };
 345         const char *list_dup[] = {
 346                 "element_0",
 347                 "element_1",
 348                 "element_2",
 349                 "element_0",
 350                 "element_2",
 351                 "element_1",
 352                 "element_1",
 353                 "element_2",
 354                 NULL
 355         };
 356         result = str_list_copy(tctx, list_dup);
 357         /* We must copy the list, as str_list_unique does a talloc_realloc() on it's parameter */
 358         result = str_list_unique(result);
 359         torture_assert(tctx, result, "str_list_unique() must not return NULL");
 360
 361         torture_assert(tctx, str_list_equal(list, result),
 362                        "str_list_unique() failed");
 363
 364         return true;
 365 }
 366
 367 static bool test_list_append(struct torture_context *tctx)
 368 {
 369         char **result;
 370         const char *list[] = {
 371                 "element_0",
 372                 "element_1",
 373                 "element_2",
 374                 NULL
 375         };
 376         const char *list2[] = {
 377                 "element_3",
 378                 "element_4",
 379                 "element_5",
 380                 NULL
 381         };
 382         const char *list_combined[] = {
 383                 "element_0",
 384                 "element_1",
 385                 "element_2",
 386                 "element_3",
 387                 "element_4",
 388                 "element_5",
 389                 NULL
 390         };
 391         result = str_list_copy(tctx, list);
 392         torture_assert(tctx, result, "str_list_copy() must not return NULL");
 393         result = str_list_append(result, list2);
 394         torture_assert(tctx, result, "str_list_append() must not return NULL");
 395         torture_assert(tctx, str_list_equal(list_combined, result),
 396                        "str_list_unique() failed");
 397
 398         return true;
 399 }
 400
 401 static bool test_list_append_const(struct torture_context *tctx)
 402 {
 403         char **result;
 404         const char *list[] = {
 405                 "element_0",
 406                 "element_1",
 407                 "element_2",
 408                 NULL
 409         };
 410         const char *list2[] = {
 411                 "element_3",
 412                 "element_4",
 413                 "element_5",
 414                 NULL
 415         };
 416         const char *list_combined[] = {
 417                 "element_0",
 418                 "element_1",
 419                 "element_2",
 420                 "element_3",
 421                 "element_4",
 422                 "element_5",
 423                 NULL
 424         };
 425         result = str_list_copy(tctx, list);
 426         torture_assert(tctx, result, "str_list_copy() must not return NULL");
 427         result = str_list_append_const(result, list2);
 428         torture_assert(tctx, result, "str_list_append_const() must not return NULL");
 429         torture_assert(tctx, str_list_equal(list_combined, result),
 430                        "str_list_unique() failed");
 431
 432         return true;
 433 }
 434
 435 struct torture_suite *torture_local_util_strlist(TALLOC_CTX *mem_ctx)
 436 {
 437         struct torture_suite *suite = torture_suite_create(mem_ctx, "STRLIST");
 438         int i;
 439
 440         for (i = 0; i < ARRAY_SIZE(test_lists_shell_strings); i++) {
 441                 torture_suite_add_simple_tcase_const(suite, "lists_shell",
 442                                 test_lists_shell, &test_lists_shell_strings[i]);
 443         }
 444
 445         for (i = 0; i < ARRAY_SIZE(test_lists_strings); i++) {
 446                 torture_suite_add_simple_tcase_const(suite, "lists",
 447                                                      test_list_make, &test_lists_strings[i]);
 448         }
 449
 450         torture_suite_add_simple_test(suite, "list_copy", test_list_copy);
 451         torture_suite_add_simple_test(suite, "make_empty", test_list_make_empty);
 452         torture_suite_add_simple_test(suite, "make_single", test_list_make_single);
 453         torture_suite_add_simple_test(suite, "list_copy_const", test_list_copy_const);
 454         torture_suite_add_simple_test(suite, "list_length", test_list_length);
 455         torture_suite_add_simple_test(suite, "list_add", test_list_add);
 456         torture_suite_add_simple_test(suite, "list_add_const", test_list_add_const);
 457         torture_suite_add_simple_test(suite, "list_remove", test_list_remove);
 458         torture_suite_add_simple_test(suite, "list_check", test_list_check);
 459         torture_suite_add_simple_test(suite, "list_check_ci", test_list_check_ci);
 460         torture_suite_add_simple_test(suite, "list_unique", test_list_unique);
 461         torture_suite_add_simple_test(suite, "list_append", test_list_append);
 462         torture_suite_add_simple_test(suite, "list_append_const", test_list_append_const);
 463
 464         return suite;
 465 }