/builds/xfbs/passgen/src/tests/stack.c
Line | Count | Source |
1 | | #include "passgen/container/stack.h" |
2 | | #include "tests.h" |
3 | | #include <stdlib.h> |
4 | | |
5 | 1 | test_result test_stack_init(void) { |
6 | 1 | passgen_stack stack; |
7 | 1 | passgen_stack_init(&stack, sizeof(size_t)); |
8 | 1 | passgen_stack_free(&stack); |
9 | 1 | return test_ok; |
10 | 1 | } |
11 | | |
12 | 1 | test_result test_stack_push_one(void) { |
13 | 1 | passgen_stack stack; |
14 | 1 | passgen_stack_init(&stack, sizeof(size_t)); |
15 | 1 | assert_eq(stack.len, 0); |
16 | 1 | |
17 | 1 | size_t value = 2; |
18 | 1 | size_t *value_ptr = passgen_stack_push(&stack, &value); |
19 | 1 | assert(value_ptr); |
20 | 1 | assert_eq(value, *value_ptr); |
21 | 1 | assert_eq(stack.len, 1); |
22 | 1 | |
23 | 1 | passgen_stack_free(&stack); |
24 | 1 | return test_ok; |
25 | 1 | } |
26 | | |
27 | 1 | test_result test_stack_push_multiple(void) { |
28 | 1 | passgen_stack stack; |
29 | 1 | passgen_stack_init(&stack, sizeof(size_t)); |
30 | 1 | |
31 | 1 | size_t value; |
32 | 1 | size_t *value_ptr; |
33 | 1 | |
34 | 1 | value = 1; |
35 | 1 | value_ptr = passgen_stack_push(&stack, &value); |
36 | 1 | assert(value_ptr); |
37 | 1 | assert_eq(value, *value_ptr); |
38 | 1 | assert_eq(stack.len, 1); |
39 | 1 | |
40 | 1 | value = 2; |
41 | 1 | value_ptr = passgen_stack_push(&stack, NULL); |
42 | 1 | assert(value_ptr); |
43 | 1 | *value_ptr = value; |
44 | 1 | assert_eq(value, *value_ptr); |
45 | 1 | assert_eq(stack.len, 2); |
46 | 1 | |
47 | 1 | value = 3; |
48 | 1 | value_ptr = passgen_stack_push(&stack, &value); |
49 | 1 | assert(value_ptr); |
50 | 1 | assert_eq(value, *value_ptr); |
51 | 1 | assert_eq(stack.len, 3); |
52 | 1 | |
53 | 1 | passgen_stack_free(&stack); |
54 | 1 | return test_ok; |
55 | 1 | } |
56 | | |
57 | 1 | test_result test_stack_push_bin_size(void) { |
58 | 1 | passgen_stack stack; |
59 | 1 | passgen_stack_init(&stack, sizeof(size_t)); |
60 | 1 | |
61 | 33 | for(size_t i = 0; i < stack.bin_size; i++32 ) { |
62 | 32 | assert_eq(stack.len, i); |
63 | 32 | size_t *value_ptr = passgen_stack_push(&stack, &i); |
64 | 32 | assert(value_ptr); |
65 | 32 | assert_eq(i, *value_ptr); |
66 | 32 | } |
67 | 1 | |
68 | 1 | passgen_stack_free(&stack); |
69 | 1 | return test_ok; |
70 | 1 | } |
71 | | |
72 | 1 | test_result test_stack_push_many(void) { |
73 | 1 | passgen_stack stack; |
74 | 1 | passgen_stack_init(&stack, sizeof(size_t)); |
75 | 1 | size_t len_max = 7 * stack.bin_size - 3; |
76 | 1 | |
77 | 222 | for(size_t i = 0; i < len_max; i++221 ) { |
78 | 221 | assert_eq(stack.len, i); |
79 | 221 | size_t *value_ptr = passgen_stack_push(&stack, &i); |
80 | 221 | assert(value_ptr); |
81 | 221 | assert_eq(i, *value_ptr); |
82 | 221 | } |
83 | 1 | |
84 | 1 | assert_eq(stack.len, len_max); |
85 | 1 | passgen_stack_free(&stack); |
86 | 1 | return test_ok; |
87 | 1 | } |
88 | | |
89 | 1 | test_result test_stack_get_one(void) { |
90 | 1 | passgen_stack stack; |
91 | 1 | passgen_stack_init(&stack, sizeof(size_t)); |
92 | 1 | size_t *value_ptr; |
93 | 1 | size_t value = 1; |
94 | 1 | |
95 | 1 | value_ptr = passgen_stack_push(&stack, &value); |
96 | 1 | assert(value_ptr); |
97 | 1 | assert_eq(value, *value_ptr); |
98 | 1 | |
99 | 1 | value_ptr = passgen_stack_get(&stack, 0); |
100 | 1 | assert(value_ptr); |
101 | 1 | assert_eq(value, *value_ptr); |
102 | 1 | |
103 | 1 | passgen_stack_free(&stack); |
104 | 1 | return test_ok; |
105 | 1 | } |
106 | | |
107 | 1 | test_result test_stack_get_two(void) { |
108 | 1 | passgen_stack stack; |
109 | 1 | passgen_stack_init(&stack, sizeof(size_t)); |
110 | 1 | size_t *value_ptr; |
111 | 1 | size_t value = 1; |
112 | 1 | |
113 | 1 | value_ptr = passgen_stack_push(&stack, &value); |
114 | 1 | assert(value_ptr); |
115 | 1 | assert_eq(value, *value_ptr); |
116 | 1 | |
117 | 1 | value = 2; |
118 | 1 | value_ptr = passgen_stack_push(&stack, &value); |
119 | 1 | assert(value_ptr); |
120 | 1 | assert_eq(value, *value_ptr); |
121 | 1 | |
122 | 1 | value_ptr = passgen_stack_get(&stack, 0); |
123 | 1 | assert(value_ptr); |
124 | 1 | assert_eq(1, *value_ptr); |
125 | 1 | |
126 | 1 | value_ptr = passgen_stack_get(&stack, 1); |
127 | 1 | assert(value_ptr); |
128 | 1 | assert_eq(2, *value_ptr); |
129 | 1 | |
130 | 1 | passgen_stack_free(&stack); |
131 | 1 | return test_ok; |
132 | 1 | } |
133 | | |
134 | 1 | test_result test_stack_get_many(void) { |
135 | 1 | passgen_stack stack; |
136 | 1 | passgen_stack_init(&stack, sizeof(size_t)); |
137 | 1 | size_t max_len = 7 * stack.bin_size - 3; |
138 | 1 | |
139 | 222 | for(size_t i = 0; i < max_len; i++221 ) { |
140 | 221 | size_t *value_ptr = passgen_stack_push(&stack, &i); |
141 | 221 | assert(value_ptr); |
142 | 221 | assert_eq(i, *value_ptr); |
143 | 221 | } |
144 | 1 | |
145 | 222 | for(size_t i = 0; 1 i < stack.len; i++221 ) { |
146 | 221 | size_t *value_ptr = passgen_stack_get(&stack, i); |
147 | 221 | assert(value_ptr); |
148 | 221 | assert_eq(i, *value_ptr); |
149 | 221 | } |
150 | 1 | |
151 | 1 | passgen_stack_free(&stack); |
152 | 1 | return test_ok; |
153 | 1 | } |
154 | | |
155 | 1 | test_result test_stack_top_empty(void) { |
156 | 1 | passgen_stack stack; |
157 | 1 | passgen_stack_init(&stack, sizeof(size_t)); |
158 | 1 | |
159 | 1 | assert(!passgen_stack_top(&stack)); |
160 | 1 | |
161 | 1 | passgen_stack_free(&stack); |
162 | 1 | return test_ok; |
163 | 1 | } |
164 | | |
165 | 1 | test_result test_stack_top_one(void) { |
166 | 1 | passgen_stack stack; |
167 | 1 | passgen_stack_init(&stack, sizeof(size_t)); |
168 | 1 | |
169 | 1 | size_t value = 1; |
170 | 1 | size_t *value_ptr; |
171 | 1 | |
172 | 1 | value_ptr = passgen_stack_push(&stack, &value); |
173 | 1 | assert(value_ptr); |
174 | 1 | assert_eq(value, *value_ptr); |
175 | 1 | |
176 | 1 | // should return the exact same pointer as push did |
177 | 1 | assert_eq(value_ptr, passgen_stack_top(&stack)); |
178 | 1 | |
179 | 1 | passgen_stack_free(&stack); |
180 | 1 | return test_ok; |
181 | 1 | } |
182 | | |
183 | 1 | test_result test_stack_top_many(void) { |
184 | 1 | passgen_stack stack; |
185 | 1 | passgen_stack_init(&stack, sizeof(size_t)); |
186 | 1 | size_t len_max = 8 * stack.bin_size; |
187 | 1 | |
188 | 257 | for(size_t i = 0; i < len_max; i++256 ) { |
189 | 256 | size_t *value_ptr = passgen_stack_push(&stack, &i); |
190 | 256 | assert(value_ptr); |
191 | 256 | assert_eq(i, *value_ptr); |
192 | 256 | assert_eq(value_ptr, passgen_stack_top(&stack)); |
193 | 256 | } |
194 | 1 | |
195 | 1 | passgen_stack_free(&stack); |
196 | 1 | return test_ok; |
197 | 1 | } |
198 | | |
199 | 254 | void element_free(void *data) { |
200 | 254 | void **real_data = data; |
201 | 254 | free(*real_data); |
202 | 254 | } |
203 | | |
204 | 1 | test_result test_stack_foreach_empty(void) { |
205 | 1 | passgen_stack stack; |
206 | 1 | passgen_stack_init(&stack, sizeof(size_t)); |
207 | 1 | passgen_stack_foreach(&stack, element_free); |
208 | 1 | passgen_stack_free(&stack); |
209 | 1 | return test_ok; |
210 | 1 | } |
211 | | |
212 | 1 | test_result test_stack_foreach_one(void) { |
213 | 1 | passgen_stack stack; |
214 | 1 | passgen_stack_init(&stack, sizeof(void *)); |
215 | 1 | void *data = malloc(255); |
216 | 1 | passgen_stack_push(&stack, &data); |
217 | 1 | passgen_stack_foreach(&stack, element_free); |
218 | 1 | passgen_stack_free(&stack); |
219 | 1 | return test_ok; |
220 | 1 | } |
221 | | |
222 | 1 | test_result test_stack_foreach_many(void) { |
223 | 1 | passgen_stack stack; |
224 | 1 | passgen_stack_init(&stack, sizeof(void *)); |
225 | 1 | size_t max_len = 8 * stack.bin_size - 3; |
226 | 1 | |
227 | 254 | for(size_t i = 0; i < max_len; i++253 ) { |
228 | 253 | void *data = malloc(255); |
229 | 253 | passgen_stack_push(&stack, &data); |
230 | 253 | } |
231 | 1 | |
232 | 1 | passgen_stack_foreach(&stack, element_free); |
233 | 1 | passgen_stack_free(&stack); |
234 | 1 | return test_ok; |
235 | 1 | } |
236 | | |
237 | 1 | test_result test_stack_pop_empty(void) { |
238 | 1 | passgen_stack stack; |
239 | 1 | passgen_stack_init(&stack, sizeof(size_t)); |
240 | 1 | |
241 | 1 | size_t value; |
242 | 1 | assert_eq(passgen_stack_pop(&stack, &value), NULL); |
243 | 1 | |
244 | 1 | passgen_stack_free(&stack); |
245 | 1 | return test_ok; |
246 | 1 | } |
247 | | |
248 | 1 | test_result test_stack_pop_one(void) { |
249 | 1 | passgen_stack stack; |
250 | 1 | passgen_stack_init(&stack, sizeof(size_t)); |
251 | 1 | |
252 | 1 | size_t value = 1; |
253 | 1 | passgen_stack_push(&stack, &value); |
254 | 1 | |
255 | 1 | size_t top = 0; |
256 | 1 | assert_eq(passgen_stack_pop(&stack, &top), &top); |
257 | 1 | assert_eq(top, value); |
258 | 1 | |
259 | 1 | passgen_stack_free(&stack); |
260 | 1 | return test_ok; |
261 | 1 | } |
262 | | |
263 | 1 | test_result test_stack_pop_some(void) { |
264 | 1 | passgen_stack stack; |
265 | 1 | passgen_stack_init(&stack, sizeof(size_t)); |
266 | 1 | |
267 | 33 | for(size_t i = 0; i < stack.bin_size; i++32 ) { |
268 | 32 | size_t *value = passgen_stack_push(&stack, &i); |
269 | 32 | assert(value); |
270 | 32 | assert_eq(*value, i); |
271 | 32 | } |
272 | 1 | |
273 | 33 | for(size_t i = 0; 1 i < stack.bin_size; i++32 ) { |
274 | 32 | size_t value; |
275 | 32 | size_t *ret = passgen_stack_pop(&stack, &value); |
276 | 32 | assert_eq(ret, &value); |
277 | 32 | assert_eq(value, stack.len); |
278 | 32 | } |
279 | 1 | |
280 | 1 | assert_eq(stack.len, 0); |
281 | 1 | |
282 | 1 | passgen_stack_free(&stack); |
283 | 1 | return test_ok; |
284 | 1 | } |
285 | | |
286 | 1 | test_result test_stack_pop_many(void) { |
287 | 1 | passgen_stack stack; |
288 | 1 | passgen_stack_init(&stack, sizeof(size_t)); |
289 | 1 | size_t max_len = 7 * stack.bin_size - 3; |
290 | 1 | |
291 | 222 | for(size_t i = 0; i < max_len; i++221 ) { |
292 | 221 | size_t *value = passgen_stack_push(&stack, &i); |
293 | 221 | assert(value); |
294 | 221 | assert_eq(*value, i); |
295 | 221 | } |
296 | 1 | |
297 | 222 | for(size_t i = 0; 1 i < max_len; i++221 ) { |
298 | 221 | size_t value; |
299 | 221 | size_t *ret = passgen_stack_pop(&stack, &value); |
300 | 221 | assert_eq(ret, &value); |
301 | 221 | assert_eq(value, stack.len); |
302 | 221 | } |
303 | 1 | |
304 | 1 | assert_eq(stack.len, 0); |
305 | 1 | |
306 | 1 | passgen_stack_free(&stack); |
307 | 1 | return test_ok; |
308 | 1 | } |