libamxc  1.10.3
C Generic Data Containers
Data Structures | Functions | Variables
test_amxc_llist.c File Reference
#include <stdio.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdlib.h>
#include <setjmp.h>
#include <cmocka.h>
#include <amxc/amxc_llist.h>
#include "test_amxc_llist.h"
#include <amxc/amxc_macros.h>

Go to the source code of this file.

Data Structures

struct  test_data_t
 

Functions

void amxc_llist_new_delete_null_check (UNUSED void **state)
 
void amxc_llist_new_delete_check (UNUSED void **state)
 
void amxc_llist_init_clean_null_check (UNUSED void **state)
 
void amxc_llist_init_clean_check (UNUSED void **state)
 
static void check_it_delete_func (amxc_llist_it_t *it)
 
void amxc_llist_delete_func_check (UNUSED void **state)
 
void amxc_llist_clean_func_check (UNUSED void **state)
 
void amxc_llist_delete_cb_check (UNUSED void **state)
 
void amxc_llist_clean_cb_check (UNUSED void **state)
 
void amxc_llist_append_null_check (UNUSED void **state)
 
void amxc_llist_append_check (UNUSED void **state)
 
void amxc_llist_prepend_null_check (UNUSED void **state)
 
void amxc_llist_prepend_check (UNUSED void **state)
 
static void amxc_llist_setup (void)
 
static void amxc_llist_teardown (void)
 
void amxc_llist_append_move_same_list_check (UNUSED void **state)
 
void amxc_llist_prepend_move_same_list_check (UNUSED void **state)
 
void amxc_llist_is_empty_null_check (UNUSED void **state)
 
void amxc_llist_is_empty_check (UNUSED void **state)
 
void amxc_llist_size_null_check (UNUSED void **state)
 
void amxc_llist_size_check (UNUSED void **state)
 
void amxc_llist_get_at_check (UNUSED void **state)
 
void amxc_llist_set_at_check (UNUSED void **state)
 
void amxc_llist_get_first_check (UNUSED void **state)
 
void amxc_llist_get_last_check (UNUSED void **state)
 
void amxc_llist_it_init_null_check (UNUSED void **state)
 
void amxc_llist_it_init_check (UNUSED void **state)
 
void amxc_llist_it_clean_null_check (UNUSED void **state)
 
void amxc_llist_it_clean_check (UNUSED void **state)
 
void amxc_llist_it_clean_cb_check (UNUSED void **state)
 
static void amxc_llist_it_setup (void)
 
static void amxc_llist_it_teardown (void)
 
void amxc_llist_it_take_null_check (UNUSED void **state)
 
void amxc_llist_it_take_check (UNUSED void **state)
 
void amxc_llist_it_take_double_check (UNUSED void **state)
 
void amxc_llist_it_insert_before_null_check (UNUSED void **state)
 
void amxc_llist_it_insert_before_check (UNUSED void **state)
 
void amxc_llist_it_insert_before_head_check (UNUSED void **state)
 
void amxc_llist_it_insert_before_invalid_it_check (UNUSED void **state)
 
void amxc_llist_it_insert_after_null_check (UNUSED void **state)
 
void amxc_llist_it_insert_after_check (UNUSED void **state)
 
void amxc_llist_it_insert_after_tail_check (UNUSED void **state)
 
void amxc_llist_it_insert_after_invalid_it_check (UNUSED void **state)
 
void amxc_llist_it_index_of_check (UNUSED void **state)
 
void amxc_llist_it_next_prev_check (UNUSED void **state)
 
void amxc_llist_it_is_in_list_check (UNUSED void **state)
 
void amxc_llist_take_at_check (UNUSED void **state)
 
void amxc_llist_swap_in_same_llist_check (UNUSED void **state)
 
void amxc_llist_swap_in_different_llist_check (UNUSED void **state)
 
static int test_cmp (amxc_llist_it_t *it1, amxc_llist_it_t *it2)
 
static void test_del_data (amxc_llist_it_t *it)
 
void test_amxc_llist_sort (UNUSED void **state)
 
void test_amxc_llist_move (UNUSED void **state)
 

Variables

static amxc_llist_it_t s_it_func_check
 
static amxc_llist_t * llist = NULL
 
static amxc_llist_t * llist1 = NULL
 
static amxc_llist_t * llist2 = NULL
 
static amxc_llist_it_t it1
 
static amxc_llist_it_t it2
 
static amxc_llist_it_t it3
 
static amxc_llist_it_t it4
 

Function Documentation

◆ amxc_llist_append_check()

void amxc_llist_append_check ( UNUSED void **  state)

Definition at line 170 of file test_amxc_llist.c.

170  {
171  amxc_llist_t* llist = NULL;
172  amxc_llist_it_t it1;
173  amxc_llist_it_t it2;
174 
175  assert_int_equal(amxc_llist_new(&llist), 0);
176  assert_int_equal(amxc_llist_it_init(&it1), 0);
177  assert_int_equal(amxc_llist_it_init(&it2), 0);
178 
179  // append iterator 1
180  assert_int_equal(amxc_llist_append(llist, &it1), 0);
181  assert_ptr_equal(llist->head, &it1);
182  assert_ptr_equal(llist->tail, &it1);
183  assert_ptr_equal(it1.next, NULL);
184  assert_ptr_equal(it1.prev, NULL);
185  assert_ptr_equal(it1.llist, llist);
186 
187  // append iterator 2
188  assert_int_equal(amxc_llist_append(llist, &it2), 0);
189  assert_ptr_equal(llist->head, &it1);
190  assert_ptr_equal(llist->tail, &it2);
191  assert_ptr_equal(it1.next, &it2);
192  assert_ptr_equal(it2.prev, &it1);
193  assert_ptr_equal(it1.prev, NULL);
194  assert_ptr_equal(it2.next, NULL);
195  assert_ptr_equal(it2.llist, llist);
196 
197  amxc_llist_delete(&llist, NULL);
198 }
amxc_llist_it_init
int amxc_llist_it_init(amxc_llist_it_t *const it)
Initializes a linked list iterator.
Definition: amxc_llist_it.c:89
amxc_llist_delete
void amxc_llist_delete(amxc_llist_t **llist, amxc_llist_it_delete_t func)
Frees the previously allocated linked list.
Definition: amxc_llist.c:101
amxc_llist_new
int amxc_llist_new(amxc_llist_t **llist)
Allocates a linked list.
Definition: amxc_llist.c:88
amxc_llist_append
int amxc_llist_append(amxc_llist_t *const llist, amxc_llist_it_t *const it)
Adds an item to the end of the linked list.
Definition: amxc_llist.c:169
_amxc_llist_it
The linked list iterator structure.
Definition: amxc_llist.h:215
_amxc_llist_it::next
struct _amxc_llist_it * next
Definition: amxc_llist.h:216
_amxc_llist_it::llist
struct _amxc_llist * llist
Definition: amxc_llist.h:220
_amxc_llist_it::prev
struct _amxc_llist_it * prev
Definition: amxc_llist.h:218
_amxc_llist
The linked list structure.
Definition: amxc_llist.h:228
_amxc_llist::head
amxc_llist_it_t * head
Definition: amxc_llist.h:229
_amxc_llist::tail
amxc_llist_it_t * tail
Definition: amxc_llist.h:230
llist
static amxc_llist_t * llist
Definition: test_amxc_llist.c:245
it2
static amxc_llist_it_t it2
Definition: test_amxc_llist.c:249
it1
static amxc_llist_it_t it1
Definition: test_amxc_llist.c:248

