[PATCH 00/27] landlock: Selftest fixes and cleanups

[PATCH 00/27] landlock: Selftest fixes and cleanups

[Günther Noack]

A collection of Landlock Selftest fixes
=======================================

This patch set is bundled together to be slightly less spammy,
but the patches are mostly independent.  The commits are ordered
such that the simpler and more orthogonal patches come earlier.

The patch set is LLM-assisted (and that turned out to be very useful
for spotting errors).  Needless to say, I have verified all commits by
hand, and reworked them where necessary.

The last few patches are a bit more cross-cutting and probably more
prone to merge conflicts, as they correct cases where we have been
using EXPECT and ASSERT in the wrong way (details in the commit
messages).  I believe that the rationale for each of these is
reasonable, but I am happy to discuss.

Motivation
==========

LLMs (and humans ;-)) have an unfortunate tendency to pick up and
replicate bad coding style patterns, so I hope that a broader cleanup
of the test style will avoid this spreading further.


When applying this patch set, please base it on a branch that has Wang
Yan's snprintf() patch in it [1], which I also support as a selftest
cleanup.

–Günther

[1] https://lore.kernel.org/all/20260626070016.61049-1-wangyan01@kylinos.cn/

Günther Noack (27):
  selftests/landlock: Propagate grandchild failures in unix_scoping
  selftests/landlock: Propagate EXPECT failures from forked children
  selftests/landlock: Check the thread result in audit.thread
  selftests/landlock: Zero-initialize the buffer in inconsistent_attr
  selftests/landlock: Fix the openat() success check in fs_bench
  selftests/landlock: Fix the reported clock tick rate in fs_bench
  selftests/landlock: Fix the ruleset_fd check in empty_or_same_ruleset
  selftests/landlock: Handle a missing control message in recv_fd()
  selftests/landlock: Assert tracefs_extract_field() results that are
    used
  selftests/landlock: Assert audit initialization in fixture setups
  selftests/landlock: Assert helper results that are used afterwards
  selftests/landlock: Assert audit_count_records() before using its
    result
  selftests/landlock: Fix memory leak in audit_init_filter_exe()
  selftests/landlock: Make audit_message large enough for any exe filter
  selftests/landlock: Close leaked file descriptors
  selftests/landlock: Check errno for combined VERSION and ERRATA flags
  selftests/landlock: Fix SIGURG handler setup in scoped_signal_test
  selftests/landlock: Fix regex_escape() error handling in
    matches_log_fs_extra()
  selftests/landlock: Fix off-by-one in regex_escape()
  selftests/landlock: Fix the snprintf() error check in
    matches_log_fs_extra()
  selftests/landlock: Use _exit() in the named_pipe_ioctl child
  selftests/landlock: Fix messages and comments in helper programs
  selftests/landlock: Fix stale comments in common.h and audit.h
  selftests/landlock: Use ASSERT for syscall failures before errno
    checks
  selftests/landlock: Assert WIFEXITED() before checking the exit status
  selftests/landlock: Use EXPECT for closing FDs and stopping threads
  selftests/landlock: Use EXPECT for checks that later steps do not need

 tools/testing/selftests/landlock/audit.h      |   20 +-
 tools/testing/selftests/landlock/audit_test.c |   56 +-
 tools/testing/selftests/landlock/base_test.c  |  190 +--
 tools/testing/selftests/landlock/common.h     |   32 +-
 tools/testing/selftests/landlock/fs_bench.c   |    5 +-
 tools/testing/selftests/landlock/fs_test.c    | 1300 +++++++++--------
 tools/testing/selftests/landlock/net_test.c   |   64 +-
 .../testing/selftests/landlock/ptrace_test.c  |   44 +-
 .../selftests/landlock/sandbox-and-launch.c   |    6 +-
 .../landlock/scoped_abstract_unix_test.c      |   45 +-
 .../selftests/landlock/scoped_signal_test.c   |   23 +-
 .../testing/selftests/landlock/scoped_test.c  |    2 +-
 .../selftests/landlock/trace_fs_test.c        |    8 +-
 tools/testing/selftests/landlock/trace_test.c |   26 +-
 tools/testing/selftests/landlock/tsync_test.c |   22 +-
 .../selftests/landlock/wait-pipe-sandbox.c    |   16 +-
 tools/testing/selftests/landlock/wait-pipe.c  |    2 +-
 17 files changed, 952 insertions(+), 909 deletions(-)

-- 
2.56.0

[PATCH 01/27] selftests/landlock: Propagate grandchild failures in unix_scoping

[Günther Noack]

scoped_vs_unscoped.unix_scoping starts a child process and a
grandchild process.  Add the missing check for the grandchild's exit
status and propagate it upwards.

Assisted-by: LLM
Signed-off-by: Günther Noack <gnoack3000@gmail.com>
---
 tools/testing/selftests/landlock/scoped_abstract_unix_test.c | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/tools/testing/selftests/landlock/scoped_abstract_unix_test.c b/tools/testing/selftests/landlock/scoped_abstract_unix_test.c
index 5dc0debacb2a..e006dba61652 100644
--- a/tools/testing/selftests/landlock/scoped_abstract_unix_test.c
+++ b/tools/testing/selftests/landlock/scoped_abstract_unix_test.c
@@ -608,6 +608,11 @@ TEST_F(scoped_vs_unscoped, unix_scoping)
 		ASSERT_EQ(grand_child, waitpid(grand_child, &status, 0));
 		EXPECT_EQ(0, close(stream_server_child));
 		EXPECT_EQ(0, close(dgram_server_child));
+
+		if (WIFSIGNALED(status) || !WIFEXITED(status) ||
+		    WEXITSTATUS(status) != EXIT_SUCCESS)
+			_metadata->exit_code = KSFT_FAIL;
+		_exit(_metadata->exit_code);
 		return;
 	}
 	EXPECT_EQ(0, close(pipe_parent[0]));
-- 
2.56.0

[PATCH 02/27] selftests/landlock: Propagate EXPECT failures from forked children

[Günther Noack]

A failed ASSERT in a forked child calls abort(), so the parent sees
the child die from a signal and the test fails.  A failed EXPECT only
sets _metadata->exit_code, and a child that exits with a fixed status
of 0 hides that failure from the parent.  The child in
trace_fown.deny_scope_fown has this problem.

Exit with _metadata->exit_code in that child.  Do the same in the
audit.log_subdomains_off_fork children.  They only use ASSERT for now,
but this keeps them correct when a check becomes an EXPECT.

Assisted-by: LLM
Signed-off-by: Günther Noack <gnoack3000@gmail.com>
---
 tools/testing/selftests/landlock/audit_test.c         | 4 ++--
 tools/testing/selftests/landlock/scoped_signal_test.c | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/tools/testing/selftests/landlock/audit_test.c b/tools/testing/selftests/landlock/audit_test.c
index 4bea8c880a4d..502a0825d877 100644
--- a/tools/testing/selftests/landlock/audit_test.c
+++ b/tools/testing/selftests/landlock/audit_test.c
@@ -314,7 +314,7 @@ TEST_F(audit, log_subdomains_off_fork)
 		ASSERT_EQ(0, landlock_restrict_self(ruleset_fd, 0));
 		ASSERT_EQ(-1, kill(getppid(), 0));
 		ASSERT_EQ(EPERM, errno);
-		_exit(0);
+		_exit(_metadata->exit_code);
 		return;
 	}
 
@@ -347,7 +347,7 @@ TEST_F(audit, log_subdomains_off_fork)
 		ASSERT_EQ(0, landlock_restrict_self(ruleset_fd, 0));
 		ASSERT_EQ(-1, kill(getppid(), 0));
 		ASSERT_EQ(EPERM, errno);
-		_exit(0);
+		_exit(_metadata->exit_code);
 		return;
 	}
 
diff --git a/tools/testing/selftests/landlock/scoped_signal_test.c b/tools/testing/selftests/landlock/scoped_signal_test.c
index 259cdcc8aa5c..47307dd2e242 100644
--- a/tools/testing/selftests/landlock/scoped_signal_test.c
+++ b/tools/testing/selftests/landlock/scoped_signal_test.c
@@ -1090,7 +1090,7 @@ TEST_F(trace_fown, deny_scope_fown)
 		ASSERT_EQ(1, write(pipe_child[1], ".", 1));
 		EXPECT_EQ(0, close(pipe_child[1]));
 
-		_exit(0);
+		_exit(_metadata->exit_code);
 		return;
 	}
 	EXPECT_EQ(0, close(pipe_parent[0]));
-- 
2.56.0

[PATCH 03/27] selftests/landlock: Check the thread result in audit.thread

[Günther Noack]

thread_audit_test() reports failures through its return value, but
audit.thread joins the thread with a NULL result pointer, so these
failures go unnoticed.

Check the returned value, as the other thread-based audit tests do.

Assisted-by: LLM
Signed-off-by: Günther Noack <gnoack3000@gmail.com>
---
 tools/testing/selftests/landlock/audit_test.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/tools/testing/selftests/landlock/audit_test.c b/tools/testing/selftests/landlock/audit_test.c
index 502a0825d877..81cb31aa32ad 100644
--- a/tools/testing/selftests/landlock/audit_test.c
+++ b/tools/testing/selftests/landlock/audit_test.c
@@ -227,6 +227,7 @@ TEST_F(audit, thread)
 	__u64 allocated_dom = 2;
 	__u64 deallocated_dom = 3;
 	pthread_t thread;
+	void *thread_ret;
 	int pipe_child[2], pipe_parent[2];
 	char buffer;
 	struct thread_data child_data;
@@ -270,7 +271,8 @@ TEST_F(audit, thread)
 	/* Signals the thread to exit, which will generate a domain deallocation. */
 	ASSERT_EQ(1, write(pipe_parent[1], ".", 1));
 	EXPECT_EQ(0, close(pipe_parent[1]));
-	ASSERT_EQ(0, pthread_join(thread, NULL));
+	ASSERT_EQ(0, pthread_join(thread, &thread_ret));
+	EXPECT_EQ(NULL, thread_ret);
 
 	EXPECT_EQ(0, matches_log_domain_deallocated(
 			     self->audit_fd, 1, denial_dom, &deallocated_dom));
-- 
2.56.0

[PATCH 04/27] selftests/landlock: Zero-initialize the buffer in inconsistent_attr

[Günther Noack]

This buffer is passed to landlock_create_ruleset() a bit further down,
expecting an ENOMSG error.  This is only guaranteed when the buffer is
zero-initialized.

Assisted-by: LLM
Signed-off-by: Günther Noack <gnoack3000@gmail.com>
---
 tools/testing/selftests/landlock/base_test.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/testing/selftests/landlock/base_test.c b/tools/testing/selftests/landlock/base_test.c
index d20ab8f0862c..4e83f9c52a6f 100644
--- a/tools/testing/selftests/landlock/base_test.c
+++ b/tools/testing/selftests/landlock/base_test.c
@@ -25,7 +25,7 @@
 TEST(inconsistent_attr)
 {
 	const long page_size = sysconf(_SC_PAGESIZE);
-	char *const buf = malloc(page_size + 1);
+	char *const buf = calloc(1, page_size + 1);
 	struct landlock_ruleset_attr *const ruleset_attr = (void *)buf;
 
 	ASSERT_NE(NULL, buf);
-- 
2.56.0

[PATCH 05/27] selftests/landlock: Fix the openat() success check in fs_bench

[Günther Noack]

fs_bench expects openat() to be denied when Landlock is enabled, but
only treats a returned FD of 0 as success.  Any other valid FD falls
through to the errno check, which then reports a stale errno value.

Check for any non-negative FD instead.

Assisted-by: LLM
Signed-off-by: Günther Noack <gnoack3000@gmail.com>
---
 tools/testing/selftests/landlock/fs_bench.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/testing/selftests/landlock/fs_bench.c b/tools/testing/selftests/landlock/fs_bench.c
index d13a88dcd1ed..78d1efcb2d20 100644
--- a/tools/testing/selftests/landlock/fs_bench.c
+++ b/tools/testing/selftests/landlock/fs_bench.c
@@ -189,7 +189,7 @@ int main(int argc, char *argv[])
 		fd = openat(curr, "file.txt", O_CREAT | O_TRUNC | O_WRONLY,
 			    0600);
 		if (use_landlock) {
-			if (fd == 0)
+			if (fd >= 0)
 				errx(1, "openat succeeded, expected EACCES");
 			if (errno != EACCES)
 				err(1, "openat expected EACCES, but got");
-- 
2.56.0

[PATCH 06/27] selftests/landlock: Fix the reported clock tick rate in fs_bench

[Günther Noack]

Since time is measured using times(2), ticks per second are obtained
using sysconf(_SC_CLK_TCK) instead of CLOCKS_PER_SEC.  (c.f. times(2)
man page)

Assisted-by: LLM
Signed-off-by: Günther Noack <gnoack3000@gmail.com>
---
 tools/testing/selftests/landlock/fs_bench.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/tools/testing/selftests/landlock/fs_bench.c b/tools/testing/selftests/landlock/fs_bench.c
index 78d1efcb2d20..05082562d272 100644
--- a/tools/testing/selftests/landlock/fs_bench.c
+++ b/tools/testing/selftests/landlock/fs_bench.c
@@ -32,7 +32,6 @@
 #include <sys/prctl.h>
 #include <sys/stat.h>
 #include <sys/times.h>
-#include <time.h>
 #include <unistd.h>
 
 #include "wrappers.h"
@@ -206,7 +205,7 @@ int main(int argc, char *argv[])
 	       end_time.tms_stime - start_time.tms_stime);
 	printf("User  : %ld clocks\n",
 	       end_time.tms_utime - start_time.tms_utime);
-	printf("Clocks per second: %ld\n", CLOCKS_PER_SEC);
+	printf("Clocks per second: %ld\n", sysconf(_SC_CLK_TCK));
 
 	close(curr);
 
-- 
2.56.0

[PATCH 07/27] selftests/landlock: Fix the ruleset_fd check in empty_or_same_ruleset

[Günther Noack]

ASSERT_LE(-1, ruleset_fd) is always true, so the test does not check
that creating a ruleset with an empty handled_access_fs fails.  Check
for -1 instead.

Assisted-by: LLM
Signed-off-by: Günther Noack <gnoack3000@gmail.com>
---
 tools/testing/selftests/landlock/fs_test.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/testing/selftests/landlock/fs_test.c b/tools/testing/selftests/landlock/fs_test.c
index 6e979cef884d..9884ce9917db 100644
--- a/tools/testing/selftests/landlock/fs_test.c
+++ b/tools/testing/selftests/landlock/fs_test.c
@@ -1463,7 +1463,7 @@ TEST_F_FORK(layout1, empty_or_same_ruleset)
 	/* Tests empty handled_access_fs. */
 	ruleset_fd =
 		landlock_create_ruleset(&ruleset_attr, sizeof(ruleset_attr), 0);
-	ASSERT_LE(-1, ruleset_fd);
+	ASSERT_EQ(-1, ruleset_fd);
 	ASSERT_EQ(ENOMSG, errno);
 
 	/* Enforces policy which denies read access to all files. */
-- 
2.56.0

[PATCH 08/27] selftests/landlock: Handle a missing control message in recv_fd()

[Günther Noack]

CMSG_FIRSTHDR() returns NULL when recvmsg(2) did not receive any
ancillary data, e.g. when the peer closed the socket without sending an
FD.  recv_fd() dereferences the result unconditionally and crashes
instead of returning an error.

Return -EIO in that case.

Assisted-by: LLM
Signed-off-by: Günther Noack <gnoack3000@gmail.com>
---
 tools/testing/selftests/landlock/common.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/testing/selftests/landlock/common.h b/tools/testing/selftests/landlock/common.h
index c5124de68a51..e195c0f48eb3 100644
--- a/tools/testing/selftests/landlock/common.h
+++ b/tools/testing/selftests/landlock/common.h
@@ -158,7 +158,7 @@ static int __maybe_unused recv_fd(int usock)
 		return -errno;
 
 	cmsg = CMSG_FIRSTHDR(&msg);
-	if (cmsg->cmsg_len != CMSG_LEN(sizeof(fd_rx)))
+	if (!cmsg || cmsg->cmsg_len != CMSG_LEN(sizeof(fd_rx)))
 		return -EIO;
 
 	memcpy(&fd_rx, CMSG_DATA(cmsg), sizeof(fd_rx));
-- 
2.56.0

[PATCH 09/27] selftests/landlock: Assert tracefs_extract_field() results that are used

[Günther Noack]

Several trace tests check tracefs_extract_field() with EXPECT_EQ() and
then compare the extracted field.  If the extraction fails, the field
buffer is left uninitialized and the following comparison reads it.

Use ASSERT_EQ() for these calls, as the other trace tests already do.

Assisted-by: LLM
Signed-off-by: Günther Noack <gnoack3000@gmail.com>
---
 tools/testing/selftests/landlock/trace_test.c | 20 +++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/tools/testing/selftests/landlock/trace_test.c b/tools/testing/selftests/landlock/trace_test.c
index f9b293a9dd56..a331df746dbc 100644
--- a/tools/testing/selftests/landlock/trace_test.c
+++ b/tools/testing/selftests/landlock/trace_test.c
@@ -175,19 +175,19 @@ TEST_F(trace, create_ruleset)
 	}
 
 	/* Verify handled_fs matches what we requested. */
-	EXPECT_EQ(0,
+	ASSERT_EQ(0,
 		  tracefs_extract_field(buf, REGEX_CREATE_RULESET(TRACE_TASK),
 					"handled_fs", field, sizeof(field)));
 	EXPECT_STREQ("read_file", field);
 
 	/* Verify handled_net matches. */
-	EXPECT_EQ(0,
+	ASSERT_EQ(0,
 		  tracefs_extract_field(buf, REGEX_CREATE_RULESET(TRACE_TASK),
 					"handled_net", field, sizeof(field)));
 	EXPECT_STREQ("bind_tcp", field);
 
 	/* Verify version is 0 at creation (no rules added yet). */
-	EXPECT_EQ(0,
+	ASSERT_EQ(0,
 		  tracefs_extract_field(buf, REGEX_CREATE_RULESET(TRACE_TASK),
 					"ruleset", field, sizeof(field)));
 	/* Format is <hex>.<dec>; version is after the dot. */
@@ -357,7 +357,7 @@ TEST_F(trace, create_domain)
 	}
 
 	/* Extract the domain ID from create_domain. */
-	EXPECT_EQ(0, tracefs_extract_field(buf, REGEX_CREATE_DOMAIN(TRACE_TASK),
+	ASSERT_EQ(0, tracefs_extract_field(buf, REGEX_CREATE_DOMAIN(TRACE_TASK),
 					   "domain", domain_id,
 					   sizeof(domain_id)));
 
@@ -365,7 +365,7 @@ TEST_F(trace, create_domain)
 	EXPECT_NE(0, strcmp(domain_id, "0"));
 
 	/* Verify parent=0 (first restriction, no prior domain). */
-	EXPECT_EQ(0, tracefs_extract_field(buf, REGEX_CREATE_DOMAIN(TRACE_TASK),
+	ASSERT_EQ(0, tracefs_extract_field(buf, REGEX_CREATE_DOMAIN(TRACE_TASK),
 					   "parent", parent_id,
 					   sizeof(parent_id)));
 	EXPECT_STREQ("0", parent_id);
@@ -381,7 +381,7 @@ TEST_F(trace, create_domain)
 		TH_LOG("Expected check_rule_inode events\n%s", buf);
 	}
 
-	EXPECT_EQ(0, tracefs_extract_field(buf, REGEX_CHECK_RULE_FS(TRACE_TASK),
+	ASSERT_EQ(0, tracefs_extract_field(buf, REGEX_CHECK_RULE_FS(TRACE_TASK),
 					   "domain", check_domain,
 					   sizeof(check_domain)));
 	EXPECT_STREQ(domain_id, check_domain);
@@ -615,7 +615,7 @@ TEST_F(trace, free_domain)
 	}
 
 	/* Verify denials count matches the single denial we triggered. */
-	EXPECT_EQ(0, tracefs_extract_field(buf, REGEX_FREE_DOMAIN(KWORKER_TASK),
+	ASSERT_EQ(0, tracefs_extract_field(buf, REGEX_FREE_DOMAIN(KWORKER_TASK),
 					   "denials", denials_field,
 					   sizeof(denials_field)));
 	EXPECT_STREQ("1", denials_field);
@@ -900,7 +900,7 @@ TEST_F(trace, non_audit_visible_denial_counting)
 	{
 		TH_LOG("free_domain event not found after 10 retries");
 	}
-	EXPECT_EQ(0, tracefs_extract_field(buf, REGEX_FREE_DOMAIN(KWORKER_TASK),
+	ASSERT_EQ(0, tracefs_extract_field(buf, REGEX_FREE_DOMAIN(KWORKER_TASK),
 					   "denials", denials_field,
 					   sizeof(denials_field)));
 	EXPECT_STREQ("1", denials_field);
@@ -949,7 +949,7 @@ TEST_F(trace, add_rule_net_port_fields)
 	 * (landlock_net_port_attr.port).  On little-endian, htons(8080) is
 	 * 36895, so this comparison catches byte-order bugs.
 	 */
-	EXPECT_EQ(0, tracefs_extract_field(buf,
+	ASSERT_EQ(0, tracefs_extract_field(buf,
 					   REGEX_ADD_RULE_NET_PORT(TRACE_TASK),
 					   "port", field, sizeof(field)));
 	EXPECT_STREQ("8080", field);
@@ -959,7 +959,7 @@ TEST_F(trace, add_rule_net_port_fields)
 	 * net access bits are unhandled because the ruleset only handles
 	 * BIND_TCP).
 	 */
-	EXPECT_EQ(0, tracefs_extract_field(
+	ASSERT_EQ(0, tracefs_extract_field(
 			     buf, REGEX_ADD_RULE_NET_PORT(TRACE_TASK),
 			     "access_rights", field, sizeof(field)));
 	EXPECT_STREQ("bind_tcp|connect_tcp|bind_udp|connect_send_udp", field);
-- 
2.56.0

[PATCH 10/27] selftests/landlock: Assert audit initialization in fixture setups

[Günther Noack]

The audit fixtures check the result of audit_init_with_exe_filter() and
audit_init() with EXPECT_LE() and continue with a negative audit FD
when the initialization fails, e.g. when auditd holds the audit socket.
Every following audit check then fails with a less useful message.

Use ASSERT_*() for the audit FD and for the audit_exec filter
initialization, whose result is used by the following calls.

Assisted-by: LLM
Signed-off-by: Günther Noack <gnoack3000@gmail.com>
---
 tools/testing/selftests/landlock/audit_test.c             | 8 ++++----
 tools/testing/selftests/landlock/fs_test.c                | 6 +++---
 tools/testing/selftests/landlock/net_test.c               | 2 +-
 tools/testing/selftests/landlock/ptrace_test.c            | 2 +-
 .../selftests/landlock/scoped_abstract_unix_test.c        | 2 +-
 5 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/tools/testing/selftests/landlock/audit_test.c b/tools/testing/selftests/landlock/audit_test.c
index 81cb31aa32ad..63b1b2a04eee 100644
--- a/tools/testing/selftests/landlock/audit_test.c
+++ b/tools/testing/selftests/landlock/audit_test.c
@@ -49,7 +49,7 @@ FIXTURE_SETUP(audit)
 	disable_caps(_metadata);
 	set_cap(_metadata, CAP_AUDIT_CONTROL);
 	self->audit_fd = audit_init_with_exe_filter(&self->audit_filter);
-	EXPECT_LE(0, self->audit_fd)
+	ASSERT_LE(0, self->audit_fd)
 	{
 		const char *error_msg;
 
@@ -652,7 +652,7 @@ FIXTURE_SETUP(audit_flags)
 	disable_caps(_metadata);
 	set_cap(_metadata, CAP_AUDIT_CONTROL);
 	self->audit_fd = audit_init_with_exe_filter(&self->audit_filter);
-	EXPECT_LE(0, self->audit_fd)
+	ASSERT_LE(0, self->audit_fd)
 	{
 		const char *error_msg;
 
@@ -841,7 +841,7 @@ FIXTURE_SETUP(audit_exec)
 	set_cap(_metadata, CAP_AUDIT_CONTROL);
 
 	self->audit_fd = audit_init();
-	EXPECT_LE(0, self->audit_fd)
+	ASSERT_LE(0, self->audit_fd)
 	{
 		const char *error_msg;
 
@@ -854,7 +854,7 @@ FIXTURE_SETUP(audit_exec)
 	}
 
 	/* Applies test filter for the bin_wait_pipe_sandbox program. */
-	EXPECT_EQ(0, audit_init_filter_exe(&self->audit_filter,
+	ASSERT_EQ(0, audit_init_filter_exe(&self->audit_filter,
 					   bin_wait_pipe_sandbox));
 	EXPECT_EQ(0, audit_filter_exe(self->audit_fd, &self->audit_filter,
 				      AUDIT_ADD_RULE));
diff --git a/tools/testing/selftests/landlock/fs_test.c b/tools/testing/selftests/landlock/fs_test.c
index 9884ce9917db..779a7bf477a9 100644
--- a/tools/testing/selftests/landlock/fs_test.c
+++ b/tools/testing/selftests/landlock/fs_test.c
@@ -7508,7 +7508,7 @@ FIXTURE_SETUP(audit_layout1)
 
 	set_cap(_metadata, CAP_AUDIT_CONTROL);
 	self->audit_fd = audit_init_with_exe_filter(&self->audit_filter);
-	EXPECT_LE(0, self->audit_fd);
+	ASSERT_LE(0, self->audit_fd);
 	disable_caps(_metadata);
 }
 
@@ -8031,7 +8031,7 @@ FIXTURE_SETUP(audit_quiet_layout1)
 
 	set_cap(_metadata, CAP_AUDIT_CONTROL);
 	self->audit_fd = audit_init_with_exe_filter(&self->audit_filter);
-	EXPECT_LE(0, self->audit_fd);
+	ASSERT_LE(0, self->audit_fd);
 	clear_cap(_metadata, CAP_AUDIT_CONTROL);
 
 	if (getenv("DEBUG_QUIET_TESTS"))
@@ -9608,7 +9608,7 @@ FIXTURE_SETUP(audit_quiet_rename)
 
 	set_cap(_metadata, CAP_AUDIT_CONTROL);
 	self->audit_fd = audit_init_with_exe_filter(&self->audit_filter);
-	EXPECT_LE(0, self->audit_fd);
+	ASSERT_LE(0, self->audit_fd);
 	clear_cap(_metadata, CAP_AUDIT_CONTROL);
 
 	if (getenv("DEBUG_QUIET_TESTS"))
diff --git a/tools/testing/selftests/landlock/net_test.c b/tools/testing/selftests/landlock/net_test.c
index 50b637354b51..c1b6e288c965 100644
--- a/tools/testing/selftests/landlock/net_test.c
+++ b/tools/testing/selftests/landlock/net_test.c
@@ -2957,7 +2957,7 @@ FIXTURE_SETUP(audit)
 
 	set_cap(_metadata, CAP_AUDIT_CONTROL);
 	self->audit_fd = audit_init_with_exe_filter(&self->audit_filter);
-	EXPECT_LE(0, self->audit_fd);
+	ASSERT_LE(0, self->audit_fd);
 	disable_caps(_metadata);
 };
 
diff --git a/tools/testing/selftests/landlock/ptrace_test.c b/tools/testing/selftests/landlock/ptrace_test.c
index e0e7f95e889b..10371c1830ad 100644
--- a/tools/testing/selftests/landlock/ptrace_test.c
+++ b/tools/testing/selftests/landlock/ptrace_test.c
@@ -323,7 +323,7 @@ FIXTURE_SETUP(audit)
 	disable_caps(_metadata);
 	set_cap(_metadata, CAP_AUDIT_CONTROL);
 	self->audit_fd = audit_init_with_exe_filter(&self->audit_filter);
-	EXPECT_LE(0, self->audit_fd);
+	ASSERT_LE(0, self->audit_fd);
 	clear_cap(_metadata, CAP_AUDIT_CONTROL);
 }
 
diff --git a/tools/testing/selftests/landlock/scoped_abstract_unix_test.c b/tools/testing/selftests/landlock/scoped_abstract_unix_test.c
index e006dba61652..5e8224623780 100644
--- a/tools/testing/selftests/landlock/scoped_abstract_unix_test.c
+++ b/tools/testing/selftests/landlock/scoped_abstract_unix_test.c
@@ -288,7 +288,7 @@ FIXTURE_SETUP(scoped_audit)
 
 	set_cap(_metadata, CAP_AUDIT_CONTROL);
 	self->audit_fd = audit_init_with_exe_filter(&self->audit_filter);
-	EXPECT_LE(0, self->audit_fd);
+	ASSERT_LE(0, self->audit_fd);
 	drop_caps(_metadata);
 }
 
-- 
2.56.0

[PATCH 11/27] selftests/landlock: Assert helper results that are used afterwards

[Günther Noack]

Some helpers check a result with EXPECT_*() and then use it:
cap_get_proc() in _init_caps() and _change_cap(), and
landlock_create_ruleset() in drop_access_rights(), create_domain() and
create_fs_domain().  On failure they pass NULL or -1 to the next calls,
which then fail with misleading messages.

Use ASSERT_*() for these checks, as create_scoped_domain() already does.

Assisted-by: LLM
Signed-off-by: Günther Noack <gnoack3000@gmail.com>
---
 tools/testing/selftests/landlock/common.h                   | 6 +++---
 tools/testing/selftests/landlock/ptrace_test.c              | 2 +-
 .../testing/selftests/landlock/scoped_abstract_unix_test.c  | 2 +-
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/tools/testing/selftests/landlock/common.h b/tools/testing/selftests/landlock/common.h
index e195c0f48eb3..e1aa0ec02c96 100644
--- a/tools/testing/selftests/landlock/common.h
+++ b/tools/testing/selftests/landlock/common.h
@@ -53,7 +53,7 @@ static void _init_caps(struct __test_metadata *const _metadata, bool drop_all)
 		EXPECT_EQ(0, cap_set_secbits(noroot));
 
 	cap_p = cap_get_proc();
-	EXPECT_NE(NULL, cap_p);
+	ASSERT_NE(NULL, cap_p);
 	EXPECT_NE(-1, cap_clear(cap_p));
 	if (!drop_all) {
 		EXPECT_NE(-1, cap_set_flag(cap_p, CAP_PERMITTED,
@@ -89,7 +89,7 @@ static void _change_cap(struct __test_metadata *const _metadata,
 	cap_t cap_p;
 
 	cap_p = cap_get_proc();
-	EXPECT_NE(NULL, cap_p);
+	ASSERT_NE(NULL, cap_p);
 	EXPECT_NE(-1, cap_set_flag(cap_p, flag, 1, &cap, value));
 	EXPECT_NE(-1, cap_set_proc(cap_p))
 	{
@@ -214,7 +214,7 @@ drop_access_rights(struct __test_metadata *const _metadata,
 
 	ruleset_fd =
 		landlock_create_ruleset(ruleset_attr, sizeof(*ruleset_attr), 0);
-	EXPECT_LE(0, ruleset_fd)
+	ASSERT_LE(0, ruleset_fd)
 	{
 		TH_LOG("Failed to create a ruleset: %s", strerror(errno));
 	}
diff --git a/tools/testing/selftests/landlock/ptrace_test.c b/tools/testing/selftests/landlock/ptrace_test.c
index 10371c1830ad..b951889cd6ca 100644
--- a/tools/testing/selftests/landlock/ptrace_test.c
+++ b/tools/testing/selftests/landlock/ptrace_test.c
@@ -37,7 +37,7 @@ static void create_domain(struct __test_metadata *const _metadata)
 
 	ruleset_fd =
 		landlock_create_ruleset(&ruleset_attr, sizeof(ruleset_attr), 0);
-	EXPECT_LE(0, ruleset_fd)
+	ASSERT_LE(0, ruleset_fd)
 	{
 		TH_LOG("Failed to create a ruleset: %s", strerror(errno));
 	}
diff --git a/tools/testing/selftests/landlock/scoped_abstract_unix_test.c b/tools/testing/selftests/landlock/scoped_abstract_unix_test.c
index 5e8224623780..55a1599819c8 100644
--- a/tools/testing/selftests/landlock/scoped_abstract_unix_test.c
+++ b/tools/testing/selftests/landlock/scoped_abstract_unix_test.c
@@ -40,7 +40,7 @@ static void create_fs_domain(struct __test_metadata *const _metadata)
 
 	ruleset_fd =
 		landlock_create_ruleset(&ruleset_attr, sizeof(ruleset_attr), 0);
-	EXPECT_LE(0, ruleset_fd)
+	ASSERT_LE(0, ruleset_fd)
 	{
 		TH_LOG("Failed to create a ruleset: %s", strerror(errno));
 	}
-- 
2.56.0

[PATCH 12/27] selftests/landlock: Assert audit_count_records() before using its result

[Günther Noack]

audit_count_records() fills in the record counts that are checked right
after it, but its return value is checked with EXPECT.  On failure, the
counts may be left uninitialized and the following checks are
meaningless.  Use ASSERT instead.

Assisted-by: LLM
Signed-off-by: Günther Noack <gnoack3000@gmail.com>
---
 tools/testing/selftests/landlock/audit_test.c | 20 ++---
 tools/testing/selftests/landlock/fs_test.c    | 86 +++++++++----------
 tools/testing/selftests/landlock/net_test.c   | 22 ++---
 .../testing/selftests/landlock/ptrace_test.c  |  6 +-
 .../landlock/scoped_abstract_unix_test.c      |  4 +-
 5 files changed, 69 insertions(+), 69 deletions(-)

diff --git a/tools/testing/selftests/landlock/audit_test.c b/tools/testing/selftests/landlock/audit_test.c
index 63b1b2a04eee..325fbb9ca297 100644
--- a/tools/testing/selftests/landlock/audit_test.c
+++ b/tools/testing/selftests/landlock/audit_test.c
@@ -329,7 +329,7 @@ TEST_F(audit, log_subdomains_off_fork)
 					NULL));
 
 	/* Drains any remaining records (e.g. domain allocation). */
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 
 	/*
 	 * Mutes subdomain logs without creating a domain.  The parent's
@@ -361,7 +361,7 @@ TEST_F(audit, log_subdomains_off_fork)
 	EXPECT_EQ(-EAGAIN, matches_log_signal(_metadata, self->audit_fd,
 					      getpid(), NULL));
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 
 	EXPECT_EQ(0, close(ruleset_fd));
@@ -487,7 +487,7 @@ TEST_F(audit, log_subdomains_off_tsync)
 					child_data.parent_pid, NULL));
 
 	/* Drains any remaining records (e.g. domain allocation). */
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 
 	/*
 	 * Mutes subdomain logs and propagates to the sibling thread via TSYNC,
@@ -509,7 +509,7 @@ TEST_F(audit, log_subdomains_off_tsync)
 	EXPECT_EQ(-EAGAIN, matches_log_signal(_metadata, self->audit_fd,
 					      child_data.parent_pid, NULL));
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 
 	EXPECT_EQ(0, close(pipe_child[0]));
@@ -571,7 +571,7 @@ TEST_F(audit, tsync_override_log_subdomains_off)
 					      child_data.parent_pid, NULL));
 
 	/* Drains any remaining records. */
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 
 	/*
@@ -740,7 +740,7 @@ TEST_F(audit_flags, signal)
 		EXPECT_EQ(EPERM, errno);
 
 		/* Makes sure there is no superfluous logged records. */
-		EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+		ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 		if (!expect_audit) {
 			EXPECT_EQ(0, records.access);
 		} else {
@@ -929,7 +929,7 @@ TEST_F(audit_exec, signal_and_open)
 	EXPECT_EQ(1, read(pipe_child[0], &buf_parent, 1));
 
 	/* Tests that there was no denial until now. */
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(0, records.domain);
 
@@ -948,7 +948,7 @@ TEST_F(audit_exec, signal_and_open)
 	}
 
 	/* Checks that we didn't miss anything. */
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 
 	/*
@@ -972,7 +972,7 @@ TEST_F(audit_exec, signal_and_open)
 	}
 
 	/* Checks that we didn't miss anything. */
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 
 	/* Waits for the child to terminate. */
@@ -995,7 +995,7 @@ TEST_F(audit_exec, signal_and_open)
 	}
 
 	/* Checks that we didn't miss anything. */
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 }
 
diff --git a/tools/testing/selftests/landlock/fs_test.c b/tools/testing/selftests/landlock/fs_test.c
index 779a7bf477a9..b1ce0f810e10 100644
--- a/tools/testing/selftests/landlock/fs_test.c
+++ b/tools/testing/selftests/landlock/fs_test.c
@@ -7538,7 +7538,7 @@ TEST_F(audit_layout1, execute_make)
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd, "fs\\.execute",
 				    file1_s1d1));
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(0, records.domain);
 }
@@ -7569,7 +7569,7 @@ TEST_F(audit_layout1, execute_read)
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
 				    "fs\\.execute,fs\\.read_file", file1_s1d1));
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(0, records.domain);
 }
@@ -7584,7 +7584,7 @@ TEST_F(audit_layout1, write_file)
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
 				    "fs\\.write_file", file1_s1d1));
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(1, records.domain);
 }
@@ -7599,7 +7599,7 @@ TEST_F(audit_layout1, read_file)
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd, "fs\\.read_file",
 				    file1_s1d1));
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(1, records.domain);
 }
@@ -7614,7 +7614,7 @@ TEST_F(audit_layout1, read_dir)
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd, "fs\\.read_dir",
 				    dir_s1d1));
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(1, records.domain);
 }
