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

[PATCH v2 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.

–Günther

---
Changes in v2:
- Rebased onto master (v7.4-rc1-132-g05441d697f7f).
- Dropped the "Assisted-by: LLM" trailers (not required any more).
- Applied the same ASSERT/EXPECT rules to the test code that was added
  in the meantime (cap_test.c and ns_test.c, plus new checks in
  base_test.c and trace_test.c):
  - "Assert tracefs_extract_field() results that are used": also the
    new handled_permissions check in trace.create_ruleset.
  - "Assert audit initialization in fixture setups": also the
    cap_audit, ns_audit and ns_proc_open fixtures.
  - "Assert audit_count_records() before using its result": also in
    cap_test.c and ns_test.c.
  - "Use ASSERT for syscall failures before errno checks": also in
    cap_test.c and ns_test.c.
  - "Use EXPECT for checks that later steps do not need": also the
    errno and WEXITSTATUS() checks in cap_test.c and ns_test.c, and the
    errno check in base_test.c's ruleset_with_unknown_permission.
- Dropped the note about depending on Wang Yan's snprintf() fix, which
  has landed as commit 8e4c736cffdd ("selftests/landlock: Fix snprintf
  truncation checks in test files").
- Link to v1: https://patch.msgid.link/20261008142604.39107-2-gnoack3000@gmail.com

To: Mickaël Salaün <mic@digikod.net>
To: Günther Noack <gnoack@google.com>
To: Shuah Khan <shuah@kernel.org>
Cc: linux-security-module@vger.kernel.org
Cc: linux-kselftest@vger.kernel.org
Cc: linux-kernel@vger.kernel.org

---
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       |  192 +--
 tools/testing/selftests/landlock/cap_test.c        |   70 +-
 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 +-
 tools/testing/selftests/landlock/ns_test.c         |  124 +-
 tools/testing/selftests/landlock/ptrace_test.c     |   44 +-
 .../selftests/landlock/sandbox-and-launch.c        |    6 +-
 .../selftests/landlock/scoped_abstract_unix_test.c |   45 +-
 .../selftests/landlock/scoped_signal_test.c        |   23 +-
 tools/testing/selftests/landlock/scoped_test.c     |    2 +-
 tools/testing/selftests/landlock/trace_fs_test.c   |    8 +-
 tools/testing/selftests/landlock/trace_test.c      |   28 +-
 tools/testing/selftests/landlock/tsync_test.c      |   22 +-
 .../testing/selftests/landlock/wait-pipe-sandbox.c |   16 +-
 tools/testing/selftests/landlock/wait-pipe.c       |    2 +-
 19 files changed, 1051 insertions(+), 1008 deletions(-)
---
base-commit: 05441d697f7f9a927264f4058cbbc6a03dfcac9d
change-id: 20261104-selftests-refactor-4741be042e4f

Best regards,
--  
Günther Noack <gnoack3000@gmail.com>

[PATCH v2 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.

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 v2 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.

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 v2 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.

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 v2 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.

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 89c0d96607de..0bf8632b725f 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 v2 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.

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 v2 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)

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 v2 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.

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 f725882fa4a7..7d399c097c93 100644
--- a/tools/testing/selftests/landlock/fs_test.c
+++ b/tools/testing/selftests/landlock/fs_test.c
@@ -1456,7 +1456,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 v2 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.

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 e29406900c04..6c2aa913ff11 100644
--- a/tools/testing/selftests/landlock/common.h
+++ b/tools/testing/selftests/landlock/common.h
@@ -171,7 +171,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 v2 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.

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

diff --git a/tools/testing/selftests/landlock/trace_test.c b/tools/testing/selftests/landlock/trace_test.c
index cb49ce8dbeda..1795d41b779f 100644
--- a/tools/testing/selftests/landlock/trace_test.c
+++ b/tools/testing/selftests/landlock/trace_test.c
@@ -175,25 +175,25 @@ 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 that no permission is handled. */
-	EXPECT_EQ(0, tracefs_extract_field(
+	ASSERT_EQ(0, tracefs_extract_field(
 			     buf, REGEX_CREATE_RULESET(TRACE_TASK),
 			     "handled_permissions", field, sizeof(field)));
 	EXPECT_STREQ("", 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. */
@@ -363,7 +363,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)));
 
@@ -371,7 +371,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);
@@ -387,7 +387,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);
@@ -621,7 +621,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);
@@ -906,7 +906,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);
@@ -955,7 +955,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);
@@ -965,7 +965,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 v2 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.

Signed-off-by: Günther Noack <gnoack3000@gmail.com>
---
 tools/testing/selftests/landlock/audit_test.c                | 8 ++++----
 tools/testing/selftests/landlock/cap_test.c                  | 2 +-
 tools/testing/selftests/landlock/fs_test.c                   | 6 +++---
 tools/testing/selftests/landlock/net_test.c                  | 2 +-
 tools/testing/selftests/landlock/ns_test.c                   | 4 ++--
 tools/testing/selftests/landlock/ptrace_test.c               | 2 +-
 tools/testing/selftests/landlock/scoped_abstract_unix_test.c | 2 +-
 7 files changed, 13 insertions(+), 13 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/cap_test.c b/tools/testing/selftests/landlock/cap_test.c
index 3d7fd02e21ed..7b3b724e4406 100644
--- a/tools/testing/selftests/landlock/cap_test.c
+++ b/tools/testing/selftests/landlock/cap_test.c
@@ -775,7 +775,7 @@ FIXTURE_SETUP(cap_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);
 	clear_cap(_metadata, CAP_AUDIT_CONTROL);
 }
 
diff --git a/tools/testing/selftests/landlock/fs_test.c b/tools/testing/selftests/landlock/fs_test.c
index 7d399c097c93..7ff94755b029 100644
--- a/tools/testing/selftests/landlock/fs_test.c
+++ b/tools/testing/selftests/landlock/fs_test.c
@@ -7504,7 +7504,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);
 }
 
@@ -8028,7 +8028,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"))
@@ -9605,7 +9605,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/ns_test.c b/tools/testing/selftests/landlock/ns_test.c
index f5d4b86edd30..6491b53742f1 100644
--- a/tools/testing/selftests/landlock/ns_test.c
+++ b/tools/testing/selftests/landlock/ns_test.c
@@ -1944,7 +1944,7 @@ FIXTURE_SETUP(ns_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);
 	clear_cap(_metadata, CAP_AUDIT_CONTROL);
 }
 
@@ -2596,7 +2596,7 @@ FIXTURE_SETUP(ns_proc_open)
 
 	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/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 v2 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.

Signed-off-by: Günther Noack <gnoack3000@gmail.com>
---
 tools/testing/selftests/landlock/common.h                    | 6 +++---
 tools/testing/selftests/landlock/ptrace_test.c               | 2 +-
 tools/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 6c2aa913ff11..a662a68bee7b 100644
--- a/tools/testing/selftests/landlock/common.h
+++ b/tools/testing/selftests/landlock/common.h
@@ -55,7 +55,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,
@@ -91,7 +91,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))
 	{
@@ -227,7 +227,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 v2 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.

Signed-off-by: Günther Noack <gnoack3000@gmail.com>
---
 tools/testing/selftests/landlock/audit_test.c      | 20 ++---
 tools/testing/selftests/landlock/cap_test.c        | 16 ++--
 tools/testing/selftests/landlock/fs_test.c         | 86 +++++++++++-----------
 tools/testing/selftests/landlock/net_test.c        | 22 +++---
 tools/testing/selftests/landlock/ns_test.c         | 26 +++----
 tools/testing/selftests/landlock/ptrace_test.c     |  6 +-
 .../selftests/landlock/scoped_abstract_unix_test.c |  4 +-
 7 files changed, 90 insertions(+), 90 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/cap_test.c b/tools/testing/selftests/landlock/cap_test.c
index 7b3b724e4406..5a7dbd26f92f 100644
--- a/tools/testing/selftests/landlock/cap_test.c
+++ b/tools/testing/selftests/landlock/cap_test.c
@@ -823,7 +823,7 @@ TEST_F(cap_audit, denied)
 	 */
 	EXPECT_EQ(0, matches_log_domain_allocated(self->audit_fd, getpid(),
 						  &domain_id));
-	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);
 }