◆ amxc_llist_append_move_same_list_check()

void amxc_llist_append_move_same_list_check ( UNUSED void **  state)

Definition at line 270 of file test_amxc_llist.c.

270  {
271  amxc_llist_setup();
272  // move iterator 1 from head to tail in llist1
273  assert_int_equal(amxc_llist_append(llist1, &it1), 0);
274  assert_ptr_equal(llist1->head, &it2);
275  assert_ptr_equal(llist1->tail, &it1);
276  assert_ptr_equal(it1.next, NULL);
277  assert_ptr_equal(it1.prev, &it3);
278  assert_ptr_equal(it2.next, &it3);
279  assert_ptr_equal(it2.prev, NULL);
280  assert_ptr_equal(it3.next, &it1);
281  assert_ptr_equal(it3.prev, &it2);
282  assert_ptr_equal(it1.llist, llist1);
283 
284  // move iterator 3 to tail in llist1
285  assert_int_equal(amxc_llist_append(llist1, &it3), 0);
286  assert_ptr_equal(llist1->head, &it2);
287  assert_ptr_equal(llist1->tail, &it3);
288  assert_ptr_equal(it1.prev, &it2);
289  assert_ptr_equal(it1.next, &it3);
290  assert_ptr_equal(it2.next, &it1);
291  assert_ptr_equal(it2.prev, NULL);
292  assert_ptr_equal(it3.next, NULL);
293  assert_ptr_equal(it3.prev, &it1);
294  assert_ptr_equal(it3.llist, llist1);
295  amxc_llist_teardown();
296 }
llist1
static amxc_llist_t * llist1
Definition: test_amxc_llist.c:246
amxc_llist_setup
static void amxc_llist_setup(void)
Definition: test_amxc_llist.c:253
it3
static amxc_llist_it_t it3
Definition: test_amxc_llist.c:250
amxc_llist_teardown
static void amxc_llist_teardown(void)
Definition: test_amxc_llist.c:265

◆ amxc_llist_append_null_check()

void amxc_llist_append_null_check ( UNUSED void **  state)

Definition at line 155 of file test_amxc_llist.c.

155  {
156  amxc_llist_t* llist = NULL;
157  amxc_llist_it_t it1;
158 
159  assert_int_equal(amxc_llist_new(&llist), 0);
160  assert_int_equal(amxc_llist_it_init(&it1), 0);
161 
162  // passing NULL pointers should not lead to segfault
163  assert_int_not_equal(amxc_llist_append(NULL, NULL), 0);
164  assert_int_not_equal(amxc_llist_append(llist, NULL), 0);
165  assert_int_not_equal(amxc_llist_append(NULL, &it1), 0);
166 
167  amxc_llist_delete(&llist, NULL);
168 }

◆ amxc_llist_clean_cb_check()

void amxc_llist_clean_cb_check ( UNUSED void **  state)

Definition at line 141 of file test_amxc_llist.c.

141  {
142  amxc_llist_t* llist = NULL;
143 
144  // create list
145  assert_int_not_equal(amxc_llist_new(&llist), -1);
146  assert_int_equal(amxc_llist_it_init(&s_it_func_check), 0);
147  assert_int_equal(amxc_llist_append(llist, &s_it_func_check), 0);
148  amxc_llist_clean(llist, NULL);
149  assert_ptr_equal(s_it_func_check.next, NULL);
150  assert_ptr_equal(s_it_func_check.prev, NULL);
151  assert_ptr_equal(s_it_func_check.llist, NULL);
152  amxc_llist_delete(&llist, NULL);
153 }
amxc_llist_clean
void amxc_llist_clean(amxc_llist_t *const llist, amxc_llist_it_delete_t func)
Removes all items from the linked list.
Definition: amxc_llist.c:124
s_it_func_check
static amxc_llist_it_t s_it_func_check
Definition: test_amxc_llist.c:98

◆ amxc_llist_clean_func_check()

void amxc_llist_clean_func_check ( UNUSED void **  state)

Definition at line 115 of file test_amxc_llist.c.

115  {
116  amxc_llist_t* llist = NULL;
117 
118  // create list
119  assert_int_not_equal(amxc_llist_new(&llist), -1);
120  assert_int_equal(amxc_llist_it_init(&s_it_func_check), 0);
121  assert_int_equal(amxc_llist_append(llist, &s_it_func_check), 0);
122 
123  amxc_llist_clean(llist, check_it_delete_func);
124 
125  amxc_llist_delete(&llist, check_it_delete_func);
126 }
check_it_delete_func
static void check_it_delete_func(amxc_llist_it_t *it)
Definition: test_amxc_llist.c:100

◆ amxc_llist_delete_cb_check()

void amxc_llist_delete_cb_check ( UNUSED void **  state)

Definition at line 128 of file test_amxc_llist.c.

128  {
129  amxc_llist_t* llist = NULL;
130 
131  // create list
132  assert_int_not_equal(amxc_llist_new(&llist), -1);
133  assert_int_equal(amxc_llist_it_init(&s_it_func_check), 0);
134  assert_int_equal(amxc_llist_append(llist, &s_it_func_check), 0);
135  amxc_llist_delete(&llist, NULL);
136  assert_ptr_equal(s_it_func_check.next, NULL);
137  assert_ptr_equal(s_it_func_check.prev, NULL);
138  assert_ptr_equal(s_it_func_check.llist, NULL);
139 }

◆ amxc_llist_delete_func_check()

void amxc_llist_delete_func_check ( UNUSED void **  state)

Definition at line 104 of file test_amxc_llist.c.

104  {
105  amxc_llist_t* llist = NULL;
106 
107  // create list
108  assert_int_not_equal(amxc_llist_new(&llist), -1);
109  assert_int_equal(amxc_llist_it_init(&s_it_func_check), 0);
110  assert_int_equal(amxc_llist_append(llist, &s_it_func_check), 0);
111 
112  amxc_llist_delete(&llist, check_it_delete_func);
113 }