@@ -7638,7 +7638,7 @@ TEST_F(audit_layout1, remove_dir)
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
 				    "fs\\.remove_dir", dir_s1d2));
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(0, records.domain);
 }
@@ -7654,7 +7654,7 @@ TEST_F(audit_layout1, remove_file)
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
 				    "fs\\.remove_file", dir_s1d3));
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(1, records.domain);
 }
@@ -7672,7 +7672,7 @@ TEST_F(audit_layout1, make_char)
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd, "fs\\.make_char",
 				    dir_s1d3));
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(1, records.domain);
 }
@@ -7691,7 +7691,7 @@ TEST_F(audit_layout1, make_whiteout)
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd, "fs\\.make_reg",
 				    dir_s1d3));
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(1, records.domain);
 }
@@ -7709,7 +7709,7 @@ TEST_F(audit_layout1, make_dir)
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd, "fs\\.make_dir",
 				    dir_s1d3));
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(1, records.domain);
 }
@@ -7727,7 +7727,7 @@ TEST_F(audit_layout1, make_reg)
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd, "fs\\.make_reg",
 				    dir_s1d3));
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(1, records.domain);
 }
@@ -7745,7 +7745,7 @@ TEST_F(audit_layout1, make_sock)
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd, "fs\\.make_sock",
 				    dir_s1d3));
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(1, records.domain);
 }
@@ -7763,7 +7763,7 @@ TEST_F(audit_layout1, make_fifo)
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd, "fs\\.make_fifo",
 				    dir_s1d3));
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(1, records.domain);
 }
@@ -7781,7 +7781,7 @@ TEST_F(audit_layout1, make_block)
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
 				    "fs\\.make_block", dir_s1d3));
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(1, records.domain);
 }
@@ -7799,7 +7799,7 @@ TEST_F(audit_layout1, make_sym)
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd, "fs\\.make_sym",
 				    dir_s1d3));
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(1, records.domain);
 }
@@ -7821,7 +7821,7 @@ TEST_F(audit_layout1, refer_handled)
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd, "fs\\.refer",
 				    dir_s1d3));
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(0, records.domain);
 }
@@ -7843,7 +7843,7 @@ TEST_F(audit_layout1, refer_make)
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
 				    "fs\\.make_reg,fs\\.refer", dir_s1d3));
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(0, records.domain);
 }
@@ -7863,7 +7863,7 @@ TEST_F(audit_layout1, refer_rename)
 				    "fs\\.remove_file,fs\\.make_reg,fs\\.refer",
 				    dir_s2d3));
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(0, records.domain);
 }
@@ -7888,7 +7888,7 @@ TEST_F(audit_layout1, refer_exchange)
 				    "fs\\.remove_file,fs\\.make_reg,fs\\.refer",
 				    dir_s2d3));
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(0, records.domain);
 }
@@ -7922,7 +7922,7 @@ TEST_F(audit_layout1, refer_rename_half)
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd, "fs\\.refer",
 				    dir_s1d1));
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(1, records.domain);
 }
@@ -7938,7 +7938,7 @@ TEST_F(audit_layout1, truncate)
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd, "fs\\.truncate",
 				    file1_s1d3));
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(1, records.domain);
 }
@@ -7957,7 +7957,7 @@ TEST_F(audit_layout1, ioctl_dev)
 					  "fs\\.ioctl_dev", "/dev/null",
 					  " ioctlcmd=0x541b"));
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(1, records.domain);
 }
@@ -7992,7 +7992,7 @@ TEST_F(audit_layout1, resolve_unix)
 	EXPECT_EQ(0, matches_log_fs_extra(_metadata, self->audit_fd,
 					  "fs\\.resolve_unix", path, NULL));
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(1, records.domain);
 
@@ -8011,7 +8011,7 @@ TEST_F(audit_layout1, mount)
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
 				    "fs\\.change_topology", dir_s3d2));
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(1, records.domain);
 }
@@ -8253,7 +8253,7 @@ void audit_quiet_layout1_test_body(struct __test_metadata *const _metadata,
 						    blocker, target->target));
 
 		/* Check that we see no (other) logs. */
-		EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+		ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 		ASSERT_EQ(0, records.access);
 
 		if (target->expect_open_success && fd >= 0) {
@@ -8297,7 +8297,7 @@ void audit_quiet_layout1_test_body(struct __test_metadata *const _metadata,
 						     " ioctlcmd=0x541b\\+"));
 
 			/* Check that we see no other logs. */
-			EXPECT_EQ(0, audit_count_records(self->audit_fd,
+			ASSERT_EQ(0, audit_count_records(self->audit_fd,
 							 &records));
 			ASSERT_EQ(0, records.access);
 			ASSERT_EQ(0, close(fd));
@@ -9698,7 +9698,7 @@ static void simple_quiet_rename(struct __test_metadata *const _metadata,
 	 * No other logs. records.domain not checked per reasoning in
 	 * audit_quiet_layout1_test_body.
 	 */
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	ASSERT_EQ(0, records.access);
 }
 
@@ -9817,7 +9817,7 @@ TEST_F(audit_quiet_rename, handle_all_deny_quiet_refer)
 	ASSERT_EQ(EXDEV, errno);
 
 	/* No logs */
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	ASSERT_EQ(0, records.access);
 }
 
@@ -9858,7 +9858,7 @@ TEST_F(audit_quiet_rename, handle_all_deny_not_quiet_refer)
 				    dir_s2d1));
 
 	/* No other logs */
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	ASSERT_EQ(0, records.access);
 }
 
@@ -9897,7 +9897,7 @@ TEST_F(audit_quiet_rename, handle_all_deny_refer_quiet_source_not_quiet_dest)
 				    dir_s2d1));
 
 	/* No other logs */
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	ASSERT_EQ(0, records.access);
 }
 
@@ -9924,7 +9924,7 @@ TEST_F(audit_quiet_rename, quiet_same_dir)
 	ASSERT_EQ(-1, renameat(AT_FDCWD, file1_s1d1, AT_FDCWD, file2_s1d1));
 	ASSERT_EQ(EACCES, errno);
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	ASSERT_EQ(0, records.access);
 }
 
@@ -9964,7 +9964,7 @@ TEST_F(audit_quiet_rename, quiet_flag_on_file_ignored)
 				    dir_s2d1));
 
 	/* No other logs */
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	ASSERT_EQ(0, records.access);
 }
 
@@ -10001,7 +10001,7 @@ TEST_F(audit_quiet_rename, quiet_flag_on_file_ignored_same_dir)
 				 "fs\\.remove_file,fs\\.make_reg", dir_s1d1));
 
 	/* No other logs */
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	ASSERT_EQ(0, records.access);
 }
 
@@ -10059,7 +10059,7 @@ TEST_F(audit_quiet_rename, two_layers_different_quiet1)
 	ASSERT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
 				    "fs\\.remove_file,fs\\.refer", dir_s1d1));
 	/* No other logs */
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	ASSERT_EQ(0, records.access);
 }
 
@@ -10114,7 +10114,7 @@ TEST_F(audit_quiet_rename, two_layers_different_quiet2)
 	 * The youngest denial will be layer 2, but refer is quieted (and that
 	 * layer does not handle any other accesses).
 	 */
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	ASSERT_EQ(0, records.access);
 }
 
@@ -10168,7 +10168,7 @@ TEST_F(audit_quiet_rename, two_layers_different_quiet3)
 	/*
 	 * The youngest denial will be layer 2, in which everything is quieted.
 	 */
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	ASSERT_EQ(0, records.access);
 }
 
@@ -10214,7 +10214,7 @@ TEST_F(audit_quiet_rename,
 	ASSERT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
 				    "fs\\.make_reg,fs\\.refer", dir_s2d1));
 	/* No other logs. */
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	ASSERT_EQ(0, records.access);
 }
 
@@ -10265,7 +10265,7 @@ TEST_F(audit_quiet_rename,
 	ASSERT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
 				    "fs\\.make_reg,fs\\.refer", dir_s2d1));
 	/* No other logs. */
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	ASSERT_EQ(0, records.access);
 }
 
@@ -10298,7 +10298,7 @@ TEST_F(audit_quiet_rename, rename_xchg)
 				RENAME_EXCHANGE));
 	ASSERT_EQ(EACCES, errno);
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	ASSERT_EQ(0, records.access);
 }
 
@@ -10327,7 +10327,7 @@ TEST_F(audit_quiet_rename, quiet_on_parent_mount)
 			       bind_file2_s1d3));
 	ASSERT_EQ(EACCES, errno);
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	ASSERT_EQ(0, records.access);
 }
 
@@ -10359,7 +10359,7 @@ TEST_F(audit_quiet_rename, quiet_behind_mountpoint_ignored)
 				    "fs\\.remove_file,fs\\.make_reg",
 				    bind_dir_s1d3));
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	ASSERT_EQ(0, records.access);
 }
 
@@ -10397,7 +10397,7 @@ TEST_F(audit_quiet_rename, quiet_on_parent_mount_disconnected)
 		  renameat(bind_s1d3_fd, file1_name, bind_s1d3_fd, file2_name));
 	ASSERT_EQ(EACCES, errno);
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	ASSERT_EQ(0, records.access);
 }
 
@@ -10435,7 +10435,7 @@ TEST_F(audit_quiet_rename, quiet_behind_mountpoint_disconnected)
 		  renameat(bind_s1d3_fd, file1_name, bind_s1d3_fd, file2_name));
 	ASSERT_EQ(EACCES, errno);
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	ASSERT_EQ(0, records.access);
 }
 
diff --git a/tools/testing/selftests/landlock/net_test.c b/tools/testing/selftests/landlock/net_test.c
index c1b6e288c965..563e2214390b 100644
--- a/tools/testing/selftests/landlock/net_test.c
+++ b/tools/testing/selftests/landlock/net_test.c
@@ -3004,7 +3004,7 @@ TEST_F(audit, bind)
 	EXPECT_EQ(0, matches_auditlog(self->audit_fd, audit_evt, "saddr",
 				      variant->addr, "src", self->srv0.port));
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(1, records.domain);
 
@@ -3015,7 +3015,7 @@ TEST_F(audit, bind)
 	ASSERT_LE(0, sock_fd);
 	EXPECT_EQ(-EACCES, bind_variant(sock_fd, &self->srv2));
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(0, records.domain);
 
@@ -3065,7 +3065,7 @@ TEST_F(audit, connect)
 	EXPECT_EQ(0, matches_auditlog(self->audit_fd, audit_evt, "daddr",
 				      variant->addr, "dest", self->srv0.port));
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(1, records.domain);
 
@@ -3075,7 +3075,7 @@ TEST_F(audit, connect)
 
 		EXPECT_EQ(0, matches_auditlog(self->audit_fd, "net\\.bind_udp",
 					      NULL, NULL, NULL, 0));
-		EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+		ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 		EXPECT_EQ(0, records.access);
 		EXPECT_EQ(0, records.domain);
 	}
@@ -3087,7 +3087,7 @@ TEST_F(audit, connect)
 	ASSERT_LE(0, sock_fd);
 	EXPECT_EQ(-EACCES, connect_variant(sock_fd, &self->srv2));
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(0, records.domain);
 
@@ -3136,7 +3136,7 @@ TEST_F(audit, connect_quiet_bind)
 	EXPECT_EQ(0, matches_auditlog(self->audit_fd, audit_evt, "daddr",
 				      variant->addr, "dest", self->srv2.port));
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 
 	EXPECT_EQ(0, close(sock_fd));
@@ -3155,7 +3155,7 @@ TEST_F(audit, connect_quiet_bind)
 	EXPECT_EQ(-EACCES, connect_variant(sock_fd, &self->srv2));
 
 	/* Quieted - no logs expected. */
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 
 	EXPECT_EQ(0, close(sock_fd));
@@ -3226,7 +3226,7 @@ TEST_F(audit, connect_bound)
 					       variant->addr, self->srv0.port,
 					       srv_remote.port));
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(1, records.domain);
 
@@ -3266,7 +3266,7 @@ TEST_F(audit, sendmsg)
 				      "daddr", variant->addr, "dest",
 				      self->srv0.port));
 
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(1, records.domain);
 
@@ -3274,7 +3274,7 @@ TEST_F(audit, sendmsg)
 	EXPECT_EQ(-EACCES, sendto_variant(sock_fd, &self->srv1, "A", 1, 0));
 	EXPECT_EQ(0, matches_auditlog(self->audit_fd, "net\\.bind_udp", NULL,
 				      NULL, NULL, 0));
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(0, records.domain);
 
@@ -3282,7 +3282,7 @@ TEST_F(audit, sendmsg)
 		  sendto_variant(sock_fd, &self->unspec_srv0, "B", 1, 0));
 	EXPECT_EQ(0, matches_auditlog(self->audit_fd, "net\\.connect_send_udp",
 				      "daddr", NULL, "dest", 0));
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(0, records.domain);
 
diff --git a/tools/testing/selftests/landlock/ptrace_test.c b/tools/testing/selftests/landlock/ptrace_test.c
index b951889cd6ca..eb36d4d1ceaf 100644
--- a/tools/testing/selftests/landlock/ptrace_test.c
+++ b/tools/testing/selftests/landlock/ptrace_test.c
@@ -343,7 +343,7 @@ TEST_F(audit, trace)
 	struct audit_records records;
 
 	/* Makes sure there is no superfluous logged records. */
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(0, records.domain);
 
@@ -381,7 +381,7 @@ TEST_F(audit, trace)
 		EXPECT_EQ(0, matches_log_ptrace(_metadata, self->audit_fd,
 						getpid()));
 
-		EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+		ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 		EXPECT_EQ(0, records.access);
 		/* Checks for a domain creation. */
 		EXPECT_EQ(1, records.domain);
@@ -428,7 +428,7 @@ TEST_F(audit, trace)
 		_metadata->exit_code = KSFT_FAIL;
 
 	/* Makes sure there is no superfluous logged records. */
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(0, records.domain);
 }
diff --git a/tools/testing/selftests/landlock/scoped_abstract_unix_test.c b/tools/testing/selftests/landlock/scoped_abstract_unix_test.c
index 55a1599819c8..67fcc3380238 100644
--- a/tools/testing/selftests/landlock/scoped_abstract_unix_test.c
+++ b/tools/testing/selftests/landlock/scoped_abstract_unix_test.c
@@ -360,7 +360,7 @@ TEST_F(scoped_audit, connect_to_child)
 		!(variant->quiet_scoped & LANDLOCK_SCOPE_ABSTRACT_UNIX_SOCKET);
 
 	/* Makes sure there is no superfluous logged records. */
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 	EXPECT_EQ(0, records.domain);
 
@@ -429,7 +429,7 @@ TEST_F(scoped_audit, connect_to_child)
 	}
 
 	/* No other logs */
-	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
+	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
 	EXPECT_EQ(0, records.access);
 
 	ASSERT_EQ(1, write(pipe_parent[1], ".", 1));
-- 
2.56.0

[PATCH 13/27] selftests/landlock: Fix memory leak in audit_init_filter_exe()

[Günther Noack]

audit_init_filter_exe() does not free the buffer returned by realpath(3)
when the path is too long.

Assisted-by: LLM
Signed-off-by: Günther Noack <gnoack3000@gmail.com>
---
 tools/testing/selftests/landlock/audit.h | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/tools/testing/selftests/landlock/audit.h b/tools/testing/selftests/landlock/audit.h
index d428ce802f49..1e533b4e26db 100644
--- a/tools/testing/selftests/landlock/audit.h
+++ b/tools/testing/selftests/landlock/audit.h
@@ -507,8 +507,10 @@ static int audit_init_filter_exe(struct audit_filter *filter, const char *path)
 
 	/* No need for the terminating NULL byte. */
 	filter->exe_len = strlen(absolute_path);
-	if (filter->exe_len > sizeof(filter->exe))
+	if (filter->exe_len > sizeof(filter->exe)) {
+		free(absolute_path);
 		return -E2BIG;
+	}
 
 	memcpy(filter->exe, absolute_path, filter->exe_len);
 	free(absolute_path);
-- 
2.56.0

[PATCH 14/27] selftests/landlock: Make audit_message large enough for any exe filter

[Günther Noack]

audit_filter_exe() copies the filtered executable path after the
audit_rule_data header in struct audit_message.  The message buffer was
sized as PATH_MAX + 200 bytes with received records in mind, but
struct audit_rule_data alone takes 1040 bytes.  That leaves only 3256
bytes for the path, while the kernel accepts up to PATH_MAX bytes, so a
long path overflows the message.

Size the buffer for an audit_rule_data followed by a PATH_MAX string.
This only makes the buffer larger, so received records still fit.

Also check that the request fits in the message and return -E2BIG
otherwise, in case exe_len does not match the filter's buffer.

Assisted-by: LLM
Signed-off-by: Günther Noack <gnoack3000@gmail.com>
---
 tools/testing/selftests/landlock/audit.h | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/tools/testing/selftests/landlock/audit.h b/tools/testing/selftests/landlock/audit.h
index 1e533b4e26db..173dcd1088db 100644
--- a/tools/testing/selftests/landlock/audit.h
+++ b/tools/testing/selftests/landlock/audit.h
@@ -41,7 +41,11 @@ struct audit_message {
 		struct audit_features features;
 		struct audit_rule_data rule;
 		struct nlmsgerr err;
-		char data[PATH_MAX + 200];
+		/*
+		 * Large enough for an audit_rule_data followed by a PATH_MAX
+		 * string (see audit_filter_exe()), and for received records.
+		 */
+		char data[sizeof(struct audit_rule_data) + PATH_MAX];
 	};
 };
 
@@ -171,6 +175,9 @@ static int audit_filter_exe(const int audit_fd,
 	if (filter->record_type != AUDIT_EXE)
 		return -EINVAL;
 
+	if (msg.header.nlmsg_len > sizeof(msg))
+		return -E2BIG;
+
 	memcpy(msg.rule.buf, filter->exe, filter->exe_len);
 	return audit_request(audit_fd, &msg, NULL);
 }
-- 
2.56.0

[PATCH 15/27] selftests/landlock: Close leaked file descriptors

[Günther Noack]

Several tests do not close file descriptors they open: the /dev/null FD
in restrict_self_fd and restrict_self_fd_flags, and the parent's ends
of the synchronization pipes in various ptrace, audit, signal and
abstract UNIX socket tests.

Close them once they are not needed anymore.

Assisted-by: LLM
Signed-off-by: Günther Noack <gnoack3000@gmail.com>
---
 tools/testing/selftests/landlock/audit_test.c          |  2 ++
 tools/testing/selftests/landlock/base_test.c           |  4 ++++
 tools/testing/selftests/landlock/ptrace_test.c         |  4 ++++
 .../selftests/landlock/scoped_abstract_unix_test.c     | 10 ++++++++++
 tools/testing/selftests/landlock/scoped_signal_test.c  |  1 +
 5 files changed, 21 insertions(+)

diff --git a/tools/testing/selftests/landlock/audit_test.c b/tools/testing/selftests/landlock/audit_test.c
index 325fbb9ca297..b38d0c5d5869 100644
--- a/tools/testing/selftests/landlock/audit_test.c
+++ b/tools/testing/selftests/landlock/audit_test.c
@@ -977,6 +977,8 @@ TEST_F(audit_exec, signal_and_open)
 
 	/* Waits for the child to terminate. */
 	EXPECT_EQ(1, write(pipe_parent[1], ".", 1));
+	EXPECT_EQ(0, close(pipe_parent[1]));
+	EXPECT_EQ(0, close(pipe_child[0]));
 	ASSERT_EQ(child, waitpid(child, &status, 0));
 	ASSERT_EQ(1, WIFEXITED(status));
 	ASSERT_EQ(0, WEXITSTATUS(status));
diff --git a/tools/testing/selftests/landlock/base_test.c b/tools/testing/selftests/landlock/base_test.c
index 4e83f9c52a6f..e486e557f453 100644
--- a/tools/testing/selftests/landlock/base_test.c
+++ b/tools/testing/selftests/landlock/base_test.c
@@ -333,6 +333,8 @@ TEST(restrict_self_fd)
 
 	EXPECT_EQ(-1, landlock_restrict_self(fd, 0));
 	EXPECT_EQ(EBADFD, errno);
+
+	EXPECT_EQ(0, close(fd));
 }
 
 TEST(restrict_self_fd_flags)
@@ -354,6 +356,8 @@ TEST(restrict_self_fd_flags)
 	EXPECT_EQ(-1, landlock_restrict_self(
 			      fd, LANDLOCK_RESTRICT_SELF_NO_NEW_PRIVS));
 	EXPECT_EQ(EBADFD, errno);
+
+	EXPECT_EQ(0, close(fd));
 }
 
 TEST(restrict_self_flags)
diff --git a/tools/testing/selftests/landlock/ptrace_test.c b/tools/testing/selftests/landlock/ptrace_test.c
index eb36d4d1ceaf..4fd2b440aa45 100644
--- a/tools/testing/selftests/landlock/ptrace_test.c
+++ b/tools/testing/selftests/landlock/ptrace_test.c
@@ -288,6 +288,8 @@ TEST_F(scoped_domains, trace)
 
 	/* Signals that the parent PTRACE_ATTACH test is done. */
 	ASSERT_EQ(1, write(pipe_parent[1], ".", 1));
+	EXPECT_EQ(0, close(pipe_parent[1]));
+	EXPECT_EQ(0, close(pipe_child[0]));
 	ASSERT_EQ(child, waitpid(child, &status, 0));
 
 	if (WIFSIGNALED(status) || !WIFEXITED(status) ||
@@ -422,6 +424,8 @@ TEST_F(audit, trace)
 
 	/* Signals that the parent PTRACE_ATTACH test is done. */
 	ASSERT_EQ(1, write(pipe_parent[1], ".", 1));
+	EXPECT_EQ(0, close(pipe_parent[1]));
+	EXPECT_EQ(0, close(pipe_child[0]));
 	ASSERT_EQ(child, waitpid(child, &status, 0));
 	if (WIFSIGNALED(status) || !WIFEXITED(status) ||
 	    WEXITSTATUS(status) != EXIT_SUCCESS)
diff --git a/tools/testing/selftests/landlock/scoped_abstract_unix_test.c b/tools/testing/selftests/landlock/scoped_abstract_unix_test.c
index 67fcc3380238..df41da5f2ab0 100644
--- a/tools/testing/selftests/landlock/scoped_abstract_unix_test.c
+++ b/tools/testing/selftests/landlock/scoped_abstract_unix_test.c
@@ -156,6 +156,7 @@ TEST_F(scoped_domains, connect_to_parent)
 
 	/* Signals to child that the parent is listening. */
 	ASSERT_EQ(1, write(pipe_parent[1], ".", 1));
+	EXPECT_EQ(0, close(pipe_parent[1]));
 
 	ASSERT_EQ(child, waitpid(child, &status, 0));
 	EXPECT_EQ(0, close(stream_server));
@@ -263,6 +264,8 @@ TEST_F(scoped_domains, connect_to_child)
 		EXPECT_EQ(EPERM, errno_dgram);
 	}
 	ASSERT_EQ(1, write(pipe_parent[1], ".", 1));
+	EXPECT_EQ(0, close(pipe_parent[1]));
+	EXPECT_EQ(0, close(pipe_child[0]));
 	EXPECT_EQ(0, close(stream_client));
 	EXPECT_EQ(0, close(dgram_client));
 
@@ -433,6 +436,8 @@ TEST_F(scoped_audit, connect_to_child)
 	EXPECT_EQ(0, records.access);
 
 	ASSERT_EQ(1, write(pipe_parent[1], ".", 1));
+	EXPECT_EQ(0, close(pipe_parent[1]));
+	EXPECT_EQ(0, close(pipe_child[0]));
 	EXPECT_EQ(0, close(dgram_client));
 
 	ASSERT_EQ(child, waitpid(child, &status, 0));
@@ -637,6 +642,7 @@ TEST_F(scoped_vs_unscoped, unix_scoping)
 	ASSERT_EQ(0, listen(stream_server_parent, backlog));
 
 	ASSERT_EQ(1, write(pipe_parent[1], ".", 1));
+	EXPECT_EQ(0, close(pipe_parent[1]));
 	ASSERT_EQ(child, waitpid(child, &status, 0));
 	EXPECT_EQ(0, close(stream_server_parent));
 	EXPECT_EQ(0, close(dgram_server_parent));
@@ -779,6 +785,7 @@ TEST_F(outside_socket, socket_with_different_domain)
 	} else {
 		server_socket = socket(AF_UNIX, variant->type, 0);
 	}
+	EXPECT_EQ(0, close(pipe_child[0]));
 	ASSERT_LE(0, server_socket);
 
 	/* Server always has a domain. */
@@ -791,6 +798,7 @@ TEST_F(outside_socket, socket_with_different_domain)
 
 	/* Signals to child that the parent is listening. */
 	ASSERT_EQ(1, write(pipe_parent[1], ".", 1));
+	EXPECT_EQ(0, close(pipe_parent[1]));
 
 	ASSERT_EQ(child, waitpid(child, &status, 0));
 	EXPECT_EQ(0, close(server_socket));
@@ -1139,6 +1147,8 @@ TEST(datagram_sockets)
 	 */
 	ASSERT_EQ(1, read(pipe_child[0], &buf, 1));
 	ASSERT_EQ(1, recv(server_conn_socket, &buf, 1, 0));
+	EXPECT_EQ(0, close(pipe_parent[1]));
+	EXPECT_EQ(0, close(pipe_child[0]));
 
 	/* Waits for all tests to finish. */
 	ASSERT_EQ(child, waitpid(child, &status, 0));
diff --git a/tools/testing/selftests/landlock/scoped_signal_test.c b/tools/testing/selftests/landlock/scoped_signal_test.c
index 47307dd2e242..0f88a6af9c72 100644
--- a/tools/testing/selftests/landlock/scoped_signal_test.c
+++ b/tools/testing/selftests/landlock/scoped_signal_test.c
@@ -1120,6 +1120,7 @@ TEST_F(trace_fown, deny_scope_fown)
 	ASSERT_EQ(0, fcntl(recv_socket, F_SETOWN, child));
 
 	ASSERT_EQ(1, write(pipe_parent[1], ".", 1));
+	EXPECT_EQ(0, close(pipe_parent[1]));
 
 	/* Waits for the child to send MSG_OOB. */
 	ASSERT_EQ(1, read(pipe_child[0], &buffer_parent, 1));
-- 
2.56.0

[PATCH 16/27] selftests/landlock: Check errno for combined VERSION and ERRATA flags

[Günther Noack]

The errata test checks that combining LANDLOCK_CREATE_RULESET_VERSION
and LANDLOCK_CREATE_RULESET_ERRATA fails, but not the resulting errno,
unlike the other checks in this test.

Assisted-by: LLM
Signed-off-by: Günther Noack <gnoack3000@gmail.com>
---
 tools/testing/selftests/landlock/base_test.c | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tools/testing/selftests/landlock/base_test.c b/tools/testing/selftests/landlock/base_test.c
index e486e557f453..5f10300a60cd 100644
--- a/tools/testing/selftests/landlock/base_test.c
+++ b/tools/testing/selftests/landlock/base_test.c
@@ -136,6 +136,8 @@ TEST(errata)
 			      NULL, 0,
 			      LANDLOCK_CREATE_RULESET_VERSION |
 				      LANDLOCK_CREATE_RULESET_ERRATA));
+	ASSERT_EQ(EINVAL, errno);
+
 	ASSERT_EQ(-1, landlock_create_ruleset(NULL, 0,
 					      LANDLOCK_CREATE_RULESET_ERRATA |
 						      1 << 31));
-- 
2.56.0

[PATCH 17/27] selftests/landlock: Fix SIGURG handler setup in scoped_signal_test

[Günther Noack]

Drop SA_SIGINFO, and rename the function to setup_sigurg_handler()
without the parameter.

* Drop the SA_SIGINFO flag: This flag implies that we use the
  three-argument sa_sigaction signal handlers, which is not the case
  here. (c.f. sigaction(2))
* Remove the "int signal" argument and rename the function:
  The function was already specific to SIGURG and this is better
  communicated through a different name.

Assisted-by: LLM
Signed-off-by: Günther Noack <gnoack3000@gmail.com>
---
 .../selftests/landlock/scoped_signal_test.c        | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/tools/testing/selftests/landlock/scoped_signal_test.c b/tools/testing/selftests/landlock/scoped_signal_test.c
index 0f88a6af9c72..66fec3822812 100644
--- a/tools/testing/selftests/landlock/scoped_signal_test.c
+++ b/tools/testing/selftests/landlock/scoped_signal_test.c
@@ -392,7 +392,7 @@ static void handle_sigurg(int sig)
 		signal_received = -1;
 }
 
