Merge branch 'for-linus' into for-next
[platform/kernel/linux-rpi.git] / lib / list-test.c
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
12 struct list_test_struct {
13         int data;
14         struct list_head list;
15 };
16
17 static 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
46 static 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
60 static 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
74 static 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
90 static 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
106 static 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
125 static 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
147 static 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
164 static void list_test_list_move(struct kunit *test)
165 {
166         struct list_head a, b;
167         LIST_HEAD(list1);
168         LIST_HEAD(list2);
169
170         list_add_tail(&a, &list1);
171         list_add_tail(&b, &list2);
172
173         /* before: [list1] -> a, [list2] -> b */
174         list_move(&a, &list2);
175         /* after: [list1] empty, [list2] -> a -> b */
176
177         KUNIT_EXPECT_TRUE(test, list_empty(&list1));
178
179         KUNIT_EXPECT_PTR_EQ(test, &a, list2.next);
180         KUNIT_EXPECT_PTR_EQ(test, &b, a.next);
181 }
182
183 static void list_test_list_move_tail(struct kunit *test)
184 {
185         struct list_head a, b;
186         LIST_HEAD(list1);
187         LIST_HEAD(list2);
188
189         list_add_tail(&a, &list1);
190         list_add_tail(&b, &list2);
191
192         /* before: [list1] -> a, [list2] -> b */
193         list_move_tail(&a, &list2);
194         /* after: [list1] empty, [list2] -> b -> a */
195
196         KUNIT_EXPECT_TRUE(test, list_empty(&list1));
197
198         KUNIT_EXPECT_PTR_EQ(test, &b, list2.next);
199         KUNIT_EXPECT_PTR_EQ(test, &a, b.next);
200 }
201
202 static void list_test_list_bulk_move_tail(struct kunit *test)
203 {
204         struct list_head a, b, c, d, x, y;
205         struct list_head *list1_values[] = { &x, &b, &c, &y };
206         struct list_head *list2_values[] = { &a, &d };
207         struct list_head *ptr;
208         LIST_HEAD(list1);
209         LIST_HEAD(list2);
210         int i = 0;
211
212         list_add_tail(&x, &list1);
213         list_add_tail(&y, &list1);
214
215         list_add_tail(&a, &list2);
216         list_add_tail(&b, &list2);
217         list_add_tail(&c, &list2);
218         list_add_tail(&d, &list2);
219
220         /* before: [list1] -> x -> y, [list2] -> a -> b -> c -> d */
221         list_bulk_move_tail(&y, &b, &c);
222         /* after: [list1] -> x -> b -> c -> y, [list2] -> a -> d */
223
224         list_for_each(ptr, &list1) {
225                 KUNIT_EXPECT_PTR_EQ(test, ptr, list1_values[i]);
226                 i++;
227         }
228         KUNIT_EXPECT_EQ(test, i, 4);
229         i = 0;
230         list_for_each(ptr, &list2) {
231                 KUNIT_EXPECT_PTR_EQ(test, ptr, list2_values[i]);
232                 i++;
233         }
234         KUNIT_EXPECT_EQ(test, i, 2);
235 }
236
237 static void list_test_list_is_first(struct kunit *test)
238 {
239         struct list_head a, b;
240         LIST_HEAD(list);
241
242         list_add_tail(&a, &list);
243         list_add_tail(&b, &list);
244
245         KUNIT_EXPECT_TRUE(test, list_is_first(&a, &list));
246         KUNIT_EXPECT_FALSE(test, list_is_first(&b, &list));
247 }
248
249 static void list_test_list_is_last(struct kunit *test)
250 {
251         struct list_head a, b;
252         LIST_HEAD(list);
253
254         list_add_tail(&a, &list);
255         list_add_tail(&b, &list);
256
257         KUNIT_EXPECT_FALSE(test, list_is_last(&a, &list));
258         KUNIT_EXPECT_TRUE(test, list_is_last(&b, &list));
259 }
260
261 static void list_test_list_empty(struct kunit *test)
262 {
263         struct list_head a;
264         LIST_HEAD(list1);
265         LIST_HEAD(list2);
266
267         list_add_tail(&a, &list1);
268
269         KUNIT_EXPECT_FALSE(test, list_empty(&list1));
270         KUNIT_EXPECT_TRUE(test, list_empty(&list2));
271 }
272
273 static void list_test_list_empty_careful(struct kunit *test)
274 {
275         /* This test doesn't check correctness under concurrent access */
276         struct list_head a;
277         LIST_HEAD(list1);
278         LIST_HEAD(list2);
279
280         list_add_tail(&a, &list1);
281
282         KUNIT_EXPECT_FALSE(test, list_empty_careful(&list1));
283         KUNIT_EXPECT_TRUE(test, list_empty_careful(&list2));
284 }
285
286 static void list_test_list_rotate_left(struct kunit *test)
287 {
288         struct list_head a, b;
289         LIST_HEAD(list);
290
291         list_add_tail(&a, &list);
292         list_add_tail(&b, &list);
293
294         /* before: [list] -> a -> b */
295         list_rotate_left(&list);
296         /* after: [list] -> b -> a */
297
298         KUNIT_EXPECT_PTR_EQ(test, list.next, &b);
299         KUNIT_EXPECT_PTR_EQ(test, b.prev, &list);
300         KUNIT_EXPECT_PTR_EQ(test, b.next, &a);
301 }
302
303 static void list_test_list_rotate_to_front(struct kunit *test)
304 {
305         struct list_head a, b, c, d;
306         struct list_head *list_values[] = { &c, &d, &a, &b };
307         struct list_head *ptr;
308         LIST_HEAD(list);
309         int i = 0;
310
311         list_add_tail(&a, &list);
312         list_add_tail(&b, &list);
313         list_add_tail(&c, &list);
314         list_add_tail(&d, &list);
315
316         /* before: [list] -> a -> b -> c -> d */
317         list_rotate_to_front(&c, &list);
318         /* after: [list] -> c -> d -> a -> b */
319
320         list_for_each(ptr, &list) {
321                 KUNIT_EXPECT_PTR_EQ(test, ptr, list_values[i]);
322                 i++;
323         }
324         KUNIT_EXPECT_EQ(test, i, 4);
325 }
326
327 static void list_test_list_is_singular(struct kunit *test)
328 {
329         struct list_head a, b;
330         LIST_HEAD(list);
331
332         /* [list] empty */
333         KUNIT_EXPECT_FALSE(test, list_is_singular(&list));
334
335         list_add_tail(&a, &list);
336
337         /* [list] -> a */
338         KUNIT_EXPECT_TRUE(test, list_is_singular(&list));
339
340         list_add_tail(&b, &list);
341
342         /* [list] -> a -> b */
343         KUNIT_EXPECT_FALSE(test, list_is_singular(&list));
344 }
345
346 static void list_test_list_cut_position(struct kunit *test)
347 {
348         struct list_head entries[3], *cur;
349         LIST_HEAD(list1);
350         LIST_HEAD(list2);
351         int i = 0;
352
353         list_add_tail(&entries[0], &list1);
354         list_add_tail(&entries[1], &list1);
355         list_add_tail(&entries[2], &list1);
356
357         /* before: [list1] -> entries[0] -> entries[1] -> entries[2] */
358         list_cut_position(&list2, &list1, &entries[1]);
359         /* after: [list2] -> entries[0] -> entries[1], [list1] -> entries[2] */
360
361         list_for_each(cur, &list2) {
362                 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
363                 i++;
364         }
365
366         KUNIT_EXPECT_EQ(test, i, 2);
367
368         list_for_each(cur, &list1) {
369                 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
370                 i++;
371         }
372 }
373
374 static void list_test_list_cut_before(struct kunit *test)
375 {
376         struct list_head entries[3], *cur;
377         LIST_HEAD(list1);
378         LIST_HEAD(list2);
379         int i = 0;
380
381         list_add_tail(&entries[0], &list1);
382         list_add_tail(&entries[1], &list1);
383         list_add_tail(&entries[2], &list1);
384
385         /* before: [list1] -> entries[0] -> entries[1] -> entries[2] */
386         list_cut_before(&list2, &list1, &entries[1]);
387         /* after: [list2] -> entries[0], [list1] -> entries[1] -> entries[2] */
388
389         list_for_each(cur, &list2) {
390                 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
391                 i++;
392         }
393
394         KUNIT_EXPECT_EQ(test, i, 1);
395
396         list_for_each(cur, &list1) {
397                 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
398                 i++;
399         }
400 }
401
402 static void list_test_list_splice(struct kunit *test)
403 {
404         struct list_head entries[5], *cur;
405         LIST_HEAD(list1);
406         LIST_HEAD(list2);
407         int i = 0;
408
409         list_add_tail(&entries[0], &list1);
410         list_add_tail(&entries[1], &list1);
411         list_add_tail(&entries[2], &list2);
412         list_add_tail(&entries[3], &list2);
413         list_add_tail(&entries[4], &list1);
414
415         /* before: [list1]->e[0]->e[1]->e[4], [list2]->e[2]->e[3] */
416         list_splice(&list2, &entries[1]);
417         /* after: [list1]->e[0]->e[1]->e[2]->e[3]->e[4], [list2] uninit */
418
419         list_for_each(cur, &list1) {
420                 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
421                 i++;
422         }
423
424         KUNIT_EXPECT_EQ(test, i, 5);
425 }
426
427 static void list_test_list_splice_tail(struct kunit *test)
428 {
429         struct list_head entries[5], *cur;
430         LIST_HEAD(list1);
431         LIST_HEAD(list2);
432         int i = 0;
433
434         list_add_tail(&entries[0], &list1);
435         list_add_tail(&entries[1], &list1);
436         list_add_tail(&entries[2], &list2);
437         list_add_tail(&entries[3], &list2);
438         list_add_tail(&entries[4], &list1);
439
440         /* before: [list1]->e[0]->e[1]->e[4], [list2]->e[2]->e[3] */
441         list_splice_tail(&list2, &entries[4]);
442         /* after: [list1]->e[0]->e[1]->e[2]->e[3]->e[4], [list2] uninit */
443
444         list_for_each(cur, &list1) {
445                 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
446                 i++;
447         }
448
449         KUNIT_EXPECT_EQ(test, i, 5);
450 }
451
452 static void list_test_list_splice_init(struct kunit *test)
453 {
454         struct list_head entries[5], *cur;
455         LIST_HEAD(list1);
456         LIST_HEAD(list2);
457         int i = 0;
458
459         list_add_tail(&entries[0], &list1);
460         list_add_tail(&entries[1], &list1);
461         list_add_tail(&entries[2], &list2);
462         list_add_tail(&entries[3], &list2);
463         list_add_tail(&entries[4], &list1);
464
465         /* before: [list1]->e[0]->e[1]->e[4], [list2]->e[2]->e[3] */
466         list_splice_init(&list2, &entries[1]);
467         /* after: [list1]->e[0]->e[1]->e[2]->e[3]->e[4], [list2] empty */
468
469         list_for_each(cur, &list1) {
470                 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
471                 i++;
472         }
473
474         KUNIT_EXPECT_EQ(test, i, 5);
475
476         KUNIT_EXPECT_TRUE(test, list_empty_careful(&list2));
477 }
478
479 static void list_test_list_splice_tail_init(struct kunit *test)
480 {
481         struct list_head entries[5], *cur;
482         LIST_HEAD(list1);
483         LIST_HEAD(list2);
484         int i = 0;
485
486         list_add_tail(&entries[0], &list1);
487         list_add_tail(&entries[1], &list1);
488         list_add_tail(&entries[2], &list2);
489         list_add_tail(&entries[3], &list2);
490         list_add_tail(&entries[4], &list1);
491
492         /* before: [list1]->e[0]->e[1]->e[4], [list2]->e[2]->e[3] */
493         list_splice_tail_init(&list2, &entries[4]);
494         /* after: [list1]->e[0]->e[1]->e[2]->e[3]->e[4], [list2] empty */
495
496         list_for_each(cur, &list1) {
497                 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
498                 i++;
499         }
500
501         KUNIT_EXPECT_EQ(test, i, 5);
502
503         KUNIT_EXPECT_TRUE(test, list_empty_careful(&list2));
504 }
505
506 static void list_test_list_entry(struct kunit *test)
507 {
508         struct list_test_struct test_struct;
509
510         KUNIT_EXPECT_PTR_EQ(test, &test_struct, list_entry(&(test_struct.list),
511                                 struct list_test_struct, list));
512 }
513
514 static void list_test_list_first_entry(struct kunit *test)
515 {
516         struct list_test_struct test_struct1, test_struct2;
517         LIST_HEAD(list);
518
519         list_add_tail(&test_struct1.list, &list);
520         list_add_tail(&test_struct2.list, &list);
521
522
523         KUNIT_EXPECT_PTR_EQ(test, &test_struct1, list_first_entry(&list,
524                                 struct list_test_struct, list));
525 }
526
527 static void list_test_list_last_entry(struct kunit *test)
528 {
529         struct list_test_struct test_struct1, test_struct2;
530         LIST_HEAD(list);
531
532         list_add_tail(&test_struct1.list, &list);
533         list_add_tail(&test_struct2.list, &list);
534
535
536         KUNIT_EXPECT_PTR_EQ(test, &test_struct2, list_last_entry(&list,
537                                 struct list_test_struct, list));
538 }
539
540 static void list_test_list_first_entry_or_null(struct kunit *test)
541 {
542         struct list_test_struct test_struct1, test_struct2;
543         LIST_HEAD(list);
544
545         KUNIT_EXPECT_FALSE(test, list_first_entry_or_null(&list,
546                                 struct list_test_struct, list));
547
548         list_add_tail(&test_struct1.list, &list);
549         list_add_tail(&test_struct2.list, &list);
550
551         KUNIT_EXPECT_PTR_EQ(test, &test_struct1,
552                         list_first_entry_or_null(&list,
553                                 struct list_test_struct, list));
554 }
555
556 static void list_test_list_next_entry(struct kunit *test)
557 {
558         struct list_test_struct test_struct1, test_struct2;
559         LIST_HEAD(list);
560
561         list_add_tail(&test_struct1.list, &list);
562         list_add_tail(&test_struct2.list, &list);
563
564
565         KUNIT_EXPECT_PTR_EQ(test, &test_struct2, list_next_entry(&test_struct1,
566                                 list));
567 }
568
569 static void list_test_list_prev_entry(struct kunit *test)
570 {
571         struct list_test_struct test_struct1, test_struct2;
572         LIST_HEAD(list);
573
574         list_add_tail(&test_struct1.list, &list);
575         list_add_tail(&test_struct2.list, &list);
576
577
578         KUNIT_EXPECT_PTR_EQ(test, &test_struct1, list_prev_entry(&test_struct2,
579                                 list));
580 }
581
582 static void list_test_list_for_each(struct kunit *test)
583 {
584         struct list_head entries[3], *cur;
585         LIST_HEAD(list);
586         int i = 0;
587
588         list_add_tail(&entries[0], &list);
589         list_add_tail(&entries[1], &list);
590         list_add_tail(&entries[2], &list);
591
592         list_for_each(cur, &list) {
593                 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
594                 i++;
595         }
596
597         KUNIT_EXPECT_EQ(test, i, 3);
598 }
599
600 static void list_test_list_for_each_prev(struct kunit *test)
601 {
602         struct list_head entries[3], *cur;
603         LIST_HEAD(list);
604         int i = 2;
605
606         list_add_tail(&entries[0], &list);
607         list_add_tail(&entries[1], &list);
608         list_add_tail(&entries[2], &list);
609
610         list_for_each_prev(cur, &list) {
611                 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
612                 i--;
613         }
614
615         KUNIT_EXPECT_EQ(test, i, -1);
616 }
617
618 static void list_test_list_for_each_safe(struct kunit *test)
619 {
620         struct list_head entries[3], *cur, *n;
621         LIST_HEAD(list);
622         int i = 0;
623
624
625         list_add_tail(&entries[0], &list);
626         list_add_tail(&entries[1], &list);
627         list_add_tail(&entries[2], &list);
628
629         list_for_each_safe(cur, n, &list) {
630                 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
631                 list_del(&entries[i]);
632                 i++;
633         }
634
635         KUNIT_EXPECT_EQ(test, i, 3);
636         KUNIT_EXPECT_TRUE(test, list_empty(&list));
637 }
638
639 static void list_test_list_for_each_prev_safe(struct kunit *test)
640 {
641         struct list_head entries[3], *cur, *n;
642         LIST_HEAD(list);
643         int i = 2;
644
645         list_add_tail(&entries[0], &list);
646         list_add_tail(&entries[1], &list);
647         list_add_tail(&entries[2], &list);
648
649         list_for_each_prev_safe(cur, n, &list) {
650                 KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
651                 list_del(&entries[i]);
652                 i--;
653         }
654
655         KUNIT_EXPECT_EQ(test, i, -1);
656         KUNIT_EXPECT_TRUE(test, list_empty(&list));
657 }
658
659 static void list_test_list_for_each_entry(struct kunit *test)
660 {
661         struct list_test_struct entries[5], *cur;
662         LIST_HEAD(list);
663         int i = 0;
664
665         for (i = 0; i < 5; ++i) {
666                 entries[i].data = i;
667                 list_add_tail(&entries[i].list, &list);
668         }
669
670         i = 0;
671
672         list_for_each_entry(cur, &list, list) {
673                 KUNIT_EXPECT_EQ(test, cur->data, i);
674                 i++;
675         }
676
677         KUNIT_EXPECT_EQ(test, i, 5);
678 }
679
680 static void list_test_list_for_each_entry_reverse(struct kunit *test)
681 {
682         struct list_test_struct entries[5], *cur;
683         LIST_HEAD(list);
684         int i = 0;
685
686         for (i = 0; i < 5; ++i) {
687                 entries[i].data = i;
688                 list_add_tail(&entries[i].list, &list);
689         }
690
691         i = 4;
692
693         list_for_each_entry_reverse(cur, &list, list) {
694                 KUNIT_EXPECT_EQ(test, cur->data, i);
695                 i--;
696         }
697
698         KUNIT_EXPECT_EQ(test, i, -1);
699 }
700
701 static struct kunit_case list_test_cases[] = {
702         KUNIT_CASE(list_test_list_init),
703         KUNIT_CASE(list_test_list_add),
704         KUNIT_CASE(list_test_list_add_tail),
705         KUNIT_CASE(list_test_list_del),
706         KUNIT_CASE(list_test_list_replace),
707         KUNIT_CASE(list_test_list_replace_init),
708         KUNIT_CASE(list_test_list_swap),
709         KUNIT_CASE(list_test_list_del_init),
710         KUNIT_CASE(list_test_list_move),
711         KUNIT_CASE(list_test_list_move_tail),
712         KUNIT_CASE(list_test_list_bulk_move_tail),
713         KUNIT_CASE(list_test_list_is_first),
714         KUNIT_CASE(list_test_list_is_last),
715         KUNIT_CASE(list_test_list_empty),
716         KUNIT_CASE(list_test_list_empty_careful),
717         KUNIT_CASE(list_test_list_rotate_left),
718         KUNIT_CASE(list_test_list_rotate_to_front),
719         KUNIT_CASE(list_test_list_is_singular),
720         KUNIT_CASE(list_test_list_cut_position),
721         KUNIT_CASE(list_test_list_cut_before),
722         KUNIT_CASE(list_test_list_splice),
723         KUNIT_CASE(list_test_list_splice_tail),
724         KUNIT_CASE(list_test_list_splice_init),
725         KUNIT_CASE(list_test_list_splice_tail_init),
726         KUNIT_CASE(list_test_list_entry),
727         KUNIT_CASE(list_test_list_first_entry),
728         KUNIT_CASE(list_test_list_last_entry),
729         KUNIT_CASE(list_test_list_first_entry_or_null),
730         KUNIT_CASE(list_test_list_next_entry),
731         KUNIT_CASE(list_test_list_prev_entry),
732         KUNIT_CASE(list_test_list_for_each),
733         KUNIT_CASE(list_test_list_for_each_prev),
734         KUNIT_CASE(list_test_list_for_each_safe),
735         KUNIT_CASE(list_test_list_for_each_prev_safe),
736         KUNIT_CASE(list_test_list_for_each_entry),
737         KUNIT_CASE(list_test_list_for_each_entry_reverse),
738         {},
739 };
740
741 static struct kunit_suite list_test_module = {
742         .name = "list-kunit-test",
743         .test_cases = list_test_cases,
744 };
745
746 kunit_test_suites(&list_test_module);
747
748 MODULE_LICENSE("GPL v2");