◆ amxc_llist_get_at_check()

void amxc_llist_get_at_check ( UNUSED void **  state)

Definition at line 371 of file test_amxc_llist.c.

371  {
372  amxc_llist_setup();
373  assert_ptr_equal(amxc_llist_get_at(NULL, 10), NULL);
374  assert_ptr_equal(amxc_llist_get_at(llist1, 0), &it1);
375  assert_ptr_equal(amxc_llist_get_at(llist1, 1), &it2);
376  assert_ptr_equal(amxc_llist_get_at(llist1, 2), &it3);
377  assert_ptr_equal(amxc_llist_get_at(llist1, 3), NULL);
378  amxc_llist_teardown();
379 }
amxc_llist_get_at
amxc_llist_it_t * amxc_llist_get_at(const amxc_llist_t *const llist, const unsigned int index)
Gets an item at a certain position of the linked list.
Definition: amxc_llist.c:222

◆ amxc_llist_get_first_check()

void amxc_llist_get_first_check ( UNUSED void **  state)

Definition at line 415 of file test_amxc_llist.c.

415  {
416  assert_ptr_equal(amxc_llist_get_first(NULL), NULL);
417 }
amxc_llist_get_first
AMXC_INLINE amxc_llist_it_t * amxc_llist_get_first(const amxc_llist_t *const llist)
Gets the first item of the linked list.
Definition: amxc_llist.h:713

◆ amxc_llist_get_last_check()

void amxc_llist_get_last_check ( UNUSED void **  state)

Definition at line 419 of file test_amxc_llist.c.

419  {
420  assert_ptr_equal(amxc_llist_get_last(NULL), NULL);
421 }
amxc_llist_get_last
AMXC_INLINE amxc_llist_it_t * amxc_llist_get_last(const amxc_llist_t *const llist)
Gets the last item of the linked list.
Definition: amxc_llist.h:732

◆ amxc_llist_init_clean_check()

void amxc_llist_init_clean_check ( UNUSED void **  state)

Definition at line 89 of file test_amxc_llist.c.

89  {
90  amxc_llist_t llist;
91 
92  assert_int_equal(amxc_llist_init(&llist), 0);
93  assert_ptr_equal(llist.head, NULL);
94  assert_ptr_equal(llist.tail, NULL);
95  amxc_llist_clean(&llist, NULL);
96 }
amxc_llist_init
int amxc_llist_init(amxc_llist_t *const llist)
Initializes a linked list.
Definition: amxc_llist.c:111

◆ amxc_llist_init_clean_null_check()

void amxc_llist_init_clean_null_check ( UNUSED void **  state)

Definition at line 83 of file test_amxc_llist.c.

83  {
84  // passing NULL pointers should not lead to segfault
85  assert_int_equal(amxc_llist_init(NULL), -1);
86  amxc_llist_clean(NULL, NULL);
87 }

◆ amxc_llist_is_empty_check()

void amxc_llist_is_empty_check ( UNUSED void **  state)

Definition at line 331 of file test_amxc_llist.c.

331  {
332  amxc_llist_t* llist = NULL;
333  amxc_llist_it_t it1;
334 
335  assert_int_equal(amxc_llist_new(&llist), 0);
336  assert_int_equal(amxc_llist_it_init(&it1), 0);
337 
338  assert_int_equal(amxc_llist_is_empty(llist), true);
339  assert_int_equal(amxc_llist_append(llist, &it1), 0);
340  assert_int_equal(amxc_llist_is_empty(llist), false);
341 
342  amxc_llist_delete(&llist, NULL);
343 }
amxc_llist_is_empty
bool amxc_llist_is_empty(const amxc_llist_t *const llist)
Checks that the linked list is empty.
Definition: amxc_llist.c:165

◆ amxc_llist_is_empty_null_check()

void amxc_llist_is_empty_null_check ( UNUSED void **  state)

Definition at line 326 of file test_amxc_llist.c.

326  {
327  // passing NULL pointers should not lead to segfault
328  assert_int_equal(amxc_llist_is_empty(NULL), true);
329 }

◆ amxc_llist_it_clean_cb_check()

void amxc_llist_it_clean_cb_check ( UNUSED void **  state)

Definition at line 454 of file test_amxc_llist.c.

454  {
455  assert_int_equal(amxc_llist_it_init(&s_it_func_check), 0);
456  amxc_llist_it_clean(&s_it_func_check, check_it_delete_func);
457 }
amxc_llist_it_clean
void amxc_llist_it_clean(amxc_llist_it_t *const it, amxc_llist_it_delete_t func)
Removes the iterator from the list and frees allocated memory.
Definition: amxc_llist_it.c:103

◆ amxc_llist_it_clean_check()

void amxc_llist_it_clean_check ( UNUSED void **  state)

Definition at line 447 of file test_amxc_llist.c.

447  {
448  amxc_llist_it_t it;
449 
450  assert_int_equal(amxc_llist_it_init(&it), 0);
451  amxc_llist_it_clean(&it, NULL);
452 }
it
static amxc_htable_it_t it[2000]
Definition: test_amxc_htable.c:69

◆ amxc_llist_it_clean_null_check()

void amxc_llist_it_clean_null_check ( UNUSED void **  state)

Definition at line 437 of file test_amxc_llist.c.

437  {
438  amxc_llist_it_t it;
439 
440  assert_int_equal(amxc_llist_it_init(&it), 0);
441 
442  // passing NULL pointers should not lead to segfault
443  amxc_llist_it_clean(NULL, check_it_delete_func);
444  amxc_llist_it_clean(&it, NULL);
445 }

◆ amxc_llist_it_index_of_check()

void amxc_llist_it_index_of_check ( UNUSED void **  state)

Definition at line 604 of file test_amxc_llist.c.

604  {
605  amxc_llist_it_setup();
606  amxc_llist_it_t it;
607 
608  assert_int_equal(amxc_llist_it_init(&it), 0);
609  assert_int_equal(amxc_llist_it_index_of(NULL), AMXC_LLIST_RANGE);
610  assert_int_equal(amxc_llist_it_index_of(&it1), 0);
611  assert_int_equal(amxc_llist_it_index_of(&it2), 1);
612  assert_int_equal(amxc_llist_it_index_of(&it3), 2);
613  assert_int_equal(amxc_llist_it_index_of(&it), AMXC_LLIST_RANGE);
614  amxc_llist_it_teardown();
615 }
AMXC_LLIST_RANGE
#define AMXC_LLIST_RANGE
Definition: amxc_llist.h:69
amxc_llist_it_index_of
unsigned int amxc_llist_it_index_of(const amxc_llist_it_t *const it)
Gets the index of an iterator in the list.
Definition: amxc_llist_it.c:182
amxc_llist_it_setup
static void amxc_llist_it_setup(void)
Definition: test_amxc_llist.c:459
amxc_llist_it_teardown
static void amxc_llist_it_teardown(void)
Definition: test_amxc_llist.c:471