-static int setup_signal_handler(int signal)
+static int setup_sigurg_handler(void)
 {
 	struct sigaction sa = {
 		.sa_handler = handle_sigurg,
@@ -401,7 +401,7 @@ static int setup_signal_handler(int signal)
 	if (sigemptyset(&sa.sa_mask))
 		return -1;
 
-	sa.sa_flags = SA_SIGINFO | SA_RESTART;
+	sa.sa_flags = SA_RESTART;
 	return sigaction(SIGURG, &sa, NULL);
 }
 
@@ -506,7 +506,7 @@ TEST_F(fown, sigurg_socket)
 		EXPECT_EQ(0, close(pipe_parent[1]));
 		EXPECT_EQ(0, close(pipe_child[0]));
 
-		ASSERT_EQ(0, setup_signal_handler(SIGURG));
+		ASSERT_EQ(0, setup_sigurg_handler());
 		client_socket = socket(AF_UNIX, SOCK_STREAM, 0);
 		ASSERT_LE(0, client_socket);
 
@@ -612,7 +612,7 @@ TEST(sigio_to_pgid_members)
 	ASSERT_EQ(0, setpgid(0, 0));
 
 	/* The non-sandboxed parent is the protected (out-of-domain) target. */
-	ASSERT_EQ(0, setup_signal_handler(SIGURG));
+	ASSERT_EQ(0, setup_sigurg_handler());
 	signal_received = 0;
 
 	ASSERT_EQ(0, pipe2(trigger, O_CLOEXEC));
@@ -629,7 +629,7 @@ TEST(sigio_to_pgid_members)
 		EXPECT_EQ(0, close(sync_child[0]));
 
 		/* In-domain positive control: the child must be signaled. */
-		ASSERT_EQ(0, setup_signal_handler(SIGURG));
+		ASSERT_EQ(0, setup_sigurg_handler());
 		signal_received = 0;
 
 		create_scoped_domain(_metadata, LANDLOCK_SCOPE_SIGNAL);
@@ -737,7 +737,7 @@ TEST(sigio_to_pgid_self)
 	ASSERT_EQ(0, setpgid(0, 0));
 
 	/* The non-sandboxed thread-group leader is the SIGIO target. */
-	ASSERT_EQ(0, setup_signal_handler(SIGURG));
+	ASSERT_EQ(0, setup_sigurg_handler());
 	signal_received = 0;
 
 	ASSERT_EQ(0, pipe2(trigger, O_CLOEXEC));
@@ -1062,7 +1062,7 @@ TEST_F(trace_fown, deny_scope_fown)
 		EXPECT_EQ(0, close(pipe_parent[1]));
 		EXPECT_EQ(0, close(pipe_child[0]));
 
-		ASSERT_EQ(0, setup_signal_handler(SIGURG));
+		ASSERT_EQ(0, setup_sigurg_handler());
 		client_socket = socket(AF_UNIX, SOCK_STREAM, 0);
 		ASSERT_LE(0, client_socket);
 
-- 
2.56.0

[PATCH 18/27] selftests/landlock: Fix regex_escape() error handling in matches_log_fs_extra()

[Günther Noack]

Use a more conventional error handling interface in regex_escape():
Return a ssize_t, which is either the number of bytes in the output,
or return -1 and set errno.

Before this change, the (log_match_cursor < 0) check in the call site
was never true because log_match_cursor is a pointer.

Assisted-by: LLM
Signed-off-by: Günther Noack <gnoack3000@gmail.com>
---
 tools/testing/selftests/landlock/common.h  | 20 ++++++++++++--------
 tools/testing/selftests/landlock/fs_test.c | 12 +++++++-----
 2 files changed, 19 insertions(+), 13 deletions(-)

diff --git a/tools/testing/selftests/landlock/common.h b/tools/testing/selftests/landlock/common.h
index e1aa0ec02c96..91842f618a3a 100644
--- a/tools/testing/selftests/landlock/common.h
+++ b/tools/testing/selftests/landlock/common.h
@@ -264,11 +264,11 @@ static void __maybe_unused set_unix_address(struct service_fixture *const srv,
  * Escapes characters that have special meaning in POSIX Basic Regular
  * Expressions: $ * . [ \ ] ^
  *
- * Returns a pointer to the NUL terminator in @dst (cursor-style API for
- * chaining), or (char *)-ENOMEM if the buffer is too small.
+ * Returns the length of the escaped string (excluding the NUL terminator), or
+ * -1 with errno set to ENOMEM if the buffer is too small.
  */
-static __maybe_unused char *regex_escape(const char *const src, char *dst,
-					 size_t dst_size)
+static __maybe_unused ssize_t regex_escape(const char *const src, char *dst,
+					   size_t dst_size)
 {
 	char *d = dst;
 
@@ -282,21 +282,25 @@ static __maybe_unused char *regex_escape(const char *const src, char *dst,
 		case ']':
 		case '^':
 			if (d >= dst + dst_size - 2)
-				return (char *)-ENOMEM;
+				goto err_nomem;
 
 			*d++ = '\\';
 			*d++ = *s;
 			break;
 		default:
 			if (d >= dst + dst_size - 1)
-				return (char *)-ENOMEM;
+				goto err_nomem;
 
 			*d++ = *s;
 		}
 	}
 	if (d >= dst + dst_size - 1)
-		return (char *)-ENOMEM;
+		goto err_nomem;
 
 	*d = '\0';
-	return d;
+	return d - dst;
+
+err_nomem:
+	errno = ENOMEM;
+	return -1;
 }
diff --git a/tools/testing/selftests/landlock/fs_test.c b/tools/testing/selftests/landlock/fs_test.c
index b1ce0f810e10..9abc2adef79d 100644
--- a/tools/testing/selftests/landlock/fs_test.c
+++ b/tools/testing/selftests/landlock/fs_test.c
@@ -7454,6 +7454,7 @@ static int matches_log_fs_extra(struct __test_metadata *const _metadata,
 	char log_match[log_match_remaining];
 	char *log_match_cursor = log_match;
 	size_t chunk_len;
+	ssize_t escaped_len;
 
 	chunk_len = snprintf(log_match_cursor, log_match_remaining,
 			     REGEX_LANDLOCK_PREFIX " blockers=%s path=\"",
@@ -7471,13 +7472,14 @@ static int matches_log_fs_extra(struct __test_metadata *const _metadata,
 
 	log_match_remaining -= chunk_len;
 	log_match_cursor += chunk_len;
-	log_match_cursor = regex_escape(absolute_path, log_match_cursor,
-					log_match_remaining);
+	escaped_len = regex_escape(absolute_path, log_match_cursor,
+				   log_match_remaining);
 	free(absolute_path);
-	if (log_match_cursor < 0)
-		return (long long)log_match_cursor;
+	if (escaped_len < 0)
+		return -errno;
 
-	log_match_remaining -= log_match_cursor - log_match;
+	log_match_remaining -= escaped_len;
+	log_match_cursor += escaped_len;
 	chunk_len = snprintf(log_match_cursor, log_match_remaining,
 			     "\" dev=\"[^\"]\\+\" ino=[0-9]\\+%s$",
 			     extra ?: "");
-- 
2.56.0

[PATCH 19/27] selftests/landlock: Fix off-by-one in regex_escape()

[Günther Noack]

The final check in regex_escape() was off by one byte
and should require one byte less to put the NUL byte.

Assisted-by: LLM
Signed-off-by: Günther Noack <gnoack3000@gmail.com>
---
 tools/testing/selftests/landlock/common.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/testing/selftests/landlock/common.h b/tools/testing/selftests/landlock/common.h
index 91842f618a3a..ae6a0eb8e343 100644
--- a/tools/testing/selftests/landlock/common.h
+++ b/tools/testing/selftests/landlock/common.h
@@ -294,7 +294,7 @@ static __maybe_unused ssize_t regex_escape(const char *const src, char *dst,
 			*d++ = *s;
 		}
 	}
-	if (d >= dst + dst_size - 1)
+	if (d >= dst + dst_size)
 		goto err_nomem;
 
 	*d = '\0';
-- 
2.56.0

[PATCH 20/27] selftests/landlock: Fix the snprintf() error check in matches_log_fs_extra()

[Günther Noack]

By storing the snprintf result in a size_t, the chunk_len < 0 check
could never be true.  Store it in an int instead, matching the return
type of snprintf().

Fixes: 316d06b01130 ("selftests/landlock: Add audit tests for filesystem")
Assisted-by: LLM
Signed-off-by: Günther Noack <gnoack3000@gmail.com>
---
 tools/testing/selftests/landlock/fs_test.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/testing/selftests/landlock/fs_test.c b/tools/testing/selftests/landlock/fs_test.c
index 9abc2adef79d..90f63af1d64d 100644
--- a/tools/testing/selftests/landlock/fs_test.c
+++ b/tools/testing/selftests/landlock/fs_test.c
@@ -7453,7 +7453,7 @@ static int matches_log_fs_extra(struct __test_metadata *const _metadata,
 				     (extra ? strlen(extra) : 0) + 1;
 	char log_match[log_match_remaining];
 	char *log_match_cursor = log_match;
-	size_t chunk_len;
+	int chunk_len;
 	ssize_t escaped_len;
 
 	chunk_len = snprintf(log_match_cursor, log_match_remaining,
-- 
2.56.0

[PATCH 21/27] selftests/landlock: Use _exit() in the named_pipe_ioctl child

[Günther Noack]

In the named_pipe_ioctl test, use _exit(2) like in other places.

Assisted-by: LLM
Signed-off-by: Günther Noack <gnoack3000@gmail.com>
---
 tools/testing/selftests/landlock/fs_test.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/testing/selftests/landlock/fs_test.c b/tools/testing/selftests/landlock/fs_test.c
index 90f63af1d64d..ba3b39ad5882 100644
--- a/tools/testing/selftests/landlock/fs_test.c
+++ b/tools/testing/selftests/landlock/fs_test.c
@@ -4276,7 +4276,7 @@ TEST_F_FORK(layout1, named_pipe_ioctl)
 	if (child_pid == 0) {
 		fd = open(path, O_WRONLY);
 		close(fd);
-		exit(0);
+		_exit(0);
 	}
 
 	fd = open(path, O_RDONLY);
-- 
2.56.0

[PATCH 22/27] selftests/landlock: Fix messages and comments in helper programs

[Günther Noack]

* sandbox-and-launch: Describe the actual argument order.
* sandbox-and-launch, wait-pipe, wait-pipe-sandbox: Report failed
  read(2) calls as read failures, not write failures.
* wait-pipe-sandbox: Terminate error messages with a newline, and fix
  comments naming "." instead of the opened "/".

Assisted-by: LLM
Signed-off-by: Günther Noack <gnoack3000@gmail.com>
---
 .../selftests/landlock/sandbox-and-launch.c      |  6 +++---
 .../selftests/landlock/wait-pipe-sandbox.c       | 16 ++++++++--------
 tools/testing/selftests/landlock/wait-pipe.c     |  2 +-
 3 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/tools/testing/selftests/landlock/sandbox-and-launch.c b/tools/testing/selftests/landlock/sandbox-and-launch.c
index 3e32e1a51ac5..8b33ddadc63e 100644
--- a/tools/testing/selftests/landlock/sandbox-and-launch.c
+++ b/tools/testing/selftests/landlock/sandbox-and-launch.c
@@ -25,8 +25,8 @@ int main(int argc, char *argv[])
 	char buf;
 
 	/*
-	 * The first argument must be the file descriptor number of a pipe.
-	 * The second argument must be the program to execute.
+	 * The first argument must be the program to execute.  The second and
+	 * third arguments must be the file descriptor numbers of two pipes.
 	 */
 	if (argc != 4) {
 		fprintf(stderr, "Wrong number of arguments (not three)\n");
@@ -67,7 +67,7 @@ int main(int argc, char *argv[])
 
 	/* Waits for the parent to try to umount. */
 	if (read(pipe_parent, &buf, 1) != 1) {
-		perror("Failed to write to the third argument");
+		perror("Failed to read from the third argument");
 		return 1;
 	}
 
diff --git a/tools/testing/selftests/landlock/wait-pipe-sandbox.c b/tools/testing/selftests/landlock/wait-pipe-sandbox.c
index 87dbc9164430..dbc0c2747e9f 100644
--- a/tools/testing/selftests/landlock/wait-pipe-sandbox.c
+++ b/tools/testing/selftests/landlock/wait-pipe-sandbox.c
@@ -31,7 +31,7 @@ static int sync_with(int pipe_child, int pipe_parent)
 
 	/* Waits for the parent do its test. */
 	if (read(pipe_parent, &buf, 1) != 1) {
-		perror("Failed to write to the second argument");
+		perror("Failed to read from the second argument");
 		return 1;
 	}
 
@@ -65,7 +65,7 @@ int main(int argc, char *argv[])
 
 	/* Tries to send a signal, denied by layer1. */
 	if (!kill(getppid(), 0)) {
-		fprintf(stderr, "Successfully sent a signal to the parent");
+		fprintf(stderr, "Successfully sent a signal to the parent\n");
 		return 1;
 	}
 
@@ -88,13 +88,13 @@ int main(int argc, char *argv[])
 
 	/* Tries to send a signal, denied by layer1. */
 	if (!kill(getppid(), 0)) {
-		fprintf(stderr, "Successfully sent a signal to the parent");
+		fprintf(stderr, "Successfully sent a signal to the parent\n");
 		return 1;
 	}
 
-	/* Tries to open ., denied by layer2. */
+	/* Tries to open /, denied by layer2. */
 	if (open("/", O_RDONLY | O_DIRECTORY | O_CLOEXEC) >= 0) {
-		fprintf(stderr, "Successfully opened /");
+		fprintf(stderr, "Successfully opened /\n");
 		return 1;
 	}
 
@@ -115,15 +115,15 @@ int main(int argc, char *argv[])
 	}
 	close(ruleset_fd);
 
-	/* Tries to open ., denied by layer2. */
+	/* Tries to open /, denied by layer2. */
 	if (open("/", O_RDONLY | O_DIRECTORY | O_CLOEXEC) >= 0) {
-		fprintf(stderr, "Successfully opened /");
+		fprintf(stderr, "Successfully opened /\n");
 		return 1;
 	}
 
 	/* Tries to send a signal, denied by layer3. */
 	if (!kill(getppid(), 0)) {
-		fprintf(stderr, "Successfully sent a signal to the parent");
+		fprintf(stderr, "Successfully sent a signal to the parent\n");
 		return 1;
 	}
 
diff --git a/tools/testing/selftests/landlock/wait-pipe.c b/tools/testing/selftests/landlock/wait-pipe.c
index 0dbcd260a0fa..3cfa4dce5f35 100644
--- a/tools/testing/selftests/landlock/wait-pipe.c
+++ b/tools/testing/selftests/landlock/wait-pipe.c
@@ -34,7 +34,7 @@ int main(int argc, char *argv[])
 
 	/* Waits for the parent do its test. */
 	if (read(pipe_parent, &buf, 1) != 1) {
-		perror("Failed to write to the second argument");
+		perror("Failed to read from the second argument");
 		return 1;
 	}
 
-- 
2.56.0

[PATCH 23/27] selftests/landlock: Fix stale comments in common.h and audit.h

[Günther Noack]

* _init_caps() lists more than three capabilities.
* A 64-bit hexadecimal domain ID has at most 16 digits, not 17.  Size
  the buffer accordingly and drop a redundant domain_id check in
  audit_match_record().

Assisted-by: LLM
Signed-off-by: Günther Noack <gnoack3000@gmail.com>
---
 tools/testing/selftests/landlock/audit.h  | 7 +++----
 tools/testing/selftests/landlock/common.h | 2 +-
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/tools/testing/selftests/landlock/audit.h b/tools/testing/selftests/landlock/audit.h
index 173dcd1088db..d23bb2ad3a30 100644
--- a/tools/testing/selftests/landlock/audit.h
+++ b/tools/testing/selftests/landlock/audit.h
@@ -274,15 +274,14 @@ static int audit_match_record(int audit_fd, const __u16 type,
 		*domain_id = 0;
 		if (matches[1].rm_so != -1) {
 			int match_len = matches[1].rm_eo - matches[1].rm_so;
-			/* The maximal characters of a 2^64 hexadecimal number is 17. */
-			char dom_id[18];
+			/* A 64-bit hexadecimal number has at most 16 digits. */
+			char dom_id[17];
 
 			if (match_len > 0 && match_len < sizeof(dom_id)) {
 				memcpy(dom_id, msg.data + matches[1].rm_so,
 				       match_len);
 				dom_id[match_len] = '\0';
-				if (domain_id)
-					*domain_id = strtoull(dom_id, NULL, 16);
+				*domain_id = strtoull(dom_id, NULL, 16);
 			}
 		}
 	}
diff --git a/tools/testing/selftests/landlock/common.h b/tools/testing/selftests/landlock/common.h
index ae6a0eb8e343..f0e8d3a498b3 100644
--- a/tools/testing/selftests/landlock/common.h
+++ b/tools/testing/selftests/landlock/common.h
@@ -34,7 +34,7 @@ static const char bin_wait_pipe_sandbox[] = "./wait-pipe-sandbox";
 static void _init_caps(struct __test_metadata *const _metadata, bool drop_all)
 {
 	cap_t cap_p;
-	/* Only these three capabilities are useful for the tests. */
+	/* Only these capabilities are useful for the tests. */
 	const cap_value_t caps[] = {
 		/* clang-format off */
 		CAP_AUDIT_CONTROL,
-- 
2.56.0

[PATCH 24/27] selftests/landlock: Use ASSERT for syscall failures before errno checks

[Günther Noack]

In cases where a syscall is expected to fail, but unexpectedly
succeeds, the resulting errno is undefined and we should not proceed
to check the errno.  Replace EXPECT* with ASSERT* macros for syscall
invocations where this is the case, so that we abort the tests early
in such cases.

In the errata test, check errno with EXPECT after the combined VERSION
and ERRATA flags, since nothing depends on it.

Assisted-by: LLM
Signed-off-by: Günther Noack <gnoack3000@gmail.com>
---
 tools/testing/selftests/landlock/audit_test.c |  8 +--
 tools/testing/selftests/landlock/base_test.c  | 40 +++++++--------
 tools/testing/selftests/landlock/fs_test.c    | 50 +++++++++----------
 tools/testing/selftests/landlock/net_test.c   | 24 ++++-----
 .../testing/selftests/landlock/ptrace_test.c  | 14 +++---
 .../landlock/scoped_abstract_unix_test.c      | 14 +++---
 6 files changed, 75 insertions(+), 75 deletions(-)

diff --git a/tools/testing/selftests/landlock/audit_test.c b/tools/testing/selftests/landlock/audit_test.c
index b38d0c5d5869..392e75ddfa3c 100644
--- a/tools/testing/selftests/landlock/audit_test.c
+++ b/tools/testing/selftests/landlock/audit_test.c
@@ -100,7 +100,7 @@ TEST_F(audit, layers)
 			EXPECT_EQ(0, landlock_restrict_self(ruleset_fd, 0));
 
 			/* Creates a denial to get the domain ID. */
-			EXPECT_EQ(-1, kill(getppid(), 0));
+			ASSERT_EQ(-1, kill(getppid(), 0));
 			EXPECT_EQ(EPERM, errno);
 			EXPECT_EQ(0,
 				  matches_log_signal(_metadata, self->audit_fd,
@@ -119,7 +119,7 @@ TEST_F(audit, layers)
 		}
 
 		/* Checks that we reached the maximum number of layers. */
-		EXPECT_EQ(-1, landlock_restrict_self(ruleset_fd, 0));
+		ASSERT_EQ(-1, landlock_restrict_self(ruleset_fd, 0));
 		EXPECT_EQ(E2BIG, errno);
 
 		/* Updates filter rules to match the drop record. */
@@ -711,7 +711,7 @@ TEST_F(audit_flags, signal)
 		EXPECT_EQ(0, close(ruleset_fd));
 
 		/* First signal checks to test log entries. */
-		EXPECT_EQ(-1, kill(getppid(), 0));
+		ASSERT_EQ(-1, kill(getppid(), 0));
 		EXPECT_EQ(EPERM, errno);
 
 		if (!expect_audit) {
@@ -736,7 +736,7 @@ TEST_F(audit_flags, signal)
 		}
 
 		/* Second signal checks to test audit_count_records(). */
-		EXPECT_EQ(-1, kill(getppid(), 0));
+		ASSERT_EQ(-1, kill(getppid(), 0));
 		EXPECT_EQ(EPERM, errno);
 
 		/* Makes sure there is no superfluous logged records. */
diff --git a/tools/testing/selftests/landlock/base_test.c b/tools/testing/selftests/landlock/base_test.c
index 5f10300a60cd..c19aa20609d6 100644
--- a/tools/testing/selftests/landlock/base_test.c
+++ b/tools/testing/selftests/landlock/base_test.c
@@ -136,7 +136,7 @@ TEST(errata)
 			      NULL, 0,
 			      LANDLOCK_CREATE_RULESET_VERSION |
 				      LANDLOCK_CREATE_RULESET_ERRATA));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 
 	ASSERT_EQ(-1, landlock_create_ruleset(NULL, 0,
 					      LANDLOCK_CREATE_RULESET_ERRATA |
@@ -333,7 +333,7 @@ TEST(restrict_self_fd)
 	fd = open("/dev/null", O_RDONLY | O_CLOEXEC);
 	ASSERT_LE(0, fd);
 
-	EXPECT_EQ(-1, landlock_restrict_self(fd, 0));
+	ASSERT_EQ(-1, landlock_restrict_self(fd, 0));
 	EXPECT_EQ(EBADFD, errno);
 
 	EXPECT_EQ(0, close(fd));
@@ -350,12 +350,12 @@ TEST(restrict_self_fd_flags)
 	 * LANDLOCK_RESTRICT_SELF_LOG_SUBDOMAINS_OFF accepts -1 but not any file
 	 * descriptor.
 	 */
-	EXPECT_EQ(-1, landlock_restrict_self(
+	ASSERT_EQ(-1, landlock_restrict_self(
 			      fd, LANDLOCK_RESTRICT_SELF_LOG_SUBDOMAINS_OFF));
 	EXPECT_EQ(EBADFD, errno);
 
 	/* LANDLOCK_RESTRICT_SELF_NO_NEW_PRIVS requires a ruleset FD. */
-	EXPECT_EQ(-1, landlock_restrict_self(
+	ASSERT_EQ(-1, landlock_restrict_self(
 			      fd, LANDLOCK_RESTRICT_SELF_NO_NEW_PRIVS));
 	EXPECT_EQ(EBADFD, errno);
 
@@ -368,40 +368,40 @@ TEST(restrict_self_flags)
 
 	/* Tests invalid flag combinations. */
 
-	EXPECT_EQ(-1, landlock_restrict_self(-1, last_flag << 1));
+	ASSERT_EQ(-1, landlock_restrict_self(-1, last_flag << 1));
 	EXPECT_EQ(EINVAL, errno);
 
-	EXPECT_EQ(-1, landlock_restrict_self(-1, -1));
+	ASSERT_EQ(-1, landlock_restrict_self(-1, -1));
 	EXPECT_EQ(EINVAL, errno);
 
 	/* Tests valid flag combinations. */
 
-	EXPECT_EQ(-1, landlock_restrict_self(-1, 0));
+	ASSERT_EQ(-1, landlock_restrict_self(-1, 0));
 	EXPECT_EQ(EBADF, errno);
 
-	EXPECT_EQ(-1, landlock_restrict_self(
+	ASSERT_EQ(-1, landlock_restrict_self(
 			      -1, LANDLOCK_RESTRICT_SELF_LOG_SAME_EXEC_OFF));
 	EXPECT_EQ(EBADF, errno);
 
-	EXPECT_EQ(-1,
+	ASSERT_EQ(-1,
 		  landlock_restrict_self(
 			  -1,
 			  LANDLOCK_RESTRICT_SELF_LOG_SAME_EXEC_OFF |
 				  LANDLOCK_RESTRICT_SELF_LOG_SUBDOMAINS_OFF));
 	EXPECT_EQ(EBADF, errno);
 
-	EXPECT_EQ(-1,
+	ASSERT_EQ(-1,
 		  landlock_restrict_self(
 			  -1,
 			  LANDLOCK_RESTRICT_SELF_LOG_NEW_EXEC_ON |
 				  LANDLOCK_RESTRICT_SELF_LOG_SUBDOMAINS_OFF));
 	EXPECT_EQ(EBADF, errno);
 
-	EXPECT_EQ(-1, landlock_restrict_self(
+	ASSERT_EQ(-1, landlock_restrict_self(
 			      -1, LANDLOCK_RESTRICT_SELF_LOG_NEW_EXEC_ON));
 	EXPECT_EQ(EBADF, errno);
 
-	EXPECT_EQ(-1,
+	ASSERT_EQ(-1,
 		  landlock_restrict_self(
 			  -1, LANDLOCK_RESTRICT_SELF_LOG_SAME_EXEC_OFF |
 				      LANDLOCK_RESTRICT_SELF_LOG_NEW_EXEC_ON));
@@ -409,18 +409,18 @@ TEST(restrict_self_flags)
 
 	/* LANDLOCK_RESTRICT_SELF_NO_NEW_PRIVS requires a ruleset FD. */
 
-	EXPECT_EQ(-1, landlock_restrict_self(
+	ASSERT_EQ(-1, landlock_restrict_self(
 			      -1, LANDLOCK_RESTRICT_SELF_NO_NEW_PRIVS));
 	EXPECT_EQ(EBADF, errno);
 
-	EXPECT_EQ(-1, landlock_restrict_self(
+	ASSERT_EQ(-1, landlock_restrict_self(
 			      -1, LANDLOCK_RESTRICT_SELF_LOG_SUBDOMAINS_OFF |
 					  LANDLOCK_RESTRICT_SELF_NO_NEW_PRIVS));
 	EXPECT_EQ(EBADF, errno);
 
 	/* Tests with an invalid ruleset_fd. */
 
-	EXPECT_EQ(-1, landlock_restrict_self(
+	ASSERT_EQ(-1, landlock_restrict_self(
 			      -2, LANDLOCK_RESTRICT_SELF_LOG_SUBDOMAINS_OFF));
 	EXPECT_EQ(EBADF, errno);
 
@@ -446,7 +446,7 @@ TEST(restrict_self_no_new_privs)
 	ASSERT_EQ(0, prctl(PR_GET_NO_NEW_PRIVS, 0, 0, 0, 0));
 
 	/* Checks that a failed call does not set no_new_privs. */
-	EXPECT_EQ(-1, landlock_restrict_self(
+	ASSERT_EQ(-1, landlock_restrict_self(
 			      -1, LANDLOCK_RESTRICT_SELF_NO_NEW_PRIVS));
 	EXPECT_EQ(EBADF, errno);
 	EXPECT_EQ(0, prctl(PR_GET_NO_NEW_PRIVS, 0, 0, 0, 0));
@@ -577,7 +577,7 @@ TEST(cred_transfer)
 	EXPECT_EQ(0, close(ruleset_fd));
 
 	/* Checks ruleset enforcement. */
-	EXPECT_EQ(-1, open("/", O_RDONLY | O_DIRECTORY | O_CLOEXEC));
+	ASSERT_EQ(-1, open("/", O_RDONLY | O_DIRECTORY | O_CLOEXEC));
 	EXPECT_EQ(EACCES, errno);
 
 	/* Needed for KEYCTL_SESSION_TO_PARENT permission checks */
@@ -591,7 +591,7 @@ TEST(cred_transfer)
 	ASSERT_LE(0, child);
 	if (child == 0) {
 		/* Checks ruleset enforcement. */
-		EXPECT_EQ(-1, open("/", O_RDONLY | O_DIRECTORY | O_CLOEXEC));
+		ASSERT_EQ(-1, open("/", O_RDONLY | O_DIRECTORY | O_CLOEXEC));
 		EXPECT_EQ(EACCES, errno);
 
 		/*
@@ -610,7 +610,7 @@ TEST(cred_transfer)
 				     0, 0, 0));
 
 		/* Re-checks ruleset enforcement. */
-		EXPECT_EQ(-1, open("/", O_RDONLY | O_DIRECTORY | O_CLOEXEC));
+		ASSERT_EQ(-1, open("/", O_RDONLY | O_DIRECTORY | O_CLOEXEC));
 		EXPECT_EQ(EACCES, errno);
 
 		_exit(_metadata->exit_code);
@@ -622,7 +622,7 @@ TEST(cred_transfer)
 	EXPECT_EQ(EXIT_SUCCESS, WEXITSTATUS(status));
 
 	/* Re-checks ruleset enforcement. */
-	EXPECT_EQ(-1, open("/", O_RDONLY | O_DIRECTORY | O_CLOEXEC));
+	ASSERT_EQ(-1, open("/", O_RDONLY | O_DIRECTORY | O_CLOEXEC));
 	EXPECT_EQ(EACCES, errno);
 }
 
diff --git a/tools/testing/selftests/landlock/fs_test.c b/tools/testing/selftests/landlock/fs_test.c
index ba3b39ad5882..c73a438e088f 100644
--- a/tools/testing/selftests/landlock/fs_test.c
+++ b/tools/testing/selftests/landlock/fs_test.c
@@ -678,7 +678,7 @@ TEST_F_FORK(layout0, rule_with_unknown_access)
 
 	for (access = 1ULL << 63; access != ACCESS_LAST; access >>= 1) {
 		path_beneath.allowed_access = access;
-		EXPECT_EQ(-1, landlock_add_rule(ruleset_fd,
+		ASSERT_EQ(-1, landlock_add_rule(ruleset_fd,
 						LANDLOCK_RULE_PATH_BENEATH,
 						&path_beneath, 0));
 		EXPECT_EQ(EINVAL, errno);
@@ -712,7 +712,7 @@ TEST_F_FORK(layout1, rule_with_unhandled_access)
 		if (access == ruleset_attr.handled_access_fs) {
 			EXPECT_EQ(0, err);
 		} else {
-			EXPECT_EQ(-1, err);
+			ASSERT_EQ(-1, err);
 			EXPECT_EQ(EINVAL, errno);
 		}
 	}
@@ -2069,7 +2069,7 @@ TEST_F_FORK(layout1, umount_sandboxer)
 
 	/* Tests that the sandboxer is tied to its mount point. */
 	set_cap(_metadata, CAP_SYS_ADMIN);
-	EXPECT_EQ(-1, umount(dir_s3d2));
+	ASSERT_EQ(-1, umount(dir_s3d2));
 	EXPECT_EQ(EBUSY, errno);
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 
@@ -2264,7 +2264,7 @@ TEST_F_FORK(layout1, rename_whiteout_denied)
 	 * file1_s3d3 is in dir_s3d2 (tmpfs), so it supports RENAME_WHITEOUT.
 	 * Denied, because whiteout creation is guarded with MAKE_REG.
 	 */
-	EXPECT_EQ(-1, renameat2(AT_FDCWD, file1_s3d3, AT_FDCWD,
+	ASSERT_EQ(-1, renameat2(AT_FDCWD, file1_s3d3, AT_FDCWD,
 				TMP_DIR "/s3d1/s3d2/s3d3/f2", RENAME_WHITEOUT));
 	EXPECT_EQ(EACCES, errno);
 }
@@ -2354,7 +2354,7 @@ TEST_F_FORK(layout1, rename_whiteout_reparenting)
 	 * there, even though it is granted in the destination directory
 	 * dir_s3d3.
 	 */
-	EXPECT_EQ(-1, renameat2(AT_FDCWD, file1_s3d4, AT_FDCWD,
+	ASSERT_EQ(-1, renameat2(AT_FDCWD, file1_s3d4, AT_FDCWD,
 				TMP_DIR "/s3d1/s3d2/s3d3/f2", RENAME_WHITEOUT));
 	EXPECT_EQ(EACCES, errno);
 
@@ -2404,7 +2404,7 @@ TEST_F_FORK(layout1, rename_whiteout_exchange)
 	 * dir_s3d4, even though it is granted in the whiteout object's own
 	 * directory dir_s3d3.
 	 */
-	EXPECT_EQ(-1, renameat2(AT_FDCWD, file1_s3d4, AT_FDCWD, whiteout_s3d3,
+	ASSERT_EQ(-1, renameat2(AT_FDCWD, file1_s3d4, AT_FDCWD, whiteout_s3d3,
 				RENAME_EXCHANGE));
 	EXPECT_EQ(EACCES, errno);
 
@@ -2637,11 +2637,11 @@ TEST_F_FORK(layout1, refer_mount_root_deny)
 	enforce_fs(_metadata, LANDLOCK_ACCESS_FS_MAKE_DIR, NULL);
 
 	/* Link denied by Landlock: EACCES. */
-	EXPECT_EQ(-1, linkat(root_fd, ".", root_fd, "does_not_exist", 0));
+	ASSERT_EQ(-1, linkat(root_fd, ".", root_fd, "does_not_exist", 0));
 	EXPECT_EQ(EACCES, errno);
 
 	/* renameat2() always returns EBUSY. */
-	EXPECT_EQ(-1, renameat2(root_fd, ".", root_fd, "does_not_exist", 0));
+	ASSERT_EQ(-1, renameat2(root_fd, ".", root_fd, "does_not_exist", 0));
 	EXPECT_EQ(EBUSY, errno);
 
 	EXPECT_EQ(0, close(root_fd));
@@ -5398,14 +5398,14 @@ TEST_F_FORK(layout1_bind, path_disconnected_rename)
 		 * Tests that access widening checks indeed prevents us from renaming it
 		 * back.
 		 */
-		EXPECT_EQ(-1, rename(dir_s4d2, dir_s1d3));
+		ASSERT_EQ(-1, rename(dir_s4d2, dir_s1d3));
 		EXPECT_EQ(EXDEV, errno);
 
 		/*
 		 * Including through the now disconnected fd (but it should return
 		 * EXDEV).
 		 */
-		EXPECT_EQ(-1, renameat(bind_s1d3_fd, file1_name, AT_FDCWD,
+		ASSERT_EQ(-1, renameat(bind_s1d3_fd, file1_name, AT_FDCWD,
 				       file1_s2d2));
 		EXPECT_EQ(EXDEV, errno);
 		_exit(_metadata->exit_code);
@@ -7630,12 +7630,12 @@ TEST_F(audit_layout1, remove_dir)
 
 	enforce_fs(_metadata, ACCESS_ALL, NULL);
 
-	EXPECT_EQ(-1, rmdir(dir_s1d3));
+	ASSERT_EQ(-1, rmdir(dir_s1d3));
 	EXPECT_EQ(EACCES, errno);
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
 				    "fs\\.remove_dir", dir_s1d2));
 
-	EXPECT_EQ(-1, unlinkat(AT_FDCWD, dir_s1d3, AT_REMOVEDIR));
+	ASSERT_EQ(-1, unlinkat(AT_FDCWD, dir_s1d3, AT_REMOVEDIR));
 	EXPECT_EQ(EACCES, errno);
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
 				    "fs\\.remove_dir", dir_s1d2));
@@ -7651,7 +7651,7 @@ TEST_F(audit_layout1, remove_file)
 
 	enforce_fs(_metadata, ACCESS_ALL, NULL);
 
-	EXPECT_EQ(-1, unlink(file1_s1d3));
+	ASSERT_EQ(-1, unlink(file1_s1d3));
 	EXPECT_EQ(EACCES, errno);
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
 				    "fs\\.remove_file", dir_s1d3));
@@ -7669,7 +7669,7 @@ TEST_F(audit_layout1, make_char)
 
 	enforce_fs(_metadata, ACCESS_ALL, NULL);
 
-	EXPECT_EQ(-1, mknod(file1_s1d3, S_IFCHR | 0644, makedev(7, 0)));
+	ASSERT_EQ(-1, mknod(file1_s1d3, S_IFCHR | 0644, makedev(7, 0)));
 	EXPECT_EQ(EACCES, errno);
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd, "fs\\.make_char",
 				    dir_s1d3));
@@ -7688,7 +7688,7 @@ TEST_F(audit_layout1, make_whiteout)
 	enforce_fs(_metadata, ACCESS_ALL, NULL);
 
 	/* Whiteout creation is denied and logged as fs.make_reg. */
-	EXPECT_EQ(-1, mknod(file1_s1d3, S_IFCHR | 0644, makedev(0, 0)));
+	ASSERT_EQ(-1, mknod(file1_s1d3, S_IFCHR | 0644, makedev(0, 0)));
 	EXPECT_EQ(EACCES, errno);
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd, "fs\\.make_reg",
 				    dir_s1d3));
@@ -7706,7 +7706,7 @@ TEST_F(audit_layout1, make_dir)
 
 	enforce_fs(_metadata, ACCESS_ALL, NULL);
 
-	EXPECT_EQ(-1, mkdir(file1_s1d3, 0755));
+	ASSERT_EQ(-1, mkdir(file1_s1d3, 0755));
 	EXPECT_EQ(EACCES, errno);
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd, "fs\\.make_dir",
 				    dir_s1d3));
@@ -7724,7 +7724,7 @@ TEST_F(audit_layout1, make_reg)
 
 	enforce_fs(_metadata, ACCESS_ALL, NULL);
 
-	EXPECT_EQ(-1, mknod(file1_s1d3, S_IFREG | 0644, 0));
+	ASSERT_EQ(-1, mknod(file1_s1d3, S_IFREG | 0644, 0));
 	EXPECT_EQ(EACCES, errno);
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd, "fs\\.make_reg",
 				    dir_s1d3));
@@ -7742,7 +7742,7 @@ TEST_F(audit_layout1, make_sock)
 
 	enforce_fs(_metadata, ACCESS_ALL, NULL);
 
-	EXPECT_EQ(-1, mknod(file1_s1d3, S_IFSOCK | 0644, 0));
+	ASSERT_EQ(-1, mknod(file1_s1d3, S_IFSOCK | 0644, 0));
 	EXPECT_EQ(EACCES, errno);
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd, "fs\\.make_sock",
 				    dir_s1d3));
@@ -7760,7 +7760,7 @@ TEST_F(audit_layout1, make_fifo)
 
 	enforce_fs(_metadata, ACCESS_ALL, NULL);
 
-	EXPECT_EQ(-1, mknod(file1_s1d3, S_IFIFO | 0644, 0));
+	ASSERT_EQ(-1, mknod(file1_s1d3, S_IFIFO | 0644, 0));
 	EXPECT_EQ(EACCES, errno);
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd, "fs\\.make_fifo",
 				    dir_s1d3));
@@ -7778,7 +7778,7 @@ TEST_F(audit_layout1, make_block)
 
 	enforce_fs(_metadata, ACCESS_ALL, NULL);
 
-	EXPECT_EQ(-1, mknod(file1_s1d3, S_IFBLK | 0644, 0));
+	ASSERT_EQ(-1, mknod(file1_s1d3, S_IFBLK | 0644, 0));
 	EXPECT_EQ(EACCES, errno);
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
 				    "fs\\.make_block", dir_s1d3));
@@ -7796,7 +7796,7 @@ TEST_F(audit_layout1, make_sym)
 
 	enforce_fs(_metadata, ACCESS_ALL, NULL);
 
-	EXPECT_EQ(-1, symlink("target", file1_s1d3));
+	ASSERT_EQ(-1, symlink("target", file1_s1d3));
 	EXPECT_EQ(EACCES, errno);
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd, "fs\\.make_sym",
 				    dir_s1d3));
@@ -7814,7 +7814,7 @@ TEST_F(audit_layout1, refer_handled)
 
 	enforce_fs(_metadata, LANDLOCK_ACCESS_FS_REFER, NULL);
 
-	EXPECT_EQ(-1, link(file1_s1d1, file1_s1d3));
+	ASSERT_EQ(-1, link(file1_s1d1, file1_s1d3));
 	EXPECT_EQ(EXDEV, errno);
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd, "fs\\.refer",
 				    dir_s1d1));
@@ -7838,7 +7838,7 @@ TEST_F(audit_layout1, refer_make)
 		   LANDLOCK_ACCESS_FS_MAKE_REG | LANDLOCK_ACCESS_FS_REFER,
 		   NULL);
 
-	EXPECT_EQ(-1, link(file1_s1d1, file1_s1d3));
+	ASSERT_EQ(-1, link(file1_s1d1, file1_s1d3));
 	EXPECT_EQ(EACCES, errno);
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd, "fs\\.refer",
 				    dir_s1d1));
@@ -7935,7 +7935,7 @@ TEST_F(audit_layout1, truncate)
 
 	enforce_fs(_metadata, ACCESS_ALL, NULL);
 
-	EXPECT_EQ(-1, truncate(file1_s1d3, 0));
+	ASSERT_EQ(-1, truncate(file1_s1d3, 0));
 	EXPECT_EQ(EACCES, errno);
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd, "fs\\.truncate",
 				    file1_s1d3));
@@ -8008,7 +8008,7 @@ TEST_F(audit_layout1, mount)
 	enforce_fs(_metadata, LANDLOCK_ACCESS_FS_EXECUTE, NULL);
 
 	set_cap(_metadata, CAP_SYS_ADMIN);
-	EXPECT_EQ(-1, mount(NULL, dir_s3d2, NULL, MS_RDONLY, NULL));
+	ASSERT_EQ(-1, mount(NULL, dir_s3d2, NULL, MS_RDONLY, NULL));
 	EXPECT_EQ(EPERM, errno);
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
diff --git a/tools/testing/selftests/landlock/net_test.c b/tools/testing/selftests/landlock/net_test.c
index 563e2214390b..51bcb4740dde 100644
--- a/tools/testing/selftests/landlock/net_test.c
+++ b/tools/testing/selftests/landlock/net_test.c
@@ -1361,11 +1361,11 @@ TEST_F(protocol, tcp_fastopen)
 	}
 
 	if (restricted) {
-		EXPECT_EQ(-1, read(client_fd, &buf, 1));
+		ASSERT_EQ(-1, read(client_fd, &buf, 1));
 		EXPECT_EQ(ENOTCONN, errno);
 	} else if (self->srv0.protocol.domain == AF_UNIX &&
 		   self->srv0.protocol.type == SOCK_STREAM) {
-		EXPECT_EQ(-1, read(client_fd, &buf, 1));
+		ASSERT_EQ(-1, read(client_fd, &buf, 1));
 		EXPECT_EQ(EINVAL, errno);
 	} else {
 		EXPECT_EQ(1, read(client_fd, &buf, 1));
@@ -2261,7 +2261,7 @@ TEST_F(mini, ruleset_with_unknown_access)
 			.handled_access_net = access_mask,
 		};
 
-		EXPECT_EQ(-1, landlock_create_ruleset(&ruleset_attr,
+		ASSERT_EQ(-1, landlock_create_ruleset(&ruleset_attr,
 						      sizeof(ruleset_attr), 0));
 		EXPECT_EQ(EINVAL, errno);
 	}
@@ -2284,7 +2284,7 @@ TEST_F(mini, rule_with_unknown_access)
 
 	for (access = 1ULL << 63; access != ACCESS_LAST; access >>= 1) {
 		net_port.allowed_access = access;
-		EXPECT_EQ(-1,
+		ASSERT_EQ(-1,
 			  landlock_add_rule(ruleset_fd, LANDLOCK_RULE_NET_PORT,
 					    &net_port, 0));
 		EXPECT_EQ(EINVAL, errno);
@@ -2316,7 +2316,7 @@ TEST_F(mini, rule_with_unhandled_access)
 		if (access == ruleset_attr.handled_access_net) {
 			EXPECT_EQ(0, err);
 		} else {
-			EXPECT_EQ(-1, err);
+			ASSERT_EQ(-1, err);
 			EXPECT_EQ(EINVAL, errno);
 		}
 	}
@@ -2349,12 +2349,12 @@ TEST_F(mini, inval)
 	ASSERT_LE(0, ruleset_fd);
 
 	/* Checks unhandled allowed_access. */
-	EXPECT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_NET_PORT,
+	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_NET_PORT,
 					&tcp_bind_connect, 0));
 	EXPECT_EQ(EINVAL, errno);
 
 	/* Checks zero access value. */
-	EXPECT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_NET_PORT,
+	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_NET_PORT,
 					&tcp_denied, 0));
 	EXPECT_EQ(ENOMSG, errno);
 
@@ -2414,15 +2414,15 @@ TEST_F(mini, tcp_port_overflow)
 	ASSERT_EQ(0, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_NET_PORT,
 				       &port_max_bind, 0));
 
-	EXPECT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_NET_PORT,
+	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_NET_PORT,
 					&port_overflow1, 0));
 	EXPECT_EQ(EINVAL, errno);
 
-	EXPECT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_NET_PORT,
+	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_NET_PORT,
 					&port_overflow2, 0));
 	EXPECT_EQ(EINVAL, errno);
 
