1 /* Copyright (C) 2010-2020 The RetroArch team
3 * ---------------------------------------------------------------------------------------
4 * The following license statement only applies to this file (test_generic_queue.c).
5 * ---------------------------------------------------------------------------------------
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:
13 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
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.
26 #include <queues/generic_queue.h>
28 #define SUITE_NAME "Generic Queue"
30 static char *_value_1 = "value1";
31 static char *_value_2 = "value2";
32 static char *_value_3 = "value3";
34 START_TEST (test_generic_queue_create)
36 generic_queue_t *queue = generic_queue_new();
37 ck_assert_ptr_nonnull(queue);
38 generic_queue_free(queue, NULL);
42 START_TEST (test_generic_queue_free)
44 generic_queue_t *queue = generic_queue_new();
45 generic_queue_free(queue, NULL);
46 generic_queue_free(NULL, NULL);
50 START_TEST (test_generic_queue_push_pop)
52 generic_queue_t *queue;
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);
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);
73 generic_queue_free(queue, NULL);
77 START_TEST (test_generic_queue_peek)
79 generic_queue_t *queue;
81 queue = generic_queue_new();
82 ck_assert_ptr_null(generic_queue_peek(queue));
83 ck_assert_ptr_null(generic_queue_peek_first(queue));
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));
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));
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));
97 generic_queue_free(queue, NULL);
101 START_TEST (test_generic_queue_shift_unshift)
103 generic_queue_t *queue;
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);
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);
124 generic_queue_free(queue, NULL);
128 START_TEST (test_generic_queue_empty)
130 generic_queue_t *queue;
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);
139 void _free_value(void *value)
144 START_TEST (test_generic_queue_iterator)
146 generic_queue_t *queue;
147 generic_queue_iterator_t *iterator;
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);
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);
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);
178 generic_queue_free(queue, &_free_value);
182 START_TEST (test_generic_queue_shift_free)
184 generic_queue_t *queue;
186 queue = generic_queue_new();
188 generic_queue_shift(queue, _value_1);
189 generic_queue_shift(queue, _value_2);
190 generic_queue_shift(queue, _value_3);
192 generic_queue_free(queue, &_free_value);
196 START_TEST (test_generic_queue_remove_one)
198 generic_queue_t *queue;
199 generic_queue_iterator_t *iterator;
201 queue = generic_queue_new();
202 generic_queue_push(queue, _value_1);
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);
209 generic_queue_free(queue, NULL);
213 static void _verify_queue_values(generic_queue_t *queue, int count, ...)
218 generic_queue_iterator_t *iterator;
220 values = (void **)malloc(count * sizeof(void *));
222 ck_assert_int_eq(count, generic_queue_length(queue));
224 va_start(values_list, count);
225 for (i = 0; i < count; i++)
226 values[i] = va_arg(values_list, void *);
229 iterator = generic_queue_iterator(queue, true);
230 for (i = 0; i < count; i++)
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);
236 ck_assert_ptr_null(iterator);
238 iterator = generic_queue_iterator(queue, false);
239 for (i = count - 1; i >= 0; i--)
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);
245 ck_assert_ptr_null(iterator);
250 START_TEST (test_generic_queue_iterator_remove_first)
252 generic_queue_t *queue;
253 generic_queue_iterator_t *iterator;
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);
260 iterator = generic_queue_iterator(queue, true);
261 iterator = generic_queue_iterator_remove(iterator);
262 generic_queue_iterator_free(iterator);
264 _verify_queue_values(queue, 2, _value_2, _value_3);
266 generic_queue_free(queue, &_free_value);
270 START_TEST (test_generic_queue_iterator_remove_middle)
272 generic_queue_t *queue;
273 generic_queue_iterator_t *iterator;
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);
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);
285 _verify_queue_values(queue, 2, _value_1, _value_3);
287 generic_queue_free(queue, &_free_value);
291 START_TEST (test_generic_queue_iterator_remove_last)
293 generic_queue_t *queue;
294 generic_queue_iterator_t *iterator;
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);
301 iterator = generic_queue_iterator(queue, false);
302 iterator = generic_queue_iterator_remove(iterator);
303 generic_queue_iterator_free(iterator);
305 _verify_queue_values(queue, 2, _value_1, _value_2);
307 generic_queue_free(queue, &_free_value);
311 START_TEST (test_generic_queue_remove_first)
313 generic_queue_t *queue;
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);
320 ck_assert_ptr_eq(generic_queue_remove(queue, _value_1), _value_1);
322 _verify_queue_values(queue, 2, _value_2, _value_3);
324 generic_queue_free(queue, &_free_value);
327 START_TEST (test_generic_queue_remove_middle)
329 generic_queue_t *queue;
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);
336 ck_assert_ptr_eq(generic_queue_remove(queue, _value_2), _value_2);
338 _verify_queue_values(queue, 2, _value_1, _value_3);
340 generic_queue_free(queue, &_free_value);
343 START_TEST (test_generic_queue_remove_last)
345 generic_queue_t *queue;
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);
352 ck_assert_ptr_eq(generic_queue_remove(queue, _value_3), _value_3);
354 _verify_queue_values(queue, 2, _value_1, _value_2);
356 generic_queue_free(queue, &_free_value);
359 START_TEST (test_generic_queue_iterator_free)
361 generic_queue_t *queue;
362 generic_queue_iterator_t *iterator;
364 queue = generic_queue_new();
365 generic_queue_push(queue, _value_1);
366 iterator = generic_queue_iterator(queue, true);
368 generic_queue_iterator_free(iterator);
369 generic_queue_iterator_free(NULL);
371 generic_queue_free(queue, _free_value);
375 Suite *create_suite(void)
377 Suite *s = suite_create(SUITE_NAME);
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);
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);
409 return (num_fail == 0) ? EXIT_SUCCESS : EXIT_FAILURE;