@@ -846,7 +846,7 @@ TEST_F(cap_audit, allowed)
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 
 	/* No records: allowed operations never trigger audit logging. */
-	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);
 }
 
@@ -872,7 +872,7 @@ TEST_F(cap_audit, allow_and_quiet_same_member)
 	/*
 	 * Quiet is inert for the allowed member: nothing is denied or logged.
 	 */
-	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);
 }
 
@@ -916,7 +916,7 @@ TEST_F(cap_audit, quieted)
 	EXPECT_EQ(0, matches_log_cap(self->audit_fd, CAP_SYS_ADMIN));
 	EXPECT_EQ(0, matches_log_domain_allocated(self->audit_fd, getpid(),
 						  &domain_id));
-	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);
 }
@@ -962,7 +962,7 @@ TEST_F(cap_audit, quiet_youngest_layer_wins)
 	EXPECT_EQ(0, matches_log_cap(self->audit_fd, CAP_SYS_CHROOT));
 	EXPECT_EQ(0, matches_log_domain_allocated(self->audit_fd, getpid(),
 						  &domain_id));
-	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);
 }
@@ -994,7 +994,7 @@ TEST_F(cap_audit, quiet_unknown_bit_no_effect)
 	EXPECT_EQ(0, matches_log_cap(self->audit_fd, CAP_SYS_CHROOT));
 	EXPECT_EQ(0, matches_log_domain_allocated(self->audit_fd, getpid(),
 						  &domain_id));
-	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);
 }
@@ -1051,7 +1051,7 @@ TEST_F(cap_audit, noaudit_probe_not_logged)
 	EXPECT_EQ(0, close(fd));
 
 	/* The denied noaudit probe leaves no audit record nor denial. */
-	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);
 
 	/*
@@ -1066,7 +1066,7 @@ TEST_F(cap_audit, noaudit_probe_not_logged)
 	EXPECT_EQ(0, matches_log_cap(self->audit_fd, CAP_SYS_ADMIN));
 	EXPECT_EQ(0, matches_log_domain_allocated(self->audit_fd, getpid(),
 						  &domain_id));
-	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/fs_test.c b/tools/testing/selftests/landlock/fs_test.c
index 7ff94755b029..100ef02b5d1a 100644
--- a/tools/testing/selftests/landlock/fs_test.c
+++ b/tools/testing/selftests/landlock/fs_test.c
@@ -7534,7 +7534,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);
 }
@@ -7565,7 +7565,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);
 }
@@ -7580,7 +7580,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);
 }
@@ -7595,7 +7595,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);
 }
@@ -7610,7 +7610,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);
 }
@@ -7634,7 +7634,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);
 }
@@ -7650,7 +7650,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);
 }
@@ -7668,7 +7668,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);
 }
@@ -7687,7 +7687,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);
 }
@@ -7705,7 +7705,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);
 }
@@ -7723,7 +7723,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);
 }
@@ -7741,7 +7741,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);
 }
@@ -7759,7 +7759,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);
 }
@@ -7777,7 +7777,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);
 }
@@ -7795,7 +7795,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);
 }
@@ -7817,7 +7817,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);
 }
@@ -7839,7 +7839,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);
 }
@@ -7859,7 +7859,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);
 }
@@ -7884,7 +7884,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);
 }
@@ -7918,7 +7918,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);
 }
@@ -7934,7 +7934,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);
 }
@@ -7954,7 +7954,7 @@ TEST_F(audit_layout1, ioctl_dev)
 					  "fs\\.ioctl_dev", "/dev/null",
 					  " ioctlcmd=0xc00ffeee"));
 
-	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);
 }
@@ -7989,7 +7989,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);
 
@@ -8008,7 +8008,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);
 }
@@ -8250,7 +8250,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) {
@@ -8294,7 +8294,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));
@@ -9695,7 +9695,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);
 }
 
@@ -9814,7 +9814,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);
 }
 
@@ -9855,7 +9855,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);
 }
 
@@ -9894,7 +9894,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);
 }
 
@@ -9921,7 +9921,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);
 }
 
@@ -9961,7 +9961,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);
 }
 
@@ -9998,7 +9998,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);
 }
 
@@ -10056,7 +10056,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);
 }
 
@@ -10111,7 +10111,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);
 }
 
@@ -10165,7 +10165,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);
 }
 
@@ -10211,7 +10211,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);
 }
 
@@ -10262,7 +10262,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);
 }
 
@@ -10295,7 +10295,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);
 }
 
@@ -10324,7 +10324,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);
 }
 
@@ -10356,7 +10356,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);
 }
 
@@ -10394,7 +10394,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);
 }
 
@@ -10432,7 +10432,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/ns_test.c b/tools/testing/selftests/landlock/ns_test.c
index 6491b53742f1..57d03233bf6d 100644
--- a/tools/testing/selftests/landlock/ns_test.c
+++ b/tools/testing/selftests/landlock/ns_test.c
@@ -1984,7 +1984,7 @@ TEST_F(ns_audit, create_denied)
 	 */
 	EXPECT_EQ(0, matches_log_domain_allocated(self->audit_fd, getpid(),
 						  &domain_id));
-	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);
 }
@@ -2005,7 +2005,7 @@ TEST_F(ns_audit, create_allowed)
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 
 	/* No records: allowed operations never trigger audit logging. */
-	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);
 }
 
@@ -2030,7 +2030,7 @@ TEST_F(ns_audit, setns_allowed)
 	EXPECT_EQ(0, close(ns_fd));
 
 	/* No records: allowed setns never triggers audit logging. */
-	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);
 }
 
@@ -2068,7 +2068,7 @@ TEST_F(ns_audit, setns_denied)
 	 */
 	EXPECT_EQ(0, matches_log_domain_allocated(self->audit_fd, getpid(),
 						  &domain_id));
-	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);
 }
@@ -2094,7 +2094,7 @@ TEST_F(ns_audit, create_quieted)
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 
 	/* The denial is suppressed: no access record. */
-	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);
 }
 
@@ -2123,7 +2123,7 @@ TEST_F(ns_audit, setns_quieted)
 	EXPECT_EQ(0, close(ns_fd));
 
 	/* The denial is suppressed: no access record. */
-	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);
 }
 
@@ -2155,7 +2155,7 @@ TEST_F(ns_audit, quiet_is_per_member)
 	EXPECT_EQ(0, matches_log_ns_create(self->audit_fd, CLONE_NEWUTS));
 	EXPECT_EQ(0, matches_log_domain_allocated(self->audit_fd, getpid(),
 						  &domain_id));
-	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);
 }
@@ -2187,7 +2187,7 @@ TEST_F(ns_audit, quiet_unknown_bit_no_effect)
 	EXPECT_EQ(0, matches_log_ns_create(self->audit_fd, CLONE_NEWUTS));
 	EXPECT_EQ(0, matches_log_domain_allocated(self->audit_fd, getpid(),
 						  &domain_id));
-	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);
 }
@@ -2212,7 +2212,7 @@ TEST_F(ns_audit, allow_and_quiet)
 	EXPECT_EQ(EPERM, errno);
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 
-	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);
 }
 
@@ -2238,7 +2238,7 @@ TEST_F(ns_audit, allow_and_quiet_same_member)
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 
 	/* Nothing denied, nothing logged. */
-	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);
 }
 
@@ -2272,7 +2272,7 @@ TEST_F(ns_audit, quiet_youngest_layer_wins)
 
 	/* The child layer denies and does not quiet: logged. */
 	EXPECT_EQ(0, matches_log_ns_create(self->audit_fd, CLONE_NEWUTS));
-	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);
 }
 
@@ -2307,7 +2307,7 @@ TEST_F(ns_audit, quiet_parent_only_denying_layer)
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 
 	/* The parent quiets and is the youngest denying layer: suppressed. */
-	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);
 }
 
