michaelh/zephyr
1
0
Fork 0
Code Releases Activity

tests: all: Fix remaining issues reported by string validation

Browse source 
Fix issues reported by string validation which was added to strings
used in zassert macros.

Signed-off-by: Krzysztof Chruściński <krzysztof.chruscinski@nordicsemi.no>
This commit is contained in:
Krzysztof Chruściński 2025-05-23 07:45:33 +02:00 • committed by Benjamin Cabé
commit 5acd29e651
29 changed files with 94 additions and 98 deletions
Download patch file Download diff file Expand all files Collapse all files

6
tests/bluetooth/controller/ctrl_isoal/src/sub_sets/isoal_test_rx.c
View file

@ -930,7 +930,7 @@ ZTEST(test_rx_unframed, test_rx_time_wrapping)
-((int64_t)ISOAL_TIME_WRAPPING_POINT_US);
expected_result = ISOAL_TIME_WRAPPING_POINT_US + time_diff + 1;
result = isoal_get_wrapped_time_test(time_now, time_diff);
zassert_equal(result, expected_result, "%lu != %lu", result, expected_result);
zassert_equal(result, expected_result, "%u != %u", result, expected_result);
/* Maximum negative difference from maximum time */
time_now = ISOAL_TIME_WRAPPING_POINT_US;
@ -939,14 +939,14 @@ ZTEST(test_rx_unframed, test_rx_time_wrapping)
-((int64_t)ISOAL_TIME_WRAPPING_POINT_US);
expected_result = ISOAL_TIME_WRAPPING_POINT_US + time_diff;
result = isoal_get_wrapped_time_test(time_now, time_diff);
zassert_equal(result, expected_result, "%lu != %lu", result, expected_result);
zassert_equal(result, expected_result, "%u != %u", result, expected_result);
/* Maximum positive difference from maximum time */
time_now = ISOAL_TIME_WRAPPING_POINT_US;
time_diff = (time_wrapping_point == UINT32_MAX ? INT32_MAX : ISOAL_TIME_WRAPPING_POINT_US);
expected_result = time_diff - 1;
result = isoal_get_wrapped_time_test(time_now, time_diff);
zassert_equal(result, expected_result, "%lu != %lu", result, expected_result);
zassert_equal(result, expected_result, "%u != %u", result, expected_result);
}
/**

4
tests/bluetooth/controller/ctrl_isoal/src/sub_sets/isoal_test_tx.c
View file

@ -121,7 +121,7 @@ static void check_next_custom_source_pdu_write_test_sdu_payload(const uint8_t *d
for (size_t i = 0; i < custom_source_pdu_write_test_sdu_payloads.out_size[pos]; i++) {
zassert_equal(custom_source_pdu_write_test_sdu_payloads.out[pos][i],
data[i],
"[Line %lu] deviation at index %u, expected %u, got %u",
"[Line %u] deviation at index %u, expected %u, got %u",
line,
i,
data[i],
@ -243,7 +243,7 @@ static isoal_status_t custom_source_pdu_emit_test(struct node_tx_iso *node_tx,
source_pdu_emit_test_fake.arg0_##_typ); \
zassert_equal(_payload_count, \
source_pdu_emit_test_handler_fake.arg0_##_typ.payload_count, \
"\t\t%u != %u", \
"\t\t%llu != %u", \
_payload_count, \
source_pdu_emit_test_handler_fake.arg0_##_typ.payload_count); \
zassert_equal(_sdu_fragments, \

2
tests/bluetooth/mesh/blob_io_flash/src/main.c
View file

@ -123,7 +123,7 @@ ZTEST(blob_io_flash, test_chunk_read)
err = blob_flash_stream.io.rd(&blob_flash_stream.io, &xfer, &block, &chunk);
zassert_equal(err, 0, "BLOB I/O read failed with err=%d off=%d len=%d",
err, block.offset + chunk.offset, chunk.size);
err, (int)(block.offset + chunk.offset), (int)chunk.size);
zassert_mem_equal(&chunk_data, &test_data[tests_data_offset], chunk.size,
"Incorrect data written into flash");

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

@ -137,12 +137,10 @@ ZTEST(clock, test_clock_cycle_32)
/*avoid cycle counter wrap around*/
if (c1 > c0) {
/* delta cycle should be greater than 1 milli-second*/
zassert_true((c1 - c0) >
(sys_clock_hw_cycles_per_sec() / MSEC_PER_SEC),
NULL);
zassert_true((c1 - c0) > (sys_clock_hw_cycles_per_sec() / MSEC_PER_SEC));
/* delta NS should be greater than 1 milli-second */
zassert_true((uint32_t)k_cyc_to_ns_floor64(c1 - c0) >
(NSEC_PER_SEC / MSEC_PER_SEC), NULL);
(NSEC_PER_SEC / MSEC_PER_SEC));
}
}

2
tests/kernel/common/src/pow2.c
View file

@ -60,7 +60,7 @@ static void test_pow2_ceil_x(unsigned long test_value,
unsigned int result = Z_POW2_CEIL(x);
zassert_equal(result, expected_result,
"ZPOW2_CEIL(%lu) returned %lu, expected %lu",
"ZPOW2_CEIL(%lu) returned %ld, expected %lu",
test_value, result, expected_result);
}

2
tests/kernel/context/src/main.c
View file

