lib/kunit/platform-test.c

// SPDX-License-Identifier: GPL-2.0
/*
 * KUnit test for KUnit platform driver infrastructure.
 */

#include <linux/platform_device.h>

#include <kunit/platform_device.h>
#include <kunit/test.h>

/*
 * Test that kunit_platform_device_alloc() creates a platform device.
 */
static void kunit_platform_device_alloc_test(struct kunit *test)
{
	KUNIT_EXPECT_NOT_ERR_OR_NULL(test,
			kunit_platform_device_alloc(test, "kunit-platform", 1));
}

/*
 * Test that kunit_platform_device_add() registers a platform device on the
 * platform bus with the proper name and id.
 */
static void kunit_platform_device_add_test(struct kunit *test)
{
	struct platform_device *pdev;
	const char *name = "kunit-platform-add";
	const int id = -1;

	pdev = kunit_platform_device_alloc(test, name, id);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev);

	KUNIT_EXPECT_EQ(test, 0, kunit_platform_device_add(test, pdev));
	KUNIT_EXPECT_TRUE(test, dev_is_platform(&pdev->dev));
	KUNIT_EXPECT_STREQ(test, pdev->name, name);
	KUNIT_EXPECT_EQ(test, pdev->id, id);
}

/*
 * Test that kunit_platform_device_add() called twice with the same device name
 * and id fails the second time and properly cleans up.
 */
static void kunit_platform_device_add_twice_fails_test(struct kunit *test)
{
	struct platform_device *pdev;
	const char *name = "kunit-platform-add-2";
	const int id = -1;

	pdev = kunit_platform_device_alloc(test, name, id);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev);
	KUNIT_ASSERT_EQ(test, 0, kunit_platform_device_add(test, pdev));

	pdev = kunit_platform_device_alloc(test, name, id);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev);

	KUNIT_EXPECT_NE(test, 0, kunit_platform_device_add(test, pdev));
}

static int kunit_platform_device_find_by_name(struct device *dev, const void *data)
{
	return strcmp(dev_name(dev), data) == 0;
}

/*
 * Test that kunit_platform_device_add() cleans up by removing the platform
 * device when the test finishes. */
static void kunit_platform_device_add_cleans_up(struct kunit *test)
{
	struct platform_device *pdev;
	const char *name = "kunit-platform-clean";
	const int id = -1;
	struct kunit fake;
	struct device *dev;

	kunit_init_test(&fake, "kunit_platform_device_add_fake_test", NULL);
	KUNIT_ASSERT_EQ(test, fake.status, KUNIT_SUCCESS);

	pdev = kunit_platform_device_alloc(&fake, name, id);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev);
	KUNIT_ASSERT_EQ(test, 0, kunit_platform_device_add(&fake, pdev));
	dev = bus_find_device(&platform_bus_type, NULL, name,
			      kunit_platform_device_find_by_name);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
	put_device(dev);

	/* Remove pdev */
	kunit_cleanup(&fake);

	/*
	 * Failing to migrate the kunit_resource would lead to an extra
	 * put_device() call on the platform device. The best we can do here is
	 * make sure the device no longer exists on the bus, but if something
	 * is wrong we'll see a refcount underflow here. We can't test for a
	 * refcount underflow because the kref matches the lifetime of the
	 * device which should already be freed and could be used by something
	 * else.
	 */
	dev = bus_find_device(&platform_bus_type, NULL, name,
			      kunit_platform_device_find_by_name);
	KUNIT_EXPECT_PTR_EQ(test, NULL, dev);
	put_device(dev);
}

/*
 * Test suite for struct platform_device kunit APIs
 */
static struct kunit_case kunit_platform_device_test_cases[] = {
	KUNIT_CASE(kunit_platform_device_alloc_test),
	KUNIT_CASE(kunit_platform_device_add_test),
	KUNIT_CASE(kunit_platform_device_add_twice_fails_test),
	KUNIT_CASE(kunit_platform_device_add_cleans_up),
	{}
};

