ztest: remove the obsolete NULL appended to zassert macros

This commit removes the usage of NULL parameter as message in
zassert_* macros after making it optional

Signed-off-by: Michał Barnaś <mb@semihalf.com>

subsys/bluetooth/controller/ll_sw/ull_llcp.c

@@ -1767,7 +1767,7 @@ void test_int_mem_proc_ctx(void)
 	}
 
 	nr_of_free_ctx = local_ctx_buffers_free();
-	zassert_equal(nr_of_free_ctx, 0, NULL);
+	zassert_equal(nr_of_free_ctx, 0);
 
 	ctx2 = proc_ctx_acquire(&mem_local_ctx);
 
@@ -1776,7 +1776,7 @@ void test_int_mem_proc_ctx(void)
 
 	llcp_proc_ctx_release(ctx1);
 	nr_of_free_ctx = local_ctx_buffers_free();
-	zassert_equal(nr_of_free_ctx, 1, NULL);
+	zassert_equal(nr_of_free_ctx, 1);
 
 	ctx1 = proc_ctx_acquire(&mem_local_ctx);
 
@@ -1858,8 +1858,8 @@ void test_int_create_proc(void)
 	ctx = create_procedure(PROC_VERSION_EXCHANGE, &mem_local_ctx);
 	zassert_not_null(ctx, NULL);
 
-	zassert_equal(ctx->proc, PROC_VERSION_EXCHANGE, NULL);
+	zassert_equal(ctx->proc, PROC_VERSION_EXCHANGE);
-	zassert_equal(ctx->collision, 0, NULL);
+	zassert_equal(ctx->collision, 0);
 
 	for (int i = 0U; i < CONFIG_BT_CTLR_LLCP_LOCAL_PROC_CTX_BUF_NUM; i++) {
 		zassert_not_null(ctx, NULL);
@@ -1881,8 +1881,8 @@ void test_int_llcp_init(void)
 
 	ull_llcp_init(&conn);
 
-	zassert_equal(conn.llcp.local.pause, 0, NULL);
+	zassert_equal(conn.llcp.local.pause, 0);
-	zassert_equal(conn.llcp.remote.pause, 0, NULL);
+	zassert_equal(conn.llcp.remote.pause, 0);
 }
 
 #endif

tests/arch/arm/arm_thread_swap_tz/src/main.c

@@ -89,7 +89,7 @@ ZTEST(thread_swap_tz, test_thread_swap_tz)
 	main_thread = (struct k_thread *)curr;
 
 	status = psa_crypto_init();
-	zassert_equal(PSA_SUCCESS, status, NULL);
+	zassert_equal(PSA_SUCCESS, status);
 
 	/* Calculate correct hash. */
 	do_hash(dummy_digest_correct);

tests/arch/arm/arm_tz_wrap_func/src/main.c

@@ -48,9 +48,9 @@ uint32_t foo1(uint32_t arg1, uint32_t arg2, uint32_t arg3, uint32_t arg4)
 	zassert_true(expect_foo1, "%s unexpectedly called", __func__);
 	zassert_equal(arg1, foo1_arg1, "Was 0x%"PRIx32", expected 0x%"PRIx32,
 		arg1, foo1_arg1);
-	zassert_equal(arg2, foo1_arg2, NULL);
+	zassert_equal(arg2, foo1_arg2);
-	zassert_equal(arg3, foo1_arg3, NULL);
+	zassert_equal(arg3, foo1_arg3);
-	zassert_equal(arg4, foo1_arg4, NULL);
+	zassert_equal(arg4, foo1_arg4);
 	expect_foo1 = false;
 	foo1_called = true;
 	expect_postface = true;
@@ -89,15 +89,15 @@ ZTEST(tz_wrap_func, test_tz_wrap_func)
 	zassert_equal(foo1_retval,
 		wrap_foo1(foo1_arg1, foo1_arg2, foo1_arg3, foo1_arg4), NULL);
 
-	zassert_equal(msp1, __get_MSP(), NULL);
+	zassert_equal(msp1, __get_MSP());
-	zassert_equal(psp1, __get_PSP(), NULL);
+	zassert_equal(psp1, __get_PSP());
 
-	zassert_true(preface_called, NULL);
+	zassert_true(preface_called);
-	zassert_true(foo1_called, NULL);
+	zassert_true(foo1_called);
-	zassert_true(postface_called, NULL);
+	zassert_true(postface_called);
-	zassert_false(expect_preface, NULL);
+	zassert_false(expect_preface);
-	zassert_false(expect_foo1, NULL);
+	zassert_false(expect_foo1);
-	zassert_false(expect_postface, NULL);
+	zassert_false(expect_postface);
 }
 
 ZTEST_SUITE(tz_wrap_func, NULL, NULL, NULL, NULL, NULL);

tests/benchmarks/data_structure_perf/rbtree_perf/src/rbtree_perf.c

@@ -136,7 +136,7 @@ static void verify_rbtree_perf(struct rbnode *root, struct rbnode *test)
 	uint32_t node_height = 0;
 
 	node_height = search_height_recurse(root, test, node_height);
-	zassert_true(node_height <= dlog_N, NULL);
+	zassert_true(node_height <= dlog_N);
 }
 
 /**

tests/bluetooth/controller/common/src/helper_pdu.c

@@ -518,7 +518,7 @@ void helper_pdu_verify_feature_req(const char *file, uint32_t line, struct pdu_d
 {
 	struct pdu_data_llctrl_feature_req *feature_req = param;
 
-	zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, NULL);
+	zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL);
 	zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_FEATURE_REQ,
 		      "Wrong opcode.\nCalled at %s:%d\n", file, line);
 
@@ -535,8 +535,8 @@ void helper_pdu_verify_peripheral_feature_req(const char *file, uint32_t line, s
 {
 	struct pdu_data_llctrl_feature_req *feature_req = param;
 
-	zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, NULL);
+	zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL);
-	zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_PER_INIT_FEAT_XCHG, NULL);
+	zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_PER_INIT_FEAT_XCHG);
 
 	for (int counter = 0; counter < 8; counter++) {
 		uint8_t expected_value = feature_req->features[counter];
@@ -551,7 +551,7 @@ void helper_pdu_verify_feature_rsp(const char *file, uint32_t line, struct pdu_d
 {
 	struct pdu_data_llctrl_feature_rsp *feature_rsp = param;
 
-	zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL, NULL);
+	zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL);
 	zassert_equal(pdu->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_FEATURE_RSP,
 		      "Response: %d Expected: %d\n", pdu->llctrl.opcode,
 		      PDU_DATA_LLCTRL_TYPE_FEATURE_RSP);

tests/bluetooth/controller/ctrl_api/src/main.c

@@ -54,8 +54,8 @@ void test_api_init(void)
 
 	ull_llcp_init(&conn);
 
-	zassert_true(lr_is_disconnected(&conn), NULL);
+	zassert_true(lr_is_disconnected(&conn));
-	zassert_true(rr_is_disconnected(&conn), NULL);
+	zassert_true(rr_is_disconnected(&conn));
 }
 
 extern void test_int_mem_proc_ctx(void);
@@ -72,8 +72,8 @@ void test_api_connect(void)
 	ull_llcp_init(&conn);
 
 	ull_cp_state_set(&conn, ULL_CP_CONNECTED);
-	zassert_true(lr_is_idle(&conn), NULL);
+	zassert_true(lr_is_idle(&conn));
-	zassert_true(rr_is_idle(&conn), NULL);
+	zassert_true(rr_is_idle(&conn));
 }
 
 void test_api_disconnect(void)
@@ -83,16 +83,16 @@ void test_api_disconnect(void)
 	ull_llcp_init(&conn);
 
 	ull_cp_state_set(&conn, ULL_CP_DISCONNECTED);
-	zassert_true(lr_is_disconnected(&conn), NULL);
+	zassert_true(lr_is_disconnected(&conn));
-	zassert_true(rr_is_disconnected(&conn), NULL);
+	zassert_true(rr_is_disconnected(&conn));
 
 	ull_cp_state_set(&conn, ULL_CP_CONNECTED);
-	zassert_true(lr_is_idle(&conn), NULL);
+	zassert_true(lr_is_idle(&conn));
-	zassert_true(rr_is_idle(&conn), NULL);
+	zassert_true(rr_is_idle(&conn));
 
 	ull_cp_state_set(&conn, ULL_CP_DISCONNECTED);
-	zassert_true(lr_is_disconnected(&conn), NULL);
+	zassert_true(lr_is_disconnected(&conn));
-	zassert_true(rr_is_disconnected(&conn), NULL);
+	zassert_true(rr_is_disconnected(&conn));
 }
 
 void test_int_disconnect_loc(void)
@@ -113,13 +113,13 @@ void test_int_disconnect_loc(void)
 	ull_cp_state_set(&conn, ULL_CP_CONNECTED);
 
 	nr_free_ctx = ctx_buffers_free();
-	zassert_equal(nr_free_ctx, test_ctx_buffers_cnt(), NULL);
+	zassert_equal(nr_free_ctx, test_ctx_buffers_cnt());
 
 	err = ull_cp_version_exchange(&conn);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	nr_free_ctx = ctx_buffers_free();
-	zassert_equal(nr_free_ctx, test_ctx_buffers_cnt() - 1, NULL);
+	zassert_equal(nr_free_ctx, test_ctx_buffers_cnt() - 1);
 
 	event_prepare(&conn);
 	lt_rx(LL_VERSION_IND, &conn, &tx, &local_version_ind);
@@ -132,7 +132,7 @@ void test_int_disconnect_loc(void)
 	ull_cp_state_set(&conn, ULL_CP_DISCONNECTED);
 
 	nr_free_ctx = ctx_buffers_free();
-	zassert_equal(nr_free_ctx, test_ctx_buffers_cnt(), NULL);
+	zassert_equal(nr_free_ctx, test_ctx_buffers_cnt());
 
 	ut_rx_q_is_empty();
 
@@ -143,7 +143,7 @@ void test_int_disconnect_loc(void)
 	event_done(&conn);
 
 	nr_free_ctx = ctx_buffers_free();
-	zassert_equal(nr_free_ctx, test_ctx_buffers_cnt(), NULL);
+	zassert_equal(nr_free_ctx, test_ctx_buffers_cnt());
 
 	/*
 	 * all buffers should still be empty
@@ -171,7 +171,7 @@ void test_int_disconnect_rem(void)
 	ull_cp_state_set(&conn, ULL_CP_CONNECTED);
 
 	nr_free_ctx = ctx_buffers_free();
-	zassert_equal(nr_free_ctx, test_ctx_buffers_cnt(), NULL);
+	zassert_equal(nr_free_ctx, test_ctx_buffers_cnt());
 	/* Prepare */
 	event_prepare(&conn);
 
@@ -179,7 +179,7 @@ void test_int_disconnect_rem(void)
 	lt_tx(LL_VERSION_IND, &conn, &remote_version_ind);
 
 	nr_free_ctx = ctx_buffers_free();
-	zassert_equal(nr_free_ctx, test_ctx_buffers_cnt(), NULL);
+	zassert_equal(nr_free_ctx, test_ctx_buffers_cnt());
 
 	/* Disconnect before we reply */
 
@@ -195,7 +195,7 @@ void test_int_disconnect_rem(void)
 	event_done(&conn);
 
 	nr_free_ctx = ctx_buffers_free();
-	zassert_equal(nr_free_ctx, test_ctx_buffers_cnt(), NULL);
+	zassert_equal(nr_free_ctx, test_ctx_buffers_cnt());
 
 	/* There should not be a host notifications */
 	ut_rx_q_is_empty();

tests/bluetooth/controller/ctrl_chmu/src/main.c

@@ -78,7 +78,7 @@ void test_channel_map_update_central_loc(void)
 	ull_cp_state_set(&conn, ULL_CP_CONNECTED);
 
 	err = ull_cp_chan_map_update(&conn, chm);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -157,7 +157,7 @@ void test_channel_map_update_central_invalid(void)
 	ull_cp_state_set(&conn, ULL_CP_CONNECTED);
 
 	err = ull_cp_chan_map_update(&conn, chm);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -350,7 +350,7 @@ void test_channel_map_update_periph_loc(void)
 	ull_cp_state_set(&conn, ULL_CP_CONNECTED);
 
 	err = ull_cp_chan_map_update(&conn, chm);
-	zassert_equal(err, BT_HCI_ERR_CMD_DISALLOWED, NULL);
+	zassert_equal(err, BT_HCI_ERR_CMD_DISALLOWED);
 
 	zassert_equal(ctx_buffers_free(), test_ctx_buffers_cnt(),
 				  "Free CTX buffers %d", ctx_buffers_free());

tests/bluetooth/controller/ctrl_cis_terminate/src/main.c

@@ -111,7 +111,7 @@ void test_cis_terminate_loc(uint8_t role)
 
 	/* Initiate an CIS Terminate Procedure */
 	err = ull_cp_cis_terminate(&conn, &cis, local_cis_terminate_ind.error_code);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);

tests/bluetooth/controller/ctrl_collision/src/main.c

@@ -178,7 +178,7 @@ void test_phy_update_central_loc_collision(void)
 
 	/* Initiate an PHY Update Procedure */
 	err = ull_cp_phy_update(&conn, PHY_2M, PREFER_S8_CODING, PHY_2M, 1);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/*** ***/
 
@@ -356,7 +356,7 @@ void test_phy_update_central_rem_collision(void)
 
 	/* Initiate an PHY Update Procedure */
 	err = ull_cp_phy_update(&conn, PHY_2M, PREFER_S8_CODING, PHY_2M, 1);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/*** ***/
 
@@ -517,7 +517,7 @@ void test_phy_update_periph_loc_collision(void)
 
 	/* Initiate an PHY Update Procedure */
 	err = ull_cp_phy_update(&conn, PHY_2M, PREFER_S8_CODING, PHY_2M, 1);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -644,7 +644,7 @@ void test_phy_conn_update_central_loc_collision(void)
 	/* (A) Initiate a PHY update procedure */
 
 	err = ull_cp_phy_update(&conn, PHY_2M, PREFER_S8_CODING, PHY_2M, 1);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);

tests/bluetooth/controller/ctrl_conn_update/src/main.c

@@ -239,7 +239,7 @@ void test_conn_update_central_loc_accept(void)
 
 	/* Initiate a Connection Parameter Request Procedure */
 	err = ull_cp_conn_update(&conn, INTVL_MIN, INTVL_MAX, LATENCY, TIMEOUT);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -391,7 +391,7 @@ void test_conn_update_central_loc_accept_reject_2nd_cpr(void)
 
 	/* Initiate a Connection Parameter Request Procedure */
 	err = ull_cp_conn_update(&conn, INTVL_MIN, INTVL_MAX, LATENCY, TIMEOUT);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -474,7 +474,7 @@ void test_conn_update_central_loc_accept_reject_2nd_cpr(void)
 
 	/* Initiate a parallel Connection Parameter Request Procedure */
 	err = ull_cp_conn_update(&conn_3rd, INTVL_MIN, INTVL_MAX, LATENCY, TIMEOUT);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn_3rd);
@@ -612,7 +612,7 @@ void test_conn_update_central_loc_invalid_param_rsp(void)
 
 	/* Initiate a Connection Parameter Request Procedure */
 	err = ull_cp_conn_update(&conn, INTVL_MIN, INTVL_MAX, LATENCY, TIMEOUT);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -681,7 +681,7 @@ void test_conn_update_central_loc_invalid_rsp(void)
 
 	/* Initiate a Connection Parameter Request Procedure */
 	err = ull_cp_conn_update(&conn, INTVL_MIN, INTVL_MAX, LATENCY, TIMEOUT);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -754,7 +754,7 @@ void test_conn_update_central_loc_reject(void)
 
 	/* Initiate a Connection Parameter Request Procedure */
 	err = ull_cp_conn_update(&conn, INTVL_MIN, INTVL_MAX, LATENCY, TIMEOUT);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -833,7 +833,7 @@ void test_conn_update_central_loc_remote_legacy(void)
 
 	/* Initiate a Connection Parameter Request Procedure */
 	err = ull_cp_conn_update(&conn, INTVL_MIN, INTVL_MAX, LATENCY, TIMEOUT);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -958,7 +958,7 @@ void test_conn_update_central_loc_unsupp_wo_feat_exch(void)
 
 	/* Initiate a Connection Parameter Request Procedure */
 	err = ull_cp_conn_update(&conn, INTVL_MIN, INTVL_MAX, LATENCY, TIMEOUT);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -1075,7 +1075,7 @@ void test_conn_update_central_loc_unsupp_w_feat_exch(void)
 
 	/* Initiate a Connection Parameter Request Procedure */
 	err = ull_cp_conn_update(&conn, INTVL_MIN, INTVL_MAX, LATENCY, TIMEOUT);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -1198,7 +1198,7 @@ void test_conn_update_central_loc_collision(void)
 
 	/* (A) Initiate a Connection Parameter Request Procedure */
 	err = ull_cp_conn_update(&conn, INTVL_MIN, INTVL_MAX, LATENCY, TIMEOUT);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -1649,7 +1649,7 @@ void test_conn_update_central_rem_collision(void)
 	/* (B) Initiate a Connection Parameter Request Procedure */
 	err = ull_cp_conn_update(&conn, req_B->interval_min, req_B->interval_max, req_B->latency,
 				 req_B->timeout);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -1831,7 +1831,7 @@ void test_conn_update_periph_loc_accept(void)
 
 	/* Initiate a Connection Parameter Request Procedure */
 	err = ull_cp_conn_update(&conn, INTVL_MIN, INTVL_MAX, LATENCY, TIMEOUT);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -1936,7 +1936,7 @@ void test_conn_update_periph_loc_reject(void)
 
 	/* Initiate a Connection Parameter Request Procedure */
 	err = ull_cp_conn_update(&conn, INTVL_MIN, INTVL_MAX, LATENCY, TIMEOUT);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -2015,7 +2015,7 @@ void test_conn_update_periph_loc_unsupp_feat_wo_feat_exch(void)
 
 	/* Initiate a Connection Parameter Request Procedure */
 	err = ull_cp_conn_update(&conn, INTVL_MIN, INTVL_MAX, LATENCY, TIMEOUT);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -2082,7 +2082,7 @@ void test_conn_update_periph_loc_unsupp_feat_w_feat_exch(void)
 
 	/* Initiate a Connection Parameter Request Procedure */
 	err = ull_cp_conn_update(&conn, INTVL_MIN, INTVL_MAX, LATENCY, TIMEOUT);
