adafruit-mirror/zephyr
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 9

ztest: remove the obsolete NULL appended to zassert macros

Browse source 
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>
This commit is contained in:
Michał Barnaś 2022-08-17 17:36:15 +02:00 committed by Anas Nashif
parent 36f74e9837
commit dae8efa692
201 changed files with 2846 additions and 2846 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
subsys/bluetooth/controller/ll_sw/ull_llcp.c
View file

@ -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->collision, 0, NULL);
zassert_equal(ctx->proc, PROC_VERSION_EXCHANGE);
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.remote.pause, 0, NULL);
zassert_equal(conn.llcp.local.pause, 0);
zassert_equal(conn.llcp.remote.pause, 0);
}
#endif

2
tests/arch/arm/arm_thread_swap_tz/src/main.c
View file

@ -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);

22
tests/arch/arm/arm_tz_wrap_func/src/main.c
View file

@ -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(arg3, foo1_arg3, NULL);
zassert_equal(arg4, foo1_arg4, NULL);
zassert_equal(arg2, foo1_arg2);
zassert_equal(arg3, foo1_arg3);
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(psp1, __get_PSP(), NULL);
zassert_equal(msp1, __get_MSP());
zassert_equal(psp1, __get_PSP());
zassert_true(preface_called, NULL);
zassert_true(foo1_called, NULL);
zassert_true(postface_called, NULL);
zassert_false(expect_preface, NULL);
zassert_false(expect_foo1, NULL);
zassert_false(expect_postface, NULL);
zassert_true(preface_called);
zassert_true(foo1_called);
zassert_true(postface_called);
zassert_false(expect_preface);
zassert_false(expect_foo1);
zassert_false(expect_postface);
}
ZTEST_SUITE(tz_wrap_func, NULL, NULL, NULL, NULL, NULL);

2
tests/benchmarks/data_structure_perf/rbtree_perf/src/rbtree_perf.c
View file

@ -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);
}
/**

8
tests/bluetooth/controller/common/src/helper_pdu.c
View file

@ -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->llctrl.opcode, PDU_DATA_LLCTRL_TYPE_PER_INIT_FEAT_XCHG, NULL);
zassert_equal(pdu->ll_id, PDU_DATA_LLID_CTRL);
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);

36
tests/bluetooth/controller/ctrl_api/src/main.c
View file

@ -54,8 +54,8 @@ void test_api_init(void)
ull_llcp_init(&conn);
zassert_true(lr_is_disconnected(&conn), NULL);
zassert_true(rr_is_disconnected(&conn), NULL);
zassert_true(lr_is_disconnected(&conn));
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(rr_is_idle(&conn), NULL);
zassert_true(lr_is_idle(&conn));
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(rr_is_disconnected(&conn), NULL);
zassert_true(lr_is_disconnected(&conn));
zassert_true(rr_is_disconnected(&conn));
ull_cp_state_set(&conn, ULL_CP_CONNECTED);
zassert_true(lr_is_idle(&conn), NULL);
zassert_true(rr_is_idle(&conn), NULL);
zassert_true(lr_is_idle(&conn));
zassert_true(rr_is_idle(&conn));
ull_cp_state_set(&conn, ULL_CP_DISCONNECTED);
zassert_true(lr_is_disconnected(&conn), NULL);
zassert_true(rr_is_disconnected(&conn), NULL);
zassert_true(lr_is_disconnected(&conn));
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();

6
tests/bluetooth/controller/ctrl_chmu/src/main.c
View file

@ -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());

2
tests/bluetooth/controller/ctrl_cis_terminate/src/main.c
View file

@ -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);

8
tests/bluetooth/controller/ctrl_collision/src/main.c
View file

@ -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);

44
tests/bluetooth/controller/ctrl_conn_update/src/main.c
View file

@ -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);

30
tests/bluetooth/controller/ctrl_cte_req/src/main.c
View file

@ -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),

18
tests/bluetooth/controller/ctrl_data_length_update/src/main.c
View file

@ -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);

40
tests/bluetooth/controller/ctrl_encrypt/src/main.c
View file

@ -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());

14
tests/bluetooth/controller/ctrl_feature_exchange/src/main.c
View file

@ -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);

50
tests/bluetooth/controller/ctrl_hci/src/main.c
View file

@ -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(phy_tx, 0x07, NULL);
zassert_equal(phy_rx, 0x03, NULL);
zassert_equal(err, BT_HCI_ERR_SUCCESS);
zassert_equal(phy_tx, 0x07);
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_rx, 0x00, NULL);
zassert_equal(phy_tx, 0x00);
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_rx, 0x03, NULL);
zassert_equal(phy_tx, 0x01);
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_rx_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);
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(max_tx_octets, 0x00, NULL);
zassert_equal(max_tx_time, 0x00, NULL);
zassert_equal(err, 00);
zassert_equal(max_tx_octets, 0x00);
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(max_tx_octets, 0x10, NULL);
zassert_equal(max_tx_time, 0x3FF, NULL);
zassert_equal(err, 00);
zassert_equal(max_tx_octets, 0x10);
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_time, 0x3FF, NULL);
zassert_equal(max_tx_octets, 0x10);
zassert_equal(max_tx_time, 0x3FF);
}
void test_hci_terminate(void)

10
tests/bluetooth/controller/ctrl_le_ping/src/main.c
View file

@ -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);

4
tests/bluetooth/controller/ctrl_min_used_chans/src/main.c
View file

@ -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());

18
tests/bluetooth/controller/ctrl_phy_update/src/main.c
View file

@ -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);

2
tests/bluetooth/controller/ctrl_terminate/src/main.c
View file

@ -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);

40
tests/bluetooth/controller/ctrl_tx_buffer_alloc/src/main.c
View file

@ -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(common_tx_buffer_alloc_count(), 0, NULL);
zassert_equal(conn[0].llcp.tx_buffer_alloc, i + 1);
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_equal(ctxs[0]->wait_reason, WAITING_FOR_TX_BUFFER, NULL);
zassert_false(llcp_tx_alloc_peek(&conn[0], ctxs[0]));
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_equal(ctxs[j]->wait_reason, WAITING_FOR_TX_BUFFER, NULL);
zassert_false(llcp_tx_alloc_peek(&conn[j], ctxs[j]));
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 */
}

16
tests/bluetooth/controller/ctrl_version/src/main.c
View file

@ -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);

