src/test/test-prioq.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2013 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <stdlib.h>
  23
  24 #include "util.h"
  25 #include "set.h"
  26 #include "prioq.h"
  27 #include "siphash24.h"
  28
  29 #define SET_SIZE 1024*4
  30
  31 static int unsigned_compare(const void *a, const void *b) {
  32         const unsigned *x = a, *y = b;
  33
  34         if (*x < *y)
  35                 return -1;
  36
  37         if (*x > *y)
  38                 return 1;
  39
  40         return 0;
  41 }
  42
  43 static void test_unsigned(void) {
  44         unsigned buffer[SET_SIZE], i;
  45         Prioq *q;
  46
  47         srand(0);
  48
  49         q = prioq_new(trivial_compare_func);
  50         assert_se(q);
  51
  52         for (i = 0; i < ELEMENTSOF(buffer); i++) {
  53                 unsigned u;
  54
  55                 u = (unsigned) rand();
  56                 buffer[i] = u;
  57                 assert_se(prioq_put(q, UINT_TO_PTR(u), NULL) >= 0);
  58         }
  59
  60         qsort(buffer, ELEMENTSOF(buffer), sizeof(buffer[0]), unsigned_compare);
  61
  62         for (i = 0; i < ELEMENTSOF(buffer); i++) {
  63                 unsigned u;
  64
  65                 assert_se(prioq_size(q) == ELEMENTSOF(buffer) - i);
  66
  67                 u = PTR_TO_UINT(prioq_pop(q));
  68                 assert_se(buffer[i] == u);
  69         }
  70
  71         assert_se(prioq_isempty(q));
  72         prioq_free(q);
  73 }
  74
  75 struct test {
  76         unsigned value;
  77         unsigned idx;
  78 };
  79
  80 static int test_compare(const void *a, const void *b) {
  81         const struct test *x = a, *y = b;
  82
  83         if (x->value < y->value)
  84                 return -1;
  85
  86         if (x->value > y->value)
  87                 return 1;
  88
  89         return 0;
  90 }
  91
  92 static unsigned long test_hash(const void *a, const uint8_t hash_key[HASH_KEY_SIZE]) {
  93         const struct test *x = a;
  94         uint64_t u;
  95
  96         siphash24((uint8_t*) &u, &x->value, sizeof(x->value), hash_key);
  97
  98         return (unsigned long) u;
  99 }
 100
 101 static const struct hash_ops test_hash_ops = {
 102         .hash = test_hash,
 103         .compare = test_compare
 104 };
 105
 106 static void test_struct(void) {
 107         Prioq *q;
 108         Set *s;
 109         unsigned previous = 0, i;
 110         int r;
 111
 112         srand(0);
 113
 114         q = prioq_new(test_compare);
 115         assert_se(q);
 116
 117         s = set_new(&test_hash_ops);
 118         assert_se(s);
 119
 120         for (i = 0; i < SET_SIZE; i++) {
 121                 struct test *t;
 122
 123                 t = new0(struct test, 1);
 124                 assert_se(t);
 125                 t->value = (unsigned) rand();
 126
 127                 r = prioq_put(q, t, &t->idx);
 128                 assert_se(r >= 0);
 129
 130                 if (i % 4 == 0) {
 131                         r = set_consume(s, t);
 132                         assert_se(r >= 0);
 133                 }
 134         }
 135
 136         for (;;) {
 137                 struct test *t;
 138
 139                 t = set_steal_first(s);
 140                 if (!t)
 141                         break;
 142
 143                 r = prioq_remove(q, t, &t->idx);
 144                 assert_se(r > 0);
 145
 146                 free(t);
 147         }
 148
 149         for (i = 0; i < SET_SIZE * 3 / 4; i++) {
 150                 struct test *t;
 151
 152                 assert_se(prioq_size(q) == (SET_SIZE * 3 / 4) - i);
 153
 154                 t = prioq_pop(q);
 155                 assert_se(t);
 156
 157                 assert_se(previous <= t->value);
 158                 previous = t->value;
 159                 free(t);
 160         }
 161
 162         assert_se(prioq_isempty(q));
 163         prioq_free(q);
 164
 165         assert_se(set_isempty(s));
 166         set_free(s);
 167 }
 168
 169 int main(int argc, char* argv[]) {
 170
 171         test_unsigned();
 172         test_struct();
 173
 174         return 0;
 175 }