-	zassert_equal(err, BT_HCI_ERR_UNSUPP_REMOTE_FEATURE, NULL);
+	zassert_equal(err, BT_HCI_ERR_UNSUPP_REMOTE_FEATURE);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -2176,7 +2176,7 @@ void test_conn_update_periph_loc_collision(void)
 
 	/* (A) Initiate a Connection Parameter Request Procedure */
 	err = ull_cp_conn_update(&conn, INTVL_MIN, INTVL_MAX, LATENCY, TIMEOUT);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -2528,7 +2528,7 @@ void test_conn_update_periph_loc_collision_reject_2nd_cpr(void)
 
 	/* (A) Initiate a Connection Parameter Request Procedure */
 	err = ull_cp_conn_update(&conn, INTVL_MIN, INTVL_MAX, LATENCY, TIMEOUT);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -2655,7 +2655,7 @@ void test_conn_update_periph_loc_collision_reject_2nd_cpr(void)
 	{
 		/* Initiate a parallel local Connection Parameter Request Procedure */
 		err = ull_cp_conn_update(&conn_2nd, INTVL_MIN, INTVL_MAX, LATENCY, TIMEOUT);
-		zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+		zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 		/* Prepare */
 		event_prepare(&conn_2nd);
@@ -2905,7 +2905,7 @@ void test_conn_update_periph_rem_accept_reject_2nd_cpr(void)
 	{
 		/* Initiate a parallel local Connection Parameter Request Procedure */
 		err = ull_cp_conn_update(&conn_2nd, INTVL_MIN, INTVL_MAX, LATENCY, TIMEOUT);
-		zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+		zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 		/* Prepare */
 		event_prepare(&conn_2nd);
@@ -3471,7 +3471,7 @@ void test_conn_update_periph_rem_collision(void)
 	/* (B) Initiate a Connection Parameter Request Procedure */
 	err = ull_cp_conn_update(&conn, req_B->interval_min, req_B->interval_max, req_B->latency,
 				 req_B->timeout);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/*******************/
 
@@ -3650,7 +3650,7 @@ void test_conn_update_central_loc_accept_no_param_req(void)
 	do {
 		/* Initiate a Connection Update Procedure */
 		err = ull_cp_conn_update(&conn, INTVL_MIN, INTVL_MAX, LATENCY, TIMEOUT);
-		zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+		zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 		/* Prepare */
 		event_prepare(&conn);
@@ -3981,7 +3981,7 @@ void test_conn_update_periph_loc_disallowed_no_param_req(void)
 
 	/* Initiate a Connection Update Procedure */
 	err = ull_cp_conn_update(&conn, INTVL_MIN, INTVL_MAX, LATENCY, TIMEOUT);
-	zassert_equal(err, BT_HCI_ERR_CMD_DISALLOWED, NULL);
+	zassert_equal(err, BT_HCI_ERR_CMD_DISALLOWED);
 
 	/* Prepare */
 	event_prepare(&conn);

tests/bluetooth/controller/ctrl_cte_req/src/main.c

@@ -110,7 +110,7 @@ ZTEST(cte_req_after_fex, test_cte_req_central_local)
 	conn.llcp.cte_req.is_enabled = 1U;
 
 	err = ull_cp_cte_req(&conn, local_cte_req.min_cte_len_req, local_cte_req.cte_type_req);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -185,7 +185,7 @@ ZTEST(cte_req_after_fex, test_cte_req_peripheral_local)
 	conn.llcp.cte_req.is_enabled = 1U;
 
 	err = ull_cp_cte_req(&conn, local_cte_req.min_cte_len_req, local_cte_req.cte_type_req);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -404,7 +404,7 @@ ZTEST(cte_req_after_fex, test_cte_req_rejected_inv_ll_param_central_local)
 	conn.llcp.cte_req.is_enabled = 1U;
 
 	err = ull_cp_cte_req(&conn, local_cte_req.min_cte_len_req, local_cte_req.cte_type_req);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -483,7 +483,7 @@ ZTEST(cte_req_after_fex, test_cte_req_rejected_inv_ll_param_peripheral_local)
 	conn.llcp.cte_req.is_enabled = 1U;
 
 	err = ull_cp_cte_req(&conn, local_cte_req.min_cte_len_req, local_cte_req.cte_type_req);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -700,7 +700,7 @@ static void test_cte_req_ll_unknown_rsp_local(uint8_t role)
 
 	/* Initiate an CTE Request Procedure */
 	err = ull_cp_cte_req(&conn, local_cte_req.min_cte_len_req, local_cte_req.cte_type_req);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -735,7 +735,7 @@ static void test_cte_req_ll_unknown_rsp_local(uint8_t role)
 
 	/* Verify that CTE response feature is marked as not supported by peer device */
 	err = ull_cp_cte_req(&conn, local_cte_req.min_cte_len_req, local_cte_req.cte_type_req);
-	zassert_equal(err, BT_HCI_ERR_UNSUPP_REMOTE_FEATURE, NULL);
+	zassert_equal(err, BT_HCI_ERR_UNSUPP_REMOTE_FEATURE);
 }
 
 ZTEST(cte_req, test_cte_req_ll_unknown_rsp_central_local)
@@ -1114,13 +1114,13 @@ static void test_local_cte_req_wait_for_phy_update_complete_and_disable(uint8_t
 
 	/* Initiate an PHY Update Procedure */
 	err = ull_cp_phy_update(&conn, PHY_CODED, PREFER_S2_CODING, PHY_CODED, HOST_INITIATED);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Initiate an CTE Request Procedure */
 	conn.llcp.cte_req.is_enabled = 1U;
 
 	err = ull_cp_cte_req(&conn, local_cte_req.min_cte_len_req, local_cte_req.cte_type_req);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	if (role == BT_HCI_ROLE_CENTRAL) {
 		run_phy_update_central(true, &phy_req, pu_event_counter(&conn),
@@ -1181,13 +1181,13 @@ static void test_local_cte_req_wait_for_phy_update_complete(uint8_t role)
 	/* Initiate an PHY Update Procedure */
 	err = ull_cp_phy_update(&conn, phy_req.rx_phys, PREFER_S2_CODING, phy_req.tx_phys,
 				HOST_INITIATED);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Initiate an CTE Request Procedure */
 	conn.llcp.cte_req.is_enabled = 1U;
 
 	err = ull_cp_cte_req(&conn, local_cte_req.min_cte_len_req, local_cte_req.cte_type_req);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	if (role == BT_HCI_ROLE_CENTRAL) {
 		run_phy_update_central(true, &phy_req, pu_event_counter(&conn),
@@ -1235,11 +1235,11 @@ static void test_local_phy_update_wait_for_cte_req_complete(uint8_t role)
 	conn.llcp.cte_req.is_enabled = 1U;
 
 	err = ull_cp_cte_req(&conn, local_cte_req.min_cte_len_req, local_cte_req.cte_type_req);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Initiate an PHY Update Procedure */
 	err = ull_cp_phy_update(&conn, PHY_CODED, PREFER_S2_CODING, PHY_CODED, HOST_INITIATED);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Handle CTE request */
 	run_local_cte_req(&local_cte_req);
@@ -1327,7 +1327,7 @@ static void test_phy_update_wait_for_remote_cte_req_complete(uint8_t role)
 
 	/* Initiate an PHY Update Procedure */
 	err = ull_cp_phy_update(&conn, PHY_CODED, PREFER_S2_CODING, PHY_CODED, HOST_INITIATED);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	run_remote_cte_req(&local_cte_req);
 
@@ -1387,7 +1387,7 @@ static void test_cte_req_wait_for_remote_phy_update_complete_and_disable(uint8_t
 	conn.llcp.cte_req.is_enabled = 1U;
 
 	err = ull_cp_cte_req(&conn, local_cte_req.min_cte_len_req, local_cte_req.cte_type_req);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	if (role == BT_HCI_ROLE_CENTRAL) {
 		run_phy_update_central(false, &phy_req, pu_event_counter(&conn),
@@ -1443,7 +1443,7 @@ static void test_cte_req_wait_for_remote_phy_update_complete(uint8_t role)
 	conn.llcp.cte_req.is_enabled = 1U;
 
 	err = ull_cp_cte_req(&conn, local_cte_req.min_cte_len_req, local_cte_req.cte_type_req);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	if (role == BT_HCI_ROLE_CENTRAL) {
 		run_phy_update_central(false, &phy_req, pu_event_counter(&conn),

tests/bluetooth/controller/ctrl_data_length_update/src/main.c

@@ -104,7 +104,7 @@ void test_data_length_update_central_loc(void)
 
 	/* Initiate a Data Length Update Procedure */
 	err = ull_cp_data_length_update(&conn, 211, 1800);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	event_prepare(&conn);
 	/* Tx Queue should have one LL Control PDU */
@@ -177,7 +177,7 @@ void test_data_length_update_central_loc_unknown_rsp(void)
 
 	/* Initiate a Data Length Update Procedure */
 	err = ull_cp_data_length_update(&conn, 211, 1800);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	event_prepare(&conn);
 	/* Tx Queue should have one LL Control PDU */
@@ -250,7 +250,7 @@ void test_data_length_update_central_loc_invalid_rsp(void)
 
 	/* Initiate a Data Length Update Procedure */
 	err = ull_cp_data_length_update(&conn, 211, 1800);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	event_prepare(&conn);
 	/* Tx Queue should have one LL Control PDU */
@@ -288,7 +288,7 @@ void test_data_length_update_central_loc_invalid_rsp(void)
 
 	/* Initiate another Data Length Update Procedure */
 	err = ull_cp_data_length_update(&conn, 211, 1800);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	event_prepare(&conn);
 	/* Tx Queue should have one LL Control PDU */
@@ -353,7 +353,7 @@ void test_data_length_update_central_loc_no_eff_change(void)
 
 	/* Initiate a Data Length Update Procedure */
 	err = ull_cp_data_length_update(&conn, 211, 1800);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	event_prepare(&conn);
 	/* Tx Queue should have one LL Control PDU */
@@ -429,7 +429,7 @@ void test_data_length_update_central_loc_no_eff_change2(void)
 
 	/* Initiate a Data Length Update Procedure */
 	err = ull_cp_data_length_update(&conn, 211, 1800);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	event_prepare(&conn);
 	/* Tx Queue should have one LL Control PDU */
@@ -454,7 +454,7 @@ void test_data_length_update_central_loc_no_eff_change2(void)
 	 * change to effective numbers, thus not generate NTF
 	 */
 	err = ull_cp_data_length_update(&conn, 211, 1800);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	event_prepare(&conn);
 	/* Tx Queue should have one LL Control PDU */
@@ -495,7 +495,7 @@ void test_data_length_update_periph_loc(void)
 
 	/* Initiate a Data Length Update Procedure */
 	err = ull_cp_data_length_update(&conn, 211, 1800);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	event_prepare(&conn);
 	/* Tx Queue should have one LL Control PDU */
@@ -714,7 +714,7 @@ void test_data_length_update_periph_rem_and_loc(void)
 
 	/* Initiate a Data Length Update Procedure */
 	err = ull_cp_data_length_update(&conn, 211, 1800);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	event_done(&conn);
 

tests/bluetooth/controller/ctrl_encrypt/src/main.c

@@ -223,7 +223,7 @@ void test_encryption_start_central_loc(void)
 
 	/* Initiate an Encryption Start Procedure */
 	err = ull_cp_encryption_start(&conn, rand, ediv, ltk);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -400,7 +400,7 @@ void test_encryption_start_central_loc_limited_memory(void)
 
 	/* Initiate an Encryption Start Procedure */
 	err = ull_cp_encryption_start(&conn, rand, ediv, ltk);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -512,10 +512,10 @@ void test_encryption_start_central_loc_limited_memory(void)
 	ull_cp_release_ntf(ntf);
 
 	/* Tx Encryption should be enabled */
-	zassert_equal(conn.lll.enc_tx, 1U, NULL);
+	zassert_equal(conn.lll.enc_tx, 1U);
 
 	/* Rx Decryption should be enabled */
-	zassert_equal(conn.lll.enc_rx, 1U, NULL);
+	zassert_equal(conn.lll.enc_rx, 1U);
 
 	/* Release dummy procedure */
 	llcp_proc_ctx_release(ctx);
@@ -589,7 +589,7 @@ void test_encryption_start_central_loc_reject_ext(void)
 
 	/* Initiate an Encryption Start Procedure */
 	err = ull_cp_encryption_start(&conn, rand, ediv, ltk);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -686,7 +686,7 @@ void test_encryption_start_central_loc_reject(void)
 
 	/* Initiate an Encryption Start Procedure */
 	err = ull_cp_encryption_start(&conn, rand, ediv, ltk);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -794,7 +794,7 @@ void test_encryption_start_central_loc_no_ltk(void)
 
 	/* Initiate an Encryption Start Procedure */
 	err = ull_cp_encryption_start(&conn, rand, ediv, ltk);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -900,7 +900,7 @@ void test_encryption_start_central_loc_no_ltk_2(void)
 
 	/* Initiate an Encryption Start Procedure */
 	err = ull_cp_encryption_start(&conn, rand, ediv, ltk);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -1008,7 +1008,7 @@ void test_encryption_start_central_loc_mic(void)
 
 	/* Initiate an Encryption Start Procedure */
 	err = ull_cp_encryption_start(&conn, rand, ediv, ltk);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -1925,7 +1925,7 @@ void test_encryption_pause_central_loc(void)
 
 	/* Initiate an Encryption Pause Procedure */
 	err = ull_cp_encryption_pause(&conn, rand, ediv, ltk);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -1953,10 +1953,10 @@ void test_encryption_pause_central_loc(void)
 	ull_cp_release_tx(&conn, tx);
 
 	/* Tx Encryption should be disabled */
-	zassert_equal(conn.lll.enc_tx, 0U, NULL);
+	zassert_equal(conn.lll.enc_tx, 0U);
 
 	/* Rx Decryption should be disabled */
-	zassert_equal(conn.lll.enc_rx, 0U, NULL);
+	zassert_equal(conn.lll.enc_rx, 0U);
 
 	/**** UNENCRYPTED ****/
 
@@ -1992,10 +1992,10 @@ void test_encryption_pause_central_loc(void)
 	CHECK_TX_CCM_STATE(conn, sk_be, iv, 0U, CCM_DIR_M_TO_S);
 
 	/* Tx Encryption should be enabled */
-	zassert_equal(conn.lll.enc_tx, 1U, NULL);
+	zassert_equal(conn.lll.enc_tx, 1U);
 
 	/* Rx Decryption should be enabled */
-	zassert_equal(conn.lll.enc_rx, 1U, NULL);
+	zassert_equal(conn.lll.enc_rx, 1U);
 
 	/* Release Tx */
 	ull_cp_release_tx(&conn, tx);
@@ -2014,10 +2014,10 @@ void test_encryption_pause_central_loc(void)
 	ull_cp_release_ntf(ntf);
 
 	/* Tx Encryption should be enabled */
-	zassert_equal(conn.lll.enc_tx, 1U, NULL);
+	zassert_equal(conn.lll.enc_tx, 1U);
 
 	/* Rx Decryption should be enabled */
-	zassert_equal(conn.lll.enc_rx, 1U, NULL);
+	zassert_equal(conn.lll.enc_rx, 1U);
 
 	zassert_equal(ctx_buffers_free(), test_ctx_buffers_cnt(),
 				  "Free CTX buffers %d", ctx_buffers_free());
@@ -2085,7 +2085,7 @@ void test_encryption_pause_periph_rem(void)
 	lt_rx_q_is_empty(&conn);
 
 	/* Rx Decryption should be disabled */
-	zassert_equal(conn.lll.enc_rx, 0U, NULL);
+	zassert_equal(conn.lll.enc_rx, 0U);
 
 	/* Rx */
 	lt_tx(LL_PAUSE_ENC_RSP, &conn, NULL);
@@ -2097,7 +2097,7 @@ void test_encryption_pause_periph_rem(void)
 	ull_cp_release_tx(&conn, tx);
 
 	/* Tx Encryption should be disabled */
-	zassert_equal(conn.lll.enc_tx, 0U, NULL);
+	zassert_equal(conn.lll.enc_tx, 0U);
 
 	/**** UNENCRYPTED ****/
 
@@ -2153,7 +2153,7 @@ void test_encryption_pause_periph_rem(void)
 	CHECK_RX_CCM_STATE(conn, sk_be, iv, 0U, CCM_DIR_M_TO_S);
 
 	/* Rx Decryption should be enabled */
-	zassert_equal(conn.lll.enc_rx, 1U, NULL);
+	zassert_equal(conn.lll.enc_rx, 1U);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -2188,7 +2188,7 @@ void test_encryption_pause_periph_rem(void)
 	CHECK_TX_CCM_STATE(conn, sk_be, iv, 0U, CCM_DIR_S_TO_M);
 
 	/* Tx Encryption should be enabled */
-	zassert_equal(conn.lll.enc_tx, 1U, NULL);
+	zassert_equal(conn.lll.enc_tx, 1U);
 
 	zassert_equal(ctx_buffers_free(), test_ctx_buffers_cnt(),
 				  "Free CTX buffers %d", ctx_buffers_free());

tests/bluetooth/controller/ctrl_feature_exchange/src/main.c

@@ -110,7 +110,7 @@ void test_feat_exchange_central_loc(void)
 
 		/* Initiate a Feature Exchange Procedure */
 		err = ull_cp_feature_exchange(&conn);
-		zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+		zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 		event_prepare(&conn);
 		/* Tx Queue should have one LL Control PDU */
@@ -176,7 +176,7 @@ void test_feat_exchange_central_loc_invalid_rsp(void)
 
 	/* Initiate a Feature Exchange Procedure */
 	err = ull_cp_feature_exchange(&conn);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	event_prepare(&conn);
 	/* Tx Queue should have one LL Control PDU */
@@ -210,7 +210,7 @@ void test_feat_exchange_central_loc_invalid_rsp(void)
 
 	/* Initiate another Feature Exchange Procedure */
 	err = ull_cp_feature_exchange(&conn);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	event_prepare(&conn);
 	/* Tx Queue should have one LL Control PDU */
@@ -245,7 +245,7 @@ void test_feat_exchange_central_loc_2(void)
 
 	err = ull_cp_feature_exchange(&conn);
 	for (int i = 0U; i < CONFIG_BT_CTLR_LLCP_LOCAL_PROC_CTX_BUF_NUM; i++) {
-		zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+		zassert_equal(err, BT_HCI_ERR_SUCCESS);
 		err = ull_cp_feature_exchange(&conn);
 	}
 
@@ -372,7 +372,7 @@ void test_feat_exchange_central_rem_2(void)
 		sys_put_le64(ut_exp_featureset[feat_count], ut_feature_rsp.features);
 
 		err = ull_cp_feature_exchange(&conn);
-		zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+		zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 		event_prepare(&conn);
 		lt_tx(LL_PERIPH_FEAT_XCHG, &conn, &remote_feature_req);
@@ -435,7 +435,7 @@ void test_peripheral_feat_exchange_periph_loc(void)
 
 	/* Initiate a Feature Exchange Procedure */
 	err = ull_cp_feature_exchange(&conn);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	event_prepare(&conn);
 	/* Tx Queue should have one LL Control PDU */
@@ -496,7 +496,7 @@ void test_feat_exchange_periph_loc_unknown_rsp(void)
 
 	event_prepare(&conn);
 	err = ull_cp_feature_exchange(&conn);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 	event_done(&conn);
 
 	event_prepare(&conn);

tests/bluetooth/controller/ctrl_hci/src/main.c

@@ -229,19 +229,19 @@ void test_hci_apto(void)
 	conn_from_pool->apto_reload = 100;
 	conn_from_pool->lll.interval = 10;
 	err = ll_apto_get(conn_handle, &apto);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 	zassert_equal(apto, 125, "Apto is %d", apto);
 
 	err = ll_apto_get(conn_handle + 1, &apto);
-	zassert_equal(err, BT_HCI_ERR_UNKNOWN_CONN_ID, NULL);
+	zassert_equal(err, BT_HCI_ERR_UNKNOWN_CONN_ID);
 
 	err = ll_apto_set(conn_handle, 1000);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 	zassert_equal(conn_from_pool->apto_reload, 800, "Apto reload is %d",
 		      conn_from_pool->apto_reload);
 
 	err = ll_apto_get(conn_handle + 1, 0x00);
-	zassert_equal(err, BT_HCI_ERR_UNKNOWN_CONN_ID, NULL);
+	zassert_equal(err, BT_HCI_ERR_UNKNOWN_CONN_ID);
 }
 
 void test_hci_phy(void)
@@ -258,7 +258,7 @@ void test_hci_phy(void)
 	ull_cp_state_set(conn_from_pool, ULL_CP_CONNECTED);
 
 	err = ll_phy_req_send(conn_handle + 1, 0x00, 0x00, 0x00);
-	zassert_equal(err, BT_HCI_ERR_UNKNOWN_CONN_ID, NULL);
+	zassert_equal(err, BT_HCI_ERR_UNKNOWN_CONN_ID);
 	conn_from_pool->llcp.fex.features_used = 0x00;
 	conn_from_pool->llcp.fex.valid = 1;
 	err = ll_phy_req_send(conn_handle, 0x03, 0xFF, 0x03);
@@ -268,27 +268,27 @@ void test_hci_phy(void)
 	err = ll_phy_req_send(conn_handle, 0x03, 0xFF, 0x03);
 	zassert_equal(err, BT_HCI_ERR_SUCCESS, "Errorcode %d", err);
 	err = ll_phy_get(conn_handle + 1, &phy_tx, &phy_rx);
-	zassert_equal(err, BT_HCI_ERR_UNKNOWN_CONN_ID, NULL);
+	zassert_equal(err, BT_HCI_ERR_UNKNOWN_CONN_ID);
 
 	conn_from_pool->lll.phy_rx = 0x3;
 	conn_from_pool->lll.phy_tx = 0x7;
 	err = ll_phy_get(conn_handle, &phy_tx, &phy_rx);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
-	zassert_equal(phy_tx, 0x07, NULL);
+	zassert_equal(phy_tx, 0x07);
-	zassert_equal(phy_rx, 0x03, NULL);
+	zassert_equal(phy_rx, 0x03);
 
 	err = ll_phy_default_set(0x00, 0x00);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 	phy_tx = ull_conn_default_phy_tx_get();
 	phy_rx = ull_conn_default_phy_rx_get();
-	zassert_equal(phy_tx, 0x00, NULL);
+	zassert_equal(phy_tx, 0x00);
-	zassert_equal(phy_rx, 0x00, NULL);
+	zassert_equal(phy_rx, 0x00);
 	err = ll_phy_default_set(0x01, 0x03);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 	phy_tx = ull_conn_default_phy_tx_get();
 	phy_rx = ull_conn_default_phy_rx_get();
-	zassert_equal(phy_tx, 0x01, NULL);
+	zassert_equal(phy_tx, 0x01);
-	zassert_equal(phy_rx, 0x03, NULL);
+	zassert_equal(phy_rx, 0x03);
 }
 
 void test_hci_dle(void)
@@ -317,25 +317,25 @@ void test_hci_dle(void)
 	zassert_equal(err, BT_HCI_ERR_UNKNOWN_CONN_ID, "Errorcode %d", err);
 
 	ll_length_max_get(&max_tx_octets, &max_tx_time, &max_rx_octets, &max_rx_time);
-	zassert_equal(max_tx_octets, LL_LENGTH_OCTETS_RX_MAX, NULL);
+	zassert_equal(max_tx_octets, LL_LENGTH_OCTETS_RX_MAX);
-	zassert_equal(max_rx_octets, LL_LENGTH_OCTETS_RX_MAX, NULL);
+	zassert_equal(max_rx_octets, LL_LENGTH_OCTETS_RX_MAX);
 	zassert_equal(max_tx_time, 17040, "Actual time is %d", max_tx_time);
 	zassert_equal(max_rx_time, 17040, "Actual time is %d", max_rx_time);
 
 	err = ll_length_default_set(0x00, 0x00);
 	ll_length_default_get(&max_tx_octets, &max_tx_time);
-	zassert_equal(err, 00, NULL);
+	zassert_equal(err, 00);
-	zassert_equal(max_tx_octets, 0x00, NULL);
+	zassert_equal(max_tx_octets, 0x00);
-	zassert_equal(max_tx_time, 0x00, NULL);
+	zassert_equal(max_tx_time, 0x00);
 	err = ll_length_default_set(0x10, 0x3FF);
 	ll_length_default_get(&max_tx_octets, &max_tx_time);
-	zassert_equal(err, 00, NULL);
+	zassert_equal(err, 00);
-	zassert_equal(max_tx_octets, 0x10, NULL);
+	zassert_equal(max_tx_octets, 0x10);
-	zassert_equal(max_tx_time, 0x3FF, NULL);
+	zassert_equal(max_tx_time, 0x3FF);
 	max_tx_octets = ull_conn_default_tx_octets_get();
 	max_tx_time = ull_conn_default_tx_time_get();
-	zassert_equal(max_tx_octets, 0x10, NULL);
+	zassert_equal(max_tx_octets, 0x10);
-	zassert_equal(max_tx_time, 0x3FF, NULL);
+	zassert_equal(max_tx_time, 0x3FF);
 }
 
 void test_hci_terminate(void)

tests/bluetooth/controller/ctrl_le_ping/src/main.c

@@ -94,7 +94,7 @@ void test_ping_central_loc(void)
 
 	/* Initiate an LE Ping Procedure */
 	err = ull_cp_le_ping(&conn);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -120,7 +120,7 @@ void test_ping_central_loc(void)
 
 	/* Initiate another LE Ping Procedure */
 	err = ull_cp_le_ping(&conn);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -185,7 +185,7 @@ void test_ping_central_loc_invalid_rsp(void)
 
 	/* Initiate an LE Ping Procedure */
 	err = ull_cp_le_ping(&conn);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -218,7 +218,7 @@ void test_ping_central_loc_invalid_rsp(void)
 
 	/* Initiate another LE Ping Procedure */
 	err = ull_cp_le_ping(&conn);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -281,7 +281,7 @@ void test_ping_periph_loc(void)
 
 	/* Initiate an LE Ping Procedure */
 	err = ull_cp_le_ping(&conn);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);

tests/bluetooth/controller/ctrl_min_used_chans/src/main.c

@@ -81,7 +81,7 @@ void test_min_used_chans_periph_loc(void)
 
 	/* Initiate a Min number of Used Channels Procedure */
 	err = ull_cp_min_used_chans(&conn, 1, 2);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -121,7 +121,7 @@ void test_min_used_chans_central_loc(void)
 
 	/* Initiate a Min number of Used Channels Procedure */
 	err = ull_cp_min_used_chans(&conn, 1, 2);
-	zassert_equal(err, BT_HCI_ERR_CMD_DISALLOWED, NULL);
+	zassert_equal(err, BT_HCI_ERR_CMD_DISALLOWED);
 
 	zassert_equal(ctx_buffers_free(), test_ctx_buffers_cnt(),
 		      "Free CTX buffers %d", ctx_buffers_free());

tests/bluetooth/controller/ctrl_phy_update/src/main.c

@@ -141,7 +141,7 @@ void test_phy_update_central_loc(void)
 
 	/* Initiate an PHY Update Procedure */
 	err = ull_cp_phy_update(&conn, PHY_2M, PREFER_S8_CODING, PHY_2M, HOST_INITIATED);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -245,7 +245,7 @@ void test_phy_update_central_loc_invalid(void)
 
 	/* Initiate an PHY Update Procedure */
 	err = ull_cp_phy_update(&conn, PHY_2M, PREFER_S8_CODING, PHY_2M, HOST_INITIATED);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -296,7 +296,7 @@ void test_phy_update_central_loc_unsupp_feat(void)
 
 	/* Initiate an PHY Update Procedure */
 	err = ull_cp_phy_update(&conn, PHY_2M, PREFER_S8_CODING, PHY_2M, HOST_INITIATED);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -443,7 +443,7 @@ void test_phy_update_periph_loc(void)
 
 	/* Initiate an PHY Update Procedure */
 	err = ull_cp_phy_update(&conn, PHY_2M, PREFER_S8_CODING, PHY_2M, HOST_INITIATED);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -749,7 +749,7 @@ void test_phy_update_central_loc_collision(void)
 
 	/* Initiate an PHY Update Procedure */
 	err = ull_cp_phy_update(&conn, PHY_2M, PREFER_S8_CODING, PHY_2M, HOST_INITIATED);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/*** ***/
 
@@ -926,7 +926,7 @@ void test_phy_update_central_rem_collision(void)
 
 	/* Initiate an PHY Update Procedure */
 	err = ull_cp_phy_update(&conn, PHY_2M, PREFER_S8_CODING, PHY_2M, HOST_INITIATED);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/*** ***/
 
@@ -1093,7 +1093,7 @@ void test_phy_update_periph_loc_collision(void)
 
 	/* Initiate an PHY Update Procedure */
 	err = ull_cp_phy_update(&conn, PHY_2M, PREFER_S8_CODING, PHY_2M, HOST_INITIATED);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -1209,7 +1209,7 @@ void test_phy_update_central_loc_no_act_change(void)
 
 	/* Initiate an PHY Update Procedure */
 	err = ull_cp_phy_update(&conn, PHY_1M, PREFER_S8_CODING, PHY_1M, HOST_INITIATED);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -1357,7 +1357,7 @@ void test_phy_update_periph_loc_no_actual_change(void)
 
 	/* Initiate an PHY Update Procedure */
 	err = ull_cp_phy_update(&conn, PHY_1M, PREFER_S8_CODING, PHY_1M, HOST_INITIATED);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);

tests/bluetooth/controller/ctrl_terminate/src/main.c

@@ -112,7 +112,7 @@ void test_terminate_loc(uint8_t role)
 
 	/* Initiate an LE Ping Procedure */
 	err = ull_cp_terminate(&conn, 0x06);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);

tests/bluetooth/controller/ctrl_tx_buffer_alloc/src/main.c

@@ -71,39 +71,39 @@ void test_tx_buffer_alloc(void)
 #if defined(LLCP_TX_CTRL_BUF_QUEUE_ENABLE)
 	/* Check alloc flow */
 	for (i = 0; i < CONFIG_BT_CTLR_LLCP_PER_CONN_TX_CTRL_BUF_NUM; i++) {
-		zassert_true(llcp_tx_alloc_peek(&conn[0], ctxs[0]), NULL);
+		zassert_true(llcp_tx_alloc_peek(&conn[0], ctxs[0]));
 		tx[tx_alloc_idx] = llcp_tx_alloc(&conn[0], ctxs[0]);
-		zassert_equal(conn[0].llcp.tx_buffer_alloc, i + 1, NULL);
+		zassert_equal(conn[0].llcp.tx_buffer_alloc, i + 1);
-		zassert_equal(common_tx_buffer_alloc_count(), 0, NULL);
+		zassert_equal(common_tx_buffer_alloc_count(), 0);
 		zassert_not_null(tx[tx_alloc_idx], NULL);
 		tx_alloc_idx++;
 	}
 	for (i = 0; i < CONFIG_BT_CTLR_LLCP_COMMON_TX_CTRL_BUF_NUM; i++) {
-		zassert_true(llcp_tx_alloc_peek(&conn[0], ctxs[0]), NULL);
+		zassert_true(llcp_tx_alloc_peek(&conn[0], ctxs[0]));
 		tx[tx_alloc_idx] = llcp_tx_alloc(&conn[0], ctxs[0]);
 		zassert_equal(conn[0].llcp.tx_buffer_alloc,
 			      CONFIG_BT_CTLR_LLCP_PER_CONN_TX_CTRL_BUF_NUM + i + 1, NULL);
-		zassert_equal(common_tx_buffer_alloc_count(), i+1, NULL);
+		zassert_equal(common_tx_buffer_alloc_count(), i+1);
 		zassert_not_null(tx[tx_alloc_idx], NULL);
 		tx_alloc_idx++;
 	}
-	zassert_false(llcp_tx_alloc_peek(&conn[0], ctxs[0]), NULL);
+	zassert_false(llcp_tx_alloc_peek(&conn[0], ctxs[0]));
-	zassert_equal(ctxs[0]->wait_reason, WAITING_FOR_TX_BUFFER, NULL);
+	zassert_equal(ctxs[0]->wait_reason, WAITING_FOR_TX_BUFFER);
 
 	for (int j = 1; j < CONFIG_BT_CTLR_LLCP_CONN; j++) {
 		/* Now global pool is exausted, but conn pool is not */
 		for (i = 0; i < CONFIG_BT_CTLR_LLCP_PER_CONN_TX_CTRL_BUF_NUM; i++) {
-			zassert_true(llcp_tx_alloc_peek(&conn[j], ctxs[j]), NULL);
+			zassert_true(llcp_tx_alloc_peek(&conn[j], ctxs[j]));
 			tx[tx_alloc_idx] = llcp_tx_alloc(&conn[j], ctxs[j]);
 			zassert_not_null(tx[tx_alloc_idx], NULL);
 			zassert_equal(common_tx_buffer_alloc_count(),
 				      CONFIG_BT_CTLR_LLCP_COMMON_TX_CTRL_BUF_NUM, NULL);
-			zassert_equal(conn[j].llcp.tx_buffer_alloc, i + 1, NULL);
+			zassert_equal(conn[j].llcp.tx_buffer_alloc, i + 1);
 			tx_alloc_idx++;
 		}
 
-		zassert_false(llcp_tx_alloc_peek(&conn[j], ctxs[j]), NULL);
+		zassert_false(llcp_tx_alloc_peek(&conn[j], ctxs[j]));
-		zassert_equal(ctxs[j]->wait_reason, WAITING_FOR_TX_BUFFER, NULL);
+		zassert_equal(ctxs[j]->wait_reason, WAITING_FOR_TX_BUFFER);
 	}
 
 	ull_cp_release_tx(&conn[0], tx[1]);
@@ -113,10 +113,10 @@ void test_tx_buffer_alloc(void)
 		      CONFIG_BT_CTLR_LLCP_COMMON_TX_CTRL_BUF_NUM - 1, NULL);
 
 	/* global pool is now 'open' again, but ctxs[1] is NOT next in line */
-	zassert_false(llcp_tx_alloc_peek(&conn[1], ctxs[1]), NULL);
+	zassert_false(llcp_tx_alloc_peek(&conn[1], ctxs[1]));
 
 	/* ... ctxs[0] is */
-	zassert_true(llcp_tx_alloc_peek(&conn[0], ctxs[0]), NULL);
+	zassert_true(llcp_tx_alloc_peek(&conn[0], ctxs[0]));
 	tx[tx_alloc_idx] = llcp_tx_alloc(&conn[0], ctxs[0]);
 	zassert_equal(common_tx_buffer_alloc_count(), CONFIG_BT_CTLR_LLCP_COMMON_TX_CTRL_BUF_NUM,
 		      NULL);
@@ -132,7 +132,7 @@ void test_tx_buffer_alloc(void)
 		      CONFIG_BT_CTLR_LLCP_COMMON_TX_CTRL_BUF_NUM - 1, NULL);
 
 	/* global pool does not allow as ctxs[2] is NOT next up */
-	zassert_false(llcp_tx_alloc_peek(&conn[2], ctxs[2]), NULL);
+	zassert_false(llcp_tx_alloc_peek(&conn[2], ctxs[2]));
 
 #if (CONFIG_BT_CTLR_LLCP_PER_CONN_TX_CTRL_BUF_NUM > 0)
 	/* Release conn[2] held tx, to confirm alloc is allowed after releasing pre-alloted buf */
@@ -145,20 +145,20 @@ void test_tx_buffer_alloc(void)
 		       CONFIG_BT_CTLR_LLCP_PER_CONN_TX_CTRL_BUF_NUM), NULL);
 
 	/* global pool does not allow as ctxs[2] is not next up, but pre alloted is now avail */
-	zassert_equal(ctxs[2]->wait_reason, WAITING_FOR_TX_BUFFER, NULL);
+	zassert_equal(ctxs[2]->wait_reason, WAITING_FOR_TX_BUFFER);
 	zassert_not_null(ctxs[2]->wait_node.next, NULL);
-	zassert_true(llcp_tx_alloc_peek(&conn[2], ctxs[2]), NULL);
+	zassert_true(llcp_tx_alloc_peek(&conn[2], ctxs[2]));
 	tx[tx_alloc_idx] = llcp_tx_alloc(&conn[2], ctxs[2]);
 	zassert_not_null(tx[tx_alloc_idx], NULL);
 	tx_alloc_idx++;
 
 	/* No longer waiting in line */
-	zassert_equal(ctxs[2]->wait_reason, WAITING_FOR_NOTHING, NULL);
+	zassert_equal(ctxs[2]->wait_reason, WAITING_FOR_NOTHING);
 	zassert_is_null(ctxs[2]->wait_node.next, NULL);
 #endif /* (CONFIG_BT_CTLR_LLCP_PER_CONN_TX_CTRL_BUF_NUM > 0) */
 
 	/* now ctxs[1] is next up */
-	zassert_true(llcp_tx_alloc_peek(&conn[1], ctxs[1]), NULL);
+	zassert_true(llcp_tx_alloc_peek(&conn[1], ctxs[1]));
 	tx[tx_alloc_idx] = llcp_tx_alloc(&conn[0], ctxs[0]);
 	zassert_not_null(tx[tx_alloc_idx], NULL);
 	tx_alloc_idx++;
@@ -170,12 +170,12 @@ void test_tx_buffer_alloc(void)
 	for (i = 0;
 	     i < CONFIG_BT_CTLR_LLCP_TX_PER_CONN_TX_CTRL_BUF_NUM_MAX * CONFIG_BT_CTLR_LLCP_CONN;
 	     i++) {
-		zassert_true(llcp_tx_alloc_peek(&conn[0], ctxs[0]), NULL);
+		zassert_true(llcp_tx_alloc_peek(&conn[0], ctxs[0]));
 		tx[tx_alloc_idx] = llcp_tx_alloc(&conn[0], ctxs[0]);
 		zassert_not_null(tx[tx_alloc_idx], NULL);
 		tx_alloc_idx++;
 	}
-	zassert_false(llcp_tx_alloc_peek(&conn[0], ctxs[0]), NULL);
+	zassert_false(llcp_tx_alloc_peek(&conn[0], ctxs[0]));
 #endif /* LLCP_TX_CTRL_BUF_QUEUE_ENABLE */
 }
 

tests/bluetooth/controller/ctrl_version/src/main.c

@@ -94,7 +94,7 @@ void test_version_exchange_central_loc(void)
 
 	/* Initiate a Version Exchange Procedure */
 	err = ull_cp_version_exchange(&conn);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -166,7 +166,7 @@ void test_version_exchange_central_loc_invalid_rsp(void)
 
 	/* Initiate a Version Exchange Procedure */
 	err = ull_cp_version_exchange(&conn);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -202,7 +202,7 @@ void test_version_exchange_central_loc_invalid_rsp(void)
 
 	/* Initiate another Version Exchange Procedure */
 	err = ull_cp_version_exchange(&conn);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -238,7 +238,7 @@ void test_version_exchange_central_loc_invalid_rsp(void)
 
 	/* Initiate yet another Version Exchange Procedure */
 	err = ull_cp_version_exchange(&conn);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -278,7 +278,7 @@ void test_version_exchange_central_loc_2(void)
 	err = ull_cp_version_exchange(&conn);
 
 	for (int i = 0U; i < CONFIG_BT_CTLR_LLCP_LOCAL_PROC_CTX_BUF_NUM; i++) {
-		zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+		zassert_equal(err, BT_HCI_ERR_SUCCESS);
 		err = ull_cp_version_exchange(&conn);
 	}
 
@@ -396,7 +396,7 @@ void test_version_exchange_central_rem_2(void)
 
 	/* Initiate a Version Exchange Procedure */
 	err = ull_cp_version_exchange(&conn);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);
@@ -468,11 +468,11 @@ void test_version_exchange_central_loc_twice(void)
 
 	/* Initiate a Version Exchange Procedure */
 	err = ull_cp_version_exchange(&conn);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Initiate a Version Exchange Procedure */
 	err = ull_cp_version_exchange(&conn);
-	zassert_equal(err, BT_HCI_ERR_SUCCESS, NULL);
+	zassert_equal(err, BT_HCI_ERR_SUCCESS);
 
 	/* Prepare */
 	event_prepare(&conn);

tests/bluetooth/host_long_adv_recv/src/main.c

@@ -430,7 +430,7 @@ ZTEST(long_adv_rx_tests, test_host_long_adv_recv)
 	send_adv_report(&report_a_2);
 	send_adv_report(&report_b_1);
 	send_adv_report(&report_b_2);
-	zassert_equal(2, get_expected_report_fake.call_count, NULL);
+	zassert_equal(2, get_expected_report_fake.call_count);
 	RESET_FAKE(get_expected_report);
 	FFF_RESET_HISTORY();
 
@@ -441,7 +441,7 @@ ZTEST(long_adv_rx_tests, test_host_long_adv_recv)
 	send_adv_report(&report_a_1);
 	send_adv_report(&report_c); /* Interleaved legacy adv report */
 	send_adv_report(&report_a_2);
-	zassert_equal(2, get_expected_report_fake.call_count, NULL);
+	zassert_equal(2, get_expected_report_fake.call_count);
 	RESET_FAKE(get_expected_report);
 	FFF_RESET_HISTORY();
 
@@ -452,7 +452,7 @@ ZTEST(long_adv_rx_tests, test_host_long_adv_recv)
 	send_adv_report(&report_a_1);
 	send_adv_report(&report_b_2); /* Interleaved short extended adv report */
 	send_adv_report(&report_a_2);
-	zassert_equal(2, get_expected_report_fake.call_count, NULL);
+	zassert_equal(2, get_expected_report_fake.call_count);
 	RESET_FAKE(get_expected_report);
 	FFF_RESET_HISTORY();
 
@@ -466,7 +466,7 @@ ZTEST(long_adv_rx_tests, test_host_long_adv_recv)
 	send_adv_report(&report_b_1); /* Interleaved fragmented adv report, NOT SUPPORTED */
 	send_adv_report(&report_a_2);
 	send_adv_report(&report_b_2);
-	zassert_equal(2, get_expected_report_fake.call_count, NULL);
+	zassert_equal(2, get_expected_report_fake.call_count);
 	RESET_FAKE(get_expected_report);
 	FFF_RESET_HISTORY();
 
@@ -486,5 +486,5 @@ ZTEST(long_adv_rx_tests, test_host_long_adv_recv)
 	/* Check that reports from a different advertiser works after truncation */
 	send_adv_report(&report_b_1);
 	send_adv_report(&report_b_2);
-	zassert_equal(1, get_expected_report_fake.call_count, NULL);
+	zassert_equal(1, get_expected_report_fake.call_count);
 }

tests/boards/altera_max10/i2c_master/src/i2c_master.c

@@ -123,7 +123,7 @@ static int test_i2c_adv7513(void)
 
 ZTEST(nios2_i2c_master, test_i2c_master)
 {
-	zassert_true(test_i2c_adv7513() == TC_PASS, NULL);
+	zassert_true(test_i2c_adv7513() == TC_PASS);
 }
 
 ZTEST_SUITE(nios2_i2c_master, NULL, NULL, NULL, NULL, NULL);

tests/boards/intel_adsp/ssp/src/main.c

@@ -383,7 +383,7 @@ ZTEST(adsp_ssp, test_adsp_ssp_config_set)
 
 	ret = dai_config_set(dev_dai_ssp, &config, &ssp_config);
 
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 }
 
 static void test_adsp_ssp_probe(void)
@@ -392,7 +392,7 @@ static void test_adsp_ssp_probe(void)
 
 	ret = dai_probe(dev_dai_ssp);
 
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 }
 
 static void *adsp_ssp_setup(void)

tests/drivers/adc/adc_api/src/test_adc.c

@@ -492,7 +492,7 @@ static int test_task_one_channel(void)
 
 ZTEST_USER(adc_basic, test_adc_sample_one_channel)
 {
-	zassert_true(test_task_one_channel() == TC_PASS, NULL);
+	zassert_true(test_task_one_channel() == TC_PASS);
 }
 
 /*
@@ -528,7 +528,7 @@ static int test_task_two_channels(void)
 ZTEST_USER(adc_basic, test_adc_sample_two_channels)
 {
 #if defined(ADC_2ND_CHANNEL_ID)
-	zassert_true(test_task_two_channels() == TC_PASS, NULL);
+	zassert_true(test_task_two_channels() == TC_PASS);
 #else
 	ztest_test_skip();
 #endif /* defined(ADC_2ND_CHANNEL_ID) */
@@ -580,7 +580,7 @@ static int test_task_asynchronous_call(void)
 ZTEST_USER(adc_basic, test_adc_asynchronous_call)
 {
 #if defined(CONFIG_ADC_ASYNC)
-	zassert_true(test_task_asynchronous_call() == TC_PASS, NULL);
+	zassert_true(test_task_asynchronous_call() == TC_PASS);
 #else
 	ztest_test_skip();
 #endif /* defined(CONFIG_ADC_ASYNC) */
@@ -642,7 +642,7 @@ static int test_task_with_interval(void)
 
 ZTEST(adc_basic, test_adc_sample_with_interval)
 {
-	zassert_true(test_task_with_interval() == TC_PASS, NULL);
+	zassert_true(test_task_with_interval() == TC_PASS);
 }
 
 /*
@@ -727,7 +727,7 @@ static int test_task_repeated_samplings(void)
 
 ZTEST(adc_basic, test_adc_repeated_samplings)
 {
-	zassert_true(test_task_repeated_samplings() == TC_PASS, NULL);
+	zassert_true(test_task_repeated_samplings() == TC_PASS);
 }
 
 /*
@@ -772,5 +772,5 @@ static int test_task_invalid_request(void)
 
 ZTEST_USER(adc_basic, test_adc_invalid_request)
 {
-	zassert_true(test_task_invalid_request() == TC_PASS, NULL);
+	zassert_true(test_task_invalid_request() == TC_PASS);
 }

tests/drivers/adc/adc_dma/src/test_adc.c

@@ -190,7 +190,7 @@ static int test_task_one_channel(void)
 
 ZTEST_USER(adc_dma, test_adc_sample_one_channel)
 {
-	zassert_true(test_task_one_channel() == TC_PASS, NULL);
+	zassert_true(test_task_one_channel() == TC_PASS);
 }
 
 /*
@@ -225,7 +225,7 @@ static int test_task_two_channels(void)
 ZTEST_USER(adc_dma, test_adc_sample_two_channels)
 {
 #if defined(ADC_2ND_CHANNEL_ID)
-	zassert_true(test_task_two_channels() == TC_PASS, NULL);
+	zassert_true(test_task_two_channels() == TC_PASS);
 #else
 	ztest_test_skip();
 #endif /* defined(ADC_2ND_CHANNEL_ID) */
@@ -275,7 +275,7 @@ static int test_task_asynchronous_call(void)
 ZTEST_USER(adc_dma, test_adc_asynchronous_call)
 {
 #if defined(CONFIG_ADC_ASYNC)
-	zassert_true(test_task_asynchronous_call() == TC_PASS, NULL);
+	zassert_true(test_task_asynchronous_call() == TC_PASS);
 #else
 	ztest_test_skip();
 #endif /* defined(CONFIG_ADC_ASYNC) */
@@ -340,7 +340,7 @@ static int test_task_with_interval(void)
 
 ZTEST(adc_dma, test_adc_sample_with_interval)
 {
-	zassert_true(test_task_with_interval() == TC_PASS, NULL);
+	zassert_true(test_task_with_interval() == TC_PASS);
 }
 
 /*
@@ -426,7 +426,7 @@ static int test_task_repeated_samplings(void)
 
 ZTEST(adc_dma, test_adc_repeated_samplings)
 {
-	zassert_true(test_task_repeated_samplings() == TC_PASS, NULL);
+	zassert_true(test_task_repeated_samplings() == TC_PASS);
 }
 
 /*
@@ -471,5 +471,5 @@ static int test_task_invalid_request(void)
 
 ZTEST_USER(adc_dma, test_adc_invalid_request)
 {
-	zassert_true(test_task_invalid_request() == TC_PASS, NULL);
+	zassert_true(test_task_invalid_request() == TC_PASS);
 }

tests/drivers/bbram/emul/src/main.c

@@ -18,8 +18,8 @@ ZTEST(bbram, test_get_size)
 
 	zassert_true(device_is_ready(dev), "Device is not ready");
 
-	zassert_ok(bbram_get_size(dev, &size), NULL);
+	zassert_ok(bbram_get_size(dev, &size));
-	zassert_equal(size, BBRAM_SIZE, NULL);
+	zassert_equal(size, BBRAM_SIZE);
 }
 
 ZTEST(bbram, test_bbram_out_of_bounds)
@@ -27,12 +27,12 @@ ZTEST(bbram, test_bbram_out_of_bounds)
 	const struct device *const dev = DEVICE_DT_GET(BBRAM_NODELABEL);
 	uint8_t buffer[BBRAM_SIZE];
 
-	zassert_equal(bbram_read(dev, 0, 0, buffer), -EFAULT, NULL);
+	zassert_equal(bbram_read(dev, 0, 0, buffer), -EFAULT);
-	zassert_equal(bbram_read(dev, 0, BBRAM_SIZE + 1, buffer), -EFAULT, NULL);
+	zassert_equal(bbram_read(dev, 0, BBRAM_SIZE + 1, buffer), -EFAULT);
-	zassert_equal(bbram_read(dev, BBRAM_SIZE - 1, 2, buffer), -EFAULT, NULL);
+	zassert_equal(bbram_read(dev, BBRAM_SIZE - 1, 2, buffer), -EFAULT);
-	zassert_equal(bbram_write(dev, 0, 0, buffer), -EFAULT, NULL);
+	zassert_equal(bbram_write(dev, 0, 0, buffer), -EFAULT);
-	zassert_equal(bbram_write(dev, 0, BBRAM_SIZE + 1, buffer), -EFAULT, NULL);
+	zassert_equal(bbram_write(dev, 0, BBRAM_SIZE + 1, buffer), -EFAULT);
-	zassert_equal(bbram_write(dev, BBRAM_SIZE - 1, 2, buffer), -EFAULT, NULL);
+	zassert_equal(bbram_write(dev, BBRAM_SIZE - 1, 2, buffer), -EFAULT);
 }
 
 ZTEST(bbram, test_read_write)
@@ -45,8 +45,8 @@ ZTEST(bbram, test_read_write)
 		expected[i] = i;
 	}
 	/* Set and verify content. */
-	zassert_ok(bbram_write(dev, 0, BBRAM_SIZE, expected), NULL);
+	zassert_ok(bbram_write(dev, 0, BBRAM_SIZE, expected));
-	zassert_ok(bbram_read(dev, 0, BBRAM_SIZE, buffer), NULL);
+	zassert_ok(bbram_read(dev, 0, BBRAM_SIZE, buffer));
 	zassert_mem_equal(buffer, expected, BBRAM_SIZE, NULL);
 }
 
@@ -54,30 +54,30 @@ ZTEST(bbram, test_set_invalid)
 {
 	const struct device *const dev = DEVICE_DT_GET(BBRAM_NODELABEL);
 
-	zassert_equal(bbram_check_invalid(dev), 0, NULL);
+	zassert_equal(bbram_check_invalid(dev), 0);
-	zassert_ok(bbram_emul_set_invalid(dev, true), NULL);
+	zassert_ok(bbram_emul_set_invalid(dev, true));
-	zassert_equal(bbram_check_invalid(dev), 1, NULL);
+	zassert_equal(bbram_check_invalid(dev), 1);
-	zassert_equal(bbram_check_invalid(dev), 0, NULL);
+	zassert_equal(bbram_check_invalid(dev), 0);
 }
 
 ZTEST(bbram, test_set_standby)
 {
 	const struct device *const dev = DEVICE_DT_GET(BBRAM_NODELABEL);
 
-	zassert_equal(bbram_check_standby_power(dev), 0, NULL);
+	zassert_equal(bbram_check_standby_power(dev), 0);
-	zassert_ok(bbram_emul_set_standby_power_state(dev, true), NULL);
+	zassert_ok(bbram_emul_set_standby_power_state(dev, true));
-	zassert_equal(bbram_check_standby_power(dev), 1, NULL);
+	zassert_equal(bbram_check_standby_power(dev), 1);
-	zassert_equal(bbram_check_standby_power(dev), 0, NULL);
+	zassert_equal(bbram_check_standby_power(dev), 0);
 }
 
 ZTEST(bbram, test_set_power)
 {
 	const struct device *const dev = DEVICE_DT_GET(BBRAM_NODELABEL);
 
-	zassert_equal(bbram_check_power(dev), 0, NULL);
+	zassert_equal(bbram_check_power(dev), 0);
-	zassert_ok(bbram_emul_set_power_state(dev, true), NULL);
+	zassert_ok(bbram_emul_set_power_state(dev, true));
-	zassert_equal(bbram_check_power(dev), 1, NULL);
+	zassert_equal(bbram_check_power(dev), 1);
-	zassert_equal(bbram_check_power(dev), 0, NULL);
+	zassert_equal(bbram_check_power(dev), 0);
 }
 
 ZTEST(bbram, test_reset_invalid_on_read)
@@ -85,9 +85,9 @@ ZTEST(bbram, test_reset_invalid_on_read)
 	const struct device *const dev = DEVICE_DT_GET(BBRAM_NODELABEL);
 	uint8_t buffer[BBRAM_SIZE];
 
-	zassert_ok(bbram_emul_set_invalid(dev, true), NULL);
+	zassert_ok(bbram_emul_set_invalid(dev, true));
-	zassert_equal(bbram_read(dev, 0, BBRAM_SIZE, buffer), -EFAULT, NULL);
+	zassert_equal(bbram_read(dev, 0, BBRAM_SIZE, buffer), -EFAULT);
-	zassert_equal(bbram_check_invalid(dev), 0, NULL);
+	zassert_equal(bbram_check_invalid(dev), 0);
 }
 
 ZTEST(bbram, test_reset_invalid_on_write)