392
tests/bluetooth/ctrl_isoal/src/main.c
View file

File diff suppressed because it is too large Load diff

10
tests/bluetooth/host_long_adv_recv/src/main.c
View file

@ -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);
}

2
tests/boards/altera_max10/i2c_master/src/i2c_master.c
View file

@ -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);

4
tests/boards/intel_adsp/ssp/src/main.c
View file

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

12
tests/drivers/adc/adc_api/src/test_adc.c
View file

@ -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);
}

12
tests/drivers/adc/adc_dma/src/test_adc.c
View file

@ -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);
}

56
tests/drivers/bbram/emul/src/main.c
View file

@ -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_equal(size, BBRAM_SIZE, NULL);
zassert_ok(bbram_get_size(dev, &size));
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, BBRAM_SIZE + 1, buffer), -EFAULT, NULL);
zassert_equal(bbram_read(dev, BBRAM_SIZE - 1, 2, buffer), -EFAULT, NULL);
zassert_equal(bbram_write(dev, 0, 0, buffer), -EFAULT, NULL);
zassert_equal(bbram_write(dev, 0, BBRAM_SIZE + 1, buffer), -EFAULT, NULL);
zassert_equal(bbram_write(dev, BBRAM_SIZE - 1, 2, buffer), -EFAULT, NULL);
zassert_equal(bbram_read(dev, 0, 0, buffer), -EFAULT);
zassert_equal(bbram_read(dev, 0, BBRAM_SIZE + 1, buffer), -EFAULT);
zassert_equal(bbram_read(dev, BBRAM_SIZE - 1, 2, buffer), -EFAULT);
zassert_equal(bbram_write(dev, 0, 0, buffer), -EFAULT);
zassert_equal(bbram_write(dev, 0, BBRAM_SIZE + 1, buffer), -EFAULT);
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_read(dev, 0, BBRAM_SIZE, buffer), NULL);
zassert_ok(bbram_write(dev, 0, BBRAM_SIZE, expected));
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_ok(bbram_emul_set_invalid(dev, true), NULL);
zassert_equal(bbram_check_invalid(dev), 1, NULL);
zassert_equal(bbram_check_invalid(dev), 0, NULL);
zassert_equal(bbram_check_invalid(dev), 0);
zassert_ok(bbram_emul_set_invalid(dev, true));
zassert_equal(bbram_check_invalid(dev), 1);
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_ok(bbram_emul_set_standby_power_state(dev, true), NULL);
zassert_equal(bbram_check_standby_power(dev), 1, NULL);
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));
zassert_equal(bbram_check_standby_power(dev), 1);
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_ok(bbram_emul_set_power_state(dev, true), NULL);
zassert_equal(bbram_check_power(dev), 1, NULL);
zassert_equal(bbram_check_power(dev), 0, NULL);
zassert_equal(bbram_check_power(dev), 0);
zassert_ok(bbram_emul_set_power_state(dev, true));
zassert_equal(bbram_check_power(dev), 1);
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_equal(bbram_read(dev, 0, BBRAM_SIZE, buffer), -EFAULT, NULL);
zassert_equal(bbram_check_invalid(dev), 0, NULL);
zassert_ok(bbram_emul_set_invalid(dev, true));
zassert_equal(bbram_read(dev, 0, BBRAM_SIZE, buffer), -EFAULT);
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_equal(bbram_write(dev, 0, BBRAM_SIZE, buffer), -EFAULT, NULL);
zassert_equal(bbram_check_invalid(dev), 0, NULL);
zassert_ok(bbram_emul_set_invalid(dev, true));
zassert_equal(bbram_write(dev, 0, BBRAM_SIZE, buffer), -EFAULT);
zassert_equal(bbram_check_invalid(dev), 0);
}
static void before(void *data)

12
tests/drivers/clock_control/nrf_lf_clock_start/src/main.c
View file

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

14
tests/drivers/clock_control/nrf_onoff_and_bt/src/main.c
View file

@ -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();

2
tests/drivers/dac/dac_loopback/src/test_dac.c
View file

@ -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);

8
tests/drivers/dma/chan_blen_transfer/src/test_dma.c
View file

@ -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));
}

6
tests/drivers/dma/chan_link_transfer/src/test_dma.c
View file

@ -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));
}

4
tests/drivers/dma/loop_transfer/src/test_dma_loop.c
View file

@ -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));
}

2
tests/drivers/dma/scatter_gather/src/test_dma_sg.c
View file

@ -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));
}

2
tests/drivers/entropy/api/src/main.c
View file

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

4
tests/drivers/espi/src/test_acpi.c
View file

@ -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));

2
tests/drivers/flash/src/main.c
View file

@ -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);

4
tests/drivers/i2c/i2c_api/src/test_i2c.c
View file

@ -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);

58
tests/drivers/i2s/i2s_api/src/test_i2s_dir_both_loopback.c
View file

@ -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));
}

48
tests/drivers/i2s/i2s_api/src/test_i2s_dir_both_states.c
View file

@ -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));
}

66
tests/drivers/i2s/i2s_api/src/test_i2s_loopback.c
View file

@ -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));
}

108
tests/drivers/i2s/i2s_api/src/test_i2s_states.c
View file

@ -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));
}

90
tests/drivers/i2s/i2s_speed/src/test_i2s_speed.c
View file

@ -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(rx_size, BLOCK_SIZE, NULL);
zassert_equal(ret, 0);
zassert_equal(rx_size, BLOCK_SIZE);
ret = i2s_read(dev_i2s_rx, &rx_block[1], &rx_size);
zassert_equal(ret, 0, NULL);
zassert_equal(rx_size, BLOCK_SIZE, NULL);
zassert_equal(ret, 0);
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(rx_size, BLOCK_SIZE, NULL);
zassert_equal(ret, 0);
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(rx_size, BLOCK_SIZE, NULL);
zassert_equal(ret, 0);
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(rx_size, BLOCK_SIZE, NULL);
zassert_equal(ret, 0);
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(rx_size, BLOCK_SIZE, NULL);
zassert_equal(ret, 0);
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(rx_size, BLOCK_SIZE, NULL);
zassert_equal(ret, 0);
zassert_equal(rx_size, BLOCK_SIZE);
ret = i2s_read(dev_i2s_rxtx, &rx_block[1], &rx_size);
zassert_equal(ret, 0, NULL);
zassert_equal(rx_size, BLOCK_SIZE, NULL);
zassert_equal(ret, 0);
zassert_equal(rx_size, BLOCK_SIZE);
ret = i2s_read(dev_i2s_rxtx, &rx_block[2], &rx_size);
zassert_equal(ret, 0, NULL);
zassert_equal(rx_size, BLOCK_SIZE, NULL);
zassert_equal(ret, 0);
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(rx_size, BLOCK_SIZE, NULL);
zassert_equal(ret, 0);
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(rx_size, BLOCK_SIZE, NULL);
zassert_equal(ret, 0);
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(rx_size, BLOCK_SIZE, NULL);
zassert_equal(ret, 0);
zassert_equal(rx_size, BLOCK_SIZE);
TC_PRINT("%d TX blocks sent\n", tx_idx);
TC_PRINT("%d RX blocks received\n", rx_idx);