-	EXPECT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_NET_PORT,
+	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_NET_PORT,
 					&port_overflow3, 0));
 	EXPECT_EQ(EINVAL, errno);
 
@@ -2430,7 +2430,7 @@ TEST_F(mini, tcp_port_overflow)
 	ASSERT_EQ(0, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_NET_PORT,
 				       &port_max_connect, 0));
 
-	EXPECT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_NET_PORT,
+	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_NET_PORT,
 					&port_overflow4, 0));
 	EXPECT_EQ(EINVAL, errno);
 
@@ -2549,7 +2549,7 @@ TEST_F(ipv4_tcp, with_fs)
 	EXPECT_EQ(0, close(dir_fd));
 
 	dir_fd = open("/", O_RDONLY);
-	EXPECT_EQ(-1, dir_fd);
+	ASSERT_EQ(-1, dir_fd);
 	EXPECT_EQ(EACCES, errno);
 
 	/* Tests port binding. */
diff --git a/tools/testing/selftests/landlock/ptrace_test.c b/tools/testing/selftests/landlock/ptrace_test.c
index 4fd2b440aa45..ea8e4be6659e 100644
--- a/tools/testing/selftests/landlock/ptrace_test.c
+++ b/tools/testing/selftests/landlock/ptrace_test.c
@@ -204,7 +204,7 @@ TEST_F(scoped_domains, trace)
 		if (can_trace_parent) {
 			EXPECT_EQ(0, ret);
 		} else {
-			EXPECT_EQ(-1, ret);
+			ASSERT_EQ(-1, ret);
 			EXPECT_EQ(EPERM, errno);
 		}
 		if (ret == 0) {
@@ -218,7 +218,7 @@ TEST_F(scoped_domains, trace)
 		if (can_trace_child) {
 			EXPECT_EQ(0, ret);
 		} else {
-			EXPECT_EQ(-1, ret);
+			ASSERT_EQ(-1, ret);
 			EXPECT_EQ(EPERM, errno);
 		}
 
@@ -259,7 +259,7 @@ TEST_F(scoped_domains, trace)
 		ASSERT_EQ(0, ptrace(PTRACE_DETACH, child, NULL, 0));
 	} else {
 		/* The child should not be traced by the parent. */
-		EXPECT_EQ(-1, ptrace(PTRACE_DETACH, child, NULL, 0));
+		ASSERT_EQ(-1, ptrace(PTRACE_DETACH, child, NULL, 0));
 		EXPECT_EQ(ESRCH, errno);
 	}
 
@@ -276,7 +276,7 @@ TEST_F(scoped_domains, trace)
 	if (can_trace_child) {
 		EXPECT_EQ(0, ret);
 	} else {
-		EXPECT_EQ(-1, ret);
+		ASSERT_EQ(-1, ret);
 		EXPECT_EQ(EPERM, errno);
 	}
 
@@ -377,7 +377,7 @@ TEST_F(audit, trace)
 		ASSERT_EQ(1, read(pipe_parent[0], &buf_child, 1));
 
 		/* Tests child PTRACE_TRACEME. */
-		EXPECT_EQ(-1, ptrace(PTRACE_TRACEME));
+		ASSERT_EQ(-1, ptrace(PTRACE_TRACEME));
 		EXPECT_EQ(EPERM, errno);
 		/* We should see the child process. */
 		EXPECT_EQ(0, matches_log_ptrace(_metadata, self->audit_fd,
@@ -414,11 +414,11 @@ TEST_F(audit, trace)
 	ASSERT_EQ(1, read(pipe_child[0], &buf_parent, 1));
 
 	/* The child should not be traced by the parent. */
-	EXPECT_EQ(-1, ptrace(PTRACE_DETACH, child, NULL, 0));
+	ASSERT_EQ(-1, ptrace(PTRACE_DETACH, child, NULL, 0));
 	EXPECT_EQ(ESRCH, errno);
 
 	/* Tests PTRACE_ATTACH on the child. */
-	EXPECT_EQ(-1, ptrace(PTRACE_ATTACH, child, NULL, 0));
+	ASSERT_EQ(-1, ptrace(PTRACE_ATTACH, child, NULL, 0));
 	EXPECT_EQ(EPERM, errno);
 	EXPECT_EQ(0, matches_log_ptrace(_metadata, self->audit_fd, child));
 
diff --git a/tools/testing/selftests/landlock/scoped_abstract_unix_test.c b/tools/testing/selftests/landlock/scoped_abstract_unix_test.c
index df41da5f2ab0..4c7f9c102d50 100644
--- a/tools/testing/selftests/landlock/scoped_abstract_unix_test.c
+++ b/tools/testing/selftests/landlock/scoped_abstract_unix_test.c
@@ -122,7 +122,7 @@ TEST_F(scoped_domains, connect_to_parent)
 		if (can_connect_to_parent) {
 			EXPECT_EQ(0, err);
 		} else {
-			EXPECT_EQ(-1, err);
+			ASSERT_EQ(-1, err);
 			EXPECT_EQ(EPERM, errno);
 		}
 		EXPECT_EQ(0, close(stream_client));
@@ -132,7 +132,7 @@ TEST_F(scoped_domains, connect_to_parent)
 		if (can_connect_to_parent) {
 			EXPECT_EQ(0, err);
 		} else {
-			EXPECT_EQ(-1, err);
+			ASSERT_EQ(-1, err);
 			EXPECT_EQ(EPERM, errno);
 		}
 		EXPECT_EQ(0, close(dgram_client));
@@ -417,7 +417,7 @@ TEST_F(scoped_audit, connect_to_child)
 	ASSERT_EQ(1, read(pipe_child[0], &buf, 1));
 	err_dgram = connect(dgram_client, &self->dgram_address.unix_addr,
 			    self->dgram_address.unix_addr_len);
-	EXPECT_EQ(-1, err_dgram);
+	ASSERT_EQ(-1, err_dgram);
 	EXPECT_EQ(EPERM, errno);
 
 	if (should_audit) {
@@ -762,7 +762,7 @@ TEST_F(outside_socket, socket_with_different_domain)
 		if (variant->child_socket) {
 			EXPECT_EQ(0, err);
 		} else {
-			EXPECT_EQ(-1, err);
+			ASSERT_EQ(-1, err);
 			EXPECT_EQ(EPERM, errno);
 		}
 		EXPECT_EQ(0, close(client_socket));
@@ -939,7 +939,7 @@ TEST_F(various_address_sockets, scoped_pathname_sockets)
 			      &stream_abstract_addr.unix_addr,
 			      stream_abstract_addr.unix_addr_len);
 		if (variant->domain == SCOPE_SANDBOX) {
-			EXPECT_EQ(-1, err);
+			ASSERT_EQ(-1, err);
 			EXPECT_EQ(EPERM, errno);
 		} else {
 			EXPECT_EQ(0, err);
@@ -954,7 +954,7 @@ TEST_F(various_address_sockets, scoped_pathname_sockets)
 			     &dgram_abstract_addr.unix_addr,
 			     dgram_abstract_addr.unix_addr_len);
 		if (variant->domain == SCOPE_SANDBOX) {
-			EXPECT_EQ(-1, err);
+			ASSERT_EQ(-1, err);
 			EXPECT_EQ(EPERM, errno);
 		} else {
 			EXPECT_EQ(1, err);
@@ -965,7 +965,7 @@ TEST_F(various_address_sockets, scoped_pathname_sockets)
 			      &dgram_abstract_addr.unix_addr,
 			      dgram_abstract_addr.unix_addr_len);
 		if (variant->domain == SCOPE_SANDBOX) {
-			EXPECT_EQ(-1, err);
+			ASSERT_EQ(-1, err);
 			EXPECT_EQ(EPERM, errno);
 		} else {
 			EXPECT_EQ(0, err);
-- 
2.56.0

[PATCH 25/27] selftests/landlock: Assert WIFEXITED() before checking the exit status

[Günther Noack]

WEXITSTATUS() is only meaningful if WIFEXITED() was true (see
wait(2)).  Check WIFEXITED() with ASSERT, as most tests already do, so
that a signaled child does not also produce a misleading exit status
failure.

Assisted-by: LLM
Signed-off-by: Günther Noack <gnoack3000@gmail.com>
---
 tools/testing/selftests/landlock/base_test.c |  2 +-
 tools/testing/selftests/landlock/fs_test.c   | 10 +++++-----
 tools/testing/selftests/landlock/net_test.c  | 14 +++++++-------
 3 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/tools/testing/selftests/landlock/base_test.c b/tools/testing/selftests/landlock/base_test.c
index c19aa20609d6..f7c063fdc397 100644
--- a/tools/testing/selftests/landlock/base_test.c
+++ b/tools/testing/selftests/landlock/base_test.c
@@ -618,7 +618,7 @@ TEST(cred_transfer)
 	}
 
 	EXPECT_EQ(child, waitpid(child, &status, 0));
-	EXPECT_EQ(1, WIFEXITED(status));
+	ASSERT_EQ(1, WIFEXITED(status));
 	EXPECT_EQ(EXIT_SUCCESS, WEXITSTATUS(status));
 
 	/* Re-checks ruleset enforcement. */
diff --git a/tools/testing/selftests/landlock/fs_test.c b/tools/testing/selftests/landlock/fs_test.c
index c73a438e088f..7e36baffdf36 100644
--- a/tools/testing/selftests/landlock/fs_test.c
+++ b/tools/testing/selftests/landlock/fs_test.c
@@ -4644,7 +4644,7 @@ static void test_connect_to_parent(struct __test_metadata *const _metadata,
 
 	/* Wait for child. */
 	ASSERT_EQ(child_pid, waitpid(child_pid, &status, 0));
-	EXPECT_EQ(1, WIFEXITED(status));
+	ASSERT_EQ(1, WIFEXITED(status));
 	EXPECT_EQ(EXIT_SUCCESS, WEXITSTATUS(status));
 
 	/* Clean up. */
@@ -4743,7 +4743,7 @@ static void test_connect_to_child(struct __test_metadata *const _metadata,
 
 	/* Wait for child. */
 	ASSERT_EQ(child_pid, waitpid(child_pid, &status, 0));
-	EXPECT_EQ(1, WIFEXITED(status));
+	ASSERT_EQ(1, WIFEXITED(status));
 	EXPECT_EQ(EXIT_SUCCESS, WEXITSTATUS(status));
 }
 
@@ -5413,7 +5413,7 @@ TEST_F_FORK(layout1_bind, path_disconnected_rename)
 	}
 
 	EXPECT_EQ(child_pid, waitpid(child_pid, &status, 0));
-	EXPECT_EQ(1, WIFEXITED(status));
+	ASSERT_EQ(1, WIFEXITED(status));
 	EXPECT_EQ(EXIT_SUCCESS, WEXITSTATUS(status));
 
 	ASSERT_EQ(0, rename(dir_s4d2, dir_s1d3))
@@ -5435,7 +5435,7 @@ TEST_F_FORK(layout1_bind, path_disconnected_rename)
 	}
 
 	EXPECT_EQ(child_pid, waitpid(child_pid, &status, 0));
-	EXPECT_EQ(1, WIFEXITED(status));
+	ASSERT_EQ(1, WIFEXITED(status));
 	EXPECT_EQ(EXIT_SUCCESS, WEXITSTATUS(status));
 
 	/*
@@ -7988,7 +7988,7 @@ TEST_F(audit_layout1, resolve_unix)
 	}
 
 	ASSERT_EQ(child_pid, waitpid(child_pid, &status, 0));
-	EXPECT_EQ(1, WIFEXITED(status));
+	ASSERT_EQ(1, WIFEXITED(status));
 	EXPECT_EQ(EXIT_SUCCESS, WEXITSTATUS(status));
 
 	EXPECT_EQ(0, matches_log_fs_extra(_metadata, self->audit_fd,
diff --git a/tools/testing/selftests/landlock/net_test.c b/tools/testing/selftests/landlock/net_test.c
index 51bcb4740dde..e194fd78d8a1 100644
--- a/tools/testing/selftests/landlock/net_test.c
+++ b/tools/testing/selftests/landlock/net_test.c
@@ -903,7 +903,7 @@ static void test_bind_and_connect(struct __test_metadata *const _metadata,
 	}
 
 	EXPECT_EQ(child, waitpid(child, &status, 0));
-	EXPECT_EQ(1, WIFEXITED(status));
+	ASSERT_EQ(1, WIFEXITED(status));
 	EXPECT_EQ(EXIT_SUCCESS, WEXITSTATUS(status));
 
 	/* Closes connection, if any. */
@@ -1274,7 +1274,7 @@ TEST_F(protocol, connect_unspec)
 	}
 
 	EXPECT_EQ(child, waitpid(child, &status, 0));
-	EXPECT_EQ(1, WIFEXITED(status));
+	ASSERT_EQ(1, WIFEXITED(status));
 	EXPECT_EQ(EXIT_SUCCESS, WEXITSTATUS(status));
 
 	/* Closes connection, if any. */
@@ -1373,7 +1373,7 @@ TEST_F(protocol, tcp_fastopen)
 	}
 
 	EXPECT_EQ(child, waitpid(child, &status, 0));
-	EXPECT_EQ(1, WIFEXITED(status));
+	ASSERT_EQ(1, WIFEXITED(status));
 	EXPECT_EQ(EXIT_SUCCESS, WEXITSTATUS(status));
 
 	if (client_fd != bind_fd)
@@ -1528,7 +1528,7 @@ TEST_F(protocol, sendmsg_dgram)
 		_exit(_metadata->exit_code);
 	}
 	EXPECT_EQ(child, waitpid(child, &status, 0));
-	EXPECT_EQ(1, WIFEXITED(status));
+	ASSERT_EQ(1, WIFEXITED(status));
 	EXPECT_EQ(EXIT_SUCCESS, WEXITSTATUS(status));
 
 	/*
@@ -1571,7 +1571,7 @@ TEST_F(protocol, sendmsg_dgram)
 		return;
 	}
 	EXPECT_EQ(child, waitpid(child, &status, 0));
-	EXPECT_EQ(1, WIFEXITED(status));
+	ASSERT_EQ(1, WIFEXITED(status));
 	EXPECT_EQ(EXIT_SUCCESS, WEXITSTATUS(status));
 
 	/*
@@ -1642,7 +1642,7 @@ TEST_F(protocol, sendmsg_dgram)
 		return;
 	}
 	EXPECT_EQ(child, waitpid(child, &status, 0));
-	EXPECT_EQ(1, WIFEXITED(status));
+	ASSERT_EQ(1, WIFEXITED(status));
 	EXPECT_EQ(EXIT_SUCCESS, WEXITSTATUS(status));
 
 	/*
@@ -1677,7 +1677,7 @@ TEST_F(protocol, sendmsg_dgram)
 		_exit(_metadata->exit_code);
 	}
 	EXPECT_EQ(child, waitpid(child, &status, 0));
-	EXPECT_EQ(1, WIFEXITED(status));
+	ASSERT_EQ(1, WIFEXITED(status));
 	EXPECT_EQ(EXIT_SUCCESS, WEXITSTATUS(status));
 }
 
-- 
2.56.0

[PATCH 26/27] selftests/landlock: Use EXPECT for closing FDs and stopping threads

[Günther Noack]

Closing FDs and cancelling or joining threads whose results are not
used is teardown, whether it happens at the end of a test or in the
middle of it.  No later check depends on it, so a failure should be
reported without aborting the test.  Use EXPECT for these calls, as
most tests already do.  The same applies to removing the FIFO and
reaping the child at the end of named_pipe_ioctl.

The close(0) in ioctl_error() stays an ASSERT, as the following IOCTL
relies on FD 0 being closed.

Assisted-by: LLM
Signed-off-by: Günther Noack <gnoack3000@gmail.com>
---
 tools/testing/selftests/landlock/base_test.c  |  40 +++----
 tools/testing/selftests/landlock/fs_test.c    | 106 +++++++++---------
 .../testing/selftests/landlock/ptrace_test.c  |  16 +--
 .../selftests/landlock/trace_fs_test.c        |   8 +-
 tools/testing/selftests/landlock/trace_test.c |   6 +-
 tools/testing/selftests/landlock/tsync_test.c |  22 ++--
 6 files changed, 99 insertions(+), 99 deletions(-)

diff --git a/tools/testing/selftests/landlock/base_test.c b/tools/testing/selftests/landlock/base_test.c
index f7c063fdc397..862ff91f6418 100644
--- a/tools/testing/selftests/landlock/base_test.c
+++ b/tools/testing/selftests/landlock/base_test.c
@@ -184,7 +184,7 @@ TEST(create_ruleset_checks_ordering)
 	ruleset_fd =
 		landlock_create_ruleset(&ruleset_attr, sizeof(ruleset_attr), 0);
 	ASSERT_LE(0, ruleset_fd);
-	ASSERT_EQ(0, close(ruleset_fd));
+	EXPECT_EQ(0, close(ruleset_fd));
 }
 
 /* Tests ordering of syscall argument checks. */
@@ -230,8 +230,8 @@ TEST(add_rule_checks_ordering)
 	ASSERT_LE(0, path_beneath_attr.parent_fd);
 	ASSERT_EQ(0, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_PATH_BENEATH,
 				       &path_beneath_attr, 0));
-	ASSERT_EQ(0, close(path_beneath_attr.parent_fd));
-	ASSERT_EQ(0, close(ruleset_fd));
+	EXPECT_EQ(0, close(path_beneath_attr.parent_fd));
+	EXPECT_EQ(0, close(ruleset_fd));
 }
 
 /* Tests ordering of syscall argument and permission checks. */
@@ -253,7 +253,7 @@ TEST(restrict_self_checks_ordering)
 	ASSERT_LE(0, path_beneath_attr.parent_fd);
 	ASSERT_EQ(0, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_PATH_BENEATH,
 				       &path_beneath_attr, 0));
-	ASSERT_EQ(0, close(path_beneath_attr.parent_fd));
+	EXPECT_EQ(0, close(path_beneath_attr.parent_fd));
 
 	/* Checks unprivileged enforcement without no_new_privs. */
 	drop_caps(_metadata);
@@ -288,7 +288,7 @@ TEST(restrict_self_checks_ordering)
 
 	/* Checks valid call. */
 	ASSERT_EQ(0, landlock_restrict_self(ruleset_fd, 0));
-	ASSERT_EQ(0, close(ruleset_fd));
+	EXPECT_EQ(0, close(ruleset_fd));
 }
 
 TEST(restrict_self_max_layers)
@@ -309,7 +309,7 @@ TEST(restrict_self_max_layers)
 	ASSERT_LE(0, path_beneath_attr.parent_fd);
 	ASSERT_EQ(0, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_PATH_BENEATH,
 				       &path_beneath_attr, 0));
-	ASSERT_EQ(0, close(path_beneath_attr.parent_fd));
+	EXPECT_EQ(0, close(path_beneath_attr.parent_fd));
 
 	/* Enforces the maximum number of allowed layers. */
 	for (int i = 0; i < LANDLOCK_MAX_NUM_LAYERS; i++)
@@ -323,7 +323,7 @@ TEST(restrict_self_max_layers)
 
 	/* Checks that the failed call did not set no_new_privs. */
 	ASSERT_EQ(0, prctl(PR_GET_NO_NEW_PRIVS, 0, 0, 0, 0));
-	ASSERT_EQ(0, close(ruleset_fd));
+	EXPECT_EQ(0, close(ruleset_fd));
 }
 
 TEST(restrict_self_fd)
@@ -477,7 +477,7 @@ TEST(ruleset_fd_io)
 	ASSERT_EQ(-1, read(ruleset_fd, &buf, 1));
 	ASSERT_EQ(EINVAL, errno);
 
-	ASSERT_EQ(0, close(ruleset_fd));
+	EXPECT_EQ(0, close(ruleset_fd));
 }
 
 /* Tests enforcement of a ruleset FD transferred through a UNIX socket. */
@@ -506,14 +506,14 @@ TEST(ruleset_fd_transfer)
 	ASSERT_EQ(0,
 		  landlock_add_rule(ruleset_fd_tx, LANDLOCK_RULE_PATH_BENEATH,
 				    &path_beneath_attr, 0));
-	ASSERT_EQ(0, close(path_beneath_attr.parent_fd));
+	EXPECT_EQ(0, close(path_beneath_attr.parent_fd));
 
 	/* Sends the ruleset FD over a socketpair and then close it. */
 	ASSERT_EQ(0, socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0,
 				socket_fds));
 	ASSERT_EQ(0, send_fd(socket_fds[0], ruleset_fd_tx));
-	ASSERT_EQ(0, close(socket_fds[0]));
-	ASSERT_EQ(0, close(ruleset_fd_tx));
+	EXPECT_EQ(0, close(socket_fds[0]));
+	EXPECT_EQ(0, close(ruleset_fd_tx));
 
 	child = fork();
 	ASSERT_LE(0, child);
@@ -521,32 +521,32 @@ TEST(ruleset_fd_transfer)
 		const int ruleset_fd_rx = recv_fd(socket_fds[1]);
 
 		ASSERT_LE(0, ruleset_fd_rx);
-		ASSERT_EQ(0, close(socket_fds[1]));
+		EXPECT_EQ(0, close(socket_fds[1]));
 
 		/* Enforces the received ruleset on the child. */
 		ASSERT_EQ(0, prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0));
 		ASSERT_EQ(0, landlock_restrict_self(ruleset_fd_rx, 0));
-		ASSERT_EQ(0, close(ruleset_fd_rx));
+		EXPECT_EQ(0, close(ruleset_fd_rx));
 
 		/* Checks that the ruleset enforcement. */
 		ASSERT_EQ(-1, open("/", O_RDONLY | O_DIRECTORY | O_CLOEXEC));
 		ASSERT_EQ(EACCES, errno);
 		dir_fd = open("/tmp", O_RDONLY | O_DIRECTORY | O_CLOEXEC);
 		ASSERT_LE(0, dir_fd);
-		ASSERT_EQ(0, close(dir_fd));
+		EXPECT_EQ(0, close(dir_fd));
 		_exit(_metadata->exit_code);
 		return;
 	}
 
-	ASSERT_EQ(0, close(socket_fds[1]));
+	EXPECT_EQ(0, close(socket_fds[1]));
 
 	/* Checks that the parent is unrestricted. */
 	dir_fd = open("/", O_RDONLY | O_DIRECTORY | O_CLOEXEC);
 	ASSERT_LE(0, dir_fd);
-	ASSERT_EQ(0, close(dir_fd));
+	EXPECT_EQ(0, close(dir_fd));
 	dir_fd = open("/tmp", O_RDONLY | O_DIRECTORY | O_CLOEXEC);
 	ASSERT_LE(0, dir_fd);
-	ASSERT_EQ(0, close(dir_fd));
+	EXPECT_EQ(0, close(dir_fd));
 
 	ASSERT_EQ(child, waitpid(child, &status, 0));
 	ASSERT_EQ(1, WIFEXITED(status));
@@ -651,9 +651,9 @@ TEST(useless_quiet_rule_fs)
 	ASSERT_EQ(EINVAL, errno);
 
 	/* Check that the rule had not been added. */
-	ASSERT_EQ(0, close(root_fd));
+	EXPECT_EQ(0, close(root_fd));
 	enforce_ruleset(_metadata, ruleset_fd);
-	ASSERT_EQ(0, close(ruleset_fd));
+	EXPECT_EQ(0, close(ruleset_fd));
 
 	ASSERT_EQ(-1, open("/", O_RDONLY | O_DIRECTORY | O_CLOEXEC));
 	ASSERT_EQ(EACCES, errno);
@@ -681,7 +681,7 @@ TEST(useless_quiet_rule_net)
 				    &net_port_attr, LANDLOCK_ADD_RULE_QUIET));
 	ASSERT_EQ(EINVAL, errno);
 
-	ASSERT_EQ(0, close(ruleset_fd));
+	EXPECT_EQ(0, close(ruleset_fd));
 }
 
 TEST(invalid_quiet_bits_1)
diff --git a/tools/testing/selftests/landlock/fs_test.c b/tools/testing/selftests/landlock/fs_test.c
index 7e36baffdf36..76f319c972db 100644
--- a/tools/testing/selftests/landlock/fs_test.c
+++ b/tools/testing/selftests/landlock/fs_test.c
@@ -499,7 +499,7 @@ TEST_F_FORK(layout1, inval)
 					&path_beneath, 0));
 	/* Returns EBADF because ruleset_fd is not a landlock-ruleset FD. */
 	ASSERT_EQ(EBADF, errno);
-	ASSERT_EQ(0, close(ruleset_fd));
+	EXPECT_EQ(0, close(ruleset_fd));
 
 	ruleset_fd = open(dir_s1d1, O_DIRECTORY | O_CLOEXEC);
 	ASSERT_LE(0, ruleset_fd);
@@ -507,7 +507,7 @@ TEST_F_FORK(layout1, inval)
 					&path_beneath, 0));
 	/* Returns EBADFD because ruleset_fd is not a valid ruleset. */
 	ASSERT_EQ(EBADFD, errno);
-	ASSERT_EQ(0, close(ruleset_fd));
+	EXPECT_EQ(0, close(ruleset_fd));
 
 	/* Gets a real ruleset. */
 	ruleset_fd =
@@ -515,14 +515,14 @@ TEST_F_FORK(layout1, inval)
 	ASSERT_LE(0, ruleset_fd);
 	ASSERT_EQ(0, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_PATH_BENEATH,
 				       &path_beneath, 0));
-	ASSERT_EQ(0, close(path_beneath.parent_fd));
+	EXPECT_EQ(0, close(path_beneath.parent_fd));
 
 	/* Tests without O_PATH. */
 	path_beneath.parent_fd = open(dir_s1d2, O_DIRECTORY | O_CLOEXEC);
 	ASSERT_LE(0, path_beneath.parent_fd);
 	ASSERT_EQ(0, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_PATH_BENEATH,
 				       &path_beneath, 0));
-	ASSERT_EQ(0, close(path_beneath.parent_fd));
+	EXPECT_EQ(0, close(path_beneath.parent_fd));
 
 	/* Tests with a ruleset FD. */
 	path_beneath.parent_fd = ruleset_fd;
@@ -563,13 +563,13 @@ TEST_F_FORK(layout1, inval)
 	ASSERT_EQ(ENOMSG, errno);
 	path_beneath.allowed_access &= ~(1ULL << 60);
 
-	ASSERT_EQ(0, close(path_beneath.parent_fd));
+	EXPECT_EQ(0, close(path_beneath.parent_fd));
 
 	/* Enforces the ruleset. */
 	ASSERT_EQ(0, prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0));
 	ASSERT_EQ(0, landlock_restrict_self(ruleset_fd, 0));
 
-	ASSERT_EQ(0, close(ruleset_fd));
+	EXPECT_EQ(0, close(ruleset_fd));
 }
 
 /* clang-format off */
@@ -639,9 +639,9 @@ TEST_F_FORK(layout1, file_and_dir_access_rights)
 			ASSERT_EQ(EINVAL, errno);
 		}
 	}
-	ASSERT_EQ(0, close(path_beneath_file.parent_fd));
-	ASSERT_EQ(0, close(path_beneath_dir.parent_fd));
-	ASSERT_EQ(0, close(ruleset_fd));
+	EXPECT_EQ(0, close(path_beneath_file.parent_fd));
+	EXPECT_EQ(0, close(path_beneath_dir.parent_fd));
+	EXPECT_EQ(0, close(ruleset_fd));
 }
 
 TEST_F_FORK(layout0, ruleset_with_unknown_access)
@@ -683,8 +683,8 @@ TEST_F_FORK(layout0, rule_with_unknown_access)
 						&path_beneath, 0));
 		EXPECT_EQ(EINVAL, errno);
 	}
-	ASSERT_EQ(0, close(path_beneath.parent_fd));
-	ASSERT_EQ(0, close(ruleset_fd));
+	EXPECT_EQ(0, close(path_beneath.parent_fd));
+	EXPECT_EQ(0, close(ruleset_fd));
 }
 
 TEST_F_FORK(layout1, rule_with_unhandled_access)
@@ -741,7 +741,7 @@ static void add_path_beneath(struct __test_metadata *const _metadata,
 		TH_LOG("Failed to update the ruleset with \"%s\": %s", path,
 		       strerror(errno));
 	}
-	ASSERT_EQ(0, close(path_beneath.parent_fd));
+	EXPECT_EQ(0, close(path_beneath.parent_fd));
 }
 
 struct rule {
@@ -843,7 +843,7 @@ TEST_F_FORK(layout0, proc_nsfs)
 	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_PATH_BENEATH,
 					&path_beneath, 0));
 	ASSERT_EQ(EBADFD, errno);
-	ASSERT_EQ(0, close(path_beneath.parent_fd));
+	EXPECT_EQ(0, close(path_beneath.parent_fd));
 }
 
 TEST_F_FORK(layout0, unpriv)
@@ -866,7 +866,7 @@ TEST_F_FORK(layout0, unpriv)
 
 	/* enforce_ruleset() calls prctl(no_new_privs). */
 	enforce_ruleset(_metadata, ruleset_fd);
-	ASSERT_EQ(0, close(ruleset_fd));
+	EXPECT_EQ(0, close(ruleset_fd));
 }
 
 TEST_F_FORK(layout1, effective_access)
@@ -914,14 +914,14 @@ TEST_F_FORK(layout1, effective_access)
 	ASSERT_LE(0, lseek(reg_fd, 0, SEEK_SET));
 	ASSERT_EQ(1, read(reg_fd, &buf, 1));
 	ASSERT_EQ('.', buf);
-	ASSERT_EQ(0, close(reg_fd));
+	EXPECT_EQ(0, close(reg_fd));
 
 	/* Just in case, double-checks effective actions. */
 	reg_fd = open(file1_s2d2, O_RDONLY | O_CLOEXEC);
 	ASSERT_LE(0, reg_fd);
 	ASSERT_EQ(-1, write(reg_fd, &buf, 1));
 	ASSERT_EQ(EBADF, errno);
-	ASSERT_EQ(0, close(reg_fd));
+	EXPECT_EQ(0, close(reg_fd));
 }
 
 TEST_F_FORK(layout1, unhandled_access)
@@ -1370,7 +1370,7 @@ TEST_F_FORK(layout1, inherit_subset)
 	add_path_beneath(_metadata, ruleset_fd, LANDLOCK_ACCESS_FS_WRITE_FILE,
 			 dir_s1d3, 0);
 	enforce_ruleset(_metadata, ruleset_fd);
-	ASSERT_EQ(0, close(ruleset_fd));
+	EXPECT_EQ(0, close(ruleset_fd));
 
 	/*
 	 * Same tests and results as above, except for open(dir_s1d3) which is
@@ -1481,7 +1481,7 @@ TEST_F_FORK(layout1, empty_or_same_ruleset)
 
 	/* Enforces a second time with the same ruleset. */
 	enforce_ruleset(_metadata, ruleset_fd);
-	ASSERT_EQ(0, close(ruleset_fd));
+	EXPECT_EQ(0, close(ruleset_fd));
 }
 
 TEST_F_FORK(layout1, rule_on_mountpoint)
@@ -1770,7 +1770,7 @@ TEST_F_FORK(layout1, covered_rule)
 	ASSERT_EQ(0, test_open(dir_s3d2, O_RDONLY));
 
 	enforce_ruleset(_metadata, ruleset_fd);
-	ASSERT_EQ(0, close(ruleset_fd));
+	EXPECT_EQ(0, close(ruleset_fd));
 
 	/* Checks that access to the new mount point is denied. */
 	ASSERT_EQ(EACCES, test_open(dir_s3d2, O_RDONLY));
@@ -1893,8 +1893,8 @@ static void test_relative_path(struct __test_metadata *const _metadata,
 	}
 
 	if (rel == REL_OPEN)
-		ASSERT_EQ(0, close(dirfd));
-	ASSERT_EQ(0, close(ruleset_fd));
+		EXPECT_EQ(0, close(dirfd));
+	EXPECT_EQ(0, close(ruleset_fd));
 }
 
 TEST_F_FORK(layout1, relative_open)
@@ -1936,8 +1936,8 @@ static void copy_file(struct __test_metadata *const _metadata,
 	ASSERT_EQ(0, fstat(src_fd, &statbuf));
 	ASSERT_EQ(statbuf.st_size,
 		  sendfile(dst_fd, src_fd, 0, statbuf.st_size));
-	ASSERT_EQ(0, close(src_fd));
-	ASSERT_EQ(0, close(dst_fd));
+	EXPECT_EQ(0, close(src_fd));
+	EXPECT_EQ(0, close(dst_fd));
 }
 
 static void test_execute(struct __test_metadata *const _metadata, const int err,
@@ -3582,7 +3582,7 @@ TEST_F_FORK(layout1, proc_unlinked_file)
 
 	proc_fd = open_proc_fd(_metadata, reg_fd, O_RDONLY | O_CLOEXEC);
 	ASSERT_LE(0, proc_fd);
-	ASSERT_EQ(0, close(proc_fd));
+	EXPECT_EQ(0, close(proc_fd));
 
 	proc_fd = open_proc_fd(_metadata, reg_fd, O_RDWR | O_CLOEXEC);
 	ASSERT_EQ(-1, proc_fd)
@@ -3592,7 +3592,7 @@ TEST_F_FORK(layout1, proc_unlinked_file)
 	}
 	ASSERT_EQ(EACCES, errno);
 
-	ASSERT_EQ(0, close(reg_fd));
+	EXPECT_EQ(0, close(reg_fd));
 }
 
 TEST_F_FORK(layout1, proc_pipe)
@@ -3633,7 +3633,7 @@ TEST_F_FORK(layout1, proc_pipe)
 		TH_LOG("Failed to write through /proc/self/fd/%d: %s",
 		       pipe_fds[1], strerror(errno));
 	}
-	ASSERT_EQ(0, close(proc_fd));
+	EXPECT_EQ(0, close(proc_fd));
 
 	/* Checks read access to pipe through /proc/self/fd . */
 	proc_fd = open_proc_fd(_metadata, pipe_fds[0], O_RDONLY | O_CLOEXEC);
@@ -3644,10 +3644,10 @@ TEST_F_FORK(layout1, proc_pipe)
 		TH_LOG("Failed to read through /proc/self/fd/%d: %s",
 		       pipe_fds[1], strerror(errno));
 	}
-	ASSERT_EQ(0, close(proc_fd));
+	EXPECT_EQ(0, close(proc_fd));
 
-	ASSERT_EQ(0, close(pipe_fds[0]));
-	ASSERT_EQ(0, close(pipe_fds[1]));
+	EXPECT_EQ(0, close(pipe_fds[0]));
+	EXPECT_EQ(0, close(pipe_fds[1]));
 }
 
 /* Invokes truncate(2) and returns its errno or 0. */
@@ -3908,10 +3908,10 @@ TEST_F_FORK(layout1, ftruncate)
 	EXPECT_EQ(0, test_ftruncate(fd_layer2));
 	EXPECT_EQ(EACCES, test_ftruncate(fd_layer3));
 
-	ASSERT_EQ(0, close(fd_layer0));
-	ASSERT_EQ(0, close(fd_layer1));
-	ASSERT_EQ(0, close(fd_layer2));
-	ASSERT_EQ(0, close(fd_layer3));
+	EXPECT_EQ(0, close(fd_layer0));
+	EXPECT_EQ(0, close(fd_layer1));
+	EXPECT_EQ(0, close(fd_layer2));
+	EXPECT_EQ(0, close(fd_layer3));
 }
 
 /* clang-format off */
@@ -4002,7 +4002,7 @@ TEST_F_FORK(ftruncate, open_and_ftruncate)
 	if (fd >= 0) {
 		EXPECT_EQ(variant->expected_ftruncate_result,
 			  test_ftruncate(fd));
-		ASSERT_EQ(0, close(fd));
+		EXPECT_EQ(0, close(fd));
 	}
 }
 
@@ -4039,10 +4039,10 @@ TEST_F_FORK(ftruncate, open_and_ftruncate_in_different_processes)
 
 		if (fd >= 0) {
 			ASSERT_EQ(0, send_fd(socket_fds[0], fd));
-			ASSERT_EQ(0, close(fd));
+			EXPECT_EQ(0, close(fd));
 		}
 
-		ASSERT_EQ(0, close(socket_fds[0]));
+		EXPECT_EQ(0, close(socket_fds[0]));
 
 		_exit(_metadata->exit_code);
 		return;
@@ -4054,15 +4054,15 @@ TEST_F_FORK(ftruncate, open_and_ftruncate_in_different_processes)
 
 		EXPECT_EQ(variant->expected_ftruncate_result,
 			  test_ftruncate(fd));