@ -251,7 +251,7 @@ static void _test_kernel_cpu_idle(int atomic)
dt = k_uptime_ticks() - t0;
zassert_true(abs((int32_t) (dt - dur)) <= slop,
"Inaccurate wakeup, idled for %d ticks, expected %d",
dt, dur);
(int)dt, dur);
}
}

2
tests/kernel/interrupt/src/dynamic_isr.c
View file

@ -114,7 +114,7 @@ extern const void *x86_irq_args[];
/**TESTPOINT: pass word-sized parameter to interrupt */
zassert_equal(handler_test_result, ISR_DYN_ARG,
"parameter(0x%lx) in handler is not correct",
"parameter(0x%" PRIxPTR ") in handler is not correct",
handler_test_result);
trigger_irq(vector_num);

2
tests/kernel/semaphore/semaphore/src/main.c
View file

@ -972,7 +972,7 @@ ZTEST(semaphore, test_sem_measure_timeout_from_thread)
zassert_true((diff_ticks < SEC2MS(1)),
"k_sem_take took too long: %d >= %d",
diff_ticks, SEC2MS(1));
(int)diff_ticks, SEC2MS(1));
k_thread_join(&sem_tid_1, K_FOREVER);
}

2
tests/kernel/timer/starve/src/main.c
View file

@ -84,7 +84,7 @@ ZTEST(starve_fn, test_starve)
zassert_equal(na_capture, 0,
"%sTimer alarm fired: %u\n",
na_capture);
tag(), na_capture);
k_timer_start(&tmr, K_MSEC(TIMER_DELAY_ms), K_NO_WAIT);

2
tests/kernel/timer/timer_api/src/main.c
View file

@ -791,7 +791,7 @@ ZTEST_USER(timer_api, test_timeout_abs)
} while (t0 != t1);
zassert_true(t0 + rem_ticks == exp_ticks,
"Wrong remaining: now %lld rem %lld expires %lld (%d)",
"Wrong remaining: now %lld rem %lld expires %lld (%lld)",
(uint64_t)t0, (uint64_t)rem_ticks, (uint64_t)exp_ticks,
t0+rem_ticks-exp_ticks);

4
tests/net/checksum_offload/src/main.c
View file

@ -333,7 +333,7 @@ static int eth_tx_offloading_disabled(const struct device *dev,
zassert_equal_ptr(&eth_context_offloading_disabled, context,
"Context pointers do not match (%p vs %p)",
eth_context_offloading_disabled, context);
&eth_context_offloading_disabled, context);
if (!pkt->buffer) {
DBG("No data to send!\n");
@ -377,7 +377,7 @@ static int eth_tx_offloading_enabled(const struct device *dev,
zassert_equal_ptr(&eth_context_offloading_enabled, context,
"Context pointers do not match (%p vs %p)",
eth_context_offloading_enabled, context);
&eth_context_offloading_enabled, context);
if (!pkt->buffer) {
DBG("No data to send!\n");

2
tests/net/ipv6/src/main.c
View file

@ -1377,7 +1377,7 @@ ZTEST(net_ipv6, test_address_lifetime)
/* The address should be expired now */
zassert_equal(ifaddr->lifetime.timer_timeout, 0,
"Timer timeout set wrong (%llu vs %llu)",
"Timer timeout set wrong (%u vs %u)",
ifaddr->lifetime.timer_timeout, 0);
zassert_equal(ifaddr->lifetime.wrap_counter, 0,
"Wrap counter wrong (%d)", ifaddr->lifetime.wrap_counter);

2
tests/net/lib/lwm2m/content_oma_tlv/src/main.c
View file

@ -1029,7 +1029,7 @@ ZTEST(net_content_oma_tlv_nodata, test_get_opaque_nodata)
ret = oma_tlv_reader.get_opaque(&test_in, value, sizeof(value),
&ctx, &last_block);
zassert_equal(ret, -ENODATA, "Invalid error code returned %d");
zassert_equal(ret, -ENODATA, "Invalid error code returned %d", ret);
}
ZTEST(net_content_oma_tlv, test_get_objlnk)

2
tests/net/lib/lwm2m/content_raw_cbor/src/main.c
View file

@ -997,7 +997,7 @@ ZTEST(net_content_raw_cbor_nodata, test_get_opaque_nodata)
struct lwm2m_opaque_context ctx = { 0 };
ret = cbor_reader.get_opaque(&test_in, value, sizeof(value), &ctx, &last_block);
zassert_equal(ret, -EBADMSG, "Invalid error code returned %d");
zassert_equal(ret, -EBADMSG, "Invalid error code returned %d", ret);
}
ZTEST(net_content_raw_cbor, test_get_objlnk)

62
tests/net/lib/mqtt_sn_client/src/mqtt_sn_client.c
View file

