deps/libretro-common/test/queues/test_generic_queue.c

   1 /* Copyright  (C) 2010-2020 The RetroArch team
   2  *
   3  * ---------------------------------------------------------------------------------------
   4  * The following license statement only applies to this file (test_generic_queue.c).
   5  * ---------------------------------------------------------------------------------------
   6  *
   7  * Permission is hereby granted, free of charge,
   8  * to any person obtaining a copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation the rights to
  10  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
  11  * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
  16  * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  18  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  19  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  21  */
  22 #include <check.h>
  23 #include <stdarg.h>
  24 #include <stdlib.h>
  25
  26 #include <queues/generic_queue.h>
  27
  28 #define SUITE_NAME "Generic Queue"
  29
  30 static char *_value_1 = "value1";
  31 static char *_value_2 = "value2";
  32 static char *_value_3 = "value3";
  33
  34 START_TEST (test_generic_queue_create)
  35 {
  36    generic_queue_t *queue = generic_queue_new();
  37    ck_assert_ptr_nonnull(queue);
  38    generic_queue_free(queue, NULL);
  39 }
  40 END_TEST
  41
  42 START_TEST (test_generic_queue_free)
  43 {
  44    generic_queue_t *queue = generic_queue_new();
  45    generic_queue_free(queue, NULL);
  46    generic_queue_free(NULL, NULL);
  47 }
  48 END_TEST
  49
  50 START_TEST (test_generic_queue_push_pop)
  51 {
  52    generic_queue_t *queue;
  53    char *value;
  54
  55    queue = generic_queue_new();
  56    generic_queue_push(queue, _value_1);
  57    ck_assert_int_eq(generic_queue_length(queue), 1);
  58    value = (char *) generic_queue_pop(queue);
  59    ck_assert_ptr_eq(value, _value_1);
  60    ck_assert_int_eq(generic_queue_length(queue), 0);
  61
  62    generic_queue_push(queue, _value_2);
  63    ck_assert_int_eq(generic_queue_length(queue), 1);
  64    generic_queue_push(queue, _value_3);
  65    ck_assert_int_eq(generic_queue_length(queue), 2);
  66    value = (char *) generic_queue_pop(queue);
  67    ck_assert_ptr_eq(value, _value_3);
  68    ck_assert_int_eq(generic_queue_length(queue), 1);
  69    value = (char *) generic_queue_pop(queue);
  70    ck_assert_ptr_eq(value, _value_2);
  71    ck_assert_int_eq(generic_queue_length(queue), 0);
  72
  73    generic_queue_free(queue, NULL);
  74 }
  75 END_TEST
  76
  77 START_TEST (test_generic_queue_peek)
  78 {
  79    generic_queue_t *queue;
  80
  81    queue = generic_queue_new();
  82    ck_assert_ptr_null(generic_queue_peek(queue));
  83    ck_assert_ptr_null(generic_queue_peek_first(queue));
  84
  85    generic_queue_push(queue, _value_1);
  86    ck_assert_ptr_eq(_value_1, generic_queue_peek(queue));
  87    ck_assert_ptr_eq(_value_1, generic_queue_peek_first(queue));
  88
  89    generic_queue_push(queue, _value_2);
  90    ck_assert_ptr_eq(_value_2, generic_queue_peek(queue));
  91    ck_assert_ptr_eq(_value_1, generic_queue_peek_first(queue));
  92
  93    generic_queue_push(queue, _value_3);
  94    ck_assert_ptr_eq(_value_3, generic_queue_peek(queue));
  95    ck_assert_ptr_eq(_value_1, generic_queue_peek_first(queue));
  96
  97    generic_queue_free(queue, NULL);
  98 }
  99 END_TEST
 100
 101 START_TEST (test_generic_queue_shift_unshift)
 102 {
 103    generic_queue_t *queue;
 104    char *value;
 105
 106    queue = generic_queue_new();
 107    generic_queue_shift(queue, _value_1);
 108    ck_assert_int_eq(generic_queue_length(queue), 1);
 109    value = (char *) generic_queue_unshift(queue);
 110    ck_assert_ptr_eq(value, _value_1);
 111    ck_assert_int_eq(generic_queue_length(queue), 0);
 112
 113    generic_queue_shift(queue, _value_2);
 114    ck_assert_int_eq(generic_queue_length(queue), 1);
 115    generic_queue_shift(queue, _value_3);
 116    ck_assert_int_eq(generic_queue_length(queue), 2);
 117    value = (char *) generic_queue_unshift(queue);
 118    ck_assert_ptr_eq(value, _value_3);
 119    ck_assert_int_eq(generic_queue_length(queue), 1);
 120    value = (char *) generic_queue_unshift(queue);
 121    ck_assert_ptr_eq(value, _value_2);
 122    ck_assert_int_eq(generic_queue_length(queue), 0);
 123
 124    generic_queue_free(queue, NULL);
 125 }
 126 END_TEST
 127
 128 START_TEST (test_generic_queue_empty)
 129 {
 130    generic_queue_t *queue;
 131
 132    queue = generic_queue_new();
 133    ck_assert_ptr_null(generic_queue_pop(queue));
 134    ck_assert_ptr_null(generic_queue_unshift(queue));
 135    generic_queue_free(queue, NULL);
 136 }
 137 END_TEST
 138
 139 void _free_value(void *value)
 140 {
 141    return;
 142 }
 143
 144 START_TEST (test_generic_queue_iterator)
 145 {
 146    generic_queue_t *queue;
 147    generic_queue_iterator_t *iterator;
 148
 149    queue = generic_queue_new();
 150    generic_queue_push(queue, _value_1);
 151    generic_queue_push(queue, _value_2);
 152    generic_queue_push(queue, _value_3);
 153
 154    iterator = generic_queue_iterator(queue, true);
 155    ck_assert_ptr_nonnull(iterator);
 156    ck_assert_ptr_eq(generic_queue_iterator_value(iterator), _value_1);
 157    iterator = generic_queue_iterator_next(iterator);
 158    ck_assert_ptr_nonnull(iterator);
 159    ck_assert_ptr_eq(generic_queue_iterator_value(iterator), _value_2);
 160    iterator = generic_queue_iterator_next(iterator);
 161    ck_assert_ptr_nonnull(iterator);
 162    ck_assert_ptr_eq(generic_queue_iterator_value(iterator), _value_3);
 163    iterator = generic_queue_iterator_next(iterator);
 164    ck_assert_ptr_null(iterator);
 165
 166    iterator = generic_queue_iterator(queue, false);
 167    ck_assert_ptr_nonnull(iterator);
 168    ck_assert_ptr_eq(generic_queue_iterator_value(iterator), _value_3);
 169    iterator = generic_queue_iterator_next(iterator);
 170    ck_assert_ptr_nonnull(iterator);
 171    ck_assert_ptr_eq(generic_queue_iterator_value(iterator), _value_2);
 172    iterator = generic_queue_iterator_next(iterator);
 173    ck_assert_ptr_nonnull(iterator);
 174    ck_assert_ptr_eq(generic_queue_iterator_value(iterator), _value_1);
 175    iterator = generic_queue_iterator_next(iterator);
 176    ck_assert_ptr_null(iterator);
 177
 178    generic_queue_free(queue, &_free_value);
 179 }
 180 END_TEST
 181
 182 START_TEST (test_generic_queue_shift_free)
 183 {
 184    generic_queue_t *queue;
 185
 186    queue = generic_queue_new();
 187
 188    generic_queue_shift(queue, _value_1);
 189    generic_queue_shift(queue, _value_2);
 190    generic_queue_shift(queue, _value_3);
 191
 192    generic_queue_free(queue, &_free_value);
 193 }
 194 END_TEST
 195
 196 START_TEST (test_generic_queue_remove_one)
 197 {
 198    generic_queue_t *queue;
 199    generic_queue_iterator_t *iterator;
 200
 201    queue = generic_queue_new();
 202    generic_queue_push(queue, _value_1);
 203
 204    iterator = generic_queue_iterator(queue, true);
 205    iterator = generic_queue_iterator_remove(iterator);
 206    ck_assert_ptr_null(iterator);
 207    ck_assert_int_eq(generic_queue_length(queue), 0);
 208
 209    generic_queue_free(queue, NULL);
 210 }
 211 END_TEST
 212
 213 static void _verify_queue_values(generic_queue_t *queue, int count, ...)
 214 {
 215    va_list values_list;
 216    void **values;
 217    int i;
 218    generic_queue_iterator_t *iterator;
 219
 220    values = (void **)malloc(count * sizeof(void *));
 221
 222    ck_assert_int_eq(count, generic_queue_length(queue));
 223
 224    va_start(values_list, count);
 225    for (i = 0; i < count; i++)
 226       values[i] = va_arg(values_list, void *);
 227    va_end(values_list);
 228
 229    iterator = generic_queue_iterator(queue, true);
 230    for (i = 0; i < count; i++)
 231    {
 232       ck_assert_ptr_nonnull(iterator);
 233       ck_assert_ptr_eq(values[i], generic_queue_iterator_value(iterator));
 234       iterator = generic_queue_iterator_next(iterator);
 235    }
 236    ck_assert_ptr_null(iterator);
 237
 238    iterator = generic_queue_iterator(queue, false);
 239    for (i = count - 1; i >= 0; i--)
 240    {
 241       ck_assert_ptr_nonnull(iterator);
 242       ck_assert_ptr_eq(values[i], generic_queue_iterator_value(iterator));
 243       iterator = generic_queue_iterator_next(iterator);
 244    }
 245    ck_assert_ptr_null(iterator);
 246
 247    free(values);
 248 }
 249
 250 START_TEST (test_generic_queue_iterator_remove_first)
 251 {
 252    generic_queue_t *queue;
 253    generic_queue_iterator_t *iterator;
 254
 255    queue = generic_queue_new();
 256    generic_queue_push(queue, _value_1);
 257    generic_queue_push(queue, _value_2);
 258    generic_queue_push(queue, _value_3);
 259
 260    iterator = generic_queue_iterator(queue, true);
 261    iterator = generic_queue_iterator_remove(iterator);
 262    generic_queue_iterator_free(iterator);
 263
 264    _verify_queue_values(queue, 2, _value_2, _value_3);
 265
 266    generic_queue_free(queue, &_free_value);
 267 }
 268 END_TEST
 269
 270 START_TEST (test_generic_queue_iterator_remove_middle)
 271 {
 272    generic_queue_t *queue;
 273    generic_queue_iterator_t *iterator;
 274
 275    queue = generic_queue_new();
 276    generic_queue_push(queue, _value_1);
 277    generic_queue_push(queue, _value_2);
 278    generic_queue_push(queue, _value_3);
 279
 280    iterator = generic_queue_iterator(queue, true);
 281    iterator = generic_queue_iterator_next(iterator);
 282    iterator = generic_queue_iterator_remove(iterator);
 283    generic_queue_iterator_free(iterator);
 284
 285    _verify_queue_values(queue, 2, _value_1, _value_3);
 286
 287    generic_queue_free(queue, &_free_value);
 288 }
 289 END_TEST
 290
 291 START_TEST (test_generic_queue_iterator_remove_last)
 292 {
 293    generic_queue_t *queue;
 294    generic_queue_iterator_t *iterator;
 295
 296    queue = generic_queue_new();
 297    generic_queue_push(queue, _value_1);
 298    generic_queue_push(queue, _value_2);
 299    generic_queue_push(queue, _value_3);
 300
 301    iterator = generic_queue_iterator(queue, false);
 302    iterator = generic_queue_iterator_remove(iterator);
 303    generic_queue_iterator_free(iterator);
 304
 305    _verify_queue_values(queue, 2, _value_1, _value_2);
 306
 307    generic_queue_free(queue, &_free_value);
 308 }
 309 END_TEST
 310
 311 START_TEST (test_generic_queue_remove_first)
 312 {
 313    generic_queue_t *queue;
 314
 315    queue = generic_queue_new();
 316    generic_queue_push(queue, _value_1);
 317    generic_queue_push(queue, _value_2);
 318    generic_queue_push(queue, _value_3);
 319
 320    ck_assert_ptr_eq(generic_queue_remove(queue, _value_1), _value_1);
 321
 322    _verify_queue_values(queue, 2, _value_2, _value_3);
 323
 324    generic_queue_free(queue, &_free_value);
 325 }
 326
 327 START_TEST (test_generic_queue_remove_middle)
 328 {
 329    generic_queue_t *queue;
 330
 331    queue = generic_queue_new();
 332    generic_queue_push(queue, _value_1);
 333    generic_queue_push(queue, _value_2);
 334    generic_queue_push(queue, _value_3);
 335
 336    ck_assert_ptr_eq(generic_queue_remove(queue, _value_2), _value_2);
 337
 338    _verify_queue_values(queue, 2, _value_1, _value_3);
 339
 340    generic_queue_free(queue, &_free_value);
 341 }
 342
 343 START_TEST (test_generic_queue_remove_last)
 344 {
 345    generic_queue_t *queue;
 346
 347    queue = generic_queue_new();
 348    generic_queue_push(queue, _value_1);
 349    generic_queue_push(queue, _value_2);
 350    generic_queue_push(queue, _value_3);
 351
 352    ck_assert_ptr_eq(generic_queue_remove(queue, _value_3), _value_3);
 353
 354    _verify_queue_values(queue, 2, _value_1, _value_2);
 355
 356    generic_queue_free(queue, &_free_value);
 357 }
 358
 359 START_TEST (test_generic_queue_iterator_free)
 360 {
 361    generic_queue_t *queue;
 362    generic_queue_iterator_t *iterator;
 363
 364    queue = generic_queue_new();
 365    generic_queue_push(queue, _value_1);
 366    iterator = generic_queue_iterator(queue, true);
 367
 368    generic_queue_iterator_free(iterator);
 369    generic_queue_iterator_free(NULL);
 370
 371    generic_queue_free(queue, _free_value);
 372 }
 373 END_TEST
 374
 375 Suite *create_suite(void)
 376 {
 377    Suite *s = suite_create(SUITE_NAME);
 378
 379    TCase *tc_core = tcase_create("Core");
 380    tcase_add_test(tc_core, test_generic_queue_create);
 381    tcase_add_test(tc_core, test_generic_queue_free);
 382    tcase_add_test(tc_core, test_generic_queue_push_pop);
 383    tcase_add_test(tc_core, test_generic_queue_peek);
 384    tcase_add_test(tc_core, test_generic_queue_shift_unshift);
 385    tcase_add_test(tc_core, test_generic_queue_empty);
 386    tcase_add_test(tc_core, test_generic_queue_iterator);
 387    tcase_add_test(tc_core, test_generic_queue_shift_free);
 388    tcase_add_test(tc_core, test_generic_queue_remove_one);
 389    tcase_add_test(tc_core, test_generic_queue_iterator_remove_first);
 390    tcase_add_test(tc_core, test_generic_queue_iterator_remove_middle);
 391    tcase_add_test(tc_core, test_generic_queue_iterator_remove_last);
 392    tcase_add_test(tc_core, test_generic_queue_remove_first);
 393    tcase_add_test(tc_core, test_generic_queue_remove_middle);
 394    tcase_add_test(tc_core, test_generic_queue_remove_last);
 395    tcase_add_test(tc_core, test_generic_queue_iterator_free);
 396    suite_add_tcase(s, tc_core);
 397
 398    return s;
 399 }
 400
 401 int main(void)
 402 {
 403         int num_fail;
 404         Suite *s = create_suite();
 405         SRunner *sr = srunner_create(s);
 406         srunner_run_all(sr, CK_NORMAL);
 407         num_fail = srunner_ntests_failed(sr);
 408         srunner_free(sr);
 409         return (num_fail == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
 410 }