@@ -2638,7 +2638,7 @@ TEST_F(ns_proc_open, open_unrestricted)
 	}
 
 	/* No Landlock denial. */
-	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(fd));
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 v2 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.

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 v2 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.

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 v2 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.

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 ++++
 tools/testing/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 0bf8632b725f..a6d355807dab 100644
--- a/tools/testing/selftests/landlock/base_test.c
+++ b/tools/testing/selftests/landlock/base_test.c
@@ -352,6 +352,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)
@@ -373,6 +375,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 v2 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.

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 a6d355807dab..9a1d5b8aacb8 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 v2 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.

Signed-off-by: Günther Noack <gnoack3000@gmail.com>
---
 tools/testing/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 v2 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.

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 a662a68bee7b..dcfdcfecde86 100644
--- a/tools/testing/selftests/landlock/common.h
+++ b/tools/testing/selftests/landlock/common.h
@@ -277,11 +277,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;
 
@@ -295,21 +295,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 100ef02b5d1a..10a386a573dd 100644
--- a/tools/testing/selftests/landlock/fs_test.c
+++ b/tools/testing/selftests/landlock/fs_test.c
@@ -7450,6 +7450,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=\"",
@@ -7467,13 +7468,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 v2 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.

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 dcfdcfecde86..0df8ae88d4fa 100644
--- a/tools/testing/selftests/landlock/common.h
+++ b/tools/testing/selftests/landlock/common.h
@@ -307,7 +307,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 v2 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")
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 10a386a573dd..1e94a3171e02 100644
--- a/tools/testing/selftests/landlock/fs_test.c
+++ b/tools/testing/selftests/landlock/fs_test.c
@@ -7449,7 +7449,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 v2 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.

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 1e94a3171e02..78b2bf06b6ee 100644
--- a/tools/testing/selftests/landlock/fs_test.c
+++ b/tools/testing/selftests/landlock/fs_test.c
@@ -4272,7 +4272,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 v2 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 "/".

Signed-off-by: Günther Noack <gnoack3000@gmail.com>
---
 tools/testing/selftests/landlock/sandbox-and-launch.c |  6 +++---
 tools/testing/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 v2 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().

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 0df8ae88d4fa..66d68a92c6cd 100644
--- a/tools/testing/selftests/landlock/common.h
+++ b/tools/testing/selftests/landlock/common.h
@@ -36,7 +36,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 v2 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.

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/cap_test.c        | 30 +++++-----
 tools/testing/selftests/landlock/fs_test.c         | 50 ++++++++--------
 tools/testing/selftests/landlock/net_test.c        | 24 ++++----
 tools/testing/selftests/landlock/ns_test.c         | 68 +++++++++++-----------
 tools/testing/selftests/landlock/ptrace_test.c     | 14 ++---
 .../selftests/landlock/scoped_abstract_unix_test.c | 14 ++---
 8 files changed, 124 insertions(+), 124 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 9a1d5b8aacb8..b1a729b94e7b 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 |
@@ -352,7 +352,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));
@@ -369,12 +369,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);
 
@@ -387,40 +387,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));
@@ -428,18 +428,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);
 
@@ -465,7 +465,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));
@@ -596,7 +596,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 */
@@ -610,7 +610,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);
 
 		/*
@@ -629,7 +629,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);
@@ -641,7 +641,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/cap_test.c b/tools/testing/selftests/landlock/cap_test.c
index 5a7dbd26f92f..8e6e92450b13 100644
--- a/tools/testing/selftests/landlock/cap_test.c
+++ b/tools/testing/selftests/landlock/cap_test.c
@@ -243,7 +243,7 @@ TEST(add_rule_unknown_no_runtime_effect)
 	 * CAP_SYS_ADMIN.
 	 */
 	set_cap(_metadata, CAP_SYS_ADMIN);
-	EXPECT_EQ(-1, sethostname("test", 4));
+	ASSERT_EQ(-1, sethostname("test", 4));
 	EXPECT_EQ(EPERM, errno);
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 }
@@ -366,7 +366,7 @@ TEST_F(cap_enforce, use)
 	/* Test CAP_SYS_ADMIN via sethostname. */
 	set_cap(_metadata, CAP_SYS_ADMIN);
 	if (variant->expected_sysadmin) {
-		EXPECT_EQ(-1, sethostname("test", 4));
+		ASSERT_EQ(-1, sethostname("test", 4));
 		EXPECT_EQ(variant->expected_sysadmin, errno);
 	} else {
 		EXPECT_EQ(0, sethostname("test", 4));
@@ -376,7 +376,7 @@ TEST_F(cap_enforce, use)
 	/* Test CAP_SYS_CHROOT via chroot. */
 	set_cap(_metadata, CAP_SYS_CHROOT);
 	if (variant->expected_chroot) {
-		EXPECT_EQ(-1, chroot("/"));
+		ASSERT_EQ(-1, chroot("/"));
 		EXPECT_EQ(variant->expected_chroot, errno);
 	} else {
 		EXPECT_EQ(0, chroot("/"));
@@ -532,7 +532,7 @@ TEST_F(cap_stacking, two_layers)
 	/* Test CAP_SYS_ADMIN via sethostname. */
 	set_cap(_metadata, CAP_SYS_ADMIN);
 	if (variant->expected_sysadmin) {
-		EXPECT_EQ(-1, sethostname("test", 4));
+		ASSERT_EQ(-1, sethostname("test", 4));
 		EXPECT_EQ(variant->expected_sysadmin, errno);
 	} else {
 		EXPECT_EQ(0, sethostname("test", 4));
@@ -542,7 +542,7 @@ TEST_F(cap_stacking, two_layers)
 	/* Test CAP_SYS_CHROOT via chroot. */
 	set_cap(_metadata, CAP_SYS_CHROOT);
 	if (variant->expected_chroot) {
-		EXPECT_EQ(-1, chroot("/"));
+		ASSERT_EQ(-1, chroot("/"));
 		EXPECT_EQ(variant->expected_chroot, errno);
 	} else {
 		EXPECT_EQ(0, chroot("/"));
@@ -586,7 +586,7 @@ TEST(cap_without_nnp)
 	 * CAP_SYS_ADMIN is still in effective set but Landlock denies it:
 	 * cap_capable() returns 0, then hook_capable() returns -EPERM.
 	 */
-	EXPECT_EQ(-1, sethostname("test", 4));
+	ASSERT_EQ(-1, sethostname("test", 4));
 	EXPECT_EQ(EPERM, errno);
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 
@@ -654,7 +654,7 @@ TEST(cap_userns_ownership_bypass)
 		 * (from user NS creation), so cap_capable() returns 0.  But
 		 * Landlock denies because no rule allows CAP_SYS_CHROOT.
 		 */
-		EXPECT_EQ(-1, chroot("/"));
+		ASSERT_EQ(-1, chroot("/"));
 		EXPECT_EQ(EPERM, errno);
 
 		_exit(_metadata->exit_code);
@@ -810,7 +810,7 @@ TEST_F(cap_audit, denied)
 
 	/* Deny CAP_SYS_CHROOT (no allow rule). */
 	set_cap(_metadata, CAP_SYS_CHROOT);
-	EXPECT_EQ(-1, chroot("/"));
+	ASSERT_EQ(-1, chroot("/"));
 	EXPECT_EQ(EPERM, errno);
 	clear_cap(_metadata, CAP_SYS_CHROOT);
 
@@ -896,7 +896,7 @@ TEST_F(cap_audit, quieted)
 	EXPECT_EQ(0, close(ruleset_fd));
 
 	set_cap(_metadata, CAP_SYS_CHROOT);
-	EXPECT_EQ(-1, chroot("/"));
+	ASSERT_EQ(-1, chroot("/"));
 	EXPECT_EQ(EPERM, errno);
 	clear_cap(_metadata, CAP_SYS_CHROOT);
 
@@ -905,7 +905,7 @@ TEST_F(cap_audit, quieted)
 	 * denial IS logged.  This proves quieting is per-member, not global.
 	 */
 	set_cap(_metadata, CAP_SYS_ADMIN);
-	EXPECT_EQ(-1, sethostname("test", 4));
+	ASSERT_EQ(-1, sethostname("test", 4));
 	EXPECT_EQ(EPERM, errno);
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 
@@ -952,7 +952,7 @@ TEST_F(cap_audit, quiet_youngest_layer_wins)
 	EXPECT_EQ(0, close(ruleset_fd));
 
 	set_cap(_metadata, CAP_SYS_CHROOT);
-	EXPECT_EQ(-1, chroot("/"));
+	ASSERT_EQ(-1, chroot("/"));
 	EXPECT_EQ(EPERM, errno);
 	clear_cap(_metadata, CAP_SYS_CHROOT);
 
@@ -986,7 +986,7 @@ TEST_F(cap_audit, quiet_unknown_bit_no_effect)
 	EXPECT_EQ(0, close(ruleset_fd));
 
 	set_cap(_metadata, CAP_SYS_CHROOT);
-	EXPECT_EQ(-1, chroot("/"));
+	ASSERT_EQ(-1, chroot("/"));
 	EXPECT_EQ(EPERM, errno);
 	clear_cap(_metadata, CAP_SYS_CHROOT);
 
@@ -1059,7 +1059,7 @@ TEST_F(cap_audit, noaudit_probe_not_logged)
 	 * domain IS logged.  This proves the empty record set above is caused
 	 * by CAP_OPT_NOAUDIT, not by an always-allow or always-silent bug.
 	 */
-	EXPECT_EQ(-1, sethostname("test", 4));
+	ASSERT_EQ(-1, sethostname("test", 4));
 	EXPECT_EQ(EPERM, errno);
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 
@@ -1271,12 +1271,12 @@ static void exercise_cap_trace_denial(struct __test_metadata *const _metadata,
 		EXPECT_EQ(0, close(fd));
 
 		/* Control: an ordinary denial in the same domain is traced. */
-		EXPECT_EQ(-1, chroot("/"));
+		ASSERT_EQ(-1, chroot("/"));
 		EXPECT_EQ(EPERM, errno);
 		clear_cap(_metadata, CAP_SYS_ADMIN);
 		clear_cap(_metadata, CAP_SYS_CHROOT);
 	} else {
-		EXPECT_EQ(-1, chroot("/"));
+		ASSERT_EQ(-1, chroot("/"));
 		EXPECT_EQ(EPERM, errno);
 		clear_cap(_metadata, CAP_SYS_CHROOT);
 	}
diff --git a/tools/testing/selftests/landlock/fs_test.c b/tools/testing/selftests/landlock/fs_test.c
index 78b2bf06b6ee..fe1ca9c2d949 100644
--- a/tools/testing/selftests/landlock/fs_test.c
+++ b/tools/testing/selftests/landlock/fs_test.c
@@ -671,7 +671,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);
@@ -705,7 +705,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);
 		}
 	}
