master
1#include "doubly_linked_list.h"
2#include <cgreen/cgreen.h>
3
4Describe(DoublyLinkedList);
5BeforeEach(DoublyLinkedList) {}
6AfterEach(DoublyLinkedList) {}
7
8Ensure(DoublyLinkedList, when_getting_head) {
9 Node *head = initialize(100);
10 assert_that(get(head, 0), is_equal_to(head));
11 free(head);
12}
13
14Ensure(DoublyLinkedList, when_getting_mid) {
15 Node *head = initialize(100);
16
17 Node *mid = add(head, 200);
18 add(head, 300);
19
20 assert_that(get(head, 1), is_equal_to(mid));
21 assert_that(get(head, 1)->data, is_equal_to(200));
22
23 free(head);
24}
25
26Ensure(DoublyLinkedList, when_getting_tail) {
27 Node *head = initialize(100);
28
29 add(head, 200);
30 Node *tail = add(head, 300);
31
32 assert_that(get(head, 2), is_equal_to(tail));
33
34 free(head);
35}
36
37Ensure(DoublyLinkedList, when_getting_from_empty_list) {
38 assert_that(get(NULL, 2), is_equal_to(NULL));
39}
40
41Ensure(DoublyLinkedList, when_getting_negative_index) {
42 Node *head = initialize(100);
43
44 assert_that(get(head, -1), is_equal_to(NULL));
45
46 free(head);
47}
48
49Ensure(DoublyLinkedList, when_getting_index_out_of_range) {
50 Node *head = initialize(100);
51
52 assert_that(get(head, 1), is_equal_to(NULL));
53
54 free(head);
55}
56
57Ensure(DoublyLinkedList, when_swapping_head_with_non_adjacent_node) {
58 Node *head = initialize(100);
59 Node *mid1 = add(head, 200);
60 Node *mid2 = add(head, 300);
61 Node *tail = add(head, 400);
62
63 swap(head, mid2);
64
65 assert_that(head->prev, is_equal_to(mid1));
66 assert_that(head->data, is_equal_to(100));
67 assert_that(head->next, is_equal_to(tail));
68
69 assert_that(mid1->prev, is_equal_to(mid2));
70 assert_that(mid1->data, is_equal_to(200));
71 assert_that(mid1->next, is_equal_to(head));
72
73 assert_that(mid2->prev, is_equal_to(NULL));
74 assert_that(mid2->data, is_equal_to(300));
75 assert_that(mid2->next, is_equal_to(mid1));
76
77 assert_that(tail->prev, is_equal_to(head));
78 assert_that(tail->data, is_equal_to(400));
79 assert_that(tail->next, is_equal_to(NULL));
80
81 free(head);
82}
83
84Ensure(DoublyLinkedList, when_swapping_head_with_non_adjacent_node_inverted) {
85 Node *head = initialize(100);
86 Node *mid1 = add(head, 200);
87 Node *mid2 = add(head, 300);
88 Node *tail = add(head, 400);
89
90 swap(mid2, head);
91
92 assert_that(head->prev, is_equal_to(mid1));
93 assert_that(head->data, is_equal_to(100));
94 assert_that(head->next, is_equal_to(tail));
95
96 assert_that(mid1->prev, is_equal_to(mid2));
97 assert_that(mid1->data, is_equal_to(200));
98 assert_that(mid1->next, is_equal_to(head));
99
100 assert_that(mid2->prev, is_equal_to(NULL));
101 assert_that(mid2->data, is_equal_to(300));
102 assert_that(mid2->next, is_equal_to(mid1));
103
104 assert_that(tail->prev, is_equal_to(head));
105 assert_that(tail->data, is_equal_to(400));
106 assert_that(tail->next, is_equal_to(NULL));
107
108 free(head);
109}
110
111Ensure(DoublyLinkedList, when_swapping_head_adjacent) {
112 Node *head = initialize(100);
113 Node *mid = add(head, 200);
114 Node *tail = add(head, 300);
115
116 swap(head, mid);
117
118 assert_that(head->prev, is_equal_to(mid));
119 assert_that(head->data, is_equal_to(100));
120 assert_that(head->next, is_equal_to(tail));
121
122 assert_that(mid->prev, is_equal_to(NULL));
123 assert_that(mid->data, is_equal_to(200));
124 assert_that(mid->next, is_equal_to(head));
125
126 assert_that(tail->prev, is_equal_to(head));
127 assert_that(tail->data, is_equal_to(300));
128 assert_that(tail->next, is_equal_to(NULL));
129
130 free(head);
131}
132
133Ensure(DoublyLinkedList, when_swapping_head_adjacent_inverted) {
134 Node *head = initialize(100);
135 Node *mid = add(head, 200);
136 Node *tail = add(head, 300);
137
138 swap(mid, head);
139
140 assert_that(head->prev, is_equal_to(mid));
141 assert_that(head->data, is_equal_to(100));
142 assert_that(head->next, is_equal_to(tail));
143
144 assert_that(mid->prev, is_equal_to(NULL));
145 assert_that(mid->data, is_equal_to(200));
146 assert_that(mid->next, is_equal_to(head));
147
148 assert_that(tail->prev, is_equal_to(head));
149 assert_that(tail->data, is_equal_to(300));
150 assert_that(tail->next, is_equal_to(NULL));
151
152 free(head);
153}
154
155Ensure(DoublyLinkedList, when_swapping_mid) {
156 Node *head = initialize(100);
157 Node *mid1 = add(head, 200);
158 Node *mid2 = add(head, 300);
159 Node *mid3 = add(head, 400);
160 Node *tail = add(head, 500);
161
162 swap(mid1, mid3);
163
164 assert_that(head->prev, is_equal_to(NULL));
165 assert_that(head->data, is_equal_to(100));
166 assert_that(head->next, is_equal_to(mid3));
167
168 assert_that(mid1->prev, is_equal_to(mid2));
169 assert_that(mid1->data, is_equal_to(200));
170 assert_that(mid1->next, is_equal_to(tail));
171
172 assert_that(mid2->prev, is_equal_to(mid3));
173 assert_that(mid2->data, is_equal_to(300));
174 assert_that(mid2->next, is_equal_to(mid1));
175
176 assert_that(mid3->prev, is_equal_to(head));
177 assert_that(mid3->data, is_equal_to(400));
178 assert_that(mid3->next, is_equal_to(mid2));
179
180 assert_that(tail->prev, is_equal_to(mid1));
181 assert_that(tail->data, is_equal_to(500));
182 assert_that(tail->next, is_equal_to(NULL));
183
184 free(head);
185}
186
187Ensure(DoublyLinkedList, when_swapping_y_mid) {
188 Node *head = initialize(100);
189 Node *mid1 = add(head, 200);
190 Node *mid2 = add(head, 300);
191 Node *mid3 = add(head, 400);
192 Node *tail = add(head, 500);
193
194 swap(mid3, mid1);
195
196 assert_that(head->prev, is_equal_to(NULL));
197 assert_that(head->data, is_equal_to(100));
198 assert_that(head->next, is_equal_to(mid3));
199
200 assert_that(mid1->prev, is_equal_to(mid2));
201 assert_that(mid1->data, is_equal_to(200));
202 assert_that(mid1->next, is_equal_to(tail));
203
204 assert_that(mid2->prev, is_equal_to(mid3));
205 assert_that(mid2->data, is_equal_to(300));
206 assert_that(mid2->next, is_equal_to(mid1));
207
208 assert_that(mid3->prev, is_equal_to(head));
209 assert_that(mid3->data, is_equal_to(400));
210 assert_that(mid3->next, is_equal_to(mid2));
211
212 assert_that(tail->prev, is_equal_to(mid1));
213 assert_that(tail->data, is_equal_to(500));
214 assert_that(tail->next, is_equal_to(NULL));
215
216 free(head);
217}
218
219Ensure(DoublyLinkedList, when_swapping_mid_adjacent) {
220 Node *head = initialize(100);
221 Node *mid1 = add(head, 200);
222 Node *mid2 = add(head, 300);
223 Node *tail = add(head, 400);
224
225 swap(mid1, mid2);
226
227 assert_that(head->prev, is_equal_to(NULL));
228 assert_that(head->data, is_equal_to(100));
229 assert_that(head->next, is_equal_to(mid2));
230
231 assert_that(mid1->prev, is_equal_to(mid2));
232 assert_that(mid1->data, is_equal_to(200));
233 assert_that(mid1->next, is_equal_to(tail));
234
235 assert_that(mid2->prev, is_equal_to(head));
236 assert_that(mid2->data, is_equal_to(300));
237 assert_that(mid2->next, is_equal_to(mid1));
238
239 assert_that(tail->prev, is_equal_to(mid1));
240 assert_that(tail->data, is_equal_to(400));
241 assert_that(tail->next, is_equal_to(NULL));
242
243 free(head);
244}
245
246Ensure(DoublyLinkedList, when_swapping_mid_adjacent_y) {
247 Node *head = initialize(100);
248 Node *mid1 = add(head, 200);
249 Node *mid2 = add(head, 300);
250 Node *tail = add(head, 400);
251
252 swap(mid2, mid1);
253
254 assert_that(head->prev, is_equal_to(NULL));
255 assert_that(head->data, is_equal_to(100));
256 assert_that(head->next, is_equal_to(mid2));
257
258 assert_that(mid1->prev, is_equal_to(mid2));
259 assert_that(mid1->data, is_equal_to(200));
260 assert_that(mid1->next, is_equal_to(tail));
261
262 assert_that(mid2->prev, is_equal_to(head));
263 assert_that(mid2->data, is_equal_to(300));
264 assert_that(mid2->next, is_equal_to(mid1));
265
266 assert_that(tail->prev, is_equal_to(mid1));
267 assert_that(tail->data, is_equal_to(400));
268 assert_that(tail->next, is_equal_to(NULL));
269
270 free(head);
271}
272
273Ensure(DoublyLinkedList, when_swapping_tail_adjacent) {
274 Node *head = initialize(100);
275 Node *mid = add(head, 200);
276 Node *tail = add(head, 300);
277
278 swap(mid, tail);
279
280 assert_that(head->prev, is_equal_to(NULL));
281 assert_that(head->data, is_equal_to(100));
282 assert_that(head->next, is_equal_to(tail));
283
284 assert_that(mid->prev, is_equal_to(tail));
285 assert_that(mid->data, is_equal_to(200));
286 assert_that(mid->next, is_equal_to(NULL));
287
288 assert_that(tail->prev, is_equal_to(head));
289 assert_that(tail->data, is_equal_to(300));
290 assert_that(tail->next, is_equal_to(mid));
291
292 free(head);
293}
294
295Ensure(DoublyLinkedList, when_swapping_tail_adjacent_inverted) {
296 Node *head = initialize(100);
297 Node *mid = add(head, 200);
298 Node *tail = add(head, 300);
299
300 swap(tail, mid);
301
302 assert_that(head->prev, is_equal_to(NULL));
303 assert_that(head->data, is_equal_to(100));
304 assert_that(head->next, is_equal_to(tail));
305
306 assert_that(mid->prev, is_equal_to(tail));
307 assert_that(mid->data, is_equal_to(200));
308 assert_that(mid->next, is_equal_to(NULL));
309
310 assert_that(tail->prev, is_equal_to(head));
311 assert_that(tail->data, is_equal_to(300));
312 assert_that(tail->next, is_equal_to(mid));
313
314 free(head);
315}
316
317Ensure(DoublyLinkedList, when_swapping_tail_with_non_adjacent_node) {
318 Node *head = initialize(100);
319 Node *mid1 = add(head, 200);
320 Node *mid2 = add(head, 300);
321 Node *tail = add(head, 400);
322
323 swap(mid1, tail);
324
325 assert_that(head->prev, is_equal_to(NULL));
326 assert_that(head->data, is_equal_to(100));
327 assert_that(head->next, is_equal_to(tail));
328
329 assert_that(mid1->prev, is_equal_to(mid2));
330 assert_that(mid1->data, is_equal_to(200));
331 assert_that(mid1->next, is_equal_to(NULL));
332
333 assert_that(mid2->prev, is_equal_to(tail));
334 assert_that(mid2->data, is_equal_to(300));
335 assert_that(mid2->next, is_equal_to(mid1));
336
337 assert_that(tail->prev, is_equal_to(head));
338 assert_that(tail->data, is_equal_to(400));
339 assert_that(tail->next, is_equal_to(mid2));
340
341 free(head);
342}
343
344Ensure(DoublyLinkedList, when_swapping_tail_with_non_adjacent_node_inverted) {
345 Node *head = initialize(100);
346 Node *mid1 = add(head, 200);
347 Node *mid2 = add(head, 300);
348 Node *tail = add(head, 400);
349
350 swap(tail, mid1);
351
352 assert_that(head->prev, is_equal_to(NULL));
353 assert_that(head->data, is_equal_to(100));
354 assert_that(head->next, is_equal_to(tail));
355
356 assert_that(mid1->prev, is_equal_to(mid2));
357 assert_that(mid1->data, is_equal_to(200));
358 assert_that(mid1->next, is_equal_to(NULL));
359
360 assert_that(mid2->prev, is_equal_to(tail));
361 assert_that(mid2->data, is_equal_to(300));
362 assert_that(mid2->next, is_equal_to(mid1));
363
364 assert_that(tail->prev, is_equal_to(head));
365 assert_that(tail->data, is_equal_to(400));
366 assert_that(tail->next, is_equal_to(mid2));
367
368 free(head);
369}
370
371Ensure(DoublyLinkedList, when_swapping_with_NULL) {
372 Node *head = initialize(100);
373 Node *mid = add(head, 200);
374 Node *tail = add(head, 300);
375
376 swap(mid, NULL);
377
378 assert_that(head->prev, is_equal_to(NULL));
379 assert_that(head->data, is_equal_to(100));
380 assert_that(head->next, is_equal_to(mid));
381
382 assert_that(mid->prev, is_equal_to(head));
383 assert_that(mid->data, is_equal_to(200));
384 assert_that(mid->next, is_equal_to(tail));
385
386 assert_that(tail->prev, is_equal_to(mid));
387 assert_that(tail->data, is_equal_to(300));
388 assert_that(tail->next, is_equal_to(NULL));
389
390 free(head);
391}
392
393Ensure(DoublyLinkedList, when_swapping_self) {
394 Node *head = initialize(100);
395 Node *mid = add(head, 200);
396 Node *tail = add(head, 300);
397
398 swap(mid, mid);
399
400 assert_that(head->prev, is_equal_to(NULL));
401 assert_that(head->data, is_equal_to(100));
402
403 free(head);
404}
405
406TestSuite *swap_doubly_linked_list_tests() {
407 TestSuite *suite = create_test_suite();
408
409 add_test_with_context(suite, DoublyLinkedList, when_getting_head);
410 add_test_with_context(suite, DoublyLinkedList, when_getting_mid);
411 add_test_with_context(suite, DoublyLinkedList, when_getting_tail);
412 add_test_with_context(suite, DoublyLinkedList, when_getting_from_empty_list);
413 add_test_with_context(suite, DoublyLinkedList, when_getting_negative_index);
414 add_test_with_context(suite, DoublyLinkedList,
415 when_getting_index_out_of_range);
416
417 add_test_with_context(suite, DoublyLinkedList, when_swapping_head_adjacent);
418 add_test_with_context(suite, DoublyLinkedList,
419 when_swapping_head_adjacent_inverted);
420 add_test_with_context(suite, DoublyLinkedList,
421 when_swapping_head_with_non_adjacent_node);
422 add_test_with_context(suite, DoublyLinkedList,
423 when_swapping_head_with_non_adjacent_node_inverted);
424 add_test_with_context(suite, DoublyLinkedList, when_swapping_mid);
425 add_test_with_context(suite, DoublyLinkedList, when_swapping_y_mid);
426 add_test_with_context(suite, DoublyLinkedList, when_swapping_mid_adjacent);
427 add_test_with_context(suite, DoublyLinkedList, when_swapping_mid_adjacent_y);
428 add_test_with_context(suite, DoublyLinkedList, when_swapping_tail_adjacent);
429 add_test_with_context(suite, DoublyLinkedList,
430 when_swapping_tail_adjacent_inverted);
431 add_test_with_context(suite, DoublyLinkedList,
432 when_swapping_tail_with_non_adjacent_node);
433 add_test_with_context(suite, DoublyLinkedList,
434 when_swapping_tail_with_non_adjacent_node_inverted);
435 add_test_with_context(suite, DoublyLinkedList, when_swapping_with_NULL);
436 add_test_with_context(suite, DoublyLinkedList, when_swapping_self);
437
438 return suite;
439}
440
441int main(int argc, char **argv) {
442 TestSuite *suite = create_test_suite();
443 add_suite(suite, swap_doubly_linked_list_tests());
444 return run_test_suite(suite, create_text_reporter());
445}