◆ amxc_llist_it_init_check()

void amxc_llist_it_init_check ( UNUSED void **  state)

Definition at line 428 of file test_amxc_llist.c.

428  {
429  amxc_llist_it_t it;
430 
431  assert_int_equal(amxc_llist_it_init(&it), 0);
432  assert_ptr_equal(it.next, NULL);
433  assert_ptr_equal(it.prev, NULL);
434  assert_ptr_equal(it.llist, NULL);
435 }
_amxc_htable_it::next
amxc_htable_it_t * next
Definition: amxc_htable.h:141

◆ amxc_llist_it_init_null_check()

void amxc_llist_it_init_null_check ( UNUSED void **  state)

Definition at line 423 of file test_amxc_llist.c.

423  {
424  // passing NULL pointers should not lead to segfault
425  assert_int_equal(amxc_llist_it_init(NULL), -1);
426 }

◆ amxc_llist_it_insert_after_check()

void amxc_llist_it_insert_after_check ( UNUSED void **  state)

Definition at line 567 of file test_amxc_llist.c.

567  {
568  amxc_llist_it_setup();
569  assert_int_equal(amxc_llist_it_insert_after(&it2, &s_it_func_check), 0);
570  assert_ptr_equal(it3.next, NULL);
571  assert_ptr_equal(it3.prev, &s_it_func_check);
572  assert_ptr_equal(it2.next, &s_it_func_check);
573  assert_ptr_equal(it2.prev, &it1);
574  assert_ptr_equal(s_it_func_check.next, &it3);
575  assert_ptr_equal(s_it_func_check.prev, &it2);
576  assert_ptr_equal(s_it_func_check.llist, llist);
577  amxc_llist_it_teardown();
578 }
amxc_llist_it_insert_after
int amxc_llist_it_insert_after(amxc_llist_it_t *const reference, amxc_llist_it_t *const it)
Inserts an iterator after another reference interator in the list.
Definition: amxc_llist_it.c:157

◆ amxc_llist_it_insert_after_invalid_it_check()

void amxc_llist_it_insert_after_invalid_it_check ( UNUSED void **  state)

Definition at line 591 of file test_amxc_llist.c.

591  {
592  amxc_llist_it_setup();
593  amxc_llist_it_take(&it2);
594 
595  assert_int_equal(amxc_llist_it_insert_after(&it2, &s_it_func_check), -1);
596  assert_ptr_equal(it2.next, NULL);
597  assert_ptr_equal(it2.prev, NULL);
598  assert_ptr_equal(s_it_func_check.next, NULL);
599  assert_ptr_equal(s_it_func_check.prev, NULL);
600  assert_ptr_equal(s_it_func_check.llist, NULL);
601  amxc_llist_it_teardown();
602 }
amxc_llist_it_take
void amxc_llist_it_take(amxc_llist_it_t *const it)
Removes the iterator from the list.
Definition: amxc_llist_it.c:110

◆ amxc_llist_it_insert_after_null_check()

void amxc_llist_it_insert_after_null_check ( UNUSED void **  state)

Definition at line 553 of file test_amxc_llist.c.

553  {
554  amxc_llist_it_setup();
555  assert_int_equal(amxc_llist_it_insert_after(NULL, NULL), -1);
556  assert_int_equal(amxc_llist_it_insert_after(&it1, NULL), -1);
557  assert_ptr_equal(it1.next, &it2);
558  assert_ptr_equal(it1.prev, NULL);
559  assert_ptr_equal(it1.llist, llist);
560  assert_int_equal(amxc_llist_it_insert_after(NULL, &it1), -1);
561  assert_ptr_equal(it1.next, &it2);
562  assert_ptr_equal(it1.prev, NULL);
563  assert_ptr_equal(it1.llist, llist);
564  amxc_llist_it_teardown();
565 }

◆ amxc_llist_it_insert_after_tail_check()

void amxc_llist_it_insert_after_tail_check ( UNUSED void **  state)

Definition at line 580 of file test_amxc_llist.c.

580  {
581  amxc_llist_it_setup();
582  assert_int_equal(amxc_llist_it_insert_after(&it3, &s_it_func_check), 0);
583  assert_ptr_equal(it3.next, &s_it_func_check);
584  assert_ptr_equal(it3.prev, &it2);
585  assert_ptr_equal(s_it_func_check.next, NULL);
586  assert_ptr_equal(s_it_func_check.prev, &it3);
587  assert_ptr_equal(s_it_func_check.llist, llist);
588  amxc_llist_it_teardown();
589 }

◆ amxc_llist_it_insert_before_check()

void amxc_llist_it_insert_before_check ( UNUSED void **  state)

Definition at line 516 of file test_amxc_llist.c.

516  {
517  amxc_llist_it_setup();
518  assert_int_equal(amxc_llist_it_insert_before(&it2, &s_it_func_check), 0);
519  assert_ptr_equal(it1.next, &s_it_func_check);
520  assert_ptr_equal(it1.prev, NULL);
521  assert_ptr_equal(it2.next, &it3);
522  assert_ptr_equal(it2.prev, &s_it_func_check);
523  assert_ptr_equal(s_it_func_check.next, &it2);
524  assert_ptr_equal(s_it_func_check.prev, &it1);
525  assert_ptr_equal(s_it_func_check.llist, llist);
526  amxc_llist_it_teardown();
527 }
amxc_llist_it_insert_before
int amxc_llist_it_insert_before(amxc_llist_it_t *const reference, amxc_llist_it_t *const it)
Inserts an iterator before a reference interator in the list.
Definition: amxc_llist_it.c:132

◆ amxc_llist_it_insert_before_head_check()

void amxc_llist_it_insert_before_head_check ( UNUSED void **  state)

Definition at line 529 of file test_amxc_llist.c.

529  {
530  amxc_llist_it_setup();
531  assert_int_equal(amxc_llist_it_insert_before(&it1, &s_it_func_check), 0);
532  assert_ptr_equal(it1.next, &it2);
533  assert_ptr_equal(it1.prev, &s_it_func_check);
534  assert_ptr_equal(s_it_func_check.next, &it1);
535  assert_ptr_equal(s_it_func_check.prev, NULL);
536  assert_ptr_equal(s_it_func_check.llist, llist);
537  amxc_llist_it_teardown();
538 }

◆ amxc_llist_it_insert_before_invalid_it_check()

void amxc_llist_it_insert_before_invalid_it_check ( UNUSED void **  state)

Definition at line 540 of file test_amxc_llist.c.

