All of lore.kernel.org
 help / color / mirror / Atom feed
* [PATCH v5 1/6] kunit: Introduce _NULL and _NOT_NULL macros
@ 2022-02-11  9:41 Ricardo Ribalda
  2022-02-11  9:41 ` [PATCH v5 2/6] kunit: use NULL macros Ricardo Ribalda
                   ` (4 more replies)
  0 siblings, 5 replies; 14+ messages in thread
From: Ricardo Ribalda @ 2022-02-11  9:41 UTC (permalink / raw)
  To: kunit-dev, kasan-dev, linux-kselftest, Brendan Higgins,
	Mika Westerberg, Daniel Latypov
  Cc: Ricardo Ribalda

Today, when we want to check if a pointer is NULL and not ERR we have
two options:

KUNIT_EXPECT_TRUE(test, ptr == NULL);

or

KUNIT_EXPECT_PTR_NE(test, ptr, (struct mystruct *)NULL);

Create a new set of macros that take care of NULL checks.

Reviewed-by: Brendan Higgins <brendanhiggins@google.com>
Reviewed-by: Daniel Latypov <dlatypov@google.com>
Signed-off-by: Ricardo Ribalda <ribalda@chromium.org>
---
 include/kunit/test.h | 84 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 84 insertions(+)

diff --git a/include/kunit/test.h b/include/kunit/test.h
index 00b9ff7783ab..e6c18b609b47 100644
--- a/include/kunit/test.h
+++ b/include/kunit/test.h
@@ -1218,6 +1218,48 @@ do {									       \
 				   fmt,					       \
 				   ##__VA_ARGS__)
 
+/**
+ * KUNIT_EXPECT_NULL() - Expects that @ptr is null.
+ * @test: The test context object.
+ * @ptr: an arbitrary pointer.
+ *
+ * Sets an expectation that the value that @ptr evaluates to is null. This is
+ * semantically equivalent to KUNIT_EXPECT_PTR_EQ(@test, ptr, NULL).
+ * See KUNIT_EXPECT_TRUE() for more information.
+ */
+#define KUNIT_EXPECT_NULL(test, ptr)				               \
+	KUNIT_EXPECT_NULL_MSG(test,					       \
+			      ptr,					       \
+			      NULL)
+
+#define KUNIT_EXPECT_NULL_MSG(test, ptr, fmt, ...)	                       \
+	KUNIT_BINARY_PTR_ASSERTION(test,				       \
+				   KUNIT_EXPECTATION,			       \
+				   ptr, ==, NULL,			       \
+				   fmt,					       \
+				   ##__VA_ARGS__)
+
+/**
+ * KUNIT_EXPECT_NOT_NULL() - Expects that @ptr is not null.
+ * @test: The test context object.
+ * @ptr: an arbitrary pointer.
+ *
+ * Sets an expectation that the value that @ptr evaluates to is not null. This
+ * is semantically equivalent to KUNIT_EXPECT_PTR_NE(@test, ptr, NULL).
+ * See KUNIT_EXPECT_TRUE() for more information.
+ */
+#define KUNIT_EXPECT_NOT_NULL(test, ptr)			               \
+	KUNIT_EXPECT_NOT_NULL_MSG(test,					       \
+				  ptr,					       \
+				  NULL)
+
+#define KUNIT_EXPECT_NOT_NULL_MSG(test, ptr, fmt, ...)	                       \
+	KUNIT_BINARY_PTR_ASSERTION(test,				       \
+				   KUNIT_EXPECTATION,			       \
+				   ptr, !=, NULL,			       \
+				   fmt,					       \
+				   ##__VA_ARGS__)
+
 /**
  * KUNIT_EXPECT_NOT_ERR_OR_NULL() - Expects that @ptr is not null and not err.
  * @test: The test context object.
@@ -1485,6 +1527,48 @@ do {									       \
 				   fmt,					       \
 				   ##__VA_ARGS__)
 
+/**
+ * KUNIT_ASSERT_NULL() - Asserts that pointers @ptr is null.
+ * @test: The test context object.
+ * @ptr: an arbitrary pointer.
+ *
+ * Sets an assertion that the values that @ptr evaluates to is null. This is
+ * the same as KUNIT_EXPECT_NULL(), except it causes an assertion
+ * failure (see KUNIT_ASSERT_TRUE()) when the assertion is not met.
+ */
+#define KUNIT_ASSERT_NULL(test, ptr) \
+	KUNIT_ASSERT_NULL_MSG(test,					       \
+			      ptr,					       \
+			      NULL)
+
+#define KUNIT_ASSERT_NULL_MSG(test, ptr, fmt, ...) \
+	KUNIT_BINARY_PTR_ASSERTION(test,				       \
+				   KUNIT_ASSERTION,			       \
+				   ptr, ==, NULL,			       \
+				   fmt,					       \
+				   ##__VA_ARGS__)
+
+/**
+ * KUNIT_ASSERT_NOT_NULL() - Asserts that pointers @ptr is not null.
+ * @test: The test context object.
+ * @ptr: an arbitrary pointer.
+ *
+ * Sets an assertion that the values that @ptr evaluates to is not null. This
+ * is the same as KUNIT_EXPECT_NOT_NULL(), except it causes an assertion
+ * failure (see KUNIT_ASSERT_TRUE()) when the assertion is not met.
+ */
+#define KUNIT_ASSERT_NOT_NULL(test, ptr) \
+	KUNIT_ASSERT_NOT_NULL_MSG(test,					       \
+				  ptr,					       \
+				  NULL)
+
+#define KUNIT_ASSERT_NOT_NULL_MSG(test, ptr, fmt, ...) \
+	KUNIT_BINARY_PTR_ASSERTION(test,				       \
+				   KUNIT_ASSERTION,			       \
+				   ptr, !=, NULL,			       \
+				   fmt,					       \
+				   ##__VA_ARGS__)
+
 /**
  * KUNIT_ASSERT_NOT_ERR_OR_NULL() - Assertion that @ptr is not null and not err.
  * @test: The test context object.
-- 
2.35.1.265.g69c8d7142f-goog


^ permalink raw reply related	[flat|nested] 14+ messages in thread

* [PATCH v5 2/6] kunit: use NULL macros
  2022-02-11  9:41 [PATCH v5 1/6] kunit: Introduce _NULL and _NOT_NULL macros Ricardo Ribalda
@ 2022-02-11  9:41 ` Ricardo Ribalda
  2022-02-11  9:41 ` [PATCH v5 3/6] thunderbolt: test: " Ricardo Ribalda
                   ` (3 subsequent siblings)
  4 siblings, 0 replies; 14+ messages in thread
From: Ricardo Ribalda @ 2022-02-11  9:41 UTC (permalink / raw)
  To: kunit-dev, kasan-dev, linux-kselftest, Brendan Higgins,
	Mika Westerberg, Daniel Latypov
  Cc: Ricardo Ribalda

Replace the NULL checks with the more specific and idiomatic NULL macros.

Reviewed-by: Brendan Higgins <brendanhiggins@google.com>
Reviewed-by: Daniel Latypov <dlatypov@google.com>
Signed-off-by: Ricardo Ribalda <ribalda@chromium.org>
---
 lib/kunit/kunit-example-test.c | 2 ++
 lib/kunit/kunit-test.c         | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/lib/kunit/kunit-example-test.c b/lib/kunit/kunit-example-test.c
index 4bbf37c04eba..91b1df7f59ed 100644
--- a/lib/kunit/kunit-example-test.c
+++ b/lib/kunit/kunit-example-test.c
@@ -91,6 +91,8 @@ static void example_all_expect_macros_test(struct kunit *test)
 	KUNIT_EXPECT_NOT_ERR_OR_NULL(test, test);
 	KUNIT_EXPECT_PTR_EQ(test, NULL, NULL);
 	KUNIT_EXPECT_PTR_NE(test, test, NULL);
+	KUNIT_EXPECT_NULL(test, NULL);
+	KUNIT_EXPECT_NOT_NULL(test, test);
 
 	/* String assertions */
 	KUNIT_EXPECT_STREQ(test, "hi", "hi");
diff --git a/lib/kunit/kunit-test.c b/lib/kunit/kunit-test.c
index 555601d17f79..8e2fe083a549 100644
--- a/lib/kunit/kunit-test.c
+++ b/lib/kunit/kunit-test.c
@@ -435,7 +435,7 @@ static void kunit_log_test(struct kunit *test)
 	KUNIT_EXPECT_NOT_ERR_OR_NULL(test,
 				     strstr(suite.log, "along with this."));
 #else
-	KUNIT_EXPECT_PTR_EQ(test, test->log, (char *)NULL);
+	KUNIT_EXPECT_NULL(test, test->log);
 #endif
 }
 
-- 
2.35.1.265.g69c8d7142f-goog


^ permalink raw reply related	[flat|nested] 14+ messages in thread

* [PATCH v5 3/6] thunderbolt: test: use NULL macros
  2022-02-11  9:41 [PATCH v5 1/6] kunit: Introduce _NULL and _NOT_NULL macros Ricardo Ribalda
  2022-02-11  9:41 ` [PATCH v5 2/6] kunit: use NULL macros Ricardo Ribalda
@ 2022-02-11  9:41 ` Ricardo Ribalda
  2022-02-11 10:08   ` Mika Westerberg
  2022-02-11  9:41 ` [PATCH v5 4/6] kasan: test: Use " Ricardo Ribalda
                   ` (2 subsequent siblings)
  4 siblings, 1 reply; 14+ messages in thread
From: Ricardo Ribalda @ 2022-02-11  9:41 UTC (permalink / raw)
  To: kunit-dev, kasan-dev, linux-kselftest, Brendan Higgins,
	Mika Westerberg, Daniel Latypov
  Cc: Ricardo Ribalda

Replace the NULL checks with the more specific and idiomatic NULL macros.

Acked-by: Daniel Latypov <dlatypov@google.com>
Signed-off-by: Ricardo Ribalda <ribalda@chromium.org>
---
 drivers/thunderbolt/test.c | 134 ++++++++++++++++++-------------------
 1 file changed, 67 insertions(+), 67 deletions(-)

diff --git a/drivers/thunderbolt/test.c b/drivers/thunderbolt/test.c
index 1f69bab236ee..486e3872a50f 100644
--- a/drivers/thunderbolt/test.c
+++ b/drivers/thunderbolt/test.c
@@ -796,9 +796,9 @@ static void tb_test_path_not_connected(struct kunit *test)
 	up = &dev2->ports[9];
 
 	path = tb_path_alloc(NULL, down, 8, up, 8, 0, "PCIe Down");
-	KUNIT_ASSERT_TRUE(test, path == NULL);
+	KUNIT_ASSERT_NULL(test, path);
 	path = tb_path_alloc(NULL, down, 8, up, 8, 1, "PCIe Down");
-	KUNIT_ASSERT_TRUE(test, path == NULL);
+	KUNIT_ASSERT_NULL(test, path);
 }
 
 struct hop_expectation {
@@ -847,7 +847,7 @@ static void tb_test_path_not_bonded_lane0(struct kunit *test)
 	up = &dev->ports[9];
 
 	path = tb_path_alloc(NULL, down, 8, up, 8, 0, "PCIe Down");
-	KUNIT_ASSERT_TRUE(test, path != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, path);
 	KUNIT_ASSERT_EQ(test, path->path_length, ARRAY_SIZE(test_data));
 	for (i = 0; i < ARRAY_SIZE(test_data); i++) {
 		const struct tb_port *in_port, *out_port;
@@ -909,7 +909,7 @@ static void tb_test_path_not_bonded_lane1(struct kunit *test)
 	out = &dev->ports[13];
 
 	path = tb_path_alloc(NULL, in, 9, out, 9, 1, "Video");
-	KUNIT_ASSERT_TRUE(test, path != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, path);
 	KUNIT_ASSERT_EQ(test, path->path_length, ARRAY_SIZE(test_data));
 	for (i = 0; i < ARRAY_SIZE(test_data); i++) {
 		const struct tb_port *in_port, *out_port;
@@ -989,7 +989,7 @@ static void tb_test_path_not_bonded_lane1_chain(struct kunit *test)
 	out = &dev3->ports[13];
 
 	path = tb_path_alloc(NULL, in, 9, out, 9, 1, "Video");
-	KUNIT_ASSERT_TRUE(test, path != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, path);
 	KUNIT_ASSERT_EQ(test, path->path_length, ARRAY_SIZE(test_data));
 	for (i = 0; i < ARRAY_SIZE(test_data); i++) {
 		const struct tb_port *in_port, *out_port;
@@ -1069,7 +1069,7 @@ static void tb_test_path_not_bonded_lane1_chain_reverse(struct kunit *test)
 	out = &host->ports[5];
 
 	path = tb_path_alloc(NULL, in, 9, out, 9, 1, "Video");
-	KUNIT_ASSERT_TRUE(test, path != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, path);
 	KUNIT_ASSERT_EQ(test, path->path_length, ARRAY_SIZE(test_data));
 	for (i = 0; i < ARRAY_SIZE(test_data); i++) {
 		const struct tb_port *in_port, *out_port;
@@ -1161,7 +1161,7 @@ static void tb_test_path_mixed_chain(struct kunit *test)
 	out = &dev4->ports[13];
 
 	path = tb_path_alloc(NULL, in, 9, out, 9, 1, "Video");
-	KUNIT_ASSERT_TRUE(test, path != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, path);
 	KUNIT_ASSERT_EQ(test, path->path_length, ARRAY_SIZE(test_data));
 	for (i = 0; i < ARRAY_SIZE(test_data); i++) {
 		const struct tb_port *in_port, *out_port;
@@ -1253,7 +1253,7 @@ static void tb_test_path_mixed_chain_reverse(struct kunit *test)
 	out = &host->ports[5];
 
 	path = tb_path_alloc(NULL, in, 9, out, 9, 1, "Video");
-	KUNIT_ASSERT_TRUE(test, path != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, path);
 	KUNIT_ASSERT_EQ(test, path->path_length, ARRAY_SIZE(test_data));
 	for (i = 0; i < ARRAY_SIZE(test_data); i++) {
 		const struct tb_port *in_port, *out_port;
@@ -1297,7 +1297,7 @@ static void tb_test_tunnel_pcie(struct kunit *test)
 	down = &host->ports[8];
 	up = &dev1->ports[9];
 	tunnel1 = tb_tunnel_alloc_pci(NULL, up, down);
-	KUNIT_ASSERT_TRUE(test, tunnel1 != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, tunnel1);
 	KUNIT_EXPECT_EQ(test, tunnel1->type, TB_TUNNEL_PCI);
 	KUNIT_EXPECT_PTR_EQ(test, tunnel1->src_port, down);
 	KUNIT_EXPECT_PTR_EQ(test, tunnel1->dst_port, up);
@@ -1312,7 +1312,7 @@ static void tb_test_tunnel_pcie(struct kunit *test)
 	down = &dev1->ports[10];
 	up = &dev2->ports[9];
 	tunnel2 = tb_tunnel_alloc_pci(NULL, up, down);
-	KUNIT_ASSERT_TRUE(test, tunnel2 != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, tunnel2);
 	KUNIT_EXPECT_EQ(test, tunnel2->type, TB_TUNNEL_PCI);
 	KUNIT_EXPECT_PTR_EQ(test, tunnel2->src_port, down);
 	KUNIT_EXPECT_PTR_EQ(test, tunnel2->dst_port, up);
@@ -1349,7 +1349,7 @@ static void tb_test_tunnel_dp(struct kunit *test)
 	out = &dev->ports[13];
 
 	tunnel = tb_tunnel_alloc_dp(NULL, in, out, 0, 0);
-	KUNIT_ASSERT_TRUE(test, tunnel != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, tunnel);
 	KUNIT_EXPECT_EQ(test, tunnel->type, TB_TUNNEL_DP);
 	KUNIT_EXPECT_PTR_EQ(test, tunnel->src_port, in);
 	KUNIT_EXPECT_PTR_EQ(test, tunnel->dst_port, out);
@@ -1395,7 +1395,7 @@ static void tb_test_tunnel_dp_chain(struct kunit *test)
 	out = &dev4->ports[14];
 
 	tunnel = tb_tunnel_alloc_dp(NULL, in, out, 0, 0);
-	KUNIT_ASSERT_TRUE(test, tunnel != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, tunnel);
 	KUNIT_EXPECT_EQ(test, tunnel->type, TB_TUNNEL_DP);
 	KUNIT_EXPECT_PTR_EQ(test, tunnel->src_port, in);
 	KUNIT_EXPECT_PTR_EQ(test, tunnel->dst_port, out);
@@ -1445,7 +1445,7 @@ static void tb_test_tunnel_dp_tree(struct kunit *test)
 	out = &dev5->ports[13];
 
 	tunnel = tb_tunnel_alloc_dp(NULL, in, out, 0, 0);
-	KUNIT_ASSERT_TRUE(test, tunnel != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, tunnel);
 	KUNIT_EXPECT_EQ(test, tunnel->type, TB_TUNNEL_DP);
 	KUNIT_EXPECT_PTR_EQ(test, tunnel->src_port, in);
 	KUNIT_EXPECT_PTR_EQ(test, tunnel->dst_port, out);
@@ -1510,7 +1510,7 @@ static void tb_test_tunnel_dp_max_length(struct kunit *test)
 	out = &dev12->ports[13];
 
 	tunnel = tb_tunnel_alloc_dp(NULL, in, out, 0, 0);
-	KUNIT_ASSERT_TRUE(test, tunnel != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, tunnel);
 	KUNIT_EXPECT_EQ(test, tunnel->type, TB_TUNNEL_DP);
 	KUNIT_EXPECT_PTR_EQ(test, tunnel->src_port, in);
 	KUNIT_EXPECT_PTR_EQ(test, tunnel->dst_port, out);
@@ -1566,7 +1566,7 @@ static void tb_test_tunnel_usb3(struct kunit *test)
 	down = &host->ports[12];
 	up = &dev1->ports[16];
 	tunnel1 = tb_tunnel_alloc_usb3(NULL, up, down, 0, 0);
-	KUNIT_ASSERT_TRUE(test, tunnel1 != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, tunnel1);
 	KUNIT_EXPECT_EQ(test, tunnel1->type, TB_TUNNEL_USB3);
 	KUNIT_EXPECT_PTR_EQ(test, tunnel1->src_port, down);
 	KUNIT_EXPECT_PTR_EQ(test, tunnel1->dst_port, up);
@@ -1581,7 +1581,7 @@ static void tb_test_tunnel_usb3(struct kunit *test)
 	down = &dev1->ports[17];
 	up = &dev2->ports[16];
 	tunnel2 = tb_tunnel_alloc_usb3(NULL, up, down, 0, 0);
-	KUNIT_ASSERT_TRUE(test, tunnel2 != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, tunnel2);
 	KUNIT_EXPECT_EQ(test, tunnel2->type, TB_TUNNEL_USB3);
 	KUNIT_EXPECT_PTR_EQ(test, tunnel2->src_port, down);
 	KUNIT_EXPECT_PTR_EQ(test, tunnel2->dst_port, up);
@@ -1628,7 +1628,7 @@ static void tb_test_tunnel_port_on_path(struct kunit *test)
 	out = &dev5->ports[13];
 
 	dp_tunnel = tb_tunnel_alloc_dp(NULL, in, out, 0, 0);
-	KUNIT_ASSERT_TRUE(test, dp_tunnel != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, dp_tunnel);
 
 	KUNIT_EXPECT_TRUE(test, tb_tunnel_port_on_path(dp_tunnel, in));
 	KUNIT_EXPECT_TRUE(test, tb_tunnel_port_on_path(dp_tunnel, out));
@@ -1685,7 +1685,7 @@ static void tb_test_tunnel_dma(struct kunit *test)
 	port = &host->ports[1];
 
 	tunnel = tb_tunnel_alloc_dma(NULL, nhi, port, 8, 1, 8, 1);
-	KUNIT_ASSERT_TRUE(test, tunnel != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, tunnel);
 	KUNIT_EXPECT_EQ(test, tunnel->type, TB_TUNNEL_DMA);
 	KUNIT_EXPECT_PTR_EQ(test, tunnel->src_port, nhi);
 	KUNIT_EXPECT_PTR_EQ(test, tunnel->dst_port, port);
@@ -1728,7 +1728,7 @@ static void tb_test_tunnel_dma_rx(struct kunit *test)
 	port = &host->ports[1];
 
 	tunnel = tb_tunnel_alloc_dma(NULL, nhi, port, -1, -1, 15, 2);
-	KUNIT_ASSERT_TRUE(test, tunnel != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, tunnel);
 	KUNIT_EXPECT_EQ(test, tunnel->type, TB_TUNNEL_DMA);
 	KUNIT_EXPECT_PTR_EQ(test, tunnel->src_port, nhi);
 	KUNIT_EXPECT_PTR_EQ(test, tunnel->dst_port, port);
@@ -1765,7 +1765,7 @@ static void tb_test_tunnel_dma_tx(struct kunit *test)
 	port = &host->ports[1];
 
 	tunnel = tb_tunnel_alloc_dma(NULL, nhi, port, 15, 2, -1, -1);
-	KUNIT_ASSERT_TRUE(test, tunnel != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, tunnel);
 	KUNIT_EXPECT_EQ(test, tunnel->type, TB_TUNNEL_DMA);
 	KUNIT_EXPECT_PTR_EQ(test, tunnel->src_port, nhi);
 	KUNIT_EXPECT_PTR_EQ(test, tunnel->dst_port, port);
@@ -1811,7 +1811,7 @@ static void tb_test_tunnel_dma_chain(struct kunit *test)
 	nhi = &host->ports[7];
 	port = &dev2->ports[3];
 	tunnel = tb_tunnel_alloc_dma(NULL, nhi, port, 8, 1, 8, 1);
-	KUNIT_ASSERT_TRUE(test, tunnel != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, tunnel);
 	KUNIT_EXPECT_EQ(test, tunnel->type, TB_TUNNEL_DMA);
 	KUNIT_EXPECT_PTR_EQ(test, tunnel->src_port, nhi);
 	KUNIT_EXPECT_PTR_EQ(test, tunnel->dst_port, port);
@@ -1857,7 +1857,7 @@ static void tb_test_tunnel_dma_match(struct kunit *test)
 	port = &host->ports[1];
 
 	tunnel = tb_tunnel_alloc_dma(NULL, nhi, port, 15, 1, 15, 1);
-	KUNIT_ASSERT_TRUE(test, tunnel != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, tunnel);
 
 	KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, 15, 1, 15, 1));
 	KUNIT_ASSERT_FALSE(test, tb_tunnel_match_dma(tunnel, 8, 1, 15, 1));
@@ -1873,7 +1873,7 @@ static void tb_test_tunnel_dma_match(struct kunit *test)
 	tb_tunnel_free(tunnel);
 
 	tunnel = tb_tunnel_alloc_dma(NULL, nhi, port, 15, 1, -1, -1);
-	KUNIT_ASSERT_TRUE(test, tunnel != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, tunnel);
 	KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, 15, 1, -1, -1));
 	KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, 15, -1, -1, -1));
 	KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, -1, 1, -1, -1));
@@ -1885,7 +1885,7 @@ static void tb_test_tunnel_dma_match(struct kunit *test)
 	tb_tunnel_free(tunnel);
 
 	tunnel = tb_tunnel_alloc_dma(NULL, nhi, port, -1, -1, 15, 11);
-	KUNIT_ASSERT_TRUE(test, tunnel != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, tunnel);
 	KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, -1, -1, 15, 11));
 	KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, -1, -1, 15, -1));
 	KUNIT_ASSERT_TRUE(test, tb_tunnel_match_dma(tunnel, -1, -1, -1, 11));
@@ -1910,7 +1910,7 @@ static void tb_test_credit_alloc_legacy_not_bonded(struct kunit *test)
 	down = &host->ports[8];
 	up = &dev->ports[9];
 	tunnel = tb_tunnel_alloc_pci(NULL, up, down);
-	KUNIT_ASSERT_TRUE(test, tunnel != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, tunnel);
 	KUNIT_ASSERT_EQ(test, tunnel->npaths, (size_t)2);
 
 	path = tunnel->paths[0];
@@ -1943,7 +1943,7 @@ static void tb_test_credit_alloc_legacy_bonded(struct kunit *test)
 	down = &host->ports[8];
 	up = &dev->ports[9];
 	tunnel = tb_tunnel_alloc_pci(NULL, up, down);
-	KUNIT_ASSERT_TRUE(test, tunnel != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, tunnel);
 	KUNIT_ASSERT_EQ(test, tunnel->npaths, (size_t)2);
 
 	path = tunnel->paths[0];
@@ -1976,7 +1976,7 @@ static void tb_test_credit_alloc_pcie(struct kunit *test)
 	down = &host->ports[8];
 	up = &dev->ports[9];
 	tunnel = tb_tunnel_alloc_pci(NULL, up, down);
-	KUNIT_ASSERT_TRUE(test, tunnel != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, tunnel);
 	KUNIT_ASSERT_EQ(test, tunnel->npaths, (size_t)2);
 
 	path = tunnel->paths[0];
@@ -2010,7 +2010,7 @@ static void tb_test_credit_alloc_dp(struct kunit *test)
 	out = &dev->ports[14];
 
 	tunnel = tb_tunnel_alloc_dp(NULL, in, out, 0, 0);
-	KUNIT_ASSERT_TRUE(test, tunnel != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, tunnel);
 	KUNIT_ASSERT_EQ(test, tunnel->npaths, (size_t)3);
 
 	/* Video (main) path */
@@ -2053,7 +2053,7 @@ static void tb_test_credit_alloc_usb3(struct kunit *test)
 	down = &host->ports[12];
 	up = &dev->ports[16];
 	tunnel = tb_tunnel_alloc_usb3(NULL, up, down, 0, 0);
-	KUNIT_ASSERT_TRUE(test, tunnel != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, tunnel);
 	KUNIT_ASSERT_EQ(test, tunnel->npaths, (size_t)2);
 
 	path = tunnel->paths[0];
@@ -2087,7 +2087,7 @@ static void tb_test_credit_alloc_dma(struct kunit *test)
 	port = &dev->ports[3];
 
 	tunnel = tb_tunnel_alloc_dma(NULL, nhi, port, 8, 1, 8, 1);
-	KUNIT_ASSERT_TRUE(test, tunnel != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, tunnel);
 	KUNIT_ASSERT_EQ(test, tunnel->npaths, (size_t)2);
 
 	/* DMA RX */
@@ -2141,7 +2141,7 @@ static void tb_test_credit_alloc_dma_multiple(struct kunit *test)
 	 * remaining 1 and then we run out of buffers.
 	 */
 	tunnel1 = tb_tunnel_alloc_dma(NULL, nhi, port, 8, 1, 8, 1);
-	KUNIT_ASSERT_TRUE(test, tunnel1 != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, tunnel1);
 	KUNIT_ASSERT_EQ(test, tunnel1->npaths, (size_t)2);
 
 	path = tunnel1->paths[0];
@@ -2159,7 +2159,7 @@ static void tb_test_credit_alloc_dma_multiple(struct kunit *test)
 	KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 14U);
 
 	tunnel2 = tb_tunnel_alloc_dma(NULL, nhi, port, 9, 2, 9, 2);
-	KUNIT_ASSERT_TRUE(test, tunnel2 != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, tunnel2);
 	KUNIT_ASSERT_EQ(test, tunnel2->npaths, (size_t)2);
 
 	path = tunnel2->paths[0];
@@ -2177,7 +2177,7 @@ static void tb_test_credit_alloc_dma_multiple(struct kunit *test)
 	KUNIT_EXPECT_EQ(test, path->hops[1].initial_credits, 1U);
 
 	tunnel3 = tb_tunnel_alloc_dma(NULL, nhi, port, 10, 3, 10, 3);
-	KUNIT_ASSERT_TRUE(test, tunnel3 == NULL);
+	KUNIT_ASSERT_NULL(test, tunnel3);
 
 	/*
 	 * Release the first DMA tunnel. That should make 14 buffers
@@ -2186,7 +2186,7 @@ static void tb_test_credit_alloc_dma_multiple(struct kunit *test)
 	tb_tunnel_free(tunnel1);
 
 	tunnel3 = tb_tunnel_alloc_dma(NULL, nhi, port, 10, 3, 10, 3);
-	KUNIT_ASSERT_TRUE(test, tunnel3 != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, tunnel3);
 
 	path = tunnel3->paths[0];
 	KUNIT_ASSERT_EQ(test, path->path_length, 2);
@@ -2216,7 +2216,7 @@ static struct tb_tunnel *TB_TEST_PCIE_TUNNEL(struct kunit *test,
 	down = &host->ports[8];
 	up = &dev->ports[9];
 	pcie_tunnel = tb_tunnel_alloc_pci(NULL, up, down);
-	KUNIT_ASSERT_TRUE(test, pcie_tunnel != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, pcie_tunnel);
 	KUNIT_ASSERT_EQ(test, pcie_tunnel->npaths, (size_t)2);
 
 	path = pcie_tunnel->paths[0];
@@ -2246,7 +2246,7 @@ static struct tb_tunnel *TB_TEST_DP_TUNNEL1(struct kunit *test,
 	in = &host->ports[5];
 	out = &dev->ports[13];
 	dp_tunnel1 = tb_tunnel_alloc_dp(NULL, in, out, 0, 0);
-	KUNIT_ASSERT_TRUE(test, dp_tunnel1 != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, dp_tunnel1);
 	KUNIT_ASSERT_EQ(test, dp_tunnel1->npaths, (size_t)3);
 
 	path = dp_tunnel1->paths[0];
@@ -2283,7 +2283,7 @@ static struct tb_tunnel *TB_TEST_DP_TUNNEL2(struct kunit *test,
 	in = &host->ports[6];
 	out = &dev->ports[14];
 	dp_tunnel2 = tb_tunnel_alloc_dp(NULL, in, out, 0, 0);
-	KUNIT_ASSERT_TRUE(test, dp_tunnel2 != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, dp_tunnel2);
 	KUNIT_ASSERT_EQ(test, dp_tunnel2->npaths, (size_t)3);
 
 	path = dp_tunnel2->paths[0];
@@ -2320,7 +2320,7 @@ static struct tb_tunnel *TB_TEST_USB3_TUNNEL(struct kunit *test,
 	down = &host->ports[12];
 	up = &dev->ports[16];
 	usb3_tunnel = tb_tunnel_alloc_usb3(NULL, up, down, 0, 0);
-	KUNIT_ASSERT_TRUE(test, usb3_tunnel != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, usb3_tunnel);
 	KUNIT_ASSERT_EQ(test, usb3_tunnel->npaths, (size_t)2);
 
 	path = usb3_tunnel->paths[0];
@@ -2350,7 +2350,7 @@ static struct tb_tunnel *TB_TEST_DMA_TUNNEL1(struct kunit *test,
 	nhi = &host->ports[7];
 	port = &dev->ports[3];
 	dma_tunnel1 = tb_tunnel_alloc_dma(NULL, nhi, port, 8, 1, 8, 1);
-	KUNIT_ASSERT_TRUE(test, dma_tunnel1 != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, dma_tunnel1);
 	KUNIT_ASSERT_EQ(test, dma_tunnel1->npaths, (size_t)2);
 
 	path = dma_tunnel1->paths[0];
@@ -2380,7 +2380,7 @@ static struct tb_tunnel *TB_TEST_DMA_TUNNEL2(struct kunit *test,
 	nhi = &host->ports[7];
 	port = &dev->ports[3];
 	dma_tunnel2 = tb_tunnel_alloc_dma(NULL, nhi, port, 9, 2, 9, 2);
-	KUNIT_ASSERT_TRUE(test, dma_tunnel2 != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, dma_tunnel2);
 	KUNIT_ASSERT_EQ(test, dma_tunnel2->npaths, (size_t)2);
 
 	path = dma_tunnel2->paths[0];
@@ -2496,50 +2496,50 @@ static void tb_test_property_parse(struct kunit *test)
 	struct tb_property *p;
 
 	dir = tb_property_parse_dir(root_directory, ARRAY_SIZE(root_directory));
-	KUNIT_ASSERT_TRUE(test, dir != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, dir);
 
 	p = tb_property_find(dir, "foo", TB_PROPERTY_TYPE_TEXT);
-	KUNIT_ASSERT_TRUE(test, !p);
+	KUNIT_ASSERT_NOT_NULL(test, p);
 
 	p = tb_property_find(dir, "vendorid", TB_PROPERTY_TYPE_TEXT);
-	KUNIT_ASSERT_TRUE(test, p != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, p);
 	KUNIT_EXPECT_STREQ(test, p->value.text, "Apple Inc.");
 
 	p = tb_property_find(dir, "vendorid", TB_PROPERTY_TYPE_VALUE);
-	KUNIT_ASSERT_TRUE(test, p != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, p);
 	KUNIT_EXPECT_EQ(test, p->value.immediate, 0xa27);
 
 	p = tb_property_find(dir, "deviceid", TB_PROPERTY_TYPE_TEXT);
-	KUNIT_ASSERT_TRUE(test, p != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, p);
 	KUNIT_EXPECT_STREQ(test, p->value.text, "Macintosh");
 
 	p = tb_property_find(dir, "deviceid", TB_PROPERTY_TYPE_VALUE);
-	KUNIT_ASSERT_TRUE(test, p != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, p);
 	KUNIT_EXPECT_EQ(test, p->value.immediate, 0xa);
 
 	p = tb_property_find(dir, "missing", TB_PROPERTY_TYPE_DIRECTORY);
-	KUNIT_ASSERT_TRUE(test, !p);
+	KUNIT_ASSERT_NOT_NULL(test, p);
 
 	p = tb_property_find(dir, "network", TB_PROPERTY_TYPE_DIRECTORY);
-	KUNIT_ASSERT_TRUE(test, p != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, p);
 
 	network_dir = p->value.dir;
 	KUNIT_EXPECT_TRUE(test, uuid_equal(network_dir->uuid, &network_dir_uuid));
 
 	p = tb_property_find(network_dir, "prtcid", TB_PROPERTY_TYPE_VALUE);
-	KUNIT_ASSERT_TRUE(test, p != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, p);
 	KUNIT_EXPECT_EQ(test, p->value.immediate, 0x1);
 
 	p = tb_property_find(network_dir, "prtcvers", TB_PROPERTY_TYPE_VALUE);
-	KUNIT_ASSERT_TRUE(test, p != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, p);
 	KUNIT_EXPECT_EQ(test, p->value.immediate, 0x1);
 
 	p = tb_property_find(network_dir, "prtcrevs", TB_PROPERTY_TYPE_VALUE);
-	KUNIT_ASSERT_TRUE(test, p != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, p);
 	KUNIT_EXPECT_EQ(test, p->value.immediate, 0x1);
 
 	p = tb_property_find(network_dir, "prtcstns", TB_PROPERTY_TYPE_VALUE);
-	KUNIT_ASSERT_TRUE(test, p != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, p);
 	KUNIT_EXPECT_EQ(test, p->value.immediate, 0x0);
 
 	p = tb_property_find(network_dir, "deviceid", TB_PROPERTY_TYPE_VALUE);
@@ -2558,7 +2558,7 @@ static void tb_test_property_format(struct kunit *test)
 	int ret, i;
 
 	dir = tb_property_parse_dir(root_directory, ARRAY_SIZE(root_directory));
-	KUNIT_ASSERT_TRUE(test, dir != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, dir);
 
 	ret = tb_property_format_dir(dir, NULL, 0);
 	KUNIT_ASSERT_EQ(test, ret, ARRAY_SIZE(root_directory));
@@ -2566,7 +2566,7 @@ static void tb_test_property_format(struct kunit *test)
 	block_len = ret;
 
 	block = kunit_kzalloc(test, block_len * sizeof(u32), GFP_KERNEL);
-	KUNIT_ASSERT_TRUE(test, block != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, block);
 
 	ret = tb_property_format_dir(dir, block, block_len);
 	KUNIT_EXPECT_EQ(test, ret, 0);
@@ -2584,10 +2584,10 @@ static void compare_dirs(struct kunit *test, struct tb_property_dir *d1,
 	int n1, n2, i;
 
 	if (d1->uuid) {
-		KUNIT_ASSERT_TRUE(test, d2->uuid != NULL);
+		KUNIT_ASSERT_NOT_NULL(test, d2->uuid);
 		KUNIT_ASSERT_TRUE(test, uuid_equal(d1->uuid, d2->uuid));
 	} else {
-		KUNIT_ASSERT_TRUE(test, d2->uuid == NULL);
+		KUNIT_ASSERT_NULL(test, d2->uuid);
 	}
 
 	n1 = 0;
@@ -2606,9 +2606,9 @@ static void compare_dirs(struct kunit *test, struct tb_property_dir *d1,
 	p2 = NULL;
 	for (i = 0; i < n1; i++) {
 		p1 = tb_property_get_next(d1, p1);
-		KUNIT_ASSERT_TRUE(test, p1 != NULL);
+		KUNIT_ASSERT_NOT_NULL(test, p1);
 		p2 = tb_property_get_next(d2, p2);
-		KUNIT_ASSERT_TRUE(test, p2 != NULL);
+		KUNIT_ASSERT_NOT_NULL(test, p2);
 
 		KUNIT_ASSERT_STREQ(test, &p1->key[0], &p2->key[0]);
 		KUNIT_ASSERT_EQ(test, p1->type, p2->type);
@@ -2616,14 +2616,14 @@ static void compare_dirs(struct kunit *test, struct tb_property_dir *d1,
 
 		switch (p1->type) {
 		case TB_PROPERTY_TYPE_DIRECTORY:
-			KUNIT_ASSERT_TRUE(test, p1->value.dir != NULL);
-			KUNIT_ASSERT_TRUE(test, p2->value.dir != NULL);
+			KUNIT_ASSERT_NOT_NULL(test, p1->value.dir);
+			KUNIT_ASSERT_NOT_NULL(test, p2->value.dir);
 			compare_dirs(test, p1->value.dir, p2->value.dir);
 			break;
 
 		case TB_PROPERTY_TYPE_DATA:
-			KUNIT_ASSERT_TRUE(test, p1->value.data != NULL);
-			KUNIT_ASSERT_TRUE(test, p2->value.data != NULL);
+			KUNIT_ASSERT_NOT_NULL(test, p1->value.data);
+			KUNIT_ASSERT_NOT_NULL(test, p2->value.data);
 			KUNIT_ASSERT_TRUE(test,
 				!memcmp(p1->value.data, p2->value.data,
 					p1->length * 4)
@@ -2631,8 +2631,8 @@ static void compare_dirs(struct kunit *test, struct tb_property_dir *d1,
 			break;
 
 		case TB_PROPERTY_TYPE_TEXT:
-			KUNIT_ASSERT_TRUE(test, p1->value.text != NULL);
-			KUNIT_ASSERT_TRUE(test, p2->value.text != NULL);
+			KUNIT_ASSERT_NOT_NULL(test, p1->value.text);
+			KUNIT_ASSERT_NOT_NULL(test, p2->value.text);
 			KUNIT_ASSERT_STREQ(test, p1->value.text, p2->value.text);
 			break;
 
@@ -2654,10 +2654,10 @@ static void tb_test_property_copy(struct kunit *test)
 	int ret, i;
 
 	src = tb_property_parse_dir(root_directory, ARRAY_SIZE(root_directory));
-	KUNIT_ASSERT_TRUE(test, src != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, src);
 
 	dst = tb_property_copy_dir(src);
-	KUNIT_ASSERT_TRUE(test, dst != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, dst);
 
 	/* Compare the structures */
 	compare_dirs(test, src, dst);
@@ -2667,7 +2667,7 @@ static void tb_test_property_copy(struct kunit *test)
 	KUNIT_ASSERT_EQ(test, ret, ARRAY_SIZE(root_directory));
 
 	block = kunit_kzalloc(test, sizeof(root_directory), GFP_KERNEL);
-	KUNIT_ASSERT_TRUE(test, block != NULL);
+	KUNIT_ASSERT_NOT_NULL(test, block);
 
 	ret = tb_property_format_dir(dst, block, ARRAY_SIZE(root_directory));
 	KUNIT_EXPECT_TRUE(test, !ret);
-- 
2.35.1.265.g69c8d7142f-goog


^ permalink raw reply related	[flat|nested] 14+ messages in thread

* [PATCH v5 4/6] kasan: test: Use NULL macros
  2022-02-11  9:41 [PATCH v5 1/6] kunit: Introduce _NULL and _NOT_NULL macros Ricardo Ribalda
  2022-02-11  9:41 ` [PATCH v5 2/6] kunit: use NULL macros Ricardo Ribalda
  2022-02-11  9:41 ` [PATCH v5 3/6] thunderbolt: test: " Ricardo Ribalda
@ 2022-02-11  9:41 ` Ricardo Ribalda
  2022-02-11  9:41 ` [PATCH v5 5/6] mctp: " Ricardo Ribalda
  2022-02-11  9:41 ` [PATCH v5 6/6] apparmor: " Ricardo Ribalda
  4 siblings, 0 replies; 14+ messages in thread
From: Ricardo Ribalda @ 2022-02-11  9:41 UTC (permalink / raw)
  To: kunit-dev, kasan-dev, linux-kselftest, Brendan Higgins,
	Mika Westerberg, Daniel Latypov
  Cc: Ricardo Ribalda

Replace PTR_EQ checks with the more idiomatic and specific NULL macros.

Acked-by: Daniel Latypov <dlatypov@google.com>
Signed-off-by: Ricardo Ribalda <ribalda@chromium.org>
---
 lib/test_kasan.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/test_kasan.c b/lib/test_kasan.c
index 847cdbefab46..d680f46740b8 100644
--- a/lib/test_kasan.c
+++ b/lib/test_kasan.c
@@ -385,7 +385,7 @@ static void krealloc_uaf(struct kunit *test)
 	kfree(ptr1);
 
 	KUNIT_EXPECT_KASAN_FAIL(test, ptr2 = krealloc(ptr1, size2, GFP_KERNEL));
-	KUNIT_ASSERT_PTR_EQ(test, (void *)ptr2, NULL);
+	KUNIT_ASSERT_NULL(test, ptr2);
 	KUNIT_EXPECT_KASAN_FAIL(test, *(volatile char *)ptr1);
 }
 
-- 
2.35.1.265.g69c8d7142f-goog


^ permalink raw reply related	[flat|nested] 14+ messages in thread

* [PATCH v5 5/6] mctp: test: Use NULL macros
  2022-02-11  9:41 [PATCH v5 1/6] kunit: Introduce _NULL and _NOT_NULL macros Ricardo Ribalda
                   ` (2 preceding siblings ...)
  2022-02-11  9:41 ` [PATCH v5 4/6] kasan: test: Use " Ricardo Ribalda
@ 2022-02-11  9:41 ` Ricardo Ribalda
  2022-02-11  9:41 ` [PATCH v5 6/6] apparmor: " Ricardo Ribalda
  4 siblings, 0 replies; 14+ messages in thread
From: Ricardo Ribalda @ 2022-02-11  9:41 UTC (permalink / raw)
  To: kunit-dev, kasan-dev, linux-kselftest, Brendan Higgins,
	Mika Westerberg, Daniel Latypov
  Cc: Ricardo Ribalda

Replace the PTR_EQ NULL checks wit the NULL macros. More idiomatic and
specific.

Acked-by: Daniel Latypov <dlatypov@google.com>
Signed-off-by: Ricardo Ribalda <ribalda@chromium.org>
---
 net/mctp/test/route-test.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/net/mctp/test/route-test.c b/net/mctp/test/route-test.c
index 750f9f9b4daf..eb70b524c78e 100644
--- a/net/mctp/test/route-test.c
+++ b/net/mctp/test/route-test.c
@@ -361,7 +361,7 @@ static void mctp_test_route_input_sk(struct kunit *test)
 	} else {
 		KUNIT_EXPECT_NE(test, rc, 0);
 		skb2 = skb_recv_datagram(sock->sk, 0, 1, &rc);
-		KUNIT_EXPECT_PTR_EQ(test, skb2, NULL);
+		KUNIT_EXPECT_NULL(test, skb2);
 	}
 
 	__mctp_route_test_fini(test, dev, rt, sock);
@@ -430,7 +430,7 @@ static void mctp_test_route_input_sk_reasm(struct kunit *test)
 		skb_free_datagram(sock->sk, skb2);
 
 	} else {
-		KUNIT_EXPECT_PTR_EQ(test, skb2, NULL);
+		KUNIT_EXPECT_NULL(test, skb2);
 	}
 
 	__mctp_route_test_fini(test, dev, rt, sock);
-- 
2.35.1.265.g69c8d7142f-goog


^ permalink raw reply related	[flat|nested] 14+ messages in thread

* [PATCH v5 6/6] apparmor: test: Use NULL macros
  2022-02-11  9:41 [PATCH v5 1/6] kunit: Introduce _NULL and _NOT_NULL macros Ricardo Ribalda
                   ` (3 preceding siblings ...)
  2022-02-11  9:41 ` [PATCH v5 5/6] mctp: " Ricardo Ribalda
@ 2022-02-11  9:41 ` Ricardo Ribalda
  4 siblings, 0 replies; 14+ messages in thread
From: Ricardo Ribalda @ 2022-02-11  9:41 UTC (permalink / raw)
  To: kunit-dev, kasan-dev, linux-kselftest, Brendan Higgins,
	Mika Westerberg, Daniel Latypov
  Cc: Ricardo Ribalda

Replace the PTR_EQ NULL checks with the more idiomatic and specific NULL
macros.

Acked-by: Daniel Latypov <dlatypov@google.com>
Signed-off-by: Ricardo Ribalda <ribalda@chromium.org>
---
 security/apparmor/policy_unpack_test.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/security/apparmor/policy_unpack_test.c b/security/apparmor/policy_unpack_test.c
index 533137f45361..5c18d2f19862 100644
--- a/security/apparmor/policy_unpack_test.c
+++ b/security/apparmor/policy_unpack_test.c
@@ -313,7 +313,7 @@ static void policy_unpack_test_unpack_strdup_out_of_bounds(struct kunit *test)
 	size = unpack_strdup(puf->e, &string, TEST_STRING_NAME);
 
 	KUNIT_EXPECT_EQ(test, size, 0);
-	KUNIT_EXPECT_PTR_EQ(test, string, (char *)NULL);
+	KUNIT_EXPECT_NULL(test, string);
 	KUNIT_EXPECT_PTR_EQ(test, puf->e->pos, start);
 }
 
@@ -409,7 +409,7 @@ static void policy_unpack_test_unpack_u16_chunk_out_of_bounds_1(
 	size = unpack_u16_chunk(puf->e, &chunk);
 
 	KUNIT_EXPECT_EQ(test, size, (size_t)0);
-	KUNIT_EXPECT_PTR_EQ(test, chunk, (char *)NULL);
+	KUNIT_EXPECT_NULL(test, chunk);
 	KUNIT_EXPECT_PTR_EQ(test, puf->e->pos, puf->e->end - 1);
 }
 
@@ -431,7 +431,7 @@ static void policy_unpack_test_unpack_u16_chunk_out_of_bounds_2(
 	size = unpack_u16_chunk(puf->e, &chunk);
 
 	KUNIT_EXPECT_EQ(test, size, (size_t)0);
-	KUNIT_EXPECT_PTR_EQ(test, chunk, (char *)NULL);
+	KUNIT_EXPECT_NULL(test, chunk);
 	KUNIT_EXPECT_PTR_EQ(test, puf->e->pos, puf->e->start + TEST_U16_OFFSET);
 }
 
-- 
2.35.1.265.g69c8d7142f-goog


^ permalink raw reply related	[flat|nested] 14+ messages in thread

* Re: [PATCH v5 3/6] thunderbolt: test: use NULL macros
  2022-02-11  9:41 ` [PATCH v5 3/6] thunderbolt: test: " Ricardo Ribalda
@ 2022-02-11 10:08   ` Mika Westerberg
  2022-02-11 15:49     ` Ricardo Ribalda
  0 siblings, 1 reply; 14+ messages in thread
From: Mika Westerberg @ 2022-02-11 10:08 UTC (permalink / raw)
  To: Ricardo Ribalda
  Cc: kunit-dev, kasan-dev, linux-kselftest, Brendan Higgins, Daniel Latypov

Hi,

On Fri, Feb 11, 2022 at 10:41:30AM +0100, Ricardo Ribalda wrote:
> Replace the NULL checks with the more specific and idiomatic NULL macros.
> 
> Acked-by: Daniel Latypov <dlatypov@google.com>
> Signed-off-by: Ricardo Ribalda <ribalda@chromium.org>
> ---

...

> @@ -2496,50 +2496,50 @@ static void tb_test_property_parse(struct kunit *test)
>  	struct tb_property *p;
>  
>  	dir = tb_property_parse_dir(root_directory, ARRAY_SIZE(root_directory));
> -	KUNIT_ASSERT_TRUE(test, dir != NULL);
> +	KUNIT_ASSERT_NOT_NULL(test, dir);
>  
>  	p = tb_property_find(dir, "foo", TB_PROPERTY_TYPE_TEXT);
> -	KUNIT_ASSERT_TRUE(test, !p);
> +	KUNIT_ASSERT_NOT_NULL(test, p);

This should be KUNIT_ASSERT_NULL(test, p) as we specifically want to
check that the property does not exist (!p is same as p == NULL).

>  	p = tb_property_find(dir, "vendorid", TB_PROPERTY_TYPE_TEXT);
> -	KUNIT_ASSERT_TRUE(test, p != NULL);
> +	KUNIT_ASSERT_NOT_NULL(test, p);
>  	KUNIT_EXPECT_STREQ(test, p->value.text, "Apple Inc.");
>  
>  	p = tb_property_find(dir, "vendorid", TB_PROPERTY_TYPE_VALUE);
> -	KUNIT_ASSERT_TRUE(test, p != NULL);
> +	KUNIT_ASSERT_NOT_NULL(test, p);
>  	KUNIT_EXPECT_EQ(test, p->value.immediate, 0xa27);
>  
>  	p = tb_property_find(dir, "deviceid", TB_PROPERTY_TYPE_TEXT);
> -	KUNIT_ASSERT_TRUE(test, p != NULL);
> +	KUNIT_ASSERT_NOT_NULL(test, p);
>  	KUNIT_EXPECT_STREQ(test, p->value.text, "Macintosh");
>  
>  	p = tb_property_find(dir, "deviceid", TB_PROPERTY_TYPE_VALUE);
> -	KUNIT_ASSERT_TRUE(test, p != NULL);
> +	KUNIT_ASSERT_NOT_NULL(test, p);
>  	KUNIT_EXPECT_EQ(test, p->value.immediate, 0xa);
>  
>  	p = tb_property_find(dir, "missing", TB_PROPERTY_TYPE_DIRECTORY);
> -	KUNIT_ASSERT_TRUE(test, !p);
> +	KUNIT_ASSERT_NOT_NULL(test, p);

Ditto here.

With those fixed (please also run the tests if possible to see that they
still pass) you can add,

Acked-by: Mika Westerberg <mika.westerberg@linux.intel.com>

Thanks!

^ permalink raw reply	[flat|nested] 14+ messages in thread

* Re: [PATCH v5 3/6] thunderbolt: test: use NULL macros
  2022-02-11 10:08   ` Mika Westerberg
@ 2022-02-11 15:49     ` Ricardo Ribalda
  2022-02-11 16:26       ` Mika Westerberg
  0 siblings, 1 reply; 14+ messages in thread
From: Ricardo Ribalda @ 2022-02-11 15:49 UTC (permalink / raw)
  To: Mika Westerberg
  Cc: kunit-dev, kasan-dev, linux-kselftest, Brendan Higgins, Daniel Latypov

Hi Mika

On Fri, 11 Feb 2022 at 11:08, Mika Westerberg
<mika.westerberg@linux.intel.com> wrote:
>
> Hi,
>
> On Fri, Feb 11, 2022 at 10:41:30AM +0100, Ricardo Ribalda wrote:
> > Replace the NULL checks with the more specific and idiomatic NULL macros.
> >
> > Acked-by: Daniel Latypov <dlatypov@google.com>
> > Signed-off-by: Ricardo Ribalda <ribalda@chromium.org>
> > ---
>
> ...
>
> > @@ -2496,50 +2496,50 @@ static void tb_test_property_parse(struct kunit *test)
> >       struct tb_property *p;
> >
> >       dir = tb_property_parse_dir(root_directory, ARRAY_SIZE(root_directory));
> > -     KUNIT_ASSERT_TRUE(test, dir != NULL);
> > +     KUNIT_ASSERT_NOT_NULL(test, dir);
> >
> >       p = tb_property_find(dir, "foo", TB_PROPERTY_TYPE_TEXT);
> > -     KUNIT_ASSERT_TRUE(test, !p);
> > +     KUNIT_ASSERT_NOT_NULL(test, p);
>
> This should be KUNIT_ASSERT_NULL(test, p) as we specifically want to
> check that the property does not exist (!p is same as p == NULL).
>
> >       p = tb_property_find(dir, "vendorid", TB_PROPERTY_TYPE_TEXT);
> > -     KUNIT_ASSERT_TRUE(test, p != NULL);
> > +     KUNIT_ASSERT_NOT_NULL(test, p);
> >       KUNIT_EXPECT_STREQ(test, p->value.text, "Apple Inc.");
> >
> >       p = tb_property_find(dir, "vendorid", TB_PROPERTY_TYPE_VALUE);
> > -     KUNIT_ASSERT_TRUE(test, p != NULL);
> > +     KUNIT_ASSERT_NOT_NULL(test, p);
> >       KUNIT_EXPECT_EQ(test, p->value.immediate, 0xa27);
> >
> >       p = tb_property_find(dir, "deviceid", TB_PROPERTY_TYPE_TEXT);
> > -     KUNIT_ASSERT_TRUE(test, p != NULL);
> > +     KUNIT_ASSERT_NOT_NULL(test, p);
> >       KUNIT_EXPECT_STREQ(test, p->value.text, "Macintosh");
> >
> >       p = tb_property_find(dir, "deviceid", TB_PROPERTY_TYPE_VALUE);
> > -     KUNIT_ASSERT_TRUE(test, p != NULL);
> > +     KUNIT_ASSERT_NOT_NULL(test, p);
> >       KUNIT_EXPECT_EQ(test, p->value.immediate, 0xa);
> >
> >       p = tb_property_find(dir, "missing", TB_PROPERTY_TYPE_DIRECTORY);
> > -     KUNIT_ASSERT_TRUE(test, !p);
> > +     KUNIT_ASSERT_NOT_NULL(test, p);
>
> Ditto here.
>
> With those fixed (please also run the tests if possible to see that they
> still pass) you can add,
>

Thanks!

To test it I had enabled:
PCI, USB4 and USB4_KUNIT_TEST

and then run it with

./tools/testing/kunit/kunit.py run --jobs=$(nproc) --arch=x86_64

Unfortunately, kunit was not able to run the tests

This hack did the trick:


 int tb_test_init(void)
 {
-       return __kunit_test_suites_init(tb_test_suites);
+       //return __kunit_test_suites_init(tb_test_suites);
+       return 0;
 }

 void tb_test_exit(void)
 {
-       return __kunit_test_suites_exit(tb_test_suites);
+       //return __kunit_test_suites_exit(tb_test_suites);
 }
+
+kunit_test_suites(&tb_test_suite);

I looked into why we do this and I found:

thunderbolt: Allow KUnit tests to be built also when CONFIG_USB4=m


I am a bit confused. The patch talks about build coverage, but even
with that patch reverted if
USB4_KUNIT_TEST=m
then test.c is built.

Shouldn't we simply revert that patch?

Thanks!

> Acked-by: Mika Westerberg <mika.westerberg@linux.intel.com>
>
> Thanks!



-- 
Ricardo Ribalda

^ permalink raw reply	[flat|nested] 14+ messages in thread

* Re: [PATCH v5 3/6] thunderbolt: test: use NULL macros
  2022-02-11 15:49     ` Ricardo Ribalda
@ 2022-02-11 16:26       ` Mika Westerberg
  2022-02-11 16:31         ` Mika Westerberg
  0 siblings, 1 reply; 14+ messages in thread
From: Mika Westerberg @ 2022-02-11 16:26 UTC (permalink / raw)
  To: Ricardo Ribalda
  Cc: kunit-dev, kasan-dev, linux-kselftest, Brendan Higgins, Daniel Latypov

On Fri, Feb 11, 2022 at 04:49:21PM +0100, Ricardo Ribalda wrote:
> Hi Mika
> 
> On Fri, 11 Feb 2022 at 11:08, Mika Westerberg
> <mika.westerberg@linux.intel.com> wrote:
> >
> > Hi,
> >
> > On Fri, Feb 11, 2022 at 10:41:30AM +0100, Ricardo Ribalda wrote:
> > > Replace the NULL checks with the more specific and idiomatic NULL macros.
> > >
> > > Acked-by: Daniel Latypov <dlatypov@google.com>
> > > Signed-off-by: Ricardo Ribalda <ribalda@chromium.org>
> > > ---
> >
> > ...
> >
> > > @@ -2496,50 +2496,50 @@ static void tb_test_property_parse(struct kunit *test)
> > >       struct tb_property *p;
> > >
> > >       dir = tb_property_parse_dir(root_directory, ARRAY_SIZE(root_directory));
> > > -     KUNIT_ASSERT_TRUE(test, dir != NULL);
> > > +     KUNIT_ASSERT_NOT_NULL(test, dir);
> > >
> > >       p = tb_property_find(dir, "foo", TB_PROPERTY_TYPE_TEXT);
> > > -     KUNIT_ASSERT_TRUE(test, !p);
> > > +     KUNIT_ASSERT_NOT_NULL(test, p);
> >
> > This should be KUNIT_ASSERT_NULL(test, p) as we specifically want to
> > check that the property does not exist (!p is same as p == NULL).
> >
> > >       p = tb_property_find(dir, "vendorid", TB_PROPERTY_TYPE_TEXT);
> > > -     KUNIT_ASSERT_TRUE(test, p != NULL);
> > > +     KUNIT_ASSERT_NOT_NULL(test, p);
> > >       KUNIT_EXPECT_STREQ(test, p->value.text, "Apple Inc.");
> > >
> > >       p = tb_property_find(dir, "vendorid", TB_PROPERTY_TYPE_VALUE);
> > > -     KUNIT_ASSERT_TRUE(test, p != NULL);
> > > +     KUNIT_ASSERT_NOT_NULL(test, p);
> > >       KUNIT_EXPECT_EQ(test, p->value.immediate, 0xa27);
> > >
> > >       p = tb_property_find(dir, "deviceid", TB_PROPERTY_TYPE_TEXT);
> > > -     KUNIT_ASSERT_TRUE(test, p != NULL);
> > > +     KUNIT_ASSERT_NOT_NULL(test, p);
> > >       KUNIT_EXPECT_STREQ(test, p->value.text, "Macintosh");
> > >
> > >       p = tb_property_find(dir, "deviceid", TB_PROPERTY_TYPE_VALUE);
> > > -     KUNIT_ASSERT_TRUE(test, p != NULL);
> > > +     KUNIT_ASSERT_NOT_NULL(test, p);
> > >       KUNIT_EXPECT_EQ(test, p->value.immediate, 0xa);
> > >
> > >       p = tb_property_find(dir, "missing", TB_PROPERTY_TYPE_DIRECTORY);
> > > -     KUNIT_ASSERT_TRUE(test, !p);
> > > +     KUNIT_ASSERT_NOT_NULL(test, p);
> >
> > Ditto here.
> >
> > With those fixed (please also run the tests if possible to see that they
> > still pass) you can add,
> >
> 
> Thanks!
> 
> To test it I had enabled:
> PCI, USB4 and USB4_KUNIT_TEST
> 
> and then run it with
> 
> ./tools/testing/kunit/kunit.py run --jobs=$(nproc) --arch=x86_64
> 
> Unfortunately, kunit was not able to run the tests
> 
> This hack did the trick:
> 
> 
>  int tb_test_init(void)
>  {
> -       return __kunit_test_suites_init(tb_test_suites);
> +       //return __kunit_test_suites_init(tb_test_suites);
> +       return 0;
>  }
> 
>  void tb_test_exit(void)
>  {
> -       return __kunit_test_suites_exit(tb_test_suites);
> +       //return __kunit_test_suites_exit(tb_test_suites);
>  }
> +
> +kunit_test_suites(&tb_test_suite);
> 
> I looked into why we do this and I found:
> 
> thunderbolt: Allow KUnit tests to be built also when CONFIG_USB4=m
> 
> 
> I am a bit confused. The patch talks about build coverage, but even
> with that patch reverted if
> USB4_KUNIT_TEST=m
> then test.c is built.
> 
> Shouldn't we simply revert that patch?

Nah, either build it into the kernel or load the driver manually:

  # modprobe thunderbolt

^ permalink raw reply	[flat|nested] 14+ messages in thread

* Re: [PATCH v5 3/6] thunderbolt: test: use NULL macros
  2022-02-11 16:26       ` Mika Westerberg
@ 2022-02-11 16:31         ` Mika Westerberg
  2022-02-11 16:33           ` Ricardo Ribalda
  0 siblings, 1 reply; 14+ messages in thread
From: Mika Westerberg @ 2022-02-11 16:31 UTC (permalink / raw)
  To: Ricardo Ribalda
  Cc: kunit-dev, kasan-dev, linux-kselftest, Brendan Higgins, Daniel Latypov

On Fri, Feb 11, 2022 at 06:26:56PM +0200, Mika Westerberg wrote:
> > To test it I had enabled:
> > PCI, USB4 and USB4_KUNIT_TEST
> > 
> > and then run it with
> > 
> > ./tools/testing/kunit/kunit.py run --jobs=$(nproc) --arch=x86_64
> > 
> > Unfortunately, kunit was not able to run the tests
> > 
> > This hack did the trick:
> > 
> > 
> >  int tb_test_init(void)
> >  {
> > -       return __kunit_test_suites_init(tb_test_suites);
> > +       //return __kunit_test_suites_init(tb_test_suites);
> > +       return 0;
> >  }
> > 
> >  void tb_test_exit(void)
> >  {
> > -       return __kunit_test_suites_exit(tb_test_suites);
> > +       //return __kunit_test_suites_exit(tb_test_suites);
> >  }
> > +
> > +kunit_test_suites(&tb_test_suite);
> > 
> > I looked into why we do this and I found:
> > 
> > thunderbolt: Allow KUnit tests to be built also when CONFIG_USB4=m
> > 
> > 
> > I am a bit confused. The patch talks about build coverage, but even
> > with that patch reverted if
> > USB4_KUNIT_TEST=m
> > then test.c is built.
> > 
> > Shouldn't we simply revert that patch?
> 
> Nah, either build it into the kernel or load the driver manually:
> 
>   # modprobe thunderbolt

Forgot to explain why this does not run the tests (I think):

 ./tools/testing/kunit/kunit.py run --jobs=$(nproc) --arch=x86_64

The driver depends on PCI and I don't think that's enabled on UML at
least. I typically run it inside QEMU.

^ permalink raw reply	[flat|nested] 14+ messages in thread

* Re: [PATCH v5 3/6] thunderbolt: test: use NULL macros
  2022-02-11 16:31         ` Mika Westerberg
@ 2022-02-11 16:33           ` Ricardo Ribalda
  2022-02-11 22:54             ` Daniel Latypov
  0 siblings, 1 reply; 14+ messages in thread
From: Ricardo Ribalda @ 2022-02-11 16:33 UTC (permalink / raw)
  To: Mika Westerberg
  Cc: kunit-dev, kasan-dev, linux-kselftest, Brendan Higgins, Daniel Latypov

Hi Mika

On Fri, 11 Feb 2022 at 17:31, Mika Westerberg
<mika.westerberg@linux.intel.com> wrote:
>
> On Fri, Feb 11, 2022 at 06:26:56PM +0200, Mika Westerberg wrote:
> > > To test it I had enabled:
> > > PCI, USB4 and USB4_KUNIT_TEST
> > >
> > > and then run it with
> > >
> > > ./tools/testing/kunit/kunit.py run --jobs=$(nproc) --arch=x86_64
> > >
> > > Unfortunately, kunit was not able to run the tests
> > >
> > > This hack did the trick:
> > >
> > >
> > >  int tb_test_init(void)
> > >  {
> > > -       return __kunit_test_suites_init(tb_test_suites);
> > > +       //return __kunit_test_suites_init(tb_test_suites);
> > > +       return 0;
> > >  }
> > >
> > >  void tb_test_exit(void)
> > >  {
> > > -       return __kunit_test_suites_exit(tb_test_suites);
> > > +       //return __kunit_test_suites_exit(tb_test_suites);
> > >  }
> > > +
> > > +kunit_test_suites(&tb_test_suite);
> > >
> > > I looked into why we do this and I found:
> > >
> > > thunderbolt: Allow KUnit tests to be built also when CONFIG_USB4=m
> > >
> > >
> > > I am a bit confused. The patch talks about build coverage, but even
> > > with that patch reverted if
> > > USB4_KUNIT_TEST=m
> > > then test.c is built.
> > >
> > > Shouldn't we simply revert that patch?
> >
> > Nah, either build it into the kernel or load the driver manually:
> >
> >   # modprobe thunderbolt
>
> Forgot to explain why this does not run the tests (I think):
>
>  ./tools/testing/kunit/kunit.py run --jobs=$(nproc) --arch=x86_64
>
> The driver depends on PCI and I don't think that's enabled on UML at
> least. I typically run it inside QEMU.


Could you try this out ?

From a clean kernel dir:

./tools/testing/kunit/kunit.py run --jobs=$(nproc) --arch=x86_64
make ARCH=x86_64 menuconfig  O=.kunit
# Enable PCI USB4 and USB4_KUNIT_TEST
./tools/testing/kunit/kunit.py run --jobs=$(nproc) --arch=x86_64

And then I get plenty of:
[16:31:57] [ERROR] Test property-entry: Expected test number N but found N+1

If I revert the previous patch all works fine.

Please note that --arch uses qemu

Thanks!


-- 
Ricardo Ribalda

^ permalink raw reply	[flat|nested] 14+ messages in thread

* Re: [PATCH v5 3/6] thunderbolt: test: use NULL macros
  2022-02-11 16:33           ` Ricardo Ribalda
@ 2022-02-11 22:54             ` Daniel Latypov
  2022-02-14  6:24               ` Mika Westerberg
  0 siblings, 1 reply; 14+ messages in thread
From: Daniel Latypov @ 2022-02-11 22:54 UTC (permalink / raw)
  To: Ricardo Ribalda
  Cc: Mika Westerberg, kunit-dev, kasan-dev, linux-kselftest, Brendan Higgins

On Fri, Feb 11, 2022 at 8:33 AM Ricardo Ribalda <ribalda@chromium.org> wrote:
>
> Hi Mika
>
> On Fri, 11 Feb 2022 at 17:31, Mika Westerberg
> <mika.westerberg@linux.intel.com> wrote:
> >
> > On Fri, Feb 11, 2022 at 06:26:56PM +0200, Mika Westerberg wrote:
> > > > To test it I had enabled:
> > > > PCI, USB4 and USB4_KUNIT_TEST
> > > >
> > > > and then run it with
> > > >
> > > > ./tools/testing/kunit/kunit.py run --jobs=$(nproc) --arch=x86_64
> > > >
> > > > Unfortunately, kunit was not able to run the tests
> > > >
> > > > This hack did the trick:
> > > >
> > > >
> > > >  int tb_test_init(void)
> > > >  {
> > > > -       return __kunit_test_suites_init(tb_test_suites);
> > > > +       //return __kunit_test_suites_init(tb_test_suites);
> > > > +       return 0;
> > > >  }
> > > >
> > > >  void tb_test_exit(void)
> > > >  {
> > > > -       return __kunit_test_suites_exit(tb_test_suites);
> > > > +       //return __kunit_test_suites_exit(tb_test_suites);
> > > >  }
> > > > +
> > > > +kunit_test_suites(&tb_test_suite);
> > > >
> > > > I looked into why we do this and I found:
> > > >
> > > > thunderbolt: Allow KUnit tests to be built also when CONFIG_USB4=m
> > > >
> > > >
> > > > I am a bit confused. The patch talks about build coverage, but even
> > > > with that patch reverted if
> > > > USB4_KUNIT_TEST=m
> > > > then test.c is built.
> > > >
> > > > Shouldn't we simply revert that patch?
> > >
> > > Nah, either build it into the kernel or load the driver manually:
> > >
> > >   # modprobe thunderbolt
> >
> > Forgot to explain why this does not run the tests (I think):
> >
> >  ./tools/testing/kunit/kunit.py run --jobs=$(nproc) --arch=x86_64
> >
> > The driver depends on PCI and I don't think that's enabled on UML at
> > least. I typically run it inside QEMU.

You can get it working on UML now.
If you apply the patch upthread for the test to use kunit_test_suites(), then

$ cat usb4_kunitconfig
CONFIG_PCI=y
CONFIG_VIRTIO_UML=y
CONFIG_UML_PCI_OVER_VIRTIO=y

CONFIG_KUNIT=y
CONFIG_USB4=y
CONFIG_USB4_KUNIT_TEST=y

$ ./tools/testing/kunit/kunit.py run --kunitconfig=usb4_kunitconfig
...
[14:48:55] [PASSED] tb_test_property_copy
[14:48:55] =================== [PASSED] thunderbolt ===================
[14:48:55] ============================================================
[14:48:55] Testing complete. Passed: 37, Failed: 0, Crashed: 0,
Skipped: 0, Errors: 0

Mika, should I propose a patch that updates the test and adds a
drivers/thunderbolt/.kunitconfig with the above contents?

Then it could be invoked as
$ ./tools/testing/kunit/kunit.py run --kunitconfig=drivers/thunderbolt

^ permalink raw reply	[flat|nested] 14+ messages in thread

* Re: [PATCH v5 3/6] thunderbolt: test: use NULL macros
  2022-02-11 22:54             ` Daniel Latypov
@ 2022-02-14  6:24               ` Mika Westerberg
  2022-02-14 18:43                 ` Daniel Latypov
  0 siblings, 1 reply; 14+ messages in thread
From: Mika Westerberg @ 2022-02-14  6:24 UTC (permalink / raw)
  To: Daniel Latypov
  Cc: Ricardo Ribalda, kunit-dev, kasan-dev, linux-kselftest, Brendan Higgins

Hi,

On Fri, Feb 11, 2022 at 02:54:37PM -0800, Daniel Latypov wrote:
> On Fri, Feb 11, 2022 at 8:33 AM Ricardo Ribalda <ribalda@chromium.org> wrote:
> >
> > Hi Mika
> >
> > On Fri, 11 Feb 2022 at 17:31, Mika Westerberg
> > <mika.westerberg@linux.intel.com> wrote:
> > >
> > > On Fri, Feb 11, 2022 at 06:26:56PM +0200, Mika Westerberg wrote:
> > > > > To test it I had enabled:
> > > > > PCI, USB4 and USB4_KUNIT_TEST
> > > > >
> > > > > and then run it with
> > > > >
> > > > > ./tools/testing/kunit/kunit.py run --jobs=$(nproc) --arch=x86_64
> > > > >
> > > > > Unfortunately, kunit was not able to run the tests
> > > > >
> > > > > This hack did the trick:
> > > > >
> > > > >
> > > > >  int tb_test_init(void)
> > > > >  {
> > > > > -       return __kunit_test_suites_init(tb_test_suites);
> > > > > +       //return __kunit_test_suites_init(tb_test_suites);
> > > > > +       return 0;
> > > > >  }
> > > > >
> > > > >  void tb_test_exit(void)
> > > > >  {
> > > > > -       return __kunit_test_suites_exit(tb_test_suites);
> > > > > +       //return __kunit_test_suites_exit(tb_test_suites);
> > > > >  }
> > > > > +
> > > > > +kunit_test_suites(&tb_test_suite);
> > > > >
> > > > > I looked into why we do this and I found:
> > > > >
> > > > > thunderbolt: Allow KUnit tests to be built also when CONFIG_USB4=m
> > > > >
> > > > >
> > > > > I am a bit confused. The patch talks about build coverage, but even
> > > > > with that patch reverted if
> > > > > USB4_KUNIT_TEST=m
> > > > > then test.c is built.
> > > > >
> > > > > Shouldn't we simply revert that patch?
> > > >
> > > > Nah, either build it into the kernel or load the driver manually:
> > > >
> > > >   # modprobe thunderbolt
> > >
> > > Forgot to explain why this does not run the tests (I think):
> > >
> > >  ./tools/testing/kunit/kunit.py run --jobs=$(nproc) --arch=x86_64
> > >
> > > The driver depends on PCI and I don't think that's enabled on UML at
> > > least. I typically run it inside QEMU.
> 
> You can get it working on UML now.
> If you apply the patch upthread for the test to use kunit_test_suites(), then
> 
> $ cat usb4_kunitconfig
> CONFIG_PCI=y
> CONFIG_VIRTIO_UML=y
> CONFIG_UML_PCI_OVER_VIRTIO=y
> 
> CONFIG_KUNIT=y
> CONFIG_USB4=y
> CONFIG_USB4_KUNIT_TEST=y
> 
> $ ./tools/testing/kunit/kunit.py run --kunitconfig=usb4_kunitconfig
> ...
> [14:48:55] [PASSED] tb_test_property_copy
> [14:48:55] =================== [PASSED] thunderbolt ===================
> [14:48:55] ============================================================
> [14:48:55] Testing complete. Passed: 37, Failed: 0, Crashed: 0,
> Skipped: 0, Errors: 0

That's great!

> Mika, should I propose a patch that updates the test and adds a
> drivers/thunderbolt/.kunitconfig with the above contents?
> 
> Then it could be invoked as
> $ ./tools/testing/kunit/kunit.py run --kunitconfig=drivers/thunderbolt

Yes please :)