@@ -95,9 +95,9 @@ ZTEST(bbram, test_reset_invalid_on_write)
 	const struct device *const dev = DEVICE_DT_GET(BBRAM_NODELABEL);
 	uint8_t buffer[BBRAM_SIZE];
 
-	zassert_ok(bbram_emul_set_invalid(dev, true), NULL);
+	zassert_ok(bbram_emul_set_invalid(dev, true));
-	zassert_equal(bbram_write(dev, 0, BBRAM_SIZE, buffer), -EFAULT, NULL);
+	zassert_equal(bbram_write(dev, 0, BBRAM_SIZE, buffer), -EFAULT);
-	zassert_equal(bbram_check_invalid(dev), 0, NULL);
+	zassert_equal(bbram_check_invalid(dev), 0);
 }
 
 static void before(void *data)

tests/drivers/clock_control/nrf_lf_clock_start/src/main.c

@@ -22,7 +22,7 @@ static void xtal_check(bool on, nrf_clock_lfclk_t type)
 		zassert_true(is_running, "Clock should be on");
 	} else {
 		zassert_true(on, "Clock should be on");
-		zassert_equal(type, NRF_CLOCK_LFCLK_Xtal, NULL);
+		zassert_equal(type, NRF_CLOCK_LFCLK_Xtal);
 	}
 }
 
@@ -32,7 +32,7 @@ static void rc_check(bool on, nrf_clock_lfclk_t type)
 		zassert_false(on, "Clock should be off");
 	} else {
 		zassert_true(on, "Clock should be on");
-		zassert_equal(type, NRF_CLOCK_LFCLK_RC, NULL);
+		zassert_equal(type, NRF_CLOCK_LFCLK_RC);
 	}
 }
 
@@ -45,7 +45,7 @@ static void synth_check(bool on, nrf_clock_lfclk_t type)
 
 	if (!IS_ENABLED(CONFIG_SYSTEM_CLOCK_NO_WAIT)) {
 		zassert_true(on, "Clock should be on");
-		zassert_equal(type, NRF_CLOCK_LFCLK_Synth, NULL);
+		zassert_equal(type, NRF_CLOCK_LFCLK_Synth);
 	}
 }
 
@@ -78,13 +78,13 @@ ZTEST(nrf_lf_clock_start, test_wait_in_thread)
 
 	z_nrf_clock_control_lf_on(CLOCK_CONTROL_NRF_LF_START_AVAILABLE);
 	o = nrf_clock_is_running(NRF_CLOCK, NRF_CLOCK_DOMAIN_LFCLK, &t);
-	zassert_false((t == NRF_CLOCK_LFCLK_Xtal) && o, NULL);
+	zassert_false((t == NRF_CLOCK_LFCLK_Xtal) && o);
 	k_busy_wait(35);
-	zassert_true(k_cycle_get_32() > 0, NULL);
+	zassert_true(k_cycle_get_32() > 0);
 
 	z_nrf_clock_control_lf_on(CLOCK_CONTROL_NRF_LF_START_STABLE);
 	o = nrf_clock_is_running(NRF_CLOCK, NRF_CLOCK_DOMAIN_LFCLK, &t);
-	zassert_true((t == NRF_CLOCK_LFCLK_Xtal) && o, NULL);
+	zassert_true((t == NRF_CLOCK_LFCLK_Xtal) && o);
 }
 
 void *test_init(void)

tests/drivers/clock_control/nrf_onoff_and_bt/src/main.c

@@ -27,10 +27,10 @@ static uint32_t iteration;
 static void before(void *data)
 {
 	ARG_UNUSED(data);
-	zassert_true(device_is_ready(entropy), NULL);
+	zassert_true(device_is_ready(entropy));
 
 	hf_mgr = z_nrf_clock_control_get_onoff(CLOCK_CONTROL_NRF_SUBSYS_HF);
-	zassert_true(hf_mgr, NULL);
+	zassert_true(hf_mgr);
 
 	iteration = 0;
 }
@@ -115,12 +115,12 @@ ZTEST(nrf_onoff_and_bt, test_onoff_interrupted)
 		iteration++;
 
 		err = entropy_get_entropy(entropy, &rand, 1);
-		zassert_equal(err, 0, NULL);
+		zassert_equal(err, 0);
 		backoff = 3 * rand;
 
 		sys_notify_init_spinwait(&cli.notify);
 		err = onoff_request(hf_mgr, &cli);
-		zassert_true(err >= 0, NULL);
+		zassert_true(err >= 0);
 
 		k_busy_wait(backoff);
 
@@ -129,7 +129,7 @@ ZTEST(nrf_onoff_and_bt, test_onoff_interrupted)
 		}
 
 		err = onoff_cancel_or_release(hf_mgr, &cli);
-		zassert_true(err >= 0, NULL);
+		zassert_true(err >= 0);
 
 		elapsed = k_uptime_get() - start_time;
 		if (elapsed > checkpoint) {
@@ -158,7 +158,7 @@ static void onoff_timeout_handler(struct k_timer *timer)
 	if (on) {
 		on = false;
 		err = onoff_cancel_or_release(hf_mgr, &cli);
-		zassert_true(err >= 0, NULL);
+		zassert_true(err >= 0);
 	} else {
 		on = true;
 		sys_notify_init_spinwait(&cli.notify);
@@ -208,7 +208,7 @@ ZTEST(nrf_onoff_and_bt, test_bt_interrupted)
 		iteration++;
 
 		err = entropy_get_entropy(entropy, &rand, 1);
-		zassert_equal(err, 0, NULL);
+		zassert_equal(err, 0);
 		backoff = 3 * rand;
 
 		z_nrf_clock_bt_ctlr_hf_request();

tests/drivers/dac/dac_loopback/src/test_dac.c

@@ -236,7 +236,7 @@ static int test_task_loopback(void)
 
 ZTEST(dac_loopback, test_dac_loopback)
 {
-	zassert_true(test_task_loopback() == TC_PASS, NULL);
+	zassert_true(test_task_loopback() == TC_PASS);
 }
 
 ZTEST_SUITE(dac_loopback, NULL, NULL, NULL, NULL, NULL);

tests/drivers/dma/chan_blen_transfer/src/test_dma.c

@@ -101,20 +101,20 @@ static int test_task(uint32_t chan_id, uint32_t blen)
 /* export test cases */
 ZTEST(dma_m2m, test_dma_m2m_chan0_burst8)
 {
-	zassert_true((test_task(CONFIG_DMA_TRANSFER_CHANNEL_NR_0, 8) == TC_PASS), NULL);
+	zassert_true((test_task(CONFIG_DMA_TRANSFER_CHANNEL_NR_0, 8) == TC_PASS));
 }
 
 ZTEST(dma_m2m, test_dma_m2m_chan1_burst8)
 {
-	zassert_true((test_task(CONFIG_DMA_TRANSFER_CHANNEL_NR_1, 8) == TC_PASS), NULL);
+	zassert_true((test_task(CONFIG_DMA_TRANSFER_CHANNEL_NR_1, 8) == TC_PASS));
 }
 
 ZTEST(dma_m2m, test_dma_m2m_chan0_burst16)
 {
-	zassert_true((test_task(CONFIG_DMA_TRANSFER_CHANNEL_NR_0, 16) == TC_PASS), NULL);
+	zassert_true((test_task(CONFIG_DMA_TRANSFER_CHANNEL_NR_0, 16) == TC_PASS));
 }
 
 ZTEST(dma_m2m, test_dma_m2m_chan1_burst16)
 {
-	zassert_true((test_task(CONFIG_DMA_TRANSFER_CHANNEL_NR_1, 16) == TC_PASS), NULL);
+	zassert_true((test_task(CONFIG_DMA_TRANSFER_CHANNEL_NR_1, 16) == TC_PASS));
 }

tests/drivers/dma/chan_link_transfer/src/test_dma.c

@@ -141,15 +141,15 @@ static int test_task(int minor, int major)
 /* export test cases */
 ZTEST(dma_m2m_link, test_dma_m2m_chan0_1_major_link)
 {
-	zassert_true((test_task(0, 1) == TC_PASS), NULL);
+	zassert_true((test_task(0, 1) == TC_PASS));
 }
 
 ZTEST(dma_m2m_link, test_dma_m2m_chan0_1_minor_link)
 {
-	zassert_true((test_task(1, 0) == TC_PASS), NULL);
+	zassert_true((test_task(1, 0) == TC_PASS));
 }
 
 ZTEST(dma_m2m_link, test_dma_m2m_chan0_1_minor_major_link)
 {
-	zassert_true((test_task(1, 1) == TC_PASS), NULL);
+	zassert_true((test_task(1, 1) == TC_PASS));
 }

tests/drivers/dma/loop_transfer/src/test_dma_loop.c

@@ -342,11 +342,11 @@ static int test_loop_suspend_resume(void)
 /* export test cases */
 ZTEST(dma_m2m_loop, test_dma_m2m_loop)
 {
-	zassert_true((test_loop() == TC_PASS), NULL);
+	zassert_true((test_loop() == TC_PASS));
 }
 
 /* export test cases */
 ZTEST(dma_m2m_loop, test_dma_m2m_loop_suspend_resume)
 {
-	zassert_true((test_loop_suspend_resume() == TC_PASS), NULL);
+	zassert_true((test_loop_suspend_resume() == TC_PASS));
 }

tests/drivers/dma/scatter_gather/src/test_dma_sg.c

@@ -148,5 +148,5 @@ static int test_sg(void)
 /* export test cases */
 ZTEST(dma_m2m_sg, test_dma_m2m_sg)
 {
-	zassert_true((test_sg() == TC_PASS), NULL);
+	zassert_true((test_sg() == TC_PASS));
 }

tests/drivers/entropy/api/src/main.c

@@ -100,7 +100,7 @@ static int get_entropy(void)
 
 ZTEST(entropy_api, test_entropy_get_entropy)
 {
-	zassert_true(get_entropy() == TC_PASS, NULL);
+	zassert_true(get_entropy() == TC_PASS);
 }
 
 void *entropy_api_setup(void)

tests/drivers/espi/src/test_acpi.c

@@ -18,7 +18,7 @@ static void test_acpi_shared_memory(void)
 
 	zassert_true(device_is_ready(espi_dev), "Device is not ready");
 
-	zassert_ok(espi_config(espi_dev, &cfg), NULL);
+	zassert_ok(espi_config(espi_dev, &cfg));
 
 	host_shm = emul_espi_host_get_acpi_shm(espi_dev);
 	zassert_not_equal(host_shm, 0, NULL);
@@ -27,7 +27,7 @@ static void test_acpi_shared_memory(void)
 					 (uint32_t *)&peripheral_shm),
 		   NULL);
 
-	zassert_equal(host_shm, peripheral_shm, NULL);
+	zassert_equal(host_shm, peripheral_shm);
 }
 
 ztest_test_suite(acpi, ztest_unit_test(test_acpi_shared_memory));

tests/drivers/flash/src/main.c

@@ -55,7 +55,7 @@ static void *flash_driver_setup(void)
 {
 	int rc;
 
-	zassert_true(device_is_ready(flash_dev), NULL);
+	zassert_true(device_is_ready(flash_dev));
 
 	const struct flash_parameters *flash_params =
 			flash_get_parameters(flash_dev);

tests/drivers/i2c/i2c_api/src/test_i2c.c

@@ -151,12 +151,12 @@ static int test_burst_gy271(void)
 
 ZTEST(i2c_gy271, test_i2c_gy271)
 {
-	zassert_true(test_gy271() == TC_PASS, NULL);
+	zassert_true(test_gy271() == TC_PASS);
 }
 
 ZTEST(i2c_gy271, test_i2c_burst_gy271)
 {
-	zassert_true(test_burst_gy271() == TC_PASS, NULL);
+	zassert_true(test_burst_gy271() == TC_PASS);
 }
 
 ZTEST_SUITE(i2c_gy271, NULL, NULL, NULL, NULL, NULL);

tests/drivers/i2s/i2s_api/src/test_i2s_dir_both_loopback.c

@@ -26,7 +26,7 @@ void test_i2s_dir_both_transfer_configure_0(void)
 	zassert_not_null(dev_i2s, "device " I2S_DEV_NAME_RX " not found");
 
 	ret = configure_stream(dev_i2s, I2S_DIR_BOTH);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	/* Check if the tested driver supports the I2S_DIR_BOTH value.
 	 * Use the DROP trigger for this, as in the current state of the driver
@@ -59,22 +59,22 @@ void test_i2s_dir_both_transfer_short(void)
 
 	/* Prefill TX queue */
 	ret = tx_block_write(dev_i2s, 0, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	TC_PRINT("%d->OK\n", 1);
 
 	ret = tx_block_write(dev_i2s, 1, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	TC_PRINT("%d->OK\n", 2);
 
 	ret = i2s_trigger(dev_i2s, I2S_DIR_BOTH, I2S_TRIGGER_START);
 	zassert_equal(ret, 0, "RX/TX START trigger failed\n");
 
 	ret = rx_block_read(dev_i2s, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	TC_PRINT("%d<-OK\n", 1);
 
 	ret = tx_block_write(dev_i2s, 2, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	TC_PRINT("%d->OK\n", 3);
 
 	/* All data written, drain TX queue and stop both streams. */
@@ -82,11 +82,11 @@ void test_i2s_dir_both_transfer_short(void)
 	zassert_equal(ret, 0, "RX/TX DRAIN trigger failed");
 
 	ret = rx_block_read(dev_i2s, 1);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	TC_PRINT("%d<-OK\n", 2);
 
 	ret = rx_block_read(dev_i2s, 2);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	TC_PRINT("%d<-OK\n", 3);
 
 	/* TODO: Verify the interface is in READY state when i2s_state_get
@@ -114,17 +114,17 @@ void test_i2s_dir_both_transfer_long(void)
 
 	/* Prefill TX queue */
 	ret = tx_block_write(dev_i2s, 0, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	ret = i2s_trigger(dev_i2s, I2S_DIR_BOTH, I2S_TRIGGER_START);
 	zassert_equal(ret, 0, "RX/TX START trigger failed\n");
 
 	for (int i = 0; i < TEST_I2S_TRANSFER_LONG_REPEAT_COUNT; i++) {
 		ret = tx_block_write(dev_i2s, 0, 0);
-		zassert_equal(ret, TC_PASS, NULL);
+		zassert_equal(ret, TC_PASS);
 
 		ret = rx_block_read(dev_i2s, 0);
-		zassert_equal(ret, TC_PASS, NULL);
+		zassert_equal(ret, TC_PASS);
 	}
 
 	/* All data written, all but one data block read, flush TX queue
@@ -134,7 +134,7 @@ void test_i2s_dir_both_transfer_long(void)
 	zassert_equal(ret, 0, "RX/TX DRAIN trigger failed");
 
 	ret = rx_block_read(dev_i2s, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	/* TODO: Verify the interface is in READY state when i2s_state_get
 	 * function is available.
@@ -159,11 +159,11 @@ void test_i2s_dir_both_transfer_restart(void)
 
 	/* Prefill TX queue */
 	ret = tx_block_write(dev_i2s, 0, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	TC_PRINT("%d->OK\n", 1);
 
 	ret = tx_block_write(dev_i2s, 1, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	TC_PRINT("%d->OK\n", 2);
 
 	ret = i2s_trigger(dev_i2s, I2S_DIR_BOTH, I2S_TRIGGER_START);
@@ -173,7 +173,7 @@ void test_i2s_dir_both_transfer_restart(void)
 	zassert_equal(ret, 0, "RX/TX STOP trigger failed");
 
 	ret = rx_block_read(dev_i2s, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	TC_PRINT("%d<-OK\n", 1);
 
 	TC_PRINT("Stop transmission\n");
@@ -185,7 +185,7 @@ void test_i2s_dir_both_transfer_restart(void)
 
 	/* Prefill TX queue */
 	ret = tx_block_write(dev_i2s, 2, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	TC_PRINT("%d->OK\n", 3);
 
 	ret = i2s_trigger(dev_i2s, I2S_DIR_BOTH, I2S_TRIGGER_START);
@@ -195,11 +195,11 @@ void test_i2s_dir_both_transfer_restart(void)
 	zassert_equal(ret, 0, "RX/TX DRAIN trigger failed");
 
 	ret = rx_block_read(dev_i2s, 1);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	TC_PRINT("%d<-OK\n", 2);
 
 	ret = rx_block_read(dev_i2s, 2);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	TC_PRINT("%d<-OK\n", 3);
 }
 
@@ -226,14 +226,14 @@ void test_i2s_dir_both_transfer_rx_overrun(void)
 
 	/* Prefill TX queue */
 	ret = tx_block_write(dev_i2s, 0, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	ret = i2s_trigger(dev_i2s, I2S_DIR_BOTH, I2S_TRIGGER_START);
 	zassert_equal(ret, 0, "RX/TX START trigger failed\n");
 
 	for (int i = 0; i < NUM_RX_BLOCKS; i++) {
 		ret = tx_block_write(dev_i2s, 0, 0);
-		zassert_equal(ret, TC_PASS, NULL);
+		zassert_equal(ret, TC_PASS);
 	}
 
 	/* All data written, flush TX queue and stop the transmission */
@@ -247,7 +247,7 @@ void test_i2s_dir_both_transfer_rx_overrun(void)
 	 * the error state.
 	 */
 	ret = rx_block_read(dev_i2s, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	/* Attempt to read more data blocks than are available in the RX queue */
 	for (int i = 0; i < NUM_RX_BLOCKS; i++) {
@@ -263,13 +263,13 @@ void test_i2s_dir_both_transfer_rx_overrun(void)
 
 	/* Transmit and receive one more data block */
 	ret = tx_block_write(dev_i2s, 0, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	ret = i2s_trigger(dev_i2s, I2S_DIR_BOTH, I2S_TRIGGER_START);
 	zassert_equal(ret, 0, "RX/TX START trigger failed\n");
 	ret = i2s_trigger(dev_i2s, I2S_DIR_BOTH, I2S_TRIGGER_DRAIN);
 	zassert_equal(ret, 0, "RX/TX DRAIN trigger failed");
 	ret = rx_block_read(dev_i2s, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	k_sleep(K_MSEC(200));
 }
@@ -293,19 +293,19 @@ void test_i2s_dir_both_transfer_tx_underrun(void)
 
 	/* Prefill TX queue */
 	ret = tx_block_write(dev_i2s, 0, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	ret = i2s_trigger(dev_i2s, I2S_DIR_BOTH, I2S_TRIGGER_START);
 	zassert_equal(ret, 0, "RX/TX START trigger failed\n");
 
 	ret = rx_block_read(dev_i2s, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	k_sleep(K_MSEC(200));
 
 	/* Write one more TX data block, expect an error */
 	ret = tx_block_write(dev_i2s, 2, -EIO);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	ret = i2s_trigger(dev_i2s, I2S_DIR_BOTH, I2S_TRIGGER_PREPARE);
 	zassert_equal(ret, 0, "RX/TX PREPARE trigger failed");
@@ -314,17 +314,17 @@ void test_i2s_dir_both_transfer_tx_underrun(void)
 
 	/* Transmit and receive two more data blocks */
 	ret = tx_block_write(dev_i2s, 1, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	ret = tx_block_write(dev_i2s, 1, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	ret = i2s_trigger(dev_i2s, I2S_DIR_BOTH, I2S_TRIGGER_START);
 	zassert_equal(ret, 0, "RX/TX START trigger failed\n");
 	ret = rx_block_read(dev_i2s, 1);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	ret = i2s_trigger(dev_i2s, I2S_DIR_BOTH, I2S_TRIGGER_DRAIN);
 	zassert_equal(ret, 0, "RX/TX DRAIN trigger failed");
 	ret = rx_block_read(dev_i2s, 1);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	k_sleep(K_MSEC(200));
 }

tests/drivers/i2s/i2s_api/src/test_i2s_dir_both_states.c

@@ -26,7 +26,7 @@ void test_i2s_dir_both_transfer_configure_1(void)
 	zassert_not_null(dev_i2s, "device " I2S_DEV_NAME_RX " not found");
 
 	ret = configure_stream(dev_i2s, I2S_DIR_BOTH);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	/* Check if the tested driver supports the I2S_DIR_BOTH value.
 	 * Use the DROP trigger for this, as in the current state of the driver
@@ -59,23 +59,23 @@ void test_i2s_dir_both_state_running_neg(void)
 
 	/* Prefill TX queue */
 	ret = tx_block_write(dev_i2s, 0, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	ret = i2s_trigger(dev_i2s, I2S_DIR_BOTH, I2S_TRIGGER_START);
 	zassert_equal(ret, 0, "RX/TX START trigger failed\n");
 
 	for (int i = 0; i < TEST_I2S_STATE_RUNNING_NEG_REPEAT_COUNT; i++) {
 		ret = tx_block_write(dev_i2s, 0, 0);
-		zassert_equal(ret, TC_PASS, NULL);
+		zassert_equal(ret, TC_PASS);
 
 		ret = rx_block_read(dev_i2s, 0);
-		zassert_equal(ret, TC_PASS, NULL);
+		zassert_equal(ret, TC_PASS);
 
 		/* Send invalid triggers, expect failure */
 		ret = i2s_trigger(dev_i2s, I2S_DIR_BOTH, I2S_TRIGGER_START);
-		zassert_equal(ret, -EIO, NULL);
+		zassert_equal(ret, -EIO);
 		ret = i2s_trigger(dev_i2s, I2S_DIR_BOTH, I2S_TRIGGER_PREPARE);
-		zassert_equal(ret, -EIO, NULL);
+		zassert_equal(ret, -EIO);
 	}
 
 	/* All data written, drain TX queue and stop both streams. */
@@ -83,7 +83,7 @@ void test_i2s_dir_both_state_running_neg(void)
 	zassert_equal(ret, 0, "RX/TX DRAIN trigger failed");
 
 	ret = rx_block_read(dev_i2s, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 }
 
 /** @brief Verify all failure cases in STOPPING state.
@@ -103,16 +103,16 @@ void test_i2s_dir_both_state_stopping_neg(void)
 
 	/* Prefill TX queue */
 	ret = tx_block_write(dev_i2s, 0, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	ret = i2s_trigger(dev_i2s, I2S_DIR_BOTH, I2S_TRIGGER_START);
 	zassert_equal(ret, 0, "RX/TX START trigger failed\n");
 
 	ret = tx_block_write(dev_i2s, 0, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	ret = rx_block_read(dev_i2s, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	/* All data written, all but one data block read, flush TX queue and
 	 * stop both streams.
@@ -122,16 +122,16 @@ void test_i2s_dir_both_state_stopping_neg(void)
 
 	/* Send invalid triggers, expect failure */
 	ret = i2s_trigger(dev_i2s, I2S_DIR_BOTH, I2S_TRIGGER_START);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 	ret = i2s_trigger(dev_i2s, I2S_DIR_BOTH, I2S_TRIGGER_STOP);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 	ret = i2s_trigger(dev_i2s, I2S_DIR_BOTH, I2S_TRIGGER_DRAIN);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 	ret = i2s_trigger(dev_i2s, I2S_DIR_BOTH, I2S_TRIGGER_PREPARE);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 
 	ret = rx_block_read(dev_i2s, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	/* This is incase the RX channel is stuck in STOPPING state.
 	 * Clear out the state before running the next test.
@@ -158,14 +158,14 @@ void test_i2s_dir_both_state_error_neg(void)
 
 	/* Prefill TX queue */
 	ret = tx_block_write(dev_i2s, 0, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	ret = i2s_trigger(dev_i2s, I2S_DIR_BOTH, I2S_TRIGGER_START);
 	zassert_equal(ret, 0, "RX/TX START trigger failed\n");
 
 	for (int i = 0; i < NUM_RX_BLOCKS; i++) {
 		ret = tx_block_write(dev_i2s, 0, 0);
-		zassert_equal(ret, TC_PASS, NULL);
+		zassert_equal(ret, TC_PASS);
 	}
 
 	/* Wait for transmission to finish */
@@ -175,7 +175,7 @@ void test_i2s_dir_both_state_error_neg(void)
 	 * the error state.
 	 */
 	ret = rx_block_read(dev_i2s, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	/* Attempt to read more data blocks than are available in the RX queue */
 	for (int i = 0; i < NUM_RX_BLOCKS; i++) {
@@ -188,15 +188,15 @@ void test_i2s_dir_both_state_error_neg(void)
 
 	/* Write one more TX data block, expect an error */
 	ret = tx_block_write(dev_i2s, 2, -EIO);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	/* Send invalid triggers, expect failure */
 	ret = i2s_trigger(dev_i2s, I2S_DIR_BOTH, I2S_TRIGGER_START);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 	ret = i2s_trigger(dev_i2s, I2S_DIR_BOTH, I2S_TRIGGER_STOP);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 	ret = i2s_trigger(dev_i2s, I2S_DIR_BOTH, I2S_TRIGGER_DRAIN);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 
 	/* Recover from ERROR state */
 	ret = i2s_trigger(dev_i2s, I2S_DIR_BOTH, I2S_TRIGGER_PREPARE);
@@ -204,13 +204,13 @@ void test_i2s_dir_both_state_error_neg(void)
 
 	/* Transmit and receive one more data block */
 	ret = tx_block_write(dev_i2s, 0, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	ret = i2s_trigger(dev_i2s, I2S_DIR_BOTH, I2S_TRIGGER_START);
 	zassert_equal(ret, 0, "RX/TX START trigger failed");
 	ret = i2s_trigger(dev_i2s, I2S_DIR_BOTH, I2S_TRIGGER_DRAIN);
 	zassert_equal(ret, 0, "RX/TX DRAIN trigger failed");
 	ret = rx_block_read(dev_i2s, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	k_sleep(K_MSEC(200));
 }

tests/drivers/i2s/i2s_api/src/test_i2s_loopback.c

@@ -22,7 +22,7 @@ void test_i2s_tx_transfer_configure_0(void)
 	zassert_not_null(dev_i2s_tx, "device " I2S_DEV_NAME_TX " not found");
 
 	ret = configure_stream(dev_i2s_tx, I2S_DIR_TX);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 }
 
 /** Configure I2S RX transfer. */
@@ -34,7 +34,7 @@ void test_i2s_rx_transfer_configure_0(void)
 	zassert_not_null(dev_i2s_rx, "device " I2S_DEV_NAME_RX " not found");
 
 	ret = configure_stream(dev_i2s_rx, I2S_DIR_RX);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 }
 
 /** @brief Short I2S transfer.
@@ -57,11 +57,11 @@ void test_i2s_transfer_short(void)
 
 	/* Prefill TX queue */
 	ret = tx_block_write(dev_i2s_tx, 0, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	TC_PRINT("%d->OK\n", 1);
 
 	ret = tx_block_write(dev_i2s_tx, 1, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	TC_PRINT("%d->OK\n", 2);
 
 	/* Start reception */
@@ -73,11 +73,11 @@ void test_i2s_transfer_short(void)
 	zassert_equal(ret, 0, "TX START trigger failed");
 
 	ret = rx_block_read(dev_i2s_rx, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	TC_PRINT("%d<-OK\n", 1);
 
 	ret = tx_block_write(dev_i2s_tx, 2, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	TC_PRINT("%d->OK\n", 3);
 
 	/* All data written, drain TX queue and stop the transmission */
@@ -85,7 +85,7 @@ void test_i2s_transfer_short(void)
 	zassert_equal(ret, 0, "TX DRAIN trigger failed");
 
 	ret = rx_block_read(dev_i2s_rx, 1);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	TC_PRINT("%d<-OK\n", 2);
 
 	/* All but one data block read, stop reception */
@@ -93,7 +93,7 @@ void test_i2s_transfer_short(void)
 	zassert_equal(ret, 0, "RX STOP trigger failed");
 
 	ret = rx_block_read(dev_i2s_rx, 2);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	TC_PRINT("%d<-OK\n", 3);
 
 	/* TODO: Verify the interface is in READY state when i2s_state_get
@@ -123,7 +123,7 @@ void test_i2s_transfer_long(void)
 
 	/* Prefill TX queue */
 	ret = tx_block_write(dev_i2s_tx, 0, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	/* Start reception */
 	ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_START);
@@ -135,10 +135,10 @@ void test_i2s_transfer_long(void)
 
 	for (int i = 0; i < TEST_I2S_TRANSFER_LONG_REPEAT_COUNT; i++) {
 		ret = tx_block_write(dev_i2s_tx, 0, 0);
-		zassert_equal(ret, TC_PASS, NULL);
+		zassert_equal(ret, TC_PASS);
 
 		ret = rx_block_read(dev_i2s_rx, 0);
-		zassert_equal(ret, TC_PASS, NULL);
+		zassert_equal(ret, TC_PASS);
 	}
 
 	/* All data written, flush TX queue and stop the transmission */
@@ -150,7 +150,7 @@ void test_i2s_transfer_long(void)
 	zassert_equal(ret, 0, "RX STOP trigger failed");
 
 	ret = rx_block_read(dev_i2s_rx, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	/* TODO: Verify the interface is in READY state when i2s_state_get
 	 * function is available.
@@ -181,7 +181,7 @@ void test_i2s_rx_sync_start(void)
 	for (int n = 0; n < NUM_TX_BLOCKS; n++) {
 		fill_buf_const((uint16_t *)buf, 1, 2);
 		ret = i2s_buf_write(dev_i2s_tx, buf, BLOCK_SIZE);
-		zassert_equal(ret, TC_PASS, NULL);
+		zassert_equal(ret, TC_PASS);
 		TC_PRINT("%d->OK\n", n);
 	}
 
@@ -195,10 +195,10 @@ void test_i2s_rx_sync_start(void)
 	ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_START);
 	zassert_equal(ret, 0, "RX START trigger failed");
 	ret = i2s_buf_read(dev_i2s_rx, buf, &rx_size);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	ret = verify_buf_const((uint16_t *)buf, 1, 2);
 
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	TC_PRINT("%d<-OK\n", 1);
 
 	/* All data written, drop TX, RX queue and stop the transmission */
@@ -245,11 +245,11 @@ void test_i2s_transfer_restart(void)
 
 	/* Prefill TX queue */
 	ret = tx_block_write(dev_i2s_tx, 0, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	TC_PRINT("%d->OK\n", 1);
 
 	ret = tx_block_write(dev_i2s_tx, 1, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	TC_PRINT("%d->OK\n", 2);
 
 	/* Start reception */
@@ -269,7 +269,7 @@ void test_i2s_transfer_restart(void)
 	zassert_equal(ret, 0, "RX STOP trigger failed");
 
 	ret = rx_block_read(dev_i2s_rx, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	TC_PRINT("%d<-OK\n", 1);
 
 	TC_PRINT("Stop transmission\n");
@@ -281,7 +281,7 @@ void test_i2s_transfer_restart(void)
 
 	/* Prefill TX queue */
 	ret = tx_block_write(dev_i2s_tx, 2, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	TC_PRINT("%d->OK\n", 3);
 
 	/* Start reception */
@@ -297,7 +297,7 @@ void test_i2s_transfer_restart(void)
 	zassert_equal(ret, 0, "TX DRAIN trigger failed");
 
 	ret = rx_block_read(dev_i2s_rx, 1);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	TC_PRINT("%d<-OK\n", 2);
 
 	/* All but one data block read, stop reception */
@@ -305,7 +305,7 @@ void test_i2s_transfer_restart(void)
 	zassert_equal(ret, 0, "RX STOP trigger failed");
 
 	ret = rx_block_read(dev_i2s_rx, 2);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	TC_PRINT("%d<-OK\n", 3);
 }
 
@@ -332,7 +332,7 @@ void test_i2s_transfer_rx_overrun(void)
 
 	/* Prefill TX queue */
 	ret = tx_block_write(dev_i2s_tx, 0, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	/* Start reception */
 	ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_START);
@@ -344,7 +344,7 @@ void test_i2s_transfer_rx_overrun(void)
 
 	for (int i = 0; i < NUM_RX_BLOCKS; i++) {
 		ret = tx_block_write(dev_i2s_tx, 0, 0);
-		zassert_equal(ret, TC_PASS, NULL);
+		zassert_equal(ret, TC_PASS);
 	}
 
 	/* All data written, flush TX queue and stop the transmission */
@@ -358,7 +358,7 @@ void test_i2s_transfer_rx_overrun(void)
 	 * the error state.
 	 */
 	ret = rx_block_read(dev_i2s_rx, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	/* Attempt to read more data blocks than are available in the RX queue */
 	for (int i = 0; i < NUM_RX_BLOCKS; i++) {
@@ -374,7 +374,7 @@ void test_i2s_transfer_rx_overrun(void)
 
 	/* Transmit and receive one more data block */
 	ret = tx_block_write(dev_i2s_tx, 0, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_START);
 	zassert_equal(ret, 0, "RX START trigger failed");
 	ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_START);
@@ -384,7 +384,7 @@ void test_i2s_transfer_rx_overrun(void)
 	ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_STOP);
 	zassert_equal(ret, 0, "RX STOP trigger failed");
 	ret = rx_block_read(dev_i2s_rx, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	k_sleep(K_MSEC(200));
 }
@@ -408,7 +408,7 @@ void test_i2s_transfer_tx_underrun(void)
 
 	/* Prefill TX queue */
 	ret = tx_block_write(dev_i2s_tx, 0, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	/* Start reception */
 	ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_START);
@@ -423,13 +423,13 @@ void test_i2s_transfer_tx_underrun(void)
 	zassert_equal(ret, 0, "RX STOP trigger failed");
 
 	ret = rx_block_read(dev_i2s_rx, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	k_sleep(K_MSEC(200));
 
 	/* Write one more TX data block, expect an error */
 	ret = tx_block_write(dev_i2s_tx, 2, -EIO);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_PREPARE);
 	zassert_equal(ret, 0, "TX PREPARE trigger failed");
@@ -438,21 +438,21 @@ void test_i2s_transfer_tx_underrun(void)
 
 	/* Transmit and receive two more data blocks */
 	ret = tx_block_write(dev_i2s_tx, 1, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	ret = tx_block_write(dev_i2s_tx, 1, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_START);
 	zassert_equal(ret, 0, "RX START trigger failed");
 	ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_START);
 	zassert_equal(ret, 0, "TX START trigger failed");
 	ret = rx_block_read(dev_i2s_rx, 1);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_DRAIN);
 	zassert_equal(ret, 0, "TX DRAIN trigger failed");
 	ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_STOP);
 	zassert_equal(ret, 0, "RX STOP trigger failed");
 	ret = rx_block_read(dev_i2s_rx, 1);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	k_sleep(K_MSEC(200));
 }

tests/drivers/i2s/i2s_api/src/test_i2s_states.c

@@ -21,7 +21,7 @@ void test_i2s_tx_transfer_configure_1(void)
 	zassert_not_null(dev_i2s_tx, "device " I2S_DEV_NAME_TX " not found");
 
 	ret = configure_stream(dev_i2s_tx, I2S_DIR_TX);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 }
 
 /** Configure I2S RX transfer. */
@@ -33,7 +33,7 @@ void test_i2s_rx_transfer_configure_1(void)
 	zassert_not_null(dev_i2s_rx, "device " I2S_DEV_NAME_RX " not found");
 
 	ret = configure_stream(dev_i2s_rx, I2S_DIR_RX);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 }
 
 /** @brief Verify all failure cases in NOT_READY state.
@@ -57,22 +57,22 @@ void test_i2s_state_not_ready_neg(void)
 	zassert_equal(ret, 0, "Failed to configure I2S RX stream");
 
 	ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_START);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 
 	ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_DRAIN);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 
 	ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_STOP);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 
 	ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_DROP);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 
 	ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_PREPARE);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 
 	ret = i2s_buf_read(dev_i2s_rx, rx_buf, &rx_size);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 
 	i2s_cfg.frame_clk_freq = 0U;
 	i2s_cfg.mem_slab = &tx_mem_slab;
@@ -81,22 +81,22 @@ void test_i2s_state_not_ready_neg(void)
 	zassert_equal(ret, 0, "Failed to configure I2S TX stream");
 
 	ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_START);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 
 	ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_DRAIN);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 
 	ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_STOP);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 
 	ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_DROP);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 
 	ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_PREPARE);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 
 	ret = tx_block_write(dev_i2s_tx, 2, -EIO);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 }
 
 /** @brief Verify all failure cases in READY state.
@@ -109,33 +109,33 @@ void test_i2s_state_ready_neg(void)
 
 	/* Configure RX stream changing its state to READY */
 	ret = configure_stream(dev_i2s_rx, I2S_DIR_RX);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	/* Send RX stream triggers */
 
 	ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_DRAIN);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 
 	ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_STOP);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 
 	ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_PREPARE);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 
 	/* Configure TX stream changing its state to READY */
 	ret = configure_stream(dev_i2s_tx, I2S_DIR_TX);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	/* Send TX stream triggers */
 
 	ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_DRAIN);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 
 	ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_STOP);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 
 	ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_PREPARE);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 }
 
 #define TEST_I2S_STATE_RUNNING_NEG_REPEAT_COUNT  5
@@ -156,7 +156,7 @@ void test_i2s_state_running_neg(void)
 
 	/* Prefill TX queue */
 	ret = tx_block_write(dev_i2s_tx, 0, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	/* Start reception */
 	ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_START);
@@ -168,20 +168,20 @@ void test_i2s_state_running_neg(void)
 
 	for (int i = 0; i < TEST_I2S_STATE_RUNNING_NEG_REPEAT_COUNT; i++) {
 		ret = tx_block_write(dev_i2s_tx, 0, 0);
-		zassert_equal(ret, TC_PASS, NULL);
+		zassert_equal(ret, TC_PASS);
 
 		ret = rx_block_read(dev_i2s_rx, 0);
-		zassert_equal(ret, TC_PASS, NULL);
+		zassert_equal(ret, TC_PASS);
 
 		/* Send invalid triggers, expect failure */
 		ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_START);
-		zassert_equal(ret, -EIO, NULL);
+		zassert_equal(ret, -EIO);
 		ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_PREPARE);
-		zassert_equal(ret, -EIO, NULL);
+		zassert_equal(ret, -EIO);
 		ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_START);
-		zassert_equal(ret, -EIO, NULL);
+		zassert_equal(ret, -EIO);
 		ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_PREPARE);
-		zassert_equal(ret, -EIO, NULL);
+		zassert_equal(ret, -EIO);
 	}
 
 	/* All data written, flush TX queue and stop the transmission */
@@ -193,7 +193,7 @@ void test_i2s_state_running_neg(void)
 	zassert_equal(ret, 0, "RX STOP trigger failed");
 
 	ret = rx_block_read(dev_i2s_rx, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 }
 
 /** @brief Verify all failure cases in STOPPING state.
@@ -213,7 +213,7 @@ void test_i2s_state_stopping_neg(void)
 
 	/* Prefill TX queue */
 	ret = tx_block_write(dev_i2s_tx, 0, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	/* Start reception */
 	ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_START);
@@ -224,10 +224,10 @@ void test_i2s_state_stopping_neg(void)
 	zassert_equal(ret, 0, "TX START trigger failed");
 
 	ret = tx_block_write(dev_i2s_tx, 0, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	ret = rx_block_read(dev_i2s_rx, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	/* All data written, flush TX queue and stop the transmission */
 	ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_DRAIN);
@@ -235,13 +235,13 @@ void test_i2s_state_stopping_neg(void)
 
 	/* Send invalid triggers, expect failure */
 	ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_START);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 	ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_STOP);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 	ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_DRAIN);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 	ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_PREPARE);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 
 	/* All but one data block read, stop reception */
 	ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_STOP);
@@ -249,16 +249,16 @@ void test_i2s_state_stopping_neg(void)
 
 	/* Send invalid triggers, expect failure */
 	ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_START);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 	ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_STOP);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 	ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_DRAIN);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 	ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_PREPARE);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 
 	ret = rx_block_read(dev_i2s_rx, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	/* This is incase the RX channel is stuck in STOPPING state.
 	 * Clear out the state before running the next test.
@@ -285,7 +285,7 @@ void test_i2s_state_error_neg(void)
 
 	/* Prefill TX queue */
 	ret = tx_block_write(dev_i2s_tx, 0, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	/* Start reception */
 	ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_START);
@@ -297,7 +297,7 @@ void test_i2s_state_error_neg(void)
 
 	for (int i = 0; i < NUM_RX_BLOCKS; i++) {
 		ret = tx_block_write(dev_i2s_tx, 0, 0);
-		zassert_equal(ret, TC_PASS, NULL);
+		zassert_equal(ret, TC_PASS);
 	}
 
 	/* Wait for transmission to finish */
@@ -307,7 +307,7 @@ void test_i2s_state_error_neg(void)
 	 * the error state.
 	 */
 	ret = rx_block_read(dev_i2s_rx, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	/* Attempt to read more data blocks than are available in the RX queue */
 	for (int i = 0; i < NUM_RX_BLOCKS; i++) {
@@ -320,11 +320,11 @@ void test_i2s_state_error_neg(void)
 
 	/* Send invalid triggers, expect failure */
 	ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_START);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 	ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_STOP);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 	ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_DRAIN);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 
 	/* Recover from ERROR state */
 	ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_PREPARE);
@@ -332,15 +332,15 @@ void test_i2s_state_error_neg(void)
 
 	/* Write one more TX data block, expect an error */
 	ret = tx_block_write(dev_i2s_tx, 2, -EIO);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	/* Send invalid triggers, expect failure */
 	ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_START);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 	ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_STOP);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 	ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_DRAIN);
-	zassert_equal(ret, -EIO, NULL);
+	zassert_equal(ret, -EIO);
 
 	/* Recover from ERROR state */
 	ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_PREPARE);
@@ -348,7 +348,7 @@ void test_i2s_state_error_neg(void)
 
 	/* Transmit and receive one more data block */
 	ret = tx_block_write(dev_i2s_tx, 0, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 	ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_START);
 	zassert_equal(ret, 0, "RX START trigger failed");
 	ret = i2s_trigger(dev_i2s_tx, I2S_DIR_TX, I2S_TRIGGER_START);
@@ -358,7 +358,7 @@ void test_i2s_state_error_neg(void)
 	ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_STOP);
 	zassert_equal(ret, 0, "RX STOP trigger failed");
 	ret = rx_block_read(dev_i2s_rx, 0);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	k_sleep(K_MSEC(200));
 }