6
tests/drivers/kscan/kscan_api/src/test_kscan.c
View file

@ -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));
}

78
tests/drivers/pinctrl/api/src/main.c
View file

@ -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(TEST_GET_PIN(scfg->pins[0]), 0, NULL);
zassert_equal(TEST_GET_PULL(scfg->pins[0]), TEST_PULL_UP, NULL);
zassert_equal(TEST_GET_PIN(scfg->pins[1]), 1, NULL);
zassert_equal(TEST_GET_PULL(scfg->pins[1]), TEST_PULL_DOWN, NULL);
zassert_equal(scfg->id, PINCTRL_STATE_DEFAULT);
zassert_equal(TEST_GET_PIN(scfg->pins[0]), 0);
zassert_equal(TEST_GET_PULL(scfg->pins[0]), TEST_PULL_UP);
zassert_equal(TEST_GET_PIN(scfg->pins[1]), 1);
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->pin_cnt, 3, NULL);
zassert_equal(TEST_GET_PIN(scfg->pins[0]), 10, NULL);
zassert_equal(TEST_GET_PULL(scfg->pins[0]), TEST_PULL_DISABLE, NULL);
zassert_equal(TEST_GET_PIN(scfg->pins[1]), 11, NULL);
zassert_equal(TEST_GET_PULL(scfg->pins[1]), TEST_PULL_DISABLE, NULL);
zassert_equal(TEST_GET_PIN(scfg->pins[2]), 12, NULL);
zassert_equal(TEST_GET_PULL(scfg->pins[2]), TEST_PULL_DISABLE, NULL);
zassert_equal(scfg->id, PINCTRL_STATE_DEFAULT);
zassert_equal(scfg->pin_cnt, 3);
zassert_equal(TEST_GET_PIN(scfg->pins[0]), 10);
zassert_equal(TEST_GET_PULL(scfg->pins[0]), TEST_PULL_DISABLE);
zassert_equal(TEST_GET_PIN(scfg->pins[1]), 11);
zassert_equal(TEST_GET_PULL(scfg->pins[1]), TEST_PULL_DISABLE);
zassert_equal(TEST_GET_PIN(scfg->pins[2]), 12);
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->pin_cnt, 3, NULL);
zassert_equal(TEST_GET_PIN(scfg->pins[0]), 10, NULL);
zassert_equal(TEST_GET_PULL(scfg->pins[0]), TEST_PULL_DISABLE, NULL);
zassert_equal(TEST_GET_PIN(scfg->pins[1]), 11, NULL);
zassert_equal(TEST_GET_PULL(scfg->pins[1]), TEST_PULL_UP, NULL);
zassert_equal(TEST_GET_PIN(scfg->pins[2]), 12, NULL);
zassert_equal(TEST_GET_PULL(scfg->pins[2]), TEST_PULL_DOWN, NULL);
zassert_equal(scfg->id, PINCTRL_STATE_MYSTATE);
zassert_equal(scfg->pin_cnt, 3);
zassert_equal(TEST_GET_PIN(scfg->pins[0]), 10);
zassert_equal(TEST_GET_PULL(scfg->pins[0]), TEST_PULL_DISABLE);
zassert_equal(TEST_GET_PIN(scfg->pins[1]), 11);
zassert_equal(TEST_GET_PULL(scfg->pins[1]), TEST_PULL_UP);
zassert_equal(TEST_GET_PIN(scfg->pins[2]), 12);
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_equal(1, pinctrl_configure_pins_fake.call_count, NULL);
zassert_equal(pcfg0->states[0].pins, pinctrl_configure_pins_fake.arg0_val, NULL);
zassert_equal(pcfg0->states[0].pin_cnt, pinctrl_configure_pins_fake.arg1_val, NULL);
zassert_ok(pinctrl_apply_state(pcfg0, PINCTRL_STATE_DEFAULT));
zassert_equal(1, pinctrl_configure_pins_fake.call_count);
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);
#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_PULL(scfg->pins[0]), TEST_PULL_DOWN, NULL);
zassert_equal(TEST_GET_PIN(scfg->pins[1]), 3, NULL);
zassert_equal(TEST_GET_PULL(scfg->pins[1]), TEST_PULL_UP, NULL);
zassert_equal(TEST_GET_PIN(scfg->pins[0]), 2);
zassert_equal(TEST_GET_PULL(scfg->pins[0]), TEST_PULL_DOWN);
zassert_equal(TEST_GET_PIN(scfg->pins[1]), 3);
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)

150
tests/drivers/pinctrl/gd32/src/main_af.c
View file