static struct kunit_suite kunit_platform_device_suite = {
	.name = "kunit_platform_device",
	.test_cases = kunit_platform_device_test_cases,
};

struct kunit_platform_driver_test_context {
	struct platform_driver pdrv;
	const char *data;
};

static const char * const test_data = "test data";

static inline struct kunit_platform_driver_test_context *
to_test_context(struct platform_device *pdev)
{
	return container_of(to_platform_driver(pdev->dev.driver),
			    struct kunit_platform_driver_test_context,
			    pdrv);
}

static int kunit_platform_driver_probe(struct platform_device *pdev)
{
	struct kunit_platform_driver_test_context *ctx;

	ctx = to_test_context(pdev);
	ctx->data = test_data;

	return 0;
}

/* Test that kunit_platform_driver_register() registers a driver that probes. */
static void kunit_platform_driver_register_test(struct kunit *test)
{
	struct platform_device *pdev;
	struct kunit_platform_driver_test_context *ctx;
	DECLARE_COMPLETION_ONSTACK(comp);
	const char *name = "kunit-platform-register";

	ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);

	pdev = kunit_platform_device_alloc(test, name, -1);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev);
	KUNIT_ASSERT_EQ(test, 0, kunit_platform_device_add(test, pdev));

	ctx->pdrv.probe = kunit_platform_driver_probe;
	ctx->pdrv.driver.name = name;
	ctx->pdrv.driver.owner = THIS_MODULE;

	KUNIT_ASSERT_EQ(test, 0, kunit_platform_device_prepare_wait_for_probe(test, pdev, &comp));

	KUNIT_EXPECT_EQ(test, 0, kunit_platform_driver_register(test, &ctx->pdrv));
	KUNIT_EXPECT_NE(test, 0, wait_for_completion_timeout(&comp, 3 * HZ));
	KUNIT_EXPECT_STREQ(test, ctx->data, test_data);
}

/*
 * Test that kunit_platform_device_prepare_wait_for_probe() completes the completion
 * when the device is already probed.
 */
static void kunit_platform_device_prepare_wait_for_probe_completes_when_already_probed(struct kunit *test)
{
	struct platform_device *pdev;
	struct kunit_platform_driver_test_context *ctx;
	DECLARE_COMPLETION_ONSTACK(comp);
	const char *name = "kunit-platform-wait";

	ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);

	pdev = kunit_platform_device_alloc(test, name, -1);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev);
	KUNIT_ASSERT_EQ(test, 0, kunit_platform_device_add(test, pdev));

	ctx->pdrv.probe = kunit_platform_driver_probe;
	ctx->pdrv.driver.name = name;
	ctx->pdrv.driver.owner = THIS_MODULE;

	/* Make sure driver has actually probed */
	KUNIT_ASSERT_EQ(test, 0, kunit_platform_device_prepare_wait_for_probe(test, pdev, &comp));
	KUNIT_ASSERT_EQ(test, 0, kunit_platform_driver_register(test, &ctx->pdrv));
	KUNIT_ASSERT_NE(test, 0, wait_for_completion_timeout(&comp, 3 * HZ));

	reinit_completion(&comp);
	KUNIT_ASSERT_EQ(test, 0, kunit_platform_device_prepare_wait_for_probe(test, pdev, &comp));

	KUNIT_EXPECT_NE(test, 0, wait_for_completion_timeout(&comp, HZ));
}

static struct kunit_case kunit_platform_driver_test_cases[] = {
	KUNIT_CASE(kunit_platform_driver_register_test),
	KUNIT_CASE(kunit_platform_device_prepare_wait_for_probe_completes_when_already_probed),
	{}
};

/*
 * Test suite for struct platform_driver kunit APIs
 */
static struct kunit_suite kunit_platform_driver_suite = {
	.name = "kunit_platform_driver",
	.test_cases = kunit_platform_driver_test_cases,
};

kunit_test_suites(
	&kunit_platform_device_suite,
	&kunit_platform_driver_suite,
);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("KUnit test for KUnit platform driver infrastructure");