t/unit/utils/llist_test.c

   1 /*
   2  * SysDB - t/unit/utils/llist_test.c
   3  * Copyright (C) 2013 Sebastian 'tokkee' Harl <sh@tokkee.org>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  16  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  17  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  18  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
  19  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  22  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  23  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  24  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  25  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #include "utils/llist.h"
  29 #include "libsysdb_test.h"
  30
  31 #include <check.h>
  32
  33 /*
  34  * private data types
  35  */
  36
  37 static sdb_object_t golden_data[] = {
  38         SDB_OBJECT_STATIC("abc"),
  39         SDB_OBJECT_STATIC("bcd"),
  40         SDB_OBJECT_STATIC("cde"),
  41         SDB_OBJECT_STATIC("def"),
  42         SDB_OBJECT_STATIC("efg"),
  43         SDB_OBJECT_STATIC("fgh"),
  44         SDB_OBJECT_STATIC("ghi")
  45 };
  46
  47 static char *unused_names[] = {
  48         "xyz",
  49         "yza",
  50         "zab"
  51 };
  52
  53 static sdb_llist_t *list;
  54
  55 static void
  56 setup(void)
  57 {
  58         list = sdb_llist_create();
  59         fail_unless(list != NULL,
  60                         "sdb_llist_create() = NULL; expected list object");
  61 } /* setup */
  62
  63 static void
  64 teardown(void)
  65 {
  66         sdb_llist_destroy(list);
  67         list = NULL;
  68 } /* teardown */
  69
  70 /* populate the list with the golden data in the specified order */
  71 static void
  72 populate(void)
  73 {
  74         size_t i;
  75         for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
  76                 int check = sdb_llist_append(list, &golden_data[i]);
  77                 fail_unless(check == 0,
  78                                 "sdb_llist_append(%s) = %i; expected: 0",
  79                                 golden_data[i].name, check);
  80         }
  81 } /* populate */
  82
  83 START_TEST(test_clone)
  84 {
  85         sdb_llist_t *clone;
  86         size_t i;
  87
  88         populate();
  89
  90         clone = sdb_llist_clone(list);
  91         fail_unless(clone != NULL,
  92                         "sdb_llist_clone() = NULL; expected: cloned list object");
  93
  94         for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
  95                 fail_unless(golden_data[i].ref_cnt == 3,
  96                                 "sdb_llist_clone() did not take ownership");
  97         }
  98
  99         sdb_llist_destroy(clone);
 100 }
 101 END_TEST
 102
 103 START_TEST(test_destroy)
 104 {
 105         size_t i;
 106         populate();
 107         sdb_llist_destroy(list);
 108         list = NULL;
 109
 110         for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
 111                 fail_unless(golden_data[i].ref_cnt == 1,
 112                                 "sdb_llist_destroy() did not deref element %s",
 113                                 golden_data[i].name);
 114         }
 115 }
 116 END_TEST
 117
 118 START_TEST(test_clear)
 119 {
 120         size_t i;
 121         populate();
 122         sdb_llist_clear(list);
 123
 124         for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
 125                 fail_unless(golden_data[i].ref_cnt == 1,
 126                                 "sdb_llist_clear() did not deref element %s",
 127                                 golden_data[i].name);
 128         }
 129
 130         i = sdb_llist_len(list);
 131         fail_unless(i == 0,
 132                         "sdb_llist_clear() left %zu elements in the list; "
 133                         "expected: 0", i);
 134 }
 135 END_TEST
 136
 137 START_TEST(test_append)
 138 {
 139         size_t i;
 140
 141         fail_unless(sdb_llist_len(list) == 0,
 142                         "sdb_llist_len(<empty list>) = %zu; expected: 0",
 143                         sdb_llist_len(list));
 144
 145         for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
 146                 int check = sdb_llist_append(list, &golden_data[i]);
 147                 fail_unless(check == 0,
 148                                 "sdb_llist_append(%s) = %i; expected: 0",
 149                                 golden_data[i].name, check);
 150                 fail_unless(golden_data[i].ref_cnt == 2,
 151                                 "sdb_llist_append(%s) did not take ownership",
 152                                 golden_data[i].name);
 153                 fail_unless(sdb_llist_len(list) == i + 1,
 154                                 "sdb_llist_len(<empty list>) = %zu; expected: zu",
 155                                 sdb_llist_len(list), i + 1);
 156         }
 157 }
 158 END_TEST
 159
 160 START_TEST(test_insert)
 161 {
 162         size_t i;
 163         for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
 164                 int check = sdb_llist_insert(list, &golden_data[i], 0);
 165                 fail_unless(check == 0,
 166                                 "sdb_llist_insert(%s, 0) = %i; expected: 0",
 167                                 golden_data[i].name, check);
 168                 fail_unless(golden_data[i].ref_cnt == 2,
 169                                 "sdb_llist_insert(%s, 0) did not take ownership",
 170                                 golden_data[i].name);
 171         }
 172 }
 173 END_TEST
 174
 175 START_TEST(test_validate_insert)
 176 {
 177         size_t i;
 178         for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
 179                 /* none of these operations will succeed
 180                  * => 1 is invalid for each case */
 181                 int check = sdb_llist_insert(list, &golden_data[i], 1);
 182                 fail_unless(check == -1,
 183                                 "sdb_llist_insert(%s, 1) = %i; expected: -1",
 184                                 golden_data[i].name, check);
 185                 fail_unless(golden_data[i].ref_cnt == 1,
 186                                 "sdb_llist_insert(%s, 1) took ownership",
 187                                 golden_data[i].name);
 188         }
 189 }
 190 END_TEST
 191
 192 START_TEST(test_get)
 193 {
 194         size_t i;
 195         populate();
 196         for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
 197                 sdb_object_t *check = sdb_llist_get(list, i);
 198                 fail_unless(check == &golden_data[i],
 199                                 "sdb_llist_get() = %p; expected: %p",
 200                                 check, &golden_data[i]);
 201                 fail_unless(check->ref_cnt == 3,
 202                                 "sdb_llist_get() didn't increment reference count; got: %i; "
 203                                 "expected: 3", check->ref_cnt);
 204                 sdb_object_deref(check);
 205         }
 206 }
 207 END_TEST
 208
 209 START_TEST(test_remove_by_name)
 210 {
 211         /* "random" indexes */
 212         int indexes[] = { 4, 5, 3, 6, 2, 0, 1 };
 213         size_t i;
 214
 215         populate();
 216
 217         for (i = 0; i < SDB_STATIC_ARRAY_LEN(indexes); ++i) {
 218                 sdb_object_t *check;
 219
 220                 fail_unless((size_t)indexes[i] < SDB_STATIC_ARRAY_LEN(golden_data),
 221                                 "INTERNAL ERROR: invalid index %i", indexes[i]);
 222
 223                 check = sdb_llist_remove_by_name(list, golden_data[indexes[i]].name);
 224                 fail_unless(check == &golden_data[indexes[i]],
 225                                 "sdb_llist_remove_by_name() = %p; expected: %p",
 226                                 check, &golden_data[indexes[i]]);
 227                 fail_unless(check->ref_cnt == 2,
 228                                 "sdb_llist_remove_by_name() returned unexpected reference "
 229                                 "count; got: %i; expected: 2", check->ref_cnt);
 230
 231                 check = sdb_llist_remove_by_name(list, golden_data[indexes[i]].name);
 232                 fail_unless(check == NULL,
 233                                 "sdb_llist_remove_by_name() did not remove the element");
 234         }
 235 }
 236 END_TEST
 237
 238 static int
 239 dummy_lookup(const sdb_object_t __attribute__((unused)) *obj,
 240                 const void __attribute__((unused)) *user_data)
 241 {
 242         return 0;
 243 } /* dummy_lookup */
 244
 245 START_TEST(test_search)
 246 {
 247         size_t i;
 248         populate();
 249         for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
 250                 sdb_object_t *check = sdb_llist_search_by_name(list,
 251                                 golden_data[i].name);
 252                 fail_unless(check == &golden_data[i],
 253                                 "sdb_llist_search_by_name(%s) = NULL; expected: %p",
 254                                 golden_data[i].name, &golden_data[i]);
 255         }
 256
 257         for (i = 0; i < SDB_STATIC_ARRAY_LEN(unused_names); ++i) {
 258                 sdb_object_t *check = sdb_llist_search_by_name(list,
 259                                 unused_names[i]);
 260                 fail_unless(check == NULL,
 261                                 "sdb_llist_search_by_name(%s) = %p; expected: NULL",
 262                                 unused_names[i], check);
 263         }
 264
 265         for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
 266                 /* dummy_lookup always return 0, thus, this will always return the
 267                  * first element */
 268                 sdb_object_t *check = sdb_llist_search(list, dummy_lookup, NULL);
 269                 fail_unless(check == &golden_data[i],
 270                                 "sdb_llist_search() = %p (%s); expected: %p (%s)",
 271                                 check, check->name, &golden_data[i], golden_data[i].name);
 272
 273                 /* => remove the first element */
 274                 check = sdb_llist_remove(list, dummy_lookup, NULL);
 275                 fail_unless(check == &golden_data[i],
 276                                 "sdb_llist_remove() = %p (%s); expected: %p (%s)",
 277                                 check, check->name, &golden_data[i], golden_data[i].name);
 278                 fail_unless(check->ref_cnt == 2,
 279                                 "sdb_llist_remove() changed reference count; got: %i; "
 280                                 "expected: 2", check->ref_cnt);
 281         }
 282         /* should now be empty */
 283         fail_unless(sdb_llist_len(list) == 0,
 284                         "Still have %i elements in the list; expected: 0",
 285                         sdb_llist_len(list));
 286 }
 287 END_TEST
 288
 289 START_TEST(test_shift)
 290 {
 291         size_t i;
 292         populate();
 293         for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
 294                 sdb_object_t *check = sdb_llist_shift(list);
 295                 fail_unless(check == &golden_data[i],
 296                                 "sdb_llist_shift() = NULL; expected: %p",
 297                                 &golden_data[i]);
 298                 fail_unless(check->ref_cnt == 2,
 299                                 "sdb_llist_shift() changed reference count; got: %i; "
 300                                 "expected: 2", check->ref_cnt);
 301         }
 302
 303         /* must be empty now */
 304         fail_unless(sdb_llist_shift(list) == NULL,
 305                         "sdb_llist_shift() returned value; expected: NULL");
 306 }
 307 END_TEST
 308
 309 START_TEST(test_iter)
 310 {
 311         sdb_llist_iter_t *iter;
 312         size_t i;
 313
 314         populate();
 315
 316         iter = sdb_llist_get_iter(list);
 317         fail_unless(iter != NULL,
 318                         "sdb_llist_get_iter() did not return an iterator");
 319
 320         for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
 321                 sdb_object_t *check;
 322                 fail_unless(sdb_llist_iter_has_next(iter),
 323                                 "sdb_llist_iter_has_next() = FALSE; expected: TRUE");
 324                 check = sdb_llist_iter_get_next(iter);
 325                 fail_unless(check == &golden_data[i],
 326                                 "sdb_llist_iter_get_next() = %p; expected: %p",
 327                                 check, &golden_data[i]);
 328         }
 329
 330         fail_unless(!sdb_llist_iter_has_next(iter),
 331                         "sdb_llist_iter_has_next() = TRUE; expected: FALSE");
 332         fail_unless(sdb_llist_iter_get_next(iter) == NULL,
 333                         "sdb_llist_iter_get_next() returned value; expected: NULL");
 334         sdb_llist_iter_destroy(iter);
 335 }
 336 END_TEST
 337
 338 START_TEST(test_iter_remove)
 339 {
 340         sdb_llist_iter_t *iter;
 341         sdb_object_t *check;
 342         size_t i;
 343
 344         populate();
 345
 346         iter = sdb_llist_get_iter(list);
 347         fail_unless(iter != NULL,
 348                         "sdb_llist_get_iter() did not return an iterator");
 349
 350         i = 0;
 351         while (sdb_llist_iter_has_next(iter)) {
 352                 check = sdb_llist_iter_get_next(iter);
 353                 fail_unless(check == &golden_data[i],
 354                                 "sdb_llist_iter_get_next() = %p; expected: %p",
 355                                 check, &golden_data[i]);
 356
 357                 sdb_llist_iter_remove_current(iter);
 358                 ++i;
 359         }
 360         sdb_llist_iter_destroy(iter);
 361
 362         fail_unless(i == (size_t)SDB_STATIC_ARRAY_LEN(golden_data),
 363                         "iterated for %zu steps; expected: %i",
 364                         i, SDB_STATIC_ARRAY_LEN(golden_data));
 365
 366         /* all elements should be removed */
 367         check = sdb_llist_shift(list);
 368         fail_unless(check == NULL,
 369                         "sdb_llist_shift() = %p; expected: NULL", check);
 370 }
 371 END_TEST
 372
 373 Suite *
 374 util_llist_suite(void)
 375 {
 376         Suite *s = suite_create("utils::llist");
 377         TCase *tc;
 378
 379         tc = tcase_create("core");
 380         tcase_add_checked_fixture(tc, setup, teardown);
 381         tcase_add_test(tc, test_clone);
 382         tcase_add_test(tc, test_destroy);
 383         tcase_add_test(tc, test_clear);
 384         tcase_add_test(tc, test_append);
 385         tcase_add_test(tc, test_insert);
 386         tcase_add_test(tc, test_validate_insert);
 387         tcase_add_test(tc, test_get);
 388         tcase_add_test(tc, test_remove_by_name);
 389         tcase_add_test(tc, test_search);
 390         tcase_add_test(tc, test_shift);
 391         tcase_add_test(tc, test_iter);
 392         tcase_add_test(tc, test_iter_remove);
 393         suite_add_tcase(s, tc);
 394
 395         return s;
 396 } /* util_llist_suite */
 397
 398 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
 399