@ -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->pin_cnt, 12U, NULL);
zassert_equal(scfg->id, PINCTRL_STATE_DEFAULT);
zassert_equal(scfg->pin_cnt, 12U);
pin = scfg->pins[0];
zassert_equal(GD32_PORT_GET(pin), 0, NULL);
zassert_equal(GD32_PIN_GET(pin), 0, NULL);
zassert_equal(GD32_AF_GET(pin), GD32_AF0, NULL);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE, NULL);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP, NULL);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ, NULL);
zassert_equal(GD32_PORT_GET(pin), 0);
zassert_equal(GD32_PIN_GET(pin), 0);
zassert_equal(GD32_AF_GET(pin), GD32_AF0);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ);
pin = scfg->pins[1];
zassert_equal(GD32_PORT_GET(pin), 1, NULL);
zassert_equal(GD32_PIN_GET(pin), 1, NULL);
zassert_equal(GD32_AF_GET(pin), GD32_AF1, NULL);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE, NULL);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP, NULL);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ, NULL);
zassert_equal(GD32_PORT_GET(pin), 1);
zassert_equal(GD32_PIN_GET(pin), 1);
zassert_equal(GD32_AF_GET(pin), GD32_AF1);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ);
pin = scfg->pins[2];
zassert_equal(GD32_PORT_GET(pin), 2, NULL);
zassert_equal(GD32_PIN_GET(pin), 2, NULL);
zassert_equal(GD32_AF_GET(pin), GD32_AF2, NULL);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE, NULL);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP, NULL);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ, NULL);
zassert_equal(GD32_PORT_GET(pin), 2);
zassert_equal(GD32_PIN_GET(pin), 2);
zassert_equal(GD32_AF_GET(pin), GD32_AF2);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ);
pin = scfg->pins[3];
zassert_equal(GD32_PORT_GET(pin), 0, NULL);
zassert_equal(GD32_PIN_GET(pin), 3, NULL);
zassert_equal(GD32_AF_GET(pin), GD32_AF3, NULL);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE, NULL);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_OD, NULL);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ, NULL);
zassert_equal(GD32_PORT_GET(pin), 0);
zassert_equal(GD32_PIN_GET(pin), 3);
zassert_equal(GD32_AF_GET(pin), GD32_AF3);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_OD);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ);
pin = scfg->pins[4];
zassert_equal(GD32_PORT_GET(pin), 1, NULL);
zassert_equal(GD32_PIN_GET(pin), 4, NULL);
zassert_equal(GD32_AF_GET(pin), GD32_AF4, NULL);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE, NULL);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP, NULL);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ, NULL);
zassert_equal(GD32_PORT_GET(pin), 1);
zassert_equal(GD32_PIN_GET(pin), 4);
zassert_equal(GD32_AF_GET(pin), GD32_AF4);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ);
pin = scfg->pins[5];
zassert_equal(GD32_PORT_GET(pin), 2, NULL);
zassert_equal(GD32_PIN_GET(pin), 5, NULL);
zassert_equal(GD32_AF_GET(pin), GD32_AF5, NULL);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_PULLUP, NULL);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP, NULL);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ, NULL);
zassert_equal(GD32_PORT_GET(pin), 2);
zassert_equal(GD32_PIN_GET(pin), 5);
zassert_equal(GD32_AF_GET(pin), GD32_AF5);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_PULLUP);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ);
pin = scfg->pins[6];
zassert_equal(GD32_PORT_GET(pin), 0, NULL);
zassert_equal(GD32_PIN_GET(pin), 6, NULL);
zassert_equal(GD32_AF_GET(pin), GD32_AF6, NULL);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_PULLDOWN, NULL);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP, NULL);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ, NULL);
zassert_equal(GD32_PORT_GET(pin), 0);
zassert_equal(GD32_PIN_GET(pin), 6);
zassert_equal(GD32_AF_GET(pin), GD32_AF6);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_PULLDOWN);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ);
pin = scfg->pins[7];
zassert_equal(GD32_PORT_GET(pin), 1, NULL);
zassert_equal(GD32_PIN_GET(pin), 7, NULL);
zassert_equal(GD32_AF_GET(pin), GD32_AF7, NULL);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE, NULL);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP, NULL);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ, NULL);
zassert_equal(GD32_PORT_GET(pin), 1);
zassert_equal(GD32_PIN_GET(pin), 7);
zassert_equal(GD32_AF_GET(pin), GD32_AF7);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ);
pin = scfg->pins[8];
zassert_equal(GD32_PORT_GET(pin), 2, NULL);
zassert_equal(GD32_PIN_GET(pin), 8, NULL);
zassert_equal(GD32_AF_GET(pin), GD32_AF8, NULL);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE, NULL);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP, NULL);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_25MHZ, NULL);
zassert_equal(GD32_PORT_GET(pin), 2);
zassert_equal(GD32_PIN_GET(pin), 8);
zassert_equal(GD32_AF_GET(pin), GD32_AF8);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_25MHZ);
pin = scfg->pins[9];
zassert_equal(GD32_PORT_GET(pin), 0, NULL);
zassert_equal(GD32_PIN_GET(pin), 9, NULL);
zassert_equal(GD32_AF_GET(pin), GD32_AF9, NULL);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE, NULL);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP, NULL);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_50MHZ, NULL);
zassert_equal(GD32_PORT_GET(pin), 0);
zassert_equal(GD32_PIN_GET(pin), 9);
zassert_equal(GD32_AF_GET(pin), GD32_AF9);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_50MHZ);
pin = scfg->pins[10];
zassert_equal(GD32_PORT_GET(pin), 1, NULL);
zassert_equal(GD32_PIN_GET(pin), 10, NULL);
zassert_equal(GD32_AF_GET(pin), GD32_AF10, NULL);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE, NULL);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP, NULL);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_MAX, NULL);
zassert_equal(GD32_PORT_GET(pin), 1);
zassert_equal(GD32_PIN_GET(pin), 10);
zassert_equal(GD32_AF_GET(pin), GD32_AF10);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_MAX);
pin = scfg->pins[11];
zassert_equal(GD32_PORT_GET(pin), 2, NULL);
zassert_equal(GD32_PIN_GET(pin), 11, NULL);
zassert_equal(GD32_AF_GET(pin), GD32_ANALOG, NULL);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE, NULL);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP, NULL);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ, NULL);
zassert_equal(GD32_PORT_GET(pin), 2);
zassert_equal(GD32_PIN_GET(pin), 11);
zassert_equal(GD32_AF_GET(pin), GD32_ANALOG);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ);
}
ZTEST_SUITE(pinctrl_gd32, NULL, NULL, NULL, NULL, NULL);

170
tests/drivers/pinctrl/gd32/src/main_afio.c
View file