540  {
541  amxc_llist_it_setup();
542  amxc_llist_it_take(&it2);
543 
544  assert_int_equal(amxc_llist_it_insert_before(&it2, &s_it_func_check), -1);
545  assert_ptr_equal(it2.next, NULL);
546  assert_ptr_equal(it2.prev, NULL);
547  assert_ptr_equal(s_it_func_check.next, NULL);
548  assert_ptr_equal(s_it_func_check.prev, NULL);
549  assert_ptr_equal(s_it_func_check.llist, NULL);
550  amxc_llist_it_teardown();
551 }

◆ amxc_llist_it_insert_before_null_check()

void amxc_llist_it_insert_before_null_check ( UNUSED void **  state)

Definition at line 502 of file test_amxc_llist.c.

502  {
503  amxc_llist_it_setup();
504  assert_int_equal(amxc_llist_it_insert_before(NULL, NULL), -1);
505  assert_int_equal(amxc_llist_it_insert_before(&it1, NULL), -1);
506  assert_ptr_equal(it1.next, &it2);
507  assert_ptr_equal(it1.prev, NULL);
508  assert_ptr_equal(it1.llist, llist);
509  assert_int_equal(amxc_llist_it_insert_before(NULL, &it1), -1);
510  assert_ptr_equal(it1.next, &it2);
511  assert_ptr_equal(it1.prev, NULL);
512  assert_ptr_equal(it1.llist, llist);
513  amxc_llist_it_teardown();
514 }

◆ amxc_llist_it_is_in_list_check()

void amxc_llist_it_is_in_list_check ( UNUSED void **  state)

Definition at line 631 of file test_amxc_llist.c.

631  {
632  amxc_llist_it_setup();
633  amxc_llist_it_t it;
634 
635  assert_int_equal(amxc_llist_it_init(&it), 0);
636 
637  assert_false(amxc_llist_it_is_in_list(NULL));
638  assert_false(amxc_llist_it_is_in_list(&it));
639  assert_true(amxc_llist_it_is_in_list(&it1));
640  assert_true(amxc_llist_it_is_in_list(&it2));
641  assert_true(amxc_llist_it_is_in_list(&it3));
642 
643  amxc_llist_it_teardown();
644 }
amxc_llist_it_is_in_list
AMXC_INLINE bool amxc_llist_it_is_in_list(const amxc_llist_it_t *const it)
Checks that an iterator is in a list.
Definition: amxc_llist.h:857

◆ amxc_llist_it_next_prev_check()

void amxc_llist_it_next_prev_check ( UNUSED void **  state)

Definition at line 617 of file test_amxc_llist.c.

617  {
618  amxc_llist_it_setup();
619 
620  assert_ptr_equal(amxc_llist_it_get_next(NULL), NULL);
621  assert_ptr_equal(amxc_llist_it_get_previous(NULL), NULL);
622 
623  assert_ptr_equal(amxc_llist_it_get_next(&it1), &it2);
624  assert_ptr_equal(amxc_llist_it_get_previous(&it2), &it1);
625  assert_ptr_equal(amxc_llist_it_get_previous(&it1), NULL);
626  assert_ptr_equal(amxc_llist_it_get_next(&it3), NULL);
627 
628  amxc_llist_it_teardown();
629 }
amxc_llist_it_get_previous
AMXC_INLINE amxc_llist_it_t * amxc_llist_it_get_previous(const amxc_llist_it_t *const reference)
Gets the previous iterator in the list.
Definition: amxc_llist.h:842
amxc_llist_it_get_next
AMXC_INLINE amxc_llist_it_t * amxc_llist_it_get_next(const amxc_llist_it_t *const reference)
Gets the next iterator in the list.
Definition: amxc_llist.h:824

◆ amxc_llist_it_setup()

static void amxc_llist_it_setup ( void  )
static

Definition at line 459 of file test_amxc_llist.c.

459  {
460  assert_int_equal(amxc_llist_new(&llist), 0);
461  assert_int_equal(amxc_llist_it_init(&it1), 0);
462  assert_int_equal(amxc_llist_it_init(&it2), 0);
463  assert_int_equal(amxc_llist_it_init(&it3), 0);
464  assert_int_equal(amxc_llist_append(llist, &it1), 0);
465  assert_int_equal(amxc_llist_append(llist, &it2), 0);
466  assert_int_equal(amxc_llist_append(llist, &it3), 0);
467 
468  assert_int_equal(amxc_llist_it_init(&s_it_func_check), 0);
469 }

◆ amxc_llist_it_take_check()

void amxc_llist_it_take_check ( UNUSED void **  state)

Definition at line 479 of file test_amxc_llist.c.

479  {
480  amxc_llist_it_setup();
481  amxc_llist_it_take(&it2);
482  assert_ptr_equal(llist->head, &it1);
483  assert_ptr_equal(llist->tail, &it3);
484  assert_ptr_equal(it1.next, &it3);
485  assert_ptr_equal(it1.prev, NULL);
486  assert_ptr_equal(it2.next, NULL);
487  assert_ptr_equal(it2.prev, NULL);
488  assert_ptr_equal(it3.next, NULL);
489  assert_ptr_equal(it3.prev, &it1);
490  assert_ptr_equal(it2.llist, NULL);
491  amxc_llist_it_teardown();
492 }

◆ amxc_llist_it_take_double_check()

void amxc_llist_it_take_double_check ( UNUSED void **  state)

Definition at line 494 of file test_amxc_llist.c.

494  {
495  amxc_llist_it_setup();
496  amxc_llist_it_take(&it2);
497  // remove the iterator again should not lead to segfault
498  amxc_llist_it_take(&it2);
499  amxc_llist_it_teardown();
500 }

◆ amxc_llist_it_take_null_check()

void amxc_llist_it_take_null_check ( UNUSED void **  state)

Definition at line 475 of file test_amxc_llist.c.

475  {
476  amxc_llist_it_take(NULL);
477 }

◆ amxc_llist_it_teardown()

static void amxc_llist_it_teardown ( void  )
static

Definition at line 471 of file test_amxc_llist.c.

471  {
472  amxc_llist_delete(&llist, NULL);
473 }

◆ amxc_llist_new_delete_check()

void amxc_llist_new_delete_check ( UNUSED void **  state)

Definition at line 73 of file test_amxc_llist.c.

73  {
74  amxc_llist_t* llist = NULL;
75  assert_int_not_equal(amxc_llist_new(&llist), -1);
76  assert_ptr_not_equal(llist, NULL);
77  assert_ptr_equal(llist->head, NULL);
78  assert_ptr_equal(llist->tail, NULL);
79  amxc_llist_delete(&llist, NULL);
80  assert_ptr_equal(llist, NULL);
81 }

◆ amxc_llist_new_delete_null_check()

void amxc_llist_new_delete_null_check ( UNUSED void **  state)