-		ASSERT_EQ(0, close(fd));
+		EXPECT_EQ(0, close(fd));
 	}
 
 	ASSERT_EQ(child, waitpid(child, &status, 0));
 	ASSERT_EQ(1, WIFEXITED(status));
 	ASSERT_EQ(EXIT_SUCCESS, WEXITSTATUS(status));
 
-	ASSERT_EQ(0, close(socket_fds[0]));
-	ASSERT_EQ(0, close(socket_fds[1]));
+	EXPECT_EQ(0, close(socket_fds[0]));
+	EXPECT_EQ(0, close(socket_fds[1]));
 }
 
 /* Invokes the FS_IOC_GETFLAGS IOCTL and returns its errno or 0. */
@@ -4096,7 +4096,7 @@ TEST(memfd_ftruncate_and_ioctl)
 		EXPECT_EQ(0, test_ftruncate(fd));
 		EXPECT_EQ(0, test_fs_ioc_getflags_ioctl(fd));
 
-		ASSERT_EQ(0, close(fd));
+		EXPECT_EQ(0, close(fd));
 
 		/* Enables Landlock. */
 		enforce_fs(_metadata, ACCESS_ALL, NULL);
@@ -4127,7 +4127,7 @@ TEST_F_FORK(layout1, o_path_ftruncate_and_ioctl)
 	EXPECT_EQ(EBADF, test_ftruncate(fd));
 	EXPECT_EQ(EBADF, test_fs_ioc_getflags_ioctl(fd));
 
-	ASSERT_EQ(0, close(fd));
+	EXPECT_EQ(0, close(fd));
 
 	/* Enables Landlock. */
 	enforce_fs(_metadata, ACCESS_ALL, NULL);
@@ -4143,7 +4143,7 @@ TEST_F_FORK(layout1, o_path_ftruncate_and_ioctl)
 	EXPECT_EQ(EBADF, test_ftruncate(fd));
 	EXPECT_EQ(EBADF, test_fs_ioc_getflags_ioctl(fd));
 
-	ASSERT_EQ(0, close(fd));
+	EXPECT_EQ(0, close(fd));
 }
 
 /*
@@ -4175,7 +4175,7 @@ static int ioctl_error(struct __test_metadata *const _metadata, int fd,
 
 	/* Restores the old FD 0 and closes the backup FD. */
 	ASSERT_EQ(0, dup2(stdinbak_fd, 0));
-	ASSERT_EQ(0, close(stdinbak_fd));
+	EXPECT_EQ(0, close(stdinbak_fd));
 
 	if (res < 0)
 		return err;
@@ -4251,7 +4251,7 @@ TEST_F_FORK(layout1, blanket_permitted_ioctls)
 	/* Default case is also blocked. */
 	EXPECT_EQ(EACCES, ioctl_error(_metadata, fd, 0xc00ffeee));
 
-	ASSERT_EQ(0, close(fd));
+	EXPECT_EQ(0, close(fd));
 }
 
 /*
@@ -4285,10 +4285,10 @@ TEST_F_FORK(layout1, named_pipe_ioctl)
 	/* FIONREAD is implemented by pipefifo_fops. */
 	EXPECT_EQ(0, test_fionread_ioctl(fd));
 
-	ASSERT_EQ(0, close(fd));
-	ASSERT_EQ(0, unlink(path));
+	EXPECT_EQ(0, close(fd));
+	EXPECT_EQ(0, unlink(path));
 
-	ASSERT_EQ(child_pid, waitpid(child_pid, NULL, 0));
+	EXPECT_EQ(child_pid, waitpid(child_pid, NULL, 0));
 }
 
 /*
@@ -4441,7 +4441,7 @@ TEST_F_FORK(ioctl, handle_dir_access_file)
 	EXPECT_EQ(0, ioctl(fd, FIOASYNC, &flag));
 	EXPECT_EQ(0, ioctl(fd, FIGETBSZ, &flag));
 
-	ASSERT_EQ(0, close(fd));
+	EXPECT_EQ(0, close(fd));
 }
 
 TEST_F_FORK(ioctl, handle_dir_access_dir)
@@ -4483,7 +4483,7 @@ TEST_F_FORK(ioctl, handle_dir_access_dir)
 	EXPECT_EQ(0, ioctl(dir_fd, FIOASYNC, &flag));
 	EXPECT_EQ(0, ioctl(dir_fd, FIGETBSZ, &flag));
 
-	ASSERT_EQ(0, close(dir_fd));
+	EXPECT_EQ(0, close(dir_fd));
 }
 
 TEST_F_FORK(ioctl, handle_file_access_file)
@@ -4517,7 +4517,7 @@ TEST_F_FORK(ioctl, handle_file_access_file)
 	EXPECT_EQ(0, ioctl(fd, FIOASYNC, &flag));
 	EXPECT_EQ(0, ioctl(fd, FIGETBSZ, &flag));
 
-	ASSERT_EQ(0, close(fd));
+	EXPECT_EQ(0, close(fd));
 }
 
 /*
@@ -7435,7 +7435,7 @@ TEST_F_FORK(layout3_fs, release_inodes)
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 
 	enforce_ruleset(_metadata, ruleset_fd);
-	ASSERT_EQ(0, close(ruleset_fd));
+	EXPECT_EQ(0, close(ruleset_fd));
 
 	/* Checks that access to the new mount point is denied. */
 	ASSERT_EQ(EACCES, test_open(TMP_DIR, O_RDONLY));
@@ -8167,7 +8167,7 @@ static int apply_a_layer(struct __test_metadata *const _metadata,
 	{
 		TH_LOG("Failed to enforce ruleset: %s", strerror(errno));
 	}
-	ASSERT_EQ(0, close(rs_fd));
+	EXPECT_EQ(0, close(rs_fd));
 
 	if (debug_quiet_tests) {
 		sprint_access_bits(handled_access_s, sizeof(handled_access_s),
@@ -8302,7 +8302,7 @@ void audit_quiet_layout1_test_body(struct __test_metadata *const _metadata,
 			ASSERT_EQ(0, audit_count_records(self->audit_fd,
 							 &records));
 			ASSERT_EQ(0, records.access);
-			ASSERT_EQ(0, close(fd));
+			EXPECT_EQ(0, close(fd));
 		}
 	}
 }
diff --git a/tools/testing/selftests/landlock/ptrace_test.c b/tools/testing/selftests/landlock/ptrace_test.c
index ea8e4be6659e..f253c6a3a436 100644
--- a/tools/testing/selftests/landlock/ptrace_test.c
+++ b/tools/testing/selftests/landlock/ptrace_test.c
@@ -183,8 +183,8 @@ TEST_F(scoped_domains, trace)
 	if (child == 0) {
 		char buf_child;
 
-		ASSERT_EQ(0, close(pipe_parent[1]));
-		ASSERT_EQ(0, close(pipe_child[0]));
+		EXPECT_EQ(0, close(pipe_parent[1]));
+		EXPECT_EQ(0, close(pipe_child[0]));
 		if (variant->domain_child)
 			create_domain(_metadata);
 
@@ -238,8 +238,8 @@ TEST_F(scoped_domains, trace)
 		return;
 	}
 
-	ASSERT_EQ(0, close(pipe_child[1]));
-	ASSERT_EQ(0, close(pipe_parent[0]));
+	EXPECT_EQ(0, close(pipe_child[1]));
+	EXPECT_EQ(0, close(pipe_parent[0]));
 	if (variant->domain_parent)
 		create_domain(_metadata);
 
@@ -370,8 +370,8 @@ TEST_F(audit, trace)
 	if (child == 0) {
 		char buf_child;
 
-		ASSERT_EQ(0, close(pipe_parent[1]));
-		ASSERT_EQ(0, close(pipe_child[0]));
+		EXPECT_EQ(0, close(pipe_parent[1]));
+		EXPECT_EQ(0, close(pipe_child[0]));
 
 		/* Waits for the parent to be in a domain, if any. */
 		ASSERT_EQ(1, read(pipe_parent[0], &buf_child, 1));
@@ -400,8 +400,8 @@ TEST_F(audit, trace)
 		return;
 	}
 
-	ASSERT_EQ(0, close(pipe_child[1]));
-	ASSERT_EQ(0, close(pipe_parent[0]));
+	EXPECT_EQ(0, close(pipe_child[1]));
+	EXPECT_EQ(0, close(pipe_parent[0]));
 	create_domain(_metadata);
 
 	/* Signals that the parent is in a domain. */
diff --git a/tools/testing/selftests/landlock/trace_fs_test.c b/tools/testing/selftests/landlock/trace_fs_test.c
index 64014ade3a0e..06161aa6d5d7 100644
--- a/tools/testing/selftests/landlock/trace_fs_test.c
+++ b/tools/testing/selftests/landlock/trace_fs_test.c
@@ -210,8 +210,8 @@ TEST_F(trace_fs, add_rule_path_beneath)
 
 	ASSERT_EQ(0, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_PATH_BENEATH,
 				       &path_beneath, 0));
-	ASSERT_EQ(0, close(path_beneath.parent_fd));
-	ASSERT_EQ(0, close(ruleset_fd));
+	EXPECT_EQ(0, close(path_beneath.parent_fd));
+	EXPECT_EQ(0, close(ruleset_fd));
 
 	buf = tracefs_read_buf();
 	ASSERT_NE(NULL, buf);
@@ -274,8 +274,8 @@ TEST_F(trace_fs, add_rule_path_beneath_escaped_path_overflow)
 
 	ASSERT_EQ(0, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_PATH_BENEATH,
 				       &path_beneath, 0));
-	ASSERT_EQ(0, close(path_beneath.parent_fd));
-	ASSERT_EQ(0, close(ruleset_fd));
+	EXPECT_EQ(0, close(path_beneath.parent_fd));
+	EXPECT_EQ(0, close(ruleset_fd));
 
 	buf = tracefs_read_buf();
 	ASSERT_NE(NULL, buf);
diff --git a/tools/testing/selftests/landlock/trace_test.c b/tools/testing/selftests/landlock/trace_test.c
index a331df746dbc..df6cc3c4d945 100644
--- a/tools/testing/selftests/landlock/trace_test.c
+++ b/tools/testing/selftests/landlock/trace_test.c
@@ -163,7 +163,7 @@ TEST_F(trace, create_ruleset)
 	ruleset_fd =
 		landlock_create_ruleset(&ruleset_attr, sizeof(ruleset_attr), 0);
 	ASSERT_LE(0, ruleset_fd);
-	ASSERT_EQ(0, close(ruleset_fd));
+	EXPECT_EQ(0, close(ruleset_fd));
 
 	buf = tracefs_read_buf();
 	ASSERT_NE(NULL, buf);
@@ -508,7 +508,7 @@ TEST_F(trace, add_rule_invalid_fd)
 	/* Invalid ruleset fd (-1). */
 	ASSERT_EQ(-1, landlock_add_rule(-1, LANDLOCK_RULE_PATH_BENEATH,
 					&path_beneath, 0));
-	ASSERT_EQ(0, close(path_beneath.parent_fd));
+	EXPECT_EQ(0, close(path_beneath.parent_fd));
 
 	buf = tracefs_read_buf();
 	ASSERT_NE(NULL, buf);
@@ -544,7 +544,7 @@ TEST_F(trace, create_domain_invalid)
 	/* Unknown flags. */
 	ASSERT_EQ(-1, landlock_restrict_self(ruleset_fd, -1));
 
-	ASSERT_EQ(0, close(ruleset_fd));
+	EXPECT_EQ(0, close(ruleset_fd));
 
 	buf = tracefs_read_buf();
 	ASSERT_NE(NULL, buf);
diff --git a/tools/testing/selftests/landlock/tsync_test.c b/tools/testing/selftests/landlock/tsync_test.c
index 2b53596c986e..aff973ba4735 100644
--- a/tools/testing/selftests/landlock/tsync_test.c
+++ b/tools/testing/selftests/landlock/tsync_test.c
@@ -152,10 +152,10 @@ TEST_F(multi_threaded, restrict)
 	EXPECT_EQ(variant->expected_no_new_privs,
 		  prctl(PR_GET_NO_NEW_PRIVS, 0, 0, 0, 0));
 
-	ASSERT_EQ(0, pthread_cancel(t1));
-	ASSERT_EQ(0, pthread_cancel(t2));
-	ASSERT_EQ(0, pthread_join(t1, NULL));
-	ASSERT_EQ(0, pthread_join(t2, NULL));
+	EXPECT_EQ(0, pthread_cancel(t1));
+	EXPECT_EQ(0, pthread_cancel(t2));
+	EXPECT_EQ(0, pthread_join(t1, NULL));
+	EXPECT_EQ(0, pthread_join(t2, NULL));
 
 	/* Checks the no_new_privs state of the sibling threads. */
 	EXPECT_EQ(variant->expected_no_new_privs, no_new_privs1);
@@ -184,10 +184,10 @@ TEST(multi_threaded_success_despite_diverging_domains)
 	EXPECT_EQ(0, landlock_restrict_self(ruleset_fd,
 					    LANDLOCK_RESTRICT_SELF_TSYNC));
 
-	ASSERT_EQ(0, pthread_cancel(t1));
-	ASSERT_EQ(0, pthread_cancel(t2));
-	ASSERT_EQ(0, pthread_join(t1, NULL));
-	ASSERT_EQ(0, pthread_join(t2, NULL));
+	EXPECT_EQ(0, pthread_cancel(t1));
+	EXPECT_EQ(0, pthread_cancel(t2));
+	EXPECT_EQ(0, pthread_join(t1, NULL));
+	EXPECT_EQ(0, pthread_join(t2, NULL));
 	EXPECT_EQ(0, close(ruleset_fd));
 }
 
@@ -309,11 +309,11 @@ TEST(tsync_interrupt)
 					    LANDLOCK_RESTRICT_SELF_TSYNC));
 
 	sd.stop = true;
-	ASSERT_EQ(0, pthread_join(signaler, NULL));
+	EXPECT_EQ(0, pthread_join(signaler, NULL));
 
 	for (i = 0; i < NUM_IDLE_THREADS; i++) {
-		ASSERT_EQ(0, pthread_cancel(threads[i]));
-		ASSERT_EQ(0, pthread_join(threads[i], NULL));
+		EXPECT_EQ(0, pthread_cancel(threads[i]));
+		EXPECT_EQ(0, pthread_join(threads[i], NULL));
 	}
 
 	EXPECT_EQ(0, close(ruleset_fd));
-- 
2.56.0

[PATCH 27/27] selftests/landlock: Use EXPECT for checks that later steps do not need

[Günther Noack]

ASSERT aborts the test, so it should only be used when continuing after
a failure is pointless.  Use EXPECT for checks whose outcome nothing
later in the test depends on:

* errno values after a failed syscall,
* test_open() and test_open_rel(), which leave no state behind,
* WEXITSTATUS() of a child that has exited,
* matches_log_fs() and matches_log_fs_extra(),
* the record counts returned by audit_count_records().

Keep ASSERT for operations whose side effects later checks depend on,
such as renames, links and file removals.

Assisted-by: LLM
Signed-off-by: Günther Noack <gnoack3000@gmail.com>
---
 tools/testing/selftests/landlock/audit_test.c |   10 +-
 tools/testing/selftests/landlock/base_test.c  |  102 +-
 tools/testing/selftests/landlock/fs_test.c    | 1024 ++++++++---------
 tools/testing/selftests/landlock/net_test.c   |    2 +-
 .../landlock/scoped_abstract_unix_test.c      |    8 +-
 .../selftests/landlock/scoped_signal_test.c   |    6 +-
 .../testing/selftests/landlock/scoped_test.c  |    2 +-
 7 files changed, 577 insertions(+), 577 deletions(-)

diff --git a/tools/testing/selftests/landlock/audit_test.c b/tools/testing/selftests/landlock/audit_test.c
index 392e75ddfa3c..23ab3a696299 100644
--- a/tools/testing/selftests/landlock/audit_test.c
+++ b/tools/testing/selftests/landlock/audit_test.c
@@ -315,14 +315,14 @@ TEST_F(audit, log_subdomains_off_fork)
 	if (child == 0) {
 		ASSERT_EQ(0, landlock_restrict_self(ruleset_fd, 0));
 		ASSERT_EQ(-1, kill(getppid(), 0));
-		ASSERT_EQ(EPERM, errno);
+		EXPECT_EQ(EPERM, errno);
 		_exit(_metadata->exit_code);
 		return;
 	}
 
 	ASSERT_EQ(child, waitpid(child, &status, 0));
 	ASSERT_EQ(true, WIFEXITED(status));
-	ASSERT_EQ(0, WEXITSTATUS(status));
+	EXPECT_EQ(0, WEXITSTATUS(status));
 
 	/* The denial must be logged (baseline). */
 	EXPECT_EQ(0, matches_log_signal(_metadata, self->audit_fd, getpid(),
@@ -348,14 +348,14 @@ TEST_F(audit, log_subdomains_off_fork)
 	if (child == 0) {
 		ASSERT_EQ(0, landlock_restrict_self(ruleset_fd, 0));
 		ASSERT_EQ(-1, kill(getppid(), 0));
-		ASSERT_EQ(EPERM, errno);
+		EXPECT_EQ(EPERM, errno);
 		_exit(_metadata->exit_code);
 		return;
 	}
 
 	ASSERT_EQ(child, waitpid(child, &status, 0));
 	ASSERT_EQ(true, WIFEXITED(status));
-	ASSERT_EQ(0, WEXITSTATUS(status));
+	EXPECT_EQ(0, WEXITSTATUS(status));
 
 	/* No denial record should appear. */
 	EXPECT_EQ(-EAGAIN, matches_log_signal(_metadata, self->audit_fd,
@@ -981,7 +981,7 @@ TEST_F(audit_exec, signal_and_open)
 	EXPECT_EQ(0, close(pipe_child[0]));
 	ASSERT_EQ(child, waitpid(child, &status, 0));
 	ASSERT_EQ(1, WIFEXITED(status));
-	ASSERT_EQ(0, WEXITSTATUS(status));
+	EXPECT_EQ(0, WEXITSTATUS(status));
 
 	/* Tests that the audit record only matches the child. */
 	if (!(variant->restrict_flags &
diff --git a/tools/testing/selftests/landlock/base_test.c b/tools/testing/selftests/landlock/base_test.c
index 862ff91f6418..76864ad53020 100644
--- a/tools/testing/selftests/landlock/base_test.c
+++ b/tools/testing/selftests/landlock/base_test.c
@@ -33,40 +33,40 @@ TEST(inconsistent_attr)
 	/* Checks copy_from_user(). */
 	ASSERT_EQ(-1, landlock_create_ruleset(ruleset_attr, 0, 0));
 	/* The size if less than sizeof(struct landlock_attr_enforce). */
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 	ASSERT_EQ(-1, landlock_create_ruleset(ruleset_attr, 1, 0));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 	ASSERT_EQ(-1, landlock_create_ruleset(ruleset_attr, 7, 0));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 
 	ASSERT_EQ(-1, landlock_create_ruleset(NULL, 1, 0));
 	/* The size if less than sizeof(struct landlock_attr_enforce). */
-	ASSERT_EQ(EFAULT, errno);
+	EXPECT_EQ(EFAULT, errno);
 
 	ASSERT_EQ(-1, landlock_create_ruleset(
 			      NULL, sizeof(struct landlock_ruleset_attr), 0));
-	ASSERT_EQ(EFAULT, errno);
+	EXPECT_EQ(EFAULT, errno);
 
 	ASSERT_EQ(-1, landlock_create_ruleset(ruleset_attr, page_size + 1, 0));
-	ASSERT_EQ(E2BIG, errno);
+	EXPECT_EQ(E2BIG, errno);
 
 	/* Checks minimal valid attribute size. */
 	ASSERT_EQ(-1, landlock_create_ruleset(ruleset_attr, 8, 0));
-	ASSERT_EQ(ENOMSG, errno);
+	EXPECT_EQ(ENOMSG, errno);
 	ASSERT_EQ(-1, landlock_create_ruleset(
 			      ruleset_attr,
 			      sizeof(struct landlock_ruleset_attr), 0));
-	ASSERT_EQ(ENOMSG, errno);
+	EXPECT_EQ(ENOMSG, errno);
 	ASSERT_EQ(-1, landlock_create_ruleset(ruleset_attr, page_size, 0));
-	ASSERT_EQ(ENOMSG, errno);
+	EXPECT_EQ(ENOMSG, errno);
 
 	/* Checks non-zero value. */
 	buf[page_size - 2] = '.';
 	ASSERT_EQ(-1, landlock_create_ruleset(ruleset_attr, page_size, 0));
-	ASSERT_EQ(E2BIG, errno);
+	EXPECT_EQ(E2BIG, errno);
 
 	ASSERT_EQ(-1, landlock_create_ruleset(ruleset_attr, page_size + 1, 0));
-	ASSERT_EQ(E2BIG, errno);
+	EXPECT_EQ(E2BIG, errno);
 
 	free(buf);
 }
@@ -81,21 +81,21 @@ TEST(abi_version)
 
 	ASSERT_EQ(-1, landlock_create_ruleset(&ruleset_attr, 0,
 					      LANDLOCK_CREATE_RULESET_VERSION));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 
 	ASSERT_EQ(-1, landlock_create_ruleset(NULL, sizeof(ruleset_attr),
 					      LANDLOCK_CREATE_RULESET_VERSION));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 
 	ASSERT_EQ(-1,
 		  landlock_create_ruleset(&ruleset_attr, sizeof(ruleset_attr),
 					  LANDLOCK_CREATE_RULESET_VERSION));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 
 	ASSERT_EQ(-1, landlock_create_ruleset(NULL, 0,
 					      LANDLOCK_CREATE_RULESET_VERSION |
 						      1 << 31));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 }
 
 /*
@@ -121,16 +121,16 @@ TEST(errata)
 
 	ASSERT_EQ(-1, landlock_create_ruleset(&ruleset_attr, 0,
 					      LANDLOCK_CREATE_RULESET_ERRATA));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 
 	ASSERT_EQ(-1, landlock_create_ruleset(NULL, sizeof(ruleset_attr),
 					      LANDLOCK_CREATE_RULESET_ERRATA));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 
 	ASSERT_EQ(-1,
 		  landlock_create_ruleset(&ruleset_attr, sizeof(ruleset_attr),
 					  LANDLOCK_CREATE_RULESET_ERRATA));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 
 	ASSERT_EQ(-1, landlock_create_ruleset(
 			      NULL, 0,
@@ -141,7 +141,7 @@ TEST(errata)
 	ASSERT_EQ(-1, landlock_create_ruleset(NULL, 0,
 					      LANDLOCK_CREATE_RULESET_ERRATA |
 						      1 << 31));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 }
 
 /* Tests ordering of syscall argument checks. */
@@ -156,29 +156,29 @@ TEST(create_ruleset_checks_ordering)
 
 	/* Checks priority for invalid flags. */
 	ASSERT_EQ(-1, landlock_create_ruleset(NULL, 0, invalid_flag));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 
 	ASSERT_EQ(-1, landlock_create_ruleset(&ruleset_attr, 0, invalid_flag));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 
 	ASSERT_EQ(-1, landlock_create_ruleset(NULL, sizeof(ruleset_attr),
 					      invalid_flag));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 
 	ASSERT_EQ(-1,
 		  landlock_create_ruleset(&ruleset_attr, sizeof(ruleset_attr),
 					  invalid_flag));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 
 	/* Checks too big ruleset_attr size. */
 	ASSERT_EQ(-1, landlock_create_ruleset(&ruleset_attr, -1, 0));
-	ASSERT_EQ(E2BIG, errno);
+	EXPECT_EQ(E2BIG, errno);
 
 	/* Checks too small ruleset_attr size. */
 	ASSERT_EQ(-1, landlock_create_ruleset(&ruleset_attr, 0, 0));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 	ASSERT_EQ(-1, landlock_create_ruleset(&ruleset_attr, 1, 0));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 
 	/* Checks valid call. */
 	ruleset_fd =
@@ -204,25 +204,25 @@ TEST(add_rule_checks_ordering)
 
 	/* Checks invalid flags. */
 	ASSERT_EQ(-1, landlock_add_rule(-1, 0, NULL, 100));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 
 	/* Checks invalid ruleset FD. */
 	ASSERT_EQ(-1, landlock_add_rule(-1, 0, NULL, 0));
-	ASSERT_EQ(EBADF, errno);
+	EXPECT_EQ(EBADF, errno);
 
 	/* Checks invalid rule type. */
 	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, 0, NULL, 0));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 
 	/* Checks invalid rule attr. */
 	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_PATH_BENEATH,
 					NULL, 0));
-	ASSERT_EQ(EFAULT, errno);
+	EXPECT_EQ(EFAULT, errno);
 
 	/* Checks invalid path_beneath.parent_fd. */
 	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_PATH_BENEATH,
 					&path_beneath_attr, 0));
-	ASSERT_EQ(EBADF, errno);
+	EXPECT_EQ(EBADF, errno);
 
 	/* Checks valid call. */
 	path_beneath_attr.parent_fd =
@@ -262,11 +262,11 @@ TEST(restrict_self_checks_ordering)
 	 * CAP_SYS_ADMIN requirement.
 	 */
 	ASSERT_EQ(-1, landlock_restrict_self(-1, -1));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 	ASSERT_EQ(-1, landlock_restrict_self(-1, 0));
-	ASSERT_EQ(EPERM, errno);
+	EXPECT_EQ(EPERM, errno);
 	ASSERT_EQ(-1, landlock_restrict_self(ruleset_fd, 0));
-	ASSERT_EQ(EPERM, errno);
+	EXPECT_EQ(EPERM, errno);
 	/*
 	 * LANDLOCK_RESTRICT_SELF_NO_NEW_PRIVS fulfills the no_new_privs /
 	 * CAP_SYS_ADMIN requirement but requires a ruleset, so the FD is
@@ -274,17 +274,17 @@ TEST(restrict_self_checks_ordering)
 	 */
 	ASSERT_EQ(-1, landlock_restrict_self(
 			      -1, LANDLOCK_RESTRICT_SELF_NO_NEW_PRIVS));
-	ASSERT_EQ(EBADF, errno);
+	EXPECT_EQ(EBADF, errno);
 
 	ASSERT_EQ(0, prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0));
 
 	/* Checks invalid flags. */
 	ASSERT_EQ(-1, landlock_restrict_self(-1, -1));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 
 	/* Checks invalid ruleset FD. */
 	ASSERT_EQ(-1, landlock_restrict_self(-1, 0));
-	ASSERT_EQ(EBADF, errno);
+	EXPECT_EQ(EBADF, errno);
 
 	/* Checks valid call. */
 	ASSERT_EQ(0, landlock_restrict_self(ruleset_fd, 0));
@@ -319,7 +319,7 @@ TEST(restrict_self_max_layers)
 	drop_caps(_metadata);
 	ASSERT_EQ(-1, landlock_restrict_self(
 			      ruleset_fd, LANDLOCK_RESTRICT_SELF_NO_NEW_PRIVS));
-	ASSERT_EQ(E2BIG, errno);
+	EXPECT_EQ(E2BIG, errno);
 
 	/* Checks that the failed call did not set no_new_privs. */
 	ASSERT_EQ(0, prctl(PR_GET_NO_NEW_PRIVS, 0, 0, 0, 0));
@@ -473,9 +473,9 @@ TEST(ruleset_fd_io)
 	ASSERT_LE(0, ruleset_fd);
 
 	ASSERT_EQ(-1, write(ruleset_fd, ".", 1));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 	ASSERT_EQ(-1, read(ruleset_fd, &buf, 1));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 
 	EXPECT_EQ(0, close(ruleset_fd));
 }
@@ -530,7 +530,7 @@ TEST(ruleset_fd_transfer)
 
 		/* Checks that the ruleset enforcement. */
 		ASSERT_EQ(-1, open("/", O_RDONLY | O_DIRECTORY | O_CLOEXEC));
-		ASSERT_EQ(EACCES, errno);
+		EXPECT_EQ(EACCES, errno);
 		dir_fd = open("/tmp", O_RDONLY | O_DIRECTORY | O_CLOEXEC);
 		ASSERT_LE(0, dir_fd);
 		EXPECT_EQ(0, close(dir_fd));
@@ -550,7 +550,7 @@ TEST(ruleset_fd_transfer)
 
 	ASSERT_EQ(child, waitpid(child, &status, 0));
 	ASSERT_EQ(1, WIFEXITED(status));
-	ASSERT_EQ(EXIT_SUCCESS, WEXITSTATUS(status));
+	EXPECT_EQ(EXIT_SUCCESS, WEXITSTATUS(status));
 }
 
 TEST(cred_transfer)
@@ -648,7 +648,7 @@ TEST(useless_quiet_rule_fs)
 	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_PATH_BENEATH,
 					&path_beneath_attr,
 					LANDLOCK_ADD_RULE_QUIET));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 
 	/* Check that the rule had not been added. */
 	EXPECT_EQ(0, close(root_fd));
@@ -656,7 +656,7 @@ TEST(useless_quiet_rule_fs)
 	EXPECT_EQ(0, close(ruleset_fd));
 
 	ASSERT_EQ(-1, open("/", O_RDONLY | O_DIRECTORY | O_CLOEXEC));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 }
 
 TEST(useless_quiet_rule_net)
@@ -679,7 +679,7 @@ TEST(useless_quiet_rule_net)
 	ASSERT_EQ(-1,
 		  landlock_add_rule(ruleset_fd, LANDLOCK_RULE_NET_PORT,
 				    &net_port_attr, LANDLOCK_ADD_RULE_QUIET));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 
 	EXPECT_EQ(0, close(ruleset_fd));
 }
@@ -702,15 +702,15 @@ TEST(invalid_quiet_bits_1)
 	/* Quiet bit set but not part of the handled mask. */
 	ASSERT_EQ(-1, landlock_create_ruleset(&ruleset_attr_fs,
 					      sizeof(ruleset_attr_fs), 0));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 
 	ASSERT_EQ(-1, landlock_create_ruleset(&ruleset_attr_net,
 					      sizeof(ruleset_attr_net), 0));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 
 	ASSERT_EQ(-1, landlock_create_ruleset(&ruleset_attr_scoped,
 					      sizeof(ruleset_attr_scoped), 0));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 }
 
 TEST(invalid_quiet_bits_2)
@@ -731,15 +731,15 @@ TEST(invalid_quiet_bits_2)
 	/* Quiet bit outside of the valid access range. */
 	ASSERT_EQ(-1, landlock_create_ruleset(&ruleset_attr_fs,
 					      sizeof(ruleset_attr_fs), 0));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 
 	ASSERT_EQ(-1, landlock_create_ruleset(&ruleset_attr_net,
 					      sizeof(ruleset_attr_net), 0));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 
 	ASSERT_EQ(-1, landlock_create_ruleset(&ruleset_attr_scoped,
 					      sizeof(ruleset_attr_scoped), 0));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 }
 
 TEST_HARNESS_MAIN
diff --git a/tools/testing/selftests/landlock/fs_test.c b/tools/testing/selftests/landlock/fs_test.c
index 76f319c972db..de79bec2e6d7 100644
--- a/tools/testing/selftests/landlock/fs_test.c
+++ b/tools/testing/selftests/landlock/fs_test.c
@@ -339,7 +339,7 @@ static void cleanup_layout(struct __test_metadata *const _metadata)
 		 * visibility of the nested TMP_DIR mount point for the test's
 		 * parent process doing this cleanup.
 		 */
-		ASSERT_EQ(EINVAL, errno);
+		EXPECT_EQ(EINVAL, errno);
 	}
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 	EXPECT_EQ(0, remove_path(TMP_DIR));
@@ -455,25 +455,25 @@ static int test_open(const char *const path, const int flags)
 
 TEST_F_FORK(layout1, no_restriction)
 {
-	ASSERT_EQ(0, test_open(dir_s1d1, O_RDONLY));
-	ASSERT_EQ(0, test_open(file1_s1d1, O_RDONLY));
-	ASSERT_EQ(0, test_open(file2_s1d1, O_RDONLY));
-	ASSERT_EQ(0, test_open(dir_s1d2, O_RDONLY));
-	ASSERT_EQ(0, test_open(file1_s1d2, O_RDONLY));
-	ASSERT_EQ(0, test_open(file2_s1d2, O_RDONLY));
-	ASSERT_EQ(0, test_open(dir_s1d3, O_RDONLY));
-	ASSERT_EQ(0, test_open(file1_s1d3, O_RDONLY));
+	EXPECT_EQ(0, test_open(dir_s1d1, O_RDONLY));
+	EXPECT_EQ(0, test_open(file1_s1d1, O_RDONLY));
+	EXPECT_EQ(0, test_open(file2_s1d1, O_RDONLY));
+	EXPECT_EQ(0, test_open(dir_s1d2, O_RDONLY));
+	EXPECT_EQ(0, test_open(file1_s1d2, O_RDONLY));
+	EXPECT_EQ(0, test_open(file2_s1d2, O_RDONLY));
+	EXPECT_EQ(0, test_open(dir_s1d3, O_RDONLY));
+	EXPECT_EQ(0, test_open(file1_s1d3, O_RDONLY));
 
-	ASSERT_EQ(0, test_open(dir_s2d1, O_RDONLY));
-	ASSERT_EQ(0, test_open(file1_s2d1, O_RDONLY));
-	ASSERT_EQ(0, test_open(dir_s2d2, O_RDONLY));
-	ASSERT_EQ(0, test_open(file1_s2d2, O_RDONLY));
-	ASSERT_EQ(0, test_open(dir_s2d3, O_RDONLY));
-	ASSERT_EQ(0, test_open(file1_s2d3, O_RDONLY));
+	EXPECT_EQ(0, test_open(dir_s2d1, O_RDONLY));
+	EXPECT_EQ(0, test_open(file1_s2d1, O_RDONLY));
+	EXPECT_EQ(0, test_open(dir_s2d2, O_RDONLY));
+	EXPECT_EQ(0, test_open(file1_s2d2, O_RDONLY));
+	EXPECT_EQ(0, test_open(dir_s2d3, O_RDONLY));
+	EXPECT_EQ(0, test_open(file1_s2d3, O_RDONLY));
 
-	ASSERT_EQ(0, test_open(dir_s3d1, O_RDONLY));
-	ASSERT_EQ(0, test_open(dir_s3d2, O_RDONLY));
-	ASSERT_EQ(0, test_open(dir_s3d3, O_RDONLY));
+	EXPECT_EQ(0, test_open(dir_s3d1, O_RDONLY));
+	EXPECT_EQ(0, test_open(dir_s3d2, O_RDONLY));
+	EXPECT_EQ(0, test_open(dir_s3d3, O_RDONLY));
 }
 
 TEST_F_FORK(layout1, inval)
@@ -498,7 +498,7 @@ TEST_F_FORK(layout1, inval)
 	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_PATH_BENEATH,
 					&path_beneath, 0));
 	/* Returns EBADF because ruleset_fd is not a landlock-ruleset FD. */
-	ASSERT_EQ(EBADF, errno);
+	EXPECT_EQ(EBADF, errno);
 	EXPECT_EQ(0, close(ruleset_fd));
 
 	ruleset_fd = open(dir_s1d1, O_DIRECTORY | O_CLOEXEC);
@@ -506,7 +506,7 @@ TEST_F_FORK(layout1, inval)
 	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_PATH_BENEATH,
 					&path_beneath, 0));
 	/* Returns EBADFD because ruleset_fd is not a valid ruleset. */
-	ASSERT_EQ(EBADFD, errno);
+	EXPECT_EQ(EBADFD, errno);
 	EXPECT_EQ(0, close(ruleset_fd));
 
 	/* Gets a real ruleset. */
@@ -528,7 +528,7 @@ TEST_F_FORK(layout1, inval)
 	path_beneath.parent_fd = ruleset_fd;
 	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_PATH_BENEATH,
 					&path_beneath, 0));
-	ASSERT_EQ(EBADFD, errno);
+	EXPECT_EQ(EBADFD, errno);
 
 	/* Checks unhandled allowed_access. */
 	path_beneath.parent_fd =
@@ -539,28 +539,28 @@ TEST_F_FORK(layout1, inval)
 	path_beneath.allowed_access |= LANDLOCK_ACCESS_FS_EXECUTE;
 	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_PATH_BENEATH,
 					&path_beneath, 0));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 	path_beneath.allowed_access &= ~LANDLOCK_ACCESS_FS_EXECUTE;
 
 	/* Tests with denied-by-default access right. */
 	path_beneath.allowed_access |= LANDLOCK_ACCESS_FS_REFER;
 	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_PATH_BENEATH,
 					&path_beneath, 0));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 	path_beneath.allowed_access &= ~LANDLOCK_ACCESS_FS_REFER;
 
 	/* Test with unknown (64-bits) value. */
 	path_beneath.allowed_access |= (1ULL << 60);
 	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_PATH_BENEATH,
 					&path_beneath, 0));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 	path_beneath.allowed_access &= ~(1ULL << 60);
 
 	/* Test with no access. */
 	path_beneath.allowed_access = 0;
 	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_PATH_BENEATH,
 					&path_beneath, 0));