@ -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->pin_cnt, 14U, NULL);
zassert_equal(scfg->id, PINCTRL_STATE_DEFAULT);
zassert_equal(scfg->pin_cnt, 14U);
pin = scfg->pins[0];
zassert_equal(GD32_PORT_GET(pin), 0, NULL);
zassert_equal(GD32_PIN_GET(pin), 0, NULL);
zassert_equal(GD32_MODE_GET(pin), GD32_MODE_ANALOG, NULL);
zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP, NULL);
zassert_equal(GD32_PORT_GET(pin), 0);
zassert_equal(GD32_PIN_GET(pin), 0);
zassert_equal(GD32_MODE_GET(pin), GD32_MODE_ANALOG);
zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP);
pin = scfg->pins[1];
zassert_equal(GD32_PORT_GET(pin), 1, NULL);
zassert_equal(GD32_PIN_GET(pin), 1, NULL);
zassert_equal(GD32_MODE_GET(pin), GD32_MODE_ALTERNATE, NULL);
zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP, NULL);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ, NULL);
zassert_equal(GD32_PORT_GET(pin), 1);
zassert_equal(GD32_PIN_GET(pin), 1);
zassert_equal(GD32_MODE_GET(pin), GD32_MODE_ALTERNATE);
zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ);
pin = scfg->pins[2];
zassert_equal(GD32_PORT_GET(pin), 2, NULL);
zassert_equal(GD32_PIN_GET(pin), 2, NULL);
zassert_equal(GD32_MODE_GET(pin), GD32_MODE_GPIO_IN, NULL);
zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP, NULL);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE, NULL);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP, NULL);
zassert_equal(GD32_PORT_GET(pin), 2);
zassert_equal(GD32_PIN_GET(pin), 2);
zassert_equal(GD32_MODE_GET(pin), GD32_MODE_GPIO_IN);
zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP);
pin = scfg->pins[3];
zassert_equal(GD32_PORT_GET(pin), 0, NULL);
zassert_equal(GD32_PIN_GET(pin), 3, NULL);
zassert_equal(GD32_MODE_GET(pin), GD32_MODE_GPIO_IN, NULL);
zassert_equal(GD32_REMAP_REG_GET(GD32_REMAP_GET(pin)), 0, NULL);
zassert_equal(GD32_REMAP_POS_GET(GD32_REMAP_GET(pin)), 0, NULL);
zassert_equal(GD32_REMAP_MSK_GET(GD32_REMAP_GET(pin)), 0x1, NULL);
zassert_equal(GD32_REMAP_VAL_GET(GD32_REMAP_GET(pin)), 1, NULL);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE, NULL);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP, NULL);
zassert_equal(GD32_PORT_GET(pin), 0);
zassert_equal(GD32_PIN_GET(pin), 3);
zassert_equal(GD32_MODE_GET(pin), GD32_MODE_GPIO_IN);
zassert_equal(GD32_REMAP_REG_GET(GD32_REMAP_GET(pin)), 0);
zassert_equal(GD32_REMAP_POS_GET(GD32_REMAP_GET(pin)), 0);
zassert_equal(GD32_REMAP_MSK_GET(GD32_REMAP_GET(pin)), 0x1);
zassert_equal(GD32_REMAP_VAL_GET(GD32_REMAP_GET(pin)), 1);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP);
pin = scfg->pins[4];
zassert_equal(GD32_PORT_GET(pin), 1, NULL);
zassert_equal(GD32_PIN_GET(pin), 4, NULL);
zassert_equal(GD32_MODE_GET(pin), GD32_MODE_ALTERNATE, NULL);
zassert_equal(GD32_REMAP_REG_GET(GD32_REMAP_GET(pin)), 0, NULL);
zassert_equal(GD32_REMAP_POS_GET(GD32_REMAP_GET(pin)), 0, NULL);
zassert_equal(GD32_REMAP_MSK_GET(GD32_REMAP_GET(pin)), 0x1, NULL);
zassert_equal(GD32_REMAP_VAL_GET(GD32_REMAP_GET(pin)), 1, NULL);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ, NULL);
zassert_equal(GD32_PORT_GET(pin), 1);
zassert_equal(GD32_PIN_GET(pin), 4);
zassert_equal(GD32_MODE_GET(pin), GD32_MODE_ALTERNATE);
zassert_equal(GD32_REMAP_REG_GET(GD32_REMAP_GET(pin)), 0);
zassert_equal(GD32_REMAP_POS_GET(GD32_REMAP_GET(pin)), 0);
zassert_equal(GD32_REMAP_MSK_GET(GD32_REMAP_GET(pin)), 0x1);
zassert_equal(GD32_REMAP_VAL_GET(GD32_REMAP_GET(pin)), 1);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ);
pin = scfg->pins[5];
zassert_equal(GD32_PORT_GET(pin), 2, NULL);
zassert_equal(GD32_PIN_GET(pin), 5, NULL);
zassert_equal(GD32_MODE_GET(pin), GD32_MODE_GPIO_IN, NULL);
zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP, NULL);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE, NULL);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP, NULL);
zassert_equal(GD32_PORT_GET(pin), 2);
zassert_equal(GD32_PIN_GET(pin), 5);
zassert_equal(GD32_MODE_GET(pin), GD32_MODE_GPIO_IN);
zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP);
pin = scfg->pins[6];
zassert_equal(GD32_PORT_GET(pin), 0, NULL);
zassert_equal(GD32_PIN_GET(pin), 6, NULL);
zassert_equal(GD32_MODE_GET(pin), GD32_MODE_GPIO_IN, NULL);
zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP, NULL);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE, NULL);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_OD, NULL);
zassert_equal(GD32_PORT_GET(pin), 0);
zassert_equal(GD32_PIN_GET(pin), 6);
zassert_equal(GD32_MODE_GET(pin), GD32_MODE_GPIO_IN);
zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_OD);
pin = scfg->pins[7];
zassert_equal(GD32_PORT_GET(pin), 1, NULL);
zassert_equal(GD32_PIN_GET(pin), 7, NULL);
zassert_equal(GD32_MODE_GET(pin), GD32_MODE_GPIO_IN, NULL);
zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP, NULL);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE, NULL);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP, NULL);
zassert_equal(GD32_PORT_GET(pin), 1);
zassert_equal(GD32_PIN_GET(pin), 7);
zassert_equal(GD32_MODE_GET(pin), GD32_MODE_GPIO_IN);
zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_NONE);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP);
pin = scfg->pins[8];
zassert_equal(GD32_PORT_GET(pin), 2, NULL);
zassert_equal(GD32_PIN_GET(pin), 8, NULL);
zassert_equal(GD32_MODE_GET(pin), GD32_MODE_GPIO_IN, NULL);
zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP, NULL);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_PULLUP, NULL);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP, NULL);
zassert_equal(GD32_PORT_GET(pin), 2);
zassert_equal(GD32_PIN_GET(pin), 8);
zassert_equal(GD32_MODE_GET(pin), GD32_MODE_GPIO_IN);
zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_PULLUP);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP);
pin = scfg->pins[9];
zassert_equal(GD32_PORT_GET(pin), 0, NULL);
zassert_equal(GD32_PIN_GET(pin), 9, NULL);
zassert_equal(GD32_MODE_GET(pin), GD32_MODE_GPIO_IN, NULL);
zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP, NULL);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_PULLDOWN, NULL);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP, NULL);
zassert_equal(GD32_PORT_GET(pin), 0);
zassert_equal(GD32_PIN_GET(pin), 9);
zassert_equal(GD32_MODE_GET(pin), GD32_MODE_GPIO_IN);
zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP);
zassert_equal(GD32_PUPD_GET(pin), GD32_PUPD_PULLDOWN);
zassert_equal(GD32_OTYPE_GET(pin), GD32_OTYPE_PP);
pin = scfg->pins[10];
zassert_equal(GD32_PORT_GET(pin), 1, NULL);
zassert_equal(GD32_PIN_GET(pin), 10, NULL);
zassert_equal(GD32_MODE_GET(pin), GD32_MODE_ALTERNATE, NULL);
zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP, NULL);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ, NULL);
zassert_equal(GD32_PORT_GET(pin), 1);
zassert_equal(GD32_PIN_GET(pin), 10);
zassert_equal(GD32_MODE_GET(pin), GD32_MODE_ALTERNATE);
zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_2MHZ);
pin = scfg->pins[11];
zassert_equal(GD32_PORT_GET(pin), 2, NULL);
zassert_equal(GD32_PIN_GET(pin), 11, NULL);
zassert_equal(GD32_MODE_GET(pin), GD32_MODE_ALTERNATE, NULL);
zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP, NULL);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_10MHZ, NULL);
zassert_equal(GD32_PORT_GET(pin), 2);
zassert_equal(GD32_PIN_GET(pin), 11);
zassert_equal(GD32_MODE_GET(pin), GD32_MODE_ALTERNATE);
zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_10MHZ);
pin = scfg->pins[12];
zassert_equal(GD32_PORT_GET(pin), 0, NULL);
zassert_equal(GD32_PIN_GET(pin), 12, NULL);
zassert_equal(GD32_MODE_GET(pin), GD32_MODE_ALTERNATE, NULL);
zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP, NULL);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_50MHZ, NULL);
zassert_equal(GD32_PORT_GET(pin), 0);
zassert_equal(GD32_PIN_GET(pin), 12);
zassert_equal(GD32_MODE_GET(pin), GD32_MODE_ALTERNATE);
zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_50MHZ);
pin = scfg->pins[13];
zassert_equal(GD32_PORT_GET(pin), 1, NULL);
zassert_equal(GD32_PIN_GET(pin), 13, NULL);
zassert_equal(GD32_MODE_GET(pin), GD32_MODE_ALTERNATE, NULL);
zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP, NULL);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_MAX, NULL);
zassert_equal(GD32_PORT_GET(pin), 1);
zassert_equal(GD32_PIN_GET(pin), 13);
zassert_equal(GD32_MODE_GET(pin), GD32_MODE_ALTERNATE);
zassert_equal(GD32_REMAP_GET(pin), GD32_NORMP);
zassert_equal(GD32_OSPEED_GET(pin), GD32_OSPEED_MAX);
}
ZTEST_SUITE(pinctrl_gd32, NULL, NULL, NULL, NULL, NULL);