@@ -2062,7 +2062,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);
 
@@ -2257,7 +2257,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);
 }
@@ -2347,7 +2347,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);
 
@@ -2397,7 +2397,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);
 
@@ -2630,11 +2630,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));
@@ -5394,14 +5394,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);
@@ -7626,12 +7626,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));
@@ -7647,7 +7647,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));
@@ -7665,7 +7665,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));
@@ -7684,7 +7684,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));
@@ -7702,7 +7702,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));
@@ -7720,7 +7720,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));
@@ -7738,7 +7738,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));
@@ -7756,7 +7756,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));
@@ -7774,7 +7774,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));
@@ -7792,7 +7792,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));
@@ -7810,7 +7810,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));
@@ -7834,7 +7834,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));
@@ -7931,7 +7931,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));
@@ -8005,7 +8005,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/ns_test.c b/tools/testing/selftests/landlock/ns_test.c
index 57d03233bf6d..96b1264c4353 100644
--- a/tools/testing/selftests/landlock/ns_test.c
+++ b/tools/testing/selftests/landlock/ns_test.c
@@ -296,7 +296,7 @@ TEST(add_rule_unknown_no_runtime_effect)
 	 * CLONE_NEWUTS is a real, known CLONE_NEW* type but was not authorised
 	 * by the rule above; deny-by-default applies.
 	 */
-	EXPECT_EQ(-1, unshare(CLONE_NEWUTS));
+	ASSERT_EQ(-1, unshare(CLONE_NEWUTS));
 	EXPECT_EQ(EPERM, errno);
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 }
@@ -346,7 +346,7 @@ TEST(add_rule_unknown_no_runtime_effect_setns)
 	 * CLONE_NEWUTS is a real, known CLONE_NEW* type but was not authorised
 	 * by the rule above; deny-by-default applies at the install hook.
 	 */