-	ASSERT_EQ(ENOMSG, errno);
+	EXPECT_EQ(ENOMSG, errno);
 	path_beneath.allowed_access &= ~(1ULL << 60);
 
 	EXPECT_EQ(0, close(path_beneath.parent_fd));
@@ -636,7 +636,7 @@ TEST_F_FORK(layout1, file_and_dir_access_rights)
 			ASSERT_EQ(0, err);
 		} else {
 			ASSERT_EQ(-1, err);
-			ASSERT_EQ(EINVAL, errno);
+			EXPECT_EQ(EINVAL, errno);
 		}
 	}
 	EXPECT_EQ(0, close(path_beneath_file.parent_fd));
@@ -656,7 +656,7 @@ TEST_F_FORK(layout0, ruleset_with_unknown_access)
 
 		ASSERT_EQ(-1, landlock_create_ruleset(&ruleset_attr,
 						      sizeof(ruleset_attr), 0));
-		ASSERT_EQ(EINVAL, errno);
+		EXPECT_EQ(EINVAL, errno);
 	}
 }
 
@@ -813,24 +813,24 @@ TEST_F_FORK(layout0, proc_nsfs)
 		rules);
 
 	ASSERT_LE(0, ruleset_fd);
-	ASSERT_EQ(0, test_open("/proc/self/ns/mnt", O_RDONLY));
+	EXPECT_EQ(0, test_open("/proc/self/ns/mnt", O_RDONLY));
 
 	enforce_ruleset(_metadata, ruleset_fd);
 
-	ASSERT_EQ(EACCES, test_open("/", O_RDONLY));
-	ASSERT_EQ(EACCES, test_open("/dev", O_RDONLY));
-	ASSERT_EQ(0, test_open("/dev/null", O_RDONLY));
-	ASSERT_EQ(EACCES, test_open("/dev/full", O_RDONLY));
+	EXPECT_EQ(EACCES, test_open("/", O_RDONLY));
+	EXPECT_EQ(EACCES, test_open("/dev", O_RDONLY));
+	EXPECT_EQ(0, test_open("/dev/null", O_RDONLY));
+	EXPECT_EQ(EACCES, test_open("/dev/full", O_RDONLY));
 
-	ASSERT_EQ(EACCES, test_open("/proc", O_RDONLY));
-	ASSERT_EQ(EACCES, test_open("/proc/self", O_RDONLY));
-	ASSERT_EQ(EACCES, test_open("/proc/self/ns", O_RDONLY));
+	EXPECT_EQ(EACCES, test_open("/proc", O_RDONLY));
+	EXPECT_EQ(EACCES, test_open("/proc/self", O_RDONLY));
+	EXPECT_EQ(EACCES, test_open("/proc/self/ns", O_RDONLY));
 	/*
 	 * Because nsfs is an internal filesystem, /proc/self/ns/mnt is a
 	 * disconnected path.  Such path cannot be identified and must then be
 	 * allowed.
 	 */
-	ASSERT_EQ(0, test_open("/proc/self/ns/mnt", O_RDONLY));
+	EXPECT_EQ(0, test_open("/proc/self/ns/mnt", O_RDONLY));
 
 	/*
 	 * Checks that it is not possible to add nsfs-like filesystem
@@ -842,7 +842,7 @@ TEST_F_FORK(layout0, proc_nsfs)
 	ASSERT_LE(0, path_beneath.parent_fd);
 	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_PATH_BENEATH,
 					&path_beneath, 0));
-	ASSERT_EQ(EBADFD, errno);
+	EXPECT_EQ(EBADFD, errno);
 	EXPECT_EQ(0, close(path_beneath.parent_fd));
 }
 
@@ -862,7 +862,7 @@ TEST_F_FORK(layout0, unpriv)
 	ruleset_fd = create_ruleset(_metadata, ACCESS_RO, rules);
 	ASSERT_LE(0, ruleset_fd);
 	ASSERT_EQ(-1, landlock_restrict_self(ruleset_fd, 0));
-	ASSERT_EQ(EPERM, errno);
+	EXPECT_EQ(EPERM, errno);
 
 	/* enforce_ruleset() calls prctl(no_new_privs). */
 	enforce_ruleset(_metadata, ruleset_fd);
@@ -889,23 +889,23 @@ TEST_F_FORK(layout1, effective_access)
 	enforce_fs(_metadata, ACCESS_RW, rules);
 
 	/* Tests on a directory (with or without O_PATH). */
-	ASSERT_EQ(EACCES, test_open("/", O_RDONLY));
-	ASSERT_EQ(0, test_open("/", O_RDONLY | O_PATH));
-	ASSERT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY));
-	ASSERT_EQ(0, test_open(dir_s1d1, O_RDONLY | O_PATH));
-	ASSERT_EQ(EACCES, test_open(file1_s1d1, O_RDONLY));
-	ASSERT_EQ(0, test_open(file1_s1d1, O_RDONLY | O_PATH));
+	EXPECT_EQ(EACCES, test_open("/", O_RDONLY));
+	EXPECT_EQ(0, test_open("/", O_RDONLY | O_PATH));
+	EXPECT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY));
+	EXPECT_EQ(0, test_open(dir_s1d1, O_RDONLY | O_PATH));
+	EXPECT_EQ(EACCES, test_open(file1_s1d1, O_RDONLY));
+	EXPECT_EQ(0, test_open(file1_s1d1, O_RDONLY | O_PATH));
 
-	ASSERT_EQ(0, test_open(dir_s1d2, O_RDONLY));
-	ASSERT_EQ(0, test_open(file1_s1d2, O_RDONLY));
-	ASSERT_EQ(0, test_open(dir_s1d3, O_RDONLY));
-	ASSERT_EQ(0, test_open(file1_s1d3, O_RDONLY));
+	EXPECT_EQ(0, test_open(dir_s1d2, O_RDONLY));
+	EXPECT_EQ(0, test_open(file1_s1d2, O_RDONLY));
+	EXPECT_EQ(0, test_open(dir_s1d3, O_RDONLY));
+	EXPECT_EQ(0, test_open(file1_s1d3, O_RDONLY));
 
 	/* Tests on a file (with or without O_PATH). */
-	ASSERT_EQ(EACCES, test_open(dir_s2d2, O_RDONLY));
-	ASSERT_EQ(0, test_open(dir_s2d2, O_RDONLY | O_PATH));
+	EXPECT_EQ(EACCES, test_open(dir_s2d2, O_RDONLY));
+	EXPECT_EQ(0, test_open(dir_s2d2, O_RDONLY | O_PATH));
 
-	ASSERT_EQ(0, test_open(file1_s2d2, O_RDONLY));
+	EXPECT_EQ(0, test_open(file1_s2d2, O_RDONLY));
 
 	/* Checks effective read and write actions. */
 	reg_fd = open(file1_s2d2, O_RDWR | O_CLOEXEC);
@@ -920,7 +920,7 @@ TEST_F_FORK(layout1, effective_access)
 	reg_fd = open(file1_s2d2, O_RDONLY | O_CLOEXEC);
 	ASSERT_LE(0, reg_fd);
 	ASSERT_EQ(-1, write(reg_fd, &buf, 1));
-	ASSERT_EQ(EBADF, errno);
+	EXPECT_EQ(EBADF, errno);
 	EXPECT_EQ(0, close(reg_fd));
 }
 
@@ -941,11 +941,11 @@ TEST_F_FORK(layout1, unhandled_access)
 	 * Because the policy does not handle LANDLOCK_ACCESS_FS_WRITE_FILE,
 	 * opening for write-only should be allowed, but not read-write.
 	 */
-	ASSERT_EQ(0, test_open(file1_s1d1, O_WRONLY));
-	ASSERT_EQ(EACCES, test_open(file1_s1d1, O_RDWR));
+	EXPECT_EQ(0, test_open(file1_s1d1, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d1, O_RDWR));
 
-	ASSERT_EQ(0, test_open(file1_s1d2, O_WRONLY));
-	ASSERT_EQ(0, test_open(file1_s1d2, O_RDWR));
+	EXPECT_EQ(0, test_open(file1_s1d2, O_WRONLY));
+	EXPECT_EQ(0, test_open(file1_s1d2, O_RDWR));
 }
 
 TEST_F_FORK(layout1, ruleset_overlap)
@@ -968,22 +968,22 @@ TEST_F_FORK(layout1, ruleset_overlap)
 	enforce_fs(_metadata, ACCESS_RW, rules);
 
 	/* Checks s1d1 hierarchy. */
-	ASSERT_EQ(EACCES, test_open(file1_s1d1, O_RDONLY));
-	ASSERT_EQ(EACCES, test_open(file1_s1d1, O_WRONLY));
-	ASSERT_EQ(EACCES, test_open(file1_s1d1, O_RDWR));
-	ASSERT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d1, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d1, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d1, O_RDWR));
+	EXPECT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY | O_DIRECTORY));
 
 	/* Checks s1d2 hierarchy. */
-	ASSERT_EQ(0, test_open(file1_s1d2, O_RDONLY));
-	ASSERT_EQ(0, test_open(file1_s1d2, O_WRONLY));
-	ASSERT_EQ(0, test_open(file1_s1d2, O_RDWR));
-	ASSERT_EQ(0, test_open(dir_s1d2, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(0, test_open(file1_s1d2, O_RDONLY));
+	EXPECT_EQ(0, test_open(file1_s1d2, O_WRONLY));
+	EXPECT_EQ(0, test_open(file1_s1d2, O_RDWR));
+	EXPECT_EQ(0, test_open(dir_s1d2, O_RDONLY | O_DIRECTORY));
 
 	/* Checks s1d3 hierarchy. */
-	ASSERT_EQ(0, test_open(file1_s1d3, O_RDONLY));
-	ASSERT_EQ(0, test_open(file1_s1d3, O_WRONLY));
-	ASSERT_EQ(0, test_open(file1_s1d3, O_RDWR));
-	ASSERT_EQ(0, test_open(dir_s1d3, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(0, test_open(file1_s1d3, O_RDONLY));
+	EXPECT_EQ(0, test_open(file1_s1d3, O_WRONLY));
+	EXPECT_EQ(0, test_open(file1_s1d3, O_RDWR));
+	EXPECT_EQ(0, test_open(dir_s1d3, O_RDONLY | O_DIRECTORY));
 }
 
 TEST_F_FORK(layout1, layer_rule_unions)
@@ -1021,67 +1021,67 @@ TEST_F_FORK(layout1, layer_rule_unions)
 	enforce_fs(_metadata, ACCESS_RW, layer1);
 
 	/* Checks s1d1 hierarchy with layer1. */
-	ASSERT_EQ(EACCES, test_open(file1_s1d1, O_RDONLY));
-	ASSERT_EQ(EACCES, test_open(file1_s1d1, O_WRONLY));
-	ASSERT_EQ(EACCES, test_open(file1_s1d1, O_RDWR));
-	ASSERT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d1, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d1, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d1, O_RDWR));
+	EXPECT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY | O_DIRECTORY));
 
 	/* Checks s1d2 hierarchy with layer1. */
-	ASSERT_EQ(0, test_open(file1_s1d2, O_RDONLY));
-	ASSERT_EQ(EACCES, test_open(file1_s1d2, O_WRONLY));
-	ASSERT_EQ(EACCES, test_open(file1_s1d2, O_RDWR));
-	ASSERT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(0, test_open(file1_s1d2, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d2, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d2, O_RDWR));
+	EXPECT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY | O_DIRECTORY));
 
 	/* Checks s1d3 hierarchy with layer1. */
-	ASSERT_EQ(0, test_open(file1_s1d3, O_RDONLY));
-	ASSERT_EQ(0, test_open(file1_s1d3, O_WRONLY));
+	EXPECT_EQ(0, test_open(file1_s1d3, O_RDONLY));
+	EXPECT_EQ(0, test_open(file1_s1d3, O_WRONLY));
 	/* dir_s1d3 should allow READ_FILE and WRITE_FILE (O_RDWR). */
-	ASSERT_EQ(0, test_open(file1_s1d3, O_RDWR));
-	ASSERT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(0, test_open(file1_s1d3, O_RDWR));
+	EXPECT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY | O_DIRECTORY));
 
 	/* Doesn't change anything from layer1. */
 	enforce_fs(_metadata, ACCESS_RW, layer2);
 
 	/* Checks s1d1 hierarchy with layer2. */
-	ASSERT_EQ(EACCES, test_open(file1_s1d1, O_RDONLY));
-	ASSERT_EQ(EACCES, test_open(file1_s1d1, O_WRONLY));
-	ASSERT_EQ(EACCES, test_open(file1_s1d1, O_RDWR));
-	ASSERT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d1, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d1, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d1, O_RDWR));
+	EXPECT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY | O_DIRECTORY));
 
 	/* Checks s1d2 hierarchy with layer2. */
-	ASSERT_EQ(0, test_open(file1_s1d2, O_RDONLY));
-	ASSERT_EQ(EACCES, test_open(file1_s1d2, O_WRONLY));
-	ASSERT_EQ(EACCES, test_open(file1_s1d2, O_RDWR));
-	ASSERT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(0, test_open(file1_s1d2, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d2, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d2, O_RDWR));
+	EXPECT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY | O_DIRECTORY));
 
 	/* Checks s1d3 hierarchy with layer2. */
-	ASSERT_EQ(0, test_open(file1_s1d3, O_RDONLY));
-	ASSERT_EQ(0, test_open(file1_s1d3, O_WRONLY));
+	EXPECT_EQ(0, test_open(file1_s1d3, O_RDONLY));
+	EXPECT_EQ(0, test_open(file1_s1d3, O_WRONLY));
 	/* dir_s1d3 should allow READ_FILE and WRITE_FILE (O_RDWR). */
-	ASSERT_EQ(0, test_open(file1_s1d3, O_RDWR));
-	ASSERT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(0, test_open(file1_s1d3, O_RDWR));
+	EXPECT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY | O_DIRECTORY));
 
 	/* Only allows write (but not read) to dir_s1d3. */
 	enforce_fs(_metadata, ACCESS_RW, layer3);
 
 	/* Checks s1d1 hierarchy with layer3. */
-	ASSERT_EQ(EACCES, test_open(file1_s1d1, O_RDONLY));
-	ASSERT_EQ(EACCES, test_open(file1_s1d1, O_WRONLY));
-	ASSERT_EQ(EACCES, test_open(file1_s1d1, O_RDWR));
-	ASSERT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d1, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d1, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d1, O_RDWR));
+	EXPECT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY | O_DIRECTORY));
 
 	/* Checks s1d2 hierarchy with layer3. */
-	ASSERT_EQ(EACCES, test_open(file1_s1d2, O_RDONLY));
-	ASSERT_EQ(EACCES, test_open(file1_s1d2, O_WRONLY));
-	ASSERT_EQ(EACCES, test_open(file1_s1d2, O_RDWR));
-	ASSERT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d2, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d2, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d2, O_RDWR));
+	EXPECT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY | O_DIRECTORY));
 
 	/* Checks s1d3 hierarchy with layer3. */
-	ASSERT_EQ(EACCES, test_open(file1_s1d3, O_RDONLY));
-	ASSERT_EQ(0, test_open(file1_s1d3, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d3, O_RDONLY));
+	EXPECT_EQ(0, test_open(file1_s1d3, O_WRONLY));
 	/* dir_s1d3 should now deny READ_FILE and WRITE_FILE (O_RDWR). */
-	ASSERT_EQ(EACCES, test_open(file1_s1d3, O_RDWR));
-	ASSERT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d3, O_RDWR));
+	EXPECT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY | O_DIRECTORY));
 }
 
 TEST_F_FORK(layout1, non_overlapping_accesses)
@@ -1107,7 +1107,7 @@ TEST_F_FORK(layout1, non_overlapping_accesses)
 	enforce_fs(_metadata, LANDLOCK_ACCESS_FS_MAKE_REG, layer1);
 
 	ASSERT_EQ(-1, mknod(file1_s1d1, S_IFREG | 0700, 0));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(0, mknod(file1_s1d2, S_IFREG | 0700, 0));
 	ASSERT_EQ(0, unlink(file1_s1d2));
 
@@ -1115,12 +1115,12 @@ TEST_F_FORK(layout1, non_overlapping_accesses)
 
 	/* Unchanged accesses for file creation. */
 	ASSERT_EQ(-1, mknod(file1_s1d1, S_IFREG | 0700, 0));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(0, mknod(file1_s1d2, S_IFREG | 0700, 0));
 
 	/* Checks file removing. */
 	ASSERT_EQ(-1, unlink(file1_s1d2));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(0, unlink(file1_s1d3));
 }
 
@@ -1219,25 +1219,25 @@ TEST_F_FORK(layout1, interleaved_masked_accesses)
 	enforce_fs(_metadata, LANDLOCK_ACCESS_FS_READ_FILE, layer1_read);
 
 	/* Checks that read access is granted for file1_s1d3 with layer 1. */
-	ASSERT_EQ(0, test_open(file1_s1d3, O_RDWR));
-	ASSERT_EQ(EACCES, test_open(file2_s1d3, O_RDONLY));
-	ASSERT_EQ(0, test_open(file2_s1d3, O_WRONLY));
+	EXPECT_EQ(0, test_open(file1_s1d3, O_RDWR));
+	EXPECT_EQ(EACCES, test_open(file2_s1d3, O_RDONLY));
+	EXPECT_EQ(0, test_open(file2_s1d3, O_WRONLY));
 
 	enforce_fs(_metadata,
 		   LANDLOCK_ACCESS_FS_READ_FILE | LANDLOCK_ACCESS_FS_WRITE_FILE,
 		   layer2_read_write);
 
 	/* Checks that previous access rights are unchanged with layer 2. */
-	ASSERT_EQ(0, test_open(file1_s1d3, O_RDWR));
-	ASSERT_EQ(EACCES, test_open(file2_s1d3, O_RDONLY));
-	ASSERT_EQ(0, test_open(file2_s1d3, O_WRONLY));
+	EXPECT_EQ(0, test_open(file1_s1d3, O_RDWR));
+	EXPECT_EQ(EACCES, test_open(file2_s1d3, O_RDONLY));
+	EXPECT_EQ(0, test_open(file2_s1d3, O_WRONLY));
 
 	enforce_fs(_metadata, LANDLOCK_ACCESS_FS_READ_FILE, layer3_read);
 
 	/* Checks that previous access rights are unchanged with layer 3. */
