[LTP] [PATCH v3 0/4] test_macros: Add TST_EXP_PASS_OR_FAIL()

[LTP] [PATCH v3 0/4] test_macros: Add TST_EXP_PASS_OR_FAIL()

[Petr Vorel]

Changes v2->v3:
* Remove TST_EXP_FD_OR_FAIL_() and TST_EXP_PASS_OR_FAIL_() (Cyril, Li)
* Actually use TST_EXP_PASS_OR_FAIL() in in few tests

Link to v2:
https://lore.kernel.org/ltp/20260710083337.1185184-1-pvorel@suse.cz/#r
https://patchwork.ozlabs.org/project/ltp/list/?series=513131&state=*

Petr Vorel (4):
  test macros: Fix TST_EXP_FD_OR_FAIL()
  test_macros: Add TST_EXP_PASS_OR_FAIL()
  tree: Use TST_EXP_PASS_OR_FAIL() and TST_EXP_FD_OR_FAIL()
  test_macros*.c: Simplify with macros macros

 include/tst_test_macros.h                     |  62 +++++++--
 lib/newlib_tests/test_macros01.c              |  57 +++++---
 lib/newlib_tests/test_macros03.c              |  42 +++---
 lib/newlib_tests/test_macros04.c              |  58 --------
 lib/newlib_tests/test_macros06.c              |  32 +++--
 testcases/kernel/syscalls/access/access01.c   |   9 +-
 .../kernel/syscalls/arch_prctl/arch_prctl01.c |   9 +-
 testcases/kernel/syscalls/bind/bind01.c       |   9 +-
 .../kernel/syscalls/epoll_ctl/epoll_ctl06.c   |  12 +-
 .../syscalls/finit_module/finit_module01.c    |   7 +-
 .../syscalls/init_module/init_module01.c      |   7 +-
 .../kernel/syscalls/landlock/landlock08.c     |  18 +--
 .../kernel/syscalls/landlock/landlock09.c     |  10 +-
 .../kernel/syscalls/landlock/landlock10.c     |   8 +-
 .../syscalls/landlock/landlock_tester.h       | 129 ++++++------------
 15 files changed, 195 insertions(+), 274 deletions(-)
 delete mode 100644 lib/newlib_tests/test_macros04.c

-- 
2.55.0


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

[LTP] [PATCH v3 1/4] test macros: Fix TST_EXP_FD_OR_FAIL()

[Petr Vorel]

SCALL in first macro needs to be stringified otherwise constants in
syscalls will be evaluated (e.g. O_RDONLY becomes 0).

That required to add TST_EXP_FAIL_().

While at it, document this reason in the header.

Fixes: a2a5730f34 ("tst_test_macros: Add TST_EXP_FD_OR_FAIL() macro")
Suggested-by: Cyril Hrubis <chrubis@suse.cz>
Reviewed-by: Li Wang <li.wang@linux.dev>
Signed-off-by: Petr Vorel <pvorel@suse.cz>
---
Please double check if TST_MSGP_() in TST_EXP_FD_() should really use
SSCALL instead of #SCALL.

 include/tst_test_macros.h | 28 ++++++++++++++++++++--------
 1 file changed, 20 insertions(+), 8 deletions(-)

diff --git a/include/tst_test_macros.h b/include/tst_test_macros.h
index f06c8aeb77..65ec873444 100644
--- a/include/tst_test_macros.h
+++ b/include/tst_test_macros.h
@@ -8,6 +8,12 @@
  * DOC: tst_test_macros.h -- helpers for testing syscalls
  */
 
+/*
+ * NOTE: for all TST_EXP_*() macros SCALL in first macro needs to be stringified
+ * otherwise constants in syscalls will be evaluated (e.g. O_RDONLY becomes 0).
+ * That is the reason for underscore variants (e.g. TST_EXP_FAIL_()).
+ */
+
 #ifndef TST_TEST_MACROS_H__
 #define TST_TEST_MACROS_H__
 
@@ -149,13 +155,16 @@ extern int TST_PASS;
  * This is a variant of the TST_EXP_POSITIVE() for a more specific case that
  * the returned value is a file descriptor.
  */
