lib/list-test.c - linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0
 /*
  * KUnit test for the Kernel Linked-list structures.
  *
  * Copyright (C) 2019, Google LLC.
  * Author: David Gow <davidgow@google.com>
  */
 #include <kunit/test.h>

 #include <linux/list.h>

 struct list_test_struct {
 	int data;
 	struct list_head list;
 };

 static void list_test_list_init(struct kunit *test)
 {
 	/* Test the different ways of initialising a list. */
 	struct list_head list1 = LIST_HEAD_INIT(list1);
 	struct list_head list2;
 	LIST_HEAD(list3);
 	struct list_head *list4;
 	struct list_head *list5;

 	INIT_LIST_HEAD(&list2);

 	list4 = kzalloc(sizeof(*list4), GFP_KERNEL | __GFP_NOFAIL);
 	INIT_LIST_HEAD(list4);

 	list5 = kmalloc(sizeof(*list5), GFP_KERNEL | __GFP_NOFAIL);
 	memset(list5, 0xFF, sizeof(*list5));
 	INIT_LIST_HEAD(list5);

 	/* list_empty_careful() checks both next and prev. */
 	KUNIT_EXPECT_TRUE(test, list_empty_careful(&list1));
 	KUNIT_EXPECT_TRUE(test, list_empty_careful(&list2));
 	KUNIT_EXPECT_TRUE(test, list_empty_careful(&list3));
 	KUNIT_EXPECT_TRUE(test, list_empty_careful(list4));
 	KUNIT_EXPECT_TRUE(test, list_empty_careful(list5));

 	kfree(list4);
 	kfree(list5);
 }

 static void list_test_list_add(struct kunit *test)
 {
 	struct list_head a, b;
 	LIST_HEAD(list);

 	list_add(&a, &list);
 	list_add(&b, &list);

 	/* should be [list] -> b -> a */
 	KUNIT_EXPECT_PTR_EQ(test, list.next, &b);
 	KUNIT_EXPECT_PTR_EQ(test, b.prev, &list);
 	KUNIT_EXPECT_PTR_EQ(test, b.next, &a);
 }

 static void list_test_list_add_tail(struct kunit *test)
 {
 	struct list_head a, b;
 	LIST_HEAD(list);

 	list_add_tail(&a, &list);
 	list_add_tail(&b, &list);

 	/* should be [list] -> a -> b */
 	KUNIT_EXPECT_PTR_EQ(test, list.next, &a);
 	KUNIT_EXPECT_PTR_EQ(test, a.prev, &list);
 	KUNIT_EXPECT_PTR_EQ(test, a.next, &b);
 }

 static void list_test_list_del(struct kunit *test)
 {
 	struct list_head a, b;
 	LIST_HEAD(list);

 	list_add_tail(&a, &list);
 	list_add_tail(&b, &list);

 	/* before: [list] -> a -> b */
 	list_del(&a);

 	/* now: [list] -> b */
 	KUNIT_EXPECT_PTR_EQ(test, list.next, &b);
 	KUNIT_EXPECT_PTR_EQ(test, b.prev, &list);
 }

 static void list_test_list_replace(struct kunit *test)
 {
 	struct list_head a_old, a_new, b;
 	LIST_HEAD(list);

 	list_add_tail(&a_old, &list);
 	list_add_tail(&b, &list);

 	/* before: [list] -> a_old -> b */
 	list_replace(&a_old, &a_new);

 	/* now: [list] -> a_new -> b */
 	KUNIT_EXPECT_PTR_EQ(test, list.next, &a_new);
 	KUNIT_EXPECT_PTR_EQ(test, b.prev, &a_new);
 }

 static void list_test_list_replace_init(struct kunit *test)
 {
 	struct list_head a_old, a_new, b;
 	LIST_HEAD(list);

 	list_add_tail(&a_old, &list);
 	list_add_tail(&b, &list);

 	/* before: [list] -> a_old -> b */
 	list_replace_init(&a_old, &a_new);

 	/* now: [list] -> a_new -> b */
 	KUNIT_EXPECT_PTR_EQ(test, list.next, &a_new);
 	KUNIT_EXPECT_PTR_EQ(test, b.prev, &a_new);

 	/* check a_old is empty (initialized) */
 	KUNIT_EXPECT_TRUE(test, list_empty_careful(&a_old));
 }

 static void list_test_list_swap(struct kunit *test)
 {
 	struct list_head a, b;
 	LIST_HEAD(list);

 	list_add_tail(&a, &list);
 	list_add_tail(&b, &list);

 	/* before: [list] -> a -> b */
 	list_swap(&a, &b);

 	/* after: [list] -> b -> a */
 	KUNIT_EXPECT_PTR_EQ(test, &b, list.next);
 	KUNIT_EXPECT_PTR_EQ(test, &a, list.prev);

 	KUNIT_EXPECT_PTR_EQ(test, &a, b.next);
 	KUNIT_EXPECT_PTR_EQ(test, &list, b.prev);

 	KUNIT_EXPECT_PTR_EQ(test, &list, a.next);
 	KUNIT_EXPECT_PTR_EQ(test, &b, a.prev);
 }

 static void list_test_list_del_init(struct kunit *test)
 {
 	struct list_head a, b;
 	LIST_HEAD(list);

 	list_add_tail(&a, &list);
 	list_add_tail(&b, &list);

 	/* before: [list] -> a -> b */
 	list_del_init(&a);
 	/* after: [list] -> b, a initialised */

 	KUNIT_EXPECT_PTR_EQ(test, list.next, &b);
 	KUNIT_EXPECT_PTR_EQ(test, b.prev, &list);
 	KUNIT_EXPECT_TRUE(test, list_empty_careful(&a));
 }

 static void list_test_list_del_init_careful(struct kunit *test)
 {
 	/* NOTE: This test only checks the behaviour of this function in
 	 * isolation. It does not verify memory model guarantees.
 	 */
 	struct list_head a, b;
 	LIST_HEAD(list);

 	list_add_tail(&a, &list);
 	list_add_tail(&b, &list);

 	/* before: [list] -> a -> b */
 	list_del_init_careful(&a);
 	/* after: [list] -> b, a initialised */

 	KUNIT_EXPECT_PTR_EQ(test, list.next, &b);
 	KUNIT_EXPECT_PTR_EQ(test, b.prev, &list);
 	KUNIT_EXPECT_TRUE(test, list_empty_careful(&a));
 }

 static void list_test_list_move(struct kunit *test)
 {
 	struct list_head a, b;
 	LIST_HEAD(list1);
 	LIST_HEAD(list2);

 	list_add_tail(&a, &list1);
 	list_add_tail(&b, &list2);

 	/* before: [list1] -> a, [list2] -> b */
 	list_move(&a, &list2);
 	/* after: [list1] empty, [list2] -> a -> b */

 	KUNIT_EXPECT_TRUE(test, list_empty(&list1));

 	KUNIT_EXPECT_PTR_EQ(test, &a, list2.next);
 	KUNIT_EXPECT_PTR_EQ(test, &b, a.next);
 }

 static void list_test_list_move_tail(struct kunit *test)
 {
 	struct list_head a, b;
 	LIST_HEAD(list1);
 	LIST_HEAD(list2);

 	list_add_tail(&a, &list1);
 	list_add_tail(&b, &list2);

 	/* before: [list1] -> a, [list2] -> b */
 	list_move_tail(&a, &list2);
 	/* after: [list1] empty, [list2] -> b -> a */

 	KUNIT_EXPECT_TRUE(test, list_empty(&list1));

 	KUNIT_EXPECT_PTR_EQ(test, &b, list2.next);
 	KUNIT_EXPECT_PTR_EQ(test, &a, b.next);
 }

 static void list_test_list_bulk_move_tail(struct kunit *test)
 {
 	struct list_head a, b, c, d, x, y;
 	struct list_head *list1_values[] = { &x, &b, &c, &y };
 	struct list_head *list2_values[] = { &a, &d };
 	struct list_head *ptr;
 	LIST_HEAD(list1);
 	LIST_HEAD(list2);
 	int i = 0;

 	list_add_tail(&x, &list1);
 	list_add_tail(&y, &list1);

 	list_add_tail(&a, &list2);
 	list_add_tail(&b, &list2);
 	list_add_tail(&c, &list2);
 	list_add_tail(&d, &list2);

 	/* before: [list1] -> x -> y, [list2] -> a -> b -> c -> d */
 	list_bulk_move_tail(&y, &b, &c);
 	/* after: [list1] -> x -> b -> c -> y, [list2] -> a -> d */

 	list_for_each(ptr, &list1) {
 		KUNIT_EXPECT_PTR_EQ(test, ptr, list1_values[i]);
 		i++;
 	}
 	KUNIT_EXPECT_EQ(test, i, 4);
 	i = 0;
 	list_for_each(ptr, &list2) {
 		KUNIT_EXPECT_PTR_EQ(test, ptr, list2_values[i]);
 		i++;
 	}
 	KUNIT_EXPECT_EQ(test, i, 2);
 }

 static void list_test_list_is_head(struct kunit *test)
 {
 	struct list_head a, b, c;

 	/* Two lists: [a] -> b, [c] */
 	INIT_LIST_HEAD(&a);
 	INIT_LIST_HEAD(&c);
 	list_add_tail(&b, &a);

 	KUNIT_EXPECT_TRUE_MSG(test, list_is_head(&a, &a),
 		"Head element of same list");
 	KUNIT_EXPECT_FALSE_MSG(test, list_is_head(&a, &b),
 		"Non-head element of same list");
 	KUNIT_EXPECT_FALSE_MSG(test, list_is_head(&a, &c),
 		"Head element of different list");
 }


 static void list_test_list_is_first(struct kunit *test)
 {
 	struct list_head a, b;
 	LIST_HEAD(list);

 	list_add_tail(&a, &list);
 	list_add_tail(&b, &list);

 	KUNIT_EXPECT_TRUE(test, list_is_first(&a, &list));
 	KUNIT_EXPECT_FALSE(test, list_is_first(&b, &list));
 }

 static void list_test_list_is_last(struct kunit *test)
 {
 	struct list_head a, b;
 	LIST_HEAD(list);

 	list_add_tail(&a, &list);
 	list_add_tail(&b, &list);

 	KUNIT_EXPECT_FALSE(test, list_is_last(&a, &list));
 	KUNIT_EXPECT_TRUE(test, list_is_last(&b, &list));
 }

 static void list_test_list_empty(struct kunit *test)
 {
 	struct list_head a;
 	LIST_HEAD(list1);
 	LIST_HEAD(list2);

 	list_add_tail(&a, &list1);

 	KUNIT_EXPECT_FALSE(test, list_empty(&list1));
 	KUNIT_EXPECT_TRUE(test, list_empty(&list2));
 }

 static void list_test_list_empty_careful(struct kunit *test)
 {
 	/* This test doesn't check correctness under concurrent access */
 	struct list_head a;
 	LIST_HEAD(list1);
 	LIST_HEAD(list2);

 	list_add_tail(&a, &list1);

 	KUNIT_EXPECT_FALSE(test, list_empty_careful(&list1));
 	KUNIT_EXPECT_TRUE(test, list_empty_careful(&list2));
 }

 static void list_test_list_rotate_left(struct kunit *test)
 {
 	struct list_head a, b;
 	LIST_HEAD(list);

 	list_add_tail(&a, &list);
 	list_add_tail(&b, &list);

 	/* before: [list] -> a -> b */
 	list_rotate_left(&list);
 	/* after: [list] -> b -> a */

 	KUNIT_EXPECT_PTR_EQ(test, list.next, &b);
 	KUNIT_EXPECT_PTR_EQ(test, b.prev, &list);
 	KUNIT_EXPECT_PTR_EQ(test, b.next, &a);
 }

 static void list_test_list_rotate_to_front(struct kunit *test)
 {
 	struct list_head a, b, c, d;
 	struct list_head *list_values[] = { &c, &d, &a, &b };
 	struct list_head *ptr;
 	LIST_HEAD(list);
 	int i = 0;

 	list_add_tail(&a, &list);
 	list_add_tail(&b, &list);
 	list_add_tail(&c, &list);
 	list_add_tail(&d, &list);

 	/* before: [list] -> a -> b -> c -> d */
 	list_rotate_to_front(&c, &list);
 	/* after: [list] -> c -> d -> a -> b */

 	list_for_each(ptr, &list) {
 		KUNIT_EXPECT_PTR_EQ(test, ptr, list_values[i]);
 		i++;
 	}
 	KUNIT_EXPECT_EQ(test, i, 4);
 }

 static void list_test_list_is_singular(struct kunit *test)
 {
 	struct list_head a, b;
 	LIST_HEAD(list);

 	/* [list] empty */
 	KUNIT_EXPECT_FALSE(test, list_is_singular(&list));

 	list_add_tail(&a, &list);

 	/* [list] -> a */
 	KUNIT_EXPECT_TRUE(test, list_is_singular(&list));

 	list_add_tail(&b, &list);

 	/* [list] -> a -> b */
 	KUNIT_EXPECT_FALSE(test, list_is_singular(&list));
 }

 static void list_test_list_cut_position(struct kunit *test)
 {
 	struct list_head entries[3], *cur;
 	LIST_HEAD(list1);
 	LIST_HEAD(list2);
 	int i = 0;

 	list_add_tail(&entries[0], &list1);
 	list_add_tail(&entries[1], &list1);
 	list_add_tail(&entries[2], &list1);

 	/* before: [list1] -> entries[0] -> entries[1] -> entries[2] */
 	list_cut_position(&list2, &list1, &entries[1]);
 	/* after: [list2] -> entries[0] -> entries[1], [list1] -> entries[2] */

 	list_for_each(cur, &list2) {
 		KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
 		i++;
 	}

 	KUNIT_EXPECT_EQ(test, i, 2);

 	list_for_each(cur, &list1) {
 		KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
 		i++;
 	}
 }

 static void list_test_list_cut_before(struct kunit *test)
 {
 	struct list_head entries[3], *cur;
 	LIST_HEAD(list1);
 	LIST_HEAD(list2);
 	int i = 0;

 	list_add_tail(&entries[0], &list1);
 	list_add_tail(&entries[1], &list1);
 	list_add_tail(&entries[2], &list1);

 	/* before: [list1] -> entries[0] -> entries[1] -> entries[2] */
 	list_cut_before(&list2, &list1, &entries[1]);
 	/* after: [list2] -> entries[0], [list1] -> entries[1] -> entries[2] */

 	list_for_each(cur, &list2) {
 		KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
 		i++;
 	}

 	KUNIT_EXPECT_EQ(test, i, 1);

 	list_for_each(cur, &list1) {
 		KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
 		i++;
 	}
 }

 static void list_test_list_splice(struct kunit *test)
 {
 	struct list_head entries[5], *cur;
 	LIST_HEAD(list1);
 	LIST_HEAD(list2);
 	int i = 0;

 	list_add_tail(&entries[0], &list1);
 	list_add_tail(&entries[1], &list1);
 	list_add_tail(&entries[2], &list2);
 	list_add_tail(&entries[3], &list2);
 	list_add_tail(&entries[4], &list1);

 	/* before: [list1]->e[0]->e[1]->e[4], [list2]->e[2]->e[3] */
 	list_splice(&list2, &entries[1]);
 	/* after: [list1]->e[0]->e[1]->e[2]->e[3]->e[4], [list2] uninit */

 	list_for_each(cur, &list1) {
 		KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
 		i++;
 	}

 	KUNIT_EXPECT_EQ(test, i, 5);
 }

 static void list_test_list_splice_tail(struct kunit *test)
 {
 	struct list_head entries[5], *cur;
 	LIST_HEAD(list1);
 	LIST_HEAD(list2);
 	int i = 0;

 	list_add_tail(&entries[0], &list1);
 	list_add_tail(&entries[1], &list1);
 	list_add_tail(&entries[2], &list2);
 	list_add_tail(&entries[3], &list2);
 	list_add_tail(&entries[4], &list1);

 	/* before: [list1]->e[0]->e[1]->e[4], [list2]->e[2]->e[3] */
 	list_splice_tail(&list2, &entries[4]);
 	/* after: [list1]->e[0]->e[1]->e[2]->e[3]->e[4], [list2] uninit */

 	list_for_each(cur, &list1) {
 		KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
 		i++;
 	}

 	KUNIT_EXPECT_EQ(test, i, 5);
 }

 static void list_test_list_splice_init(struct kunit *test)
 {
 	struct list_head entries[5], *cur;
 	LIST_HEAD(list1);
 	LIST_HEAD(list2);
 	int i = 0;

 	list_add_tail(&entries[0], &list1);
 	list_add_tail(&entries[1], &list1);
 	list_add_tail(&entries[2], &list2);
 	list_add_tail(&entries[3], &list2);
 	list_add_tail(&entries[4], &list1);

 	/* before: [list1]->e[0]->e[1]->e[4], [list2]->e[2]->e[3] */
 	list_splice_init(&list2, &entries[1]);
 	/* after: [list1]->e[0]->e[1]->e[2]->e[3]->e[4], [list2] empty */

 	list_for_each(cur, &list1) {
 		KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
 		i++;
 	}

 	KUNIT_EXPECT_EQ(test, i, 5);

 	KUNIT_EXPECT_TRUE(test, list_empty_careful(&list2));
 }

 static void list_test_list_splice_tail_init(struct kunit *test)
 {
 	struct list_head entries[5], *cur;
 	LIST_HEAD(list1);
 	LIST_HEAD(list2);
 	int i = 0;

 	list_add_tail(&entries[0], &list1);
 	list_add_tail(&entries[1], &list1);
 	list_add_tail(&entries[2], &list2);
 	list_add_tail(&entries[3], &list2);
 	list_add_tail(&entries[4], &list1);

 	/* before: [list1]->e[0]->e[1]->e[4], [list2]->e[2]->e[3] */
 	list_splice_tail_init(&list2, &entries[4]);
 	/* after: [list1]->e[0]->e[1]->e[2]->e[3]->e[4], [list2] empty */

 	list_for_each(cur, &list1) {
 		KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
 		i++;
 	}

 	KUNIT_EXPECT_EQ(test, i, 5);

 	KUNIT_EXPECT_TRUE(test, list_empty_careful(&list2));
 }

 static void list_test_list_entry(struct kunit *test)
 {
 	struct list_test_struct test_struct;

 	KUNIT_EXPECT_PTR_EQ(test, &test_struct, list_entry(&(test_struct.list),
 				struct list_test_struct, list));
 }

 static void list_test_list_entry_is_head(struct kunit *test)
 {
 	struct list_test_struct test_struct1, test_struct2, test_struct3;

 	INIT_LIST_HEAD(&test_struct1.list);
 	INIT_LIST_HEAD(&test_struct3.list);

 	list_add_tail(&test_struct2.list, &test_struct1.list);

 	KUNIT_EXPECT_TRUE_MSG(test,
 		list_entry_is_head((&test_struct1), &test_struct1.list, list),
 		"Head element of same list");
 	KUNIT_EXPECT_FALSE_MSG(test,
 		list_entry_is_head((&test_struct2), &test_struct1.list, list),
 		"Non-head element of same list");
 	KUNIT_EXPECT_FALSE_MSG(test,
 		list_entry_is_head((&test_struct3), &test_struct1.list, list),
 		"Head element of different list");
 }

 static void list_test_list_first_entry(struct kunit *test)
 {
 	struct list_test_struct test_struct1, test_struct2;
 	LIST_HEAD(list);

 	list_add_tail(&test_struct1.list, &list);
 	list_add_tail(&test_struct2.list, &list);


 	KUNIT_EXPECT_PTR_EQ(test, &test_struct1, list_first_entry(&list,
 				struct list_test_struct, list));
 }

 static void list_test_list_last_entry(struct kunit *test)
 {
 	struct list_test_struct test_struct1, test_struct2;
 	LIST_HEAD(list);

 	list_add_tail(&test_struct1.list, &list);
 	list_add_tail(&test_struct2.list, &list);


 	KUNIT_EXPECT_PTR_EQ(test, &test_struct2, list_last_entry(&list,
 				struct list_test_struct, list));
 }

 static void list_test_list_first_entry_or_null(struct kunit *test)
 {
 	struct list_test_struct test_struct1, test_struct2;
 	LIST_HEAD(list);

 	KUNIT_EXPECT_FALSE(test, list_first_entry_or_null(&list,
 				struct list_test_struct, list));

 	list_add_tail(&test_struct1.list, &list);
 	list_add_tail(&test_struct2.list, &list);

 	KUNIT_EXPECT_PTR_EQ(test, &test_struct1,
 			list_first_entry_or_null(&list,
 				struct list_test_struct, list));
 }

 static void list_test_list_next_entry(struct kunit *test)
 {
 	struct list_test_struct test_struct1, test_struct2;
 	LIST_HEAD(list);

 	list_add_tail(&test_struct1.list, &list);
 	list_add_tail(&test_struct2.list, &list);


 	KUNIT_EXPECT_PTR_EQ(test, &test_struct2, list_next_entry(&test_struct1,
 				list));
 }

 static void list_test_list_prev_entry(struct kunit *test)
 {
 	struct list_test_struct test_struct1, test_struct2;
 	LIST_HEAD(list);

 	list_add_tail(&test_struct1.list, &list);
 	list_add_tail(&test_struct2.list, &list);


 	KUNIT_EXPECT_PTR_EQ(test, &test_struct1, list_prev_entry(&test_struct2,
 				list));
 }

 static void list_test_list_for_each(struct kunit *test)
 {
 	struct list_head entries[3], *cur;
 	LIST_HEAD(list);
 	int i = 0;

 	list_add_tail(&entries[0], &list);
 	list_add_tail(&entries[1], &list);
 	list_add_tail(&entries[2], &list);

 	list_for_each(cur, &list) {
 		KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
 		i++;
 	}

 	KUNIT_EXPECT_EQ(test, i, 3);
 }

 static void list_test_list_for_each_prev(struct kunit *test)
 {
 	struct list_head entries[3], *cur;
 	LIST_HEAD(list);
 	int i = 2;

 	list_add_tail(&entries[0], &list);
 	list_add_tail(&entries[1], &list);
 	list_add_tail(&entries[2], &list);

 	list_for_each_prev(cur, &list) {
 		KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
 		i--;
 	}

 	KUNIT_EXPECT_EQ(test, i, -1);
 }

 static void list_test_list_for_each_safe(struct kunit *test)
 {
 	struct list_head entries[3], *cur, *n;
 	LIST_HEAD(list);
 	int i = 0;


 	list_add_tail(&entries[0], &list);
 	list_add_tail(&entries[1], &list);
 	list_add_tail(&entries[2], &list);

 	list_for_each_safe(cur, n, &list) {
 		KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
 		list_del(&entries[i]);
 		i++;
 	}

 	KUNIT_EXPECT_EQ(test, i, 3);
 	KUNIT_EXPECT_TRUE(test, list_empty(&list));
 }

 static void list_test_list_for_each_prev_safe(struct kunit *test)
 {
 	struct list_head entries[3], *cur, *n;
 	LIST_HEAD(list);
 	int i = 2;

 	list_add_tail(&entries[0], &list);
 	list_add_tail(&entries[1], &list);
 	list_add_tail(&entries[2], &list);

 	list_for_each_prev_safe(cur, n, &list) {
 		KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
 		list_del(&entries[i]);
 		i--;
 	}

 	KUNIT_EXPECT_EQ(test, i, -1);
 	KUNIT_EXPECT_TRUE(test, list_empty(&list));
 }

 static void list_test_list_for_each_entry(struct kunit *test)
 {
 	struct list_test_struct entries[5], *cur;
 	LIST_HEAD(list);
 	int i = 0;

 	for (i = 0; i < 5; ++i) {
 		entries[i].data = i;
 		list_add_tail(&entries[i].list, &list);
 	}

 	i = 0;

 	list_for_each_entry(cur, &list, list) {
 		KUNIT_EXPECT_EQ(test, cur->data, i);
 		i++;
 	}

 	KUNIT_EXPECT_EQ(test, i, 5);
 }

 static void list_test_list_for_each_entry_reverse(struct kunit *test)
 {
 	struct list_test_struct entries[5], *cur;
 	LIST_HEAD(list);
 	int i = 0;

 	for (i = 0; i < 5; ++i) {
 		entries[i].data = i;
 		list_add_tail(&entries[i].list, &list);
 	}

 	i = 4;

 	list_for_each_entry_reverse(cur, &list, list) {
 		KUNIT_EXPECT_EQ(test, cur->data, i);
 		i--;
 	}

 	KUNIT_EXPECT_EQ(test, i, -1);
 }

 static struct kunit_case list_test_cases[] = {
 	KUNIT_CASE(list_test_list_init),
 	KUNIT_CASE(list_test_list_add),
 	KUNIT_CASE(list_test_list_add_tail),
 	KUNIT_CASE(list_test_list_del),
 	KUNIT_CASE(list_test_list_replace),
 	KUNIT_CASE(list_test_list_replace_init),
 	KUNIT_CASE(list_test_list_swap),
 	KUNIT_CASE(list_test_list_del_init),
 	KUNIT_CASE(list_test_list_del_init_careful),
 	KUNIT_CASE(list_test_list_move),
 	KUNIT_CASE(list_test_list_move_tail),
 	KUNIT_CASE(list_test_list_bulk_move_tail),
 	KUNIT_CASE(list_test_list_is_head),
 	KUNIT_CASE(list_test_list_is_first),
 	KUNIT_CASE(list_test_list_is_last),
 	KUNIT_CASE(list_test_list_empty),
 	KUNIT_CASE(list_test_list_empty_careful),
 	KUNIT_CASE(list_test_list_rotate_left),
 	KUNIT_CASE(list_test_list_rotate_to_front),
 	KUNIT_CASE(list_test_list_is_singular),
 	KUNIT_CASE(list_test_list_cut_position),
 	KUNIT_CASE(list_test_list_cut_before),
 	KUNIT_CASE(list_test_list_splice),
 	KUNIT_CASE(list_test_list_splice_tail),
 	KUNIT_CASE(list_test_list_splice_init),
 	KUNIT_CASE(list_test_list_splice_tail_init),
 	KUNIT_CASE(list_test_list_entry),
 	KUNIT_CASE(list_test_list_entry_is_head),
 	KUNIT_CASE(list_test_list_first_entry),
 	KUNIT_CASE(list_test_list_last_entry),
 	KUNIT_CASE(list_test_list_first_entry_or_null),
 	KUNIT_CASE(list_test_list_next_entry),
 	KUNIT_CASE(list_test_list_prev_entry),
 	KUNIT_CASE(list_test_list_for_each),
 	KUNIT_CASE(list_test_list_for_each_prev),
 	KUNIT_CASE(list_test_list_for_each_safe),
 	KUNIT_CASE(list_test_list_for_each_prev_safe),
 	KUNIT_CASE(list_test_list_for_each_entry),
 	KUNIT_CASE(list_test_list_for_each_entry_reverse),
 	{},
 };

 static struct kunit_suite list_test_module = {
 	.name = "list-kunit-test",
 	.test_cases = list_test_cases,
 };

 kunit_test_suites(&list_test_module);

 MODULE_LICENSE("GPL v2");
	// SPDX-License-Identifier: GPL-2.0
	/*
	* KUnit test for the Kernel Linked-list structures.
	*
	* Copyright (C) 2019, Google LLC.
	* Author: David Gow <davidgow@google.com>
	*/
	#include <kunit/test.h>

	#include <linux/list.h>

	struct list_test_struct {
	int data;
	struct list_head list;
	};

	static void list_test_list_init(struct kunit *test)
	{
	/* Test the different ways of initialising a list. */
	struct list_head list1 = LIST_HEAD_INIT(list1);
	struct list_head list2;
	LIST_HEAD(list3);
	struct list_head *list4;
	struct list_head *list5;

	INIT_LIST_HEAD(&list2);

	list4 = kzalloc(sizeof(*list4), GFP_KERNEL \| __GFP_NOFAIL);
	INIT_LIST_HEAD(list4);

	list5 = kmalloc(sizeof(*list5), GFP_KERNEL \| __GFP_NOFAIL);
	memset(list5, 0xFF, sizeof(*list5));
	INIT_LIST_HEAD(list5);

	/* list_empty_careful() checks both next and prev. */
	KUNIT_EXPECT_TRUE(test, list_empty_careful(&list1));
	KUNIT_EXPECT_TRUE(test, list_empty_careful(&list2));
	KUNIT_EXPECT_TRUE(test, list_empty_careful(&list3));
	KUNIT_EXPECT_TRUE(test, list_empty_careful(list4));
	KUNIT_EXPECT_TRUE(test, list_empty_careful(list5));

	kfree(list4);
	kfree(list5);
	}

	static void list_test_list_add(struct kunit *test)
	{
	struct list_head a, b;
	LIST_HEAD(list);

	list_add(&a, &list);
	list_add(&b, &list);

	/* should be [list] -> b -> a */
	KUNIT_EXPECT_PTR_EQ(test, list.next, &b);
	KUNIT_EXPECT_PTR_EQ(test, b.prev, &list);
	KUNIT_EXPECT_PTR_EQ(test, b.next, &a);
	}

	static void list_test_list_add_tail(struct kunit *test)
	{
	struct list_head a, b;
	LIST_HEAD(list);

	list_add_tail(&a, &list);
	list_add_tail(&b, &list);

	/* should be [list] -> a -> b */
	KUNIT_EXPECT_PTR_EQ(test, list.next, &a);
	KUNIT_EXPECT_PTR_EQ(test, a.prev, &list);
	KUNIT_EXPECT_PTR_EQ(test, a.next, &b);
	}

	static void list_test_list_del(struct kunit *test)
	{
	struct list_head a, b;
	LIST_HEAD(list);

	list_add_tail(&a, &list);
	list_add_tail(&b, &list);

	/* before: [list] -> a -> b */
	list_del(&a);

	/* now: [list] -> b */
	KUNIT_EXPECT_PTR_EQ(test, list.next, &b);
	KUNIT_EXPECT_PTR_EQ(test, b.prev, &list);
	}

	static void list_test_list_replace(struct kunit *test)
	{
	struct list_head a_old, a_new, b;
	LIST_HEAD(list);

	list_add_tail(&a_old, &list);
	list_add_tail(&b, &list);

	/* before: [list] -> a_old -> b */
	list_replace(&a_old, &a_new);

	/* now: [list] -> a_new -> b */
	KUNIT_EXPECT_PTR_EQ(test, list.next, &a_new);
	KUNIT_EXPECT_PTR_EQ(test, b.prev, &a_new);
	}

	static void list_test_list_replace_init(struct kunit *test)
	{
	struct list_head a_old, a_new, b;
	LIST_HEAD(list);

	list_add_tail(&a_old, &list);
	list_add_tail(&b, &list);

	/* before: [list] -> a_old -> b */
	list_replace_init(&a_old, &a_new);

	/* now: [list] -> a_new -> b */
	KUNIT_EXPECT_PTR_EQ(test, list.next, &a_new);
	KUNIT_EXPECT_PTR_EQ(test, b.prev, &a_new);

	/* check a_old is empty (initialized) */
	KUNIT_EXPECT_TRUE(test, list_empty_careful(&a_old));
	}

	static void list_test_list_swap(struct kunit *test)
	{
	struct list_head a, b;
	LIST_HEAD(list);

	list_add_tail(&a, &list);
	list_add_tail(&b, &list);

	/* before: [list] -> a -> b */
	list_swap(&a, &b);

	/* after: [list] -> b -> a */
	KUNIT_EXPECT_PTR_EQ(test, &b, list.next);
	KUNIT_EXPECT_PTR_EQ(test, &a, list.prev);

	KUNIT_EXPECT_PTR_EQ(test, &a, b.next);
	KUNIT_EXPECT_PTR_EQ(test, &list, b.prev);

	KUNIT_EXPECT_PTR_EQ(test, &list, a.next);
	KUNIT_EXPECT_PTR_EQ(test, &b, a.prev);
	}

	static void list_test_list_del_init(struct kunit *test)
	{
	struct list_head a, b;
	LIST_HEAD(list);

	list_add_tail(&a, &list);
	list_add_tail(&b, &list);

	/* before: [list] -> a -> b */
	list_del_init(&a);
	/* after: [list] -> b, a initialised */

	KUNIT_EXPECT_PTR_EQ(test, list.next, &b);
	KUNIT_EXPECT_PTR_EQ(test, b.prev, &list);
	KUNIT_EXPECT_TRUE(test, list_empty_careful(&a));
	}

	static void list_test_list_del_init_careful(struct kunit *test)
	{
	/* NOTE: This test only checks the behaviour of this function in
	* isolation. It does not verify memory model guarantees.
	*/
	struct list_head a, b;
	LIST_HEAD(list);

	list_add_tail(&a, &list);
	list_add_tail(&b, &list);

	/* before: [list] -> a -> b */
	list_del_init_careful(&a);
	/* after: [list] -> b, a initialised */

	KUNIT_EXPECT_PTR_EQ(test, list.next, &b);
	KUNIT_EXPECT_PTR_EQ(test, b.prev, &list);
	KUNIT_EXPECT_TRUE(test, list_empty_careful(&a));
	}

	static void list_test_list_move(struct kunit *test)
	{
	struct list_head a, b;
	LIST_HEAD(list1);
	LIST_HEAD(list2);

	list_add_tail(&a, &list1);
	list_add_tail(&b, &list2);

	/* before: [list1] -> a, [list2] -> b */
	list_move(&a, &list2);
	/* after: [list1] empty, [list2] -> a -> b */

	KUNIT_EXPECT_TRUE(test, list_empty(&list1));

	KUNIT_EXPECT_PTR_EQ(test, &a, list2.next);
	KUNIT_EXPECT_PTR_EQ(test, &b, a.next);
	}

	static void list_test_list_move_tail(struct kunit *test)
	{
	struct list_head a, b;
	LIST_HEAD(list1);
	LIST_HEAD(list2);

	list_add_tail(&a, &list1);
	list_add_tail(&b, &list2);

	/* before: [list1] -> a, [list2] -> b */
	list_move_tail(&a, &list2);
	/* after: [list1] empty, [list2] -> b -> a */

	KUNIT_EXPECT_TRUE(test, list_empty(&list1));

	KUNIT_EXPECT_PTR_EQ(test, &b, list2.next);
	KUNIT_EXPECT_PTR_EQ(test, &a, b.next);
	}

	static void list_test_list_bulk_move_tail(struct kunit *test)
	{
	struct list_head a, b, c, d, x, y;
	struct list_head *list1_values[] = { &x, &b, &c, &y };
	struct list_head *list2_values[] = { &a, &d };
	struct list_head *ptr;
	LIST_HEAD(list1);
	LIST_HEAD(list2);
	int i = 0;

	list_add_tail(&x, &list1);
	list_add_tail(&y, &list1);

	list_add_tail(&a, &list2);
	list_add_tail(&b, &list2);
	list_add_tail(&c, &list2);
	list_add_tail(&d, &list2);

	/* before: [list1] -> x -> y, [list2] -> a -> b -> c -> d */
	list_bulk_move_tail(&y, &b, &c);
	/* after: [list1] -> x -> b -> c -> y, [list2] -> a -> d */

	list_for_each(ptr, &list1) {
	KUNIT_EXPECT_PTR_EQ(test, ptr, list1_values[i]);
	i++;
	}
	KUNIT_EXPECT_EQ(test, i, 4);
	i = 0;
	list_for_each(ptr, &list2) {
	KUNIT_EXPECT_PTR_EQ(test, ptr, list2_values[i]);
	i++;
	}
	KUNIT_EXPECT_EQ(test, i, 2);
	}

	static void list_test_list_is_head(struct kunit *test)
	{
	struct list_head a, b, c;

	/* Two lists: [a] -> b, [c] */
	INIT_LIST_HEAD(&a);
	INIT_LIST_HEAD(&c);
	list_add_tail(&b, &a);

	KUNIT_EXPECT_TRUE_MSG(test, list_is_head(&a, &a),
	"Head element of same list");
	KUNIT_EXPECT_FALSE_MSG(test, list_is_head(&a, &b),
	"Non-head element of same list");
	KUNIT_EXPECT_FALSE_MSG(test, list_is_head(&a, &c),
	"Head element of different list");
	}


	static void list_test_list_is_first(struct kunit *test)
	{
	struct list_head a, b;
	LIST_HEAD(list);

	list_add_tail(&a, &list);
	list_add_tail(&b, &list);

	KUNIT_EXPECT_TRUE(test, list_is_first(&a, &list));
	KUNIT_EXPECT_FALSE(test, list_is_first(&b, &list));
	}

	static void list_test_list_is_last(struct kunit *test)
	{
	struct list_head a, b;
	LIST_HEAD(list);

	list_add_tail(&a, &list);
	list_add_tail(&b, &list);

	KUNIT_EXPECT_FALSE(test, list_is_last(&a, &list));
	KUNIT_EXPECT_TRUE(test, list_is_last(&b, &list));
	}

	static void list_test_list_empty(struct kunit *test)
	{
	struct list_head a;
	LIST_HEAD(list1);
	LIST_HEAD(list2);

	list_add_tail(&a, &list1);

	KUNIT_EXPECT_FALSE(test, list_empty(&list1));
	KUNIT_EXPECT_TRUE(test, list_empty(&list2));
	}

	static void list_test_list_empty_careful(struct kunit *test)
	{
	/* This test doesn't check correctness under concurrent access */
	struct list_head a;
	LIST_HEAD(list1);
	LIST_HEAD(list2);

	list_add_tail(&a, &list1);

	KUNIT_EXPECT_FALSE(test, list_empty_careful(&list1));
	KUNIT_EXPECT_TRUE(test, list_empty_careful(&list2));
	}

	static void list_test_list_rotate_left(struct kunit *test)
	{
	struct list_head a, b;
	LIST_HEAD(list);

	list_add_tail(&a, &list);
	list_add_tail(&b, &list);

	/* before: [list] -> a -> b */
	list_rotate_left(&list);
	/* after: [list] -> b -> a */

	KUNIT_EXPECT_PTR_EQ(test, list.next, &b);
	KUNIT_EXPECT_PTR_EQ(test, b.prev, &list);
	KUNIT_EXPECT_PTR_EQ(test, b.next, &a);
	}

	static void list_test_list_rotate_to_front(struct kunit *test)
	{
	struct list_head a, b, c, d;
	struct list_head *list_values[] = { &c, &d, &a, &b };
	struct list_head *ptr;
	LIST_HEAD(list);
	int i = 0;

	list_add_tail(&a, &list);
	list_add_tail(&b, &list);
	list_add_tail(&c, &list);
	list_add_tail(&d, &list);

	/* before: [list] -> a -> b -> c -> d */
	list_rotate_to_front(&c, &list);
	/* after: [list] -> c -> d -> a -> b */

	list_for_each(ptr, &list) {
	KUNIT_EXPECT_PTR_EQ(test, ptr, list_values[i]);
	i++;
	}
	KUNIT_EXPECT_EQ(test, i, 4);
	}

	static void list_test_list_is_singular(struct kunit *test)
	{
	struct list_head a, b;
	LIST_HEAD(list);

	/* [list] empty */
	KUNIT_EXPECT_FALSE(test, list_is_singular(&list));

	list_add_tail(&a, &list);

	/* [list] -> a */
	KUNIT_EXPECT_TRUE(test, list_is_singular(&list));

	list_add_tail(&b, &list);

	/* [list] -> a -> b */
	KUNIT_EXPECT_FALSE(test, list_is_singular(&list));
	}

	static void list_test_list_cut_position(struct kunit *test)
	{
	struct list_head entries[3], *cur;
	LIST_HEAD(list1);
	LIST_HEAD(list2);
	int i = 0;

	list_add_tail(&entries[0], &list1);
	list_add_tail(&entries[1], &list1);
	list_add_tail(&entries[2], &list1);

	/* before: [list1] -> entries[0] -> entries[1] -> entries[2] */
	list_cut_position(&list2, &list1, &entries[1]);
	/* after: [list2] -> entries[0] -> entries[1], [list1] -> entries[2] */

	list_for_each(cur, &list2) {
	KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
	i++;
	}

	KUNIT_EXPECT_EQ(test, i, 2);

	list_for_each(cur, &list1) {
	KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
	i++;
	}
	}

	static void list_test_list_cut_before(struct kunit *test)
	{
	struct list_head entries[3], *cur;
	LIST_HEAD(list1);
	LIST_HEAD(list2);
	int i = 0;

	list_add_tail(&entries[0], &list1);
	list_add_tail(&entries[1], &list1);
	list_add_tail(&entries[2], &list1);

	/* before: [list1] -> entries[0] -> entries[1] -> entries[2] */
	list_cut_before(&list2, &list1, &entries[1]);
	/* after: [list2] -> entries[0], [list1] -> entries[1] -> entries[2] */

	list_for_each(cur, &list2) {
	KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
	i++;
	}

	KUNIT_EXPECT_EQ(test, i, 1);

	list_for_each(cur, &list1) {
	KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
	i++;
	}
	}

	static void list_test_list_splice(struct kunit *test)
	{
	struct list_head entries[5], *cur;
	LIST_HEAD(list1);
	LIST_HEAD(list2);
	int i = 0;

	list_add_tail(&entries[0], &list1);
	list_add_tail(&entries[1], &list1);
	list_add_tail(&entries[2], &list2);
	list_add_tail(&entries[3], &list2);
	list_add_tail(&entries[4], &list1);

	/* before: [list1]->e[0]->e[1]->e[4], [list2]->e[2]->e[3] */
	list_splice(&list2, &entries[1]);
	/* after: [list1]->e[0]->e[1]->e[2]->e[3]->e[4], [list2] uninit */

	list_for_each(cur, &list1) {
	KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
	i++;
	}

	KUNIT_EXPECT_EQ(test, i, 5);
	}

	static void list_test_list_splice_tail(struct kunit *test)
	{
	struct list_head entries[5], *cur;
	LIST_HEAD(list1);
	LIST_HEAD(list2);
	int i = 0;

	list_add_tail(&entries[0], &list1);
	list_add_tail(&entries[1], &list1);
	list_add_tail(&entries[2], &list2);
	list_add_tail(&entries[3], &list2);
	list_add_tail(&entries[4], &list1);

	/* before: [list1]->e[0]->e[1]->e[4], [list2]->e[2]->e[3] */
	list_splice_tail(&list2, &entries[4]);
	/* after: [list1]->e[0]->e[1]->e[2]->e[3]->e[4], [list2] uninit */

	list_for_each(cur, &list1) {
	KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
	i++;
	}

	KUNIT_EXPECT_EQ(test, i, 5);
	}

	static void list_test_list_splice_init(struct kunit *test)
	{
	struct list_head entries[5], *cur;
	LIST_HEAD(list1);
	LIST_HEAD(list2);
	int i = 0;

	list_add_tail(&entries[0], &list1);
	list_add_tail(&entries[1], &list1);
	list_add_tail(&entries[2], &list2);
	list_add_tail(&entries[3], &list2);
	list_add_tail(&entries[4], &list1);

	/* before: [list1]->e[0]->e[1]->e[4], [list2]->e[2]->e[3] */
	list_splice_init(&list2, &entries[1]);
	/* after: [list1]->e[0]->e[1]->e[2]->e[3]->e[4], [list2] empty */

	list_for_each(cur, &list1) {
	KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
	i++;
	}

	KUNIT_EXPECT_EQ(test, i, 5);

	KUNIT_EXPECT_TRUE(test, list_empty_careful(&list2));
	}

	static void list_test_list_splice_tail_init(struct kunit *test)
	{
	struct list_head entries[5], *cur;
	LIST_HEAD(list1);
	LIST_HEAD(list2);
	int i = 0;

	list_add_tail(&entries[0], &list1);
	list_add_tail(&entries[1], &list1);
	list_add_tail(&entries[2], &list2);
	list_add_tail(&entries[3], &list2);
	list_add_tail(&entries[4], &list1);

	/* before: [list1]->e[0]->e[1]->e[4], [list2]->e[2]->e[3] */
	list_splice_tail_init(&list2, &entries[4]);
	/* after: [list1]->e[0]->e[1]->e[2]->e[3]->e[4], [list2] empty */

	list_for_each(cur, &list1) {
	KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
	i++;
	}

	KUNIT_EXPECT_EQ(test, i, 5);

	KUNIT_EXPECT_TRUE(test, list_empty_careful(&list2));
	}

	static void list_test_list_entry(struct kunit *test)
	{
	struct list_test_struct test_struct;

	KUNIT_EXPECT_PTR_EQ(test, &test_struct, list_entry(&(test_struct.list),
	struct list_test_struct, list));
	}

	static void list_test_list_entry_is_head(struct kunit *test)
	{
	struct list_test_struct test_struct1, test_struct2, test_struct3;

	INIT_LIST_HEAD(&test_struct1.list);
	INIT_LIST_HEAD(&test_struct3.list);

	list_add_tail(&test_struct2.list, &test_struct1.list);

	KUNIT_EXPECT_TRUE_MSG(test,
	list_entry_is_head((&test_struct1), &test_struct1.list, list),
	"Head element of same list");
	KUNIT_EXPECT_FALSE_MSG(test,
	list_entry_is_head((&test_struct2), &test_struct1.list, list),
	"Non-head element of same list");
	KUNIT_EXPECT_FALSE_MSG(test,
	list_entry_is_head((&test_struct3), &test_struct1.list, list),
	"Head element of different list");
	}

	static void list_test_list_first_entry(struct kunit *test)
	{
	struct list_test_struct test_struct1, test_struct2;
	LIST_HEAD(list);

	list_add_tail(&test_struct1.list, &list);
	list_add_tail(&test_struct2.list, &list);


	KUNIT_EXPECT_PTR_EQ(test, &test_struct1, list_first_entry(&list,
	struct list_test_struct, list));
	}

	static void list_test_list_last_entry(struct kunit *test)
	{
	struct list_test_struct test_struct1, test_struct2;
	LIST_HEAD(list);

	list_add_tail(&test_struct1.list, &list);
	list_add_tail(&test_struct2.list, &list);


	KUNIT_EXPECT_PTR_EQ(test, &test_struct2, list_last_entry(&list,
	struct list_test_struct, list));
	}

	static void list_test_list_first_entry_or_null(struct kunit *test)
	{
	struct list_test_struct test_struct1, test_struct2;
	LIST_HEAD(list);

	KUNIT_EXPECT_FALSE(test, list_first_entry_or_null(&list,
	struct list_test_struct, list));

	list_add_tail(&test_struct1.list, &list);
	list_add_tail(&test_struct2.list, &list);

	KUNIT_EXPECT_PTR_EQ(test, &test_struct1,
	list_first_entry_or_null(&list,
	struct list_test_struct, list));
	}

	static void list_test_list_next_entry(struct kunit *test)
	{
	struct list_test_struct test_struct1, test_struct2;
	LIST_HEAD(list);

	list_add_tail(&test_struct1.list, &list);
	list_add_tail(&test_struct2.list, &list);


	KUNIT_EXPECT_PTR_EQ(test, &test_struct2, list_next_entry(&test_struct1,
	list));
	}

	static void list_test_list_prev_entry(struct kunit *test)
	{
	struct list_test_struct test_struct1, test_struct2;
	LIST_HEAD(list);

	list_add_tail(&test_struct1.list, &list);
	list_add_tail(&test_struct2.list, &list);


	KUNIT_EXPECT_PTR_EQ(test, &test_struct1, list_prev_entry(&test_struct2,
	list));
	}

	static void list_test_list_for_each(struct kunit *test)
	{
	struct list_head entries[3], *cur;
	LIST_HEAD(list);
	int i = 0;

	list_add_tail(&entries[0], &list);
	list_add_tail(&entries[1], &list);
	list_add_tail(&entries[2], &list);

	list_for_each(cur, &list) {
	KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
	i++;
	}

	KUNIT_EXPECT_EQ(test, i, 3);
	}

	static void list_test_list_for_each_prev(struct kunit *test)
	{
	struct list_head entries[3], *cur;
	LIST_HEAD(list);
	int i = 2;

	list_add_tail(&entries[0], &list);
	list_add_tail(&entries[1], &list);
	list_add_tail(&entries[2], &list);

	list_for_each_prev(cur, &list) {
	KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
	i--;
	}

	KUNIT_EXPECT_EQ(test, i, -1);
	}

	static void list_test_list_for_each_safe(struct kunit *test)
	{
	struct list_head entries[3], cur, n;
	LIST_HEAD(list);
	int i = 0;


	list_add_tail(&entries[0], &list);
	list_add_tail(&entries[1], &list);
	list_add_tail(&entries[2], &list);

	list_for_each_safe(cur, n, &list) {
	KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
	list_del(&entries[i]);
	i++;
	}

	KUNIT_EXPECT_EQ(test, i, 3);
	KUNIT_EXPECT_TRUE(test, list_empty(&list));
	}

	static void list_test_list_for_each_prev_safe(struct kunit *test)
	{
	struct list_head entries[3], cur, n;
	LIST_HEAD(list);
	int i = 2;

	list_add_tail(&entries[0], &list);
	list_add_tail(&entries[1], &list);
	list_add_tail(&entries[2], &list);

	list_for_each_prev_safe(cur, n, &list) {
	KUNIT_EXPECT_PTR_EQ(test, cur, &entries[i]);
	list_del(&entries[i]);
	i--;
	}

	KUNIT_EXPECT_EQ(test, i, -1);
	KUNIT_EXPECT_TRUE(test, list_empty(&list));
	}

	static void list_test_list_for_each_entry(struct kunit *test)
	{
	struct list_test_struct entries[5], *cur;
	LIST_HEAD(list);
	int i = 0;

	for (i = 0; i < 5; ++i) {
	entries[i].data = i;
	list_add_tail(&entries[i].list, &list);
	}

	i = 0;

	list_for_each_entry(cur, &list, list) {
	KUNIT_EXPECT_EQ(test, cur->data, i);
	i++;
	}

	KUNIT_EXPECT_EQ(test, i, 5);
	}

	static void list_test_list_for_each_entry_reverse(struct kunit *test)
	{
	struct list_test_struct entries[5], *cur;
	LIST_HEAD(list);
	int i = 0;

	for (i = 0; i < 5; ++i) {
	entries[i].data = i;
	list_add_tail(&entries[i].list, &list);
	}

	i = 4;

	list_for_each_entry_reverse(cur, &list, list) {
	KUNIT_EXPECT_EQ(test, cur->data, i);
	i--;
	}

	KUNIT_EXPECT_EQ(test, i, -1);
	}

	static struct kunit_case list_test_cases[] = {
	KUNIT_CASE(list_test_list_init),
	KUNIT_CASE(list_test_list_add),
	KUNIT_CASE(list_test_list_add_tail),
	KUNIT_CASE(list_test_list_del),
	KUNIT_CASE(list_test_list_replace),
	KUNIT_CASE(list_test_list_replace_init),
	KUNIT_CASE(list_test_list_swap),
	KUNIT_CASE(list_test_list_del_init),
	KUNIT_CASE(list_test_list_del_init_careful),
	KUNIT_CASE(list_test_list_move),
	KUNIT_CASE(list_test_list_move_tail),
	KUNIT_CASE(list_test_list_bulk_move_tail),
	KUNIT_CASE(list_test_list_is_head),
	KUNIT_CASE(list_test_list_is_first),
	KUNIT_CASE(list_test_list_is_last),
	KUNIT_CASE(list_test_list_empty),
	KUNIT_CASE(list_test_list_empty_careful),
	KUNIT_CASE(list_test_list_rotate_left),
	KUNIT_CASE(list_test_list_rotate_to_front),
	KUNIT_CASE(list_test_list_is_singular),
	KUNIT_CASE(list_test_list_cut_position),
	KUNIT_CASE(list_test_list_cut_before),
	KUNIT_CASE(list_test_list_splice),
	KUNIT_CASE(list_test_list_splice_tail),
	KUNIT_CASE(list_test_list_splice_init),
	KUNIT_CASE(list_test_list_splice_tail_init),
	KUNIT_CASE(list_test_list_entry),
	KUNIT_CASE(list_test_list_entry_is_head),
	KUNIT_CASE(list_test_list_first_entry),
	KUNIT_CASE(list_test_list_last_entry),
	KUNIT_CASE(list_test_list_first_entry_or_null),
	KUNIT_CASE(list_test_list_next_entry),
	KUNIT_CASE(list_test_list_prev_entry),
	KUNIT_CASE(list_test_list_for_each),
	KUNIT_CASE(list_test_list_for_each_prev),
	KUNIT_CASE(list_test_list_for_each_safe),
	KUNIT_CASE(list_test_list_for_each_prev_safe),
	KUNIT_CASE(list_test_list_for_each_entry),
	KUNIT_CASE(list_test_list_for_each_entry_reverse),
	{},
	};

	static struct kunit_suite list_test_module = {
	.name = "list-kunit-test",
	.test_cases = list_test_cases,
	};

	kunit_test_suites(&list_test_module);

	MODULE_LICENSE("GPL v2");