Definition at line 67 of file test_amxc_llist.c.

67  {
68  // passing NULL pointers should not lead to segfault
69  assert_int_equal(amxc_llist_new(NULL), -1);
70  amxc_llist_delete(NULL, NULL);
71 }

◆ amxc_llist_prepend_check()

void amxc_llist_prepend_check ( UNUSED void **  state)

Definition at line 215 of file test_amxc_llist.c.

215  {
216  amxc_llist_t* llist = NULL;
217  amxc_llist_it_t it1;
218  amxc_llist_it_t it2;
219 
220  assert_int_equal(amxc_llist_new(&llist), 0);
221  assert_int_equal(amxc_llist_it_init(&it1), 0);
222  assert_int_equal(amxc_llist_it_init(&it2), 0);
223 
224  // prepend iterator 1
225  assert_int_equal(amxc_llist_prepend(llist, &it1), 0);
226  assert_ptr_equal(llist->head, &it1);
227  assert_ptr_equal(llist->tail, &it1);
228  assert_ptr_equal(it1.next, NULL);
229  assert_ptr_equal(it1.prev, NULL);
230  assert_ptr_equal(it1.llist, llist);
231 
232  // append iterator 2
233  assert_int_equal(amxc_llist_prepend(llist, &it2), 0);
234  assert_ptr_equal(llist->head, &it2);
235  assert_ptr_equal(llist->tail, &it1);
236  assert_ptr_equal(it2.next, &it1);
237  assert_ptr_equal(it1.prev, &it2);
238  assert_ptr_equal(it2.prev, NULL);
239  assert_ptr_equal(it1.next, NULL);
240  assert_ptr_equal(it2.llist, llist);
241 
242  amxc_llist_delete(&llist, NULL);
243 }
amxc_llist_prepend
int amxc_llist_prepend(amxc_llist_t *const llist, amxc_llist_it_t *const it)
Adds an item to the beginning of the linked list.
Definition: amxc_llist.c:196

◆ amxc_llist_prepend_move_same_list_check()

void amxc_llist_prepend_move_same_list_check ( UNUSED void **  state)

Definition at line 298 of file test_amxc_llist.c.

298  {
299  amxc_llist_setup();
300  // move iterator 3 from tail to head in llist1
301  assert_int_equal(amxc_llist_prepend(llist1, &it3), 0);
302  assert_ptr_equal(llist1->head, &it3);
303  assert_ptr_equal(llist1->tail, &it2);
304  assert_ptr_equal(it1.next, &it2);
305  assert_ptr_equal(it1.prev, &it3);
306  assert_ptr_equal(it2.next, NULL);
307  assert_ptr_equal(it2.prev, &it1);
308  assert_ptr_equal(it3.next, &it1);
309  assert_ptr_equal(it3.prev, NULL);
310  assert_ptr_equal(it3.llist, llist1);
311 
312  // move iterator 2 to tail in llist1
313  assert_int_equal(amxc_llist_prepend(llist1, &it2), 0);
314  assert_ptr_equal(llist1->head, &it2);
315  assert_ptr_equal(llist1->tail, &it1);
316  assert_ptr_equal(it1.prev, &it3);
317  assert_ptr_equal(it1.next, NULL);
318  assert_ptr_equal(it2.next, &it3);
319  assert_ptr_equal(it2.prev, NULL);
320  assert_ptr_equal(it3.next, &it1);
321  assert_ptr_equal(it3.prev, &it2);
322  assert_ptr_equal(it2.llist, llist1);
323  amxc_llist_teardown();
324 }

◆ amxc_llist_prepend_null_check()

void amxc_llist_prepend_null_check ( UNUSED void **  state)

Definition at line 200 of file test_amxc_llist.c.

200  {
201  amxc_llist_t* llist = NULL;
202  amxc_llist_it_t it1;
203 
204  assert_int_equal(amxc_llist_new(&llist), 0);
205  assert_int_equal(amxc_llist_it_init(&it1), 0);
206 
207  // passing NULL pointers should not lead to segfault
208  assert_int_not_equal(amxc_llist_prepend(NULL, NULL), 0);
209  assert_int_not_equal(amxc_llist_prepend(llist, NULL), 0);
210  assert_int_not_equal(amxc_llist_prepend(NULL, &it1), 0);
211 
212  amxc_llist_delete(&llist, NULL);
213 }

◆ amxc_llist_set_at_check()

void amxc_llist_set_at_check ( UNUSED void **  state)

Definition at line 381 of file test_amxc_llist.c.

381  {
382  amxc_llist_setup();
383  amxc_llist_it_t it;
384  assert_int_equal(amxc_llist_set_at(NULL, 10, &it1), -1);
385 
386  assert_int_equal(amxc_llist_it_init(&it), 0);
387 
388  assert_int_equal(amxc_llist_set_at(llist1, 0, &it), 0);
389  assert_ptr_equal(it.next, &it1);
390  assert_ptr_equal(it.prev, NULL);
391  amxc_llist_it_take(&it);
392 
393  assert_int_equal(amxc_llist_set_at(llist1, 1, &it), 0);
394  assert_ptr_equal(it.next, &it2);
395  assert_ptr_equal(it.prev, &it1);
396  amxc_llist_it_take(&it);
397 
398  assert_int_equal(amxc_llist_set_at(llist1, 2, &it), 0);
399  assert_ptr_equal(it.next, &it3);
400  assert_ptr_equal(it.prev, &it2);
401  amxc_llist_it_take(&it);
402 
403  assert_int_equal(amxc_llist_set_at(llist1, 3, &it), 0);
404  assert_ptr_equal(it.next, NULL);
405  assert_ptr_equal(it.prev, &it3);
406  amxc_llist_it_take(&it);
407 
408  assert_int_equal(amxc_llist_set_at(llist1, 10, &it), -1);
409  assert_ptr_equal(it.next, NULL);
410  assert_ptr_equal(it.prev, NULL);
411  amxc_llist_it_take(&it);
412  amxc_llist_teardown();
413 }
amxc_llist_set_at
int amxc_llist_set_at(amxc_llist_t *llist, const unsigned int index, amxc_llist_it_t *const it)
Inserts an item at a certain position.
Definition: amxc_llist.c:237

◆ amxc_llist_setup()

static void amxc_llist_setup ( void  )
static

Definition at line 253 of file test_amxc_llist.c.