@ -168,22 +168,22 @@ static void mqtt_sn_connect_no_will(struct mqtt_sn_client *client)
err = mqtt_sn_client_init(client, &client_id, &transport, evt_cb, tx, sizeof(tx), rx,
sizeof(rx));
zassert_equal(err, 0, "unexpected error %d");
zassert_equal(err, 0, "unexpected error %d", err);
zassert_true(tp_initialized, "Transport not initialized");
err = mqtt_sn_add_gw(client, gw_id, gw_addr);
zassert_equal(err, 0, "unexpected error %d");
zassert_equal(err, 0, "unexpected error %d", err);
zassert_equal(evt_cb_data.called, 0, "Unexpected event");
zassert_false(sys_slist_is_empty(&client->gateway), "GW not saved.");
err = mqtt_sn_connect(client, false, false);
zassert_equal(err, 0, "unexpected error %d");
zassert_equal(err, 0, "unexpected error %d", err);
assert_msg_send(1, 12, &gw_addr);
zassert_equal(client->state, 0, "Wrong state");
zassert_equal(evt_cb_data.called, 0, "Unexpected event");
err = input(client, connack, sizeof(connack), &gw_addr);
zassert_equal(err, 0, "unexpected error %d");
zassert_equal(err, 0, "unexpected error %d", err);
zassert_equal(client->state, 1, "Wrong state");
zassert_equal(evt_cb_data.called, 1, "NO event");
zassert_equal(evt_cb_data.last_evt.type, MQTT_SN_EVT_CONNECTED, "Wrong event");
@ -197,29 +197,29 @@ static ZTEST(mqtt_sn_client, test_mqtt_sn_handle_advertise)
err = mqtt_sn_client_init(mqtt_client, &client_id, &transport, evt_cb, tx, sizeof(tx), rx,
sizeof(rx));
zassert_equal(err, 0, "unexpected error %d");
zassert_equal(err, 0, "unexpected error %d", err);
err = input(mqtt_client, advertise, sizeof(advertise), &gw_addr);
zassert_equal(err, 0, "unexpected error %d");
zassert_equal(err, 0, "unexpected error %d", err);
zassert_false(sys_slist_is_empty(&mqtt_client->gateway), "GW not saved.");
zassert_equal(evt_cb_data.called, 1, "NO event");
zassert_equal(evt_cb_data.last_evt.type, MQTT_SN_EVT_ADVERTISE, "Wrong event");
err = input(mqtt_client, advertise, sizeof(advertise), &gw_addr);
zassert_equal(err, 0, "unexpected error %d");
zassert_equal(err, 0, "unexpected error %d", err);
zassert_false(sys_slist_is_empty(&mqtt_client->gateway), "GW not saved.");
zassert_equal(sys_slist_len(&mqtt_client->gateway), 1, "Too many Gateways stored.");
zassert_equal(evt_cb_data.called, 2, "Unexpected event");
zassert_equal(evt_cb_data.last_evt.type, MQTT_SN_EVT_ADVERTISE, "Wrong event");
err = mqtt_sn_connect(mqtt_client, false, false);
zassert_equal(err, 0, "unexpected error %d");
zassert_equal(err, 0, "unexpected error %d", err);
assert_msg_send(1, 12, &gw_addr);
zassert_equal(mqtt_client->state, 0, "Wrong state");
zassert_equal(evt_cb_data.called, 2, "Unexpected event");
err = input(mqtt_client, connack, sizeof(connack), &gw_addr);
zassert_equal(err, 0, "unexpected error %d");
zassert_equal(err, 0, "unexpected error %d", err);
zassert_equal(mqtt_client->state, 1, "Wrong state");
zassert_equal(evt_cb_data.called, 3, "NO event");
zassert_equal(evt_cb_data.last_evt.type, MQTT_SN_EVT_CONNECTED, "Wrong event");
@ -240,10 +240,10 @@ static ZTEST(mqtt_sn_client, test_mqtt_sn_add_gw)
err = mqtt_sn_client_init(mqtt_client, &client_id, &transport, evt_cb, tx, sizeof(tx), rx,
sizeof(rx));
zassert_equal(err, 0, "unexpected error %d");
zassert_equal(err, 0, "unexpected error %d", err);
err = mqtt_sn_add_gw(mqtt_client, gw_id, gw_addr);
zassert_equal(err, 0, "unexpected error %d");
zassert_equal(err, 0, "unexpected error %d", err);
zassert_false(sys_slist_is_empty(&mqtt_client->gateway), "GW not saved.");
zassert_equal(evt_cb_data.called, 0, "Unexpected event");
}
@ -260,11 +260,11 @@ static ZTEST(mqtt_sn_client, test_mqtt_sn_search_gw)
err = mqtt_sn_client_init(mqtt_client, &client_id, &transport, evt_cb, tx, sizeof(tx), rx,
sizeof(rx));
zassert_equal(err, 0, "unexpected error %d");
zassert_equal(err, 0, "unexpected error %d", err);
err = k_sem_take(&mqtt_sn_tx_sem, K_NO_WAIT);
err = mqtt_sn_search(mqtt_client, 1);
zassert_equal(err, 0, "unexpected error %d");
zassert_equal(err, 0, "unexpected error %d", err);
err = k_sem_take(&mqtt_sn_tx_sem, K_SECONDS(10));
zassert_equal(err, 0, "Timed out waiting for callback.");
@ -274,7 +274,7 @@ static ZTEST(mqtt_sn_client, test_mqtt_sn_search_gw)
zassert_equal(evt_cb_data.called, 0, "Unexpected event");
err = input(mqtt_client, gwinfo, sizeof(gwinfo), &gw_addr);
zassert_equal(err, 0, "unexpected error %d");
zassert_equal(err, 0, "unexpected error %d", err);
zassert_false(sys_slist_is_empty(&mqtt_client->gateway), "GW not saved.");
zassert_equal(evt_cb_data.last_evt.type, MQTT_SN_EVT_GWINFO, "Wrong event");
}
@ -292,11 +292,11 @@ static ZTEST(mqtt_sn_client, test_mqtt_sn_search_peer)
err = mqtt_sn_client_init(mqtt_client, &client_id, &transport, evt_cb, tx, sizeof(tx), rx,
sizeof(rx));
zassert_equal(err, 0, "unexpected error %d");
zassert_equal(err, 0, "unexpected error %d", err);
err = k_sem_take(&mqtt_sn_tx_sem, K_NO_WAIT);
err = mqtt_sn_search(mqtt_client, 1);
zassert_equal(err, 0, "unexpected error %d");
zassert_equal(err, 0, "unexpected error %d", err);
err = k_sem_take(&mqtt_sn_tx_sem, K_SECONDS(10));
zassert_equal(err, 0, "Timed out waiting for callback.");
@ -306,7 +306,7 @@ static ZTEST(mqtt_sn_client, test_mqtt_sn_search_peer)
zassert_equal(evt_cb_data.called, 0, "Unexpected event");
err = input(mqtt_client, gwinfo, sizeof(gwinfo), &gw_addr);
zassert_equal(err, 0, "unexpected error %d");
zassert_equal(err, 0, "unexpected error %d", err);
zassert_false(sys_slist_is_empty(&mqtt_client->gateway), "GW not saved.");
zassert_equal(evt_cb_data.called, 1, "NO event");
zassert_equal(evt_cb_data.last_evt.type, MQTT_SN_EVT_GWINFO, "Wrong event");
@ -319,16 +319,16 @@ static ZTEST(mqtt_sn_client, test_mqtt_sn_respond_searchgw)
err = mqtt_sn_client_init(mqtt_client, &client_id, &transport, evt_cb, tx, sizeof(tx), rx,
sizeof(rx));
zassert_equal(err, 0, "unexpected error %d");
zassert_equal(err, 0, "unexpected error %d", err);
err = mqtt_sn_add_gw(mqtt_client, gw_id, gw_addr);
zassert_equal(err, 0, "unexpected error %d");
zassert_equal(err, 0, "unexpected error %d", err);
zassert_false(sys_slist_is_empty(&mqtt_client->gateway), "GW not saved.");
zassert_equal(evt_cb_data.called, 0, "Unexpected event");
err = k_sem_take(&mqtt_sn_tx_sem, K_NO_WAIT);
err = input(mqtt_client, searchgw, sizeof(searchgw), &client2_id);
zassert_equal(err, 0, "unexpected error %d");
zassert_equal(err, 0, "unexpected error %d", err);
err = k_sem_take(&mqtt_sn_tx_sem, K_SECONDS(10));
zassert_equal(err, 0, "Timed out waiting for callback.");
@ -353,10 +353,10 @@ static ZTEST(mqtt_sn_client, test_mqtt_sn_connect_will)
err = mqtt_sn_client_init(mqtt_client, &client_id, &transport, evt_cb, tx, sizeof(tx), rx,
sizeof(rx));
zassert_equal(err, 0, "unexpected error %d");
zassert_equal(err, 0, "unexpected error %d", err);
err = mqtt_sn_add_gw(mqtt_client, gw_id, gw_addr);
zassert_equal(err, 0, "unexpected error %d");
zassert_equal(err, 0, "unexpected error %d", err);
zassert_false(sys_slist_is_empty(&mqtt_client->gateway), "GW not saved.");
zassert_equal(evt_cb_data.called, 0, "Unexpected event");
@ -364,23 +364,23 @@ static ZTEST(mqtt_sn_client, test_mqtt_sn_connect_will)
mqtt_client->will_msg = MQTT_SN_DATA_STRING_LITERAL("msg");
err = mqtt_sn_connect(mqtt_client, true, false);
zassert_equal(err, 0, "unexpected error %d");
zassert_equal(err, 0, "unexpected error %d", err);
assert_msg_send(1, 12, &gw_addr);
zassert_equal(mqtt_client->state, 0, "Wrong state");
err = input(mqtt_client, willtopicreq, sizeof(willtopicreq), &gw_addr);
zassert_equal(err, 0, "unexpected error %d");
zassert_equal(err, 0, "unexpected error %d", err);
zassert_equal(mqtt_client->state, 0, "Wrong state");
assert_msg_send(1, 8, &gw_addr);
err = input(mqtt_client, willmsgreq, sizeof(willmsgreq), &gw_addr);
zassert_equal(err, 0, "unexpected error %d");
zassert_equal(err, 0, "unexpected error %d", err);
zassert_equal(mqtt_client->state, 0, "Wrong state");
zassert_equal(evt_cb_data.called, 0, "Unexpected event");
assert_msg_send(1, 5, &gw_addr);
err = input(mqtt_client, connack, sizeof(connack), &gw_addr);
zassert_equal(err, 0, "unexpected error %d");
zassert_equal(err, 0, "unexpected error %d", err);
zassert_equal(mqtt_client->state, 1, "Wrong state");
zassert_equal(evt_cb_data.called, 1, "NO event");
zassert_equal(evt_cb_data.last_evt.type, MQTT_SN_EVT_CONNECTED, "Wrong event");
@ -409,7 +409,7 @@ static ZTEST(mqtt_sn_client, test_mqtt_sn_publish_qos0)
/* Send REGACK in response */
err = input(mqtt_client, regack, sizeof(regack), &gw_addr);
zassert_equal(err, 0, "unexpected error %d");
zassert_equal(err, 0, "unexpected error %d", err);
err = k_sem_take(&mqtt_sn_tx_sem, K_NO_WAIT);
assert_msg_send(0, 0, NULL);
@ -461,7 +461,7 @@ static ZTEST(mqtt_sn_client, test_mqtt_sn_wait_regack)
/* Send REGACK in response */
err = input(mqtt_client, regack1, sizeof(regack1), &gw_addr);
zassert_equal(err, 0, "unexpected error %d");
zassert_equal(err, 0, "unexpected error %d", err);
err = k_sem_take(&mqtt_sn_tx_sem, K_NO_WAIT);
assert_msg_send(0, 0, NULL);
@ -475,7 +475,7 @@ static ZTEST(mqtt_sn_client, test_mqtt_sn_wait_regack)
/* Send next REGACK in response */
err = input(mqtt_client, regack2, sizeof(regack2), &gw_addr);
zassert_equal(err, 0, "unexpected error %d");
zassert_equal(err, 0, "unexpected error %d", err);
err = k_sem_take(&mqtt_sn_tx_sem, K_NO_WAIT);
assert_msg_send(0, 0, NULL);
@ -523,7 +523,7 @@ static ZTEST(mqtt_sn_client, test_mqtt_sn_wait_suback)
assert_msg_send(0, 0, NULL);
err = input(mqtt_client, suback1, sizeof(suback1), &gw_addr);
zassert_ok(err, "unexpected error %d");
zassert_ok(err, "unexpected error %d", err);
err = k_sem_take(&mqtt_sn_tx_sem, K_SECONDS(1));
/* Expect second SUBSCRIBE message */
assert_msg_send(1, 12, &gw_addr);
@ -539,7 +539,7 @@ static ZTEST(mqtt_sn_client, test_mqtt_sn_wait_suback)
zassert_not_ok(err, "Error expected");
err = input(mqtt_client, suback2, sizeof(suback2), &gw_addr);
zassert_ok(err, "unexpected error %d");
zassert_ok(err, "unexpected error %d", err);
err = k_sem_take(&mqtt_sn_tx_sem, K_SECONDS(1));
/* Expect UNSUBSCRIBE message */
assert_msg_send(1, 12, &gw_addr);

