[linux.git] / lib / list-test.c

// SPDX-License-Identifier: GPL-2.0
/*
 * KUnit test for the Kernel Linked-list structures.
 *
 * Copyright (C) 2019, Google LLC.
 * Author: David Gow <[email protected]>
 */
#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_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_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_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_move),
	KUNIT_CASE(list_test_list_move_tail),
	KUNIT_CASE(list_test_list_bulk_move_tail),
	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_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");
Commit	Line	Data
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 <[email protected]>
	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;
cb88577b	662	LIST_HEAD(list);
ea2dd7c0 DG	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;
cb88577b	683	LIST_HEAD(list);
ea2dd7c0 DG	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
c475c77d AM	746	kunit_test_suites(&list_test_module);
	747
	748	MODULE_LICENSE("GPL v2");