~lkcamp/discussion

drm: selftest: Convert to KUnit v1 PROPOSED

Hi,

This RFC is a preview of the progress we made in the KUnit hackathon[0].
This patch, made by Maíra and Arthur, converts the damage helper test
from the original DRM selftest framework to use the KUnit framework.

[0] https://groups.google.com/g/kunit-dev/c/YqFR1q2uZvk/m/IbvItSfHBAAJ

The IGT part of this work can be found here:
https://gitlab.freedesktop.org/isinyaaa/igt-gpu-tools/-/tree/introduce-kunit

We also have patches in progress converting the following tests:
framebuffer, cmdline_parser, dp_mst_helper, rect and dma-buf. As soon as
we sort out if this is the right way to proceed in both kernel and IGT
side, the hackathon participants will submit them.

Below, a dmesg output followed by the IGT output of the damage helper
test.

Thanks!

[   32.502165] [IGT] kms_kunit: executing
[   32.896062]     # Subtest: drm_damage_helper_tests
[   32.896115]     1..21
[   32.906500]     ok 1 - igt_damage_iter_no_damage
[   32.907957]     ok 2 - igt_damage_iter_no_damage_fractional_src
[   32.922087]     ok 3 - igt_damage_iter_no_damage_src_moved
[   32.926174]     ok 4 - igt_damage_iter_no_damage_fractional_src_moved
[   32.931746]     ok 5 - igt_damage_iter_no_damage_not_visible
[   32.935329]     ok 6 - igt_damage_iter_no_damage_no_crtc
[   32.939826]     ok 7 - igt_damage_iter_no_damage_no_fb
[   32.942118]     ok 8 - igt_damage_iter_simple_damage
[   32.944158]     ok 9 - igt_damage_iter_single_damage
[   32.945583]     ok 10 - igt_damage_iter_single_damage_intersect_src
[   32.946565]     ok 11 - igt_damage_iter_single_damage_outside_src
[   32.949206]     ok 12 - igt_damage_iter_single_damage_fractional_src
[   32.952464]     ok 13 - igt_damage_iter_single_damage_intersect_fractional_src
[   32.954321]     ok 14 - igt_damage_iter_single_damage_outside_fractional_src
[   32.957147]     ok 15 - igt_damage_iter_single_damage_src_moved
[   32.959162]     ok 16 - igt_damage_iter_single_damage_fractional_src_moved
[   32.961100]     ok 17 - igt_damage_iter_damage
[   32.963609]     ok 18 - igt_damage_iter_damage_one_intersect
[   32.964913]     ok 19 - igt_damage_iter_damage_one_outside
[   32.966389]     ok 20 - igt_damage_iter_damage_src_moved
[   32.968279]     ok 21 - igt_damage_iter_damage_not_visible
[   32.971710] # drm_damage_helper_tests: pass:21 fail:0 skip:0 total:21
[   32.973887] # Totals: pass:21 fail:0 skip:0 total:21
[   32.975511] ok 1 - drm_damage_helper_tests
[   33.051033] [IGT] kms_kunit: exiting, ret=0

