notaz.gp2x.de / pcsx_rearmed.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
cdrom: adjust timing
[pcsx_rearmed.git] / deps / libretro-common / test / lists / test_linked_list.c
CommitLineData
3719602c
PC		 1/* Copyright (C) 2010-2020 The RetroArch team
2 *
3 * ---------------------------------------------------------------------------------------
4 * The following license statement only applies to this file (test_linked_list.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
23#include <check.h>
24#include <stdarg.h>
25#include <stdlib.h>
26
27#include <lists/linked_list.h>
28
29#define SUITE_NAME "Linked List"
30
31static char *_value_1 = "value1";
32static char *_value_2 = "value2";
33static char *_value_3 = "value3";
34
35START_TEST (test_linked_list_create)
36{
37 linked_list_t *list = linked_list_new();
38 ck_assert_ptr_nonnull(list);
39 linked_list_free(list, NULL);
40}
41END_TEST
42
43START_TEST (test_linked_list_free)
44{
45 linked_list_t *queue = linked_list_new();
46 linked_list_free(queue, NULL);
47 linked_list_free(NULL, NULL);
48}
49END_TEST
50
51static int _free_alloced_value_count;
52static void _free_alloced_value(void *value)
53{
54 _free_alloced_value_count++;
55 free(value);
56}
57
58START_TEST (test_linked_list_free_with_fn)
59{
60 linked_list_t *list = linked_list_new();
61 linked_list_add(list, malloc(1));
62 linked_list_add(list, malloc(1));
63 linked_list_add(list, malloc(1));
64
65 _free_alloced_value_count = 0;
66 linked_list_free(list, &_free_alloced_value);
67
68 ck_assert_int_eq(3, _free_alloced_value_count);
69}
70END_TEST
71
72static void _verify_list(linked_list_t *list, int size, ...)
73{
74 va_list values_list;
75 void **values;
76 int i;
77 linked_list_iterator_t *iterator;
78
79 values = (void **)malloc(size * sizeof(void *));
80
81 ck_assert_int_eq(linked_list_size(list), size);
82
83 va_start(values_list, size);
84 for (i = 0; i < size; i++)
85 {
86 values[i] = va_arg(values_list, void *);
87 ck_assert_ptr_eq(values[i], linked_list_get(list, i));
88 }
89 va_end(values_list);
90
91 iterator = linked_list_iterator(list, true);
92 for (i = 0; i < size; i++)
93 {
94 ck_assert_ptr_nonnull(iterator);
95 ck_assert_ptr_eq(values[i], linked_list_iterator_value(iterator));
96 iterator = linked_list_iterator_next(iterator);
97 }
98 ck_assert_ptr_null(iterator);
99
100 iterator = linked_list_iterator(list, false);
101 for (i = size - 1; i >= 0; i--)
102 {
103 ck_assert_ptr_nonnull(iterator);
104 ck_assert_ptr_eq(values[i], linked_list_iterator_value(iterator));
105 iterator = linked_list_iterator_next(iterator);
106 }
107 ck_assert_ptr_null(iterator);
108
109 free(values);
110}
111
112START_TEST (test_linked_list_add)
113{
114 linked_list_t *list = linked_list_new();
115 linked_list_add(list, _value_1);
116 linked_list_add(list, _value_2);
117 linked_list_add(list, _value_3);
118
119 _verify_list(list, 3, _value_1, _value_2, _value_3);
120
121 linked_list_free(list, NULL);
122}
123END_TEST
124
125START_TEST (test_linked_list_insert_empty)
126{
127 linked_list_t *list = linked_list_new();
128 linked_list_insert(list, 0, _value_1);
129
130 ck_assert_int_eq(linked_list_size(list), 1);
131 ck_assert_ptr_eq(linked_list_get(list, 0), _value_1);
132
133 linked_list_free(list, NULL);
134}
135END_TEST
136
137START_TEST (test_linked_list_insert_first)
138{
139 linked_list_t *list = linked_list_new();
140 linked_list_add(list, _value_2);
141 linked_list_add(list, _value_3);
142 linked_list_insert(list, 0, _value_1);
143
144 _verify_list(list, 3, _value_1, _value_2, _value_3);
145
146 linked_list_free(list, NULL);
147}
148END_TEST
149
150START_TEST (test_linked_list_insert_middle)
151{
152 linked_list_t *list = linked_list_new();
153 linked_list_add(list, _value_1);
154 linked_list_add(list, _value_3);
155 linked_list_insert(list, 1, _value_2);
156
157 _verify_list(list, 3, _value_1, _value_2, _value_3);
158
159 linked_list_free(list, NULL);
160}
161END_TEST
162
163START_TEST (test_linked_list_insert_last)
164{
165 linked_list_t *list = linked_list_new();
166 linked_list_add(list, _value_1);
167 linked_list_add(list, _value_2);
168 linked_list_insert(list, 2, _value_3);
169
170 _verify_list(list, 3, _value_1, _value_2, _value_3);
171
172 linked_list_free(list, NULL);
173}
174END_TEST
175
176START_TEST (test_linked_list_insert_invalid)
177{
178 linked_list_t *list = linked_list_new();
179 linked_list_insert(list, 2, _value_1);
180
181 ck_assert_int_eq(linked_list_size(list), 0);
182
183 linked_list_free(list, NULL);
184}
185END_TEST
186
187START_TEST (test_linked_list_insert_null)
188{
189 linked_list_insert(NULL, 0, _value_1);
190}
191END_TEST
192
193START_TEST (test_linked_list_get_invalid)
194{
195 linked_list_t *list = linked_list_new();
196 ck_assert_ptr_null(linked_list_get(list, 2));
197
198 linked_list_free(list, NULL);
199}
200END_TEST
201
202START_TEST (test_linked_list_get_null)
203{
204 ck_assert_ptr_null(linked_list_get(NULL, 0));
205}
206END_TEST
207
208START_TEST (test_linked_list_get_first_matching_null)
209{
210 ck_assert_ptr_null(linked_list_get_first_matching(NULL, NULL, NULL));
211}
212END_TEST
213
214START_TEST (test_linked_list_get_first_matching_function_null)
215{
216 linked_list_t *list = linked_list_new();
217 ck_assert_ptr_null(linked_list_get_first_matching(list, NULL, NULL));
218
219 linked_list_free(list, NULL);
220}
221
222bool _matches_function(void *value, void *state)
223{
224 ck_assert_ptr_eq(_value_1, state);
225 return value == _value_2;
226}
227
228START_TEST (test_linked_list_get_first_matching_no_match)
229{
230 linked_list_t *list = linked_list_new();
231 ck_assert_ptr_null(linked_list_get_first_matching(list, &_matches_function, _value_1));
232
233 linked_list_free(list, NULL);
234}
235END_TEST
236
237START_TEST (test_linked_list_get_first_matching_with_match)
238{
239 linked_list_t *list = linked_list_new();
240 linked_list_add(list, _value_1);
241 linked_list_add(list, _value_2);
242 linked_list_add(list, _value_3);
243
244 ck_assert_ptr_eq(_value_2, linked_list_get_first_matching(list, &_matches_function, _value_1));
245
246 linked_list_free(list, NULL);
247}
248END_TEST
249
250START_TEST (test_linked_list_get_last_matching_null)
251{
252 ck_assert_ptr_null(linked_list_get_last_matching(NULL, NULL, NULL));
253}
254END_TEST
255
256START_TEST (test_linked_list_get_last_matching_function_null)
257{
258 linked_list_t *list = linked_list_new();
259 ck_assert_ptr_null(linked_list_get_last_matching(list, NULL, NULL));
260
261 linked_list_free(list, NULL);
262}
263
264START_TEST (test_linked_list_get_last_matching_no_match)
265{
266 linked_list_t *list = linked_list_new();
267 ck_assert_ptr_null(linked_list_get_last_matching(list, &_matches_function, _value_1));
268
269 linked_list_free(list, NULL);
270}
271END_TEST
272
273START_TEST (test_linked_list_get_last_matching_with_match)
274{
275 linked_list_t *list = linked_list_new();
276 linked_list_add(list, _value_1);
277 linked_list_add(list, _value_2);
278 linked_list_add(list, _value_3);
279
280 ck_assert_ptr_eq(_value_2, linked_list_get_last_matching(list, &_matches_function, _value_1));
281
282 linked_list_free(list, NULL);
283}
284END_TEST
285
286START_TEST (test_linked_list_remove_at_null)
287{
288 ck_assert_ptr_null(linked_list_remove_at(NULL, 0));
289}
290END_TEST
291
292START_TEST (test_linked_list_remove_at_empty)
293{
294 linked_list_t *list = linked_list_new();
295 ck_assert_ptr_null(linked_list_remove_at(list, 0));
296
297 linked_list_free(list, NULL);
298}
299END_TEST
300
301START_TEST (test_linked_list_remove_at_invalid)
302{
303 linked_list_t *list = linked_list_new();
304 linked_list_add(list, _value_1);
305 linked_list_add(list, _value_2);
306 linked_list_add(list, _value_3);
307
308 linked_list_remove_at(list, 3);
309
310 _verify_list(list, 3, _value_1, _value_2, _value_3);
311
312 linked_list_free(list, NULL);
313}
314END_TEST
315
316START_TEST (test_linked_list_remove_at_first)
317{
318 linked_list_t *list = linked_list_new();
319 linked_list_add(list, _value_1);
320 linked_list_add(list, _value_2);
321 linked_list_add(list, _value_3);
322
323 linked_list_remove_at(list, 0);
324
325 _verify_list(list, 2, _value_2, _value_3);
326
327 linked_list_free(list, NULL);
328}
329END_TEST
330
331START_TEST (test_linked_list_remove_at_middle)
332{
333 linked_list_t *list = linked_list_new();
334 linked_list_add(list, _value_1);
335 linked_list_add(list, _value_2);
336 linked_list_add(list, _value_3);
337
338 linked_list_remove_at(list, 1);
339
340 _verify_list(list, 2, _value_1, _value_3);
341
342 linked_list_free(list, NULL);
343}
344END_TEST
345
346START_TEST (test_linked_list_remove_at_last)
347{
348 linked_list_t *list = linked_list_new();
349 linked_list_add(list, _value_1);
350 linked_list_add(list, _value_2);
351 linked_list_add(list, _value_3);
352
353 linked_list_remove_at(list, 2);
354
355 _verify_list(list, 2, _value_1, _value_2);
356
357 linked_list_free(list, NULL);
358}
359END_TEST
360
361START_TEST (test_linked_list_remove_at_only)
362{
363 linked_list_t *list = linked_list_new();
364 linked_list_add(list, _value_1);
365
366 linked_list_remove_at(list, 0);
367
368 _verify_list(list, 0);
369
370 linked_list_free(list, NULL);
371}
372END_TEST
373
374START_TEST (test_linked_list_remove_first_null)
375{
376 ck_assert_ptr_null(linked_list_remove_first(NULL, _value_1));
377}
378END_TEST
379
380START_TEST (test_linked_list_remove_first_empty)
381{
382 linked_list_t *list = linked_list_new();
383 ck_assert_ptr_null(linked_list_remove_first(list, _value_1));
384
385 linked_list_free(list, NULL);
386}
387END_TEST
388
389START_TEST (test_linked_list_remove_first_not_found)
390{
391 linked_list_t *list = linked_list_new();
392 linked_list_add(list, _value_1);
393 linked_list_add(list, _value_2);
394 linked_list_add(list, _value_3);
395
396 ck_assert_ptr_null(linked_list_remove_first(list, "foo"));
397
398 _verify_list(list, 3, _value_1, _value_2, _value_3);
399
400 linked_list_free(list, NULL);
401}
402END_TEST
403
404START_TEST (test_linked_list_remove_first_first)
405{
406 linked_list_t *list = linked_list_new();
407 linked_list_add(list, _value_1);
408 linked_list_add(list, _value_2);
409 linked_list_add(list, _value_3);
410
411 ck_assert_ptr_eq(linked_list_remove_first(list, _value_1), _value_1);
412
413 _verify_list(list, 2, _value_2, _value_3);
414
415 linked_list_free(list, NULL);
416}
417END_TEST
418
419START_TEST (test_linked_list_remove_first_middle)
420{
421 linked_list_t *list = linked_list_new();
422 linked_list_add(list, _value_1);
423 linked_list_add(list, _value_2);
424 linked_list_add(list, _value_3);
425
426 ck_assert_ptr_eq(linked_list_remove_first(list, _value_2), _value_2);
427
428 _verify_list(list, 2, _value_1, _value_3);
429
430 linked_list_free(list, NULL);
431}
432END_TEST
433
434START_TEST (test_linked_list_remove_first_last)
435{
436 linked_list_t *list = linked_list_new();
437 linked_list_add(list, _value_1);
438 linked_list_add(list, _value_2);
439 linked_list_add(list, _value_3);
440
441 ck_assert_ptr_eq(linked_list_remove_first(list, _value_3), _value_3);
442
443 _verify_list(list, 2, _value_1, _value_2);
444
445 linked_list_free(list, NULL);
446}
447END_TEST
448
449START_TEST (test_linked_list_remove_first_only)
450{
451 linked_list_t *list = linked_list_new();
452 linked_list_add(list, _value_1);
453
454 ck_assert_ptr_eq(linked_list_remove_first(list, _value_1), _value_1);
455
456 _verify_list(list, 0);
457
458 linked_list_free(list, NULL);
459}
460END_TEST
461
462START_TEST (test_linked_list_remove_first_multiple)
463{
464 linked_list_t *list = linked_list_new();
465 linked_list_add(list, _value_1);
466 linked_list_add(list, _value_2);
467 linked_list_add(list, _value_1);
468
469 ck_assert_ptr_eq(linked_list_remove_first(list, _value_1), _value_1);
470
471 _verify_list(list, 2, _value_2, _value_1);
472
473 linked_list_free(list, NULL);
474}
475END_TEST
476
477START_TEST (test_linked_list_remove_last_null)
478{
479 ck_assert_ptr_null(linked_list_remove_last(NULL, _value_1));
480}
481END_TEST
482
483START_TEST (test_linked_list_remove_last_empty)
484{
485 linked_list_t *list = linked_list_new();
486 ck_assert_ptr_null(linked_list_remove_last(list, _value_1));
487
488 linked_list_free(list, NULL);
489}
490END_TEST
491
492START_TEST (test_linked_list_remove_last_not_found)
493{
494 linked_list_t *list = linked_list_new();
495 linked_list_add(list, _value_1);
496 linked_list_add(list, _value_2);
497 linked_list_add(list, _value_3);
498
499 ck_assert_ptr_null(linked_list_remove_last(list, "foo"));
500
501 _verify_list(list, 3, _value_1, _value_2, _value_3);
502
503 linked_list_free(list, NULL);
504}
505END_TEST
506
507START_TEST (test_linked_list_remove_last_first)
508{
509 linked_list_t *list = linked_list_new();
510 linked_list_add(list, _value_1);
511 linked_list_add(list, _value_2);
512 linked_list_add(list, _value_3);
513
514 ck_assert_ptr_eq(linked_list_remove_last(list, _value_1), _value_1);
515
516 _verify_list(list, 2, _value_2, _value_3);
517
518 linked_list_free(list, NULL);
519}
520END_TEST
521
522START_TEST (test_linked_list_remove_last_middle)
523{
524 linked_list_t *list = linked_list_new();
525 linked_list_add(list, _value_1);
526 linked_list_add(list, _value_2);
527 linked_list_add(list, _value_3);
528
529 ck_assert_ptr_eq(linked_list_remove_last(list, _value_2), _value_2);
530
531 _verify_list(list, 2, _value_1, _value_3);
532
533 linked_list_free(list, NULL);
534}
535END_TEST
536
537START_TEST (test_linked_list_remove_last_last)
538{
539 linked_list_t *list = linked_list_new();
540 linked_list_add(list, _value_1);
541 linked_list_add(list, _value_2);
542 linked_list_add(list, _value_3);
543
544 ck_assert_ptr_eq(linked_list_remove_last(list, _value_3), _value_3);
545
546 _verify_list(list, 2, _value_1, _value_2);
547
548 linked_list_free(list, NULL);
549}
550END_TEST
551
552START_TEST (test_linked_list_remove_last_only)
553{
554 linked_list_t *list = linked_list_new();
555 linked_list_add(list, _value_1);
556
557 ck_assert_ptr_eq(linked_list_remove_last(list, _value_1), _value_1);
558
559 _verify_list(list, 0);
560
561 linked_list_free(list, NULL);
562}
563END_TEST
564
565START_TEST (test_linked_list_remove_last_multiple)
566{
567 linked_list_t *list = linked_list_new();
568 linked_list_add(list, _value_1);
569 linked_list_add(list, _value_2);
570 linked_list_add(list, _value_1);
571
572 ck_assert_ptr_eq(linked_list_remove_last(list, _value_1), _value_1);
573
574 _verify_list(list, 2, _value_1, _value_2);
575
576 linked_list_free(list, NULL);
577}
578END_TEST
579
580START_TEST (test_linked_list_remove_all_null)
581{
582 ck_assert_ptr_null(linked_list_remove_all(NULL, _value_1));
583}
584END_TEST
585
586START_TEST (test_linked_list_remove_all_empty)
587{
588 linked_list_t *list = linked_list_new();
589 ck_assert_ptr_null(linked_list_remove_all(list, _value_1));
590
591 linked_list_free(list, NULL);
592}
593END_TEST
594
595START_TEST (test_linked_list_remove_all_not_found)
596{
597 linked_list_t *list = linked_list_new();
598 linked_list_add(list, _value_1);
599 linked_list_add(list, _value_2);
600 linked_list_add(list, _value_3);
601
602 ck_assert_ptr_null(linked_list_remove_all(list, "foo"));
603
604 _verify_list(list, 3, _value_1, _value_2, _value_3);
605
606 linked_list_free(list, NULL);
607}
608END_TEST
609
610START_TEST (test_linked_list_remove_all_first)
611{
612 linked_list_t *list = linked_list_new();
613 linked_list_add(list, _value_1);
614 linked_list_add(list, _value_2);
615 linked_list_add(list, _value_3);
616
617 ck_assert_ptr_eq(linked_list_remove_all(list, _value_1), _value_1);
618
619 _verify_list(list, 2, _value_2, _value_3);
620
621 linked_list_free(list, NULL);
622}
623END_TEST
624
625START_TEST (test_linked_list_remove_all_middle)
626{
627 linked_list_t *list = linked_list_new();
628 linked_list_add(list, _value_1);
629 linked_list_add(list, _value_2);
630 linked_list_add(list, _value_3);
631
632 ck_assert_ptr_eq(linked_list_remove_all(list, _value_2), _value_2);
633
634 _verify_list(list, 2, _value_1, _value_3);
635
636 linked_list_free(list, NULL);
637}
638END_TEST
639
640START_TEST (test_linked_list_remove_all_last)
641{
642 linked_list_t *list = linked_list_new();
643 linked_list_add(list, _value_1);
644 linked_list_add(list, _value_2);
645 linked_list_add(list, _value_3);
646
647 ck_assert_ptr_eq(linked_list_remove_all(list, _value_3), _value_3);
648
649 _verify_list(list, 2, _value_1, _value_2);
650
651 linked_list_free(list, NULL);
652}
653END_TEST
654
655START_TEST (test_linked_list_remove_all_only)
656{
657 linked_list_t *list = linked_list_new();
658 linked_list_add(list, _value_1);
659
660 ck_assert_ptr_eq(linked_list_remove_all(list, _value_1), _value_1);
661
662 _verify_list(list, 0);
663
664 linked_list_free(list, NULL);
665}
666END_TEST
667
668START_TEST (test_linked_list_remove_all_multiple)
669{
670 linked_list_t *list = linked_list_new();
671 linked_list_add(list, _value_1);
672 linked_list_add(list, _value_2);
673 linked_list_add(list, _value_1);
674
675 ck_assert_ptr_eq(linked_list_remove_all(list, _value_1), _value_1);
676
677 _verify_list(list, 1, _value_2);
678
679 linked_list_free(list, NULL);
680}
681END_TEST
682
683bool _match_value_1(void *value)
684{
685 return _value_1 == value;
686}
687
688bool _no_match(void *value)
689{
690 return false;
691}
692
693START_TEST (test_linked_list_remove_first_matching_null)
694{
695 ck_assert_ptr_null(linked_list_remove_first_matching(NULL, &_match_value_1));
696}
697END_TEST
698
699START_TEST (test_linked_list_remove_first_matching_empty)
700{
701 linked_list_t *list = linked_list_new();
702 ck_assert_ptr_null(linked_list_remove_first_matching(list, &_match_value_1));
703
704 linked_list_free(list, NULL);
705}
706END_TEST
707
708START_TEST (test_linked_list_remove_first_matching_not_found)
709{
710 linked_list_t *list = linked_list_new();
711 linked_list_add(list, _value_1);
712 linked_list_add(list, _value_2);
713 linked_list_add(list, _value_3);
714
715 ck_assert_ptr_null(linked_list_remove_first_matching(list, &_no_match));
716
717 _verify_list(list, 3, _value_1, _value_2, _value_3);
718
719 linked_list_free(list, NULL);
720}
721END_TEST
722
723START_TEST (test_linked_list_remove_first_matching_first)
724{
725 linked_list_t *list = linked_list_new();
726 linked_list_add(list, _value_1);
727 linked_list_add(list, _value_2);
728 linked_list_add(list, _value_3);
729
730 ck_assert_ptr_eq(linked_list_remove_first_matching(list, &_match_value_1), _value_1);
731
732 _verify_list(list, 2, _value_2, _value_3);
733
734 linked_list_free(list, NULL);
735}
736END_TEST
737
738START_TEST (test_linked_list_remove_first_matching_middle)
739{
740 linked_list_t *list = linked_list_new();
741 linked_list_add(list, _value_2);
742 linked_list_add(list, _value_1);
743 linked_list_add(list, _value_3);
744
745 ck_assert_ptr_eq(linked_list_remove_first_matching(list, &_match_value_1), _value_1);
746
747 _verify_list(list, 2, _value_2, _value_3);
748
749 linked_list_free(list, NULL);
750}
751END_TEST
752
753START_TEST (test_linked_list_remove_first_matching_last)
754{
755 linked_list_t *list = linked_list_new();
756 linked_list_add(list, _value_2);
757 linked_list_add(list, _value_3);
758 linked_list_add(list, _value_1);
759
760 ck_assert_ptr_eq(linked_list_remove_first_matching(list, &_match_value_1), _value_1);
761
762 _verify_list(list, 2, _value_2, _value_3);
763
764 linked_list_free(list, NULL);
765}
766END_TEST
767
768START_TEST (test_linked_list_remove_first_matching_only)
769{
770 linked_list_t *list = linked_list_new();
771 linked_list_add(list, _value_1);
772
773 ck_assert_ptr_eq(linked_list_remove_first_matching(list, &_match_value_1), _value_1);
774
775 _verify_list(list, 0);
776
777 linked_list_free(list, NULL);
778}
779END_TEST
780
781START_TEST (test_linked_list_remove_first_matching_multiple)
782{
783 linked_list_t *list = linked_list_new();
784 linked_list_add(list, _value_1);
785 linked_list_add(list, _value_2);
786 linked_list_add(list, _value_1);
787
788 ck_assert_ptr_eq(linked_list_remove_first_matching(list, &_match_value_1), _value_1);
789
790 _verify_list(list, 2, _value_2, _value_1);
791
792 linked_list_free(list, NULL);
793}
794END_TEST
795
796START_TEST (test_linked_list_remove_last_matching_null)
797{
798 ck_assert_ptr_null(linked_list_remove_last_matching(NULL, &_match_value_1));
799}
800END_TEST
801
802START_TEST (test_linked_list_remove_last_matching_empty)
803{
804 linked_list_t *list = linked_list_new();
805 ck_assert_ptr_null(linked_list_remove_last_matching(list, &_match_value_1));
806
807 linked_list_free(list, NULL);
808}
809END_TEST
810
811START_TEST (test_linked_list_remove_last_matching_not_found)
812{
813 linked_list_t *list = linked_list_new();
814 linked_list_add(list, _value_1);
815 linked_list_add(list, _value_2);
816 linked_list_add(list, _value_3);
817
818 ck_assert_ptr_null(linked_list_remove_last_matching(list, &_no_match));
819
820 _verify_list(list, 3, _value_1, _value_2, _value_3);
821
822 linked_list_free(list, NULL);
823}
824END_TEST
825
826START_TEST (test_linked_list_remove_last_matching_first)
827{
828 linked_list_t *list = linked_list_new();
829 linked_list_add(list, _value_1);
830 linked_list_add(list, _value_2);
831 linked_list_add(list, _value_3);
832
833 ck_assert_ptr_eq(linked_list_remove_last_matching(list, &_match_value_1), _value_1);
834
835 _verify_list(list, 2, _value_2, _value_3);
836
837 linked_list_free(list, NULL);
838}
839END_TEST
840
841START_TEST (test_linked_list_remove_last_matching_middle)
842{
843 linked_list_t *list = linked_list_new();
844 linked_list_add(list, _value_2);
845 linked_list_add(list, _value_1);
846 linked_list_add(list, _value_3);
847
848 ck_assert_ptr_eq(linked_list_remove_last_matching(list, &_match_value_1), _value_1);
849
850 _verify_list(list, 2, _value_2, _value_3);
851
852 linked_list_free(list, NULL);
853}
854END_TEST
855
856START_TEST (test_linked_list_remove_last_matching_last)
857{
858 linked_list_t *list = linked_list_new();
859 linked_list_add(list, _value_2);
860 linked_list_add(list, _value_3);
861 linked_list_add(list, _value_1);
862
863 ck_assert_ptr_eq(linked_list_remove_last_matching(list, &_match_value_1), _value_1);
864
865 _verify_list(list, 2, _value_2, _value_3);
866
867 linked_list_free(list, NULL);
868}
869END_TEST
870
871START_TEST (test_linked_list_remove_last_matching_only)
872{
873 linked_list_t *list = linked_list_new();
874 linked_list_add(list, _value_1);
875
876 ck_assert_ptr_eq(linked_list_remove_last_matching(list, &_match_value_1), _value_1);
877
878 _verify_list(list, 0);
879
880 linked_list_free(list, NULL);
881}
882END_TEST
883
884START_TEST (test_linked_list_remove_last_matching_multiple)
885{
886 linked_list_t *list = linked_list_new();
887 linked_list_add(list, _value_1);
888 linked_list_add(list, _value_2);
889 linked_list_add(list, _value_1);
890
891 ck_assert_ptr_eq(linked_list_remove_last_matching(list, &_match_value_1), _value_1);
892
893 _verify_list(list, 2, _value_1, _value_2);
894
895 linked_list_free(list, NULL);
896}
897END_TEST
898
899START_TEST (test_linked_list_remove_all_matching_null)
900{
901 linked_list_remove_all_matching(NULL, &_match_value_1);
902}
903END_TEST
904
905START_TEST (test_linked_list_remove_all_matching_empty)
906{
907 linked_list_t *list = linked_list_new();
908 linked_list_remove_all_matching(list, &_match_value_1);
909
910 linked_list_free(list, NULL);
911}
912END_TEST
913
914START_TEST (test_linked_list_remove_all_matching_not_found)
915{
916 linked_list_t *list = linked_list_new();
917 linked_list_add(list, _value_1);
918 linked_list_add(list, _value_2);
919 linked_list_add(list, _value_3);
920
921 linked_list_remove_all_matching(list, &_no_match);
922
923 _verify_list(list, 3, _value_1, _value_2, _value_3);
924
925 linked_list_free(list, NULL);
926}
927END_TEST
928
929START_TEST (test_linked_list_remove_all_matching_first)
930{
931 linked_list_t *list = linked_list_new();
932 linked_list_add(list, _value_1);
933 linked_list_add(list, _value_2);
934 linked_list_add(list, _value_3);
935
936 linked_list_remove_all_matching(list, &_match_value_1);
937
938 _verify_list(list, 2, _value_2, _value_3);
939
940 linked_list_free(list, NULL);
941}
942END_TEST
943
944START_TEST (test_linked_list_remove_all_matching_middle)
945{
946 linked_list_t *list = linked_list_new();
947 linked_list_add(list, _value_2);
948 linked_list_add(list, _value_1);
949 linked_list_add(list, _value_3);
950
951 linked_list_remove_all_matching(list, &_match_value_1);
952
953 _verify_list(list, 2, _value_2, _value_3);
954
955 linked_list_free(list, NULL);
956}
957END_TEST
958
959START_TEST (test_linked_list_remove_all_matching_last)
960{
961 linked_list_t *list = linked_list_new();
962 linked_list_add(list, _value_2);
963 linked_list_add(list, _value_3);
964 linked_list_add(list, _value_1);
965
966 linked_list_remove_all_matching(list, &_match_value_1);
967
968 _verify_list(list, 2, _value_2, _value_3);
969
970 linked_list_free(list, NULL);
971}
972END_TEST
973
974START_TEST (test_linked_list_remove_all_matching_only)
975{
976 linked_list_t *list = linked_list_new();
977 linked_list_add(list, _value_1);
978
979 linked_list_remove_all_matching(list, &_match_value_1);
980
981 _verify_list(list, 0);
982
983 linked_list_free(list, NULL);
984}
985END_TEST
986
987START_TEST (test_linked_list_remove_all_matching_multiple)
988{
989 linked_list_t *list = linked_list_new();
990 linked_list_add(list, _value_1);
991 linked_list_add(list, _value_2);
992 linked_list_add(list, _value_1);
993
994 linked_list_remove_all_matching(list, &_match_value_1);
995
996 _verify_list(list, 1, _value_2);
997
998 linked_list_free(list, NULL);
999}
1000END_TEST
1001
1002START_TEST (test_linked_list_set_at_null)
1003{
1004 ck_assert_int_eq(linked_list_set_at(NULL, 0, _value_1) == true, 0);
1005}
1006END_TEST
1007
1008START_TEST (test_linked_list_set_at_empty)
1009{
1010 linked_list_t *list = linked_list_new();
1011 ck_assert_int_eq(linked_list_set_at(list, 0, _value_1) == true, 0);
1012
1013 linked_list_free(list, NULL);
1014}
1015END_TEST
1016
1017START_TEST (test_linked_list_set_at_invalid)
1018{
1019 linked_list_t *list = linked_list_new();
1020 linked_list_add(list, _value_1);
1021 ck_assert_int_eq(linked_list_set_at(list, 1, _value_2) == true, 0);
1022
1023 linked_list_free(list, NULL);
1024}
1025END_TEST
1026
1027static char *_replacement_value = "foo";
1028
1029START_TEST (test_linked_list_set_at_first)
1030{
1031 linked_list_t *list = linked_list_new();
1032 linked_list_add(list, _value_1);
1033 linked_list_add(list, _value_2);
1034 linked_list_add(list, _value_3);
1035
1036 ck_assert_int_eq(linked_list_set_at(list, 0, _replacement_value) == false, 0);
1037
1038 _verify_list(list, 3, _replacement_value, _value_2, _value_3);
1039
1040 linked_list_free(list, NULL);
1041}
1042END_TEST
1043
1044START_TEST (test_linked_list_set_at_middle)
1045{
1046 linked_list_t *list = linked_list_new();
1047 linked_list_add(list, _value_1);
1048 linked_list_add(list, _value_2);
1049 linked_list_add(list, _value_3);
1050
1051 ck_assert_int_eq(linked_list_set_at(list, 1, _replacement_value) == false, 0);
1052
1053 _verify_list(list, 3, _value_1, _replacement_value, _value_3);
1054
1055 linked_list_free(list, NULL);
1056}
1057END_TEST
1058
1059START_TEST (test_linked_list_set_at_last)
1060{
1061 linked_list_t *list = linked_list_new();
1062 linked_list_add(list, _value_1);
1063 linked_list_add(list, _value_2);
1064 linked_list_add(list, _value_3);
1065
1066 ck_assert_int_eq(linked_list_set_at(list, 2, _replacement_value) == false, 0);
1067
1068 _verify_list(list, 3, _value_1, _value_2, _replacement_value);
1069
1070 linked_list_free(list, NULL);
1071}
1072END_TEST
1073
1074START_TEST (test_linked_list_iterator_remove_null)
1075{
1076 ck_assert_ptr_null(linked_list_iterator_remove(NULL));
1077}
1078END_TEST
1079
1080START_TEST (test_linked_list_iterator_remove_first)
1081{
1082 linked_list_t *list;
1083 linked_list_iterator_t *iterator;
1084
1085 list = linked_list_new();
1086 linked_list_add(list, _value_1);
1087 linked_list_add(list, _value_2);
1088 linked_list_add(list, _value_3);
1089
1090 iterator = linked_list_iterator(list, true);
1091 iterator = linked_list_iterator_remove(iterator);
1092
1093 ck_assert_ptr_nonnull(iterator);
1094 ck_assert_ptr_eq(linked_list_iterator_value(iterator), _value_2);
1095 _verify_list(list, 2, _value_2, _value_3);
1096
1097 linked_list_iterator_free(iterator);
1098 linked_list_free(list, NULL);
1099}
1100END_TEST
1101
1102START_TEST (test_linked_list_iterator_remove_middle)
1103{
1104 linked_list_t *list;
1105 linked_list_iterator_t *iterator;
1106
1107 list = linked_list_new();
1108 linked_list_add(list, _value_1);
1109 linked_list_add(list, _value_2);
1110 linked_list_add(list, _value_3);
1111
1112 iterator = linked_list_iterator(list, true);
1113 iterator = linked_list_iterator_next(iterator);
1114 iterator = linked_list_iterator_remove(iterator);
1115
1116 ck_assert_ptr_nonnull(iterator);
1117 ck_assert_ptr_eq(linked_list_iterator_value(iterator), _value_3);
1118 _verify_list(list, 2, _value_1, _value_3);
1119
1120 linked_list_iterator_free(iterator);
1121 linked_list_free(list, NULL);
1122}
1123END_TEST
1124
1125START_TEST (test_linked_list_iterator_remove_last)
1126{
1127 linked_list_t *list;
1128 linked_list_iterator_t *iterator;
1129
1130 list = linked_list_new();
1131 linked_list_add(list, _value_1);
1132 linked_list_add(list, _value_2);
1133 linked_list_add(list, _value_3);
1134
1135 iterator = linked_list_iterator(list, true);
1136 iterator = linked_list_iterator_next(iterator);
1137 iterator = linked_list_iterator_next(iterator);
1138 iterator = linked_list_iterator_remove(iterator);
1139
1140 ck_assert_ptr_null(iterator);
1141 _verify_list(list, 2, _value_1, _value_2);
1142
1143 linked_list_free(list, NULL);
1144}
1145END_TEST
1146
1147START_TEST (test_linked_list_iterator_free_null)
1148{
1149 linked_list_iterator_free(NULL);
1150}
1151END_TEST
1152
1153static size_t _foreach_count;
1154static void _foreach_fn(size_t index, void *value)
1155{
1156 _foreach_count++;
1157}
1158
1159START_TEST (test_linked_list_foreach_null_list)
1160{
1161 linked_list_foreach(NULL, _foreach_fn);
1162}
1163END_TEST
1164
1165START_TEST (test_linked_list_foreach_null_fn)
1166{
1167 linked_list_t *list = linked_list_new();
1168 linked_list_add(list, _value_1);
1169 linked_list_add(list, _value_2);
1170 linked_list_add(list, _value_3);
1171
1172 linked_list_foreach(list, NULL);
1173
1174 linked_list_free(list, NULL);
1175}
1176END_TEST
1177
1178START_TEST (test_linked_list_foreach_valid)
1179{
1180 linked_list_t *list = linked_list_new();
1181 linked_list_add(list, _value_1);
1182 linked_list_add(list, _value_2);
1183 linked_list_add(list, _value_3);
1184
1185 _foreach_count = 0;
1186 linked_list_foreach(list, &_foreach_fn);
1187 ck_assert_uint_eq(3, _foreach_count);
1188
1189 linked_list_free(list, NULL);
1190}
1191
1192Suite *create_suite(void)
1193{
1194 Suite *s = suite_create(SUITE_NAME);
1195
1196 TCase *tc_core = tcase_create("Core");
1197 tcase_add_test(tc_core, test_linked_list_create);
1198 tcase_add_test(tc_core, test_linked_list_free);
1199 tcase_add_test(tc_core, test_linked_list_free_with_fn);
1200 tcase_add_test(tc_core, test_linked_list_add);
1201 tcase_add_test(tc_core, test_linked_list_insert_empty);
1202 tcase_add_test(tc_core, test_linked_list_insert_first);
1203 tcase_add_test(tc_core, test_linked_list_insert_middle);
1204 tcase_add_test(tc_core, test_linked_list_insert_last);
1205 tcase_add_test(tc_core, test_linked_list_insert_invalid);
1206 tcase_add_test(tc_core, test_linked_list_insert_null);
1207 tcase_add_test(tc_core, test_linked_list_get_invalid);
1208 tcase_add_test(tc_core, test_linked_list_get_null);
1209 tcase_add_test(tc_core, test_linked_list_get_first_matching_null);
1210 tcase_add_test(tc_core, test_linked_list_get_first_matching_function_null);
1211 tcase_add_test(tc_core, test_linked_list_get_first_matching_no_match);
1212 tcase_add_test(tc_core, test_linked_list_get_first_matching_with_match);
1213 tcase_add_test(tc_core, test_linked_list_get_last_matching_null);
1214 tcase_add_test(tc_core, test_linked_list_get_last_matching_function_null);
1215 tcase_add_test(tc_core, test_linked_list_get_last_matching_no_match);
1216 tcase_add_test(tc_core, test_linked_list_get_last_matching_with_match);
1217 tcase_add_test(tc_core, test_linked_list_remove_at_null);
1218 tcase_add_test(tc_core, test_linked_list_remove_at_empty);
1219 tcase_add_test(tc_core, test_linked_list_remove_at_invalid);
1220 tcase_add_test(tc_core, test_linked_list_remove_at_first);
1221 tcase_add_test(tc_core, test_linked_list_remove_at_middle);
1222 tcase_add_test(tc_core, test_linked_list_remove_at_last);
1223 tcase_add_test(tc_core, test_linked_list_remove_at_only);
1224 tcase_add_test(tc_core, test_linked_list_remove_first_null);
1225 tcase_add_test(tc_core, test_linked_list_remove_first_empty);
1226 tcase_add_test(tc_core, test_linked_list_remove_first_not_found);
1227 tcase_add_test(tc_core, test_linked_list_remove_first_first);
1228 tcase_add_test(tc_core, test_linked_list_remove_first_middle);
1229 tcase_add_test(tc_core, test_linked_list_remove_first_last);
1230 tcase_add_test(tc_core, test_linked_list_remove_first_only);
1231 tcase_add_test(tc_core, test_linked_list_remove_first_multiple);
1232 tcase_add_test(tc_core, test_linked_list_remove_last_null);
1233 tcase_add_test(tc_core, test_linked_list_remove_last_empty);
1234 tcase_add_test(tc_core, test_linked_list_remove_last_not_found);
1235 tcase_add_test(tc_core, test_linked_list_remove_last_first);
1236 tcase_add_test(tc_core, test_linked_list_remove_last_middle);
1237 tcase_add_test(tc_core, test_linked_list_remove_last_last);
1238 tcase_add_test(tc_core, test_linked_list_remove_last_only);
1239 tcase_add_test(tc_core, test_linked_list_remove_last_multiple);
1240 tcase_add_test(tc_core, test_linked_list_remove_all_null);
1241 tcase_add_test(tc_core, test_linked_list_remove_all_empty);
1242 tcase_add_test(tc_core, test_linked_list_remove_all_not_found);
1243 tcase_add_test(tc_core, test_linked_list_remove_all_first);
1244 tcase_add_test(tc_core, test_linked_list_remove_all_middle);
1245 tcase_add_test(tc_core, test_linked_list_remove_all_last);
1246 tcase_add_test(tc_core, test_linked_list_remove_all_only);
1247 tcase_add_test(tc_core, test_linked_list_remove_all_multiple);
1248 tcase_add_test(tc_core, test_linked_list_remove_first_matching_null);
1249 tcase_add_test(tc_core, test_linked_list_remove_first_matching_empty);
1250 tcase_add_test(tc_core, test_linked_list_remove_first_matching_not_found);
1251 tcase_add_test(tc_core, test_linked_list_remove_first_matching_first);
1252 tcase_add_test(tc_core, test_linked_list_remove_first_matching_middle);
1253 tcase_add_test(tc_core, test_linked_list_remove_first_matching_last);
1254 tcase_add_test(tc_core, test_linked_list_remove_first_matching_only);
1255 tcase_add_test(tc_core, test_linked_list_remove_first_matching_multiple);
1256 tcase_add_test(tc_core, test_linked_list_remove_last_matching_null);
1257 tcase_add_test(tc_core, test_linked_list_remove_last_matching_empty);
1258 tcase_add_test(tc_core, test_linked_list_remove_last_matching_not_found);
1259 tcase_add_test(tc_core, test_linked_list_remove_last_matching_first);
1260 tcase_add_test(tc_core, test_linked_list_remove_last_matching_middle);
1261 tcase_add_test(tc_core, test_linked_list_remove_last_matching_last);
1262 tcase_add_test(tc_core, test_linked_list_remove_last_matching_only);
1263 tcase_add_test(tc_core, test_linked_list_remove_last_matching_multiple);
1264 tcase_add_test(tc_core, test_linked_list_remove_all_matching_null);
1265 tcase_add_test(tc_core, test_linked_list_remove_all_matching_empty);
1266 tcase_add_test(tc_core, test_linked_list_remove_all_matching_not_found);
1267 tcase_add_test(tc_core, test_linked_list_remove_all_matching_first);
1268 tcase_add_test(tc_core, test_linked_list_remove_all_matching_middle);
1269 tcase_add_test(tc_core, test_linked_list_remove_all_matching_last);
1270 tcase_add_test(tc_core, test_linked_list_remove_all_matching_only);
1271 tcase_add_test(tc_core, test_linked_list_remove_all_matching_multiple);
1272 tcase_add_test(tc_core, test_linked_list_set_at_null);
1273 tcase_add_test(tc_core, test_linked_list_set_at_empty);
1274 tcase_add_test(tc_core, test_linked_list_set_at_invalid);
1275 tcase_add_test(tc_core, test_linked_list_set_at_first);
1276 tcase_add_test(tc_core, test_linked_list_set_at_middle);
1277 tcase_add_test(tc_core, test_linked_list_set_at_last);
1278 tcase_add_test(tc_core, test_linked_list_iterator_remove_null);
1279 tcase_add_test(tc_core, test_linked_list_iterator_remove_first);
1280 tcase_add_test(tc_core, test_linked_list_iterator_remove_middle);
1281 tcase_add_test(tc_core, test_linked_list_iterator_remove_last);
1282 tcase_add_test(tc_core, test_linked_list_iterator_free_null);
1283 tcase_add_test(tc_core, test_linked_list_foreach_null_list);
1284 tcase_add_test(tc_core, test_linked_list_foreach_null_fn);
1285 tcase_add_test(tc_core, test_linked_list_foreach_valid);
1286 suite_add_tcase(s, tc_core);
1287
1288 return s;
1289}
1290
1291int main(void)
1292{
1293 int num_fail;
1294 Suite *s = create_suite();
1295 SRunner *sr = srunner_create(s);
1296 srunner_run_all(sr, CK_NORMAL);
1297 num_fail = srunner_ntests_failed(sr);
1298 srunner_free(sr);
1299 return (num_fail == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
1300}
ARM optimized PCSX fork