1 /* SPDX-License-Identifier: GPL-2.0-only */
2
3 #include <tests/test.h>
4 #include <stdlib.h>
5 #include <string.h>
6 #include <commonlib/list.h>
7
8 struct test_container {
9 int value;
10
11 struct list_node list_node;
12 };
13
test_list_insert_after(void ** state)14 void test_list_insert_after(void **state)
15 {
16 int i = 0;
17 struct list_node root = { .prev = NULL, .next = NULL };
18 struct test_container *c1 = (struct test_container *)malloc(sizeof(*c1));
19 struct test_container *c2 = (struct test_container *)malloc(sizeof(*c2));
20 struct test_container *c3 = (struct test_container *)malloc(sizeof(*c2));
21 struct test_container *ptr;
22 const int values[] = { 5, 10, 13 }; /* Random values */
23
24 memset(c1, 0, sizeof(*c1));
25 memset(c2, 0, sizeof(*c2));
26 memset(c2, 0, sizeof(*c3));
27
28 c1->value = values[0];
29 c2->value = values[1];
30 c3->value = values[2];
31
32 list_insert_after(&c1->list_node, &root);
33 list_insert_after(&c2->list_node, &c1->list_node);
34 list_insert_after(&c3->list_node, &c2->list_node);
35
36 list_for_each(ptr, root, list_node) {
37 assert_int_equal(values[i], ptr->value);
38 i++;
39 }
40
41 assert_int_equal(3, i);
42
43 free(c3);
44 free(c2);
45 free(c1);
46 }
47
test_list_insert_before(void ** state)48 void test_list_insert_before(void **state)
49 {
50 int i = 0;
51 struct list_node root = { .prev = NULL, .next = NULL };
52 struct test_container *c1 = (struct test_container *)malloc(sizeof(*c1));
53 struct test_container *c2 = (struct test_container *)malloc(sizeof(*c2));
54 struct test_container *c3 = (struct test_container *)malloc(sizeof(*c2));
55 struct test_container *ptr;
56 const int values[] = { 19, 71, 991 }; /* Random values */
57
58 memset(c1, 0, sizeof(*c1));
59 memset(c2, 0, sizeof(*c2));
60 memset(c2, 0, sizeof(*c3));
61
62 c1->value = values[0];
63 c2->value = values[1];
64 c3->value = values[2];
65
66 list_insert_after(&c3->list_node, &root);
67 list_insert_before(&c2->list_node, &c3->list_node);
68 list_insert_before(&c1->list_node, &c2->list_node);
69
70
71 list_for_each(ptr, root, list_node) {
72 assert_int_equal(values[i], ptr->value);
73 i++;
74 }
75
76 assert_int_equal(3, i);
77
78 free(c3);
79 free(c2);
80 free(c1);
81 }
82
test_list_remove(void ** state)83 void test_list_remove(void **state)
84 {
85 struct list_node root = { .prev = NULL, .next = NULL };
86 struct test_container *c1 = (struct test_container *)malloc(sizeof(*c1));
87 struct test_container *c2 = (struct test_container *)malloc(sizeof(*c2));
88 struct test_container *ptr;
89 int len;
90
91 list_insert_after(&c1->list_node, &root);
92 list_insert_after(&c2->list_node, &c1->list_node);
93
94 len = 0;
95 list_for_each(ptr, root, list_node) {
96 len++;
97 }
98 assert_int_equal(2, len);
99
100 list_remove(&c1->list_node);
101
102 len = 0;
103 list_for_each(ptr, root, list_node) {
104 len++;
105 }
106 assert_int_equal(1, len);
107
108 list_remove(&c2->list_node);
109 len = 0;
110 list_for_each(ptr, root, list_node) {
111 len++;
112 }
113 assert_int_equal(0, len);
114
115 free(c2);
116 free(c1);
117 }
118
test_list_append(void ** state)119 void test_list_append(void **state)
120 {
121 size_t idx;
122 struct test_container *node;
123 struct list_node root = {};
124 struct test_container nodes[] = {
125 {1}, {2}, {3}
126 };
127
128 for (idx = 0; idx < ARRAY_SIZE(nodes); ++idx)
129 list_append(&nodes[idx].list_node, &root);
130
131 idx = 0;
132 list_for_each(node, root, list_node) {
133 assert_ptr_equal(node, &nodes[idx]);
134 idx++;
135 }
136 }
137
main(void)138 int main(void)
139 {
140 const struct CMUnitTest tests[] = {
141 cmocka_unit_test(test_list_insert_after),
142 cmocka_unit_test(test_list_insert_before),
143 cmocka_unit_test(test_list_remove),
144 cmocka_unit_test(test_list_append),
145 };
146
147
148 return cb_run_group_tests(tests, NULL, NULL);
149 }
150