-	ASSERT_EQ(0, test_open(file1_s1d3, O_RDWR));
-	ASSERT_EQ(EACCES, test_open(file2_s1d3, O_RDONLY));
-	ASSERT_EQ(0, test_open(file2_s1d3, O_WRONLY));
+	EXPECT_EQ(0, test_open(file1_s1d3, O_RDWR));
+	EXPECT_EQ(EACCES, test_open(file2_s1d3, O_RDONLY));
+	EXPECT_EQ(0, test_open(file2_s1d3, O_WRONLY));
 
 	/* This time, denies write access for the file hierarchy. */
 	enforce_fs(_metadata,
@@ -1248,36 +1248,36 @@ TEST_F_FORK(layout1, interleaved_masked_accesses)
 	 * Checks that the only change with layer 4 is that write access is
 	 * denied.
 	 */
-	ASSERT_EQ(0, test_open(file1_s1d3, O_RDONLY));
-	ASSERT_EQ(EACCES, test_open(file1_s1d3, O_WRONLY));
-	ASSERT_EQ(EACCES, test_open(file2_s1d3, O_RDONLY));
-	ASSERT_EQ(EACCES, test_open(file2_s1d3, O_WRONLY));
+	EXPECT_EQ(0, test_open(file1_s1d3, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d3, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(file2_s1d3, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(file2_s1d3, O_WRONLY));
 
 	enforce_fs(_metadata, LANDLOCK_ACCESS_FS_READ_FILE, layer5_read);
 
 	/* Checks that previous access rights are unchanged with layer 5. */
-	ASSERT_EQ(0, test_open(file1_s1d3, O_RDONLY));
-	ASSERT_EQ(EACCES, test_open(file1_s1d3, O_WRONLY));
-	ASSERT_EQ(EACCES, test_open(file2_s1d3, O_WRONLY));
-	ASSERT_EQ(EACCES, test_open(file2_s1d3, O_RDONLY));
+	EXPECT_EQ(0, test_open(file1_s1d3, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d3, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(file2_s1d3, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(file2_s1d3, O_RDONLY));
 
 	enforce_fs(_metadata, LANDLOCK_ACCESS_FS_EXECUTE, layer6_execute);
 
 	/* Checks that previous access rights are unchanged with layer 6. */
-	ASSERT_EQ(0, test_open(file1_s1d3, O_RDONLY));
-	ASSERT_EQ(EACCES, test_open(file1_s1d3, O_WRONLY));
-	ASSERT_EQ(EACCES, test_open(file2_s1d3, O_WRONLY));
-	ASSERT_EQ(EACCES, test_open(file2_s1d3, O_RDONLY));
+	EXPECT_EQ(0, test_open(file1_s1d3, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d3, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(file2_s1d3, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(file2_s1d3, O_RDONLY));
 
 	enforce_fs(_metadata,
 		   LANDLOCK_ACCESS_FS_READ_FILE | LANDLOCK_ACCESS_FS_WRITE_FILE,
 		   layer7_read_write);
 
 	/* Checks read access is now denied with layer 7. */
-	ASSERT_EQ(EACCES, test_open(file1_s1d3, O_RDONLY));
-	ASSERT_EQ(EACCES, test_open(file1_s1d3, O_WRONLY));
-	ASSERT_EQ(EACCES, test_open(file2_s1d3, O_WRONLY));
-	ASSERT_EQ(EACCES, test_open(file2_s1d3, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d3, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d3, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(file2_s1d3, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(file2_s1d3, O_RDONLY));
 }
 
 TEST_F_FORK(layout1, inherit_subset)
@@ -1294,18 +1294,18 @@ TEST_F_FORK(layout1, inherit_subset)
 
 	enforce_ruleset(_metadata, ruleset_fd);
 
-	ASSERT_EQ(EACCES, test_open(file1_s1d1, O_WRONLY));
-	ASSERT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d1, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY | O_DIRECTORY));
 
 	/* Write access is forbidden. */
-	ASSERT_EQ(EACCES, test_open(file1_s1d2, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d2, O_WRONLY));
 	/* Readdir access is allowed. */
-	ASSERT_EQ(0, test_open(dir_s1d2, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(0, test_open(dir_s1d2, O_RDONLY | O_DIRECTORY));
 
 	/* Write access is forbidden. */
-	ASSERT_EQ(EACCES, test_open(file1_s1d3, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d3, O_WRONLY));
 	/* Readdir access is allowed. */
-	ASSERT_EQ(0, test_open(dir_s1d3, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(0, test_open(dir_s1d3, O_RDONLY | O_DIRECTORY));
 
 	/*
 	 * Tests shared rule extension: the following rules should not grant
@@ -1328,18 +1328,18 @@ TEST_F_FORK(layout1, inherit_subset)
 	enforce_ruleset(_metadata, ruleset_fd);
 
 	/* Same tests and results as above. */
-	ASSERT_EQ(EACCES, test_open(file1_s1d1, O_WRONLY));
-	ASSERT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d1, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY | O_DIRECTORY));
 
 	/* It is still forbidden to write in file1_s1d2. */
-	ASSERT_EQ(EACCES, test_open(file1_s1d2, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d2, O_WRONLY));
 	/* Readdir access is still allowed. */
-	ASSERT_EQ(0, test_open(dir_s1d2, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(0, test_open(dir_s1d2, O_RDONLY | O_DIRECTORY));
 
 	/* It is still forbidden to write in file1_s1d3. */
-	ASSERT_EQ(EACCES, test_open(file1_s1d3, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d3, O_WRONLY));
 	/* Readdir access is still allowed. */
-	ASSERT_EQ(0, test_open(dir_s1d3, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(0, test_open(dir_s1d3, O_RDONLY | O_DIRECTORY));
 
 	/*
 	 * Try to get more privileges by adding new access rights to the parent
@@ -1349,18 +1349,18 @@ TEST_F_FORK(layout1, inherit_subset)
 	enforce_ruleset(_metadata, ruleset_fd);
 
 	/* Same tests and results as above. */
-	ASSERT_EQ(EACCES, test_open(file1_s1d1, O_WRONLY));
-	ASSERT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d1, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY | O_DIRECTORY));
 
 	/* It is still forbidden to write in file1_s1d2. */
-	ASSERT_EQ(EACCES, test_open(file1_s1d2, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d2, O_WRONLY));
 	/* Readdir access is still allowed. */
-	ASSERT_EQ(0, test_open(dir_s1d2, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(0, test_open(dir_s1d2, O_RDONLY | O_DIRECTORY));
 
 	/* It is still forbidden to write in file1_s1d3. */
-	ASSERT_EQ(EACCES, test_open(file1_s1d3, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d3, O_WRONLY));
 	/* Readdir access is still allowed. */
-	ASSERT_EQ(0, test_open(dir_s1d3, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(0, test_open(dir_s1d3, O_RDONLY | O_DIRECTORY));
 
 	/*
 	 * Now, dir_s1d3 get a new rule tied to it, only allowing
@@ -1379,21 +1379,21 @@ TEST_F_FORK(layout1, inherit_subset)
 	 */
 
 	/* Same tests and results as above. */
-	ASSERT_EQ(EACCES, test_open(file1_s1d1, O_WRONLY));
-	ASSERT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d1, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY | O_DIRECTORY));
 
 	/* It is still forbidden to write in file1_s1d2. */
-	ASSERT_EQ(EACCES, test_open(file1_s1d2, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d2, O_WRONLY));
 	/* Readdir access is still allowed. */
-	ASSERT_EQ(0, test_open(dir_s1d2, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(0, test_open(dir_s1d2, O_RDONLY | O_DIRECTORY));
 
 	/* It is still forbidden to write in file1_s1d3. */
-	ASSERT_EQ(EACCES, test_open(file1_s1d3, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d3, O_WRONLY));
 	/*
 	 * Readdir of dir_s1d3 is still allowed because of the OR policy inside
 	 * the same layer.
 	 */
-	ASSERT_EQ(0, test_open(dir_s1d3, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(0, test_open(dir_s1d3, O_RDONLY | O_DIRECTORY));
 }
 
 TEST_F_FORK(layout1, inherit_superset)
@@ -1410,11 +1410,11 @@ TEST_F_FORK(layout1, inherit_superset)
 	enforce_ruleset(_metadata, ruleset_fd);
 
 	/* Readdir access is denied for dir_s1d2. */
-	ASSERT_EQ(EACCES, test_open(dir_s1d2, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(EACCES, test_open(dir_s1d2, O_RDONLY | O_DIRECTORY));
 	/* Readdir access is allowed for dir_s1d3. */
-	ASSERT_EQ(0, test_open(dir_s1d3, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(0, test_open(dir_s1d3, O_RDONLY | O_DIRECTORY));
 	/* File access is allowed for file1_s1d3. */
-	ASSERT_EQ(0, test_open(file1_s1d3, O_RDONLY));
+	EXPECT_EQ(0, test_open(file1_s1d3, O_RDONLY));
 
 	/* Now dir_s1d2, parent of dir_s1d3, gets a new rule tied to it. */
 	add_path_beneath(_metadata, ruleset_fd,
@@ -1425,11 +1425,11 @@ TEST_F_FORK(layout1, inherit_superset)
 	EXPECT_EQ(0, close(ruleset_fd));
 
 	/* Readdir access is still denied for dir_s1d2. */
-	ASSERT_EQ(EACCES, test_open(dir_s1d2, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(EACCES, test_open(dir_s1d2, O_RDONLY | O_DIRECTORY));
 	/* Readdir access is still allowed for dir_s1d3. */
-	ASSERT_EQ(0, test_open(dir_s1d3, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(0, test_open(dir_s1d3, O_RDONLY | O_DIRECTORY));
 	/* File access is still allowed for file1_s1d3. */
-	ASSERT_EQ(0, test_open(file1_s1d3, O_RDONLY));
+	EXPECT_EQ(0, test_open(file1_s1d3, O_RDONLY));
 }
 
 TEST_F_FORK(layout0, max_layers)
@@ -1450,7 +1450,7 @@ TEST_F_FORK(layout0, max_layers)
 	for (i = 0; i < 2; i++) {
 		err = landlock_restrict_self(ruleset_fd, 0);
 		ASSERT_EQ(-1, err);
-		ASSERT_EQ(E2BIG, errno);
+		EXPECT_EQ(E2BIG, errno);
 	}
 	EXPECT_EQ(0, close(ruleset_fd));
 }
@@ -1464,20 +1464,20 @@ TEST_F_FORK(layout1, empty_or_same_ruleset)
 	ruleset_fd =
 		landlock_create_ruleset(&ruleset_attr, sizeof(ruleset_attr), 0);
 	ASSERT_EQ(-1, ruleset_fd);
-	ASSERT_EQ(ENOMSG, errno);
+	EXPECT_EQ(ENOMSG, errno);
 
 	/* Enforces policy which denies read access to all files. */
 	enforce_fs(_metadata, LANDLOCK_ACCESS_FS_READ_FILE, NULL);
 
-	ASSERT_EQ(EACCES, test_open(file1_s1d1, O_RDONLY));
-	ASSERT_EQ(0, test_open(dir_s1d1, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d1, O_RDONLY));
+	EXPECT_EQ(0, test_open(dir_s1d1, O_RDONLY));
 
 	/* Nests a policy which denies read access to all directories. */
 	ruleset_fd =
 		create_ruleset(_metadata, LANDLOCK_ACCESS_FS_READ_DIR, NULL);
 	enforce_ruleset(_metadata, ruleset_fd);
-	ASSERT_EQ(EACCES, test_open(file1_s1d1, O_RDONLY));
-	ASSERT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d1, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY));
 
 	/* Enforces a second time with the same ruleset. */
 	enforce_ruleset(_metadata, ruleset_fd);
@@ -1501,13 +1501,13 @@ TEST_F_FORK(layout1, rule_on_mountpoint)
 
 	enforce_fs(_metadata, ACCESS_RW, rules);
 
-	ASSERT_EQ(0, test_open(dir_s1d1, O_RDONLY));
+	EXPECT_EQ(0, test_open(dir_s1d1, O_RDONLY));
 
-	ASSERT_EQ(EACCES, test_open(dir_s2d1, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(dir_s2d1, O_RDONLY));
 
-	ASSERT_EQ(EACCES, test_open(dir_s3d1, O_RDONLY));
-	ASSERT_EQ(0, test_open(dir_s3d2, O_RDONLY));
-	ASSERT_EQ(0, test_open(dir_s3d3, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(dir_s3d1, O_RDONLY));
+	EXPECT_EQ(0, test_open(dir_s3d2, O_RDONLY));
+	EXPECT_EQ(0, test_open(dir_s3d3, O_RDONLY));
 }
 
 TEST_F_FORK(layout1, rule_over_mountpoint)
@@ -1527,13 +1527,13 @@ TEST_F_FORK(layout1, rule_over_mountpoint)
 
 	enforce_fs(_metadata, ACCESS_RW, rules);
 
-	ASSERT_EQ(0, test_open(dir_s1d1, O_RDONLY));
+	EXPECT_EQ(0, test_open(dir_s1d1, O_RDONLY));
 
-	ASSERT_EQ(EACCES, test_open(dir_s2d1, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(dir_s2d1, O_RDONLY));
 
-	ASSERT_EQ(0, test_open(dir_s3d1, O_RDONLY));
-	ASSERT_EQ(0, test_open(dir_s3d2, O_RDONLY));
-	ASSERT_EQ(0, test_open(dir_s3d3, O_RDONLY));
+	EXPECT_EQ(0, test_open(dir_s3d1, O_RDONLY));
+	EXPECT_EQ(0, test_open(dir_s3d2, O_RDONLY));
+	EXPECT_EQ(0, test_open(dir_s3d3, O_RDONLY));
 }
 
 /*
@@ -1553,15 +1553,15 @@ TEST_F_FORK(layout1, rule_over_root_allow_then_deny)
 	enforce_fs(_metadata, ACCESS_RW, rules);
 
 	/* Checks allowed access. */
-	ASSERT_EQ(0, test_open("/", O_RDONLY));
-	ASSERT_EQ(0, test_open(dir_s1d1, O_RDONLY));
+	EXPECT_EQ(0, test_open("/", O_RDONLY));
+	EXPECT_EQ(0, test_open(dir_s1d1, O_RDONLY));
 
 	rules[0].access = LANDLOCK_ACCESS_FS_READ_FILE;
 	enforce_fs(_metadata, ACCESS_RW, rules);
 
 	/* Checks denied access (on a directory). */
-	ASSERT_EQ(EACCES, test_open("/", O_RDONLY));
-	ASSERT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open("/", O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY));
 }
 
 TEST_F_FORK(layout1, rule_over_root_deny)
@@ -1577,8 +1577,8 @@ TEST_F_FORK(layout1, rule_over_root_deny)
 	enforce_fs(_metadata, ACCESS_RW, rules);
 
 	/* Checks denied access (on a directory). */
-	ASSERT_EQ(EACCES, test_open("/", O_RDONLY));
-	ASSERT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open("/", O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY));
 }
 
 TEST_F_FORK(layout1, rule_inside_mount_ns)
@@ -1601,8 +1601,8 @@ TEST_F_FORK(layout1, rule_inside_mount_ns)
 
 	enforce_fs(_metadata, ACCESS_RW, rules);
 
-	ASSERT_EQ(0, test_open("s3d3", O_RDONLY));
-	ASSERT_EQ(EACCES, test_open("/", O_RDONLY));
+	EXPECT_EQ(0, test_open("s3d3", O_RDONLY));
+	EXPECT_EQ(EACCES, test_open("/", O_RDONLY));
 }
 
 TEST_F_FORK(layout1, mount_and_pivot)
@@ -1619,9 +1619,9 @@ TEST_F_FORK(layout1, mount_and_pivot)
 
 	set_cap(_metadata, CAP_SYS_ADMIN);
 	ASSERT_EQ(-1, mount(NULL, dir_s3d2, NULL, MS_RDONLY, NULL));
-	ASSERT_EQ(EPERM, errno);
+	EXPECT_EQ(EPERM, errno);
 	ASSERT_EQ(-1, syscall(__NR_pivot_root, dir_s3d2, dir_s3d3));
-	ASSERT_EQ(EPERM, errno);
+	EXPECT_EQ(EPERM, errno);
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 }
 
@@ -1651,7 +1651,7 @@ TEST_F_FORK(layout1, move_mount)
 	set_cap(_metadata, CAP_SYS_ADMIN);
 	ASSERT_EQ(-1, syscall(__NR_move_mount, AT_FDCWD, dir_s3d2, AT_FDCWD,
 			      dir_s1d2, 0));
-	ASSERT_EQ(EPERM, errno);
+	EXPECT_EQ(EPERM, errno);
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 }
 
@@ -1691,16 +1691,16 @@ TEST_F_FORK(layout1, topology_changes_with_net_and_fs)
 	/* Mount, remount, move_mount, umount, and pivot_root checks. */
 	set_cap(_metadata, CAP_SYS_ADMIN);
 	ASSERT_EQ(-1, mount_opt(&mnt_tmp, dir_s1d2));
-	ASSERT_EQ(EPERM, errno);
+	EXPECT_EQ(EPERM, errno);
 	ASSERT_EQ(-1, mount(NULL, dir_s3d2, NULL, MS_PRIVATE | MS_REC, NULL));
-	ASSERT_EQ(EPERM, errno);
+	EXPECT_EQ(EPERM, errno);
 	ASSERT_EQ(-1, syscall(__NR_move_mount, AT_FDCWD, dir_s3d2, AT_FDCWD,
 			      dir_s2d2, 0));
-	ASSERT_EQ(EPERM, errno);
+	EXPECT_EQ(EPERM, errno);
 	ASSERT_EQ(-1, umount(dir_s3d2));
-	ASSERT_EQ(EPERM, errno);
+	EXPECT_EQ(EPERM, errno);
 	ASSERT_EQ(-1, syscall(__NR_pivot_root, dir_s3d2, dir_s3d3));
-	ASSERT_EQ(EPERM, errno);
+	EXPECT_EQ(EPERM, errno);
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 }
 
@@ -1731,10 +1731,10 @@ TEST_F_FORK(layout1, release_inodes)
 	enforce_ruleset(_metadata, ruleset_fd);
 	EXPECT_EQ(0, close(ruleset_fd));
 
-	ASSERT_EQ(0, test_open(file1_s1d1, O_RDONLY));
-	ASSERT_EQ(EACCES, test_open(dir_s3d2, O_RDONLY));
+	EXPECT_EQ(0, test_open(file1_s1d1, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(dir_s3d2, O_RDONLY));
 	/* This dir_s3d3 would not be allowed and does not exist anyway. */
-	ASSERT_EQ(ENOENT, test_open(dir_s3d3, O_RDONLY));
+	EXPECT_EQ(ENOENT, test_open(dir_s3d3, O_RDONLY));
 }
 
 /*
@@ -1767,13 +1767,13 @@ TEST_F_FORK(layout1, covered_rule)
 	ASSERT_EQ(0, mount_opt(&mnt_tmp, dir_s3d2));
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 
-	ASSERT_EQ(0, test_open(dir_s3d2, O_RDONLY));
+	EXPECT_EQ(0, test_open(dir_s3d2, O_RDONLY));
 
 	enforce_ruleset(_metadata, ruleset_fd);
 	EXPECT_EQ(0, close(ruleset_fd));
 
 	/* Checks that access to the new mount point is denied. */
-	ASSERT_EQ(EACCES, test_open(dir_s3d2, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(dir_s3d2, O_RDONLY));
 }
 
 enum relative_access {
@@ -1860,35 +1860,35 @@ static void test_relative_path(struct __test_metadata *const _metadata,
 		break;
 	}
 
-	ASSERT_EQ((rel == REL_CHROOT_CHDIR) ? 0 : EACCES,
+	EXPECT_EQ((rel == REL_CHROOT_CHDIR) ? 0 : EACCES,
 		  test_open_rel(dirfd, "..", O_RDONLY));
-	ASSERT_EQ(0, test_open_rel(dirfd, ".", O_RDONLY));
+	EXPECT_EQ(0, test_open_rel(dirfd, ".", O_RDONLY));
 
 	if (rel == REL_CHROOT_ONLY) {
 		/* The current directory is dir_s2d2. */
-		ASSERT_EQ(0, test_open_rel(dirfd, "./s2d3", O_RDONLY));
+		EXPECT_EQ(0, test_open_rel(dirfd, "./s2d3", O_RDONLY));
 	} else {
 		/* The current directory is dir_s1d2. */
-		ASSERT_EQ(0, test_open_rel(dirfd, "./s1d3", O_RDONLY));
+		EXPECT_EQ(0, test_open_rel(dirfd, "./s1d3", O_RDONLY));
 	}
 
 	if (rel == REL_CHROOT_ONLY || rel == REL_CHROOT_CHDIR) {
 		/* Checks the root dir_s1d2. */
-		ASSERT_EQ(0, test_open_rel(dirfd, "/..", O_RDONLY));
-		ASSERT_EQ(0, test_open_rel(dirfd, "/", O_RDONLY));
-		ASSERT_EQ(0, test_open_rel(dirfd, "/f1", O_RDONLY));
-		ASSERT_EQ(0, test_open_rel(dirfd, "/s1d3", O_RDONLY));
+		EXPECT_EQ(0, test_open_rel(dirfd, "/..", O_RDONLY));
+		EXPECT_EQ(0, test_open_rel(dirfd, "/", O_RDONLY));
+		EXPECT_EQ(0, test_open_rel(dirfd, "/f1", O_RDONLY));
+		EXPECT_EQ(0, test_open_rel(dirfd, "/s1d3", O_RDONLY));
 	}
 
 	if (rel != REL_CHROOT_CHDIR) {
-		ASSERT_EQ(EACCES, test_open_rel(dirfd, "../../s1d1", O_RDONLY));
-		ASSERT_EQ(0, test_open_rel(dirfd, "../../s1d1/s1d2", O_RDONLY));
-		ASSERT_EQ(0, test_open_rel(dirfd, "../../s1d1/s1d2/s1d3",
+		EXPECT_EQ(EACCES, test_open_rel(dirfd, "../../s1d1", O_RDONLY));
+		EXPECT_EQ(0, test_open_rel(dirfd, "../../s1d1/s1d2", O_RDONLY));
+		EXPECT_EQ(0, test_open_rel(dirfd, "../../s1d1/s1d2/s1d3",
 					   O_RDONLY));
 
-		ASSERT_EQ(EACCES, test_open_rel(dirfd, "../../s2d1", O_RDONLY));
-		ASSERT_EQ(0, test_open_rel(dirfd, "../../s2d1/s2d2", O_RDONLY));
-		ASSERT_EQ(0, test_open_rel(dirfd, "../../s2d1/s2d2/s2d3",
+		EXPECT_EQ(EACCES, test_open_rel(dirfd, "../../s2d1", O_RDONLY));
+		EXPECT_EQ(0, test_open_rel(dirfd, "../../s2d1/s2d2", O_RDONLY));
+		EXPECT_EQ(0, test_open_rel(dirfd, "../../s2d1/s2d2/s2d3",
 					   O_RDONLY));
 	}
 
@@ -1960,7 +1960,7 @@ static void test_execute(struct __test_metadata *const _metadata, const int err,
 	}
 	ASSERT_EQ(child, waitpid(child, &status, 0));
 	ASSERT_EQ(1, WIFEXITED(status));
-	ASSERT_EQ(err ? 2 : 0, WEXITSTATUS(status))
+	EXPECT_EQ(err ? 2 : 0, WEXITSTATUS(status))
 	{
 		TH_LOG("Unexpected return code for \"%s\"", path);
 	};
@@ -2002,18 +2002,18 @@ TEST_F_FORK(layout1, execute)
 
 	enforce_fs(_metadata, rules[0].access, rules);
 
-	ASSERT_EQ(0, test_open(dir_s1d1, O_RDONLY));
-	ASSERT_EQ(0, test_open(file1_s1d1, O_RDONLY));
+	EXPECT_EQ(0, test_open(dir_s1d1, O_RDONLY));
+	EXPECT_EQ(0, test_open(file1_s1d1, O_RDONLY));
 	test_execute(_metadata, EACCES, file1_s1d1);
 	test_check_exec(_metadata, EACCES, file1_s1d1);
 
-	ASSERT_EQ(0, test_open(dir_s1d2, O_RDONLY));
-	ASSERT_EQ(0, test_open(file1_s1d2, O_RDONLY));
+	EXPECT_EQ(0, test_open(dir_s1d2, O_RDONLY));
+	EXPECT_EQ(0, test_open(file1_s1d2, O_RDONLY));
 	test_execute(_metadata, 0, file1_s1d2);
 	test_check_exec(_metadata, 0, file1_s1d2);
 
-	ASSERT_EQ(0, test_open(dir_s1d3, O_RDONLY));
-	ASSERT_EQ(0, test_open(file1_s1d3, O_RDONLY));
+	EXPECT_EQ(0, test_open(dir_s1d3, O_RDONLY));
+	EXPECT_EQ(0, test_open(file1_s1d3, O_RDONLY));
 	test_execute(_metadata, 0, file1_s1d3);
 	test_check_exec(_metadata, 0, file1_s1d3);
 }
@@ -2092,7 +2092,7 @@ TEST_F_FORK(layout1, umount_sandboxer)
 	EXPECT_EQ(1, write(pipe_parent[1], ".", 1));
 	ASSERT_EQ(child, waitpid(child, &status, 0));
 	ASSERT_EQ(1, WIFEXITED(status));
-	ASSERT_EQ(0, WEXITSTATUS(status));
+	EXPECT_EQ(0, WEXITSTATUS(status));
 }
 
 TEST_F_FORK(layout1, link)
@@ -2119,15 +2119,15 @@ TEST_F_FORK(layout1, link)
 	enforce_fs(_metadata, layer1[0].access, layer1);
 
 	ASSERT_EQ(-1, link(file2_s1d1, file1_s1d1));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 
 	/* Denies linking because of reparenting. */
 	ASSERT_EQ(-1, link(file1_s2d1, file1_s1d2));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 	ASSERT_EQ(-1, link(file2_s1d2, file1_s1d3));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 	ASSERT_EQ(-1, link(file2_s1d3, file1_s1d2));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 
 	ASSERT_EQ(0, link(file2_s1d2, file1_s1d2));
 	ASSERT_EQ(0, link(file2_s1d3, file1_s1d3));
@@ -2196,47 +2196,47 @@ TEST_F_FORK(layout1, rename_file)
 	 * but to a different directory (which also allows file removal).
 	 */
 	ASSERT_EQ(-1, rename(file1_s2d3, file1_s1d3));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, file1_s2d3, AT_FDCWD, file1_s1d3,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, file1_s2d3, AT_FDCWD, dir_s1d3,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 
 	/*
 	 * Tries to replace a file, from a directory that denies file removal,
 	 * to a different directory (which allows file removal).
 	 */
 	ASSERT_EQ(-1, rename(file1_s2d1, file1_s1d3));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, file1_s2d1, AT_FDCWD, file1_s1d3,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, dir_s2d2, AT_FDCWD, file1_s1d3,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 
 	/* Exchanges files and directories that partially allow removal. */
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, dir_s2d2, AT_FDCWD, file1_s2d1,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	/* Checks that file1_s2d1 cannot be removed (instead of ENOTDIR). */
 	ASSERT_EQ(-1, rename(dir_s2d2, file1_s2d1));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, file1_s2d1, AT_FDCWD, dir_s2d2,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	/* Checks that file1_s1d1 cannot be removed (instead of EISDIR). */
 	ASSERT_EQ(-1, rename(file1_s1d1, dir_s1d2));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 
 	/* Renames files with different parents. */
 	ASSERT_EQ(-1, rename(file1_s2d2, file1_s1d2));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 	ASSERT_EQ(0, unlink(file1_s1d3));
 	ASSERT_EQ(-1, rename(file1_s2d1, file1_s1d3));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 
 	/* Exchanges and renames files with same parent. */
 	ASSERT_EQ(0, renameat2(AT_FDCWD, file2_s2d3, AT_FDCWD, file1_s2d3,
@@ -2444,12 +2444,12 @@ TEST_F_FORK(layout1, rename_dir)
 	/* Exchanges and renames directory to a different parent. */
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, dir_s2d3, AT_FDCWD, dir_s1d3,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 	ASSERT_EQ(-1, rename(dir_s2d3, dir_s1d3));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, file1_s2d2, AT_FDCWD, dir_s1d3,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 
 	/*
 	 * Exchanges directory to the same parent, which doesn't allow
@@ -2457,16 +2457,16 @@ TEST_F_FORK(layout1, rename_dir)
 	 */
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, dir_s1d1, AT_FDCWD, dir_s2d1,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	/* Checks that dir_s1d2 cannot be removed (instead of ENOTDIR). */
 	ASSERT_EQ(-1, rename(dir_s1d2, file1_s1d1));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, file1_s1d1, AT_FDCWD, dir_s1d2,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	/* Checks that dir_s1d2 cannot be removed (instead of EISDIR). */
 	ASSERT_EQ(-1, rename(file1_s1d1, dir_s1d2));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 
 	/*
 	 * Exchanges and renames directory to the same parent, which allows
@@ -2497,22 +2497,22 @@ TEST_F_FORK(layout1, reparent_refer)
 	enforce_fs(_metadata, LANDLOCK_ACCESS_FS_REFER, layer1);
 
 	ASSERT_EQ(-1, rename(dir_s1d2, dir_s2d1));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 	ASSERT_EQ(-1, rename(dir_s1d2, dir_s2d2));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 	ASSERT_EQ(-1, rename(dir_s1d2, dir_s2d3));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 
 	ASSERT_EQ(-1, rename(dir_s1d3, dir_s2d1));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 	ASSERT_EQ(-1, rename(dir_s1d3, dir_s2d2));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 	/*
 	 * Moving should only be allowed when the source and the destination
 	 * parent directory have REFER.
 	 */
 	ASSERT_EQ(-1, rename(dir_s1d3, dir_s2d3));
-	ASSERT_EQ(ENOTEMPTY, errno);
+	EXPECT_EQ(ENOTEMPTY, errno);
 	ASSERT_EQ(0, unlink(file1_s2d3));
 	ASSERT_EQ(0, unlink(file2_s2d3));
 	ASSERT_EQ(0, rename(dir_s1d3, dir_s2d3));
@@ -2711,27 +2711,27 @@ TEST_F_FORK(layout1, reparent_link)
 
 	/* Denies linking because of missing MAKE_REG. */
 	ASSERT_EQ(-1, link(file2_s1d1, file1_s1d1));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	/* Denies linking because of missing source and destination REFER. */
 	ASSERT_EQ(-1, link(file1_s2d1, file1_s1d2));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 	/* Denies linking because of missing source REFER. */
 	ASSERT_EQ(-1, link(file1_s2d1, file1_s1d3));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 
 	/* Denies linking because of missing MAKE_REG. */
 	ASSERT_EQ(-1, link(file1_s2d2, file1_s1d1));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	/* Denies linking because of missing destination REFER. */
 	ASSERT_EQ(-1, link(file1_s2d2, file1_s1d2));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 
 	/* Allows linking because of REFER and MAKE_REG. */
 	ASSERT_EQ(0, link(file1_s2d2, file1_s1d3));
 	ASSERT_EQ(0, unlink(file1_s2d2));
 	/* Reverse linking denied because of missing MAKE_REG. */
 	ASSERT_EQ(-1, link(file1_s1d3, file1_s2d2));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(0, unlink(file1_s2d3));
 	/* Checks reverse linking. */
 	ASSERT_EQ(0, link(file1_s1d3, file1_s2d3));
@@ -2745,9 +2745,9 @@ TEST_F_FORK(layout1, reparent_link)
 	ASSERT_EQ(0, unlink(file1_s1d3));
 
 	ASSERT_EQ(-1, link(file2_s1d2, file1_s1d3));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 	ASSERT_EQ(-1, link(file2_s1d3, file1_s1d2));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 
 	ASSERT_EQ(0, link(file2_s1d2, file1_s1d2));
 	ASSERT_EQ(0, link(file2_s1d3, file1_s1d3));
@@ -2786,57 +2786,57 @@ TEST_F_FORK(layout1, reparent_rename)
 	/* Denies renaming because of missing MAKE_REG. */
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, file2_s1d1, AT_FDCWD, file1_s1d1,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, file1_s1d1, AT_FDCWD, file2_s1d1,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(0, unlink(file1_s1d1));
 	ASSERT_EQ(-1, rename(file2_s1d1, file1_s1d1));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	/* Even denies same file exchange. */
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, file2_s1d1, AT_FDCWD, file2_s1d1,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 
 	/* Denies renaming because of missing source and destination REFER. */
 	ASSERT_EQ(-1, rename(file1_s2d1, file1_s1d2));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 	/*
 	 * Denies renaming because of missing MAKE_REG, source and destination
 	 * REFER.
 	 */
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, file1_s2d1, AT_FDCWD, file2_s1d1,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, file2_s1d1, AT_FDCWD, file1_s2d1,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 
 	/* Denies renaming because of missing source REFER. */
 	ASSERT_EQ(-1, rename(file1_s2d1, file1_s1d3));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 	/* Denies renaming because of missing MAKE_REG. */
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, file1_s2d1, AT_FDCWD, file2_s1d3,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 
 	/* Denies renaming because of missing MAKE_REG. */
 	ASSERT_EQ(-1, rename(file1_s2d2, file1_s1d1));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	/* Denies renaming because of missing destination REFER*/
 	ASSERT_EQ(-1, rename(file1_s2d2, file1_s1d2));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 
 	/* Denies exchange because of one missing MAKE_REG. */
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, file1_s2d2, AT_FDCWD, file2_s1d3,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	/* Allows renaming because of REFER and MAKE_REG. */
 	ASSERT_EQ(0, rename(file1_s2d2, file1_s1d3));
 
 	/* Reverse renaming denied because of missing MAKE_REG. */
 	ASSERT_EQ(-1, rename(file1_s1d3, file1_s2d2));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(0, unlink(file1_s2d3));
 	ASSERT_EQ(0, rename(file1_s1d3, file1_s2d3));
 
@@ -2868,17 +2868,17 @@ TEST_F_FORK(layout1, reparent_rename)
 	 */
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, file1_s2d3, AT_FDCWD, dir_s1d3,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, dir_s1d3, AT_FDCWD, file1_s2d3,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 	ASSERT_EQ(-1, rename(file1_s2d3, dir_s1d3));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 
 	ASSERT_EQ(-1, rename(file2_s1d2, file1_s1d3));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 	ASSERT_EQ(-1, rename(file2_s1d3, file1_s1d2));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 
 	/* Renaming in the same directory is always allowed. */
 	ASSERT_EQ(0, rename(file2_s1d2, file1_s1d2));
@@ -2887,12 +2887,12 @@ TEST_F_FORK(layout1, reparent_rename)
 	ASSERT_EQ(0, unlink(file1_s1d2));
 	/* Denies because of missing source MAKE_REG and destination REFER. */
 	ASSERT_EQ(-1, rename(dir_s2d3, file1_s1d2));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 
 	ASSERT_EQ(0, unlink(file1_s1d3));
 	/* Denies because of missing source MAKE_REG and REFER. */
 	ASSERT_EQ(-1, rename(dir_s2d2, file1_s1d3));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 }
 
 static void
@@ -2976,14 +2976,14 @@ TEST_F_FORK(layout1, reparent_exdev_layers_rename1)
 	 * MAKE_DIR is not tied to dir_s2d2.
 	 */
 	ASSERT_EQ(-1, rename(dir_s1d3, file1_s2d2));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 
 	/*
 	 * Moving the dir_s1d3 directory below dir_s2d3 is forbidden because it
 	 * would grants MAKE_REG and MAKE_DIR rights to it.
 	 */
 	ASSERT_EQ(-1, rename(dir_s1d3, file1_s2d3));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 
 	/*
 	 * Moving the file2_s1d3 file below dir_s2d3 is denied because the
@@ -2991,7 +2991,7 @@ TEST_F_FORK(layout1, reparent_exdev_layers_rename1)
 	 * default.
 	 */
 	ASSERT_EQ(-1, rename(file2_s1d3, file1_s2d3));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 }
 
 TEST_F_FORK(layout1, reparent_exdev_layers_rename2)
@@ -3000,42 +3000,42 @@ TEST_F_FORK(layout1, reparent_exdev_layers_rename2)
 
 	/* Checks EACCES predominance over EXDEV. */
 	ASSERT_EQ(-1, rename(file1_s1d1, file1_s2d2));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(-1, rename(file1_s1d2, file1_s2d2));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(-1, rename(file1_s1d1, file1_s2d3));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 	/* Modify layout! */
 	ASSERT_EQ(0, rename(file1_s1d2, file1_s2d3));
 
 	/* Without REFER source. */
 	ASSERT_EQ(-1, rename(dir_s1d1, file1_s2d2));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 	ASSERT_EQ(-1, rename(dir_s1d2, file1_s2d2));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 
 	reparent_exdev_layers_enforce2(_metadata);
 
 	/* Checks EACCES predominance over EXDEV. */
 	ASSERT_EQ(-1, rename(file1_s1d1, file1_s2d2));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	/* Checks with actual file2_s1d2. */
 	ASSERT_EQ(-1, rename(file2_s1d2, file1_s2d2));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(-1, rename(file1_s1d1, file1_s2d3));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 	/*
 	 * Modifying the layout is now denied because the second layer does not
 	 * handle REFER, which is always denied by default.
 	 */
 	ASSERT_EQ(-1, rename(file2_s1d2, file1_s2d3));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 
 	/* Without REFER source, EACCES wins over EXDEV. */
 	ASSERT_EQ(-1, rename(dir_s1d1, file1_s2d2));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(-1, rename(dir_s1d2, file1_s2d2));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 }
 
 TEST_F_FORK(layout1, reparent_exdev_layers_exchange1)
@@ -3053,10 +3053,10 @@ TEST_F_FORK(layout1, reparent_exdev_layers_exchange1)
 	/* Error predominance with file exchange: returns EXDEV and EACCES. */
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, file1_s1d1, AT_FDCWD, file1_s2d3,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, file1_s2d3, AT_FDCWD, file1_s1d1,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 
 	/*
 	 * Checks with directories which creation could be allowed, but denied
@@ -3064,10 +3064,10 @@ TEST_F_FORK(layout1, reparent_exdev_layers_exchange1)
 	 */
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, dir_file1_s1d2, AT_FDCWD,
 				dir_file2_s2d3, RENAME_EXCHANGE));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, dir_file2_s2d3, AT_FDCWD,
 				dir_file1_s1d2, RENAME_EXCHANGE));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 
 	/* Checks with same access rights. */
 	ASSERT_EQ(0, renameat2(AT_FDCWD, dir_s1d3, AT_FDCWD, dir_s2d3,
@@ -3100,46 +3100,46 @@ TEST_F_FORK(layout1, reparent_exdev_layers_exchange1)
 	 */
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, dir_file2_s2d3, AT_FDCWD, file1_s2d2,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, file1_s2d2, AT_FDCWD, dir_file2_s2d3,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 
 	reparent_exdev_layers_enforce2(_metadata);
 
 	/* Error predominance with file exchange: returns EXDEV and EACCES. */
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, file1_s1d1, AT_FDCWD, file1_s2d3,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, file1_s2d3, AT_FDCWD, file1_s1d1,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 
 	/* Checks with directories which creation is now denied. */
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, dir_file1_s1d2, AT_FDCWD,
 				dir_file2_s2d3, RENAME_EXCHANGE));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, dir_file2_s2d3, AT_FDCWD,
 				dir_file1_s1d2, RENAME_EXCHANGE));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 
 	/* Checks with different (child-only) access rights. */
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, dir_s1d3, AT_FDCWD, dir_s2d3,
 				RENAME_EXCHANGE));
 	/* Denied because of MAKE_DIR. */
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, dir_s2d3, AT_FDCWD, dir_s1d3,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 
 	/* Checks with different (child-only) access rights. */
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, dir_s2d3, AT_FDCWD, dir_file1_s1d2,
 				RENAME_EXCHANGE));
 	/* Denied because of MAKE_DIR. */
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, dir_file1_s1d2, AT_FDCWD, dir_s2d3,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 
 	/* See layout1.reparent_exdev_layers_exchange2 for complement. */
 }
@@ -3157,10 +3157,10 @@ TEST_F_FORK(layout1, reparent_exdev_layers_exchange2)
 	/* Checks that exchange between file and directory are consistent. */
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, file1_s2d2, AT_FDCWD, dir_file2_s2d3,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, dir_file2_s2d3, AT_FDCWD, file1_s2d2,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 }
 
 TEST_F_FORK(layout1, reparent_exdev_layers_exchange3)
@@ -3181,10 +3181,10 @@ TEST_F_FORK(layout1, reparent_exdev_layers_exchange3)
 			       RENAME_EXCHANGE));
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, file1_s2d2, AT_FDCWD, dir_file2_s2d3,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, dir_file2_s2d3, AT_FDCWD, file1_s2d2,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 }
 
 TEST_F_FORK(layout1, reparent_remove)
@@ -3214,23 +3214,23 @@ TEST_F_FORK(layout1, reparent_remove)
 
 	/* Access denied because of wrong/swapped remove file/dir. */
 	ASSERT_EQ(-1, rename(file1_s1d1, dir_s2d2));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(-1, rename(dir_s2d2, file1_s1d1));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, file1_s1d1, AT_FDCWD, dir_s2d2,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, file1_s1d1, AT_FDCWD, dir_s2d3,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 
 	/* Access allowed thanks to the matching rights. */
 	ASSERT_EQ(-1, rename(file1_s2d1, dir_s1d2));
-	ASSERT_EQ(EISDIR, errno);
+	EXPECT_EQ(EISDIR, errno);
 	ASSERT_EQ(-1, rename(dir_s1d2, file1_s2d1));
-	ASSERT_EQ(ENOTDIR, errno);
+	EXPECT_EQ(ENOTDIR, errno);
 	ASSERT_EQ(-1, rename(dir_s1d3, file1_s2d1));
-	ASSERT_EQ(ENOTDIR, errno);
+	EXPECT_EQ(ENOTDIR, errno);
 	ASSERT_EQ(0, unlink(file1_s2d1));
 	ASSERT_EQ(0, unlink(file1_s1d3));
 	ASSERT_EQ(0, unlink(file2_s1d3));
@@ -3242,7 +3242,7 @@ TEST_F_FORK(layout1, reparent_remove)
 			       RENAME_EXCHANGE));
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, file1_s2d2, AT_FDCWD, dir_s1d3,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 }
 
 TEST_F_FORK(layout1, reparent_dom_superset)
@@ -3283,13 +3283,13 @@ TEST_F_FORK(layout1, reparent_dom_superset)
 		   layer1);
 
 	ASSERT_EQ(-1, rename(file1_s1d2, file1_s2d1));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 	/*
 	 * Moving file1_s1d2 beneath dir_s2d3 would grant it the READ_FILE
 	 * access right.
 	 */
 	ASSERT_EQ(-1, rename(file1_s1d2, file1_s2d3));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 	/*
 	 * Moving file1_s1d2 should be allowed even if dir_s2d2 grants a
 	 * superset of access rights compared to dir_s1d2, because file1_s1d2
@@ -3299,13 +3299,13 @@ TEST_F_FORK(layout1, reparent_dom_superset)
 	ASSERT_EQ(0, rename(file1_s2d2, file1_s1d2));
 
 	ASSERT_EQ(-1, rename(dir_s1d3, file1_s2d1));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 	/*
 	 * Moving dir_s1d3 beneath dir_s2d3 would grant it the MAKE_FIFO access
 	 * right.
 	 */
 	ASSERT_EQ(-1, rename(dir_s1d3, file1_s2d3));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 	/*
 	 * Moving dir_s1d3 should be allowed even if dir_s2d2 grants a superset
 	 * of access rights compared to dir_s1d2, because dir_s1d3 already has
@@ -3322,7 +3322,7 @@ TEST_F_FORK(layout1, reparent_dom_superset)
 	 */
 	ASSERT_EQ(0, rename(file1_s2d3, file2_s1d2));
 	ASSERT_EQ(-1, rename(file2_s1d2, file1_s2d3));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 	ASSERT_EQ(0, unlink(file2_s1d2));
 	ASSERT_EQ(0, unlink(file2_s2d3));
 	/*
@@ -3331,7 +3331,7 @@ TEST_F_FORK(layout1, reparent_dom_superset)
 	 */
 	ASSERT_EQ(0, rename(dir_s2d3, file2_s1d2));
 	ASSERT_EQ(-1, rename(file2_s1d2, dir_s2d3));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 }
 
 TEST_F_FORK(layout1, remove_dir)
@@ -3357,13 +3357,13 @@ TEST_F_FORK(layout1, remove_dir)
 
 	/* dir_s1d2 itself cannot be removed. */
 	ASSERT_EQ(-1, rmdir(dir_s1d2));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(-1, unlinkat(AT_FDCWD, dir_s1d2, AT_REMOVEDIR));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(-1, rmdir(dir_s1d1));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(-1, unlinkat(AT_FDCWD, dir_s1d1, AT_REMOVEDIR));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 }
 
 TEST_F_FORK(layout1, remove_file)
@@ -3379,9 +3379,9 @@ TEST_F_FORK(layout1, remove_file)
 	enforce_fs(_metadata, rules[0].access, rules);
 
 	ASSERT_EQ(-1, unlink(file1_s1d1));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(-1, unlinkat(AT_FDCWD, file1_s1d1, 0));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(0, unlink(file1_s1d2));
 	ASSERT_EQ(0, unlinkat(AT_FDCWD, file1_s1d3, 0));
 }
@@ -3415,11 +3415,11 @@ static void test_make_file(struct __test_metadata *const _metadata,
 	enforce_fs(_metadata, access, rules);
 
 	ASSERT_EQ(-1, mknod(file1_s1d1, mode | 0400, dev));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(-1, link(file2_s1d1, file1_s1d1));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(-1, rename(file2_s1d1, file1_s1d1));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 
 	ASSERT_EQ(0, mknod(file1_s1d2, mode | 0400, dev))
 	{
@@ -3507,11 +3507,11 @@ TEST_F_FORK(layout1, make_sym)
 	enforce_fs(_metadata, rules[0].access, rules);
 
 	ASSERT_EQ(-1, symlink("none", file1_s1d1));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(-1, link(file2_s1d1, file1_s1d1));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(-1, rename(file2_s1d1, file1_s1d1));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 
 	ASSERT_EQ(0, symlink("none", file1_s1d2));
 	ASSERT_EQ(0, link(file1_s1d2, file2_s1d2));
@@ -3542,7 +3542,7 @@ TEST_F_FORK(layout1, make_dir)
 
 	/* Uses file_* as directory names. */
 	ASSERT_EQ(-1, mkdir(file1_s1d1, 0700));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 	ASSERT_EQ(0, mkdir(file1_s1d2, 0700));
 	ASSERT_EQ(0, mkdir(file1_s1d3, 0700));
 }
@@ -3574,8 +3574,8 @@ TEST_F_FORK(layout1, proc_unlinked_file)
 		   LANDLOCK_ACCESS_FS_READ_FILE | LANDLOCK_ACCESS_FS_WRITE_FILE,
 		   rules);
 
-	ASSERT_EQ(EACCES, test_open(file1_s1d2, O_RDWR));
-	ASSERT_EQ(0, test_open(file1_s1d2, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d2, O_RDWR));
+	EXPECT_EQ(0, test_open(file1_s1d2, O_RDONLY));
 	reg_fd = open(file1_s1d2, O_RDONLY | O_CLOEXEC);
 	ASSERT_LE(0, reg_fd);
 	ASSERT_EQ(0, unlink(file1_s1d2));
@@ -3590,7 +3590,7 @@ TEST_F_FORK(layout1, proc_unlinked_file)
 		TH_LOG("Successfully opened /proc/self/fd/%d: %s", reg_fd,
 		       strerror(errno));
 	}
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 
 	EXPECT_EQ(0, close(reg_fd));
 }
@@ -3613,8 +3613,8 @@ TEST_F_FORK(layout1, proc_pipe)
 	enforce_fs(_metadata, rules[0].access, rules);
 
 	/* Checks enforcement for normal files. */
-	ASSERT_EQ(0, test_open(file1_s1d2, O_RDWR));
-	ASSERT_EQ(EACCES, test_open(file1_s1d1, O_RDWR));
+	EXPECT_EQ(0, test_open(file1_s1d2, O_RDWR));
+	EXPECT_EQ(EACCES, test_open(file1_s1d1, O_RDWR));
 
 	/* Checks access to pipes through FD. */
 	ASSERT_EQ(0, pipe2(pipe_fds, O_CLOEXEC));
@@ -4059,7 +4059,7 @@ TEST_F_FORK(ftruncate, open_and_ftruncate_in_different_processes)
 
 	ASSERT_EQ(child, waitpid(child, &status, 0));
 	ASSERT_EQ(1, WIFEXITED(status));
-	ASSERT_EQ(EXIT_SUCCESS, WEXITSTATUS(status));
+	EXPECT_EQ(EXIT_SUCCESS, WEXITSTATUS(status));
 
 	EXPECT_EQ(0, close(socket_fds[0]));
 	EXPECT_EQ(0, close(socket_fds[1]));
@@ -5043,24 +5043,24 @@ FIXTURE_TEARDOWN_PARENT(layout1_bind)
 
 TEST_F_FORK(layout1_bind, no_restriction)
 {
-	ASSERT_EQ(0, test_open(dir_s1d1, O_RDONLY));
-	ASSERT_EQ(0, test_open(file1_s1d1, O_RDONLY));
-	ASSERT_EQ(0, test_open(dir_s1d2, O_RDONLY));
-	ASSERT_EQ(0, test_open(file1_s1d2, O_RDONLY));
-	ASSERT_EQ(0, test_open(dir_s1d3, O_RDONLY));
-	ASSERT_EQ(0, test_open(file1_s1d3, O_RDONLY));
+	EXPECT_EQ(0, test_open(dir_s1d1, O_RDONLY));
+	EXPECT_EQ(0, test_open(file1_s1d1, O_RDONLY));
+	EXPECT_EQ(0, test_open(dir_s1d2, O_RDONLY));
+	EXPECT_EQ(0, test_open(file1_s1d2, O_RDONLY));
+	EXPECT_EQ(0, test_open(dir_s1d3, O_RDONLY));
+	EXPECT_EQ(0, test_open(file1_s1d3, O_RDONLY));
 
-	ASSERT_EQ(0, test_open(dir_s2d1, O_RDONLY));
-	ASSERT_EQ(0, test_open(file1_s2d1, O_RDONLY));
-	ASSERT_EQ(0, test_open(dir_s2d2, O_RDONLY));
-	ASSERT_EQ(0, test_open(file1_s2d2, O_RDONLY));
-	ASSERT_EQ(ENOENT, test_open(dir_s2d3, O_RDONLY));
-	ASSERT_EQ(ENOENT, test_open(file1_s2d3, O_RDONLY));
+	EXPECT_EQ(0, test_open(dir_s2d1, O_RDONLY));
+	EXPECT_EQ(0, test_open(file1_s2d1, O_RDONLY));
+	EXPECT_EQ(0, test_open(dir_s2d2, O_RDONLY));
+	EXPECT_EQ(0, test_open(file1_s2d2, O_RDONLY));
+	EXPECT_EQ(ENOENT, test_open(dir_s2d3, O_RDONLY));
+	EXPECT_EQ(ENOENT, test_open(file1_s2d3, O_RDONLY));
 
-	ASSERT_EQ(0, test_open(bind_dir_s1d3, O_RDONLY));
-	ASSERT_EQ(0, test_open(bind_file1_s1d3, O_RDONLY));
+	EXPECT_EQ(0, test_open(bind_dir_s1d3, O_RDONLY));
+	EXPECT_EQ(0, test_open(bind_file1_s1d3, O_RDONLY));
 
-	ASSERT_EQ(0, test_open(dir_s3d1, O_RDONLY));
+	EXPECT_EQ(0, test_open(dir_s3d1, O_RDONLY));
 }
 
 TEST_F_FORK(layout1_bind, same_content_same_file)
@@ -5117,73 +5117,73 @@ TEST_F_FORK(layout1_bind, same_content_same_file)
 	enforce_fs(_metadata, ACCESS_RW, layer1_parent);
 
 	/* Checks source hierarchy. */