253  {
254  assert_int_equal(amxc_llist_new(&llist1), 0);
255  assert_int_equal(amxc_llist_new(&llist2), 0);
256  assert_int_equal(amxc_llist_it_init(&it1), 0);
257  assert_int_equal(amxc_llist_it_init(&it2), 0);
258  assert_int_equal(amxc_llist_it_init(&it3), 0);
259  assert_int_equal(amxc_llist_it_init(&it4), 0);
260  assert_int_equal(amxc_llist_append(llist1, &it1), 0);
261  assert_int_equal(amxc_llist_append(llist1, &it2), 0);
262  assert_int_equal(amxc_llist_append(llist1, &it3), 0);
263 }
it4
static amxc_llist_it_t it4
Definition: test_amxc_llist.c:251
llist2
static amxc_llist_t * llist2
Definition: test_amxc_llist.c:247

◆ amxc_llist_size_check()

void amxc_llist_size_check ( UNUSED void **  state)

Definition at line 350 of file test_amxc_llist.c.

350  {
351  amxc_llist_t* llist = NULL;
352  amxc_llist_it_t it1;
353  amxc_llist_it_t it2;
354 
355  assert_int_equal(amxc_llist_new(&llist), 0);
356  assert_int_equal(amxc_llist_it_init(&it1), 0);
357  assert_int_equal(amxc_llist_it_init(&it2), 0);
358 
359  assert_int_equal(amxc_llist_size(llist), 0);
360  assert_int_equal(amxc_llist_append(llist, &it1), 0);
361  assert_int_equal(amxc_llist_size(llist), 1);
362  assert_int_equal(amxc_llist_append(llist, &it2), 0);
363  assert_int_equal(amxc_llist_size(llist), 2);
364 
365  amxc_llist_clean(llist, NULL);
366  assert_int_equal(amxc_llist_size(llist), 0);
367 
368  amxc_llist_delete(&llist, NULL);
369 }
amxc_llist_size
size_t amxc_llist_size(const amxc_llist_t *const llist)
Calculates the size of the linked list.
Definition: amxc_llist.c:151

◆ amxc_llist_size_null_check()

void amxc_llist_size_null_check ( UNUSED void **  state)

Definition at line 345 of file test_amxc_llist.c.

345  {
346  // passing NULL pointers should not lead to segfault
347  assert_int_equal(amxc_llist_size(NULL), 0);
348 }

◆ amxc_llist_swap_in_different_llist_check()

void amxc_llist_swap_in_different_llist_check ( UNUSED void **  state)

Definition at line 696 of file test_amxc_llist.c.

696  {
697  amxc_llist_setup();
698 
699  assert_int_equal(amxc_llist_append(llist2, &it4), 0);
700  assert_int_equal(amxc_llist_it_swap(&it4, &it1), 0);
701  assert_ptr_equal(it4.llist, llist1);
702  assert_ptr_equal(it1.llist, llist2);
703 
704  assert_ptr_equal(amxc_llist_it_get_next(&it1), NULL);
705  assert_ptr_equal(amxc_llist_it_get_previous(&it1), NULL);
706 
707  assert_ptr_equal(amxc_llist_it_get_next(&it4), &it2);
708  assert_ptr_equal(amxc_llist_it_get_previous(&it4), NULL);
709 
710  amxc_llist_it_take(&it3);
711  assert_ptr_equal(it3.llist, NULL);
712  assert_int_equal(amxc_llist_it_swap(&it4, &it3), 0);
713 
714  amxc_llist_teardown();
715 }
amxc_llist_it_swap
int amxc_llist_it_swap(amxc_llist_it_t *it1, amxc_llist_it_t *it2)
Swaps two linked list iterators.
Definition: amxc_llist_it.c:200

◆ amxc_llist_swap_in_same_llist_check()

void amxc_llist_swap_in_same_llist_check ( UNUSED void **  state)

Definition at line 659 of file test_amxc_llist.c.

659  {
660  amxc_llist_setup();
661 
662  assert_ptr_equal(amxc_llist_get_first(llist1), &it1);
663  assert_int_equal(amxc_llist_it_swap(&it1, &it2), 0);
664  assert_ptr_equal(amxc_llist_get_first(llist1), &it2);
665  assert_ptr_equal(amxc_llist_it_get_next(&it1), &it3);
666  assert_ptr_equal(amxc_llist_it_get_previous(&it1), &it2);
667  assert_ptr_equal(amxc_llist_it_get_previous(&it2), NULL);
668  assert_ptr_equal(amxc_llist_it_get_next(&it2), &it1);
669 
670  assert_int_equal(amxc_llist_it_swap(&it3, &it2), 0);
671  assert_ptr_equal(amxc_llist_get_first(llist1), &it3);
672  assert_ptr_equal(amxc_llist_it_get_next(&it1), &it2);
673  assert_ptr_equal(amxc_llist_it_get_previous(&it1), &it3);
674  assert_ptr_equal(amxc_llist_it_get_previous(&it3), NULL);
675  assert_ptr_equal(amxc_llist_it_get_next(&it3), &it1);
676  assert_ptr_equal(amxc_llist_get_last(llist1), &it2);
677 
678  assert_int_equal(amxc_llist_it_swap(&it1, &it3), 0);
679  assert_int_equal(amxc_llist_it_swap(&it2, &it3), 0);
680  assert_ptr_equal(amxc_llist_get_first(llist1), &it1);
681  assert_ptr_equal(amxc_llist_it_get_next(&it1), &it2);
682  assert_ptr_equal(amxc_llist_it_get_next(&it2), &it3);
683  assert_ptr_equal(amxc_llist_it_get_next(&it3), NULL);
684  assert_ptr_equal(amxc_llist_get_last(llist1), &it3);
685  assert_ptr_equal(amxc_llist_it_get_previous(&it3), &it2);
686  assert_ptr_equal(amxc_llist_it_get_previous(&it2), &it1);
687  assert_ptr_equal(amxc_llist_it_get_previous(&it1), NULL);
688 
689  assert_int_equal(amxc_llist_it_swap(&it1, &it1), 0);
690  assert_int_not_equal(amxc_llist_it_swap(&it1, NULL), 0);
691  assert_int_not_equal(amxc_llist_it_swap(NULL, &it1), 0);
692 
693  amxc_llist_teardown();
694 }

◆ amxc_llist_take_at_check()

void amxc_llist_take_at_check ( UNUSED void **  state)

Definition at line 646 of file test_amxc_llist.c.

646  {
647  amxc_llist_it_setup();
648 
649  assert_ptr_equal(amxc_llist_take_at(NULL, 0), NULL);
650  assert_ptr_equal(amxc_llist_take_at(NULL, 1), NULL);
651 
652  assert_ptr_equal(amxc_llist_take_at(llist, 2), &it3);
653  assert_ptr_equal(amxc_llist_take_at(llist, 0), &it1);
654  assert_ptr_equal(amxc_llist_take_at(llist, 0), &it2);
655 
656  amxc_llist_it_teardown();
657 }
amxc_llist_take_at
AMXC_INLINE amxc_llist_it_t * amxc_llist_take_at(const amxc_llist_t *llist, const unsigned int index)
Removes an item at a certain position of the linked list.
Definition: amxc_llist.h:803