72
tests/drivers/pinctrl/nrf/src/main.c
View file

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

4
tests/drivers/sensor/generic/src/dummy_sensor.c
View file

@ -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(config->i2c_address, 123, NULL);
zassert_equal(strcmp(config->i2c_name, "dummy I2C"), 0);
zassert_equal(config->i2c_address, 123);
if (i2c != NULL) {
LOG_ERR("Should be Null for %s device!", config->i2c_name);

18
tests/drivers/syscon/src/main.c
View file

@ -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_write_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);
}
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_equal(i, val, NULL);
zassert_ok(syscon_read_reg(dev, i, &val));
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_equal(((uint8_t *)base_addr)[i], i, NULL);
zassert_ok(syscon_write_reg(dev, i, i));
zassert_equal(((uint8_t *)base_addr)[i], i);
}
}

4
tests/drivers/uart/uart_basic_api/src/test_uart_config.c
View file

@ -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));
}

4
tests/drivers/uart/uart_basic_api/src/test_uart_fifo.c
View file

@ -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);
}

2
tests/drivers/uart/uart_basic_api/src/test_uart_pending.c
View file

@ -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);
}

4
tests/drivers/uart/uart_basic_api/src/test_uart_poll.c
View file

@ -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);
}

14
tests/drivers/uart/uart_mix_fifo_poll/src/main.c
View file

@ -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);

10
tests/drivers/uart/uart_pm/src/main.c
View file

@ -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,

8
tests/drivers/watchdog/wdt_basic_api/src/test_wdt.c
View file

@ -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) {

48
tests/kernel/common/src/bitarray.c
View file

@ -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, 12, 32), NULL);
zassert_true(sys_bitarray_is_region_set(&ba, 8, 32), NULL);
zassert_true(sys_bitarray_is_region_set(&ba, 14, 30), NULL);
zassert_true(sys_bitarray_is_region_set(&ba, 20, 24), NULL);
zassert_true(sys_bitarray_is_region_set(&ba, 4, 0));
zassert_true(sys_bitarray_is_region_set(&ba, 12, 32));
zassert_true(sys_bitarray_is_region_set(&ba, 8, 32));
zassert_true(sys_bitarray_is_region_set(&ba, 14, 30));
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, 12, 32), NULL);
zassert_false(sys_bitarray_is_region_cleared(&ba, 8, 32), NULL);
zassert_false(sys_bitarray_is_region_cleared(&ba, 14, 30), NULL);
zassert_false(sys_bitarray_is_region_cleared(&ba, 20, 24), NULL);
zassert_false(sys_bitarray_is_region_cleared(&ba, 4, 0));
zassert_false(sys_bitarray_is_region_cleared(&ba, 12, 32));
zassert_false(sys_bitarray_is_region_cleared(&ba, 8, 32));
zassert_false(sys_bitarray_is_region_cleared(&ba, 14, 30));
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, 12, 32), NULL);
zassert_true(sys_bitarray_is_region_cleared(&ba, 8, 32), NULL);
zassert_true(sys_bitarray_is_region_cleared(&ba, 14, 30), NULL);
zassert_true(sys_bitarray_is_region_cleared(&ba, 20, 24), NULL);
zassert_true(sys_bitarray_is_region_cleared(&ba, 4, 0));
zassert_true(sys_bitarray_is_region_cleared(&ba, 12, 32));
zassert_true(sys_bitarray_is_region_cleared(&ba, 8, 32));
zassert_true(sys_bitarray_is_region_cleared(&ba, 14, 30));
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, 12, 32), NULL);
zassert_false(sys_bitarray_is_region_set(&ba, 8, 32), NULL);
zassert_false(sys_bitarray_is_region_set(&ba, 14, 30), NULL);
zassert_false(sys_bitarray_is_region_set(&ba, 20, 24), NULL);
zassert_false(sys_bitarray_is_region_set(&ba, 4, 0));
zassert_false(sys_bitarray_is_region_set(&ba, 12, 32));
zassert_false(sys_bitarray_is_region_set(&ba, 8, 32));
zassert_false(sys_bitarray_is_region_set(&ba, 14, 30));
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_cleared(&ba, 10, 60), NULL);
zassert_false(sys_bitarray_is_region_set(&ba, 8, 120), NULL);
zassert_false(sys_bitarray_is_region_cleared(&ba, 8, 120), NULL);
zassert_false(sys_bitarray_is_region_set(&ba, 10, 60));
zassert_false(sys_bitarray_is_region_cleared(&ba, 10, 60));
zassert_false(sys_bitarray_is_region_set(&ba, 8, 120));
zassert_false(sys_bitarray_is_region_cleared(&ba, 8, 120));
printk("Testing bit array region bit manipulations\n");

