On Wed, Jul 22, 2015 at 11:06:00AM +0200, Christophe Milard wrote: > 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. >
OK I'll change this (and in libthread.a) and send a new version. -- Stuart. _______________________________________________ lng-odp mailing list [email protected] https://lists.linaro.org/mailman/listinfo/lng-odp