2
tests/net/lib/tls_credentials/src/main.c
View file

@ -28,7 +28,7 @@ static void test_credential_add(void)
for (i = 0; i < CONFIG_TLS_MAX_CREDENTIALS_NUMBER - 2; i++) {
ret = tls_credential_add(i, TLS_CREDENTIAL_CA_CERTIFICATE,
test_ca_cert, sizeof(test_ca_cert));
zassert_equal(ret, 0, "Failed to add credential %d %d", i);
zassert_equal(ret, 0, "Failed to add credential %d", i);
}
/* Function should allow to add credentials of different types

4
tests/net/offloaded_netdev/src/main.c
View file

@ -359,13 +359,13 @@ static void test_addr_add_common(struct net_if *test_iface, const char *off_type
lookup_iface = NULL;
zassert_equal_ptr(net_if_ipv4_addr_lookup(&test_addr_ipv4, &lookup_iface),
ipv4_addr,
"Failed to find IPv4 address on a %s offloaded interface");
"Failed to find IPv4 address on a %s offloaded interface", off_type);
zassert_equal_ptr(lookup_iface, test_iface, "Wrong interface");
lookup_iface = NULL;
zassert_equal_ptr(net_if_ipv6_addr_lookup(&test_addr_ipv6, &lookup_iface),
ipv6_addr,
"Failed to find IPv6 address on a %s offloaded interface");
"Failed to find IPv6 address on a %s offloaded interface", off_type);
zassert_equal_ptr(lookup_iface, test_iface, "Wrong interface");
zassert_true(net_if_ipv4_addr_rm(test_iface, &test_addr_ipv4),

2
tests/net/socket/af_packet/src/main.c
View file

@ -259,7 +259,7 @@ static void prepare_udp_socket(int *sock, struct sockaddr_in *sockaddr, uint16_t
int ret;
*sock = zsock_socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
zassert_true(*sock >= 0, "Cannot create DGRAM (UDP) socket (%d)", sock);
zassert_true(*sock >= 0, "Cannot create DGRAM (UDP) socket (%d)", *sock);
sockaddr->sin_family = AF_INET;
sockaddr->sin_port = htons(local_port);

2
tests/net/socket/tls/src/main.c
View file

@ -67,7 +67,7 @@ static void test_config_psk(int s_sock, int c_sock)
zassert_equal(tls_credential_add(PSK_TAG, TLS_CREDENTIAL_PSK,
psk, sizeof(psk)),
0, "Failed to register PSK %d");
0, "Failed to register PSK");
zassert_equal(tls_credential_add(PSK_TAG, TLS_CREDENTIAL_PSK_ID,
psk_id, strlen(psk_id)),
0, "Failed to register PSK ID");

2
tests/net/socket/udp/src/main.c
View file

@ -2446,7 +2446,7 @@ ZTEST(net_socket_udp, test_36_v6_address_removal)
}
ifaddr = net_if_ipv6_addr_lookup(&my_addr1, &iface);
zassert_equal(ifaddr->atomic_ref, 1, "Ref count is wrong (%ld vs %ld)",
zassert_equal(ifaddr->atomic_ref, 1, "Ref count is wrong (%ld vs %d)",
ifaddr->atomic_ref, 1);
prepare_sock_udp_v6(MY_IPV6_ADDR_ETH, CLIENT_PORT, &client_sock, &client_addr);

12
tests/net/tx_timestamp/src/main.c
View file

@ -171,7 +171,7 @@ static void timestamp_callback(struct net_pkt *pkt)
*/
zassert_true(pkt->timestamp.nanosecond > pkt->timestamp.second,
"Timestamp not working ok (%d < %d)\n",
pkt->timestamp.nanosecond, pkt->timestamp.second);
(int)pkt->timestamp.nanosecond, (int)pkt->timestamp.second);
}
/* The pkt was ref'ed in send_some_data()() */
@ -201,7 +201,7 @@ void test_timestamp_setup(void)
net_if_call_timestamp_cb(pkt);
zassert_true(timestamp_cb_called, "Timestamp callback not called\n");
zassert_equal(atomic_get(&pkt->atomic_ref), 0, "Pkt %p not released\n");
zassert_equal(atomic_get(&pkt->atomic_ref), 0, "Pkt %p not released\n", pkt);
}
static void timestamp_callback_2(struct net_pkt *pkt)
@ -214,7 +214,7 @@ static void timestamp_callback_2(struct net_pkt *pkt)
*/
zassert_true(pkt->timestamp.nanosecond > pkt->timestamp.second,
"Timestamp not working ok (%d < %d)\n",
pkt->timestamp.nanosecond, pkt->timestamp.second);
(int)pkt->timestamp.nanosecond, (int)pkt->timestamp.second);
}
zassert_equal(eth_interfaces[1], net_pkt_iface(pkt),
@ -247,7 +247,7 @@ void test_timestamp_setup_2nd_iface(void)
net_if_call_timestamp_cb(pkt);
zassert_true(timestamp_cb_called, "Timestamp callback not called\n");
zassert_equal(atomic_get(&pkt->atomic_ref), 0, "Pkt %p not released\n");
zassert_equal(atomic_get(&pkt->atomic_ref), 0, "Pkt %p not released\n", pkt);
}
void test_timestamp_setup_all(void)
@ -272,7 +272,7 @@ void test_timestamp_setup_all(void)
net_if_call_timestamp_cb(pkt);
zassert_true(timestamp_cb_called, "Timestamp callback not called\n");
zassert_equal(atomic_get(&pkt->atomic_ref), 0, "Pkt %p not released\n");
zassert_equal(atomic_get(&pkt->atomic_ref), 0, "Pkt %p not released\n", pkt);
net_if_unregister_timestamp_cb(&timestamp_cb_3);
}
@ -296,7 +296,7 @@ void test_timestamp_cleanup(void)
net_if_call_timestamp_cb(pkt);
zassert_false(timestamp_cb_called, "Timestamp callback called\n");
zassert_false(atomic_get(&pkt->atomic_ref) < 1, "Pkt %p released\n");
zassert_false(atomic_get(&pkt->atomic_ref) < 1, "Pkt %p released\n", pkt);
net_pkt_unref(pkt);
}

