Linux-NVDIMM Archive on lore.kernel.org
 help / color / Atom feed
From: Rob Herring <robh@kernel.org>
To: Brendan Higgins <brendanhiggins@google.com>
Cc: brakmo@fb.com, dri-devel <dri-devel@lists.freedesktop.org>,
	linux-kselftest@vger.kernel.org, shuah@kernel.org,
	Frank Rowand <frowand.list@gmail.com>,
	linux-nvdimm <linux-nvdimm@lists.01.org>,
	Richard Weinberger <richard@nod.at>,
	knut.omang@oracle.com,
	Kieran Bingham <kieran.bingham@ideasonboard.com>,
	Joel Stanley <joel@jms.id.au>, Jeff Dike <jdike@addtoit.com>,
	"Bird," Timothy" <Tim.Bird@sony.com>,
	Kees Cook <keescook@google.com>," linux-um@lists.infradead.org,
	Steven Rostedt <rostedt@goodmis.org>,
	Julia Lawall <julia.lawall@lip6.fr>,
	kunit-dev@googlegroups.com,
	Greg Kroah-Hartman <gregkh@linuxfoundation.org>,
	"linux-kernel@vger.kernel.org" <linux-kernel@vger.kernel.org>,
	"Luis R. Rodriguez" <mcgrof@kernel.org>,
	Daniel Vetter <daniel@ffwll.ch>,
	Michael Ellerman <mpe@ellerman.id.au>,
	Joe Perches <joe@perches.com>,
	Kevin Hilman <khilman@baylibre.com>
Subject: Re: [RFC v3 17/19] of: unittest: migrate tests to run on KUnit
Date: Wed, 28 Nov 2018 14:56:36 -0600
Message-ID: <CAL_Jsq+09Kx7yMBC_Jw45QGmk6U_fp4N6HOZDwYrM4tWw+_dOA@mail.gmail.com> (raw)
In-Reply-To: <20181128193636.254378-18-brendanhiggins@google.com>

On Wed, Nov 28, 2018 at 1:38 PM Brendan Higgins
<brendanhiggins@google.com> wrote:
>
> Migrate tests without any cleanup, or modifying test logic in anyway to
> run under KUnit using the KUnit expectation and assertion API.

Nice! You beat me to it. This is probably going to conflict with what
is in the DT tree for 4.21. Also, please Cc the DT list for
drivers/of/ changes.

Looks good to me, but a few mostly formatting comments below.

>
> Signed-off-by: Brendan Higgins <brendanhiggins@google.com>
> ---
>  drivers/of/Kconfig    |    1 +
>  drivers/of/unittest.c | 1405 ++++++++++++++++++++++-------------------
>  2 files changed, 752 insertions(+), 654 deletions(-)
>
> diff --git a/drivers/of/Kconfig b/drivers/of/Kconfig
> index ad3fcad4d75b8..f309399deac20 100644
> --- a/drivers/of/Kconfig
> +++ b/drivers/of/Kconfig
> @@ -15,6 +15,7 @@ if OF
>  config OF_UNITTEST
>         bool "Device Tree runtime unit tests"
>         depends on !SPARC
> +       depends on KUNIT

Unless KUNIT has depends, better to be a select here.

>         select IRQ_DOMAIN
>         select OF_EARLY_FLATTREE
>         select OF_RESOLVE
> diff --git a/drivers/of/unittest.c b/drivers/of/unittest.c
> index 41b49716ac75f..a5ef44730ffdb 100644
> --- a/drivers/of/unittest.c
> +++ b/drivers/of/unittest.c
> @@ -26,186 +26,187 @@
>
>  #include <linux/bitops.h>
>
> +#include <kunit/test.h>
> +
>  #include "of_private.h"
>
> -static struct unittest_results {
> -       int passed;
> -       int failed;
> -} unittest_results;
> -
> -#define unittest(result, fmt, ...) ({ \
> -       bool failed = !(result); \
> -       if (failed) { \
> -               unittest_results.failed++; \
> -               pr_err("FAIL %s():%i " fmt, __func__, __LINE__, ##__VA_ARGS__); \
> -       } else { \
> -               unittest_results.passed++; \
> -               pr_debug("pass %s():%i\n", __func__, __LINE__); \
> -       } \
> -       failed; \
> -})
> -
> -static void __init of_unittest_find_node_by_name(void)
> +static void of_unittest_find_node_by_name(struct kunit *test)

Why do we have to drop __init everywhere? The tests run later?

>  {
>         struct device_node *np;
>         const char *options, *name;
>
>         np = of_find_node_by_path("/testcase-data");
>         name = kasprintf(GFP_KERNEL, "%pOF", np);
> -       unittest(np && !strcmp("/testcase-data", name),
> -               "find /testcase-data failed\n");
> +       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);
>
>         /* Test if trailing '/' works */
> -       np = of_find_node_by_path("/testcase-data/");
> -       unittest(!np, "trailing '/' on /testcase-data/ should fail\n");
> +       KUNIT_EXPECT_EQ_MSG(test, of_find_node_by_path("/testcase-data/"), NULL,
> +                           "trailing '/' on /testcase-data/ should fail\n");
>
>         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);
> -       unittest(np && !strcmp("/testcase-data/phandle-tests/consumer-a", name),
> -               "find /testcase-data/phandle-tests/consumer-a failed\n");
> +       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);
>
>         np = of_find_node_by_path("testcase-alias");
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
>         name = kasprintf(GFP_KERNEL, "%pOF", np);
> -       unittest(np && !strcmp("/testcase-data", name),
> -               "find testcase-alias failed\n");
> +       KUNIT_EXPECT_STREQ_MSG(test, "/testcase-data", name,
> +                              "find testcase-alias failed\n");
>         of_node_put(np);
>         kfree(name);
>
>         /* Test if trailing '/' works on aliases */
> -       np = of_find_node_by_path("testcase-alias/");
> -       unittest(!np, "trailing '/' on testcase-alias/ should fail\n");
> +       KUNIT_EXPECT_EQ_MSG(test, of_find_node_by_path("testcase-alias/"), NULL,
> +                           "trailing '/' on testcase-alias/ should fail\n");
>
>         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);
> -       unittest(np && !strcmp("/testcase-data/phandle-tests/consumer-a", name),
> -               "find testcase-alias/phandle-tests/consumer-a failed\n");
> +       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);
>
> -       np = of_find_node_by_path("/testcase-data/missing-path");
> -       unittest(!np, "non-existent path returned node %pOF\n", np);
> +       KUNIT_EXPECT_EQ_MSG(test,
> +                           of_find_node_by_path("/testcase-data/missing-path"),
> +                           NULL,
> +                           "non-existent path returned node %pOF\n", np);

1 tab indent would help with less vertical code (in general, not this
one so much).