tests/drivers/i2s/i2s_speed/src/test_i2s_speed.c

@@ -187,7 +187,7 @@ void test_i2s_tx_transfer_configure(void)
 	zassert_not_null(dev_i2s_tx, "device " I2S_DEV_NAME_TX " not found");
 
 	ret = configure_stream(dev_i2s_tx, I2S_DIR_TX);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 }
 
 /** Configure I2S RX transfer. */
@@ -199,7 +199,7 @@ void test_i2s_rx_transfer_configure(void)
 	zassert_not_null(dev_i2s_rx, "device " I2S_DEV_NAME_RX " not found");
 
 	ret = configure_stream(dev_i2s_rx, I2S_DIR_RX);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 }
 
 /** @brief Short I2S transfer.
@@ -226,11 +226,11 @@ void test_i2s_transfer_short(void)
 	/* Prefill TX queue */
 	for (int i = 0; i < 3; i++) {
 		ret = k_mem_slab_alloc(&tx_0_mem_slab, &tx_block, K_FOREVER);
-		zassert_equal(ret, 0, NULL);
+		zassert_equal(ret, 0);
 		fill_buf((uint16_t *)tx_block, i);
 
 		ret = i2s_write(dev_i2s_tx, tx_block, BLOCK_SIZE);
-		zassert_equal(ret, 0, NULL);
+		zassert_equal(ret, 0);
 
 		TC_PRINT("%d->OK\n", i);
 	}
@@ -248,34 +248,34 @@ void test_i2s_transfer_short(void)
 	zassert_equal(ret, 0, "TX DRAIN trigger failed");
 
 	ret = i2s_read(dev_i2s_rx, &rx_block[0], &rx_size);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
-	zassert_equal(rx_size, BLOCK_SIZE, NULL);
+	zassert_equal(rx_size, BLOCK_SIZE);
 
 	ret = i2s_read(dev_i2s_rx, &rx_block[1], &rx_size);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
-	zassert_equal(rx_size, BLOCK_SIZE, NULL);
+	zassert_equal(rx_size, BLOCK_SIZE);
 
 	/* All but one data block read, stop reception */
 	ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_STOP);
 	zassert_equal(ret, 0, "RX STOP trigger failed");
 
 	ret = i2s_read(dev_i2s_rx, &rx_block[2], &rx_size);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
-	zassert_equal(rx_size, BLOCK_SIZE, NULL);
+	zassert_equal(rx_size, BLOCK_SIZE);
 
 	/* Verify received data */
 	ret = verify_buf((uint16_t *)rx_block[0], 0);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
 	k_mem_slab_free(&rx_0_mem_slab, &rx_block[0]);
 	TC_PRINT("%d<-OK\n", 1);
 
 	ret = verify_buf((uint16_t *)rx_block[1], 1);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
 	k_mem_slab_free(&rx_0_mem_slab, &rx_block[1]);
 	TC_PRINT("%d<-OK\n", 2);
 
 	ret = verify_buf((uint16_t *)rx_block[2], 2);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
 	k_mem_slab_free(&rx_0_mem_slab, &rx_block[2]);
 	TC_PRINT("%d<-OK\n", 3);
 }
@@ -308,7 +308,7 @@ void test_i2s_transfer_long(void)
 	for (tx_idx = 0; tx_idx < NUM_BLOCKS; tx_idx++) {
 		ret = k_mem_slab_alloc(&tx_0_mem_slab, &tx_block[tx_idx],
 				       K_FOREVER);
-		zassert_equal(ret, 0, NULL);
+		zassert_equal(ret, 0);
 		fill_buf((uint16_t *)tx_block[tx_idx], tx_idx % 3);
 	}
 
@@ -316,10 +316,10 @@ void test_i2s_transfer_long(void)
 
 	/* Prefill TX queue */
 	ret = i2s_write(dev_i2s_tx, tx_block[tx_idx++], BLOCK_SIZE);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
 
 	ret = i2s_write(dev_i2s_tx, tx_block[tx_idx++], BLOCK_SIZE);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
 
 	/* Start reception */
 	ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_START);
@@ -331,11 +331,11 @@ void test_i2s_transfer_long(void)
 
 	for (; tx_idx < NUM_BLOCKS; ) {
 		ret = i2s_write(dev_i2s_tx, tx_block[tx_idx++], BLOCK_SIZE);
-		zassert_equal(ret, 0, NULL);
+		zassert_equal(ret, 0);
 
 		ret = i2s_read(dev_i2s_rx, &rx_block[rx_idx++], &rx_size);
-		zassert_equal(ret, 0, NULL);
+		zassert_equal(ret, 0);
-		zassert_equal(rx_size, BLOCK_SIZE, NULL);
+		zassert_equal(rx_size, BLOCK_SIZE);
 	}
 
 	/* All data written, flush TX queue and stop the transmission */
@@ -343,16 +343,16 @@ void test_i2s_transfer_long(void)
 	zassert_equal(ret, 0, "TX DRAIN trigger failed");
 
 	ret = i2s_read(dev_i2s_rx, &rx_block[rx_idx++], &rx_size);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
-	zassert_equal(rx_size, BLOCK_SIZE, NULL);
+	zassert_equal(rx_size, BLOCK_SIZE);
 
 	/* All but one data block read, stop reception */
 	ret = i2s_trigger(dev_i2s_rx, I2S_DIR_RX, I2S_TRIGGER_STOP);
 	zassert_equal(ret, 0, "RX STOP trigger failed");
 
 	ret = i2s_read(dev_i2s_rx, &rx_block[rx_idx++], &rx_size);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
-	zassert_equal(rx_size, BLOCK_SIZE, NULL);
+	zassert_equal(rx_size, BLOCK_SIZE);
 
 	TC_PRINT("%d TX blocks sent\n", tx_idx);
 	TC_PRINT("%d RX blocks received\n", rx_idx);
@@ -379,7 +379,7 @@ void test_i2s_dir_both_transfer_configure(void)
 	zassert_not_null(dev_i2s_rxtx, "device " I2S_DEV_NAME_RX " not found");
 
 	ret = configure_stream(dev_i2s_rxtx, I2S_DIR_BOTH);
-	zassert_equal(ret, TC_PASS, NULL);
+	zassert_equal(ret, TC_PASS);
 
 	/* Check if the tested driver supports the I2S_DIR_BOTH value.
 	 * Use the DROP trigger for this, as in the current state of the driver
@@ -416,11 +416,11 @@ void test_i2s_dir_both_transfer_short(void)
 	/* Prefill TX queue */
 	for (int i = 0; i < 3; i++) {
 		ret = k_mem_slab_alloc(&tx_0_mem_slab, &tx_block, K_FOREVER);
-		zassert_equal(ret, 0, NULL);
+		zassert_equal(ret, 0);
 		fill_buf((uint16_t *)tx_block, i);
 
 		ret = i2s_write(dev_i2s_rxtx, tx_block, BLOCK_SIZE);
-		zassert_equal(ret, 0, NULL);
+		zassert_equal(ret, 0);
 
 		TC_PRINT("%d->OK\n", i);
 	}
@@ -433,30 +433,30 @@ void test_i2s_dir_both_transfer_short(void)
 	zassert_equal(ret, 0, "RX/TX DRAIN trigger failed");
 
 	ret = i2s_read(dev_i2s_rxtx, &rx_block[0], &rx_size);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
-	zassert_equal(rx_size, BLOCK_SIZE, NULL);
+	zassert_equal(rx_size, BLOCK_SIZE);
 
 	ret = i2s_read(dev_i2s_rxtx, &rx_block[1], &rx_size);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
-	zassert_equal(rx_size, BLOCK_SIZE, NULL);
+	zassert_equal(rx_size, BLOCK_SIZE);
 
 	ret = i2s_read(dev_i2s_rxtx, &rx_block[2], &rx_size);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
-	zassert_equal(rx_size, BLOCK_SIZE, NULL);
+	zassert_equal(rx_size, BLOCK_SIZE);
 
 	/* Verify received data */
 	ret = verify_buf((uint16_t *)rx_block[0], 0);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
 	k_mem_slab_free(&rx_0_mem_slab, &rx_block[0]);
 	TC_PRINT("%d<-OK\n", 1);
 
 	ret = verify_buf((uint16_t *)rx_block[1], 1);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
 	k_mem_slab_free(&rx_0_mem_slab, &rx_block[1]);
 	TC_PRINT("%d<-OK\n", 2);
 
 	ret = verify_buf((uint16_t *)rx_block[2], 2);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
 	k_mem_slab_free(&rx_0_mem_slab, &rx_block[2]);
 	TC_PRINT("%d<-OK\n", 3);
 }
@@ -487,7 +487,7 @@ void test_i2s_dir_both_transfer_long(void)
 	for (tx_idx = 0; tx_idx < NUM_BLOCKS; tx_idx++) {
 		ret = k_mem_slab_alloc(&tx_0_mem_slab, &tx_block[tx_idx],
 				       K_FOREVER);
-		zassert_equal(ret, 0, NULL);
+		zassert_equal(ret, 0);
 		fill_buf((uint16_t *)tx_block[tx_idx], tx_idx % 3);
 	}
 
@@ -495,21 +495,21 @@ void test_i2s_dir_both_transfer_long(void)
 
 	/* Prefill TX queue */
 	ret = i2s_write(dev_i2s_rxtx, tx_block[tx_idx++], BLOCK_SIZE);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
 
 	ret = i2s_write(dev_i2s_rxtx, tx_block[tx_idx++], BLOCK_SIZE);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
 
 	ret = i2s_trigger(dev_i2s_rxtx, I2S_DIR_BOTH, I2S_TRIGGER_START);
 	zassert_equal(ret, 0, "RX/TX START trigger failed\n");
 
 	for (; tx_idx < NUM_BLOCKS; ) {
 		ret = i2s_write(dev_i2s_rxtx, tx_block[tx_idx++], BLOCK_SIZE);
-		zassert_equal(ret, 0, NULL);
+		zassert_equal(ret, 0);
 
 		ret = i2s_read(dev_i2s_rxtx, &rx_block[rx_idx++], &rx_size);
-		zassert_equal(ret, 0, NULL);
+		zassert_equal(ret, 0);
-		zassert_equal(rx_size, BLOCK_SIZE, NULL);
+		zassert_equal(rx_size, BLOCK_SIZE);
 	}
 
 	/* All data written, drain TX queue and stop both streams. */
@@ -517,12 +517,12 @@ void test_i2s_dir_both_transfer_long(void)
 	zassert_equal(ret, 0, "RX/TX DRAIN trigger failed");
 
 	ret = i2s_read(dev_i2s_rxtx, &rx_block[rx_idx++], &rx_size);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
-	zassert_equal(rx_size, BLOCK_SIZE, NULL);
+	zassert_equal(rx_size, BLOCK_SIZE);
 
 	ret = i2s_read(dev_i2s_rxtx, &rx_block[rx_idx++], &rx_size);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
-	zassert_equal(rx_size, BLOCK_SIZE, NULL);
+	zassert_equal(rx_size, BLOCK_SIZE);
 
 	TC_PRINT("%d TX blocks sent\n", tx_idx);
 	TC_PRINT("%d RX blocks received\n", rx_idx);

tests/drivers/kscan/kscan_api/src/test_kscan.c

@@ -83,16 +83,16 @@ static int test_disable_enable_callback(void)
 void test_init_callback(void)
 {
 	/* Configure kscan matrix with an appropriate callback */
-	zassert_true(test_kb_callback() == TC_PASS, NULL);
+	zassert_true(test_kb_callback() == TC_PASS);
 	k_sleep(K_MSEC(1000));
 
 	/* Configure kscan with a null callback */
-	zassert_true(test_null_callback() == TC_PASS, NULL);
+	zassert_true(test_null_callback() == TC_PASS);
 }
 
 void test_control_callback(void)
 {
 	/* Disable/enable notifications to user */
-	zassert_true(test_disable_enable_callback() == TC_PASS, NULL);
+	zassert_true(test_disable_enable_callback() == TC_PASS);
 	k_sleep(K_MSEC(1000));
 }

tests/drivers/pinctrl/api/src/main.c

@@ -38,17 +38,17 @@ ZTEST(pinctrl_api, test_config_dev0)
 {
 	const struct pinctrl_state *scfg;
 
-	zassert_equal(pcfg0->state_cnt, 1, NULL);
+	zassert_equal(pcfg0->state_cnt, 1);
 #ifdef CONFIG_PINCTRL_STORE_REG
-	zassert_equal(pcfg0->reg, 0, NULL);
+	zassert_equal(pcfg0->reg, 0);
 #endif
 
 	scfg = &pcfg0->states[0];
-	zassert_equal(scfg->id, PINCTRL_STATE_DEFAULT, NULL);
+	zassert_equal(scfg->id, PINCTRL_STATE_DEFAULT);
-	zassert_equal(TEST_GET_PIN(scfg->pins[0]), 0, NULL);
+	zassert_equal(TEST_GET_PIN(scfg->pins[0]), 0);
-	zassert_equal(TEST_GET_PULL(scfg->pins[0]), TEST_PULL_UP, NULL);
+	zassert_equal(TEST_GET_PULL(scfg->pins[0]), TEST_PULL_UP);
-	zassert_equal(TEST_GET_PIN(scfg->pins[1]), 1, NULL);
+	zassert_equal(TEST_GET_PIN(scfg->pins[1]), 1);
-	zassert_equal(TEST_GET_PULL(scfg->pins[1]), TEST_PULL_DOWN, NULL);
+	zassert_equal(TEST_GET_PULL(scfg->pins[1]), TEST_PULL_DOWN);
 }
 
 /**
@@ -62,30 +62,30 @@ ZTEST(pinctrl_api, test_config_dev1)
 {
 	const struct pinctrl_state *scfg;
 
-	zassert_equal(pcfg1->state_cnt, 2, NULL);
+	zassert_equal(pcfg1->state_cnt, 2);
 #ifdef CONFIG_PINCTRL_STORE_REG
-	zassert_equal(pcfg1->reg, 1, NULL);
+	zassert_equal(pcfg1->reg, 1);
 #endif
 
 	scfg = &pcfg1->states[0];
-	zassert_equal(scfg->id, PINCTRL_STATE_DEFAULT, NULL);
+	zassert_equal(scfg->id, PINCTRL_STATE_DEFAULT);
-	zassert_equal(scfg->pin_cnt, 3, NULL);
+	zassert_equal(scfg->pin_cnt, 3);
-	zassert_equal(TEST_GET_PIN(scfg->pins[0]), 10, NULL);
+	zassert_equal(TEST_GET_PIN(scfg->pins[0]), 10);
-	zassert_equal(TEST_GET_PULL(scfg->pins[0]), TEST_PULL_DISABLE, NULL);
+	zassert_equal(TEST_GET_PULL(scfg->pins[0]), TEST_PULL_DISABLE);
-	zassert_equal(TEST_GET_PIN(scfg->pins[1]), 11, NULL);
+	zassert_equal(TEST_GET_PIN(scfg->pins[1]), 11);
-	zassert_equal(TEST_GET_PULL(scfg->pins[1]), TEST_PULL_DISABLE, NULL);
+	zassert_equal(TEST_GET_PULL(scfg->pins[1]), TEST_PULL_DISABLE);
-	zassert_equal(TEST_GET_PIN(scfg->pins[2]), 12, NULL);
+	zassert_equal(TEST_GET_PIN(scfg->pins[2]), 12);
-	zassert_equal(TEST_GET_PULL(scfg->pins[2]), TEST_PULL_DISABLE, NULL);
+	zassert_equal(TEST_GET_PULL(scfg->pins[2]), TEST_PULL_DISABLE);
 
 	scfg = &pcfg1->states[1];
-	zassert_equal(scfg->id, PINCTRL_STATE_MYSTATE, NULL);
+	zassert_equal(scfg->id, PINCTRL_STATE_MYSTATE);
-	zassert_equal(scfg->pin_cnt, 3, NULL);
+	zassert_equal(scfg->pin_cnt, 3);
-	zassert_equal(TEST_GET_PIN(scfg->pins[0]), 10, NULL);
+	zassert_equal(TEST_GET_PIN(scfg->pins[0]), 10);
-	zassert_equal(TEST_GET_PULL(scfg->pins[0]), TEST_PULL_DISABLE, NULL);
+	zassert_equal(TEST_GET_PULL(scfg->pins[0]), TEST_PULL_DISABLE);
-	zassert_equal(TEST_GET_PIN(scfg->pins[1]), 11, NULL);
+	zassert_equal(TEST_GET_PIN(scfg->pins[1]), 11);
-	zassert_equal(TEST_GET_PULL(scfg->pins[1]), TEST_PULL_UP, NULL);
+	zassert_equal(TEST_GET_PULL(scfg->pins[1]), TEST_PULL_UP);
-	zassert_equal(TEST_GET_PIN(scfg->pins[2]), 12, NULL);
+	zassert_equal(TEST_GET_PIN(scfg->pins[2]), 12);
-	zassert_equal(TEST_GET_PULL(scfg->pins[2]), TEST_PULL_DOWN, NULL);
+	zassert_equal(TEST_GET_PULL(scfg->pins[2]), TEST_PULL_DOWN);
 }
 
 /**
@@ -97,11 +97,11 @@ ZTEST(pinctrl_api, test_lookup_state)
 	const struct pinctrl_state *scfg;
 
 	ret = pinctrl_lookup_state(pcfg0, PINCTRL_STATE_DEFAULT, &scfg);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
 	zassert_equal_ptr(scfg, &pcfg0->states[0], NULL);
 
 	ret = pinctrl_lookup_state(pcfg0, PINCTRL_STATE_SLEEP, &scfg);
-	zassert_equal(ret, -ENOENT, NULL);
+	zassert_equal(ret, -ENOENT);
 }
 
 /**
@@ -109,14 +109,14 @@ ZTEST(pinctrl_api, test_lookup_state)
  */
 ZTEST(pinctrl_api, test_apply_state)
 {
-	zassert_ok(pinctrl_apply_state(pcfg0, PINCTRL_STATE_DEFAULT), NULL);
+	zassert_ok(pinctrl_apply_state(pcfg0, PINCTRL_STATE_DEFAULT));
-	zassert_equal(1, pinctrl_configure_pins_fake.call_count, NULL);
+	zassert_equal(1, pinctrl_configure_pins_fake.call_count);
-	zassert_equal(pcfg0->states[0].pins, pinctrl_configure_pins_fake.arg0_val, NULL);
+	zassert_equal(pcfg0->states[0].pins, pinctrl_configure_pins_fake.arg0_val);
-	zassert_equal(pcfg0->states[0].pin_cnt, pinctrl_configure_pins_fake.arg1_val, NULL);
+	zassert_equal(pcfg0->states[0].pin_cnt, pinctrl_configure_pins_fake.arg1_val);
 #ifdef CONFIG_PINCTRL_STORE_REG
-	zassert_equal(0, pinctrl_configure_pins_fake.arg2_val, NULL);
+	zassert_equal(0, pinctrl_configure_pins_fake.arg2_val);
 #else
-	zassert_equal(PINCTRL_REG_NONE, pinctrl_configure_pins_fake.arg2_val, NULL);
+	zassert_equal(PINCTRL_REG_NONE, pinctrl_configure_pins_fake.arg2_val);
 #endif
 }
 
@@ -146,17 +146,17 @@ ZTEST(pinctrl_api, test_update_states)
 	const struct pinctrl_state *scfg;
 
 	ret = pinctrl_update_states(pcfg0, test_device0_alt, ARRAY_SIZE(test_device0_alt));
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
 
 	scfg = &pcfg0->states[0];
-	zassert_equal(TEST_GET_PIN(scfg->pins[0]), 2, NULL);
+	zassert_equal(TEST_GET_PIN(scfg->pins[0]), 2);
-	zassert_equal(TEST_GET_PULL(scfg->pins[0]), TEST_PULL_DOWN, NULL);
+	zassert_equal(TEST_GET_PULL(scfg->pins[0]), TEST_PULL_DOWN);
-	zassert_equal(TEST_GET_PIN(scfg->pins[1]), 3, NULL);
+	zassert_equal(TEST_GET_PIN(scfg->pins[1]), 3);
-	zassert_equal(TEST_GET_PULL(scfg->pins[1]), TEST_PULL_UP, NULL);
+	zassert_equal(TEST_GET_PULL(scfg->pins[1]), TEST_PULL_UP);
 
 	ret = pinctrl_update_states(pcfg0, test_device0_alt_invalid,
 				    ARRAY_SIZE(test_device0_alt_invalid));
-	zassert_equal(ret, -EINVAL, NULL);
+	zassert_equal(ret, -EINVAL);
 }
 
 static void pinctrl_api_before(void *f)

tests/drivers/pinctrl/gd32/src/main_af.c

@@ -16,108 +16,108 @@ ZTEST(pinctrl_gd32, test_dt_extract)
 	const struct pinctrl_state *scfg;
 	pinctrl_soc_pin_t pin;
 
-	zassert_equal(pcfg->state_cnt, 1U, NULL);
+	zassert_equal(pcfg->state_cnt, 1U);
 
 	scfg = &pcfg->states[0];
 
-	zassert_equal(scfg->id, PINCTRL_STATE_DEFAULT, NULL);
+	zassert_equal(scfg->id, PINCTRL_STATE_DEFAULT);
-	zassert_equal(scfg->pin_cnt, 12U, NULL);
+	zassert_equal(scfg->pin_cnt, 12U);
 
 	pin = scfg->pins[0];
-	zassert_equal(GD32_PORT_GET(pin), 0, NULL);
+	zassert_equal(GD32_PORT_GET(pin), 0);
-	zassert_equal(GD32_PIN_GET(pin), 0, NULL);
+	zassert_equal(GD32_PIN_GET(pin), 0);
-	zassert_equal(GD32_AF_GET(pin), GD32_AF0, NULL);
+	zassert_equal(GD32_AF_GET(pin), GD32_AF0);
-	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE, NULL);
+	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE);
-	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP, NULL);
+	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP);
-	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ, NULL);
+	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ);
 
 	pin = scfg->pins[1];
-	zassert_equal(GD32_PORT_GET(pin), 1, NULL);
+	zassert_equal(GD32_PORT_GET(pin), 1);
-	zassert_equal(GD32_PIN_GET(pin), 1, NULL);
+	zassert_equal(GD32_PIN_GET(pin), 1);
-	zassert_equal(GD32_AF_GET(pin), GD32_AF1, NULL);
+	zassert_equal(GD32_AF_GET(pin), GD32_AF1);
-	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE, NULL);
+	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE);
-	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP, NULL);
+	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP);
-	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ, NULL);
+	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ);
 
 	pin = scfg->pins[2];
-	zassert_equal(GD32_PORT_GET(pin), 2, NULL);
+	zassert_equal(GD32_PORT_GET(pin), 2);
-	zassert_equal(GD32_PIN_GET(pin), 2, NULL);
+	zassert_equal(GD32_PIN_GET(pin), 2);
-	zassert_equal(GD32_AF_GET(pin), GD32_AF2, NULL);
+	zassert_equal(GD32_AF_GET(pin), GD32_AF2);
-	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE, NULL);
+	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE);
-	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP, NULL);
+	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP);
-	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ, NULL);
+	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ);
 
 	pin = scfg->pins[3];
-	zassert_equal(GD32_PORT_GET(pin), 0, NULL);
+	zassert_equal(GD32_PORT_GET(pin), 0);
-	zassert_equal(GD32_PIN_GET(pin), 3, NULL);
+	zassert_equal(GD32_PIN_GET(pin), 3);
-	zassert_equal(GD32_AF_GET(pin), GD32_AF3, NULL);
+	zassert_equal(GD32_AF_GET(pin), GD32_AF3);
-	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE, NULL);
+	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE);
-	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_OD, NULL);
+	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_OD);
-	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ, NULL);
+	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ);
 
 	pin = scfg->pins[4];
-	zassert_equal(GD32_PORT_GET(pin), 1, NULL);
+	zassert_equal(GD32_PORT_GET(pin), 1);
-	zassert_equal(GD32_PIN_GET(pin), 4, NULL);
+	zassert_equal(GD32_PIN_GET(pin), 4);
-	zassert_equal(GD32_AF_GET(pin), GD32_AF4, NULL);
+	zassert_equal(GD32_AF_GET(pin), GD32_AF4);
-	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE, NULL);
+	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE);
-	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP, NULL);
+	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP);
-	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ, NULL);
+	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ);
 
 	pin = scfg->pins[5];
-	zassert_equal(GD32_PORT_GET(pin), 2, NULL);
+	zassert_equal(GD32_PORT_GET(pin), 2);
-	zassert_equal(GD32_PIN_GET(pin), 5, NULL);
+	zassert_equal(GD32_PIN_GET(pin), 5);
-	zassert_equal(GD32_AF_GET(pin), GD32_AF5, NULL);
+	zassert_equal(GD32_AF_GET(pin), GD32_AF5);
-	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_PULLUP, NULL);
+	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_PULLUP);
-	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP, NULL);
+	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP);
-	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ, NULL);
+	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ);
 
 	pin = scfg->pins[6];
-	zassert_equal(GD32_PORT_GET(pin), 0, NULL);
+	zassert_equal(GD32_PORT_GET(pin), 0);
-	zassert_equal(GD32_PIN_GET(pin), 6, NULL);
+	zassert_equal(GD32_PIN_GET(pin), 6);
-	zassert_equal(GD32_AF_GET(pin), GD32_AF6, NULL);
+	zassert_equal(GD32_AF_GET(pin), GD32_AF6);
-	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_PULLDOWN, NULL);
+	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_PULLDOWN);
-	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP, NULL);
+	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP);
-	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ, NULL);
+	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ);
 
 	pin = scfg->pins[7];
-	zassert_equal(GD32_PORT_GET(pin), 1, NULL);
+	zassert_equal(GD32_PORT_GET(pin), 1);
-	zassert_equal(GD32_PIN_GET(pin), 7, NULL);
+	zassert_equal(GD32_PIN_GET(pin), 7);
-	zassert_equal(GD32_AF_GET(pin), GD32_AF7, NULL);
+	zassert_equal(GD32_AF_GET(pin), GD32_AF7);
-	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE, NULL);
+	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE);
-	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP, NULL);
+	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP);
-	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ, NULL);
+	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ);
 
 	pin = scfg->pins[8];
-	zassert_equal(GD32_PORT_GET(pin), 2, NULL);
+	zassert_equal(GD32_PORT_GET(pin), 2);
-	zassert_equal(GD32_PIN_GET(pin), 8, NULL);
+	zassert_equal(GD32_PIN_GET(pin), 8);
-	zassert_equal(GD32_AF_GET(pin), GD32_AF8, NULL);
+	zassert_equal(GD32_AF_GET(pin), GD32_AF8);
-	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE, NULL);
+	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE);
-	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP, NULL);
+	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP);
-	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_25MHZ, NULL);
+	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_25MHZ);
 
 	pin = scfg->pins[9];
-	zassert_equal(GD32_PORT_GET(pin), 0, NULL);
+	zassert_equal(GD32_PORT_GET(pin), 0);
-	zassert_equal(GD32_PIN_GET(pin), 9, NULL);
+	zassert_equal(GD32_PIN_GET(pin), 9);
-	zassert_equal(GD32_AF_GET(pin), GD32_AF9, NULL);
+	zassert_equal(GD32_AF_GET(pin), GD32_AF9);
-	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE, NULL);
+	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE);
-	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP, NULL);
+	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP);
-	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_50MHZ, NULL);
+	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_50MHZ);
 
 	pin = scfg->pins[10];
-	zassert_equal(GD32_PORT_GET(pin), 1, NULL);
+	zassert_equal(GD32_PORT_GET(pin), 1);
-	zassert_equal(GD32_PIN_GET(pin), 10, NULL);
+	zassert_equal(GD32_PIN_GET(pin), 10);
-	zassert_equal(GD32_AF_GET(pin), GD32_AF10, NULL);
+	zassert_equal(GD32_AF_GET(pin), GD32_AF10);
-	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE, NULL);
+	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE);
-	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP, NULL);
+	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP);
-	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_MAX, NULL);
+	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_MAX);
 
 	pin = scfg->pins[11];
-	zassert_equal(GD32_PORT_GET(pin), 2, NULL);
+	zassert_equal(GD32_PORT_GET(pin), 2);
-	zassert_equal(GD32_PIN_GET(pin), 11, NULL);
+	zassert_equal(GD32_PIN_GET(pin), 11);
-	zassert_equal(GD32_AF_GET(pin), GD32_ANALOG, NULL);
+	zassert_equal(GD32_AF_GET(pin), GD32_ANALOG);
-	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE, NULL);
+	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE);
-	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP, NULL);
+	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP);
-	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ, NULL);
+	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ);
 }
 
 ZTEST_SUITE(pinctrl_gd32, NULL, NULL, NULL, NULL, NULL);

tests/drivers/pinctrl/gd32/src/main_afio.c

@@ -16,122 +16,122 @@ ZTEST(pinctrl_gd32, test_dt_extract)
 	const struct pinctrl_state *scfg;
 	pinctrl_soc_pin_t pin;
 
-	zassert_equal(pcfg->state_cnt, 1U, NULL);
+	zassert_equal(pcfg->state_cnt, 1U);
 
 	scfg = &pcfg->states[0];
 
-	zassert_equal(scfg->id, PINCTRL_STATE_DEFAULT, NULL);
+	zassert_equal(scfg->id, PINCTRL_STATE_DEFAULT);
-	zassert_equal(scfg->pin_cnt, 14U, NULL);
+	zassert_equal(scfg->pin_cnt, 14U);
 
 	pin = scfg->pins[0];
-	zassert_equal(GD32_PORT_GET(pin), 0, NULL);
+	zassert_equal(GD32_PORT_GET(pin), 0);
-	zassert_equal(GD32_PIN_GET(pin), 0, NULL);
+	zassert_equal(GD32_PIN_GET(pin), 0);
-	zassert_equal(GD32_MODE_GET(pin), GD32_MODE_ANALOG, NULL);
+	zassert_equal(GD32_MODE_GET(pin), GD32_MODE_ANALOG);
-	zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP, NULL);
+	zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP);
 
 	pin = scfg->pins[1];
