On 2015-07-21 14:32, Stuart Haslam wrote:
> Split the majority of the test cases out into a separate file in
> preparation for them being reused to perform thrmask tests.
>
> Signed-off-by: Stuart Haslam <[email protected]>
> ---
> test/validation/Makefile.inc | 7 +-
> test/validation/common/.gitignore | 2 +-
> test/validation/common/Makefile.am | 6 +-
> test/validation/common/mask_common.c | 472
> +++++++++++++++++++++++++++++++++++
> test/validation/common/mask_common.h | 28 +++
> test/validation/cpumask/Makefile.am | 2 +-
> test/validation/cpumask/cpumask.c | 465 +---------------------------------
> 7 files changed, 513 insertions(+), 469 deletions(-)
> create mode 100644 test/validation/common/mask_common.c
> create mode 100644 test/validation/common/mask_common.h
>
> diff --git a/test/validation/Makefile.inc b/test/validation/Makefile.inc
> index 31729b8..55a10e2 100644
> --- a/test/validation/Makefile.inc
> +++ b/test/validation/Makefile.inc
> @@ -1,7 +1,10 @@
> include $(top_srcdir)/test/Makefile.inc
>
> -AM_CFLAGS += -I$(top_srcdir)/test/validation/common
> +COMMON_DIR = $(top_srcdir)/test/validation/common
> +
> +AM_CFLAGS += -I$(COMMON_DIR)
> AM_LDFLAGS += -static
>
> -LIBCUNIT_COMMON = $(top_builddir)/test/validation/common/libcunit_common.a
> +LIBCUNIT_COMMON = $(COMMON_DIR)/libcunit_common.a
> +LIBCPUMASK_COMMON = $(COMMON_DIR)/libcpumask_common.a
> LIBODP = $(LIB)/libodphelper.la $(LIB)/libodp.la
> diff --git a/test/validation/common/.gitignore
> b/test/validation/common/.gitignore
> index e8aa876..6600799 100644
> --- a/test/validation/common/.gitignore
> +++ b/test/validation/common/.gitignore
> @@ -1,2 +1,2 @@
> libcunit_common.a
> -libcunit_common_as_main.a
> +libcpumask_common.a
> diff --git a/test/validation/common/Makefile.am
> b/test/validation/common/Makefile.am
> index 5548c52..89a6e4f 100644
> --- a/test/validation/common/Makefile.am
> +++ b/test/validation/common/Makefile.am
> @@ -1,6 +1,8 @@
> AUTOMAKE_OPTIONS = foreign
> include $(top_srcdir)/test/Makefile.inc
>
> -noinst_LIBRARIES = libcunit_common.a
> -libcunit_common_a_CFLAGS = $(AM_CFLAGS)
> +noinst_LIBRARIES = libcunit_common.a libcpumask_common.a
> +
> libcunit_common_a_SOURCES = odp_cunit_common.c
> +
> +libcpumask_common_a_SOURCES = mask_common.c
> diff --git a/test/validation/common/mask_common.c
> b/test/validation/common/mask_common.c
> new file mode 100644
> index 0000000..e10b2fe
> --- /dev/null
> +++ b/test/validation/common/mask_common.c
> @@ -0,0 +1,472 @@
> +/* Copyright (c) 2015, Linaro Limited
> + * All rights reserved.
> + *
> + * SPDX-License-Identifier: BSD-3-Clause
> + */
> +
> +#include <odp.h>
> +#include "odp_cunit_common.h"
> +#include "mask_common.h"
> +
> +/*
> + * The following string are used to build cpu masks with
> + * odp_cpumask_from_str(). Both 0x prefixed and non prefixed
> + * hex values are supported by odp_cpumask_from_str()
> + */
> +#define TEST_MASK_NO_CPU "0x0"
> +#define TEST_MASK_CPU_0 "0x1"
> +#define TEST_MASK_CPU_1 "0x2"
> +#define TEST_MASK_CPU_2 "0x4"
> +#define TEST_MASK_CPU_0_2 "0x5"
> +#define TEST_MASK_CPU_0_3 "0x9"
> +#define TEST_MASK_CPU_1_2 "0x6"
> +#define TEST_MASK_CPU_1_3 "0xA"
> +#define TEST_MASK_CPU_0_1_2 "0x7"
> +#define TEST_MASK_CPU_0_2_4_6 "0x55"
> +#define TEST_MASK_CPU_1_2_4_6 "0x56"
> +
> +#define TEST_MASK_CPU_0_NO_PREFIX "1"
> +
> +/* padding pattern used to check buffer overflow: */
> +#define FILLING_PATTERN 0x55
> +
> +/*
> + * returns the length of a string, excluding terminating NULL.
> + * As its C lib strlen equivalent. Just rewritten here to avoid C lib
> + * dependency in ODP tests (for platform independent / bare metal testing)
> + */
> +static unsigned int stringlen(const char *str)
> +{
> + unsigned int i = 0;
> +
> + while (str[i] != 0)
> + i++;
> + return i;
> +}
> +
> +/*
> + * builds a string containing a 0x prefixed hex number
> + * where a single bit (corresponding to cpu) is set.
> + * The string is null terminated.
> + * cpu_to_str(0) returns "0x1".
> + * cpu_to_str(10) returns "0x400".
> + * The buffer should be at least ceil(cpu/4)+3 bytes long,
> + * to accommodate with 4 cpus per nibble + "0x" prefix + null.
> + */
> +#define CPUS_PER_NIBBLE 4
> +static void cpu_to_str(char *buff, int cpu)
> +{
> + const char *hex_nibble = "1248";
> + int i = 0;
> +
> + buff[i++] = '0';
> + buff[i++] = 'x';
> + buff[i++] = hex_nibble[cpu % CPUS_PER_NIBBLE];
> + while (cpu > 3) {
> + buff[i++] = '0';
> + cpu -= CPUS_PER_NIBBLE;
> + }
> + buff[i++] = 0; /* null */
> +}
> +
> +/*
> + * Returns the maximum number of CPUs that a mask can contain.
> + */
> +unsigned mask_capacity(void)
> +{
> + odp_cpumask_t mask;
> +
> + odp_cpumask_setall(&mask);
> +
> + return odp_cpumask_count(&mask);
> +}
> +
> +void cpumask_test_odp_cpumask_to_from_str(void)
> +{
> + odp_cpumask_t mask;
> + int32_t str_sz;
> + unsigned int buf_sz; /* buf size for the 2 following bufs */
> + char *buf_in;
> + char *buf_out;
> + unsigned int cpu;
> + unsigned int i;
> +
> + /* makes sure the mask has room for at least 1 CPU...: */
> + CU_ASSERT_FATAL(mask_capacity() > 0);
> +
> + /* allocate memory for the buffers containing the mask strings:
> + 1 char per nibble, i.e. 1 char per 4 cpus +extra for "0x" and null:*/
> + buf_sz = (mask_capacity() >> 2) + 20;
> + buf_in = malloc(buf_sz);
> + buf_out = malloc(buf_sz);
> + CU_ASSERT_FATAL(buf_in && buf_out);
> +
> + /* test 1 CPU at a time for all possible cpu positions in the mask */
> + for (cpu = 0; cpu < mask_capacity(); cpu++) {
> + /* init buffer for overwrite check: */
> + for (i = 0; i < buf_sz; i++)
> + buf_out[i] = FILLING_PATTERN;
> +
> + /* generate a hex string with that cpu set: */
> + cpu_to_str(buf_in, cpu);
> +
> + /* generate mask: */
> + odp_cpumask_from_str(&mask, buf_in);
> +
> + /* reverse cpu mask computation to get string back: */
> + str_sz = odp_cpumask_to_str(&mask, buf_out,
> + stringlen(buf_in) + 1);
> +
> + /* check that returned size matches original (with NULL): */
> + CU_ASSERT(str_sz == (int32_t)stringlen(buf_in) + 1);
> +
> + /* check that returned string matches original (with NULL): */
> + CU_ASSERT_NSTRING_EQUAL(buf_out, buf_in, stringlen(buf_in) + 1);
> +
> + /* check that no extra buffer writes occurred: */
> + CU_ASSERT(buf_out[stringlen(buf_in) + 2] == FILLING_PATTERN);
> + }
> +
> + /* re-init buffer for overwrite check: */
> + for (i = 0; i < buf_sz; i++)
> + buf_out[i] = FILLING_PATTERN;
> +
> + /* check for buffer overflow when too small buffer given: */
> + odp_cpumask_from_str(&mask, TEST_MASK_CPU_0);
> + str_sz = odp_cpumask_to_str(&mask, buf_out, stringlen(TEST_MASK_CPU_0));
> +
> + CU_ASSERT(str_sz == -1);
> +
> + for (i = 0; i < buf_sz; i++)
> + CU_ASSERT(buf_out[i] == FILLING_PATTERN);
> +
> + /* check for handling of missing "0x" prefix: */
> + odp_cpumask_from_str(&mask, TEST_MASK_CPU_0_NO_PREFIX);
> +
> + str_sz = odp_cpumask_to_str(&mask, buf_out,
> + stringlen(TEST_MASK_CPU_0) + 1);
> +
> + CU_ASSERT_NSTRING_EQUAL(buf_out, TEST_MASK_CPU_0,
> + stringlen(TEST_MASK_CPU_0) + 1);
> +
> + free(buf_out);
> + free(buf_in);
> +}
> +
> +void cpumask_test_odp_cpumask_equal(void)
> +{
> + odp_cpumask_t mask1;
> + odp_cpumask_t mask2;
> + odp_cpumask_t mask3;
> +
> + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0);
> + odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0);
> + odp_cpumask_from_str(&mask3, TEST_MASK_NO_CPU);
> + CU_ASSERT(odp_cpumask_equal(&mask1, &mask2));
> + CU_ASSERT_FALSE(odp_cpumask_equal(&mask1, &mask3));
> +
> + if (mask_capacity() < 4)
> + return;
> +
> + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0_2);
> + odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0_2);
> + odp_cpumask_from_str(&mask3, TEST_MASK_CPU_1_2);
> + CU_ASSERT(odp_cpumask_equal(&mask1, &mask2));
> + CU_ASSERT_FALSE(odp_cpumask_equal(&mask1, &mask3));
> +
> + if (mask_capacity() < 8)
> + return;
> +
> + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0_2_4_6);
> + odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0_2_4_6);
> + odp_cpumask_from_str(&mask3, TEST_MASK_CPU_1_2_4_6);
> + CU_ASSERT(odp_cpumask_equal(&mask1, &mask2));
> + CU_ASSERT_FALSE(odp_cpumask_equal(&mask1, &mask3));
> +}
> +
> +void cpumask_test_odp_cpumask_zero(void)
> +{
> + odp_cpumask_t mask1;
> + odp_cpumask_t mask2;
> +
> + odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU);
> + odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0);
> + odp_cpumask_zero(&mask2);
> + CU_ASSERT(odp_cpumask_equal(&mask1, &mask2));
> +}
> +
> +void cpumask_test_odp_cpumask_set(void)
> +{
> + odp_cpumask_t mask1;
> + odp_cpumask_t mask2;
> +
> + odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU);
> + odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0);
> + odp_cpumask_set(&mask1, 0);
> + CU_ASSERT(odp_cpumask_equal(&mask1, &mask2));
> +
> + if (mask_capacity() < 4)
> + return;
> +
> + odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0_3);
> + odp_cpumask_set(&mask1, 3);
> + CU_ASSERT(odp_cpumask_equal(&mask1, &mask2));
> +
> + /* make sure that re-asserting a cpu has no impact: */
> + odp_cpumask_set(&mask1, 3);
> + CU_ASSERT(odp_cpumask_equal(&mask1, &mask2));
> +}
> +
> +void cpumask_test_odp_cpumask_clr(void)
> +{
> + odp_cpumask_t mask1;
> + odp_cpumask_t mask2;
> +
> + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0);
> + odp_cpumask_from_str(&mask2, TEST_MASK_NO_CPU);
> + odp_cpumask_clr(&mask1, 0);
> + CU_ASSERT(odp_cpumask_equal(&mask1, &mask2));
> +
> + if (mask_capacity() < 4)
> + return;
> +
> + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0_2);
> + odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0);
> + odp_cpumask_clr(&mask1, 2);
> + CU_ASSERT(odp_cpumask_equal(&mask1, &mask2));
> +
> + odp_cpumask_from_str(&mask2, TEST_MASK_NO_CPU);
> + odp_cpumask_clr(&mask1, 0);
> + CU_ASSERT(odp_cpumask_equal(&mask1, &mask2));
> +
> + /* make sure that re-clearing a cpu has no impact: */
> + odp_cpumask_clr(&mask1, 0);
> + CU_ASSERT(odp_cpumask_equal(&mask1, &mask2));
> +}
> +
> +void cpumask_test_odp_cpumask_isset(void)
> +{
> + odp_cpumask_t mask1;
> +
> + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0);
> + CU_ASSERT(odp_cpumask_isset(&mask1, 0));
> +
> + odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU);
> + CU_ASSERT_FALSE(odp_cpumask_isset(&mask1, 0));
> +
> + if (mask_capacity() < 4)
> + return;
> +
> + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0_2);
> + CU_ASSERT(odp_cpumask_isset(&mask1, 0));
> + CU_ASSERT_FALSE(odp_cpumask_isset(&mask1, 1));
> + CU_ASSERT(odp_cpumask_isset(&mask1, 2));
> + CU_ASSERT_FALSE(odp_cpumask_isset(&mask1, 3));
> +}
> +
> +void cpumask_test_odp_cpumask_count(void)
> +{
> + odp_cpumask_t mask1;
> +
> + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0);
> + CU_ASSERT(odp_cpumask_count(&mask1) == 1);
> +
> + odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU);
> + CU_ASSERT(odp_cpumask_count(&mask1) == 0);
> +
> + if (mask_capacity() < 4)
> + return;
> +
> + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0_2);
> + CU_ASSERT(odp_cpumask_count(&mask1) == 2);
> +}
> +
> +void cpumask_test_odp_cpumask_and(void)
> +{
> + odp_cpumask_t mask1;
> + odp_cpumask_t mask2;
> + odp_cpumask_t mask3;
> + odp_cpumask_t mask4;
> +
> + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0);
> + odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0);
> + odp_cpumask_from_str(&mask4, TEST_MASK_CPU_0);
> + odp_cpumask_and(&mask3, &mask1, &mask2);
> + CU_ASSERT(odp_cpumask_equal(&mask3, &mask4));
> +
> + odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU);
> + odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0);
> + odp_cpumask_from_str(&mask4, TEST_MASK_NO_CPU);
> + odp_cpumask_and(&mask3, &mask1, &mask2);
> + CU_ASSERT(odp_cpumask_equal(&mask3, &mask4));
> +
> + odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU);
> + odp_cpumask_from_str(&mask2, TEST_MASK_NO_CPU);
> + odp_cpumask_from_str(&mask4, TEST_MASK_NO_CPU);
> + odp_cpumask_and(&mask3, &mask1, &mask2);
> + CU_ASSERT(odp_cpumask_equal(&mask3, &mask4));
> +
> + if (mask_capacity() < 4)
> + return;
> +
> + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0_2);
> + odp_cpumask_from_str(&mask2, TEST_MASK_CPU_1_2);
> + odp_cpumask_from_str(&mask4, TEST_MASK_CPU_2);
> + odp_cpumask_and(&mask3, &mask1, &mask2);
> + CU_ASSERT(odp_cpumask_equal(&mask3, &mask4));
> +}
> +
> +void cpumask_test_odp_cpumask_or(void)
> +{
> + odp_cpumask_t mask1;
> + odp_cpumask_t mask2;
> + odp_cpumask_t mask3;
> + odp_cpumask_t mask4;
> +
> + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0);
> + odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0);
> + odp_cpumask_from_str(&mask4, TEST_MASK_CPU_0);
> + odp_cpumask_or(&mask3, &mask1, &mask2);
> + CU_ASSERT(odp_cpumask_equal(&mask3, &mask4));
> +
> + odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU);
> + odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0);
> + odp_cpumask_from_str(&mask4, TEST_MASK_CPU_0);
> + odp_cpumask_or(&mask3, &mask1, &mask2);
> + CU_ASSERT(odp_cpumask_equal(&mask3, &mask4));
> +
> + odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU);
> + odp_cpumask_from_str(&mask2, TEST_MASK_NO_CPU);
> + odp_cpumask_from_str(&mask4, TEST_MASK_NO_CPU);
> + odp_cpumask_or(&mask3, &mask1, &mask2);
> + CU_ASSERT(odp_cpumask_equal(&mask3, &mask4));
> +
> + if (mask_capacity() < 4)
> + return;
> +
> + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0_2);
> + odp_cpumask_from_str(&mask2, TEST_MASK_CPU_1);
> + odp_cpumask_from_str(&mask4, TEST_MASK_CPU_0_1_2);
> + odp_cpumask_or(&mask3, &mask1, &mask2);
> + CU_ASSERT(odp_cpumask_equal(&mask3, &mask4));
> +}
> +
> +void cpumask_test_odp_cpumask_xor(void)
> +{
> + odp_cpumask_t mask1;
> + odp_cpumask_t mask2;
> + odp_cpumask_t mask3;
> + odp_cpumask_t mask4;
> +
> + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0);
> + odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0);
> + odp_cpumask_from_str(&mask4, TEST_MASK_NO_CPU);
> + odp_cpumask_xor(&mask3, &mask1, &mask2);
> + CU_ASSERT(odp_cpumask_equal(&mask3, &mask4));
> +
> + odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU);
> + odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0);
> + odp_cpumask_from_str(&mask4, TEST_MASK_CPU_0);
> + odp_cpumask_xor(&mask3, &mask1, &mask2);
> + CU_ASSERT(odp_cpumask_equal(&mask3, &mask4));
> +
> + odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU);
> + odp_cpumask_from_str(&mask2, TEST_MASK_NO_CPU);
> + odp_cpumask_from_str(&mask4, TEST_MASK_NO_CPU);
> + odp_cpumask_xor(&mask3, &mask1, &mask2);
> + CU_ASSERT(odp_cpumask_equal(&mask3, &mask4));
> +
> + if (mask_capacity() < 4)
> + return;
> +
> + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_2);
> + odp_cpumask_from_str(&mask2, TEST_MASK_CPU_1_2);
> + odp_cpumask_from_str(&mask4, TEST_MASK_CPU_1);
> + odp_cpumask_xor(&mask3, &mask1, &mask2);
> + CU_ASSERT(odp_cpumask_equal(&mask3, &mask4));
> +}
> +
> +void cpumask_test_odp_cpumask_copy(void)
> +{
> + odp_cpumask_t mask1;
> + odp_cpumask_t mask2;
> +
> + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0);
> + odp_cpumask_copy(&mask2, &mask1);
> + CU_ASSERT(odp_cpumask_equal(&mask1, &mask2));
> +}
> +
> +void cpumask_test_odp_cpumask_first(void)
> +{
> + odp_cpumask_t mask1;
> +
> + /* check when there is no first */
> + odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU);
> + CU_ASSERT(odp_cpumask_first(&mask1) == -1);
> +
> + /* single CPU case: */
> + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0);
> + CU_ASSERT(odp_cpumask_first(&mask1) == 0);
> +
> + if (mask_capacity() < 4)
> + return;
> +
> + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_1_3);
> + CU_ASSERT(odp_cpumask_first(&mask1) == 1);
> +}
> +
> +void cpumask_test_odp_cpumask_last(void)
> +{
> + odp_cpumask_t mask1;
> +
> + /* check when there is no last: */
> + odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU);
> + CU_ASSERT(odp_cpumask_last(&mask1) == -1);
> +
> + /* single CPU case: */
> + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0);
> + CU_ASSERT(odp_cpumask_last(&mask1) == 0);
> +
> + if (mask_capacity() < 4)
> + return;
> +
> + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_1_3);
> + CU_ASSERT(odp_cpumask_last(&mask1) == 3);
> +}
> +
> +void cpumask_test_odp_cpumask_next(void)
> +{
> + unsigned int i;
> + int expected[] = {1, 3, 3, -1};
> + odp_cpumask_t mask1;
> +
> + /* case when the mask does not contain any CPU: */
> + odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU);
> + CU_ASSERT(odp_cpumask_next(&mask1, -1) == -1);
> +
> + /* case when the mask just contain CPU 0: */
> + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0);
> + CU_ASSERT(odp_cpumask_next(&mask1, -1) == 0);
> + CU_ASSERT(odp_cpumask_next(&mask1, 0) == -1);
> +
> + if (mask_capacity() < 4)
> + return;
> +
> + odp_cpumask_from_str(&mask1, TEST_MASK_CPU_1_3);
> +
> + for (i = 0; i < sizeof(expected) / sizeof(int); i++)
> + CU_ASSERT(odp_cpumask_next(&mask1, i) == expected[i]);
> +}
> +
> +void cpumask_test_odp_cpumask_setall(void)
> +{
> + int num_cpus;
> + int max_cpus = mask_capacity();
> + odp_cpumask_t mask;
> +
> + odp_cpumask_setall(&mask);
> + num_cpus = odp_cpumask_count(&mask);
> +
> + CU_ASSERT(num_cpus > 0);
> + CU_ASSERT(num_cpus >= max_cpus);
> +}
> diff --git a/test/validation/common/mask_common.h
> b/test/validation/common/mask_common.h
> new file mode 100644
> index 0000000..17cae45
> --- /dev/null
> +++ b/test/validation/common/mask_common.h
> @@ -0,0 +1,28 @@
> +/* Copyright (c) 2015, Linaro Limited
> + * All rights reserved.
> + *
> + * SPDX-License-Identifier: BSD-3-Clause
> + */
> +
> +#ifndef ODP_MASK_COMMON_H_
> +#define ODP_MASK_COMMON_H_
> +
> +unsigned mask_capacity(void);
> +
> +void cpumask_test_odp_cpumask_to_from_str(void);
> +void cpumask_test_odp_cpumask_equal(void);
> +void cpumask_test_odp_cpumask_zero(void);
> +void cpumask_test_odp_cpumask_set(void);
> +void cpumask_test_odp_cpumask_clr(void);
> +void cpumask_test_odp_cpumask_isset(void);
> +void cpumask_test_odp_cpumask_count(void);
> +void cpumask_test_odp_cpumask_and(void);
> +void cpumask_test_odp_cpumask_or(void);
> +void cpumask_test_odp_cpumask_xor(void);
> +void cpumask_test_odp_cpumask_copy(void);
> +void cpumask_test_odp_cpumask_first(void);
> +void cpumask_test_odp_cpumask_last(void);
> +void cpumask_test_odp_cpumask_next(void);
> +void cpumask_test_odp_cpumask_setall(void);
> +
> +#endif
> diff --git a/test/validation/cpumask/Makefile.am
> b/test/validation/cpumask/Makefile.am
> index 61b65ec..1cc1990 100644
> --- a/test/validation/cpumask/Makefile.am
> +++ b/test/validation/cpumask/Makefile.am
> @@ -5,4 +5,4 @@ libcpumask_a_SOURCES = cpumask.c
>
> bin_PROGRAMS = cpumask_main$(EXEEXT)
> dist_cpumask_main_SOURCES = cpumask_main.c
> -cpumask_main_LDADD = libcpumask.a $(LIBCUNIT_COMMON) $(LIBODP)
I think the contents of LIBCPUMASK_COMMON should be linked into libcpumask.a,
not only within the final binary:
So libcpumask.a should contain the all tests for cpumask (including common
ones).
Otherwise the lib looses its sense.
Is there any reason not to do so? (I haven't tryed and I know autotools are
nasty...)
Christophe.
> +cpumask_main_LDADD = libcpumask.a $(LIBCPUMASK_COMMON) $(LIBCUNIT_COMMON)
> $(LIBODP)
> diff --git a/test/validation/cpumask/cpumask.c
> b/test/validation/cpumask/cpumask.c
> index d72569e..76b7648 100644
> --- a/test/validation/cpumask/cpumask.c
> +++ b/test/validation/cpumask/cpumask.c
> @@ -5,475 +5,14 @@
> */
>
> #include <odp.h>
> +
> #include "odp_cunit_common.h"
> #include "cpumask.h"
> -
> -/*
> - * The following string are used to build cpu masks with
> - * odp_cpumask_from_str(). Both 0x prefixed and non prefixed
> - * hex values are supported by odp_cpumask_from_str()
> - */
> -#define TEST_MASK_NO_CPU "0x0"
> -#define TEST_MASK_CPU_0 "0x1"
> -#define TEST_MASK_CPU_1 "0x2"
> -#define TEST_MASK_CPU_2 "0x4"
> -#define TEST_MASK_CPU_0_2 "0x5"
> -#define TEST_MASK_CPU_0_3 "0x9"
> -#define TEST_MASK_CPU_1_2 "0x6"
> -#define TEST_MASK_CPU_1_3 "0xA"
> -#define TEST_MASK_CPU_0_1_2 "0x7"
> -#define TEST_MASK_CPU_0_2_4_6 "0x55"
> -#define TEST_MASK_CPU_1_2_4_6 "0x56"
> -
> -#define TEST_MASK_CPU_0_NO_PREFIX "1"
> -
> -/* padding pattern used to check buffer overflow: */
> -#define FILLING_PATTERN 0x55
> +#include "mask_common.h"
>
> /* default worker paramiter to get all that may be available */
> #define ALL_AVAILABLE 0
>
> -/*
> - * returns the length of a string, excluding terminating NULL.
> - * As its C lib strlen equivalent. Just rewritten here to avoid C lib
> - * dependency in ODP tests (for platform independent / bare metal testing)
> - */
> -static unsigned int stringlen(const char *str)
> -{
> - unsigned int i = 0;
> -
> - while (str[i] != 0)
> - i++;
> - return i;
> -}
> -
> -/*
> - * builds a string containing a 0x prefixed hex number
> - * where a single bit (corresponding to cpu) is set.
> - * The string is null terminated.
> - * cpu_to_str(0) returns "0x1".
> - * cpu_to_str(10) returns "0x400".
> - * The buffer should be at least ceil(cpu/4)+3 bytes long,
> - * to accommodate with 4 cpus per nibble + "0x" prefix + null.
> - */
> -#define CPUS_PER_NIBBLE 4
> -static void cpu_to_str(char *buff, int cpu)
> -{
> - const char *hex_nibble = "1248";
> - int i = 0;
> -
> - buff[i++] = '0';
> - buff[i++] = 'x';
> - buff[i++] = hex_nibble[cpu % CPUS_PER_NIBBLE];
> - while (cpu > 3) {
> - buff[i++] = '0';
> - cpu -= CPUS_PER_NIBBLE;
> - }
> - buff[i++] = 0; /* null */
> -}
> -
> -/*
> - * Returns the maximum number of CPUs that a mask can contain.
> - */
> -static unsigned mask_capacity(void)
> -{
> - odp_cpumask_t mask;
> -
> - odp_cpumask_setall(&mask);
> -
> - return odp_cpumask_count(&mask);
> -}
> -
> -static void cpumask_test_odp_cpumask_to_from_str(void)
> -{
> - odp_cpumask_t mask;
> - int32_t str_sz;
> - unsigned int buf_sz; /* buf size for the 2 following bufs */
> - char *buf_in;
> - char *buf_out;
> - unsigned int cpu;
> - unsigned int i;
> -
> - /* makes sure the mask has room for at least 1 CPU...: */
> - CU_ASSERT_FATAL(mask_capacity() > 0);
> -
> - /* allocate memory for the buffers containing the mask strings:
> - 1 char per nibble, i.e. 1 char per 4 cpus +extra for "0x" and null:*/
> - buf_sz = (mask_capacity() >> 2) + 20;
> - buf_in = malloc(buf_sz);
> - buf_out = malloc(buf_sz);
> - CU_ASSERT_FATAL(buf_in && buf_out);
> -
> - /* test 1 CPU at a time for all possible cpu positions in the mask */
> - for (cpu = 0; cpu < mask_capacity(); cpu++) {
> - /* init buffer for overwrite check: */
> - for (i = 0; i < buf_sz; i++)
> - buf_out[i] = FILLING_PATTERN;
> -
> - /* generate a hex string with that cpu set: */
> - cpu_to_str(buf_in, cpu);
> -
> - /* generate mask: */
> - odp_cpumask_from_str(&mask, buf_in);
> -
> - /* reverse cpu mask computation to get string back: */
> - str_sz = odp_cpumask_to_str(&mask, buf_out,
> - stringlen(buf_in) + 1);
> -
> - /* check that returned size matches original (with NULL): */
> - CU_ASSERT(str_sz == (int32_t)stringlen(buf_in) + 1);
> -
> - /* check that returned string matches original (with NULL): */
> - CU_ASSERT_NSTRING_EQUAL(buf_out, buf_in, stringlen(buf_in) + 1);
> -
> - /* check that no extra buffer writes occurred: */
> - CU_ASSERT(buf_out[stringlen(buf_in) + 2] == FILLING_PATTERN);
> - }
> -
> - /* re-init buffer for overwrite check: */
> - for (i = 0; i < buf_sz; i++)
> - buf_out[i] = FILLING_PATTERN;
> -
> - /* check for buffer overflow when too small buffer given: */
> - odp_cpumask_from_str(&mask, TEST_MASK_CPU_0);
> - str_sz = odp_cpumask_to_str(&mask, buf_out, stringlen(TEST_MASK_CPU_0));
> -
> - CU_ASSERT(str_sz == -1);
> -
> - for (i = 0; i < buf_sz; i++)
> - CU_ASSERT(buf_out[i] == FILLING_PATTERN);
> -
> - /* check for handling of missing "0x" prefix: */
> - odp_cpumask_from_str(&mask, TEST_MASK_CPU_0_NO_PREFIX);
> -
> - str_sz = odp_cpumask_to_str(&mask, buf_out,
> - stringlen(TEST_MASK_CPU_0) + 1);
> -
> - CU_ASSERT_NSTRING_EQUAL(buf_out, TEST_MASK_CPU_0,
> - stringlen(TEST_MASK_CPU_0) + 1);
> -
> - free(buf_out);
> - free(buf_in);
> -}
> -
> -static void cpumask_test_odp_cpumask_equal(void)
> -{
> - odp_cpumask_t mask1;
> - odp_cpumask_t mask2;
> - odp_cpumask_t mask3;
> -
> - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0);
> - odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0);
> - odp_cpumask_from_str(&mask3, TEST_MASK_NO_CPU);
> - CU_ASSERT(odp_cpumask_equal(&mask1, &mask2));
> - CU_ASSERT_FALSE(odp_cpumask_equal(&mask1, &mask3));
> -
> - if (mask_capacity() < 4)
> - return;
> -
> - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0_2);
> - odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0_2);
> - odp_cpumask_from_str(&mask3, TEST_MASK_CPU_1_2);
> - CU_ASSERT(odp_cpumask_equal(&mask1, &mask2));
> - CU_ASSERT_FALSE(odp_cpumask_equal(&mask1, &mask3));
> -
> - if (mask_capacity() < 8)
> - return;
> -
> - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0_2_4_6);
> - odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0_2_4_6);
> - odp_cpumask_from_str(&mask3, TEST_MASK_CPU_1_2_4_6);
> - CU_ASSERT(odp_cpumask_equal(&mask1, &mask2));
> - CU_ASSERT_FALSE(odp_cpumask_equal(&mask1, &mask3));
> -}
> -
> -static void cpumask_test_odp_cpumask_zero(void)
> -{
> - odp_cpumask_t mask1;
> - odp_cpumask_t mask2;
> -
> - odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU);
> - odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0);
> - odp_cpumask_zero(&mask2);
> - CU_ASSERT(odp_cpumask_equal(&mask1, &mask2));
> -}
> -
> -static void cpumask_test_odp_cpumask_set(void)
> -{
> - odp_cpumask_t mask1;
> - odp_cpumask_t mask2;
> -
> - odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU);
> - odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0);
> - odp_cpumask_set(&mask1, 0);
> - CU_ASSERT(odp_cpumask_equal(&mask1, &mask2));
> -
> - if (mask_capacity() < 4)
> - return;
> -
> - odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0_3);
> - odp_cpumask_set(&mask1, 3);
> - CU_ASSERT(odp_cpumask_equal(&mask1, &mask2));
> -
> - /* make sure that re-asserting a cpu has no impact: */
> - odp_cpumask_set(&mask1, 3);
> - CU_ASSERT(odp_cpumask_equal(&mask1, &mask2));
> -}
> -
> -static void cpumask_test_odp_cpumask_clr(void)
> -{
> - odp_cpumask_t mask1;
> - odp_cpumask_t mask2;
> -
> - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0);
> - odp_cpumask_from_str(&mask2, TEST_MASK_NO_CPU);
> - odp_cpumask_clr(&mask1, 0);
> - CU_ASSERT(odp_cpumask_equal(&mask1, &mask2));
> -
> - if (mask_capacity() < 4)
> - return;
> -
> - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0_2);
> - odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0);
> - odp_cpumask_clr(&mask1, 2);
> - CU_ASSERT(odp_cpumask_equal(&mask1, &mask2));
> -
> - odp_cpumask_from_str(&mask2, TEST_MASK_NO_CPU);
> - odp_cpumask_clr(&mask1, 0);
> - CU_ASSERT(odp_cpumask_equal(&mask1, &mask2));
> -
> - /* make sure that re-clearing a cpu has no impact: */
> - odp_cpumask_clr(&mask1, 0);
> - CU_ASSERT(odp_cpumask_equal(&mask1, &mask2));
> -}
> -
> -static void cpumask_test_odp_cpumask_isset(void)
> -{
> - odp_cpumask_t mask1;
> -
> - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0);
> - CU_ASSERT(odp_cpumask_isset(&mask1, 0));
> -
> - odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU);
> - CU_ASSERT_FALSE(odp_cpumask_isset(&mask1, 0));
> -
> - if (mask_capacity() < 4)
> - return;
> -
> - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0_2);
> - CU_ASSERT(odp_cpumask_isset(&mask1, 0));
> - CU_ASSERT_FALSE(odp_cpumask_isset(&mask1, 1));
> - CU_ASSERT(odp_cpumask_isset(&mask1, 2));
> - CU_ASSERT_FALSE(odp_cpumask_isset(&mask1, 3));
> -}
> -
> -static void cpumask_test_odp_cpumask_count(void)
> -{
> - odp_cpumask_t mask1;
> -
> - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0);
> - CU_ASSERT(odp_cpumask_count(&mask1) == 1);
> -
> - odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU);
> - CU_ASSERT(odp_cpumask_count(&mask1) == 0);
> -
> - if (mask_capacity() < 4)
> - return;
> -
> - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0_2);
> - CU_ASSERT(odp_cpumask_count(&mask1) == 2);
> -}
> -
> -static void cpumask_test_odp_cpumask_and(void)
> -{
> - odp_cpumask_t mask1;
> - odp_cpumask_t mask2;
> - odp_cpumask_t mask3;
> - odp_cpumask_t mask4;
> -
> - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0);
> - odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0);
> - odp_cpumask_from_str(&mask4, TEST_MASK_CPU_0);
> - odp_cpumask_and(&mask3, &mask1, &mask2);
> - CU_ASSERT(odp_cpumask_equal(&mask3, &mask4));
> -
> - odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU);
> - odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0);
> - odp_cpumask_from_str(&mask4, TEST_MASK_NO_CPU);
> - odp_cpumask_and(&mask3, &mask1, &mask2);
> - CU_ASSERT(odp_cpumask_equal(&mask3, &mask4));
> -
> - odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU);
> - odp_cpumask_from_str(&mask2, TEST_MASK_NO_CPU);
> - odp_cpumask_from_str(&mask4, TEST_MASK_NO_CPU);
> - odp_cpumask_and(&mask3, &mask1, &mask2);
> - CU_ASSERT(odp_cpumask_equal(&mask3, &mask4));
> -
> - if (mask_capacity() < 4)
> - return;
> -
> - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0_2);
> - odp_cpumask_from_str(&mask2, TEST_MASK_CPU_1_2);
> - odp_cpumask_from_str(&mask4, TEST_MASK_CPU_2);
> - odp_cpumask_and(&mask3, &mask1, &mask2);
> - CU_ASSERT(odp_cpumask_equal(&mask3, &mask4));
> -}
> -
> -static void cpumask_test_odp_cpumask_or(void)
> -{
> - odp_cpumask_t mask1;
> - odp_cpumask_t mask2;
> - odp_cpumask_t mask3;
> - odp_cpumask_t mask4;
> -
> - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0);
> - odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0);
> - odp_cpumask_from_str(&mask4, TEST_MASK_CPU_0);
> - odp_cpumask_or(&mask3, &mask1, &mask2);
> - CU_ASSERT(odp_cpumask_equal(&mask3, &mask4));
> -
> - odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU);
> - odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0);
> - odp_cpumask_from_str(&mask4, TEST_MASK_CPU_0);
> - odp_cpumask_or(&mask3, &mask1, &mask2);
> - CU_ASSERT(odp_cpumask_equal(&mask3, &mask4));
> -
> - odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU);
> - odp_cpumask_from_str(&mask2, TEST_MASK_NO_CPU);
> - odp_cpumask_from_str(&mask4, TEST_MASK_NO_CPU);
> - odp_cpumask_or(&mask3, &mask1, &mask2);
> - CU_ASSERT(odp_cpumask_equal(&mask3, &mask4));
> -
> - if (mask_capacity() < 4)
> - return;
> -
> - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0_2);
> - odp_cpumask_from_str(&mask2, TEST_MASK_CPU_1);
> - odp_cpumask_from_str(&mask4, TEST_MASK_CPU_0_1_2);
> - odp_cpumask_or(&mask3, &mask1, &mask2);
> - CU_ASSERT(odp_cpumask_equal(&mask3, &mask4));
> -}
> -
> -static void cpumask_test_odp_cpumask_xor(void)
> -{
> - odp_cpumask_t mask1;
> - odp_cpumask_t mask2;
> - odp_cpumask_t mask3;
> - odp_cpumask_t mask4;
> -
> - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0);
> - odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0);
> - odp_cpumask_from_str(&mask4, TEST_MASK_NO_CPU);
> - odp_cpumask_xor(&mask3, &mask1, &mask2);
> - CU_ASSERT(odp_cpumask_equal(&mask3, &mask4));
> -
> - odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU);
> - odp_cpumask_from_str(&mask2, TEST_MASK_CPU_0);
> - odp_cpumask_from_str(&mask4, TEST_MASK_CPU_0);
> - odp_cpumask_xor(&mask3, &mask1, &mask2);
> - CU_ASSERT(odp_cpumask_equal(&mask3, &mask4));
> -
> - odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU);
> - odp_cpumask_from_str(&mask2, TEST_MASK_NO_CPU);
> - odp_cpumask_from_str(&mask4, TEST_MASK_NO_CPU);
> - odp_cpumask_xor(&mask3, &mask1, &mask2);
> - CU_ASSERT(odp_cpumask_equal(&mask3, &mask4));
> -
> - if (mask_capacity() < 4)
> - return;
> -
> - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_2);
> - odp_cpumask_from_str(&mask2, TEST_MASK_CPU_1_2);
> - odp_cpumask_from_str(&mask4, TEST_MASK_CPU_1);
> - odp_cpumask_xor(&mask3, &mask1, &mask2);
> - CU_ASSERT(odp_cpumask_equal(&mask3, &mask4));
> -}
> -
> -static void cpumask_test_odp_cpumask_copy(void)
> -{
> - odp_cpumask_t mask1;
> - odp_cpumask_t mask2;
> -
> - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0);
> - odp_cpumask_copy(&mask2, &mask1);
> - CU_ASSERT(odp_cpumask_equal(&mask1, &mask2));
> -}
> -
> -static void cpumask_test_odp_cpumask_first(void)
> -{
> - odp_cpumask_t mask1;
> -
> - /* check when there is no first */
> - odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU);
> - CU_ASSERT(odp_cpumask_first(&mask1) == -1);
> -
> - /* single CPU case: */
> - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0);
> - CU_ASSERT(odp_cpumask_first(&mask1) == 0);
> -
> - if (mask_capacity() < 4)
> - return;
> -
> - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_1_3);
> - CU_ASSERT(odp_cpumask_first(&mask1) == 1);
> -}
> -
> -static void cpumask_test_odp_cpumask_last(void)
> -{
> - odp_cpumask_t mask1;
> -
> - /* check when there is no last: */
> - odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU);
> - CU_ASSERT(odp_cpumask_last(&mask1) == -1);
> -
> - /* single CPU case: */
> - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0);
> - CU_ASSERT(odp_cpumask_last(&mask1) == 0);
> -
> - if (mask_capacity() < 4)
> - return;
> -
> - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_1_3);
> - CU_ASSERT(odp_cpumask_last(&mask1) == 3);
> -}
> -
> -static void cpumask_test_odp_cpumask_next(void)
> -{
> - unsigned int i;
> - int expected[] = {1, 3, 3, -1};
> - odp_cpumask_t mask1;
> -
> - /* case when the mask does not contain any CPU: */
> - odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU);
> - CU_ASSERT(odp_cpumask_next(&mask1, -1) == -1);
> -
> - /* case when the mask just contain CPU 0: */
> - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0);
> - CU_ASSERT(odp_cpumask_next(&mask1, -1) == 0);
> - CU_ASSERT(odp_cpumask_next(&mask1, 0) == -1);
> -
> - if (mask_capacity() < 4)
> - return;
> -
> - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_1_3);
> -
> - for (i = 0; i < sizeof(expected) / sizeof(int); i++)
> - CU_ASSERT(odp_cpumask_next(&mask1, i) == expected[i]);
> -}
> -
> -static void cpumask_test_odp_cpumask_setall(void)
> -{
> - int num_cpus;
> - int max_cpus = mask_capacity();
> - odp_cpumask_t mask;
> -
> - odp_cpumask_setall(&mask);
> - num_cpus = odp_cpumask_count(&mask);
> -
> - CU_ASSERT(num_cpus > 0);
> - CU_ASSERT(num_cpus >= max_cpus);
> -}
> -
> static void cpumask_test_odp_cpumask_def_control(void)
> {
> unsigned num;
> --
> 2.1.1
>
> _______________________________________________
> lng-odp mailing list
> [email protected]
> https://lists.linaro.org/mailman/listinfo/lng-odp
_______________________________________________
lng-odp mailing list
[email protected]
https://lists.linaro.org/mailman/listinfo/lng-odp
