The patch titled
Subject: lib/bits_kunit: follow new file name convention for KUnit tests
has been added to the -mm tree. Its filename is
lib-bits_kunit-follow-new-file-name-convention-for-kunit-tests.patch
This patch should soon appear at
https://ozlabs.org/~akpm/mmots/broken-out/lib-bits_kunit-follow-new-file-name-convention-for-kunit-tests.patch
and later at
https://ozlabs.org/~akpm/mmotm/broken-out/lib-bits_kunit-follow-new-file-name-convention-for-kunit-tests.patch
Before you just go and hit "reply", please:
a) Consider who else should be cc'ed
b) Prefer to cc a suitable mailing list as well
c) Ideally: find the original patch on the mailing list and do a
reply-to-all to that, adding suitable additional cc's
*** Remember to use Documentation/process/submit-checklist.rst when testing your code ***
The -mm tree is included into linux-next and is updated
there every 3-4 working days
------------------------------------------------------
From: Andy Shevchenko <andriy.shevchenko@xxxxxxxxxxxxxxx>
Subject: lib/bits_kunit: follow new file name convention for KUnit tests
Follow new file name convention for the KUnit tests. Since we have
lib/*test*.c in a few variations, use 'kunit' suffix to distinguish usual
test cases with KUnit-based ones.
Link: https://lkml.kernel.org/r/20201112180732.75589-3-andriy.shevchenko@xxxxxxxxxxxxxxx
Signed-off-by: Andy Shevchenko <andriy.shevchenko@xxxxxxxxxxxxxxx>
Reviewed-by: David Gow <davidgow@xxxxxxxxxx>
Acked-by: Brendan Higgins <brendanhiggins@xxxxxxxxxx>
Cc: Mark Brown <broonie@xxxxxxxxxx>
Cc: Matti Vaittinen <matti.vaittinen@xxxxxxxxxxxxxxxxx>
Cc: Shuah Khan <skhan@xxxxxxxxxxxxxxxxxxx>
Cc: Vitor Massaru Iha <vitor@xxxxxxxxxxx>
Signed-off-by: Andrew Morton <akpm@xxxxxxxxxxxxxxxxxxxx>
---
lib/Makefile | 2
lib/bits_kunit.c | 75 ++++
lib/list-test.c | 748 ---------------------------------------------
lib/list_kunit.c | 748 +++++++++++++++++++++++++++++++++++++++++++++
lib/test_bits.c | 75 ----
5 files changed, 824 insertions(+), 824 deletions(-)
--- /dev/null
+++ a/lib/bits_kunit.c
@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Test cases for functions and macros in bits.h
+ */
+
+#include <kunit/test.h>
+#include <linux/bits.h>
+
+
+static void genmask_test(struct kunit *test)
+{
+ KUNIT_EXPECT_EQ(test, 1ul, GENMASK(0, 0));
+ KUNIT_EXPECT_EQ(test, 3ul, GENMASK(1, 0));
+ KUNIT_EXPECT_EQ(test, 6ul, GENMASK(2, 1));
+ KUNIT_EXPECT_EQ(test, 0xFFFFFFFFul, GENMASK(31, 0));
+
+#ifdef TEST_GENMASK_FAILURES
+ /* these should fail compilation */
+ GENMASK(0, 1);
+ GENMASK(0, 10);
+ GENMASK(9, 10);
+#endif
+
+
+}
+
+static void genmask_ull_test(struct kunit *test)
+{
+ KUNIT_EXPECT_EQ(test, 1ull, GENMASK_ULL(0, 0));
+ KUNIT_EXPECT_EQ(test, 3ull, GENMASK_ULL(1, 0));
+ KUNIT_EXPECT_EQ(test, 0x000000ffffe00000ull, GENMASK_ULL(39, 21));
+ KUNIT_EXPECT_EQ(test, 0xffffffffffffffffull, GENMASK_ULL(63, 0));
+
+#ifdef TEST_GENMASK_FAILURES
+ /* these should fail compilation */
+ GENMASK_ULL(0, 1);
+ GENMASK_ULL(0, 10);
+ GENMASK_ULL(9, 10);
+#endif
+}
+
+static void genmask_input_check_test(struct kunit *test)
+{
+ unsigned int x, y;
+ int z, w;
+
+ /* Unknown input */
+ KUNIT_EXPECT_EQ(test, 0, GENMASK_INPUT_CHECK(x, 0));
+ KUNIT_EXPECT_EQ(test, 0, GENMASK_INPUT_CHECK(0, x));
+ KUNIT_EXPECT_EQ(test, 0, GENMASK_INPUT_CHECK(x, y));
+
+ KUNIT_EXPECT_EQ(test, 0, GENMASK_INPUT_CHECK(z, 0));
+ KUNIT_EXPECT_EQ(test, 0, GENMASK_INPUT_CHECK(0, z));
+ KUNIT_EXPECT_EQ(test, 0, GENMASK_INPUT_CHECK(z, w));
+
+ /* Valid input */
+ KUNIT_EXPECT_EQ(test, 0, GENMASK_INPUT_CHECK(1, 1));
+ KUNIT_EXPECT_EQ(test, 0, GENMASK_INPUT_CHECK(39, 21));
+}
+
+
+static struct kunit_case bits_test_cases[] = {
+ KUNIT_CASE(genmask_test),
+ KUNIT_CASE(genmask_ull_test),
+ KUNIT_CASE(genmask_input_check_test),
+ {}
+};
+
+static struct kunit_suite bits_test_suite = {
+ .name = "bits-test",
+ .test_cases = bits_test_cases,
+};
+kunit_test_suite(bits_test_suite);
+
+MODULE_LICENSE("GPL");
--- /dev/null
+++ a/lib/list_kunit.c
@@ -0,0 +1,748 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * KUnit test for the Kernel Linked-list structures.
+ *
+ * Copyright (C) 2019, Google LLC.
+ * Author: David Gow <davidgow@xxxxxxxxxx>
+ */
+#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");
--- a/lib/list-test.c
+++ /dev/null
@@ -1,748 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * KUnit test for the Kernel Linked-list structures.
- *
- * Copyright (C) 2019, Google LLC.
- * Author: David Gow <davidgow@xxxxxxxxxx>
- */
-#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");
--- a/lib/Makefile~lib-bits_kunit-follow-new-file-name-convention-for-kunit-tests
+++ a/lib/Makefile
@@ -349,6 +349,6 @@ obj-$(CONFIG_PLDMFW) += pldmfw/
# KUnit tests
obj-$(CONFIG_BITFIELD_KUNIT) += bitfield_kunit.o
+obj-$(CONFIG_BITS_TEST) += bits_kunit.o
obj-$(CONFIG_LINEAR_RANGES_TEST) += linear_ranges_kunit.o
obj-$(CONFIG_LIST_KUNIT_TEST) += list_kunit.o
-obj-$(CONFIG_BITS_TEST) += test_bits.o
--- a/lib/test_bits.c
+++ /dev/null
@@ -1,75 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0+
-/*
- * Test cases for functions and macros in bits.h
- */
-
-#include <kunit/test.h>
-#include <linux/bits.h>
-
-
-static void genmask_test(struct kunit *test)
-{
- KUNIT_EXPECT_EQ(test, 1ul, GENMASK(0, 0));
- KUNIT_EXPECT_EQ(test, 3ul, GENMASK(1, 0));
- KUNIT_EXPECT_EQ(test, 6ul, GENMASK(2, 1));
- KUNIT_EXPECT_EQ(test, 0xFFFFFFFFul, GENMASK(31, 0));
-
-#ifdef TEST_GENMASK_FAILURES
- /* these should fail compilation */
- GENMASK(0, 1);
- GENMASK(0, 10);
- GENMASK(9, 10);
-#endif
-
-
-}
-
-static void genmask_ull_test(struct kunit *test)
-{
- KUNIT_EXPECT_EQ(test, 1ull, GENMASK_ULL(0, 0));
- KUNIT_EXPECT_EQ(test, 3ull, GENMASK_ULL(1, 0));
- KUNIT_EXPECT_EQ(test, 0x000000ffffe00000ull, GENMASK_ULL(39, 21));
- KUNIT_EXPECT_EQ(test, 0xffffffffffffffffull, GENMASK_ULL(63, 0));
-
-#ifdef TEST_GENMASK_FAILURES
- /* these should fail compilation */
- GENMASK_ULL(0, 1);
- GENMASK_ULL(0, 10);
- GENMASK_ULL(9, 10);
-#endif
-}
-
-static void genmask_input_check_test(struct kunit *test)
-{
- unsigned int x, y;
- int z, w;
-
- /* Unknown input */
- KUNIT_EXPECT_EQ(test, 0, GENMASK_INPUT_CHECK(x, 0));
- KUNIT_EXPECT_EQ(test, 0, GENMASK_INPUT_CHECK(0, x));
- KUNIT_EXPECT_EQ(test, 0, GENMASK_INPUT_CHECK(x, y));
-
- KUNIT_EXPECT_EQ(test, 0, GENMASK_INPUT_CHECK(z, 0));
- KUNIT_EXPECT_EQ(test, 0, GENMASK_INPUT_CHECK(0, z));
- KUNIT_EXPECT_EQ(test, 0, GENMASK_INPUT_CHECK(z, w));
-
- /* Valid input */
- KUNIT_EXPECT_EQ(test, 0, GENMASK_INPUT_CHECK(1, 1));
- KUNIT_EXPECT_EQ(test, 0, GENMASK_INPUT_CHECK(39, 21));
-}
-
-
-static struct kunit_case bits_test_cases[] = {
- KUNIT_CASE(genmask_test),
- KUNIT_CASE(genmask_ull_test),
- KUNIT_CASE(genmask_input_check_test),
- {}
-};
-
-static struct kunit_suite bits_test_suite = {
- .name = "bits-test",
- .test_cases = bits_test_cases,
-};
-kunit_test_suite(bits_test_suite);
-
-MODULE_LICENSE("GPL");
_
Patches currently in -mm which might be from andriy.shevchenko@xxxxxxxxxxxxxxx are
kernelh-split-out-mathematical-helpers.patch
bitmap-convert-bitmap_empty-bitmap_full-to-return-boolean.patch
lib-list_kunit-follow-new-file-name-convention-for-kunit-tests.patch
lib-linear_ranges_kunit-follow-new-file-name-convention-for-kunit-tests.patch
lib-bits_kunit-follow-new-file-name-convention-for-kunit-tests.patch
lib-cmdline-fix-get_option-for-strings-starting-with-hyphen.patch
lib-cmdline-allow-null-to-be-an-output-for-get_option.patch
lib-cmdline_kunit-add-a-new-test-suite-for-cmdline-api.patch