-	zassert_equal(GD32_PORT_GET(pin), 1, NULL);
+	zassert_equal(GD32_PORT_GET(pin), 1);
-	zassert_equal(GD32_PIN_GET(pin), 1, NULL);
+	zassert_equal(GD32_PIN_GET(pin), 1);
-	zassert_equal(GD32_MODE_GET(pin), GD32_MODE_ALTERNATE, NULL);
+	zassert_equal(GD32_MODE_GET(pin), GD32_MODE_ALTERNATE);
-	zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP, NULL);
+	zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP);
-	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ, NULL);
+	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ);
 
 	pin = scfg->pins[2];
-	zassert_equal(GD32_PORT_GET(pin), 2, NULL);
+	zassert_equal(GD32_PORT_GET(pin), 2);
-	zassert_equal(GD32_PIN_GET(pin), 2, NULL);
+	zassert_equal(GD32_PIN_GET(pin), 2);
-	zassert_equal(GD32_MODE_GET(pin), GD32_MODE_GPIO_IN, NULL);
+	zassert_equal(GD32_MODE_GET(pin), GD32_MODE_GPIO_IN);
-	zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP, NULL);
+	zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP);
-	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE, NULL);
+	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE);
-	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP, NULL);
+	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP);
 
 	pin = scfg->pins[3];
-	zassert_equal(GD32_PORT_GET(pin), 0, NULL);
+	zassert_equal(GD32_PORT_GET(pin), 0);
-	zassert_equal(GD32_PIN_GET(pin), 3, NULL);
+	zassert_equal(GD32_PIN_GET(pin), 3);
-	zassert_equal(GD32_MODE_GET(pin), GD32_MODE_GPIO_IN, NULL);
+	zassert_equal(GD32_MODE_GET(pin), GD32_MODE_GPIO_IN);
-	zassert_equal(GD32_REMAP_REG_GET(GD32_REMAP_GET(pin)), 0, NULL);
+	zassert_equal(GD32_REMAP_REG_GET(GD32_REMAP_GET(pin)), 0);
-	zassert_equal(GD32_REMAP_POS_GET(GD32_REMAP_GET(pin)), 0, NULL);
+	zassert_equal(GD32_REMAP_POS_GET(GD32_REMAP_GET(pin)), 0);
-	zassert_equal(GD32_REMAP_MSK_GET(GD32_REMAP_GET(pin)), 0x1, NULL);
+	zassert_equal(GD32_REMAP_MSK_GET(GD32_REMAP_GET(pin)), 0x1);
-	zassert_equal(GD32_REMAP_VAL_GET(GD32_REMAP_GET(pin)), 1, NULL);
+	zassert_equal(GD32_REMAP_VAL_GET(GD32_REMAP_GET(pin)), 1);
-	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE, NULL);
+	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE);
-	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP, NULL);
+	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP);
 
 	pin = scfg->pins[4];
-	zassert_equal(GD32_PORT_GET(pin), 1, NULL);
+	zassert_equal(GD32_PORT_GET(pin), 1);
-	zassert_equal(GD32_PIN_GET(pin), 4, NULL);
+	zassert_equal(GD32_PIN_GET(pin), 4);
-	zassert_equal(GD32_MODE_GET(pin), GD32_MODE_ALTERNATE, NULL);
+	zassert_equal(GD32_MODE_GET(pin), GD32_MODE_ALTERNATE);
-	zassert_equal(GD32_REMAP_REG_GET(GD32_REMAP_GET(pin)), 0, NULL);
+	zassert_equal(GD32_REMAP_REG_GET(GD32_REMAP_GET(pin)), 0);
-	zassert_equal(GD32_REMAP_POS_GET(GD32_REMAP_GET(pin)), 0, NULL);
+	zassert_equal(GD32_REMAP_POS_GET(GD32_REMAP_GET(pin)), 0);
-	zassert_equal(GD32_REMAP_MSK_GET(GD32_REMAP_GET(pin)), 0x1, NULL);
+	zassert_equal(GD32_REMAP_MSK_GET(GD32_REMAP_GET(pin)), 0x1);
-	zassert_equal(GD32_REMAP_VAL_GET(GD32_REMAP_GET(pin)), 1, NULL);
+	zassert_equal(GD32_REMAP_VAL_GET(GD32_REMAP_GET(pin)), 1);
-	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ, NULL);
+	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ);
 
 	pin = scfg->pins[5];
-	zassert_equal(GD32_PORT_GET(pin), 2, NULL);
+	zassert_equal(GD32_PORT_GET(pin), 2);
-	zassert_equal(GD32_PIN_GET(pin), 5, NULL);
+	zassert_equal(GD32_PIN_GET(pin), 5);
-	zassert_equal(GD32_MODE_GET(pin), GD32_MODE_GPIO_IN, NULL);
+	zassert_equal(GD32_MODE_GET(pin), GD32_MODE_GPIO_IN);
-	zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP, NULL);
+	zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP);
-	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE, NULL);
+	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE);
-	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP, NULL);
+	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP);
 
 	pin = scfg->pins[6];
-	zassert_equal(GD32_PORT_GET(pin), 0, NULL);
+	zassert_equal(GD32_PORT_GET(pin), 0);
-	zassert_equal(GD32_PIN_GET(pin), 6, NULL);
+	zassert_equal(GD32_PIN_GET(pin), 6);
-	zassert_equal(GD32_MODE_GET(pin), GD32_MODE_GPIO_IN, NULL);
+	zassert_equal(GD32_MODE_GET(pin), GD32_MODE_GPIO_IN);
-	zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP, NULL);
+	zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP);
-	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE, NULL);
+	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE);
-	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_OD, NULL);
+	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_OD);
 
 	pin = scfg->pins[7];
-	zassert_equal(GD32_PORT_GET(pin), 1, NULL);
+	zassert_equal(GD32_PORT_GET(pin), 1);
-	zassert_equal(GD32_PIN_GET(pin), 7, NULL);
+	zassert_equal(GD32_PIN_GET(pin), 7);
-	zassert_equal(GD32_MODE_GET(pin), GD32_MODE_GPIO_IN, NULL);
+	zassert_equal(GD32_MODE_GET(pin), GD32_MODE_GPIO_IN);
-	zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP, NULL);
+	zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP);
-	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE, NULL);
+	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE);
-	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP, NULL);
+	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP);
 
 	pin = scfg->pins[8];
-	zassert_equal(GD32_PORT_GET(pin), 2, NULL);
+	zassert_equal(GD32_PORT_GET(pin), 2);
-	zassert_equal(GD32_PIN_GET(pin), 8, NULL);
+	zassert_equal(GD32_PIN_GET(pin), 8);
-	zassert_equal(GD32_MODE_GET(pin), GD32_MODE_GPIO_IN, NULL);
+	zassert_equal(GD32_MODE_GET(pin), GD32_MODE_GPIO_IN);
-	zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP, NULL);
+	zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP);
-	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_PULLUP, NULL);
+	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_PULLUP);
-	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP, NULL);
+	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP);
 
 	pin = scfg->pins[9];
-	zassert_equal(GD32_PORT_GET(pin), 0, NULL);
+	zassert_equal(GD32_PORT_GET(pin), 0);
-	zassert_equal(GD32_PIN_GET(pin), 9, NULL);
+	zassert_equal(GD32_PIN_GET(pin), 9);
-	zassert_equal(GD32_MODE_GET(pin), GD32_MODE_GPIO_IN, NULL);
+	zassert_equal(GD32_MODE_GET(pin), GD32_MODE_GPIO_IN);
-	zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP, NULL);
+	zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP);
-	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_PULLDOWN, NULL);
+	zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_PULLDOWN);
-	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP, NULL);
+	zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP);
 
 	pin = scfg->pins[10];
-	zassert_equal(GD32_PORT_GET(pin), 1, NULL);
+	zassert_equal(GD32_PORT_GET(pin), 1);
-	zassert_equal(GD32_PIN_GET(pin), 10, NULL);
+	zassert_equal(GD32_PIN_GET(pin), 10);
-	zassert_equal(GD32_MODE_GET(pin), GD32_MODE_ALTERNATE, NULL);
+	zassert_equal(GD32_MODE_GET(pin), GD32_MODE_ALTERNATE);
-	zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP, NULL);
+	zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP);
-	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ, NULL);
+	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ);
 
 	pin = scfg->pins[11];
-	zassert_equal(GD32_PORT_GET(pin), 2, NULL);
+	zassert_equal(GD32_PORT_GET(pin), 2);
-	zassert_equal(GD32_PIN_GET(pin), 11, NULL);
+	zassert_equal(GD32_PIN_GET(pin), 11);
-	zassert_equal(GD32_MODE_GET(pin), GD32_MODE_ALTERNATE, NULL);
+	zassert_equal(GD32_MODE_GET(pin), GD32_MODE_ALTERNATE);
-	zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP, NULL);
+	zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP);
-	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_10MHZ, NULL);
+	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_10MHZ);
 
 	pin = scfg->pins[12];
-	zassert_equal(GD32_PORT_GET(pin), 0, NULL);
+	zassert_equal(GD32_PORT_GET(pin), 0);
-	zassert_equal(GD32_PIN_GET(pin), 12, NULL);
+	zassert_equal(GD32_PIN_GET(pin), 12);
-	zassert_equal(GD32_MODE_GET(pin), GD32_MODE_ALTERNATE, NULL);
+	zassert_equal(GD32_MODE_GET(pin), GD32_MODE_ALTERNATE);
-	zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP, NULL);
+	zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP);
-	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_50MHZ, NULL);
+	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_50MHZ);
 
 	pin = scfg->pins[13];
-	zassert_equal(GD32_PORT_GET(pin), 1, NULL);
+	zassert_equal(GD32_PORT_GET(pin), 1);
-	zassert_equal(GD32_PIN_GET(pin), 13, NULL);
+	zassert_equal(GD32_PIN_GET(pin), 13);
-	zassert_equal(GD32_MODE_GET(pin), GD32_MODE_ALTERNATE, NULL);
+	zassert_equal(GD32_MODE_GET(pin), GD32_MODE_ALTERNATE);
-	zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP, NULL);
+	zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP);
-	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_MAX, NULL);
+	zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_MAX);
 }
 
 ZTEST_SUITE(pinctrl_gd32, NULL, NULL, NULL, NULL, NULL);

tests/drivers/pinctrl/nrf/src/main.c

@@ -16,52 +16,52 @@ ZTEST(pinctrl_nrf, test_dt_extract)
 {
 	const struct pinctrl_state *scfg;
 
-	zassert_equal(pcfg->reg, 0x0U, NULL);
+	zassert_equal(pcfg->reg, 0x0U);
-	zassert_equal(pcfg->state_cnt, 1U, NULL);
+	zassert_equal(pcfg->state_cnt, 1U);
 
 	scfg = &pcfg->states[0];
 
-	zassert_equal(scfg->id, PINCTRL_STATE_DEFAULT, NULL);
+	zassert_equal(scfg->id, PINCTRL_STATE_DEFAULT);
-	zassert_equal(scfg->pin_cnt, 7U, NULL);
+	zassert_equal(scfg->pin_cnt, 7U);
 
-	zassert_equal(NRF_GET_FUN(scfg->pins[0]), NRF_FUN_UART_TX, NULL);
+	zassert_equal(NRF_GET_FUN(scfg->pins[0]), NRF_FUN_UART_TX);
-	zassert_equal(NRF_GET_LP(scfg->pins[0]), NRF_LP_DISABLE, NULL);
+	zassert_equal(NRF_GET_LP(scfg->pins[0]), NRF_LP_DISABLE);
-	zassert_equal(NRF_GET_DRIVE(scfg->pins[0]), NRF_DRIVE_S0S1, NULL);
+	zassert_equal(NRF_GET_DRIVE(scfg->pins[0]), NRF_DRIVE_S0S1);
-	zassert_equal(NRF_GET_PULL(scfg->pins[0]), NRF_PULL_NONE, NULL);
+	zassert_equal(NRF_GET_PULL(scfg->pins[0]), NRF_PULL_NONE);
-	zassert_equal(NRF_GET_PIN(scfg->pins[0]), 1U, NULL);
+	zassert_equal(NRF_GET_PIN(scfg->pins[0]), 1U);
 
-	zassert_equal(NRF_GET_FUN(scfg->pins[1]), NRF_FUN_UART_RTS, NULL);
+	zassert_equal(NRF_GET_FUN(scfg->pins[1]), NRF_FUN_UART_RTS);
-	zassert_equal(NRF_GET_LP(scfg->pins[1]), NRF_LP_DISABLE, NULL);
+	zassert_equal(NRF_GET_LP(scfg->pins[1]), NRF_LP_DISABLE);
-	zassert_equal(NRF_GET_DRIVE(scfg->pins[1]), NRF_DRIVE_S0S1, NULL);
+	zassert_equal(NRF_GET_DRIVE(scfg->pins[1]), NRF_DRIVE_S0S1);
-	zassert_equal(NRF_GET_PULL(scfg->pins[1]), NRF_PULL_NONE, NULL);
+	zassert_equal(NRF_GET_PULL(scfg->pins[1]), NRF_PULL_NONE);
-	zassert_equal(NRF_GET_PIN(scfg->pins[1]), 2U, NULL);
+	zassert_equal(NRF_GET_PIN(scfg->pins[1]), 2U);
 
-	zassert_equal(NRF_GET_FUN(scfg->pins[2]), NRF_FUN_UART_RX, NULL);
+	zassert_equal(NRF_GET_FUN(scfg->pins[2]), NRF_FUN_UART_RX);
-	zassert_equal(NRF_GET_PIN(scfg->pins[2]), NRF_PIN_DISCONNECTED, NULL);
+	zassert_equal(NRF_GET_PIN(scfg->pins[2]), NRF_PIN_DISCONNECTED);
 
-	zassert_equal(NRF_GET_FUN(scfg->pins[3]), NRF_FUN_UART_RX, NULL);
+	zassert_equal(NRF_GET_FUN(scfg->pins[3]), NRF_FUN_UART_RX);
-	zassert_equal(NRF_GET_LP(scfg->pins[3]), NRF_LP_DISABLE, NULL);
+	zassert_equal(NRF_GET_LP(scfg->pins[3]), NRF_LP_DISABLE);
-	zassert_equal(NRF_GET_DRIVE(scfg->pins[3]), NRF_DRIVE_H0S1, NULL);
+	zassert_equal(NRF_GET_DRIVE(scfg->pins[3]), NRF_DRIVE_H0S1);
-	zassert_equal(NRF_GET_PULL(scfg->pins[3]), NRF_PULL_NONE, NULL);
+	zassert_equal(NRF_GET_PULL(scfg->pins[3]), NRF_PULL_NONE);
-	zassert_equal(NRF_GET_PIN(scfg->pins[3]), 3U, NULL);
+	zassert_equal(NRF_GET_PIN(scfg->pins[3]), 3U);
 
-	zassert_equal(NRF_GET_FUN(scfg->pins[4]), NRF_FUN_UART_RX, NULL);
+	zassert_equal(NRF_GET_FUN(scfg->pins[4]), NRF_FUN_UART_RX);
-	zassert_equal(NRF_GET_LP(scfg->pins[4]), NRF_LP_DISABLE, NULL);
+	zassert_equal(NRF_GET_LP(scfg->pins[4]), NRF_LP_DISABLE);
-	zassert_equal(NRF_GET_DRIVE(scfg->pins[4]), NRF_DRIVE_S0S1, NULL);
+	zassert_equal(NRF_GET_DRIVE(scfg->pins[4]), NRF_DRIVE_S0S1);
-	zassert_equal(NRF_GET_PULL(scfg->pins[4]), NRF_PULL_UP, NULL);
+	zassert_equal(NRF_GET_PULL(scfg->pins[4]), NRF_PULL_UP);
-	zassert_equal(NRF_GET_PIN(scfg->pins[4]), 4U, NULL);
+	zassert_equal(NRF_GET_PIN(scfg->pins[4]), 4U);
 
-	zassert_equal(NRF_GET_FUN(scfg->pins[5]), NRF_FUN_UART_RX, NULL);
+	zassert_equal(NRF_GET_FUN(scfg->pins[5]), NRF_FUN_UART_RX);
-	zassert_equal(NRF_GET_LP(scfg->pins[5]), NRF_LP_DISABLE, NULL);
+	zassert_equal(NRF_GET_LP(scfg->pins[5]), NRF_LP_DISABLE);
-	zassert_equal(NRF_GET_DRIVE(scfg->pins[5]), NRF_DRIVE_S0S1, NULL);
+	zassert_equal(NRF_GET_DRIVE(scfg->pins[5]), NRF_DRIVE_S0S1);
-	zassert_equal(NRF_GET_PULL(scfg->pins[5]), NRF_PULL_DOWN, NULL);
+	zassert_equal(NRF_GET_PULL(scfg->pins[5]), NRF_PULL_DOWN);
-	zassert_equal(NRF_GET_PIN(scfg->pins[5]), 5U, NULL);
+	zassert_equal(NRF_GET_PIN(scfg->pins[5]), 5U);
 
-	zassert_equal(NRF_GET_FUN(scfg->pins[6]), NRF_FUN_UART_CTS, NULL);
+	zassert_equal(NRF_GET_FUN(scfg->pins[6]), NRF_FUN_UART_CTS);
-	zassert_equal(NRF_GET_LP(scfg->pins[6]), NRF_LP_ENABLE, NULL);
+	zassert_equal(NRF_GET_LP(scfg->pins[6]), NRF_LP_ENABLE);
-	zassert_equal(NRF_GET_DRIVE(scfg->pins[6]), NRF_DRIVE_S0S1, NULL);
+	zassert_equal(NRF_GET_DRIVE(scfg->pins[6]), NRF_DRIVE_S0S1);
-	zassert_equal(NRF_GET_PULL(scfg->pins[6]), NRF_PULL_NONE, NULL);
+	zassert_equal(NRF_GET_PULL(scfg->pins[6]), NRF_PULL_NONE);
-	zassert_equal(NRF_GET_PIN(scfg->pins[6]), 38U, NULL);
+	zassert_equal(NRF_GET_PIN(scfg->pins[6]), 38U);
 }
 
 ZTEST_SUITE(pinctrl_nrf, NULL, NULL, NULL, NULL, NULL);

tests/drivers/sensor/generic/src/dummy_sensor.c

@@ -80,8 +80,8 @@ static int dummy_sensor_init(const struct device *dev)
 	const struct device *i2c = device_get_binding(config->i2c_name);
 
 	/* Bus and address should be configured. */
-	zassert_equal(strcmp(config->i2c_name, "dummy I2C"), 0, NULL);
+	zassert_equal(strcmp(config->i2c_name, "dummy I2C"), 0);
-	zassert_equal(config->i2c_address, 123, NULL);
+	zassert_equal(config->i2c_address, 123);
 
 	if (i2c != NULL) {
 		LOG_ERR("Should be Null for %s device!", config->i2c_name);

tests/drivers/syscon/src/main.c

@@ -19,7 +19,7 @@ ZTEST(syscon, test_size)
 	size_t size;
 
 	zassert_not_null(dev, NULL);
-	zassert_ok(syscon_get_size(dev, &size), NULL);
+	zassert_ok(syscon_get_size(dev, &size));
 	zassert_equal(size, expected_size, "size(0x%x) != expected_size(0x%x)", size,
 		      expected_size);
 }
@@ -29,8 +29,8 @@ ZTEST(syscon, test_out_of_bounds)
 	const struct device *const dev = DEVICE_DT_GET(DT_NODELABEL(syscon));
 	uint32_t val;
 
-	zassert_equal(syscon_read_reg(dev, DT_REG_SIZE(DT_NODELABEL(syscon)), &val), -EINVAL, NULL);
+	zassert_equal(syscon_read_reg(dev, DT_REG_SIZE(DT_NODELABEL(syscon)), &val), -EINVAL);
-	zassert_equal(syscon_write_reg(dev, DT_REG_SIZE(DT_NODELABEL(syscon)), val), -EINVAL, NULL);
+	zassert_equal(syscon_write_reg(dev, DT_REG_SIZE(DT_NODELABEL(syscon)), val), -EINVAL);
 }
 
 ZTEST(syscon, test_read)
@@ -39,11 +39,11 @@ ZTEST(syscon, test_read)
 	uintptr_t base_addr;
 	uint32_t val;
 
-	zassert_ok(syscon_get_base(dev, &base_addr), NULL);
+	zassert_ok(syscon_get_base(dev, &base_addr));
 	for (size_t i = 0; i < ARRAY_SIZE(var_in_res0); ++i) {
 		((uint8_t *)base_addr)[i] = i;
-		zassert_ok(syscon_read_reg(dev, i, &val), NULL);
+		zassert_ok(syscon_read_reg(dev, i, &val));
-		zassert_equal(i, val, NULL);
+		zassert_equal(i, val);
 	}
 }
 
@@ -52,10 +52,10 @@ ZTEST(syscon, test_write)
 	const struct device *const dev = DEVICE_DT_GET(DT_NODELABEL(syscon));
 	uintptr_t base_addr;
 
-	zassert_ok(syscon_get_base(dev, &base_addr), NULL);
+	zassert_ok(syscon_get_base(dev, &base_addr));
 	for (uint32_t i = 0; i < ARRAY_SIZE(var_in_res0); ++i) {
-		zassert_ok(syscon_write_reg(dev, i, i), NULL);
+		zassert_ok(syscon_write_reg(dev, i, i));
-		zassert_equal(((uint8_t *)base_addr)[i], i, NULL);
+		zassert_equal(((uint8_t *)base_addr)[i], i);
 	}
 }
 

tests/drivers/uart/uart_basic_api/src/test_uart_config.c

@@ -99,7 +99,7 @@ ZTEST(uart_basic_api, test_uart_configure)
 {
 	int ret = test_configure();
 
-	zassert_true((ret == TC_PASS) || (ret == TC_SKIP), NULL);
+	zassert_true((ret == TC_PASS) || (ret == TC_SKIP));
 }
 
 #if CONFIG_SHELL
@@ -110,5 +110,5 @@ ZTEST(uart_basic_api, test_uart_config_get)
 {
 	int ret = test_config_get();
 
-	zassert_true((ret == TC_PASS) || (ret == TC_SKIP), NULL);
+	zassert_true((ret == TC_PASS) || (ret == TC_SKIP));
 }

tests/drivers/uart/uart_basic_api/src/test_uart_fifo.c

@@ -164,7 +164,7 @@ ZTEST(uart_basic_api, test_uart_fifo_fill)
 #ifndef CONFIG_UART_INTERRUPT_DRIVEN
 	ztest_test_skip();
 #endif
-	zassert_true(test_fifo_fill() == TC_PASS, NULL);
+	zassert_true(test_fifo_fill() == TC_PASS);
 }
 
 #if CONFIG_SHELL
@@ -176,5 +176,5 @@ ZTEST(uart_basic_api, test_uart_fifo_read)
 #ifndef CONFIG_UART_INTERRUPT_DRIVEN
 	ztest_test_skip();
 #endif
-	zassert_true(test_fifo_read() == TC_PASS, NULL);
+	zassert_true(test_fifo_read() == TC_PASS);
 }

tests/drivers/uart/uart_basic_api/src/test_uart_pending.c

@@ -150,5 +150,5 @@ ZTEST(uart_basic_api_pending, test_uart_pending)
 #ifndef CONFIG_UART_INTERRUPT_DRIVEN
 	ztest_test_skip();
 #endif
-	zassert_true(test_pending() == TC_PASS, NULL);
+	zassert_true(test_pending() == TC_PASS);
 }

tests/drivers/uart/uart_basic_api/src/test_uart_poll.c

@@ -61,7 +61,7 @@ void test_uart_poll_out(void)
 ZTEST(uart_basic_api, test_uart_poll_out)
 #endif
 {
-	zassert_true(test_poll_out() == TC_PASS, NULL);
+	zassert_true(test_poll_out() == TC_PASS);
 }
 
 #if CONFIG_SHELL
@@ -70,5 +70,5 @@ void test_uart_poll_in(void)
 ZTEST(uart_basic_api, test_uart_poll_in)
 #endif
 {
-	zassert_true(test_poll_in() == TC_PASS, NULL);
+	zassert_true(test_poll_in() == TC_PASS);
 }

tests/drivers/uart/uart_mix_fifo_poll/src/main.c

@@ -105,7 +105,7 @@ static void counter_top_handler(const struct device *dev, void *user_data)
 
 		err = uart_rx_enable(uart_dev, async_rx_buf,
 				     sizeof(async_rx_buf), 1 * USEC_PER_MSEC);
-		zassert_true(err >= 0, NULL);
+		zassert_true(err >= 0);
 		async_rx_enabled = true;
 	} else if (int_driven) {
 		if (enable) {
@@ -148,15 +148,15 @@ static void init_test(void)
 	/* Setup counter which will periodically enable/disable UART RX,
 	 * Disabling RX should lead to flow control being activated.
 	 */
-	zassert_true(device_is_ready(counter_dev), NULL);
+	zassert_true(device_is_ready(counter_dev));
 
 	top_cfg.ticks = counter_us_to_ticks(counter_dev, 1000);
 
 	err = counter_set_top_value(counter_dev, &top_cfg);
-	zassert_true(err >= 0, NULL);
+	zassert_true(err >= 0);
 
 	err = counter_start(counter_dev);
-	zassert_true(err >= 0, NULL);
+	zassert_true(err >= 0);
 }
 
 static void rx_isr(void)
@@ -256,7 +256,7 @@ static void int_async_thread_func(void *p_data, void *base, void *range)
 			int err;
 
 			err = k_sem_take(&async_tx_sem, K_MSEC(1000));
-			zassert_true(err >= 0, NULL);
+			zassert_true(err >= 0);
 
 			int idx = data->cnt & 0xF;
 			size_t len = (idx < BUF_SIZE / 2) ? 5 : 1; /* Try various lengths */
@@ -345,12 +345,12 @@ ZTEST(uart_mix_fifo_poll, test_mixed_uart_access)
 
 	for (int i = 0; i < num_of_contexts; i++) {
 		err = k_sem_take(&test_data[i].sem, K_MSEC(10000));
-		zassert_equal(err, 0, NULL);
+		zassert_equal(err, 0);
 	}
 
 	if (async || int_driven) {
 		err = k_sem_take(&int_async_data.sem, K_MSEC(10000));
-		zassert_equal(err, 0, NULL);
+		zassert_equal(err, 0);
 	}
 
 	k_msleep(10);

tests/drivers/uart/uart_pm/src/main.c

@@ -34,7 +34,7 @@ static void polling_verify(const struct device *dev, bool is_async, bool active)
 	}
 
 	err = uart_poll_in(dev, &c);
-	zassert_equal(err, -1, NULL);
+	zassert_equal(err, -1);
 
 	for (int i = 0; i < ARRAY_SIZE(outs); i++) {
 		uart_poll_out(dev, outs[i]);
@@ -43,11 +43,11 @@ static void polling_verify(const struct device *dev, bool is_async, bool active)
 		if (active) {
 			err = uart_poll_in(dev, &c);
 			zassert_equal(err, 0, "Unexpected err: %d", err);
-			zassert_equal(c, outs[i], NULL);
+			zassert_equal(c, outs[i]);
 		}
 
 		err = uart_poll_in(dev, &c);
-		zassert_equal(err, -1, NULL);
+		zassert_equal(err, -1);
 	}
 }
 
@@ -102,7 +102,7 @@ static bool async_verify(const struct device *dev, bool active)
 		zassert_equal(err, 0, "Unexpected err: %d", err);
 	}
 
-	zassert_true(tx_done, NULL);
+	zassert_true(tx_done);
 
 	return true;
 }
@@ -118,7 +118,7 @@ static void communication_verify(const struct device *dev, bool active)
 	enum pm_device_state power_state; \
 	int err = pm_device_state_get(dev, &power_state); \
 	zassert_equal(err, 0, "Unexpected err: %d", err); \
-	zassert_equal(power_state, exp_state, NULL); \
+	zassert_equal(power_state, exp_state); \
 } while (0)
 
 static void action_run(const struct device *dev, enum pm_device_action action,

tests/drivers/watchdog/wdt_basic_api/src/test_wdt.c

@@ -355,24 +355,24 @@ static int test_wdt_bad_window_max(void)
 ZTEST(wdt_basic_test_suite, test_wdt)
 {
 	if ((m_testcase_index != 1U) && (m_testcase_index != 2U)) {
-		zassert_true(test_wdt_no_callback() == TC_PASS, NULL);
+		zassert_true(test_wdt_no_callback() == TC_PASS);
 	}
 	if (m_testcase_index == 1U) {
 #if TEST_WDT_CALLBACK_1
-		zassert_true(test_wdt_callback_1() == TC_PASS, NULL);
+		zassert_true(test_wdt_callback_1() == TC_PASS);
 #else
 		m_testcase_index++;
 #endif
 	}
 	if (m_testcase_index == 2U) {
 #if TEST_WDT_CALLBACK_2
-		zassert_true(test_wdt_callback_2() == TC_PASS, NULL);
+		zassert_true(test_wdt_callback_2() == TC_PASS);
 #else
 		m_testcase_index++;
 #endif
 	}
 	if (m_testcase_index == 3U) {
-		zassert_true(test_wdt_bad_window_max() == TC_PASS, NULL);
+		zassert_true(test_wdt_bad_window_max() == TC_PASS);
 		m_testcase_index++;
 	}
 	if (m_testcase_index > 3) {

tests/kernel/common/src/bitarray.c

@@ -521,37 +521,37 @@ ZTEST(bitarray, test_bitarray_region_set_clear)
 	ba.bundles[0] = 0xFF0F0F0F;
 	ba.bundles[1] = 0x0F0F0FFF;
 
-	zassert_true(sys_bitarray_is_region_set(&ba,  4,  0), NULL);
+	zassert_true(sys_bitarray_is_region_set(&ba,  4,  0));
-	zassert_true(sys_bitarray_is_region_set(&ba, 12, 32), NULL);
+	zassert_true(sys_bitarray_is_region_set(&ba, 12, 32));
-	zassert_true(sys_bitarray_is_region_set(&ba,  8, 32), NULL);
+	zassert_true(sys_bitarray_is_region_set(&ba,  8, 32));
-	zassert_true(sys_bitarray_is_region_set(&ba, 14, 30), NULL);
+	zassert_true(sys_bitarray_is_region_set(&ba, 14, 30));
-	zassert_true(sys_bitarray_is_region_set(&ba, 20, 24), NULL);
+	zassert_true(sys_bitarray_is_region_set(&ba, 20, 24));
 
-	zassert_false(sys_bitarray_is_region_cleared(&ba,  4,  0), NULL);
+	zassert_false(sys_bitarray_is_region_cleared(&ba,  4,  0));
-	zassert_false(sys_bitarray_is_region_cleared(&ba, 12, 32), NULL);
+	zassert_false(sys_bitarray_is_region_cleared(&ba, 12, 32));
-	zassert_false(sys_bitarray_is_region_cleared(&ba,  8, 32), NULL);
+	zassert_false(sys_bitarray_is_region_cleared(&ba,  8, 32));
-	zassert_false(sys_bitarray_is_region_cleared(&ba, 14, 30), NULL);
+	zassert_false(sys_bitarray_is_region_cleared(&ba, 14, 30));
-	zassert_false(sys_bitarray_is_region_cleared(&ba, 20, 24), NULL);
+	zassert_false(sys_bitarray_is_region_cleared(&ba, 20, 24));
 
 	ba.bundles[0] = ~ba.bundles[0];
 	ba.bundles[1] = ~ba.bundles[1];
 
-	zassert_true(sys_bitarray_is_region_cleared(&ba,  4,  0), NULL);
+	zassert_true(sys_bitarray_is_region_cleared(&ba,  4,  0));
-	zassert_true(sys_bitarray_is_region_cleared(&ba, 12, 32), NULL);
+	zassert_true(sys_bitarray_is_region_cleared(&ba, 12, 32));
-	zassert_true(sys_bitarray_is_region_cleared(&ba,  8, 32), NULL);
+	zassert_true(sys_bitarray_is_region_cleared(&ba,  8, 32));
-	zassert_true(sys_bitarray_is_region_cleared(&ba, 14, 30), NULL);
+	zassert_true(sys_bitarray_is_region_cleared(&ba, 14, 30));
-	zassert_true(sys_bitarray_is_region_cleared(&ba, 20, 24), NULL);
+	zassert_true(sys_bitarray_is_region_cleared(&ba, 20, 24));
 
-	zassert_false(sys_bitarray_is_region_set(&ba,  4,  0), NULL);
+	zassert_false(sys_bitarray_is_region_set(&ba,  4,  0));
-	zassert_false(sys_bitarray_is_region_set(&ba, 12, 32), NULL);
+	zassert_false(sys_bitarray_is_region_set(&ba, 12, 32));
-	zassert_false(sys_bitarray_is_region_set(&ba,  8, 32), NULL);
+	zassert_false(sys_bitarray_is_region_set(&ba,  8, 32));
-	zassert_false(sys_bitarray_is_region_set(&ba, 14, 30), NULL);
+	zassert_false(sys_bitarray_is_region_set(&ba, 14, 30));
-	zassert_false(sys_bitarray_is_region_set(&ba, 20, 24), NULL);
+	zassert_false(sys_bitarray_is_region_set(&ba, 20, 24));
 
-	zassert_false(sys_bitarray_is_region_set(&ba, 10, 60), NULL);
+	zassert_false(sys_bitarray_is_region_set(&ba, 10, 60));
-	zassert_false(sys_bitarray_is_region_cleared(&ba, 10, 60), NULL);
+	zassert_false(sys_bitarray_is_region_cleared(&ba, 10, 60));
-	zassert_false(sys_bitarray_is_region_set(&ba, 8, 120), NULL);
+	zassert_false(sys_bitarray_is_region_set(&ba, 8, 120));
-	zassert_false(sys_bitarray_is_region_cleared(&ba, 8, 120), NULL);
+	zassert_false(sys_bitarray_is_region_cleared(&ba, 8, 120));
 
 	printk("Testing bit array region bit manipulations\n");
 

tests/kernel/common/src/clock.c

@@ -71,7 +71,7 @@ ZTEST_USER(clock, test_clock_uptime)
 	/**TESTPOINT: uptime straddled ms boundary*/
 	t32 = k_uptime_get_32();
 	ALIGN_MS_BOUNDARY;
-	zassert_true(k_uptime_get_32() > t32, NULL);
+	zassert_true(k_uptime_get_32() > t32);
 
 	/**TESTPOINT: uptime delta*/
 	d64 = k_uptime_delta(&d64);
@@ -231,8 +231,8 @@ ZTEST(clock, test_ms_time_duration)
 
 	/** TESTPOINT: waiting time less than duration and check the count*/
 	k_busy_wait(LESS_DURATION * 1000);
-	zassert_true(tdata.duration_count == 0, NULL);
+	zassert_true(tdata.duration_count == 0);
-	zassert_true(tdata.stop_count == 0, NULL);
+	zassert_true(tdata.stop_count == 0);
 
 	/** TESTPOINT: proving duration in millisecond */
 	init_data_count();

tests/kernel/common/src/errno.c

@@ -55,7 +55,7 @@ static void errno_thread(void *_n, void *_my_errno, void *_unused)
 		result[n].pass = TC_PASS;
 	}
 
-	zassert_equal(errno, my_errno, NULL);
+	zassert_equal(errno, my_errno);
 
 	k_fifo_put(&fifo, &result[n]);
 }
@@ -97,7 +97,7 @@ ZTEST(common_errno, test_thread_context)
 		}
 	}
 