-#define TST_EXP_FD(SCALL, ...)                                                 \
+#define TST_EXP_FD(SCALL, ...)                                  \
+	TST_EXP_FD_(SCALL, #SCALL, ##__VA_ARGS__)
+
+#define TST_EXP_FD_(SCALL, SSCALL, ...)                                     \
 	({                                                                     \
-		TST_EXP_POSITIVE__(SCALL, #SCALL, ##__VA_ARGS__);              \
+		TST_EXP_POSITIVE__(SCALL, SSCALL, ##__VA_ARGS__);              \
 		                                                               \
 		if (TST_PASS)                                                  \
 			TST_MSGP_(TPASS, " returned fd %ld", TST_RET,          \
-				#SCALL, ##__VA_ARGS__);                        \
+				SSCALL, ##__VA_ARGS__);                        \
 		                                                               \
 		TST_RET;                                                       \
 	})
@@ -174,11 +183,11 @@ extern int TST_PASS;
  * Internally it uses TST_EXP_FAIL() and TST_EXP_FD().
  */
 #define TST_EXP_FD_OR_FAIL(SCALL, ERRNO, ...)                                  \
-	({                                                                     \
+	({                                                                 \
 		if (ERRNO)                                                     \
-			TST_EXP_FAIL(SCALL, ERRNO, ##__VA_ARGS__);             \
+			TST_EXP_FAIL_(SCALL, #SCALL, ERRNO, ##__VA_ARGS__);    \
 		else                                                           \
-			TST_EXP_FD(SCALL, ##__VA_ARGS__);                      \
+			TST_EXP_FD_(SCALL, #SCALL, ##__VA_ARGS__);             \
 		                                                               \
 		TST_RET;                                                       \
 	})
@@ -488,10 +497,13 @@ const char *tst_errno_names(char *buf, const int *exp_errs, int exp_errs_cnt);
  * printed by the pass or fail tst_res() calls. If omitted the first parameter
  * is converted to a string and used instead.
  */
-#define TST_EXP_FAIL(SCALL, EXP_ERR, ...)                                      \
+#define TST_EXP_FAIL(SCALL, EXP_ERR, ...) \
+	TST_EXP_FAIL_(SCALL, #SCALL, EXP_ERR, ##__VA_ARGS__)
+
+#define TST_EXP_FAIL_(SCALL, SSCALL, EXP_ERR, ...) \
 	do {                                                                   \
 		int tst_exp_err__ = EXP_ERR;                                   \
-		TST_EXP_FAIL_ARR_(SCALL, #SCALL, &tst_exp_err__, 1,            \
+		TST_EXP_FAIL_ARR_(SCALL, SSCALL, &tst_exp_err__, 1,            \
                                   ##__VA_ARGS__);                              \
 	} while (0)
 
-- 
2.55.0


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

[LTP] [PATCH v3 2/4] test_macros: Add TST_EXP_PASS_OR_FAIL()

[Petr Vorel]

This allows instead of:

	if (err) {
		TST_EXP_FAIL(epoll_ctl(efd, EPOLL_CTL_ADD,
				 fd.fd, &ev), err,
				 "epoll_ctl() on %s", tst_fd_desc(&fd));
	} else {
		TST_EXP_PASS(epoll_ctl(efd, EPOLL_CTL_ADD,
				 fd.fd, &ev),
				 "epoll_ctl() on %s", tst_fd_desc(&fd));
	}

to simplify to just:
	TST_EXP_PASS_OR_FAIL(epoll_ctl(efd, EPOLL_CTL_ADD,
			 fd.fd, &ev), err,
			 "epoll_ctl() on %s", tst_fd_desc(&fd));

That required to add TST_EXP_PASS_().

Add test into test_macros03.c.

+ Fix macro parameter name in TST_EXP_FD_OR_FAIL() (upper case).

Signed-off-by: Petr Vorel <pvorel@suse.cz>
---
Please double check if TST_MSGP_() and TST_EXP_PASS_PTR_() in
TST_EXP_PASS_() should really use SSCALL instead of #SCALL.

 include/tst_test_macros.h        | 34 ++++++++++++++++++++++++++++----
 lib/newlib_tests/test_macros03.c |  9 ++++++++-
 2 files changed, 38 insertions(+), 5 deletions(-)

diff --git a/include/tst_test_macros.h b/include/tst_test_macros.h
index 65ec873444..12bd9d47ed 100644
--- a/include/tst_test_macros.h
+++ b/include/tst_test_macros.h
@@ -177,7 +177,7 @@ extern int TST_PASS;
  * @ERRNO: Expected errno or 0.
  * @...: A printf-like parameters.
  *
- * Expect a file descriptor if errno is 0 otherwise expect a failure with
+ * Expect a file descriptor if ERRNO is 0 otherwise expect a failure with
  * expected errno.
  *
  * Internally it uses TST_EXP_FAIL() and TST_EXP_FD().
@@ -347,11 +347,14 @@ extern int TST_PASS;
  * is converted to a string and used instead.
  */
 #define TST_EXP_PASS(SCALL, ...)                                               \
+	TST_EXP_PASS_(SCALL, #SCALL, ##__VA_ARGS__)
+
+#define TST_EXP_PASS_(SCALL, SSCALL, ...)                                      \
 	do {                                                                   \
-		TST_EXP_PASS_SILENT_(SCALL, #SCALL, ##__VA_ARGS__);            \
+		TST_EXP_PASS_SILENT_(SCALL, SSCALL, ##__VA_ARGS__);            \
 		                                                               \
 		if (TST_PASS)                                                  \
-			TST_MSG_(TPASS, " passed", #SCALL, ##__VA_ARGS__);     \
+			TST_MSG_(TPASS, " passed", SSCALL, ##__VA_ARGS__);     \
 	} while (0)                                                            \
 
 #define TST_EXP_PASS_PTR_(SCALL, SSCALL, FAIL_PTR_VAL, ...)                    \
@@ -360,9 +363,32 @@ extern int TST_PASS;
 					FAIL_PTR_VAL, ##__VA_ARGS__);          \
 		                                                               \
 		if (TST_PASS)                                                  \
-			TST_MSG_(TPASS, " passed", #SCALL, ##__VA_ARGS__);     \
+			TST_MSG_(TPASS, " passed", SSCALL, ##__VA_ARGS__);     \
 	} while (0)
 
+/**
+ * TST_EXP_PASS_OR_FAIL() - Test syscall and expect it to pass or fail with
+ * expected errno.
+ *
+ * @SCALL: Tested syscall.
+ * @ERRNO: Expected errno or 0.
+ * @...: A printf-like parameters.
+ *
+ * Expect to pass if ERRNO is 0 otherwise expect a failure with
+ * expected errno.
+ *
+ * Internally it uses TST_EXP_FAIL() and TST_EXP_PASS().
+ */
+#define TST_EXP_PASS_OR_FAIL(SCALL, ERRNO, ...)                               \
+	({                                                                     \
+		if (ERRNO)                                                     \
+			TST_EXP_FAIL_(SCALL, #SCALL, ERRNO, ##__VA_ARGS__);    \
+		else                                                           \
+			TST_EXP_PASS_(SCALL, #SCALL, ##__VA_ARGS__);           \
+		                                                               \
+		TST_RET;                                                       \
+	})
+
 /**
  * TST_EXP_PASS_PTR_VOID() - Test syscall to return a valid pointer.
  *
diff --git a/lib/newlib_tests/test_macros03.c b/lib/newlib_tests/test_macros03.c
index 19a0ad6fd3..2a281bafcd 100644
--- a/lib/newlib_tests/test_macros03.c
+++ b/lib/newlib_tests/test_macros03.c
@@ -9,9 +9,11 @@
 
 #include "tst_test.h"
 
+#define ERR_ERRNO EINVAL
+
 static int fail_fn(void)
 {
-	errno = EINVAL;
+	errno = ERR_ERRNO;
 	return -1;
 }
 
@@ -42,6 +44,11 @@ static void do_test(void)
 	tst_res(TINFO, "TST_PASS = %i from TST_EXP_PASS_SILENT(pass_fn, ...)", TST_PASS);
 	TST_EXP_PASS_SILENT(inval_ret_fn(), "inval_ret_fn()");
 	tst_res(TINFO, "TST_PASS = %i", TST_PASS);
+
+	tst_res(TINFO, "Testing TST_EXP_PASS_OR_FAIL() macro (pass)");
+	TST_EXP_PASS_OR_FAIL(pass_fn(), 0, "pass_fn()");
+	tst_res(TINFO, "Testing TST_EXP_PASS_OR_FAIL() macro (fail)");
+	TST_EXP_PASS_OR_FAIL(fail_fn(), ERR_ERRNO, "fail_fn()");
 }
 
 static struct tst_test test = {
-- 
2.55.0


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

[LTP] [PATCH v3 3/4] tree: Use TST_EXP_PASS_OR_FAIL() and TST_EXP_FD_OR_FAIL()

[Petr Vorel]

Shorten code with test macros.

Signed-off-by: Petr Vorel <pvorel@suse.cz>
---
 testcases/kernel/syscalls/access/access01.c   |   9 +-
 .../kernel/syscalls/arch_prctl/arch_prctl01.c |   9 +-
 testcases/kernel/syscalls/bind/bind01.c       |   9 +-
 .../kernel/syscalls/epoll_ctl/epoll_ctl06.c   |  12 +-
 .../syscalls/finit_module/finit_module01.c    |   7 +-
 .../syscalls/init_module/init_module01.c      |   7 +-
 .../kernel/syscalls/landlock/landlock08.c     |  18 +--
 .../kernel/syscalls/landlock/landlock09.c     |  10 +-
 .../kernel/syscalls/landlock/landlock10.c     |   8 +-
 .../syscalls/landlock/landlock_tester.h       | 129 ++++++------------
 10 files changed, 66 insertions(+), 152 deletions(-)

diff --git a/testcases/kernel/syscalls/access/access01.c b/testcases/kernel/syscalls/access/access01.c
index 66907d1279..e8d81b392f 100644
--- a/testcases/kernel/syscalls/access/access01.c
+++ b/testcases/kernel/syscalls/access/access01.c
@@ -236,13 +236,8 @@ static struct tcase {
 
 static void access_test(struct tcase *tc, const char *user)
 {
-	if (tc->exp_errno) {
-		TST_EXP_FAIL(access(tc->fname, tc->mode), tc->exp_errno,
-		             "access(%s, %s) as %s", tc->fname, tc->name, user);
-	} else {
-		TST_EXP_PASS(access(tc->fname, tc->mode),
-		             "access(%s, %s) as %s", tc->fname, tc->name, user);
-	}
+	TST_EXP_PASS_OR_FAIL(access(tc->fname, tc->mode), tc->exp_errno,
+				 "access(%s, %s) as %s", tc->fname, tc->name, user);
 }
 
 static void verify_access(unsigned int n)
diff --git a/testcases/kernel/syscalls/arch_prctl/arch_prctl01.c b/testcases/kernel/syscalls/arch_prctl/arch_prctl01.c
index 8ce905c6ce..851a5cf50a 100644
--- a/testcases/kernel/syscalls/arch_prctl/arch_prctl01.c
+++ b/testcases/kernel/syscalls/arch_prctl/arch_prctl01.c
@@ -50,10 +50,9 @@ static void setup(void)
 
 static void run(unsigned int index)
 {
-	if (tag)
-		TST_EXP_PASS(arch_prctl_set(ARCH_SET_CPUID, index));
-	else
-		TST_EXP_FAIL(arch_prctl_set(ARCH_SET_CPUID, index), ENODEV);
+	int err = tag ? 0 : ENODEV;
+
+	TST_EXP_PASS_OR_FAIL(arch_prctl_set(ARCH_SET_CPUID, index), err);
 
 	// if cpu has cpuid_fault flag, ARCH_GET_CPUID returns what has been
 	// set: index, otherwise, returns default status: 1
@@ -61,7 +60,7 @@ static void run(unsigned int index)
 
 	TEST(arch_prctl_get(ARCH_GET_CPUID));
 	if (TST_RET == exp)
-		tst_res(TPASS, "get cpuid succeed.");
+		tst_res(TPASS, "get cpuid succeed");
 	else
 		tst_res(TFAIL, "get wrong cpuid status");
 }
diff --git a/testcases/kernel/syscalls/bind/bind01.c b/testcases/kernel/syscalls/bind/bind01.c
index 1bf55e898d..7f27bf3b7c 100644
--- a/testcases/kernel/syscalls/bind/bind01.c
+++ b/testcases/kernel/syscalls/bind/bind01.c
@@ -69,12 +69,9 @@ static void verify_bind(unsigned int nr)
 {
 	struct test_case *tcase = &tcases[nr];
 
-	if (tcase->experrno) {
-		TST_EXP_FAIL(bind(*tcase->socket_fd, tcase->sockaddr, tcase->salen),
-				tcase->experrno, "%s", tcase->desc);
-	} else {
-		TST_EXP_PASS(bind(*tcase->socket_fd, tcase->sockaddr, tcase->salen),
-				"%s", tcase->desc);
+	TST_EXP_PASS_OR_FAIL(bind(*tcase->socket_fd, tcase->sockaddr, tcase->salen),
+			tcase->experrno, "%s", tcase->desc);
+	if (TST_PASS) {
 		SAFE_CLOSE(inet_socket);
 		inet_socket = SAFE_SOCKET(PF_INET, SOCK_STREAM, 0);
 	}
diff --git a/testcases/kernel/syscalls/epoll_ctl/epoll_ctl06.c b/testcases/kernel/syscalls/epoll_ctl/epoll_ctl06.c
index a06d996e02..69321582f1 100644
--- a/testcases/kernel/syscalls/epoll_ctl/epoll_ctl06.c
+++ b/testcases/kernel/syscalls/epoll_ctl/epoll_ctl06.c
@@ -52,15 +52,9 @@ static void run(void)
 		ev.data.fd = fd.fd;
 		err = exp_errno(fd.type);
 
-		if (err) {
-			TST_EXP_FAIL(epoll_ctl(efd, EPOLL_CTL_ADD,
-				     fd.fd, &ev), err,
-				     "epoll_ctl() on %s", tst_fd_desc(&fd));
-		} else {
-			TST_EXP_PASS(epoll_ctl(efd, EPOLL_CTL_ADD,
-				     fd.fd, &ev),
-				     "epoll_ctl() on %s", tst_fd_desc(&fd));
-		}
+		TST_EXP_PASS_OR_FAIL(epoll_ctl(efd, EPOLL_CTL_ADD,
+				 fd.fd, &ev), err,
+				 "epoll_ctl() on %s", tst_fd_desc(&fd));
 
 		SAFE_CLOSE(efd);
 	}
diff --git a/testcases/kernel/syscalls/finit_module/finit_module01.c b/testcases/kernel/syscalls/finit_module/finit_module01.c
index 397d5a1ae4..ec14a42588 100644
--- a/testcases/kernel/syscalls/finit_module/finit_module01.c
+++ b/testcases/kernel/syscalls/finit_module/finit_module01.c
@@ -34,12 +34,9 @@ static void setup(void)
 
 static void run(void)
 {
-	if (sig_enforce == 1) {
-		TST_EXP_FAIL(finit_module(fd, "status=valid", 0), EKEYREJECTED);
-		return;
-	}
+	int err = sig_enforce == 1 ? EKEYREJECTED : 0;
 
-	TST_EXP_PASS(finit_module(fd, "status=valid", 0));
+	TST_EXP_PASS_OR_FAIL(finit_module(fd, "status=valid", 0), err);
 	if (!TST_PASS)
 		return;
 
diff --git a/testcases/kernel/syscalls/init_module/init_module01.c b/testcases/kernel/syscalls/init_module/init_module01.c
index a0d4792c95..171e360f89 100644
--- a/testcases/kernel/syscalls/init_module/init_module01.c
+++ b/testcases/kernel/syscalls/init_module/init_module01.c
@@ -39,12 +39,9 @@ static void setup(void)
 
 static void run(void)
 {
-	if (sig_enforce == 1) {
-		TST_EXP_FAIL(init_module(buf, sb.st_size, "status=valid"), EKEYREJECTED);
-		return;
-	}
+	int err = sig_enforce == 1 ? EKEYREJECTED : 0;
 
-	TST_EXP_PASS(init_module(buf, sb.st_size, "status=valid"));
+	TST_EXP_PASS_OR_FAIL(init_module(buf, sb.st_size, "status=valid"), err);
 	if (!TST_PASS)
 		return;
 
diff --git a/testcases/kernel/syscalls/landlock/landlock08.c b/testcases/kernel/syscalls/landlock/landlock08.c
index 770061ba0b..052b016be6 100644
--- a/testcases/kernel/syscalls/landlock/landlock08.c
+++ b/testcases/kernel/syscalls/landlock/landlock08.c
@@ -102,13 +102,8 @@ static void test_bind(const struct tcase *tc, const in_port_t port, const int ex
 	create_socket(&socket, tc->family, port, tc->type);
 	getsocket_addr(&socket, tc->family, &addr);
 
-	if (exp_err) {
-		TST_EXP_FAIL(bind(socket.fd, addr, socket.address_size),
-			     exp_err, "bind() access on port %u", port);
-	} else {
-		TST_EXP_PASS(bind(socket.fd, addr, socket.address_size),
-			     "bind() access on port %u", port);
-	}
+	TST_EXP_PASS_OR_FAIL(bind(socket.fd, addr, socket.address_size),
+		exp_err, "bind() access on port %u", port);
 
 	SAFE_CLOSE(socket.fd);
 }
@@ -121,13 +116,8 @@ static void test_connect(const struct tcase *tc, const in_port_t port, const int
 	create_socket(&socket, tc->family, port, tc->type);
 	getsocket_addr(&socket, tc->family, &addr);
 
-	if (exp_err) {
-		TST_EXP_FAIL(connect(socket.fd, addr, socket.address_size),
-			     exp_err, "connect() on port %u", port);
-	} else {
-		TST_EXP_PASS(connect(socket.fd, addr, socket.address_size),
-			     "connect() on port %u", port);
-	}
+	TST_EXP_PASS_OR_FAIL(connect(socket.fd, addr, socket.address_size),
+		exp_err, "connect() on port %u", port);
 
 	SAFE_CLOSE(socket.fd);
 }
diff --git a/testcases/kernel/syscalls/landlock/landlock09.c b/testcases/kernel/syscalls/landlock/landlock09.c
index 09a762bb1b..c2d73a7085 100644
--- a/testcases/kernel/syscalls/landlock/landlock09.c
+++ b/testcases/kernel/syscalls/landlock/landlock09.c
@@ -35,6 +35,8 @@ static void scoped_sandbox(const char *from)
 
 static void run_client(void)
 {
+	int err = tst_variant == DOMAIN_CLIENT ? EPERM : 0;
+
 	if (tst_variant == DOMAIN_CLIENT)
 		scoped_sandbox("client");
 
@@ -47,14 +49,8 @@ static void run_client(void)
 	TST_CHECKPOINT_WAIT(0);
 
 	tst_res(TINFO, "Connecting to UNIX socket");
-
 	sendsock = SAFE_SOCKET(AF_UNIX, SOCK_STREAM, 0);
-
-	if (tst_variant != DOMAIN_CLIENT)
-		TST_EXP_PASS(connect(sendsock, (struct sockaddr *)&addr, SOCKET_LENGTH));
-	else
-		TST_EXP_FAIL(connect(sendsock, (struct sockaddr *)&addr, SOCKET_LENGTH), EPERM);
-
+	TST_EXP_PASS_OR_FAIL(connect(sendsock, (struct sockaddr *)&addr, SOCKET_LENGTH), err);
 	SAFE_CLOSE(sendsock);
 
 	TST_CHECKPOINT_WAKE(0);
diff --git a/testcases/kernel/syscalls/landlock/landlock10.c b/testcases/kernel/syscalls/landlock/landlock10.c
index a29e3bca82..96ee40bc79 100644
--- a/testcases/kernel/syscalls/landlock/landlock10.c
+++ b/testcases/kernel/syscalls/landlock/landlock10.c
@@ -30,6 +30,8 @@ static void scoped_sandbox(const char *from)
 
 static void run(void)
 {
+	int err = tst_variant == DOMAIN_KILLER ? EPERM : 0;
+
 	/* isolate test inside a process so we won't stack too many
 	 * layers (-E2BIG) when there are multiple test's iterations
 	 */
@@ -62,11 +64,7 @@ static void run(void)
 
 		TST_CHECKPOINT_WAKE(0);
 
-		if (tst_variant == DOMAIN_KILLER)
-			TST_EXP_FAIL(kill(paused_pid, SIGKILL), EPERM);
-		else
-			TST_EXP_PASS(kill(paused_pid, SIGKILL));
-
+		TST_EXP_PASS_OR_FAIL(kill(paused_pid, SIGKILL), err);
 		exit(0);
 	}
 
diff --git a/testcases/kernel/syscalls/landlock/landlock_tester.h b/testcases/kernel/syscalls/landlock/landlock_tester.h
index 4e77e8a61f..3e2abd2e78 100644
--- a/testcases/kernel/syscalls/landlock/landlock_tester.h
+++ b/testcases/kernel/syscalls/landlock/landlock_tester.h
@@ -145,7 +145,7 @@ static void tester_cleanup_files(void)
 	_remove_file(FILE_REGULAR);
 }
 
-static void _test_exec(const int result)
+static void _test_exec(const int exp_err)
 {
 	int status;
 	pid_t pid;
@@ -155,16 +155,7 @@ static void _test_exec(const int result)
 
 	pid = SAFE_FORK();
 	if (!pid) {
-		int rval;
-
-		if (result == TPASS) {
-			rval = execve(FILE_EXEC, args, NULL);
-			if (rval == -1)
-				tst_res(TFAIL | TERRNO, "Failed to execute test binary");
-		} else {
-			TST_EXP_FAIL(execve(FILE_EXEC, args, NULL), EACCES);
-		}
-
+		TST_EXP_PASS_OR_FAIL(execve(FILE_EXEC, args, NULL), exp_err);
 		_exit(1);
 	}
 
@@ -172,31 +163,23 @@ static void _test_exec(const int result)
 	if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
 		return;
 
-	tst_res(result, "Test binary has been executed");
+	tst_res(exp_err ? TFAIL : TPASS, "Test binary has been executed");
 }
 
-static void _test_write(const int result)
+static void _test_write(const int exp_err)
 {
 	tst_res(TINFO, "Test writing file");
 
-	if (result == TPASS)
-		TST_EXP_FD(open(FILE_WRITE, O_WRONLY, PERM_MODE));
-	else
-		TST_EXP_FAIL(open(FILE_WRITE, O_WRONLY, PERM_MODE), EACCES);
-
+	TST_EXP_FD_OR_FAIL(open(FILE_WRITE, O_WRONLY, PERM_MODE), exp_err);
 	if (TST_RET != -1)
 		SAFE_CLOSE(TST_RET);
 }
 
-static void _test_read(const int result)
+static void _test_read(const int exp_err)
 {
 	tst_res(TINFO, "Test reading file");
 
-	if (result == TPASS)
-		TST_EXP_FD(open(FILE_READ, O_RDONLY, PERM_MODE));
-	else
-		TST_EXP_FAIL(open(FILE_READ, O_RDONLY, PERM_MODE), EACCES);
-
+	TST_EXP_FD_OR_FAIL(open(FILE_READ, O_RDONLY, PERM_MODE), exp_err);
 	if (TST_RET != -1)
 		SAFE_CLOSE(TST_RET);
 }
@@ -239,122 +222,90 @@ static void _test_readdir(const int result)
 	TST_EXP_EQ_LI(files_counted, ARRAY_SIZE(readdir_files));
 }
 
-static void _test_rmdir(const int result)
+static void _test_rmdir(const int exp_err)
 {
 	tst_res(TINFO, "Test removing directory");
-
-	if (result == TPASS)
-		TST_EXP_PASS(rmdir(DIR_RMDIR));
-	else
-		TST_EXP_FAIL(rmdir(DIR_RMDIR), EACCES);
+	TST_EXP_PASS_OR_FAIL(rmdir(DIR_RMDIR), exp_err);
 }
 
-static void _test_rmfile(const int result)
+static void _test_rmfile(const int exp_err)
 {
 	tst_res(TINFO, "Test removing file");
-
-	if (result == TPASS) {
-		TST_EXP_PASS(unlink(FILE_UNLINK));
-		TST_EXP_PASS(remove(FILE_REMOVE));
-	} else {
-		TST_EXP_FAIL(unlink(FILE_UNLINK), EACCES);
-		TST_EXP_FAIL(remove(FILE_REMOVE), EACCES);
-	}
+	TST_EXP_PASS_OR_FAIL(unlink(FILE_UNLINK), exp_err);
+	TST_EXP_PASS_OR_FAIL(remove(FILE_REMOVE), exp_err);
 }
 
-static void _test_make(const char *path, const int type, const int dev, const int result)
+static void _test_make(const char *path, const int type, const int dev, const int exp_err)
 {
 	tst_res(TINFO, "Test normal or special files creation");
-
-	if (result == TPASS)
-		TST_EXP_PASS(mknod(path, type | 0400, dev));
-	else
-		TST_EXP_FAIL(mknod(path, type | 0400, dev), EACCES);
+	TST_EXP_PASS_OR_FAIL(mknod(path, type | 0400, dev), exp_err);
 }
 
-static void _test_symbolic(const int result)
+static void _test_symbolic(const int exp_err)
 {
 	tst_res(TINFO, "Test symbolic links");
-
-	if (result == TPASS)
-		TST_EXP_PASS(symlink(FILE_SYM0, FILE_SYM1));
-	else
-		TST_EXP_FAIL(symlink(FILE_SYM0, FILE_SYM1), EACCES);
+	TST_EXP_PASS_OR_FAIL(symlink(FILE_SYM0, FILE_SYM1), exp_err);
 }
 
-static void _test_truncate(const int result)
+static void _test_truncate(const int exp_err)
 {
 	int fd;
 
 	tst_res(TINFO, "Test truncating file");
 
-	if (result == TPASS) {
-		TST_EXP_PASS(truncate(FILE_TRUNCATE, 10));
-
-		fd = SAFE_OPEN(FILE_TRUNCATE, O_WRONLY, PERM_MODE);
-		if (fd != -1) {
-			TST_EXP_PASS(ftruncate(fd, 10));
-			SAFE_CLOSE(fd);
-		}
-
-		fd = TST_EXP_FD(open(FILE_TRUNCATE, O_WRONLY | O_TRUNC, PERM_MODE));
-		if (fd != -1)
-			SAFE_CLOSE(fd);
-	} else {
-		TST_EXP_FAIL(truncate(FILE_TRUNCATE, 10), EACCES);
-
-		fd = open(FILE_TRUNCATE, O_WRONLY, PERM_MODE);
-		if (fd != -1) {
-			TST_EXP_FAIL(ftruncate(fd, 10), EACCES);
-			SAFE_CLOSE(fd);
-		}
-
-		TST_EXP_FAIL(open(FILE_TRUNCATE, O_WRONLY | O_TRUNC, PERM_MODE), EACCES);
-
-		if (TST_RET != -1)
-			SAFE_CLOSE(TST_RET);
+	TST_EXP_PASS_OR_FAIL(truncate(FILE_TRUNCATE, 10), exp_err);
+	TST_EXP_FD_OR_FAIL(fd = open(FILE_TRUNCATE, O_WRONLY | O_TRUNC, PERM_MODE), exp_err);
+	if (fd != -1) {
+		TST_EXP_PASS_OR_FAIL(ftruncate(fd, 10), exp_err);
+		SAFE_CLOSE(fd);
 	}
+
+	TST_EXP_FD_OR_FAIL(fd = open(FILE_TRUNCATE, O_WRONLY | O_TRUNC, PERM_MODE), exp_err);
+	if (fd != -1)
+		SAFE_CLOSE(TST_RET);
 }
 
 static void tester_run_fs_rules(const int rules, const int result)
 {
+	int exp_err = result == TPASS ? 0 : EACCES;
+
 	if (rules & LANDLOCK_ACCESS_FS_EXECUTE)
-		_test_exec(result);
+		_test_exec(exp_err);
 
 	if (rules & LANDLOCK_ACCESS_FS_WRITE_FILE)
-		_test_write(result);
+		_test_write(exp_err);
 
 	if (rules & LANDLOCK_ACCESS_FS_READ_FILE)
-		_test_read(result);
+		_test_read(exp_err);
 
 	if (rules & LANDLOCK_ACCESS_FS_READ_DIR)
 		_test_readdir(result);
 
 	if (rules & LANDLOCK_ACCESS_FS_REMOVE_DIR)
-		_test_rmdir(result);
+		_test_rmdir(exp_err);
 
 	if (rules & LANDLOCK_ACCESS_FS_REMOVE_FILE)
-		_test_rmfile(result);
+		_test_rmfile(exp_err);
 
 	if (rules & LANDLOCK_ACCESS_FS_MAKE_REG)
-		_test_make(FILE_REGULAR, S_IFREG, 0, result);
+		_test_make(FILE_REGULAR, S_IFREG, 0, exp_err);
 
 	if (strcmp(tst_device->fs_type, "vfat") &&
 	    strcmp(tst_device->fs_type, "exfat")) {
 		if (rules & LANDLOCK_ACCESS_FS_MAKE_CHAR)
-			_test_make(DEV_CHAR0, S_IFCHR, dev_chr, result);
+			_test_make(DEV_CHAR0, S_IFCHR, dev_chr, exp_err);
 
 		if (rules & LANDLOCK_ACCESS_FS_MAKE_BLOCK)
-			_test_make(DEV_BLK0, S_IFBLK, dev_blk, result);
+			_test_make(DEV_BLK0, S_IFBLK, dev_blk, exp_err);
 
 		if (rules & LANDLOCK_ACCESS_FS_MAKE_SOCK)
-			_test_make(FILE_SOCKET, S_IFSOCK, 0, result);
+			_test_make(FILE_SOCKET, S_IFSOCK, 0, exp_err);
 
 		if (rules & LANDLOCK_ACCESS_FS_MAKE_FIFO)
-			_test_make(FILE_FIFO, S_IFIFO, 0, result);
+			_test_make(FILE_FIFO, S_IFIFO, 0, exp_err);
 
 		if (rules & LANDLOCK_ACCESS_FS_MAKE_SYM)
-			_test_symbolic(result);
+			_test_symbolic(exp_err);
 	}
 
 	if (rules & LANDLOCK_ACCESS_FS_TRUNCATE) {
@@ -366,7 +317,7 @@ static void tester_run_fs_rules(const int rules, const int result)
 			return;
 		}
 
-		_test_truncate(result);
+		_test_truncate(exp_err);
 	}
 }
 
-- 
2.55.0


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

[LTP] [PATCH v3 4/4] test_macros*.c: Simplify with macros macros

[Petr Vorel]

Use similar macros as is used in test_macros02.c in other tests
to reduce duplicity (and slightly degrease readability).

Also
* Merge test_macros04.c into test_macros01.c
* Increase coverage by skipping msg parameter
* Test also TST_EXP_FD_OR_FAIL()

Signed-off-by: Petr Vorel <pvorel@suse.cz>
---
 lib/newlib_tests/test_macros01.c | 57 +++++++++++++++++++------------
 lib/newlib_tests/test_macros03.c | 43 ++++++++++++-----------
 lib/newlib_tests/test_macros04.c | 58 --------------------------------
 lib/newlib_tests/test_macros06.c | 32 +++++++++++-------
 4 files changed, 76 insertions(+), 114 deletions(-)
 delete mode 100644 lib/newlib_tests/test_macros04.c

diff --git a/lib/newlib_tests/test_macros01.c b/lib/newlib_tests/test_macros01.c
index c04c943637..d6fdac7bd9 100644
--- a/lib/newlib_tests/test_macros01.c
+++ b/lib/newlib_tests/test_macros01.c
@@ -1,21 +1,30 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 /*
  * Copyright (c) 2020 Cyril Hrubis <chrubis@suse.cz>
+ * Copyright (c) 2021 Yang Xu <xuyang2018.jy@fujitsu.com>
+ * Copyright (c) Linux Test Project, 2026
  */
 
 /*
- * Test TST_EXP_FD and TST_EXP_FD_SILENT macro.
+ * Test macros:
+ *
+ * - TST_EXP_PASS
+ * - TST_EXP_PASS_SILENT
+ * - TST_EXP_FD
+ * - TST_EXP_FD_SILENT
+ * - TST_EXP_PID
+ * - TST_EXP_PID_SILENT
  */
 
 #include "tst_test.h"
 
-static int fail_fd(void)
+static int fail_fn(void)
 {
 	errno = EINVAL;
 	return -1;
 }
 
-static int pass_fd(void)
+static int pass_fn(void)
 {
 	return 42;
 }
@@ -30,27 +39,31 @@ static int zero_val(void)
 	return 0;
 }
 
+#define TEST_MACRO(macro, fail_fn, pass_fn, inval_fn, zero_val_fn) \
+	do { \
+		tst_res(TINFO, "* Testing " #macro "() macro"); \
+		macro(fail_fn(), #fail_fn"()"); \
+		tst_res(TINFO, "TST_PASS = %i", TST_PASS); \
+		macro(fail_fn()); /* skip msg parameter */ \
+		tst_res(TINFO, "TST_PASS = %i", TST_PASS); \
+		macro(pass_fn(), #pass_fn"()"); \
+		tst_res(TINFO, "TST_PASS = %i", TST_PASS); \
+		macro(inval_fn(), #inval_fn"()"); \
+		tst_res(TINFO, "TST_PASS = %i", TST_PASS); \
+		macro(zero_val_fn(), #zero_val_fn"()"); \
+		tst_res(TINFO, "TST_PASS = %i", TST_PASS); \
+	} while (0)
+
 static void do_test(void)
 {
-	tst_res(TINFO, "Testing TST_EXP_FD macro");
-	TST_EXP_FD(fail_fd(), "fail_fd()");
-	tst_res(TINFO, "TST_PASS = %i", TST_PASS);
-	TST_EXP_FD(pass_fd(), "pass_fd()");
-	tst_res(TINFO, "TST_PASS = %i", TST_PASS);
-	TST_EXP_FD(inval_val(), "inval_val()");
-	tst_res(TINFO, "TST_PASS = %i", TST_PASS);
-	TST_EXP_FD(zero_val(), "zero_val()");
-	tst_res(TINFO, "TST_PASS = %i", TST_PASS);
-
-	tst_res(TINFO, "Testing TST_EXP_FD_SILENT macro");
-	TST_EXP_FD_SILENT(fail_fd(), "fail_fd()");
-	tst_res(TINFO, "TST_PASS = %i", TST_PASS);
-	TST_EXP_FD_SILENT(pass_fd(), "%s", "pass_fd()");
-	tst_res(TINFO, "TST_PASS = %i from TST_EXP_FD_SILENT(pass_fd, ...)", TST_PASS);
-	TST_EXP_FD_SILENT(inval_val(), "inval_val()");
-	tst_res(TINFO, "TST_PASS = %i", TST_PASS);
-	TST_EXP_FD_SILENT(zero_val(), "zero_val()");
-	tst_res(TINFO, "TST_PASS = %i from TST_EXP_FD_SILENT(zero_val, ...)", TST_PASS);
+	TEST_MACRO(TST_EXP_PASS, fail_fn, pass_fn, inval_val, zero_val);
+	TEST_MACRO(TST_EXP_PASS_SILENT, fail_fn, pass_fn, inval_val, zero_val);
+
+	TEST_MACRO(TST_EXP_FD, fail_fn, pass_fn, inval_val, zero_val);
+	TEST_MACRO(TST_EXP_FD_SILENT, fail_fn, pass_fn, inval_val, zero_val);
+
+	TEST_MACRO(TST_EXP_PID, fail_fn, pass_fn, inval_val, zero_val);
+	TEST_MACRO(TST_EXP_PID_SILENT, fail_fn, pass_fn, inval_val, zero_val);
 }
 
 static struct tst_test test = {
diff --git a/lib/newlib_tests/test_macros03.c b/lib/newlib_tests/test_macros03.c
index 2a281bafcd..536240620d 100644
--- a/lib/newlib_tests/test_macros03.c
+++ b/lib/newlib_tests/test_macros03.c
@@ -1,10 +1,14 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 /*
  * Copyright (c) 2020 Cyril Hrubis <chrubis@suse.cz>
+ * Copyright (c) Linux Test Project, 2026
  */
 
 /*
- * Test TST_EXP_PASS and TST_EXP_PASS_SILENT macro.
+ * Test macros:
+ *
+ * - TST_EXP_PASS_OR_FAIL
+ * - TST_EXP_FD_OR_FAIL
  */
 
 #include "tst_test.h"
@@ -22,33 +26,28 @@ static int pass_fn(void)
 	return 0;
 }
 
-static int inval_ret_fn(void)
+static int pass_fd(void)
 {
 	return 42;
 }
 
+#define TEST_MACRO(macro, fail_fn, pass_fn, fail_err) \
+	do { \
+		tst_res(TINFO, "* Testing " #macro "() macro"); \
+		macro(fail_fn(), fail_err, #fail_fn"()"); \
+		tst_res(TINFO, "TST_PASS = %i", TST_PASS); \
+		macro(fail_fn(), fail_err); /* skip msg parameter */ \
+		tst_res(TINFO, "TST_PASS = %i", TST_PASS); \
+		macro(pass_fn(), 0, #pass_fn"()"); \
+		tst_res(TINFO, "TST_PASS = %i", TST_PASS); \
+		macro(fail_fn(), 0); /* skip msg parameter */ \
+		tst_res(TINFO, "TST_PASS = %i", TST_PASS); \
+	} while (0)
+
 static void do_test(void)
 {
-	tst_res(TINFO, "Testing TST_EXP_PASS macro");
-	TST_EXP_PASS(fail_fn(), "fail_fn()");
-	tst_res(TINFO, "TST_PASS = %i", TST_PASS);
-	TST_EXP_PASS(pass_fn(), "pass_fn()");
-	tst_res(TINFO, "TST_PASS = %i", TST_PASS);
-	TST_EXP_PASS(inval_ret_fn(), "inval_ret_fn()");
-	tst_res(TINFO, "TST_PASS = %i", TST_PASS);
-
-	tst_res(TINFO, "Testing TST_EXP_PASS_SILENT macro");
-	TST_EXP_PASS_SILENT(fail_fn(), "fail_fn()");
-	tst_res(TINFO, "TST_PASS = %i", TST_PASS);
-	TST_EXP_PASS_SILENT(pass_fn(), "pass_fn()");
-	tst_res(TINFO, "TST_PASS = %i from TST_EXP_PASS_SILENT(pass_fn, ...)", TST_PASS);
-	TST_EXP_PASS_SILENT(inval_ret_fn(), "inval_ret_fn()");
-	tst_res(TINFO, "TST_PASS = %i", TST_PASS);
-
-	tst_res(TINFO, "Testing TST_EXP_PASS_OR_FAIL() macro (pass)");
-	TST_EXP_PASS_OR_FAIL(pass_fn(), 0, "pass_fn()");
-	tst_res(TINFO, "Testing TST_EXP_PASS_OR_FAIL() macro (fail)");
-	TST_EXP_PASS_OR_FAIL(fail_fn(), ERR_ERRNO, "fail_fn()");
+	TEST_MACRO(TST_EXP_PASS_OR_FAIL, fail_fn, pass_fn, ERR_ERRNO);
+	TEST_MACRO(TST_EXP_FD_OR_FAIL, fail_fn, pass_fd, ERR_ERRNO);
 }
 
 static struct tst_test test = {
diff --git a/lib/newlib_tests/test_macros04.c b/lib/newlib_tests/test_macros04.c
deleted file mode 100644
index e0111807fe..0000000000
--- a/lib/newlib_tests/test_macros04.c
+++ /dev/null
@@ -1,58 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-or-later
-/*
- * Copyright (c) 2021 Yang Xu <xuyang2018.jy@fujitsu.com>
- */
-
-/*
- * Test TST_EXP_PID and TST_EXP_PID_SILENT macro.
- */
-
-#include "tst_test.h"
-
-static int fail_pid(void)
-{
-	errno = EINVAL;
-	return -1;
-}
-
-static int pass_pid(void)
-{
-	return 42;
-}
-
-static int inval_val(void)
-{
-	return -42;
-}
-
-static int zero_val(void)
-{
-	return 0;
-}
-
-static void do_test(void)
-{
-	tst_res(TINFO, "Testing TST_EXP_PID macro");
-	TST_EXP_PID(fail_pid(), "fail_pid()");
-	tst_res(TINFO, "TST_PASS = %i", TST_PASS);
-	TST_EXP_PID(pass_pid(), "pass_pid()");
-	tst_res(TINFO, "TST_PASS = %i", TST_PASS);
-	TST_EXP_PID(inval_val(), "inval_val()");
-	tst_res(TINFO, "TST_PASS = %i", TST_PASS);
-	TST_EXP_PID(zero_val(), "zero_val()");
-	tst_res(TINFO, "TST_PASS = %i", TST_PASS);
-
-	tst_res(TINFO, "Testing TST_EXP_PID_SILENT macro");
-	TST_EXP_PID_SILENT(fail_pid(), "fail_pid()");
-	tst_res(TINFO, "TST_PASS = %i", TST_PASS);
-	TST_EXP_PID_SILENT(pass_pid(), "%s", "pass_pid()");
-	tst_res(TINFO, "TST_PASS = %i from TST_EXP_PID_SILENT(pass_pid, ...)", TST_PASS);
-	TST_EXP_PID_SILENT(inval_val(), "inval_val()");
-	tst_res(TINFO, "TST_PASS = %i", TST_PASS);
-	TST_EXP_PID_SILENT(zero_val(), "zero_val()");
-	tst_res(TINFO, "TST_PASS = %i from TST_EXP_PID_SILENT(zero_val, ...)", TST_PASS);
-}
-
-static struct tst_test test = {
-	.test_all = do_test,
-};
diff --git a/lib/newlib_tests/test_macros06.c b/lib/newlib_tests/test_macros06.c
index 4d300d7977..621014a72a 100644
--- a/lib/newlib_tests/test_macros06.c
+++ b/lib/newlib_tests/test_macros06.c
@@ -1,10 +1,14 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 /*
  * Copyright (c) 2021 zhanglianjie <zhanglianjie@uniontech.com>
+ * Copyright (c) Linux Test Project, 2026
  */
 
 /*
- * Test TST_EXP_VAL and TST_EXP_VAL_SILENT macro.
+ * Test macros:
+ *
+ * - TST_EXP_VAL
+ * - TST_EXP_VAL_SILENT
  */
 
 #include "tst_test.h"
@@ -20,19 +24,23 @@ static int pass_val(void)
 	return 42;
 }
 
+#define TEST_MACRO(macro, fail_fn, pass_fn, pass_val, fail_err) \
+	do { \
+		tst_res(TINFO, "* Testing " #macro "() macro"); \
+		macro(fail_fn(), fail_err, #fail_fn"()"); \
+		tst_res(TINFO, "TST_PASS = %i", TST_PASS); \
+		macro(fail_fn(), fail_err); /* skip msg parameter */ \
+		tst_res(TINFO, "TST_PASS = %i", TST_PASS); \
+		macro(pass_fn(), pass_val, #pass_fn"()"); \
+		tst_res(TINFO, "TST_PASS = %i", TST_PASS); \
+		macro(fail_fn(), pass_val); /* skip msg parameter */ \
+		tst_res(TINFO, "TST_PASS = %i", TST_PASS); \
+	} while (0)
+
 static void do_test(void)
 {
-	tst_res(TINFO, "Testing TST_EXP_VAL macro");
-	TST_EXP_VAL(fail_val(), 40, "fail_val()");
-	tst_res(TINFO, "TST_PASS = %i", TST_PASS);
-	TST_EXP_VAL(pass_val(), 42, "pass_val()");
-	tst_res(TINFO, "TST_PASS = %i", TST_PASS);
-
-	tst_res(TINFO, "Testing TST_EXP_VAL_SILENT macro");
-	TST_EXP_VAL_SILENT(fail_val(), 40, "fail_val()");
-	tst_res(TINFO, "TST_PASS = %i from TST_EXP_VAL_SILENT(fail_val, ...)", TST_PASS);
-	TST_EXP_VAL_SILENT(pass_val(), 42, "pass_val()");
-	tst_res(TINFO, "TST_PASS = %i from TST_EXP_VAL_SILENT(pass_val, ...)", TST_PASS);
+	TEST_MACRO(TST_EXP_VAL, fail_val, pass_val, 42, 40);
+	TEST_MACRO(TST_EXP_VAL_SILENT, fail_val, pass_val, 42, 40);
 }
 
 static struct tst_test test = {
-- 
2.55.0


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

Re: [LTP] test macros: Fix TST_EXP_FD_OR_FAIL()

[linuxtestproject.agent]

Hi Petr,

On Tue, 11 Aug 2026, Petr Vorel wrote:
> test macros: Fix TST_EXP_FD_OR_FAIL()

--- [PATCH 3/4] ---

> +	TST_EXP_PASS_OR_FAIL(finit_module(fd, "status=valid", 0), err);
>  	if (!TST_PASS)
>  		return;

Could this return when err is nonzero as well?  An expected EKEYREJECTED
sets TST_PASS, so the signature-enforcement path continues to
tst_module_unload() even though the module was never loaded.  The rmmod
retries then end the test with TBROK.  The same issue is present in
init_module01.c.

> +	TST_EXP_FD_OR_FAIL(fd = open(FILE_TRUNCATE, O_WRONLY | O_TRUNC, PERM_MODE), exp_err);
> +	if (fd != -1) {
> +		TST_EXP_PASS_OR_FAIL(ftruncate(fd, 10), exp_err);
> +		SAFE_CLOSE(fd);
>  	}
> +
> +	TST_EXP_FD_OR_FAIL(fd = open(FILE_TRUNCATE, O_WRONLY | O_TRUNC, PERM_MODE), exp_err);

Could the first open keep O_WRONLY without O_TRUNC?  In the
LANDLOCK_ACCESS_FS_WRITE_FILE-only variant, O_TRUNC is denied, fd remains
-1, and the ftruncate() check is skipped.  The next identical open then
tests O_TRUNC twice.

--- [PATCH 4/4] ---

> diff --git a/lib/newlib_tests/test_macros04.c b/lib/newlib_tests/test_macros04.c
> deleted file mode 100644

Could the test_macros04 entry be removed from lib/newlib_tests/.gitignore
along with the deleted test?

Verdict - Needs revision

---
Note:

The agent can sometimes produce false positives although often its
findings are genuine. If you find issues with the review, please
comment this email or ignore the suggestions.

Regards,
LTP AI Reviewer

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

Re: [LTP] [PATCH v3 1/4] test macros: Fix TST_EXP_FD_OR_FAIL()

[Cyril Hrubis]

Hi!
Reviewed-by: Cyril Hrubis <chrubis@suse.cz>

-- 
Cyril Hrubis
chrubis@suse.cz

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

Re: [LTP] [PATCH v3 2/4] test_macros: Add TST_EXP_PASS_OR_FAIL()

[Cyril Hrubis]

Hi!
Reviewed-by: Cyril Hrubis <chrubis@suse.cz>

-- 
Cyril Hrubis
chrubis@suse.cz

-- 
Mailing list info: https://lists.linux.it/listinfo/ltp