6
tests/kernel/common/src/clock.c
View file

@ -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.stop_count == 0, NULL);
zassert_true(tdata.duration_count == 0);
zassert_true(tdata.stop_count == 0);
/** TESTPOINT: proving duration in millisecond */
init_data_count();

4
tests/kernel/common/src/errno.c
View file

@ -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;

18
tests/kernel/device/src/main.c
View file

@ -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");

70
tests/kernel/events/event_api/src/test_event_apis.c
View file

@ -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(test_events == 0, NULL);
zassert_true(rv == 0);
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(test_events == 0, NULL);
zassert_true(rv == 0);
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(test_events == 0, NULL);
zassert_true(rv == 0);
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(test_events == 0, NULL);
zassert_true(rv == 0);
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(test_events == 0x234, NULL);
zassert_true(rv == 0);
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(test_events == 0x1234, NULL);
zassert_true(rv == 0);
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(test_events == 0, NULL);
zassert_true(test_event.events == 0x123, NULL);
zassert_true(rv == 0);
zassert_true(test_events == 0);
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(test_events == 0, NULL);
zassert_true(test_event.events == 0x248, NULL);
zassert_true(rv == 0);
zassert_true(test_events == 0);
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(test_events == 0x248001, NULL);
zassert_true(test_event.events == 0x248021, NULL);
zassert_true(rv == 0);
zassert_true(test_events == 0x248001);
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(test_events == 0x123450, NULL);
zassert_true(test_event.events == 0x123456, NULL);
zassert_true(rv == 0);
zassert_true(test_events == 0x123450);
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);
}

60
tests/kernel/events/sys_event/src/main.c
View file

@ -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(test_events == 0, NULL);
zassert_true(rv == 0);
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(test_events == 0, NULL);
zassert_true(rv == 0);
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(test_events == 0, NULL);
zassert_true(rv == 0);
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(test_events == 0, NULL);
zassert_true(rv == 0);
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(test_events == 0x234, NULL);
zassert_true(rv == 0);
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(test_events == 0x1234, NULL);
zassert_true(rv == 0);
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(test_events == 0, NULL);
zassert_true(test_event.events == 0x123, NULL);
zassert_true(rv == 0);
zassert_true(test_events == 0);
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(test_events == 0, NULL);
zassert_true(test_event.events == 0x248, NULL);
zassert_true(rv == 0);
zassert_true(test_events == 0);
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(test_events == 0x248001, NULL);
zassert_true(test_event.events == 0x248021, NULL);
zassert_true(rv == 0);
zassert_true(test_events == 0x248001);
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(test_events == 0x123450, NULL);
zassert_true(test_event.events == 0x123456, NULL);
zassert_true(rv == 0);
zassert_true(test_events == 0x123450);
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);
}
/**

16
tests/kernel/fifo/fifo_api/src/test_fifo_contexts.c
View file

@ -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);

2
tests/kernel/fifo/fifo_api/src/test_fifo_loop.c
View file

@ -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]);
}
}

40
tests/kernel/fifo/fifo_timeout/src/main.c
View file

@ -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(is_timeout_in_range(start_time, d->timeout), NULL);
zassert_true(packet == 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(is_timeout_in_range(start_time, timeout), NULL);
zassert_true(packet == 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(is_timeout_in_range(start_time, timeout), NULL);
zassert_true(packet != 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_false(reply_packet.reply, NULL);
zassert_true(packet != 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(reply_packet.reply, NULL);
zassert_true(packet != 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(reply_packet.reply, NULL);
zassert_true(packet != 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);
}
/**

14
tests/kernel/fifo/fifo_usage/src/main.c
View file

@ -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 */

2
tests/kernel/fpu_sharing/generic/src/load_store.c
View file

@ -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

2
tests/kernel/lifo/lifo_api/src/test_lifo_contexts.c
View file

@ -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]);
}
}

2
tests/kernel/lifo/lifo_api/src/test_lifo_loop.c
View file

@ -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]);
}
}

42
tests/kernel/lifo/lifo_usage/src/main.c
View file

@ -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(is_timeout_in_range(start_time, timeout), NULL);
zassert_true(packet != 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_false(reply_packet.reply, NULL);
zassert_true(packet != 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(reply_packet.reply, NULL);
zassert_true(packet != 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(reply_packet.reply, NULL);
zassert_true(packet != 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(is_timeout_in_range(start_time, d->timeout), NULL);
zassert_true(packet == 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);
}
/**

14
tests/kernel/mbox/mbox_api/src/test_mbox_api.c
View file

@ -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.size, sizeof(data[info_type]), NULL);
zassert_equal(mmsg.info, PUT_GET_BUFFER);
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.size, sizeof(data[info_type]), NULL);
zassert_equal(mmsg.info, ASYNC_PUT_GET_BUFFER);
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);

2
tests/kernel/mem_heap/mheap_api_concept/src/test_mheap_api.c
View file

@ -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;
}

2
tests/kernel/mem_heap/mheap_api_concept/src/test_mheap_concept.c
View file

@ -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*/

8
tests/kernel/mem_protect/futex/src/main.c
View file

@ -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);
}
/**

8
tests/kernel/mem_protect/mem_protect/src/kobject.c
View file

@ -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);
}
/****************************************************************************/

8
tests/kernel/mem_protect/mem_protect/src/mem_partition.c
View file

@ -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");
}