◆ amxc_llist_teardown()

static void amxc_llist_teardown ( void  )
static

Definition at line 265 of file test_amxc_llist.c.

265  {
266  amxc_llist_delete(&llist1, NULL);
267  amxc_llist_delete(&llist2, NULL);
268 }

◆ check_it_delete_func()

static void check_it_delete_func ( amxc_llist_it_t *  it)
static

Definition at line 100 of file test_amxc_llist.c.

100  {
101  assert_ptr_equal(it, &s_it_func_check);
102 }

◆ test_amxc_llist_move()

void test_amxc_llist_move ( UNUSED void **  state)

Definition at line 771 of file test_amxc_llist.c.

771  {
772  amxc_llist_t src;
773  amxc_llist_t dst;
774  const char data[16] = "KRATELEPUIMQCXOS";
775 
776  amxc_llist_init(&src);
777  amxc_llist_init(&dst);
778  for(int i = 0; i < 16; i++) {
779  test_data_t* item = calloc(1, sizeof(test_data_t));
780  item->data = data[i];
781  amxc_llist_append(&src, &item->it);
782  }
783  assert_int_equal(amxc_llist_size(&src), 16);
784  assert_int_equal(amxc_llist_size(&dst), 0);
785 
786  assert_int_equal(amxc_llist_move(&dst, &src), 0);
787  assert_int_equal(amxc_llist_size(&src), 0);
788  assert_int_equal(amxc_llist_size(&dst), 16);
789 
790  for(int i = 0; i < 16; i++) {
791  test_data_t* item = calloc(1, sizeof(test_data_t));
792  item->data = data[i];
793  amxc_llist_append(&src, &item->it);
794  }
795 
796  assert_int_equal(amxc_llist_size(&src), 16);
797  assert_int_equal(amxc_llist_size(&dst), 16);
798 
799  assert_int_equal(amxc_llist_move(&dst, &src), 0);
800  assert_int_equal(amxc_llist_size(&src), 0);
801  assert_int_equal(amxc_llist_size(&dst), 32);
802 
803  assert_int_not_equal(amxc_llist_move(&dst, NULL), 0);
804  assert_int_not_equal(amxc_llist_move(NULL, &src), 0);
805 
806  amxc_llist_clean(&dst, test_del_data);
807  amxc_llist_clean(&src, test_del_data);
808 }
amxc_llist_move
int amxc_llist_move(amxc_llist_t *const dest, amxc_llist_t *const src)
Moves all items from one linked list to another linked list.
Definition: amxc_llist.c:135
test_data_t
Definition: test_amxc_llist.c:717
test_data_t::data
char data
Definition: test_amxc_llist.c:719
test_data_t::it
amxc_llist_it_t it
Definition: test_amxc_llist.c:718
data
char data[]
Definition: test_amxc_array.c:69
test_del_data
static void test_del_data(amxc_llist_it_t *it)
Definition: test_amxc_llist.c:735

◆ test_amxc_llist_sort()

void test_amxc_llist_sort ( UNUSED void **  state)

Definition at line 740 of file test_amxc_llist.c.

740  {
741  amxc_llist_t llist;
742  const char data[16] = "KRATELEPUIMQCXOS";
743  const char sorted[16] = "ACEEIKLMOPQRSTUX";
744 
745  amxc_llist_init(&llist);
746  for(int i = 0; i < 16; i++) {
747  test_data_t* item = calloc(1, sizeof(test_data_t));
748  item->data = data[i];
749  amxc_llist_append(&llist, &item->it);
750  }
751 
752  assert_int_equal(amxc_llist_sort(&llist, test_cmp), 0);
753  const amxc_llist_it_t* it = amxc_llist_get_first(&llist);
754  for(unsigned int index = 0; index < 16; index++) {
755  test_data_t* d = amxc_llist_it_get_data(it, test_data_t, it);
756  printf("%c\n", d->data);
757  assert_int_equal(d->data, sorted[index]);
758  it = amxc_llist_it_get_next(it);
759  }
760  amxc_llist_clean(&llist, test_del_data);
761 
762  amxc_llist_init(&llist);
763  assert_int_equal(amxc_llist_sort(&llist, test_cmp), 0);
764  amxc_llist_clean(&llist, test_del_data);
765 
766  assert_int_not_equal(amxc_llist_sort(&llist, NULL), 0);
767  assert_int_not_equal(amxc_llist_sort(NULL, test_cmp), 0);
768 }
amxc_llist_it_get_data
#define amxc_llist_it_get_data(it, type, member)
Gets the data pointer from a linked list iterator.
Definition: amxc_llist.h:238
amxc_llist_sort
int amxc_llist_sort(amxc_llist_t *const llist, amxc_llist_it_cmp_t cmp)
Sorts a linked list.
Definition: amxc_llist.c:262
test_cmp
static int test_cmp(amxc_llist_it_t *it1, amxc_llist_it_t *it2)
Definition: test_amxc_llist.c:722

◆ test_cmp()

static int test_cmp ( amxc_llist_it_t *  it1,
amxc_llist_it_t *  it2 
)
static

Definition at line 722 of file test_amxc_llist.c.

722  {
723  test_data_t* d1 = amxc_llist_it_get_data(it1, test_data_t, it);
724  test_data_t* d2 = amxc_llist_it_get_data(it2, test_data_t, it);
725 
726  if(d1->data < d2->data) {
727  return -1;
728  } else if(d1->data > d2->data) {
729  return 1;
730  }
731 
732  return 0;
733 }

◆ test_del_data()

static void test_del_data ( amxc_llist_it_t *  it)
static

Definition at line 735 of file test_amxc_llist.c.

735  {
736  test_data_t* d = amxc_llist_it_get_data(it, test_data_t, it);
737  free(d);
738 }

Variable Documentation

◆ it1

amxc_llist_it_t it1
static

Definition at line 248 of file test_amxc_llist.c.

◆ it2

amxc_llist_it_t it2
static

Definition at line 249 of file test_amxc_llist.c.

◆ it3

amxc_llist_it_t it3
static

Definition at line 250 of file test_amxc_llist.c.

◆ it4

amxc_llist_it_t it4
static

Definition at line 251 of file test_amxc_llist.c.

◆ llist

amxc_llist_t* llist = NULL
static

Definition at line 245 of file test_amxc_llist.c.

◆ llist1

amxc_llist_t* llist1 = NULL
static

Definition at line 246 of file test_amxc_llist.c.

◆ llist2

amxc_llist_t* llist2 = NULL
static

Definition at line 247 of file test_amxc_llist.c.

◆ s_it_func_check

amxc_llist_it_t s_it_func_check
static

Definition at line 98 of file test_amxc_llist.c.