t/utils/llist_test.c

   1 /*
   2  * SysDB - t/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         SSTRING_OBJ("abc"),
  39         SSTRING_OBJ("bcd"),
  40         SSTRING_OBJ("cde"),
  41         SSTRING_OBJ("def"),
  42         SSTRING_OBJ("efg"),
  43         SSTRING_OBJ("fgh"),
  44         SSTRING_OBJ("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_sdb_llist_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_sdb_llist_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_sdb_llist_append)
 119 {
 120         size_t i;
 121
 122         fail_unless(sdb_llist_len(list) == 0,
 123                         "sdb_llist_len(<empty list>) = %zu; expected: 0",
 124                         sdb_llist_len(list));
 125
 126         for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
 127                 int check = sdb_llist_append(list, &golden_data[i]);
 128                 fail_unless(check == 0,
 129                                 "sdb_llist_append(%s) = %i; expected: 0",
 130                                 golden_data[i].name, check);
 131                 fail_unless(golden_data[i].ref_cnt == 2,
 132                                 "sdb_llist_append(%s) did not take ownership",
 133                                 golden_data[i].name);
 134                 fail_unless(sdb_llist_len(list) == i + 1,
 135                                 "sdb_llist_len(<empty list>) = %zu; expected: zu",
 136                                 sdb_llist_len(list), i + 1);
 137         }
 138 }
 139 END_TEST
 140
 141 START_TEST(test_sdb_llist_insert)
 142 {
 143         size_t i;
 144         for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
 145                 int check = sdb_llist_insert(list, &golden_data[i], 0);
 146                 fail_unless(check == 0,
 147                                 "sdb_llist_insert(%s, 0) = %i; expected: 0",
 148                                 golden_data[i].name, check);
 149                 fail_unless(golden_data[i].ref_cnt == 2,
 150                                 "sdb_llist_insert(%s, 0) did not take ownership",
 151                                 golden_data[i].name);
 152         }
 153 }
 154 END_TEST
 155
 156 START_TEST(test_validate_insert)
 157 {
 158         size_t i;
 159         for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
 160                 /* none of these operations will succeed
 161                  * => 1 is invalid for each case */
 162                 int check = sdb_llist_insert(list, &golden_data[i], 1);
 163                 fail_unless(check == -1,
 164                                 "sdb_llist_insert(%s, 1) = %i; expected: -1",
 165                                 golden_data[i].name, check);
 166                 fail_unless(golden_data[i].ref_cnt == 1,
 167                                 "sdb_llist_insert(%s, 1) took ownership",
 168                                 golden_data[i].name);
 169         }
 170 }
 171 END_TEST
 172
 173 START_TEST(test_sdb_llist_get)
 174 {
 175         size_t i;
 176         populate();
 177         for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
 178                 sdb_object_t *check = sdb_llist_get(list, i);
 179                 fail_unless(check == &golden_data[i],
 180                                 "sdb_llist_get() = NULL; expected: %p",
 181                                 &golden_data[i]);
 182                 fail_unless(check->ref_cnt == 2,
 183                                 "sdb_llist_get() changed reference count; got: %i; "
 184                                 "expected: 2", check->ref_cnt);
 185         }
 186 }
 187 END_TEST
 188
 189 START_TEST(test_sdb_llist_search)
 190 {
 191         size_t i;
 192         populate();
 193         for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
 194                 sdb_object_t *check = sdb_llist_search_by_name(list,
 195                                 golden_data[i].name);
 196                 fail_unless(check == &golden_data[i],
 197                                 "sdb_llist_search_by_name(%s) = NULL; expected: %p",
 198                                 golden_data[i].name, &golden_data[i]);
 199         }
 200
 201         for (i = 0; i < SDB_STATIC_ARRAY_LEN(unused_names); ++i) {
 202                 sdb_object_t *check = sdb_llist_search_by_name(list,
 203                                 unused_names[i]);
 204                 fail_unless(check == NULL,
 205                                 "sdb_llist_search_by_name(%s) = %p; expected: NULL",
 206                                 unused_names[i], check);
 207         }
 208 }
 209 END_TEST
 210
 211 START_TEST(test_sdb_llist_shift)
 212 {
 213         size_t i;
 214         populate();
 215         for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
 216                 sdb_object_t *check = sdb_llist_shift(list);
 217                 fail_unless(check == &golden_data[i],
 218                                 "sdb_llist_shift() = NULL; expected: %p",
 219                                 &golden_data[i]);
 220                 fail_unless(check->ref_cnt == 2,
 221                                 "sdb_llist_shift() changed reference count; got: %i; "
 222                                 "expected: 2", check->ref_cnt);
 223         }
 224
 225         /* must be empty now */
 226         fail_unless(sdb_llist_shift(list) == NULL,
 227                         "sdb_llist_shift() returned value; expected: NULL");
 228 }
 229 END_TEST
 230
 231 START_TEST(test_sdb_llist_iter)
 232 {
 233         sdb_llist_iter_t *iter;
 234         size_t i;
 235
 236         populate();
 237
 238         iter = sdb_llist_get_iter(list);
 239         fail_unless(iter != NULL,
 240                         "sdb_llist_get_iter() did not return an iterator");
 241
 242         for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
 243                 sdb_object_t *check;
 244                 fail_unless(sdb_llist_iter_has_next(iter),
 245                                 "sdb_llist_iter_has_next() = FALSE; expected: TRUE");
 246                 check = sdb_llist_iter_get_next(iter);
 247                 fail_unless(check == &golden_data[i],
 248                                 "sdb_llist_iter_get_next() = %p; expected: %p",
 249                                 check, &golden_data[i]);
 250         }
 251
 252         fail_unless(!sdb_llist_iter_has_next(iter),
 253                         "sdb_llist_iter_has_next() = TRUE; expected: FALSE");
 254         fail_unless(sdb_llist_iter_get_next(iter) == NULL,
 255                         "sdb_llist_iter_get_next() returned value; expected: NULL");
 256         sdb_llist_iter_destroy(iter);
 257 }
 258 END_TEST
 259
 260 START_TEST(test_sdb_llist_iter_remove)
 261 {
 262         sdb_llist_iter_t *iter;
 263         sdb_object_t *check;
 264         size_t i;
 265
 266         populate();
 267
 268         iter = sdb_llist_get_iter(list);
 269         fail_unless(iter != NULL,
 270                         "sdb_llist_get_iter() did not return an iterator");
 271
 272         i = 0;
 273         while (sdb_llist_iter_has_next(iter)) {
 274                 check = sdb_llist_iter_get_next(iter);
 275                 fail_unless(check == &golden_data[i],
 276                                 "sdb_llist_iter_get_next() = %p; expected: %p",
 277                                 check, &golden_data[i]);
 278
 279                 sdb_llist_iter_remove_current(iter);
 280                 ++i;
 281         }
 282         sdb_llist_iter_destroy(iter);
 283
 284         fail_unless(i == (size_t)SDB_STATIC_ARRAY_LEN(golden_data),
 285                         "iterated for %zu steps; expected: %i",
 286                         i, SDB_STATIC_ARRAY_LEN(golden_data));
 287
 288         /* all elements should be removed */
 289         check = sdb_llist_shift(list);
 290         fail_unless(check == NULL,
 291                         "sdb_llist_shift() = %p; expected: NULL", check);
 292 }
 293 END_TEST
 294
 295 Suite *
 296 util_llist_suite(void)
 297 {
 298         Suite *s = suite_create("utils::llist");
 299         TCase *tc;
 300
 301         tc = tcase_create("core");
 302         tcase_add_checked_fixture(tc, setup, teardown);
 303         tcase_add_test(tc, test_sdb_llist_clone);
 304         tcase_add_test(tc, test_sdb_llist_destroy);
 305         tcase_add_test(tc, test_sdb_llist_append);
 306         tcase_add_test(tc, test_sdb_llist_insert);
 307         tcase_add_test(tc, test_validate_insert);
 308         tcase_add_test(tc, test_sdb_llist_get);
 309         tcase_add_test(tc, test_sdb_llist_search);
 310         tcase_add_test(tc, test_sdb_llist_shift);
 311         tcase_add_test(tc, test_sdb_llist_iter);
 312         tcase_add_test(tc, test_sdb_llist_iter_remove);
 313         suite_add_tcase(s, tc);
 314
 315         return s;
 316 } /* util_llist_suite */
 317
 318 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
 319