diff options
Diffstat (limited to 'test/validation/api')
59 files changed, 1801 insertions, 1082 deletions
diff --git a/test/validation/api/Makefile.am b/test/validation/api/Makefile.am index 5a3c0216b..5a846b0c6 100644 --- a/test/validation/api/Makefile.am +++ b/test/validation/api/Makefile.am @@ -6,6 +6,7 @@ ODP_MODULES = align \ chksum \ classification \ comp \ + cpu \ cpumask \ crypto \ dma \ @@ -46,6 +47,7 @@ TESTS = \ chksum/chksum_main$(EXEEXT) \ classification/classification_main$(EXEEXT) \ comp/comp_main$(EXEEXT) \ + cpu/cpu_main$(EXEEXT) \ cpumask/cpumask_main$(EXEEXT) \ crypto/crypto_main$(EXEEXT) \ dma/dma_main$(EXEEXT) \ diff --git a/test/validation/api/README b/test/validation/api/README index 7ee903478..665bb7896 100644 --- a/test/validation/api/README +++ b/test/validation/api/README @@ -1,8 +1,5 @@ -Copyright (c) 2015-2018, Linaro Limited -All rights reserved. - -SPDX-License-Identifier: BSD-3-Clause - +SPDX-License-Identifier: BSD-3-Clause +Copyright (c) 2015-2018 Linaro Limited To add tests in here, please observe the rules listed below. This list is a brief overview, for a more detailed explanation of the test diff --git a/test/validation/api/atomic/atomic.c b/test/validation/api/atomic/atomic.c index fab982462..8ae541fe4 100644 --- a/test/validation/api/atomic/atomic.c +++ b/test/validation/api/atomic/atomic.c @@ -1,8 +1,6 @@ -/* Copyright (c) 2014-2018, Linaro Limited +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2014-2018 Linaro Limited * Copyright (c) 2021-2022 Nokia - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause */ #include <malloc.h> @@ -55,7 +53,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..aaf646e8a 100644 --- a/test/validation/api/barrier/barrier.c +++ b/test/validation/api/barrier/barrier.c @@ -1,8 +1,6 @@ -/* Copyright (c) 2014-2018, Linaro Limited - * Copyright (c) 2022, Nokia - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2014-2018 Linaro Limited + * Copyright (c) 2022 Nokia */ #include <malloc.h> @@ -106,7 +104,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/buffer/buffer.c b/test/validation/api/buffer/buffer.c index 2a79ed27e..89f16d283 100644 --- a/test/validation/api/buffer/buffer.c +++ b/test/validation/api/buffer/buffer.c @@ -1,16 +1,15 @@ -/* Copyright (c) 2014-2018, Linaro Limited - * Copyright (c) 2019-2022, Nokia - * Copyright (c) 2022, Marvell - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2014-2018 Linaro Limited + * Copyright (c) 2019-2024 Nokia + * Copyright (c) 2022 Marvell */ #include <odp_api.h> -#include <odp/helper/odph_debug.h> +#include <odp/helper/odph_api.h> #include "odp_cunit_common.h" #define BUF_ALIGN ODP_CACHE_LINE_SIZE +#define BUF_MAX_SIZE 65536 #define BUF_SIZE 1500 #define BUF_NUM 100 #define BURST 8 @@ -61,6 +60,7 @@ static void test_pool_alloc_free(const odp_pool_param_t *param) uint32_t num_buf = 0; void *addr; odp_event_subtype_t subtype; + const uint32_t max_size = pool_capa.buf.max_size; uint32_t num = param->buf.num; uint32_t size = param->buf.size; uint32_t align = param->buf.align; @@ -104,7 +104,8 @@ static void test_pool_alloc_free(const odp_pool_param_t *param) wrong_type = true; if (subtype != ODP_EVENT_NO_SUBTYPE) wrong_subtype = true; - if (odp_buffer_size(buffer[i]) < size) + if (odp_buffer_size(buffer[i]) < size || + (max_size && odp_buffer_size(buffer[i]) > max_size)) wrong_size = true; addr = odp_buffer_addr(buffer[i]); @@ -142,6 +143,7 @@ static void test_pool_alloc_free_multi(const odp_pool_param_t *param) odp_event_t ev; void *addr; odp_event_subtype_t subtype; + const uint32_t max_size = pool_capa.buf.max_size; uint32_t num = param->buf.num; uint32_t size = param->buf.size; uint32_t align = param->buf.align; @@ -193,7 +195,8 @@ static void test_pool_alloc_free_multi(const odp_pool_param_t *param) wrong_type = true; if (subtype != ODP_EVENT_NO_SUBTYPE) wrong_subtype = true; - if (odp_buffer_size(buffer[i]) < size) + if (odp_buffer_size(buffer[i]) < size || + (max_size && odp_buffer_size(buffer[i]) > max_size)) wrong_size = true; addr = odp_buffer_addr(buffer[i]); @@ -389,6 +392,16 @@ static void buffer_test_pool_alloc_free(void) test_pool_alloc_free(&default_param); } +static void buffer_test_pool_alloc_free_max_size(void) +{ + odp_pool_param_t param; + + memcpy(¶m, &default_param, sizeof(odp_pool_param_t)); + param.buf.size = pool_capa.buf.max_size ? pool_capa.buf.max_size : BUF_MAX_SIZE; + + test_pool_alloc_free(¶m); +} + static void buffer_test_pool_alloc_free_min_cache(void) { odp_pool_param_t param; @@ -412,6 +425,16 @@ static void buffer_test_pool_alloc_free_multi(void) test_pool_alloc_free_multi(&default_param); } +static void buffer_test_pool_alloc_free_multi_max_size(void) +{ + odp_pool_param_t param; + + memcpy(¶m, &default_param, sizeof(odp_pool_param_t)); + param.buf.size = pool_capa.buf.max_size ? pool_capa.buf.max_size : BUF_MAX_SIZE; + + test_pool_alloc_free_multi(¶m); +} + static void buffer_test_pool_alloc_free_multi_min_cache(void) { odp_pool_param_t param; @@ -552,6 +575,7 @@ static void buffer_test_user_area(void) CU_ASSERT(prev != addr); ev = odp_buffer_to_event(buffer[i]); + odp_event_user_flag_set(ev, 1); CU_ASSERT(odp_event_user_area(ev) == addr); CU_ASSERT(odp_event_user_area_and_flag(ev, &flag) == addr); CU_ASSERT(flag < 0); @@ -570,9 +594,11 @@ static void buffer_test_user_area(void) odp_testinfo_t buffer_suite[] = { ODP_TEST_INFO(buffer_test_pool_alloc_free), + ODP_TEST_INFO(buffer_test_pool_alloc_free_max_size), ODP_TEST_INFO(buffer_test_pool_alloc_free_min_cache), ODP_TEST_INFO(buffer_test_pool_alloc_free_max_cache), ODP_TEST_INFO(buffer_test_pool_alloc_free_multi), + ODP_TEST_INFO(buffer_test_pool_alloc_free_multi_max_size), ODP_TEST_INFO(buffer_test_pool_alloc_free_multi_min_cache), ODP_TEST_INFO(buffer_test_pool_alloc_free_multi_max_cache), ODP_TEST_INFO(buffer_test_pool_single_pool), diff --git a/test/validation/api/chksum/chksum.c b/test/validation/api/chksum/chksum.c index 0be418f3a..17f8fed12 100644 --- a/test/validation/api/chksum/chksum.c +++ b/test/validation/api/chksum/chksum.c @@ -1,7 +1,5 @@ -/* Copyright (c) 2017-2018, Linaro Limited - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2017-2018 Linaro Limited */ #include <odp_api.h> diff --git a/test/validation/api/classification/classification.c b/test/validation/api/classification/classification.c index ef9a647cb..ef975c237 100644 --- a/test/validation/api/classification/classification.c +++ b/test/validation/api/classification/classification.c @@ -1,7 +1,5 @@ -/* Copyright (c) 2015-2018, Linaro Limited - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2015-2018 Linaro Limited */ #include <odp_api.h> diff --git a/test/validation/api/classification/classification.h b/test/validation/api/classification/classification.h index 70dcc6230..1f66b832a 100644 --- a/test/validation/api/classification/classification.h +++ b/test/validation/api/classification/classification.h @@ -1,7 +1,5 @@ -/* Copyright (c) 2015-2018, Linaro Limited - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2015-2018 Linaro Limited */ #ifndef _ODP_TEST_CLASSIFICATION_H_ diff --git a/test/validation/api/classification/odp_classification_basic.c b/test/validation/api/classification/odp_classification_basic.c index ca0b58ad5..b5ccdcfea 100644 --- a/test/validation/api/classification/odp_classification_basic.c +++ b/test/validation/api/classification/odp_classification_basic.c @@ -1,8 +1,6 @@ -/* Copyright (c) 2015-2018, Linaro Limited - * Copyright (c) 2021-2023, Nokia - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2015-2018 Linaro Limited + * Copyright (c) 2021-2023 Nokia */ #include <odp_cunit_common.h> @@ -22,14 +20,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/classification/odp_classification_common.c b/test/validation/api/classification/odp_classification_common.c index 1fb4c51b5..b767a7582 100644 --- a/test/validation/api/classification/odp_classification_common.c +++ b/test/validation/api/classification/odp_classification_common.c @@ -1,8 +1,6 @@ -/* Copyright (c) 2015-2018, Linaro Limited - * Copyright (c) 2020, Nokia - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2015-2018 Linaro Limited + * Copyright (c) 2020 Nokia */ #include "odp_classification_testsuites.h" diff --git a/test/validation/api/classification/odp_classification_test_pmr.c b/test/validation/api/classification/odp_classification_test_pmr.c index 7db0e1b5e..04cf098e3 100644 --- a/test/validation/api/classification/odp_classification_test_pmr.c +++ b/test/validation/api/classification/odp_classification_test_pmr.c @@ -1,8 +1,6 @@ -/* Copyright (c) 2015-2018, Linaro Limited - * Copyright (c) 2019-2023, Nokia - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2015-2018 Linaro Limited + * Copyright (c) 2019-2023 Nokia */ #include "odp_classification_testsuites.h" diff --git a/test/validation/api/classification/odp_classification_tests.c b/test/validation/api/classification/odp_classification_tests.c index d81884006..086b712ad 100644 --- a/test/validation/api/classification/odp_classification_tests.c +++ b/test/validation/api/classification/odp_classification_tests.c @@ -1,8 +1,6 @@ -/* Copyright (c) 2015-2018, Linaro Limited - * Copyright (c) 2020-2023, Nokia - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2015-2018 Linaro Limited + * Copyright (c) 2020-2023 Nokia */ #include "odp_classification_testsuites.h" @@ -226,7 +224,7 @@ void configure_cls_pmr_chain(odp_bool_t enable_pktv) uint16_t val; uint16_t maskport; - char cosname[ODP_QUEUE_NAME_LEN]; + char cosname[ODP_COS_NAME_LEN]; odp_queue_param_t qparam; odp_cls_cos_param_t cls_param; char queuename[ODP_QUEUE_NAME_LEN]; diff --git a/test/validation/api/classification/odp_classification_testsuites.h b/test/validation/api/classification/odp_classification_testsuites.h index 888613b1f..34f93ee8d 100644 --- a/test/validation/api/classification/odp_classification_testsuites.h +++ b/test/validation/api/classification/odp_classification_testsuites.h @@ -1,7 +1,5 @@ -/* Copyright (c) 2015-2018, Linaro Limited - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2015-2018 Linaro Limited */ #ifndef ODP_CLASSIFICATION_TESTSUITES_H_ diff --git a/test/validation/api/comp/comp.c b/test/validation/api/comp/comp.c index b7dfcd359..7078453df 100644 --- a/test/validation/api/comp/comp.c +++ b/test/validation/api/comp/comp.c @@ -1,7 +1,5 @@ -/* Copyright (c) 2018, Linaro Limited - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2018 Linaro Limited */ #include <odp_api.h> diff --git a/test/validation/api/comp/test_vectors.h b/test/validation/api/comp/test_vectors.h index 36d98b30d..c99041c9a 100644 --- a/test/validation/api/comp/test_vectors.h +++ b/test/validation/api/comp/test_vectors.h @@ -1,7 +1,5 @@ -/* Copyright (c) 2018, Linaro Limited - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2018 Linaro Limited */ #ifndef _ODP_TEST_COMP_VECTORS_H_ diff --git a/test/validation/api/cpu/.gitignore b/test/validation/api/cpu/.gitignore new file mode 100644 index 000000000..1b07639e6 --- /dev/null +++ b/test/validation/api/cpu/.gitignore @@ -0,0 +1 @@ +cpu_main diff --git a/test/validation/api/cpu/Makefile.am b/test/validation/api/cpu/Makefile.am new file mode 100644 index 000000000..c53fbc850 --- /dev/null +++ b/test/validation/api/cpu/Makefile.am @@ -0,0 +1,4 @@ +include ../Makefile.inc + +test_PROGRAMS = cpu_main +cpu_main_SOURCES = cpu.c diff --git a/test/validation/api/cpu/cpu.c b/test/validation/api/cpu/cpu.c new file mode 100644 index 000000000..5b05a0f83 --- /dev/null +++ b/test/validation/api/cpu/cpu.c @@ -0,0 +1,461 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2024 Nokia + * Copyright (c) 2015-2018 Linaro Limited + */ + +#include <odp_api.h> +#include <odp/helper/odph_api.h> + +#include "odp_cunit_common.h" +#include "test_common_macros.h" + +#define PERIODS_100_MSEC 160 +#define RES_TRY_NUM 10 +#define GIGA_HZ 1000000000ULL +#define KILO_HZ 1000ULL + +/* 10 usec wait time assumes >100kHz resolution on CPU cycles counter */ +#define WAIT_TIME (10 * ODP_TIME_USEC_IN_NS) + +/* Data for cache prefetch test cases */ +static uint8_t global_data[8 * ODP_CACHE_LINE_SIZE] ODP_ALIGNED_CACHE; + +static int check_cycle_counter(void) +{ + if (odp_cpu_cycles_max() == 0) { + printf("Cycle counter is not supported, skipping test\n"); + return ODP_TEST_INACTIVE; + } + + return ODP_TEST_ACTIVE; +} + +static int check_cpu_hz(void) +{ + if (odp_cpu_hz() == 0) { + printf("odp_cpu_hz() is not supported, skipping test\n"); + return ODP_TEST_INACTIVE; + } + + return ODP_TEST_ACTIVE; +} + +static int check_cpu_hz_max(void) +{ + if (odp_cpu_hz_max() == 0) { + printf("odp_cpu_hz_max() is not supported, skipping test\n"); + return ODP_TEST_INACTIVE; + } + return ODP_TEST_ACTIVE; +} + +static int check_cpu_hz_id(void) +{ + uint64_t hz; + odp_cpumask_t mask; + int i, num, cpu; + + num = odp_cpumask_all_available(&mask); + cpu = odp_cpumask_first(&mask); + + for (i = 0; i < num; i++) { + hz = odp_cpu_hz_id(cpu); + if (hz == 0) { + printf("odp_cpu_hz_id() is not supported by CPU %d, skipping test\n", cpu); + return ODP_TEST_INACTIVE; + } + cpu = odp_cpumask_next(&mask, cpu); + } + + return ODP_TEST_ACTIVE; +} + +static int check_cpu_hz_max_id(void) +{ + uint64_t hz; + odp_cpumask_t mask; + int i, num, cpu; + + num = odp_cpumask_all_available(&mask); + cpu = odp_cpumask_first(&mask); + + for (i = 0; i < num; i++) { + hz = odp_cpu_hz_max_id(cpu); + if (hz == 0) { + printf("odp_cpu_hz_max_id() is not supported by CPU %d, skipping test\n", + cpu); + return ODP_TEST_INACTIVE; + } + cpu = odp_cpumask_next(&mask, cpu); + } + + return ODP_TEST_ACTIVE; +} + +static void cpu_id(void) +{ + CU_ASSERT(odp_cpu_id() >= 0); +} + +static void cpu_count(void) +{ + int cpus; + + cpus = odp_cpu_count(); + CU_ASSERT(0 < cpus); +} + +static void cpu_model_str(void) +{ + char model[128]; + + snprintf(model, 128, "%s", odp_cpu_model_str()); + CU_ASSERT(strlen(model) > 0); + CU_ASSERT(strlen(model) < 127); +} + +static void cpu_model_str_id(void) +{ + char model[128]; + odp_cpumask_t mask; + int i, num, cpu; + + num = odp_cpumask_all_available(&mask); + cpu = odp_cpumask_first(&mask); + + for (i = 0; i < num; i++) { + snprintf(model, 128, "%s", odp_cpu_model_str_id(cpu)); + CU_ASSERT(strlen(model) > 0); + CU_ASSERT(strlen(model) < 127); + cpu = odp_cpumask_next(&mask, cpu); + } +} + +static void cpu_hz(void) +{ + uint64_t hz = odp_cpu_hz(); + + /* Test value sanity: less than 10GHz */ + CU_ASSERT(hz < 10 * GIGA_HZ); + + /* larger than 1kHz */ + CU_ASSERT(hz > 1 * KILO_HZ); +} + +static void cpu_hz_id(void) +{ + uint64_t hz; + odp_cpumask_t mask; + int i, num, cpu; + + num = odp_cpumask_all_available(&mask); + cpu = odp_cpumask_first(&mask); + + for (i = 0; i < num; i++) { + hz = odp_cpu_hz_id(cpu); + /* Test value sanity: less than 10GHz */ + CU_ASSERT(hz < 10 * GIGA_HZ); + /* larger than 1kHz */ + CU_ASSERT(hz > 1 * KILO_HZ); + cpu = odp_cpumask_next(&mask, cpu); + } +} + +static void cpu_hz_max(void) +{ + uint64_t hz = odp_cpu_hz_max(); + + /* Sanity check value */ + CU_ASSERT(hz > 1 * KILO_HZ); + CU_ASSERT(hz < 20 * GIGA_HZ); +} + +static void cpu_hz_max_id(void) +{ + uint64_t hz; + odp_cpumask_t mask; + int i, num, cpu; + + num = odp_cpumask_all_available(&mask); + cpu = odp_cpumask_first(&mask); + + for (i = 0; i < num; i++) { + hz = odp_cpu_hz_max_id(cpu); + /* Sanity check value */ + CU_ASSERT(hz > 1 * KILO_HZ); + CU_ASSERT(hz < 20 * GIGA_HZ); + cpu = odp_cpumask_next(&mask, cpu); + } +} + +static void cpu_cycles(void) +{ + uint64_t c2, c1, diff, max; + + c1 = odp_cpu_cycles(); + odp_time_wait_ns(WAIT_TIME); + c2 = odp_cpu_cycles(); + + CU_ASSERT(c2 != c1); + + max = odp_cpu_cycles_max(); + + /* With 10 usec delay, diff should be small compared to the maximum. + * Otherwise, counter is going backwards. */ + if (c2 > c1) { + diff = c2 - c1; + CU_ASSERT(diff < (max - diff)); + } + + /* Same applies also when there was a wrap. */ + if (c2 < c1) { + diff = max - c1 + c2; + CU_ASSERT(diff < (max - diff)); + } +} + +static void cpu_cycles_diff(void) +{ + uint64_t c2, c1, max; + uint64_t tmp, diff, res; + + res = odp_cpu_cycles_resolution(); + max = odp_cpu_cycles_max(); + + c1 = res; + c2 = 2 * res; + diff = odp_cpu_cycles_diff(c2, c1); + CU_ASSERT(diff == res); + + c1 = odp_cpu_cycles(); + odp_time_wait_ns(WAIT_TIME); + c2 = odp_cpu_cycles(); + diff = odp_cpu_cycles_diff(c2, c1); + CU_ASSERT(diff > 0); + CU_ASSERT(diff < (max - diff)); + + /* check resolution for wrap */ + c1 = max - 2 * res; + do + c2 = odp_cpu_cycles(); + while (c1 < c2); + + diff = odp_cpu_cycles_diff(c1, c1); + CU_ASSERT(diff == 0); + + /* wrap */ + tmp = c2 + (max - c1) + res; + diff = odp_cpu_cycles_diff(c2, c1); + CU_ASSERT(diff == tmp); + + /* no wrap, revert args */ + tmp = c1 - c2; + diff = odp_cpu_cycles_diff(c1, c2); + CU_ASSERT(diff == tmp); +} + +static void cpu_cycles_max(void) +{ + uint64_t c2, c1; + uint64_t max1, max2; + + max1 = odp_cpu_cycles_max(); + odp_time_wait_ns(WAIT_TIME); + max2 = odp_cpu_cycles_max(); + + CU_ASSERT(max1 >= UINT32_MAX / 2); + CU_ASSERT(max1 == max2); + + c1 = odp_cpu_cycles(); + odp_time_wait_ns(WAIT_TIME); + c2 = odp_cpu_cycles(); + + CU_ASSERT(c1 <= max1 && c2 <= max1); +} + +static void cpu_cycles_resolution(void) +{ + int i; + uint64_t res; + uint64_t c2, c1, max; + uint64_t test_cycles = odp_cpu_hz() / 100; /* CPU cycles in 10 msec */ + + max = odp_cpu_cycles_max(); + + res = odp_cpu_cycles_resolution(); + CU_ASSERT(res != 0); + CU_ASSERT(res < max / 1024); + + for (i = 0; i < RES_TRY_NUM; i++) { + c1 = odp_cpu_cycles(); + odp_time_wait_ns(10 * ODP_TIME_MSEC_IN_NS + i); + c2 = odp_cpu_cycles(); + + /* Diff may be zero with low resolution */ + if (test_cycles && test_cycles > res) { + uint64_t diff = odp_cpu_cycles_diff(c2, c1); + + CU_ASSERT(diff >= res); + } + } +} + +static void cpu_cycles_long_period(void) +{ + int i; + int periods = PERIODS_100_MSEC; + uint64_t max_period_duration = 100 * ODP_TIME_MSEC_IN_NS + periods - 1; + uint64_t c2, c1, c3, max; + uint64_t tmp, diff, res; + + res = odp_cpu_cycles_resolution(); + max = odp_cpu_cycles_max(); + + c3 = odp_cpu_cycles(); + + CU_ASSERT(c3 <= max); + /* + * If the cycle counter is not close to wrapping around during + * the test, then speed up the test by not trying to see the wrap + * around too hard. Assume cycle counter frequency of less than 10 GHz. + */ + CU_ASSERT(odp_cpu_hz_max() < 10ULL * ODP_TIME_SEC_IN_NS); + if (max - c3 > 10 * periods * max_period_duration) + periods = 10; + + printf("\n Testing CPU cycles for %i seconds... ", periods / 10); + + for (i = 0; i < periods; i++) { + c1 = odp_cpu_cycles(); + odp_time_wait_ns(100 * ODP_TIME_MSEC_IN_NS + i); + c2 = odp_cpu_cycles(); + + CU_ASSERT(c2 != c1); + CU_ASSERT(c1 <= max && c2 <= max); + + if (c2 > c1) + tmp = c2 - c1; + else + tmp = c2 + (max - c1) + res; + + diff = odp_cpu_cycles_diff(c2, c1); + CU_ASSERT(diff == tmp); + + /* wrap is detected and verified */ + if (c2 < c1) + break; + } + + /* wrap was detected, no need to continue */ + if (i < periods) { + printf("wrap was detected.\n"); + return; + } + + /* wrap has to be detected if possible */ + CU_ASSERT(max > UINT32_MAX); + CU_ASSERT((max - c3) > UINT32_MAX); + + printf("wrap was not detected.\n"); +} + +static void cpu_pause(void) +{ + odp_cpu_pause(); +} + +static void cpu_prefetch(void) +{ + /* Cacheline aligned address */ + odp_prefetch(&global_data[0]); + + /* Not cacheline aligned address */ + odp_prefetch(&global_data[ODP_CACHE_LINE_SIZE + 11]); + + /* An invalid address */ + odp_prefetch(NULL); + + odp_prefetch_l1(&global_data[0]); + odp_prefetch_l1(&global_data[ODP_CACHE_LINE_SIZE + 11]); + odp_prefetch_l1(NULL); + + odp_prefetch_l2(&global_data[0]); + odp_prefetch_l2(&global_data[ODP_CACHE_LINE_SIZE + 11]); + odp_prefetch_l2(NULL); + + odp_prefetch_l3(&global_data[0]); + odp_prefetch_l3(&global_data[ODP_CACHE_LINE_SIZE + 11]); + odp_prefetch_l3(NULL); +} + +static void cpu_prefetch_store(void) +{ + odp_prefetch_store(&global_data[0]); + odp_prefetch_store(&global_data[ODP_CACHE_LINE_SIZE + 11]); + odp_prefetch_store(NULL); + + odp_prefetch_store_l1(&global_data[0]); + odp_prefetch_store_l1(&global_data[ODP_CACHE_LINE_SIZE + 11]); + odp_prefetch_store_l1(NULL); + + odp_prefetch_store_l2(&global_data[0]); + odp_prefetch_store_l2(&global_data[ODP_CACHE_LINE_SIZE + 11]); + odp_prefetch_store_l2(NULL); + + odp_prefetch_store_l3(&global_data[0]); + odp_prefetch_store_l3(&global_data[ODP_CACHE_LINE_SIZE + 11]); + odp_prefetch_store_l3(NULL); +} + +static void cpu_prefetch_strm(void) +{ + odp_prefetch_strm_l1(&global_data[0]); + odp_prefetch_strm_l1(&global_data[ODP_CACHE_LINE_SIZE + 11]); + odp_prefetch_strm_l1(NULL); + + odp_prefetch_store_strm_l1(&global_data[0]); + odp_prefetch_store_strm_l1(&global_data[ODP_CACHE_LINE_SIZE + 11]); + odp_prefetch_store_strm_l1(NULL); +} + +odp_testinfo_t cpu_suite[] = { + ODP_TEST_INFO(cpu_id), + ODP_TEST_INFO(cpu_count), + ODP_TEST_INFO(cpu_model_str), + ODP_TEST_INFO(cpu_model_str_id), + ODP_TEST_INFO_CONDITIONAL(cpu_hz, check_cpu_hz), + ODP_TEST_INFO_CONDITIONAL(cpu_hz_id, check_cpu_hz_id), + ODP_TEST_INFO_CONDITIONAL(cpu_hz_max, check_cpu_hz_max), + ODP_TEST_INFO_CONDITIONAL(cpu_hz_max_id, check_cpu_hz_max_id), + ODP_TEST_INFO_CONDITIONAL(cpu_cycles, check_cycle_counter), + ODP_TEST_INFO_CONDITIONAL(cpu_cycles_diff, check_cycle_counter), + ODP_TEST_INFO_CONDITIONAL(cpu_cycles_max, check_cycle_counter), + ODP_TEST_INFO_CONDITIONAL(cpu_cycles_resolution, check_cycle_counter), + ODP_TEST_INFO_CONDITIONAL(cpu_cycles_long_period, check_cycle_counter), + ODP_TEST_INFO(cpu_pause), + ODP_TEST_INFO(cpu_prefetch), + ODP_TEST_INFO(cpu_prefetch_store), + ODP_TEST_INFO(cpu_prefetch_strm), + ODP_TEST_INFO_NULL, +}; + +odp_suiteinfo_t cpu_suites[] = { + {"CPU", NULL, NULL, cpu_suite}, + ODP_SUITE_INFO_NULL, +}; + +int main(int argc, char *argv[]) +{ + int ret; + + /* parse common options: */ + if (odp_cunit_parse_options(&argc, argv)) + return -1; + + ret = odp_cunit_register(cpu_suites); + + if (ret == 0) + ret = odp_cunit_run(); + + return ret; +} diff --git a/test/validation/api/cpumask/cpumask.c b/test/validation/api/cpumask/cpumask.c index db500df3a..9ca182fc9 100644 --- a/test/validation/api/cpumask/cpumask.c +++ b/test/validation/api/cpumask/cpumask.c @@ -1,8 +1,6 @@ -/* Copyright (c) 2015-2018, Linaro Limited - * Copyright (c) 2021-2022, Nokia - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2015-2018 Linaro Limited + * Copyright (c) 2021-2022 Nokia */ #include <odp_api.h> diff --git a/test/validation/api/crypto/crypto_op_test.c b/test/validation/api/crypto/crypto_op_test.c index ae1465581..f2703c5cc 100644 --- a/test/validation/api/crypto/crypto_op_test.c +++ b/test/validation/api/crypto/crypto_op_test.c @@ -1,8 +1,6 @@ -/* Copyright (c) 2014-2018, Linaro Limited - * Copyright (c) 2021-2024, Nokia - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2014-2018 Linaro Limited + * Copyright (c) 2021-2024 Nokia */ #include <string.h> @@ -164,6 +162,10 @@ static void write_header_and_trailer(odp_packet_t pkt, { uint32_t trailer_offset = odp_packet_len(pkt) - trailer_len; uint32_t max_len = header_len > trailer_len ? header_len : trailer_len; + + if (!max_len) + return; + uint8_t buffer[max_len]; int rc; diff --git a/test/validation/api/crypto/crypto_op_test.h b/test/validation/api/crypto/crypto_op_test.h index 9805457ad..966e0a643 100644 --- a/test/validation/api/crypto/crypto_op_test.h +++ b/test/validation/api/crypto/crypto_op_test.h @@ -1,8 +1,5 @@ -/* - * Copyright (c) 2021-2023, Nokia - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2021-2023 Nokia */ #ifndef CRYPTO_OP_TEST_H diff --git a/test/validation/api/crypto/odp_crypto_test_inp.c b/test/validation/api/crypto/odp_crypto_test_inp.c index 532aaf525..7ce37a3cd 100644 --- a/test/validation/api/crypto/odp_crypto_test_inp.c +++ b/test/validation/api/crypto/odp_crypto_test_inp.c @@ -1,8 +1,6 @@ -/* Copyright (c) 2014-2018, Linaro Limited - * Copyright (c) 2021-2023, Nokia - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2014-2018 Linaro Limited + * Copyright (c) 2021-2024 Nokia */ #include <string.h> @@ -34,18 +32,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) @@ -190,8 +188,8 @@ static int session_create(crypto_session_t *session, int rc; odp_crypto_ses_create_err_t status; odp_crypto_session_param_t ses_params; - uint8_t cipher_key_data[ref->cipher_key_length]; - uint8_t auth_key_data[ref->auth_key_length]; + uint8_t cipher_key_data[MAX_KEY_LEN]; + uint8_t auth_key_data[MAX_KEY_LEN]; odp_crypto_key_t cipher_key = { .data = cipher_key_data, .length = ref->cipher_key_length @@ -776,6 +774,10 @@ static odp_cipher_alg_t cipher_algs[] = { ODP_CIPHER_ALG_SNOW3G_UEA2, ODP_CIPHER_ALG_AES_EEA2, ODP_CIPHER_ALG_ZUC_EEA3, + ODP_CIPHER_ALG_SNOW_V, + ODP_CIPHER_ALG_SM4_ECB, + ODP_CIPHER_ALG_SM4_CBC, + ODP_CIPHER_ALG_SM4_CTR, }; /* @@ -790,6 +792,10 @@ static odp_auth_alg_t auth_algs[] = { ODP_AUTH_ALG_SHA256_HMAC, ODP_AUTH_ALG_SHA384_HMAC, ODP_AUTH_ALG_SHA512_HMAC, + ODP_AUTH_ALG_SHA3_224_HMAC, + ODP_AUTH_ALG_SHA3_256_HMAC, + ODP_AUTH_ALG_SHA3_384_HMAC, + ODP_AUTH_ALG_SHA3_512_HMAC, ODP_AUTH_ALG_AES_GMAC, ODP_AUTH_ALG_AES_CMAC, ODP_AUTH_ALG_AES_XCBC_MAC, @@ -797,12 +803,20 @@ static odp_auth_alg_t auth_algs[] = { ODP_AUTH_ALG_SNOW3G_UIA2, ODP_AUTH_ALG_AES_EIA2, ODP_AUTH_ALG_ZUC_EIA3, + ODP_AUTH_ALG_SNOW_V_GMAC, + ODP_AUTH_ALG_SM3_HMAC, + ODP_AUTH_ALG_SM4_GMAC, ODP_AUTH_ALG_MD5, ODP_AUTH_ALG_SHA1, ODP_AUTH_ALG_SHA224, ODP_AUTH_ALG_SHA256, ODP_AUTH_ALG_SHA384, ODP_AUTH_ALG_SHA512, + ODP_AUTH_ALG_SHA3_224, + ODP_AUTH_ALG_SHA3_256, + ODP_AUTH_ALG_SHA3_384, + ODP_AUTH_ALG_SHA3_512, + ODP_AUTH_ALG_SM3, }; static void test_auth_hashes_in_auth_range(void) diff --git a/test/validation/api/crypto/test_vector_defs.h b/test/validation/api/crypto/test_vector_defs.h index 46ae4e4e1..6c2eb2085 100644 --- a/test/validation/api/crypto/test_vector_defs.h +++ b/test/validation/api/crypto/test_vector_defs.h @@ -1,8 +1,6 @@ -/* Copyright (c) 2014-2018, Linaro Limited - * Copyright (c) 2021-2023, Nokia - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2014-2018 Linaro Limited + * Copyright (c) 2021-2023 Nokia */ #ifndef TEST_VECTOR_DEFS_H diff --git a/test/validation/api/crypto/test_vectors.h b/test/validation/api/crypto/test_vectors.h index a38644246..33ba52d34 100644 --- a/test/validation/api/crypto/test_vectors.h +++ b/test/validation/api/crypto/test_vectors.h @@ -1,8 +1,6 @@ -/* Copyright (c) 2014-2018, Linaro Limited - * Copyright (c) 2021-2023, Nokia - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2014-2018 Linaro Limited + * Copyright (c) 2021-2023 Nokia */ #ifndef TEST_VECTORS_H diff --git a/test/validation/api/crypto/test_vectors_len.h b/test/validation/api/crypto/test_vectors_len.h index 3818b57a0..92b5c8453 100644 --- a/test/validation/api/crypto/test_vectors_len.h +++ b/test/validation/api/crypto/test_vectors_len.h @@ -1,8 +1,7 @@ -/* Copyright (c) 2014-2018, Linaro Limited - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2014-2018 Linaro Limited */ + #ifndef TEST_VECTORS_LEN_ #define TEST_VECTORS_LEN_ diff --git a/test/validation/api/crypto/util.c b/test/validation/api/crypto/util.c index 557e5e951..c40d61313 100644 --- a/test/validation/api/crypto/util.c +++ b/test/validation/api/crypto/util.c @@ -1,8 +1,6 @@ -/* Copyright (c) 2014-2018, Linaro Limited - * Copyright (c) 2021-2023, Nokia - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2014-2018 Linaro Limited + * Copyright (c) 2021-2024 Nokia */ #include <string.h> @@ -32,8 +30,14 @@ const char *auth_alg_name(odp_auth_alg_t auth) return "ODP_AUTH_ALG_SHA384_HMAC"; case ODP_AUTH_ALG_SHA512_HMAC: return "ODP_AUTH_ALG_SHA512_HMAC"; - case ODP_AUTH_ALG_AES_XCBC_MAC: - return "ODP_AUTH_ALG_AES_XCBC_MAC"; + case ODP_AUTH_ALG_SHA3_224_HMAC: + return "ODP_AUTH_ALG_SHA3_224_HMAC"; + case ODP_AUTH_ALG_SHA3_256_HMAC: + return "ODP_AUTH_ALG_SHA3_256_HMAC"; + case ODP_AUTH_ALG_SHA3_384_HMAC: + return "ODP_AUTH_ALG_SHA3_384_HMAC"; + case ODP_AUTH_ALG_SHA3_512_HMAC: + return "ODP_AUTH_ALG_SHA3_512_HMAC"; case ODP_AUTH_ALG_AES_GCM: return "ODP_AUTH_ALG_AES_GCM"; case ODP_AUTH_ALG_AES_GMAC: @@ -42,6 +46,8 @@ const char *auth_alg_name(odp_auth_alg_t auth) return "ODP_AUTH_ALG_AES_CCM"; case ODP_AUTH_ALG_AES_CMAC: return "ODP_AUTH_ALG_AES_CMAC"; + case ODP_AUTH_ALG_AES_XCBC_MAC: + return "ODP_AUTH_ALG_AES_XCBC_MAC"; case ODP_AUTH_ALG_CHACHA20_POLY1305: return "ODP_AUTH_ALG_CHACHA20_POLY1305"; case ODP_AUTH_ALG_KASUMI_F9: @@ -52,6 +58,18 @@ const char *auth_alg_name(odp_auth_alg_t auth) return "ODP_AUTH_ALG_AES_EIA2"; case ODP_AUTH_ALG_ZUC_EIA3: return "ODP_AUTH_ALG_ZUC_EIA3"; + case ODP_AUTH_ALG_SNOW_V_GCM: + return "ODP_AUTH_ALG_SNOW_V_GCM"; + case ODP_AUTH_ALG_SNOW_V_GMAC: + return "ODP_AUTH_ALG_SNOW_V_GMAC"; + case ODP_AUTH_ALG_SM3_HMAC: + return "ODP_AUTH_ALG_SM3_HMAC"; + case ODP_AUTH_ALG_SM4_GCM: + return "ODP_AUTH_ALG_SM4_GCM"; + case ODP_AUTH_ALG_SM4_GMAC: + return "ODP_AUTH_ALG_SM4_GMAC"; + case ODP_AUTH_ALG_SM4_CCM: + return "ODP_AUTH_ALG_SM4_CCM"; case ODP_AUTH_ALG_MD5: return "ODP_AUTH_ALG_MD5"; case ODP_AUTH_ALG_SHA1: @@ -64,6 +82,8 @@ const char *auth_alg_name(odp_auth_alg_t auth) return "ODP_AUTH_ALG_SHA384"; case ODP_AUTH_ALG_SHA512: return "ODP_AUTH_ALG_SHA512"; + case ODP_AUTH_ALG_SM3: + return "ODP_AUTH_ALG_SM3"; default: return "Unknown"; } @@ -104,6 +124,20 @@ const char *cipher_alg_name(odp_cipher_alg_t cipher) return "ODP_CIPHER_ALG_AES_EEA2"; case ODP_CIPHER_ALG_ZUC_EEA3: return "ODP_CIPHER_ALG_ZUC_EEA3"; + case ODP_CIPHER_ALG_SNOW_V: + return "ODP_CIPHER_ALG_SNOW_V"; + case ODP_CIPHER_ALG_SNOW_V_GCM: + return "ODP_CIPHER_ALG_SNOW_V_GCM"; + case ODP_CIPHER_ALG_SM4_ECB: + return "ODP_CIPHER_ALG_SM4_ECB"; + case ODP_CIPHER_ALG_SM4_CBC: + return "ODP_CIPHER_ALG_SM4_CBC"; + case ODP_CIPHER_ALG_SM4_CTR: + return "ODP_CIPHER_ALG_SM4_CTR"; + case ODP_CIPHER_ALG_SM4_GCM: + return "ODP_CIPHER_ALG_SM4_GCM"; + case ODP_CIPHER_ALG_SM4_CCM: + return "ODP_CIPHER_ALG_SM4_CCM"; default: return "Unknown"; } @@ -201,6 +235,34 @@ int check_alg_support(odp_cipher_alg_t cipher, odp_auth_alg_t auth) if (!capability.ciphers.bit.zuc_eea3) return ODP_TEST_INACTIVE; break; + case ODP_CIPHER_ALG_SNOW_V: + if (!capability.ciphers.bit.snow_v) + return ODP_TEST_INACTIVE; + break; + case ODP_CIPHER_ALG_SNOW_V_GCM: + if (!capability.ciphers.bit.snow_v_gcm) + return ODP_TEST_INACTIVE; + break; + case ODP_CIPHER_ALG_SM4_ECB: + if (!capability.ciphers.bit.sm4_ecb) + return ODP_TEST_INACTIVE; + break; + case ODP_CIPHER_ALG_SM4_CBC: + if (!capability.ciphers.bit.sm4_cbc) + return ODP_TEST_INACTIVE; + break; + case ODP_CIPHER_ALG_SM4_CTR: + if (!capability.ciphers.bit.sm4_ctr) + return ODP_TEST_INACTIVE; + break; + case ODP_CIPHER_ALG_SM4_GCM: + if (!capability.ciphers.bit.sm4_gcm) + return ODP_TEST_INACTIVE; + break; + case ODP_CIPHER_ALG_SM4_CCM: + if (!capability.ciphers.bit.sm4_ccm) + return ODP_TEST_INACTIVE; + break; default: ODPH_ERR("Unsupported cipher algorithm\n"); return ODP_TEST_INACTIVE; @@ -236,8 +298,20 @@ int check_alg_support(odp_cipher_alg_t cipher, odp_auth_alg_t auth) if (!capability.auths.bit.sha512_hmac) return ODP_TEST_INACTIVE; break; - case ODP_AUTH_ALG_AES_XCBC_MAC: - if (!capability.auths.bit.aes_xcbc_mac) + case ODP_AUTH_ALG_SHA3_224_HMAC: + if (!capability.auths.bit.sha3_224_hmac) + return ODP_TEST_INACTIVE; + break; + case ODP_AUTH_ALG_SHA3_256_HMAC: + if (!capability.auths.bit.sha3_256_hmac) + return ODP_TEST_INACTIVE; + break; + case ODP_AUTH_ALG_SHA3_384_HMAC: + if (!capability.auths.bit.sha3_384_hmac) + return ODP_TEST_INACTIVE; + break; + case ODP_AUTH_ALG_SHA3_512_HMAC: + if (!capability.auths.bit.sha3_512_hmac) return ODP_TEST_INACTIVE; break; case ODP_AUTH_ALG_AES_GCM: @@ -256,6 +330,10 @@ int check_alg_support(odp_cipher_alg_t cipher, odp_auth_alg_t auth) if (!capability.auths.bit.aes_cmac) return ODP_TEST_INACTIVE; break; + case ODP_AUTH_ALG_AES_XCBC_MAC: + if (!capability.auths.bit.aes_xcbc_mac) + return ODP_TEST_INACTIVE; + break; case ODP_AUTH_ALG_CHACHA20_POLY1305: if (!capability.auths.bit.chacha20_poly1305) return ODP_TEST_INACTIVE; @@ -276,6 +354,30 @@ int check_alg_support(odp_cipher_alg_t cipher, odp_auth_alg_t auth) if (!capability.auths.bit.zuc_eia3) return ODP_TEST_INACTIVE; break; + case ODP_AUTH_ALG_SNOW_V_GCM: + if (!capability.auths.bit.snow_v_gcm) + return ODP_TEST_INACTIVE; + break; + case ODP_AUTH_ALG_SNOW_V_GMAC: + if (!capability.auths.bit.snow_v_gmac) + return ODP_TEST_INACTIVE; + break; + case ODP_AUTH_ALG_SM3_HMAC: + if (!capability.auths.bit.sm3_hmac) + return ODP_TEST_INACTIVE; + break; + case ODP_AUTH_ALG_SM4_GCM: + if (!capability.auths.bit.sm4_gcm) + return ODP_TEST_INACTIVE; + break; + case ODP_AUTH_ALG_SM4_GMAC: + if (!capability.auths.bit.sm4_gmac) + return ODP_TEST_INACTIVE; + break; + case ODP_AUTH_ALG_SM4_CCM: + if (!capability.auths.bit.sm4_ccm) + return ODP_TEST_INACTIVE; + break; case ODP_AUTH_ALG_MD5: if (!capability.auths.bit.md5) return ODP_TEST_INACTIVE; @@ -300,6 +402,26 @@ int check_alg_support(odp_cipher_alg_t cipher, odp_auth_alg_t auth) if (!capability.auths.bit.sha512) return ODP_TEST_INACTIVE; break; + case ODP_AUTH_ALG_SHA3_224: + if (!capability.auths.bit.sha3_224) + return ODP_TEST_INACTIVE; + break; + case ODP_AUTH_ALG_SHA3_256: + if (!capability.auths.bit.sha3_256) + return ODP_TEST_INACTIVE; + break; + case ODP_AUTH_ALG_SHA3_384: + if (!capability.auths.bit.sha3_384) + return ODP_TEST_INACTIVE; + break; + case ODP_AUTH_ALG_SHA3_512: + if (!capability.auths.bit.sha3_512) + return ODP_TEST_INACTIVE; + break; + case ODP_AUTH_ALG_SM3: + if (!capability.auths.bit.sm3) + return ODP_TEST_INACTIVE; + break; default: ODPH_ERR("Unsupported authentication algorithm\n"); return ODP_TEST_INACTIVE; diff --git a/test/validation/api/crypto/util.h b/test/validation/api/crypto/util.h index 5cba21890..b6a013255 100644 --- a/test/validation/api/crypto/util.h +++ b/test/validation/api/crypto/util.h @@ -1,8 +1,6 @@ -/* Copyright (c) 2014-2018, Linaro Limited - * Copyright (c) 2021-2023, Nokia - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2014-2018 Linaro Limited + * Copyright (c) 2021-2023 Nokia */ #ifndef UTIL_H diff --git a/test/validation/api/dma/dma.c b/test/validation/api/dma/dma.c index efc7fa039..739a6c5c6 100644 --- a/test/validation/api/dma/dma.c +++ b/test/validation/api/dma/dma.c @@ -1,7 +1,5 @@ -/* Copyright (c) 2021-2023, Nokia - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2021-2023 Nokia */ #include <odp_api.h> @@ -325,6 +323,24 @@ static void test_dma_same_name_named(void) CU_ASSERT(odp_dma_destroy(dma_b) == 0); } +static void test_dma_long_name(void) +{ + odp_dma_param_t dma_param; + odp_dma_t dma; + char name[ODP_DMA_NAME_LEN]; + + memset(name, 'a', sizeof(name)); + name[sizeof(name) - 1] = 0; + + odp_dma_param_init(&dma_param); + dma_param.compl_mode_mask = ODP_DMA_COMPL_SYNC; + dma = odp_dma_create(name, &dma_param); + + CU_ASSERT_FATAL(dma != ODP_DMA_INVALID); + CU_ASSERT(odp_dma_to_u64(dma) == odp_dma_to_u64(odp_dma_lookup(name))); + CU_ASSERT(odp_dma_destroy(dma) == 0); +} + static void test_dma_compl_pool(void) { odp_pool_t pool; @@ -397,6 +413,24 @@ static void test_dma_compl_pool_same_name(void) CU_ASSERT_FATAL(odp_pool_destroy(pool_b) == 0); } +static void test_dma_compl_pool_long_name(void) +{ + odp_dma_pool_param_t dma_pool_param; + odp_pool_t pool; + char name[ODP_POOL_NAME_LEN]; + + memset(name, 'a', sizeof(name)); + name[sizeof(name) - 1] = 0; + + odp_dma_pool_param_init(&dma_pool_param); + dma_pool_param.num = 1; + pool = odp_dma_pool_create(name, &dma_pool_param); + + CU_ASSERT_FATAL(pool != ODP_POOL_INVALID); + CU_ASSERT(pool == odp_pool_lookup(name)); + CU_ASSERT_FATAL(odp_pool_destroy(pool) == 0); +} + static void test_dma_compl_pool_max_pools(void) { odp_dma_pool_param_t dma_pool_param; @@ -458,6 +492,7 @@ static void test_dma_compl_user_area(void) CU_ASSERT(prev != addr); ev = odp_dma_compl_to_event(compl_evs[i]); + odp_event_user_flag_set(ev, 1); CU_ASSERT(odp_event_user_area(ev) == addr); CU_ASSERT(odp_event_user_area_and_flag(ev, &flag) == addr); CU_ASSERT(flag < 0); @@ -1636,8 +1671,10 @@ odp_testinfo_t dma_suite[] = { ODP_TEST_INFO_CONDITIONAL(test_dma_debug, check_sync), ODP_TEST_INFO_CONDITIONAL(test_dma_same_name_null, check_session_count), ODP_TEST_INFO_CONDITIONAL(test_dma_same_name_named, check_session_count), + ODP_TEST_INFO_CONDITIONAL(test_dma_long_name, check_session_count), ODP_TEST_INFO_CONDITIONAL(test_dma_compl_pool, check_event), ODP_TEST_INFO_CONDITIONAL(test_dma_compl_pool_same_name, check_event), + ODP_TEST_INFO_CONDITIONAL(test_dma_compl_pool_long_name, check_event), ODP_TEST_INFO_CONDITIONAL(test_dma_compl_pool_max_pools, check_event), ODP_TEST_INFO_CONDITIONAL(test_dma_compl_user_area, check_event_user_area), ODP_TEST_INFO_CONDITIONAL(test_dma_compl_user_area_init, check_event_user_area_init), diff --git a/test/validation/api/errno/errno.c b/test/validation/api/errno/errno.c index 70708ce01..1cbd27b1b 100644 --- a/test/validation/api/errno/errno.c +++ b/test/validation/api/errno/errno.c @@ -1,7 +1,5 @@ -/* Copyright (c) 2015-2018, Linaro Limited - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2015-2018 Linaro Limited */ #include <odp_api.h> @@ -13,9 +11,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/event/event.c b/test/validation/api/event/event.c index fbcc08d6f..a4f967791 100644 --- a/test/validation/api/event/event.c +++ b/test/validation/api/event/event.c @@ -1,8 +1,6 @@ -/* Copyright (c) 2017-2018, Linaro Limited - * Copyright (c) 2023, Nokia - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2017-2018 Linaro Limited + * Copyright (c) 2023 Nokia */ #include <odp_api.h> diff --git a/test/validation/api/hash/hash.c b/test/validation/api/hash/hash.c index a935ef7ac..60c6755b2 100644 --- a/test/validation/api/hash/hash.c +++ b/test/validation/api/hash/hash.c @@ -1,8 +1,6 @@ -/* Copyright (c) 2015-2018, Linaro Limited - * Copyright (c) 2021, Nokia - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2015-2018 Linaro Limited + * Copyright (c) 2021 Nokia */ #include <odp_api.h> diff --git a/test/validation/api/ipsec/ipsec.c b/test/validation/api/ipsec/ipsec.c index 5ad7bd48d..0389175f0 100644 --- a/test/validation/api/ipsec/ipsec.c +++ b/test/validation/api/ipsec/ipsec.c @@ -1,9 +1,7 @@ -/* Copyright (c) 2017-2018, Linaro Limited - * Copyright (c) 2018-2022, Nokia - * Copyright (c) 2020-2021, Marvell - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2017-2018 Linaro Limited + * Copyright (c) 2018-2022 Nokia + * Copyright (c) 2020-2021 Marvell */ #include <odp_api.h> @@ -457,27 +455,28 @@ 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 */ + /* No user area/flag or source pool for IPsec status events */ + odp_event_user_flag_set(ev_status, 1); CU_ASSERT(odp_event_user_area(ev_status) == NULL); CU_ASSERT(odp_event_user_area_and_flag(ev_status, &flag) == NULL); CU_ASSERT(flag < 0); 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 +501,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 +563,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 +588,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 +627,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 +650,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 +679,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 +688,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 +709,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 +772,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 +781,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 +792,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 +865,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 +882,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 +949,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 +959,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 +986,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 +1027,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 +1037,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 +1065,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 +1076,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 +1103,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 +1146,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 +1199,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.h b/test/validation/api/ipsec/ipsec.h index 47612e3b3..3daa364cc 100644 --- a/test/validation/api/ipsec/ipsec.h +++ b/test/validation/api/ipsec/ipsec.h @@ -1,9 +1,7 @@ -/* Copyright (c) 2017-2018, Linaro Limited - * Copyright (c) 2020, Marvell - * Copyright (c) 2020, Nokia - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2017-2018 Linaro Limited + * Copyright (c) 2020 Marvell + * Copyright (c) 2020 Nokia */ #ifndef _ODP_TEST_IPSEC_H_ diff --git a/test/validation/api/ipsec/ipsec_test_in.c b/test/validation/api/ipsec/ipsec_test_in.c index b5251544e..a93bf9f2a 100644 --- a/test/validation/api/ipsec/ipsec_test_in.c +++ b/test/validation/api/ipsec/ipsec_test_in.c @@ -1,9 +1,7 @@ -/* Copyright (c) 2017-2018, Linaro Limited - * Copyright (c) 2020-2021, Marvell - * Copyright (c) 2021, Nokia - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2017-2018 Linaro Limited + * Copyright (c) 2020-2021 Marvell + * Copyright (c) 2021 Nokia */ #include <odp/helper/odph_api.h> @@ -62,7 +60,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 +95,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 +130,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 +162,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 +195,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 +227,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 +259,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 +291,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 +323,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 +355,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 +387,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 +419,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 +454,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 +492,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 +527,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 +560,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 +593,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 +629,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 +680,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 +732,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 +783,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 +842,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 +874,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 +901,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 +929,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 +957,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 +984,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 +1011,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 +1035,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 +1067,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 +1103,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 +1139,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 +1175,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 +1211,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 +1247,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 +1288,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 +1321,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 +1357,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 +1393,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 +1425,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 +1457,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 +1489,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 +1524,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 +1559,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 +1591,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 +1626,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 +1661,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 +1694,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 +1727,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 +1767,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 +1800,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 +1950,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 +2005,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 +2139,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 +2198,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 +2229,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..fea66b630 100644 --- a/test/validation/api/ipsec/ipsec_test_out.c +++ b/test/validation/api/ipsec/ipsec_test_out.c @@ -1,9 +1,7 @@ -/* Copyright (c) 2017-2018, Linaro Limited - * Copyright (c) 2020, Marvell - * Copyright (c) 2020-2022, Nokia - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2017-2018 Linaro Limited + * Copyright (c) 2020 Marvell + * Copyright (c) 2020-2022 Nokia */ #include <odp/helper/odph_api.h> @@ -145,7 +143,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 +182,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 +227,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 +257,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 +296,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 +342,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 +362,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 +378,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 +525,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 +564,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 +577,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 +625,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 +673,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 +813,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 +850,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 +890,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 +938,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 +979,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 +1019,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 +1058,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 +1103,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 +1133,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 +1172,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 +1218,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 +1250,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 +1297,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 +1307,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 +1385,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 +1427,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 +1476,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 +1490,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 +1558,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 +1686,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/ipsec/reass_test_vectors.c b/test/validation/api/ipsec/reass_test_vectors.c index c3bb2bfd4..45dd7af1b 100644 --- a/test/validation/api/ipsec/reass_test_vectors.c +++ b/test/validation/api/ipsec/reass_test_vectors.c @@ -1,7 +1,5 @@ -/* Copyright (c) 2021, Marvell - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2021 Marvell */ #include "ipsec.h" diff --git a/test/validation/api/ipsec/reass_test_vectors.h b/test/validation/api/ipsec/reass_test_vectors.h index 02b41c573..4c8d8e1f4 100644 --- a/test/validation/api/ipsec/reass_test_vectors.h +++ b/test/validation/api/ipsec/reass_test_vectors.h @@ -1,7 +1,5 @@ - /* Copyright (c) 2021, Marvell - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2021 Marvell */ #ifndef _ODP_REASS_TEST_VECTORS_H_ diff --git a/test/validation/api/ipsec/test_vectors.h b/test/validation/api/ipsec/test_vectors.h index b032ef973..b02912f68 100644 --- a/test/validation/api/ipsec/test_vectors.h +++ b/test/validation/api/ipsec/test_vectors.h @@ -1,8 +1,6 @@ -/* Copyright (c) 2017-2018, Linaro Limited - * Copyright (c) 2020, Nokia - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2017-2018 Linaro Limited + * Copyright (c) 2020 Nokia */ #ifndef _ODP_TEST_IPSEC_VECTORS_H_ diff --git a/test/validation/api/lock/lock.c b/test/validation/api/lock/lock.c index a4e6932c4..e8eb4360b 100644 --- a/test/validation/api/lock/lock.c +++ b/test/validation/api/lock/lock.c @@ -1,7 +1,5 @@ -/* Copyright (c) 2014-2018, Linaro Limited - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2014-2018 Linaro Limited */ #include <malloc.h> @@ -117,7 +115,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/ml/ml.c b/test/validation/api/ml/ml.c index 5f8be1b64..1f3383428 100644 --- a/test/validation/api/ml/ml.c +++ b/test/validation/api/ml/ml.c @@ -317,6 +317,7 @@ static void test_ml_compl_user_area(void) memset(addr, 0, size); ev = odp_ml_compl_to_event(compl_evs[i]); + odp_event_user_flag_set(ev, 1); CU_ASSERT(odp_event_user_area(ev) == addr); CU_ASSERT(odp_event_user_area_and_flag(ev, &flag) == addr); CU_ASSERT(flag < 0); diff --git a/test/validation/api/packet/packet.c b/test/validation/api/packet/packet.c index ca9c73f17..7e7208755 100644 --- a/test/validation/api/packet/packet.c +++ b/test/validation/api/packet/packet.c @@ -1,13 +1,9 @@ -/* Copyright (c) 2014-2018, Linaro Limited - * Copyright (c) 2019-2023, Nokia - * Copyright (c) 2020, Marvell - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2014-2018 Linaro Limited + * Copyright (c) 2019-2024 Nokia + * Copyright (c) 2020 Marvell */ -#include <stdlib.h> - #include <odp_api.h> #include <odp_cunit_common.h> #include <test_packet_ipv4.h> @@ -16,6 +12,9 @@ #include <odp/helper/odph_api.h> +#include <stdint.h> +#include <stdlib.h> + /* Reserve some tailroom for tests */ #define TAILROOM_RESERVE 4 /* Number of packets in the test packet pool */ @@ -118,8 +117,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 +848,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. */ @@ -908,14 +907,24 @@ static void packet_test_length(void) static void packet_test_reset(void) { - uint32_t len, headroom; + uint32_t len, max_len, headroom; + uint32_t uarea_size = default_param.pkt.uarea_size; uintptr_t ptr_len; void *data, *new_data, *tail, *new_tail; + struct udata_struct *udat; odp_packet_t pkt; pkt = odp_packet_alloc(default_pool, packet_len); CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID); + if (uarea_size) { + udat = odp_packet_user_area(pkt); + + CU_ASSERT_FATAL(udat != NULL); + CU_ASSERT_FATAL(odp_packet_user_area_size(pkt) >= uarea_size); + memcpy(udat, &test_packet_udata, uarea_size); + } + len = odp_packet_len(pkt); CU_ASSERT(len == packet_len); @@ -946,8 +955,10 @@ static void packet_test_reset(void) ptr_len = (uintptr_t)odp_packet_data(pkt) - (uintptr_t)odp_packet_head(pkt); CU_ASSERT(ptr_len == (headroom + 1)); - CU_ASSERT(odp_packet_reset(pkt, len) == 0); - CU_ASSERT(odp_packet_len(pkt) == len); + max_len = odp_packet_reset_max_len(pkt); + CU_ASSERT(max_len >= len); + CU_ASSERT(odp_packet_reset(pkt, max_len) == 0); + CU_ASSERT(odp_packet_len(pkt) == max_len); CU_ASSERT(odp_packet_headroom(pkt) == headroom); ptr_len = (uintptr_t)odp_packet_data(pkt) - (uintptr_t)odp_packet_head(pkt); @@ -956,7 +967,7 @@ static void packet_test_reset(void) tail = odp_packet_tail(pkt); new_tail = odp_packet_pull_tail(pkt, 1); - CU_ASSERT(odp_packet_len(pkt) == len - 1); + CU_ASSERT(odp_packet_len(pkt) == max_len - 1); CU_ASSERT((uintptr_t)new_tail == ((uintptr_t)tail - 1)); CU_ASSERT(odp_packet_reset(pkt, len) == 0); CU_ASSERT(odp_packet_len(pkt) == len); @@ -973,6 +984,86 @@ static void packet_test_reset(void) CU_ASSERT(odp_packet_reset(pkt, len) == 0); CU_ASSERT(odp_packet_len(pkt) == len); + if (odp_packet_reset_max_len(pkt) < UINT32_MAX) { + CU_ASSERT(odp_packet_reset(pkt, odp_packet_reset_max_len(pkt) + 1) < 0); + CU_ASSERT(odp_packet_len(pkt) == len); + } + + if (uarea_size) { + udat = odp_packet_user_area(pkt); + + CU_ASSERT_FATAL(udat != NULL); + CU_ASSERT_FATAL(odp_packet_user_area_size(pkt) >= uarea_size); + CU_ASSERT(memcmp(udat, &test_packet_udata, uarea_size) == 0); + } + + odp_packet_free(pkt); +} + +static void packet_test_reset_meta(void) +{ + uint32_t data_len, seg_len, headroom, tailroom; + uint32_t uarea_size = default_param.pkt.uarea_size; + void *data, *head, *tail; + struct udata_struct *udat; + odp_packet_t pkt; + int num_segs; + + pkt = odp_packet_alloc(default_pool, segmented_packet_len); + CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID); + + if (uarea_size) { + udat = odp_packet_user_area(pkt); + + CU_ASSERT_FATAL(udat != NULL); + CU_ASSERT_FATAL(odp_packet_user_area_size(pkt) >= uarea_size); + memcpy(udat, &test_packet_udata, uarea_size); + } + + data_len = odp_packet_len(pkt); + CU_ASSERT(data_len == segmented_packet_len); + + odp_packet_pull_head(pkt, 1); + head = odp_packet_head(pkt); + CU_ASSERT(head != NULL); + + odp_packet_pull_tail(pkt, 1); + tail = odp_packet_tail(pkt); + CU_ASSERT(tail != NULL); + + headroom = odp_packet_headroom(pkt); + tailroom = odp_packet_tailroom(pkt); + + data = odp_packet_data(pkt); + data_len = odp_packet_len(pkt); + + seg_len = odp_packet_seg_len(pkt); + num_segs = odp_packet_num_segs(pkt); + + odp_packet_reset_meta(pkt); + + CU_ASSERT(odp_packet_data(pkt) == data); + CU_ASSERT(odp_packet_len(pkt) == data_len); + CU_ASSERT(odp_packet_seg_len(pkt) == seg_len); + CU_ASSERT(odp_packet_num_segs(pkt) == num_segs); + CU_ASSERT(odp_packet_headroom(pkt) == headroom); + CU_ASSERT(odp_packet_tailroom(pkt) == tailroom); + CU_ASSERT(odp_packet_head(pkt) == head); + CU_ASSERT(odp_packet_tail(pkt) == tail); + + packet_set_inflags_common(pkt, 1); + packet_check_inflags_common(pkt, 1); + odp_packet_reset_meta(pkt); + packet_check_inflags_all(pkt, 0); + + if (uarea_size) { + udat = odp_packet_user_area(pkt); + + CU_ASSERT_FATAL(udat != NULL); + CU_ASSERT_FATAL(odp_packet_user_area_size(pkt) >= uarea_size); + CU_ASSERT(memcmp(udat, &test_packet_udata, uarea_size) == 0); + } + odp_packet_free(pkt); } @@ -1066,7 +1157,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 +1171,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 +1215,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 +1313,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 +1414,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 +1726,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 +1946,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; @@ -2614,7 +2705,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)); @@ -2624,7 +2715,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); @@ -2632,19 +2723,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) @@ -3285,6 +3376,10 @@ static void packet_vector_test_user_area(void) CU_ASSERT(odp_event_user_area(ev) == addr); CU_ASSERT(odp_event_user_area_and_flag(ev, &flag) == addr); CU_ASSERT(flag == 0); + odp_event_user_flag_set(ev, 1); + CU_ASSERT(odp_event_user_area_and_flag(ev, &flag) == addr); + CU_ASSERT(flag > 0); + CU_ASSERT(odp_packet_vector_user_flag(pktv[i]) > 0); prev = addr; memset(addr, 0, size); @@ -3478,6 +3573,10 @@ static void packet_test_user_area(void) CU_ASSERT(odp_event_user_area(ev) == odp_packet_user_area(pkt)); CU_ASSERT(odp_event_user_area_and_flag(ev, &flag) == odp_packet_user_area(pkt)); CU_ASSERT(flag == 0); + odp_event_user_flag_set(ev, 1); + CU_ASSERT(odp_event_user_area_and_flag(ev, &flag) == odp_packet_user_area(pkt)); + CU_ASSERT(flag > 0); + CU_ASSERT(odp_packet_user_flag(pkt) > 0); odp_packet_free(pkt); CU_ASSERT(odp_pool_destroy(pool) == 0); @@ -3629,12 +3728,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); @@ -3673,12 +3769,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); @@ -3712,10 +3805,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); @@ -3746,12 +3837,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); @@ -3874,12 +3962,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); @@ -4130,12 +4215,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); @@ -4493,6 +4575,7 @@ odp_testinfo_t packet_suite[] = { ODP_TEST_INFO(packet_test_segments), ODP_TEST_INFO(packet_test_length), ODP_TEST_INFO(packet_test_reset), + ODP_TEST_INFO(packet_test_reset_meta), ODP_TEST_INFO(packet_test_prefetch), ODP_TEST_INFO(packet_test_headroom), ODP_TEST_INFO(packet_test_tailroom), diff --git a/test/validation/api/pktio/lso.c b/test/validation/api/pktio/lso.c index 832c08859..40d0917b4 100644 --- a/test/validation/api/pktio/lso.c +++ b/test/validation/api/pktio/lso.c @@ -1,7 +1,5 @@ -/* Copyright (c) 2020-2022, Nokia - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2020-2022 Nokia */ #include <odp_api.h> @@ -657,7 +655,7 @@ static void test_lso_request_clear(odp_lso_profile_t lso_profile, const uint8_t static void lso_send_custom_eth(const uint8_t *test_packet, uint32_t pkt_len, uint32_t max_payload, int use_opt) { - int i, ret, num; + int i, ret, num, num_rcv; odp_lso_profile_param_t param; odp_lso_profile_t profile; uint32_t offset, len, payload_len, payload_sum; @@ -698,6 +696,7 @@ static void lso_send_custom_eth(const uint8_t *test_packet, uint32_t pkt_len, ui offset = hdr_len; payload_sum = 0; segnum = 0xffff; + num_rcv = 0; for (i = 0; i < num; i++) { odph_ethhdr_t *eth = (odph_ethhdr_t *)odp_packet_l2_ptr(pkt_out[i], NULL); @@ -712,7 +711,7 @@ static void lso_send_custom_eth(const uint8_t *test_packet, uint32_t pkt_len, ui if (ret == 0) { segnum = odp_be_to_cpu_16(segnum); - CU_ASSERT(segnum == i); + CU_ASSERT(segnum == num_rcv); } else { CU_FAIL("Seg num field read failed\n"); } @@ -729,6 +728,7 @@ static void lso_send_custom_eth(const uint8_t *test_packet, uint32_t pkt_len, ui offset += payload_len; payload_sum += payload_len; + num_rcv++; } ODPH_DBG(" Received payload length: %u bytes\n", payload_sum); diff --git a/test/validation/api/pktio/lso.h b/test/validation/api/pktio/lso.h index ce3dc7b64..d5688369f 100644 --- a/test/validation/api/pktio/lso.h +++ b/test/validation/api/pktio/lso.h @@ -1,7 +1,5 @@ -/* Copyright (c) 2020, Nokia - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2020 Nokia */ #ifndef _ODP_TEST_PKTIO_LSO_H_ diff --git a/test/validation/api/pktio/parser.c b/test/validation/api/pktio/parser.c index 7d243877c..a21a9c0f8 100644 --- a/test/validation/api/pktio/parser.c +++ b/test/validation/api/pktio/parser.c @@ -1,7 +1,5 @@ -/* Copyright (c) 2017-2018, Linaro Limited - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2017-2018 Linaro Limited */ #include <odp_api.h> diff --git a/test/validation/api/pktio/parser.h b/test/validation/api/pktio/parser.h index 4424737fd..8341d9a2c 100644 --- a/test/validation/api/pktio/parser.h +++ b/test/validation/api/pktio/parser.h @@ -1,7 +1,5 @@ -/* Copyright (c) 2017-2018, Linaro Limited - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2017-2018 Linaro Limited */ #ifndef _ODP_TEST_PARSER_H_ diff --git a/test/validation/api/pktio/pktio.c b/test/validation/api/pktio/pktio.c index deef4895a..12e0a2cd9 100644 --- a/test/validation/api/pktio/pktio.c +++ b/test/validation/api/pktio/pktio.c @@ -1,9 +1,7 @@ -/* Copyright (c) 2014-2018, Linaro Limited - * Copyright (c) 2020-2024, Nokia - * Copyright (c) 2020, Marvell - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2014-2018 Linaro Limited + * Copyright (c) 2020-2024 Nokia + * Copyright (c) 2020 Marvell */ #include <odp_api.h> @@ -1598,48 +1596,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) @@ -3661,7 +3659,8 @@ static void pktio_test_pktout_compl_event(bool use_plain_queue) CU_ASSERT(odp_packet_tx_compl_user_ptr(tx_compl) == (const void *)&pkt_seq[i]); - /* No user area or source pool for TX completion events */ + /* No user area/flag or source pool for TX completion events */ + odp_event_user_flag_set(ev, 1); CU_ASSERT(odp_event_user_area(ev) == NULL); CU_ASSERT(odp_event_user_area_and_flag(ev, &flag) == NULL); CU_ASSERT(flag < 0); @@ -3703,7 +3702,8 @@ static void pktio_test_pktout_compl_event(bool use_plain_queue) } } - /* No user area or source pool for TX completion events */ + /* No user area/flag or source pool for TX completion events */ + odp_event_user_flag_set(ev, 1); CU_ASSERT(odp_event_user_area(ev) == NULL); CU_ASSERT(odp_event_user_area_and_flag(ev, &flag) == NULL); CU_ASSERT(flag < 0); @@ -5095,7 +5095,7 @@ static void pktio_test_pktin_event_queue(odp_pktin_mode_t pktin_mode) odp_pktin_queue_param_t in_queue_param; odp_pktout_queue_param_t out_queue_param; odp_pktout_queue_t pktout_queue; - odp_queue_t queue, from; + odp_queue_t queue, from = ODP_QUEUE_INVALID; odp_pool_t buf_pool; odp_pool_param_t pool_param; odp_packet_t pkt_tbl[TX_BATCH_LEN]; @@ -5189,8 +5189,6 @@ static void pktio_test_pktin_event_queue(odp_pktin_mode_t pktin_mode) if (ev == ODP_EVENT_INVALID) break; - - CU_ASSERT(from == queue); } else { ev = odp_queue_deq(queue); @@ -5214,9 +5212,12 @@ static void pktio_test_pktin_event_queue(odp_pktin_mode_t pktin_mode) if (odp_event_type(ev) == ODP_EVENT_PACKET) { pkt = odp_packet_from_event(ev); - if (pktio_pkt_seq(pkt) != TEST_SEQ_INVALID) + if (pktio_pkt_seq(pkt) != TEST_SEQ_INVALID) { num_pkt++; + if (pktin_mode == ODP_PKTIN_MODE_SCHED) + CU_ASSERT(from == queue); + } } else if (odp_event_type(ev) == ODP_EVENT_BUFFER) { num_buf++; } else { diff --git a/test/validation/api/pool/pool.c b/test/validation/api/pool/pool.c index 86a47230a..95d9ef14e 100644 --- a/test/validation/api/pool/pool.c +++ b/test/validation/api/pool/pool.c @@ -1,9 +1,7 @@ -/* Copyright (c) 2014-2018, Linaro Limited - * Copyright (c) 2020, Marvell - * Copyright (c) 2020-2023, Nokia - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2014-2018 Linaro Limited + * Copyright (c) 2020 Marvell + * Copyright (c) 2020-2023 Nokia */ #include <odp_api.h> @@ -402,6 +400,35 @@ static void pool_test_lookup_info_print(void) CU_ASSERT(odp_pool_destroy(pool) == 0); } +static void pool_test_long_name(void) +{ + odp_pool_t pool; + odp_pool_info_t info; + odp_pool_param_t param; + char name[ODP_POOL_NAME_LEN]; + + memset(name, 'a', sizeof(name)); + name[sizeof(name) - 1] = 0; + + memset(&info, 0, sizeof(info)); + odp_pool_param_init(¶m); + + param.type = ODP_POOL_BUFFER; + param.buf.size = BUF_SIZE; + param.buf.num = BUF_NUM; + param.buf.uarea_size = 64; + + pool = odp_pool_create(name, ¶m); + CU_ASSERT_FATAL(pool != ODP_POOL_INVALID); + + pool = odp_pool_lookup(name); + CU_ASSERT_FATAL(pool != ODP_POOL_INVALID); + + CU_ASSERT_FATAL(odp_pool_info(pool, &info) == 0); + CU_ASSERT(strncmp(name, info.name, sizeof(name)) == 0); + CU_ASSERT(odp_pool_destroy(pool) == 0); +} + static void pool_test_same_name(const odp_pool_param_t *param) { odp_pool_t pool, pool_a, pool_b; @@ -1136,7 +1163,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) @@ -1832,6 +1859,31 @@ static void test_packet_pool_ext_info(void) CU_ASSERT(odp_pool_destroy(pool) == 0); } +static void test_packet_pool_ext_long_name(void) +{ + odp_pool_t pool; + odp_pool_ext_param_t param; + odp_pool_info_t info; + char name[ODP_POOL_NAME_LEN]; + + memset(name, 'a', sizeof(name)); + name[sizeof(name) - 1] = 0; + + pool_ext_init_packet_pool_param(¶m); + pool = odp_pool_ext_create(name, ¶m); + + CU_ASSERT_FATAL(pool != ODP_POOL_INVALID); + CU_ASSERT_FATAL(pool == odp_pool_lookup(name)); + + memset(&info, 0, sizeof(odp_pool_info_t)); + CU_ASSERT_FATAL(odp_pool_info(pool, &info) == 0); + + CU_ASSERT(info.pool_ext); + CU_ASSERT(strncmp(name, info.name, strlen(name)) == 0); + + CU_ASSERT(odp_pool_destroy(pool) == 0); +} + static odp_shm_t populate_pool(odp_pool_t pool, odp_pool_ext_capability_t *capa, void *buf[], uint32_t num, uint32_t buf_size) { @@ -2303,6 +2355,7 @@ odp_testinfo_t pool_suite[] = { ODP_TEST_INFO_CONDITIONAL(pool_test_vector_uarea_init, pool_check_vector_uarea_init), ODP_TEST_INFO_CONDITIONAL(pool_test_timeout_uarea_init, pool_check_timeout_uarea_init), ODP_TEST_INFO(pool_test_lookup_info_print), + ODP_TEST_INFO(pool_test_long_name), ODP_TEST_INFO(pool_test_same_name_buf), ODP_TEST_INFO(pool_test_same_name_pkt), ODP_TEST_INFO(pool_test_same_name_tmo), @@ -2347,6 +2400,7 @@ odp_testinfo_t pool_ext_suite[] = { ODP_TEST_INFO_CONDITIONAL(test_packet_pool_ext_create, check_pool_ext_support), ODP_TEST_INFO_CONDITIONAL(test_packet_pool_ext_lookup, check_pool_ext_support), ODP_TEST_INFO_CONDITIONAL(test_packet_pool_ext_info, check_pool_ext_support), + ODP_TEST_INFO_CONDITIONAL(test_packet_pool_ext_long_name, check_pool_ext_support), ODP_TEST_INFO_CONDITIONAL(test_packet_pool_ext_populate, check_pool_ext_support), ODP_TEST_INFO_CONDITIONAL(test_packet_pool_ext_alloc, check_pool_ext_support), ODP_TEST_INFO_CONDITIONAL(test_packet_pool_ext_uarea_init, diff --git a/test/validation/api/queue/queue.c b/test/validation/api/queue/queue.c index 4b5ccde65..992f4e4d3 100644 --- a/test/validation/api/queue/queue.c +++ b/test/validation/api/queue/queue.c @@ -1,8 +1,6 @@ -/* Copyright (c) 2014-2018, Linaro Limited - * Copyright (c) 2021-2023, Nokia - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2014-2018 Linaro Limited + * Copyright (c) 2021-2023 Nokia */ #include <odp_api.h> @@ -843,6 +841,37 @@ static void queue_test_same_name_sched(void) queue_test_same_name(1); } +static void queue_test_long_name(int sched) +{ + odp_queue_t queue; + odp_queue_param_t param; + char name[ODP_QUEUE_NAME_LEN]; + + memset(name, 'a', sizeof(name)); + name[sizeof(name) - 1] = 0; + + odp_queue_param_init(¶m); + + if (sched) + param.type = ODP_QUEUE_TYPE_SCHED; + + queue = odp_queue_create(name, ¶m); + CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID); + CU_ASSERT(queue == odp_queue_lookup(name)); + + CU_ASSERT_FATAL(odp_queue_destroy(queue) == 0); +} + +static void queue_test_long_name_plain(void) +{ + queue_test_long_name(0); +} + +static void queue_test_long_name_sched(void) +{ + queue_test_long_name(1); +} + static void queue_test_info(void) { odp_queue_t q_plain, q_order; @@ -1148,6 +1177,8 @@ odp_testinfo_t queue_suite[] = { ODP_TEST_INFO(queue_test_param), ODP_TEST_INFO(queue_test_same_name_plain), ODP_TEST_INFO(queue_test_same_name_sched), + ODP_TEST_INFO(queue_test_long_name_plain), + ODP_TEST_INFO(queue_test_long_name_sched), ODP_TEST_INFO(queue_test_info), ODP_TEST_INFO(queue_test_mt_plain_block), ODP_TEST_INFO(queue_test_mt_plain_nonblock_lf), diff --git a/test/validation/api/random/random.c b/test/validation/api/random/random.c index 551fe775d..6c32cb0f7 100644 --- a/test/validation/api/random/random.c +++ b/test/validation/api/random/random.c @@ -1,8 +1,6 @@ -/* Copyright (c) 2015-2018, Linaro Limited - * Copyright (c) 2021-2022, Nokia - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2015-2018 Linaro Limited + * Copyright (c) 2021-2022 Nokia */ #include <odp_api.h> diff --git a/test/validation/api/scheduler/scheduler.c b/test/validation/api/scheduler/scheduler.c index 8dddd8d8f..9ecb88a5d 100644 --- a/test/validation/api/scheduler/scheduler.c +++ b/test/validation/api/scheduler/scheduler.c @@ -1,8 +1,6 @@ -/* Copyright (c) 2014-2018, Linaro Limited - * Copyright (c) 2019-2024, Nokia - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2014-2018 Linaro Limited + * Copyright (c) 2019-2024 Nokia */ #include <odp_api.h> @@ -987,6 +985,26 @@ static void scheduler_test_create_group(void) CU_ASSERT_FATAL(odp_schedule(NULL, wait_time) == ODP_EVENT_INVALID); } +static void scheduler_test_group_long_name(void) +{ + odp_thrmask_t mask; + odp_schedule_group_t group; + int thr_id; + char name[ODP_SCHED_GROUP_NAME_LEN]; + + memset(name, 'a', sizeof(name)); + name[sizeof(name) - 1] = 0; + + thr_id = odp_thread_id(); + odp_thrmask_zero(&mask); + odp_thrmask_set(&mask, thr_id); + + group = odp_schedule_group_create(name, &mask); + CU_ASSERT_FATAL(group != ODP_SCHED_GROUP_INVALID); + CU_ASSERT(group == odp_schedule_group_lookup(name)); + CU_ASSERT_FATAL(odp_schedule_group_destroy(group) == 0); +} + static void scheduler_test_create_max_groups(void) { odp_thrmask_t mask; @@ -1367,12 +1385,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 +1816,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 +1847,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 +2601,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 */ @@ -3183,7 +3201,7 @@ static int create_queues(test_globals_t *globals) for (j = 0; j < queues_per_prio; j++) { /* Per sched sync type */ - char name[32]; + char name[ODP_QUEUE_NAME_LEN]; odp_queue_t q, pq; snprintf(name, sizeof(name), "sched_%d_%d_n", i, j); @@ -3674,6 +3692,7 @@ odp_testinfo_t scheduler_basic_suite[] = { ODP_TEST_INFO(scheduler_test_order_ignore), ODP_TEST_INFO(scheduler_test_group_info_predef), ODP_TEST_INFO(scheduler_test_create_group), + ODP_TEST_INFO(scheduler_test_group_long_name), ODP_TEST_INFO(scheduler_test_create_max_groups), ODP_TEST_INFO(scheduler_test_groups), ODP_TEST_INFO(scheduler_test_pause_resume), diff --git a/test/validation/api/scheduler/scheduler_no_predef_groups.c b/test/validation/api/scheduler/scheduler_no_predef_groups.c index ad6f6d3a2..d2ea48eb6 100644 --- a/test/validation/api/scheduler/scheduler_no_predef_groups.c +++ b/test/validation/api/scheduler/scheduler_no_predef_groups.c @@ -1,8 +1,6 @@ -/* Copyright (c) 2013-2018, Linaro Limited - * Copyright (c) 2019-2021, Nokia - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2013-2018 Linaro Limited + * Copyright (c) 2019-2021 Nokia */ #include <odp_api.h> diff --git a/test/validation/api/shmem/shmem.c b/test/validation/api/shmem/shmem.c index 9e91dab35..51a6b316e 100644 --- a/test/validation/api/shmem/shmem.c +++ b/test/validation/api/shmem/shmem.c @@ -1,8 +1,6 @@ -/* Copyright (c) 2014-2018, Linaro Limited - * Copyright (c) 2019-2021, Nokia - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2014-2018 Linaro Limited + * Copyright (c) 2019-2021 Nokia */ #include <odp_api.h> @@ -261,6 +259,20 @@ static void shmem_test_reserve(void) CU_ASSERT(odp_shm_free(shm) == 0); } +static void shmem_test_reserve_long_name(void) +{ + odp_shm_t shm; + char name[ODP_SHM_NAME_LEN]; + + memset(name, 'a', sizeof(name)); + name[sizeof(name) - 1] = 0; + + shm = odp_shm_reserve(name, MEDIUM_MEM, ALIGN_SIZE, 0); + CU_ASSERT_FATAL(shm != ODP_SHM_INVALID); + CU_ASSERT_FATAL(shm == odp_shm_lookup(name)); + CU_ASSERT(odp_shm_free(shm) == 0); +} + static void shmem_test_info(void) { odp_shm_t shm; @@ -610,7 +622,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 +632,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 +642,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 +675,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 +702,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 +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_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 +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_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 +810,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 +867,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 +897,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 +962,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 +1012,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 +1047,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 +1103,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) @@ -1139,6 +1151,7 @@ static int shm_suite_init(void) odp_testinfo_t shmem_suite[] = { ODP_TEST_INFO(shmem_test_capability), ODP_TEST_INFO(shmem_test_reserve), + ODP_TEST_INFO(shmem_test_reserve_long_name), ODP_TEST_INFO(shmem_test_info), ODP_TEST_INFO_CONDITIONAL(shmem_test_flag_hp, shmem_check_flag_hp), ODP_TEST_INFO_CONDITIONAL(shmem_test_flag_no_hp, shmem_check_flag_no_hp), diff --git a/test/validation/api/stash/stash.c b/test/validation/api/stash/stash.c index 162697ba9..80b09fd93 100644 --- a/test/validation/api/stash/stash.c +++ b/test/validation/api/stash/stash.c @@ -1,7 +1,5 @@ -/* Copyright (c) 2020-2023, Nokia - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2020-2023 Nokia */ #include <odp_api.h> @@ -237,6 +235,30 @@ static void stash_create_u32(void) CU_ASSERT_FATAL(odp_stash_destroy(stash) == 0); } +static void stash_create_u32_long_name(void) +{ + odp_stash_t stash; + odp_stash_param_t param; + uint32_t num = global.num_default.u32; + char name[ODP_STASH_NAME_LEN]; + + memset(name, 'a', sizeof(name)); + name[sizeof(name) - 1] = 0; + + odp_stash_param_init(¶m); + param.num_obj = num; + param.obj_size = sizeof(uint32_t); + + stash = odp_stash_create(name, ¶m); + + CU_ASSERT_FATAL(stash != ODP_STASH_INVALID); + + printf("\n Stash handle: 0x%" PRIx64 "\n", odp_stash_to_u64(stash)); + + CU_ASSERT(stash == odp_stash_lookup(name)); + CU_ASSERT_FATAL(odp_stash_destroy(stash) == 0); +} + static void stash_create_u64_all(void) { odp_stash_param_t param; @@ -1309,6 +1331,7 @@ odp_testinfo_t stash_suite[] = { ODP_TEST_INFO(stash_param_defaults), ODP_TEST_INFO_CONDITIONAL(stash_create_u64, check_support_64), ODP_TEST_INFO(stash_create_u32), + ODP_TEST_INFO(stash_create_u32_long_name), ODP_TEST_INFO_CONDITIONAL(stash_default_put_u64_1, check_support_64), ODP_TEST_INFO_CONDITIONAL(stash_default_put_u64_n, check_support_64), ODP_TEST_INFO_CONDITIONAL(stash_default_u64_put_u64_1, check_support_64), diff --git a/test/validation/api/std/std.c b/test/validation/api/std/std.c index 161ee87cf..85a8ec0a5 100644 --- a/test/validation/api/std/std.c +++ b/test/validation/api/std/std.c @@ -1,7 +1,5 @@ -/* Copyright (c) 2015-2018, Linaro Limited - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2015-2018 Linaro Limited */ #include <odp_api.h> diff --git a/test/validation/api/system/system.c b/test/validation/api/system/system.c index 3f7e0497d..63a0a7e2a 100644 --- a/test/validation/api/system/system.c +++ b/test/validation/api/system/system.c @@ -1,7 +1,5 @@ -/* Copyright (c) 2015-2018, Linaro Limited - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2015-2018 Linaro Limited */ #include <ctype.h> @@ -27,8 +25,8 @@ static void test_version_api_str(void) char version_string[128]; char *s = version_string; - strncpy(version_string, odp_version_api_str(), - sizeof(version_string) - 1); + odph_strcpy(version_string, odp_version_api_str(), + sizeof(version_string)); while (*s) { if (isdigit((int)*s) || (strncmp(s, ".", 1) == 0)) { @@ -77,186 +75,6 @@ static void test_version_macro(void) ODP_VERSION_API); } -static void system_test_odp_cpu_count(void) -{ - int cpus; - - cpus = odp_cpu_count(); - CU_ASSERT(0 < cpus); -} - -static void system_test_cpu_cycles(void) -{ - uint64_t c2, c1, diff, max; - - c1 = odp_cpu_cycles(); - odp_time_wait_ns(WAIT_TIME); - c2 = odp_cpu_cycles(); - - CU_ASSERT(c2 != c1); - - max = odp_cpu_cycles_max(); - - /* With 10 usec delay, diff should be small compared to the maximum. - * Otherwise, counter is going backwards. */ - if (c2 > c1) { - diff = c2 - c1; - CU_ASSERT(diff < (max - diff)); - } - - /* Same applies also when there was a wrap. */ - if (c2 < c1) { - diff = max - c1 + c2; - CU_ASSERT(diff < (max - diff)); - } -} - -static void system_test_cpu_cycles_max(void) -{ - uint64_t c2, c1; - uint64_t max1, max2; - - max1 = odp_cpu_cycles_max(); - odp_time_wait_ns(WAIT_TIME); - max2 = odp_cpu_cycles_max(); - - CU_ASSERT(max1 >= UINT32_MAX / 2); - CU_ASSERT(max1 == max2); - - c1 = odp_cpu_cycles(); - odp_time_wait_ns(WAIT_TIME); - c2 = odp_cpu_cycles(); - - CU_ASSERT(c1 <= max1 && c2 <= max1); -} - -static void system_test_cpu_cycles_resolution(void) -{ - int i; - uint64_t res; - uint64_t c2, c1, max; - uint64_t test_cycles = odp_cpu_hz() / 100; /* CPU cycles in 10 msec */ - - max = odp_cpu_cycles_max(); - - res = odp_cpu_cycles_resolution(); - CU_ASSERT(res != 0); - CU_ASSERT(res < max / 1024); - - for (i = 0; i < RES_TRY_NUM; i++) { - c1 = odp_cpu_cycles(); - odp_time_wait_ns(10 * ODP_TIME_MSEC_IN_NS + i); - c2 = odp_cpu_cycles(); - - /* Diff may be zero with low resolution */ - if (test_cycles && test_cycles > res) { - uint64_t diff = odp_cpu_cycles_diff(c2, c1); - - CU_ASSERT(diff >= res); - } - - } -} - -static void system_test_cpu_cycles_diff(void) -{ - uint64_t c2, c1, max; - uint64_t tmp, diff, res; - - res = odp_cpu_cycles_resolution(); - max = odp_cpu_cycles_max(); - - c1 = res; - c2 = 2 * res; - diff = odp_cpu_cycles_diff(c2, c1); - CU_ASSERT(diff == res); - - c1 = odp_cpu_cycles(); - odp_time_wait_ns(WAIT_TIME); - c2 = odp_cpu_cycles(); - diff = odp_cpu_cycles_diff(c2, c1); - CU_ASSERT(diff > 0); - CU_ASSERT(diff < (max - diff)); - - /* check resolution for wrap */ - c1 = max - 2 * res; - do - c2 = odp_cpu_cycles(); - while (c1 < c2); - - diff = odp_cpu_cycles_diff(c1, c1); - CU_ASSERT(diff == 0); - - /* wrap */ - tmp = c2 + (max - c1) + res; - diff = odp_cpu_cycles_diff(c2, c1); - CU_ASSERT(diff == tmp); - - /* no wrap, revert args */ - tmp = c1 - c2; - diff = odp_cpu_cycles_diff(c1, c2); - CU_ASSERT(diff == tmp); -} - -static void system_test_cpu_cycles_long_period(void) -{ - int i; - int periods = PERIODS_100_MSEC; - uint64_t max_period_duration = 100 * ODP_TIME_MSEC_IN_NS + periods - 1; - uint64_t c2, c1, c3, max; - uint64_t tmp, diff, res; - - res = odp_cpu_cycles_resolution(); - max = odp_cpu_cycles_max(); - - c3 = odp_cpu_cycles(); - - CU_ASSERT(c3 <= max); - /* - * If the cycle counter is not close to wrapping around during - * the test, then speed up the test by not trying to see the wrap - * around too hard. Assume cycle counter frequency of less than 10 GHz. - */ - CU_ASSERT(odp_cpu_hz_max() < 10ULL * ODP_TIME_SEC_IN_NS); - if (max - c3 > 10 * periods * max_period_duration) - periods = 10; - - printf("\n Testing CPU cycles for %i seconds... ", periods / 10); - - for (i = 0; i < periods; i++) { - c1 = odp_cpu_cycles(); - odp_time_wait_ns(100 * ODP_TIME_MSEC_IN_NS + i); - c2 = odp_cpu_cycles(); - - CU_ASSERT(c2 != c1); - CU_ASSERT(c1 <= max && c2 <= max); - - if (c2 > c1) - tmp = c2 - c1; - else - tmp = c2 + (max - c1) + res; - - diff = odp_cpu_cycles_diff(c2, c1); - CU_ASSERT(diff == tmp); - - /* wrap is detected and verified */ - if (c2 < c1) - break; - } - - /* wrap was detected, no need to continue */ - if (i < periods) { - printf("wrap was detected.\n"); - return; - } - - /* wrap has to be detected if possible */ - CU_ASSERT(max > UINT32_MAX); - CU_ASSERT((max - c3) > UINT32_MAX); - - printf("wrap was not detected.\n"); -} - static void system_test_odp_sys_cache_line_size(void) { uint64_t cache_size; @@ -277,32 +95,6 @@ static void system_test_odp_sys_cache_line_size(void) 2 * ODP_CACHE_LINE_SIZE); } -static void system_test_odp_cpu_model_str(void) -{ - char model[128]; - - snprintf(model, 128, "%s", odp_cpu_model_str()); - CU_ASSERT(strlen(model) > 0); - CU_ASSERT(strlen(model) < 127); -} - -static void system_test_odp_cpu_model_str_id(void) -{ - char model[128]; - odp_cpumask_t mask; - int i, num, cpu; - - num = odp_cpumask_all_available(&mask); - cpu = odp_cpumask_first(&mask); - - for (i = 0; i < num; i++) { - snprintf(model, 128, "%s", odp_cpu_model_str_id(cpu)); - CU_ASSERT(strlen(model) > 0); - CU_ASSERT(strlen(model) < 127); - cpu = odp_cpumask_next(&mask, cpu); - } -} - static void system_test_odp_sys_page_size(void) { uint64_t page; @@ -343,135 +135,6 @@ static void system_test_odp_sys_huge_page_size_all(void) } } -static int system_check_cycle_counter(void) -{ - if (odp_cpu_cycles_max() == 0) { - printf("Cycle counter is not supported, skipping test\n"); - return ODP_TEST_INACTIVE; - } - - return ODP_TEST_ACTIVE; -} - -static int system_check_odp_cpu_hz(void) -{ - if (odp_cpu_hz() == 0) { - printf("odp_cpu_hz() is not supported, skipping test\n"); - return ODP_TEST_INACTIVE; - } - - return ODP_TEST_ACTIVE; -} - -static void system_test_odp_cpu_hz(void) -{ - uint64_t hz = odp_cpu_hz(); - - /* Test value sanity: less than 10GHz */ - CU_ASSERT(hz < 10 * GIGA_HZ); - - /* larger than 1kHz */ - CU_ASSERT(hz > 1 * KILO_HZ); -} - -static int system_check_odp_cpu_hz_id(void) -{ - uint64_t hz; - odp_cpumask_t mask; - int i, num, cpu; - - num = odp_cpumask_all_available(&mask); - cpu = odp_cpumask_first(&mask); - - for (i = 0; i < num; i++) { - hz = odp_cpu_hz_id(cpu); - if (hz == 0) { - printf("odp_cpu_hz_id() is not supported by CPU %d, skipping test\n", cpu); - return ODP_TEST_INACTIVE; - } - cpu = odp_cpumask_next(&mask, cpu); - } - - return ODP_TEST_ACTIVE; -} - -static void system_test_odp_cpu_hz_id(void) -{ - uint64_t hz; - odp_cpumask_t mask; - int i, num, cpu; - - num = odp_cpumask_all_available(&mask); - cpu = odp_cpumask_first(&mask); - - for (i = 0; i < num; i++) { - hz = odp_cpu_hz_id(cpu); - /* Test value sanity: less than 10GHz */ - CU_ASSERT(hz < 10 * GIGA_HZ); - /* larger than 1kHz */ - CU_ASSERT(hz > 1 * KILO_HZ); - cpu = odp_cpumask_next(&mask, cpu); - } -} - -static int system_check_odp_cpu_hz_max(void) -{ - if (odp_cpu_hz_max() == 0) { - printf("odp_cpu_hz_max() is not supported, skipping test\n"); - return ODP_TEST_INACTIVE; - } - return ODP_TEST_ACTIVE; -} - -static void system_test_odp_cpu_hz_max(void) -{ - uint64_t hz = odp_cpu_hz_max(); - - /* Sanity check value */ - CU_ASSERT(hz > 1 * KILO_HZ); - CU_ASSERT(hz < 20 * GIGA_HZ); -} - -static int system_check_odp_cpu_hz_max_id(void) -{ - uint64_t hz; - odp_cpumask_t mask; - int i, num, cpu; - - num = odp_cpumask_all_available(&mask); - cpu = odp_cpumask_first(&mask); - - for (i = 0; i < num; i++) { - hz = odp_cpu_hz_max_id(cpu); - if (hz == 0) { - printf("odp_cpu_hz_max_id() is not supported by CPU %d, skipping test\n", - cpu); - return ODP_TEST_INACTIVE; - } - cpu = odp_cpumask_next(&mask, cpu); - } - - return ODP_TEST_ACTIVE; -} - -static void system_test_odp_cpu_hz_max_id(void) -{ - uint64_t hz; - odp_cpumask_t mask; - int i, num, cpu; - - num = odp_cpumask_all_available(&mask); - cpu = odp_cpumask_first(&mask); - - for (i = 0; i < num; i++) { - hz = odp_cpu_hz_max_id(cpu); - /* Sanity check value */ - CU_ASSERT(hz > 1 * KILO_HZ); - CU_ASSERT(hz < 20 * GIGA_HZ); - cpu = odp_cpumask_next(&mask, cpu); - } -} - static void system_test_info_print(void) { printf("\n\nCalling system info print...\n"); @@ -645,31 +308,10 @@ odp_testinfo_t system_suite[] = { ODP_TEST_INFO(test_version_api_str), ODP_TEST_INFO(test_version_str), ODP_TEST_INFO(test_version_macro), - ODP_TEST_INFO(system_test_odp_cpu_count), ODP_TEST_INFO(system_test_odp_sys_cache_line_size), - ODP_TEST_INFO(system_test_odp_cpu_model_str), - ODP_TEST_INFO(system_test_odp_cpu_model_str_id), ODP_TEST_INFO(system_test_odp_sys_page_size), ODP_TEST_INFO(system_test_odp_sys_huge_page_size), ODP_TEST_INFO(system_test_odp_sys_huge_page_size_all), - ODP_TEST_INFO_CONDITIONAL(system_test_odp_cpu_hz, - system_check_odp_cpu_hz), - ODP_TEST_INFO_CONDITIONAL(system_test_odp_cpu_hz_id, - system_check_odp_cpu_hz_id), - ODP_TEST_INFO_CONDITIONAL(system_test_odp_cpu_hz_max, - system_check_odp_cpu_hz_max), - ODP_TEST_INFO_CONDITIONAL(system_test_odp_cpu_hz_max_id, - system_check_odp_cpu_hz_max_id), - ODP_TEST_INFO_CONDITIONAL(system_test_cpu_cycles, - system_check_cycle_counter), - ODP_TEST_INFO_CONDITIONAL(system_test_cpu_cycles_max, - system_check_cycle_counter), - ODP_TEST_INFO_CONDITIONAL(system_test_cpu_cycles_resolution, - system_check_cycle_counter), - ODP_TEST_INFO_CONDITIONAL(system_test_cpu_cycles_diff, - system_check_cycle_counter), - ODP_TEST_INFO_CONDITIONAL(system_test_cpu_cycles_long_period, - system_check_cycle_counter), ODP_TEST_INFO(system_test_info), ODP_TEST_INFO(system_test_meminfo), ODP_TEST_INFO(system_test_info_print), diff --git a/test/validation/api/thread/thread.c b/test/validation/api/thread/thread.c index ad9ffa745..778e51b07 100644 --- a/test/validation/api/thread/thread.c +++ b/test/validation/api/thread/thread.c @@ -1,8 +1,6 @@ -/* Copyright (c) 2015-2018, Linaro Limited - * Copyright (c) 2022, Nokia - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2015-2018 Linaro Limited + * Copyright (c) 2022 Nokia */ #include <odp_api.h> @@ -83,11 +81,6 @@ static int thread_global_term(odp_instance_t inst) return 0; } -static void thread_test_odp_cpu_id(void) -{ - CU_ASSERT(odp_cpu_id() >= 0); -} - static void thread_test_odp_thread_id(void) { int id = odp_thread_id(); @@ -222,7 +215,6 @@ static void thread_test_odp_thrmask_control(void) } odp_testinfo_t thread_suite[] = { - ODP_TEST_INFO(thread_test_odp_cpu_id), ODP_TEST_INFO(thread_test_odp_thread_id), ODP_TEST_INFO(thread_test_odp_thread_count), ODP_TEST_INFO(thread_test_odp_thread_count_max), diff --git a/test/validation/api/time/time.c b/test/validation/api/time/time.c index cfef7f619..67eae7190 100644 --- a/test/validation/api/time/time.c +++ b/test/validation/api/time/time.c @@ -1,8 +1,6 @@ -/* Copyright (c) 2015-2018, Linaro Limited - * Copyright (c) 2019-2024, Nokia - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2015-2018 Linaro Limited + * Copyright (c) 2019-2024 Nokia */ #ifndef _GNU_SOURCE @@ -19,14 +17,15 @@ #define MIN_TIME_RATE 32000 #define MAX_TIME_RATE 15000000000 #define DELAY_TOLERANCE 40000000 /* deviation for delay */ -#define WAIT_SECONDS 3 +#define WAIT_SECONDS 3 #define MAX_WORKERS 32 +#define TEST_ROUNDS 1024 #define TIME_SAMPLES 2 #define TIME_TOLERANCE_NS 1000000 #define TIME_TOLERANCE_CI_NS 40000000 #define TIME_TOLERANCE_1CPU_NS 40000000 #define GLOBAL_SHM_NAME "GlobalTimeTest" -#define YEAR_IN_NS (365 * 24 * ODP_TIME_HOUR_IN_NS) +#define YEAR_IN_NS (365 * 24 * ODP_TIME_HOUR_IN_NS) static uint64_t local_res; static uint64_t global_res; @@ -40,6 +39,9 @@ typedef struct { uint32_t num_threads; odp_barrier_t test_barrier; odp_time_t time[MAX_WORKERS + 1][TIME_SAMPLES]; + odp_queue_t queue[MAX_WORKERS]; + uint32_t num_queues; + odp_atomic_u32_t event_count; } global_shared_mem_t; static global_shared_mem_t *global_mem; @@ -924,7 +926,14 @@ static void time_test_global_sync(const int ctrl) cpu = odp_cpumask_next(&cpumask, cpu); } - CU_ASSERT(odph_thread_join(thread_tbl, num) == num); + odph_thread_join_result_t res[num]; + + int ret = odph_thread_join_result(thread_tbl, res, num); + + CU_ASSERT(ret == num); + + for (int i = 0; i < num; i++) + CU_ASSERT(!res[i].is_sig && res[i].ret == 0); for (int s = 0; s < TIME_SAMPLES; s++) { int min_idx = 0, max_idx = 0; @@ -975,6 +984,179 @@ static void time_test_global_sync_control(void) time_test_global_sync(1); } +static odp_queue_t select_dst_queue(int thread_id, const odp_queue_t queue[], uint32_t num) +{ + uint8_t rand_u8; + int rand_id = 0; + + if (num == 1) + return queue[0]; + + do { + odp_random_data(&rand_u8, 1, ODP_RANDOM_BASIC); + rand_id = rand_u8 % num; + } while (rand_id == thread_id); + + return queue[rand_id]; +} + +static int run_time_global_thread(void *arg) +{ + global_shared_mem_t *gbl = arg; + const int thread_id = odp_thread_id(); + const odp_queue_t src_queue = gbl->queue[thread_id % gbl->num_queues]; + const odp_queue_t *queues = gbl->queue; + const uint32_t num_queues = gbl->num_queues; + odp_atomic_u32_t *event_count = &gbl->event_count; + + odp_barrier_wait(&gbl->test_barrier); + + while (odp_atomic_load_u32(event_count) < TEST_ROUNDS) { + odp_time_t *ts; + odp_time_t cur_time; + odp_buffer_t buf; + odp_queue_t dst_queue; + odp_event_t ev = odp_queue_deq(src_queue); + + if (ev == ODP_EVENT_INVALID) { + odp_cpu_pause(); + continue; + } + + cur_time = odp_time_global(); + + buf = odp_buffer_from_event(ev); + ts = odp_buffer_addr(buf); + + CU_ASSERT(odp_time_cmp(cur_time, *ts) >= 0); + + *ts = cur_time; + + dst_queue = select_dst_queue(thread_id, queues, num_queues); + + CU_ASSERT_FATAL(odp_queue_enq(dst_queue, ev) == 0); + + odp_atomic_inc_u32(event_count); + } + return 0; +} + +static void time_test_global_mt(void) +{ + odp_cpumask_t cpumask; + odp_pool_t pool; + odp_pool_param_t pool_param; + odp_pool_capability_t pool_capa; + odp_queue_param_t queue_param; + odp_queue_capability_t queue_capa; + odph_thread_t thread_tbl[MAX_WORKERS]; + odph_thread_common_param_t thr_common; + odph_thread_param_t thr_param; + odp_time_t cur_time; + uint32_t i; + int num_workers = odp_cpumask_default_worker(&cpumask, global_mem->num_threads); + uint32_t num_events = num_workers; + uint32_t num_queues = num_workers; + + CU_ASSERT_FATAL(odp_pool_capability(&pool_capa) == 0); + CU_ASSERT_FATAL(odp_queue_capability(&queue_capa) == 0); + + if (pool_capa.buf.max_num && num_events > pool_capa.buf.max_num) + num_events = pool_capa.buf.max_num; + + if (queue_capa.plain.max_size && num_events > queue_capa.plain.max_size) + num_events = queue_capa.plain.max_size; + + if (queue_capa.plain.max_num < num_queues) + num_queues = queue_capa.plain.max_num; + CU_ASSERT_FATAL(num_queues > 0); + + odp_pool_param_init(&pool_param); + pool_param.buf.size = sizeof(odp_time_t); + pool_param.buf.num = num_events; + pool_param.type = ODP_POOL_BUFFER; + + pool = odp_pool_create("test event pool", &pool_param); + CU_ASSERT_FATAL(pool != ODP_POOL_INVALID); + + odp_queue_param_init(&queue_param); + queue_param.size = num_events; + queue_param.type = ODP_QUEUE_TYPE_PLAIN; + + for (i = 0; i < num_queues; i++) { + global_mem->queue[i] = odp_queue_create(NULL, &queue_param); + CU_ASSERT_FATAL(global_mem->queue[i] != ODP_QUEUE_INVALID); + } + global_mem->num_queues = num_queues; + + odp_atomic_init_u32(&global_mem->event_count, 0); + + for (i = 0; i < num_events; i++) { + odp_time_t *ts; + odp_buffer_t buf = odp_buffer_alloc(pool); + + if (buf == ODP_BUFFER_INVALID) + break; + + ts = odp_buffer_addr(buf); + *ts = odp_time_global(); + + CU_ASSERT_FATAL(odp_queue_enq(global_mem->queue[i % num_queues], + odp_buffer_to_event(buf)) == 0); + } + CU_ASSERT_FATAL(i > 0); + CU_ASSERT(i == num_events); + + odp_barrier_init(&global_mem->test_barrier, num_workers); + + odph_thread_param_init(&thr_param); + thr_param.start = run_time_global_thread; + thr_param.arg = global_mem; + thr_param.thr_type = ODP_THREAD_WORKER; + + odph_thread_common_param_init(&thr_common); + thr_common.instance = *instance; + thr_common.cpumask = &cpumask; + thr_common.share_param = 1; + + CU_ASSERT_FATAL(odph_thread_create(thread_tbl, &thr_common, &thr_param, num_workers) == + num_workers); + + odph_thread_join_result_t res[num_workers]; + + int ret = odph_thread_join_result(thread_tbl, res, num_workers); + + CU_ASSERT(ret == num_workers); + + for (i = 0; i < (uint32_t)num_workers; i++) + CU_ASSERT(!res[i].is_sig && res[i].ret == 0); + + cur_time = odp_time_global_strict(); + + for (i = 0; i < num_queues; i++) { + odp_queue_t queue = global_mem->queue[i]; + + while (1) { + odp_buffer_t buf; + odp_time_t *ts; + odp_event_t ev = odp_queue_deq(queue); + + if (ev == ODP_EVENT_INVALID) + break; + + buf = odp_buffer_from_event(ev); + ts = odp_buffer_addr(buf); + + CU_ASSERT(odp_time_cmp(cur_time, *ts) >= 0); + odp_buffer_free(buf); + }; + + CU_ASSERT(odp_queue_destroy(queue) == 0); + } + + CU_ASSERT(odp_pool_destroy(pool) == 0); +} + odp_testinfo_t time_suite_time[] = { ODP_TEST_INFO(time_test_constants), ODP_TEST_INFO(time_test_startup_time), @@ -983,6 +1165,7 @@ odp_testinfo_t time_suite_time[] = { ODP_TEST_INFO(time_test_local_cmp), ODP_TEST_INFO(time_test_local_diff), ODP_TEST_INFO(time_test_local_sum), + ODP_TEST_INFO(time_test_global_mt), ODP_TEST_INFO(time_test_global_res), ODP_TEST_INFO(time_test_global_conversion), ODP_TEST_INFO(time_test_global_cmp), diff --git a/test/validation/api/timer/timer.c b/test/validation/api/timer/timer.c index 3678d0cb2..98637b2e1 100644 --- a/test/validation/api/timer/timer.c +++ b/test/validation/api/timer/timer.c @@ -1,8 +1,6 @@ -/* Copyright (c) 2015-2018, Linaro Limited - * Copyright (c) 2019-2023, Nokia - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2015-2018 Linaro Limited + * Copyright (c) 2019-2023 Nokia */ /* For rand_r and nanosleep */ @@ -650,6 +648,7 @@ static void timer_test_timeout_user_area(void) CU_ASSERT(prev != addr); ev = odp_timeout_to_event(tmo[i]); + odp_event_user_flag_set(ev, 1); CU_ASSERT(odp_event_user_area(ev) == addr); CU_ASSERT(odp_event_user_area_and_flag(ev, &flag) == addr); CU_ASSERT(flag < 0); @@ -748,6 +747,32 @@ static void timer_pool_create_destroy(void) CU_ASSERT(odp_queue_destroy(queue) == 0); } +static void timer_pool_long_name(void) +{ + odp_timer_pool_param_t tparam; + odp_timer_pool_info_t info; + odp_timer_pool_t pool; + odp_timer_clk_src_t clk_src = test_global->clk_src; + char name[ODP_TIMER_POOL_NAME_LEN]; + + memset(name, 'a', sizeof(name)); + name[sizeof(name) - 1] = 0; + + odp_timer_pool_param_init(&tparam); + tparam.res_ns = global_mem->param.res_ns; + tparam.min_tmo = global_mem->param.min_tmo; + tparam.max_tmo = global_mem->param.max_tmo; + tparam.num_timers = 100; + tparam.priv = 0; + tparam.clk_src = clk_src; + + pool = odp_timer_pool_create(name, &tparam); + CU_ASSERT(pool != ODP_TIMER_POOL_INVALID); + CU_ASSERT(odp_timer_pool_info(pool, &info) == 0); + CU_ASSERT(!strcmp(name, info.name)); + odp_timer_pool_destroy(pool); +} + static void timer_pool_create_max(void) { odp_timer_capability_t capa; @@ -3160,6 +3185,7 @@ odp_suiteinfo_t timer_general_suites[] = { odp_testinfo_t timer_suite[] = { ODP_TEST_INFO(timer_test_capa), ODP_TEST_INFO(timer_pool_create_destroy), + ODP_TEST_INFO(timer_pool_long_name), ODP_TEST_INFO(timer_pool_create_max), ODP_TEST_INFO(timer_pool_max_res), ODP_TEST_INFO(timer_pool_current_tick), diff --git a/test/validation/api/traffic_mngr/traffic_mngr.c b/test/validation/api/traffic_mngr/traffic_mngr.c index b7f546dcd..dcf21b820 100644 --- a/test/validation/api/traffic_mngr/traffic_mngr.c +++ b/test/validation/api/traffic_mngr/traffic_mngr.c @@ -1,9 +1,7 @@ -/* Copyright (c) 2015-2018, Linaro Limited - * Copyright (c) 2022, Marvell - * Copyright (c) 2022, Nokia - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright (c) 2015-2018 Linaro Limited + * Copyright (c) 2022 Marvell + * Copyright (c) 2022 Nokia */ #ifndef _GNU_SOURCE @@ -67,7 +65,8 @@ #define MAX_PKTS 1000u #define PKT_BUF_SIZE 1460 -#define MAX_PAYLOAD 1400 +#define MIN_HDR_LEN (ODPH_ETHHDR_LEN + ODPH_UDPHDR_LEN + ODPH_IPV4HDR_LEN) +#define MAX_PAYLOAD (PKT_BUF_SIZE - MIN_HDR_LEN) #define USE_IPV4 false #define USE_IPV6 true #define USE_UDP false @@ -103,7 +102,6 @@ #define ETHERNET_OVHD_LEN (ETHERNET_IFG + ETHERNET_PREAMBLE) #define CRC_LEN 4 #define SHAPER_LEN_ADJ ETHERNET_OVHD_LEN -#define TM_NAME_LEN 32 #define BILLION 1000000000ULL #define MS 1000000 /* Millisecond in units of NS */ #define MBPS 1000000 @@ -801,6 +799,12 @@ static odp_packet_t make_pkt(odp_pool_t pkt_pool, uint8_t *buf, *pkt_class_ptr, next_hdr; int rc; + if (payload_len > MAX_PAYLOAD) { + ODPH_ERR("packet payload length of %u exceeds MAX_PAYLOAD of %u\n", + payload_len, MAX_PAYLOAD); + return ODP_PACKET_INVALID; + } + l4_hdr_len = pkt_info->use_tcp ? ODPH_TCPHDR_LEN : ODPH_UDPHDR_LEN; l3_hdr_len = pkt_info->use_ipv6 ? ODPH_IPV6HDR_LEN : ODPH_IPV4HDR_LEN; vlan_hdr_len = pkt_info->use_vlan ? ODPH_VLANHDR_LEN : 0; @@ -1570,7 +1574,7 @@ static tm_node_desc_t *create_tm_node(odp_tm_t odp_tm, odp_tm_wred_t green_profile, yellow_profile, red_profile; odp_tm_node_t tm_node, parent_node; uint32_t node_desc_size, queue_desc_size, priority; - char node_name[TM_NAME_LEN]; + char node_name[ODP_TM_NAME_LEN]; int rc; odp_tm_node_params_init(&node_params); @@ -1731,7 +1735,7 @@ static tm_node_desc_t *find_node_desc(uint8_t tm_system_idx, name_ptr++; while (node_desc != NULL) { - if (strncmp(node_desc->node_name, node_name, TM_NAME_LEN) == 0) + if (strncmp(node_desc->node_name, node_name, ODP_TM_NAME_LEN) == 0) return node_desc; if (name_ptr == NULL) @@ -1866,7 +1870,7 @@ static int create_tm_system(void) tm_node_desc_t *root_node_desc; uint32_t level, max_nodes[ODP_TM_MAX_LEVELS]; odp_tm_t odp_tm, found_odp_tm; - char tm_name[TM_NAME_LEN]; + char tm_name[ODP_TM_NAME_LEN]; int rc; odp_tm_requirements_init(&requirements); @@ -2546,7 +2550,7 @@ static void traffic_mngr_test_shaper_profile(void) odp_tm_shaper_params_t shaper_params; odp_tm_shaper_t profile; uint32_t idx, shaper_idx, i; - char shaper_name[TM_NAME_LEN]; + char shaper_name[ODP_TM_NAME_LEN]; odp_tm_shaper_params_init(&shaper_params); shaper_params.shaper_len_adjust = SHAPER_LEN_ADJ; @@ -2610,7 +2614,7 @@ static void traffic_mngr_test_sched_profile(void) odp_tm_sched_params_t sched_params; odp_tm_sched_t profile; uint32_t idx, priority, sched_idx, i; - char sched_name[TM_NAME_LEN]; + char sched_name[ODP_TM_NAME_LEN]; odp_tm_sched_params_init(&sched_params); @@ -2683,7 +2687,7 @@ static void traffic_mngr_test_threshold_profile(threshold_type_t threshold) odp_tm_threshold_params_t threshold_params; odp_tm_threshold_t profile; uint32_t idx, threshold_idx, i; - char threshold_name[TM_NAME_LEN]; + char threshold_name[ODP_TM_NAME_LEN]; odp_tm_threshold_params_init(&threshold_params); @@ -2778,7 +2782,7 @@ static void traffic_mngr_test_wred_profile(void) odp_tm_wred_params_t wred_params; odp_tm_wred_t profile; uint32_t idx, color, wred_idx, i, c; - char wred_name[TM_NAME_LEN]; + char wred_name[ODP_TM_NAME_LEN]; odp_tm_wred_params_init(&wred_params); wred_params.enable_wred = 1; @@ -3068,7 +3072,7 @@ static int set_sched_fanin(const char *node_name, odp_tm_node_t tm_node, fanin_node; uint32_t fanin_cnt, fanin, priority; uint8_t sched_weight; - char sched_name[TM_NAME_LEN]; + char sched_name[ODP_TM_NAME_LEN]; int rc; node_desc = find_node_desc(0, node_name); @@ -4456,7 +4460,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 +4470,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 +4485,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 +4506,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); } @@ -4961,6 +4965,92 @@ static void traffic_mngr_test_lso_ipv4(void) CU_ASSERT(odp_tm_is_idle(odp_tm_systems[0])); } +static void traffic_mngr_test_node_long_name(void) +{ + odp_tm_node_params_t node_params; + odp_tm_node_t tm_node; + char name[ODP_TM_NAME_LEN]; + + memset(name, 'a', sizeof(name)); + name[sizeof(name) - 1] = 0; + + odp_tm_node_params_init(&node_params); + + tm_node = odp_tm_node_create(odp_tm_systems[0], name, &node_params); + CU_ASSERT(tm_node != ODP_TM_INVALID); + CU_ASSERT(tm_node == odp_tm_node_lookup(odp_tm_systems[0], name)); + CU_ASSERT(!odp_tm_node_destroy(tm_node)); +} + +static void traffic_mngr_test_shaper_long_name(void) +{ + odp_tm_shaper_params_t shaper_params; + odp_tm_shaper_t profile; + char name[ODP_TM_NAME_LEN]; + + memset(name, 'a', sizeof(name)); + name[sizeof(name) - 1] = 0; + + odp_tm_shaper_params_init(&shaper_params); + profile = odp_tm_shaper_create(name, &shaper_params); + + CU_ASSERT(profile != ODP_TM_INVALID); + CU_ASSERT(profile == odp_tm_shaper_lookup(name)); + CU_ASSERT(!odp_tm_shaper_destroy(profile)); +} + +static void traffic_mngr_test_sched_long_name(void) +{ + odp_tm_sched_params_t sched_params; + odp_tm_sched_t profile; + char name[ODP_TM_NAME_LEN]; + + memset(name, 'a', sizeof(name)); + name[sizeof(name) - 1] = 0; + + odp_tm_sched_params_init(&sched_params); + profile = odp_tm_sched_create(name, &sched_params); + + CU_ASSERT(profile != ODP_TM_INVALID); + CU_ASSERT(profile == odp_tm_sched_lookup(name)); + CU_ASSERT(!odp_tm_sched_destroy(profile)); +} + +static void traffic_mngr_test_threshold_long_name(void) +{ + odp_tm_threshold_params_t threshold_params; + odp_tm_threshold_t profile; + char name[ODP_TM_NAME_LEN]; + + memset(name, 'a', sizeof(name)); + name[sizeof(name) - 1] = 0; + + odp_tm_threshold_params_init(&threshold_params); + threshold_params.enable_max_bytes = true; + profile = odp_tm_threshold_create(name, &threshold_params); + + CU_ASSERT(profile != ODP_TM_INVALID); + CU_ASSERT(profile == odp_tm_thresholds_lookup(name)); + CU_ASSERT(!odp_tm_threshold_destroy(profile)); +} + +static void traffic_mngr_test_wred_long_name(void) +{ + odp_tm_wred_params_t wred_params; + odp_tm_wred_t profile; + char name[ODP_TM_NAME_LEN]; + + memset(name, 'a', sizeof(name)); + name[sizeof(name) - 1] = 0; + + odp_tm_wred_params_init(&wred_params); + profile = odp_tm_wred_create(name, &wred_params); + + CU_ASSERT(profile != ODP_TM_INVALID); + CU_ASSERT(profile == odp_tm_wred_lookup(name)); + CU_ASSERT(!odp_tm_wred_destroy(profile)); +} + static void traffic_mngr_test_destroy(void) { CU_ASSERT(destroy_tm_systems() == 0); @@ -5012,6 +5102,15 @@ odp_testinfo_t traffic_mngr_suite[] = { traffic_mngr_check_tx_aging), ODP_TEST_INFO(traffic_mngr_test_fanin_info), ODP_TEST_INFO_CONDITIONAL(traffic_mngr_test_lso_ipv4, traffic_mngr_check_lso_ipv4), + ODP_TEST_INFO(traffic_mngr_test_node_long_name), + ODP_TEST_INFO_CONDITIONAL(traffic_mngr_test_shaper_long_name, + traffic_mngr_check_shaper), + ODP_TEST_INFO_CONDITIONAL(traffic_mngr_test_sched_long_name, + traffic_mngr_check_scheduler), + ODP_TEST_INFO_CONDITIONAL(traffic_mngr_test_threshold_long_name, + traffic_mngr_check_thresholds_byte), + ODP_TEST_INFO_CONDITIONAL(traffic_mngr_test_wred_long_name, + traffic_mngr_check_wred), ODP_TEST_INFO(traffic_mngr_test_destroy), ODP_TEST_INFO_NULL, }; |