IGT-Version: 1.26-g71e8eceb (x86_64) (Linux: 5.15.0-rc7amd-fix+ x86_64)
[IGT] running 21 tests...
[IGT] SUBTEST ok 1 - igt_damage_iter_no_damage
[IGT] SUBTEST ok 2 - igt_damage_iter_no_damage_fractional_src
[IGT] SUBTEST ok 3 - igt_damage_iter_no_damage_src_moved
[IGT] SUBTEST ok 4 - igt_damage_iter_no_damage_fractional_src_moved
[IGT] SUBTEST ok 5 - igt_damage_iter_no_damage_not_visible
[IGT] SUBTEST ok 6 - igt_damage_iter_no_damage_no_crtc
[IGT] SUBTEST ok 7 - igt_damage_iter_no_damage_no_fb
[IGT] SUBTEST ok 8 - igt_damage_iter_simple_damage
[IGT] SUBTEST ok 9 - igt_damage_iter_single_damage
[IGT] SUBTEST ok 10 - igt_damage_iter_single_damage_intersect_src
[IGT] SUBTEST ok 11 - igt_damage_iter_single_damage_outside_src
[IGT] SUBTEST ok 12 - igt_damage_iter_single_damage_fractional_src
[IGT] SUBTEST ok 13 - igt_damage_iter_single_damage_intersect_fractional_src
[IGT] SUBTEST ok 14 - igt_damage_iter_single_damage_outside_fractional_src
[IGT] SUBTEST ok 15 - igt_damage_iter_single_damage_src_moved
[IGT] SUBTEST ok 16 - igt_damage_iter_single_damage_fractional_src_moved
[IGT] SUBTEST ok 17 - igt_damage_iter_damage
[IGT] SUBTEST ok 18 - igt_damage_iter_damage_one_intersect
[IGT] SUBTEST ok 19 - igt_damage_iter_damage_one_outside
[IGT] SUBTEST ok 20 - igt_damage_iter_damage_src_moved
[IGT] SUBTEST ok 21 - igt_damage_iter_damage_not_visible
[IGT] TEST SUCCEEDED ok 1 - drm_damage_helper_tests
SUCCESS (0.465s) 

Maíra Canal (1):
  drm: selftest: convert drm_damage_helper selftest to KUnit

 drivers/gpu/drm/Kconfig                       |  13 ++
 drivers/gpu/drm/Makefile                      |   2 +-
 drivers/gpu/drm/selftests/Makefile            |   5 +-
 .../gpu/drm/selftests/drm_modeset_selftests.h |  21 --
 .../drm/selftests/test-drm_damage_helper.c    | 215 +++++++++---------
 5 files changed, 127 insertions(+), 129 deletions(-)

-- 
2.33.1
Export patchset (mbox)
How do I use this?

Copy & paste the following snippet into your terminal to import this patchset into git:

curl -s https://lists.sr.ht/~lkcamp/discussion/patches/26377/mbox | git am -3
Learn more about email & git

[RFC PATCH 1/1] drm: selftest: convert drm_damage_helper selftest to KUnit Export this patch

From: Maíra Canal <maira.canal@usp.br>

Considering the current adoption of the KUnit framework, convert the
DRM damage helper selftest to the KUnit API.
Co-developed-by: Arthur Grillo <arthur.grillo@usp.br>
Signed-off-by: Arthur Grillo <arthur.grillo@usp.br>
Signed-off-by: Maíra Canal <maira.canal@usp.br>
Signed-off-by: André Almeida <andrealmeid@collabora.com>
---
 drivers/gpu/drm/Kconfig                       |  13 ++
 drivers/gpu/drm/Makefile                      |   2 +-
 drivers/gpu/drm/selftests/Makefile            |   5 +-
 .../gpu/drm/selftests/drm_modeset_selftests.h |  21 --
 .../drm/selftests/test-drm_damage_helper.c    | 215 +++++++++---------
 5 files changed, 127 insertions(+), 129 deletions(-)

diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig
index cea777ae7fb9..56f6ca74ebb6 100644
--- a/drivers/gpu/drm/Kconfig
+++ b/drivers/gpu/drm/Kconfig
@@ -79,6 +79,19 @@ config DRM_DEBUG_SELFTEST

	  If in doubt, say "N".

config DRM_DAMAGE_HELPER_KUNIT_TEST
	tristate "KUnit tests for DRM damage helper"
	depends on DRM && KUNIT
	select DRM_KMS_HELPER
	default KUNIT_ALL_TESTS
	help
	  This option provides a KUnit module that can be used to run
	  an unit test on the DRM damage helper API. This option is not
	  useful for distributions or general kernels, but only for kernel
	  developers working on DRM and associated drivers.

	  If in doubt, say "N".

config DRM_KMS_HELPER
	tristate
	depends on DRM
diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
index ad1112154898..e632c43c9b7d 100644
--- a/drivers/gpu/drm/Makefile
+++ b/drivers/gpu/drm/Makefile
@@ -58,7 +58,7 @@ drm_kms_helper-$(CONFIG_DRM_DP_AUX_CHARDEV) += drm_dp_aux_dev.o
drm_kms_helper-$(CONFIG_DRM_DP_CEC) += drm_dp_cec.o

obj-$(CONFIG_DRM_KMS_HELPER) += drm_kms_helper.o
obj-$(CONFIG_DRM_DEBUG_SELFTEST) += selftests/
obj-y += selftests/

obj-$(CONFIG_DRM)	+= drm.o
obj-$(CONFIG_DRM_MIPI_DBI) += drm_mipi_dbi.o
diff --git a/drivers/gpu/drm/selftests/Makefile b/drivers/gpu/drm/selftests/Makefile
index 0856e4b12f70..311f6af2caf1 100644
--- a/drivers/gpu/drm/selftests/Makefile
+++ b/drivers/gpu/drm/selftests/Makefile
@@ -1,7 +1,8 @@
# SPDX-License-Identifier: GPL-2.0-only
test-drm_modeset-y := test-drm_modeset_common.o test-drm_plane_helper.o \
                      test-drm_format.o test-drm_framebuffer.o \
		      test-drm_damage_helper.o test-drm_dp_mst_helper.o \
		      test-drm_rect.o
		      test-drm_dp_mst_helper.o test-drm_rect.o

obj-$(CONFIG_DRM_DEBUG_SELFTEST) += test-drm_mm.o test-drm_modeset.o test-drm_cmdline_parser.o

obj-$(CONFIG_DRM_DAMAGE_HELPER_KUNIT_TEST) += test-drm_damage_helper.o
diff --git a/drivers/gpu/drm/selftests/drm_modeset_selftests.h b/drivers/gpu/drm/selftests/drm_modeset_selftests.h
index 782e285ca383..4787b3b70709 100644
--- a/drivers/gpu/drm/selftests/drm_modeset_selftests.h
+++ b/drivers/gpu/drm/selftests/drm_modeset_selftests.h
@@ -15,26 +15,5 @@ selftest(check_drm_format_block_width, igt_check_drm_format_block_width)
selftest(check_drm_format_block_height, igt_check_drm_format_block_height)
selftest(check_drm_format_min_pitch, igt_check_drm_format_min_pitch)
selftest(check_drm_framebuffer_create, igt_check_drm_framebuffer_create)
selftest(damage_iter_no_damage, igt_damage_iter_no_damage)
selftest(damage_iter_no_damage_fractional_src, igt_damage_iter_no_damage_fractional_src)
selftest(damage_iter_no_damage_src_moved, igt_damage_iter_no_damage_src_moved)
selftest(damage_iter_no_damage_fractional_src_moved, igt_damage_iter_no_damage_fractional_src_moved)
selftest(damage_iter_no_damage_not_visible, igt_damage_iter_no_damage_not_visible)
selftest(damage_iter_no_damage_no_crtc, igt_damage_iter_no_damage_no_crtc)
selftest(damage_iter_no_damage_no_fb, igt_damage_iter_no_damage_no_fb)
selftest(damage_iter_simple_damage, igt_damage_iter_simple_damage)
selftest(damage_iter_single_damage, igt_damage_iter_single_damage)
selftest(damage_iter_single_damage_intersect_src, igt_damage_iter_single_damage_intersect_src)
selftest(damage_iter_single_damage_outside_src, igt_damage_iter_single_damage_outside_src)
selftest(damage_iter_single_damage_fractional_src, igt_damage_iter_single_damage_fractional_src)
selftest(damage_iter_single_damage_intersect_fractional_src, igt_damage_iter_single_damage_intersect_fractional_src)
selftest(damage_iter_single_damage_outside_fractional_src, igt_damage_iter_single_damage_outside_fractional_src)
selftest(damage_iter_single_damage_src_moved, igt_damage_iter_single_damage_src_moved)
selftest(damage_iter_single_damage_fractional_src_moved, igt_damage_iter_single_damage_fractional_src_moved)
selftest(damage_iter_damage, igt_damage_iter_damage)
selftest(damage_iter_damage_one_intersect, igt_damage_iter_damage_one_intersect)
selftest(damage_iter_damage_one_outside, igt_damage_iter_damage_one_outside)
selftest(damage_iter_damage_src_moved, igt_damage_iter_damage_src_moved)
selftest(damage_iter_damage_not_visible, igt_damage_iter_damage_not_visible)
selftest(dp_mst_calc_pbn_mode, igt_dp_mst_calc_pbn_mode)
selftest(dp_mst_sideband_msg_req_decode, igt_dp_mst_sideband_msg_req_decode)
diff --git a/drivers/gpu/drm/selftests/test-drm_damage_helper.c b/drivers/gpu/drm/selftests/test-drm_damage_helper.c
index 1c19a5d3eefb..83905661d41e 100644
--- a/drivers/gpu/drm/selftests/test-drm_damage_helper.c
+++ b/drivers/gpu/drm/selftests/test-drm_damage_helper.c
@@ -3,14 +3,11 @@
 * Test case for drm_damage_helper functions
 */