-	EXPECT_EQ(-1, setns(ns_fd, CLONE_NEWUTS));
+	ASSERT_EQ(-1, setns(ns_fd, CLONE_NEWUTS));
 	EXPECT_EQ(EPERM, errno);
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 	EXPECT_EQ(0, close(ns_fd));
@@ -707,7 +707,7 @@ TEST_F(ns_create, unshare)
 
 	err = unshare(variant->namespace_types);
 	if (variant->expected_result) {
-		EXPECT_EQ(-1, err);
+		ASSERT_EQ(-1, err);
 		EXPECT_EQ(variant->expected_result, errno);
 	} else {
 		EXPECT_EQ(0, err);
@@ -753,7 +753,7 @@ TEST_F(ns_create, clone3)
 		_exit(EXIT_SUCCESS);
 
 	if (variant->expected_result) {
-		EXPECT_EQ(-1, pid);
+		ASSERT_EQ(-1, pid);
 		EXPECT_EQ(variant->expected_result, errno);
 	} else {
 		ASSERT_LE(0, pid);
@@ -821,7 +821,7 @@ TEST_F(ns_create, setns)
 
 	err = setns(ns_fd, variant->namespace_types);
 	if (expected) {
-		EXPECT_EQ(-1, err);
+		ASSERT_EQ(-1, err);
 		EXPECT_EQ(expected, errno);
 	} else {
 		EXPECT_EQ(0, err);
@@ -949,7 +949,7 @@ TEST_F(ns_stacking, two_layers)
 	if (expect_success) {
 		EXPECT_EQ(0, unshare(CLONE_NEWUSER));
 	} else {
-		EXPECT_EQ(-1, unshare(CLONE_NEWUSER));
+		ASSERT_EQ(-1, unshare(CLONE_NEWUSER));
 		EXPECT_EQ(EPERM, errno);
 	}
 }
@@ -997,7 +997,7 @@ TEST(combined_cap_ns)
 
 	/* CAP_SYS_CHROOT denied (not in allowed capability rules). */
 	set_cap(_metadata, CAP_SYS_CHROOT);
-	EXPECT_EQ(-1, chroot("/"));
+	ASSERT_EQ(-1, chroot("/"));
 	EXPECT_EQ(EPERM, errno);
 	clear_cap(_metadata, CAP_SYS_CHROOT);
 
@@ -1007,7 +1007,7 @@ TEST(combined_cap_ns)
 	 * to pass, so that Landlock's hook is actually reached.
 	 */
 	set_cap(_metadata, CAP_SYS_ADMIN);
-	EXPECT_EQ(-1, unshare(CLONE_NEWUTS));
+	ASSERT_EQ(-1, unshare(CLONE_NEWUTS));
 	EXPECT_EQ(EPERM, errno);
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 
@@ -1040,7 +1040,7 @@ TEST(ns_create_partial)
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 
 	/* User namespace should be denied (no rule). */
-	EXPECT_EQ(-1, unshare(CLONE_NEWUSER));
+	ASSERT_EQ(-1, unshare(CLONE_NEWUSER));
 	EXPECT_EQ(EPERM, errno);
 }
 
@@ -1117,7 +1117,7 @@ TEST_F(ns_mount_fd, open_tree_clone)
 	fd = sys_open_tree(AT_FDCWD, "/",
 			   OPEN_TREE_CLONE | OPEN_TREE_CLOEXEC | AT_RECURSIVE);
 	if (variant->expected_errno) {
-		EXPECT_EQ(-1, fd);
+		ASSERT_EQ(-1, fd);
 		EXPECT_EQ(variant->expected_errno, errno);
 	} else {
 		ASSERT_LE(0, fd);
@@ -1152,7 +1152,7 @@ TEST_F(ns_mount_fd, open_tree_namespace)
 			   OPEN_TREE_NAMESPACE | OPEN_TREE_CLOEXEC |
 				   AT_RECURSIVE);
 	if (variant->expected_errno) {
-		EXPECT_EQ(-1, fd);
+		ASSERT_EQ(-1, fd);
 		EXPECT_EQ(variant->expected_errno, errno);
 	} else {
 		ASSERT_LE(0, fd);
@@ -1189,7 +1189,7 @@ TEST_F(ns_mount_fd, fsmount_default)
 
 	mnt_fd = sys_fsmount(fs_fd, FSMOUNT_CLOEXEC, 0);
 	if (variant->expected_errno) {
-		EXPECT_EQ(-1, mnt_fd);
+		ASSERT_EQ(-1, mnt_fd);
 		EXPECT_EQ(variant->expected_errno, errno);
 	} else {
 		ASSERT_LE(0, mnt_fd);
@@ -1225,7 +1225,7 @@ TEST_F(ns_mount_fd, fsmount_namespace)
 
 	mnt_fd = sys_fsmount(fs_fd, FSMOUNT_CLOEXEC | FSMOUNT_NAMESPACE, 0);
 	if (variant->expected_errno) {
-		EXPECT_EQ(-1, mnt_fd);
+		ASSERT_EQ(-1, mnt_fd);
 		EXPECT_EQ(variant->expected_errno, errno);
 	} else {
 		ASSERT_LE(0, mnt_fd);
@@ -1297,7 +1297,7 @@ TEST_F(ns_create_multi_flag, unshare)
 
 		err = unshare(CLONE_NEWUSER | CLONE_NEWUTS);
 		if (variant->expected_errno) {
-			EXPECT_EQ(-1, err);
+			ASSERT_EQ(-1, err);
 			EXPECT_EQ(variant->expected_errno, errno);
 		} else {
 			EXPECT_EQ(0, err);
@@ -1425,7 +1425,7 @@ TEST_F(setns_cross_process, setns)
 
 	set_cap(_metadata, CAP_SYS_ADMIN);
 	if (variant->expected_setns) {
-		EXPECT_EQ(-1, setns(ns_fd, CLONE_NEWUTS));
+		ASSERT_EQ(-1, setns(ns_fd, CLONE_NEWUTS));
 		EXPECT_EQ(variant->expected_setns, errno);
 	} else {
 		EXPECT_EQ(0, setns(ns_fd, CLONE_NEWUTS));
@@ -1480,7 +1480,7 @@ TEST(setns_and_create)
 	ASSERT_EQ(0, unshare(CLONE_NEWUTS));
 
 	/* IPC unshare: denied by NS rule (type not allowed). */
-	EXPECT_EQ(-1, unshare(CLONE_NEWIPC));
+	ASSERT_EQ(-1, unshare(CLONE_NEWIPC));
 	EXPECT_EQ(EPERM, errno);
 
 	/* setns into current UTS: allowed by NS rule. */
@@ -1495,7 +1495,7 @@ TEST(setns_and_create)
 	 * needed (no capable() call from the kernel for user NS).  Denied
 	 * because CLONE_NEWUSER is not in the allowed namespace types.
 	 */
-	EXPECT_EQ(-1, unshare(CLONE_NEWUSER));
+	ASSERT_EQ(-1, unshare(CLONE_NEWUSER));
 	EXPECT_EQ(EPERM, errno);
 }
 
@@ -1542,7 +1542,7 @@ TEST(two_permissions_cap_denied)
 	 * fails before the namespace hook is reached.
 	 */
 	set_cap(_metadata, CAP_SYS_ADMIN);
-	EXPECT_EQ(-1, unshare(CLONE_NEWUTS));
+	ASSERT_EQ(-1, unshare(CLONE_NEWUTS));
 	EXPECT_EQ(EPERM, errno);
 
 	/*
@@ -1553,7 +1553,7 @@ TEST(two_permissions_cap_denied)
 	 */
 	ns_fd = open("/proc/self/ns/uts", O_RDONLY);
 	ASSERT_LE(0, ns_fd);
-	EXPECT_EQ(-1, setns(ns_fd, CLONE_NEWUTS));
+	ASSERT_EQ(-1, setns(ns_fd, CLONE_NEWUTS));
 	EXPECT_EQ(EPERM, errno);
 	EXPECT_EQ(0, close(ns_fd));
 	clear_cap(_metadata, CAP_SYS_ADMIN);
@@ -1605,7 +1605,7 @@ TEST(two_permissions_combined_unshare_denied)
 	 * created.
 	 */
 	set_cap(_metadata, CAP_SYS_ADMIN);
-	EXPECT_EQ(-1, unshare(CLONE_NEWUSER | CLONE_NEWUTS));
+	ASSERT_EQ(-1, unshare(CLONE_NEWUSER | CLONE_NEWUTS));
 	EXPECT_EQ(EPERM, errno);
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 
@@ -1712,7 +1712,7 @@ TEST(two_permissions_ns_denied)
 	 * in the allowed namespace types, so the Landlock namespace hook denies
 	 * it.
 	 */
-	EXPECT_EQ(-1, unshare(CLONE_NEWUTS));
+	ASSERT_EQ(-1, unshare(CLONE_NEWUTS));
 	EXPECT_EQ(EPERM, errno);
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 }
@@ -1764,7 +1764,7 @@ TEST(two_permissions_mnt_setns)
 	 */
 	set_cap(_metadata, CAP_SYS_ADMIN);
 	set_cap(_metadata, CAP_SYS_CHROOT);
-	EXPECT_EQ(-1, setns(ns_fd, CLONE_NEWNS));
+	ASSERT_EQ(-1, setns(ns_fd, CLONE_NEWNS));
 	EXPECT_EQ(EPERM, errno);
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 	clear_cap(_metadata, CAP_SYS_CHROOT);
@@ -1785,7 +1785,7 @@ TEST(two_permissions_mnt_setns)
 	 */
 	set_cap(_metadata, CAP_SYS_ADMIN);
 	set_cap(_metadata, CAP_SYS_CHROOT);
-	EXPECT_EQ(-1, setns(ns_fd, CLONE_NEWNS));
+	ASSERT_EQ(-1, setns(ns_fd, CLONE_NEWNS));
 	EXPECT_EQ(EPERM, errno);
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 	clear_cap(_metadata, CAP_SYS_CHROOT);
@@ -1880,7 +1880,7 @@ TEST(setns_inherited_fd)
 		EXPECT_EQ(0, close(ruleset_fd));
 
 		set_cap(_metadata, CAP_SYS_ADMIN);
-		EXPECT_EQ(-1, setns(ns_fd, CLONE_NEWUTS));
+		ASSERT_EQ(-1, setns(ns_fd, CLONE_NEWUTS));
 		EXPECT_EQ(EPERM, errno);
 		clear_cap(_metadata, CAP_SYS_ADMIN);
 
@@ -1971,7 +1971,7 @@ TEST_F(ns_audit, create_denied)
 	EXPECT_EQ(0, close(ruleset_fd));
 
 	set_cap(_metadata, CAP_SYS_ADMIN);
-	EXPECT_EQ(-1, unshare(CLONE_NEWUTS));
+	ASSERT_EQ(-1, unshare(CLONE_NEWUTS));
 	EXPECT_EQ(EPERM, errno);
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 
@@ -2053,7 +2053,7 @@ TEST_F(ns_audit, setns_denied)
 	ASSERT_EQ(0, ioctl(ns_fd, NS_GET_ID, &ns_id));
 
 	set_cap(_metadata, CAP_SYS_ADMIN);
-	EXPECT_EQ(-1, setns(ns_fd, CLONE_NEWUTS));
+	ASSERT_EQ(-1, setns(ns_fd, CLONE_NEWUTS));
 	EXPECT_EQ(EPERM, errno);
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 	EXPECT_EQ(0, close(ns_fd));
@@ -2089,7 +2089,7 @@ TEST_F(ns_audit, create_quieted)
 	EXPECT_EQ(0, close(ruleset_fd));
 
 	set_cap(_metadata, CAP_SYS_ADMIN);
-	EXPECT_EQ(-1, unshare(CLONE_NEWUTS));
+	ASSERT_EQ(-1, unshare(CLONE_NEWUTS));
 	EXPECT_EQ(EPERM, errno);
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 
@@ -2117,7 +2117,7 @@ TEST_F(ns_audit, setns_quieted)
 	ASSERT_LE(0, ns_fd);
 
 	set_cap(_metadata, CAP_SYS_ADMIN);
-	EXPECT_EQ(-1, setns(ns_fd, CLONE_NEWUTS));
+	ASSERT_EQ(-1, setns(ns_fd, CLONE_NEWUTS));
 	EXPECT_EQ(EPERM, errno);
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 	EXPECT_EQ(0, close(ns_fd));
@@ -2147,7 +2147,7 @@ TEST_F(ns_audit, quiet_is_per_member)
 	EXPECT_EQ(0, close(ruleset_fd));
 
 	set_cap(_metadata, CAP_SYS_ADMIN);
-	EXPECT_EQ(-1, unshare(CLONE_NEWUTS));
+	ASSERT_EQ(-1, unshare(CLONE_NEWUTS));
 	EXPECT_EQ(EPERM, errno);
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 
@@ -2179,7 +2179,7 @@ TEST_F(ns_audit, quiet_unknown_bit_no_effect)
 	EXPECT_EQ(0, close(ruleset_fd));
 
 	set_cap(_metadata, CAP_SYS_ADMIN);
-	EXPECT_EQ(-1, unshare(CLONE_NEWUTS));
+	ASSERT_EQ(-1, unshare(CLONE_NEWUTS));
 	EXPECT_EQ(EPERM, errno);
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 
@@ -2208,7 +2208,7 @@ TEST_F(ns_audit, allow_and_quiet)
 	set_cap(_metadata, CAP_SYS_ADMIN);
 	EXPECT_EQ(0, unshare(CLONE_NEWNET));
 	/* Quieted member: denied but not logged. */
-	EXPECT_EQ(-1, unshare(CLONE_NEWUTS));
+	ASSERT_EQ(-1, unshare(CLONE_NEWUTS));
 	EXPECT_EQ(EPERM, errno);
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 
@@ -2266,7 +2266,7 @@ TEST_F(ns_audit, quiet_youngest_layer_wins)
 	EXPECT_EQ(0, close(ruleset_fd));
 
 	set_cap(_metadata, CAP_SYS_ADMIN);
-	EXPECT_EQ(-1, unshare(CLONE_NEWUTS));
+	ASSERT_EQ(-1, unshare(CLONE_NEWUTS));
 	EXPECT_EQ(EPERM, errno);
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 
@@ -2302,7 +2302,7 @@ TEST_F(ns_audit, quiet_parent_only_denying_layer)
 	EXPECT_EQ(0, close(ruleset_fd));
 
 	set_cap(_metadata, CAP_SYS_ADMIN);
-	EXPECT_EQ(-1, unshare(CLONE_NEWUTS));
+	ASSERT_EQ(-1, unshare(CLONE_NEWUTS));
 	EXPECT_EQ(EPERM, errno);
 	clear_cap(_metadata, CAP_SYS_ADMIN);
 
@@ -2498,7 +2498,7 @@ static void test_ns_trace_denial(struct __test_metadata *const _metadata,
 		ret = setns(ns_fd, CLONE_NEWUTS);
 	else
 		ret = unshare(CLONE_NEWUTS);
-	EXPECT_EQ(-1, ret);
+	ASSERT_EQ(-1, ret);
 	EXPECT_EQ(EPERM, errno);
 
 	clear_cap(_metadata, CAP_SYS_ADMIN);
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 v2 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.

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 b1a729b94e7b..4cb30b943aa8 100644
--- a/tools/testing/selftests/landlock/base_test.c
+++ b/tools/testing/selftests/landlock/base_test.c
@@ -637,7 +637,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 fe1ca9c2d949..183dfc42895c 100644
--- a/tools/testing/selftests/landlock/fs_test.c
+++ b/tools/testing/selftests/landlock/fs_test.c
@@ -4640,7 +4640,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. */
@@ -4739,7 +4739,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));
 }
 
@@ -5409,7 +5409,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))
@@ -5431,7 +5431,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));
 
 	/*
@@ -7985,7 +7985,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 v2 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.

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 +++++++++++------------
 tools/testing/selftests/landlock/ptrace_test.c   |  16 ++--
 tools/testing/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 4cb30b943aa8..46af291edaef 100644
--- a/tools/testing/selftests/landlock/base_test.c
+++ b/tools/testing/selftests/landlock/base_test.c
@@ -203,7 +203,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. */
@@ -249,8 +249,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. */
@@ -272,7 +272,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);
@@ -307,7 +307,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)
@@ -328,7 +328,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++)
@@ -342,7 +342,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)
@@ -496,7 +496,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. */
@@ -525,14 +525,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);
@@ -540,32 +540,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));
@@ -670,9 +670,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);
@@ -700,7 +700,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 183dfc42895c..408e4b220e02 100644
--- a/tools/testing/selftests/landlock/fs_test.c
+++ b/tools/testing/selftests/landlock/fs_test.c
@@ -492,7 +492,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);
@@ -500,7 +500,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 =
@@ -508,14 +508,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;
@@ -556,13 +556,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 */
@@ -632,9 +632,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)
@@ -676,8 +676,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)
@@ -734,7 +734,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 {
@@ -836,7 +836,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)
@@ -859,7 +859,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)
@@ -907,14 +907,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)
@@ -1363,7 +1363,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
@@ -1474,7 +1474,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)
@@ -1763,7 +1763,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));
@@ -1886,8 +1886,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)
@@ -1929,8 +1929,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,
@@ -3575,7 +3575,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)
@@ -3585,7 +3585,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)
@@ -3626,7 +3626,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);
@@ -3637,10 +3637,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. */
@@ -3901,10 +3901,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 */
@@ -3995,7 +3995,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));
 	}
 }
 
