3  * KUnit test for the Kernel Linked-list structures.
8 #include <kunit/test.h>
18 static void list_test_list_init(struct kunit *test)
37 	KUNIT_EXPECT_TRUE(test, list_empty_careful(&list1));
38 	KUNIT_EXPECT_TRUE(test, list_empty_careful(&list2));
39 	KUNIT_EXPECT_TRUE(test, list_empty_careful(&list3));
40 	KUNIT_EXPECT_TRUE(test, list_empty_careful(list4));
41 	KUNIT_EXPECT_TRUE(test, list_empty_careful(list5));
47 static void list_test_list_add(struct kunit *test)
56 	KUNIT_EXPECT_PTR_EQ(test, list.next, &b);
57 	KUNIT_EXPECT_PTR_EQ(test, b.prev, &list);
58 	KUNIT_EXPECT_PTR_EQ(test, b.next, &a);
61 static void list_test_list_add_tail(struct kunit *test)
70 	KUNIT_EXPECT_PTR_EQ(test, list.next, &a);
71 	KUNIT_EXPECT_PTR_EQ(test, a.prev, &list);
72 	KUNIT_EXPECT_PTR_EQ(test, a.next, &b);
75 static void list_test_list_del(struct kunit *test)
87 	KUNIT_EXPECT_PTR_EQ(test, list.next, &b);
88 	KUNIT_EXPECT_PTR_EQ(test, b.prev, &list);
91 static void list_test_list_replace(struct kunit *test)
103 	KUNIT_EXPECT_PTR_EQ(test, list.next, &a_new);
104 	KUNIT_EXPECT_PTR_EQ(test, b.prev, &a_new);
107 static void list_test_list_replace_init(struct kunit *test)
119 	KUNIT_EXPECT_PTR_EQ(test, list.next, &a_new);
120 	KUNIT_EXPECT_PTR_EQ(test, b.prev, &a_new);
123 	KUNIT_EXPECT_TRUE(test, list_empty_careful(&a_old));
126 static void list_test_list_swap(struct kunit *test)
138 	KUNIT_EXPECT_PTR_EQ(test, &b, list.next);
139 	KUNIT_EXPECT_PTR_EQ(test, &a, list.prev);
141 	KUNIT_EXPECT_PTR_EQ(test, &a, b.next);
142 	KUNIT_EXPECT_PTR_EQ(test, &list, b.prev);
144 	KUNIT_EXPECT_PTR_EQ(test, &list, a.next);
145 	KUNIT_EXPECT_PTR_EQ(test, &b, a.prev);
148 static void list_test_list_del_init(struct kunit *test)
160 	KUNIT_EXPECT_PTR_EQ(test, list.next, &b);
161 	KUNIT_EXPECT_PTR_EQ(test, b.prev, &list);
162 	KUNIT_EXPECT_TRUE(test, list_empty_careful(&a));
165 static void list_test_list_del_init_careful(struct kunit *test)
167 	/* NOTE: This test only checks the behaviour of this function in
180 	KUNIT_EXPECT_PTR_EQ(test, list.next, &b);
181 	KUNIT_EXPECT_PTR_EQ(test, b.prev, &list);
182 	KUNIT_EXPECT_TRUE(test, list_empty_careful(&a));
185 static void list_test_list_move(struct kunit *test)
198 	KUNIT_EXPECT_TRUE(test, list_empty(&list1));
200 	KUNIT_EXPECT_PTR_EQ(test, &a, list2.next);
201 	KUNIT_EXPECT_PTR_EQ(test, &b, a.next);
204 static void list_test_list_move_tail(struct kunit *test)
217 	KUNIT_EXPECT_TRUE(test, list_empty(&list1));
219 	KUNIT_EXPECT_PTR_EQ(test, &b, list2.next);
220 	KUNIT_EXPECT_PTR_EQ(test, &a, b.next);
223 static void list_test_list_bulk_move_tail(struct kunit *test)
246 		KUNIT_EXPECT_PTR_EQ(test, ptr, list1_values[i]);
249 	KUNIT_EXPECT_EQ(test, i, 4);
252 		KUNIT_EXPECT_PTR_EQ(test, ptr, list2_values[i]);
255 	KUNIT_EXPECT_EQ(test, i, 2);
258 static void list_test_list_is_head(struct kunit *test)
267 	KUNIT_EXPECT_TRUE_MSG(test, list_is_head(&a, &a),
269 	KUNIT_EXPECT_FALSE_MSG(test, list_is_head(&a, &b),
271 	KUNIT_EXPECT_FALSE_MSG(test, list_is_head(&a, &c),
276 static void list_test_list_is_first(struct kunit *test)
284 	KUNIT_EXPECT_TRUE(test, list_is_first(&a, &list));
285 	KUNIT_EXPECT_FALSE(test, list_is_first(&b, &list));
288 static void list_test_list_is_last(struct kunit *test)
296 	KUNIT_EXPECT_FALSE(test, list_is_last(&a, &list));
297 	KUNIT_EXPECT_TRUE(test, list_is_last(&b, &list));
300 static void list_test_list_empty(struct kunit *test)
308 	KUNIT_EXPECT_FALSE(test, list_empty(&list1));
309 	KUNIT_EXPECT_TRUE(test, list_empty(&list2));
312 static void list_test_list_empty_careful(struct kunit *test)
314 	/* This test doesn't check correctness under concurrent access */
321 	KUNIT_EXPECT_FALSE(test, list_empty_careful(&list1));
322 	KUNIT_EXPECT_TRUE(test, list_empty_careful(&list2));
325 static void list_test_list_rotate_left(struct kunit *test)
337 	KUNIT_EXPECT_PTR_EQ(test, list.next, &b);
338 	KUNIT_EXPECT_PTR_EQ(test, b.prev, &list);
339 	KUNIT_EXPECT_PTR_EQ(test, b.next, &a);
342 static void list_test_list_rotate_to_front(struct kunit *test)
360 		KUNIT_EXPECT_PTR_EQ(test, ptr, list_values[i]);
363 	KUNIT_EXPECT_EQ(test, i, 4);
366 static void list_test_list_is_singular(struct kunit *test)
372 	KUNIT_EXPECT_FALSE(test, list_is_singular(&list));
377 	KUNIT_EXPECT_TRUE(test, list_is_singular(&list));
382 	KUNIT_EXPECT_FALSE(test, list_is_singular(&list));
385 static void list_test_list_cut_position(struct kunit *test)
401 		KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
405 	KUNIT_EXPECT_EQ(test, i, 2);
408 		KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
413 static void list_test_list_cut_before(struct kunit *test)
429 		KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
433 	KUNIT_EXPECT_EQ(test, i, 1);
436 		KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
441 static void list_test_list_splice(struct kunit *test)
459 		KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
463 	KUNIT_EXPECT_EQ(test, i, 5);
466 static void list_test_list_splice_tail(struct kunit *test)
484 		KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
488 	KUNIT_EXPECT_EQ(test, i, 5);
491 static void list_test_list_splice_init(struct kunit *test)
509 		KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
513 	KUNIT_EXPECT_EQ(test, i, 5);
515 	KUNIT_EXPECT_TRUE(test, list_empty_careful(&list2));
518 static void list_test_list_splice_tail_init(struct kunit *test)
536 		KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
540 	KUNIT_EXPECT_EQ(test, i, 5);
542 	KUNIT_EXPECT_TRUE(test, list_empty_careful(&list2));
545 static void list_test_list_entry(struct kunit *test)
549 	KUNIT_EXPECT_PTR_EQ(test, &test_struct, list_entry(&(test_struct.list),
553 static void list_test_list_entry_is_head(struct kunit *test)
562 	KUNIT_EXPECT_TRUE_MSG(test,
565 	KUNIT_EXPECT_FALSE_MSG(test,
568 	KUNIT_EXPECT_FALSE_MSG(test,
573 static void list_test_list_first_entry(struct kunit *test)
582 	KUNIT_EXPECT_PTR_EQ(test, &test_struct1, list_first_entry(&list,
586 static void list_test_list_last_entry(struct kunit *test)
595 	KUNIT_EXPECT_PTR_EQ(test, &test_struct2, list_last_entry(&list,
599 static void list_test_list_first_entry_or_null(struct kunit *test)
604 	KUNIT_EXPECT_FALSE(test, list_first_entry_or_null(&list,
610 	KUNIT_EXPECT_PTR_EQ(test, &test_struct1,
615 static void list_test_list_next_entry(struct kunit *test)
624 	KUNIT_EXPECT_PTR_EQ(test, &test_struct2, list_next_entry(&test_struct1,
628 static void list_test_list_prev_entry(struct kunit *test)
637 	KUNIT_EXPECT_PTR_EQ(test, &test_struct1, list_prev_entry(&test_struct2,
641 static void list_test_list_for_each(struct kunit *test)
652 		KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
656 	KUNIT_EXPECT_EQ(test, i, 3);
659 static void list_test_list_for_each_prev(struct kunit *test)
670 		KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
674 	KUNIT_EXPECT_EQ(test, i, -1);
677 static void list_test_list_for_each_safe(struct kunit *test)
689 		KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
694 	KUNIT_EXPECT_EQ(test, i, 3);
695 	KUNIT_EXPECT_TRUE(test, list_empty(&list));
698 static void list_test_list_for_each_prev_safe(struct kunit *test)
709 		KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
714 	KUNIT_EXPECT_EQ(test, i, -1);
715 	KUNIT_EXPECT_TRUE(test, list_empty(&list));
718 static void list_test_list_for_each_entry(struct kunit *test)
732 		KUNIT_EXPECT_EQ(test, cur->data, i);
736 	KUNIT_EXPECT_EQ(test, i, 5);
739 static void list_test_list_for_each_entry_reverse(struct kunit *test)
753 		KUNIT_EXPECT_EQ(test, cur->data, i);
757 	KUNIT_EXPECT_EQ(test, i, -1);
804 	.name = "list-kunit-test",
813 static void hlist_test_init(struct kunit *test)
831 	KUNIT_EXPECT_TRUE(test, hlist_empty(&list1));
832 	KUNIT_EXPECT_TRUE(test, hlist_empty(&list2));
833 	KUNIT_EXPECT_TRUE(test, hlist_empty(&list3));
834 	KUNIT_EXPECT_TRUE(test, hlist_empty(list4));
835 	KUNIT_EXPECT_TRUE(test, hlist_empty(list5));
841 static void hlist_test_unhashed(struct kunit *test)
849 	KUNIT_EXPECT_TRUE(test, hlist_unhashed(&a));
854 	KUNIT_EXPECT_FALSE(test, hlist_unhashed(&a));
859 	KUNIT_EXPECT_TRUE(test, hlist_unhashed(&a));
862 /* Doesn't test concurrency guarantees */
863 static void hlist_test_unhashed_lockless(struct kunit *test)
871 	KUNIT_EXPECT_TRUE(test, hlist_unhashed_lockless(&a));
876 	KUNIT_EXPECT_FALSE(test, hlist_unhashed_lockless(&a));
881 	KUNIT_EXPECT_TRUE(test, hlist_unhashed_lockless(&a));
884 static void hlist_test_del(struct kunit *test)
896 	KUNIT_EXPECT_PTR_EQ(test, list.first, &b);
897 	KUNIT_EXPECT_PTR_EQ(test, b.pprev, &list.first);
900 static void hlist_test_del_init(struct kunit *test)
912 	KUNIT_EXPECT_PTR_EQ(test, list.first, &b);
913 	KUNIT_EXPECT_PTR_EQ(test, b.pprev, &list.first);
916 	KUNIT_EXPECT_PTR_EQ(test, a.next, NULL);
917 	KUNIT_EXPECT_PTR_EQ(test, a.pprev, NULL);
921 static void hlist_test_add(struct kunit *test)
932 	KUNIT_EXPECT_PTR_EQ(test, list.first, &b);
934 	KUNIT_EXPECT_PTR_EQ(test, c.pprev, &(b.next));
935 	KUNIT_EXPECT_PTR_EQ(test, b.next, &c);
937 	KUNIT_EXPECT_PTR_EQ(test, a.pprev, &(c.next));
938 	KUNIT_EXPECT_PTR_EQ(test, c.next, &a);
940 	KUNIT_EXPECT_PTR_EQ(test, d.pprev, &(a.next));
941 	KUNIT_EXPECT_PTR_EQ(test, a.next, &d);
945 static void hlist_test_fake(struct kunit *test)
952 	KUNIT_EXPECT_FALSE(test, hlist_fake(&a));
957 	KUNIT_EXPECT_TRUE(test, hlist_fake(&a));
960 static void hlist_test_is_singular_node(struct kunit *test)
966 	KUNIT_EXPECT_FALSE(test, hlist_is_singular_node(&a, &list));
969 	KUNIT_EXPECT_TRUE(test, hlist_is_singular_node(&a, &list));
972 	KUNIT_EXPECT_FALSE(test, hlist_is_singular_node(&a, &list));
973 	KUNIT_EXPECT_FALSE(test, hlist_is_singular_node(&b, &list));
976 static void hlist_test_empty(struct kunit *test)
982 	KUNIT_EXPECT_TRUE(test, hlist_empty(&list));
987 	KUNIT_EXPECT_FALSE(test, hlist_empty(&list));
990 static void hlist_test_move_list(struct kunit *test)
998 	KUNIT_EXPECT_FALSE(test, hlist_empty(&list1));
999 	KUNIT_EXPECT_TRUE(test, hlist_empty(&list2));
1001 	KUNIT_EXPECT_TRUE(test, hlist_empty(&list1));
1002 	KUNIT_EXPECT_FALSE(test, hlist_empty(&list2));
1006 static void hlist_test_entry(struct kunit *test)
1010 	KUNIT_EXPECT_PTR_EQ(test, &test_struct,
1015 static void hlist_test_entry_safe(struct kunit *test)
1019 	KUNIT_EXPECT_PTR_EQ(test, &test_struct,
1023 	KUNIT_EXPECT_PTR_EQ(test, NULL,
1028 static void hlist_test_for_each(struct kunit *test)
1039 		KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
1043 	KUNIT_EXPECT_EQ(test, i, 3);
1047 static void hlist_test_for_each_safe(struct kunit *test)
1058 		KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
1063 	KUNIT_EXPECT_EQ(test, i, 3);
1064 	KUNIT_EXPECT_TRUE(test, hlist_empty(&list));
1067 static void hlist_test_for_each_entry(struct kunit *test)
1083 		KUNIT_EXPECT_EQ(test, cur->data, i);
1087 	KUNIT_EXPECT_EQ(test, i, 5);
1090 static void hlist_test_for_each_entry_continue(struct kunit *test)
1108 		KUNIT_EXPECT_EQ(test, cur->data, i);
1114 	KUNIT_EXPECT_EQ(test, i, 5);
1116 	KUNIT_EXPECT_EQ(test, entries[0].data, 0);
1118 	KUNIT_EXPECT_EQ(test, entries[1].data, 42);
1121 static void hlist_test_for_each_entry_from(struct kunit *test)
1138 		KUNIT_EXPECT_EQ(test, cur->data, i);
1144 	KUNIT_EXPECT_EQ(test, i, 5);
1146 	KUNIT_EXPECT_EQ(test, entries[0].data, 42);
1149 static void hlist_test_for_each_entry_safe(struct kunit *test)
1166 		KUNIT_EXPECT_EQ(test, cur->data, i);
1171 	KUNIT_EXPECT_EQ(test, i, 5);
1172 	KUNIT_EXPECT_TRUE(test, hlist_empty(&list));
1225 static void klist_test_add_tail(struct kunit *test)
1235 	KUNIT_EXPECT_EQ(test, node_count, 1);
1236 	KUNIT_EXPECT_PTR_EQ(test, last_node, &a);
1239 	KUNIT_EXPECT_EQ(test, node_count, 2);
1240 	KUNIT_EXPECT_PTR_EQ(test, last_node, &b);
1245 	KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &a);
1246 	KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &b);
1247 	KUNIT_EXPECT_NULL(test, klist_next(&i));
1253 static void klist_test_add_head(struct kunit *test)
1263 	KUNIT_EXPECT_EQ(test, node_count, 1);
1264 	KUNIT_EXPECT_PTR_EQ(test, last_node, &a);
1267 	KUNIT_EXPECT_EQ(test, node_count, 2);
1268 	KUNIT_EXPECT_PTR_EQ(test, last_node, &b);
1273 	KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &b);
1274 	KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &a);
1275 	KUNIT_EXPECT_NULL(test, klist_next(&i));
1281 static void klist_test_add_behind(struct kunit *test)
1294 	KUNIT_EXPECT_EQ(test, node_count, 3);
1295 	KUNIT_EXPECT_PTR_EQ(test, last_node, &c);
1298 	KUNIT_EXPECT_EQ(test, node_count, 4);
1299 	KUNIT_EXPECT_PTR_EQ(test, last_node, &d);
1304 	KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &b);
1305 	KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &d);
1306 	KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &a);
1307 	KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &c);
1308 	KUNIT_EXPECT_NULL(test, klist_next(&i));
1314 static void klist_test_add_before(struct kunit *test)
1326 	KUNIT_EXPECT_EQ(test, node_count, 3);
1327 	KUNIT_EXPECT_PTR_EQ(test, last_node, &c);
1330 	KUNIT_EXPECT_EQ(test, node_count, 4);
1331 	KUNIT_EXPECT_PTR_EQ(test, last_node, &d);
1336 	KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &d);
1337 	KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &b);
1338 	KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &c);
1339 	KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &a);
1340 	KUNIT_EXPECT_NULL(test, klist_next(&i));
1350 static void klist_test_del_refcount_greater_than_zero(struct kunit *test)
1367 	KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &a);
1368 	KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &b);
1370 	KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &c);
1380 	KUNIT_EXPECT_TRUE(test, klist_node_attached(&c));
1383 	KUNIT_EXPECT_EQ(test, node_count, 4);
1384 	KUNIT_EXPECT_PTR_EQ(test, last_node, &d);
1392 	KUNIT_EXPECT_EQ(test, node_count, 3);
1393 	KUNIT_EXPECT_PTR_EQ(test, last_node, &c);
1401 static void klist_test_del_refcount_zero(struct kunit *test)
1419 	KUNIT_EXPECT_EQ(test, node_count, 3);
1420 	KUNIT_EXPECT_PTR_EQ(test, last_node, &c);
1425 	KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &a);
1426 	KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &b);
1427 	KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &d);
1428 	KUNIT_EXPECT_NULL(test, klist_next(&i));
1434 static void klist_test_remove(struct kunit *test)
1436 	/* This test doesn't check correctness under concurrent access */
1453 	KUNIT_EXPECT_EQ(test, node_count, 3);
1454 	KUNIT_EXPECT_PTR_EQ(test, last_node, &c);
1459 	KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &a);
1460 	KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &b);
1461 	KUNIT_EXPECT_PTR_EQ(test, klist_next(&i), &d);
1462 	KUNIT_EXPECT_NULL(test, klist_next(&i));
1468 static void klist_test_node_attached(struct kunit *test)
1475 	KUNIT_EXPECT_FALSE(test, klist_node_attached(&a));
1477 	KUNIT_EXPECT_TRUE(test, klist_node_attached(&a));
1479 	KUNIT_EXPECT_FALSE(test, klist_node_attached(&a));

Indexes created Tue Jun 18 09:53:56 MDT 2024