Commit | Line | Data |
---|---|---|
3719602c PC |
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 | } |