14
tests/net/utils/src/main.c
View file

@ -821,8 +821,8 @@ ZTEST(test_utils_fn, test_addr_parse)
zassert_true(
net_ipv4_addr_cmp(
&net_sin(&addr)->sin_addr,
&parse_ipv4_entries[i].result.sin_addr),
parse_ipv4_entries[i].address);
&parse_ipv4_entries[i].result.sin_addr) ==
parse_ipv4_entries[i].verdict);
zassert_true(net_sin(&addr)->sin_port ==
parse_ipv4_entries[i].result.sin_port,
"IPv4 port");
@ -850,8 +850,8 @@ ZTEST(test_utils_fn, test_addr_parse)
zassert_true(
net_ipv6_addr_cmp(
&net_sin6(&addr)->sin6_addr,
&parse_ipv6_entries[i].result.sin6_addr),
parse_ipv6_entries[i].address);
&parse_ipv6_entries[i].result.sin6_addr) ==
parse_ipv6_entries[i].verdict);
zassert_true(net_sin6(&addr)->sin6_port ==
parse_ipv6_entries[i].result.sin6_port,
"IPv6 port");
@ -1233,8 +1233,7 @@ ZTEST(test_utils_fn, test_addr_parse_mask)
zassert_true(
net_ipv4_addr_cmp(
&net_sin(&addr)->sin_addr,
&parse_ipv4_entries[i].result.sin_addr),
parse_ipv4_entries[i].address);
&parse_ipv4_entries[i].result.sin_addr));
zassert_true(net_sin(&addr)->sin_port == 0,
"IPv4 port");
zassert_true(net_sin(&addr)->sin_family ==
@ -1262,8 +1261,7 @@ ZTEST(test_utils_fn, test_addr_parse_mask)
zassert_true(
net_ipv6_addr_cmp(
&net_sin6(&addr)->sin6_addr,
&parse_ipv6_entries[i].result.sin6_addr),
parse_ipv6_entries[i].address);
&parse_ipv6_entries[i].result.sin6_addr));
zassert_true(net_sin6(&addr)->sin6_port == 0,
"IPv6 port");
zassert_true(net_sin6(&addr)->sin6_family ==

12
tests/net/virtual/src/main.c
View file

@ -116,7 +116,7 @@ static int eth_tx(const struct device *dev, struct net_pkt *pkt)
zassert_equal_ptr(&eth_context, context,
"Context pointers do not match (%p vs %p)",
eth_context, context);
&eth_context, context);
if (!pkt->buffer) {
DBG("No data to send!\n");
@ -686,7 +686,7 @@ ZTEST(net_virtual, test_virtual_04_get_mtu)
ret = net_mgmt(NET_REQUEST_VIRTUAL_INTERFACE_GET_MTU,
iface, &params, sizeof(params));
zassert_equal(ret, 0, "Cannot get interface %d MTU (%d)",
zassert_equal(ret, 0, "Cannot get interface %d MTU %d (%d)",
net_if_get_by_iface(iface), params.mtu, ret);
zassert_equal(params.mtu, MTU,
@ -978,7 +978,7 @@ static void test_virtual_recv_data_from_tunnel(int remote_ip,
if (peer_addr.sa_family == AF_INET) {
outer = create_outer(attached, AF_INET, IPPROTO_IP,
sizeof(struct net_ipv4_hdr), 0);
zassert_not_null(outer, "Cannot allocate %s pkt", outer);
zassert_not_null(outer, "Cannot allocate pkt");
ret = net_ipv4_create(outer, &net_sin(&src_addr)->sin_addr,
&net_sin(&dst_addr)->sin_addr);
@ -987,7 +987,7 @@ static void test_virtual_recv_data_from_tunnel(int remote_ip,
} else {
outer = create_outer(attached, AF_INET6, IPPROTO_IPV6,
sizeof(struct net_ipv6_hdr), 0);
zassert_not_null(outer, "Cannot allocate %s pkt", outer);
zassert_not_null(outer, "Cannot allocate %p pkt", outer);
ret = net_ipv6_create(outer, &net_sin6(&src_addr)->sin6_addr,
&net_sin6(&dst_addr)->sin6_addr);
@ -1000,7 +1000,7 @@ static void test_virtual_recv_data_from_tunnel(int remote_ip,
sizeof(struct net_ipv4_hdr),
sizeof(struct net_udp_hdr) +
strlen(test_data));
zassert_not_null(inner, "Cannot allocate %s pkt", inner);
zassert_not_null(inner, "Cannot allocate pkt");
ret = net_ipv4_create(inner, &net_sin(&inner_src)->sin_addr,
innerv4);
@ -1013,7 +1013,7 @@ static void test_virtual_recv_data_from_tunnel(int remote_ip,
sizeof(struct net_ipv6_hdr),
sizeof(struct net_udp_hdr) +
strlen(test_data));
zassert_not_null(inner, "Cannot allocate %s pkt", inner);
zassert_not_null(inner, "Cannot allocate pkt");
ret = net_ipv6_create(inner, &net_sin6(&inner_src)->sin6_addr,
innerv6);

2
tests/net/vlan/src/main.c
View file

@ -203,7 +203,7 @@ static int eth_tx(const struct device *dev, struct net_pkt *pkt)
zassert_equal_ptr(&eth_vlan_context, context,
"Context pointers do not match (%p vs %p)",
eth_vlan_context, context);
&eth_vlan_context, context);
if (!pkt->buffer) {
DBG("No data to send!\n");

2
tests/posix/common/src/pthread_attr.c
View file

@ -513,7 +513,7 @@ ZTEST(pthread_attr, test_pthread_attr_policy_and_priority_limits)
zassert_not_equal(-1, param.sched_priority,
"sched_get_priority_%s(%s) failed: %d",
i == 0 ? "min" : "max", policy_names[policy], errno);
zassert_ok(errno, "sched_get_priority_%s(%s) set errno to %s",
zassert_ok(errno, "sched_get_priority_%s(%s) set errno to %d",
i == 0 ? "min" : "max", policy_names[policy], errno);
}

4
tests/posix/eventfd/src/_main.c
View file

@ -53,7 +53,7 @@ void eventfd_poll_unset_common(int fd)
ret = eventfd_read(fd, &val);
zassert_equal(ret, 0, "read ret %d", ret);
zassert_equal(val, 2*TESTVAL, "val == %d, expected %d", val, TESTVAL);
zassert_equal(val, 2*TESTVAL, "val == %d, expected %d", (int)val, TESTVAL);
/* eventfd shall block on subsequent reads */
@ -74,7 +74,7 @@ void eventfd_poll_set_common(int fd)
ret = eventfd_read(fd, &val);
zassert_equal(ret, 0, "read ret %d", ret);
zassert_equal(val, TESTVAL, "val == %d", val);
zassert_equal(val, TESTVAL, "val == %d", (int)val);
event = POLLIN;
ret = is_blocked(fd, &event);

8
tests/posix/single_process/src/sysconf.c
View file

@ -15,17 +15,17 @@ ZTEST(posix_single_process, test_posix_sysconf)
/* SC that's implemented */
ret = sysconf(_SC_VERSION);
zassert_equal(ret, _POSIX_VERSION, "sysconf returned unexpected value %d", ret);
zassert_equal(ret, _POSIX_VERSION, "sysconf returned unexpected value %ld", ret);
/* SC that's not implemented */
ret = sysconf(_SC_MEMLOCK_RANGE);
zassert_equal(ret, -1, "sysconf returned unexpected value %d", ret);
zassert_equal(ret, -1, "sysconf returned unexpected value %ld", ret);
/* SC that value depends on target's configuration */
ret = sysconf(_SC_SEMAPHORES);
if (IS_ENABLED(CONFIG_POSIX_THREADS)) {
zassert_equal(ret, _POSIX_VERSION, "sysconf returned unexpected value %d", ret);
zassert_equal(ret, _POSIX_VERSION, "sysconf returned unexpected value %ld", ret);
} else {
zassert_equal(ret, -1L, "sysconf returned unexpected value %d", ret);
zassert_equal(ret, -1L, "sysconf returned unexpected value %ld", ret);
}
}

20
tests/posix/timers/src/nanosleep.c
View file

@ -35,8 +35,8 @@ static void common_errors(int selection, clockid_t clock_id, int flags)
zassert_equal(select_nanosleep(selection, clock_id, flags, NULL, &rem), -1);
zassert_equal(errno, EFAULT);
/* Expect rem to be the same when function returns */
zassert_equal(rem.tv_sec, 0, "actual: %d expected: %d", rem.tv_sec, 0);
zassert_equal(rem.tv_nsec, 0, "actual: %d expected: %d", rem.tv_nsec, 0);
zassert_equal(rem.tv_sec, 0, "actual: %d expected: %d", (int)rem.tv_sec, 0);
zassert_equal(rem.tv_nsec, 0, "actual: %d expected: %d", (int)rem.tv_nsec, 0);
/* negative times */
errno = 0;
@ -75,8 +75,8 @@ static void common_errors(int selection, clockid_t clock_id, int flags)
/* Sleep for 0.0 s. Expect req & rem to be the same when function returns */
zassert_equal(select_nanosleep(selection, clock_id, flags, &req, &rem), 0);
zassert_equal(errno, 0);
zassert_equal(rem.tv_sec, 0, "actual: %d expected: %d", rem.tv_sec, 0);
zassert_equal(rem.tv_nsec, 0, "actual: %d expected: %d", rem.tv_nsec, 0);
zassert_equal(rem.tv_sec, 0, "actual: %d expected: %d", (int)rem.tv_sec, 0);
zassert_equal(rem.tv_nsec, 0, "actual: %d expected: %d", (int)rem.tv_nsec, 0);
/*
* req and rem point to the same timespec
@ -87,8 +87,8 @@ static void common_errors(int selection, clockid_t clock_id, int flags)
req = (struct timespec){.tv_sec = 0, .tv_nsec = 1};
zassert_equal(select_nanosleep(selection, clock_id, flags, &req, &req), 0);
zassert_equal(errno, 0);
zassert_equal(req.tv_sec, 0, "actual: %d expected: %d", req.tv_sec, 0);
zassert_equal(req.tv_nsec, 0, "actual: %d expected: %d", req.tv_nsec, 0);
zassert_equal(req.tv_sec, 0, "actual: %d expected: %d", (int)req.tv_sec, 0);
zassert_equal(req.tv_nsec, 0, "actual: %d expected: %d", (int)req.tv_nsec, 0);
}
ZTEST(posix_timers, test_nanosleep_errors_errno)
@ -106,14 +106,14 @@ ZTEST(posix_timers, test_clock_nanosleep_errors_errno)
/* Absolute timeout in the past. */
clock_gettime(CLOCK_MONOTONIC, &req);
zassert_equal(clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &req, &rem), 0);
zassert_equal(rem.tv_sec, 0, "actual: %d expected: %d", rem.tv_sec, 0);
zassert_equal(rem.tv_nsec, 0, "actual: %d expected: %d", rem.tv_nsec, 0);
zassert_equal(rem.tv_sec, 0, "actual: %d expected: %d", (int)rem.tv_sec, 0);
zassert_equal(rem.tv_nsec, 0, "actual: %d expected: %d", (int)rem.tv_nsec, 0);
/* Absolute timeout in the past relative to the realtime clock. */
clock_gettime(CLOCK_REALTIME, &req);
zassert_equal(clock_nanosleep(CLOCK_REALTIME, TIMER_ABSTIME, &req, &rem), 0);
zassert_equal(rem.tv_sec, 0, "actual: %d expected: %d", rem.tv_sec, 0);
zassert_equal(rem.tv_nsec, 0, "actual: %d expected: %d", rem.tv_nsec, 0);
zassert_equal(rem.tv_sec, 0, "actual: %d expected: %d", (int)rem.tv_sec, 0);
zassert_equal(rem.tv_nsec, 0, "actual: %d expected: %d", (int)rem.tv_nsec, 0);
}
ZTEST(posix_timers, test_nanosleep_execution)

4
tests/posix/xsi_single_process/src/gethostid.c
View file

@ -18,6 +18,6 @@ ZTEST(xsi_single_process, test_gethostid)
uint32_t id32 = gethostid();
zassert_equal((uint32_t)id, id32, "gethostid() returned inconsistent values", (uint32_t)id,
id32);
zassert_equal((uint32_t)id, id32, "gethostid() returned inconsistent values %u (exp: %u)",
(uint32_t)id, id32);
}