@@ -4032,10 +4032,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;
@@ -4047,15 +4047,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. */
@@ -4089,7 +4089,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);
@@ -4120,7 +4120,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);
@@ -4136,7 +4136,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));
 }
 
 /* Arbitrary command with nonzero bits in both 16-bit halves. */
@@ -4171,7 +4171,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;
@@ -4247,7 +4247,7 @@ TEST_F_FORK(layout1, blanket_permitted_ioctls)
 	/* Default case is also blocked. */
 	EXPECT_EQ(EACCES, ioctl_error(_metadata, fd, unknown_ioctl_cmd));
 
-	ASSERT_EQ(0, close(fd));
+	EXPECT_EQ(0, close(fd));
 }
 
 /*
@@ -4281,10 +4281,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));
 }
 
 /*
@@ -4437,7 +4437,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)
@@ -4479,7 +4479,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)
@@ -4513,7 +4513,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));
 }
 
 /*
@@ -7431,7 +7431,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));
@@ -8164,7 +8164,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),
@@ -8299,7 +8299,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 1795d41b779f..0effe5d6d973 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);
@@ -514,7 +514,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);
@@ -550,7 +550,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 v2 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.

Signed-off-by: Günther Noack <gnoack3000@gmail.com>
---
 tools/testing/selftests/landlock/audit_test.c      |   10 +-
 tools/testing/selftests/landlock/base_test.c       |  104 +-
 tools/testing/selftests/landlock/cap_test.c        |   22 +-
 tools/testing/selftests/landlock/fs_test.c         | 1024 ++++++++++----------
 tools/testing/selftests/landlock/net_test.c        |    2 +-
 tools/testing/selftests/landlock/ns_test.c         |   26 +-
 .../selftests/landlock/scoped_abstract_unix_test.c |    8 +-
 .../selftests/landlock/scoped_signal_test.c        |    6 +-
 tools/testing/selftests/landlock/scoped_test.c     |    2 +-
 9 files changed, 602 insertions(+), 602 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 46af291edaef..c055280015ad 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);
 }
 
 #define PERMISSION_LAST LANDLOCK_PERMISSION_CAPABILITY_USE
@@ -159,7 +159,7 @@ TEST(ruleset_with_unknown_permission)
 		/* Unknown handled_permissions values must be rejected. */
 		ASSERT_EQ(-1, landlock_create_ruleset(&ruleset_attr,
 						      sizeof(ruleset_attr), 0));
