kernel/resource_kunit.c - linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0+
 /*
  * Test cases for API provided by resource.c and ioport.h
  */

 #include <kunit/test.h>
 #include <linux/ioport.h>
 #include <linux/kernel.h>
 #include <linux/string.h>
 #include <linux/sizes.h>
 #include <linux/mm.h>

 #define R0_START	0x0000
 #define R0_END		0xffff
 #define R1_START	0x1234
 #define R1_END		0x2345
 #define R2_START	0x4567
 #define R2_END		0x5678
 #define R3_START	0x6789
 #define R3_END		0x789a
 #define R4_START	0x2000
 #define R4_END		0x7000

 static struct resource r0 = { .start = R0_START, .end = R0_END };
 static struct resource r1 = { .start = R1_START, .end = R1_END };
 static struct resource r2 = { .start = R2_START, .end = R2_END };
 static struct resource r3 = { .start = R3_START, .end = R3_END };
 static struct resource r4 = { .start = R4_START, .end = R4_END };

 struct result {
 	struct resource *r1;
 	struct resource *r2;
 	struct resource r;
 	bool ret;
 };

 static struct result results_for_union[] = {
 	{
 		.r1 = &r1, .r2 = &r0, .r.start = R0_START, .r.end = R0_END, .ret = true,
 	}, {
 		.r1 = &r2, .r2 = &r0, .r.start = R0_START, .r.end = R0_END, .ret = true,
 	}, {
 		.r1 = &r3, .r2 = &r0, .r.start = R0_START, .r.end = R0_END, .ret = true,
 	}, {
 		.r1 = &r4, .r2 = &r0, .r.start = R0_START, .r.end = R0_END, .ret = true,
 	}, {
 		.r1 = &r2, .r2 = &r1, .ret = false,
 	}, {
 		.r1 = &r3, .r2 = &r1, .ret = false,
 	}, {
 		.r1 = &r4, .r2 = &r1, .r.start = R1_START, .r.end = R4_END, .ret = true,
 	}, {
 		.r1 = &r2, .r2 = &r3, .ret = false,
 	}, {
 		.r1 = &r2, .r2 = &r4, .r.start = R4_START, .r.end = R4_END, .ret = true,
 	}, {
 		.r1 = &r3, .r2 = &r4, .r.start = R4_START, .r.end = R3_END, .ret = true,
 	},
 };

 static struct result results_for_intersection[] = {
 	{
 		.r1 = &r1, .r2 = &r0, .r.start = R1_START, .r.end = R1_END, .ret = true,
 	}, {
 		.r1 = &r2, .r2 = &r0, .r.start = R2_START, .r.end = R2_END, .ret = true,
 	}, {
 		.r1 = &r3, .r2 = &r0, .r.start = R3_START, .r.end = R3_END, .ret = true,
 	}, {
 		.r1 = &r4, .r2 = &r0, .r.start = R4_START, .r.end = R4_END, .ret = true,
 	}, {
 		.r1 = &r2, .r2 = &r1, .ret = false,
 	}, {
 		.r1 = &r3, .r2 = &r1, .ret = false,
 	}, {
 		.r1 = &r4, .r2 = &r1, .r.start = R4_START, .r.end = R1_END, .ret = true,
 	}, {
 		.r1 = &r2, .r2 = &r3, .ret = false,
 	}, {
 		.r1 = &r2, .r2 = &r4, .r.start = R2_START, .r.end = R2_END, .ret = true,
 	}, {
 		.r1 = &r3, .r2 = &r4, .r.start = R3_START, .r.end = R4_END, .ret = true,
 	},
 };

 static void resource_do_test(struct kunit *test, bool ret, struct resource *r,
 			     bool exp_ret, struct resource *exp_r,
 			     struct resource *r1, struct resource *r2)
 {
 	KUNIT_EXPECT_EQ_MSG(test, ret, exp_ret, "Resources %pR %pR", r1, r2);
 	KUNIT_EXPECT_EQ_MSG(test, r->start, exp_r->start, "Start elements are not equal");
 	KUNIT_EXPECT_EQ_MSG(test, r->end, exp_r->end, "End elements are not equal");
 }

 static void resource_do_union_test(struct kunit *test, struct result *r)
 {
 	struct resource result;
 	bool ret;

 	memset(&result, 0, sizeof(result));
 	ret = resource_union(r->r1, r->r2, &result);
 	resource_do_test(test, ret, &result, r->ret, &r->r, r->r1, r->r2);

 	memset(&result, 0, sizeof(result));
 	ret = resource_union(r->r2, r->r1, &result);
 	resource_do_test(test, ret, &result, r->ret, &r->r, r->r2, r->r1);
 }

 static void resource_test_union(struct kunit *test)
 {
 	struct result *r = results_for_union;
 	unsigned int i = 0;

 	do {
 		resource_do_union_test(test, &r[i]);
 	} while (++i < ARRAY_SIZE(results_for_union));
 }

 static void resource_do_intersection_test(struct kunit *test, struct result *r)
 {
 	struct resource result;
 	bool ret;

 	memset(&result, 0, sizeof(result));
 	ret = resource_intersection(r->r1, r->r2, &result);
 	resource_do_test(test, ret, &result, r->ret, &r->r, r->r1, r->r2);

 	memset(&result, 0, sizeof(result));
 	ret = resource_intersection(r->r2, r->r1, &result);
 	resource_do_test(test, ret, &result, r->ret, &r->r, r->r2, r->r1);
 }

 static void resource_test_intersection(struct kunit *test)
 {
 	struct result *r = results_for_intersection;
 	unsigned int i = 0;

 	do {
 		resource_do_intersection_test(test, &r[i]);
 	} while (++i < ARRAY_SIZE(results_for_intersection));
 }

 /*
  * The test resource tree for region_intersects() test:
  *
  * BASE-BASE+1M-1 : Test System RAM 0
  *		  # hole 0 (BASE+1M-BASE+2M)
  * BASE+2M-BASE+3M-1 : Test CXL Window 0
  * BASE+3M-BASE+4M-1 : Test System RAM 1
  * BASE+4M-BASE+7M-1 : Test CXL Window 1
  *   BASE+4M-BASE+5M-1 : Test System RAM 2
  *     BASE+4M+128K-BASE+4M+256K-1: Test Code
  *   BASE+5M-BASE+6M-1 : Test System RAM 3
  */
 #define RES_TEST_RAM0_OFFSET	0
 #define RES_TEST_RAM0_SIZE	SZ_1M
 #define RES_TEST_HOLE0_OFFSET	(RES_TEST_RAM0_OFFSET + RES_TEST_RAM0_SIZE)
 #define RES_TEST_HOLE0_SIZE	SZ_1M
 #define RES_TEST_WIN0_OFFSET	(RES_TEST_HOLE0_OFFSET + RES_TEST_HOLE0_SIZE)
 #define RES_TEST_WIN0_SIZE	SZ_1M
 #define RES_TEST_RAM1_OFFSET	(RES_TEST_WIN0_OFFSET + RES_TEST_WIN0_SIZE)
 #define RES_TEST_RAM1_SIZE	SZ_1M
 #define RES_TEST_WIN1_OFFSET	(RES_TEST_RAM1_OFFSET + RES_TEST_RAM1_SIZE)
 #define RES_TEST_WIN1_SIZE	(SZ_1M * 3)
 #define RES_TEST_RAM2_OFFSET	RES_TEST_WIN1_OFFSET
 #define RES_TEST_RAM2_SIZE	SZ_1M
 #define RES_TEST_CODE_OFFSET	(RES_TEST_RAM2_OFFSET + SZ_128K)
 #define RES_TEST_CODE_SIZE	SZ_128K
 #define RES_TEST_RAM3_OFFSET	(RES_TEST_RAM2_OFFSET + RES_TEST_RAM2_SIZE)
 #define RES_TEST_RAM3_SIZE	SZ_1M
 #define RES_TEST_TOTAL_SIZE	((RES_TEST_WIN1_OFFSET + RES_TEST_WIN1_SIZE))

 static void remove_free_resource(void *ctx)
 {
 	struct resource *res = (struct resource *)ctx;

 	remove_resource(res);
 	kfree(res);
 }

 static void resource_test_request_region(struct kunit *test, struct resource *parent,
 					 resource_size_t start, resource_size_t size,
 					 const char *name, unsigned long flags)
 {
 	struct resource *res;

 	res = __request_region(parent, start, size, name, flags);
 	KUNIT_ASSERT_NOT_NULL(test, res);
 	kunit_add_action_or_reset(test, remove_free_resource, res);
 }

 static void resource_test_insert_resource(struct kunit *test, struct resource *parent,
 					  resource_size_t start, resource_size_t size,
 					  const char *name, unsigned long flags)
 {
 	struct resource *res;

 	res = kzalloc(sizeof(*res), GFP_KERNEL);
 	KUNIT_ASSERT_NOT_NULL(test, res);

 	res->name = name;
 	res->start = start;
 	res->end = start + size - 1;
 	res->flags = flags;
 	if (insert_resource(parent, res)) {
 		kfree(res);
 		KUNIT_FAIL_AND_ABORT(test, "Fail to insert resource %pR\n", res);
 	}

 	kunit_add_action_or_reset(test, remove_free_resource, res);
 }

 static void resource_test_region_intersects(struct kunit *test)
 {
 	unsigned long flags =  IORESOURCE_SYSTEM_RAM | IORESOURCE_BUSY;
 	struct resource *parent;
 	resource_size_t start;

 	/* Find an iomem_resource hole to hold test resources */
 	parent = alloc_free_mem_region(&iomem_resource, RES_TEST_TOTAL_SIZE, SZ_1M,
 				       "test resources");
 	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
 	start = parent->start;
 	kunit_add_action_or_reset(test, remove_free_resource, parent);

 	resource_test_request_region(test, parent, start + RES_TEST_RAM0_OFFSET,
 				     RES_TEST_RAM0_SIZE, "Test System RAM 0", flags);
 	resource_test_insert_resource(test, parent, start + RES_TEST_WIN0_OFFSET,
 				      RES_TEST_WIN0_SIZE, "Test CXL Window 0",
 				      IORESOURCE_MEM);
 	resource_test_request_region(test, parent, start + RES_TEST_RAM1_OFFSET,
 				     RES_TEST_RAM1_SIZE, "Test System RAM 1", flags);
 	resource_test_insert_resource(test, parent, start + RES_TEST_WIN1_OFFSET,
 				      RES_TEST_WIN1_SIZE, "Test CXL Window 1",
 				      IORESOURCE_MEM);
 	resource_test_request_region(test, parent, start + RES_TEST_RAM2_OFFSET,
 				     RES_TEST_RAM2_SIZE, "Test System RAM 2", flags);
 	resource_test_insert_resource(test, parent, start + RES_TEST_CODE_OFFSET,
 				      RES_TEST_CODE_SIZE, "Test Code", flags);
 	resource_test_request_region(test, parent, start + RES_TEST_RAM3_OFFSET,
 				     RES_TEST_RAM3_SIZE, "Test System RAM 3", flags);
 	kunit_release_action(test, remove_free_resource, parent);

 	KUNIT_EXPECT_EQ(test, REGION_INTERSECTS,
 			region_intersects(start + RES_TEST_RAM0_OFFSET, PAGE_SIZE,
 					  IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
 	KUNIT_EXPECT_EQ(test, REGION_INTERSECTS,
 			region_intersects(start + RES_TEST_RAM0_OFFSET +
 					  RES_TEST_RAM0_SIZE - PAGE_SIZE, 2 * PAGE_SIZE,
 					  IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
 	KUNIT_EXPECT_EQ(test, REGION_DISJOINT,
 			region_intersects(start + RES_TEST_HOLE0_OFFSET, PAGE_SIZE,
 					  IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
 	KUNIT_EXPECT_EQ(test, REGION_DISJOINT,
 			region_intersects(start + RES_TEST_HOLE0_OFFSET +
 					  RES_TEST_HOLE0_SIZE - PAGE_SIZE, 2 * PAGE_SIZE,
 					  IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
 	KUNIT_EXPECT_EQ(test, REGION_MIXED,
 			region_intersects(start + RES_TEST_WIN0_OFFSET +
 					  RES_TEST_WIN0_SIZE - PAGE_SIZE, 2 * PAGE_SIZE,
 					  IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
 	KUNIT_EXPECT_EQ(test, REGION_INTERSECTS,
 			region_intersects(start + RES_TEST_RAM1_OFFSET +
 					  RES_TEST_RAM1_SIZE - PAGE_SIZE, 2 * PAGE_SIZE,
 					  IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
 	KUNIT_EXPECT_EQ(test, REGION_INTERSECTS,
 			region_intersects(start + RES_TEST_RAM2_OFFSET +
 					  RES_TEST_RAM2_SIZE - PAGE_SIZE, 2 * PAGE_SIZE,
 					  IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
 	KUNIT_EXPECT_EQ(test, REGION_INTERSECTS,
 			region_intersects(start + RES_TEST_CODE_OFFSET, PAGE_SIZE,
 					  IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
 	KUNIT_EXPECT_EQ(test, REGION_INTERSECTS,
 			region_intersects(start + RES_TEST_RAM2_OFFSET,
 					  RES_TEST_RAM2_SIZE + PAGE_SIZE,
 					  IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
 	KUNIT_EXPECT_EQ(test, REGION_MIXED,
 			region_intersects(start + RES_TEST_RAM3_OFFSET,
 					  RES_TEST_RAM3_SIZE + PAGE_SIZE,
 					  IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
 }

 static struct kunit_case resource_test_cases[] = {
 	KUNIT_CASE(resource_test_union),
 	KUNIT_CASE(resource_test_intersection),
 	KUNIT_CASE(resource_test_region_intersects),
 	{}
 };

 static struct kunit_suite resource_test_suite = {
 	.name = "resource",
 	.test_cases = resource_test_cases,
 };
 kunit_test_suite(resource_test_suite);

 MODULE_DESCRIPTION("I/O Port & Memory Resource manager unit tests");
 MODULE_LICENSE("GPL");
	// SPDX-License-Identifier: GPL-2.0+
	/*
	* Test cases for API provided by resource.c and ioport.h
	*/

	#include <kunit/test.h>
	#include <linux/ioport.h>
	#include <linux/kernel.h>
	#include <linux/string.h>
	#include <linux/sizes.h>
	#include <linux/mm.h>

	#define R0_START 0x0000
	#define R0_END 0xffff
	#define R1_START 0x1234
	#define R1_END 0x2345
	#define R2_START 0x4567
	#define R2_END 0x5678
	#define R3_START 0x6789
	#define R3_END 0x789a
	#define R4_START 0x2000
	#define R4_END 0x7000

	static struct resource r0 = { .start = R0_START, .end = R0_END };
	static struct resource r1 = { .start = R1_START, .end = R1_END };
	static struct resource r2 = { .start = R2_START, .end = R2_END };
	static struct resource r3 = { .start = R3_START, .end = R3_END };
	static struct resource r4 = { .start = R4_START, .end = R4_END };

	struct result {
	struct resource *r1;
	struct resource *r2;
	struct resource r;
	bool ret;
	};

	static struct result results_for_union[] = {
	{
	.r1 = &r1, .r2 = &r0, .r.start = R0_START, .r.end = R0_END, .ret = true,
	}, {
	.r1 = &r2, .r2 = &r0, .r.start = R0_START, .r.end = R0_END, .ret = true,
	}, {
	.r1 = &r3, .r2 = &r0, .r.start = R0_START, .r.end = R0_END, .ret = true,
	}, {
	.r1 = &r4, .r2 = &r0, .r.start = R0_START, .r.end = R0_END, .ret = true,
	}, {
	.r1 = &r2, .r2 = &r1, .ret = false,
	}, {
	.r1 = &r3, .r2 = &r1, .ret = false,
	}, {
	.r1 = &r4, .r2 = &r1, .r.start = R1_START, .r.end = R4_END, .ret = true,
	}, {
	.r1 = &r2, .r2 = &r3, .ret = false,
	}, {
	.r1 = &r2, .r2 = &r4, .r.start = R4_START, .r.end = R4_END, .ret = true,
	}, {
	.r1 = &r3, .r2 = &r4, .r.start = R4_START, .r.end = R3_END, .ret = true,
	},
	};

	static struct result results_for_intersection[] = {
	{
	.r1 = &r1, .r2 = &r0, .r.start = R1_START, .r.end = R1_END, .ret = true,
	}, {
	.r1 = &r2, .r2 = &r0, .r.start = R2_START, .r.end = R2_END, .ret = true,
	}, {
	.r1 = &r3, .r2 = &r0, .r.start = R3_START, .r.end = R3_END, .ret = true,
	}, {
	.r1 = &r4, .r2 = &r0, .r.start = R4_START, .r.end = R4_END, .ret = true,
	}, {
	.r1 = &r2, .r2 = &r1, .ret = false,
	}, {
	.r1 = &r3, .r2 = &r1, .ret = false,
	}, {
	.r1 = &r4, .r2 = &r1, .r.start = R4_START, .r.end = R1_END, .ret = true,
	}, {
	.r1 = &r2, .r2 = &r3, .ret = false,
	}, {
	.r1 = &r2, .r2 = &r4, .r.start = R2_START, .r.end = R2_END, .ret = true,
	}, {
	.r1 = &r3, .r2 = &r4, .r.start = R3_START, .r.end = R4_END, .ret = true,
	},
	};

	static void resource_do_test(struct kunit test, bool ret, struct resource r,
	bool exp_ret, struct resource *exp_r,
	struct resource r1, struct resource r2)
	{
	KUNIT_EXPECT_EQ_MSG(test, ret, exp_ret, "Resources %pR %pR", r1, r2);
	KUNIT_EXPECT_EQ_MSG(test, r->start, exp_r->start, "Start elements are not equal");
	KUNIT_EXPECT_EQ_MSG(test, r->end, exp_r->end, "End elements are not equal");
	}

	static void resource_do_union_test(struct kunit test, struct result r)
	{
	struct resource result;
	bool ret;

	memset(&result, 0, sizeof(result));
	ret = resource_union(r->r1, r->r2, &result);
	resource_do_test(test, ret, &result, r->ret, &r->r, r->r1, r->r2);

	memset(&result, 0, sizeof(result));
	ret = resource_union(r->r2, r->r1, &result);
	resource_do_test(test, ret, &result, r->ret, &r->r, r->r2, r->r1);
	}

	static void resource_test_union(struct kunit *test)
	{
	struct result *r = results_for_union;
	unsigned int i = 0;

	do {
	resource_do_union_test(test, &r[i]);
	} while (++i < ARRAY_SIZE(results_for_union));
	}

	static void resource_do_intersection_test(struct kunit test, struct result r)
	{
	struct resource result;
	bool ret;

	memset(&result, 0, sizeof(result));
	ret = resource_intersection(r->r1, r->r2, &result);
	resource_do_test(test, ret, &result, r->ret, &r->r, r->r1, r->r2);

	memset(&result, 0, sizeof(result));
	ret = resource_intersection(r->r2, r->r1, &result);
	resource_do_test(test, ret, &result, r->ret, &r->r, r->r2, r->r1);
	}

	static void resource_test_intersection(struct kunit *test)
	{
	struct result *r = results_for_intersection;
	unsigned int i = 0;

	do {
	resource_do_intersection_test(test, &r[i]);
	} while (++i < ARRAY_SIZE(results_for_intersection));
	}

	/*
	* The test resource tree for region_intersects() test:
	*
	* BASE-BASE+1M-1 : Test System RAM 0
	* # hole 0 (BASE+1M-BASE+2M)
	* BASE+2M-BASE+3M-1 : Test CXL Window 0
	* BASE+3M-BASE+4M-1 : Test System RAM 1
	* BASE+4M-BASE+7M-1 : Test CXL Window 1
	* BASE+4M-BASE+5M-1 : Test System RAM 2
	* BASE+4M+128K-BASE+4M+256K-1: Test Code
	* BASE+5M-BASE+6M-1 : Test System RAM 3
	*/
	#define RES_TEST_RAM0_OFFSET 0
	#define RES_TEST_RAM0_SIZE SZ_1M
	#define RES_TEST_HOLE0_OFFSET (RES_TEST_RAM0_OFFSET + RES_TEST_RAM0_SIZE)
	#define RES_TEST_HOLE0_SIZE SZ_1M
	#define RES_TEST_WIN0_OFFSET (RES_TEST_HOLE0_OFFSET + RES_TEST_HOLE0_SIZE)
	#define RES_TEST_WIN0_SIZE SZ_1M
	#define RES_TEST_RAM1_OFFSET (RES_TEST_WIN0_OFFSET + RES_TEST_WIN0_SIZE)
	#define RES_TEST_RAM1_SIZE SZ_1M
	#define RES_TEST_WIN1_OFFSET (RES_TEST_RAM1_OFFSET + RES_TEST_RAM1_SIZE)
	#define RES_TEST_WIN1_SIZE (SZ_1M * 3)
	#define RES_TEST_RAM2_OFFSET RES_TEST_WIN1_OFFSET
	#define RES_TEST_RAM2_SIZE SZ_1M
	#define RES_TEST_CODE_OFFSET (RES_TEST_RAM2_OFFSET + SZ_128K)
	#define RES_TEST_CODE_SIZE SZ_128K
	#define RES_TEST_RAM3_OFFSET (RES_TEST_RAM2_OFFSET + RES_TEST_RAM2_SIZE)
	#define RES_TEST_RAM3_SIZE SZ_1M
	#define RES_TEST_TOTAL_SIZE ((RES_TEST_WIN1_OFFSET + RES_TEST_WIN1_SIZE))

	static void remove_free_resource(void *ctx)
	{
	struct resource res = (struct resource )ctx;

	remove_resource(res);
	kfree(res);
	}

	static void resource_test_request_region(struct kunit test, struct resource parent,
	resource_size_t start, resource_size_t size,
	const char *name, unsigned long flags)
	{
	struct resource *res;

	res = __request_region(parent, start, size, name, flags);
	KUNIT_ASSERT_NOT_NULL(test, res);
	kunit_add_action_or_reset(test, remove_free_resource, res);
	}

	static void resource_test_insert_resource(struct kunit test, struct resource parent,
	resource_size_t start, resource_size_t size,
	const char *name, unsigned long flags)
	{
	struct resource *res;

	res = kzalloc(sizeof(*res), GFP_KERNEL);
	KUNIT_ASSERT_NOT_NULL(test, res);

	res->name = name;
	res->start = start;
	res->end = start + size - 1;
	res->flags = flags;
	if (insert_resource(parent, res)) {
	kfree(res);
	KUNIT_FAIL_AND_ABORT(test, "Fail to insert resource %pR\n", res);
	}

	kunit_add_action_or_reset(test, remove_free_resource, res);
	}

	static void resource_test_region_intersects(struct kunit *test)
	{
	unsigned long flags = IORESOURCE_SYSTEM_RAM \| IORESOURCE_BUSY;
	struct resource *parent;
	resource_size_t start;

	/* Find an iomem_resource hole to hold test resources */
	parent = alloc_free_mem_region(&iomem_resource, RES_TEST_TOTAL_SIZE, SZ_1M,
	"test resources");
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
	start = parent->start;
	kunit_add_action_or_reset(test, remove_free_resource, parent);

	resource_test_request_region(test, parent, start + RES_TEST_RAM0_OFFSET,
	RES_TEST_RAM0_SIZE, "Test System RAM 0", flags);
	resource_test_insert_resource(test, parent, start + RES_TEST_WIN0_OFFSET,
	RES_TEST_WIN0_SIZE, "Test CXL Window 0",
	IORESOURCE_MEM);
	resource_test_request_region(test, parent, start + RES_TEST_RAM1_OFFSET,
	RES_TEST_RAM1_SIZE, "Test System RAM 1", flags);
	resource_test_insert_resource(test, parent, start + RES_TEST_WIN1_OFFSET,
	RES_TEST_WIN1_SIZE, "Test CXL Window 1",
	IORESOURCE_MEM);
	resource_test_request_region(test, parent, start + RES_TEST_RAM2_OFFSET,
	RES_TEST_RAM2_SIZE, "Test System RAM 2", flags);
	resource_test_insert_resource(test, parent, start + RES_TEST_CODE_OFFSET,
	RES_TEST_CODE_SIZE, "Test Code", flags);
	resource_test_request_region(test, parent, start + RES_TEST_RAM3_OFFSET,
	RES_TEST_RAM3_SIZE, "Test System RAM 3", flags);
	kunit_release_action(test, remove_free_resource, parent);

	KUNIT_EXPECT_EQ(test, REGION_INTERSECTS,
	region_intersects(start + RES_TEST_RAM0_OFFSET, PAGE_SIZE,
	IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
	KUNIT_EXPECT_EQ(test, REGION_INTERSECTS,
	region_intersects(start + RES_TEST_RAM0_OFFSET +
	RES_TEST_RAM0_SIZE - PAGE_SIZE, 2 * PAGE_SIZE,
	IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
	KUNIT_EXPECT_EQ(test, REGION_DISJOINT,
	region_intersects(start + RES_TEST_HOLE0_OFFSET, PAGE_SIZE,
	IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
	KUNIT_EXPECT_EQ(test, REGION_DISJOINT,
	region_intersects(start + RES_TEST_HOLE0_OFFSET +
	RES_TEST_HOLE0_SIZE - PAGE_SIZE, 2 * PAGE_SIZE,
	IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
	KUNIT_EXPECT_EQ(test, REGION_MIXED,
	region_intersects(start + RES_TEST_WIN0_OFFSET +
	RES_TEST_WIN0_SIZE - PAGE_SIZE, 2 * PAGE_SIZE,
	IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
	KUNIT_EXPECT_EQ(test, REGION_INTERSECTS,
	region_intersects(start + RES_TEST_RAM1_OFFSET +
	RES_TEST_RAM1_SIZE - PAGE_SIZE, 2 * PAGE_SIZE,
	IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
	KUNIT_EXPECT_EQ(test, REGION_INTERSECTS,
	region_intersects(start + RES_TEST_RAM2_OFFSET +
	RES_TEST_RAM2_SIZE - PAGE_SIZE, 2 * PAGE_SIZE,
	IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
	KUNIT_EXPECT_EQ(test, REGION_INTERSECTS,
	region_intersects(start + RES_TEST_CODE_OFFSET, PAGE_SIZE,
	IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
	KUNIT_EXPECT_EQ(test, REGION_INTERSECTS,
	region_intersects(start + RES_TEST_RAM2_OFFSET,
	RES_TEST_RAM2_SIZE + PAGE_SIZE,
	IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
	KUNIT_EXPECT_EQ(test, REGION_MIXED,
	region_intersects(start + RES_TEST_RAM3_OFFSET,
	RES_TEST_RAM3_SIZE + PAGE_SIZE,
	IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
	}

	static struct kunit_case resource_test_cases[] = {
	KUNIT_CASE(resource_test_union),
	KUNIT_CASE(resource_test_intersection),
	KUNIT_CASE(resource_test_region_intersects),
	{}
	};

	static struct kunit_suite resource_test_suite = {
	.name = "resource",
	.test_cases = resource_test_cases,
	};
	kunit_test_suite(resource_test_suite);

	MODULE_DESCRIPTION("I/O Port & Memory Resource manager unit tests");
	MODULE_LICENSE("GPL");