10
tests/kernel/mem_protect/obj_validation/src/main.c
View file

@ -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((struct k_sem *)&bad_sem, -EBADF), NULL);
zassert_false(test_object((struct k_sem *)0xFFFFFFFF, -EBADF), NULL);
zassert_false(test_object(&stack_sem, -EBADF));
zassert_false(test_object((struct k_sem *)&bad_sem, -EBADF));
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));
}
}

2
tests/kernel/mem_protect/stackprot/src/main.c
View file

@ -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__);
}

34
tests/kernel/mem_slab/mslab_api/src/test_mslab_api.c
View file

@ -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_true(k_uptime_delta(&tms) < TIMEOUT, NULL);
zassert_equal(err, -ENOMEM);
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_used_get(pslab), BLK_NUM, NULL);
zassert_equal(k_mem_slab_num_free_get(pslab), 0);
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_used_get(pslab), BLK_NUM - 1 - i, 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);
}
}
@ -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_free_get(&mslab), BLK_NUM, NULL);
zassert_equal(k_mem_slab_num_used_get(&mslab), 0);
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_free_get(&kmslab), BLK_NUM, NULL);
zassert_equal(k_mem_slab_num_used_get(&kmslab), 0);
zassert_equal(k_mem_slab_num_free_get(&kmslab), BLK_NUM);
}
/**

2
tests/kernel/mem_slab/mslab_concept/src/test_mslab_alloc_wait.c
View file

@ -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);
}

12
tests/kernel/msgq/msgq_api/src/test_msgq_attrs.c
View file

@ -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

72
tests/kernel/msgq/msgq_api/src/test_msgq_contexts.c
View file

@ -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(read_data, data[0], NULL);
zassert_equal(k_msgq_peek(pmsgq, &read_data), 0);
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(rx_data, data[i], NULL);
zassert_equal(ret, 0);
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_used_get(pmsgq), 0, NULL);
zassert_equal(k_msgq_peek(pmsgq, &read_data), -ENOMSG, NULL);
zassert_equal(k_msgq_num_free_get(pmsgq), MSGQ_LEN);
zassert_equal(k_msgq_num_used_get(pmsgq), 0);
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_used_get(p1), 1, NULL);
zassert_equal(k_msgq_num_free_get(p1), 0);
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);
}

16
tests/kernel/msgq/msgq_api/src/test_msgq_fail.c
View file

@ -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 */

8
tests/kernel/msgq/msgq_api/src/test_msgq_purge.c
View file

@ -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);
}

6
tests/kernel/msgq/msgq_usage/src/main.c
View file

@ -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(service2q, &service2_msgq, NULL);
zassert_equal(service1q, &service1_msgq);
zassert_equal(service2q, &service2_msgq);
/* let the test thread continue */
k_sem_give(&test_continue);

6
tests/kernel/mutex/mutex_api/src/test_mutex_apis.c
View file

@ -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 */

2
tests/kernel/mutex/mutex_error_case/src/test_mutex_error.c
View file

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

6
tests/kernel/mutex/sys_mutex/src/main.c
View file

@ -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 */

32
tests/kernel/pipe/pipe_api/src/test_pipe_contexts.c
View file

@ -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, 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);
}
#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,

36
tests/kernel/pipe/pipe_api/src/test_pipe_fail.c
View file

@ -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_false(k_pipe_alloc_init(p, PIPE_LEN), NULL);
zassert_true(p != 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_false(k_pipe_alloc_init(p, PIPE_LEN), NULL);
zassert_true(p != 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_false(k_pipe_alloc_init(p, PIPE_LEN), NULL);
zassert_true(p != 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_false(k_pipe_alloc_init(p, PIPE_LEN), NULL);
zassert_true(p != 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_false(k_pipe_alloc_init(p, PIPE_LEN), NULL);
zassert_true(p != 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_false(k_pipe_alloc_init(p, PIPE_LEN), NULL);
zassert_true(p != NULL);
zassert_false(k_pipe_alloc_init(p, PIPE_LEN));
ztest_set_fault_valid(true);
k_pipe_put(p, &tx_data, to_wt,

14
tests/kernel/poll/src/test_poll.c
View file

@ -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, 4096, K_NO_WAIT), -ENOMEM, NULL);
zassert_equal(k_poll(events, INT_MAX, K_NO_WAIT), -EINVAL);
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 */

24
tests/kernel/queue/src/test_queue_contexts.c
View file

@ -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(mid_count == 0, NULL);
zassert_true(low_count == 0);
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);

6
tests/kernel/queue/src/test_queue_loop.c
View file

@ -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]));
}
}

22
tests/kernel/queue/src/test_queue_user.c
View file

@ -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_equal(qd->data, i, NULL);
zassert_true(qd != 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_equal(qd->data, i, NULL);
zassert_true(qd != NULL);
zassert_equal(qd->data, i);
}
}

2
tests/kernel/sched/schedule_api/src/test_priority_scheduling.c
View file

@ -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 */

18
tests/kernel/sched/schedule_api/src/test_sched_is_preempt_thread.c
View file

@ -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);
}

8
tests/kernel/sched/schedule_api/src/test_sched_priority.c
View file

@ -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 */

44
tests/kernel/sched/schedule_api/src/test_sched_timeslice_and_lock.c
View file

@ -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[1].executed == 1, NULL);
zassert_true(tdata[0].executed == 1);
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[1].executed == 1, NULL);
zassert_true(tdata[2].executed == 0, NULL);
zassert_true(tdata[0].executed == 1);
zassert_true(tdata[1].executed == 1);
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[1].executed == 1, NULL);
zassert_true(tdata[2].executed == 0, NULL);
zassert_true(tdata[0].executed == 1);
zassert_true(tdata[1].executed == 1);
zassert_true(tdata[2].executed == 0);
/* restore environment */
teardown_threads();

Some files were not shown because too many files have changed in this diff Show more