^ permalink raw reply	[flat|nested] 14+ messages in thread

* Re: [PATCH v5 3/6] thunderbolt: test: use NULL macros
  2022-02-14  6:24               ` Mika Westerberg
@ 2022-02-14 18:43                 ` Daniel Latypov
  0 siblings, 0 replies; 14+ messages in thread
From: Daniel Latypov @ 2022-02-14 18:43 UTC (permalink / raw)
  To: Mika Westerberg
  Cc: Ricardo Ribalda, kunit-dev, kasan-dev, linux-kselftest, Brendan Higgins

On Sun, Feb 13, 2022 at 10:24 PM Mika Westerberg
<mika.westerberg@linux.intel.com> wrote:
> > Mika, should I propose a patch that updates the test and adds a
> > drivers/thunderbolt/.kunitconfig with the above contents?
> >
> > Then it could be invoked as
> > $ ./tools/testing/kunit/kunit.py run --kunitconfig=drivers/thunderbolt
>
> Yes please :)

Sounds good! Sent out
https://lore.kernel.org/lkml/20220214184104.1710107-1-dlatypov@google.com/

^ permalink raw reply	[flat|nested] 14+ messages in thread

end of thread, other threads:[~2022-02-14 18:45 UTC | newest]

Thread overview: 14+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2022-02-11  9:41 [PATCH v5 1/6] kunit: Introduce _NULL and _NOT_NULL macros Ricardo Ribalda
2022-02-11  9:41 ` [PATCH v5 2/6] kunit: use NULL macros Ricardo Ribalda
2022-02-11  9:41 ` [PATCH v5 3/6] thunderbolt: test: " Ricardo Ribalda
2022-02-11 10:08   ` Mika Westerberg
2022-02-11 15:49     ` Ricardo Ribalda
2022-02-11 16:26       ` Mika Westerberg
2022-02-11 16:31         ` Mika Westerberg
2022-02-11 16:33           ` Ricardo Ribalda
2022-02-11 22:54             ` Daniel Latypov
2022-02-14  6:24               ` Mika Westerberg
2022-02-14 18:43                 ` Daniel Latypov
2022-02-11  9:41 ` [PATCH v5 4/6] kasan: test: Use " Ricardo Ribalda
2022-02-11  9:41 ` [PATCH v5 5/6] mctp: " Ricardo Ribalda
2022-02-11  9:41 ` [PATCH v5 6/6] apparmor: " Ricardo Ribalda

This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.