-	zassert_equal(errno, test_errno, NULL);
+	zassert_equal(errno, test_errno);
 
 	if (errno != errno_values[N_THREADS]) {
 		rv = TC_FAIL;

tests/kernel/device/src/main.c

@@ -54,17 +54,17 @@ ZTEST(device, test_dummy_device)
 
 	/* Validates device binding for a non-existing device object */
 	dev = device_get_binding(DUMMY_PORT_1);
-	zassert_equal(dev, NULL, NULL);
+	zassert_equal(dev, NULL);
 
 	/* Validates device binding for an existing device object */
 	dev = device_get_binding(DUMMY_PORT_2);
-	zassert_false((dev == NULL), NULL);
+	zassert_false((dev == NULL));
 
 	/* device_get_binding() returns false for device object
 	 * with failed init.
 	 */
 	dev = device_get_binding(BAD_DRIVER);
-	zassert_true((dev == NULL), NULL);
+	zassert_true((dev == NULL));
 }
 
 /**
@@ -81,7 +81,7 @@ ZTEST_USER(device, test_dynamic_name)
 
 	snprintk(name, sizeof(name), "%s", DUMMY_PORT_2);
 	mux = device_get_binding(name);
-	zassert_true(mux != NULL, NULL);
+	zassert_true(mux != NULL);
 }
 
 /**
@@ -99,7 +99,7 @@ ZTEST_USER(device, test_bogus_dynamic_name)
 
 	snprintk(name, sizeof(name), "ANOTHER_BOGUS_NAME");
 	mux = device_get_binding(name);
-	zassert_true(mux == NULL, NULL);
+	zassert_true(mux == NULL);
 }
 
 /**
@@ -119,7 +119,7 @@ ZTEST_USER(device, test_null_dynamic_name)
 	char *drv_name = NULL;
 
 	mux = device_get_binding(drv_name);
-	zassert_equal(mux, 0,  NULL);
+	zassert_equal(mux, 0);
 #else
 	ztest_test_skip();
 #endif
@@ -233,7 +233,7 @@ ZTEST(device, test_device_list)
 	struct device const *devices;
 	size_t devcount = z_device_get_all_static(&devices);
 
-	zassert_false((devcount == 0), NULL);
+	zassert_false((devcount == 0));
 }
 
 static int sys_init_counter;
@@ -340,7 +340,7 @@ ZTEST(device, test_abstraction_driver_common)
 
 	/* verify driver A API has called */
 	dev = device_get_binding(MY_DRIVER_A);
-	zassert_false((dev == NULL), NULL);
+	zassert_false((dev == NULL));
 
 	ret = subsystem_do_this(dev, foo, bar);
 	zassert_true(ret == (foo + bar), "common API do_this fail");
@@ -350,7 +350,7 @@ ZTEST(device, test_abstraction_driver_common)
 
 	/* verify driver B API has called */
 	dev = device_get_binding(MY_DRIVER_B);
-	zassert_false((dev == NULL), NULL);
+	zassert_false((dev == NULL));
 
 	ret = subsystem_do_this(dev, foo, bar);
 	zassert_true(ret == (foo - bar), "common API do_this fail");

tests/kernel/events/event_api/src/test_event_apis.c

@@ -71,7 +71,7 @@ ZTEST(events_api, test_k_event_init)
 	thread = z_waitq_head(&event.wait_q);
 
 	zassert_is_null(thread, NULL);
-	zassert_true(event.events == 0, NULL);
+	zassert_true(event.events == 0);
 }
 
 static void receive_existing_events(void)
@@ -189,8 +189,8 @@ static void test_receive_existing_events(void)
 
 	k_sem_give(&sync_sem);
 	rv = k_sem_take(&receiver_sem, LONG_TIMEOUT);
-	zassert_true(rv == 0, NULL);
+	zassert_true(rv == 0);
-	zassert_true(test_events == 0, NULL);
+	zassert_true(test_events == 0);
 
 	/*
 	 * Sync point 1-2.
@@ -199,8 +199,8 @@ static void test_receive_existing_events(void)
 
 	k_sem_give(&sync_sem);
 	rv = k_sem_take(&receiver_sem, LONG_TIMEOUT);
-	zassert_true(rv == 0, NULL);
+	zassert_true(rv == 0);
-	zassert_true(test_events == 0, NULL);
+	zassert_true(test_events == 0);
 
 	/*
 	 * Sync point 1-3.
@@ -209,8 +209,8 @@ static void test_receive_existing_events(void)
 
 	k_sem_give(&sync_sem);
 	rv = k_sem_take(&receiver_sem, LONG_TIMEOUT);
-	zassert_true(rv == 0, NULL);
+	zassert_true(rv == 0);
-	zassert_true(test_events == 0, NULL);
+	zassert_true(test_events == 0);
 
 	/*
 	 * Sync point 1-4.
@@ -219,8 +219,8 @@ static void test_receive_existing_events(void)
 
 	k_sem_give(&sync_sem);
 	rv = k_sem_take(&receiver_sem, LONG_TIMEOUT);
-	zassert_true(rv == 0, NULL);
+	zassert_true(rv == 0);
-	zassert_true(test_events == 0, NULL);
+	zassert_true(test_events == 0);
 
 	/*
 	 * Sync point 1-5.
@@ -229,8 +229,8 @@ static void test_receive_existing_events(void)
 
 	k_sem_give(&sync_sem);
 	rv = k_sem_take(&receiver_sem, LONG_TIMEOUT);
-	zassert_true(rv == 0, NULL);
+	zassert_true(rv == 0);
-	zassert_true(test_events == 0x234, NULL);
+	zassert_true(test_events == 0x234);
 
 	/*
 	 * Sync point 1-6.
@@ -239,8 +239,8 @@ static void test_receive_existing_events(void)
 
 	k_sem_give(&sync_sem);
 	rv = k_sem_take(&receiver_sem, LONG_TIMEOUT);
-	zassert_true(rv == 0, NULL);
+	zassert_true(rv == 0);
-	zassert_true(test_events == 0x1234, NULL);
+	zassert_true(test_events == 0x1234);
 }
 
 /**
@@ -261,9 +261,9 @@ static void test_reset_on_wait(void)
 	k_sleep(DELAY);           /* Give receiver thread time to run */
 	k_event_post(&test_event, 0x123);
 	rv = k_sem_take(&receiver_sem, LONG_TIMEOUT);
-	zassert_true(rv == 0, NULL);
+	zassert_true(rv == 0);
-	zassert_true(test_events == 0, NULL);
+	zassert_true(test_events == 0);
-	zassert_true(test_event.events == 0x123, NULL);
+	zassert_true(test_event.events == 0x123);
 
 	/*
 	 * Sync point 2-2. Reset events before receive.
@@ -274,9 +274,9 @@ static void test_reset_on_wait(void)
 	k_sleep(DELAY);
 	k_event_post(&test_event, 0x248);
 	rv = k_sem_take(&receiver_sem, LONG_TIMEOUT);
-	zassert_true(rv == 0, NULL);
+	zassert_true(rv == 0);
-	zassert_true(test_events == 0, NULL);
+	zassert_true(test_events == 0);
-	zassert_true(test_event.events == 0x248, NULL);
+	zassert_true(test_event.events == 0x248);
 
 	/*
 	 * Sync point 2-3. Reset events before receive.
@@ -287,9 +287,9 @@ static void test_reset_on_wait(void)
 	k_sleep(DELAY);
 	k_event_post(&test_event, 0x248021);
 	rv = k_sem_take(&receiver_sem, LONG_TIMEOUT);
-	zassert_true(rv == 0, NULL);
+	zassert_true(rv == 0);
-	zassert_true(test_events == 0x248001, NULL);
+	zassert_true(test_events == 0x248001);
-	zassert_true(test_event.events  == 0x248021, NULL);
+	zassert_true(test_event.events  == 0x248021);
 
 	/*
 	 * Sync point 2-4. Reset events before receive.
@@ -300,9 +300,9 @@ static void test_reset_on_wait(void)
 	k_sleep(DELAY);
 	k_event_post(&test_event, 0x123456);
 	rv = k_sem_take(&receiver_sem, LONG_TIMEOUT);
-	zassert_true(rv == 0, NULL);
+	zassert_true(rv == 0);
-	zassert_true(test_events == 0x123450, NULL);
+	zassert_true(test_events == 0x123450);
-	zassert_true(test_event.events  == 0x123456, NULL);
+	zassert_true(test_event.events  == 0x123456);
 
 	k_event_set(&test_event, 0x0);  /* Reset events */
 	k_sem_give(&sync_sem);
@@ -326,7 +326,7 @@ void test_wake_multiple_threads(void)
 
 	events = k_event_wait_all(&test_event, 0x333, false, SHORT_TIMEOUT);
 
-	zassert_true(events == 0x333, NULL);
+	zassert_true(events == 0x333);
 }
 
 /**
@@ -344,7 +344,7 @@ ZTEST(events_api, test_event_deliver)
 
 	k_event_init(&event);
 
-	zassert_true(event.events == 0, NULL);
+	zassert_true(event.events == 0);
 
 	/*
 	 * Verify k_event_post()  and k_event_set() update the
@@ -353,15 +353,15 @@ ZTEST(events_api, test_event_deliver)
 
 	events = 0xAAAA;
 	k_event_post(&event, events);
-	zassert_true(event.events == events, NULL);
+	zassert_true(event.events == events);
 
 	events |= 0x55555ABC;
 	k_event_post(&event, events);
-	zassert_true(event.events == events, NULL);
+	zassert_true(event.events == events);
 
 	events = 0xAAAA0000;
 	k_event_set(&event, events);
-	zassert_true(event.events == events, NULL);
+	zassert_true(event.events == events);
 
 	/*
 	 * Verify k_event_set_masked() update the events
@@ -369,25 +369,25 @@ ZTEST(events_api, test_event_deliver)
 	 */
 	events = 0x33333333;
 	k_event_set(&event, events);
-	zassert_true(event.events == events, NULL);
+	zassert_true(event.events == events);
 
 	events_mask = 0x11111111;
 	k_event_set_masked(&event, 0, events_mask);
-	zassert_true(event.events == 0x22222222, NULL);
+	zassert_true(event.events == 0x22222222);
 
 	events_mask = 0x22222222;
 	k_event_set_masked(&event, 0, events_mask);
-	zassert_true(event.events == 0, NULL);
+	zassert_true(event.events == 0);
 
 	events = 0x22222222;
 	events_mask = 0x22222222;
 	k_event_set_masked(&event, events, events_mask);
-	zassert_true(event.events == events, NULL);
+	zassert_true(event.events == events);
 
 	events = 0x11111111;
 	events_mask = 0x33333333;
 	k_event_set_masked(&event, events, events_mask);
-	zassert_true(event.events == events, NULL);
+	zassert_true(event.events == events);
 
 }
 

tests/kernel/events/sys_event/src/main.c

@@ -69,7 +69,7 @@ ZTEST(sys_events, test_k_event_init)
 {
 	k_event_init(&init_event);
 
-	zassert_true(init_event.events == 0, NULL);
+	zassert_true(init_event.events == 0);
 }
 
 static void receive_existing_events(void)
@@ -186,8 +186,8 @@ static void test_receive_existing_events(void)
 
 	k_sem_give(&sync_sem);
 	rv = k_sem_take(&receiver_sem, LONG_TIMEOUT);
-	zassert_true(rv == 0, NULL);
+	zassert_true(rv == 0);
-	zassert_true(test_events == 0, NULL);
+	zassert_true(test_events == 0);
 
 	/*
 	 * Sync point 1-2.
@@ -196,8 +196,8 @@ static void test_receive_existing_events(void)
 
 	k_sem_give(&sync_sem);
 	rv = k_sem_take(&receiver_sem, LONG_TIMEOUT);
-	zassert_true(rv == 0, NULL);
+	zassert_true(rv == 0);
-	zassert_true(test_events == 0, NULL);
+	zassert_true(test_events == 0);
 
 	/*
 	 * Sync point 1-3.
@@ -206,8 +206,8 @@ static void test_receive_existing_events(void)
 
 	k_sem_give(&sync_sem);
 	rv = k_sem_take(&receiver_sem, LONG_TIMEOUT);
-	zassert_true(rv == 0, NULL);
+	zassert_true(rv == 0);
-	zassert_true(test_events == 0, NULL);
+	zassert_true(test_events == 0);
 
 	/*
 	 * Sync point 1-4.
@@ -216,8 +216,8 @@ static void test_receive_existing_events(void)
 
 	k_sem_give(&sync_sem);
 	rv = k_sem_take(&receiver_sem, LONG_TIMEOUT);
-	zassert_true(rv == 0, NULL);
+	zassert_true(rv == 0);
-	zassert_true(test_events == 0, NULL);
+	zassert_true(test_events == 0);
 
 	/*
 	 * Sync point 1-5.
@@ -226,8 +226,8 @@ static void test_receive_existing_events(void)
 
 	k_sem_give(&sync_sem);
 	rv = k_sem_take(&receiver_sem, LONG_TIMEOUT);
-	zassert_true(rv == 0, NULL);
+	zassert_true(rv == 0);
-	zassert_true(test_events == 0x234, NULL);
+	zassert_true(test_events == 0x234);
 
 	/*
 	 * Sync point 1-6.
@@ -236,8 +236,8 @@ static void test_receive_existing_events(void)
 
 	k_sem_give(&sync_sem);
 	rv = k_sem_take(&receiver_sem, LONG_TIMEOUT);
-	zassert_true(rv == 0, NULL);
+	zassert_true(rv == 0);
-	zassert_true(test_events == 0x1234, NULL);
+	zassert_true(test_events == 0x1234);
 }
 
 /**
@@ -258,9 +258,9 @@ static void test_reset_on_receive(void)
 	k_sleep(DELAY);           /* Give receiver thread time to run */
 	k_event_post(&test_event, 0x123);
 	rv = k_sem_take(&receiver_sem, LONG_TIMEOUT);
-	zassert_true(rv == 0, NULL);
+	zassert_true(rv == 0);
-	zassert_true(test_events == 0, NULL);
+	zassert_true(test_events == 0);
-	zassert_true(test_event.events == 0x123, NULL);
+	zassert_true(test_event.events == 0x123);
 
 	/*
 	 * Sync point 2-2. Clear events before receive.
@@ -271,9 +271,9 @@ static void test_reset_on_receive(void)
 	k_sleep(DELAY);
 	k_event_post(&test_event, 0x248);
 	rv = k_sem_take(&receiver_sem, LONG_TIMEOUT);
-	zassert_true(rv == 0, NULL);
+	zassert_true(rv == 0);
-	zassert_true(test_events == 0, NULL);
+	zassert_true(test_events == 0);
-	zassert_true(test_event.events == 0x248, NULL);
+	zassert_true(test_event.events == 0x248);
 
 	/*
 	 * Sync point 2-3. Clear events before receive.
@@ -284,9 +284,9 @@ static void test_reset_on_receive(void)
 	k_sleep(DELAY);
 	k_event_post(&test_event, 0x248021);
 	rv = k_sem_take(&receiver_sem, LONG_TIMEOUT);
-	zassert_true(rv == 0, NULL);
+	zassert_true(rv == 0);
-	zassert_true(test_events == 0x248001, NULL);
+	zassert_true(test_events == 0x248001);
-	zassert_true(test_event.events  == 0x248021, NULL);
+	zassert_true(test_event.events  == 0x248021);
 
 	/*
 	 * Sync point 2-4. Clear events before receive.
@@ -297,9 +297,9 @@ static void test_reset_on_receive(void)
 	k_sleep(DELAY);
 	k_event_post(&test_event, 0x123456);
 	rv = k_sem_take(&receiver_sem, LONG_TIMEOUT);
-	zassert_true(rv == 0, NULL);
+	zassert_true(rv == 0);
-	zassert_true(test_events == 0x123450, NULL);
+	zassert_true(test_events == 0x123450);
-	zassert_true(test_event.events  == 0x123456, NULL);
+	zassert_true(test_event.events  == 0x123456);
 
 	k_event_set(&test_event, 0x0);  /* Clear events */
 
@@ -324,7 +324,7 @@ void test_wake_multiple_threads(void)
 
 	events = k_event_wait_all(&test_event, 0x333, false, SHORT_TIMEOUT);
 
-	zassert_true(events == 0x333, NULL);
+	zassert_true(events == 0x333);
 }
 
 /**
@@ -340,7 +340,7 @@ ZTEST(sys_events, test_event_deliver)
 
 	k_event_init(&deliver_event);
 
-	zassert_true(deliver_event.events == 0, NULL);
+	zassert_true(deliver_event.events == 0);
 
 	/*
 	 * Verify k_event_post() and k_event_set() update the
@@ -349,15 +349,15 @@ ZTEST(sys_events, test_event_deliver)
 
 	events = 0xAAAA;
 	k_event_post(&deliver_event, events);
-	zassert_true(deliver_event.events == events, NULL);
+	zassert_true(deliver_event.events == events);
 
 	events |= 0x55555ABC;
 	k_event_post(&deliver_event, events);
-	zassert_true(deliver_event.events == events, NULL);
+	zassert_true(deliver_event.events == events);
 
 	events = 0xAAAA0000;
 	k_event_set(&deliver_event, events);
-	zassert_true(deliver_event.events == events, NULL);
+	zassert_true(deliver_event.events == events);
 }
 
 /**

tests/kernel/fifo/fifo_api/src/test_fifo_contexts.c

@@ -51,17 +51,17 @@ static void tfifo_get(struct k_fifo *pfifo)
 	for (int i = 0; i < LIST_LEN; i++) {
 		/**TESTPOINT: fifo get*/
 		rx_data = k_fifo_get(pfifo, K_NO_WAIT);
-		zassert_equal(rx_data, (void *)&data[i], NULL);
+		zassert_equal(rx_data, (void *)&data[i]);
 	}
 	/*get fifo data from "fifo_put_list"*/
 	for (int i = 0; i < LIST_LEN; i++) {
 		rx_data = k_fifo_get(pfifo, K_NO_WAIT);
-		zassert_equal(rx_data, (void *)&data_l[i], NULL);
+		zassert_equal(rx_data, (void *)&data_l[i]);
 	}
 	/*get fifo data from "fifo_put_slist"*/
 	for (int i = 0; i < LIST_LEN; i++) {
 		rx_data = k_fifo_get(pfifo, K_NO_WAIT);
-		zassert_equal(rx_data, (void *)&data_sl[i], NULL);
+		zassert_equal(rx_data, (void *)&data_sl[i]);
 	}
 }
 
@@ -69,13 +69,13 @@ static void tfifo_get(struct k_fifo *pfifo)
 static void tIsr_entry_put(const void *p)
 {
 	tfifo_put((struct k_fifo *)p);
-	zassert_false(k_fifo_is_empty((struct k_fifo *)p), NULL);
+	zassert_false(k_fifo_is_empty((struct k_fifo *)p));
 }
 
 static void tIsr_entry_get(const void *p)
 {
 	tfifo_get((struct k_fifo *)p);
-	zassert_true(k_fifo_is_empty((struct k_fifo *)p), NULL);
+	zassert_true(k_fifo_is_empty((struct k_fifo *)p));
 }
 
 static void tThread_entry(void *p1, void *p2, void *p3)
@@ -118,11 +118,11 @@ static void tfifo_is_empty(void *p)
 
 	tfifo_put(&fifo);
 	/**TESTPOINT: return false when data available*/
-	zassert_false(k_fifo_is_empty(pfifo), NULL);
+	zassert_false(k_fifo_is_empty(pfifo));
 
 	tfifo_get(&fifo);
 	/**TESTPOINT: return true with data unavailable*/
-	zassert_true(k_fifo_is_empty(pfifo), NULL);
+	zassert_true(k_fifo_is_empty(pfifo));
 }
 
 /**
@@ -180,7 +180,7 @@ ZTEST(fifo_api, test_fifo_is_empty_thread)
 {
 	k_fifo_init(&fifo);
 	/**TESTPOINT: k_fifo_is_empty after init*/
-	zassert_true(k_fifo_is_empty(&fifo), NULL);
+	zassert_true(k_fifo_is_empty(&fifo));
 
 	/**TESTPONT: check fifo is empty from thread*/
 	tfifo_is_empty(&fifo);

tests/kernel/fifo/fifo_api/src/test_fifo_loop.c

@@ -32,7 +32,7 @@ static void tfifo_get(struct k_fifo *pfifo)
 	for (int i = 0; i < LIST_LEN; i++) {
 		/**TESTPOINT: fifo get*/
 		rx_data = k_fifo_get(pfifo, K_NO_WAIT);
-		zassert_equal(rx_data, (void *)&data[i], NULL);
+		zassert_equal(rx_data, (void *)&data[i]);
 	}
 }
 

tests/kernel/fifo/fifo_timeout/src/main.c

@@ -87,7 +87,7 @@ static void *get_scratch_packet(void)
 {
 	void *packet = k_fifo_get(&scratch_fifo_packets_fifo, K_NO_WAIT);
 
-	zassert_true(packet != NULL, NULL);
+	zassert_true(packet != NULL);
 	return packet;
 }
 
@@ -127,8 +127,8 @@ static void test_thread_pend_and_timeout(void *p1, void *p2, void *p3)
 
 	start_time = k_cycle_get_32();
 	packet = k_fifo_get(d->fifo, K_MSEC(d->timeout));
-	zassert_true(packet == NULL, NULL);
+	zassert_true(packet == NULL);
-	zassert_true(is_timeout_in_range(start_time, d->timeout), NULL);
+	zassert_true(is_timeout_in_range(start_time, d->timeout));
 
 	k_fifo_put(&timeout_order_fifo, d);
 }
@@ -201,7 +201,7 @@ static void test_thread_pend_and_get_data(void *p1, void *p2, void *p3)
 	void *packet;
 
 	packet = k_fifo_get(d->fifo, K_MSEC(d->timeout));
-	zassert_true(packet != NULL, NULL);
+	zassert_true(packet != NULL);
 
 	put_scratch_packet(packet);
 	k_fifo_put(&timeout_order_fifo, d);
@@ -306,12 +306,12 @@ ZTEST(fifo_timeout_1cpu, test_timeout_empty_fifo)
 	timeout = 10U;
 	start_time = k_cycle_get_32();
 	packet = k_fifo_get(&fifo_timeout[0], K_MSEC(timeout));
-	zassert_true(packet == NULL, NULL);
+	zassert_true(packet == NULL);
-	zassert_true(is_timeout_in_range(start_time, timeout), NULL);
+	zassert_true(is_timeout_in_range(start_time, timeout));
 
 	/* Test empty fifo with timeout of K_NO_WAIT */
 	packet = k_fifo_get(&fifo_timeout[0], K_NO_WAIT);
-	zassert_true(packet == NULL, NULL);
+	zassert_true(packet == NULL);
 }
 
 /**
@@ -326,14 +326,14 @@ ZTEST(fifo_timeout, test_timeout_non_empty_fifo)
 	scratch_packet = get_scratch_packet();
 	k_fifo_put(&fifo_timeout[0], scratch_packet);
 	packet = k_fifo_get(&fifo_timeout[0], K_NO_WAIT);
-	zassert_true(packet != NULL, NULL);
+	zassert_true(packet != NULL);
 	put_scratch_packet(scratch_packet);
 
 	 /* Test k_fifo_get with K_FOREVER */
 	scratch_packet = get_scratch_packet();
 	k_fifo_put(&fifo_timeout[0], scratch_packet);
 	packet = k_fifo_get(&fifo_timeout[0], K_FOREVER);
-	zassert_true(packet != NULL, NULL);
+	zassert_true(packet != NULL);
 	put_scratch_packet(scratch_packet);
 }
 
@@ -368,8 +368,8 @@ ZTEST(fifo_timeout_1cpu, test_timeout_fifo_thread)
 				FIFO_THREAD_PRIO, K_INHERIT_PERMS, K_NO_WAIT);
 
 	packet = k_fifo_get(&fifo_timeout[0], K_MSEC(timeout + 10));
-	zassert_true(packet != NULL, NULL);
+	zassert_true(packet != NULL);
-	zassert_true(is_timeout_in_range(start_time, timeout), NULL);
+	zassert_true(is_timeout_in_range(start_time, timeout));
 	put_scratch_packet(packet);
 
 	/*
@@ -385,8 +385,8 @@ ZTEST(fifo_timeout_1cpu, test_timeout_fifo_thread)
 
 	k_yield();
 	packet = k_fifo_get(&timeout_order_fifo, K_NO_WAIT);
-	zassert_true(packet != NULL, NULL);
+	zassert_true(packet != NULL);
-	zassert_false(reply_packet.reply, NULL);
+	zassert_false(reply_packet.reply);
 
 	/*
 	 * Test k_fifo_get with timeout of K_NO_WAIT and the fifo
@@ -404,8 +404,8 @@ ZTEST(fifo_timeout_1cpu, test_timeout_fifo_thread)
 
 	k_yield();
 	packet = k_fifo_get(&timeout_order_fifo, K_NO_WAIT);
-	zassert_true(packet != NULL, NULL);
+	zassert_true(packet != NULL);
-	zassert_true(reply_packet.reply, NULL);
+	zassert_true(reply_packet.reply);
 	put_scratch_packet(scratch_packet);
 
 	/*
@@ -423,8 +423,8 @@ ZTEST(fifo_timeout_1cpu, test_timeout_fifo_thread)
 				FIFO_THREAD_PRIO, K_INHERIT_PERMS, K_NO_WAIT);
 
 	packet = k_fifo_get(&timeout_order_fifo, K_FOREVER);
-	zassert_true(packet != NULL, NULL);
+	zassert_true(packet != NULL);
-	zassert_true(reply_packet.reply, NULL);
+	zassert_true(reply_packet.reply);
 	put_scratch_packet(scratch_packet);
 }
 
@@ -444,7 +444,7 @@ ZTEST(fifo_timeout_1cpu, test_timeout_threads_pend_on_fifo)
 	 */
 	test_data_size = ARRAY_SIZE(timeout_order_data);
 	rv = test_multiple_threads_pending(timeout_order_data, test_data_size);
-	zassert_equal(rv, TC_PASS, NULL);
+	zassert_equal(rv, TC_PASS);
 }
 
 /**
@@ -464,7 +464,7 @@ ZTEST(fifo_timeout_1cpu, test_timeout_threads_pend_on_dual_fifos)
 	test_data_size = ARRAY_SIZE(timeout_order_data_mult_fifo);
 	rv = test_multiple_threads_pending(timeout_order_data_mult_fifo,
 							test_data_size);
-	zassert_equal(rv, TC_PASS, NULL);
+	zassert_equal(rv, TC_PASS);
 
 }
 
@@ -485,7 +485,7 @@ ZTEST(fifo_timeout_1cpu, test_timeout_threads_pend_fail_on_fifo)
 	 */
 	test_data_size = ARRAY_SIZE(timeout_order_data);
 	rv = test_multiple_threads_get_data(timeout_order_data, test_data_size);
-	zassert_equal(rv, TC_PASS, NULL);
+	zassert_equal(rv, TC_PASS);
 }
 
 /**

tests/kernel/fifo/fifo_usage/src/main.c

@@ -64,7 +64,7 @@ static void tIsr_entry_put(const void *p)
 	for (i = 0U; i < LIST_LEN; i++) {
 		k_fifo_put((struct k_fifo *)p, (void *)&data_isr[i]);
 	}
-	zassert_false(k_fifo_is_empty((struct k_fifo *)p), NULL);
+	zassert_false(k_fifo_is_empty((struct k_fifo *)p));
 }
 
 static void tIsr_entry_get(const void *p)
@@ -75,9 +75,9 @@ static void tIsr_entry_get(const void *p)
 	/* Get items from fifo */
 	for (i = 0U; i < LIST_LEN; i++) {
 		rx_data = k_fifo_get((struct k_fifo *)p, K_NO_WAIT);
-		zassert_equal(rx_data, (void *)&data_isr[i], NULL);
+		zassert_equal(rx_data, (void *)&data_isr[i]);
 	}
-	zassert_true(k_fifo_is_empty((struct k_fifo *)p), NULL);
+	zassert_true(k_fifo_is_empty((struct k_fifo *)p));
 }
 
 static void thread_entry_fn_single(void *p1, void *p2, void *p3)
@@ -88,7 +88,7 @@ static void thread_entry_fn_single(void *p1, void *p2, void *p3)
 	/* Get items from fifo */
 	for (i = 0U; i < LIST_LEN; i++) {
 		rx_data = k_fifo_get((struct k_fifo *)p1, K_NO_WAIT);
-		zassert_equal(rx_data, (void *)&data1[i], NULL);
+		zassert_equal(rx_data, (void *)&data1[i]);
 	}
 
 	/* Put items into fifo */
@@ -108,7 +108,7 @@ static void thread_entry_fn_dual(void *p1, void *p2, void *p3)
 	for (i = 0U; i < LIST_LEN; i++) {
 		/* Get items from fifo2 */
 		rx_data = k_fifo_get((struct k_fifo *)p2, K_FOREVER);
-		zassert_equal(rx_data, (void *)&data2[i], NULL);
+		zassert_equal(rx_data, (void *)&data2[i]);
 
 		/* Put items into fifo1 */
 		k_fifo_put((struct k_fifo *)p1, (void *)&data1[i]);
@@ -164,7 +164,7 @@ ZTEST(fifo_usage, test_single_fifo_play)
 	/* Get items from fifo */
 	for (i = 0U; i < LIST_LEN; i++) {
 		rx_data = k_fifo_get(&fifo1, K_NO_WAIT);
-		zassert_equal(rx_data, (void *)&data2[i], NULL);
+		zassert_equal(rx_data, (void *)&data2[i]);
 	}
 
 	/* Clear the spawn thread to avoid side effect */
@@ -195,7 +195,7 @@ ZTEST(fifo_usage, test_dual_fifo_play)
 
 		/* Get item from fifo */
 		rx_data = k_fifo_get(&fifo1, K_FOREVER);
-		zassert_equal(rx_data, (void *)&data1[i], NULL);
+		zassert_equal(rx_data, (void *)&data1[i]);
 	}
 
 	/* Clear the spawn thread to avoid side effect */

tests/kernel/fpu_sharing/generic/src/load_store.c

@@ -184,7 +184,7 @@ static void load_store_low(void)
 		}
 
 		/* Terminate if a test error has been reported */
-		zassert_false(error, NULL);
+		zassert_false(error);
 
 		/*
 		 * After every 1000 iterations (arbitrarily chosen), explicitly

tests/kernel/lifo/lifo_api/src/test_lifo_contexts.c

@@ -34,7 +34,7 @@ static void tlifo_get(struct k_lifo *plifo)
 	for (int i = LIST_LEN-1; i >= 0; i--) {
 		/**TESTPOINT: lifo get*/
 		rx_data = k_lifo_get(plifo, K_FOREVER);
-		zassert_equal(rx_data, (void *)&data[i], NULL);
+		zassert_equal(rx_data, (void *)&data[i]);
 	}
 }
 

tests/kernel/lifo/lifo_api/src/test_lifo_loop.c

@@ -32,7 +32,7 @@ static void tlifo_get(struct k_lifo *plifo)
 	for (int i = LIST_LEN-1; i >= 0; i--) {
 		/**TESTPOINT: lifo get*/
 		rx_data = k_lifo_get(plifo, K_FOREVER);
-		zassert_equal(rx_data, (void *)&data[i], NULL);
+		zassert_equal(rx_data, (void *)&data[i]);
 	}
 }
 

tests/kernel/lifo/lifo_usage/src/main.c

@@ -80,7 +80,7 @@ static void *get_scratch_packet(void)
 {
 	void *packet = k_lifo_get(&scratch_lifo_packets_lifo, K_NO_WAIT);
 
-	zassert_true(packet != NULL, NULL);
+	zassert_true(packet != NULL);
 	return packet;
 }
 
@@ -96,11 +96,11 @@ static void thread_entry_nowait(void *p1, void *p2, void *p3)
 	ret = k_lifo_get((struct k_lifo *)p1, K_FOREVER);
 
 	/* data pushed at last should be read first */
-	zassert_equal(ret, (void *)&data[1], NULL);
+	zassert_equal(ret, (void *)&data[1]);
 
 	ret = k_lifo_get((struct k_lifo *)p1, K_FOREVER);
 
-	zassert_equal(ret, (void *)&data[0], NULL);
+	zassert_equal(ret, (void *)&data[0]);
 
 	k_sem_give(&start_sema);
 }
@@ -250,13 +250,13 @@ ZTEST(lifo_usage_1cpu, test_lifo_wait)
 
 	ret = k_lifo_get(&plifo, K_FOREVER);
 
-	zassert_equal(ret, (void *)&data[0], NULL);
+	zassert_equal(ret, (void *)&data[0]);
 
 	k_sem_take(&wait_sema, K_FOREVER);
 
 	ret = k_lifo_get(&plifo, K_FOREVER);
 
-	zassert_equal(ret, (void *)&data[1], NULL);
+	zassert_equal(ret, (void *)&data[1]);
 
 	k_thread_abort(tid);
 }
@@ -277,13 +277,13 @@ ZTEST(lifo_usage_1cpu, test_timeout_empty_lifo)
 
 	packet = k_lifo_get(&lifo_timeout[0], K_MSEC(timeout));
 
-	zassert_equal(packet, NULL, NULL);
+	zassert_equal(packet, NULL);
 
-	zassert_true(is_timeout_in_range(start_time, timeout), NULL);
+	zassert_true(is_timeout_in_range(start_time, timeout));
 
 	/* Test empty lifo with timeout of K_NO_WAIT */
 	packet = k_lifo_get(&lifo_timeout[0], K_NO_WAIT);
-	zassert_equal(packet, NULL, NULL);
+	zassert_equal(packet, NULL);
 }
 
 /**
@@ -298,14 +298,14 @@ ZTEST(lifo_usage, test_timeout_non_empty_lifo)
 	scratch_packet = get_scratch_packet();
 	k_lifo_put(&lifo_timeout[0], scratch_packet);
 	packet = k_lifo_get(&lifo_timeout[0], K_NO_WAIT);
-	zassert_true(packet != NULL, NULL);
+	zassert_true(packet != NULL);
 	put_scratch_packet(scratch_packet);
 
 	 /* Test k_lifo_get with K_FOREVER */
 	scratch_packet = get_scratch_packet();
 	k_lifo_put(&lifo_timeout[0], scratch_packet);
 	packet = k_lifo_get(&lifo_timeout[0], K_FOREVER);
-	zassert_true(packet != NULL, NULL);
+	zassert_true(packet != NULL);
 }
 
 /**
@@ -331,8 +331,8 @@ ZTEST(lifo_usage_1cpu, test_timeout_lifo_thread)
 				LIFO_THREAD_PRIO, K_INHERIT_PERMS, K_NO_WAIT);
 
 	packet = k_lifo_get(&lifo_timeout[0], K_MSEC(timeout + 10));
-	zassert_true(packet != NULL, NULL);
+	zassert_true(packet != NULL);
-	zassert_true(is_timeout_in_range(start_time, timeout), NULL);
+	zassert_true(is_timeout_in_range(start_time, timeout));
 	put_scratch_packet(packet);
 
 	/*
@@ -348,8 +348,8 @@ ZTEST(lifo_usage_1cpu, test_timeout_lifo_thread)
 
 	k_yield();
 	packet = k_lifo_get(&timeout_order_lifo, K_NO_WAIT);
-	zassert_true(packet != NULL, NULL);
+	zassert_true(packet != NULL);
-	zassert_false(reply_packet.reply, NULL);
+	zassert_false(reply_packet.reply);
 
 	/*
 	 * Test k_lifo_get with timeout of K_NO_WAIT and the lifo
@@ -367,8 +367,8 @@ ZTEST(lifo_usage_1cpu, test_timeout_lifo_thread)
 
 	k_yield();
 	packet = k_lifo_get(&timeout_order_lifo, K_NO_WAIT);
-	zassert_true(packet != NULL, NULL);
+	zassert_true(packet != NULL);
-	zassert_true(reply_packet.reply, NULL);
+	zassert_true(reply_packet.reply);
 	put_scratch_packet(scratch_packet);
 
 	/*
@@ -386,8 +386,8 @@ ZTEST(lifo_usage_1cpu, test_timeout_lifo_thread)
 				LIFO_THREAD_PRIO, K_INHERIT_PERMS, K_NO_WAIT);
 
 	packet = k_lifo_get(&timeout_order_lifo, K_FOREVER);
-	zassert_true(packet != NULL, NULL);
+	zassert_true(packet != NULL);
-	zassert_true(reply_packet.reply, NULL);
+	zassert_true(reply_packet.reply);
 	put_scratch_packet(scratch_packet);
 }
 
@@ -403,8 +403,8 @@ void test_thread_pend_and_timeout(void *p1, void *p2, void *p3)
 
 	start_time = k_cycle_get_32();
 	packet = k_lifo_get(d->klifo, K_MSEC(d->timeout));
-	zassert_true(packet == NULL, NULL);
+	zassert_true(packet == NULL);
-	zassert_true(is_timeout_in_range(start_time, d->timeout), NULL);
+	zassert_true(is_timeout_in_range(start_time, d->timeout));
 
 	k_lifo_put(&timeout_order_lifo, d);
 }
@@ -426,7 +426,7 @@ ZTEST(lifo_usage_1cpu, test_timeout_threads_pend_on_lifo)
 	 */
 	test_data_size = ARRAY_SIZE(timeout_order_data);
 	rv = test_multiple_threads_pending(timeout_order_data, test_data_size);
