diff --git a/lib/test_bitmap.c b/lib/test_bitmap.c
index 65a75d58ed9e4..41c82b8339ffc 100644
--- a/lib/test_bitmap.c
+++ b/lib/test_bitmap.c
@@ -13,17 +13,14 @@
 #include <linux/slab.h>
 #include <linux/string.h>
 #include <linux/uaccess.h>
-
-#include "../tools/testing/selftests/kselftest_module.h"
+#include <kunit/test.h>
 
 #define EXP1_IN_BITS	(sizeof(exp1) * 8)
 
-KSTM_MODULE_GLOBALS();
-
-static char pbl_buffer[PAGE_SIZE] __initdata;
-static char print_buf[PAGE_SIZE * 2] __initdata;
+static char pbl_buffer[PAGE_SIZE];
+static char print_buf[PAGE_SIZE * 2];
 
-static const unsigned long exp1[] __initconst = {
+static const unsigned long exp1[] = {
 	BITMAP_FROM_U64(1),
 	BITMAP_FROM_U64(2),
 	BITMAP_FROM_U64(0x0000ffff),
@@ -41,70 +38,59 @@ static const unsigned long exp1[] __initconst = {
 	BITMAP_FROM_U64(0x80000000),
 };
 
-static const unsigned long exp2[] __initconst = {
+static const unsigned long exp2[] = {
 	BITMAP_FROM_U64(0x3333333311111111ULL),
 	BITMAP_FROM_U64(0xffffffff77777777ULL),
 };
 
 /* Fibonacci sequence */
-static const unsigned long exp2_to_exp3_mask[] __initconst = {
+static const unsigned long exp2_to_exp3_mask[] = {
 	BITMAP_FROM_U64(0x008000020020212eULL),
 };
 /* exp3_0_1 = (exp2[0] & ~exp2_to_exp3_mask) | (exp2[1] & exp2_to_exp3_mask) */
-static const unsigned long exp3_0_1[] __initconst = {
+static const unsigned long exp3_0_1[] = {
 	BITMAP_FROM_U64(0x33b3333311313137ULL),
 };
 /* exp3_1_0 = (exp2[1] & ~exp2_to_exp3_mask) | (exp2[0] & exp2_to_exp3_mask) */
-static const unsigned long exp3_1_0[] __initconst = {
+static const unsigned long exp3_1_0[] = {
 	BITMAP_FROM_U64(0xff7fffff77575751ULL),
 };
 
-static bool __init
-__check_eq_ulong(const char *srcfile, unsigned int line,
+static void
+__check_eq_ulong(struct kunit *test, const char *srcfile, unsigned int line,
 		 const unsigned long exp_ulong, unsigned long x)
 {
-	if (exp_ulong != x) {
-		pr_err("[%s:%u] expected %lu, got %lu\n",
-			srcfile, line, exp_ulong, x);
-		return false;
-	}
-	return true;
+	KUNIT_ASSERT_EQ_MSG(test, exp_ulong, x,
+			    "[%s:%u] expected %lu, got %lu\n",
+			    srcfile, line, exp_ulong, x);
 }
 
-static bool __init
-__check_eq_bitmap(const char *srcfile, unsigned int line,
+static void
+__check_eq_bitmap(struct kunit *test, const char *srcfile, unsigned int line,
 		  const unsigned long *exp_bmap, const unsigned long *bmap,
 		  unsigned int nbits)
 {
-	if (!bitmap_equal(exp_bmap, bmap, nbits)) {
-		pr_warn("[%s:%u] bitmaps contents differ: expected \"%*pbl\", got \"%*pbl\"\n",
-			srcfile, line,
-			nbits, exp_bmap, nbits, bmap);
-		return false;
-	}
-	return true;
+	KUNIT_ASSERT_TRUE_MSG(test, bitmap_equal(exp_bmap, bmap, nbits),
+			      "[%s:%u] bitmaps contents differ: expected \"%*pbl\", got \"%*pbl\"\n",
+			      srcfile, line, nbits, exp_bmap, nbits, bmap);
 }
 
-static bool __init
-__check_eq_pbl(const char *srcfile, unsigned int line,
+static void
+__check_eq_pbl(struct kunit *test, const char *srcfile, unsigned int line,
 	       const char *expected_pbl,
 	       const unsigned long *bitmap, unsigned int nbits)
 {
 	snprintf(pbl_buffer, sizeof(pbl_buffer), "%*pbl", nbits, bitmap);
-	if (strcmp(expected_pbl, pbl_buffer)) {
-		pr_warn("[%s:%u] expected \"%s\", got \"%s\"\n",
-			srcfile, line,
-			expected_pbl, pbl_buffer);
-		return false;
-	}
-	return true;
+	KUNIT_ASSERT_STREQ_MSG(test, expected_pbl, pbl_buffer,
+			       "[%s:%u] expected \"%s\", got \"%s\"\n",
+			       srcfile, line, expected_pbl, pbl_buffer);
 }
 
-static bool __init
+static bool
 __check_eq_u32_array(const char *srcfile, unsigned int line,
 		     const u32 *exp_arr, unsigned int exp_len,
 		     const u32 *arr, unsigned int len) __used;
-static bool __init
+static bool
 __check_eq_u32_array(const char *srcfile, unsigned int line,
 		     const u32 *exp_arr, unsigned int exp_len,
 		     const u32 *arr, unsigned int len)
@@ -128,100 +114,82 @@ __check_eq_u32_array(const char *srcfile, unsigned int line,
 	return true;
 }
 
-static bool __init __check_eq_clump8(const char *srcfile, unsigned int line,
-				    const unsigned int offset,
-				    const unsigned int size,
-				    const unsigned char *const clump_exp,
-				    const unsigned long *const clump)
+static void __check_eq_clump8(struct kunit *test, const char *srcfile, unsigned int line,
+			      const unsigned int offset,
+			      const unsigned int size,
+			      const unsigned char *const clump_exp,
+			      const unsigned long *const clump)
 {
 	unsigned long exp;
 
-	if (offset >= size) {
-		pr_warn("[%s:%u] bit offset for clump out-of-bounds: expected less than %u, got %u\n",
-			srcfile, line, size, offset);
-		return false;
-	}
+	KUNIT_ASSERT_LE_MSG(test, offset, size,
+			    "[%s:%u] bit offset for clump out-of-bounds: expected less than %u, got %u\n",
+			    srcfile, line, size, offset);
 
 	exp = clump_exp[offset / 8];
-	if (!exp) {
-		pr_warn("[%s:%u] bit offset for zero clump: expected nonzero clump, got bit offset %u with clump value 0",
-			srcfile, line, offset);
-		return false;
-	}
-
-	if (*clump != exp) {
-		pr_warn("[%s:%u] expected clump value of 0x%lX, got clump value of 0x%lX",
-			srcfile, line, exp, *clump);
-		return false;
-	}
+	KUNIT_ASSERT_TRUE_MSG(test, exp,
+			      "[%s:%u] bit offset for zero clump: expected nonzero clump, got bit offset %u with clump value 0",
+			      srcfile, line, offset);
 
-	return true;
+	KUNIT_ASSERT_EQ_MSG(test, *clump, exp,
+			    "[%s:%u] expected clump value of 0x%lX, got clump value of 0x%lX",
+			    srcfile, line, exp, *clump);
 }
 
-static bool __init
-__check_eq_str(const char *srcfile, unsigned int line,
-		const char *exp_str, const char *str,
-		unsigned int len)
+static void
+__check_eq_str(struct kunit *test, const char *srcfile, unsigned int line,
+	       const char *exp_str, const char *str,
+	       unsigned int len)
 {
-	bool eq;
+	KUNIT_EXPECT_STREQ_MSG(test, exp_str, str,
+			       "[%s:%u] expected %s, got %s\n",
+			       srcfile, line, exp_str, str);
 
-	eq = strncmp(exp_str, str, len) == 0;
-	if (!eq)
-		pr_err("[%s:%u] expected %s, got %s\n", srcfile, line, exp_str, str);
-
-	return eq;
 }
 
-#define __expect_eq(suffix, ...)					\
+#define __expect_eq(test, suffix, ...)					\
 	({								\
-		int result = 0;						\
-		total_tests++;						\
-		if (!__check_eq_ ## suffix(__FILE__, __LINE__,		\
-					   ##__VA_ARGS__)) {		\
-			failed_tests++;					\
-			result = 1;					\
-		}							\
-		result;							\
+		__check_eq_ ## suffix(test, __FILE__, __LINE__,		\
+					   ##__VA_ARGS__);		\
 	})
 
-#define expect_eq_ulong(...)		__expect_eq(ulong, ##__VA_ARGS__)
-#define expect_eq_uint(x, y)		expect_eq_ulong((unsigned int)(x), (unsigned int)(y))
-#define expect_eq_bitmap(...)		__expect_eq(bitmap, ##__VA_ARGS__)
-#define expect_eq_pbl(...)		__expect_eq(pbl, ##__VA_ARGS__)
-#define expect_eq_u32_array(...)	__expect_eq(u32_array, ##__VA_ARGS__)
-#define expect_eq_clump8(...)		__expect_eq(clump8, ##__VA_ARGS__)
-#define expect_eq_str(...)		__expect_eq(str, ##__VA_ARGS__)
+#define expect_eq_ulong(test, ...)	__expect_eq(test, ulong, ##__VA_ARGS__)
+#define expect_eq_uint(test, x, y)	expect_eq_ulong(test, (unsigned int)(x), (unsigned int)(y))
+#define expect_eq_bitmap(test, ...)	__expect_eq(test, bitmap, ##__VA_ARGS__)
+#define expect_eq_pbl(test, ...)	__expect_eq(test, pbl, ##__VA_ARGS__)
+#define expect_eq_clump8(test, ...)	__expect_eq(test, clump8, ##__VA_ARGS__)
+#define expect_eq_str(test, ...)	__expect_eq(test, str, ##__VA_ARGS__)
 
-static void __init test_zero_clear(void)
+static void test_zero_clear(struct kunit *test)
 {
 	DECLARE_BITMAP(bmap, 1024);
 
 	/* Known way to set all bits */
 	memset(bmap, 0xff, 128);
 
-	expect_eq_pbl("0-22", bmap, 23);
-	expect_eq_pbl("0-1023", bmap, 1024);
+	expect_eq_pbl(test, "0-22", bmap, 23);
+	expect_eq_pbl(test, "0-1023", bmap, 1024);
 
 	/* single-word bitmaps */
 	bitmap_clear(bmap, 0, 9);
-	expect_eq_pbl("9-1023", bmap, 1024);
+	expect_eq_pbl(test, "9-1023", bmap, 1024);
 
 	bitmap_zero(bmap, 35);
-	expect_eq_pbl("64-1023", bmap, 1024);
+	expect_eq_pbl(test, "64-1023", bmap, 1024);
 
 	/* cross boundaries operations */
 	bitmap_clear(bmap, 79, 19);
-	expect_eq_pbl("64-78,98-1023", bmap, 1024);
+	expect_eq_pbl(test, "64-78,98-1023", bmap, 1024);
 
 	bitmap_zero(bmap, 115);
-	expect_eq_pbl("128-1023", bmap, 1024);
+	expect_eq_pbl(test, "128-1023", bmap, 1024);
 
 	/* Zeroing entire area */
 	bitmap_zero(bmap, 1024);
-	expect_eq_pbl("", bmap, 1024);
+	expect_eq_pbl(test, "", bmap, 1024);
 }
 
-static void __init test_find_nth_bit(void)
+static void test_find_nth_bit(struct kunit *test)
 {
 	unsigned long b, bit, cnt = 0;
 	DECLARE_BITMAP(bmap, 64 * 3);
@@ -236,62 +204,62 @@ static void __init test_find_nth_bit(void)
 	__set_bit(80, bmap);
 	__set_bit(123, bmap);
 
-	expect_eq_uint(10,  find_nth_bit(bmap, 64 * 3, 0));
-	expect_eq_uint(20,  find_nth_bit(bmap, 64 * 3, 1));
-	expect_eq_uint(30,  find_nth_bit(bmap, 64 * 3, 2));
-	expect_eq_uint(40,  find_nth_bit(bmap, 64 * 3, 3));
-	expect_eq_uint(50,  find_nth_bit(bmap, 64 * 3, 4));
-	expect_eq_uint(60,  find_nth_bit(bmap, 64 * 3, 5));
-	expect_eq_uint(80,  find_nth_bit(bmap, 64 * 3, 6));
-	expect_eq_uint(123, find_nth_bit(bmap, 64 * 3, 7));
-	expect_eq_uint(0,   !!(find_nth_bit(bmap, 64 * 3, 8) < 64 * 3));
-
-	expect_eq_uint(10,  find_nth_bit(bmap, 64 * 3 - 1, 0));
-	expect_eq_uint(20,  find_nth_bit(bmap, 64 * 3 - 1, 1));
-	expect_eq_uint(30,  find_nth_bit(bmap, 64 * 3 - 1, 2));
-	expect_eq_uint(40,  find_nth_bit(bmap, 64 * 3 - 1, 3));
-	expect_eq_uint(50,  find_nth_bit(bmap, 64 * 3 - 1, 4));
-	expect_eq_uint(60,  find_nth_bit(bmap, 64 * 3 - 1, 5));
-	expect_eq_uint(80,  find_nth_bit(bmap, 64 * 3 - 1, 6));
-	expect_eq_uint(123, find_nth_bit(bmap, 64 * 3 - 1, 7));
-	expect_eq_uint(0,   !!(find_nth_bit(bmap, 64 * 3 - 1, 8) < 64 * 3 - 1));
+	expect_eq_uint(test, 10,  find_nth_bit(bmap, 64 * 3, 0));
+	expect_eq_uint(test, 20,  find_nth_bit(bmap, 64 * 3, 1));
+	expect_eq_uint(test, 30,  find_nth_bit(bmap, 64 * 3, 2));
+	expect_eq_uint(test, 40,  find_nth_bit(bmap, 64 * 3, 3));
+	expect_eq_uint(test, 50,  find_nth_bit(bmap, 64 * 3, 4));
+	expect_eq_uint(test, 60,  find_nth_bit(bmap, 64 * 3, 5));
+	expect_eq_uint(test, 80,  find_nth_bit(bmap, 64 * 3, 6));
+	expect_eq_uint(test, 123, find_nth_bit(bmap, 64 * 3, 7));
+	expect_eq_uint(test, 0,   !!(find_nth_bit(bmap, 64 * 3, 8) < 64 * 3));
+
+	expect_eq_uint(test, 10,  find_nth_bit(bmap, 64 * 3 - 1, 0));
+	expect_eq_uint(test, 20,  find_nth_bit(bmap, 64 * 3 - 1, 1));
+	expect_eq_uint(test, 30,  find_nth_bit(bmap, 64 * 3 - 1, 2));
+	expect_eq_uint(test, 40,  find_nth_bit(bmap, 64 * 3 - 1, 3));
+	expect_eq_uint(test, 50,  find_nth_bit(bmap, 64 * 3 - 1, 4));
+	expect_eq_uint(test, 60,  find_nth_bit(bmap, 64 * 3 - 1, 5));
+	expect_eq_uint(test, 80,  find_nth_bit(bmap, 64 * 3 - 1, 6));
+	expect_eq_uint(test, 123, find_nth_bit(bmap, 64 * 3 - 1, 7));
+	expect_eq_uint(test, 0,   !!(find_nth_bit(bmap, 64 * 3 - 1, 8) < 64 * 3 - 1));
 
 	for_each_set_bit(bit, exp1, EXP1_IN_BITS) {
 		b = find_nth_bit(exp1, EXP1_IN_BITS, cnt++);
-		expect_eq_uint(b, bit);
+		expect_eq_uint(test, b, bit);
 	}
 }
 
-static void __init test_fill_set(void)
+static void test_fill_set(struct kunit *test)
 {
 	DECLARE_BITMAP(bmap, 1024);
 
 	/* Known way to clear all bits */
 	memset(bmap, 0x00, 128);
 
-	expect_eq_pbl("", bmap, 23);
-	expect_eq_pbl("", bmap, 1024);
+	expect_eq_pbl(test, "", bmap, 23);
+	expect_eq_pbl(test, "", bmap, 1024);
 
 	/* single-word bitmaps */
 	bitmap_set(bmap, 0, 9);
-	expect_eq_pbl("0-8", bmap, 1024);
+	expect_eq_pbl(test, "0-8", bmap, 1024);
 
 	bitmap_fill(bmap, 35);
-	expect_eq_pbl("0-63", bmap, 1024);
+	expect_eq_pbl(test, "0-63", bmap, 1024);
 
 	/* cross boundaries operations */
 	bitmap_set(bmap, 79, 19);
-	expect_eq_pbl("0-63,79-97", bmap, 1024);
+	expect_eq_pbl(test, "0-63,79-97", bmap, 1024);
 
 	bitmap_fill(bmap, 115);
-	expect_eq_pbl("0-127", bmap, 1024);
+	expect_eq_pbl(test, "0-127", bmap, 1024);
 
 	/* Zeroing entire area */
 	bitmap_fill(bmap, 1024);
-	expect_eq_pbl("0-1023", bmap, 1024);
+	expect_eq_pbl(test, "0-1023", bmap, 1024);
 }
 
-static void __init test_copy(void)
+static void test_copy(struct kunit *test)
 {
 	DECLARE_BITMAP(bmap1, 1024);
 	DECLARE_BITMAP(bmap2, 1024);
@@ -302,20 +270,20 @@ static void __init test_copy(void)
 	/* single-word bitmaps */
 	bitmap_set(bmap1, 0, 19);
 	bitmap_copy(bmap2, bmap1, 23);
-	expect_eq_pbl("0-18", bmap2, 1024);
+	expect_eq_pbl(test, "0-18", bmap2, 1024);
 
 	bitmap_set(bmap2, 0, 23);
 	bitmap_copy(bmap2, bmap1, 23);
-	expect_eq_pbl("0-18", bmap2, 1024);
+	expect_eq_pbl(test, "0-18", bmap2, 1024);
 
 	/* multi-word bitmaps */
 	bitmap_set(bmap1, 0, 109);
 	bitmap_copy(bmap2, bmap1, 1024);
-	expect_eq_pbl("0-108", bmap2, 1024);
+	expect_eq_pbl(test, "0-108", bmap2, 1024);
 
 	bitmap_fill(bmap2, 1024);
 	bitmap_copy(bmap2, bmap1, 1024);
-	expect_eq_pbl("0-108", bmap2, 1024);
+	expect_eq_pbl(test, "0-108", bmap2, 1024);
 
 	/* the following tests assume a 32- or 64-bit arch (even 128b
 	 * if we care)
@@ -323,14 +291,14 @@ static void __init test_copy(void)
 
 	bitmap_fill(bmap2, 1024);
 	bitmap_copy(bmap2, bmap1, 109);  /* ... but 0-padded til word length */
-	expect_eq_pbl("0-108,128-1023", bmap2, 1024);
+	expect_eq_pbl(test, "0-108,128-1023", bmap2, 1024);
 
 	bitmap_fill(bmap2, 1024);
 	bitmap_copy(bmap2, bmap1, 97);  /* ... but aligned on word length */
-	expect_eq_pbl("0-108,128-1023", bmap2, 1024);
+	expect_eq_pbl(test, "0-108,128-1023", bmap2, 1024);
 }
 
-static void __init test_bitmap_region(void)
+static void test_bitmap_region(struct kunit *test)
 {
 	int pos, order;
 
@@ -341,21 +309,21 @@ static void __init test_bitmap_region(void)
 	for (order = 0; order < 10; order++) {
 		pos = bitmap_find_free_region(bmap, 1000, order);
 		if (order == 0)
-			expect_eq_uint(pos, 0);
+			expect_eq_uint(test, pos, 0);
 		else
-			expect_eq_uint(pos, order < 9 ? BIT(order) : -ENOMEM);
+			expect_eq_uint(test, pos, order < 9 ? BIT(order) : -ENOMEM);
 	}
 
 	bitmap_release_region(bmap, 0, 0);
 	for (order = 1; order < 9; order++)
 		bitmap_release_region(bmap, BIT(order), order);
 
-	expect_eq_uint(bitmap_weight(bmap, 1000), 0);
+	expect_eq_uint(test, bitmap_weight(bmap, 1000), 0);
 }
 
 #define EXP2_IN_BITS	(sizeof(exp2) * 8)
 
-static void __init test_replace(void)
+static void test_replace(struct kunit *test)
 {
 	unsigned int nbits = 64;
 	unsigned int nlongs = DIV_ROUND_UP(nbits, BITS_PER_LONG);
@@ -365,38 +333,38 @@ static void __init test_replace(void)
 
 	bitmap_zero(bmap, 1024);
 	bitmap_replace(bmap, &exp2[0 * nlongs], &exp2[1 * nlongs], exp2_to_exp3_mask, nbits);
-	expect_eq_bitmap(bmap, exp3_0_1, nbits);
+	expect_eq_bitmap(test, bmap, exp3_0_1, nbits);
 
 	bitmap_zero(bmap, 1024);
 	bitmap_replace(bmap, &exp2[1 * nlongs], &exp2[0 * nlongs], exp2_to_exp3_mask, nbits);
-	expect_eq_bitmap(bmap, exp3_1_0, nbits);
+	expect_eq_bitmap(test, bmap, exp3_1_0, nbits);
 
 	bitmap_fill(bmap, 1024);
 	bitmap_replace(bmap, &exp2[0 * nlongs], &exp2[1 * nlongs], exp2_to_exp3_mask, nbits);
-	expect_eq_bitmap(bmap, exp3_0_1, nbits);
+	expect_eq_bitmap(test, bmap, exp3_0_1, nbits);
 
 	bitmap_fill(bmap, 1024);
 	bitmap_replace(bmap, &exp2[1 * nlongs], &exp2[0 * nlongs], exp2_to_exp3_mask, nbits);
-	expect_eq_bitmap(bmap, exp3_1_0, nbits);
+	expect_eq_bitmap(test, bmap, exp3_1_0, nbits);
 }
 
-static const unsigned long sg_mask[] __initconst = {
+static const unsigned long sg_mask[] = {
 	BITMAP_FROM_U64(0x000000000000035aULL),
 };
 
-static const unsigned long sg_src[] __initconst = {
+static const unsigned long sg_src[] = {
 	BITMAP_FROM_U64(0x0000000000000667ULL),
 };
 
-static const unsigned long sg_gather_exp[] __initconst = {
+static const unsigned long sg_gather_exp[] = {
 	BITMAP_FROM_U64(0x0000000000000029ULL),
 };
 
-static const unsigned long sg_scatter_exp[] __initconst = {
+static const unsigned long sg_scatter_exp[] = {
 	BITMAP_FROM_U64(0x000000000000021aULL),
 };
 
-static void __init test_bitmap_sg(void)
+static void test_bitmap_sg(struct kunit *test)
 {
 	unsigned int nbits = 64;
 	DECLARE_BITMAP(bmap_gather, 100);
@@ -407,18 +375,18 @@ static void __init test_bitmap_sg(void)
 	/* Simple gather call */
 	bitmap_zero(bmap_gather, 100);
 	bitmap_gather(bmap_gather, sg_src, sg_mask, nbits);
-	expect_eq_bitmap(sg_gather_exp, bmap_gather, nbits);
+	expect_eq_bitmap(test, sg_gather_exp, bmap_gather, nbits);
 
 	/* Simple scatter call */
 	bitmap_zero(bmap_scatter, 100);
 	bitmap_scatter(bmap_scatter, sg_src, sg_mask, nbits);
-	expect_eq_bitmap(sg_scatter_exp, bmap_scatter, nbits);
+	expect_eq_bitmap(test, sg_scatter_exp, bmap_scatter, nbits);
 
 	/* Scatter/gather relationship */
 	bitmap_zero(bmap_tmp, 100);
 	bitmap_gather(bmap_tmp, bmap_scatter, sg_mask, nbits);
 	bitmap_scatter(bmap_res, bmap_tmp, sg_mask, nbits);
-	expect_eq_bitmap(bmap_scatter, bmap_res, nbits);
+	expect_eq_bitmap(test, bmap_scatter, bmap_res, nbits);
 }
 
 #define PARSE_TIME	0x1
@@ -432,7 +400,7 @@ struct test_bitmap_parselist{
 	const int flags;
 };
 
-static const struct test_bitmap_parselist parselist_tests[] __initconst = {
+static const struct test_bitmap_parselist parselist_tests[] = {
 #define step (sizeof(u64) / sizeof(unsigned long))
 
 	{0, "0",			&exp1[0], 8, 0},
@@ -517,7 +485,7 @@ static const struct test_bitmap_parselist parselist_tests[] __initconst = {
 
 };
 
-static void __init test_bitmap_parselist(void)
+static void test_bitmap_parselist(struct kunit *test)
 {
 	int i;
 	int err;
@@ -531,21 +499,14 @@ static void __init test_bitmap_parselist(void)
 		err = bitmap_parselist(ptest.in, bmap, ptest.nbits);
 		time = ktime_get() - time;
 
-		if (err != ptest.errno) {
-			pr_err("parselist: %d: input is %s, errno is %d, expected %d\n",
-					i, ptest.in, err, ptest.errno);
-			failed_tests++;
-			continue;
-		}
+		KUNIT_ASSERT_EQ_MSG(test, err, ptest.errno,
+				    "parselist: %d: input is %s, errno is %d, expected %d\n",
+				    i, ptest.in, err, ptest.errno);
 
-		if (!err && ptest.expected
-			 && !__bitmap_equal(bmap, ptest.expected, ptest.nbits)) {
-			pr_err("parselist: %d: input is %s, result is 0x%lx, expected 0x%lx\n",
-					i, ptest.in, bmap[0],
-					*ptest.expected);
-			failed_tests++;
-			continue;
-		}
+		KUNIT_ASSERT_FALSE_MSG(test, !err && ptest.expected &&
+				       !__bitmap_equal(bmap, ptest.expected, ptest.nbits),
+				       "parselist: %d: input is %s, result is 0x%lx, expected 0x%lx\n",
+				       i, ptest.in, bmap[0], *ptest.expected);
 
 		if (ptest.flags & PARSE_TIME)
 			pr_info("parselist: %d: input is '%s' OK, Time: %llu\n",
@@ -555,7 +516,7 @@ static void __init test_bitmap_parselist(void)
 	}
 }
 
-static void __init test_bitmap_printlist(void)
+static void test_bitmap_printlist(struct kunit *test)
 {
 	unsigned long *bmap = kmalloc(PAGE_SIZE, GFP_KERNEL);
 	char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
@@ -575,17 +536,13 @@ static void __init test_bitmap_printlist(void)
 	ret = bitmap_print_to_pagebuf(true, buf, bmap, PAGE_SIZE * 8);
 	time = ktime_get() - time;
 
-	if (ret != slen + 1) {
-		pr_err("bitmap_print_to_pagebuf: result is %d, expected %d\n", ret, slen);
-		failed_tests++;
-		goto out;
-	}
+	KUNIT_ASSERT_EQ_MSG(test, ret, slen + 1,
+			    "bitmap_print_to_pagebuf: result is %d, expected %d\n",
+			    ret, slen);
 
-	if (strncmp(buf, expected, slen)) {
-		pr_err("bitmap_print_to_pagebuf: result is %s, expected %s\n", buf, expected);
-		failed_tests++;
-		goto out;
-	}
+	KUNIT_ASSERT_FALSE_MSG(test, strncmp(buf, expected, slen),
+			       "bitmap_print_to_pagebuf: result is %s, expected %s\n",
+			       buf, expected);
 
 	pr_info("bitmap_print_to_pagebuf: input is '%s', Time: %llu\n", buf, time);
 out:
@@ -593,20 +550,20 @@ static void __init test_bitmap_printlist(void)
 	kfree(bmap);
 }
 
-static const unsigned long parse_test[] __initconst = {
+static const unsigned long parse_test[] = {
 	BITMAP_FROM_U64(0),
 	BITMAP_FROM_U64(1),
 	BITMAP_FROM_U64(0xdeadbeef),
 	BITMAP_FROM_U64(0x100000000ULL),
 };
 
-static const unsigned long parse_test2[] __initconst = {
+static const unsigned long parse_test2[] = {
 	BITMAP_FROM_U64(0x100000000ULL), BITMAP_FROM_U64(0xdeadbeef),
 	BITMAP_FROM_U64(0x100000000ULL), BITMAP_FROM_U64(0xbaadf00ddeadbeef),
 	BITMAP_FROM_U64(0x100000000ULL), BITMAP_FROM_U64(0x0badf00ddeadbeef),
 };
 
-static const struct test_bitmap_parselist parse_tests[] __initconst = {
+static const struct test_bitmap_parselist parse_tests[] = {
 	{0, "",				&parse_test[0 * step], 32, 0},
 	{0, " ",			&parse_test[0 * step], 32, 0},
 	{0, "0",			&parse_test[0 * step], 32, 0},
@@ -633,7 +590,7 @@ static const struct test_bitmap_parselist parse_tests[] __initconst = {
 #undef step
 };
 
-static void __init test_bitmap_parse(void)
+static void test_bitmap_parse(struct kunit *_test)
 {
 	int i;
 	int err;
@@ -648,21 +605,14 @@ static void __init test_bitmap_parse(void)
 		err = bitmap_parse(test.in, len, bmap, test.nbits);
 		time = ktime_get() - time;
 
-		if (err != test.errno) {
-			pr_err("parse: %d: input is %s, errno is %d, expected %d\n",
-					i, test.in, err, test.errno);
-			failed_tests++;
-			continue;
-		}
+		KUNIT_ASSERT_EQ_MSG(_test, err, test.errno,
+				    "parse: %d: input is %s, errno is %d, expected %d\n",
+				     i, test.in, err, test.errno);
 
-		if (!err && test.expected
-			 && !__bitmap_equal(bmap, test.expected, test.nbits)) {
-			pr_err("parse: %d: input is %s, result is 0x%lx, expected 0x%lx\n",
-					i, test.in, bmap[0],
-					*test.expected);
-			failed_tests++;
-			continue;
-		}
+		KUNIT_ASSERT_FALSE_MSG(_test, !err && test.expected &&
+				       !__bitmap_equal(bmap, test.expected, test.nbits),
+				       "parse: %d: input is %s, result is 0x%lx, expected 0x%lx\n",
+					i, test.in, bmap[0], *test.expected);
 
 		if (test.flags & PARSE_TIME)
 			pr_info("parse: %d: input is '%s' OK, Time: %llu\n",
@@ -670,7 +620,7 @@ static void __init test_bitmap_parse(void)
 	}
 }
 
-static void __init test_bitmap_arr32(void)
+static void test_bitmap_arr32(struct kunit *test)
 {
 	unsigned int nbits, next_bit;
 	u32 arr[EXP1_IN_BITS / 32];
@@ -681,24 +631,22 @@ static void __init test_bitmap_arr32(void)
 	for (nbits = 0; nbits < EXP1_IN_BITS; ++nbits) {
 		bitmap_to_arr32(arr, exp1, nbits);
 		bitmap_from_arr32(bmap2, arr, nbits);
-		expect_eq_bitmap(bmap2, exp1, nbits);
+		expect_eq_bitmap(test, bmap2, exp1, nbits);
 
 		next_bit = find_next_bit(bmap2,
 				round_up(nbits, BITS_PER_LONG), nbits);
-		if (next_bit < round_up(nbits, BITS_PER_LONG)) {
-			pr_err("bitmap_copy_arr32(nbits == %d:"
-				" tail is not safely cleared: %d\n",
-				nbits, next_bit);
-			failed_tests++;
-		}
+
+		KUNIT_ASSERT_GE_MSG(test, next_bit, round_up(nbits, BITS_PER_LONG),
+				    "bitmap_copy_arr32(nbits == %d: tail is not safely cleared: %d\n",
+				    nbits, next_bit);
 
 		if (nbits < EXP1_IN_BITS - 32)
-			expect_eq_uint(arr[DIV_ROUND_UP(nbits, 32)],
-								0xa5a5a5a5);
+			expect_eq_uint(test, arr[DIV_ROUND_UP(nbits, 32)],
+				       0xa5a5a5a5);
 	}
 }
 
-static void __init test_bitmap_arr64(void)
+static void test_bitmap_arr64(struct kunit *test)
 {
 	unsigned int nbits, next_bit;
 	u64 arr[EXP1_IN_BITS / 64];
@@ -710,29 +658,25 @@ static void __init test_bitmap_arr64(void)
 		memset(bmap2, 0xff, sizeof(arr));
 		bitmap_to_arr64(arr, exp1, nbits);
 		bitmap_from_arr64(bmap2, arr, nbits);
-		expect_eq_bitmap(bmap2, exp1, nbits);
+		expect_eq_bitmap(test, bmap2, exp1, nbits);
 
 		next_bit = find_next_bit(bmap2, round_up(nbits, BITS_PER_LONG), nbits);
-		if (next_bit < round_up(nbits, BITS_PER_LONG)) {
-			pr_err("bitmap_copy_arr64(nbits == %d:"
-				" tail is not safely cleared: %d\n", nbits, next_bit);
-			failed_tests++;
-		}
+		KUNIT_ASSERT_GE_MSG(test, next_bit, round_up(nbits, BITS_PER_LONG),
+				    "bitmap_copy_arr64(nbits == %d: tail is not safely cleared: %d\n",
+				    nbits, next_bit);
 
-		if ((nbits % 64) &&
-		    (arr[(nbits - 1) / 64] & ~GENMASK_ULL((nbits - 1) % 64, 0))) {
-			pr_err("bitmap_to_arr64(nbits == %d): tail is not safely cleared: 0x%016llx (must be 0x%016llx)\n",
-			       nbits, arr[(nbits - 1) / 64],
-			       GENMASK_ULL((nbits - 1) % 64, 0));
-			failed_tests++;
-		}
+		KUNIT_ASSERT_FALSE_MSG(test, (nbits % 64) &&
+				       (arr[(nbits - 1) / 64] & ~GENMASK_ULL((nbits - 1) % 64, 0)),
+				       "bitmap_to_arr64(nbits == %d): tail is not safely cleared: 0x%016llx (must be 0x%016llx)\n",
+				       nbits, arr[(nbits - 1) / 64],
+				       GENMASK_ULL((nbits - 1) % 64, 0));
 
 		if (nbits < EXP1_IN_BITS - 64)
-			expect_eq_uint(arr[DIV_ROUND_UP(nbits, 64)], 0xa5a5a5a5);
+			expect_eq_uint(test, arr[DIV_ROUND_UP(nbits, 64)], 0xa5a5a5a5);
 	}
 }
 
-static void noinline __init test_mem_optimisations(void)
+static noinline void test_mem_optimisations(struct kunit *test)
 {
 	DECLARE_BITMAP(bmap1, 1024);
 	DECLARE_BITMAP(bmap2, 1024);
@@ -745,31 +689,26 @@ static void noinline __init test_mem_optimisations(void)
 
 			bitmap_set(bmap1, start, nbits);
 			__bitmap_set(bmap2, start, nbits);
-			if (!bitmap_equal(bmap1, bmap2, 1024)) {
-				printk("set not equal %d %d\n", start, nbits);
-				failed_tests++;
-			}
-			if (!__bitmap_equal(bmap1, bmap2, 1024)) {
-				printk("set not __equal %d %d\n", start, nbits);
-				failed_tests++;
-			}
+
+			KUNIT_ASSERT_TRUE_MSG(test, bitmap_equal(bmap1, bmap2, 1024),
+					      "set not equal %d %d\n", start, nbits);
+
+			KUNIT_ASSERT_TRUE_MSG(test, __bitmap_equal(bmap1, bmap2, 1024),
+					      "set not __equal %d %d\n", start, nbits);
 
 			bitmap_clear(bmap1, start, nbits);
 			__bitmap_clear(bmap2, start, nbits);
-			if (!bitmap_equal(bmap1, bmap2, 1024)) {
-				printk("clear not equal %d %d\n", start, nbits);
-				failed_tests++;
-			}
-			if (!__bitmap_equal(bmap1, bmap2, 1024)) {
-				printk("clear not __equal %d %d\n", start,
-									nbits);
-				failed_tests++;
-			}
+
+			KUNIT_ASSERT_TRUE_MSG(test, bitmap_equal(bmap1, bmap2, 1024),
+					      "clear not equal %d %d\n", start, nbits);
+
+			KUNIT_ASSERT_TRUE_MSG(test, __bitmap_equal(bmap1, bmap2, 1024),
+					      "clear not __equal %d %d\n", start, nbits);
 		}
 	}
 }
 
-static const unsigned char clump_exp[] __initconst = {
+static const unsigned char clump_exp[] = {
 	0x01,	/* 1 bit set */
 	0x02,	/* non-edge 1 bit set */
 	0x00,	/* zero bits set */
@@ -780,7 +719,7 @@ static const unsigned char clump_exp[] __initconst = {
 	0x05,	/* non-adjacent 2 bits set */
 };
 
-static void __init test_for_each_set_clump8(void)
+static void test_for_each_set_clump8(struct kunit *test)
 {
 #define CLUMP_EXP_NUMBITS 64
 	DECLARE_BITMAP(bits, CLUMP_EXP_NUMBITS);
@@ -799,10 +738,10 @@ static void __init test_for_each_set_clump8(void)
 	bitmap_set(bits, 58, 1);	/* 0x05 - part 2 */
 
 	for_each_set_clump8(start, clump, bits, CLUMP_EXP_NUMBITS)
-		expect_eq_clump8(start, CLUMP_EXP_NUMBITS, clump_exp, &clump);
+		expect_eq_clump8(test, start, CLUMP_EXP_NUMBITS, clump_exp, &clump);
 }
 
-static void __init test_for_each_set_bit_wrap(void)
+static void test_for_each_set_bit_wrap(struct kunit *test)
 {
 	DECLARE_BITMAP(orig, 500);
 	DECLARE_BITMAP(copy, 500);
@@ -823,11 +762,11 @@ static void __init test_for_each_set_bit_wrap(void)
 		for_each_set_bit_wrap(bit, orig, 500, wr)
 			bitmap_set(copy, bit, 1);
 
-		expect_eq_bitmap(orig, copy, 500);
+		expect_eq_bitmap(test, orig, copy, 500);
 	}
 }
 
-static void __init test_for_each_set_bit(void)
+static void test_for_each_set_bit(struct kunit *test)
 {
 	DECLARE_BITMAP(orig, 500);
 	DECLARE_BITMAP(copy, 500);
@@ -846,10 +785,10 @@ static void __init test_for_each_set_bit(void)
 	for_each_set_bit(bit, orig, 500)
 		bitmap_set(copy, bit, 1);
 
-	expect_eq_bitmap(orig, copy, 500);
+	expect_eq_bitmap(test, orig, copy, 500);
 }
 
-static void __init test_for_each_set_bit_from(void)
+static void test_for_each_set_bit_from(struct kunit *test)
 {
 	DECLARE_BITMAP(orig, 500);
 	DECLARE_BITMAP(copy, 500);
@@ -875,11 +814,11 @@ static void __init test_for_each_set_bit_from(void)
 
 		bitmap_copy(tmp, orig, 500);
 		bitmap_clear(tmp, 0, wr);
-		expect_eq_bitmap(tmp, copy, 500);
+		expect_eq_bitmap(test, tmp, copy, 500);
 	}
 }
 
-static void __init test_for_each_clear_bit(void)
+static void test_for_each_clear_bit(struct kunit *test)
 {
 	DECLARE_BITMAP(orig, 500);
 	DECLARE_BITMAP(copy, 500);
@@ -898,10 +837,10 @@ static void __init test_for_each_clear_bit(void)
 	for_each_clear_bit(bit, orig, 500)
 		bitmap_clear(copy, bit, 1);
 
-	expect_eq_bitmap(orig, copy, 500);
+	expect_eq_bitmap(test, orig, copy, 500);
 }
 
-static void __init test_for_each_clear_bit_from(void)
+static void test_for_each_clear_bit_from(struct kunit *test)
 {
 	DECLARE_BITMAP(orig, 500);
 	DECLARE_BITMAP(copy, 500);
@@ -927,11 +866,11 @@ static void __init test_for_each_clear_bit_from(void)
 
 		bitmap_copy(tmp, orig, 500);
 		bitmap_set(tmp, 0, wr);
-		expect_eq_bitmap(tmp, copy, 500);
+		expect_eq_bitmap(test, tmp, copy, 500);
 	}
 }
 
-static void __init test_for_each_set_bitrange(void)
+static void test_for_each_set_bitrange(struct kunit *test)
 {
 	DECLARE_BITMAP(orig, 500);
 	DECLARE_BITMAP(copy, 500);
@@ -950,10 +889,10 @@ static void __init test_for_each_set_bitrange(void)
 	for_each_set_bitrange(s, e, orig, 500)
 		bitmap_set(copy, s, e-s);
 
-	expect_eq_bitmap(orig, copy, 500);
+	expect_eq_bitmap(test, orig, copy, 500);
 }
 
-static void __init test_for_each_clear_bitrange(void)
+static void test_for_each_clear_bitrange(struct kunit *test)
 {
 	DECLARE_BITMAP(orig, 500);
 	DECLARE_BITMAP(copy, 500);
@@ -972,10 +911,10 @@ static void __init test_for_each_clear_bitrange(void)
 	for_each_clear_bitrange(s, e, orig, 500)
 		bitmap_clear(copy, s, e-s);
 
-	expect_eq_bitmap(orig, copy, 500);
+	expect_eq_bitmap(test, orig, copy, 500);
 }
 
-static void __init test_for_each_set_bitrange_from(void)
+static void test_for_each_set_bitrange_from(struct kunit *test)
 {
 	DECLARE_BITMAP(orig, 500);
 	DECLARE_BITMAP(copy, 500);
@@ -1001,11 +940,11 @@ static void __init test_for_each_set_bitrange_from(void)
 
 		bitmap_copy(tmp, orig, 500);
 		bitmap_clear(tmp, 0, wr);
-		expect_eq_bitmap(tmp, copy, 500);
+		expect_eq_bitmap(test, tmp, copy, 500);
 	}
 }
 
-static void __init test_for_each_clear_bitrange_from(void)
+static void test_for_each_clear_bitrange_from(struct kunit *test)
 {
 	DECLARE_BITMAP(orig, 500);
 	DECLARE_BITMAP(copy, 500);
@@ -1031,7 +970,7 @@ static void __init test_for_each_clear_bitrange_from(void)
 
 		bitmap_copy(tmp, orig, 500);
 		bitmap_set(tmp, 0, wr);
-		expect_eq_bitmap(tmp, copy, 500);
+		expect_eq_bitmap(test, tmp, copy, 500);
 	}
 }
 
@@ -1076,7 +1015,7 @@ static struct test_bitmap_cut test_cut[] = {
 	},
 };
 
-static void __init test_bitmap_cut(void)
+static void test_bitmap_cut(struct kunit *test)
 {
 	unsigned long b[5], *in = &b[1], *out = &b[0];	/* Partial overlap */
 	int i;
@@ -1088,7 +1027,7 @@ static void __init test_bitmap_cut(void)
 
 		bitmap_cut(out, in, t->first, t->cut, t->nbits);
 
-		expect_eq_bitmap(t->expected, out, t->nbits);
+		expect_eq_bitmap(test, t->expected, out, t->nbits);
 	}
 }
 
@@ -1099,14 +1038,14 @@ struct test_bitmap_print {
 	const char *list;
 };
 
-static const unsigned long small_bitmap[] __initconst = {
+static const unsigned long small_bitmap[] = {
 	BITMAP_FROM_U64(0x3333333311111111ULL),
 };
 
-static const char small_mask[] __initconst = "33333333,11111111\n";
-static const char small_list[] __initconst = "0,4,8,12,16,20,24,28,32-33,36-37,40-41,44-45,48-49,52-53,56-57,60-61\n";
+static const char small_mask[] = "33333333,11111111\n";
+static const char small_list[] = "0,4,8,12,16,20,24,28,32-33,36-37,40-41,44-45,48-49,52-53,56-57,60-61\n";
 
-static const unsigned long large_bitmap[] __initconst = {
+static const unsigned long large_bitmap[] = {
 	BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL),
 	BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL),
 	BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL),
@@ -1129,28 +1068,28 @@ static const unsigned long large_bitmap[] __initconst = {
 	BITMAP_FROM_U64(0x3333333311111111ULL), BITMAP_FROM_U64(0x3333333311111111ULL),
 };
 
-static const char large_mask[] __initconst = "33333333,11111111,33333333,11111111,"
-					"33333333,11111111,33333333,11111111,"
-					"33333333,11111111,33333333,11111111,"
-					"33333333,11111111,33333333,11111111,"
-					"33333333,11111111,33333333,11111111,"
-					"33333333,11111111,33333333,11111111,"
-					"33333333,11111111,33333333,11111111,"
-					"33333333,11111111,33333333,11111111,"
-					"33333333,11111111,33333333,11111111,"
-					"33333333,11111111,33333333,11111111,"
-					"33333333,11111111,33333333,11111111,"
-					"33333333,11111111,33333333,11111111,"
-					"33333333,11111111,33333333,11111111,"
-					"33333333,11111111,33333333,11111111,"
-					"33333333,11111111,33333333,11111111,"
-					"33333333,11111111,33333333,11111111,"
-					"33333333,11111111,33333333,11111111,"
-					"33333333,11111111,33333333,11111111,"
-					"33333333,11111111,33333333,11111111,"
-					"33333333,11111111,33333333,11111111\n";
-
-static const char large_list[] __initconst = /* more than 4KB */
+static const char large_mask[] = "33333333,11111111,33333333,11111111,"
+				 "33333333,11111111,33333333,11111111,"
+				 "33333333,11111111,33333333,11111111,"
+				 "33333333,11111111,33333333,11111111,"
+				 "33333333,11111111,33333333,11111111,"
+				 "33333333,11111111,33333333,11111111,"
+				 "33333333,11111111,33333333,11111111,"
+				 "33333333,11111111,33333333,11111111,"
+				 "33333333,11111111,33333333,11111111,"
+				 "33333333,11111111,33333333,11111111,"
+				 "33333333,11111111,33333333,11111111,"
+				 "33333333,11111111,33333333,11111111,"
+				 "33333333,11111111,33333333,11111111,"
+				 "33333333,11111111,33333333,11111111,"
+				 "33333333,11111111,33333333,11111111,"
+				 "33333333,11111111,33333333,11111111,"
+				 "33333333,11111111,33333333,11111111,"
+				 "33333333,11111111,33333333,11111111,"
+				 "33333333,11111111,33333333,11111111,"
+				 "33333333,11111111,33333333,11111111\n";
+
+static const char large_list[] = /* more than 4KB */
 	"0,4,8,12,16,20,24,28,32-33,36-37,40-41,44-45,48-49,52-53,56-57,60-61,64,68,72,76,80,84,88,92,96-97,100-101,104-1"
 	"05,108-109,112-113,116-117,120-121,124-125,128,132,136,140,144,148,152,156,160-161,164-165,168-169,172-173,176-1"
 	"77,180-181,184-185,188-189,192,196,200,204,208,212,216,220,224-225,228-229,232-233,236-237,240-241,244-245,248-2"
@@ -1192,12 +1131,12 @@ static const char large_list[] __initconst = /* more than 4KB */
 	"2489,2492-2493,2496,2500,2504,2508,2512,2516,2520,2524,2528-2529,2532-2533,2536-2537,2540-2541,2544-2545,2548-25"
 	"49,2552-2553,2556-2557\n";
 
-static const struct test_bitmap_print test_print[] __initconst = {
+static const struct test_bitmap_print test_print[] = {
 	{ small_bitmap, sizeof(small_bitmap) * BITS_PER_BYTE, small_mask, small_list },
 	{ large_bitmap, sizeof(large_bitmap) * BITS_PER_BYTE, large_mask, large_list },
 };
 
-static void __init test_bitmap_print_buf(void)
+static void test_bitmap_print_buf(struct kunit *test)
 {
 	int i;
 
@@ -1207,20 +1146,20 @@ static void __init test_bitmap_print_buf(void)
 
 		n = bitmap_print_bitmask_to_buf(print_buf, t->bitmap, t->nbits,
 						0, 2 * PAGE_SIZE);
-		expect_eq_uint(strlen(t->mask) + 1, n);
-		expect_eq_str(t->mask, print_buf, n);
+		expect_eq_uint(test, strlen(t->mask) + 1, n);
+		expect_eq_str(test, t->mask, print_buf, n);
 
 		n = bitmap_print_list_to_buf(print_buf, t->bitmap, t->nbits,
 					     0, 2 * PAGE_SIZE);
-		expect_eq_uint(strlen(t->list) + 1, n);
-		expect_eq_str(t->list, print_buf, n);
+		expect_eq_uint(test, strlen(t->list) + 1, n);
+		expect_eq_str(test, t->list, print_buf, n);
 
 		/* test by non-zero offset */
 		if (strlen(t->list) > PAGE_SIZE) {
 			n = bitmap_print_list_to_buf(print_buf, t->bitmap, t->nbits,
 						     PAGE_SIZE, PAGE_SIZE);
-			expect_eq_uint(strlen(t->list) + 1 - PAGE_SIZE, n);
-			expect_eq_str(t->list + PAGE_SIZE, print_buf, n);
+			expect_eq_uint(test, strlen(t->list) + 1 - PAGE_SIZE, n);
+			expect_eq_str(test, t->list + PAGE_SIZE, print_buf, n);
 		}
 	}
 }
@@ -1229,7 +1168,7 @@ static void __init test_bitmap_print_buf(void)
  * FIXME: Clang breaks compile-time evaluations when KASAN and GCOV are enabled.
  * To workaround it, GCOV is force-disabled in Makefile for this configuration.
  */
-static void __init test_bitmap_const_eval(void)
+static void test_bitmap_const_eval(struct kunit *test)
 {
 	DECLARE_BITMAP(bitmap, BITS_PER_LONG);
 	unsigned long initvar = BIT(2);
@@ -1297,7 +1236,7 @@ static void __init test_bitmap_const_eval(void)
 /*
  * Helper function to test bitmap_write() overwriting the chosen byte pattern.
  */
-static void __init test_bitmap_write_helper(const char *pattern)
+static void test_bitmap_write_helper(struct kunit *test, const char *pattern)
 {
 	DECLARE_BITMAP(bitmap, TEST_BIT_LEN);
 	DECLARE_BITMAP(exp_bitmap, TEST_BIT_LEN);
@@ -1321,7 +1260,7 @@ static void __init test_bitmap_write_helper(const char *pattern)
 		for (bit = 0; bit <= 1; bit++) {
 			bitmap_write(bitmap, bit, i, 1);
 			__assign_bit(i, exp_bitmap, bit);
-			expect_eq_bitmap(exp_bitmap, bitmap,
+			expect_eq_bitmap(test, exp_bitmap, bitmap,
 					 TEST_BIT_LEN);
 		}
 	}
@@ -1331,7 +1270,7 @@ static void __init test_bitmap_write_helper(const char *pattern)
 	bitmap_copy(exp_bitmap, pat_bitmap, TEST_BIT_LEN);
 	for (i = 0; i < TEST_BIT_LEN; i++) {
 		bitmap_write(bitmap, ~0UL, i, 0);
-		expect_eq_bitmap(exp_bitmap, bitmap, TEST_BIT_LEN);
+		expect_eq_bitmap(test, exp_bitmap, bitmap, TEST_BIT_LEN);
 	}
 
 	for (nbits = BITS_PER_LONG; nbits >= 1; nbits--) {
@@ -1344,14 +1283,14 @@ static void __init test_bitmap_write_helper(const char *pattern)
 			for (n = 0; n < nbits; n++)
 				__assign_bit(i + n, exp_bitmap, w & BIT(n));
 			bitmap_write(bitmap, w, i, nbits);
-			expect_eq_bitmap(exp_bitmap, bitmap, TEST_BIT_LEN);
+			expect_eq_bitmap(test, exp_bitmap, bitmap, TEST_BIT_LEN);
 			r = bitmap_read(bitmap, i, nbits);
-			expect_eq_ulong(r, w);
+			expect_eq_ulong(test, r, w);
 		}
 	}
 }
 
-static void __init test_bitmap_read_write(void)
+static void test_bitmap_read_write(struct kunit *test)
 {
 	unsigned char *pattern[3] = {"", "all:1/2", "all"};
 	DECLARE_BITMAP(bitmap, TEST_BIT_LEN);
@@ -1386,21 +1325,21 @@ static void __init test_bitmap_read_write(void)
 
 		bitmap_write(bitmap, 0b10101UL, i, 5);
 		val = bitmap_read(bitmap, i, 5);
-		expect_eq_ulong(0b10101UL, val);
+		expect_eq_ulong(test, 0b10101UL, val);
 
 		bitmap_write(bitmap, 0b101UL, i + 5, 3);
 		val = bitmap_read(bitmap, i + 5, 3);
-		expect_eq_ulong(0b101UL, val);
+		expect_eq_ulong(test, 0b101UL, val);
 
 		val = bitmap_read(bitmap, i, 8);
-		expect_eq_ulong(0b10110101UL, val);
+		expect_eq_ulong(test, 0b10110101UL, val);
 	}
 
 	for (pi = 0; pi < ARRAY_SIZE(pattern); pi++)
-		test_bitmap_write_helper(pattern[pi]);
+		test_bitmap_write_helper(test, pattern[pi]);
 }
 
-static void __init test_bitmap_read_perf(void)
+static void test_bitmap_read_perf(struct kunit *test)
 {
 	DECLARE_BITMAP(bitmap, TEST_BIT_LEN);
 	unsigned int cnt, nbits, i;
@@ -1426,7 +1365,7 @@ static void __init test_bitmap_read_perf(void)
 	pr_info("Time spent in %s:\t%llu\n", __func__, time);
 }
 
-static void __init test_bitmap_write_perf(void)
+static void test_bitmap_write_perf(struct kunit *test)
 {
 	DECLARE_BITMAP(bitmap, TEST_BIT_LEN);
 	unsigned int cnt, nbits, i;
@@ -1450,41 +1389,46 @@ static void __init test_bitmap_write_perf(void)
 
 #undef TEST_BIT_LEN
 
-static void __init selftest(void)
-{
-	test_zero_clear();
-	test_fill_set();
-	test_copy();
-	test_bitmap_region();
-	test_replace();
-	test_bitmap_sg();
-	test_bitmap_arr32();
-	test_bitmap_arr64();
-	test_bitmap_parse();
-	test_bitmap_parselist();
-	test_bitmap_printlist();
-	test_mem_optimisations();
-	test_bitmap_cut();
-	test_bitmap_print_buf();
-	test_bitmap_const_eval();
-	test_bitmap_read_write();
-	test_bitmap_read_perf();
-	test_bitmap_write_perf();
-
-	test_find_nth_bit();
-	test_for_each_set_bit();
-	test_for_each_set_bit_from();
-	test_for_each_clear_bit();
-	test_for_each_clear_bit_from();
-	test_for_each_set_bitrange();
-	test_for_each_clear_bitrange();
-	test_for_each_set_bitrange_from();
-	test_for_each_clear_bitrange_from();
-	test_for_each_set_clump8();
-	test_for_each_set_bit_wrap();
-}
+static struct kunit_case bitmap_test_cases[] = {
+	KUNIT_CASE(test_zero_clear),
+	KUNIT_CASE(test_fill_set),
+	KUNIT_CASE(test_copy),
+	KUNIT_CASE(test_bitmap_region),
+	KUNIT_CASE(test_replace),
+	KUNIT_CASE(test_bitmap_sg),
+	KUNIT_CASE(test_bitmap_arr32),
+	KUNIT_CASE(test_bitmap_arr64),
+	KUNIT_CASE(test_bitmap_parse),
+	KUNIT_CASE(test_bitmap_parselist),
+	KUNIT_CASE(test_bitmap_printlist),
+	KUNIT_CASE(test_mem_optimisations),
+	KUNIT_CASE(test_bitmap_cut),
+	KUNIT_CASE(test_bitmap_print_buf),
+	KUNIT_CASE(test_bitmap_const_eval),
+	KUNIT_CASE(test_bitmap_read_write),
+	KUNIT_CASE(test_bitmap_read_perf),
+	KUNIT_CASE(test_bitmap_write_perf),
+
+	KUNIT_CASE(test_find_nth_bit),
+	KUNIT_CASE(test_for_each_set_bit),
+	KUNIT_CASE(test_for_each_set_bit_from),
+	KUNIT_CASE(test_for_each_clear_bit),
+	KUNIT_CASE(test_for_each_clear_bit_from),
+	KUNIT_CASE(test_for_each_set_bitrange),
+	KUNIT_CASE(test_for_each_clear_bitrange),
+	KUNIT_CASE(test_for_each_set_bitrange_from),
+	KUNIT_CASE(test_for_each_clear_bitrange_from),
+	KUNIT_CASE(test_for_each_set_clump8),
+	KUNIT_CASE(test_for_each_set_bit_wrap),
+	{}
+};
+
+static struct kunit_suite bitmap_test_suite = {
+	.name = "bitmap",
+	.test_cases = bitmap_test_cases,
+};
 
-KSTM_MODULE_LOADERS(test_bitmap);
+kunit_test_suite(bitmap_test_suite);
 MODULE_AUTHOR("david decotigny <david.decotigny@googlers.com>");
 MODULE_DESCRIPTION("Test cases for bitmap API");
 MODULE_LICENSE("GPL");
