From patchwork Wed Nov 28 19:36:34 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Brendan Higgins X-Patchwork-Id: 1004808 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=lists.infradead.org (client-ip=2607:7c80:54:e::133; helo=bombadil.infradead.org; envelope-from=linux-um-bounces+incoming=patchwork.ozlabs.org@lists.infradead.org; receiver=) Authentication-Results: ozlabs.org; dmarc=fail (p=reject dis=none) header.from=google.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="AKbHvaKW"; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=google.com header.i=@google.com header.b="jv5rPw2v"; dkim-atps=neutral Received: from bombadil.infradead.org (bombadil.infradead.org [IPv6:2607:7c80:54:e::133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 434rYn3xnNz9s5c for ; Thu, 29 Nov 2018 06:38:53 +1100 (AEDT) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:Cc:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:To:From:Subject:References:Mime-Version :Message-Id:In-Reply-To:Date:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=zTJKaJLO1tNH3e4Li9E01QPoxyPi90rcZKqUtWtfD00=; b=AKbHvaKWsp/RY/ YMkjsDE8ipuNY7aopfUjHmF4cJa0TZIjdELP/BmxZwXtr1bkTTSQvf549G1Z6rhGclf6/x8ZiDjAN YmVxFTFJ4jrU8DsKU58FfcWknpWF8xCG8zmfh26QsqXb/wb0XggEnBdDss7ezb+Tl3sob1suP7Aow WvWtu/aauxrvreeRhm2VkiWWvEPnrsTuS/RifxMs6/7l16k3ga+a8opzQ5fR6Xd5lp6Lohu656Jmd ca9+EyHsPPxuCNqR+A+gJBLe24dZxzlE1fOlKoB+ZLsAVIugeFXriiBrZl2n7fIOH3Cu4EA16dRXv 6aHSJKqCSFF9Te9CMfUg==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.90_1 #2 (Red Hat Linux)) id 1gS5fV-0003tk-JT; Wed, 28 Nov 2018 19:38:41 +0000 Received: from mail-qt1-x849.google.com ([2607:f8b0:4864:20::849]) by bombadil.infradead.org with esmtps (Exim 4.90_1 #2 (Red Hat Linux)) id 1gS5fP-0003mL-3A for linux-um@lists.infradead.org; Wed, 28 Nov 2018 19:38:40 +0000 Received: by mail-qt1-x849.google.com with SMTP id w1so12739037qta.12 for ; Wed, 28 Nov 2018 11:38:26 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc; bh=n3sRFfgHS0+ehQlu28YzkXASfQRHI1FBWnjtKJRIVNc=; b=jv5rPw2vzQyR6i4oGsPi83/nd4YPp620f4LEfflNZa0SDr5mtoT6t2BHkGz9jk2B3v xaGkOpgW++MeyiYvNTsVbXMdMAwmBkFDdzyY8G3yD0HDyoRrqmFsjscL4rd4UPx1D52A 60ltqe2Lzu8B7oG7PhURgdQoc8CJhScO0w/+HV9TKa8aOyODnZgFQ7vw2xxmLVRZs0v0 NWKSPsmmzmdh4hSij8OUPBg0wApkEZaIXu7btDKndWkqmx3WFyezWdOfgdbtxqUIeIlm w9If/qmd+mS1JVYlSRy7Pxmht2/zRVZCtlw6Ay9cGanBNgRg7KhNjqnHI7EiUgUC2+4s lMpQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=n3sRFfgHS0+ehQlu28YzkXASfQRHI1FBWnjtKJRIVNc=; b=uGUmKBT66FHKwAjSaP9DVFSUM5qvxEjXzmFKwlS9pVgjMYnvKRrqavIRrxic1XIGC7 nZP0Xa/rpAW6LEbgovy6Qzs/Q19edPGIVJGM97rAStYM+FtzKpbbrCrfDSZr543W1jnH YnRTaYHOjh+NkK6wecssUmdLSj1gJx2MtYonhu9ajM1OwaVxdRv3RSxf3eVg1kH0/eYF j4PxCd0THp6FbfDH6ym7BjRQbav81BHc5GCWk4OfuSU7Gzg8eb8tCYVlUeU9VFASofb9 O9LrsA7MRqU8mER+WFUzuykHwfnjuy5kANeHb9lv1l/odPI6DNsGcNCdQNtMsCHtTYBi 40Lg== X-Gm-Message-State: AA+aEWZvlC2vbN+ZRhcmRXk6yTRYuGluLsf5s1r1aQ2w3Y7IpjvjYUWt dEuG4+/B/kOTxr2mkAGNnvbTNU1YZAaVOo6MnMtWgw== X-Google-Smtp-Source: AFSGD/UJQnZ/mXZgZxiTRw1yCJ+aQT8SSMjvVEEN1Q+XIJfhm8nBSRiz3g2ZvaX/atiVqnT8/gG5gV0fnJMmGisqQk87WA== X-Received: by 2002:ac8:9d:: with SMTP id c29mr4533913qtg.50.1543433905633; Wed, 28 Nov 2018 11:38:25 -0800 (PST) Date: Wed, 28 Nov 2018 11:36:34 -0800 In-Reply-To: <20181128193636.254378-1-brendanhiggins@google.com> Message-Id: <20181128193636.254378-18-brendanhiggins@google.com> Mime-Version: 1.0 References: <20181128193636.254378-1-brendanhiggins@google.com> X-Mailer: git-send-email 2.20.0.rc0.387.gc7a69e6b6c-goog Subject: [RFC v3 17/19] of: unittest: migrate tests to run on KUnit From: Brendan Higgins To: gregkh@linuxfoundation.org, keescook@google.com, mcgrof@kernel.org, shuah@kernel.org X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20181128_113835_400293_B1899605 X-CRM114-Status: GOOD ( 13.25 ) X-Spam-Score: -7.7 (-------) X-Spam-Report: SpamAssassin version 3.4.2 on bombadil.infradead.org summary: Content analysis details: (-7.7 points) pts rule name description ---- ---------------------- -------------------------------------------------- -0.0 RCVD_IN_DNSWL_NONE RBL: Sender listed at http://www.dnswl.org/, no trust [2607:f8b0:4864:20:0:0:0:849 listed in] [list.dnswl.org] -7.5 USER_IN_DEF_DKIM_WL From: address is in the default DKIM white-list -0.0 SPF_PASS SPF: sender matches SPF record 0.1 DKIM_SIGNED Message has a DKIM or DK signature, not necessarily valid -0.1 DKIM_VALID_EF Message has a valid DKIM or DK signature from envelope-from domain -0.1 DKIM_VALID_AU Message has a valid DKIM or DK signature from author's domain -0.1 DKIM_VALID Message has at least one valid DKIM or DK signature -0.0 DKIMWL_WL_MED DKIMwl.org - Whitelisted Medium sender 0.0 T_FILL_THIS_FORM_SHORT Fill in a short form with personal information X-BeenThere: linux-um@lists.infradead.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: brakmo@fb.com, jdike@addtoit.com, dri-devel@lists.freedesktop.org, linux-kselftest@vger.kernel.org, frowand.list@gmail.com, robh@kernel.org, linux-nvdimm@lists.01.org, richard@nod.at, knut.omang@oracle.com, kieran.bingham@ideasonboard.com, joel@jms.id.au, khilman@baylibre.com, Brendan Higgins , Tim.Bird@sony.com, linux-um@lists.infradead.org, rostedt@goodmis.org, julia.lawall@lip6.fr, dan.j.williams@intel.com, kunit-dev@googlegroups.com, linux-kernel@vger.kernel.org, daniel@ffwll.ch, mpe@ellerman.id.au, joe@perches.com Sender: "linux-um" Errors-To: linux-um-bounces+incoming=patchwork.ozlabs.org@lists.infradead.org Migrate tests without any cleanup, or modifying test logic in anyway to run under KUnit using the KUnit expectation and assertion API. Signed-off-by: Brendan Higgins --- 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 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 +#include + #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) { 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); 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); + 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), + 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);