-		ASSERT_EQ(EINVAL, errno);
+		EXPECT_EQ(EINVAL, errno);
 	}
 }
 
@@ -175,29 +175,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 =
@@ -223,25 +223,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 =
@@ -281,11 +281,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
@@ -293,17 +293,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));
@@ -338,7 +338,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));
@@ -492,9 +492,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));
 }
@@ -549,7 +549,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));
@@ -569,7 +569,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)
@@ -667,7 +667,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));
@@ -675,7 +675,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)
@@ -698,7 +698,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));
 }
@@ -721,15 +721,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)
@@ -750,15 +750,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/cap_test.c b/tools/testing/selftests/landlock/cap_test.c
index 8e6e92450b13..2b5767f70e26 100644
--- a/tools/testing/selftests/landlock/cap_test.c
+++ b/tools/testing/selftests/landlock/cap_test.c
@@ -80,14 +80,14 @@ TEST(add_rule_bad_attr)
 	/* Invalid rule pointer returns EFAULT. */
 	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_CAPABILITY,
 					NULL, 0));
-	ASSERT_EQ(EFAULT, errno);
+	EXPECT_EQ(EFAULT, errno);
 
 	/* Empty permissions selector returns ENOMSG. */
 	attr.permissions = 0;
 	attr.allowed_capabilities = (1ULL << CAP_NET_RAW);
 	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_CAPABILITY,
 					&attr, 0));
-	ASSERT_EQ(ENOMSG, errno);
+	EXPECT_EQ(ENOMSG, errno);
 
 	/* Useless rule: neither allowed nor quiet capabilities set. */
 	attr.permissions = LANDLOCK_PERMISSION_CAPABILITY_USE;
@@ -95,7 +95,7 @@ TEST(add_rule_bad_attr)
 	attr.quiet_capabilities = 0;
 	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_CAPABILITY,
 					&attr, 0));
-	ASSERT_EQ(ENOMSG, errno);
+	EXPECT_EQ(ENOMSG, errno);
 
 	/* Quiet-only rule (empty allowed set) is legal. */
 	attr.permissions = LANDLOCK_PERMISSION_CAPABILITY_USE;
@@ -117,14 +117,14 @@ TEST(add_rule_bad_attr)
 	attr.allowed_capabilities = (1ULL << CAP_NET_RAW);
 	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_CAPABILITY,
 					&attr, 0));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 
 	/* permissions with wrong type. */
 	attr.permissions = LANDLOCK_PERMISSION_NAMESPACE_USE;
 	attr.allowed_capabilities = (1ULL << CAP_NET_RAW);
 	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_CAPABILITY,
 					&attr, 0));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 
 	/*
 	 * Unknown capability bits (e.g. bit 63) are silently accepted for
@@ -145,7 +145,7 @@ TEST(add_rule_bad_attr)
 	attr.allowed_capabilities = (1ULL << CAP_NET_RAW);
 	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_CAPABILITY,
 					&attr, LANDLOCK_ADD_RULE_QUIET));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 
 	EXPECT_EQ(0, close(ruleset_fd));
 
@@ -161,7 +161,7 @@ TEST(add_rule_bad_attr)
 	attr.allowed_capabilities = (1ULL << CAP_NET_RAW);
 	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_CAPABILITY,
 					&attr, 0));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 	EXPECT_EQ(0, close(ruleset_fd));
 }
 
@@ -705,7 +705,7 @@ TEST(cap_target_userns_independent)
 	EXPECT_EQ(0, close(sockets[0]));
 	ASSERT_EQ(target, waitpid(target, &status, 0));
 	ASSERT_TRUE(WIFEXITED(status));
-	ASSERT_EQ(EXIT_SUCCESS, WEXITSTATUS(status));
+	EXPECT_EQ(EXIT_SUCCESS, WEXITSTATUS(status));
 
 	set_cap(_metadata, CAP_SYS_ADMIN);
 	for (int sandboxed = 0; sandboxed <= 1; sandboxed++) {
@@ -1154,10 +1154,10 @@ TEST_F(cap_trace, rule_events)
 				       1ULL << CAP_SYS_CHROOT));
 	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_CAPABILITY,
 					&invalid_attr, 0));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_CAPABILITY,
 					&valid_attr, LANDLOCK_ADD_RULE_QUIET));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 	ASSERT_EQ(0, add_cap_rule_full(ruleset_fd, 1ULL << CAP_SYS_ADMIN,
 				       1ULL << CAP_SYS_CHROOT));
 	ASSERT_EQ(0, add_cap_rule(ruleset_fd, 63));
@@ -1303,7 +1303,7 @@ static void test_cap_trace_denial(struct __test_metadata *const _metadata,
 
 	ASSERT_EQ(child, waitpid(child, &status, 0));
 	ASSERT_TRUE(WIFEXITED(status));
-	ASSERT_EQ(EXIT_SUCCESS, WEXITSTATUS(status));
+	EXPECT_EQ(EXIT_SUCCESS, WEXITSTATUS(status));
 
 	buf = tracefs_read_buf();
 	ASSERT_NE(NULL, buf);
diff --git a/tools/testing/selftests/landlock/fs_test.c b/tools/testing/selftests/landlock/fs_test.c
index 408e4b220e02..c3357ed08e1e 100644
--- a/tools/testing/selftests/landlock/fs_test.c
+++ b/tools/testing/selftests/landlock/fs_test.c
@@ -332,7 +332,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));
@@ -448,25 +448,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)
@@ -491,7 +491,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);
@@ -499,7 +499,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. */
@@ -521,7 +521,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 =
@@ -532,28 +532,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));
@@ -629,7 +629,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));
@@ -649,7 +649,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);
 	}
 }
 
@@ -806,24 +806,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
@@ -835,7 +835,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));
 }
 
@@ -855,7 +855,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);
@@ -882,23 +882,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);
@@ -913,7 +913,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));
 }
 
@@ -934,11 +934,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)
@@ -961,22 +961,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)
@@ -1014,67 +1014,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)
@@ -1100,7 +1100,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));
 
@@ -1108,12 +1108,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));
 }
 
@@ -1212,25 +1212,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,
@@ -1241,36 +1241,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)
@@ -1287,18 +1287,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
@@ -1321,18 +1321,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
@@ -1342,18 +1342,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
@@ -1372,21 +1372,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)
@@ -1403,11 +1403,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,
@@ -1418,11 +1418,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)
@@ -1443,7 +1443,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));
 }
@@ -1457,20 +1457,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);
@@ -1494,13 +1494,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)
@@ -1520,13 +1520,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));
 }
 
 /*
@@ -1546,15 +1546,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)
@@ -1570,8 +1570,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)
@@ -1594,8 +1594,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)
@@ -1612,9 +1612,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);
 }
 
@@ -1644,7 +1644,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);
 }
 
@@ -1684,16 +1684,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);
 }
 
@@ -1724,10 +1724,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));
 }
 
 /*
@@ -1760,13 +1760,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 {
@@ -1853,35 +1853,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));
 	}
 
@@ -1953,7 +1953,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);
 	};
@@ -1995,18 +1995,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);
 }
@@ -2085,7 +2085,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)
@@ -2112,15 +2112,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));
@@ -2189,47 +2189,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,
@@ -2437,12 +2437,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
@@ -2450,16 +2450,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
@@ -2490,22 +2490,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));
@@ -2704,27 +2704,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));
@@ -2738,9 +2738,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));
@@ -2779,57 +2779,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));
 
@@ -2861,17 +2861,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));
@@ -2880,12 +2880,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
@@ -2969,14 +2969,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
@@ -2984,7 +2984,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)
@@ -2993,42 +2993,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)
@@ -3046,10 +3046,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
@@ -3057,10 +3057,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,
@@ -3093,46 +3093,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. */
 }
