drivers/of/base-test.c - linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0
 /*
  * Unit tests for functions defined in base.c.
  */
 #include <linux/of.h>

 #include <kunit/test.h>

 #include "test-common.h"

 static void of_test_find_node_by_name_basic(struct kunit *test)
 {
 	struct device_node *np;
 	const char *name;

 	np = of_find_node_by_path("/testcase-data");
 	name = kasprintf(GFP_KERNEL, "%pOF", np);
 	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
 	KUNIT_EXPECT_STREQ_MSG(test, "/testcase-data", name,
 			       "find /testcase-data failed\n");
 	of_node_put(np);
 	kfree(name);
 }

 static void of_test_find_node_by_name_trailing_slash(struct kunit *test)
 {
 	/* Test if trailing '/' works */
 	KUNIT_EXPECT_EQ_MSG(test, of_find_node_by_path("/testcase-data/"), NULL,
 			    "trailing '/' on /testcase-data/ should fail\n");

 }

 static void of_test_find_node_by_name_multiple_components(struct kunit *test)
 {
 	struct device_node *np;
 	const char *name;

 	np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-a");
 	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
 	name = kasprintf(GFP_KERNEL, "%pOF", np);
 	KUNIT_EXPECT_STREQ_MSG(test,
 			       "/testcase-data/phandle-tests/consumer-a", name,
 			       "find /testcase-data/phandle-tests/consumer-a failed\n");
 	of_node_put(np);
 	kfree(name);
 }

 static void of_test_find_node_by_name_with_alias(struct kunit *test)
 {
 	struct device_node *np;
 	const char *name;

 	np = of_find_node_by_path("testcase-alias");
 	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
 	name = kasprintf(GFP_KERNEL, "%pOF", np);
 	KUNIT_EXPECT_STREQ_MSG(test, "/testcase-data", name,
 			       "find testcase-alias failed\n");
 	of_node_put(np);
 	kfree(name);
 }

 static void of_test_find_node_by_name_with_alias_and_slash(struct kunit *test)
 {
 	/* Test if trailing '/' works on aliases */
 	KUNIT_EXPECT_EQ_MSG(test, of_find_node_by_path("testcase-alias/"), NULL,
 			   "trailing '/' on testcase-alias/ should fail\n");
 }

 /*
  * TODO(brendanhiggins@google.com): This looks like a duplicate of
  * of_test_find_node_by_name_multiple_components
  */
 static void of_test_find_node_by_name_multiple_components_2(struct kunit *test)
 {
 	struct device_node *np;
 	const char *name;

 	np = of_find_node_by_path("testcase-alias/phandle-tests/consumer-a");
 	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
 	name = kasprintf(GFP_KERNEL, "%pOF", np);
 	KUNIT_EXPECT_STREQ_MSG(test,
 			       "/testcase-data/phandle-tests/consumer-a", name,
 			       "find testcase-alias/phandle-tests/consumer-a failed\n");
 	of_node_put(np);
 	kfree(name);
 }

 static void of_test_find_node_by_name_missing_path(struct kunit *test)
 {
 	struct device_node *np;

 	KUNIT_EXPECT_EQ_MSG(test,
 			    np = of_find_node_by_path(
 					    "/testcase-data/missing-path"),
 			    NULL,
 			   "non-existent path returned node %pOF\n", np);
 	of_node_put(np);
 }

 static void of_test_find_node_by_name_missing_alias(struct kunit *test)
 {
 	struct device_node *np;

 	KUNIT_EXPECT_EQ_MSG(test,
 			    np = of_find_node_by_path("missing-alias"), NULL,
 			   "non-existent alias returned node %pOF\n", np);
 	of_node_put(np);
 }

 static void of_test_find_node_by_name_missing_alias_with_relative_path(
 		struct kunit *test)
 {
 	struct device_node *np;

 	KUNIT_EXPECT_EQ_MSG(test,
 			    np = of_find_node_by_path(
 					    "testcase-alias/missing-path"),
 			    NULL,
 			   "non-existent alias with relative path returned node %pOF\n",
 			   np);
 	of_node_put(np);
 }

 static void of_test_find_node_by_name_with_option(struct kunit *test)
 {
 	struct device_node *np;
 	const char *options;

 	np = of_find_node_opts_by_path("/testcase-data:testoption", &options);
 	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
 	KUNIT_EXPECT_STREQ_MSG(test, "testoption", options,
 			       "option path test failed\n");
 	of_node_put(np);
 }

 static void of_test_find_node_by_name_with_option_and_slash(struct kunit *test)
 {
 	struct device_node *np;
 	const char *options;

 	np = of_find_node_opts_by_path("/testcase-data:test/option", &options);
 	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
 	KUNIT_EXPECT_STREQ_MSG(test, "test/option", options,
 			       "option path test, subcase #1 failed\n");
 	of_node_put(np);

 	np = of_find_node_opts_by_path(
 			"/testcase-data/testcase-device1:test/option",
 			&options);
 	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
 	KUNIT_EXPECT_STREQ_MSG(test, "test/option", options,
 			       "option path test, subcase #2 failed\n");
 	of_node_put(np);
 }

 static void of_test_find_node_by_name_with_null_option(struct kunit *test)
 {
 	struct device_node *np;

 	np = of_find_node_opts_by_path("/testcase-data:testoption", NULL);
 	KUNIT_EXPECT_NOT_ERR_OR_NULL_MSG(test, np,
 					 "NULL option path test failed\n");
 	of_node_put(np);
 }

 static void of_test_find_node_by_name_with_option_alias(struct kunit *test)
 {
 	struct device_node *np;
 	const char *options;

 	np = of_find_node_opts_by_path("testcase-alias:testaliasoption",
 				       &options);
 	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
 	KUNIT_EXPECT_STREQ_MSG(test, "testaliasoption", options,
 			       "option alias path test failed\n");
 	of_node_put(np);
 }

 static void of_test_find_node_by_name_with_option_alias_and_slash(
 		struct kunit *test)
 {
 	struct device_node *np;
 	const char *options;

 	np = of_find_node_opts_by_path("testcase-alias:test/alias/option",
 				       &options);
 	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
 	KUNIT_EXPECT_STREQ_MSG(test, "test/alias/option", options,
 			       "option alias path test, subcase #1 failed\n");
 	of_node_put(np);
 }

 static void of_test_find_node_by_name_with_null_option_alias(struct kunit *test)
 {
 	struct device_node *np;

 	np = of_find_node_opts_by_path("testcase-alias:testaliasoption", NULL);
 	KUNIT_EXPECT_NOT_ERR_OR_NULL_MSG(
 			test, np, "NULL option alias path test failed\n");
 	of_node_put(np);
 }

 static void of_test_find_node_by_name_option_clearing(struct kunit *test)
 {
 	struct device_node *np;
 	const char *options;

 	options = "testoption";
 	np = of_find_node_opts_by_path("testcase-alias", &options);
 	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
 	KUNIT_EXPECT_EQ_MSG(test, options, NULL,
 			    "option clearing test failed\n");
 	of_node_put(np);
 }

 static void of_test_find_node_by_name_option_clearing_root(struct kunit *test)
 {
 	struct device_node *np;
 	const char *options;

 	options = "testoption";
 	np = of_find_node_opts_by_path("/", &options);
 	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
 	KUNIT_EXPECT_EQ_MSG(test, options, NULL,
 			    "option clearing root node test failed\n");
 	of_node_put(np);
 }

 static int of_test_find_node_by_name_init(struct kunit *test)
 {
 	/* adding data for unittest */
 	KUNIT_ASSERT_EQ(test, 0, unittest_data_add());

 	if (!of_aliases)
 		of_aliases = of_find_node_by_path("/aliases");

 	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, of_find_node_by_path(
 			"/testcase-data/phandle-tests/consumer-a"));

 	return 0;
 }

 static struct kunit_case of_test_find_node_by_name_cases[] = {
 	KUNIT_CASE(of_test_find_node_by_name_basic),
 	KUNIT_CASE(of_test_find_node_by_name_trailing_slash),
 	KUNIT_CASE(of_test_find_node_by_name_multiple_components),
 	KUNIT_CASE(of_test_find_node_by_name_with_alias),
 	KUNIT_CASE(of_test_find_node_by_name_with_alias_and_slash),
 	KUNIT_CASE(of_test_find_node_by_name_multiple_components_2),
 	KUNIT_CASE(of_test_find_node_by_name_missing_path),
 	KUNIT_CASE(of_test_find_node_by_name_missing_alias),
 	KUNIT_CASE(of_test_find_node_by_name_missing_alias_with_relative_path),
 	KUNIT_CASE(of_test_find_node_by_name_with_option),
 	KUNIT_CASE(of_test_find_node_by_name_with_option_and_slash),
 	KUNIT_CASE(of_test_find_node_by_name_with_null_option),
 	KUNIT_CASE(of_test_find_node_by_name_with_option_alias),
 	KUNIT_CASE(of_test_find_node_by_name_with_option_alias_and_slash),
 	KUNIT_CASE(of_test_find_node_by_name_with_null_option_alias),
 	KUNIT_CASE(of_test_find_node_by_name_option_clearing),
 	KUNIT_CASE(of_test_find_node_by_name_option_clearing_root),
 	{},
 };

 static struct kunit_module of_test_find_node_by_name_module = {
 	.name = "of-test-find-node-by-name",
 	.init = of_test_find_node_by_name_init,
 	.test_cases = of_test_find_node_by_name_cases,
 };
 module_test(of_test_find_node_by_name_module);

 struct of_test_dynamic_context {
 	struct device_node *np;
 	struct property *prop0;
 	struct property *prop1;
 };

 static void of_test_dynamic_basic(struct kunit *test)
 {
 	struct of_test_dynamic_context *ctx = test->priv;
 	struct device_node *np = ctx->np;
 	struct property *prop0 = ctx->prop0;

 	/* Add a new property - should pass*/
 	prop0->name = "new-property";
 	prop0->value = "new-property-data";
 	prop0->length = strlen(prop0->value) + 1;
 	KUNIT_EXPECT_EQ_MSG(test, of_add_property(np, prop0), 0,
 			    "Adding a new property failed\n");

 	/* Test that we can remove a property */
 	KUNIT_EXPECT_EQ(test, of_remove_property(np, prop0), 0);
 }

 static void of_test_dynamic_add_existing_property(struct kunit *test)
 {
 	struct of_test_dynamic_context *ctx = test->priv;
 	struct device_node *np = ctx->np;
 	struct property *prop0 = ctx->prop0, *prop1 = ctx->prop1;

 	/* Add a new property - should pass*/
 	prop0->name = "new-property";
 	prop0->value = "new-property-data";
 	prop0->length = strlen(prop0->value) + 1;
 	KUNIT_EXPECT_EQ_MSG(test, of_add_property(np, prop0), 0,
 			    "Adding a new property failed\n");

 	/* Try to add an existing property - should fail */
 	prop1->name = "new-property";
 	prop1->value = "new-property-data-should-fail";
 	prop1->length = strlen(prop1->value) + 1;
 	KUNIT_EXPECT_NE_MSG(test, of_add_property(np, prop1), 0,
 			    "Adding an existing property should have failed\n");
 }

 static void of_test_dynamic_modify_existing_property(struct kunit *test)
 {
 	struct of_test_dynamic_context *ctx = test->priv;
 	struct device_node *np = ctx->np;
 	struct property *prop0 = ctx->prop0, *prop1 = ctx->prop1;

 	/* Add a new property - should pass*/
 	prop0->name = "new-property";
 	prop0->value = "new-property-data";
 	prop0->length = strlen(prop0->value) + 1;
 	KUNIT_EXPECT_EQ_MSG(test, of_add_property(np, prop0), 0,
 			    "Adding a new property failed\n");

 	/* Try to modify an existing property - should pass */
 	prop1->name = "new-property";
 	prop1->value = "modify-property-data-should-pass";
 	prop1->length = strlen(prop1->value) + 1;
 	KUNIT_EXPECT_EQ_MSG(test, of_update_property(np, prop1), 0,
 			    "Updating an existing property should have passed\n");
 }

 static void of_test_dynamic_modify_non_existent_property(struct kunit *test)
 {
 	struct of_test_dynamic_context *ctx = test->priv;
 	struct device_node *np = ctx->np;
 	struct property *prop0 = ctx->prop0;

 	/* Try to modify non-existent property - should pass*/
 	prop0->name = "modify-property";
 	prop0->value = "modify-missing-property-data-should-pass";
 	prop0->length = strlen(prop0->value) + 1;
 	KUNIT_EXPECT_EQ_MSG(test, of_update_property(np, prop0), 0,
 			    "Updating a missing property should have passed\n");
 }

 static void of_test_dynamic_large_property(struct kunit *test)
 {
 	struct of_test_dynamic_context *ctx = test->priv;
 	struct device_node *np = ctx->np;
 	struct property *prop0 = ctx->prop0;

 	/* Adding very large property - should pass */
 	prop0->name = "large-property-PAGE_SIZEx8";
 	prop0->length = PAGE_SIZE * 8;
 	prop0->value = kunit_kzalloc(test, prop0->length, GFP_KERNEL);
 	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, prop0->value);

 	KUNIT_EXPECT_EQ_MSG(test, of_add_property(np, prop0), 0,
 			    "Adding a large property should have passed\n");
 }

 static int of_test_dynamic_init(struct kunit *test)
 {
 	struct of_test_dynamic_context *ctx;

 	KUNIT_ASSERT_EQ(test, 0, unittest_data_add());

 	if (!of_aliases)
 		of_aliases = of_find_node_by_path("/aliases");

 	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, of_find_node_by_path(
 			"/testcase-data/phandle-tests/consumer-a"));

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

 	ctx->np = of_find_node_by_path("/testcase-data");
 	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx->np);

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

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

 	return 0;
 }

 static void of_test_dynamic_exit(struct kunit *test)
 {
 	struct of_test_dynamic_context *ctx = test->priv;
 	struct device_node *np = ctx->np;

 	of_remove_property(np, ctx->prop0);
 	of_remove_property(np, ctx->prop1);
 	of_node_put(np);
 }

 static struct kunit_case of_test_dynamic_cases[] = {
 	KUNIT_CASE(of_test_dynamic_basic),
 	KUNIT_CASE(of_test_dynamic_add_existing_property),
 	KUNIT_CASE(of_test_dynamic_modify_existing_property),
 	KUNIT_CASE(of_test_dynamic_modify_non_existent_property),
 	KUNIT_CASE(of_test_dynamic_large_property),
 	{},
 };

 static struct kunit_module of_test_dynamic_module = {
 	.name = "of-dynamic-test",
 	.init = of_test_dynamic_init,
 	.exit = of_test_dynamic_exit,
 	.test_cases = of_test_dynamic_cases,
 };
 module_test(of_test_dynamic_module);
	// SPDX-License-Identifier: GPL-2.0
	/*
	* Unit tests for functions defined in base.c.
	*/
	#include <linux/of.h>

	#include <kunit/test.h>

	#include "test-common.h"

	static void of_test_find_node_by_name_basic(struct kunit *test)
	{
	struct device_node *np;
	const char *name;

	np = of_find_node_by_path("/testcase-data");
	name = kasprintf(GFP_KERNEL, "%pOF", np);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
	KUNIT_EXPECT_STREQ_MSG(test, "/testcase-data", name,
	"find /testcase-data failed\n");
	of_node_put(np);
	kfree(name);
	}

	static void of_test_find_node_by_name_trailing_slash(struct kunit *test)
	{
	/* Test if trailing '/' works */
	KUNIT_EXPECT_EQ_MSG(test, of_find_node_by_path("/testcase-data/"), NULL,
	"trailing '/' on /testcase-data/ should fail\n");

	}

	static void of_test_find_node_by_name_multiple_components(struct kunit *test)
	{
	struct device_node *np;
	const char *name;

	np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-a");
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
	name = kasprintf(GFP_KERNEL, "%pOF", np);
	KUNIT_EXPECT_STREQ_MSG(test,
	"/testcase-data/phandle-tests/consumer-a", name,
	"find /testcase-data/phandle-tests/consumer-a failed\n");
	of_node_put(np);
	kfree(name);
	}

	static void of_test_find_node_by_name_with_alias(struct kunit *test)
	{
	struct device_node *np;
	const char *name;

	np = of_find_node_by_path("testcase-alias");
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
	name = kasprintf(GFP_KERNEL, "%pOF", np);
	KUNIT_EXPECT_STREQ_MSG(test, "/testcase-data", name,
	"find testcase-alias failed\n");
	of_node_put(np);
	kfree(name);
	}

	static void of_test_find_node_by_name_with_alias_and_slash(struct kunit *test)
	{
	/* Test if trailing '/' works on aliases */
	KUNIT_EXPECT_EQ_MSG(test, of_find_node_by_path("testcase-alias/"), NULL,
	"trailing '/' on testcase-alias/ should fail\n");
	}

	/*
	* TODO(brendanhiggins@google.com): This looks like a duplicate of
	* of_test_find_node_by_name_multiple_components
	*/
	static void of_test_find_node_by_name_multiple_components_2(struct kunit *test)
	{
	struct device_node *np;
	const char *name;

	np = of_find_node_by_path("testcase-alias/phandle-tests/consumer-a");
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
	name = kasprintf(GFP_KERNEL, "%pOF", np);
	KUNIT_EXPECT_STREQ_MSG(test,
	"/testcase-data/phandle-tests/consumer-a", name,
	"find testcase-alias/phandle-tests/consumer-a failed\n");
	of_node_put(np);
	kfree(name);
	}

	static void of_test_find_node_by_name_missing_path(struct kunit *test)
	{
	struct device_node *np;

	KUNIT_EXPECT_EQ_MSG(test,
	np = of_find_node_by_path(
	"/testcase-data/missing-path"),
	NULL,
	"non-existent path returned node %pOF\n", np);
	of_node_put(np);
	}

	static void of_test_find_node_by_name_missing_alias(struct kunit *test)
	{
	struct device_node *np;

	KUNIT_EXPECT_EQ_MSG(test,
	np = of_find_node_by_path("missing-alias"), NULL,
	"non-existent alias returned node %pOF\n", np);
	of_node_put(np);
	}

	static void of_test_find_node_by_name_missing_alias_with_relative_path(
	struct kunit *test)
	{
	struct device_node *np;

	KUNIT_EXPECT_EQ_MSG(test,
	np = of_find_node_by_path(
	"testcase-alias/missing-path"),
	NULL,
	"non-existent alias with relative path returned node %pOF\n",
	np);
	of_node_put(np);
	}

	static void of_test_find_node_by_name_with_option(struct kunit *test)
	{
	struct device_node *np;
	const char *options;

	np = of_find_node_opts_by_path("/testcase-data:testoption", &options);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
	KUNIT_EXPECT_STREQ_MSG(test, "testoption", options,
	"option path test failed\n");
	of_node_put(np);
	}

	static void of_test_find_node_by_name_with_option_and_slash(struct kunit *test)
	{
	struct device_node *np;
	const char *options;

	np = of_find_node_opts_by_path("/testcase-data:test/option", &options);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
	KUNIT_EXPECT_STREQ_MSG(test, "test/option", options,
	"option path test, subcase #1 failed\n");
	of_node_put(np);

	np = of_find_node_opts_by_path(
	"/testcase-data/testcase-device1:test/option",
	&options);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
	KUNIT_EXPECT_STREQ_MSG(test, "test/option", options,
	"option path test, subcase #2 failed\n");
	of_node_put(np);
	}

	static void of_test_find_node_by_name_with_null_option(struct kunit *test)
	{
	struct device_node *np;

	np = of_find_node_opts_by_path("/testcase-data:testoption", NULL);
	KUNIT_EXPECT_NOT_ERR_OR_NULL_MSG(test, np,
	"NULL option path test failed\n");
	of_node_put(np);
	}

	static void of_test_find_node_by_name_with_option_alias(struct kunit *test)
	{
	struct device_node *np;
	const char *options;

	np = of_find_node_opts_by_path("testcase-alias:testaliasoption",
	&options);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
	KUNIT_EXPECT_STREQ_MSG(test, "testaliasoption", options,
	"option alias path test failed\n");
	of_node_put(np);
	}

	static void of_test_find_node_by_name_with_option_alias_and_slash(
	struct kunit *test)
	{
	struct device_node *np;
	const char *options;

	np = of_find_node_opts_by_path("testcase-alias:test/alias/option",
	&options);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
	KUNIT_EXPECT_STREQ_MSG(test, "test/alias/option", options,
	"option alias path test, subcase #1 failed\n");
	of_node_put(np);
	}

	static void of_test_find_node_by_name_with_null_option_alias(struct kunit *test)
	{
	struct device_node *np;

	np = of_find_node_opts_by_path("testcase-alias:testaliasoption", NULL);
	KUNIT_EXPECT_NOT_ERR_OR_NULL_MSG(
	test, np, "NULL option alias path test failed\n");
	of_node_put(np);
	}

	static void of_test_find_node_by_name_option_clearing(struct kunit *test)
	{
	struct device_node *np;
	const char *options;

	options = "testoption";
	np = of_find_node_opts_by_path("testcase-alias", &options);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
	KUNIT_EXPECT_EQ_MSG(test, options, NULL,
	"option clearing test failed\n");
	of_node_put(np);
	}

	static void of_test_find_node_by_name_option_clearing_root(struct kunit *test)
	{
	struct device_node *np;
	const char *options;

	options = "testoption";
	np = of_find_node_opts_by_path("/", &options);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
	KUNIT_EXPECT_EQ_MSG(test, options, NULL,
	"option clearing root node test failed\n");
	of_node_put(np);
	}

	static int of_test_find_node_by_name_init(struct kunit *test)
	{
	/* adding data for unittest */
	KUNIT_ASSERT_EQ(test, 0, unittest_data_add());

	if (!of_aliases)
	of_aliases = of_find_node_by_path("/aliases");

	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, of_find_node_by_path(
	"/testcase-data/phandle-tests/consumer-a"));

	return 0;
	}

	static struct kunit_case of_test_find_node_by_name_cases[] = {
	KUNIT_CASE(of_test_find_node_by_name_basic),
	KUNIT_CASE(of_test_find_node_by_name_trailing_slash),
	KUNIT_CASE(of_test_find_node_by_name_multiple_components),
	KUNIT_CASE(of_test_find_node_by_name_with_alias),
	KUNIT_CASE(of_test_find_node_by_name_with_alias_and_slash),
	KUNIT_CASE(of_test_find_node_by_name_multiple_components_2),
	KUNIT_CASE(of_test_find_node_by_name_missing_path),
	KUNIT_CASE(of_test_find_node_by_name_missing_alias),
	KUNIT_CASE(of_test_find_node_by_name_missing_alias_with_relative_path),
	KUNIT_CASE(of_test_find_node_by_name_with_option),
	KUNIT_CASE(of_test_find_node_by_name_with_option_and_slash),
	KUNIT_CASE(of_test_find_node_by_name_with_null_option),
	KUNIT_CASE(of_test_find_node_by_name_with_option_alias),
	KUNIT_CASE(of_test_find_node_by_name_with_option_alias_and_slash),
	KUNIT_CASE(of_test_find_node_by_name_with_null_option_alias),
	KUNIT_CASE(of_test_find_node_by_name_option_clearing),
	KUNIT_CASE(of_test_find_node_by_name_option_clearing_root),
	{},
	};

	static struct kunit_module of_test_find_node_by_name_module = {
	.name = "of-test-find-node-by-name",
	.init = of_test_find_node_by_name_init,
	.test_cases = of_test_find_node_by_name_cases,
	};
	module_test(of_test_find_node_by_name_module);

	struct of_test_dynamic_context {
	struct device_node *np;
	struct property *prop0;
	struct property *prop1;
	};

	static void of_test_dynamic_basic(struct kunit *test)
	{
	struct of_test_dynamic_context *ctx = test->priv;
	struct device_node *np = ctx->np;
	struct property *prop0 = ctx->prop0;

	/* Add a new property - should pass*/
	prop0->name = "new-property";
	prop0->value = "new-property-data";
	prop0->length = strlen(prop0->value) + 1;
	KUNIT_EXPECT_EQ_MSG(test, of_add_property(np, prop0), 0,
	"Adding a new property failed\n");

	/* Test that we can remove a property */
	KUNIT_EXPECT_EQ(test, of_remove_property(np, prop0), 0);
	}

	static void of_test_dynamic_add_existing_property(struct kunit *test)
	{
	struct of_test_dynamic_context *ctx = test->priv;
	struct device_node *np = ctx->np;
	struct property prop0 = ctx->prop0, prop1 = ctx->prop1;

	/* Add a new property - should pass*/
	prop0->name = "new-property";
	prop0->value = "new-property-data";
	prop0->length = strlen(prop0->value) + 1;
	KUNIT_EXPECT_EQ_MSG(test, of_add_property(np, prop0), 0,
	"Adding a new property failed\n");

	/* Try to add an existing property - should fail */
	prop1->name = "new-property";
	prop1->value = "new-property-data-should-fail";
	prop1->length = strlen(prop1->value) + 1;
	KUNIT_EXPECT_NE_MSG(test, of_add_property(np, prop1), 0,
	"Adding an existing property should have failed\n");
	}

	static void of_test_dynamic_modify_existing_property(struct kunit *test)
	{
	struct of_test_dynamic_context *ctx = test->priv;
	struct device_node *np = ctx->np;
	struct property prop0 = ctx->prop0, prop1 = ctx->prop1;

	/* Add a new property - should pass*/
	prop0->name = "new-property";
	prop0->value = "new-property-data";
	prop0->length = strlen(prop0->value) + 1;
	KUNIT_EXPECT_EQ_MSG(test, of_add_property(np, prop0), 0,
	"Adding a new property failed\n");

	/* Try to modify an existing property - should pass */
	prop1->name = "new-property";
	prop1->value = "modify-property-data-should-pass";
	prop1->length = strlen(prop1->value) + 1;
	KUNIT_EXPECT_EQ_MSG(test, of_update_property(np, prop1), 0,
	"Updating an existing property should have passed\n");
	}

	static void of_test_dynamic_modify_non_existent_property(struct kunit *test)
	{
	struct of_test_dynamic_context *ctx = test->priv;
	struct device_node *np = ctx->np;
	struct property *prop0 = ctx->prop0;

	/* Try to modify non-existent property - should pass*/
	prop0->name = "modify-property";
	prop0->value = "modify-missing-property-data-should-pass";
	prop0->length = strlen(prop0->value) + 1;
	KUNIT_EXPECT_EQ_MSG(test, of_update_property(np, prop0), 0,
	"Updating a missing property should have passed\n");
	}

	static void of_test_dynamic_large_property(struct kunit *test)
	{
	struct of_test_dynamic_context *ctx = test->priv;
	struct device_node *np = ctx->np;
	struct property *prop0 = ctx->prop0;

	/* Adding very large property - should pass */
	prop0->name = "large-property-PAGE_SIZEx8";
	prop0->length = PAGE_SIZE * 8;
	prop0->value = kunit_kzalloc(test, prop0->length, GFP_KERNEL);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, prop0->value);

	KUNIT_EXPECT_EQ_MSG(test, of_add_property(np, prop0), 0,
	"Adding a large property should have passed\n");
	}

	static int of_test_dynamic_init(struct kunit *test)
	{
	struct of_test_dynamic_context *ctx;

	KUNIT_ASSERT_EQ(test, 0, unittest_data_add());

	if (!of_aliases)
	of_aliases = of_find_node_by_path("/aliases");

	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, of_find_node_by_path(
	"/testcase-data/phandle-tests/consumer-a"));

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

	ctx->np = of_find_node_by_path("/testcase-data");
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx->np);

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

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

	return 0;
	}

	static void of_test_dynamic_exit(struct kunit *test)
	{
	struct of_test_dynamic_context *ctx = test->priv;
	struct device_node *np = ctx->np;

	of_remove_property(np, ctx->prop0);
	of_remove_property(np, ctx->prop1);
	of_node_put(np);
	}

	static struct kunit_case of_test_dynamic_cases[] = {
	KUNIT_CASE(of_test_dynamic_basic),
	KUNIT_CASE(of_test_dynamic_add_existing_property),
	KUNIT_CASE(of_test_dynamic_modify_existing_property),
	KUNIT_CASE(of_test_dynamic_modify_non_existent_property),
	KUNIT_CASE(of_test_dynamic_large_property),
	{},
	};

	static struct kunit_module of_test_dynamic_module = {
	.name = "of-dynamic-test",
	.init = of_test_dynamic_init,
	.exit = of_test_dynamic_exit,
	.test_cases = of_test_dynamic_cases,
	};
	module_test(of_test_dynamic_module);