>         of_node_put(np);
>
> -       np = of_find_node_by_path("missing-alias");
> -       unittest(!np, "non-existent alias returned node %pOF\n", np);
> +       KUNIT_EXPECT_EQ_MSG(test, of_find_node_by_path("missing-alias"), NULL,
> +                           "non-existent alias returned node %pOF\n", np);
>         of_node_put(np);
>
> -       np = of_find_node_by_path("testcase-alias/missing-path");
> -       unittest(!np, "non-existent alias with relative path returned node %pOF\n", np);
> +       KUNIT_EXPECT_EQ_MSG(test,
> +                           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);
>
>         np = of_find_node_opts_by_path("/testcase-data:testoption", &options);
> -       unittest(np && !strcmp("testoption", options),
> -                "option path test failed\n");
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
> +       KUNIT_EXPECT_STREQ_MSG(test, "testoption", options,
> +                              "option path test failed\n");
>         of_node_put(np);
>
>         np = of_find_node_opts_by_path("/testcase-data:test/option", &options);
> -       unittest(np && !strcmp("test/option", options),
> -                "option path test, subcase #1 failed\n");
> +       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);
> -       unittest(np && !strcmp("test/option", options),
> -                "option path test, subcase #2 failed\n");
> +       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);
>
>         np = of_find_node_opts_by_path("/testcase-data:testoption", NULL);
> -       unittest(np, "NULL option path test failed\n");
> +       KUNIT_EXPECT_NOT_ERR_OR_NULL_MSG(test, np,
> +                                        "NULL option path test failed\n");
>         of_node_put(np);
>
>         np = of_find_node_opts_by_path("testcase-alias:testaliasoption",
>                                        &options);
> -       unittest(np && !strcmp("testaliasoption", options),
> -                "option alias path test failed\n");
> +       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);
>
>         np = of_find_node_opts_by_path("testcase-alias:test/alias/option",
>                                        &options);
> -       unittest(np && !strcmp("test/alias/option", options),
> -                "option alias path test, subcase #1 failed\n");
> +       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);
>
>         np = of_find_node_opts_by_path("testcase-alias:testaliasoption", NULL);
> -       unittest(np, "NULL option alias path test failed\n");
> +       KUNIT_EXPECT_NOT_ERR_OR_NULL_MSG(test, np,
> +                                        "NULL option alias path test failed\n");
>         of_node_put(np);
>
>         options = "testoption";
>         np = of_find_node_opts_by_path("testcase-alias", &options);
> -       unittest(np && !options, "option clearing test failed\n");
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
> +       KUNIT_EXPECT_EQ_MSG(test, options, NULL,
> +                           "option clearing test failed\n");
>         of_node_put(np);
>
>         options = "testoption";
>         np = of_find_node_opts_by_path("/", &options);
> -       unittest(np && !options, "option clearing root node test failed\n");
> +       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 void __init of_unittest_dynamic(void)
> +static void of_unittest_dynamic(struct kunit *test)
>  {
>         struct device_node *np;
>         struct property *prop;
>
>         np = of_find_node_by_path("/testcase-data");
> -       if (!np) {
> -               pr_err("missing testcase data\n");
> -               return;
> -       }
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
>
>         /* Array of 4 properties for the purpose of testing */
>         prop = kcalloc(4, sizeof(*prop), GFP_KERNEL);
> -       if (!prop) {
> -               unittest(0, "kzalloc() failed\n");
> -               return;
> -       }
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, prop);
>
>         /* Add a new property - should pass*/
>         prop->name = "new-property";
>         prop->value = "new-property-data";
>         prop->length = strlen(prop->value) + 1;
> -       unittest(of_add_property(np, prop) == 0, "Adding a new property failed\n");
> +       KUNIT_EXPECT_EQ_MSG(test, of_add_property(np, prop), 0,
> +                           "Adding a new property failed\n");
>
>         /* Try to add an existing property - should fail */
>         prop++;
>         prop->name = "new-property";
>         prop->value = "new-property-data-should-fail";
>         prop->length = strlen(prop->value) + 1;
> -       unittest(of_add_property(np, prop) != 0,
> -                "Adding an existing property should have failed\n");
> +       KUNIT_EXPECT_NE_MSG(test, of_add_property(np, prop), 0,
> +                           "Adding an existing property should have failed\n");
>
>         /* Try to modify an existing property - should pass */
>         prop->value = "modify-property-data-should-pass";
>         prop->length = strlen(prop->value) + 1;
> -       unittest(of_update_property(np, prop) == 0,
> -                "Updating an existing property should have passed\n");
> +       KUNIT_EXPECT_EQ_MSG(test, of_update_property(np, prop), 0,
> +                           "Updating an existing property should have passed\n");
>
>         /* Try to modify non-existent property - should pass*/
>         prop++;
>         prop->name = "modify-property";
>         prop->value = "modify-missing-property-data-should-pass";
>         prop->length = strlen(prop->value) + 1;
> -       unittest(of_update_property(np, prop) == 0,
> -                "Updating a missing property should have passed\n");
> +       KUNIT_EXPECT_EQ_MSG(test, of_update_property(np, prop), 0,
> +                           "Updating a missing property should have passed\n");
>
>         /* Remove property - should pass */
> -       unittest(of_remove_property(np, prop) == 0,
> -                "Removing a property should have passed\n");
> +       KUNIT_EXPECT_EQ_MSG(test, of_remove_property(np, prop), 0,
> +                           "Removing a property should have passed\n");
>
>         /* Adding very large property - should pass */
>         prop++;
>         prop->name = "large-property-PAGE_SIZEx8";
>         prop->length = PAGE_SIZE * 8;
>         prop->value = kzalloc(prop->length, GFP_KERNEL);
> -       unittest(prop->value != NULL, "Unable to allocate large buffer\n");
> -       if (prop->value)
> -               unittest(of_add_property(np, prop) == 0,
> -                        "Adding a large property should have passed\n");
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, prop->value);
> +       KUNIT_EXPECT_EQ_MSG(test, of_add_property(np, prop), 0,
> +                           "Adding a large property should have passed\n");
>  }
>
> -static int __init of_unittest_check_node_linkage(struct device_node *np)
> +static int of_unittest_check_node_linkage(struct device_node *np)
>  {
>         struct device_node *child;
>         int count = 0, rc;
> @@ -230,27 +231,29 @@ static int __init of_unittest_check_node_linkage(struct device_node *np)
>         return rc;
>  }
>
> -static void __init of_unittest_check_tree_linkage(void)
> +static void of_unittest_check_tree_linkage(struct kunit *test)
>  {
>         struct device_node *np;
>         int allnode_count = 0, child_count;
>
> -       if (!of_root)
> -               return;
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, of_root);
>
>         for_each_of_allnodes(np)
>                 allnode_count++;
>         child_count = of_unittest_check_node_linkage(of_root);
>
> -       unittest(child_count > 0, "Device node data structure is corrupted\n");
> -       unittest(child_count == allnode_count,
> -                "allnodes list size (%i) doesn't match sibling lists size (%i)\n",
> -                allnode_count, child_count);
> +       KUNIT_EXPECT_GT_MSG(test, child_count, 0,
> +                           "Device node data structure is corrupted\n");
> +       KUNIT_EXPECT_EQ_MSG(test, child_count, allnode_count,
> +                           "allnodes list size (%i) doesn't match sibling lists size (%i)\n",
> +                           allnode_count, child_count);
>         pr_debug("allnodes list size (%i); sibling lists size (%i)\n", allnode_count, child_count);
>  }
>
> -static void __init of_unittest_printf_one(struct device_node *np, const char *fmt,
> -                                         const char *expected)
> +static void of_unittest_printf_one(struct kunit *test,
> +                                  struct device_node *np,
> +                                  const char *fmt,
> +                                  const char *expected)
>  {
>         unsigned char *buf;
>         int buf_size;
> @@ -266,9 +269,12 @@ static void __init of_unittest_printf_one(struct device_node *np, const char *fm
>         size = snprintf(buf, buf_size - 2, fmt, np);
>
>         /* use strcmp() instead of strncmp() here to be absolutely sure strings match */
> -       unittest((strcmp(buf, expected) == 0) && (buf[size+1] == 0xff),
> -               "sprintf failed; fmt='%s' expected='%s' rslt='%s'\n",
> -               fmt, expected, buf);
> +       KUNIT_EXPECT_STREQ_MSG(test, buf, expected,
> +                              "sprintf failed; fmt='%s' expected='%s' rslt='%s'\n",
> +                              fmt, expected, buf);
> +       KUNIT_EXPECT_EQ_MSG(test, buf[size+1], 0xff,
> +                           "sprintf failed; fmt='%s' expected='%s' rslt='%s'\n",
> +                           fmt, expected, buf);
>
>         /* Make sure length limits work */
>         size++;
> @@ -276,40 +282,43 @@ static void __init of_unittest_printf_one(struct device_node *np, const char *fm
>                 /* Clear the buffer, and make sure it works correctly still */
>                 memset(buf, 0xff, buf_size);
>                 snprintf(buf, size+1, fmt, np);
> -               unittest(strncmp(buf, expected, size) == 0 && (buf[size+1] == 0xff),
> -                       "snprintf failed; size=%i fmt='%s' expected='%s' rslt='%s'\n",
> -                       size, fmt, expected, buf);
> +               KUNIT_EXPECT_STREQ_MSG(test, buf, expected,
> +                                      "snprintf failed; size=%i fmt='%s' expected='%s' rslt='%s'\n",
> +                                      size, fmt, expected, buf);
> +               KUNIT_EXPECT_EQ_MSG(test, buf[size+1], 0xff,
> +                                   "snprintf failed; size=%i fmt='%s' expected='%s' rslt='%s'\n",
> +                                   size, fmt, expected, buf);
>         }
>         kfree(buf);
>  }
>
> -static void __init of_unittest_printf(void)
> +static void of_unittest_printf(struct kunit *test)
>  {
>         struct device_node *np;
>         const char *full_name = "/testcase-data/platform-tests/test-device@1/dev@100";
>         char phandle_str[16] = "";
>
>         np = of_find_node_by_path(full_name);
> -       if (!np) {
> -               unittest(np, "testcase data missing\n");
> -               return;
> -       }
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
>
>         num_to_str(phandle_str, sizeof(phandle_str), np->phandle, 0);
>
> -       of_unittest_printf_one(np, "%pOF",  full_name);
> -       of_unittest_printf_one(np, "%pOFf", full_name);
> -       of_unittest_printf_one(np, "%pOFp", phandle_str);
> -       of_unittest_printf_one(np, "%pOFP", "dev@100");
> -       of_unittest_printf_one(np, "ABC %pOFP ABC", "ABC dev@100 ABC");
> -       of_unittest_printf_one(np, "%10pOFP", "   dev@100");
> -       of_unittest_printf_one(np, "%-10pOFP", "dev@100   ");
> -       of_unittest_printf_one(of_root, "%pOFP", "/");
> -       of_unittest_printf_one(np, "%pOFF", "----");
> -       of_unittest_printf_one(np, "%pOFPF", "dev@100:----");
> -       of_unittest_printf_one(np, "%pOFPFPc", "dev@100:----:dev@100:test-sub-device");
> -       of_unittest_printf_one(np, "%pOFc", "test-sub-device");
> -       of_unittest_printf_one(np, "%pOFC",
> +       of_unittest_printf_one(test, np, "%pOF",  full_name);
> +       of_unittest_printf_one(test, np, "%pOFf", full_name);
> +       of_unittest_printf_one(test, np, "%pOFp", phandle_str);
> +       of_unittest_printf_one(test, np, "%pOFP", "dev@100");
> +       of_unittest_printf_one(test, np, "ABC %pOFP ABC", "ABC dev@100 ABC");
> +       of_unittest_printf_one(test, np, "%10pOFP", "   dev@100");
> +       of_unittest_printf_one(test, np, "%-10pOFP", "dev@100   ");
> +       of_unittest_printf_one(test, of_root, "%pOFP", "/");
> +       of_unittest_printf_one(test, np, "%pOFF", "----");
> +       of_unittest_printf_one(test, np, "%pOFPF", "dev@100:----");
> +       of_unittest_printf_one(test,
> +                              np,
> +                              "%pOFPFPc",
> +                              "dev@100:----:dev@100:test-sub-device");
> +       of_unittest_printf_one(test, np, "%pOFc", "test-sub-device");
> +       of_unittest_printf_one(test, np, "%pOFC",
>                         "\"test-sub-device\",\"test-compat2\",\"test-compat3\"");
>  }
>
> @@ -319,7 +328,7 @@ struct node_hash {
>  };
>
>  static DEFINE_HASHTABLE(phandle_ht, 8);
> -static void __init of_unittest_check_phandles(void)
> +static void of_unittest_check_phandles(struct kunit *test)
>  {
>         struct device_node *np;
>         struct node_hash *nh;
> @@ -331,24 +340,25 @@ static void __init of_unittest_check_phandles(void)
>                         continue;
>
>                 hash_for_each_possible(phandle_ht, nh, node, np->phandle) {
> +                       KUNIT_EXPECT_NE_MSG(test, nh->np->phandle, np->phandle,
> +                                           "Duplicate phandle! %i used by %pOF and %pOF\n",
> +                                           np->phandle, nh->np, np);
>                         if (nh->np->phandle == np->phandle) {
> -                               pr_info("Duplicate phandle! %i used by %pOF and %pOF\n",
> -                                       np->phandle, nh->np, np);
>                                 dup_count++;
>                                 break;
>                         }
>                 }
>
>                 nh = kzalloc(sizeof(*nh), GFP_KERNEL);
> -               if (WARN_ON(!nh))
> -                       return;
> +               KUNIT_ASSERT_NOT_ERR_OR_NULL(test, nh);
>
>                 nh->np = np;
>                 hash_add(phandle_ht, &nh->node, np->phandle);
>                 phandle_count++;
>         }
> -       unittest(dup_count == 0, "Found %i duplicates in %i phandles\n",
> -                dup_count, phandle_count);
> +       KUNIT_EXPECT_EQ_MSG(test, dup_count, 0,
> +                           "Found %i duplicates in %i phandles\n",
> +                           dup_count, phandle_count);
>
>         /* Clean up */
>         hash_for_each_safe(phandle_ht, i, tmp, nh, node) {
> @@ -357,20 +367,22 @@ static void __init of_unittest_check_phandles(void)
>         }
>  }
>
> -static void __init of_unittest_parse_phandle_with_args(void)
> +static void of_unittest_parse_phandle_with_args(struct kunit *test)
>  {
>         struct device_node *np;
>         struct of_phandle_args args;
> -       int i, rc;
> +       int i, rc = 0;
>
>         np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-a");
> -       if (!np) {
> -               pr_err("missing testcase data\n");
> -               return;
> -       }
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
>
> -       rc = of_count_phandle_with_args(np, "phandle-list", "#phandle-cells");
> -       unittest(rc == 7, "of_count_phandle_with_args() returned %i, expected 7\n", rc);
> +       KUNIT_EXPECT_EQ_MSG(test,
> +                           of_count_phandle_with_args(np,
> +                                                      "phandle-list",
> +                                                      "#phandle-cells"),
> +                           7,
> +                           "of_count_phandle_with_args() returned %i, expected 7\n",
> +                           rc);
>
>         for (i = 0; i < 8; i++) {
>                 bool passed = true;
> @@ -423,81 +435,90 @@ static void __init of_unittest_parse_phandle_with_args(void)
>                         passed = false;
>                 }
>
> -               unittest(passed, "index %i - data error on node %pOF rc=%i\n",
> -                        i, args.np, rc);
> +               KUNIT_EXPECT_TRUE_MSG(test, passed,
> +                                     "index %i - data error on node %pOF rc=%i\n",
> +                                     i, args.np, rc);
>         }
>
>         /* Check for missing list property */
> -       rc = of_parse_phandle_with_args(np, "phandle-list-missing",
> -                                       "#phandle-cells", 0, &args);
> -       unittest(rc == -ENOENT, "expected:%i got:%i\n", -ENOENT, rc);
> -       rc = of_count_phandle_with_args(np, "phandle-list-missing",
> -                                       "#phandle-cells");
> -       unittest(rc == -ENOENT, "expected:%i got:%i\n", -ENOENT, rc);
> +       KUNIT_EXPECT_EQ(test,
> +                       of_parse_phandle_with_args(np,
> +                                                  "phandle-list-missing",
> +                                                  "#phandle-cells",
> +                                                  0, &args),
> +                       -ENOENT);
> +       KUNIT_EXPECT_EQ(test,
> +                       of_count_phandle_with_args(np,
> +                                                  "phandle-list-missing",
> +                                                  "#phandle-cells"),
> +                       -ENOENT);
>
>         /* Check for missing cells property */
> -       rc = of_parse_phandle_with_args(np, "phandle-list",
> -                                       "#phandle-cells-missing", 0, &args);
> -       unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
> -       rc = of_count_phandle_with_args(np, "phandle-list",
> -                                       "#phandle-cells-missing");
> -       unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
> +       KUNIT_EXPECT_EQ(test,
> +                       of_parse_phandle_with_args(np,
> +                                                  "phandle-list",
> +                                                  "#phandle-cells-missing",
> +                                                  0, &args),
> +                       -EINVAL);
> +       KUNIT_EXPECT_EQ(test,
> +                       of_count_phandle_with_args(np,
> +                                                  "phandle-list",
> +                                                  "#phandle-cells-missing"),
> +                       -EINVAL);
>
>         /* Check for bad phandle in list */
> -       rc = of_parse_phandle_with_args(np, "phandle-list-bad-phandle",
> -                                       "#phandle-cells", 0, &args);
> -       unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
> -       rc = of_count_phandle_with_args(np, "phandle-list-bad-phandle",
> -                                       "#phandle-cells");
> -       unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
> +       KUNIT_EXPECT_EQ(test,
> +                       of_parse_phandle_with_args(np,
> +                                                  "phandle-list-bad-phandle",
> +                                                  "#phandle-cells",
> +                                                  0, &args),
> +                       -EINVAL);
> +       KUNIT_EXPECT_EQ(test,
> +                       of_count_phandle_with_args(np,
> +                                                  "phandle-list-bad-phandle",
> +                                                  "#phandle-cells"),
> +                       -EINVAL);
>
>         /* Check for incorrectly formed argument list */
> -       rc = of_parse_phandle_with_args(np, "phandle-list-bad-args",
> -                                       "#phandle-cells", 1, &args);
> -       unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
> -       rc = of_count_phandle_with_args(np, "phandle-list-bad-args",
> -                                       "#phandle-cells");
> -       unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
> +       KUNIT_EXPECT_EQ(test,
> +                       of_parse_phandle_with_args(np,
> +                                                  "phandle-list-bad-args",
> +                                                  "#phandle-cells",
> +                                                  1, &args),
> +                       -EINVAL);
> +       KUNIT_EXPECT_EQ(test,
> +                       of_count_phandle_with_args(np,
> +                                                  "phandle-list-bad-args",
> +                                                  "#phandle-cells"),
> +                       -EINVAL);
>  }
>
> -static void __init of_unittest_parse_phandle_with_args_map(void)
> +static void of_unittest_parse_phandle_with_args_map(struct kunit *test)
>  {
>         struct device_node *np, *p0, *p1, *p2, *p3;
>         struct of_phandle_args args;
>         int i, rc;
>
>         np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-b");
> -       if (!np) {
> -               pr_err("missing testcase data\n");
> -               return;
> -       }
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
>
>         p0 = of_find_node_by_path("/testcase-data/phandle-tests/provider0");
> -       if (!p0) {
> -               pr_err("missing testcase data\n");
> -               return;
> -       }
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, p0);
>
>         p1 = of_find_node_by_path("/testcase-data/phandle-tests/provider1");
> -       if (!p1) {
> -               pr_err("missing testcase data\n");
> -               return;
> -       }
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, p1);
>
>         p2 = of_find_node_by_path("/testcase-data/phandle-tests/provider2");
> -       if (!p2) {
> -               pr_err("missing testcase data\n");
> -               return;
> -       }
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, p2);
>
>         p3 = of_find_node_by_path("/testcase-data/phandle-tests/provider3");
> -       if (!p3) {
> -               pr_err("missing testcase data\n");
> -               return;
> -       }
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, p3);
>
> -       rc = of_count_phandle_with_args(np, "phandle-list", "#phandle-cells");
> -       unittest(rc == 7, "of_count_phandle_with_args() returned %i, expected 7\n", rc);
> +       KUNIT_EXPECT_EQ(test,
> +                      of_count_phandle_with_args(np,
> +                                                 "phandle-list",
> +                                                 "#phandle-cells"),
> +                      7);
>
>         for (i = 0; i < 8; i++) {
>                 bool passed = true;
> @@ -554,117 +575,214 @@ static void __init of_unittest_parse_phandle_with_args_map(void)
>                         passed = false;
>                 }
>
> -               unittest(passed, "index %i - data error on node %s rc=%i\n",
> -                        i, args.np->full_name, rc);
> +               KUNIT_EXPECT_TRUE_MSG(test, passed,
> +                                     "index %i - data error on node %s rc=%i\n",
> +                                     i, args.np->full_name, rc);
>         }
>
>         /* Check for missing list property */
> -       rc = of_parse_phandle_with_args_map(np, "phandle-list-missing",
> -                                           "phandle", 0, &args);
> -       unittest(rc == -ENOENT, "expected:%i got:%i\n", -ENOENT, rc);
> +       KUNIT_EXPECT_EQ(test,
> +                       of_parse_phandle_with_args_map(np,
> +                                                      "phandle-list-missing",
> +                                                      "phandle",
> +                                                      0, &args),
> +                       -ENOENT);
>
>         /* Check for missing cells,map,mask property */
> -       rc = of_parse_phandle_with_args_map(np, "phandle-list",
> -                                           "phandle-missing", 0, &args);
> -       unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
> +       KUNIT_EXPECT_EQ(test,
> +                       of_parse_phandle_with_args_map(np,
> +                                                      "phandle-list",
> +                                                      "phandle-missing",
> +                                                      0, &args),
> +                       -EINVAL);
>
>         /* Check for bad phandle in list */
> -       rc = of_parse_phandle_with_args_map(np, "phandle-list-bad-phandle",
> -                                           "phandle", 0, &args);
> -       unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
> +       KUNIT_EXPECT_EQ(test,
> +                       of_parse_phandle_with_args_map(np,
> +                                                      "phandle-list-bad-phandle",
> +                                                      "phandle",
> +                                                      0, &args),
> +                       -EINVAL);
>
>         /* Check for incorrectly formed argument list */
> -       rc = of_parse_phandle_with_args_map(np, "phandle-list-bad-args",
> -                                           "phandle", 1, &args);
> -       unittest(rc == -EINVAL, "expected:%i got:%i\n", -EINVAL, rc);
> +       KUNIT_EXPECT_EQ(test,
> +                       of_parse_phandle_with_args_map(np,
> +                                                      "phandle-list-bad-args",
> +                                                      "phandle",
> +                                                      1, &args),
> +                       -EINVAL);
>  }
>
> -static void __init of_unittest_property_string(void)
> +static void of_unittest_property_string(struct kunit *test)
>  {
>         const char *strings[4];
>         struct device_node *np;
>         int rc;
>
>         np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-a");
> -       if (!np) {
> -               pr_err("No testcase data in device tree\n");
> -               return;
> -       }
> -
> -       rc = of_property_match_string(np, "phandle-list-names", "first");
> -       unittest(rc == 0, "first expected:0 got:%i\n", rc);
> -       rc = of_property_match_string(np, "phandle-list-names", "second");
> -       unittest(rc == 1, "second expected:1 got:%i\n", rc);
> -       rc = of_property_match_string(np, "phandle-list-names", "third");
> -       unittest(rc == 2, "third expected:2 got:%i\n", rc);
> -       rc = of_property_match_string(np, "phandle-list-names", "fourth");
> -       unittest(rc == -ENODATA, "unmatched string; rc=%i\n", rc);
> -       rc = of_property_match_string(np, "missing-property", "blah");
> -       unittest(rc == -EINVAL, "missing property; rc=%i\n", rc);
> -       rc = of_property_match_string(np, "empty-property", "blah");
> -       unittest(rc == -ENODATA, "empty property; rc=%i\n", rc);
> -       rc = of_property_match_string(np, "unterminated-string", "blah");
> -       unittest(rc == -EILSEQ, "unterminated string; rc=%i\n", rc);
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
> +
> +       KUNIT_EXPECT_EQ(test,
> +                       of_property_match_string(np,
> +                                                "phandle-list-names",
> +                                                "first"),
> +                       0);
> +       KUNIT_EXPECT_EQ(test,
> +                       of_property_match_string(np,
> +                                                "phandle-list-names",
> +                                                "second"),
> +                       1);

Fewer lines on these would be better even if we go over 80 chars.

> +       KUNIT_EXPECT_EQ(test,
> +                       of_property_match_string(np,
> +                                                "phandle-list-names",
> +                                                "third"),
> +                       2);
> +       KUNIT_EXPECT_EQ_MSG(test,
> +                           of_property_match_string(np,
> +                                                    "phandle-list-names",
> +                                                    "fourth"),
> +                           -ENODATA,
> +                           "unmatched string");
> +       KUNIT_EXPECT_EQ_MSG(test,
> +                           of_property_match_string(np,
> +                                                    "missing-property",
> +                                                    "blah"),
> +                           -EINVAL,
> +                           "missing property");
> +       KUNIT_EXPECT_EQ_MSG(test,
> +                           of_property_match_string(np,
> +                                                    "empty-property",
> +                                                    "blah"),
> +                           -ENODATA,
> +                           "empty property");
> +       KUNIT_EXPECT_EQ_MSG(test,
> +                           of_property_match_string(np,
> +                                                    "unterminated-string",
> +                                                    "blah"),
> +                           -EILSEQ,
> +                           "unterminated string");
>
>         /* of_property_count_strings() tests */
> -       rc = of_property_count_strings(np, "string-property");
> -       unittest(rc == 1, "Incorrect string count; rc=%i\n", rc);
> -       rc = of_property_count_strings(np, "phandle-list-names");
> -       unittest(rc == 3, "Incorrect string count; rc=%i\n", rc);
> -       rc = of_property_count_strings(np, "unterminated-string");
> -       unittest(rc == -EILSEQ, "unterminated string; rc=%i\n", rc);
> -       rc = of_property_count_strings(np, "unterminated-string-list");
> -       unittest(rc == -EILSEQ, "unterminated string array; rc=%i\n", rc);
> +       KUNIT_EXPECT_EQ(test,
> +                       of_property_count_strings(np, "string-property"),
> +                       1);
> +       KUNIT_EXPECT_EQ(test,
> +                       of_property_count_strings(np, "phandle-list-names"),
> +                       3);
> +       KUNIT_EXPECT_EQ_MSG(test,
> +                           of_property_count_strings(np,
> +                                                     "unterminated-string"),
> +                           -EILSEQ,
> +                           "unterminated string");
> +       KUNIT_EXPECT_EQ_MSG(test,
> +                           of_property_count_strings(
> +                                           np,
> +                                           "unterminated-string-list"),
> +                           -EILSEQ,
> +                           "unterminated string array");
>
>         /* of_property_read_string_index() tests */
>         rc = of_property_read_string_index(np, "string-property", 0, strings);
> -       unittest(rc == 0 && !strcmp(strings[0], "foobar"), "of_property_read_string_index() failure; rc=%i\n", rc);
> +       KUNIT_ASSERT_EQ(test, rc, 0);
> +       KUNIT_EXPECT_STREQ(test, strings[0], "foobar");
>         strings[0] = NULL;
>         rc = of_property_read_string_index(np, "string-property", 1, strings);
> -       unittest(rc == -ENODATA && strings[0] == NULL, "of_property_read_string_index() failure; rc=%i\n", rc);
> -       rc = of_property_read_string_index(np, "phandle-list-names", 0, strings);
> -       unittest(rc == 0 && !strcmp(strings[0], "first"), "of_property_read_string_index() failure; rc=%i\n", rc);
> -       rc = of_property_read_string_index(np, "phandle-list-names", 1, strings);
> -       unittest(rc == 0 && !strcmp(strings[0], "second"), "of_property_read_string_index() failure; rc=%i\n", rc);
> -       rc = of_property_read_string_index(np, "phandle-list-names", 2, strings);
> -       unittest(rc == 0 && !strcmp(strings[0], "third"), "of_property_read_string_index() failure; rc=%i\n", rc);
> +       KUNIT_EXPECT_EQ(test, rc, -ENODATA);
> +       KUNIT_EXPECT_EQ(test, strings[0], NULL);
> +       rc = of_property_read_string_index(np,
> +                                          "phandle-list-names",
> +                                          0,
> +                                          strings);
> +       KUNIT_ASSERT_EQ(test, rc, 0);
> +       KUNIT_EXPECT_STREQ(test, strings[0], "first");
> +       rc = of_property_read_string_index(np,
> +                                          "phandle-list-names",
> +                                          1,
> +                                          strings);
> +       KUNIT_ASSERT_EQ(test, rc, 0);
> +       KUNIT_EXPECT_STREQ(test, strings[0], "second");
> +       rc = of_property_read_string_index(np,
> +                                          "phandle-list-names",
> +                                          2,
> +                                          strings);
> +       KUNIT_ASSERT_EQ(test, rc, 0);
> +       KUNIT_EXPECT_STREQ(test, strings[0], "third");
>         strings[0] = NULL;
> -       rc = of_property_read_string_index(np, "phandle-list-names", 3, strings);
> -       unittest(rc == -ENODATA && strings[0] == NULL, "of_property_read_string_index() failure; rc=%i\n", rc);
> +       rc = of_property_read_string_index(np,
> +                                          "phandle-list-names", 3, strings);
> +       KUNIT_EXPECT_EQ(test, rc, -ENODATA);
> +       KUNIT_EXPECT_EQ(test, strings[0], NULL);
>         strings[0] = NULL;
> -       rc = of_property_read_string_index(np, "unterminated-string", 0, strings);
> -       unittest(rc == -EILSEQ && strings[0] == NULL, "of_property_read_string_index() failure; rc=%i\n", rc);
> -       rc = of_property_read_string_index(np, "unterminated-string-list", 0, strings);
> -       unittest(rc == 0 && !strcmp(strings[0], "first"), "of_property_read_string_index() failure; rc=%i\n", rc);
> +       rc = of_property_read_string_index(np,
> +                                          "unterminated-string",
> +                                          0,
> +                                          strings);
> +       KUNIT_EXPECT_EQ(test, rc, -EILSEQ);
> +       KUNIT_EXPECT_EQ(test, strings[0], NULL);
> +       rc = of_property_read_string_index(np,
> +                                          "unterminated-string-list",
> +                                          0,
> +                                          strings);
> +       KUNIT_ASSERT_EQ(test, rc, 0);
> +       KUNIT_EXPECT_STREQ(test, strings[0], "first");
>         strings[0] = NULL;
> -       rc = of_property_read_string_index(np, "unterminated-string-list", 2, strings); /* should fail */
> -       unittest(rc == -EILSEQ && strings[0] == NULL, "of_property_read_string_index() failure; rc=%i\n", rc);
> -       strings[1] = NULL;
> +       rc = of_property_read_string_index(np,
> +                                          "unterminated-string-list",
> +                                          2,
> +                                          strings); /* should fail */
> +       KUNIT_EXPECT_EQ(test, rc, -EILSEQ);
> +       KUNIT_EXPECT_EQ(test, strings[0], NULL);
>
>         /* of_property_read_string_array() tests */
> -       rc = of_property_read_string_array(np, "string-property", strings, 4);
> -       unittest(rc == 1, "Incorrect string count; rc=%i\n", rc);
> -       rc = of_property_read_string_array(np, "phandle-list-names", strings, 4);
> -       unittest(rc == 3, "Incorrect string count; rc=%i\n", rc);
> -       rc = of_property_read_string_array(np, "unterminated-string", strings, 4);
> -       unittest(rc == -EILSEQ, "unterminated string; rc=%i\n", rc);
> +       strings[1] = NULL;
> +       KUNIT_EXPECT_EQ(test,
> +                       of_property_read_string_array(np,
> +                                                     "string-property",
> +                                                     strings, 4),
> +                       1);
> +       KUNIT_EXPECT_EQ(test,
> +                       of_property_read_string_array(np,
> +                                                     "phandle-list-names",
> +                                                     strings, 4),
> +                       3);
> +       KUNIT_EXPECT_EQ_MSG(test,
> +                           of_property_read_string_array(np,
> +                                                         "unterminated-string",
> +                                                         strings, 4),
> +                           -EILSEQ,
> +                           "unterminated string");
>         /* -- An incorrectly formed string should cause a failure */
> -       rc = of_property_read_string_array(np, "unterminated-string-list", strings, 4);
> -       unittest(rc == -EILSEQ, "unterminated string array; rc=%i\n", rc);
> +       KUNIT_EXPECT_EQ_MSG(test,
> +                           of_property_read_string_array(
> +                                           np,
> +                                           "unterminated-string-list",
> +                                           strings,
> +                                           4),
> +                           -EILSEQ,
> +                           "unterminated string array");
>         /* -- parsing the correctly formed strings should still work: */
>         strings[2] = NULL;
> -       rc = of_property_read_string_array(np, "unterminated-string-list", strings, 2);
> -       unittest(rc == 2 && strings[2] == NULL, "of_property_read_string_array() failure; rc=%i\n", rc);
> +       rc = of_property_read_string_array(np,
> +                                          "unterminated-string-list",
> +                                          strings,
> +                                          2);
> +       KUNIT_EXPECT_EQ(test, rc, 2);
> +       KUNIT_EXPECT_EQ(test, strings[2], NULL);
>         strings[1] = NULL;
> -       rc = of_property_read_string_array(np, "phandle-list-names", strings, 1);
> -       unittest(rc == 1 && strings[1] == NULL, "Overwrote end of string array; rc=%i, str='%s'\n", rc, strings[1]);
> +       rc = of_property_read_string_array(np,
> +                                          "phandle-list-names",
> +                                          strings,
> +                                          1);
> +       KUNIT_ASSERT_EQ(test, rc, 1);
> +       KUNIT_EXPECT_EQ_MSG(test, strings[1], NULL,
> +                           "Overwrote end of string array");
>  }
>
>  #define propcmp(p1, p2) (((p1)->length == (p2)->length) && \
>                         (p1)->value && (p2)->value && \
>                         !memcmp((p1)->value, (p2)->value, (p1)->length) && \
>                         !strcmp((p1)->name, (p2)->name))
> -static void __init of_unittest_property_copy(void)
> +static void of_unittest_property_copy(struct kunit *test)
>  {
>  #ifdef CONFIG_OF_DYNAMIC
>         struct property p1 = { .name = "p1", .length = 0, .value = "" };
> @@ -672,20 +790,24 @@ static void __init of_unittest_property_copy(void)
>         struct property *new;
>
>         new = __of_prop_dup(&p1, GFP_KERNEL);
> -       unittest(new && propcmp(&p1, new), "empty property didn't copy correctly\n");
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, new);
> +       KUNIT_EXPECT_TRUE_MSG(test, propcmp(&p1, new),
> +                             "empty property didn't copy correctly");
>         kfree(new->value);
>         kfree(new->name);
>         kfree(new);
>
>         new = __of_prop_dup(&p2, GFP_KERNEL);
> -       unittest(new && propcmp(&p2, new), "non-empty property didn't copy correctly\n");
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, new);
> +       KUNIT_EXPECT_TRUE_MSG(test, propcmp(&p2, new),
> +                             "non-empty property didn't copy correctly");
>         kfree(new->value);
>         kfree(new->name);
>         kfree(new);
>  #endif
>  }
>
> -static void __init of_unittest_changeset(void)
> +static void of_unittest_changeset(struct kunit *test)
>  {
>  #ifdef CONFIG_OF_DYNAMIC
>         struct property *ppadd, padd = { .name = "prop-add", .length = 1, .value = "" };
> @@ -698,32 +820,32 @@ static void __init of_unittest_changeset(void)
>         struct of_changeset chgset;
>
>         n1 = __of_node_dup(NULL, "n1");
> -       unittest(n1, "testcase setup failure\n");
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, n1);
>
>         n2 = __of_node_dup(NULL, "n2");
> -       unittest(n2, "testcase setup failure\n");
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, n2);
>
>         n21 = __of_node_dup(NULL, "n21");
> -       unittest(n21, "testcase setup failure %p\n", n21);
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, n21);
>
>         nchangeset = of_find_node_by_path("/testcase-data/changeset");
>         nremove = of_get_child_by_name(nchangeset, "node-remove");
> -       unittest(nremove, "testcase setup failure\n");
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, nremove);
>
>         ppadd = __of_prop_dup(&padd, GFP_KERNEL);
> -       unittest(ppadd, "testcase setup failure\n");
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ppadd);
>
>         ppname_n1  = __of_prop_dup(&pname_n1, GFP_KERNEL);
> -       unittest(ppname_n1, "testcase setup failure\n");
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ppname_n1);
>
>         ppname_n2  = __of_prop_dup(&pname_n2, GFP_KERNEL);
> -       unittest(ppname_n2, "testcase setup failure\n");
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ppname_n2);
>
>         ppname_n21 = __of_prop_dup(&pname_n21, GFP_KERNEL);
> -       unittest(ppname_n21, "testcase setup failure\n");
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ppname_n21);
>
>         ppupdate = __of_prop_dup(&pupdate, GFP_KERNEL);
> -       unittest(ppupdate, "testcase setup failure\n");
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ppupdate);
>
>         parent = nchangeset;
>         n1->parent = parent;
> @@ -731,54 +853,82 @@ static void __init of_unittest_changeset(void)
>         n21->parent = n2;
>
>         ppremove = of_find_property(parent, "prop-remove", NULL);
> -       unittest(ppremove, "failed to find removal prop");
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ppremove);
>
>         of_changeset_init(&chgset);
>
> -       unittest(!of_changeset_attach_node(&chgset, n1), "fail attach n1\n");
> -       unittest(!of_changeset_add_property(&chgset, n1, ppname_n1), "fail add prop name\n");
> -
> -       unittest(!of_changeset_attach_node(&chgset, n2), "fail attach n2\n");
> -       unittest(!of_changeset_add_property(&chgset, n2, ppname_n2), "fail add prop name\n");
> -
> -       unittest(!of_changeset_detach_node(&chgset, nremove), "fail remove node\n");
> -       unittest(!of_changeset_add_property(&chgset, n21, ppname_n21), "fail add prop name\n");
> -
> -       unittest(!of_changeset_attach_node(&chgset, n21), "fail attach n21\n");
> -
> -       unittest(!of_changeset_add_property(&chgset, parent, ppadd), "fail add prop prop-add\n");
> -       unittest(!of_changeset_update_property(&chgset, parent, ppupdate), "fail update prop\n");
> -       unittest(!of_changeset_remove_property(&chgset, parent, ppremove), "fail remove prop\n");
> -
> -       unittest(!of_changeset_apply(&chgset), "apply failed\n");
> +       KUNIT_EXPECT_FALSE_MSG(test, of_changeset_attach_node(&chgset, n1),
> +                              "fail attach n1\n");
> +       KUNIT_EXPECT_FALSE_MSG(test,
> +                              of_changeset_add_property(&chgset,
> +                                                        n1,
> +                                                        ppname_n1),
> +                              "fail add prop name\n");
> +
> +       KUNIT_EXPECT_FALSE_MSG(test, of_changeset_attach_node(&chgset, n2),
> +                              "fail attach n2\n");
> +       KUNIT_EXPECT_FALSE_MSG(test,
> +                              of_changeset_add_property(&chgset,
> +                                                        n2,
> +                                                        ppname_n2),
> +                              "fail add prop name\n");
> +
> +       KUNIT_EXPECT_FALSE_MSG(test, of_changeset_detach_node(&chgset, nremove),
> +                              "fail remove node\n");
> +       KUNIT_EXPECT_FALSE_MSG(test,
> +                              of_changeset_add_property(&chgset,
> +                                                        n21,
> +                                                        ppname_n21),
> +                              "fail add prop name\n");
> +
> +       KUNIT_EXPECT_FALSE_MSG(test, of_changeset_attach_node(&chgset, n21),
> +                              "fail attach n21\n");
> +
> +       KUNIT_EXPECT_FALSE_MSG(test,
> +                              of_changeset_add_property(&chgset,
> +                                                        parent,
> +                                                        ppadd),
> +                              "fail add prop prop-add\n");
> +       KUNIT_EXPECT_FALSE_MSG(test,
> +                              of_changeset_update_property(&chgset,
> +                                                           parent,
> +                                                           ppupdate),
> +                              "fail update prop\n");
> +       KUNIT_EXPECT_FALSE_MSG(test,
> +                              of_changeset_remove_property(&chgset,
> +                                                           parent,
> +                                                           ppremove),
> +                              "fail remove prop\n");
> +
> +       KUNIT_EXPECT_FALSE_MSG(test, of_changeset_apply(&chgset),
> +                              "apply failed\n");
>
>         of_node_put(nchangeset);
>
>         /* Make sure node names are constructed correctly */
> -       unittest((np = of_find_node_by_path("/testcase-data/changeset/n2/n21")),
> -                "'%pOF' not added\n", n21);
> +       KUNIT_EXPECT_NOT_ERR_OR_NULL_MSG(
> +                       test,
> +                       np = of_find_node_by_path(
> +                                       "/testcase-data/changeset/n2/n21"),
> +                       "'%pOF' not added\n", n21);
>         of_node_put(np);
>
> -       unittest(!of_changeset_revert(&chgset), "revert failed\n");
> +       KUNIT_EXPECT_FALSE(test, of_changeset_revert(&chgset));
>
>         of_changeset_destroy(&chgset);
>  #endif
>  }
>
> -static void __init of_unittest_parse_interrupts(void)
> +static void of_unittest_parse_interrupts(struct kunit *test)
>  {
>         struct device_node *np;
>         struct of_phandle_args args;
>         int i, rc;
>
> -       if (of_irq_workarounds & OF_IMAP_OLDWORLD_MAC)
> -               return;
> +       KUNIT_ASSERT_FALSE(test, of_irq_workarounds & OF_IMAP_OLDWORLD_MAC);
>
>         np = of_find_node_by_path("/testcase-data/interrupts/interrupts0");
> -       if (!np) {
> -               pr_err("missing testcase data\n");
> -               return;
> -       }
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
>
>         for (i = 0; i < 4; i++) {
>                 bool passed = true;
> @@ -790,16 +940,14 @@ static void __init of_unittest_parse_interrupts(void)
>                 passed &= (args.args_count == 1);
>                 passed &= (args.args[0] == (i + 1));
>
> -               unittest(passed, "index %i - data error on node %pOF rc=%i\n",
> -                        i, args.np, rc);
> +               KUNIT_EXPECT_TRUE_MSG(test, passed,
> +                                     "index %i - data error on node %pOF rc=%i\n",
> +                                     i, args.np, rc);
>         }
>         of_node_put(np);
>
>         np = of_find_node_by_path("/testcase-data/interrupts/interrupts1");
> -       if (!np) {
> -               pr_err("missing testcase data\n");
> -               return;
> -       }
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
>
>         for (i = 0; i < 4; i++) {
>                 bool passed = true;
> @@ -836,26 +984,23 @@ static void __init of_unittest_parse_interrupts(void)
>                 default:
>                         passed = false;
>                 }
> -               unittest(passed, "index %i - data error on node %pOF rc=%i\n",
> -                        i, args.np, rc);
> +               KUNIT_EXPECT_TRUE_MSG(test, passed,
> +                                    "index %i - data error on node %pOF rc=%i\n",
> +                                    i, args.np, rc);
>         }
>         of_node_put(np);
>  }
>
> -static void __init of_unittest_parse_interrupts_extended(void)
> +static void of_unittest_parse_interrupts_extended(struct kunit *test)
>  {
>         struct device_node *np;
>         struct of_phandle_args args;
>         int i, rc;
>
> -       if (of_irq_workarounds & OF_IMAP_OLDWORLD_MAC)
> -               return;
> +       KUNIT_ASSERT_FALSE(test, of_irq_workarounds & OF_IMAP_OLDWORLD_MAC);
>
>         np = of_find_node_by_path("/testcase-data/interrupts/interrupts-extended0");
> -       if (!np) {
> -               pr_err("missing testcase data\n");
> -               return;
> -       }
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
>
>         for (i = 0; i < 7; i++) {
>                 bool passed = true;
> @@ -909,8 +1054,9 @@ static void __init of_unittest_parse_interrupts_extended(void)
>                         passed = false;
>                 }
>
> -               unittest(passed, "index %i - data error on node %pOF rc=%i\n",
> -                        i, args.np, rc);
> +               KUNIT_EXPECT_TRUE_MSG(test, passed,
> +                                     "index %i - data error on node %pOF rc=%i\n",
> +                                     i, args.np, rc);
>         }
>         of_node_put(np);
>  }
> @@ -950,7 +1096,7 @@ static struct {
>         { .path = "/testcase-data/match-node/name9", .data = "K", },
>  };
>
> -static void __init of_unittest_match_node(void)
> +static void of_unittest_match_node(struct kunit *test)
>  {
>         struct device_node *np;
>         const struct of_device_id *match;
> @@ -958,26 +1104,19 @@ static void __init of_unittest_match_node(void)
>
>         for (i = 0; i < ARRAY_SIZE(match_node_tests); i++) {
>                 np = of_find_node_by_path(match_node_tests[i].path);
> -               if (!np) {
> -                       unittest(0, "missing testcase node %s\n",
> -                               match_node_tests[i].path);
> -                       continue;
> -               }
> +               KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
>
>                 match = of_match_node(match_node_table, np);
> -               if (!match) {
> -                       unittest(0, "%s didn't match anything\n",
> -                               match_node_tests[i].path);
> -                       continue;
> -               }
> +               KUNIT_ASSERT_NOT_ERR_OR_NULL_MSG(test, np,
> +                                                "%s didn't match anything",
> +                                                match_node_tests[i].path);
>
> -               if (strcmp(match->data, match_node_tests[i].data) != 0) {
> -                       unittest(0, "%s got wrong match. expected %s, got %s\n",
> -                               match_node_tests[i].path, match_node_tests[i].data,
> -                               (const char *)match->data);
> -                       continue;
> -               }
> -               unittest(1, "passed");
> +               KUNIT_EXPECT_STREQ_MSG(test,
> +                                      match->data, match_node_tests[i].data,
> +                                      "%s got wrong match. expected %s, got %s\n",
> +                                      match_node_tests[i].path,
> +                                      match_node_tests[i].data,
> +                                      (const char *)match->data);
>         }
>  }
>
> @@ -989,9 +1128,9 @@ static struct resource test_bus_res = {
>  static const struct platform_device_info test_bus_info = {
>         .name = "unittest-bus",
>  };
> -static void __init of_unittest_platform_populate(void)
> +static void of_unittest_platform_populate(struct kunit *test)
>  {
> -       int irq, rc;
> +       int irq;
>         struct device_node *np, *child, *grandchild;
>         struct platform_device *pdev, *test_bus;
>         const struct of_device_id match[] = {
> @@ -1005,32 +1144,27 @@ static void __init of_unittest_platform_populate(void)
>         /* Test that a missing irq domain returns -EPROBE_DEFER */
>         np = of_find_node_by_path("/testcase-data/testcase-device1");
>         pdev = of_find_device_by_node(np);
> -       unittest(pdev, "device 1 creation failed\n");
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev);
>
>         if (!(of_irq_workarounds & OF_IMAP_OLDWORLD_MAC)) {
>                 irq = platform_get_irq(pdev, 0);
> -               unittest(irq == -EPROBE_DEFER,
> -                        "device deferred probe failed - %d\n", irq);
> +               KUNIT_ASSERT_EQ(test, irq, -EPROBE_DEFER);
>
>                 /* Test that a parsing failure does not return -EPROBE_DEFER */
>                 np = of_find_node_by_path("/testcase-data/testcase-device2");
>                 pdev = of_find_device_by_node(np);
> -               unittest(pdev, "device 2 creation failed\n");
> +               KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev);
>                 irq = platform_get_irq(pdev, 0);
> -               unittest(irq < 0 && irq != -EPROBE_DEFER,
> -                        "device parsing error failed - %d\n", irq);
> +               KUNIT_ASSERT_TRUE_MSG(test, irq < 0 && irq != -EPROBE_DEFER,
> +                                     "device parsing error failed - %d\n",
> +                                     irq);
>         }
>
>         np = of_find_node_by_path("/testcase-data/platform-tests");
> -       unittest(np, "No testcase data in device tree\n");
> -       if (!np)
> -               return;
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
>
>         test_bus = platform_device_register_full(&test_bus_info);
> -       rc = PTR_ERR_OR_ZERO(test_bus);
> -       unittest(!rc, "testbus registration failed; rc=%i\n", rc);
> -       if (rc)
> -               return;
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, test_bus);
>         test_bus->dev.of_node = np;
>
>         /*
> @@ -1045,17 +1179,21 @@ static void __init of_unittest_platform_populate(void)
>         of_platform_populate(np, match, NULL, &test_bus->dev);
>         for_each_child_of_node(np, child) {
>                 for_each_child_of_node(child, grandchild)
> -                       unittest(of_find_device_by_node(grandchild),
> -                                "Could not create device for node '%s'\n",
> -                                grandchild->name);
> +                       KUNIT_EXPECT_TRUE_MSG(test,
> +                                             of_find_device_by_node(
> +                                                             grandchild),
> +                                             "Could not create device for node '%s'\n",
> +                                             grandchild->name);
>         }
>
>         of_platform_depopulate(&test_bus->dev);
>         for_each_child_of_node(np, child) {
>                 for_each_child_of_node(child, grandchild)
> -                       unittest(!of_find_device_by_node(grandchild),
> -                                "device didn't get destroyed '%s'\n",
> -                                grandchild->name);
> +                       KUNIT_EXPECT_FALSE_MSG(test,
> +                                              of_find_device_by_node(
> +                                                              grandchild),
> +                                              "device didn't get destroyed '%s'\n",
> +                                              grandchild->name);
>         }
>
>         platform_device_unregister(test_bus);
> @@ -1129,7 +1267,7 @@ static int attach_node_and_children(struct device_node *np)
>   *     unittest_data_add - Reads, copies data from
>   *     linked tree and attaches it to the live tree
>   */
> -static int __init unittest_data_add(void)
> +static int unittest_data_add(void)
>  {
>         void *unittest_data;
>         struct device_node *unittest_data_node, *np;
> @@ -1200,7 +1338,7 @@ static int __init unittest_data_add(void)
>  }
>
>  #ifdef CONFIG_OF_OVERLAY
> -static int __init overlay_data_apply(const char *overlay_name, int *overlay_id);
> +static int overlay_data_apply(const char *overlay_name, int *overlay_id);
>
>  static int unittest_probe(struct platform_device *pdev)
>  {
> @@ -1429,173 +1567,157 @@ static void of_unittest_destroy_tracked_overlays(void)
>         } while (defers > 0);
>  }
>
> -static int __init of_unittest_apply_overlay(int overlay_nr, int unittest_nr,
> -               int *overlay_id)
> +static int of_unittest_apply_overlay(struct kunit *test,
> +                                    int overlay_nr,
> +                                    int unittest_nr,
> +                                    int *overlay_id)
>  {
>         const char *overlay_name;
>
>         overlay_name = overlay_name_from_nr(overlay_nr);
>
> -       if (!overlay_data_apply(overlay_name, overlay_id)) {
> -               unittest(0, "could not apply overlay \"%s\"\n",
> -                               overlay_name);
> -               return -EFAULT;
> -       }
> +       KUNIT_ASSERT_TRUE_MSG(test,
> +                             overlay_data_apply(overlay_name, overlay_id),
> +                             "could not apply overlay \"%s\"\n",
> +                             overlay_name);
>         of_unittest_track_overlay(*overlay_id);
>
>         return 0;
>  }
>
>  /* apply an overlay while checking before and after states */
> -static int __init of_unittest_apply_overlay_check(int overlay_nr,
> +static int of_unittest_apply_overlay_check(struct kunit *test, int overlay_nr,
>                 int unittest_nr, int before, int after,
>                 enum overlay_type ovtype)
>  {
> -       int ret, ovcs_id;
> +       int ovcs_id;
>
>         /* unittest device must not be in before state */
> -       if (of_unittest_device_exists(unittest_nr, ovtype) != before) {
> -               unittest(0, "%s with device @\"%s\" %s\n",
> -                               overlay_name_from_nr(overlay_nr),
> -                               unittest_path(unittest_nr, ovtype),
> -                               !before ? "enabled" : "disabled");
> -               return -EINVAL;
> -       }
> +       KUNIT_ASSERT_EQ_MSG(test,
> +                           of_unittest_device_exists(unittest_nr, ovtype),
> +                           before,
> +                           "%s with device @\"%s\" %s\n",
> +                           overlay_name_from_nr(overlay_nr),
> +                           unittest_path(unittest_nr, ovtype),
> +                           !before ? "enabled" : "disabled");
>
>         ovcs_id = 0;
> -       ret = of_unittest_apply_overlay(overlay_nr, unittest_nr, &ovcs_id);
> -       if (ret != 0) {
> -               /* of_unittest_apply_overlay already called unittest() */
> -               return ret;
> -       }
> +       KUNIT_EXPECT_EQ(test,
> +                       of_unittest_apply_overlay(test,
> +                                                 overlay_nr,
> +                                                 unittest_nr,
> +                                                 &ovcs_id),
> +                       0);
>
>         /* unittest device must be to set to after state */
> -       if (of_unittest_device_exists(unittest_nr, ovtype) != after) {
> -               unittest(0, "%s failed to create @\"%s\" %s\n",
> -                               overlay_name_from_nr(overlay_nr),
> -                               unittest_path(unittest_nr, ovtype),
> -                               !after ? "enabled" : "disabled");
> -               return -EINVAL;
> -       }
> +       KUNIT_ASSERT_EQ_MSG(test,
> +                           of_unittest_device_exists(unittest_nr, ovtype),
> +                           after,
> +                           "%s failed to create @\"%s\" %s\n",
> +                           overlay_name_from_nr(overlay_nr),
> +                           unittest_path(unittest_nr, ovtype),
> +                           !after ? "enabled" : "disabled");
>
>         return 0;
>  }
>
>  /* apply an overlay and then revert it while checking before, after states */
> -static int __init of_unittest_apply_revert_overlay_check(int overlay_nr,
> +static int of_unittest_apply_revert_overlay_check(
> +               struct kunit *test, int overlay_nr,
>                 int unittest_nr, int before, int after,
>                 enum overlay_type ovtype)
>  {
> -       int ret, ovcs_id;
> +       int ovcs_id;
>
>         /* unittest device must be in before state */
> -       if (of_unittest_device_exists(unittest_nr, ovtype) != before) {
> -               unittest(0, "%s with device @\"%s\" %s\n",
> -                               overlay_name_from_nr(overlay_nr),
> -                               unittest_path(unittest_nr, ovtype),
> -                               !before ? "enabled" : "disabled");
> -               return -EINVAL;
> -       }
> +       KUNIT_ASSERT_EQ_MSG(test,
> +                           of_unittest_device_exists(unittest_nr, ovtype),
> +                           before,
> +                           "%s with device @\"%s\" %s\n",
> +                           overlay_name_from_nr(overlay_nr),
> +                           unittest_path(unittest_nr, ovtype),
> +                           !before ? "enabled" : "disabled");
>
>         /* apply the overlay */
>         ovcs_id = 0;
> -       ret = of_unittest_apply_overlay(overlay_nr, unittest_nr, &ovcs_id);
> -       if (ret != 0) {
> -               /* of_unittest_apply_overlay already called unittest() */
> -               return ret;
> -       }
> +       KUNIT_ASSERT_EQ(test,
> +                       of_unittest_apply_overlay(test,
> +                                                 overlay_nr,
> +                                                 unittest_nr,
> +                                                 &ovcs_id),
> +                       0);
>
>         /* unittest device must be in after state */
> -       if (of_unittest_device_exists(unittest_nr, ovtype) != after) {
> -               unittest(0, "%s failed to create @\"%s\" %s\n",
> -                               overlay_name_from_nr(overlay_nr),
> -                               unittest_path(unittest_nr, ovtype),
> -                               !after ? "enabled" : "disabled");
> -               return -EINVAL;
> -       }
> -
> -       ret = of_overlay_remove(&ovcs_id);
> -       if (ret != 0) {
> -               unittest(0, "%s failed to be destroyed @\"%s\"\n",
> -                               overlay_name_from_nr(overlay_nr),
> -                               unittest_path(unittest_nr, ovtype));
> -               return ret;
> -       }
> +       KUNIT_ASSERT_EQ_MSG(test,
> +                           of_unittest_device_exists(unittest_nr, ovtype),
> +                           after,
> +                           "%s failed to create @\"%s\" %s\n",
> +                           overlay_name_from_nr(overlay_nr),
> +                           unittest_path(unittest_nr, ovtype),
> +                           !after ? "enabled" : "disabled");
> +
> +       KUNIT_ASSERT_EQ_MSG(test, of_overlay_remove(&ovcs_id), 0,
> +                           "%s failed to be destroyed @\"%s\"\n",
> +                           overlay_name_from_nr(overlay_nr),
> +                           unittest_path(unittest_nr, ovtype));
>
>         /* unittest device must be again in before state */
> -       if (of_unittest_device_exists(unittest_nr, PDEV_OVERLAY) != before) {
> -               unittest(0, "%s with device @\"%s\" %s\n",
> -                               overlay_name_from_nr(overlay_nr),
> -                               unittest_path(unittest_nr, ovtype),
> -                               !before ? "enabled" : "disabled");
> -               return -EINVAL;
> -       }
> +       KUNIT_ASSERT_EQ_MSG(test,
> +                           of_unittest_device_exists(unittest_nr,
> +                                                     PDEV_OVERLAY),
> +                           before,
> +                           "%s with device @\"%s\" %s\n",
> +                           overlay_name_from_nr(overlay_nr),
> +                           unittest_path(unittest_nr, ovtype),
> +                           !before ? "enabled" : "disabled");
>
>         return 0;
>  }
>
>  /* test activation of device */
> -static void __init of_unittest_overlay_0(void)
> +static void of_unittest_overlay_0(struct kunit *test)
>  {
>         /* device should enable */
> -       if (of_unittest_apply_overlay_check(0, 0, 0, 1, PDEV_OVERLAY))
> -               return;
> -
> -       unittest(1, "overlay test %d passed\n", 0);
> +       of_unittest_apply_overlay_check(test, 0, 0, 0, 1, PDEV_OVERLAY);
>  }
>
>  /* test deactivation of device */
> -static void __init of_unittest_overlay_1(void)
> +static void of_unittest_overlay_1(struct kunit *test)
>  {
>         /* device should disable */
> -       if (of_unittest_apply_overlay_check(1, 1, 1, 0, PDEV_OVERLAY))
> -               return;
> -
> -       unittest(1, "overlay test %d passed\n", 1);
> +       of_unittest_apply_overlay_check(test, 1, 1, 1, 0, PDEV_OVERLAY);
>  }
>
>  /* test activation of device */
> -static void __init of_unittest_overlay_2(void)
> +static void of_unittest_overlay_2(struct kunit *test)
>  {
>         /* device should enable */
> -       if (of_unittest_apply_overlay_check(2, 2, 0, 1, PDEV_OVERLAY))
> -               return;
> -
> -       unittest(1, "overlay test %d passed\n", 2);
> +       of_unittest_apply_overlay_check(test, 2, 2, 0, 1, PDEV_OVERLAY);
>  }
>
>  /* test deactivation of device */
> -static void __init of_unittest_overlay_3(void)
> +static void of_unittest_overlay_3(struct kunit *test)
>  {
>         /* device should disable */
> -       if (of_unittest_apply_overlay_check(3, 3, 1, 0, PDEV_OVERLAY))
> -               return;
> -
> -       unittest(1, "overlay test %d passed\n", 3);
> +       of_unittest_apply_overlay_check(test, 3, 3, 1, 0, PDEV_OVERLAY);
>  }
>
>  /* test activation of a full device node */
> -static void __init of_unittest_overlay_4(void)
> +static void of_unittest_overlay_4(struct kunit *test)
>  {
>         /* device should disable */
> -       if (of_unittest_apply_overlay_check(4, 4, 0, 1, PDEV_OVERLAY))
> -               return;
> -
> -       unittest(1, "overlay test %d passed\n", 4);
> +       of_unittest_apply_overlay_check(test, 4, 4, 0, 1, PDEV_OVERLAY);
>  }
>
>  /* test overlay apply/revert sequence */
> -static void __init of_unittest_overlay_5(void)
> +static void of_unittest_overlay_5(struct kunit *test)
>  {
>         /* device should disable */
> -       if (of_unittest_apply_revert_overlay_check(5, 5, 0, 1, PDEV_OVERLAY))
> -               return;
> -
> -       unittest(1, "overlay test %d passed\n", 5);
> +       of_unittest_apply_revert_overlay_check(test, 5, 5, 0, 1, PDEV_OVERLAY);
>  }
>
>  /* test overlay application in sequence */
> -static void __init of_unittest_overlay_6(void)
> +static void of_unittest_overlay_6(struct kunit *test)
>  {
>         int i, ov_id[2], ovcs_id;
>         int overlay_nr = 6, unittest_nr = 6;
> @@ -1604,74 +1726,69 @@ static void __init of_unittest_overlay_6(void)
>
>         /* unittest device must be in before state */
>         for (i = 0; i < 2; i++) {
> -               if (of_unittest_device_exists(unittest_nr + i, PDEV_OVERLAY)
> -                               != before) {
> -                       unittest(0, "%s with device @\"%s\" %s\n",
> -                                       overlay_name_from_nr(overlay_nr + i),
> -                                       unittest_path(unittest_nr + i,
> -                                               PDEV_OVERLAY),
> -                                       !before ? "enabled" : "disabled");
> -                       return;
> -               }
> +               KUNIT_ASSERT_EQ_MSG(test,
> +                                   of_unittest_device_exists(unittest_nr + i,
> +                                                             PDEV_OVERLAY),
> +                                   before,
> +                                   "%s with device @\"%s\" %s\n",
> +                                   overlay_name_from_nr(overlay_nr + i),
> +                                   unittest_path(unittest_nr + i,
> +                                                 PDEV_OVERLAY),
> +                                   !before ? "enabled" : "disabled");
>         }
>
>         /* apply the overlays */
>         for (i = 0; i < 2; i++) {
> -
>                 overlay_name = overlay_name_from_nr(overlay_nr + i);
>
> -               if (!overlay_data_apply(overlay_name, &ovcs_id)) {
> -                       unittest(0, "could not apply overlay \"%s\"\n",
> -                                       overlay_name);
> -                       return;
> -               }
> +               KUNIT_ASSERT_TRUE_MSG(test,
> +                                     overlay_data_apply(overlay_name,
> +                                                        &ovcs_id),
> +                                     "could not apply overlay \"%s\"\n",
> +                                     overlay_name);
>                 ov_id[i] = ovcs_id;
>                 of_unittest_track_overlay(ov_id[i]);
>         }
>
>         for (i = 0; i < 2; i++) {
>                 /* unittest device must be in after state */
> -               if (of_unittest_device_exists(unittest_nr + i, PDEV_OVERLAY)
> -                               != after) {
> -                       unittest(0, "overlay @\"%s\" failed @\"%s\" %s\n",
> -                                       overlay_name_from_nr(overlay_nr + i),
> -                                       unittest_path(unittest_nr + i,
> -                                               PDEV_OVERLAY),
> -                                       !after ? "enabled" : "disabled");
> -                       return;
> -               }
> +               KUNIT_ASSERT_EQ_MSG(test,
> +                                   of_unittest_device_exists(unittest_nr + i,
> +                                                             PDEV_OVERLAY),
> +                                   after,
> +                                   "overlay @\"%s\" failed @\"%s\" %s\n",
> +                                   overlay_name_from_nr(overlay_nr + i),
> +                                   unittest_path(unittest_nr + i,
> +                                                 PDEV_OVERLAY),
> +                                   !after ? "enabled" : "disabled");
>         }
>
>         for (i = 1; i >= 0; i--) {
>                 ovcs_id = ov_id[i];
> -               if (of_overlay_remove(&ovcs_id)) {
> -                       unittest(0, "%s failed destroy @\"%s\"\n",
> -                                       overlay_name_from_nr(overlay_nr + i),
> -                                       unittest_path(unittest_nr + i,
> -                                               PDEV_OVERLAY));
> -                       return;
> -               }
> +               KUNIT_ASSERT_FALSE_MSG(test, of_overlay_remove(&ovcs_id),
> +                                      "%s failed destroy @\"%s\"\n",
> +                                      overlay_name_from_nr(overlay_nr + i),
> +                                      unittest_path(unittest_nr + i,
> +                                                    PDEV_OVERLAY));
>                 of_unittest_untrack_overlay(ov_id[i]);
>         }
>
>         for (i = 0; i < 2; i++) {
>                 /* unittest device must be again in before state */
> -               if (of_unittest_device_exists(unittest_nr + i, PDEV_OVERLAY)
> -                               != before) {
> -                       unittest(0, "%s with device @\"%s\" %s\n",
> -                                       overlay_name_from_nr(overlay_nr + i),
> -                                       unittest_path(unittest_nr + i,
> -                                               PDEV_OVERLAY),
> -                                       !before ? "enabled" : "disabled");
> -                       return;
> -               }
> +               KUNIT_ASSERT_EQ_MSG(test,
> +                                   of_unittest_device_exists(unittest_nr + i,
> +                                                             PDEV_OVERLAY),
> +                                   before,
> +                                   "%s with device @\"%s\" %s\n",
> +                                   overlay_name_from_nr(overlay_nr + i),
> +                                   unittest_path(unittest_nr + i,
> +                                                 PDEV_OVERLAY),
> +                                   !before ? "enabled" : "disabled");
>         }
> -
> -       unittest(1, "overlay test %d passed\n", 6);
>  }
>
>  /* test overlay application in sequence */
> -static void __init of_unittest_overlay_8(void)
> +static void of_unittest_overlay_8(struct kunit *test)
>  {
>         int i, ov_id[2], ovcs_id;
>         int overlay_nr = 8, unittest_nr = 8;
> @@ -1681,76 +1798,73 @@ static void __init of_unittest_overlay_8(void)
>
>         /* apply the overlays */
>         for (i = 0; i < 2; i++) {
> -
>                 overlay_name = overlay_name_from_nr(overlay_nr + i);
>
> -               if (!overlay_data_apply(overlay_name, &ovcs_id)) {
> -                       unittest(0, "could not apply overlay \"%s\"\n",
> -                                       overlay_name);
> -                       return;
> -               }
> +               KUNIT_ASSERT_TRUE_MSG(test,
> +                                     overlay_data_apply(overlay_name,
> +                                                        &ovcs_id),
> +                                     "could not apply overlay \"%s\"\n",
> +                                     overlay_name);
>                 ov_id[i] = ovcs_id;
>                 of_unittest_track_overlay(ov_id[i]);
>         }
>
>         /* now try to remove first overlay (it should fail) */
>         ovcs_id = ov_id[0];
> -       if (!of_overlay_remove(&ovcs_id)) {
> -               unittest(0, "%s was destroyed @\"%s\"\n",
> -                               overlay_name_from_nr(overlay_nr + 0),
> -                               unittest_path(unittest_nr,
> -                                       PDEV_OVERLAY));
> -               return;
> -       }
> +       KUNIT_ASSERT_TRUE_MSG(test, of_overlay_remove(&ovcs_id),
> +                             "%s was destroyed @\"%s\"\n",
> +                             overlay_name_from_nr(overlay_nr + 0),
> +                             unittest_path(unittest_nr,
> +                                           PDEV_OVERLAY));
>
>         /* removing them in order should work */
>         for (i = 1; i >= 0; i--) {
>                 ovcs_id = ov_id[i];
> -               if (of_overlay_remove(&ovcs_id)) {
> -                       unittest(0, "%s not destroyed @\"%s\"\n",
> -                                       overlay_name_from_nr(overlay_nr + i),
> -                                       unittest_path(unittest_nr,
> -                                               PDEV_OVERLAY));
> -                       return;
> -               }
> +               KUNIT_ASSERT_FALSE_MSG(test, of_overlay_remove(&ovcs_id),
> +                                      "%s not destroyed @\"%s\"\n",
> +                                      overlay_name_from_nr(overlay_nr + i),
> +                                      unittest_path(unittest_nr,
> +                                                    PDEV_OVERLAY));
>                 of_unittest_untrack_overlay(ov_id[i]);
>         }
> -
> -       unittest(1, "overlay test %d passed\n", 8);
>  }
>
>  /* test insertion of a bus with parent devices */
> -static void __init of_unittest_overlay_10(void)
> +static void of_unittest_overlay_10(struct kunit *test)
>  {
> -       int ret;
>         char *child_path;
>
>         /* device should disable */
> -       ret = of_unittest_apply_overlay_check(10, 10, 0, 1, PDEV_OVERLAY);
> -       if (unittest(ret == 0,
> -                       "overlay test %d failed; overlay application\n", 10))
> -               return;
> +       KUNIT_ASSERT_EQ_MSG(test,
> +                           of_unittest_apply_overlay_check(test,
> +                                                           10,
> +                                                           10,
> +                                                           0,
> +                                                           1,
> +                                                           PDEV_OVERLAY),

I prefer putting multiple args on a line and having fewer lines.

> +                           0,
> +                           "overlay test %d failed; overlay application\n",
> +                           10);
>
>         child_path = kasprintf(GFP_KERNEL, "%s/test-unittest101",
>                         unittest_path(10, PDEV_OVERLAY));
> -       if (unittest(child_path, "overlay test %d failed; kasprintf\n", 10))
> -               return;
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, child_path);
>
> -       ret = of_path_device_type_exists(child_path, PDEV_OVERLAY);
> +       KUNIT_EXPECT_TRUE_MSG(test,
> +                             of_path_device_type_exists(child_path,
> +                                                        PDEV_OVERLAY),
> +                             "overlay test %d failed; no child device\n", 10);
>         kfree(child_path);
> -
> -       unittest(ret, "overlay test %d failed; no child device\n", 10);
>  }
>
>  /* test insertion of a bus with parent devices (and revert) */
> -static void __init of_unittest_overlay_11(void)
> +static void of_unittest_overlay_11(struct kunit *test)
>  {
> -       int ret;
> -
>         /* device should disable */
> -       ret = of_unittest_apply_revert_overlay_check(11, 11, 0, 1,
> -                       PDEV_OVERLAY);
> -       unittest(ret == 0, "overlay test %d failed; overlay apply\n", 11);
> +       KUNIT_EXPECT_FALSE(test,
> +                         of_unittest_apply_revert_overlay_check(test,
> +                                                                11, 11, 0, 1,
> +                                                                PDEV_OVERLAY));
>  }
>
>  #if IS_BUILTIN(CONFIG_I2C) && IS_ENABLED(CONFIG_OF_OVERLAY)
> @@ -1972,25 +2086,23 @@ static struct i2c_driver unittest_i2c_mux_driver = {
>
>  #endif
>
> -static int of_unittest_overlay_i2c_init(void)
> +static int of_unittest_overlay_i2c_init(struct kunit *test)
>  {
> -       int ret;
> +       KUNIT_ASSERT_EQ_MSG(test,
> +                           i2c_add_driver(&unittest_i2c_dev_driver),
> +                           0,
> +                           "could not register unittest i2c device driver\n");
>
> -       ret = i2c_add_driver(&unittest_i2c_dev_driver);
> -       if (unittest(ret == 0,
> -                       "could not register unittest i2c device driver\n"))
> -               return ret;
> -
> -       ret = platform_driver_register(&unittest_i2c_bus_driver);
> -       if (unittest(ret == 0,
> -                       "could not register unittest i2c bus driver\n"))
> -               return ret;
> +       KUNIT_ASSERT_EQ_MSG(test,
> +                           platform_driver_register(&unittest_i2c_bus_driver),
> +                           0,
> +                           "could not register unittest i2c bus driver\n");
>
>  #if IS_BUILTIN(CONFIG_I2C_MUX)
> -       ret = i2c_add_driver(&unittest_i2c_mux_driver);
> -       if (unittest(ret == 0,
> -                       "could not register unittest i2c mux driver\n"))
> -               return ret;
> +       KUNIT_ASSERT_EQ_MSG(test,
> +                           i2c_add_driver(&unittest_i2c_mux_driver),
> +                           0,
> +                           "could not register unittest i2c mux driver\n");
>  #endif
>
>         return 0;
> @@ -2005,101 +2117,89 @@ static void of_unittest_overlay_i2c_cleanup(void)
>         i2c_del_driver(&unittest_i2c_dev_driver);
>  }
>
> -static void __init of_unittest_overlay_i2c_12(void)
> +static void of_unittest_overlay_i2c_12(struct kunit *test)
>  {
>         /* device should enable */
> -       if (of_unittest_apply_overlay_check(12, 12, 0, 1, I2C_OVERLAY))
> -               return;
> -
> -       unittest(1, "overlay test %d passed\n", 12);
> +       of_unittest_apply_overlay_check(test, 12, 12, 0, 1, I2C_OVERLAY);
>  }
>
>  /* test deactivation of device */
> -static void __init of_unittest_overlay_i2c_13(void)
> +static void of_unittest_overlay_i2c_13(struct kunit *test)
>  {
>         /* device should disable */
> -       if (of_unittest_apply_overlay_check(13, 13, 1, 0, I2C_OVERLAY))
> -               return;
> -
> -       unittest(1, "overlay test %d passed\n", 13);
> +       of_unittest_apply_overlay_check(test, 13, 13, 1, 0, I2C_OVERLAY);
>  }
>
>  /* just check for i2c mux existence */
> -static void of_unittest_overlay_i2c_14(void)
> +static void of_unittest_overlay_i2c_14(struct kunit *test)
>  {
> +       KUNIT_SUCCEED(test);
>  }
>
> -static void __init of_unittest_overlay_i2c_15(void)
> +static void of_unittest_overlay_i2c_15(struct kunit *test)
>  {
>         /* device should enable */
> -       if (of_unittest_apply_overlay_check(15, 15, 0, 1, I2C_OVERLAY))
> -               return;
> -
> -       unittest(1, "overlay test %d passed\n", 15);
> +       of_unittest_apply_overlay_check(test, 15, 15, 0, 1, I2C_OVERLAY);
>  }
>
>  #else
>
> -static inline void of_unittest_overlay_i2c_14(void) { }
> -static inline void of_unittest_overlay_i2c_15(void) { }
> +static inline void of_unittest_overlay_i2c_14(struct kunit *test) { }
> +static inline void of_unittest_overlay_i2c_15(struct kunit *test) { }
>
>  #endif
>
> -static void __init of_unittest_overlay(void)
> +static void of_unittest_overlay(struct kunit *test)
>  {
>         struct device_node *bus_np = NULL;
>
> -       if (platform_driver_register(&unittest_driver)) {
> -               unittest(0, "could not register unittest driver\n");
> -               goto out;
> -       }
> +       KUNIT_ASSERT_FALSE_MSG(test,
> +                              platform_driver_register(&unittest_driver),
> +                              "could not register unittest driver\n");
>
>         bus_np = of_find_node_by_path(bus_path);
> -       if (bus_np == NULL) {
> -               unittest(0, "could not find bus_path \"%s\"\n", bus_path);
> -               goto out;
> -       }
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL_MSG(test, bus_np,
> +                                        "could not find bus_path \"%s\"\n",
> +                                        bus_path);
>
> -       if (of_platform_default_populate(bus_np, NULL, NULL)) {
> -               unittest(0, "could not populate bus @ \"%s\"\n", bus_path);
> -               goto out;
> -       }
> +       KUNIT_ASSERT_FALSE_MSG(test,
> +                              of_platform_default_populate(bus_np, NULL, NULL),
> +                              "could not populate bus @ \"%s\"\n", bus_path);
>
> -       if (!of_unittest_device_exists(100, PDEV_OVERLAY)) {
> -               unittest(0, "could not find unittest0 @ \"%s\"\n",
> -                               unittest_path(100, PDEV_OVERLAY));
> -               goto out;
> -       }
> +       KUNIT_ASSERT_TRUE_MSG(test,
> +                             of_unittest_device_exists(100, PDEV_OVERLAY),
> +                             "could not find unittest0 @ \"%s\"\n",
> +                             unittest_path(100, PDEV_OVERLAY));
>
> -       if (of_unittest_device_exists(101, PDEV_OVERLAY)) {
> -               unittest(0, "unittest1 @ \"%s\" should not exist\n",
> -                               unittest_path(101, PDEV_OVERLAY));
> -               goto out;
> -       }
> -
> -       unittest(1, "basic infrastructure of overlays passed");
> +       KUNIT_ASSERT_FALSE_MSG(test,
> +                              of_unittest_device_exists(101, PDEV_OVERLAY),
> +                              "unittest1 @ \"%s\" should not exist\n",
> +                              unittest_path(101, PDEV_OVERLAY));
>
>         /* tests in sequence */
> -       of_unittest_overlay_0();
> -       of_unittest_overlay_1();
> -       of_unittest_overlay_2();
> -       of_unittest_overlay_3();
> -       of_unittest_overlay_4();
> -       of_unittest_overlay_5();
> -       of_unittest_overlay_6();
> -       of_unittest_overlay_8();
> -
> -       of_unittest_overlay_10();
> -       of_unittest_overlay_11();
> +       of_unittest_overlay_0(test);
> +       of_unittest_overlay_1(test);
> +       of_unittest_overlay_2(test);
> +       of_unittest_overlay_3(test);
> +       of_unittest_overlay_4(test);
> +       of_unittest_overlay_5(test);
> +       of_unittest_overlay_6(test);
> +       of_unittest_overlay_8(test);
> +
> +       of_unittest_overlay_10(test);
> +       of_unittest_overlay_11(test);
>
>  #if IS_BUILTIN(CONFIG_I2C)
> -       if (unittest(of_unittest_overlay_i2c_init() == 0, "i2c init failed\n"))
> +       KUNIT_ASSERT_EQ_MSG(test,
> +                          of_unittest_overlay_i2c_init(test),
> +                          0,
> +                          "i2c init failed\n");
>                 goto out;
>
> -       of_unittest_overlay_i2c_12();
> -       of_unittest_overlay_i2c_13();
> -       of_unittest_overlay_i2c_14();
> -       of_unittest_overlay_i2c_15();
> +       of_unittest_overlay_i2c_12(test);
> +       of_unittest_overlay_i2c_13(test);
> +       of_unittest_overlay_i2c_14(test);
> +       of_unittest_overlay_i2c_15(test);
>
>         of_unittest_overlay_i2c_cleanup();
>  #endif
> @@ -2111,7 +2211,7 @@ static void __init of_unittest_overlay(void)
>  }
>
>  #else
> -static inline void __init of_unittest_overlay(void) { }
> +static inline void of_unittest_overlay(struct kunit *test) { }
>  #endif
>
>  #ifdef CONFIG_OF_OVERLAY
> @@ -2254,7 +2354,7 @@ void __init unittest_unflatten_overlay_base(void)
>   *
>   * Return 0 on unexpected error.
>   */
> -static int __init overlay_data_apply(const char *overlay_name, int *overlay_id)
> +static int overlay_data_apply(const char *overlay_name, int *overlay_id)
>  {
>         struct overlay_info *info;
>         int found = 0;
> @@ -2301,19 +2401,17 @@ static int __init overlay_data_apply(const char *overlay_name, int *overlay_id)
>   * The first part of the function is _not_ normal overlay usage; it is
>   * finishing splicing the base overlay device tree into the live tree.
>   */
> -static __init void of_unittest_overlay_high_level(void)
> +static void of_unittest_overlay_high_level(struct kunit *test)
>  {
>         struct device_node *last_sibling;
>         struct device_node *np;
>         struct device_node *of_symbols;
> -       struct device_node *overlay_base_symbols;
> +       struct device_node *overlay_base_symbols = 0;
>         struct device_node **pprev;
>         struct property *prop;
>
> -       if (!overlay_base_root) {
> -               unittest(0, "overlay_base_root not initialized\n");
> -               return;
> -       }
> +       KUNIT_ASSERT_TRUE_MSG(test, overlay_base_root,
> +                             "overlay_base_root not initialized\n");
>
>         /*
>          * Could not fixup phandles in unittest_unflatten_overlay_base()
> @@ -2358,11 +2456,10 @@ static __init void of_unittest_overlay_high_level(void)
>         }
>
>         for (np = overlay_base_root->child; np; np = np->sibling) {
> -               if (of_get_child_by_name(of_root, np->name)) {
> -                       unittest(0, "illegal node name in overlay_base %s",
> -                               np->name);
> -                       return;
> -               }
> +               KUNIT_ASSERT_FALSE_MSG(test,
> +                                     of_get_child_by_name(of_root, np->name),
> +                                     "illegal node name in overlay_base %s",
> +                                     np->name);
>         }
>
>         /*
> @@ -2395,21 +2492,24 @@ static __init void of_unittest_overlay_high_level(void)
>
>                         new_prop = __of_prop_dup(prop, GFP_KERNEL);
>                         if (!new_prop) {
> -                               unittest(0, "__of_prop_dup() of '%s' from overlay_base node __symbols__",
> -                                        prop->name);
> +                               KUNIT_FAIL(test,
> +                                          "__of_prop_dup() of '%s' from overlay_base node __symbols__",
> +                                          prop->name);
>                                 goto err_unlock;
>                         }
>                         if (__of_add_property(of_symbols, new_prop)) {
>                                 /* "name" auto-generated by unflatten */
>                                 if (!strcmp(new_prop->name, "name"))
>                                         continue;
> -                               unittest(0, "duplicate property '%s' in overlay_base node __symbols__",
> -                                        prop->name);
> +                               KUNIT_FAIL(test,
> +                                          "duplicate property '%s' in overlay_base node __symbols__",
> +                                          prop->name);
>                                 goto err_unlock;
>                         }
>                         if (__of_add_property_sysfs(of_symbols, new_prop)) {
> -                               unittest(0, "unable to add property '%s' in overlay_base node __symbols__ to sysfs",
> -                                        prop->name);
> +                               KUNIT_FAIL(test,
> +                                          "unable to add property '%s' in overlay_base node __symbols__ to sysfs",
> +                                          prop->name);
>                                 goto err_unlock;
>                         }
>                 }
> @@ -2420,14 +2520,16 @@ static __init void of_unittest_overlay_high_level(void)
>
>         /* now do the normal overlay usage test */
>
> -       unittest(overlay_data_apply("overlay", NULL),
> -                "Adding overlay 'overlay' failed\n");
> +       KUNIT_EXPECT_TRUE_MSG(test, overlay_data_apply("overlay", NULL),
> +                             "Adding overlay 'overlay' failed\n");
>
> -       unittest(overlay_data_apply("overlay_bad_phandle", NULL),
> -                "Adding overlay 'overlay_bad_phandle' failed\n");
> +       KUNIT_EXPECT_TRUE_MSG(test,
> +                             overlay_data_apply("overlay_bad_phandle", NULL),
> +                             "Adding overlay 'overlay_bad_phandle' failed\n");
>
> -       unittest(overlay_data_apply("overlay_bad_symbol", NULL),
> -                "Adding overlay 'overlay_bad_symbol' failed\n");
> +       KUNIT_EXPECT_TRUE_MSG(test,
> +                             overlay_data_apply("overlay_bad_symbol", NULL),
> +                             "Adding overlay 'overlay_bad_symbol' failed\n");
>
>         return;
>
> @@ -2437,54 +2539,49 @@ static __init void of_unittest_overlay_high_level(void)
>
>  #else
>
> -static inline __init void of_unittest_overlay_high_level(void) {}
> +static inline void of_unittest_overlay_high_level(struct kunit *test) {}
>
>  #endif
>
> -static int __init of_unittest(void)
> +static int of_test_init(struct kunit *test)
>  {
> -       struct device_node *np;
> -       int res;
> -
>         /* adding data for unittest */
> -       res = unittest_data_add();
> -       if (res)
> -               return res;
> +       KUNIT_ASSERT_EQ(test, 0, unittest_data_add());
> +
>         if (!of_aliases)
>                 of_aliases = of_find_node_by_path("/aliases");
>
> -       np = of_find_node_by_path("/testcase-data/phandle-tests/consumer-a");
> -       if (!np) {
> -               pr_info("No testcase data in device tree; not running tests\n");
> -               return 0;
> -       }
> -       of_node_put(np);
> +       KUNIT_ASSERT_NOT_ERR_OR_NULL(test, of_find_node_by_path(
> +                       "/testcase-data/phandle-tests/consumer-a"));
>
> -       pr_info("start of unittest - you will see error messages\n");
> -       of_unittest_check_tree_linkage();
> -       of_unittest_check_phandles();
> -       of_unittest_find_node_by_name();
> -       of_unittest_dynamic();
> -       of_unittest_parse_phandle_with_args();
> -       of_unittest_parse_phandle_with_args_map();
> -       of_unittest_printf();
> -       of_unittest_property_string();
> -       of_unittest_property_copy();
> -       of_unittest_changeset();
> -       of_unittest_parse_interrupts();
> -       of_unittest_parse_interrupts_extended();
> -       of_unittest_match_node();
> -       of_unittest_platform_populate();
> -       of_unittest_overlay();
> +       return 0;
> +}
>
> +static struct kunit_case of_test_cases[] = {
> +       KUNIT_CASE(of_unittest_check_tree_linkage),
> +       KUNIT_CASE(of_unittest_check_phandles),
> +       KUNIT_CASE(of_unittest_find_node_by_name),
> +       KUNIT_CASE(of_unittest_dynamic),
> +       KUNIT_CASE(of_unittest_parse_phandle_with_args),
> +       KUNIT_CASE(of_unittest_parse_phandle_with_args_map),
> +       KUNIT_CASE(of_unittest_printf),
> +       KUNIT_CASE(of_unittest_property_string),
> +       KUNIT_CASE(of_unittest_property_copy),
> +       KUNIT_CASE(of_unittest_changeset),
> +       KUNIT_CASE(of_unittest_parse_interrupts),
> +       KUNIT_CASE(of_unittest_parse_interrupts_extended),
> +       KUNIT_CASE(of_unittest_match_node),
> +       KUNIT_CASE(of_unittest_platform_populate),
> +       KUNIT_CASE(of_unittest_overlay),
>         /* Double check linkage after removing testcase data */
> -       of_unittest_check_tree_linkage();
> -
> -       of_unittest_overlay_high_level();
> -
> -       pr_info("end of unittest - %i passed, %i failed\n",
> -               unittest_results.passed, unittest_results.failed);
> +       KUNIT_CASE(of_unittest_check_tree_linkage),
> +       KUNIT_CASE(of_unittest_overlay_high_level),
> +       {},
> +};
>
> -       return 0;
> -}
> -late_initcall(of_unittest);
> +static struct kunit_module of_test_module = {
> +       .name = "of-test",
> +       .init = of_test_init,
> +       .test_cases = of_test_cases,
> +};
> +module_test(of_test_module);
> --
> 2.20.0.rc0.387.gc7a69e6b6c-goog
>
_______________________________________________
Linux-nvdimm mailing list
Linux-nvdimm@lists.01.org
https://lists.01.org/mailman/listinfo/linux-nvdimm

  reply index

Thread overview: 118+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2018-11-28 19:36 [RFC v3 00/19] kunit: introduce KUnit, the Linux kernel unit testing framework Brendan Higgins
2018-11-28 19:36 ` [RFC v3 01/19] kunit: test: add KUnit test runner core Brendan Higgins
2018-11-30  3:14   ` Luis Chamberlain
2018-12-01  1:51     ` Brendan Higgins
2018-12-01  2:57       ` Luis Chamberlain
2018-12-05 13:15     ` Anton Ivanov
2018-12-05 14:45       ` Arnd Bergmann
2018-12-05 14:49         ` Anton Ivanov
2018-11-30  3:28   ` Luis Chamberlain
     [not found]     ` <20181130032802.GG18410-dAjH6bxAqesAS62YNPtMr3dQhYtBYE6JAL8bYrjMMd8@public.gmane.org>
2018-12-01  2:08       ` Brendan Higgins
2018-12-01  3:10         ` Luis Chamberlain
     [not found]           ` <20181201031049.GL28501-dAjH6bxAqesAS62YNPtMr3dQhYtBYE6JAL8bYrjMMd8@public.gmane.org>
2018-12-03 22:47             ` Brendan Higgins
2018-12-01  3:02   ` Luis Chamberlain
2018-11-28 19:36 ` [RFC v3 10/19] kunit: test: add test managed resource tests Brendan Higgins
     [not found] ` <20181128193636.254378-1-brendanhiggins-hpIqsD4AKlfQT0dZR+AlfA@public.gmane.org>
2018-11-28 19:36   ` [RFC v3 02/19] kunit: test: add test resource management API Brendan Higgins
2018-11-28 19:36   ` [RFC v3 03/19] kunit: test: add string_stream a std::stream like string builder Brendan Higgins
2018-11-30  3:29     ` Luis Chamberlain
2018-12-01  2:14       ` Brendan Higgins
2018-12-01  3:12         ` Luis Chamberlain
2018-12-03 10:55       ` Petr Mladek
2018-12-04  0:35         ` Brendan Higgins
2018-11-28 19:36   ` [RFC v3 04/19] kunit: test: add test_stream a std::stream like logger Brendan Higgins
2018-11-28 19:36   ` [RFC v3 05/19] kunit: test: add the concept of expectations Brendan Higgins
2018-11-28 19:36   ` [RFC v3 06/19] arch: um: enable running kunit from User Mode Linux Brendan Higgins
2018-11-28 21:26     ` Rob Herring
2018-11-30  3:37       ` Luis Chamberlain
2018-11-30 14:05         ` Rob Herring
2018-11-30 18:22           ` Luis Chamberlain
     [not found]             ` <20181130182203.GS18410-dAjH6bxAqesAS62YNPtMr3dQhYtBYE6JAL8bYrjMMd8@public.gmane.org>
2018-12-03 23:22               ` Brendan Higgins
2018-11-30  3:30     ` Luis Chamberlain
2018-11-28 19:36   ` [RFC v3 07/19] kunit: test: add initial tests Brendan Higgins
2018-11-30  3:40     ` Luis Chamberlain
2018-12-03 23:26       ` Brendan Higgins
2018-12-03 23:43         ` Luis Chamberlain
2018-11-28 19:36   ` [RFC v3 08/19] arch: um: add shim to trap to allow installing a fault catcher for tests Brendan Higgins
2018-11-30  3:34     ` Luis Chamberlain
     [not found]       ` <20181130033429.GK18410-dAjH6bxAqesAS62YNPtMr3dQhYtBYE6JAL8bYrjMMd8@public.gmane.org>
2018-12-03 23:34         ` Brendan Higgins
     [not found]           ` <CAFd5g45+MAVaSW8HN9x57Y8Um=TV1Oa=-K8yExPBS-4KjLyciQ-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org>
2018-12-03 23:46             ` Luis Chamberlain
     [not found]               ` <20181203234628.GR28501-dAjH6bxAqesAS62YNPtMr3dQhYtBYE6JAL8bYrjMMd8@public.gmane.org>
2018-12-04  0:44                 ` Brendan Higgins
2018-11-30  3:41     ` Luis Chamberlain
2018-12-03 23:37       ` Brendan Higgins
2018-11-28 19:36   ` [RFC v3 09/19] kunit: test: add the concept of assertions Brendan Higgins
2018-11-28 19:36   ` [RFC v3 11/19] kunit: add Python libraries for handing KUnit config and kernel Brendan Higgins
2018-11-29 13:54     ` Kieran Bingham
     [not found]       ` <841cf4ae-501b-05ae-5863-a51010709b67-ryLnwIuWjnjg/C1BVhZhaw@public.gmane.org>
2018-12-03 23:48         ` Brendan Higgins
2018-12-04 20:47           ` Luis Chamberlain
2018-12-06 12:32             ` Kieran Bingham
2018-12-06 15:37               ` Matthew Wilcox
2018-12-07 11:30                 ` Kieran Bingham
2018-12-11 14:09                 ` Petr Mladek
2018-12-11 14:41                   ` Steven Rostedt
2018-12-11 17:01                     ` Anton Ivanov
2019-02-09  0:40                       ` Brendan Higgins
2018-12-07  1:05               ` Luis Chamberlain
2018-12-07 18:35               ` Kent Overstreet
2018-11-30  3:44     ` Luis Chamberlain
2018-12-03 23:50       ` Brendan Higgins
2018-12-04 20:48         ` Luis Chamberlain
2018-11-28 19:36   ` [RFC v3 12/19] kunit: add KUnit wrapper script and simple output parser Brendan Higgins
2018-11-28 19:36   ` [RFC v3 13/19] kunit: improve output from python wrapper Brendan Higgins
2018-11-28 19:36   ` [RFC v3 14/19] Documentation: kunit: add documentation for KUnit Brendan Higgins
2018-11-29 13:56     ` Kieran Bingham
2018-11-30  3:45       ` Luis Chamberlain
     [not found]         ` <20181130034525.GP18410-dAjH6bxAqesAS62YNPtMr3dQhYtBYE6JAL8bYrjMMd8@public.gmane.org>
2018-12-03 23:53           ` Brendan Higgins
2018-12-06 12:16             ` Kieran Bingham
2019-02-09  0:56               ` Brendan Higgins
2019-02-11 12:16                 ` Kieran Bingham
2019-02-12 22:10                   ` Brendan Higgins
2019-02-13 21:55                     ` Kieran Bingham
2019-02-14  0:17                       ` Brendan Higgins
2019-02-14 17:26                         ` Luis Chamberlain
2019-02-14 22:07                           ` Brendan Higgins
2018-11-28 19:36   ` [RFC v3 15/19] MAINTAINERS: add entry for KUnit the unit testing framework Brendan Higgins
2018-11-28 19:36   ` [RFC v3 17/19] of: unittest: migrate tests to run on KUnit Brendan Higgins
2018-11-28 20:56     ` Rob Herring [this message]
2018-11-30  0:39       ` Randy Dunlap
     [not found]         ` <18814973-8f0a-4647-a097-fcc3dc0b3cd3-wEGCiKHe2LqWVfeAwA7xHQ@public.gmane.org>
2018-12-04  0:13           ` Brendan Higgins
2018-12-04 13:40             ` Rob Herring
     [not found]               ` <CAL_JsqL_PivQbrJFEusdKAy-2EQtKL3OHbmyYSK9bzuTOQegqA-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org>
2018-12-05 23:42                 ` Brendan Higgins
2018-12-07  0:41                   ` Rob Herring
2018-12-04  0:08       ` Brendan Higgins
2019-02-13  1:44       ` Brendan Higgins
2019-02-14 20:10         ` Rob Herring
2019-02-14 21:52           ` Brendan Higgins
2019-02-18 22:56         ` Frank Rowand
2019-02-28  0:29           ` Brendan Higgins
2018-12-04 10:56     ` Frank Rowand
2018-11-28 19:36   ` [RFC v3 18/19] of: unittest: split out a couple of test cases from unittest Brendan Higgins
2018-12-04 10:58     ` Frank Rowand
2018-12-05 23:54       ` Brendan Higgins
2019-02-14 23:57         ` Frank Rowand
2019-02-15  0:56           ` Brendan Higgins
2019-02-15  2:05             ` Frank Rowand
2019-02-15 10:56               ` Brendan Higgins
2019-02-18 22:25                 ` Frank Rowand
2019-02-20 20:44                   ` Frank Rowand
2019-02-20 20:47                     ` Frank Rowand
2019-02-28  3:52                     ` Brendan Higgins
2019-03-22  0:22                       ` Frank Rowand
2019-03-22  1:30                         ` Brendan Higgins
2019-03-22  1:47                           ` Frank Rowand
2019-03-25 22:15                             ` Brendan Higgins
2019-09-20 16:57                           ` Rob Herring
2019-09-21 23:57                             ` Frank Rowand
2019-03-22  1:34                         ` Frank Rowand
2019-03-25 22:18                           ` Brendan Higgins
2018-11-28 19:36   ` [RFC v3 19/19] of: unittest: split up some super large test cases Brendan Higgins
2018-11-28 19:36 ` [RFC v3 16/19] arch: um: make UML unflatten device tree when testing Brendan Higgins
2018-11-28 21:16   ` Rob Herring
     [not found]     ` <CAL_JsqK5cG=QzMBFSZ31_-3ujnxqxv=jj3XYajbRLT7yWYZbfw-JsoAwUIsXosN+BqQ9rBEUg@public.gmane.org>
2018-12-04  0:00       ` Brendan Higgins
2018-11-30  3:46   ` Luis Chamberlain
2018-12-04  0:02     ` Brendan Higgins
2018-12-04 10:52 ` [RFC v3 00/19] kunit: introduce KUnit, the Linux kernel unit testing framework Frank Rowand
2018-12-04 11:40 ` Frank Rowand
2018-12-04 13:49   ` Rob Herring
2018-12-05 23:10     ` Brendan Higgins
2019-03-22  0:27       ` Frank Rowand
2019-03-25 22:04         ` Brendan Higgins

Reply instructions:

You may reply publically to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=CAL_Jsq+09Kx7yMBC_Jw45QGmk6U_fp4N6HOZDwYrM4tWw+_dOA@mail.gmail.com \
    --to=robh@kernel.org \
    --cc=Tim.Bird@sony.com \
    --cc=brakmo@fb.com \
    --cc=brendanhiggins@google.com \
    --cc=daniel@ffwll.ch \
    --cc=dri-devel@lists.freedesktop.org \
    --cc=frowand.list@gmail.com \
    --cc=gregkh@linuxfoundation.org \
    --cc=jdike@addtoit.com \
    --cc=joe@perches.com \
    --cc=joel@jms.id.au \
    --cc=julia.lawall@lip6.fr \
    --cc=keescook@google.com \
    --cc=khilman@baylibre.com \
    --cc=kieran.bingham@ideasonboard.com \
    --cc=knut.omang@oracle.com \
    --cc=kunit-dev@googlegroups.com \
    --cc=linux-kernel@vger.kernel.org \
    --cc=linux-kselftest@vger.kernel.org \
    --cc=linux-nvdimm@lists.01.org \
    --cc=linux-um@lists.infradead.org \
    --cc=mcgrof@kernel.org \
    --cc=mpe@ellerman.id.au \
    --cc=richard@nod.at \
    --cc=rostedt@goodmis.org \
    --cc=shuah@kernel.org \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link

Linux-NVDIMM Archive on lore.kernel.org

Archives are clonable:
	git clone --mirror https://lore.kernel.org/linux-nvdimm/0 linux-nvdimm/git/0.git

	# If you have public-inbox 1.1+ installed, you may
	# initialize and index your mirror using the following commands:
	public-inbox-init -V2 linux-nvdimm linux-nvdimm/ https://lore.kernel.org/linux-nvdimm \
		linux-nvdimm@lists.01.org
	public-inbox-index linux-nvdimm

Example config snippet for mirrors

Newsgroup available over NNTP:
	nntp://nntp.lore.kernel.org/org.01.lists.linux-nvdimm


AGPL code for this site: git clone https://public-inbox.org/public-inbox.git