projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'for-5.18-rc5-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/kdave...
[linux-2.6-block.git] / lib / list-test.c
CommitLineData
ea2dd7c0
DG		 1// SPDX-License-Identifier: GPL-2.0
2/*
3 * KUnit test for the Kernel Linked-list structures.
4 *
5 * Copyright (C) 2019, Google LLC.
6 * Author: David Gow <davidgow@google.com>
7 */
8#include <kunit/test.h>
9
10#include <linux/list.h>
11
12struct list_test_struct {
13 int data;
14 struct list_head list;
15};
16
17static void list_test_list_init(struct kunit *test)
18{
19 /* Test the different ways of initialising a list. */
20 struct list_head list1 = LIST_HEAD_INIT(list1);
21 struct list_head list2;
22 LIST_HEAD(list3);
23 struct list_head *list4;
24 struct list_head *list5;
25
26 INIT_LIST_HEAD(&list2);
27
28 list4 = kzalloc(sizeof(*list4), GFP_KERNEL | __GFP_NOFAIL);
29 INIT_LIST_HEAD(list4);
30
31 list5 = kmalloc(sizeof(*list5), GFP_KERNEL | __GFP_NOFAIL);
32 memset(list5, 0xFF, sizeof(*list5));
33 INIT_LIST_HEAD(list5);
34
35 /* list_empty_careful() checks both next and prev. */
36 KUNIT_EXPECT_TRUE(test, list_empty_careful(&list1));
37 KUNIT_EXPECT_TRUE(test, list_empty_careful(&list2));
38 KUNIT_EXPECT_TRUE(test, list_empty_careful(&list3));
39 KUNIT_EXPECT_TRUE(test, list_empty_careful(list4));
40 KUNIT_EXPECT_TRUE(test, list_empty_careful(list5));
41
42 kfree(list4);
43 kfree(list5);
44}
45
46static void list_test_list_add(struct kunit *test)
47{
48 struct list_head a, b;
49 LIST_HEAD(list);
50
51 list_add(&a, &list);
52 list_add(&b, &list);
53
54 /* should be [list] -> b -> a */
55 KUNIT_EXPECT_PTR_EQ(test, list.next, &b);
56 KUNIT_EXPECT_PTR_EQ(test, b.prev, &list);
57 KUNIT_EXPECT_PTR_EQ(test, b.next, &a);
58}
59
60static void list_test_list_add_tail(struct kunit *test)
61{
62 struct list_head a, b;
63 LIST_HEAD(list);
64
65 list_add_tail(&a, &list);
66 list_add_tail(&b, &list);
67
68 /* should be [list] -> a -> b */
69 KUNIT_EXPECT_PTR_EQ(test, list.next, &a);
70 KUNIT_EXPECT_PTR_EQ(test, a.prev, &list);
71 KUNIT_EXPECT_PTR_EQ(test, a.next, &b);
72}
73
74static void list_test_list_del(struct kunit *test)
75{
76 struct list_head a, b;
77 LIST_HEAD(list);
78
79 list_add_tail(&a, &list);
80 list_add_tail(&b, &list);
81
82 /* before: [list] -> a -> b */
83 list_del(&a);
84
85 /* now: [list] -> b */
86 KUNIT_EXPECT_PTR_EQ(test, list.next, &b);
87 KUNIT_EXPECT_PTR_EQ(test, b.prev, &list);
88}
89
90static void list_test_list_replace(struct kunit *test)
91{
92 struct list_head a_old, a_new, b;
93 LIST_HEAD(list);
94
95 list_add_tail(&a_old, &list);
96 list_add_tail(&b, &list);
97
98 /* before: [list] -> a_old -> b */
99 list_replace(&a_old, &a_new);
100
101 /* now: [list] -> a_new -> b */
102 KUNIT_EXPECT_PTR_EQ(test, list.next, &a_new);
103 KUNIT_EXPECT_PTR_EQ(test, b.prev, &a_new);
104}
105
106static void list_test_list_replace_init(struct kunit *test)
107{
108 struct list_head a_old, a_new, b;
109 LIST_HEAD(list);
110
111 list_add_tail(&a_old, &list);
112 list_add_tail(&b, &list);
113
114 /* before: [list] -> a_old -> b */
115 list_replace_init(&a_old, &a_new);
116
117 /* now: [list] -> a_new -> b */
118 KUNIT_EXPECT_PTR_EQ(test, list.next, &a_new);
119 KUNIT_EXPECT_PTR_EQ(test, b.prev, &a_new);
120
121 /* check a_old is empty (initialized) */
122 KUNIT_EXPECT_TRUE(test, list_empty_careful(&a_old));
123}
124
125static void list_test_list_swap(struct kunit *test)
126{
127 struct list_head a, b;
128 LIST_HEAD(list);
129
130 list_add_tail(&a, &list);
131 list_add_tail(&b, &list);
132
133 /* before: [list] -> a -> b */
134 list_swap(&a, &b);
135
136 /* after: [list] -> b -> a */
137 KUNIT_EXPECT_PTR_EQ(test, &b, list.next);
138 KUNIT_EXPECT_PTR_EQ(test, &a, list.prev);
139
140 KUNIT_EXPECT_PTR_EQ(test, &a, b.next);
141 KUNIT_EXPECT_PTR_EQ(test, &list, b.prev);
142
143 KUNIT_EXPECT_PTR_EQ(test, &list, a.next);
144 KUNIT_EXPECT_PTR_EQ(test, &b, a.prev);
145}
146
147static void list_test_list_del_init(struct kunit *test)
148{
149 struct list_head a, b;
150 LIST_HEAD(list);
151
152 list_add_tail(&a, &list);
153 list_add_tail(&b, &list);
154
155 /* before: [list] -> a -> b */
156 list_del_init(&a);
157 /* after: [list] -> b, a initialised */
158
159 KUNIT_EXPECT_PTR_EQ(test, list.next, &b);
160 KUNIT_EXPECT_PTR_EQ(test, b.prev, &list);
161 KUNIT_EXPECT_TRUE(test, list_empty_careful(&a));
162}
163
d7fd696c
DG		 164static void list_test_list_del_init_careful(struct kunit *test)
165{
166 /* NOTE: This test only checks the behaviour of this function in
167 * isolation. It does not verify memory model guarantees.
168 */
169 struct list_head a, b;
170 LIST_HEAD(list);
171
172 list_add_tail(&a, &list);
173 list_add_tail(&b, &list);
174
175 /* before: [list] -> a -> b */
176 list_del_init_careful(&a);
177 /* after: [list] -> b, a initialised */
178
179 KUNIT_EXPECT_PTR_EQ(test, list.next, &b);
180 KUNIT_EXPECT_PTR_EQ(test, b.prev, &list);
181 KUNIT_EXPECT_TRUE(test, list_empty_careful(&a));
182}
183
ea2dd7c0
DG		 184static void list_test_list_move(struct kunit *test)
185{
186 struct list_head a, b;
187 LIST_HEAD(list1);
188 LIST_HEAD(list2);
189
190 list_add_tail(&a, &list1);
191 list_add_tail(&b, &list2);
192
193 /* before: [list1] -> a, [list2] -> b */
194 list_move(&a, &list2);
195 /* after: [list1] empty, [list2] -> a -> b */
196
197 KUNIT_EXPECT_TRUE(test, list_empty(&list1));
198
199 KUNIT_EXPECT_PTR_EQ(test, &a, list2.next);
200 KUNIT_EXPECT_PTR_EQ(test, &b, a.next);
201}
202
203static void list_test_list_move_tail(struct kunit *test)
204{
205 struct list_head a, b;
206 LIST_HEAD(list1);
207 LIST_HEAD(list2);
208
209 list_add_tail(&a, &list1);
210 list_add_tail(&b, &list2);
211
212 /* before: [list1] -> a, [list2] -> b */
213 list_move_tail(&a, &list2);
214 /* after: [list1] empty, [list2] -> b -> a */
215
216 KUNIT_EXPECT_TRUE(test, list_empty(&list1));
217
218 KUNIT_EXPECT_PTR_EQ(test, &b, list2.next);
219 KUNIT_EXPECT_PTR_EQ(test, &a, b.next);
220}
221
222static void list_test_list_bulk_move_tail(struct kunit *test)
223{
224 struct list_head a, b, c, d, x, y;
225 struct list_head *list1_values[] = { &x, &b, &c, &y };
226 struct list_head *list2_values[] = { &a, &d };
227 struct list_head *ptr;
228 LIST_HEAD(list1);
229 LIST_HEAD(list2);
230 int i = 0;
231
232 list_add_tail(&x, &list1);
233 list_add_tail(&y, &list1);
234
235 list_add_tail(&a, &list2);
236 list_add_tail(&b, &list2);
237 list_add_tail(&c, &list2);
238 list_add_tail(&d, &list2);
239
240 /* before: [list1] -> x -> y, [list2] -> a -> b -> c -> d */
241 list_bulk_move_tail(&y, &b, &c);
242 /* after: [list1] -> x -> b -> c -> y, [list2] -> a -> d */
243
244 list_for_each(ptr, &list1) {
245 KUNIT_EXPECT_PTR_EQ(test, ptr, list1_values[i]);
246 i++;
247 }
248 KUNIT_EXPECT_EQ(test, i, 4);
249 i = 0;
250 list_for_each(ptr, &list2) {
251 KUNIT_EXPECT_PTR_EQ(test, ptr, list2_values[i]);
252 i++;
253 }
254 KUNIT_EXPECT_EQ(test, i, 2);
255}
256
37dc573c
DG		 257static void list_test_list_is_head(struct kunit *test)
258{
259 struct list_head a, b, c;
260
261 /* Two lists: [a] -> b, [c] */
262 INIT_LIST_HEAD(&a);
263 INIT_LIST_HEAD(&c);
264 list_add_tail(&b, &a);
265
266 KUNIT_EXPECT_TRUE_MSG(test, list_is_head(&a, &a),
267 "Head element of same list");
268 KUNIT_EXPECT_FALSE_MSG(test, list_is_head(&a, &b),
269 "Non-head element of same list");
270 KUNIT_EXPECT_FALSE_MSG(test, list_is_head(&a, &c),
271 "Head element of different list");
272}
273
274
ea2dd7c0
DG		 275static void list_test_list_is_first(struct kunit *test)
276{
277 struct list_head a, b;
278 LIST_HEAD(list);
279
280 list_add_tail(&a, &list);
281 list_add_tail(&b, &list);
282
283 KUNIT_EXPECT_TRUE(test, list_is_first(&a, &list));
284 KUNIT_EXPECT_FALSE(test, list_is_first(&b, &list));
285}
286
287static void list_test_list_is_last(struct kunit *test)
288{
289 struct list_head a, b;
290 LIST_HEAD(list);
291
292 list_add_tail(&a, &list);
293 list_add_tail(&b, &list);
294
295 KUNIT_EXPECT_FALSE(test, list_is_last(&a, &list));
296 KUNIT_EXPECT_TRUE(test, list_is_last(&b, &list));
297}
298
299static void list_test_list_empty(struct kunit *test)
300{
301 struct list_head a;
302 LIST_HEAD(list1);
303 LIST_HEAD(list2);
304
305 list_add_tail(&a, &list1);
306
307 KUNIT_EXPECT_FALSE(test, list_empty(&list1));
308 KUNIT_EXPECT_TRUE(test, list_empty(&list2));
309}
310
311static void list_test_list_empty_careful(struct kunit *test)
312{
313 /* This test doesn't check correctness under concurrent access */
314 struct list_head a;
315 LIST_HEAD(list1);
316 LIST_HEAD(list2);
317
318 list_add_tail(&a, &list1);
319
320 KUNIT_EXPECT_FALSE(test, list_empty_careful(&list1));
321 KUNIT_EXPECT_TRUE(test, list_empty_careful(&list2));
322}
323
324static void list_test_list_rotate_left(struct kunit *test)
325{
326 struct list_head a, b;
327 LIST_HEAD(list);
328
329 list_add_tail(&a, &list);
330 list_add_tail(&b, &list);
331
332 /* before: [list] -> a -> b */
333 list_rotate_left(&list);
334 /* after: [list] -> b -> a */
335
336 KUNIT_EXPECT_PTR_EQ(test, list.next, &b);
337 KUNIT_EXPECT_PTR_EQ(test, b.prev, &list);
338 KUNIT_EXPECT_PTR_EQ(test, b.next, &a);
339}
340
341static void list_test_list_rotate_to_front(struct kunit *test)
342{
343 struct list_head a, b, c, d;
344 struct list_head *list_values[] = { &c, &d, &a, &b };
345 struct list_head *ptr;
346 LIST_HEAD(list);
347 int i = 0;
348
349 list_add_tail(&a, &list);
350 list_add_tail(&b, &list);
351 list_add_tail(&c, &list);
352 list_add_tail(&d, &list);
353
354 /* before: [list] -> a -> b -> c -> d */
355 list_rotate_to_front(&c, &list);
356 /* after: [list] -> c -> d -> a -> b */
357
358 list_for_each(ptr, &list) {
359 KUNIT_EXPECT_PTR_EQ(test, ptr, list_values[i]);
360 i++;
361 }
362 KUNIT_EXPECT_EQ(test, i, 4);
363}
364
365static void list_test_list_is_singular(struct kunit *test)
366{
367 struct list_head a, b;
368 LIST_HEAD(list);
369
370 /* [list] empty */
371 KUNIT_EXPECT_FALSE(test, list_is_singular(&list));
372
373 list_add_tail(&a, &list);
374
375 /* [list] -> a */
376 KUNIT_EXPECT_TRUE(test, list_is_singular(&list));
377
378 list_add_tail(&b, &list);
379
380 /* [list] -> a -> b */
381 KUNIT_EXPECT_FALSE(test, list_is_singular(&list));
382}
383
384static void list_test_list_cut_position(struct kunit *test)
385{
386 struct list_head entries[3], *cur;
387 LIST_HEAD(list1);
388 LIST_HEAD(list2);
389 int i = 0;
390
391 list_add_tail(&entries[0], &list1);
392 list_add_tail(&entries[1], &list1);
393 list_add_tail(&entries[2], &list1);
394
395 /* before: [list1] -> entries[0] -> entries[1] -> entries[2] */
396 list_cut_position(&list2, &list1, &entries[1]);
397 /* after: [list2] -> entries[0] -> entries[1], [list1] -> entries[2] */
398
399 list_for_each(cur, &list2) {
400 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
401 i++;
402 }
403
404 KUNIT_EXPECT_EQ(test, i, 2);
405
406 list_for_each(cur, &list1) {
407 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
408 i++;
409 }
410}
411
412static void list_test_list_cut_before(struct kunit *test)
413{
414 struct list_head entries[3], *cur;
415 LIST_HEAD(list1);
416 LIST_HEAD(list2);
417 int i = 0;
418
419 list_add_tail(&entries[0], &list1);
420 list_add_tail(&entries[1], &list1);
421 list_add_tail(&entries[2], &list1);
422
423 /* before: [list1] -> entries[0] -> entries[1] -> entries[2] */
424 list_cut_before(&list2, &list1, &entries[1]);
425 /* after: [list2] -> entries[0], [list1] -> entries[1] -> entries[2] */
426
427 list_for_each(cur, &list2) {
428 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
429 i++;
430 }
431
432 KUNIT_EXPECT_EQ(test, i, 1);
433
434 list_for_each(cur, &list1) {
435 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
436 i++;
437 }
438}
439
440static void list_test_list_splice(struct kunit *test)
441{
442 struct list_head entries[5], *cur;
443 LIST_HEAD(list1);
444 LIST_HEAD(list2);
445 int i = 0;
446
447 list_add_tail(&entries[0], &list1);
448 list_add_tail(&entries[1], &list1);
449 list_add_tail(&entries[2], &list2);
450 list_add_tail(&entries[3], &list2);
451 list_add_tail(&entries[4], &list1);
452
453 /* before: [list1]->e[0]->e[1]->e[4], [list2]->e[2]->e[3] */
454 list_splice(&list2, &entries[1]);
455 /* after: [list1]->e[0]->e[1]->e[2]->e[3]->e[4], [list2] uninit */
456
457 list_for_each(cur, &list1) {
458 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
459 i++;
460 }
461
462 KUNIT_EXPECT_EQ(test, i, 5);
463}
464
465static void list_test_list_splice_tail(struct kunit *test)
466{
467 struct list_head entries[5], *cur;
468 LIST_HEAD(list1);
469 LIST_HEAD(list2);
470 int i = 0;
471
472 list_add_tail(&entries[0], &list1);
473 list_add_tail(&entries[1], &list1);
474 list_add_tail(&entries[2], &list2);
475 list_add_tail(&entries[3], &list2);
476 list_add_tail(&entries[4], &list1);
477
478 /* before: [list1]->e[0]->e[1]->e[4], [list2]->e[2]->e[3] */
479 list_splice_tail(&list2, &entries[4]);
480 /* after: [list1]->e[0]->e[1]->e[2]->e[3]->e[4], [list2] uninit */
481
482 list_for_each(cur, &list1) {
483 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
484 i++;
485 }
486
487 KUNIT_EXPECT_EQ(test, i, 5);
488}
489
490static void list_test_list_splice_init(struct kunit *test)
491{
492 struct list_head entries[5], *cur;
493 LIST_HEAD(list1);
494 LIST_HEAD(list2);
495 int i = 0;
496
497 list_add_tail(&entries[0], &list1);
498 list_add_tail(&entries[1], &list1);
499 list_add_tail(&entries[2], &list2);
500 list_add_tail(&entries[3], &list2);
501 list_add_tail(&entries[4], &list1);
502
503 /* before: [list1]->e[0]->e[1]->e[4], [list2]->e[2]->e[3] */
504 list_splice_init(&list2, &entries[1]);
505 /* after: [list1]->e[0]->e[1]->e[2]->e[3]->e[4], [list2] empty */
506
507 list_for_each(cur, &list1) {
508 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
509 i++;
510 }
511
512 KUNIT_EXPECT_EQ(test, i, 5);
513
514 KUNIT_EXPECT_TRUE(test, list_empty_careful(&list2));
515}
516
517static void list_test_list_splice_tail_init(struct kunit *test)
518{
519 struct list_head entries[5], *cur;
520 LIST_HEAD(list1);
521 LIST_HEAD(list2);
522 int i = 0;
523
524 list_add_tail(&entries[0], &list1);
525 list_add_tail(&entries[1], &list1);
526 list_add_tail(&entries[2], &list2);
527 list_add_tail(&entries[3], &list2);
528 list_add_tail(&entries[4], &list1);
529
530 /* before: [list1]->e[0]->e[1]->e[4], [list2]->e[2]->e[3] */
531 list_splice_tail_init(&list2, &entries[4]);
532 /* after: [list1]->e[0]->e[1]->e[2]->e[3]->e[4], [list2] empty */
533
534 list_for_each(cur, &list1) {
535 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
536 i++;
537 }
538
539 KUNIT_EXPECT_EQ(test, i, 5);
540
541 KUNIT_EXPECT_TRUE(test, list_empty_careful(&list2));
542}
543
544static void list_test_list_entry(struct kunit *test)
545{
546 struct list_test_struct test_struct;
547
548 KUNIT_EXPECT_PTR_EQ(test, &test_struct, list_entry(&(test_struct.list),
549 struct list_test_struct, list));
550}
551
5debe5bf
DG		 552static void list_test_list_entry_is_head(struct kunit *test)
553{
554 struct list_test_struct test_struct1, test_struct2, test_struct3;
555
556 INIT_LIST_HEAD(&test_struct1.list);
557 INIT_LIST_HEAD(&test_struct3.list);
558
559 list_add_tail(&test_struct2.list, &test_struct1.list);
560
561 KUNIT_EXPECT_TRUE_MSG(test,
562 list_entry_is_head((&test_struct1), &test_struct1.list, list),
563 "Head element of same list");
564 KUNIT_EXPECT_FALSE_MSG(test,
565 list_entry_is_head((&test_struct2), &test_struct1.list, list),
566 "Non-head element of same list");
567 KUNIT_EXPECT_FALSE_MSG(test,
568 list_entry_is_head((&test_struct3), &test_struct1.list, list),
569 "Head element of different list");
570}
571
ea2dd7c0
DG		 572static void list_test_list_first_entry(struct kunit *test)
573{
574 struct list_test_struct test_struct1, test_struct2;
575 LIST_HEAD(list);
576
577 list_add_tail(&test_struct1.list, &list);
578 list_add_tail(&test_struct2.list, &list);
579
580
581 KUNIT_EXPECT_PTR_EQ(test, &test_struct1, list_first_entry(&list,
582 struct list_test_struct, list));
583}
584
585static void list_test_list_last_entry(struct kunit *test)
586{
587 struct list_test_struct test_struct1, test_struct2;
588 LIST_HEAD(list);
589
590 list_add_tail(&test_struct1.list, &list);
591 list_add_tail(&test_struct2.list, &list);
592
593
594 KUNIT_EXPECT_PTR_EQ(test, &test_struct2, list_last_entry(&list,
595 struct list_test_struct, list));
596}
597
598static void list_test_list_first_entry_or_null(struct kunit *test)
599{
600 struct list_test_struct test_struct1, test_struct2;
601 LIST_HEAD(list);
602
603 KUNIT_EXPECT_FALSE(test, list_first_entry_or_null(&list,
604 struct list_test_struct, list));
605
606 list_add_tail(&test_struct1.list, &list);
607 list_add_tail(&test_struct2.list, &list);
608
609 KUNIT_EXPECT_PTR_EQ(test, &test_struct1,
610 list_first_entry_or_null(&list,
611 struct list_test_struct, list));
612}
613
614static void list_test_list_next_entry(struct kunit *test)
615{
616 struct list_test_struct test_struct1, test_struct2;
617 LIST_HEAD(list);
618
619 list_add_tail(&test_struct1.list, &list);
620 list_add_tail(&test_struct2.list, &list);
621
622
623 KUNIT_EXPECT_PTR_EQ(test, &test_struct2, list_next_entry(&test_struct1,
624 list));
625}
626
627static void list_test_list_prev_entry(struct kunit *test)
628{
629 struct list_test_struct test_struct1, test_struct2;
630 LIST_HEAD(list);
631
632 list_add_tail(&test_struct1.list, &list);
633 list_add_tail(&test_struct2.list, &list);
634
635
636 KUNIT_EXPECT_PTR_EQ(test, &test_struct1, list_prev_entry(&test_struct2,
637 list));
638}
639
640static void list_test_list_for_each(struct kunit *test)
641{
642 struct list_head entries[3], *cur;
643 LIST_HEAD(list);
644 int i = 0;
645
646 list_add_tail(&entries[0], &list);
647 list_add_tail(&entries[1], &list);
648 list_add_tail(&entries[2], &list);
649
650 list_for_each(cur, &list) {
651 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
652 i++;
653 }
654
655 KUNIT_EXPECT_EQ(test, i, 3);
656}
657
658static void list_test_list_for_each_prev(struct kunit *test)
659{
660 struct list_head entries[3], *cur;
661 LIST_HEAD(list);
662 int i = 2;
663
664 list_add_tail(&entries[0], &list);
665 list_add_tail(&entries[1], &list);
666 list_add_tail(&entries[2], &list);
667
668 list_for_each_prev(cur, &list) {
669 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
670 i--;
671 }
672
673 KUNIT_EXPECT_EQ(test, i, -1);
674}
675
676static void list_test_list_for_each_safe(struct kunit *test)
677{
678 struct list_head entries[3], *cur, *n;
679 LIST_HEAD(list);
680 int i = 0;
681
682
683 list_add_tail(&entries[0], &list);
684 list_add_tail(&entries[1], &list);
685 list_add_tail(&entries[2], &list);
686
687 list_for_each_safe(cur, n, &list) {
688 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
689 list_del(&entries[i]);
690 i++;
691 }
692
693 KUNIT_EXPECT_EQ(test, i, 3);
694 KUNIT_EXPECT_TRUE(test, list_empty(&list));
695}
696
697static void list_test_list_for_each_prev_safe(struct kunit *test)
698{
699 struct list_head entries[3], *cur, *n;
700 LIST_HEAD(list);
701 int i = 2;
702
703 list_add_tail(&entries[0], &list);
704 list_add_tail(&entries[1], &list);
705 list_add_tail(&entries[2], &list);
706
707 list_for_each_prev_safe(cur, n, &list) {
708 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
709 list_del(&entries[i]);
710 i--;
711 }
712
713 KUNIT_EXPECT_EQ(test, i, -1);
714 KUNIT_EXPECT_TRUE(test, list_empty(&list));
715}
716
717static void list_test_list_for_each_entry(struct kunit *test)
718{
719 struct list_test_struct entries[5], *cur;
cb88577b 720 LIST_HEAD(list);
ea2dd7c0
DG		 721 int i = 0;
722
723 for (i = 0; i < 5; ++i) {
724 entries[i].data = i;
725 list_add_tail(&entries[i].list, &list);
726 }
727
728 i = 0;
729
730 list_for_each_entry(cur, &list, list) {
731 KUNIT_EXPECT_EQ(test, cur->data, i);
732 i++;
733 }
734
735 KUNIT_EXPECT_EQ(test, i, 5);
736}
737
738static void list_test_list_for_each_entry_reverse(struct kunit *test)
739{
740 struct list_test_struct entries[5], *cur;
cb88577b 741 LIST_HEAD(list);
ea2dd7c0
DG		 742 int i = 0;
743
744 for (i = 0; i < 5; ++i) {
745 entries[i].data = i;
746 list_add_tail(&entries[i].list, &list);
747 }
748
749 i = 4;
750
751 list_for_each_entry_reverse(cur, &list, list) {
752 KUNIT_EXPECT_EQ(test, cur->data, i);
753 i--;
754 }
755
756 KUNIT_EXPECT_EQ(test, i, -1);
757}
758
759static struct kunit_case list_test_cases[] = {
760 KUNIT_CASE(list_test_list_init),
761 KUNIT_CASE(list_test_list_add),
762 KUNIT_CASE(list_test_list_add_tail),
763 KUNIT_CASE(list_test_list_del),
764 KUNIT_CASE(list_test_list_replace),
765 KUNIT_CASE(list_test_list_replace_init),
766 KUNIT_CASE(list_test_list_swap),
767 KUNIT_CASE(list_test_list_del_init),
d7fd696c 768 KUNIT_CASE(list_test_list_del_init_careful),
ea2dd7c0
DG		 769 KUNIT_CASE(list_test_list_move),
770 KUNIT_CASE(list_test_list_move_tail),
771 KUNIT_CASE(list_test_list_bulk_move_tail),
37dc573c 772 KUNIT_CASE(list_test_list_is_head),
ea2dd7c0
DG		 773 KUNIT_CASE(list_test_list_is_first),
774 KUNIT_CASE(list_test_list_is_last),
775 KUNIT_CASE(list_test_list_empty),
776 KUNIT_CASE(list_test_list_empty_careful),
777 KUNIT_CASE(list_test_list_rotate_left),
778 KUNIT_CASE(list_test_list_rotate_to_front),
779 KUNIT_CASE(list_test_list_is_singular),
780 KUNIT_CASE(list_test_list_cut_position),
781 KUNIT_CASE(list_test_list_cut_before),
782 KUNIT_CASE(list_test_list_splice),
783 KUNIT_CASE(list_test_list_splice_tail),
784 KUNIT_CASE(list_test_list_splice_init),
785 KUNIT_CASE(list_test_list_splice_tail_init),
786 KUNIT_CASE(list_test_list_entry),
5debe5bf 787 KUNIT_CASE(list_test_list_entry_is_head),
ea2dd7c0
DG		 788 KUNIT_CASE(list_test_list_first_entry),
789 KUNIT_CASE(list_test_list_last_entry),
790 KUNIT_CASE(list_test_list_first_entry_or_null),
791 KUNIT_CASE(list_test_list_next_entry),
792 KUNIT_CASE(list_test_list_prev_entry),
793 KUNIT_CASE(list_test_list_for_each),
794 KUNIT_CASE(list_test_list_for_each_prev),
795 KUNIT_CASE(list_test_list_for_each_safe),
796 KUNIT_CASE(list_test_list_for_each_prev_safe),
797 KUNIT_CASE(list_test_list_for_each_entry),
798 KUNIT_CASE(list_test_list_for_each_entry_reverse),
799 {},
800};
801
802static struct kunit_suite list_test_module = {
803 .name = "list-kunit-test",
804 .test_cases = list_test_cases,
805};
806
c475c77d
AM		 807kunit_test_suites(&list_test_module);
808
809MODULE_LICENSE("GPL v2");
Linux 6.x block layer and io_uring tree(s)