From 9f8ddd038ed2fb199ceb36f094cbdb8fb84ddb07 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jere=20Lepp=C3=A4nen?= Date: Mon, 26 Feb 2024 11:41:41 +0200 Subject: validation: use fewer CU_ASSERT types MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Use only CU_ASSERT and CU_ASSERT_FATAL CUnit assert types. This makes the test code more readable, and there's no benefit in using the other assert types. Signed-off-by: Jere Leppänen Reviewed-by: Matias Elo Reviewed-by: Janne Peltonen --- test/common/mask_common.c | 19 +- test/validation/api/atomic/atomic.c | 2 +- test/validation/api/barrier/barrier.c | 2 +- .../api/classification/odp_classification_basic.c | 10 +- test/validation/api/crypto/odp_crypto_test_inp.c | 24 +-- test/validation/api/errno/errno.c | 4 +- test/validation/api/ipsec/ipsec.c | 184 ++++++++----------- test/validation/api/ipsec/ipsec_test_in.c | 120 ++++++------ test/validation/api/ipsec/ipsec_test_out.c | 201 ++++++++++----------- test/validation/api/lock/lock.c | 2 +- test/validation/api/packet/packet.c | 89 ++++----- test/validation/api/pktio/pktio.c | 66 +++---- test/validation/api/pool/pool.c | 2 +- test/validation/api/scheduler/scheduler.c | 14 +- test/validation/api/shmem/shmem.c | 36 ++-- test/validation/api/traffic_mngr/traffic_mngr.c | 22 +-- 16 files changed, 367 insertions(+), 430 deletions(-) diff --git a/test/common/mask_common.c b/test/common/mask_common.c index 65c9c6629..4201584e1 100644 --- a/test/common/mask_common.c +++ b/test/common/mask_common.c @@ -123,8 +123,8 @@ MASK_TESTFUNC(to_from_str) /* check that returned size matches original (with NULL): */ CU_ASSERT(str_sz == (int32_t)stringlen(buf_in) + 1); - /* check that returned string matches original (with NULL): */ - CU_ASSERT_NSTRING_EQUAL(buf_out, buf_in, stringlen(buf_in) + 1); + /* check that returned string matches original: */ + CU_ASSERT(!strcmp(buf_out, buf_in)); /* check that no extra buffer writes occurred: */ CU_ASSERT(buf_out[stringlen(buf_in) + 2] == FILLING_PATTERN); @@ -150,8 +150,7 @@ MASK_TESTFUNC(to_from_str) stringlen(TEST_MASK_0) + 1); CU_ASSERT(str_sz == (int32_t)stringlen(TEST_MASK_0) + 1); - CU_ASSERT_NSTRING_EQUAL(buf_out, TEST_MASK_0, - stringlen(TEST_MASK_0) + 1); + CU_ASSERT(!strcmp(buf_out, TEST_MASK_0)); free(buf_out); free(buf_in); @@ -167,7 +166,7 @@ MASK_TESTFUNC(equal) _odp_mask_from_str(&mask2, TEST_MASK_0); _odp_mask_from_str(&mask3, TEST_MASK_NONE); CU_ASSERT(_odp_mask_equal(&mask1, &mask2)); - CU_ASSERT_FALSE(_odp_mask_equal(&mask1, &mask3)); + CU_ASSERT(!_odp_mask_equal(&mask1, &mask3)); if (mask_capacity() < 4) return; @@ -176,7 +175,7 @@ MASK_TESTFUNC(equal) _odp_mask_from_str(&mask2, TEST_MASK_0_2); _odp_mask_from_str(&mask3, TEST_MASK_1_2); CU_ASSERT(_odp_mask_equal(&mask1, &mask2)); - CU_ASSERT_FALSE(_odp_mask_equal(&mask1, &mask3)); + CU_ASSERT(!_odp_mask_equal(&mask1, &mask3)); if (mask_capacity() < 8) return; @@ -185,7 +184,7 @@ MASK_TESTFUNC(equal) _odp_mask_from_str(&mask2, TEST_MASK_0_2_4_6); _odp_mask_from_str(&mask3, TEST_MASK_1_2_4_6); CU_ASSERT(_odp_mask_equal(&mask1, &mask2)); - CU_ASSERT_FALSE(_odp_mask_equal(&mask1, &mask3)); + CU_ASSERT(!_odp_mask_equal(&mask1, &mask3)); } MASK_TESTFUNC(zero) @@ -256,16 +255,16 @@ MASK_TESTFUNC(isset) CU_ASSERT(_odp_mask_isset(&mask1, 0)); _odp_mask_from_str(&mask1, TEST_MASK_NONE); - CU_ASSERT_FALSE(_odp_mask_isset(&mask1, 0)); + CU_ASSERT(!_odp_mask_isset(&mask1, 0)); if (mask_capacity() < 4) return; _odp_mask_from_str(&mask1, TEST_MASK_0_2); CU_ASSERT(_odp_mask_isset(&mask1, 0)); - CU_ASSERT_FALSE(_odp_mask_isset(&mask1, 1)); + CU_ASSERT(!_odp_mask_isset(&mask1, 1)); CU_ASSERT(_odp_mask_isset(&mask1, 2)); - CU_ASSERT_FALSE(_odp_mask_isset(&mask1, 3)); + CU_ASSERT(!_odp_mask_isset(&mask1, 3)); } MASK_TESTFUNC(count) diff --git a/test/validation/api/atomic/atomic.c b/test/validation/api/atomic/atomic.c index fab982462..31e4ff3f7 100644 --- a/test/validation/api/atomic/atomic.c +++ b/test/validation/api/atomic/atomic.c @@ -55,7 +55,7 @@ static void thread_init(void) global_shm = odp_shm_lookup(GLOBAL_SHM_NAME); global_mem = odp_shm_addr(global_shm); - CU_ASSERT_PTR_NOT_NULL(global_mem); + CU_ASSERT(global_mem != NULL); } static void test_atomic_inc_32(void) diff --git a/test/validation/api/barrier/barrier.c b/test/validation/api/barrier/barrier.c index 7dc9a44c6..5df1f16c4 100644 --- a/test/validation/api/barrier/barrier.c +++ b/test/validation/api/barrier/barrier.c @@ -106,7 +106,7 @@ static per_thread_mem_t *thread_init(void) global_shm = odp_shm_lookup(GLOBAL_SHM_NAME); global_mem = odp_shm_addr(global_shm); - CU_ASSERT_PTR_NOT_NULL(global_mem); + CU_ASSERT(global_mem != NULL); per_thread_mem->global_mem = global_mem; diff --git a/test/validation/api/classification/odp_classification_basic.c b/test/validation/api/classification/odp_classification_basic.c index ca0b58ad5..921478928 100644 --- a/test/validation/api/classification/odp_classification_basic.c +++ b/test/validation/api/classification/odp_classification_basic.c @@ -22,14 +22,14 @@ static void test_defaults(uint8_t fill) CU_ASSERT(cos_param.action == ODP_COS_ACTION_ENQUEUE); CU_ASSERT(cos_param.num_queue == 1); - CU_ASSERT_EQUAL(cos_param.stats_enable, false); - CU_ASSERT_EQUAL(cos_param.red.enable, false); - CU_ASSERT_EQUAL(cos_param.bp.enable, false); - CU_ASSERT_EQUAL(cos_param.vector.enable, false); + CU_ASSERT(cos_param.stats_enable == false); + CU_ASSERT(cos_param.red.enable == false); + CU_ASSERT(cos_param.bp.enable == false); + CU_ASSERT(cos_param.vector.enable == false); memset(&pmr_param, fill, sizeof(pmr_param)); odp_cls_pmr_param_init(&pmr_param); - CU_ASSERT_EQUAL(pmr_param.range_term, false); + CU_ASSERT(pmr_param.range_term == false); } static void cls_default_values(void) diff --git a/test/validation/api/crypto/odp_crypto_test_inp.c b/test/validation/api/crypto/odp_crypto_test_inp.c index 532aaf525..7608805e0 100644 --- a/test/validation/api/crypto/odp_crypto_test_inp.c +++ b/test/validation/api/crypto/odp_crypto_test_inp.c @@ -34,18 +34,18 @@ static void test_defaults(uint8_t fill) memset(¶m, fill, sizeof(param)); odp_crypto_session_param_init(¶m); - CU_ASSERT_EQUAL(param.op, ODP_CRYPTO_OP_ENCODE); - CU_ASSERT_EQUAL(param.op_type, ODP_CRYPTO_OP_TYPE_LEGACY); - CU_ASSERT_EQUAL(param.cipher_range_in_bits, false); - CU_ASSERT_EQUAL(param.auth_range_in_bits, false); - CU_ASSERT_EQUAL(param.auth_cipher_text, false); - CU_ASSERT_EQUAL(param.null_crypto_enable, false); - CU_ASSERT_EQUAL(param.op_mode, ODP_CRYPTO_SYNC); - CU_ASSERT_EQUAL(param.cipher_alg, ODP_CIPHER_ALG_NULL); - CU_ASSERT_EQUAL(param.cipher_iv_len, 0); - CU_ASSERT_EQUAL(param.auth_alg, ODP_AUTH_ALG_NULL); - CU_ASSERT_EQUAL(param.auth_iv_len, 0); - CU_ASSERT_EQUAL(param.auth_aad_len, 0); + CU_ASSERT(param.op == ODP_CRYPTO_OP_ENCODE); + CU_ASSERT(param.op_type == ODP_CRYPTO_OP_TYPE_LEGACY); + CU_ASSERT(param.cipher_range_in_bits == false); + CU_ASSERT(param.auth_range_in_bits == false); + CU_ASSERT(param.auth_cipher_text == false); + CU_ASSERT(param.null_crypto_enable == false); + CU_ASSERT(param.op_mode == ODP_CRYPTO_SYNC); + CU_ASSERT(param.cipher_alg == ODP_CIPHER_ALG_NULL); + CU_ASSERT(param.cipher_iv_len == 0); + CU_ASSERT(param.auth_alg == ODP_AUTH_ALG_NULL); + CU_ASSERT(param.auth_iv_len == 0); + CU_ASSERT(param.auth_aad_len == 0); } static void test_default_values(void) diff --git a/test/validation/api/errno/errno.c b/test/validation/api/errno/errno.c index 70708ce01..ec90547dd 100644 --- a/test/validation/api/errno/errno.c +++ b/test/validation/api/errno/errno.c @@ -13,9 +13,9 @@ static void errno_test_odp_errno_sunny_day(void) odp_errno_zero(); my_errno = odp_errno(); - CU_ASSERT_TRUE(my_errno == 0); + CU_ASSERT(my_errno == 0); odp_errno_print("odp_errno"); - CU_ASSERT_PTR_NOT_NULL(odp_errno_str(my_errno)); + CU_ASSERT(odp_errno_str(my_errno) != NULL); } odp_testinfo_t errno_suite[] = { diff --git a/test/validation/api/ipsec/ipsec.c b/test/validation/api/ipsec/ipsec.c index 5ad7bd48d..7be3ad30f 100644 --- a/test/validation/api/ipsec/ipsec.c +++ b/test/validation/api/ipsec/ipsec.c @@ -457,8 +457,8 @@ static void ipsec_status_event_handle(odp_event_t ev_status, }; CU_ASSERT_FATAL(ODP_EVENT_INVALID != ev_status); - CU_ASSERT_EQUAL(1, odp_event_is_valid(ev_status)); - CU_ASSERT_EQUAL_FATAL(ODP_EVENT_IPSEC_STATUS, odp_event_type(ev_status)); + CU_ASSERT(1 == odp_event_is_valid(ev_status)); + CU_ASSERT_FATAL(ODP_EVENT_IPSEC_STATUS == odp_event_type(ev_status)); /* No user area or source pool for IPsec status events */ CU_ASSERT(odp_event_user_area(ev_status) == NULL); @@ -467,17 +467,17 @@ static void ipsec_status_event_handle(odp_event_t ev_status, CU_ASSERT(odp_event_pool(ev_status) == ODP_POOL_INVALID); - CU_ASSERT_EQUAL(0, odp_ipsec_status(&status, ev_status)); - CU_ASSERT_EQUAL(ODP_IPSEC_STATUS_WARN, status.id); - CU_ASSERT_EQUAL(sa, status.sa); - CU_ASSERT_EQUAL(0, status.result); + CU_ASSERT(0 == odp_ipsec_status(&status, ev_status)); + CU_ASSERT(ODP_IPSEC_STATUS_WARN == status.id); + CU_ASSERT(sa == status.sa); + CU_ASSERT(0 == status.result); if (IPSEC_TEST_EXPIRY_IGNORED != sa_expiry) { if (IPSEC_TEST_EXPIRY_SOFT_PKT == sa_expiry) { - CU_ASSERT_EQUAL(1, status.warn.soft_exp_packets); + CU_ASSERT(1 == status.warn.soft_exp_packets); sa_expiry_notified = true; } else if (IPSEC_TEST_EXPIRY_SOFT_BYTE == sa_expiry) { - CU_ASSERT_EQUAL(1, status.warn.soft_exp_bytes); + CU_ASSERT(1 == status.warn.soft_exp_bytes); sa_expiry_notified = true; } } @@ -502,51 +502,47 @@ void ipsec_sa_destroy(odp_ipsec_sa_t sa) odp_ipsec_status_t status; int ret; - CU_ASSERT_EQUAL(IPSEC_SA_CTX, odp_ipsec_sa_context(sa)); + CU_ASSERT(IPSEC_SA_CTX == odp_ipsec_sa_context(sa)); - CU_ASSERT_EQUAL(ODP_IPSEC_OK, odp_ipsec_sa_disable(sa)); + CU_ASSERT(ODP_IPSEC_OK == odp_ipsec_sa_disable(sa)); if (ODP_QUEUE_INVALID != suite_context.queue) { event = recv_event(suite_context.queue, EVENT_WAIT_TIME); CU_ASSERT(odp_event_is_valid(event) == 1); - CU_ASSERT_EQUAL(ODP_EVENT_IPSEC_STATUS, odp_event_type(event)); + CU_ASSERT(ODP_EVENT_IPSEC_STATUS == odp_event_type(event)); ret = odp_ipsec_status(&status, event); CU_ASSERT(ret == 0); if (ret == 0) { - CU_ASSERT_EQUAL(ODP_IPSEC_STATUS_SA_DISABLE, status.id); - CU_ASSERT_EQUAL(sa, status.sa); - CU_ASSERT_EQUAL(0, status.result); - CU_ASSERT_EQUAL(0, status.warn.all); + CU_ASSERT(ODP_IPSEC_STATUS_SA_DISABLE == status.id); + CU_ASSERT(sa == status.sa); + CU_ASSERT(0 == status.result); + CU_ASSERT(0 == status.warn.all); } odp_event_free(event); } - CU_ASSERT_EQUAL(ODP_IPSEC_OK, odp_ipsec_sa_destroy(sa)); + CU_ASSERT(ODP_IPSEC_OK == odp_ipsec_sa_destroy(sa)); } odp_packet_t ipsec_packet(const ipsec_test_packet *itp) { odp_packet_t pkt = odp_packet_alloc(suite_context.pool, itp->len); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_PACKET_INVALID, pkt); + CU_ASSERT_FATAL(ODP_PACKET_INVALID != pkt); if (ODP_PACKET_INVALID == pkt) return pkt; - CU_ASSERT_EQUAL(0, odp_packet_copy_from_mem(pkt, 0, itp->len, - itp->data)); + CU_ASSERT(0 == odp_packet_copy_from_mem(pkt, 0, itp->len, itp->data)); if (itp->l2_offset != ODP_PACKET_OFFSET_INVALID) - CU_ASSERT_EQUAL(0, odp_packet_l2_offset_set(pkt, - itp->l2_offset)); + CU_ASSERT(0 == odp_packet_l2_offset_set(pkt, itp->l2_offset)); if (itp->l3_offset != ODP_PACKET_OFFSET_INVALID) - CU_ASSERT_EQUAL(0, odp_packet_l3_offset_set(pkt, - itp->l3_offset)); + CU_ASSERT(0 == odp_packet_l3_offset_set(pkt, itp->l3_offset)); if (itp->l4_offset != ODP_PACKET_OFFSET_INVALID) - CU_ASSERT_EQUAL(0, odp_packet_l4_offset_set(pkt, - itp->l4_offset)); + CU_ASSERT(0 == odp_packet_l4_offset_set(pkt, itp->l4_offset)); odp_packet_user_ptr_set(pkt, PACKET_USER_PTR); @@ -568,11 +564,9 @@ static void check_l2_header(const ipsec_test_packet *itp, odp_packet_t pkt) CU_ASSERT_FATAL(l2 != ODP_PACKET_OFFSET_INVALID); CU_ASSERT_FATAL(l3 != ODP_PACKET_OFFSET_INVALID); - CU_ASSERT_EQUAL(l3 - l2, hdr_len); + CU_ASSERT(l3 - l2 == hdr_len); odp_packet_copy_to_mem(pkt, 0, len, data); - CU_ASSERT_EQUAL(0, memcmp(data + l2, - itp->data + itp->l2_offset, - hdr_len)); + CU_ASSERT(0 == memcmp(data + l2, itp->data + itp->l2_offset, hdr_len)); } /* @@ -595,17 +589,17 @@ static void ipsec_check_packet(const ipsec_test_packet *itp, odp_packet_t pkt, odp_packet_copy_to_mem(pkt, 0, len, data); if (l3 == ODP_PACKET_OFFSET_INVALID) { - CU_ASSERT_EQUAL(itp->l3_offset, ODP_PACKET_OFFSET_INVALID); - CU_ASSERT_EQUAL(l4, ODP_PACKET_OFFSET_INVALID); + CU_ASSERT(itp->l3_offset == ODP_PACKET_OFFSET_INVALID); + CU_ASSERT(l4 == ODP_PACKET_OFFSET_INVALID); return; } - CU_ASSERT_EQUAL(len - l3, itp->len - itp->l3_offset); + CU_ASSERT(len - l3 == itp->len - itp->l3_offset); if (len - l3 != itp->len - itp->l3_offset) return; - CU_ASSERT_EQUAL(l4 - l3, itp->l4_offset - itp->l3_offset); + CU_ASSERT(l4 - l3 == itp->l4_offset - itp->l3_offset); if (l4 - l3 != itp->l4_offset - itp->l3_offset) return; @@ -634,16 +628,13 @@ static void ipsec_check_packet(const ipsec_test_packet *itp, odp_packet_t pkt, * Check packet data before the first possible * location of the AH ICV field. */ - CU_ASSERT_EQUAL(0, memcmp(data + l3, - itp->data + itp->l3_offset, - ODPH_IPV4HDR_LEN + 12)); + CU_ASSERT(0 == memcmp(data + l3, itp->data + itp->l3_offset, + ODPH_IPV4HDR_LEN + 12)); return; } } - CU_ASSERT_EQUAL(0, memcmp(data + l3, - itp->data + itp->l3_offset, - len - l3)); + CU_ASSERT(0 == memcmp(data + l3, itp->data + itp->l3_offset, len - l3)); } static int send_pkts(const ipsec_test_part part[], int num_part) @@ -660,7 +651,7 @@ static int send_pkts(const ipsec_test_part part[], int num_part) for (i = 0; i < num_part; i++) pkt[i] = ipsec_packet(part[i].pkt_in); - CU_ASSERT_EQUAL(num_part, odp_pktout_send(pktout, pkt, num_part)); + CU_ASSERT(num_part == odp_pktout_send(pktout, pkt, num_part)); return num_part; } @@ -689,8 +680,7 @@ static int recv_pkts_inline(const ipsec_test_part *part, odp_queue_t queue = ODP_QUEUE_INVALID; int i; - CU_ASSERT_EQUAL_FATAL(1, odp_pktin_event_queue(suite_context.pktio, - &queue, 1)); + CU_ASSERT_FATAL(1 == odp_pktin_event_queue(suite_context.pktio, &queue, 1)); for (i = 0; i < part->num_pkt;) { odp_event_t ev; @@ -699,10 +689,8 @@ static int recv_pkts_inline(const ipsec_test_part *part, ev = recv_event(queue, 0); if (ODP_EVENT_INVALID != ev) { CU_ASSERT(odp_event_is_valid(ev) == 1); - CU_ASSERT_EQUAL(ODP_EVENT_PACKET, - odp_event_types(ev, &subtype)); - CU_ASSERT_EQUAL(ODP_EVENT_PACKET_BASIC, - subtype); + CU_ASSERT(ODP_EVENT_PACKET == odp_event_types(ev, &subtype)); + CU_ASSERT(ODP_EVENT_PACKET_BASIC == subtype); CU_ASSERT(part->out[i].status.error.sa_lookup); pkto[i] = odp_packet_from_event(ev); @@ -722,7 +710,7 @@ static int recv_pkts_inline(const ipsec_test_part *part, int j; CU_ASSERT(odp_event_is_valid(ev) == 1); - CU_ASSERT_EQUAL(ODP_EVENT_PACKET, odp_event_type(ev)); + CU_ASSERT(ODP_EVENT_PACKET == odp_event_type(ev)); pkt = odp_packet_from_event(ev); CU_ASSERT(!part->out[i].status.error.sa_lookup); @@ -785,10 +773,8 @@ static int ipsec_process_in(const ipsec_test_part *part, if (ODP_IPSEC_OP_MODE_SYNC == suite_context.inbound_op_mode) { pkt = ipsec_packet(part->pkt_in); - CU_ASSERT_EQUAL(part->num_pkt, odp_ipsec_in(&pkt, 1, - pkto, &num_out, - ¶m)); - CU_ASSERT_EQUAL(num_out, part->num_pkt); + CU_ASSERT(part->num_pkt == odp_ipsec_in(&pkt, 1, pkto, &num_out, ¶m)); + CU_ASSERT(num_out == part->num_pkt); CU_ASSERT_FATAL(*pkto != ODP_PACKET_INVALID); CU_ASSERT(odp_packet_subtype(*pkto) == ODP_EVENT_PACKET_IPSEC); } else if (ODP_IPSEC_OP_MODE_ASYNC == suite_context.inbound_op_mode) { @@ -796,7 +782,7 @@ static int ipsec_process_in(const ipsec_test_part *part, pkt = ipsec_packet(part->pkt_in); consumed = odp_ipsec_in_enq(&pkt, 1, ¶m); - CU_ASSERT_EQUAL(1, consumed); + CU_ASSERT(1 == consumed); if (consumed <= 0) num_out = 0; @@ -807,18 +793,17 @@ static int ipsec_process_in(const ipsec_test_part *part, event = recv_pkt_async_inbound(part->out[i].status); CU_ASSERT(odp_event_is_valid(event) == 1); - CU_ASSERT_EQUAL(ODP_EVENT_PACKET, - odp_event_types(event, &subtype)); - CU_ASSERT_EQUAL(ODP_EVENT_PACKET_IPSEC, subtype); + CU_ASSERT(ODP_EVENT_PACKET == odp_event_types(event, &subtype)); + CU_ASSERT(ODP_EVENT_PACKET_IPSEC == subtype); pkto[i] = odp_ipsec_packet_from_event(event); CU_ASSERT_FATAL(pkto[i] != ODP_PACKET_INVALID); CU_ASSERT(odp_packet_subtype(pkto[i]) == ODP_EVENT_PACKET_IPSEC); } } else { - CU_ASSERT_EQUAL(1, send_pkts(part, 1)); + CU_ASSERT(1 == send_pkts(part, 1)); if (part->num_pkt) - CU_ASSERT_EQUAL(part->num_pkt, recv_pkts_inline(part, pkto)); + CU_ASSERT(part->num_pkt == recv_pkts_inline(part, pkto)); } return num_out; @@ -881,14 +866,13 @@ static int ipsec_send_out_one(const ipsec_test_part *part, param.opt = &part->opt; if (ODP_IPSEC_OP_MODE_SYNC == suite_context.outbound_op_mode) { - CU_ASSERT_EQUAL(1, odp_ipsec_out(&pkt, 1, pkto, &num_out, - ¶m)); + CU_ASSERT(1 == odp_ipsec_out(&pkt, 1, pkto, &num_out, ¶m)); CU_ASSERT_FATAL(num_out == 1); CU_ASSERT_FATAL(*pkto != ODP_PACKET_INVALID); CU_ASSERT(odp_packet_subtype(*pkto) == ODP_EVENT_PACKET_IPSEC); } else if (ODP_IPSEC_OP_MODE_ASYNC == suite_context.outbound_op_mode) { num_out = odp_ipsec_out_enq(&pkt, 1, ¶m); - CU_ASSERT_EQUAL(1, num_out); + CU_ASSERT(1 == num_out); num_out = (num_out == 1) ? 1 : 0; @@ -899,9 +883,8 @@ static int ipsec_send_out_one(const ipsec_test_part *part, event = recv_event(suite_context.queue, EVENT_WAIT_TIME); CU_ASSERT(odp_event_is_valid(event) == 1); - CU_ASSERT_EQUAL(ODP_EVENT_PACKET, - odp_event_types(event, &subtype)); - CU_ASSERT_EQUAL(ODP_EVENT_PACKET_IPSEC, subtype); + CU_ASSERT(ODP_EVENT_PACKET == odp_event_types(event, &subtype)); + CU_ASSERT(ODP_EVENT_PACKET_IPSEC == subtype); pkto[i] = odp_ipsec_packet_from_event(event); CU_ASSERT_FATAL(pkto[i] != ODP_PACKET_INVALID); CU_ASSERT(odp_packet_subtype(pkto[i]) == @@ -967,12 +950,8 @@ static int ipsec_send_out_one(const ipsec_test_part *part, inline_param.tm_queue = ODP_TM_INVALID; inline_param.outer_hdr.len = hdr_len; - CU_ASSERT_EQUAL(1, odp_ipsec_out_inline(&pkt, 1, ¶m, - &inline_param)); - CU_ASSERT_EQUAL_FATAL(1, - odp_pktin_event_queue(suite_context. - pktio, - &queue, 1)); + CU_ASSERT(1 == odp_ipsec_out_inline(&pkt, 1, ¶m, &inline_param)); + CU_ASSERT_FATAL(1 == odp_pktin_event_queue(suite_context.pktio, &queue, 1)); for (i = 0; i < num_out;) { odp_event_t ev; @@ -981,10 +960,8 @@ static int ipsec_send_out_one(const ipsec_test_part *part, ev = recv_event(queue, 0); if (ODP_EVENT_INVALID != ev) { CU_ASSERT(odp_event_is_valid(ev) == 1); - CU_ASSERT_EQUAL(ODP_EVENT_PACKET, - odp_event_types(ev, &subtype)); - CU_ASSERT_EQUAL(ODP_EVENT_PACKET_BASIC, - subtype); + CU_ASSERT(ODP_EVENT_PACKET == odp_event_types(ev, &subtype)); + CU_ASSERT(ODP_EVENT_PACKET_BASIC == subtype); CU_ASSERT(!part->out[i].status.error.all); pkto[i] = odp_packet_from_event(ev); @@ -1010,10 +987,8 @@ static int ipsec_send_out_one(const ipsec_test_part *part, continue; } - CU_ASSERT_EQUAL(ODP_EVENT_PACKET, - ev_type); - CU_ASSERT_EQUAL(ODP_EVENT_PACKET_IPSEC, - subtype); + CU_ASSERT(ODP_EVENT_PACKET == ev_type); + CU_ASSERT(ODP_EVENT_PACKET_IPSEC == subtype); /* In the case of SA hard expiry tests, hard expiry error bits are * expected to be set. The exact error bits expected to be set based @@ -1053,9 +1028,8 @@ static void ipsec_pkt_seq_num_check(odp_packet_t pkt, uint32_t seq_num) uint32_t l4_off; odph_ipv4hdr_t ip; - CU_ASSERT_NOT_EQUAL_FATAL(ODP_PACKET_OFFSET_INVALID, l3_off); - CU_ASSERT_EQUAL_FATAL(0, odp_packet_copy_to_mem(pkt, l3_off, sizeof(ip), - &ip)); + CU_ASSERT_FATAL(ODP_PACKET_OFFSET_INVALID != l3_off); + CU_ASSERT_FATAL(0 == odp_packet_copy_to_mem(pkt, l3_off, sizeof(ip), &ip)); if (ODPH_IPV4HDR_VER(ip.ver_ihl) == ODPH_IPV4) { l4_off = l3_off + (ODPH_IPV4HDR_IHL(ip.ver_ihl) * 4); @@ -1064,12 +1038,12 @@ static void ipsec_pkt_seq_num_check(odp_packet_t pkt, uint32_t seq_num) odph_esphdr_t esp; odp_packet_copy_to_mem(pkt, l4_off, sizeof(esp), &esp); - CU_ASSERT_EQUAL(odp_be_to_cpu_32(esp.seq_no), seq_num); + CU_ASSERT(odp_be_to_cpu_32(esp.seq_no) == seq_num); } else if (ip.proto == ODPH_IPPROTO_AH) { odph_ahhdr_t ah; odp_packet_copy_to_mem(pkt, l4_off, sizeof(ah), &ah); - CU_ASSERT_EQUAL(odp_be_to_cpu_32(ah.seq_no), seq_num); + CU_ASSERT(odp_be_to_cpu_32(ah.seq_no) == seq_num); } else { CU_FAIL("Unexpected IP Proto"); } @@ -1092,11 +1066,10 @@ static void verify_in(const ipsec_test_part *part, if (ODP_EVENT_PACKET_IPSEC != odp_event_subtype(odp_packet_to_event(pkto[i]))) { /* Inline packet failed SA lookup */ - CU_ASSERT_EQUAL(1, part->out[i].status.error.sa_lookup); + CU_ASSERT(1 == part->out[i].status.error.sa_lookup); } else { - CU_ASSERT_EQUAL(0, odp_ipsec_result(&result, pkto[i])); - CU_ASSERT_EQUAL(part->out[i].status.error.all, - result.status.error.all); + CU_ASSERT(0 == odp_ipsec_result(&result, pkto[i])); + CU_ASSERT(part->out[i].status.error.all == result.status.error.all); if (part->out[i].status.error.all != 0) { odp_packet_free(pkto[i]); @@ -1104,17 +1077,13 @@ static void verify_in(const ipsec_test_part *part, } if (0 == result.status.error.all) - CU_ASSERT_EQUAL(0, - odp_packet_has_error(pkto[i])); - CU_ASSERT_EQUAL(suite_context.inbound_op_mode == - ODP_IPSEC_OP_MODE_INLINE, - result.flag.inline_mode); - CU_ASSERT_EQUAL(sa, result.sa); - CU_ASSERT_EQUAL(part->out[i].status.warn.all, - result.status.warn.all); + CU_ASSERT(0 == odp_packet_has_error(pkto[i])); + CU_ASSERT((suite_context.inbound_op_mode == ODP_IPSEC_OP_MODE_INLINE) == + result.flag.inline_mode); + CU_ASSERT(sa == result.sa); + CU_ASSERT(part->out[i].status.warn.all == result.status.warn.all); if (ODP_IPSEC_SA_INVALID != sa) - CU_ASSERT_EQUAL(IPSEC_SA_CTX, - odp_ipsec_sa_context(sa)); + CU_ASSERT(IPSEC_SA_CTX == odp_ipsec_sa_context(sa)); if (suite_context.inbound_op_mode != ODP_IPSEC_OP_MODE_SYNC) { uint32_t len; @@ -1135,12 +1104,10 @@ static void verify_in(const ipsec_test_part *part, if (part->out[i].pkt_res != NULL && part->out[i].l3_type != _ODP_PROTO_L3_TYPE_UNDEF) - CU_ASSERT_EQUAL(part->out[i].l3_type, - odp_packet_l3_type(pkto[i])); + CU_ASSERT(part->out[i].l3_type == odp_packet_l3_type(pkto[i])); if (part->out[i].pkt_res != NULL && part->out[i].l4_type != _ODP_PROTO_L4_TYPE_UNDEF) - CU_ASSERT_EQUAL(part->out[i].l4_type, - odp_packet_l4_type(pkto[i])); + CU_ASSERT(part->out[i].l4_type == odp_packet_l4_type(pkto[i])); odp_packet_free(pkto[i]); } } @@ -1180,26 +1147,23 @@ int ipsec_check_out(const ipsec_test_part *part, odp_ipsec_sa_t sa, if (ODP_EVENT_PACKET_IPSEC != odp_event_subtype(odp_packet_to_event(pkto[i]))) { /* Inline packet went through loop */ - CU_ASSERT_EQUAL(0, part->out[i].status.error.all); + CU_ASSERT(0 == part->out[i].status.error.all); CU_ASSERT(odp_packet_user_ptr(pkto[i]) == NULL); /* L2 header must match the requested one */ check_l2_header(part->out[i].pkt_res, pkto[i]); } else { /* IPsec packet */ - CU_ASSERT_EQUAL(0, odp_ipsec_result(&result, pkto[i])); + CU_ASSERT(0 == odp_ipsec_result(&result, pkto[i])); if (part->out[i].sa_expiry != IPSEC_TEST_EXPIRY_NONE) if (ipsec_check_sa_expiry(part->out[i].sa_expiry, &result) != 0) return num_out; - CU_ASSERT_EQUAL(part->out[i].status.error.all, - result.status.error.all); + CU_ASSERT(part->out[i].status.error.all == result.status.error.all); if (0 == result.status.error.all) - CU_ASSERT_EQUAL(0, - odp_packet_has_error(pkto[i])); - CU_ASSERT_EQUAL(sa, result.sa); - CU_ASSERT_EQUAL(IPSEC_SA_CTX, - odp_ipsec_sa_context(sa)); + CU_ASSERT(0 == odp_packet_has_error(pkto[i])); + CU_ASSERT(sa == result.sa); + CU_ASSERT(IPSEC_SA_CTX == odp_ipsec_sa_context(sa)); CU_ASSERT(odp_packet_user_ptr(pkto[i]) == PACKET_USER_PTR); /* Parse the packet to set L4 offset and type */ @@ -1236,7 +1200,7 @@ void ipsec_check_in_one(const ipsec_test_part *part, odp_ipsec_sa_t sa) int num_out; num_out = ipsec_process_in(part, sa, pkto); - CU_ASSERT_EQUAL(num_out, part->num_pkt); + CU_ASSERT(num_out == part->num_pkt); verify_in(part, sa, pkto); } diff --git a/test/validation/api/ipsec/ipsec_test_in.c b/test/validation/api/ipsec/ipsec_test_in.c index b5251544e..4d78a973a 100644 --- a/test/validation/api/ipsec/ipsec_test_in.c +++ b/test/validation/api/ipsec/ipsec_test_in.c @@ -62,7 +62,7 @@ static void test_in_ipv4_ah_sha256(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv4_icmp_0_ah_sha256_1, @@ -97,7 +97,7 @@ static void test_in_ipv4_ah_sha256_tun_ipv4(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv4_icmp_0_ah_tun_ipv4_sha256_1, @@ -132,7 +132,7 @@ static void test_in_ipv4_ah_sha256_tun_ipv6(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv4_icmp_0_ah_tun_ipv6_sha256_1, @@ -164,7 +164,7 @@ static void test_in_ipv4_ah_sha256_tun_ipv4_notun(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv4_icmp_0_ah_tun_ipv4_sha256_1, @@ -197,7 +197,7 @@ static void test_in_ipv4_esp_null_sha256(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv4_icmp_0_esp_null_sha256_1, @@ -229,7 +229,7 @@ static void test_in_ipv4_esp_aes_cbc_null(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv4_icmp_0_esp_aes_cbc_null_1, @@ -261,7 +261,7 @@ static void test_in_ipv4_esp_aes_cbc_sha1(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv4_icmp_0_esp_aes_cbc_sha1_1, @@ -293,7 +293,7 @@ static void test_in_ipv4_esp_aes_cbc_sha256(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv4_icmp_0_esp_aes_cbc_sha256_1, @@ -325,7 +325,7 @@ static void test_in_ipv4_esp_aes_cbc_sha384(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv4_icmp_0_esp_aes_cbc_sha384_1, @@ -357,7 +357,7 @@ static void test_in_ipv4_esp_aes_cbc_sha512(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv4_icmp_0_esp_aes_cbc_sha512_1, @@ -389,7 +389,7 @@ static void test_in_ipv4_esp_aes_ctr_null(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv4_icmp_0_esp_aes_ctr_null_1, @@ -421,7 +421,7 @@ static void test_in_ipv4_ah_sha256_lookup(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv4_icmp_0_ah_sha256_1, @@ -456,7 +456,7 @@ static void test_in_ipv4_esp_null_sha256_lookup(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv4_icmp_0_esp_null_sha256_1, @@ -494,7 +494,7 @@ static void test_in_ipv4_esp_null_sha256_tun_ipv4(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv4_icmp_0_esp_tun_ipv4_null_sha256_1, @@ -529,7 +529,7 @@ static void test_in_ipv4_esp_null_sha256_tun_ipv6(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv4_icmp_0_esp_tun_ipv6_null_sha256_1, @@ -562,7 +562,7 @@ static void test_in_ipv4_esp_udp_null_sha256(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv4_icmp_0_esp_udp_null_sha256_1, @@ -595,7 +595,7 @@ static void test_in_ipv4_esp_udp_null_sha256_lookup(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv4_icmp_0_esp_udp_null_sha256_1, @@ -631,7 +631,7 @@ static void test_in_ipv4_ah_sha256_noreplay(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv4_icmp_0_ah_sha256_1, @@ -682,7 +682,7 @@ static void test_in_ipv4_ah_sha256_replay(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv4_icmp_0_ah_sha256_1, @@ -734,7 +734,7 @@ static void test_in_ipv4_esp_null_sha256_noreplay(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv4_icmp_0_esp_null_sha256_1, @@ -785,7 +785,7 @@ static void test_in_ipv4_esp_null_sha256_replay(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv4_icmp_0_esp_null_sha256_1, @@ -844,7 +844,7 @@ static void test_in_ipv4_ah_esp_pkt(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); test.pkt_in = &pkt_ipv4_icmp_0_esp_null_sha256_1; test.num_pkt = 1; @@ -876,7 +876,7 @@ static void test_in_ipv4_esp_ah_pkt(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); test.pkt_in = &pkt_ipv4_icmp_0_ah_sha256_1; test.num_pkt = 1; @@ -903,7 +903,7 @@ static void test_in_ipv4_ah_esp_pkt_lookup(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); test.pkt_in = &pkt_ipv4_icmp_0_esp_null_sha256_1; test.flags.lookup = 1; @@ -931,7 +931,7 @@ static void test_in_ipv4_esp_ah_pkt_lookup(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); test.pkt_in = &pkt_ipv4_icmp_0_ah_sha256_1; test.flags.lookup = 1; @@ -959,7 +959,7 @@ static void test_in_ipv4_ah_sha256_bad1(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); test.pkt_in = &pkt_ipv4_icmp_0_ah_sha256_1_bad1; test.num_pkt = 1; @@ -986,7 +986,7 @@ static void test_in_ipv4_ah_sha256_bad2(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); test.pkt_in = &pkt_ipv4_icmp_0_ah_sha256_1_bad2; test.num_pkt = 1; @@ -1013,7 +1013,7 @@ static void test_in_ipv4_esp_null_sha256_bad1(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); test.pkt_in = &pkt_ipv4_icmp_0_esp_null_sha256_1_bad1; test.num_pkt = 1; @@ -1037,7 +1037,7 @@ static void test_in_ipv4_rfc3602_5_esp(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_rfc3602_5_esp, @@ -1069,7 +1069,7 @@ static void test_in_ipv4_rfc3602_6_esp(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_rfc3602_6_esp, @@ -1105,7 +1105,7 @@ static void test_in_ipv4_rfc3602_7_esp(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_rfc3602_7_esp, @@ -1141,7 +1141,7 @@ static void test_in_ipv4_rfc3602_8_esp(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_rfc3602_8_esp, @@ -1177,7 +1177,7 @@ static void test_in_ipv4_mcgrew_gcm_2_esp(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_mcgrew_gcm_test_2_esp, @@ -1213,7 +1213,7 @@ static void test_in_ipv4_mcgrew_gcm_3_esp(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_mcgrew_gcm_test_3_esp, @@ -1249,7 +1249,7 @@ static void test_in_ipv4_mcgrew_gcm_4_esp(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_mcgrew_gcm_test_4_esp, @@ -1290,7 +1290,7 @@ static void test_in_ipv4_mcgrew_gcm_12_esp(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_mcgrew_gcm_test_12_esp, @@ -1323,7 +1323,7 @@ static void test_in_ipv4_mcgrew_gcm_12_esp_notun(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_mcgrew_gcm_test_12_esp, @@ -1359,7 +1359,7 @@ static void test_in_ipv4_mcgrew_gcm_15_esp(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_mcgrew_gcm_test_15_esp, @@ -1395,7 +1395,7 @@ static void test_in_ipv4_rfc7634_chacha(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv4_rfc7634_esp, @@ -1427,7 +1427,7 @@ static void test_in_ipv4_ah_aes_gmac_128(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv4_icmp_0_ah_aes_gmac_128_1, @@ -1459,7 +1459,7 @@ static void test_in_ipv4_esp_null_aes_gmac_128(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv4_icmp_0_esp_null_aes_gmac_128_1, @@ -1491,7 +1491,7 @@ static void test_in_ipv6_ah_sha256(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv6_icmp_0_ah_sha256_1, @@ -1526,7 +1526,7 @@ static void test_in_ipv6_ah_sha256_tun_ipv4(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv6_icmp_0_ah_tun_ipv4_sha256_1, @@ -1561,7 +1561,7 @@ static void test_in_ipv6_ah_sha256_tun_ipv6(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv6_icmp_0_ah_tun_ipv6_sha256_1, @@ -1593,7 +1593,7 @@ static void test_in_ipv6_esp_null_sha256(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv6_icmp_0_esp_null_sha256_1, @@ -1628,7 +1628,7 @@ static void test_in_ipv6_esp_null_sha256_tun_ipv4(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv6_icmp_0_esp_tun_ipv4_null_sha256_1, @@ -1663,7 +1663,7 @@ static void test_in_ipv6_esp_null_sha256_tun_ipv6(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv6_icmp_0_esp_tun_ipv6_null_sha256_1, @@ -1696,7 +1696,7 @@ static void test_in_ipv6_esp_udp_null_sha256(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv6_icmp_0_esp_udp_null_sha256_1, @@ -1729,7 +1729,7 @@ static void test_in_ipv6_esp_udp_null_sha256_lookup(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv6_icmp_0_esp_udp_null_sha256_1, @@ -1769,7 +1769,7 @@ static void test_ipsec_sa_print(void) in_sa = odp_ipsec_sa_create(¶m_in); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, in_sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != in_sa); odp_ipsec_sa_print(in_sa); @@ -1802,7 +1802,7 @@ static void test_multi_out_in(odp_ipsec_sa_t out_sa, */ part_prep_esp(&test_out, 1, tunnel_ip_ver == ODPH_IPV6); test_out.pkt_in = input_packets[i]; - CU_ASSERT_EQUAL(ipsec_check_out(&test_out, out_sa, &pkt), 1); + CU_ASSERT(ipsec_check_out(&test_out, out_sa, &pkt) == 1); /* * Perform inbound IPsec processing for the IPsec packet. @@ -1952,10 +1952,10 @@ static void test_in_ipv4_esp_reass_success(void) param_in.inbound.reassembly_en = 1; out_sa = odp_ipsec_sa_create(¶m_out); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, out_sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != out_sa); in_sa = odp_ipsec_sa_create(¶m_in); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, in_sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != in_sa); printf("\n IPv4 two frags"); test_in_ipv4_esp_reass_success_two_frags(out_sa, in_sa); @@ -2007,10 +2007,10 @@ static void test_in_ipv4_esp_reass_incomp(void) param_in.inbound.reassembly_en = 1; out_sa = odp_ipsec_sa_create(¶m_out); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, out_sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != out_sa); in_sa = odp_ipsec_sa_create(¶m_in); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, in_sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != in_sa); printf("\n IPv4 missing frag"); test_in_ipv4_esp_reass_incomp_missing(out_sa, in_sa); @@ -2141,10 +2141,10 @@ static void test_in_ipv6_esp_reass_success(void) param_in.inbound.reassembly_en = 1; out_sa = odp_ipsec_sa_create(¶m_out); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, out_sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != out_sa); in_sa = odp_ipsec_sa_create(¶m_in); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, in_sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != in_sa); printf("\n IPv6 two frags"); test_in_ipv6_esp_reass_success_two_frags(out_sa, in_sa); @@ -2200,10 +2200,10 @@ static void test_in_ipv6_esp_reass_incomp(void) param_in.inbound.reassembly_en = 1; out_sa = odp_ipsec_sa_create(¶m_out); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, out_sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != out_sa); in_sa = odp_ipsec_sa_create(¶m_in); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, in_sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != in_sa); printf("\n IPv6 missing frag"); test_in_ipv6_esp_reass_incomp_missing(out_sa, in_sa); @@ -2231,7 +2231,7 @@ static void test_in_ipv4_null_aes_xcbc_esp(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv4_null_aes_xcbc_esp, diff --git a/test/validation/api/ipsec/ipsec_test_out.c b/test/validation/api/ipsec/ipsec_test_out.c index ca8bf97a5..5e1218738 100644 --- a/test/validation/api/ipsec/ipsec_test_out.c +++ b/test/validation/api/ipsec/ipsec_test_out.c @@ -145,7 +145,7 @@ static void test_out_ipv4_ah_sha256(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv4_icmp_0, @@ -184,7 +184,7 @@ static void test_out_ipv4_ah_sha256_tun_ipv4(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv4_icmp_0, @@ -229,7 +229,7 @@ static void test_out_ipv4_ah_sha256_tun_ipv6(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv4_icmp_0, @@ -259,7 +259,7 @@ static void test_out_ipv4_esp_null_sha256(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv4_icmp_0, @@ -298,7 +298,7 @@ static void test_out_ipv4_esp_null_sha256_tun_ipv4(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv4_icmp_0, @@ -344,7 +344,7 @@ static void test_out_ipv4_esp_null_sha256_tun_ipv6(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv4_icmp_0, @@ -364,15 +364,15 @@ static void test_out_ipv4_esp_null_sha256_tun_ipv6(void) static void test_ipsec_stats_zero_assert(odp_ipsec_stats_t *stats) { - CU_ASSERT_EQUAL(stats->success, 0); - CU_ASSERT_EQUAL(stats->proto_err, 0); - CU_ASSERT_EQUAL(stats->auth_err, 0); - CU_ASSERT_EQUAL(stats->antireplay_err, 0); - CU_ASSERT_EQUAL(stats->alg_err, 0); - CU_ASSERT_EQUAL(stats->mtu_err, 0); - CU_ASSERT_EQUAL(stats->hard_exp_bytes_err, 0); - CU_ASSERT_EQUAL(stats->hard_exp_pkts_err, 0); - CU_ASSERT_EQUAL(stats->success_bytes, 0); + CU_ASSERT(stats->success == 0); + CU_ASSERT(stats->proto_err == 0); + CU_ASSERT(stats->auth_err == 0); + CU_ASSERT(stats->antireplay_err == 0); + CU_ASSERT(stats->alg_err == 0); + CU_ASSERT(stats->mtu_err == 0); + CU_ASSERT(stats->hard_exp_bytes_err == 0); + CU_ASSERT(stats->hard_exp_pkts_err == 0); + CU_ASSERT(stats->success_bytes == 0); } static void test_ipsec_stats_test_assert(odp_ipsec_stats_t *stats, @@ -380,34 +380,34 @@ static void test_ipsec_stats_test_assert(odp_ipsec_stats_t *stats, uint64_t succ_bytes) { if (test == IPSEC_TEST_STATS_SUCCESS) { - CU_ASSERT_EQUAL(stats->success, 1); + CU_ASSERT(stats->success == 1); CU_ASSERT(stats->success_bytes >= succ_bytes); } else { - CU_ASSERT_EQUAL(stats->success, 0); - CU_ASSERT_EQUAL(stats->success_bytes, 0); + CU_ASSERT(stats->success == 0); + CU_ASSERT(stats->success_bytes == 0); } if (test == IPSEC_TEST_STATS_PROTO_ERR) { /* Braces needed by CU macro */ - CU_ASSERT_EQUAL(stats->proto_err, 1); + CU_ASSERT(stats->proto_err == 1); } else { /* Braces needed by CU macro */ - CU_ASSERT_EQUAL(stats->proto_err, 0); + CU_ASSERT(stats->proto_err == 0); } if (test == IPSEC_TEST_STATS_AUTH_ERR) { /* Braces needed by CU macro */ - CU_ASSERT_EQUAL(stats->auth_err, 1); + CU_ASSERT(stats->auth_err == 1); } else { /* Braces needed by CU macro */ - CU_ASSERT_EQUAL(stats->auth_err, 0); + CU_ASSERT(stats->auth_err == 0); } - CU_ASSERT_EQUAL(stats->antireplay_err, 0); - CU_ASSERT_EQUAL(stats->alg_err, 0); - CU_ASSERT_EQUAL(stats->mtu_err, 0); - CU_ASSERT_EQUAL(stats->hard_exp_bytes_err, 0); - CU_ASSERT_EQUAL(stats->hard_exp_pkts_err, 0); + CU_ASSERT(stats->antireplay_err == 0); + CU_ASSERT(stats->alg_err == 0); + CU_ASSERT(stats->mtu_err == 0); + CU_ASSERT(stats->hard_exp_bytes_err == 0); + CU_ASSERT(stats->hard_exp_pkts_err == 0); } static void ipsec_pkt_proto_err_set(odp_packet_t pkt) @@ -527,7 +527,7 @@ static void test_out_in_common(const ipsec_test_flags *flags, odp_proto_l3_type_t out_l3_type = ODP_PROTO_L3_TYPE_IPV4; odp_proto_l4_type_t out_l4_type = ODP_PROTO_L4_TYPE_ESP; - CU_ASSERT_NOT_EQUAL_FATAL(flags, NULL); + CU_ASSERT_FATAL(flags != NULL); /* ICV won't be generated for NULL AUTH */ if ((flags->stats == IPSEC_TEST_STATS_AUTH_ERR) && @@ -566,7 +566,7 @@ static void test_out_in_common(const ipsec_test_flags *flags, if (sa_out == ODP_IPSEC_SA_INVALID && sa_creation_failure_ok(¶m)) return; - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa_out); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa_out); ipsec_sa_param_fill(¶m, ODP_IPSEC_DIR_INBOUND, proto, 123, tun_ptr, @@ -579,7 +579,7 @@ static void test_out_in_common(const ipsec_test_flags *flags, sa_in = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa_in); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa_in); if ((flags->tunnel && flags->tunnel_is_v6) || (!flags->tunnel && flags->v6)) @@ -627,9 +627,9 @@ static void test_out_in_common(const ipsec_test_flags *flags, test_in.out[0].status.error.auth = 1; if (flags->stats != IPSEC_TEST_STATS_NONE) { - CU_ASSERT_EQUAL(odp_ipsec_stats(sa_out, &stats), 0); + CU_ASSERT(odp_ipsec_stats(sa_out, &stats) == 0); test_ipsec_stats_zero_assert(&stats); - CU_ASSERT_EQUAL(odp_ipsec_stats(sa_in, &stats), 0); + CU_ASSERT(odp_ipsec_stats(sa_in, &stats) == 0); test_ipsec_stats_zero_assert(&stats); } @@ -675,11 +675,11 @@ static void test_out_in_common(const ipsec_test_flags *flags, /* All stats tests have outbound operation success and inbound * varying. */ - CU_ASSERT_EQUAL(odp_ipsec_stats(sa_out, &stats), 0); + CU_ASSERT(odp_ipsec_stats(sa_out, &stats) == 0); test_ipsec_stats_test_assert(&stats, IPSEC_TEST_STATS_SUCCESS, succ_bytes); - CU_ASSERT_EQUAL(odp_ipsec_stats(sa_in, &stats), 0); + CU_ASSERT(odp_ipsec_stats(sa_in, &stats) == 0); test_ipsec_stats_test_assert(&stats, flags->stats, succ_bytes); } @@ -815,7 +815,7 @@ static void test_out_ipv4_esp_udp_null_sha256(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv4_icmp_0, @@ -852,7 +852,7 @@ static void test_out_ipv4_ah_sha256_frag_check(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); test.pkt_in = &pkt_ipv4_icmp_0; test.num_pkt = 1; @@ -892,7 +892,7 @@ static void test_out_ipv4_ah_sha256_frag_check_2(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); test.pkt_in = &pkt_ipv4_icmp_0; test.num_pkt = 1; @@ -940,7 +940,7 @@ static void test_out_ipv4_esp_null_sha256_frag_check(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); test.pkt_in = &pkt_ipv4_icmp_0; test.num_pkt = 1; @@ -981,7 +981,7 @@ static void test_out_ipv4_esp_null_sha256_frag_check_2(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); test.pkt_in = &pkt_ipv4_icmp_0; test.num_pkt = 1; @@ -1021,7 +1021,7 @@ static void test_out_ipv6_ah_sha256(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv6_icmp_0, @@ -1060,7 +1060,7 @@ static void test_out_ipv6_ah_sha256_tun_ipv4(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv6_icmp_0, @@ -1105,7 +1105,7 @@ static void test_out_ipv6_ah_sha256_tun_ipv6(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv6_icmp_0, @@ -1135,7 +1135,7 @@ static void test_out_ipv6_esp_null_sha256(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv6_icmp_0, @@ -1174,7 +1174,7 @@ static void test_out_ipv6_esp_null_sha256_tun_ipv4(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv6_icmp_0, @@ -1220,7 +1220,7 @@ static void test_out_ipv6_esp_null_sha256_tun_ipv6(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv6_icmp_0, @@ -1252,7 +1252,7 @@ static void test_out_ipv6_esp_udp_null_sha256(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv6_icmp_0, @@ -1299,7 +1299,7 @@ static void test_out_dummy_esp_null_sha256_tun(odp_ipsec_tunnel_param_t tunnel) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_sa_param_fill(¶m, ODP_IPSEC_DIR_INBOUND, ODP_IPSEC_ESP, 123, &tunnel, @@ -1309,7 +1309,7 @@ static void test_out_dummy_esp_null_sha256_tun(odp_ipsec_tunnel_param_t tunnel) sa2 = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa2); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa2); test.pkt_in = &pkt_test_nodata; test.num_opt = 1; @@ -1387,7 +1387,7 @@ static void test_out_ipv4_udp_esp_null_sha256(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv4_udp, @@ -1429,7 +1429,7 @@ static void test_out_ipv4_null_aes_xcbc(void) sa = odp_ipsec_sa_create(¶m); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa); ipsec_test_part test = { .pkt_in = &pkt_ipv4_null_aes_xcbc_plain, @@ -1478,7 +1478,7 @@ static void test_sa_info(void) sa_out = odp_ipsec_sa_create(¶m_out); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, sa_out); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != sa_out); ipsec_sa_param_fill(¶m_in, ODP_IPSEC_DIR_INBOUND, ODP_IPSEC_ESP, @@ -1492,57 +1492,48 @@ static void test_sa_info(void) CU_ASSERT_FATAL(sa_in != ODP_IPSEC_SA_INVALID); memset(&info_out, 0, sizeof(info_out)); - CU_ASSERT_EQUAL_FATAL(0, odp_ipsec_sa_info(sa_out, &info_out)); - - CU_ASSERT_EQUAL(info_out.param.dir, param_out.dir); - CU_ASSERT_EQUAL(info_out.param.proto, param_out.proto); - CU_ASSERT_EQUAL(info_out.param.mode, param_out.mode); - - CU_ASSERT_EQUAL(info_out.param.crypto.cipher_alg, - param_out.crypto.cipher_alg); - CU_ASSERT_EQUAL(info_out.param.crypto.auth_alg, - param_out.crypto.auth_alg); - CU_ASSERT_EQUAL(info_out.param.opt.udp_encap, param_out.opt.udp_encap); - CU_ASSERT_EQUAL(info_out.param.spi, param_out.spi); - CU_ASSERT_EQUAL(info_out.param.opt.esn, param_out.opt.esn); - CU_ASSERT_EQUAL(info_out.param.opt.udp_encap, param_out.opt.udp_encap); - CU_ASSERT_EQUAL(info_out.param.opt.copy_dscp, param_out.opt.copy_dscp); - CU_ASSERT_EQUAL(info_out.param.opt.copy_flabel, param_out.opt.copy_flabel); - CU_ASSERT_EQUAL(info_out.param.opt.copy_df, param_out.opt.copy_df); - - CU_ASSERT_EQUAL(ODP_IPSEC_MODE_TUNNEL, info_out.param.mode); - - CU_ASSERT_EQUAL(info_out.param.outbound.tunnel.type, - param_out.outbound.tunnel.type); - CU_ASSERT_EQUAL(info_out.param.outbound.tunnel.ipv4.dscp, - param_out.outbound.tunnel.ipv4.dscp); - CU_ASSERT_EQUAL(info_out.param.outbound.tunnel.ipv4.df, - param_out.outbound.tunnel.ipv4.df); - CU_ASSERT_NOT_EQUAL_FATAL(NULL, - info_out.param.outbound.tunnel.ipv4.src_addr); - CU_ASSERT_EQUAL(0, memcmp(info_out.param.outbound.tunnel.ipv4.src_addr, - param_out.outbound.tunnel.ipv4.src_addr, - ODP_IPV4_ADDR_SIZE)); - CU_ASSERT_NOT_EQUAL_FATAL(NULL, - info_out.param.outbound.tunnel.ipv4.dst_addr); - CU_ASSERT_EQUAL(0, memcmp(info_out.param.outbound.tunnel.ipv4.dst_addr, - param_out.outbound.tunnel.ipv4.dst_addr, - ODP_IPV4_ADDR_SIZE)); - - CU_ASSERT_EQUAL(info_out.param.lifetime.soft_limit.bytes, - param_out.lifetime.soft_limit.bytes); - CU_ASSERT_EQUAL(info_out.param.lifetime.hard_limit.bytes, - param_out.lifetime.hard_limit.bytes); - CU_ASSERT_EQUAL(info_out.param.lifetime.soft_limit.packets, - param_out.lifetime.soft_limit.packets); - CU_ASSERT_EQUAL(info_out.param.lifetime.hard_limit.packets, - param_out.lifetime.hard_limit.packets); - - CU_ASSERT_EQUAL(0, info_out.outbound.seq_num); + CU_ASSERT_FATAL(0 == odp_ipsec_sa_info(sa_out, &info_out)); + + CU_ASSERT(info_out.param.dir == param_out.dir); + CU_ASSERT(info_out.param.proto == param_out.proto); + CU_ASSERT(info_out.param.mode == param_out.mode); + + CU_ASSERT(info_out.param.crypto.cipher_alg == param_out.crypto.cipher_alg); + CU_ASSERT(info_out.param.crypto.auth_alg == param_out.crypto.auth_alg); + CU_ASSERT(info_out.param.opt.udp_encap == param_out.opt.udp_encap); + CU_ASSERT(info_out.param.spi == param_out.spi); + CU_ASSERT(info_out.param.opt.esn == param_out.opt.esn); + CU_ASSERT(info_out.param.opt.udp_encap == param_out.opt.udp_encap); + CU_ASSERT(info_out.param.opt.copy_dscp == param_out.opt.copy_dscp); + CU_ASSERT(info_out.param.opt.copy_flabel == param_out.opt.copy_flabel); + CU_ASSERT(info_out.param.opt.copy_df == param_out.opt.copy_df); + + CU_ASSERT(ODP_IPSEC_MODE_TUNNEL == info_out.param.mode); + + CU_ASSERT(info_out.param.outbound.tunnel.type == param_out.outbound.tunnel.type); + CU_ASSERT(info_out.param.outbound.tunnel.ipv4.dscp == param_out.outbound.tunnel.ipv4.dscp); + CU_ASSERT(info_out.param.outbound.tunnel.ipv4.df == param_out.outbound.tunnel.ipv4.df); + CU_ASSERT_FATAL(NULL != info_out.param.outbound.tunnel.ipv4.src_addr); + CU_ASSERT(0 == memcmp(info_out.param.outbound.tunnel.ipv4.src_addr, + param_out.outbound.tunnel.ipv4.src_addr, + ODP_IPV4_ADDR_SIZE)); + CU_ASSERT_FATAL(NULL != info_out.param.outbound.tunnel.ipv4.dst_addr); + CU_ASSERT(0 == memcmp(info_out.param.outbound.tunnel.ipv4.dst_addr, + param_out.outbound.tunnel.ipv4.dst_addr, + ODP_IPV4_ADDR_SIZE)); + + CU_ASSERT(info_out.param.lifetime.soft_limit.bytes == param_out.lifetime.soft_limit.bytes); + CU_ASSERT(info_out.param.lifetime.hard_limit.bytes == param_out.lifetime.hard_limit.bytes); + CU_ASSERT(info_out.param.lifetime.soft_limit.packets == + param_out.lifetime.soft_limit.packets); + CU_ASSERT(info_out.param.lifetime.hard_limit.packets == + param_out.lifetime.hard_limit.packets); + + CU_ASSERT(0 == info_out.outbound.seq_num); memset(&info_in, 0, sizeof(info_in)); - CU_ASSERT_EQUAL_FATAL(0, odp_ipsec_sa_info(sa_in, &info_in)); - CU_ASSERT_EQUAL(0, info_in.inbound.antireplay_window_top); + CU_ASSERT_FATAL(0 == odp_ipsec_sa_info(sa_in, &info_in)); + CU_ASSERT(0 == info_in.inbound.antireplay_window_top); ipsec_test_part test_out = { .pkt_in = &pkt_ipv4_icmp_0, @@ -1569,12 +1560,12 @@ static void test_sa_info(void) ipsec_check_out_in_one(&test_out, &test_in, sa_out, sa_in, NULL); memset(&info_out, 0, sizeof(info_out)); - CU_ASSERT_EQUAL_FATAL(0, odp_ipsec_sa_info(sa_out, &info_out)); - CU_ASSERT_EQUAL(1, info_out.outbound.seq_num); + CU_ASSERT_FATAL(0 == odp_ipsec_sa_info(sa_out, &info_out)); + CU_ASSERT(1 == info_out.outbound.seq_num); memset(&info_in, 0, sizeof(info_in)); - CU_ASSERT_EQUAL_FATAL(0, odp_ipsec_sa_info(sa_in, &info_in)); - CU_ASSERT_EQUAL(1, info_in.inbound.antireplay_window_top); + CU_ASSERT_FATAL(0 == odp_ipsec_sa_info(sa_in, &info_in)); + CU_ASSERT(1 == info_in.inbound.antireplay_window_top); ipsec_sa_destroy(sa_out); ipsec_sa_destroy(sa_in); @@ -1697,7 +1688,7 @@ static void test_out_ipv4_esp_sa_expiry(enum ipsec_test_sa_expiry expiry) param_out.lifetime.hard_limit.packets = hard_limit_pkt; out_sa = odp_ipsec_sa_create(¶m_out); - CU_ASSERT_NOT_EQUAL_FATAL(ODP_IPSEC_SA_INVALID, out_sa); + CU_ASSERT_FATAL(ODP_IPSEC_SA_INVALID != out_sa); ipsec_test_part test_out = { .pkt_in = &pkt_ipv4_icmp_0, diff --git a/test/validation/api/lock/lock.c b/test/validation/api/lock/lock.c index a4e6932c4..34871b716 100644 --- a/test/validation/api/lock/lock.c +++ b/test/validation/api/lock/lock.c @@ -117,7 +117,7 @@ static per_thread_mem_t *thread_init(void) global_shm = odp_shm_lookup(GLOBAL_SHM_NAME); global_mem = odp_shm_addr(global_shm); - CU_ASSERT_PTR_NOT_NULL(global_mem); + CU_ASSERT(global_mem != NULL); per_thread_mem->global_mem = global_mem; diff --git a/test/validation/api/packet/packet.c b/test/validation/api/packet/packet.c index 6ae558d09..47cce8296 100644 --- a/test/validation/api/packet/packet.c +++ b/test/validation/api/packet/packet.c @@ -118,8 +118,8 @@ static void _packet_compare_data(odp_packet_t pkt1, odp_packet_t pkt2, pkt1map = odp_packet_offset(pkt1, offset, &seglen1, NULL); pkt2map = odp_packet_offset(pkt2, offset, &seglen2, NULL); - CU_ASSERT_PTR_NOT_NULL_FATAL(pkt1map); - CU_ASSERT_PTR_NOT_NULL_FATAL(pkt2map); + CU_ASSERT_FATAL(pkt1map != NULL); + CU_ASSERT_FATAL(pkt2map != NULL); cmplen = seglen1 < seglen2 ? seglen1 : seglen2; ret = memcmp(pkt1map, pkt2map, cmplen); @@ -849,8 +849,8 @@ static void packet_test_basic_metadata(void) odp_time_t ts; odp_packet_data_range_t range; - CU_ASSERT_PTR_NOT_NULL(odp_packet_head(pkt)); - CU_ASSERT_PTR_NOT_NULL(odp_packet_data(pkt)); + CU_ASSERT(odp_packet_head(pkt) != NULL); + CU_ASSERT(odp_packet_data(pkt) != NULL); CU_ASSERT(odp_packet_pool(pkt) != ODP_POOL_INVALID); /* Packet was allocated by application so shouldn't have valid pktio. */ @@ -1066,7 +1066,7 @@ static void packet_test_layer_offsets(void) CU_ASSERT(seg_len != 0); l4_addr = odp_packet_l4_ptr(pkt, &seg_len); CU_ASSERT(seg_len != 0); - CU_ASSERT_PTR_NOT_NULL(l2_addr); + CU_ASSERT(l2_addr != NULL); CU_ASSERT(l2_addr == l3_addr); CU_ASSERT(l2_addr == l4_addr); @@ -1080,11 +1080,11 @@ static void packet_test_layer_offsets(void) /* Addresses should not be the same */ l2_addr = odp_packet_l2_ptr(pkt, NULL); - CU_ASSERT_PTR_NOT_NULL(l2_addr); + CU_ASSERT(l2_addr != NULL); l3_addr = odp_packet_l3_ptr(pkt, NULL); - CU_ASSERT_PTR_NOT_NULL(l3_addr); + CU_ASSERT(l3_addr != NULL); l4_addr = odp_packet_l4_ptr(pkt, NULL); - CU_ASSERT_PTR_NOT_NULL(l4_addr); + CU_ASSERT(l4_addr != NULL); CU_ASSERT(l2_addr != l3_addr); CU_ASSERT(l2_addr != l4_addr); @@ -1124,7 +1124,7 @@ static void _verify_headroom_shift(odp_packet_t *pkt, } packet_sanity_check(*pkt); - CU_ASSERT_PTR_NOT_NULL(data); + CU_ASSERT(data != NULL); if (extended) { CU_ASSERT(rc >= 0); CU_ASSERT(odp_packet_seg_len(*pkt) == seg_len); @@ -1222,7 +1222,7 @@ static void _verify_tailroom_shift(odp_packet_t *pkt, } packet_sanity_check(*pkt); - CU_ASSERT_PTR_NOT_NULL(tail); + CU_ASSERT(tail != NULL); if (extended) { CU_ASSERT(rc >= 0); @@ -1323,7 +1323,7 @@ static void packet_test_segments(void) seg_data = odp_packet_seg_data(pkt, seg); CU_ASSERT(seg_data_len > 0); - CU_ASSERT_PTR_NOT_NULL(seg_data); + CU_ASSERT(seg_data != NULL); CU_ASSERT(odp_packet_seg_to_u64(seg) != odp_packet_seg_to_u64(ODP_PACKET_SEG_INVALID)); CU_ASSERT(odp_memcmp(seg_data, seg_data, seg_data_len) == 0); @@ -1635,8 +1635,8 @@ static void _packet_compare_offset(odp_packet_t pkt1, uint32_t off1, pkt1map = odp_packet_offset(pkt1, off1, &seglen1, NULL); pkt2map = odp_packet_offset(pkt2, off2, &seglen2, NULL); - CU_ASSERT_PTR_NOT_NULL_FATAL(pkt1map); - CU_ASSERT_PTR_NOT_NULL_FATAL(pkt2map); + CU_ASSERT_FATAL(pkt1map != NULL); + CU_ASSERT_FATAL(pkt2map != NULL); cmplen = seglen1 < seglen2 ? seglen1 : seglen2; if (len < cmplen) cmplen = len; @@ -1855,7 +1855,7 @@ static void packet_test_copydata(void) CU_ASSERT_FATAL(pkt_len > 0); data_buf = malloc(pkt_len); - CU_ASSERT_PTR_NOT_NULL_FATAL(data_buf); + CU_ASSERT_FATAL(data_buf != NULL); for (i = 0; i < pkt_len; i++) data_buf[i] = (uint8_t)i; @@ -2620,7 +2620,7 @@ static void packet_test_offset(void) CU_ASSERT(seg_len > 1); CU_ASSERT(seg_len == odp_packet_seg_len(pkt)); CU_ASSERT(seg_len == odp_packet_seg_data_len(pkt, seg)); - CU_ASSERT_PTR_NOT_NULL(ptr); + CU_ASSERT(ptr != NULL); CU_ASSERT(ptr == odp_packet_data(pkt)); CU_ASSERT(ptr == odp_packet_seg_data(pkt, seg)); @@ -2630,7 +2630,7 @@ static void packet_test_offset(void) offset = 1; ptr = odp_packet_offset(pkt, offset, &seg_len, NULL); - CU_ASSERT_PTR_NOT_NULL(ptr); + CU_ASSERT(ptr != NULL); CU_ASSERT(ptr == start_ptr + offset); CU_ASSERT(seg_len == full_seg_len - offset); @@ -2638,19 +2638,19 @@ static void packet_test_offset(void) offset = full_seg_len - 1; ptr = odp_packet_offset(pkt, offset, &seg_len, NULL); - CU_ASSERT_PTR_NOT_NULL(ptr); + CU_ASSERT(ptr != NULL); CU_ASSERT(ptr == start_ptr + offset); CU_ASSERT(seg_len == full_seg_len - offset); /* Query the last byte in a packet */ offset = odp_packet_len(pkt) - 1; ptr = odp_packet_offset(pkt, offset, &seg_len, NULL); - CU_ASSERT_PTR_NOT_NULL(ptr); + CU_ASSERT(ptr != NULL); CU_ASSERT(seg_len == 1); /* Pass NULL to [out] arguments */ ptr = odp_packet_offset(pkt, 0, NULL, NULL); - CU_ASSERT_PTR_NOT_NULL(ptr); + CU_ASSERT(ptr != NULL); } static void packet_test_ref(void) @@ -3635,12 +3635,9 @@ static void parse_eth_ipv4_udp(void) CU_ASSERT(odp_packet_has_udp(pkt[i])); CU_ASSERT(!odp_packet_has_ipv6(pkt[i])); CU_ASSERT(!odp_packet_has_tcp(pkt[i])); - CU_ASSERT_EQUAL(odp_packet_l2_type(pkt[i]), - ODP_PROTO_L2_TYPE_ETH); - CU_ASSERT_EQUAL(odp_packet_l3_type(pkt[i]), - ODP_PROTO_L3_TYPE_IPV4); - CU_ASSERT_EQUAL(odp_packet_l4_type(pkt[i]), - ODP_PROTO_L4_TYPE_UDP); + CU_ASSERT(odp_packet_l2_type(pkt[i]) == ODP_PROTO_L2_TYPE_ETH); + CU_ASSERT(odp_packet_l3_type(pkt[i]) == ODP_PROTO_L3_TYPE_IPV4); + CU_ASSERT(odp_packet_l4_type(pkt[i]) == ODP_PROTO_L4_TYPE_UDP); } odp_packet_free_multi(pkt, num_pkt); @@ -3679,12 +3676,9 @@ static void parse_eth_snap_ipv4_udp(void) CU_ASSERT(odp_packet_has_udp(pkt[i])); CU_ASSERT(!odp_packet_has_ipv6(pkt[i])); CU_ASSERT(!odp_packet_has_tcp(pkt[i])); - CU_ASSERT_EQUAL(odp_packet_l2_type(pkt[i]), - ODP_PROTO_L2_TYPE_ETH); - CU_ASSERT_EQUAL(odp_packet_l3_type(pkt[i]), - ODP_PROTO_L3_TYPE_IPV4); - CU_ASSERT_EQUAL(odp_packet_l4_type(pkt[i]), - ODP_PROTO_L4_TYPE_UDP); + CU_ASSERT(odp_packet_l2_type(pkt[i]) == ODP_PROTO_L2_TYPE_ETH); + CU_ASSERT(odp_packet_l3_type(pkt[i]) == ODP_PROTO_L3_TYPE_IPV4); + CU_ASSERT(odp_packet_l4_type(pkt[i]) == ODP_PROTO_L4_TYPE_UDP); } odp_packet_free_multi(pkt, num_pkt); @@ -3718,10 +3712,8 @@ static void parse_ipv4_udp(void) CU_ASSERT(odp_packet_has_udp(pkt[i])); CU_ASSERT(!odp_packet_has_ipv6(pkt[i])); CU_ASSERT(!odp_packet_has_tcp(pkt[i])); - CU_ASSERT_EQUAL(odp_packet_l3_type(pkt[i]), - ODP_PROTO_L3_TYPE_IPV4); - CU_ASSERT_EQUAL(odp_packet_l4_type(pkt[i]), - ODP_PROTO_L4_TYPE_UDP); + CU_ASSERT(odp_packet_l3_type(pkt[i]) == ODP_PROTO_L3_TYPE_IPV4); + CU_ASSERT(odp_packet_l4_type(pkt[i]) == ODP_PROTO_L4_TYPE_UDP); } odp_packet_free_multi(pkt, num_pkt); @@ -3752,12 +3744,9 @@ static void parse_eth_ipv4_tcp(void) CU_ASSERT(odp_packet_has_tcp(pkt[i])); CU_ASSERT(!odp_packet_has_ipv6(pkt[i])); CU_ASSERT(!odp_packet_has_udp(pkt[i])); - CU_ASSERT_EQUAL(odp_packet_l2_type(pkt[i]), - ODP_PROTO_L2_TYPE_ETH); - CU_ASSERT_EQUAL(odp_packet_l3_type(pkt[i]), - ODP_PROTO_L3_TYPE_IPV4); - CU_ASSERT_EQUAL(odp_packet_l4_type(pkt[i]), - ODP_PROTO_L4_TYPE_TCP); + CU_ASSERT(odp_packet_l2_type(pkt[i]) == ODP_PROTO_L2_TYPE_ETH); + CU_ASSERT(odp_packet_l3_type(pkt[i]) == ODP_PROTO_L3_TYPE_IPV4); + CU_ASSERT(odp_packet_l4_type(pkt[i]) == ODP_PROTO_L4_TYPE_TCP); } odp_packet_free_multi(pkt, num_pkt); @@ -3880,12 +3869,9 @@ static void parse_eth_vlan_ipv6_udp(void) CU_ASSERT(odp_packet_has_udp(pkt[i])); CU_ASSERT(!odp_packet_has_ipv4(pkt[i])); CU_ASSERT(!odp_packet_has_tcp(pkt[i])); - CU_ASSERT_EQUAL(odp_packet_l2_type(pkt[i]), - ODP_PROTO_L2_TYPE_ETH); - CU_ASSERT_EQUAL(odp_packet_l3_type(pkt[i]), - ODP_PROTO_L3_TYPE_IPV6); - CU_ASSERT_EQUAL(odp_packet_l4_type(pkt[i]), - ODP_PROTO_L4_TYPE_UDP); + CU_ASSERT(odp_packet_l2_type(pkt[i]) == ODP_PROTO_L2_TYPE_ETH); + CU_ASSERT(odp_packet_l3_type(pkt[i]) == ODP_PROTO_L3_TYPE_IPV6); + CU_ASSERT(odp_packet_l4_type(pkt[i]) == ODP_PROTO_L4_TYPE_UDP); } odp_packet_free_multi(pkt, num_pkt); @@ -4136,12 +4122,9 @@ static void parse_eth_ipv6_ipsec_ah(void) CU_ASSERT(!odp_packet_has_ipv4(pkt[i])); CU_ASSERT(!odp_packet_has_tcp(pkt[i])); CU_ASSERT(!odp_packet_has_udp(pkt[i])); - CU_ASSERT_EQUAL(odp_packet_l2_type(pkt[i]), - ODP_PROTO_L2_TYPE_ETH); - CU_ASSERT_EQUAL(odp_packet_l3_type(pkt[i]), - ODP_PROTO_L3_TYPE_IPV6); - CU_ASSERT_EQUAL(odp_packet_l4_type(pkt[i]), - ODP_PROTO_L4_TYPE_AH); + CU_ASSERT(odp_packet_l2_type(pkt[i]) == ODP_PROTO_L2_TYPE_ETH); + CU_ASSERT(odp_packet_l3_type(pkt[i]) == ODP_PROTO_L3_TYPE_IPV6); + CU_ASSERT(odp_packet_l4_type(pkt[i]) == ODP_PROTO_L4_TYPE_AH); } odp_packet_free_multi(pkt, num_pkt); diff --git a/test/validation/api/pktio/pktio.c b/test/validation/api/pktio/pktio.c index deef4895a..992c88729 100644 --- a/test/validation/api/pktio/pktio.c +++ b/test/validation/api/pktio/pktio.c @@ -1598,48 +1598,48 @@ static void test_defaults(uint8_t fill) memset(&pktio_p, fill, sizeof(pktio_p)); odp_pktio_param_init(&pktio_p); - CU_ASSERT_EQUAL(pktio_p.in_mode, ODP_PKTIN_MODE_DIRECT); - CU_ASSERT_EQUAL(pktio_p.out_mode, ODP_PKTOUT_MODE_DIRECT); + CU_ASSERT(pktio_p.in_mode == ODP_PKTIN_MODE_DIRECT); + CU_ASSERT(pktio_p.out_mode == ODP_PKTOUT_MODE_DIRECT); memset(&qp_in, fill, sizeof(qp_in)); odp_pktin_queue_param_init(&qp_in); - CU_ASSERT_EQUAL(qp_in.op_mode, ODP_PKTIO_OP_MT); - CU_ASSERT_EQUAL(qp_in.classifier_enable, 0); - CU_ASSERT_EQUAL(qp_in.hash_enable, 0); - CU_ASSERT_EQUAL(qp_in.hash_proto.all_bits, 0); - CU_ASSERT_EQUAL(qp_in.num_queues, 1); - CU_ASSERT_EQUAL(qp_in.queue_size[0], 0); - CU_ASSERT_EQUAL(qp_in.queue_param.enq_mode, ODP_QUEUE_OP_MT); - CU_ASSERT_EQUAL(qp_in.queue_param.sched.prio, odp_schedule_default_prio()); - CU_ASSERT_EQUAL(qp_in.queue_param.sched.sync, ODP_SCHED_SYNC_PARALLEL); - CU_ASSERT_EQUAL(qp_in.queue_param.sched.group, ODP_SCHED_GROUP_ALL); - CU_ASSERT_EQUAL(qp_in.queue_param.sched.lock_count, 0); - CU_ASSERT_EQUAL(qp_in.queue_param.order, ODP_QUEUE_ORDER_KEEP); - CU_ASSERT_EQUAL(qp_in.queue_param.nonblocking, ODP_BLOCKING); - CU_ASSERT_EQUAL(qp_in.queue_param.context, NULL); - CU_ASSERT_EQUAL(qp_in.queue_param.context_len, 0); - CU_ASSERT_EQUAL(qp_in.queue_param_ovr, NULL); - CU_ASSERT_EQUAL(qp_in.vector.enable, false); + CU_ASSERT(qp_in.op_mode == ODP_PKTIO_OP_MT); + CU_ASSERT(qp_in.classifier_enable == 0); + CU_ASSERT(qp_in.hash_enable == 0); + CU_ASSERT(qp_in.hash_proto.all_bits == 0); + CU_ASSERT(qp_in.num_queues == 1); + CU_ASSERT(qp_in.queue_size[0] == 0); + CU_ASSERT(qp_in.queue_param.enq_mode == ODP_QUEUE_OP_MT); + CU_ASSERT(qp_in.queue_param.sched.prio == odp_schedule_default_prio()); + CU_ASSERT(qp_in.queue_param.sched.sync == ODP_SCHED_SYNC_PARALLEL); + CU_ASSERT(qp_in.queue_param.sched.group == ODP_SCHED_GROUP_ALL); + CU_ASSERT(qp_in.queue_param.sched.lock_count == 0); + CU_ASSERT(qp_in.queue_param.order == ODP_QUEUE_ORDER_KEEP); + CU_ASSERT(qp_in.queue_param.nonblocking == ODP_BLOCKING); + CU_ASSERT(qp_in.queue_param.context == NULL); + CU_ASSERT(qp_in.queue_param.context_len == 0); + CU_ASSERT(qp_in.queue_param_ovr == NULL); + CU_ASSERT(qp_in.vector.enable == false); memset(&qp_out, fill, sizeof(qp_out)); odp_pktout_queue_param_init(&qp_out); - CU_ASSERT_EQUAL(qp_out.op_mode, ODP_PKTIO_OP_MT); - CU_ASSERT_EQUAL(qp_out.num_queues, 1); - CU_ASSERT_EQUAL(qp_out.queue_size[0], 0); + CU_ASSERT(qp_out.op_mode == ODP_PKTIO_OP_MT); + CU_ASSERT(qp_out.num_queues == 1); + CU_ASSERT(qp_out.queue_size[0] == 0); memset(&pktio_conf, fill, sizeof(pktio_conf)); odp_pktio_config_init(&pktio_conf); - CU_ASSERT_EQUAL(pktio_conf.pktin.all_bits, 0); - CU_ASSERT_EQUAL(pktio_conf.pktout.all_bits, 0); - CU_ASSERT_EQUAL(pktio_conf.parser.layer, ODP_PROTO_LAYER_ALL); - CU_ASSERT_EQUAL(pktio_conf.enable_loop, false); - CU_ASSERT_EQUAL(pktio_conf.inbound_ipsec, false); - CU_ASSERT_EQUAL(pktio_conf.outbound_ipsec, false); - CU_ASSERT_EQUAL(pktio_conf.enable_lso, false); - CU_ASSERT_EQUAL(pktio_conf.reassembly.en_ipv4, false); - CU_ASSERT_EQUAL(pktio_conf.reassembly.en_ipv6, false); - CU_ASSERT_EQUAL(pktio_conf.reassembly.max_wait_time, 0); - CU_ASSERT_EQUAL(pktio_conf.reassembly.max_num_frags, 2); + CU_ASSERT(pktio_conf.pktin.all_bits == 0); + CU_ASSERT(pktio_conf.pktout.all_bits == 0); + CU_ASSERT(pktio_conf.parser.layer == ODP_PROTO_LAYER_ALL); + CU_ASSERT(pktio_conf.enable_loop == false); + CU_ASSERT(pktio_conf.inbound_ipsec == false); + CU_ASSERT(pktio_conf.outbound_ipsec == false); + CU_ASSERT(pktio_conf.enable_lso == false); + CU_ASSERT(pktio_conf.reassembly.en_ipv4 == false); + CU_ASSERT(pktio_conf.reassembly.en_ipv6 == false); + CU_ASSERT(pktio_conf.reassembly.max_wait_time == 0); + CU_ASSERT(pktio_conf.reassembly.max_num_frags == 2); } static void pktio_test_default_values(void) diff --git a/test/validation/api/pool/pool.c b/test/validation/api/pool/pool.c index 86a47230a..4ced1fee2 100644 --- a/test/validation/api/pool/pool.c +++ b/test/validation/api/pool/pool.c @@ -1136,7 +1136,7 @@ static void pool_test_create_after_fork(void) shm = odp_shm_reserve(NULL, sizeof(global_shared_mem_t), 0, 0); CU_ASSERT_FATAL(shm != ODP_SHM_INVALID); global_mem = odp_shm_addr(shm); - CU_ASSERT_PTR_NOT_NULL_FATAL(global_mem); + CU_ASSERT_FATAL(global_mem != NULL); num = odp_cpumask_default_worker(NULL, 0); if (num > MAX_WORKERS) diff --git a/test/validation/api/scheduler/scheduler.c b/test/validation/api/scheduler/scheduler.c index 8dddd8d8f..1b91b1324 100644 --- a/test/validation/api/scheduler/scheduler.c +++ b/test/validation/api/scheduler/scheduler.c @@ -1367,12 +1367,12 @@ static void chaos_run(unsigned int qtype) shm = odp_shm_lookup(GLOBALS_SHM_NAME); CU_ASSERT_FATAL(shm != ODP_SHM_INVALID); globals = odp_shm_addr(shm); - CU_ASSERT_PTR_NOT_NULL_FATAL(globals); + CU_ASSERT_FATAL(globals != NULL); shm = odp_shm_lookup(SHM_THR_ARGS_NAME); CU_ASSERT_FATAL(shm != ODP_SHM_INVALID); args = odp_shm_addr(shm); - CU_ASSERT_PTR_NOT_NULL_FATAL(args); + CU_ASSERT_FATAL(args != NULL); args->globals = globals; @@ -1798,7 +1798,7 @@ static void schedule_common(odp_schedule_sync_t sync, int num_queues, shm = odp_shm_lookup(GLOBALS_SHM_NAME); CU_ASSERT_FATAL(shm != ODP_SHM_INVALID); globals = odp_shm_addr(shm); - CU_ASSERT_PTR_NOT_NULL_FATAL(globals); + CU_ASSERT_FATAL(globals != NULL); memset(&args, 0, sizeof(thread_args_t)); args.globals = globals; @@ -1829,12 +1829,12 @@ static void parallel_execute(odp_schedule_sync_t sync, int num_queues, shm = odp_shm_lookup(GLOBALS_SHM_NAME); CU_ASSERT_FATAL(shm != ODP_SHM_INVALID); globals = odp_shm_addr(shm); - CU_ASSERT_PTR_NOT_NULL_FATAL(globals); + CU_ASSERT_FATAL(globals != NULL); shm = odp_shm_lookup(SHM_THR_ARGS_NAME); CU_ASSERT_FATAL(shm != ODP_SHM_INVALID); args = odp_shm_addr(shm); - CU_ASSERT_PTR_NOT_NULL_FATAL(args); + CU_ASSERT_FATAL(args != NULL); args->globals = globals; args->sync = sync; @@ -2583,12 +2583,12 @@ static void scheduler_test_sched_and_plain(odp_schedule_sync_t sync) shm = odp_shm_lookup(GLOBALS_SHM_NAME); CU_ASSERT_FATAL(shm != ODP_SHM_INVALID); globals = odp_shm_addr(shm); - CU_ASSERT_PTR_NOT_NULL_FATAL(globals); + CU_ASSERT_FATAL(globals != NULL); shm = odp_shm_lookup(SHM_THR_ARGS_NAME); CU_ASSERT_FATAL(shm != ODP_SHM_INVALID); args = odp_shm_addr(shm); - CU_ASSERT_PTR_NOT_NULL_FATAL(args); + CU_ASSERT_FATAL(args != NULL); args->globals = globals; /* Make sure all events fit to queues */ diff --git a/test/validation/api/shmem/shmem.c b/test/validation/api/shmem/shmem.c index 9e91dab35..7ba179d53 100644 --- a/test/validation/api/shmem/shmem.c +++ b/test/validation/api/shmem/shmem.c @@ -610,7 +610,7 @@ static int run_test_reserve_after_fork(void *arg ODP_UNUSED) CU_ASSERT(ODP_SHM_INVALID != shm); glob_data->shm[thr_index] = shm; pattern_small = odp_shm_addr(shm); - CU_ASSERT_PTR_NOT_NULL(pattern_small); + CU_ASSERT(pattern_small != NULL); for (i = 0; i < SMALL_MEM; i++) pattern_small->data[i] = i; break; @@ -620,7 +620,7 @@ static int run_test_reserve_after_fork(void *arg ODP_UNUSED) CU_ASSERT(ODP_SHM_INVALID != shm); glob_data->shm[thr_index] = shm; pattern_medium = odp_shm_addr(shm); - CU_ASSERT_PTR_NOT_NULL(pattern_medium); + CU_ASSERT(pattern_medium != NULL); for (i = 0; i < MEDIUM_MEM; i++) pattern_medium->data[i] = (i << 2); break; @@ -630,7 +630,7 @@ static int run_test_reserve_after_fork(void *arg ODP_UNUSED) CU_ASSERT(ODP_SHM_INVALID != shm); glob_data->shm[thr_index] = shm; pattern_big = odp_shm_addr(shm); - CU_ASSERT_PTR_NOT_NULL(pattern_big); + CU_ASSERT(pattern_big != NULL); for (i = 0; i < BIG_MEM; i++) pattern_big->data[i] = (i >> 2); break; @@ -663,7 +663,7 @@ static void shmem_test_reserve_after_fork(void) shm = odp_shm_reserve(MEM_NAME, sizeof(shared_test_data_t), 0, 0); CU_ASSERT(ODP_SHM_INVALID != shm); glob_data = odp_shm_addr(shm); - CU_ASSERT_PTR_NOT_NULL(glob_data); + CU_ASSERT(glob_data != NULL); num = odp_cpumask_default_worker(NULL, 0); if (num > MAX_WORKERS) @@ -690,21 +690,21 @@ static void shmem_test_reserve_after_fork(void) case 0: pattern_small = odp_shm_addr(glob_data->shm[thr_index]); - CU_ASSERT_PTR_NOT_NULL(pattern_small); + CU_ASSERT(pattern_small != NULL); for (i = 0; i < SMALL_MEM; i++) CU_ASSERT(pattern_small->data[i] == i); break; case 1: pattern_medium = odp_shm_addr(glob_data->shm[thr_index]); - CU_ASSERT_PTR_NOT_NULL(pattern_medium); + CU_ASSERT(pattern_medium != NULL); for (i = 0; i < MEDIUM_MEM; i++) CU_ASSERT(pattern_medium->data[i] == (i << 2)); break; case 2: pattern_big = odp_shm_addr(glob_data->shm[thr_index]); - CU_ASSERT_PTR_NOT_NULL(pattern_big); + CU_ASSERT(pattern_big != NULL); for (i = 0; i < BIG_MEM; i++) CU_ASSERT(pattern_big->data[i] == (i >> 2)); break; @@ -774,7 +774,7 @@ static int run_test_singleva_after_fork(void *arg ODP_UNUSED) CU_ASSERT_FATAL(ODP_SHM_INVALID != shm); glob_data->shm[thr_index] = shm; pattern_small = odp_shm_addr(shm); - CU_ASSERT_PTR_NOT_NULL(pattern_small); + CU_ASSERT(pattern_small != NULL); glob_data->address[thr_index] = (void *)pattern_small; for (i = 0; i < SMALL_MEM; i++) pattern_small->data[i] = i; @@ -786,7 +786,7 @@ static int run_test_singleva_after_fork(void *arg ODP_UNUSED) CU_ASSERT_FATAL(ODP_SHM_INVALID != shm); glob_data->shm[thr_index] = shm; pattern_medium = odp_shm_addr(shm); - CU_ASSERT_PTR_NOT_NULL(pattern_medium); + CU_ASSERT(pattern_medium != NULL); glob_data->address[thr_index] = (void *)pattern_medium; for (i = 0; i < MEDIUM_MEM; i++) pattern_medium->data[i] = (i << 2); @@ -798,7 +798,7 @@ static int run_test_singleva_after_fork(void *arg ODP_UNUSED) CU_ASSERT_FATAL(ODP_SHM_INVALID != shm); glob_data->shm[thr_index] = shm; pattern_big = odp_shm_addr(shm); - CU_ASSERT_PTR_NOT_NULL(pattern_big); + CU_ASSERT(pattern_big != NULL); glob_data->address[thr_index] = (void *)pattern_big; for (i = 0; i < BIG_MEM; i++) pattern_big->data[i] = (i >> 2); @@ -855,7 +855,7 @@ static void shmem_test_singleva_after_fork(void) 0, 0); CU_ASSERT(ODP_SHM_INVALID != shm); glob_data = odp_shm_addr(shm); - CU_ASSERT_PTR_NOT_NULL(glob_data); + CU_ASSERT(glob_data != NULL); num = odp_cpumask_default_worker(NULL, 3); if (num > MAX_WORKERS) @@ -885,21 +885,21 @@ static void shmem_test_singleva_after_fork(void) case 0: pattern_small = odp_shm_addr(glob_data->shm[thr_index]); - CU_ASSERT_PTR_NOT_NULL_FATAL(pattern_small); + CU_ASSERT_FATAL(pattern_small != NULL); for (i = 0; i < SMALL_MEM; i++) CU_ASSERT(pattern_small->data[i] == i); break; case 1: pattern_medium = odp_shm_addr(glob_data->shm[thr_index]); - CU_ASSERT_PTR_NOT_NULL_FATAL(pattern_medium); + CU_ASSERT_FATAL(pattern_medium != NULL); for (i = 0; i < MEDIUM_MEM; i++) CU_ASSERT(pattern_medium->data[i] == (i << 2)); break; case 2: pattern_big = odp_shm_addr(glob_data->shm[thr_index]); - CU_ASSERT_PTR_NOT_NULL_FATAL(pattern_big); + CU_ASSERT_FATAL(pattern_big != NULL); for (i = 0; i < BIG_MEM; i++) CU_ASSERT(pattern_big->data[i] == (i >> 2)); break; @@ -950,7 +950,7 @@ static int run_test_stress(void *arg ODP_UNUSED) shm = odp_shm_lookup(MEM_NAME); glob_data = odp_shm_addr(shm); - CU_ASSERT_PTR_NOT_NULL(glob_data); + CU_ASSERT(glob_data != NULL); /* wait for general GO! */ odp_barrier_wait(&glob_data->test_barrier1); @@ -1000,7 +1000,7 @@ static int run_test_stress(void *arg ODP_UNUSED) } address = odp_shm_addr(shm); - CU_ASSERT_PTR_NOT_NULL(address); + CU_ASSERT(address != NULL); glob_data->stress[index].address = address; glob_data->stress[index].flags = flags; glob_data->stress[index].size = size; @@ -1035,7 +1035,7 @@ static int run_test_stress(void *arg ODP_UNUSED) != 0); address = odp_shm_addr(shm); - CU_ASSERT_PTR_NOT_NULL(address); + CU_ASSERT(address != NULL); align = glob_data->stress[index].align; if (align) { @@ -1091,7 +1091,7 @@ static void shmem_test_stress(void) 0, 0); CU_ASSERT(ODP_SHM_INVALID != globshm); glob_data = odp_shm_addr(globshm); - CU_ASSERT_PTR_NOT_NULL(glob_data); + CU_ASSERT(glob_data != NULL); num = odp_cpumask_default_worker(NULL, 0); if (num > MAX_WORKERS) diff --git a/test/validation/api/traffic_mngr/traffic_mngr.c b/test/validation/api/traffic_mngr/traffic_mngr.c index b7f546dcd..041e32ab5 100644 --- a/test/validation/api/traffic_mngr/traffic_mngr.c +++ b/test/validation/api/traffic_mngr/traffic_mngr.c @@ -4456,7 +4456,7 @@ static void test_defaults(uint8_t fill) memset(&req, fill, sizeof(req)); odp_tm_requirements_init(&req); - CU_ASSERT_EQUAL(req.num_levels, 0); + CU_ASSERT(req.num_levels == 0); CU_ASSERT(!req.tm_queue_shaper_needed); CU_ASSERT(!req.tm_queue_wred_needed); CU_ASSERT(!req.tm_queue_dual_slope_needed); @@ -4466,7 +4466,7 @@ static void test_defaults(uint8_t fill) CU_ASSERT(!req.drop_prec_marking_needed); for (n = 0; n < ODP_NUM_PACKET_COLORS; n++) CU_ASSERT(!req.marking_colors_needed[n]); - CU_ASSERT_EQUAL(req.pkt_prio_mode, ODP_TM_PKT_PRIO_MODE_PRESERVE); + CU_ASSERT(req.pkt_prio_mode == ODP_TM_PKT_PRIO_MODE_PRESERVE); for (n = 0; n < ODP_TM_MAX_LEVELS; n++) { odp_tm_level_requirements_t *l_req = &req.per_level[n]; @@ -4481,14 +4481,14 @@ static void test_defaults(uint8_t fill) memset(&shaper, fill, sizeof(shaper)); odp_tm_shaper_params_init(&shaper); CU_ASSERT(shaper.packet_mode == ODP_TM_SHAPER_RATE_SHAPE); - CU_ASSERT_EQUAL(shaper.shaper_len_adjust, 0); + CU_ASSERT(shaper.shaper_len_adjust == 0); CU_ASSERT(!shaper.dual_rate); CU_ASSERT(!shaper.packet_mode); memset(&sched, 0xff, sizeof(sched)); odp_tm_sched_params_init(&sched); for (n = 0; n < ODP_TM_MAX_PRIORITIES; n++) - CU_ASSERT_EQUAL(sched.sched_modes[n], ODP_TM_BYTE_BASED_WEIGHTS); + CU_ASSERT(sched.sched_modes[n] == ODP_TM_BYTE_BASED_WEIGHTS); memset(&threshold, fill, sizeof(threshold)); odp_tm_threshold_params_init(&threshold); @@ -4502,18 +4502,18 @@ static void test_defaults(uint8_t fill) memset(&node, fill, sizeof(node)); odp_tm_node_params_init(&node); - CU_ASSERT_EQUAL(node.shaper_profile, ODP_TM_INVALID); - CU_ASSERT_EQUAL(node.threshold_profile, ODP_TM_INVALID); + CU_ASSERT(node.shaper_profile == ODP_TM_INVALID); + CU_ASSERT(node.threshold_profile == ODP_TM_INVALID); for (n = 0; n < ODP_NUM_PACKET_COLORS; n++) - CU_ASSERT_EQUAL(node.wred_profile[n], ODP_TM_INVALID); + CU_ASSERT(node.wred_profile[n] == ODP_TM_INVALID); memset(&queue, fill, sizeof(queue)); odp_tm_queue_params_init(&queue); - CU_ASSERT_EQUAL(queue.shaper_profile, ODP_TM_INVALID); - CU_ASSERT_EQUAL(queue.threshold_profile, ODP_TM_INVALID); + CU_ASSERT(queue.shaper_profile == ODP_TM_INVALID); + CU_ASSERT(queue.threshold_profile == ODP_TM_INVALID); for (n = 0; n < ODP_NUM_PACKET_COLORS; n++) - CU_ASSERT_EQUAL(queue.wred_profile[n], ODP_TM_INVALID); - CU_ASSERT_EQUAL(queue.priority, 0); + CU_ASSERT(queue.wred_profile[n] == ODP_TM_INVALID); + CU_ASSERT(queue.priority == 0); CU_ASSERT(queue.ordered_enqueue); } -- cgit v1.2.3