@@ -3150,10 +3150,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)
@@ -3174,10 +3174,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)
@@ -3207,23 +3207,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));
@@ -3235,7 +3235,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)
@@ -3276,13 +3276,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
@@ -3292,13 +3292,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
@@ -3315,7 +3315,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));
 	/*
@@ -3324,7 +3324,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)
@@ -3350,13 +3350,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)
@@ -3372,9 +3372,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));
 }
@@ -3408,11 +3408,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))
 	{
@@ -3500,11 +3500,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));
@@ -3535,7 +3535,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));
 }
@@ -3567,8 +3567,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));
@@ -3583,7 +3583,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));
 }
@@ -3606,8 +3606,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));
@@ -4052,7 +4052,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]));
@@ -5039,24 +5039,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)
@@ -5113,73 +5113,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)
@@ -5203,15 +5203,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));
@@ -6846,33 +6846,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)               \
@@ -7016,29 +7016,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
@@ -7047,13 +7047,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). */
@@ -7061,13 +7061,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. */
@@ -7075,21 +7075,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. */
@@ -7097,24 +7097,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. */
@@ -7122,22 +7122,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));
 	}
 }
 
@@ -7434,7 +7434,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,
@@ -7914,7 +7914,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",
@@ -8233,7 +8233,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;
@@ -8248,12 +8248,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)
@@ -8265,11 +8265,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));
@@ -8289,7 +8289,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,
@@ -8298,7 +8298,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));
 		}
 	}
@@ -9687,10 +9687,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));
 	}
 	/*
@@ -9698,7 +9698,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)
@@ -9813,11 +9813,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)
@@ -9849,16 +9849,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)
@@ -9890,14 +9890,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)
@@ -9921,10 +9921,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)
@@ -9953,18 +9953,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)
@@ -9993,15 +9993,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)
@@ -10049,17 +10049,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)
@@ -10107,14 +10107,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)
@@ -10162,13 +10162,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,
@@ -10206,15 +10206,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,
@@ -10258,14 +10258,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)
@@ -10295,10 +10295,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)
@@ -10324,10 +10324,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)
@@ -10353,13 +10353,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)
@@ -10394,10 +10394,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)
@@ -10432,10 +10432,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/ns_test.c b/tools/testing/selftests/landlock/ns_test.c
index 96b1264c4353..5c93f7010bbd 100644
--- a/tools/testing/selftests/landlock/ns_test.c
+++ b/tools/testing/selftests/landlock/ns_test.c
@@ -121,14 +121,14 @@ TEST(add_rule_bad_attr)
 	/* Invalid rule pointer returns EFAULT. */
 	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_NAMESPACE,
 					NULL, 0));
-	ASSERT_EQ(EFAULT, errno);
+	EXPECT_EQ(EFAULT, errno);
 
 	/* Empty permissions selector returns ENOMSG. */
 	attr.permissions = 0;
 	attr.allowed_namespace_types = CLONE_NEWUTS;
 	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_NAMESPACE,
 					&attr, 0));
-	ASSERT_EQ(ENOMSG, errno);
+	EXPECT_EQ(ENOMSG, errno);
 
 	/* Valid namespace selector plus an extra unhandled selector bit. */
 	attr.permissions = LANDLOCK_PERMISSION_NAMESPACE_USE |
@@ -136,14 +136,14 @@ TEST(add_rule_bad_attr)
 	attr.allowed_namespace_types = CLONE_NEWUTS;
 	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_NAMESPACE,
 					&attr, 0));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 
 	/* permissions with wrong type. */
 	attr.permissions = LANDLOCK_PERMISSION_CAPABILITY_USE;
 	attr.allowed_namespace_types = CLONE_NEWUTS;
 	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_NAMESPACE,
 					&attr, 0));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 
 	/*
 	 * Unknown namespace bits (e.g. bit 63) are silently accepted for
@@ -160,7 +160,7 @@ TEST(add_rule_bad_attr)
 	attr.quiet_namespace_types = 0;
 	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_NAMESPACE,
 					&attr, 0));
-	ASSERT_EQ(ENOMSG, errno);
+	EXPECT_EQ(ENOMSG, errno);
 
 	/* Quiet-only rule (empty allowed set) is legal. */
 	attr.permissions = LANDLOCK_PERMISSION_NAMESPACE_USE;
@@ -201,7 +201,7 @@ TEST(add_rule_bad_attr)
 	attr.allowed_namespace_types = CLONE_NEWUTS;
 	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_NAMESPACE,
 					&attr, LANDLOCK_ADD_RULE_QUIET));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 
 	EXPECT_EQ(0, close(ruleset_fd));
 
@@ -217,7 +217,7 @@ TEST(add_rule_bad_attr)
 	attr.allowed_namespace_types = CLONE_NEWUTS;
 	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_NAMESPACE,
 					&attr, 0));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 	EXPECT_EQ(0, close(ruleset_fd));
 }
 
@@ -759,7 +759,7 @@ TEST_F(ns_create, clone3)
 		ASSERT_LE(0, pid);
 		ASSERT_EQ(pid, waitpid(pid, &status, 0));
 		ASSERT_EQ(1, WIFEXITED(status));
-		ASSERT_EQ(EXIT_SUCCESS, WEXITSTATUS(status));
+		EXPECT_EQ(EXIT_SUCCESS, WEXITSTATUS(status));
 	}
 
 	if (!variant->drop_all_caps &&
@@ -1307,7 +1307,7 @@ TEST_F(ns_create_multi_flag, unshare)
 
 	ASSERT_EQ(child, waitpid(child, &status, 0));
 	ASSERT_EQ(1, WIFEXITED(status));
-	ASSERT_EQ(EXIT_SUCCESS, WEXITSTATUS(status));
+	EXPECT_EQ(EXIT_SUCCESS, WEXITSTATUS(status));
 }
 
 /* clang-format off */
@@ -1438,7 +1438,7 @@ TEST_F(setns_cross_process, setns)
 	EXPECT_EQ(0, close(pipe_parent[1]));
 	ASSERT_EQ(child, waitpid(child, &status, 0));
 	ASSERT_EQ(1, WIFEXITED(status));
-	ASSERT_EQ(EXIT_SUCCESS, WEXITSTATUS(status));
+	EXPECT_EQ(EXIT_SUCCESS, WEXITSTATUS(status));
 }
 
 /*
@@ -1660,7 +1660,7 @@ TEST(two_permissions_combined_unshare_allowed)
 	}
 	ASSERT_EQ(child, waitpid(child, &status, 0));
 	ASSERT_EQ(1, WIFEXITED(status));
-	ASSERT_EQ(EXIT_SUCCESS, WEXITSTATUS(status));
+	EXPECT_EQ(EXIT_SUCCESS, WEXITSTATUS(status));
 }
 
 /*
@@ -2393,10 +2393,10 @@ TEST_F(ns_trace, rule_events)
 	ASSERT_EQ(0, add_ns_rule_full(ruleset_fd, CLONE_NEWUTS, CLONE_NEWNET));
 	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_NAMESPACE,
 					&invalid_attr, 0));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 	ASSERT_EQ(-1, landlock_add_rule(ruleset_fd, LANDLOCK_RULE_NAMESPACE,
 					&valid_attr, LANDLOCK_ADD_RULE_QUIET));
-	ASSERT_EQ(EINVAL, errno);
+	EXPECT_EQ(EINVAL, errno);
 	ASSERT_EQ(0, add_ns_rule_full(ruleset_fd, CLONE_NEWUTS, CLONE_NEWNET));
 	ASSERT_EQ(0, add_ns_rule(ruleset_fd, 1ULL << 63));
 	EXPECT_EQ(0, close(ruleset_fd));
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