AcoSail/kernel_optimize_test
8
0
Fork 0
forked from luck/tmp_suning_uos_patched
Code Pull Requests Activity
548193cba2
kernel_optimize_test/lib/list-test.c
Alan Maguire c475c77d5b kunit: allow kunit tests to be loaded as a module 
As tests are added to kunit, it will become less feasible to execute
all built tests together.  By supporting modular tests we provide
a simple way to do selective execution on a running system; specifying

CONFIG_KUNIT=y
CONFIG_KUNIT_EXAMPLE_TEST=m

...means we can simply "insmod example-test.ko" to run the tests.

To achieve this we need to do the following:

o export the required symbols in kunit
o string-stream tests utilize non-exported symbols so for now we skip
  building them when CONFIG_KUNIT_TEST=m.
o drivers/base/power/qos-test.c contains a few unexported interface
  references, namely freq_qos_read_value() and freq_constraints_init().
  Both of these could be potentially defined as static inline functions
  in include/linux/pm_qos.h, but for now we simply avoid supporting
  module build for that test suite.
o support a new way of declaring test suites.  Because a module cannot
  do multiple late_initcall()s, we provide a kunit_test_suites() macro
  to declare multiple suites within the same module at once.
o some test module names would have been too general ("test-test"
  and "example-test" for kunit tests, "inode-test" for ext4 tests);
  rename these as appropriate ("kunit-test", "kunit-example-test"
  and "ext4-inode-test" respectively).

Also define kunit_test_suite() via kunit_test_suites()
as callers in other trees may need the old definition.

Co-developed-by: Knut Omang <knut.omang@oracle.com>
Signed-off-by: Knut Omang <knut.omang@oracle.com>
Signed-off-by: Alan Maguire <alan.maguire@oracle.com>
Reviewed-by: Brendan Higgins <brendanhiggins@google.com>
Acked-by: Theodore Ts'o <tytso@mit.edu> # for ext4 bits
Acked-by: David Gow <davidgow@google.com> # For list-test
Reported-by: kbuild test robot <lkp@intel.com>
Signed-off-by: Shuah Khan <skhan@linuxfoundation.org>
2020-01-09 16:42:29 -07:00

749 lines
17 KiB
C
Raw Blame History

// 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_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;
static 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;
static 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");
View Git Blame Copy Permalink