-	zassert_equal(rv, TC_PASS, NULL);
+	zassert_equal(rv, TC_PASS);
 }
 
 /**

tests/kernel/mbox/mbox_api/src/test_mbox_api.c

@@ -166,7 +166,7 @@ static void tmbox_put(struct k_mbox *pmbox)
 		mmsg.tx_data = data[1];
 		mmsg.tx_block.data = NULL;
 		mmsg.tx_target_thread = K_ANY;
-		zassert_true(k_mbox_put(pmbox, &mmsg, K_FOREVER) == 0, NULL);
+		zassert_true(k_mbox_put(pmbox, &mmsg, K_FOREVER) == 0);
 		break;
 
 	case ASYNC_PUT_TO_WAITING_GET:
@@ -252,9 +252,9 @@ static void tmbox_get(struct k_mbox *pmbox)
 		zassert_true(k_mbox_get(pmbox, &mmsg, rxdata, K_FOREVER) == 0,
 			     NULL);
 		/*verify .info*/
-		zassert_equal(mmsg.info, PUT_GET_NULL, NULL);
+		zassert_equal(mmsg.info, PUT_GET_NULL);
 		/*verify .size*/
-		zassert_equal(mmsg.size, 0, NULL);
+		zassert_equal(mmsg.size, 0);
 		break;
 	case PUT_GET_BUFFER:
 		__fallthrough;
@@ -268,8 +268,8 @@ static void tmbox_get(struct k_mbox *pmbox)
 		}
 		zassert_true(k_mbox_get(pmbox, &mmsg, rxdata, K_FOREVER) == 0,
 			     NULL);
-		zassert_equal(mmsg.info, PUT_GET_BUFFER, NULL);
+		zassert_equal(mmsg.info, PUT_GET_BUFFER);
-		zassert_equal(mmsg.size, sizeof(data[info_type]), NULL);
+		zassert_equal(mmsg.size, sizeof(data[info_type]));
 		/*verify rxdata*/
 		zassert_true(memcmp(rxdata, data[info_type], MAIL_LEN) == 0,
 			     NULL);
@@ -280,8 +280,8 @@ static void tmbox_get(struct k_mbox *pmbox)
 		mmsg.rx_source_thread = K_ANY;
 		zassert_true(k_mbox_get(pmbox, &mmsg, NULL, K_FOREVER) == 0,
 			     NULL);
-		zassert_equal(mmsg.info, ASYNC_PUT_GET_BUFFER, NULL);
+		zassert_equal(mmsg.info, ASYNC_PUT_GET_BUFFER);
-		zassert_equal(mmsg.size, sizeof(data[info_type]), NULL);
+		zassert_equal(mmsg.size, sizeof(data[info_type]));
 		k_mbox_data_get(&mmsg, rxdata);
 		zassert_true(memcmp(rxdata, data[info_type], MAIL_LEN) == 0,
 			     NULL);

tests/kernel/mem_heap/mheap_api_concept/src/test_mheap_api.c

@@ -133,7 +133,7 @@ ZTEST(mheap_api, test_mheap_calloc)
 
 	/* Memory should be zeroed and not crash us if we read/write to it */
 	for (int i = 0; i < BOUNDS; i++) {
-		zassert_equal(mem[i], 0, NULL);
+		zassert_equal(mem[i], 0);
 		mem[i] = 1;
 	}
 

tests/kernel/mem_heap/mheap_api_concept/src/test_mheap_concept.c

@@ -42,7 +42,7 @@ ZTEST(mheap_api, test_mheap_malloc_align4)
 	for (int i = 0; i < BLK_NUM_MAX; i++) {
 		block[i] = k_malloc(i);
 		zassert_not_null(block[i], NULL);
-		zassert_false((uintptr_t)block[i] % sizeof(void *), NULL);
+		zassert_false((uintptr_t)block[i] % sizeof(void *));
 	}
 
 	/* test case tear down*/

tests/kernel/mem_protect/futex/src/main.c

@@ -460,14 +460,14 @@ static void futex_wait_wake(void *p1, void *p2, void *p3)
 	 * Use assertion to verify k_futex_wait() returns 0
 	 */
 	ret_value = k_futex_wait(&simple_futex, 13, K_FOREVER);
-	zassert_equal(ret_value, 0, NULL);
+	zassert_equal(ret_value, 0);
 
 	/* Test user thread can make wake without error
 	 * Use assertion to verify k_futex_wake() returns 1,
 	 * because only 1 thread wakes
 	 */
 	ret_value = k_futex_wake(&simple_futex, false);
-	zassert_equal(ret_value, 1, NULL);
+	zassert_equal(ret_value, 1);
 }
 
 static void futex_wake(void *p1, void *p2, void *p3)
@@ -478,7 +478,7 @@ static void futex_wake(void *p1, void *p2, void *p3)
 	k_futex_wake(&simple_futex, false);
 
 	ret_value = k_futex_wait(&simple_futex, 13, K_FOREVER);
-	zassert_equal(ret_value, 0, NULL);
+	zassert_equal(ret_value, 0);
 
 	/* Test user can write to the futex value
 	 * Use assertion to verify subtraction correctness
@@ -486,7 +486,7 @@ static void futex_wake(void *p1, void *p2, void *p3)
 	 */
 	atomic_sub(&simple_futex.val, 1);
 	atomic_ret_val = atomic_get(&simple_futex.val);
-	zassert_equal(atomic_ret_val, 12, NULL);
+	zassert_equal(atomic_ret_val, 12);
 }
 
 /**

tests/kernel/mem_protect/mem_protect/src/kobject.c

@@ -1040,12 +1040,12 @@ static void thread_stack_init_objects(void *p1, void *p2, void *p3)
 	/* check that thread is initialized when running */
 	ko = z_object_find(&child_thread);
 	ret = z_object_validate(ko, K_OBJ_ANY, _OBJ_INIT_TRUE);
-	zassert_equal(ret, _OBJ_INIT_TRUE, NULL);
+	zassert_equal(ret, _OBJ_INIT_TRUE);
 
 	/* check that stack is initialized when running */
 	ko = z_object_find(child_stack);
 	ret = z_object_validate(ko, K_OBJ_ANY, _OBJ_INIT_TRUE);
-	zassert_equal(ret, _OBJ_INIT_TRUE, NULL);
+	zassert_equal(ret, _OBJ_INIT_TRUE);
 }
 
 /**
@@ -1078,12 +1078,12 @@ ZTEST(mem_protect_kobj, test_mark_thread_exit_uninitialized)
 	/* check thread is uninitialized after its exit */
 	ko = z_object_find(&child_thread);
 	ret = z_object_validate(ko, K_OBJ_ANY, _OBJ_INIT_FALSE);
-	zassert_equal(ret, _OBJ_INIT_FALSE, NULL);
+	zassert_equal(ret, _OBJ_INIT_FALSE);
 
 	/* check stack is uninitialized after thread exit */
 	ko = z_object_find(child_stack);
 	ret = z_object_validate(ko, K_OBJ_ANY, _OBJ_INIT_FALSE);
-	zassert_equal(ret, _OBJ_INIT_FALSE, NULL);
+	zassert_equal(ret, _OBJ_INIT_FALSE);
 }
 
 /****************************************************************************/

tests/kernel/mem_protect/mem_protect/src/mem_partition.c

@@ -27,19 +27,19 @@ ZTEST_USER(mem_protect_part, test_mem_part_assign_bss_vars_zero)
 	/* The global variable var will be inside the bounds of
 	 * ztest_mem_partition and be initialized with 1356 at boot.
 	 */
-	zassert_true(var == 1356, NULL);
+	zassert_true(var == 1356);
 
 	/* The global variable zeroed_var will be inside the bounds of
 	 * ztest_mem_partition and must be zeroed at boot size K_APP_BMEM() was
 	 * used, indicating a BSS variable.
 	 */
-	zassert_true(zeroed_var == 0, NULL);
+	zassert_true(zeroed_var == 0);
 
 	/* The global variable var will be inside the bounds of
 	 * ztest_mem_partition and must be zeroed at boot size K_APP_BMEM() was
 	 * used, indicating a BSS variable.
 	 */
-	zassert_true(bss_var == 0, NULL);
+	zassert_true(bss_var == 0);
 }
 
 K_APPMEM_PARTITION_DEFINE(part_arch);
@@ -59,7 +59,7 @@ K_APP_BMEM(part_arch) uint8_t __aligned(MEM_REGION_ALLOC)
  */
 ZTEST(mem_protect_part, test_mem_part_auto_determ_size)
 {
-	zassert_true(part_arch.size == MEM_REGION_ALLOC, NULL);
+	zassert_true(part_arch.size == MEM_REGION_ALLOC);
 	zassert_true(part_arch.start == (uintptr_t)buf_arc,
 	   "Base address of memory partition not determined at build time");
 }

tests/kernel/mem_protect/obj_validation/src/main.c

@@ -86,9 +86,9 @@ ZTEST(object_validation, test_generic_object)
 	struct k_sem stack_sem;
 
 	/* None of these should be even in the table */
-	zassert_false(test_object(&stack_sem, -EBADF), NULL);
+	zassert_false(test_object(&stack_sem, -EBADF));
-	zassert_false(test_object((struct k_sem *)&bad_sem, -EBADF), NULL);
+	zassert_false(test_object((struct k_sem *)&bad_sem, -EBADF));
-	zassert_false(test_object((struct k_sem *)0xFFFFFFFF, -EBADF), NULL);
+	zassert_false(test_object((struct k_sem *)0xFFFFFFFF, -EBADF));
 	object_permission_checks(&sem3, false);
 	object_permission_checks(&sem1, true);
 	object_permission_checks(&sem2, false);
@@ -106,11 +106,11 @@ ZTEST(object_validation, test_generic_object)
 	/* dynamic object table well-populated with semaphores at this point */
 	for (int i = 0; i < SEM_ARRAY_SIZE; i++) {
 		/* Should have permission granted but be uninitialized */
-		zassert_false(test_object(dyn_sem[i], -EINVAL), NULL);
+		zassert_false(test_object(dyn_sem[i], -EINVAL));
 		k_object_access_revoke(dyn_sem[i], k_current_get());
 		object_permission_checks(dyn_sem[i], false);
 		k_object_free(dyn_sem[i]);
-		zassert_false(test_object(dyn_sem[i], -EBADF), NULL);
+		zassert_false(test_object(dyn_sem[i], -EBADF));
 	}
 }
 

tests/kernel/mem_protect/stackprot/src/main.c

@@ -112,7 +112,7 @@ static struct k_thread alt_thread_data;
  */
 ZTEST_USER(stackprot, test_stackprot)
 {
-	zassert_true(ret == TC_PASS, NULL);
+	zassert_true(ret == TC_PASS);
 	print_loop(__func__);
 }
 

tests/kernel/mem_slab/mslab_api/src/test_mslab_api.c

@@ -62,7 +62,7 @@ static void tmslab_alloc_align(void *data)
 		 * TESTPOINT: To ensure that each memory block is similarly
 		 * aligned to this boundary
 		 */
-		zassert_true((uintptr_t)block[i] % BLK_ALIGN == 0U, NULL);
+		zassert_true((uintptr_t)block[i] % BLK_ALIGN == 0U);
 	}
 	for (int i = 0; i < BLK_NUM; i++) {
 		k_mem_slab_free(pslab, &block[i]);
@@ -89,16 +89,16 @@ static void tmslab_alloc_timeout(void *data)
 	err = k_mem_slab_alloc(pslab, &block_fail, K_MSEC(TIMEOUT));
 	if (IS_ENABLED(CONFIG_MULTITHREADING)) {
 		/* TESTPOINT: -EAGAIN Waiting period timed out*/
-		zassert_equal(err, -EAGAIN, NULL);
+		zassert_equal(err, -EAGAIN);
 		/*
 		 * TESTPOINT: timeout Maximum time to wait for operation to
 		 * complete (in milliseconds)
 		 */
-		zassert_true(k_uptime_delta(&tms) >= TIMEOUT, NULL);
+		zassert_true(k_uptime_delta(&tms) >= TIMEOUT);
 	} else {
 		/* If no multithreading any timeout is treated as K_NO_WAIT */
-		zassert_equal(err, -ENOMEM, NULL);
+		zassert_equal(err, -ENOMEM);
-		zassert_true(k_uptime_delta(&tms) < TIMEOUT, NULL);
+		zassert_true(k_uptime_delta(&tms) < TIMEOUT);
 	}
 
 	for (int i = 0; i < BLK_NUM; i++) {
@@ -115,30 +115,30 @@ static void tmslab_used_get(void *data)
 		zassert_true(k_mem_slab_alloc(pslab, &block[i], K_NO_WAIT) == 0,
 			     NULL);
 		/* TESTPOINT: Get the number of used blocks in a memory slab.*/
-		zassert_equal(k_mem_slab_num_used_get(pslab), i + 1, NULL);
+		zassert_equal(k_mem_slab_num_used_get(pslab), i + 1);
 		/*
 		 * TESTPOINT: Get the number of unused blocks in a memory slab.
 		 */
-		zassert_equal(k_mem_slab_num_free_get(pslab), BLK_NUM - 1 - i, NULL);
+		zassert_equal(k_mem_slab_num_free_get(pslab), BLK_NUM - 1 - i);
 	}
 
 	zassert_equal(k_mem_slab_alloc(pslab, &block_fail, K_NO_WAIT), -ENOMEM,
 		      NULL);
 	/* free get on allocation failure*/
-	zassert_equal(k_mem_slab_num_free_get(pslab), 0, NULL);
+	zassert_equal(k_mem_slab_num_free_get(pslab), 0);
 	/* used get on allocation failure*/
-	zassert_equal(k_mem_slab_num_used_get(pslab), BLK_NUM, NULL);
+	zassert_equal(k_mem_slab_num_used_get(pslab), BLK_NUM);
 
 	zassert_equal(k_mem_slab_alloc(pslab, &block_fail, K_MSEC(TIMEOUT)),
 		      IS_ENABLED(CONFIG_MULTITHREADING) ? -EAGAIN : -ENOMEM,
 		      NULL);
-	zassert_equal(k_mem_slab_num_free_get(pslab), 0, NULL);
+	zassert_equal(k_mem_slab_num_free_get(pslab), 0);
-	zassert_equal(k_mem_slab_num_used_get(pslab), BLK_NUM, NULL);
+	zassert_equal(k_mem_slab_num_used_get(pslab), BLK_NUM);
 
 	for (int i = 0; i < BLK_NUM; i++) {
 		k_mem_slab_free(pslab, &block[i]);
-		zassert_equal(k_mem_slab_num_free_get(pslab), i + 1, NULL);
+		zassert_equal(k_mem_slab_num_free_get(pslab), i + 1);
-		zassert_equal(k_mem_slab_num_used_get(pslab), BLK_NUM - 1 - i, NULL);
+		zassert_equal(k_mem_slab_num_used_get(pslab), BLK_NUM - 1 - i);
 	}
 }
 
@@ -199,8 +199,8 @@ ZTEST(mslab_api, test_mslab_kinit)
 	zassert_equal(k_mem_slab_init(&mslab, tslab, BLK_SIZE + 1, BLK_NUM),
 				-EINVAL, NULL);
 	k_mem_slab_init(&mslab, tslab, BLK_SIZE, BLK_NUM);
-	zassert_equal(k_mem_slab_num_used_get(&mslab), 0, NULL);
+	zassert_equal(k_mem_slab_num_used_get(&mslab), 0);
-	zassert_equal(k_mem_slab_num_free_get(&mslab), BLK_NUM, NULL);
+	zassert_equal(k_mem_slab_num_free_get(&mslab), BLK_NUM);
 }
 
 /**
@@ -214,8 +214,8 @@ ZTEST(mslab_api, test_mslab_kinit)
  */
 ZTEST(mslab_api, test_mslab_kdefine)
 {
-	zassert_equal(k_mem_slab_num_used_get(&kmslab), 0, NULL);
+	zassert_equal(k_mem_slab_num_used_get(&kmslab), 0);
-	zassert_equal(k_mem_slab_num_free_get(&kmslab), BLK_NUM, NULL);
+	zassert_equal(k_mem_slab_num_free_get(&kmslab), BLK_NUM);
 }
 
 /**

tests/kernel/mem_slab/mslab_concept/src/test_mslab_alloc_wait.c

@@ -29,7 +29,7 @@ void tmslab_alloc_wait_timeout(void *p1, void *p2, void *p3)
 
 void tmslab_alloc_wait_ok(void *p1, void *p2, void *p3)
 {
-	zassert_true(k_mem_slab_alloc(&mslab1, &block_ok, TIMEOUT) == 0, NULL);
+	zassert_true(k_mem_slab_alloc(&mslab1, &block_ok, TIMEOUT) == 0);
 	k_sem_give(&sync_sema);
 }
 

tests/kernel/msgq/msgq_api/src/test_msgq_attrs.c

@@ -16,24 +16,24 @@ static void attrs_get(struct k_msgq *q)
 	struct k_msgq_attrs attrs;
 
 	k_msgq_get_attrs(q, &attrs);
-	zassert_equal(attrs.used_msgs, 0, NULL);
+	zassert_equal(attrs.used_msgs, 0);
 
 	/*fill the queue to full*/
 	for (int i = 0; i < MSGQ_LEN; i++) {
 		ret = k_msgq_put(q, (void *)&send_buf[i], K_NO_WAIT);
-		zassert_equal(ret, 0, NULL);
+		zassert_equal(ret, 0);
 	}
 
 	k_msgq_get_attrs(q, &attrs);
-	zassert_equal(attrs.used_msgs, MSGQ_LEN, NULL);
+	zassert_equal(attrs.used_msgs, MSGQ_LEN);
 
 	for (int i = 0; i < MSGQ_LEN; i++) {
 		ret = k_msgq_get(q, (void *)&rec_buf[i], K_NO_WAIT);
-		zassert_equal(ret, 0, NULL);
+		zassert_equal(ret, 0);
 	}
 
 	k_msgq_get_attrs(q, &attrs);
-	zassert_equal(attrs.used_msgs, 0, NULL);
+	zassert_equal(attrs.used_msgs, 0);
 }
 
 /**
@@ -65,7 +65,7 @@ ZTEST_USER(msgq_api, test_msgq_user_attrs_get)
 
 	q = k_object_alloc(K_OBJ_MSGQ);
 	zassert_not_null(q, "couldn't alloc message queue");
-	zassert_false(k_msgq_alloc_init(q, MSG_SIZE, MSGQ_LEN), NULL);
+	zassert_false(k_msgq_alloc_init(q, MSG_SIZE, MSGQ_LEN));
 	attrs_get(q);
 }
 #endif

tests/kernel/msgq/msgq_api/src/test_msgq_contexts.c

@@ -29,21 +29,21 @@ static void put_msgq(struct k_msgq *pmsgq)
 
 	for (int i = 0; i < MSGQ_LEN; i++) {
 		ret = k_msgq_put(pmsgq, (void *)&data[i], K_NO_WAIT);
-		zassert_equal(ret, 0, NULL);
+		zassert_equal(ret, 0);
 
 		/**TESTPOINT: Check if k_msgq_peek reads msgq
 		 * in FIFO manner.
 		 * Everytime msg is enqueued, msg read should
 		 * always be the first message
 		 */
-		zassert_equal(k_msgq_peek(pmsgq, &read_data), 0, NULL);
+		zassert_equal(k_msgq_peek(pmsgq, &read_data), 0);
-		zassert_equal(read_data, data[0], NULL);
+		zassert_equal(read_data, data[0]);
 
 		/**TESTPOINT: msgq free get*/
 		zassert_equal(k_msgq_num_free_get(pmsgq),
 				MSGQ_LEN - 1 - i, NULL);
 		/**TESTPOINT: msgq used get*/
-		zassert_equal(k_msgq_num_used_get(pmsgq), i + 1, NULL);
+		zassert_equal(k_msgq_num_used_get(pmsgq), i + 1);
 	}
 }
 
@@ -53,16 +53,16 @@ static void get_msgq(struct k_msgq *pmsgq)
 	int ret;
 
 	for (int i = 0; i < MSGQ_LEN; i++) {
-		zassert_equal(k_msgq_peek(pmsgq, &read_data), 0, NULL);
+		zassert_equal(k_msgq_peek(pmsgq, &read_data), 0);
 
 		ret = k_msgq_get(pmsgq, &rx_data, K_FOREVER);
-		zassert_equal(ret, 0, NULL);
+		zassert_equal(ret, 0);
-		zassert_equal(rx_data, data[i], NULL);
+		zassert_equal(rx_data, data[i]);
 
 		/**TESTPOINT: Check if msg read is the msg deleted*/
-		zassert_equal(read_data, rx_data, NULL);
+		zassert_equal(read_data, rx_data);
 		/**TESTPOINT: msgq free get*/
-		zassert_equal(k_msgq_num_free_get(pmsgq), i + 1, NULL);
+		zassert_equal(k_msgq_num_free_get(pmsgq), i + 1);
 		/**TESTPOINT: msgq used get*/
 		zassert_equal(k_msgq_num_used_get(pmsgq),
 				MSGQ_LEN - 1 - i, NULL);
@@ -74,9 +74,9 @@ static void purge_msgq(struct k_msgq *pmsgq)
 	uint32_t read_data;
 
 	k_msgq_purge(pmsgq);
-	zassert_equal(k_msgq_num_free_get(pmsgq), MSGQ_LEN, NULL);
+	zassert_equal(k_msgq_num_free_get(pmsgq), MSGQ_LEN);
-	zassert_equal(k_msgq_num_used_get(pmsgq), 0, NULL);
+	zassert_equal(k_msgq_num_used_get(pmsgq), 0);
-	zassert_equal(k_msgq_peek(pmsgq, &read_data), -ENOMSG, NULL);
+	zassert_equal(k_msgq_peek(pmsgq, &read_data), -ENOMSG);
 }
 
 static void tisr_entry(const void *p)
@@ -113,11 +113,11 @@ static void thread_entry_overflow(void *p1, void *p2, void *p3)
 
 	ret = k_msgq_get(p1, &rx_buf[0], K_FOREVER);
 
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
 
 	ret = k_msgq_get(p1, &rx_buf[1], K_FOREVER);
 
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
 
 	k_sem_give(&end_sema);
 }
@@ -128,7 +128,7 @@ static void msgq_thread_overflow(struct k_msgq *pmsgq)
 
 	ret = k_msgq_put(pmsgq, (void *)&data[0], K_FOREVER);
 
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
 
 	/**TESTPOINT: thread-thread data passing via message queue*/
 	k_tid_t tid = k_thread_create(&tdata, tstack, STACK_SIZE,
@@ -138,7 +138,7 @@ static void msgq_thread_overflow(struct k_msgq *pmsgq)
 
 	ret = k_msgq_put(pmsgq, (void *)&data[1], K_FOREVER);
 
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
 
 	k_sem_take(&end_sema, K_FOREVER);
 	k_thread_abort(tid);
@@ -174,7 +174,7 @@ static void pend_thread_entry(void *p1, void *p2, void *p3)
 	int ret;
 
 	ret = k_msgq_put(p1, &data[1], TIMEOUT);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
 }
 
 static void msgq_thread_data_passing(struct k_msgq *pmsgq)
@@ -217,7 +217,7 @@ static void get_empty_entry(void *p1, void *p2, void *p3)
 	k_sem_give(&end_sema);
 	/* blocked forever */
 	ret = k_msgq_get(p1, rx_buf, K_FOREVER);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
 }
 
 static void put_full_entry(void *p1, void *p2, void *p3)
@@ -225,8 +225,8 @@ static void put_full_entry(void *p1, void *p2, void *p3)
 	int ret;
 
 	/* make sure the queue is full */
-	zassert_equal(k_msgq_num_free_get(p1), 0, NULL);
+	zassert_equal(k_msgq_num_free_get(p1), 0);
-	zassert_equal(k_msgq_num_used_get(p1), 1, NULL);
+	zassert_equal(k_msgq_num_used_get(p1), 1);
 
 	ret = k_msgq_put(p1, &data[1], K_NO_WAIT);
 	zassert_equal(ret, -ENOMSG, "Put message to full queue");
@@ -238,7 +238,7 @@ static void put_full_entry(void *p1, void *p2, void *p3)
 	k_sem_give(&end_sema);
 	/* blocked forever */
 	ret = k_msgq_put(p1, &data[1], K_FOREVER);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
 }
 
 /**
@@ -257,7 +257,7 @@ ZTEST(msgq_api_1cpu, test_msgq_thread)
 	/**TESTPOINT: init via k_msgq_init*/
 	k_msgq_init(&msgq, tbuffer, MSG_SIZE, MSGQ_LEN);
 	ret = k_sem_init(&end_sema, 0, 1);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
 
 	msgq_thread(&msgq);
 	msgq_thread(&kmsgq);
@@ -274,10 +274,10 @@ ZTEST(msgq_api, test_msgq_thread_overflow)
 	/**TESTPOINT: init via k_msgq_init*/
 	k_msgq_init(&msgq, tbuffer, MSG_SIZE, 2);
 	ret = k_sem_init(&end_sema, 0, 1);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
 
 	ret = k_msgq_put(&msgq, (void *)&data[0], K_FOREVER);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
 
 	msgq_thread_overflow(&msgq);
 	msgq_thread_overflow(&kmsgq);
@@ -299,9 +299,9 @@ ZTEST_USER(msgq_api, test_msgq_user_thread)
 
 	q = k_object_alloc(K_OBJ_MSGQ);
 	zassert_not_null(q, "couldn't alloc message queue");
-	zassert_false(k_msgq_alloc_init(q, MSG_SIZE, MSGQ_LEN), NULL);
+	zassert_false(k_msgq_alloc_init(q, MSG_SIZE, MSGQ_LEN));
 	ret = k_sem_init(&end_sema, 0, 1);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
 
 	msgq_thread(q);
 }
@@ -317,9 +317,9 @@ ZTEST_USER(msgq_api, test_msgq_user_thread_overflow)
 
 	q = k_object_alloc(K_OBJ_MSGQ);
 	zassert_not_null(q, "couldn't alloc message queue");
-	zassert_false(k_msgq_alloc_init(q, MSG_SIZE, 1), NULL);
+	zassert_false(k_msgq_alloc_init(q, MSG_SIZE, 1));
 	ret = k_sem_init(&end_sema, 0, 1);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
 
 	msgq_thread_overflow(q);
 }
@@ -350,7 +350,7 @@ ZTEST(msgq_api_1cpu, test_msgq_pend_thread)
 
 	k_msgq_init(&msgq1, tbuffer1, MSG_SIZE, 1);
 	ret = k_sem_init(&end_sema, 0, 1);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
 
 	msgq_thread_data_passing(&msgq1);
 }
@@ -397,7 +397,7 @@ ZTEST(msgq_api_1cpu, test_msgq_empty)
 
 	k_msgq_init(&msgq1, tbuffer1, MSG_SIZE, 1);
 	ret = k_sem_init(&end_sema, 0, 1);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
 
 	k_tid_t tid = k_thread_create(&tdata2, tstack2, STACK_SIZE,
 				      get_empty_entry, &msgq1, NULL,
@@ -405,16 +405,16 @@ ZTEST(msgq_api_1cpu, test_msgq_empty)
 
 	k_sem_take(&end_sema, K_FOREVER);
 	/* that getting thread is being blocked now */
-	zassert_equal(tid->base.thread_state, _THREAD_PENDING, NULL);
+	zassert_equal(tid->base.thread_state, _THREAD_PENDING);
 	/* since there is a thread is waiting for message, this queue
 	 * can't be cleanup
 	 */
 	ret = k_msgq_cleanup(&msgq1);
-	zassert_equal(ret, -EBUSY, NULL);
+	zassert_equal(ret, -EBUSY);
 
 	/* put a message to wake that getting thread */
 	ret = k_msgq_put(&msgq1, &data[0], K_NO_WAIT);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
 
 	k_thread_abort(tid);
 }
@@ -437,17 +437,17 @@ ZTEST(msgq_api_1cpu, test_msgq_full)
 
 	k_msgq_init(&msgq1, tbuffer1, MSG_SIZE, 1);
 	ret = k_sem_init(&end_sema, 0, 1);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
 
 	ret = k_msgq_put(&msgq1, &data[0], K_NO_WAIT);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
 
 	k_tid_t tid = k_thread_create(&tdata2, tstack2, STACK_SIZE,
 					put_full_entry, &msgq1, NULL,
 					NULL, pri, 0, K_NO_WAIT);
 	k_sem_take(&end_sema, K_FOREVER);
 	/* that putting thread is being blocked now */
-	zassert_equal(tid->base.thread_state, _THREAD_PENDING, NULL);
+	zassert_equal(tid->base.thread_state, _THREAD_PENDING);
 	k_thread_abort(tid);
 }
 

tests/kernel/msgq/msgq_api/src/test_msgq_fail.c

@@ -13,15 +13,15 @@ static void put_fail(struct k_msgq *q)
 {
 	int ret = k_msgq_put(q, (void *)&data[0], K_NO_WAIT);
 
-	zassert_false(ret, NULL);
+	zassert_false(ret);
 	ret = k_msgq_put(q, (void *)&data[0], K_NO_WAIT);
-	zassert_false(ret, NULL);
+	zassert_false(ret);
 	/**TESTPOINT: msgq put returns -ENOMSG*/
 	ret = k_msgq_put(q, (void *)&data[1], K_NO_WAIT);
-	zassert_equal(ret, -ENOMSG, NULL);
+	zassert_equal(ret, -ENOMSG);
 	/**TESTPOINT: msgq put returns -EAGAIN*/
 	ret = k_msgq_put(q, (void *)&data[0], TIMEOUT);
-	zassert_equal(ret, -EAGAIN, NULL);
+	zassert_equal(ret, -EAGAIN);
 
 	k_msgq_purge(q);
 }
@@ -33,10 +33,10 @@ static void get_fail(struct k_msgq *q)
 	/**TESTPOINT: msgq get returns -ENOMSG*/
 	int ret = k_msgq_get(q, &rx_data, K_NO_WAIT);
 
-	zassert_equal(ret, -ENOMSG, NULL);
+	zassert_equal(ret, -ENOMSG);
 	/**TESTPOINT: msgq get returns -EAGAIN*/
 	ret = k_msgq_get(q, &rx_data, TIMEOUT);
-	zassert_equal(ret, -EAGAIN, NULL);
+	zassert_equal(ret, -EAGAIN);
 }
 
 /**
@@ -65,7 +65,7 @@ ZTEST_USER(msgq_api, test_msgq_user_put_fail)
 
 	q = k_object_alloc(K_OBJ_MSGQ);
 	zassert_not_null(q, "couldn't alloc message queue");
-	zassert_false(k_msgq_alloc_init(q, MSG_SIZE, MSGQ_LEN), NULL);
+	zassert_false(k_msgq_alloc_init(q, MSG_SIZE, MSGQ_LEN));
 	put_fail(q);
 }
 #endif /* CONFIG_USERSPACE */
@@ -91,7 +91,7 @@ ZTEST_USER(msgq_api, test_msgq_user_get_fail)
 
 	q = k_object_alloc(K_OBJ_MSGQ);
 	zassert_not_null(q, "couldn't alloc message queue");
-	zassert_false(k_msgq_alloc_init(q, MSG_SIZE, MSGQ_LEN), NULL);
+	zassert_false(k_msgq_alloc_init(q, MSG_SIZE, MSGQ_LEN));
 	get_fail(q);
 }
 #endif /* CONFIG_USERSPACE */

tests/kernel/msgq/msgq_api/src/test_msgq_purge.c

@@ -16,7 +16,7 @@ static void tThread_entry(void *p1, void *p2, void *p3)
 {
 	int ret = k_msgq_put((struct k_msgq *)p1, (void *)&data[0], TIMEOUT);
 
-	zassert_equal(ret, -ENOMSG, NULL);
+	zassert_equal(ret, -ENOMSG);
 }
 
 static void purge_when_put(struct k_msgq *q)
@@ -26,7 +26,7 @@ static void purge_when_put(struct k_msgq *q)
 	/*fill the queue to full*/
 	for (int i = 0; i < MSGQ_LEN; i++) {
 		ret = k_msgq_put(q, (void *)&data[i], K_NO_WAIT);
-		zassert_equal(ret, 0, NULL);
+		zassert_equal(ret, 0);
 	}
 	/*create another thread waiting to put msg*/
 	k_thread_create(&tdata, tstack, STACK_SIZE,
@@ -40,7 +40,7 @@ static void purge_when_put(struct k_msgq *q)
 	/*verify msg put after purge*/
 	for (int i = 0; i < MSGQ_LEN; i++) {
 		ret = k_msgq_put(q, (void *)&data[i], K_NO_WAIT);
-		zassert_equal(ret, 0, NULL);
+		zassert_equal(ret, 0);
 	}
 
 	k_thread_abort(&tdata);
@@ -73,7 +73,7 @@ ZTEST_USER(msgq_api, test_msgq_user_purge_when_put)
 
 	q = k_object_alloc(K_OBJ_MSGQ);
 	zassert_not_null(q, "couldn't alloc message queue");
-	zassert_false(k_msgq_alloc_init(q, MSG_SIZE, MSGQ_LEN), NULL);
+	zassert_false(k_msgq_alloc_init(q, MSG_SIZE, MSGQ_LEN));
 
 	purge_when_put(q);
 }

tests/kernel/msgq/msgq_usage/src/main.c

@@ -194,13 +194,13 @@ static void client_entry(void *p1, void *p2, void *p3)
 	/* query services */
 	k_msgq_put(&manager_q, client_data, K_NO_WAIT);
 	ret = k_msgq_get(&client_msgq, service_data, K_FOREVER);
-	zassert_equal(ret, 0, NULL);
+	zassert_equal(ret, 0);
 
 	service1q = (struct k_msgq *)service_data[0];
 	service2q = (struct k_msgq *)service_data[1];
 	/* all services should be running */
-	zassert_equal(service1q, &service1_msgq, NULL);
+	zassert_equal(service1q, &service1_msgq);
-	zassert_equal(service2q, &service2_msgq, NULL);
+	zassert_equal(service2q, &service2_msgq);
 	/* let the test thread continue */
 	k_sem_give(&test_continue);
 

tests/kernel/mutex/mutex_api/src/test_mutex_apis.c

@@ -35,7 +35,7 @@ static void tThread_entry_lock_forever(void *p1, void *p2, void *p3)
 
 static void tThread_entry_lock_no_wait(void *p1, void *p2, void *p3)
 {
-	zassert_true(k_mutex_lock((struct k_mutex *)p1, K_NO_WAIT) != 0, NULL);
+	zassert_true(k_mutex_lock((struct k_mutex *)p1, K_NO_WAIT) != 0);
 	TC_PRINT("bypass locked resource from spawn thread\n");
 }
 
@@ -62,7 +62,7 @@ static void tmutex_test_lock(struct k_mutex *pmutex,
 			entry_fn, pmutex, NULL, NULL,
 			K_PRIO_PREEMPT(0),
 			K_USER | K_INHERIT_PERMS, K_NO_WAIT);
-	zassert_true(k_mutex_lock(pmutex, K_FOREVER) == 0, NULL);
+	zassert_true(k_mutex_lock(pmutex, K_FOREVER) == 0);
 	TC_PRINT("access resource from main thread\n");
 
 	/* wait for spawn thread to take action */
@@ -78,7 +78,7 @@ static void tmutex_test_lock_timeout(struct k_mutex *pmutex,
 			entry_fn, pmutex, NULL, NULL,
 			K_PRIO_PREEMPT(0),
 			K_USER | K_INHERIT_PERMS, K_NO_WAIT);
-	zassert_true(k_mutex_lock(pmutex, K_FOREVER) == 0, NULL);
+	zassert_true(k_mutex_lock(pmutex, K_FOREVER) == 0);
 	TC_PRINT("access resource from main thread\n");
 
 	/* wait for spawn thread to take action */

