test/test-int-queue.c

   1 /*
   2  * Copyright © 2013 Red Hat, Inc.
   3  *
   4  * Permission to use, copy, modify, distribute, and sell this software and its
   5  * documentation for any purpose is hereby granted without fee, provided that
   6  * the above copyright notice appear in all copies and that both that copyright
   7  * notice and this permission notice appear in supporting documentation, and
   8  * that the name of the copyright holders not be used in advertising or
   9  * publicity pertaining to distribution of the software without specific,
  10  * written prior permission.  The copyright holders make no representations
  11  * about the suitability of this software for any purpose.  It is provided "as
  12  * is" without express or implied warranty.
  13  *
  14  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  15  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  16  * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  17  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  18  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  19  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  20  * OF THIS SOFTWARE.
  21  */
  22
  23 #include <config.h>
  24 #include <limits.h>
  25 #include <libevdev/libevdev-int.h>
  26 #include "test-common.h"
  27
  28
  29
  30
  31 START_TEST(test_queue_alloc)
  32 {
  33         struct libevdev dev;
  34         int rc;
  35
  36         rc = queue_alloc(&dev, 0);
  37         ck_assert_int_eq(rc, -ENOMEM);
  38
  39         rc = queue_alloc(&dev, ULONG_MAX);
  40         ck_assert_int_eq(rc, -ENOMEM);
  41
  42         rc = queue_alloc(&dev, 100);
  43         ck_assert_int_eq(rc, 0);
  44
  45         ck_assert_int_eq(dev.queue_size, 100);
  46         ck_assert_int_eq(dev.queue_next, 0);
  47
  48         queue_free(&dev);
  49         ck_assert_int_eq(dev.queue_size, 0);
  50         ck_assert_int_eq(dev.queue_next, 0);
  51
  52 }
  53 END_TEST
  54
  55 START_TEST(test_queue_sizes)
  56 {
  57         struct libevdev dev = {0};
  58
  59         queue_alloc(&dev, 0);
  60         ck_assert_int_eq(queue_num_elements(&dev), 0);
  61         ck_assert_int_eq(queue_num_free_elements(&dev), 0);
  62         ck_assert_int_eq(queue_size(&dev), 0);
  63
  64         queue_alloc(&dev, 100);
  65         ck_assert_int_eq(queue_num_elements(&dev), 0);
  66         ck_assert_int_eq(queue_num_free_elements(&dev), 100);
  67         ck_assert_int_eq(queue_size(&dev), 100);
  68
  69         queue_free(&dev);
  70
  71         ck_assert_int_eq(queue_num_elements(&dev), 0);
  72         ck_assert_int_eq(queue_num_free_elements(&dev), 0);
  73         ck_assert_int_eq(queue_size(&dev), 0);
  74 }
  75 END_TEST
  76
  77 START_TEST(test_queue_push)
  78 {
  79         struct libevdev dev = {0};
  80         struct input_event *ev;
  81
  82         queue_alloc(&dev, 0);
  83         ev = queue_push(&dev);
  84         ck_assert(ev == NULL);
  85
  86         queue_alloc(&dev, 2);
  87         ev = queue_push(&dev);
  88         ck_assert(ev == dev.queue);
  89         ck_assert_int_eq(queue_num_elements(&dev), 1);
  90         ck_assert_int_eq(queue_num_free_elements(&dev), 1);
  91
  92         ev = queue_push(&dev);
  93         ck_assert(ev == dev.queue + 1);
  94
  95         ev = queue_push(&dev);
  96         ck_assert(ev == NULL);
  97
  98         queue_free(&dev);
  99         ev = queue_push(&dev);
 100         ck_assert(ev == NULL);
 101
 102 }
 103 END_TEST
 104
 105 START_TEST(test_queue_pop)
 106 {
 107         struct libevdev dev = {0};
 108         struct input_event ev, *e, tmp;
 109         int rc;
 110
 111         queue_alloc(&dev, 0);
 112         rc = queue_pop(&dev, &ev);
 113         ck_assert_int_eq(rc, 1);
 114
 115         queue_alloc(&dev, 2);
 116         e = queue_push(&dev);
 117         memset(e, 0xab, sizeof(*e));
 118         ck_assert_int_eq(queue_num_elements(&dev), 1);
 119         ck_assert_int_eq(queue_num_free_elements(&dev), 1);
 120
 121         rc = queue_pop(&dev, &ev);
 122         ck_assert_int_eq(rc, 0);
 123         memset(&tmp, 0xab, sizeof(tmp));
 124         rc = memcmp(&tmp, &ev, sizeof(tmp));
 125         ck_assert_int_eq(rc, 0);
 126
 127         ck_assert_int_eq(queue_num_elements(&dev), 0);
 128         ck_assert_int_eq(queue_num_free_elements(&dev), 2);
 129
 130         rc = queue_pop(&dev, &ev);
 131         ck_assert_int_eq(rc, 1);
 132
 133         queue_free(&dev);
 134 }
 135 END_TEST
 136
 137 START_TEST(test_queue_peek)
 138 {
 139         struct libevdev dev = {0};
 140         struct input_event ev, *e, tmp;
 141         int rc;
 142
 143         queue_alloc(&dev, 0);
 144         rc = queue_peek(&dev, 0, &ev);
 145         ck_assert_int_eq(rc, 1);
 146
 147         queue_alloc(&dev, 2);
 148         e = queue_push(&dev);
 149         memset(e, 0xab, sizeof(*e));
 150
 151         rc = queue_peek(&dev, 0, &ev);
 152         ck_assert_int_eq(rc, 0);
 153         memset(&tmp, 0xab, sizeof(tmp));
 154         rc = memcmp(&tmp, &ev, sizeof(tmp));
 155         ck_assert_int_eq(rc, 0);
 156
 157         ck_assert_int_eq(queue_num_elements(&dev), 1);
 158         e = queue_push(&dev);
 159         memset(e, 0xbc, sizeof(*e));
 160
 161         rc = queue_peek(&dev, 1, &ev);
 162         ck_assert_int_eq(rc, 0);
 163         memset(&tmp, 0xbc, sizeof(tmp));
 164         rc = memcmp(&tmp, &ev, sizeof(tmp));
 165         ck_assert_int_eq(rc, 0);
 166
 167         rc = queue_peek(&dev, 0, &ev);
 168         ck_assert_int_eq(rc, 0);
 169         memset(&tmp, 0xab, sizeof(tmp));
 170         rc = memcmp(&tmp, &ev, sizeof(tmp));
 171         ck_assert_int_eq(rc, 0);
 172
 173         ck_assert_int_eq(queue_num_elements(&dev), 2);
 174
 175         queue_free(&dev);
 176 }
 177 END_TEST
 178
 179 START_TEST(test_queue_shift)
 180 {
 181         struct libevdev dev = {0};
 182         struct input_event ev, *first, *second, e1, e2;
 183         int rc;
 184
 185         ck_assert_int_eq(queue_shift(&dev, &ev), 1);
 186
 187         queue_alloc(&dev, 10);
 188         ck_assert_int_eq(queue_shift(&dev, &ev), 1);
 189
 190         first = queue_push(&dev);
 191         ck_assert(first != NULL);
 192         memset(first, 0xab, sizeof(*first));
 193
 194         e1 = *first;
 195
 196         second = queue_push(&dev);
 197         ck_assert(second != NULL);
 198         memset(second, 0x12, sizeof(*second));
 199
 200         e2 = *second;
 201
 202         rc = queue_shift(&dev, &ev);
 203         ck_assert_int_eq(rc, 0);
 204         rc = memcmp(&ev, &e1, sizeof(ev));
 205         ck_assert_int_eq(rc, 0);
 206
 207         rc = queue_shift(&dev, &ev);
 208         ck_assert_int_eq(rc, 0);
 209         rc = memcmp(&ev, &e2, sizeof(ev));
 210         ck_assert_int_eq(rc, 0);
 211
 212         ck_assert_int_eq(queue_shift(&dev, &ev), 1);
 213
 214         queue_free(&dev);
 215 }
 216 END_TEST
 217
 218 START_TEST(test_queue_shift_multiple)
 219 {
 220         struct libevdev dev = {0};
 221         struct input_event ev, *first, *second, e1, e2;
 222         struct input_event events[5];
 223         int rc;
 224
 225         ck_assert_int_eq(queue_shift_multiple(&dev, 1, &ev), 0);
 226         ck_assert_int_eq(queue_shift_multiple(&dev, 0, &ev), 0);
 227
 228         queue_alloc(&dev, 10);
 229         ck_assert_int_eq(queue_shift_multiple(&dev, 1, &ev), 0);
 230         ck_assert_int_eq(queue_shift_multiple(&dev, 0, &ev), 0);
 231
 232         first = queue_push(&dev);
 233         ck_assert(first != NULL);
 234         memset(first, 0xab, sizeof(*first));
 235         e1 = *first;
 236
 237         second = queue_push(&dev);
 238         ck_assert(second != NULL);
 239         memset(second, 0x12, sizeof(*second));
 240         e2 = *second;
 241
 242         rc = queue_shift_multiple(&dev, 5, events);
 243         ck_assert_int_eq(rc, 2);
 244         rc = memcmp(&events[0], &e1, sizeof(ev));
 245         ck_assert_int_eq(rc, 0);
 246         rc = memcmp(&events[1], &e2, sizeof(ev));
 247         ck_assert_int_eq(rc, 0);
 248
 249         first = queue_push(&dev);
 250         ck_assert(first != NULL);
 251         memset(first, 0xab, sizeof(*first));
 252         e1 = *first;
 253
 254         second = queue_push(&dev);
 255         ck_assert(second != NULL);
 256         memset(second, 0x12, sizeof(*second));
 257         e2 = *second;
 258
 259         rc = queue_shift_multiple(&dev, 1, events);
 260         ck_assert_int_eq(rc, 1);
 261         rc = memcmp(&events[0], &e1, sizeof(ev));
 262         ck_assert_int_eq(rc, 0);
 263
 264         rc = queue_shift_multiple(&dev, 1, events);
 265         ck_assert_int_eq(rc, 1);
 266         rc = memcmp(&events[0], &e2, sizeof(ev));
 267         ck_assert_int_eq(rc, 0);
 268
 269         ck_assert_int_eq(queue_shift_multiple(&dev, 1, events), 0);
 270
 271         queue_free(&dev);
 272 }
 273 END_TEST
 274
 275 START_TEST(test_queue_next_element)
 276 {
 277         struct libevdev dev = {0};
 278         struct input_event ev, *first, *second;
 279         int rc;
 280
 281         queue_alloc(&dev, 0);
 282         first = queue_next_element(&dev);
 283         ck_assert(first == NULL);
 284
 285         queue_alloc(&dev, 2);
 286         first = queue_next_element(&dev);
 287         ck_assert(first != NULL);
 288         memset(first, 0xab, sizeof(*first));
 289
 290         second = queue_next_element(&dev);
 291         ck_assert(second != NULL);
 292         memset(second, 0xbc, sizeof(*second));
 293
 294         /* queue_next_element does not advance, so we overwrite */
 295         memset(&ev, 0xbc, sizeof(ev));
 296         rc = memcmp(&ev, first, sizeof(ev));
 297         ck_assert_int_eq(rc, 0);
 298
 299         ck_assert_int_eq(queue_num_elements(&dev), 0);
 300
 301         first = queue_next_element(&dev);
 302         ck_assert(first != NULL);
 303         memset(first, 0xab, sizeof(*first));
 304
 305         queue_set_num_elements(&dev, 1);
 306         ck_assert_int_eq(queue_num_elements(&dev), 1);
 307
 308         second = queue_next_element(&dev);
 309         ck_assert(second != NULL);
 310         memset(second, 0xbc, sizeof(*second));
 311
 312         memset(&ev, 0xab, sizeof(ev));
 313         rc = memcmp(&ev, first, sizeof(ev));
 314         ck_assert_int_eq(rc, 0);
 315
 316         queue_free(&dev);
 317 }
 318 END_TEST
 319
 320 START_TEST(test_queue_set_num_elements)
 321 {
 322         struct libevdev dev = {0};
 323
 324         queue_alloc(&dev, 0);
 325         ck_assert_int_eq(queue_set_num_elements(&dev, 1), 1);
 326
 327         queue_alloc(&dev, 2);
 328         ck_assert_int_eq(queue_set_num_elements(&dev, 3), 1);
 329         ck_assert_int_eq(queue_set_num_elements(&dev, 2), 0);
 330
 331         queue_free(&dev);
 332 }
 333 END_TEST
 334
 335 Suite *
 336 queue_suite(void)
 337 {
 338         Suite *s = suite_create("Event queue");
 339
 340         TCase *tc = tcase_create("Queue allocation");
 341         tcase_add_test(tc, test_queue_alloc);
 342         tcase_add_test(tc, test_queue_sizes);
 343         suite_add_tcase(s, tc);
 344
 345         tc = tcase_create("Queue push/pop/peek");
 346         tcase_add_test(tc, test_queue_push);
 347         tcase_add_test(tc, test_queue_pop);
 348         tcase_add_test(tc, test_queue_peek);
 349         suite_add_tcase(s, tc);
 350
 351         tc = tcase_create("Queue shift");
 352         tcase_add_test(tc, test_queue_shift);
 353         tcase_add_test(tc, test_queue_shift_multiple);
 354         suite_add_tcase(s, tc);
 355
 356         tc = tcase_create("Queue next elem");
 357         tcase_add_test(tc, test_queue_next_element);
 358         tcase_add_test(tc, test_queue_set_num_elements);
 359         suite_add_tcase(s, tc);
 360
 361         return s;
 362 }
 363