#define pr_fmt(fmt) "drm_damage_helper: " fmt

#include <kunit/test.h>
#include <drm/drm_damage_helper.h>
#include <drm/drm_plane.h>
#include <drm/drm_drv.h>

#include "test-drm_modeset_common.h"

struct drm_driver mock_driver;
static struct drm_device mock_device;
static struct drm_object_properties mock_obj_props;
@@ -114,7 +111,7 @@ const struct drm_framebuffer fb = {
	mock_setup(&old_state); \
	mock_setup(&state);

int igt_damage_iter_no_damage(void *ignored)
static void igt_damage_iter_no_damage(struct kunit *test)
{
	struct drm_atomic_helper_damage_iter iter;
	struct drm_rect clip;
@@ -129,13 +126,12 @@ int igt_damage_iter_no_damage(void *ignored)
	drm_atomic_for_each_plane_damage(&iter, &clip)
		num_hits++;

	FAIL(num_hits != 1, "Should return plane src as damage.");
	FAIL_ON(!check_damage_clip(&state, &clip, 0, 0, 2048, 2048));

	return 0;
	KUNIT_EXPECT_EQ(test, num_hits, 1);
	KUNIT_EXPECT_TRUE(test,
			check_damage_clip(&state, &clip, 0, 0, 2048, 2048));
}

int igt_damage_iter_no_damage_fractional_src(void *ignored)
static void igt_damage_iter_no_damage_fractional_src(struct kunit *test)
{
	struct drm_atomic_helper_damage_iter iter;
	struct drm_rect clip;
@@ -152,13 +148,12 @@ int igt_damage_iter_no_damage_fractional_src(void *ignored)
	drm_atomic_for_each_plane_damage(&iter, &clip)
		num_hits++;

	FAIL(num_hits != 1, "Should return rounded off plane src as damage.");
	FAIL_ON(!check_damage_clip(&state, &clip, 3, 3, 1028, 772));

	return 0;
	KUNIT_EXPECT_EQ(test, num_hits, 1);
	KUNIT_EXPECT_TRUE(test,
			check_damage_clip(&state, &clip, 3, 3, 1028, 772));
}

int igt_damage_iter_no_damage_src_moved(void *ignored)
static void igt_damage_iter_no_damage_src_moved(struct kunit *test)
{
	struct drm_atomic_helper_damage_iter iter;
	struct drm_rect clip;
@@ -174,13 +169,12 @@ int igt_damage_iter_no_damage_src_moved(void *ignored)
	drm_atomic_for_each_plane_damage(&iter, &clip)
		num_hits++;

	FAIL(num_hits != 1, "Should return plane src as damage.");
	FAIL_ON(!check_damage_clip(&state, &clip, 10, 10, 1034, 778));

	return 0;
	KUNIT_EXPECT_EQ(test, num_hits, 1);
	KUNIT_EXPECT_TRUE(test,
			check_damage_clip(&state, &clip, 10, 10, 1034, 778));
}

int igt_damage_iter_no_damage_fractional_src_moved(void *ignored)
static void igt_damage_iter_no_damage_fractional_src_moved(struct kunit *test)
{
	struct drm_atomic_helper_damage_iter iter;
	struct drm_rect clip;
@@ -197,13 +191,11 @@ int igt_damage_iter_no_damage_fractional_src_moved(void *ignored)
	drm_atomic_for_each_plane_damage(&iter, &clip)
		num_hits++;

	FAIL(num_hits != 1, "Should return plane src as damage.");
	FAIL_ON(!check_damage_clip(&state, &clip, 4, 4, 1029, 773));

	return 0;
	KUNIT_EXPECT_EQ(test, num_hits, 1);
	KUNIT_EXPECT_TRUE(test, check_damage_clip(&state, &clip, 4, 4, 1029, 773));
}

int igt_damage_iter_no_damage_not_visible(void *ignored)
static void igt_damage_iter_no_damage_not_visible(struct kunit *test)
{
	struct drm_atomic_helper_damage_iter iter;
	struct drm_rect clip;
@@ -221,12 +213,10 @@ int igt_damage_iter_no_damage_not_visible(void *ignored)
	drm_atomic_for_each_plane_damage(&iter, &clip)
		num_hits++;

	FAIL(num_hits != 0, "Should have no damage.");

	return 0;
	KUNIT_EXPECT_EQ(test, num_hits, 0);
}

int igt_damage_iter_no_damage_no_crtc(void *ignored)
static void igt_damage_iter_no_damage_no_crtc(struct kunit *test)
{
	struct drm_atomic_helper_damage_iter iter;
	struct drm_rect clip;
@@ -242,12 +232,10 @@ int igt_damage_iter_no_damage_no_crtc(void *ignored)
	drm_atomic_for_each_plane_damage(&iter, &clip)
		num_hits++;

	FAIL(num_hits != 0, "Should have no damage.");

	return 0;
	KUNIT_EXPECT_EQ(test, num_hits, 0);
}

int igt_damage_iter_no_damage_no_fb(void *ignored)
static void igt_damage_iter_no_damage_no_fb(struct kunit *test)
{
	struct drm_atomic_helper_damage_iter iter;
	struct drm_plane_state old_state;
@@ -267,12 +255,10 @@ int igt_damage_iter_no_damage_no_fb(void *ignored)
	drm_atomic_for_each_plane_damage(&iter, &clip)
		num_hits++;

	FAIL(num_hits != 0, "Should have no damage.");

	return 0;
	KUNIT_EXPECT_EQ(test, num_hits, 0);
}

int igt_damage_iter_simple_damage(void *ignored)
static void igt_damage_iter_simple_damage(struct kunit *test)
{
	struct drm_atomic_helper_damage_iter iter;
	struct drm_property_blob damage_blob;
@@ -292,13 +278,11 @@ int igt_damage_iter_simple_damage(void *ignored)
	drm_atomic_for_each_plane_damage(&iter, &clip)
		num_hits++;

	FAIL(num_hits != 1, "Should return damage when set.");
	FAIL_ON(!check_damage_clip(&state, &clip, 0, 0, 1024, 768));

	return 0;
	KUNIT_EXPECT_EQ(test, num_hits, 1);
	KUNIT_EXPECT_TRUE(test, check_damage_clip(&state, &clip, 0, 0, 1024, 768));
}

int igt_damage_iter_single_damage(void *ignored)
static void igt_damage_iter_single_damage(struct kunit *test)
{
	struct drm_atomic_helper_damage_iter iter;
	struct drm_property_blob damage_blob;
@@ -317,13 +301,12 @@ int igt_damage_iter_single_damage(void *ignored)
	drm_atomic_for_each_plane_damage(&iter, &clip)
		num_hits++;

	FAIL(num_hits != 1, "Should return damage when set.");
	FAIL_ON(!check_damage_clip(&state, &clip, 256, 192, 768, 576));

	return 0;
	KUNIT_EXPECT_EQ(test, num_hits, 1);
	KUNIT_EXPECT_TRUE(test,
			check_damage_clip(&state, &clip, 256, 192, 768, 576));
}

int igt_damage_iter_single_damage_intersect_src(void *ignored)
static void igt_damage_iter_single_damage_intersect_src(struct kunit *test)
{
	struct drm_atomic_helper_damage_iter iter;
	struct drm_property_blob damage_blob;
@@ -343,13 +326,12 @@ int igt_damage_iter_single_damage_intersect_src(void *ignored)
	drm_atomic_for_each_plane_damage(&iter, &clip)
		num_hits++;

	FAIL(num_hits != 1, "Should return damage clipped to src.");
	FAIL_ON(!check_damage_clip(&state, &clip, 256, 192, 1024, 768));

	return 0;
	KUNIT_EXPECT_EQ(test, num_hits, 1);
	KUNIT_EXPECT_TRUE(test,
			check_damage_clip(&state, &clip, 256, 192, 1024, 768));
}

int igt_damage_iter_single_damage_outside_src(void *ignored)
static void igt_damage_iter_single_damage_outside_src(struct kunit *test)
{
	struct drm_atomic_helper_damage_iter iter;
	struct drm_property_blob damage_blob;
@@ -369,12 +351,10 @@ int igt_damage_iter_single_damage_outside_src(void *ignored)
	drm_atomic_for_each_plane_damage(&iter, &clip)
		num_hits++;

	FAIL(num_hits != 0, "Should have no damage.");

	return 0;
	KUNIT_EXPECT_EQ(test, num_hits, 0);
}

int igt_damage_iter_single_damage_fractional_src(void *ignored)
static void igt_damage_iter_single_damage_fractional_src(struct kunit *test)
{
	struct drm_atomic_helper_damage_iter iter;
	struct drm_property_blob damage_blob;
@@ -396,13 +376,13 @@ int igt_damage_iter_single_damage_fractional_src(void *ignored)
	drm_atomic_for_each_plane_damage(&iter, &clip)
		num_hits++;

	FAIL(num_hits != 1, "Should return damage when set.");
	FAIL_ON(!check_damage_clip(&state, &clip, 10, 10, 256, 330));

	return 0;
	KUNIT_EXPECT_EQ(test, num_hits, 1);
	KUNIT_EXPECT_TRUE(test,
			check_damage_clip(&state, &clip, 10, 10, 256, 330));
}

int igt_damage_iter_single_damage_intersect_fractional_src(void *ignored)
static void igt_damage_iter_single_damage_intersect_fractional_src(
		struct kunit *test)
{
	struct drm_atomic_helper_damage_iter iter;
	struct drm_property_blob damage_blob;
@@ -425,13 +405,13 @@ int igt_damage_iter_single_damage_intersect_fractional_src(void *ignored)
	drm_atomic_for_each_plane_damage(&iter, &clip)
		num_hits++;

	FAIL(num_hits != 1, "Should return damage clipped to rounded off src.");
	FAIL_ON(!check_damage_clip(&state, &clip, 10, 4, 1029, 330));

	return 0;
	KUNIT_EXPECT_EQ(test, num_hits, 1);
	KUNIT_EXPECT_TRUE(test,
			check_damage_clip(&state, &clip, 10, 4, 1029, 330));
}

int igt_damage_iter_single_damage_outside_fractional_src(void *ignored)
static void igt_damage_iter_single_damage_outside_fractional_src(
		struct kunit *test)
{
	struct drm_atomic_helper_damage_iter iter;
	struct drm_property_blob damage_blob;
@@ -454,12 +434,10 @@ int igt_damage_iter_single_damage_outside_fractional_src(void *ignored)
	drm_atomic_for_each_plane_damage(&iter, &clip)
		num_hits++;

	FAIL(num_hits != 0, "Should have no damage.");

	return 0;
	KUNIT_EXPECT_EQ(test, num_hits, 0);
}

int igt_damage_iter_single_damage_src_moved(void *ignored)
static void igt_damage_iter_single_damage_src_moved(struct kunit *test)
{
	struct drm_atomic_helper_damage_iter iter;
	struct drm_property_blob damage_blob;
@@ -480,13 +458,13 @@ int igt_damage_iter_single_damage_src_moved(void *ignored)
	drm_atomic_for_each_plane_damage(&iter, &clip)
		num_hits++;

	FAIL(num_hits != 1, "Should return plane src as damage.");
	FAIL_ON(!check_damage_clip(&state, &clip, 10, 10, 1034, 778));

	return 0;
	KUNIT_EXPECT_EQ(test, num_hits, 1);
	KUNIT_EXPECT_TRUE(test,
			check_damage_clip(&state, &clip, 10, 10, 1034, 778));
}

int igt_damage_iter_single_damage_fractional_src_moved(void *ignored)
static void igt_damage_iter_single_damage_fractional_src_moved(
		struct kunit *test)
{
	struct drm_atomic_helper_damage_iter iter;
	struct drm_property_blob damage_blob;
@@ -509,13 +487,11 @@ int igt_damage_iter_single_damage_fractional_src_moved(void *ignored)
	drm_atomic_for_each_plane_damage(&iter, &clip)
		num_hits++;

	FAIL(num_hits != 1, "Should return rounded off plane src as damage.");
	FAIL_ON(!check_damage_clip(&state, &clip, 4, 4, 1029, 773));

	return 0;
	KUNIT_EXPECT_EQ(test, num_hits, 1);
	KUNIT_EXPECT_TRUE(test, check_damage_clip(&state, &clip, 4, 4, 1029, 773));
}

int igt_damage_iter_damage(void *ignored)
static void igt_damage_iter_damage(struct kunit *test)
{
	struct drm_atomic_helper_damage_iter iter;
	struct drm_property_blob damage_blob;
@@ -535,18 +511,18 @@ int igt_damage_iter_damage(void *ignored)
	drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
	drm_atomic_for_each_plane_damage(&iter, &clip) {
		if (num_hits == 0)
			FAIL_ON(!check_damage_clip(&state, &clip, 20, 30, 200, 180));
			KUNIT_EXPECT_TRUE(test,
					check_damage_clip(&state, &clip, 20, 30, 200, 180));
		if (num_hits == 1)
			FAIL_ON(!check_damage_clip(&state, &clip, 240, 200, 280, 250));
			KUNIT_EXPECT_TRUE(test,
					check_damage_clip(&state, &clip, 240, 200, 280, 250));
		num_hits++;
	}

	FAIL(num_hits != 2, "Should return damage when set.");

	return 0;
	KUNIT_EXPECT_EQ(test, num_hits, 2);
}

int igt_damage_iter_damage_one_intersect(void *ignored)
static void igt_damage_iter_damage_one_intersect(struct kunit *test)
{
	struct drm_atomic_helper_damage_iter iter;
	struct drm_property_blob damage_blob;
@@ -568,18 +544,18 @@ int igt_damage_iter_damage_one_intersect(void *ignored)
	drm_atomic_helper_damage_iter_init(&iter, &old_state, &state);
	drm_atomic_for_each_plane_damage(&iter, &clip) {
		if (num_hits == 0)
			FAIL_ON(!check_damage_clip(&state, &clip, 20, 30, 200, 180));
			KUNIT_EXPECT_TRUE(test,
					check_damage_clip(&state, &clip, 20, 30, 200, 180));
		if (num_hits == 1)
			FAIL_ON(!check_damage_clip(&state, &clip, 4, 4, 1029, 773));
			KUNIT_EXPECT_TRUE(test,
					check_damage_clip(&state, &clip, 4, 4, 1029, 773));
		num_hits++;
	}

	FAIL(num_hits != 2, "Should return damage when set.");

	return 0;
	KUNIT_EXPECT_EQ(test, num_hits, 2);
}

int igt_damage_iter_damage_one_outside(void *ignored)
static void igt_damage_iter_damage_one_outside(struct kunit *test)
{
	struct drm_atomic_helper_damage_iter iter;
	struct drm_property_blob damage_blob;
@@ -600,13 +576,12 @@ int igt_damage_iter_damage_one_outside(void *ignored)
	drm_atomic_for_each_plane_damage(&iter, &clip)
		num_hits++;

	FAIL(num_hits != 1, "Should return damage when set.");
	FAIL_ON(!check_damage_clip(&state, &clip, 240, 200, 280, 250));

	return 0;
	KUNIT_EXPECT_EQ(test, num_hits, 1);
	KUNIT_EXPECT_TRUE(test,
			check_damage_clip(&state, &clip, 240, 200, 280, 250));
}

int igt_damage_iter_damage_src_moved(void *ignored)
static void igt_damage_iter_damage_src_moved(struct kunit *test)
{
	struct drm_atomic_helper_damage_iter iter;
	struct drm_property_blob damage_blob;
@@ -629,13 +604,11 @@ int igt_damage_iter_damage_src_moved(void *ignored)
	drm_atomic_for_each_plane_damage(&iter, &clip)
		num_hits++;

	FAIL(num_hits != 1, "Should return round off plane src as damage.");
	FAIL_ON(!check_damage_clip(&state, &clip, 3, 3, 1028, 772));

	return 0;
	KUNIT_EXPECT_EQ(test, num_hits, 1);
	KUNIT_EXPECT_TRUE(test, check_damage_clip(&state, &clip, 3, 3, 1028, 772));
}

int igt_damage_iter_damage_not_visible(void *ignored)
static void igt_damage_iter_damage_not_visible(struct kunit *test)
{
	struct drm_atomic_helper_damage_iter iter;
	struct drm_property_blob damage_blob;
@@ -660,7 +633,39 @@ int igt_damage_iter_damage_not_visible(void *ignored)
	drm_atomic_for_each_plane_damage(&iter, &clip)
		num_hits++;

	FAIL(num_hits != 0, "Should not return any damage.");

	return 0;
	KUNIT_EXPECT_EQ(test, num_hits, 0);
}

static struct kunit_case drm_damage_helper_tests[] = {
	KUNIT_CASE(igt_damage_iter_no_damage),
	KUNIT_CASE(igt_damage_iter_no_damage_fractional_src),
	KUNIT_CASE(igt_damage_iter_no_damage_src_moved),
	KUNIT_CASE(igt_damage_iter_no_damage_fractional_src_moved),
	KUNIT_CASE(igt_damage_iter_no_damage_not_visible),
	KUNIT_CASE(igt_damage_iter_no_damage_no_crtc),
	KUNIT_CASE(igt_damage_iter_no_damage_no_fb),
	KUNIT_CASE(igt_damage_iter_simple_damage),
	KUNIT_CASE(igt_damage_iter_single_damage),
	KUNIT_CASE(igt_damage_iter_single_damage_intersect_src),
	KUNIT_CASE(igt_damage_iter_single_damage_outside_src),
	KUNIT_CASE(igt_damage_iter_single_damage_fractional_src),
	KUNIT_CASE(igt_damage_iter_single_damage_intersect_fractional_src),
	KUNIT_CASE(igt_damage_iter_single_damage_outside_fractional_src),
	KUNIT_CASE(igt_damage_iter_single_damage_src_moved),
	KUNIT_CASE(igt_damage_iter_single_damage_fractional_src_moved),
	KUNIT_CASE(igt_damage_iter_damage),
	KUNIT_CASE(igt_damage_iter_damage_one_intersect),
	KUNIT_CASE(igt_damage_iter_damage_one_outside),
	KUNIT_CASE(igt_damage_iter_damage_src_moved),
	KUNIT_CASE(igt_damage_iter_damage_not_visible),
	{ }
};

static struct kunit_suite drm_damage_helper_test_suite = {
	.name = "drm_damage_helper_tests",
	.test_cases = drm_damage_helper_tests,
};

kunit_test_suite(drm_damage_helper_test_suite);

MODULE_LICENSE("GPL");
-- 
2.33.1