tests/kernel/mutex/mutex_error_case/src/test_mutex_error.c

@@ -42,7 +42,7 @@ void ztest_post_fatal_error_hook(unsigned int reason,
 
 {
 	/* check if expected error */
-	zassert_equal(reason, K_ERR_KERNEL_OOPS, NULL);
+	zassert_equal(reason, K_ERR_KERNEL_OOPS);
 }
 
 static void tThread_entry_negative(void *p1, void *p2, void *p3)

tests/kernel/mutex/sys_mutex/src/main.c

@@ -343,7 +343,7 @@ ZTEST_USER_OR_NOT(mutex_complex, test_mutex)
 			      priority[i], rv);
 
 		/* Catch any errors from other threads */
-		zassert_equal(tc_rc, TC_PASS, NULL);
+		zassert_equal(tc_rc, TC_PASS);
 	}
 
 	/* ~ 4 seconds have passed */
@@ -375,7 +375,7 @@ ZTEST_USER_OR_NOT(mutex_complex, test_mutex)
 			      droppri[i], rv);
 		sys_mutex_unlock(givemutex[i]);
 
-		zassert_equal(tc_rc, TC_PASS, NULL);
+		zassert_equal(tc_rc, TC_PASS);
 	}
 
 	rv = k_thread_priority_get(k_current_get());
@@ -383,7 +383,7 @@ ZTEST_USER_OR_NOT(mutex_complex, test_mutex)
 
 	k_sleep(K_SECONDS(1));     /* Give thread_11 time to run */
 
-	zassert_equal(tc_rc, TC_PASS, NULL);
+	zassert_equal(tc_rc, TC_PASS);
 
 	/* test recursive locking using a private mutex */
 

tests/kernel/pipe/pipe_api/src/test_pipe_contexts.c

@@ -54,7 +54,7 @@ static void tpipe_put(struct k_pipe *ppipe, k_timeout_t timeout)
 			BYTES_TO_WRITE : (PIPE_LEN - i);
 		zassert_false(k_pipe_put(ppipe, &data[i], to_wt,
 					 &wt_byte, 1, timeout), NULL);
-		zassert_true(wt_byte == to_wt || wt_byte == 1, NULL);
+		zassert_true(wt_byte == to_wt || wt_byte == 1);
 	}
 }
 
@@ -70,10 +70,10 @@ static void tpipe_get(struct k_pipe *ppipe, k_timeout_t timeout)
 			BYTES_TO_READ : (PIPE_LEN - i);
 		zassert_false(k_pipe_get(ppipe, &rx_data[i], to_rd,
 					 &rd_byte, 1, timeout), NULL);
-		zassert_true(rd_byte == to_rd || rd_byte == 1, NULL);
+		zassert_true(rd_byte == to_rd || rd_byte == 1);
 	}
 	for (int i = 0; i < PIPE_LEN; i++) {
-		zassert_equal(rx_data[i], data[i], NULL);
+		zassert_equal(rx_data[i], data[i]);
 	}
 }
 
@@ -131,7 +131,7 @@ static void tpipe_put_no_wait(struct k_pipe *ppipe)
 			BYTES_TO_WRITE : (PIPE_LEN - i);
 		zassert_false(k_pipe_put(ppipe, &data[i], to_wt,
 					&wt_byte, 1, K_NO_WAIT), NULL);
-		zassert_true(wt_byte == to_wt || wt_byte == 1, NULL);
+		zassert_true(wt_byte == to_wt || wt_byte == 1);
 	}
 }
 
@@ -188,12 +188,12 @@ ZTEST(pipe_api_1cpu, test_pipe_alloc)
 {
 	int ret;
 
-	zassert_false(k_pipe_alloc_init(&pipe_test_alloc, PIPE_LEN), NULL);
+	zassert_false(k_pipe_alloc_init(&pipe_test_alloc, PIPE_LEN));
 
 	tpipe_kthread_to_kthread(&pipe_test_alloc);
 	k_pipe_cleanup(&pipe_test_alloc);
 
-	zassert_false(k_pipe_alloc_init(&pipe_test_alloc, 0), NULL);
+	zassert_false(k_pipe_alloc_init(&pipe_test_alloc, 0));
 	k_pipe_cleanup(&pipe_test_alloc);
 
 	ret = k_pipe_alloc_init(&pipe_test_alloc, 2048);
@@ -210,7 +210,7 @@ ZTEST(pipe_api, test_pipe_cleanup)
 {
 	int ret;
 
-	zassert_false(k_pipe_alloc_init(&pipe_test_alloc, PIPE_LEN), NULL);
+	zassert_false(k_pipe_alloc_init(&pipe_test_alloc, PIPE_LEN));
 
 	/**TESTPOINT: test if a dynamically allocated buffer can be freed*/
 	ret = k_pipe_cleanup(&pipe_test_alloc);
@@ -222,7 +222,7 @@ ZTEST(pipe_api, test_pipe_cleanup)
 	zassert_true((ret == 0) && (kpipe.buffer != NULL),
 			"Static buffer should not be freed.");
 
-	zassert_false(k_pipe_alloc_init(&pipe_test_alloc, PIPE_LEN), NULL);
+	zassert_false(k_pipe_alloc_init(&pipe_test_alloc, PIPE_LEN));
 
 	k_tid_t tid = k_thread_create(&tdata, tstack, STACK_SIZE,
 			thread_for_get_forever, &pipe_test_alloc, NULL,
@@ -309,10 +309,10 @@ ZTEST_USER(pipe_api_1cpu, test_pipe_user_thread2thread)
 	/**TESTPOINT: test k_object_alloc pipe*/
 	struct k_pipe *p = k_object_alloc(K_OBJ_PIPE);
 
-	zassert_true(p != NULL, NULL);
+	zassert_true(p != NULL);
 
 	/**TESTPOINT: test k_pipe_alloc_init*/
-	zassert_false(k_pipe_alloc_init(p, PIPE_LEN), NULL);
+	zassert_false(k_pipe_alloc_init(p, PIPE_LEN));
 	tpipe_thread_thread(p);
 
 }
@@ -328,8 +328,8 @@ ZTEST(pipe_api, test_resource_pool_auto_free)
 	/* Pool has 2 blocks, both should succeed if kernel object and pipe
 	 * buffer are auto-freed when the allocating threads exit
 	 */
-	zassert_true(k_heap_alloc(&test_pool, 64, K_NO_WAIT) != NULL, NULL);
+	zassert_true(k_heap_alloc(&test_pool, 64, K_NO_WAIT) != NULL);
-	zassert_true(k_heap_alloc(&test_pool, 64, K_NO_WAIT) != NULL, NULL);
+	zassert_true(k_heap_alloc(&test_pool, 64, K_NO_WAIT) != NULL);
 }
 #endif
 
@@ -355,9 +355,9 @@ ZTEST(pipe_api, test_half_pipe_put_get)
 
 	/* TESTPOINT: min_xfer > bytes_to_read */
 	ret = k_pipe_put(&kpipe, &rx_data[0], 1, &rd_byte, 24, K_NO_WAIT);
-	zassert_true(ret == -EINVAL, NULL);
+	zassert_true(ret == -EINVAL);
 	ret = k_pipe_put(&kpipe, &rx_data[0], 24, NULL, 1, K_NO_WAIT);
-	zassert_true(ret == -EINVAL, NULL);
+	zassert_true(ret == -EINVAL);
 
 	/**TESTPOINT: thread-thread data passing via pipe*/
 	k_tid_t tid1 = k_thread_create(&tdata1, tstack1, STACK_SIZE,
@@ -386,9 +386,9 @@ ZTEST(pipe_api, test_pipe_get_put)
 
 	/* TESTPOINT: min_xfer > bytes_to_read */
 	ret = k_pipe_get(&kpipe, &rx_data[0], 1, &rd_byte, 24, K_NO_WAIT);
-	zassert_true(ret == -EINVAL, NULL);
+	zassert_true(ret == -EINVAL);
 	ret = k_pipe_get(&kpipe, &rx_data[0], 24, NULL, 1, K_NO_WAIT);
-	zassert_true(ret == -EINVAL, NULL);
+	zassert_true(ret == -EINVAL);
 
 	/**TESTPOINT: thread-thread data passing via pipe*/
 	k_tid_t tid1 = k_thread_create(&tdata1, tstack1, STACK_SIZE,

tests/kernel/pipe/pipe_api/src/test_pipe_fail.c

@@ -23,11 +23,11 @@ static void put_fail(struct k_pipe *p)
 	/**TESTPOINT: pipe put returns -EIO*/
 	zassert_equal(k_pipe_put(p, data, PIPE_LEN, &wt_byte,
 				 1, K_NO_WAIT), -EIO, NULL);
-	zassert_false(wt_byte, NULL);
+	zassert_false(wt_byte);
 	/**TESTPOINT: pipe put returns -EAGAIN*/
 	zassert_equal(k_pipe_put(p, data, PIPE_LEN, &wt_byte,
 				 1, TIMEOUT), -EAGAIN, NULL);
-	zassert_true(wt_byte < 1, NULL);
+	zassert_true(wt_byte < 1);
 	zassert_equal(k_pipe_put(p, data, PIPE_LEN, &wt_byte,
 				 PIPE_LEN + 1, TIMEOUT), -EINVAL, NULL);
 
@@ -54,12 +54,12 @@ ZTEST_USER(pipe_api_1cpu, test_pipe_user_put_fail)
 {
 	struct k_pipe *p = k_object_alloc(K_OBJ_PIPE);
 
-	zassert_true(p != NULL, NULL);
+	zassert_true(p != NULL);
-	zassert_false(k_pipe_alloc_init(p, PIPE_LEN), NULL);
+	zassert_false(k_pipe_alloc_init(p, PIPE_LEN));
 	/* check the number of bytes that may be read from pipe. */
-	zassert_equal(k_pipe_read_avail(p), 0, NULL);
+	zassert_equal(k_pipe_read_avail(p), 0);
 	/* check the number of bytes that may be written to pipe.*/
-	zassert_equal(k_pipe_write_avail(p), PIPE_LEN, NULL);
+	zassert_equal(k_pipe_write_avail(p), PIPE_LEN);
 
 	put_fail(p);
 }
@@ -73,11 +73,11 @@ static void get_fail(struct k_pipe *p)
 	/**TESTPOINT: pipe put returns -EIO*/
 	zassert_equal(k_pipe_get(p, rx_data, PIPE_LEN, &rd_byte, 1,
 				 K_NO_WAIT), -EIO, NULL);
-	zassert_false(rd_byte, NULL);
+	zassert_false(rd_byte);
 	/**TESTPOINT: pipe put returns -EAGAIN*/
 	zassert_equal(k_pipe_get(p, rx_data, PIPE_LEN, &rd_byte, 1,
 				 TIMEOUT), -EAGAIN, NULL);
-	zassert_true(rd_byte < 1, NULL);
+	zassert_true(rd_byte < 1);
 	zassert_equal(k_pipe_get(p, rx_data, PIPE_LEN, &rd_byte, 1,
 				 TIMEOUT), -EAGAIN, NULL);
 }
@@ -107,8 +107,8 @@ ZTEST_USER(pipe_api, test_pipe_user_get_fail)
 {
 	struct k_pipe *p = k_object_alloc(K_OBJ_PIPE);
 
-	zassert_true(p != NULL, NULL);
+	zassert_true(p != NULL);
-	zassert_false(k_pipe_alloc_init(p, PIPE_LEN), NULL);
+	zassert_false(k_pipe_alloc_init(p, PIPE_LEN));
 
 	get_fail(p);
 }
@@ -166,8 +166,8 @@ ZTEST_USER(pipe_api, test_pipe_get_unreach_data)
 	struct k_pipe *p = k_object_alloc(K_OBJ_PIPE);
 	size_t rd_byte = 0;
 
-	zassert_true(p != NULL, NULL);
+	zassert_true(p != NULL);
-	zassert_false(k_pipe_alloc_init(p, PIPE_LEN), NULL);
+	zassert_false(k_pipe_alloc_init(p, PIPE_LEN));
 
 	ztest_set_fault_valid(true);
 	k_pipe_get(p, user_unreach, PIPE_LEN,
@@ -190,8 +190,8 @@ ZTEST_USER(pipe_api, test_pipe_get_unreach_size)
 	struct k_pipe *p = k_object_alloc(K_OBJ_PIPE);
 	unsigned char rx_data[PIPE_LEN];
 
-	zassert_true(p != NULL, NULL);
+	zassert_true(p != NULL);
-	zassert_false(k_pipe_alloc_init(p, PIPE_LEN), NULL);
+	zassert_false(k_pipe_alloc_init(p, PIPE_LEN));
 
 	ztest_set_fault_valid(true);
 	k_pipe_get(p, rx_data, PIPE_LEN,
@@ -234,8 +234,8 @@ ZTEST_USER(pipe_api, test_pipe_put_unreach_data)
 	struct k_pipe *p = k_object_alloc(K_OBJ_PIPE);
 	size_t to_wt = 0, wt_byte = 0;
 
-	zassert_true(p != NULL, NULL);
+	zassert_true(p != NULL);
-	zassert_false(k_pipe_alloc_init(p, PIPE_LEN), NULL);
+	zassert_false(k_pipe_alloc_init(p, PIPE_LEN));
 
 	ztest_set_fault_valid(true);
 	k_pipe_put(p, &user_unreach[0], to_wt,
@@ -259,8 +259,8 @@ ZTEST_USER(pipe_api, test_pipe_put_unreach_size)
 	unsigned char tx_data = 0xa;
 	size_t to_wt = 0;
 
-	zassert_true(p != NULL, NULL);
+	zassert_true(p != NULL);
-	zassert_false(k_pipe_alloc_init(p, PIPE_LEN), NULL);
+	zassert_false(k_pipe_alloc_init(p, PIPE_LEN));
 
 	ztest_set_fault_valid(true);
 	k_pipe_put(p, &tx_data, to_wt,

tests/kernel/poll/src/test_poll.c

@@ -100,11 +100,11 @@ ZTEST_USER(poll_api_1cpu, test_poll_no_wait)
 	 * implementation
 	 */
 
-	zassert_equal(k_poll(events, INT_MAX, K_NO_WAIT), -EINVAL, NULL);
+	zassert_equal(k_poll(events, INT_MAX, K_NO_WAIT), -EINVAL);
-	zassert_equal(k_poll(events, 4096, K_NO_WAIT), -ENOMEM, NULL);
+	zassert_equal(k_poll(events, 4096, K_NO_WAIT), -ENOMEM);
 
 	/* Allow zero events */
-	zassert_equal(k_poll(events, 0, K_NO_WAIT), -EAGAIN, NULL);
+	zassert_equal(k_poll(events, 0, K_NO_WAIT), -EAGAIN);
 
 	struct k_poll_event bad_events[] = {
 		K_POLL_EVENT_INITIALIZER(K_POLL_TYPE_SEM_AVAILABLE,
@@ -126,9 +126,9 @@ ZTEST_USER(poll_api_1cpu, test_poll_no_wait)
 #endif /* CONFIG_USERSPACE */
 
 	/* test polling events that are already ready */
-	zassert_false(k_fifo_alloc_put(&no_wait_fifo, &msg), NULL);
+	zassert_false(k_fifo_alloc_put(&no_wait_fifo, &msg));
 	k_poll_signal_raise(&no_wait_signal, SIGNAL_RESULT);
-	zassert_false(k_msgq_put(mq, msgq_msg, K_NO_WAIT), NULL);
+	zassert_false(k_msgq_put(mq, msgq_msg, K_NO_WAIT));
 
 	zassert_equal(k_poll(events, ARRAY_SIZE(events), K_NO_WAIT), 0, "");
 
@@ -149,7 +149,7 @@ ZTEST_USER(poll_api_1cpu, test_poll_no_wait)
 	zassert_equal(events[3].state, K_POLL_STATE_NOT_READY, "");
 
 	zassert_equal(events[4].state, K_POLL_STATE_MSGQ_DATA_AVAILABLE, "");
-	zassert_false(k_msgq_get(mq, msgq_recv_buf, K_NO_WAIT), NULL);
+	zassert_false(k_msgq_get(mq, msgq_recv_buf, K_NO_WAIT));
 	zassert_false(memcmp(msgq_msg, msgq_recv_buf, MSGQ_MSG_SIZE), "");
 
 	/* verify events are not ready anymore (user has to clear them first) */
@@ -785,7 +785,7 @@ ZTEST(poll_api_1cpu, test_poll_zero_events)
 	k_poll_event_init(&event, K_POLL_TYPE_SEM_AVAILABLE,
 			  K_POLL_MODE_NOTIFY_ONLY, &zero_events_sem);
 
-	zassert_equal(k_poll(&event, 0, K_MSEC(50)), -EAGAIN, NULL);
+	zassert_equal(k_poll(&event, 0, K_MSEC(50)), -EAGAIN);
 }
 
 /* subthread entry */

tests/kernel/queue/src/test_queue_contexts.c

@@ -70,23 +70,23 @@ static void tqueue_get(struct k_queue *pqueue)
 	for (int i = 0; i < LIST_LEN; i++) {
 		/**TESTPOINT: queue get*/
 		rx_data = k_queue_get(pqueue, K_NO_WAIT);
-		zassert_equal(rx_data, (void *)&data_p[i], NULL);
+		zassert_equal(rx_data, (void *)&data_p[i]);
 	}
 	/*get queue data from "queue_append"*/
 	for (int i = 0; i < LIST_LEN; i++) {
 		/**TESTPOINT: queue get*/
 		rx_data = k_queue_get(pqueue, K_NO_WAIT);
-		zassert_equal(rx_data, (void *)&data[i], NULL);
+		zassert_equal(rx_data, (void *)&data[i]);
 	}
 	/*get queue data from "queue_append_list"*/
 	for (int i = 0; i < LIST_LEN; i++) {
 		rx_data = k_queue_get(pqueue, K_NO_WAIT);
-		zassert_equal(rx_data, (void *)&data_l[i], NULL);
+		zassert_equal(rx_data, (void *)&data_l[i]);
 	}
 	/*get queue data from "queue_merge_slist"*/
 	for (int i = 0; i < LIST_LEN; i++) {
 		rx_data = k_queue_get(pqueue, K_NO_WAIT);
-		zassert_equal(rx_data, (void *)&data_sl[i], NULL);
+		zassert_equal(rx_data, (void *)&data_sl[i]);
 	}
 }
 
@@ -260,7 +260,7 @@ static void tqueue_alloc(struct k_queue *pqueue)
 	k_queue_alloc_append(pqueue, (void *)&data_append);
 
 	/* Insertion fails and alloc returns NOMEM */
-	zassert_false(k_queue_remove(pqueue, &data_append), NULL);
+	zassert_false(k_queue_remove(pqueue, &data_append));
 
 	/* Assign resource pool of lower size */
 	k_thread_heap_assign(k_current_get(), &mem_pool_fail);
@@ -270,12 +270,12 @@ static void tqueue_alloc(struct k_queue *pqueue)
 	 */
 	k_queue_alloc_prepend(pqueue, (void *)&data_prepend);
 
-	zassert_false(k_queue_remove(pqueue, &data_prepend), NULL);
+	zassert_false(k_queue_remove(pqueue, &data_prepend));
 
 	/* No element must be present in the queue, as all
 	 * operations failed
 	 */
-	zassert_true(k_queue_is_empty(pqueue), NULL);
+	zassert_true(k_queue_is_empty(pqueue));
 
 	/* Assign resource pool of sufficient size */
 	k_thread_heap_assign(k_current_get(), &mem_pool_pass);
@@ -284,7 +284,7 @@ static void tqueue_alloc(struct k_queue *pqueue)
 		      NULL);
 
 	/* Now queue shouldn't be empty */
-	zassert_false(k_queue_is_empty(pqueue), NULL);
+	zassert_false(k_queue_is_empty(pqueue));
 
 	zassert_true(k_queue_get(pqueue, K_FOREVER) != NULL,
 		     NULL);
@@ -322,7 +322,7 @@ static void queue_poll_race_consume(void *p1, void *p2, void *p3)
 	int *count = p2;
 
 	while (true) {
-		zassert_true(k_queue_get(q, K_FOREVER) != NULL, NULL);
+		zassert_true(k_queue_get(q, K_FOREVER) != NULL);
 		*count += 1;
 	}
 }
@@ -361,12 +361,12 @@ ZTEST(queue_api_1cpu, test_queue_poll_race)
 	k_queue_append(&queue, &data[0]);
 	k_queue_append(&queue, &data[1]);
 
-	zassert_true(low_count == 0, NULL);
+	zassert_true(low_count == 0);
-	zassert_true(mid_count == 0, NULL);
+	zassert_true(mid_count == 0);
 
 	k_sleep(K_MSEC(10));
 
-	zassert_true(low_count + mid_count == 2, NULL);
+	zassert_true(low_count + mid_count == 2);
 
 	k_thread_abort(&tdata);
 	k_thread_abort(&tdata1);

tests/kernel/queue/src/test_queue_loop.c

@@ -44,14 +44,14 @@ static void tqueue_get(struct k_queue *pqueue)
 	for (int i = 0; i < LIST_LEN; i++) {
 		/**TESTPOINT: queue get*/
 		rx_data = k_queue_get(pqueue, K_NO_WAIT);
-		zassert_equal(rx_data, (void *)&data_p[i], NULL);
+		zassert_equal(rx_data, (void *)&data_p[i]);
 	}
 
 	/*get queue data from "queue_append"*/
 	for (int i = 0; i < LIST_LEN; i++) {
 		/**TESTPOINT: queue get*/
 		rx_data = k_queue_get(pqueue, K_NO_WAIT);
-		zassert_equal(rx_data, (void *)&data[i], NULL);
+		zassert_equal(rx_data, (void *)&data[i]);
 	}
 }
 
@@ -60,7 +60,7 @@ static void tqueue_find_and_remove(struct k_queue *pqueue)
 	/*remove queue data from "queue_find_and_remove"*/
 	for (int i = 0; i < LIST_LEN; i++) {
 		/**TESTPOINT: queue find and remove*/
-		zassert_true(k_queue_remove(pqueue, &data_r[i]), NULL);
+		zassert_true(k_queue_remove(pqueue, &data_r[i]));
 	}
 }
 

tests/kernel/queue/src/test_queue_user.c

@@ -30,9 +30,9 @@ void child_thread_get(void *p1, void *p2, void *p3)
 	struct k_queue *q = p1;
 	struct k_sem *sem = p2;
 
-	zassert_false(k_queue_is_empty(q), NULL);
+	zassert_false(k_queue_is_empty(q));
 	qd = k_queue_peek_head(q);
-	zassert_equal(qd->data, 0, NULL);
+	zassert_equal(qd->data, 0);
 	qd = k_queue_peek_tail(q);
 	zassert_equal(qd->data, (LIST_LEN * 2) - 1,
 		      "got %d expected %d", qd->data, (LIST_LEN * 2) - 1);
@@ -40,7 +40,7 @@ void child_thread_get(void *p1, void *p2, void *p3)
 	for (int i = 0; i < (LIST_LEN * 2); i++) {
 		qd = k_queue_get(q, K_FOREVER);
 
-		zassert_equal(qd->data, i, NULL);
+		zassert_equal(qd->data, i);
 		if (qd->allocated) {
 			/* snode should never have been touched */
 			zassert_is_null(qd->snode.next, NULL);
@@ -48,7 +48,7 @@ void child_thread_get(void *p1, void *p2, void *p3)
 	}
 
 
-	zassert_true(k_queue_is_empty(q), NULL);
+	zassert_true(k_queue_is_empty(q));
 
 	/* This one gets canceled */
 	qd = k_queue_get(q, K_FOREVER);
@@ -104,7 +104,7 @@ ZTEST(queue_api_1cpu, test_queue_supv_to_user)
 		qdata[i + 1].data = i + 1;
 		qdata[i + 1].allocated = true;
 		qdata[i + 1].snode.next = NULL;
-		zassert_false(k_queue_alloc_append(q, &qdata[i + 1]), NULL);
+		zassert_false(k_queue_alloc_append(q, &qdata[i + 1]));
 	}
 
 	k_thread_create(&child_thread, child_stack, STACK_SIZE,
@@ -140,15 +140,15 @@ ZTEST_USER(queue_api, test_queue_alloc_prepend_user)
 
 	for (int i = 0; i < LIST_LEN * 2; i++) {
 		qdata[i].data = i;
-		zassert_false(k_queue_alloc_prepend(q, &qdata[i]), NULL);
+		zassert_false(k_queue_alloc_prepend(q, &qdata[i]));
 	}
 
 	for (int i = (LIST_LEN * 2) - 1; i >= 0; i--) {
 		struct qdata *qd;
 
 		qd = k_queue_get(q, K_NO_WAIT);
-		zassert_true(qd != NULL, NULL);
+		zassert_true(qd != NULL);
-		zassert_equal(qd->data, i, NULL);
+		zassert_equal(qd->data, i);
 	}
 }
 
@@ -174,15 +174,15 @@ ZTEST_USER(queue_api, test_queue_alloc_append_user)
 
 	for (int i = 0; i < LIST_LEN * 2; i++) {
 		qdata[i].data = i;
-		zassert_false(k_queue_alloc_append(q, &qdata[i]), NULL);
+		zassert_false(k_queue_alloc_append(q, &qdata[i]));
 	}
 
 	for (int i = 0; i < LIST_LEN * 2; i++) {
 		struct qdata *qd;
 
 		qd = k_queue_get(q, K_NO_WAIT);
-		zassert_true(qd != NULL, NULL);
+		zassert_true(qd != NULL);
-		zassert_equal(qd->data, i, NULL);
+		zassert_equal(qd->data, i);
 	}
 }
 

tests/kernel/sched/schedule_api/src/test_priority_scheduling.c

@@ -43,7 +43,7 @@ static void thread_tslice(void *p1, void *p2, void *p3)
 		/* Printing alphabet corresponding to thread */
 		TC_PRINT("%c", thread_parameter);
 		/* Testing if threads are executed as per priority */
-		zassert_true((idx == thread_idx), NULL);
+		zassert_true((idx == thread_idx));
 		thread_idx = (thread_idx + 1) % (NUM_THREAD);
 
 		/* Release CPU and give chance to Ztest thread to run */

tests/kernel/sched/schedule_api/src/test_sched_is_preempt_thread.c

@@ -15,38 +15,38 @@ static struct k_sem end_sema;
 static void tIsr(const void *data)
 {
 	/** TESTPOINT: The code is running at ISR. */
-	zassert_false(k_is_preempt_thread(), NULL);
+	zassert_false(k_is_preempt_thread());
 }
 
 static void tpreempt_ctx(void *p1, void *p2, void *p3)
 {
 	/** TESTPOINT: The thread's priority is in the preemptible range. */
-	zassert_true(k_is_preempt_thread(), NULL);
+	zassert_true(k_is_preempt_thread());
 	k_sched_lock();
 	/** TESTPOINT: The thread has locked the scheduler. */
-	zassert_false(k_is_preempt_thread(), NULL);
+	zassert_false(k_is_preempt_thread());
 	k_sched_unlock();
 	/** TESTPOINT: The thread has not locked the scheduler. */
-	zassert_true(k_is_preempt_thread(), NULL);
+	zassert_true(k_is_preempt_thread());
 	k_thread_priority_set(k_current_get(), K_PRIO_COOP(1));
 	/** TESTPOINT: The thread's priority is in the cooperative range. */
-	zassert_false(k_is_preempt_thread(), NULL);
+	zassert_false(k_is_preempt_thread());
 	k_sem_give(&end_sema);
 }
 
 static void tcoop_ctx(void *p1, void *p2, void *p3)
 {
 	/** TESTPOINT: The thread's priority is in the cooperative range. */
-	zassert_false(k_is_preempt_thread(), NULL);
+	zassert_false(k_is_preempt_thread());
 	k_thread_priority_set(k_current_get(), K_PRIO_PREEMPT(1));
 	/** TESTPOINT: The thread's priority is in the preemptible range. */
-	zassert_true(k_is_preempt_thread(), NULL);
+	zassert_true(k_is_preempt_thread());
 	k_sched_lock();
 	/** TESTPOINT: The thread has locked the scheduler. */
-	zassert_false(k_is_preempt_thread(), NULL);
+	zassert_false(k_is_preempt_thread());
 	k_sched_unlock();
 	/** TESTPOINT: The thread has not locked the scheduler. */
-	zassert_true(k_is_preempt_thread(), NULL);
+	zassert_true(k_is_preempt_thread());
 	k_sem_give(&end_sema);
 }
 

tests/kernel/sched/schedule_api/src/test_sched_priority.c

@@ -59,10 +59,10 @@ ZTEST(threads_scheduling, test_priority_cooperative)
 				      thread_entry, NULL, NULL, NULL,
 				      spawn_prio, 0, K_NO_WAIT);
 	/* checkpoint: current thread shouldn't preempted by higher thread */
-	zassert_true(last_prio == k_thread_priority_get(k_current_get()), NULL);
+	zassert_true(last_prio == k_thread_priority_get(k_current_get()));
 	k_sleep(K_MSEC(100));
 	/* checkpoint: spawned thread get executed */
-	zassert_true(last_prio == spawn_prio, NULL);
+	zassert_true(last_prio == spawn_prio);
 	k_thread_abort(tid);
 
 	/* restore environment */
@@ -94,7 +94,7 @@ ZTEST(threads_scheduling, test_priority_preemptible)
 				      thread_entry, NULL, NULL, NULL,
 				      spawn_prio, 0, K_NO_WAIT);
 	/* checkpoint: thread is preempted by higher thread */
-	zassert_true(last_prio == spawn_prio, NULL);
+	zassert_true(last_prio == spawn_prio);
 
 	k_sleep(K_MSEC(100));
 	k_thread_abort(tid);
@@ -104,7 +104,7 @@ ZTEST(threads_scheduling, test_priority_preemptible)
 			      thread_entry, NULL, NULL, NULL,
 			      spawn_prio, 0, K_NO_WAIT);
 	/* checkpoint: thread is not preempted by lower thread */
-	zassert_false(last_prio == spawn_prio, NULL);
+	zassert_false(last_prio == spawn_prio);
 	k_thread_abort(tid);
 
 	/* restore environment */

tests/kernel/sched/schedule_api/src/test_sched_timeslice_and_lock.c

@@ -106,10 +106,10 @@ ZTEST(threads_scheduling, test_yield_cooperative)
 	spawn_threads(0);
 	/* checkpoint: only higher priority thread get executed when yield */
 	k_yield();
-	zassert_true(tdata[0].executed == 1, NULL);
+	zassert_true(tdata[0].executed == 1);
-	zassert_true(tdata[1].executed == 1, NULL);
+	zassert_true(tdata[1].executed == 1);
 	for (int i = 2; i < THREADS_NUM; i++) {
-		zassert_true(tdata[i].executed == 0, NULL);
+		zassert_true(tdata[i].executed == 0);
 	}
 	/* restore environment */
 	teardown_threads();
@@ -133,7 +133,7 @@ ZTEST(threads_scheduling, test_sleep_cooperative)
 	/* checkpoint: all ready threads get executed when k_sleep */
 	k_sleep(K_MSEC(100));
 	for (int i = 0; i < THREADS_NUM; i++) {
-		zassert_true(tdata[i].executed == 1, NULL);
+		zassert_true(tdata[i].executed == 1);
 	}
 
 	/* restore environment */
@@ -150,7 +150,7 @@ ZTEST(threads_scheduling, test_busy_wait_cooperative)
 	k_busy_wait(100000); /* 100 ms */
 	/* checkpoint: No other threads get executed */
 	for (int i = 0; i < THREADS_NUM; i++) {
-		zassert_true(tdata[i].executed == 0, NULL);
+		zassert_true(tdata[i].executed == 0);
 	}
 	/* restore environment */
 	teardown_threads();
@@ -178,10 +178,10 @@ ZTEST(threads_scheduling, test_sleep_wakeup_preemptible)
 	spawn_threads(10 * 1000); /* 10 second */
 	/* checkpoint: lower threads not executed, high threads are in sleep */
 	for (int i = 0; i < THREADS_NUM; i++) {
-		zassert_true(tdata[i].executed == 0, NULL);
+		zassert_true(tdata[i].executed == 0);
 	}
 	k_wakeup(tdata[0].tid);
-	zassert_true(tdata[0].executed == 1, NULL);
+	zassert_true(tdata[0].executed == 1);
 	/* restore environment */
 	teardown_threads();
 }
@@ -249,12 +249,12 @@ ZTEST(threads_scheduling, test_time_slicing_preemptible)
 	k_sched_time_slice_set(200, 0); /* 200 ms */
 	spawn_threads(0);
 	/* checkpoint: higher priority threads get executed immediately */
-	zassert_true(tdata[0].executed == 1, NULL);
+	zassert_true(tdata[0].executed == 1);
 	k_busy_wait(500000); /* 500 ms */
 	/* checkpoint: equal priority threads get executed every time slice */
-	zassert_true(tdata[1].executed == 1, NULL);
+	zassert_true(tdata[1].executed == 1);
 	for (int i = 2; i < THREADS_NUM; i++) {
-		zassert_true(tdata[i].executed == 0, NULL);
+		zassert_true(tdata[i].executed == 0);
 	}
 
 	/* restore environment */
@@ -287,12 +287,12 @@ ZTEST(threads_scheduling, test_time_slicing_disable_preemptible)
 
 	spawn_threads(0);
 	/* checkpoint: higher priority threads get executed immediately */
-	zassert_true(tdata[0].executed == 1, NULL);
+	zassert_true(tdata[0].executed == 1);
 	k_busy_wait(500000); /* 500 ms */
 	/* checkpoint: equal priority threads get executed every time slice */
-	zassert_true(tdata[1].executed == 0, NULL);
+	zassert_true(tdata[1].executed == 0);
 	for (int i = 2; i < THREADS_NUM; i++) {
-		zassert_true(tdata[i].executed == 0, NULL);
+		zassert_true(tdata[i].executed == 0);
 	}
 	/* restore environment */
 	teardown_threads();
@@ -322,13 +322,13 @@ ZTEST(threads_scheduling, test_lock_preemptible)
 	k_busy_wait(100000);
 	/* checkpoint: all other threads not been executed */
 	for (int i = 0; i < THREADS_NUM; i++) {
-		zassert_true(tdata[i].executed == 0, NULL);
+		zassert_true(tdata[i].executed == 0);
 	}
 	/* make current thread unready */
 	k_sleep(K_MSEC(100));
 	/* checkpoint: all other threads get executed */
 	for (int i = 0; i < THREADS_NUM; i++) {
-		zassert_true(tdata[i].executed == 1, NULL);
+		zassert_true(tdata[i].executed == 1);
 	}
 	/* restore environment */
 	teardown_threads();
@@ -362,9 +362,9 @@ ZTEST(threads_scheduling, test_unlock_preemptible)
 	k_yield();
 
 	/* checkpoint: higher and equal threads get executed */
-	zassert_true(tdata[0].executed == 1, NULL);
+	zassert_true(tdata[0].executed == 1);
-	zassert_true(tdata[1].executed == 1, NULL);
+	zassert_true(tdata[1].executed == 1);
-	zassert_true(tdata[2].executed == 0, NULL);
+	zassert_true(tdata[2].executed == 0);
 
 	/* restore environment */
 	teardown_threads();
@@ -403,7 +403,7 @@ ZTEST(threads_scheduling, test_unlock_nested_sched_lock)
 
 	/* checkpoint: no threads get executed */
 	for (int i = 0; i < THREADS_NUM; i++) {
-		zassert_true(tdata[i].executed == 0, NULL);
+		zassert_true(tdata[i].executed == 0);
 	}
 
 	/* unlock another; this let the higher thread to run */
@@ -413,9 +413,9 @@ ZTEST(threads_scheduling, test_unlock_nested_sched_lock)
 	k_yield();
 
 	/* checkpoint: higher threads NOT get executed */
-	zassert_true(tdata[0].executed == 1, NULL);
+	zassert_true(tdata[0].executed == 1);
-	zassert_true(tdata[1].executed == 1, NULL);
+	zassert_true(tdata[1].executed == 1);
-	zassert_true(tdata[2].executed == 0, NULL);
+	zassert_true(tdata[2].executed == 0);
 
 	/* restore environment */
 	teardown_threads();