-	ASSERT_EQ(0, test_open(file1_s1d1, O_RDONLY));
-	ASSERT_EQ(EACCES, test_open(file1_s1d1, O_WRONLY));
-	ASSERT_EQ(0, test_open(dir_s1d1, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(0, test_open(file1_s1d1, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d1, O_WRONLY));
+	EXPECT_EQ(0, test_open(dir_s1d1, O_RDONLY | O_DIRECTORY));
 
-	ASSERT_EQ(0, test_open(file1_s1d2, O_RDONLY));
-	ASSERT_EQ(EACCES, test_open(file1_s1d2, O_WRONLY));
-	ASSERT_EQ(0, test_open(dir_s1d2, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(0, test_open(file1_s1d2, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d2, O_WRONLY));
+	EXPECT_EQ(0, test_open(dir_s1d2, O_RDONLY | O_DIRECTORY));
 
 	/* Checks destination hierarchy. */
-	ASSERT_EQ(0, test_open(file1_s2d1, O_RDWR));
-	ASSERT_EQ(0, test_open(dir_s2d1, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(0, test_open(file1_s2d1, O_RDWR));
+	EXPECT_EQ(0, test_open(dir_s2d1, O_RDONLY | O_DIRECTORY));
 
-	ASSERT_EQ(0, test_open(file1_s2d2, O_RDWR));
-	ASSERT_EQ(0, test_open(dir_s2d2, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(0, test_open(file1_s2d2, O_RDWR));
+	EXPECT_EQ(0, test_open(dir_s2d2, O_RDONLY | O_DIRECTORY));
 
 	/* Sets rules for the mount points. */
 	enforce_fs(_metadata, ACCESS_RW, layer2_mount_point);
 
 	/* Checks source hierarchy. */
-	ASSERT_EQ(EACCES, test_open(file1_s1d1, O_RDONLY));
-	ASSERT_EQ(EACCES, test_open(file1_s1d1, O_WRONLY));
-	ASSERT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d1, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d1, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(dir_s1d1, O_RDONLY | O_DIRECTORY));
 
-	ASSERT_EQ(0, test_open(file1_s1d2, O_RDONLY));
-	ASSERT_EQ(EACCES, test_open(file1_s1d2, O_WRONLY));
-	ASSERT_EQ(0, test_open(dir_s1d2, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(0, test_open(file1_s1d2, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d2, O_WRONLY));
+	EXPECT_EQ(0, test_open(dir_s1d2, O_RDONLY | O_DIRECTORY));
 
 	/* Checks destination hierarchy. */
-	ASSERT_EQ(EACCES, test_open(file1_s2d1, O_RDONLY));
-	ASSERT_EQ(EACCES, test_open(file1_s2d1, O_WRONLY));
-	ASSERT_EQ(EACCES, test_open(dir_s2d1, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(EACCES, test_open(file1_s2d1, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s2d1, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(dir_s2d1, O_RDONLY | O_DIRECTORY));
 
-	ASSERT_EQ(0, test_open(file1_s2d2, O_RDWR));
-	ASSERT_EQ(0, test_open(dir_s2d2, O_RDONLY | O_DIRECTORY));
-	ASSERT_EQ(0, test_open(bind_dir_s1d3, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(0, test_open(file1_s2d2, O_RDWR));
+	EXPECT_EQ(0, test_open(dir_s2d2, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(0, test_open(bind_dir_s1d3, O_RDONLY | O_DIRECTORY));
 
 	/* Sets a (shared) rule only on the source. */
 	enforce_fs(_metadata, ACCESS_RW, layer3_source);
 
 	/* Checks source hierarchy. */
-	ASSERT_EQ(EACCES, test_open(file1_s1d2, O_RDONLY));
-	ASSERT_EQ(EACCES, test_open(file1_s1d2, O_WRONLY));
-	ASSERT_EQ(EACCES, test_open(dir_s1d2, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d2, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d2, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(dir_s1d2, O_RDONLY | O_DIRECTORY));
 
-	ASSERT_EQ(0, test_open(file1_s1d3, O_RDONLY));
-	ASSERT_EQ(EACCES, test_open(file1_s1d3, O_WRONLY));
-	ASSERT_EQ(EACCES, test_open(dir_s1d3, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(0, test_open(file1_s1d3, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d3, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(dir_s1d3, O_RDONLY | O_DIRECTORY));
 
 	/* Checks destination hierarchy. */
-	ASSERT_EQ(EACCES, test_open(file1_s2d2, O_RDONLY));
-	ASSERT_EQ(EACCES, test_open(file1_s2d2, O_WRONLY));
-	ASSERT_EQ(EACCES, test_open(dir_s2d2, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(EACCES, test_open(file1_s2d2, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s2d2, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(dir_s2d2, O_RDONLY | O_DIRECTORY));
 
-	ASSERT_EQ(0, test_open(bind_file1_s1d3, O_RDONLY));
-	ASSERT_EQ(EACCES, test_open(bind_file1_s1d3, O_WRONLY));
-	ASSERT_EQ(EACCES, test_open(bind_dir_s1d3, O_RDONLY | O_DIRECTORY));
+	EXPECT_EQ(0, test_open(bind_file1_s1d3, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(bind_file1_s1d3, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(bind_dir_s1d3, O_RDONLY | O_DIRECTORY));
 
 	/* Sets a (shared) rule only on the destination. */
 	enforce_fs(_metadata, ACCESS_RW, layer4_destination);
 
 	/* Checks source hierarchy. */
-	ASSERT_EQ(EACCES, test_open(file1_s1d3, O_RDONLY));
-	ASSERT_EQ(EACCES, test_open(file1_s1d3, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d3, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(file1_s1d3, O_WRONLY));
 
 	/* Checks destination hierarchy. */
-	ASSERT_EQ(EACCES, test_open(bind_file1_s1d3, O_RDONLY));
-	ASSERT_EQ(EACCES, test_open(bind_file1_s1d3, O_WRONLY));
+	EXPECT_EQ(EACCES, test_open(bind_file1_s1d3, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(bind_file1_s1d3, O_WRONLY));
 }
 
 TEST_F_FORK(layout1_bind, reparent_cross_mount)
@@ -5207,15 +5207,15 @@ TEST_F_FORK(layout1_bind, reparent_cross_mount)
 
 	/* Checks basic denied move. */
 	ASSERT_EQ(-1, rename(file1_s1d1, file1_s1d2));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 
 	/* Checks real cross-mount move (Landlock is not involved). */
 	ASSERT_EQ(-1, rename(file1_s2d1, file1_s2d2));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 
 	/* Checks move that will give more accesses. */
 	ASSERT_EQ(-1, rename(file1_s2d2, bind_file1_s1d3));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 
 	/* Checks legitimate downgrade move. */
 	ASSERT_EQ(0, rename(bind_file1_s1d3, file1_s2d2));
@@ -6850,33 +6850,33 @@ TEST_F_FORK(layout2_overlay, no_restriction)
 	if (self->skip_test)
 		SKIP(return, "overlayfs is not supported (test)");
 
-	ASSERT_EQ(0, test_open(lower_fl1, O_RDONLY));
-	ASSERT_EQ(0, test_open(lower_dl1, O_RDONLY));
-	ASSERT_EQ(0, test_open(lower_dl1_fl2, O_RDONLY));
-	ASSERT_EQ(0, test_open(lower_fo1, O_RDONLY));
-	ASSERT_EQ(0, test_open(lower_do1, O_RDONLY));
-	ASSERT_EQ(0, test_open(lower_do1_fo2, O_RDONLY));
-	ASSERT_EQ(0, test_open(lower_do1_fl3, O_RDONLY));
+	EXPECT_EQ(0, test_open(lower_fl1, O_RDONLY));
+	EXPECT_EQ(0, test_open(lower_dl1, O_RDONLY));
+	EXPECT_EQ(0, test_open(lower_dl1_fl2, O_RDONLY));
+	EXPECT_EQ(0, test_open(lower_fo1, O_RDONLY));
+	EXPECT_EQ(0, test_open(lower_do1, O_RDONLY));
+	EXPECT_EQ(0, test_open(lower_do1_fo2, O_RDONLY));
+	EXPECT_EQ(0, test_open(lower_do1_fl3, O_RDONLY));
 
-	ASSERT_EQ(0, test_open(upper_fu1, O_RDONLY));
-	ASSERT_EQ(0, test_open(upper_du1, O_RDONLY));
-	ASSERT_EQ(0, test_open(upper_du1_fu2, O_RDONLY));
-	ASSERT_EQ(0, test_open(upper_fo1, O_RDONLY));
-	ASSERT_EQ(0, test_open(upper_do1, O_RDONLY));
-	ASSERT_EQ(0, test_open(upper_do1_fo2, O_RDONLY));
-	ASSERT_EQ(0, test_open(upper_do1_fu3, O_RDONLY));
+	EXPECT_EQ(0, test_open(upper_fu1, O_RDONLY));
+	EXPECT_EQ(0, test_open(upper_du1, O_RDONLY));
+	EXPECT_EQ(0, test_open(upper_du1_fu2, O_RDONLY));
+	EXPECT_EQ(0, test_open(upper_fo1, O_RDONLY));
+	EXPECT_EQ(0, test_open(upper_do1, O_RDONLY));
+	EXPECT_EQ(0, test_open(upper_do1_fo2, O_RDONLY));
+	EXPECT_EQ(0, test_open(upper_do1_fu3, O_RDONLY));
 
-	ASSERT_EQ(0, test_open(merge_fl1, O_RDONLY));
-	ASSERT_EQ(0, test_open(merge_dl1, O_RDONLY));
-	ASSERT_EQ(0, test_open(merge_dl1_fl2, O_RDONLY));
-	ASSERT_EQ(0, test_open(merge_fu1, O_RDONLY));
-	ASSERT_EQ(0, test_open(merge_du1, O_RDONLY));
-	ASSERT_EQ(0, test_open(merge_du1_fu2, O_RDONLY));
-	ASSERT_EQ(0, test_open(merge_fo1, O_RDONLY));
-	ASSERT_EQ(0, test_open(merge_do1, O_RDONLY));
-	ASSERT_EQ(0, test_open(merge_do1_fo2, O_RDONLY));
-	ASSERT_EQ(0, test_open(merge_do1_fl3, O_RDONLY));
-	ASSERT_EQ(0, test_open(merge_do1_fu3, O_RDONLY));
+	EXPECT_EQ(0, test_open(merge_fl1, O_RDONLY));
+	EXPECT_EQ(0, test_open(merge_dl1, O_RDONLY));
+	EXPECT_EQ(0, test_open(merge_dl1_fl2, O_RDONLY));
+	EXPECT_EQ(0, test_open(merge_fu1, O_RDONLY));
+	EXPECT_EQ(0, test_open(merge_du1, O_RDONLY));
+	EXPECT_EQ(0, test_open(merge_du1_fu2, O_RDONLY));
+	EXPECT_EQ(0, test_open(merge_fo1, O_RDONLY));
+	EXPECT_EQ(0, test_open(merge_do1, O_RDONLY));
+	EXPECT_EQ(0, test_open(merge_do1_fo2, O_RDONLY));
+	EXPECT_EQ(0, test_open(merge_do1_fl3, O_RDONLY));
+	EXPECT_EQ(0, test_open(merge_do1_fu3, O_RDONLY));
 }
 
 #define for_each_path(path_list, path_entry, i)               \
@@ -7020,29 +7020,29 @@ TEST_F_FORK(layout2_overlay, same_content_different_file)
 
 	/* Checks lower layer. */
 	for_each_path(lower_base_files, path_entry, i) {
-		ASSERT_EQ(0, test_open(path_entry, O_RDONLY));
-		ASSERT_EQ(EACCES, test_open(path_entry, O_WRONLY));
+		EXPECT_EQ(0, test_open(path_entry, O_RDONLY));
+		EXPECT_EQ(EACCES, test_open(path_entry, O_WRONLY));
 	}
 	for_each_path(lower_base_directories, path_entry, i) {
-		ASSERT_EQ(EACCES,
+		EXPECT_EQ(EACCES,
 			  test_open(path_entry, O_RDONLY | O_DIRECTORY));
 	}
 	for_each_path(lower_sub_files, path_entry, i) {
-		ASSERT_EQ(0, test_open(path_entry, O_RDONLY));
-		ASSERT_EQ(EACCES, test_open(path_entry, O_WRONLY));
+		EXPECT_EQ(0, test_open(path_entry, O_RDONLY));
+		EXPECT_EQ(EACCES, test_open(path_entry, O_WRONLY));
 	}
 	/* Checks upper layer. */
 	for_each_path(upper_base_files, path_entry, i) {
-		ASSERT_EQ(0, test_open(path_entry, O_RDONLY));
-		ASSERT_EQ(EACCES, test_open(path_entry, O_WRONLY));
+		EXPECT_EQ(0, test_open(path_entry, O_RDONLY));
+		EXPECT_EQ(EACCES, test_open(path_entry, O_WRONLY));
 	}
 	for_each_path(upper_base_directories, path_entry, i) {
-		ASSERT_EQ(EACCES,
+		EXPECT_EQ(EACCES,
 			  test_open(path_entry, O_RDONLY | O_DIRECTORY));
 	}
 	for_each_path(upper_sub_files, path_entry, i) {
-		ASSERT_EQ(0, test_open(path_entry, O_RDONLY));
-		ASSERT_EQ(EACCES, test_open(path_entry, O_WRONLY));
+		EXPECT_EQ(0, test_open(path_entry, O_RDONLY));
+		EXPECT_EQ(EACCES, test_open(path_entry, O_WRONLY));
 	}
 	/*
 	 * Checks that access rights are independent from the lower and upper
@@ -7051,13 +7051,13 @@ TEST_F_FORK(layout2_overlay, same_content_different_file)
 	 * through the merge point is still allowed.
 	 */
 	for_each_path(merge_base_files, path_entry, i) {
-		ASSERT_EQ(0, test_open(path_entry, O_RDWR));
+		EXPECT_EQ(0, test_open(path_entry, O_RDWR));
 	}
 	for_each_path(merge_base_directories, path_entry, i) {
-		ASSERT_EQ(0, test_open(path_entry, O_RDONLY | O_DIRECTORY));
+		EXPECT_EQ(0, test_open(path_entry, O_RDONLY | O_DIRECTORY));
 	}
 	for_each_path(merge_sub_files, path_entry, i) {
-		ASSERT_EQ(0, test_open(path_entry, O_RDWR));
+		EXPECT_EQ(0, test_open(path_entry, O_RDWR));
 	}
 
 	/* Sets rules on data directories (i.e. inside overlay scope). */
@@ -7065,13 +7065,13 @@ TEST_F_FORK(layout2_overlay, same_content_different_file)
 
 	/* Checks merge. */
 	for_each_path(merge_base_files, path_entry, i) {
-		ASSERT_EQ(0, test_open(path_entry, O_RDWR));
+		EXPECT_EQ(0, test_open(path_entry, O_RDWR));
 	}
 	for_each_path(merge_base_directories, path_entry, i) {
-		ASSERT_EQ(0, test_open(path_entry, O_RDONLY | O_DIRECTORY));
+		EXPECT_EQ(0, test_open(path_entry, O_RDONLY | O_DIRECTORY));
 	}
 	for_each_path(merge_sub_files, path_entry, i) {
-		ASSERT_EQ(0, test_open(path_entry, O_RDWR));
+		EXPECT_EQ(0, test_open(path_entry, O_RDWR));
 	}
 
 	/* Same checks with tighter rules. */
@@ -7079,21 +7079,21 @@ TEST_F_FORK(layout2_overlay, same_content_different_file)
 
 	/* Checks changes for lower layer. */
 	for_each_path(lower_base_files, path_entry, i) {
-		ASSERT_EQ(EACCES, test_open(path_entry, O_RDONLY));
+		EXPECT_EQ(EACCES, test_open(path_entry, O_RDONLY));
 	}
 	/* Checks changes for upper layer. */
 	for_each_path(upper_base_files, path_entry, i) {
-		ASSERT_EQ(EACCES, test_open(path_entry, O_RDONLY));
+		EXPECT_EQ(EACCES, test_open(path_entry, O_RDONLY));
 	}
 	/* Checks all merge accesses. */
 	for_each_path(merge_base_files, path_entry, i) {
-		ASSERT_EQ(EACCES, test_open(path_entry, O_RDWR));
+		EXPECT_EQ(EACCES, test_open(path_entry, O_RDWR));
 	}
 	for_each_path(merge_base_directories, path_entry, i) {
-		ASSERT_EQ(0, test_open(path_entry, O_RDONLY | O_DIRECTORY));
+		EXPECT_EQ(0, test_open(path_entry, O_RDONLY | O_DIRECTORY));
 	}
 	for_each_path(merge_sub_files, path_entry, i) {
-		ASSERT_EQ(0, test_open(path_entry, O_RDWR));
+		EXPECT_EQ(0, test_open(path_entry, O_RDWR));
 	}
 
 	/* Sets rules directly on overlayed files. */
@@ -7101,24 +7101,24 @@ TEST_F_FORK(layout2_overlay, same_content_different_file)
 
 	/* Checks unchanged accesses on lower layer. */
 	for_each_path(lower_sub_files, path_entry, i) {
-		ASSERT_EQ(0, test_open(path_entry, O_RDONLY));
-		ASSERT_EQ(EACCES, test_open(path_entry, O_WRONLY));
+		EXPECT_EQ(0, test_open(path_entry, O_RDONLY));
+		EXPECT_EQ(EACCES, test_open(path_entry, O_WRONLY));
 	}
 	/* Checks unchanged accesses on upper layer. */
 	for_each_path(upper_sub_files, path_entry, i) {
-		ASSERT_EQ(0, test_open(path_entry, O_RDONLY));
-		ASSERT_EQ(EACCES, test_open(path_entry, O_WRONLY));
+		EXPECT_EQ(0, test_open(path_entry, O_RDONLY));
+		EXPECT_EQ(EACCES, test_open(path_entry, O_WRONLY));
 	}
 	/* Checks all merge accesses. */
 	for_each_path(merge_base_files, path_entry, i) {
-		ASSERT_EQ(EACCES, test_open(path_entry, O_RDWR));
+		EXPECT_EQ(EACCES, test_open(path_entry, O_RDWR));
 	}
 	for_each_path(merge_base_directories, path_entry, i) {
-		ASSERT_EQ(EACCES,
+		EXPECT_EQ(EACCES,
 			  test_open(path_entry, O_RDONLY | O_DIRECTORY));
 	}
 	for_each_path(merge_sub_files, path_entry, i) {
-		ASSERT_EQ(0, test_open(path_entry, O_RDWR));
+		EXPECT_EQ(0, test_open(path_entry, O_RDWR));
 	}
 
 	/* Only allows access to the merge hierarchy. */
@@ -7126,22 +7126,22 @@ TEST_F_FORK(layout2_overlay, same_content_different_file)
 
 	/* Checks new accesses on lower layer. */
 	for_each_path(lower_sub_files, path_entry, i) {
-		ASSERT_EQ(EACCES, test_open(path_entry, O_RDONLY));
+		EXPECT_EQ(EACCES, test_open(path_entry, O_RDONLY));
 	}
 	/* Checks new accesses on upper layer. */
 	for_each_path(upper_sub_files, path_entry, i) {
-		ASSERT_EQ(EACCES, test_open(path_entry, O_RDONLY));
+		EXPECT_EQ(EACCES, test_open(path_entry, O_RDONLY));
 	}
 	/* Checks all merge accesses. */
 	for_each_path(merge_base_files, path_entry, i) {
-		ASSERT_EQ(EACCES, test_open(path_entry, O_RDWR));
+		EXPECT_EQ(EACCES, test_open(path_entry, O_RDWR));
 	}
 	for_each_path(merge_base_directories, path_entry, i) {
-		ASSERT_EQ(EACCES,
+		EXPECT_EQ(EACCES,
 			  test_open(path_entry, O_RDONLY | O_DIRECTORY));
 	}
 	for_each_path(merge_sub_files, path_entry, i) {
-		ASSERT_EQ(0, test_open(path_entry, O_RDWR));
+		EXPECT_EQ(0, test_open(path_entry, O_RDWR));
 	}
 }
 
@@ -7438,7 +7438,7 @@ TEST_F_FORK(layout3_fs, release_inodes)
 	EXPECT_EQ(0, close(ruleset_fd));
 
 	/* Checks that access to the new mount point is denied. */
-	ASSERT_EQ(EACCES, test_open(TMP_DIR, O_RDONLY));
+	EXPECT_EQ(EACCES, test_open(TMP_DIR, O_RDONLY));
 }
 
 static int matches_log_fs_extra(struct __test_metadata *const _metadata,
@@ -7918,7 +7918,7 @@ TEST_F(audit_layout1, refer_rename_half)
 	enforce_fs(_metadata, LANDLOCK_ACCESS_FS_REFER, layer1);
 
 	ASSERT_EQ(-1, rename(dir_s1d2, dir_s2d3));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 
 	/* Only half of the request is denied. */
 	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd, "fs\\.refer",
@@ -8236,7 +8236,7 @@ void audit_quiet_layout1_test_body(struct __test_metadata *const _metadata,
 			};
 		} else {
 			ASSERT_EQ(-1, fd);
-			ASSERT_EQ(EACCES, errno);
+			EXPECT_EQ(EACCES, errno);
 		}
 
 		expect_audit = true;
@@ -8251,12 +8251,12 @@ void audit_quiet_layout1_test_body(struct __test_metadata *const _metadata,
 			expect_audit = false;
 
 		if (expect_audit)
-			ASSERT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
+			EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
 						    blocker, target->target));
 
 		/* Check that we see no (other) logs. */
 		ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
-		ASSERT_EQ(0, records.access);
+		EXPECT_EQ(0, records.access);
 
 		if (target->expect_open_success && fd >= 0) {
 			if (debug_quiet_tests)
@@ -8268,11 +8268,11 @@ void audit_quiet_layout1_test_body(struct __test_metadata *const _metadata,
 			} else {
 				ASSERT_EQ(-1, ret);
 				if (open_mode != O_RDONLY)
-					ASSERT_EQ(EACCES, errno);
+					EXPECT_EQ(EACCES, errno);
 			}
 
 			if (target->audit_truncate)
-				ASSERT_EQ(0, matches_log_fs(_metadata,
+				EXPECT_EQ(0, matches_log_fs(_metadata,
 							    self->audit_fd,
 							    "fs\\.truncate",
 							    target->target));
@@ -8292,7 +8292,7 @@ void audit_quiet_layout1_test_body(struct __test_metadata *const _metadata,
 			}
 
 			if (target->audit_ioctl)
-				ASSERT_EQ(0, matches_log_fs_extra(
+				EXPECT_EQ(0, matches_log_fs_extra(
 						     _metadata, self->audit_fd,
 						     "fs\\.ioctl_dev",
 						     target->target,
@@ -8301,7 +8301,7 @@ void audit_quiet_layout1_test_body(struct __test_metadata *const _metadata,
 			/* Check that we see no other logs. */
 			ASSERT_EQ(0, audit_count_records(self->audit_fd,
 							 &records));
-			ASSERT_EQ(0, records.access);
+			EXPECT_EQ(0, records.access);
 			EXPECT_EQ(0, close(fd));
 		}
 	}
@@ -9690,10 +9690,10 @@ static void simple_quiet_rename(struct __test_metadata *const _metadata,
 		}
 
 		if (source_blockers)
-			ASSERT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
+			EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
 						    source_blockers, dir_s1d1));
 		if (dest_blockers)
-			ASSERT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
+			EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
 						    dest_blockers, dir_s2d1));
 	}
 	/*
@@ -9701,7 +9701,7 @@ static void simple_quiet_rename(struct __test_metadata *const _metadata,
 	 * audit_quiet_layout1_test_body.
 	 */
 	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
-	ASSERT_EQ(0, records.access);
+	EXPECT_EQ(0, records.access);
 }
 
 TEST_F(audit_quiet_rename, rename_ok)
@@ -9816,11 +9816,11 @@ TEST_F(audit_quiet_rename, handle_all_deny_quiet_refer)
 	ASSERT_EQ(0, apply_a_layer(_metadata, &layer));
 
 	ASSERT_EQ(-1, renameat(AT_FDCWD, file1_s1d1, AT_FDCWD, file1_s2d1));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 
 	/* No logs */
 	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
-	ASSERT_EQ(0, records.access);
+	EXPECT_EQ(0, records.access);
 }
 
 TEST_F(audit_quiet_rename, handle_all_deny_not_quiet_refer)
@@ -9852,16 +9852,16 @@ TEST_F(audit_quiet_rename, handle_all_deny_not_quiet_refer)
 	ASSERT_EQ(0, apply_a_layer(_metadata, &layer));
 
 	ASSERT_EQ(-1, renameat(AT_FDCWD, file1_s1d1, AT_FDCWD, file1_s2d1));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 
-	ASSERT_EQ(0, matches_log_fs(_metadata, self->audit_fd, "fs\\.refer",
+	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd, "fs\\.refer",
 				    dir_s1d1));
-	ASSERT_EQ(0, matches_log_fs(_metadata, self->audit_fd, "fs\\.refer",
+	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd, "fs\\.refer",
 				    dir_s2d1));
 
 	/* No other logs */
 	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
-	ASSERT_EQ(0, records.access);
+	EXPECT_EQ(0, records.access);
 }
 
 TEST_F(audit_quiet_rename, handle_all_deny_refer_quiet_source_not_quiet_dest)
@@ -9893,14 +9893,14 @@ TEST_F(audit_quiet_rename, handle_all_deny_refer_quiet_source_not_quiet_dest)
 	ASSERT_EQ(0, apply_a_layer(_metadata, &layer));
 
 	ASSERT_EQ(-1, renameat(AT_FDCWD, file1_s1d1, AT_FDCWD, file1_s2d1));
-	ASSERT_EQ(EXDEV, errno);
+	EXPECT_EQ(EXDEV, errno);
 
-	ASSERT_EQ(0, matches_log_fs(_metadata, self->audit_fd, "fs\\.refer",
+	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd, "fs\\.refer",
 				    dir_s2d1));
 
 	/* No other logs */
 	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
-	ASSERT_EQ(0, records.access);
+	EXPECT_EQ(0, records.access);
 }
 
 TEST_F(audit_quiet_rename, quiet_same_dir)
@@ -9924,10 +9924,10 @@ TEST_F(audit_quiet_rename, quiet_same_dir)
 	ASSERT_EQ(0, apply_a_layer(_metadata, &layer));
 
 	ASSERT_EQ(-1, renameat(AT_FDCWD, file1_s1d1, AT_FDCWD, file2_s1d1));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 
 	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
-	ASSERT_EQ(0, records.access);
+	EXPECT_EQ(0, records.access);
 }
 
 TEST_F(audit_quiet_rename, quiet_flag_on_file_ignored)
@@ -9956,18 +9956,18 @@ TEST_F(audit_quiet_rename, quiet_flag_on_file_ignored)
 	ASSERT_EQ(0, apply_a_layer(_metadata, &layer));
 
 	ASSERT_EQ(-1, renameat(AT_FDCWD, file1_s1d1, AT_FDCWD, file1_s2d1));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 
-	ASSERT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
+	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
 				    "fs\\.remove_file,fs\\.refer", dir_s1d1));
 	/* We didn't unlink destination file */
-	ASSERT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
+	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
 				    "fs\\.remove_file,fs\\.make_reg,fs\\.refer",
 				    dir_s2d1));
 
 	/* No other logs */
 	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
-	ASSERT_EQ(0, records.access);
+	EXPECT_EQ(0, records.access);
 }
 
 TEST_F(audit_quiet_rename, quiet_flag_on_file_ignored_same_dir)
@@ -9996,15 +9996,15 @@ TEST_F(audit_quiet_rename, quiet_flag_on_file_ignored_same_dir)
 	ASSERT_EQ(0, apply_a_layer(_metadata, &layer));
 
 	ASSERT_EQ(-1, renameat(AT_FDCWD, file1_s1d1, AT_FDCWD, file2_s1d1));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 
-	ASSERT_EQ(0,
+	EXPECT_EQ(0,
 		  matches_log_fs(_metadata, self->audit_fd,
 				 "fs\\.remove_file,fs\\.make_reg", dir_s1d1));
 
 	/* No other logs */
 	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
-	ASSERT_EQ(0, records.access);
+	EXPECT_EQ(0, records.access);
 }
 
 TEST_F(audit_quiet_rename, two_layers_different_quiet1)
@@ -10052,17 +10052,17 @@ TEST_F(audit_quiet_rename, two_layers_different_quiet1)
 	ASSERT_EQ(0, apply_a_layer(_metadata, &layer2));
 
 	ASSERT_EQ(-1, renameat(AT_FDCWD, file1_s1d1, AT_FDCWD, file1_s2d1));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 
 	/*
 	 * The youngest denial will be layer 2.  Refer is quieted but we are
 	 * also missing remove_file on source.
 	 */
-	ASSERT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
+	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
 				    "fs\\.remove_file,fs\\.refer", dir_s1d1));
 	/* No other logs */
 	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
-	ASSERT_EQ(0, records.access);
+	EXPECT_EQ(0, records.access);
 }
 
 TEST_F(audit_quiet_rename, two_layers_different_quiet2)
@@ -10110,14 +10110,14 @@ TEST_F(audit_quiet_rename, two_layers_different_quiet2)
 	ASSERT_EQ(0, apply_a_layer(_metadata, &layer2));
 
 	ASSERT_EQ(-1, renameat(AT_FDCWD, file1_s1d1, AT_FDCWD, file1_s2d1));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 
 	/*
 	 * The youngest denial will be layer 2, but refer is quieted (and that
 	 * layer does not handle any other accesses).
 	 */
 	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
-	ASSERT_EQ(0, records.access);
+	EXPECT_EQ(0, records.access);
 }
 
 TEST_F(audit_quiet_rename, two_layers_different_quiet3)
@@ -10165,13 +10165,13 @@ TEST_F(audit_quiet_rename, two_layers_different_quiet3)
 	ASSERT_EQ(0, apply_a_layer(_metadata, &layer2));
 
 	ASSERT_EQ(-1, renameat(AT_FDCWD, file1_s1d1, AT_FDCWD, file1_s2d1));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 
 	/*
 	 * The youngest denial will be layer 2, in which everything is quieted.
 	 */
 	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
-	ASSERT_EQ(0, records.access);
+	EXPECT_EQ(0, records.access);
 }
 
 TEST_F(audit_quiet_rename,
@@ -10209,15 +10209,15 @@ TEST_F(audit_quiet_rename,
 	ASSERT_EQ(0, apply_a_layer(_metadata, &layer2));
 
 	ASSERT_EQ(-1, renameat(AT_FDCWD, file1_s1d1, AT_FDCWD, file1_s2d1));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 
-	ASSERT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
+	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
 				    "fs\\.remove_file,fs\\.refer", dir_s1d1));
-	ASSERT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
+	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
 				    "fs\\.make_reg,fs\\.refer", dir_s2d1));
 	/* No other logs. */
 	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
-	ASSERT_EQ(0, records.access);
+	EXPECT_EQ(0, records.access);
 }
 
 TEST_F(audit_quiet_rename,
@@ -10261,14 +10261,14 @@ TEST_F(audit_quiet_rename,
 	ASSERT_EQ(0, apply_a_layer(_metadata, &layer2));
 
 	ASSERT_EQ(-1, renameat(AT_FDCWD, file1_s1d1, AT_FDCWD, file1_s2d1));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 
 	/* Source is quieted but destination is not. */
-	ASSERT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
+	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
 				    "fs\\.make_reg,fs\\.refer", dir_s2d1));
 	/* No other logs. */
 	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
-	ASSERT_EQ(0, records.access);
+	EXPECT_EQ(0, records.access);
 }
 
 TEST_F(audit_quiet_rename, rename_xchg)
@@ -10298,10 +10298,10 @@ TEST_F(audit_quiet_rename, rename_xchg)
 
 	ASSERT_EQ(-1, renameat2(AT_FDCWD, file1_s1d1, AT_FDCWD, file1_s2d1,
 				RENAME_EXCHANGE));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 
 	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
-	ASSERT_EQ(0, records.access);
+	EXPECT_EQ(0, records.access);
 }
 
 TEST_F(audit_quiet_rename, quiet_on_parent_mount)
@@ -10327,10 +10327,10 @@ TEST_F(audit_quiet_rename, quiet_on_parent_mount)
 
 	ASSERT_EQ(-1, renameat(AT_FDCWD, bind_file1_s1d3, AT_FDCWD,
 			       bind_file2_s1d3));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 
 	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
-	ASSERT_EQ(0, records.access);
+	EXPECT_EQ(0, records.access);
 }
 
 TEST_F(audit_quiet_rename, quiet_behind_mountpoint_ignored)
@@ -10356,13 +10356,13 @@ TEST_F(audit_quiet_rename, quiet_behind_mountpoint_ignored)
 
 	ASSERT_EQ(-1, renameat(AT_FDCWD, bind_file1_s1d3, AT_FDCWD,
 			       bind_file2_s1d3));
-	ASSERT_EQ(EACCES, errno);
-	ASSERT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
+	EXPECT_EQ(EACCES, errno);
+	EXPECT_EQ(0, matches_log_fs(_metadata, self->audit_fd,
 				    "fs\\.remove_file,fs\\.make_reg",
 				    bind_dir_s1d3));
 
 	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
-	ASSERT_EQ(0, records.access);
+	EXPECT_EQ(0, records.access);
 }
 
 TEST_F(audit_quiet_rename, quiet_on_parent_mount_disconnected)
@@ -10397,10 +10397,10 @@ TEST_F(audit_quiet_rename, quiet_on_parent_mount_disconnected)
 
 	ASSERT_EQ(-1,
 		  renameat(bind_s1d3_fd, file1_name, bind_s1d3_fd, file2_name));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 
 	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
-	ASSERT_EQ(0, records.access);
+	EXPECT_EQ(0, records.access);
 }
 
 TEST_F(audit_quiet_rename, quiet_behind_mountpoint_disconnected)
@@ -10435,10 +10435,10 @@ TEST_F(audit_quiet_rename, quiet_behind_mountpoint_disconnected)
 
 	ASSERT_EQ(-1,
 		  renameat(bind_s1d3_fd, file1_name, bind_s1d3_fd, file2_name));
-	ASSERT_EQ(EACCES, errno);
+	EXPECT_EQ(EACCES, errno);
 
 	ASSERT_EQ(0, audit_count_records(self->audit_fd, &records));
-	ASSERT_EQ(0, records.access);
+	EXPECT_EQ(0, records.access);
 }
 
 /* clang-format off */
diff --git a/tools/testing/selftests/landlock/net_test.c b/tools/testing/selftests/landlock/net_test.c
index e194fd78d8a1..31e113873d66 100644
--- a/tools/testing/selftests/landlock/net_test.c
+++ b/tools/testing/selftests/landlock/net_test.c
@@ -3720,7 +3720,7 @@ TEST_F(trace_net_address, deny_access_net)
 
 	ASSERT_EQ(child, waitpid(child, &status, 0));
 	ASSERT_TRUE(WIFEXITED(status));
-	ASSERT_EQ(0, WEXITSTATUS(status));
+	EXPECT_EQ(0, WEXITSTATUS(status));
 
 	buf = tracefs_read_buf();
 	ASSERT_NE(NULL, buf);
diff --git a/tools/testing/selftests/landlock/scoped_abstract_unix_test.c b/tools/testing/selftests/landlock/scoped_abstract_unix_test.c
index 4c7f9c102d50..9aa1d375ef51 100644
--- a/tools/testing/selftests/landlock/scoped_abstract_unix_test.c
+++ b/tools/testing/selftests/landlock/scoped_abstract_unix_test.c
@@ -1114,7 +1114,7 @@ TEST(datagram_sockets)
 		ASSERT_EQ(-1, sendto(client_unconn_socket, ".", 1, 0,
 				     &non_connected_addr.unix_addr,
 				     non_connected_addr.unix_addr_len));
-		ASSERT_EQ(EPERM, errno);
+		EXPECT_EQ(EPERM, errno);
 		ASSERT_EQ(1, write(pipe_child[1], ".", 1));
 
 		EXPECT_EQ(0, close(client_conn_socket));
@@ -1196,17 +1196,17 @@ TEST(self_connect)
 		ASSERT_EQ(-1,
 			  connect(connected_socket, &connected_addr.unix_addr,
 				  connected_addr.unix_addr_len));
-		ASSERT_EQ(EPERM, errno);
+		EXPECT_EQ(EPERM, errno);
 
 		ASSERT_EQ(-1, sendto(connected_socket, ".", 1, 0,
 				     &connected_addr.unix_addr,
 				     connected_addr.unix_addr_len));
-		ASSERT_EQ(EPERM, errno);
+		EXPECT_EQ(EPERM, errno);
 
 		ASSERT_EQ(-1, sendto(non_connected_socket, ".", 1, 0,
 				     &non_connected_addr.unix_addr,
 				     non_connected_addr.unix_addr_len));
-		ASSERT_EQ(EPERM, errno);
+		EXPECT_EQ(EPERM, errno);
 
 		EXPECT_EQ(0, close(connected_socket));
 		EXPECT_EQ(0, close(non_connected_socket));
diff --git a/tools/testing/selftests/landlock/scoped_signal_test.c b/tools/testing/selftests/landlock/scoped_signal_test.c
index 66fec3822812..f9c270a1107a 100644
--- a/tools/testing/selftests/landlock/scoped_signal_test.c
+++ b/tools/testing/selftests/landlock/scoped_signal_test.c
@@ -124,7 +124,7 @@ TEST_F(scoping_signals, send_sig_to_parent)
 		 */
 		err = kill(parent, variant->sig);
 		ASSERT_EQ(-1, err);
-		ASSERT_EQ(EPERM, errno);
+		EXPECT_EQ(EPERM, errno);
 
 		/*
 		 * No matter of the domain, a process should be able to
@@ -216,7 +216,7 @@ TEST_F(scoped_domains, check_access_signal)
 			ASSERT_EQ(0, err);
 		} else {
 			ASSERT_EQ(-1, err);
-			ASSERT_EQ(EPERM, errno);
+			EXPECT_EQ(EPERM, errno);
 		}
 		/*
 		 * No matter of the domain, a process should be able to
@@ -241,7 +241,7 @@ TEST_F(scoped_domains, check_access_signal)
 		ASSERT_EQ(0, err);
 	} else {
 		ASSERT_EQ(-1, err);
-		ASSERT_EQ(EPERM, errno);
+		EXPECT_EQ(EPERM, errno);
 	}
 	ASSERT_EQ(0, raise(0));
 
diff --git a/tools/testing/selftests/landlock/scoped_test.c b/tools/testing/selftests/landlock/scoped_test.c
index b90f76ed0d9c..4d8f79170892 100644
--- a/tools/testing/selftests/landlock/scoped_test.c
+++ b/tools/testing/selftests/landlock/scoped_test.c
@@ -26,7 +26,7 @@ TEST(ruleset_with_unknown_scope)
 
 		ASSERT_EQ(-1, landlock_create_ruleset(&ruleset_attr,
 						      sizeof(ruleset_attr), 0));
-		ASSERT_EQ(EINVAL, errno);
+		EXPECT_EQ(EINVAL, errno);
 	}
 }
 
-- 
2.56.0

Re: [PATCH 00/27] landlock: Selftest fixes and cleanups

[Günther Noack]

On Thu, Oct 08, 2026 at 04:25:29PM +0200, Günther Noack wrote:
> The last few patches are a bit more cross-cutting and probably more
> prone to merge conflicts, as they correct cases where we have been
> using EXPECT and ASSERT in the wrong way (details in the commit
> messages).  I believe that the rationale for each of these is
> reasonable, but I am happy to discuss.

Minor post scriptum:

That's the last four patches.  They are large, but largely mechanical
refactorings.  If it merge-conflicts with another selftest
refactoring, it should be possible to replicate equivalent patches
relatively easily with the help of an LLM.  If you prefer to go that
way for the last patches, that would also be fine with me.

–Günther