On 2015-07-21 14:32, Stuart Haslam wrote: > Refactor the cpumask tests a bit so that they may be reused to perform > the thrmask testing. > > Signed-off-by: Stuart Haslam <[email protected]>
Reviewed-by: Christophe Milard <[email protected]> > --- > test/validation/common/mask_common.c | 478 > +++++++++++++++++------------------ > test/validation/common/mask_common.h | 51 ++-- > test/validation/cpumask/cpumask.h | 5 + > 3 files changed, 280 insertions(+), 254 deletions(-) > > diff --git a/test/validation/common/mask_common.c > b/test/validation/common/mask_common.c > index e10b2fe..fce7725 100644 > --- a/test/validation/common/mask_common.c > +++ b/test/validation/common/mask_common.c > @@ -5,27 +5,27 @@ > */ > > #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() > + * The following strings are used to build masks with odp_*mask_from_str(). > + * Both 0x prefixed and non prefixed hex values are supported. > */ > -#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" > +#define TEST_MASK_NONE "0x0" > +#define TEST_MASK_0 "0x1" > +#define TEST_MASK_1 "0x2" > +#define TEST_MASK_2 "0x4" > +#define TEST_MASK_0_2 "0x5" > +#define TEST_MASK_0_3 "0x9" > +#define TEST_MASK_1_2 "0x6" > +#define TEST_MASK_1_3 "0xA" > +#define TEST_MASK_0_1_2 "0x7" > +#define TEST_MASK_0_2_4_6 "0x55" > +#define TEST_MASK_1_2_4_6 "0x56" > + > +#define TEST_MASK_0_NO_PREFIX "1" > > /* padding pattern used to check buffer overflow: */ > #define FILLING_PATTERN 0x55 > @@ -45,26 +45,26 @@ static unsigned int stringlen(const char *str) > } > > /* > - * builds a string containing a 0x prefixed hex number > - * where a single bit (corresponding to cpu) is set. > + * builds a string containing a 0x prefixed hex number where a single bit > + * (corresponding to a cpu or thread) 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. > + * bit_set_str(0) returns "0x1". > + * bit_set_str(10) returns "0x400". > + * The buffer should be at least ceil(offs/4)+3 bytes long, > + * to accommodate with 4 bits per nibble + "0x" prefix + null. > */ > -#define CPUS_PER_NIBBLE 4 > -static void cpu_to_str(char *buff, int cpu) > +#define BITS_PER_NIBBLE 4 > +static void bit_set_str(char *buff, int offs) > { > 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++] = hex_nibble[offs % BITS_PER_NIBBLE]; > + while (offs > 3) { > buff[i++] = '0'; > - cpu -= CPUS_PER_NIBBLE; > + offs -= BITS_PER_NIBBLE; > } > buff[i++] = 0; /* null */ > } > @@ -74,16 +74,16 @@ static void cpu_to_str(char *buff, int cpu) > */ > unsigned mask_capacity(void) > { > - odp_cpumask_t mask; > + _odp_mask_t mask; > > - odp_cpumask_setall(&mask); > + _odp_mask_setall(&mask); > > - return odp_cpumask_count(&mask); > + return _odp_mask_count(&mask); > } > > -void cpumask_test_odp_cpumask_to_from_str(void) > +MASK_TESTFUNC(to_from_str) > { > - odp_cpumask_t mask; > + _odp_mask_t mask; > int32_t str_sz; > unsigned int buf_sz; /* buf size for the 2 following bufs */ > char *buf_in; > @@ -108,14 +108,14 @@ void cpumask_test_odp_cpumask_to_from_str(void) > buf_out[i] = FILLING_PATTERN; > > /* generate a hex string with that cpu set: */ > - cpu_to_str(buf_in, cpu); > + bit_set_str(buf_in, cpu); > > /* generate mask: */ > - odp_cpumask_from_str(&mask, buf_in); > + _odp_mask_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); > + str_sz = _odp_mask_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); > @@ -132,8 +132,8 @@ void cpumask_test_odp_cpumask_to_from_str(void) > 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)); > + _odp_mask_from_str(&mask, TEST_MASK_0); > + str_sz = _odp_mask_to_str(&mask, buf_out, stringlen(TEST_MASK_0)); > > CU_ASSERT(str_sz == -1); > > @@ -141,332 +141,332 @@ void cpumask_test_odp_cpumask_to_from_str(void) > 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); > + _odp_mask_from_str(&mask, TEST_MASK_0_NO_PREFIX); > > - str_sz = odp_cpumask_to_str(&mask, buf_out, > - stringlen(TEST_MASK_CPU_0) + 1); > + str_sz = _odp_mask_to_str(&mask, buf_out, > + stringlen(TEST_MASK_0) + 1); > > - CU_ASSERT_NSTRING_EQUAL(buf_out, TEST_MASK_CPU_0, > - stringlen(TEST_MASK_CPU_0) + 1); > + CU_ASSERT_NSTRING_EQUAL(buf_out, TEST_MASK_0, > + stringlen(TEST_MASK_0) + 1); > > free(buf_out); > free(buf_in); > } > > -void cpumask_test_odp_cpumask_equal(void) > +MASK_TESTFUNC(equal) > { > - odp_cpumask_t mask1; > - odp_cpumask_t mask2; > - odp_cpumask_t mask3; > + _odp_mask_t mask1; > + _odp_mask_t mask2; > + _odp_mask_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)); > + _odp_mask_from_str(&mask1, TEST_MASK_0); > + _odp_mask_from_str(&mask2, TEST_MASK_0); > + _odp_mask_from_str(&mask3, TEST_MASK_NONE); > + CU_ASSERT(_odp_mask_equal(&mask1, &mask2)); > + CU_ASSERT_FALSE(_odp_mask_equal(&mask1, &mask3)); > > 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)); > + _odp_mask_from_str(&mask1, TEST_MASK_0_2); > + _odp_mask_from_str(&mask2, TEST_MASK_0_2); > + _odp_mask_from_str(&mask3, TEST_MASK_1_2); > + CU_ASSERT(_odp_mask_equal(&mask1, &mask2)); > + CU_ASSERT_FALSE(_odp_mask_equal(&mask1, &mask3)); > > 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)); > + _odp_mask_from_str(&mask1, TEST_MASK_0_2_4_6); > + _odp_mask_from_str(&mask2, TEST_MASK_0_2_4_6); > + _odp_mask_from_str(&mask3, TEST_MASK_1_2_4_6); > + CU_ASSERT(_odp_mask_equal(&mask1, &mask2)); > + CU_ASSERT_FALSE(_odp_mask_equal(&mask1, &mask3)); > } > > -void cpumask_test_odp_cpumask_zero(void) > +MASK_TESTFUNC(zero) > { > - odp_cpumask_t mask1; > - odp_cpumask_t mask2; > + _odp_mask_t mask1; > + _odp_mask_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)); > + _odp_mask_from_str(&mask1, TEST_MASK_NONE); > + _odp_mask_from_str(&mask2, TEST_MASK_0); > + _odp_mask_zero(&mask2); > + CU_ASSERT(_odp_mask_equal(&mask1, &mask2)); > } > > -void cpumask_test_odp_cpumask_set(void) > +MASK_TESTFUNC(set) > { > - odp_cpumask_t mask1; > - odp_cpumask_t mask2; > + _odp_mask_t mask1; > + _odp_mask_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)); > + _odp_mask_from_str(&mask1, TEST_MASK_NONE); > + _odp_mask_from_str(&mask2, TEST_MASK_0); > + _odp_mask_set(&mask1, 0); > + CU_ASSERT(_odp_mask_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)); > + _odp_mask_from_str(&mask2, TEST_MASK_0_3); > + _odp_mask_set(&mask1, 3); > + CU_ASSERT(_odp_mask_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)); > + _odp_mask_set(&mask1, 3); > + CU_ASSERT(_odp_mask_equal(&mask1, &mask2)); > } > > -void cpumask_test_odp_cpumask_clr(void) > +MASK_TESTFUNC(clr) > { > - odp_cpumask_t mask1; > - odp_cpumask_t mask2; > + _odp_mask_t mask1; > + _odp_mask_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)); > + _odp_mask_from_str(&mask1, TEST_MASK_0); > + _odp_mask_from_str(&mask2, TEST_MASK_NONE); > + _odp_mask_clr(&mask1, 0); > + CU_ASSERT(_odp_mask_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_mask_from_str(&mask1, TEST_MASK_0_2); > + _odp_mask_from_str(&mask2, TEST_MASK_0); > + _odp_mask_clr(&mask1, 2); > + CU_ASSERT(_odp_mask_equal(&mask1, &mask2)); > > - odp_cpumask_from_str(&mask2, TEST_MASK_NO_CPU); > - odp_cpumask_clr(&mask1, 0); > - CU_ASSERT(odp_cpumask_equal(&mask1, &mask2)); > + _odp_mask_from_str(&mask2, TEST_MASK_NONE); > + _odp_mask_clr(&mask1, 0); > + CU_ASSERT(_odp_mask_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)); > + _odp_mask_clr(&mask1, 0); > + CU_ASSERT(_odp_mask_equal(&mask1, &mask2)); > } > > -void cpumask_test_odp_cpumask_isset(void) > +MASK_TESTFUNC(isset) > { > - odp_cpumask_t mask1; > + _odp_mask_t mask1; > > - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0); > - CU_ASSERT(odp_cpumask_isset(&mask1, 0)); > + _odp_mask_from_str(&mask1, TEST_MASK_0); > + CU_ASSERT(_odp_mask_isset(&mask1, 0)); > > - odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU); > - CU_ASSERT_FALSE(odp_cpumask_isset(&mask1, 0)); > + _odp_mask_from_str(&mask1, TEST_MASK_NONE); > + CU_ASSERT_FALSE(_odp_mask_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)); > + _odp_mask_from_str(&mask1, TEST_MASK_0_2); > + CU_ASSERT(_odp_mask_isset(&mask1, 0)); > + CU_ASSERT_FALSE(_odp_mask_isset(&mask1, 1)); > + CU_ASSERT(_odp_mask_isset(&mask1, 2)); > + CU_ASSERT_FALSE(_odp_mask_isset(&mask1, 3)); > } > > -void cpumask_test_odp_cpumask_count(void) > +MASK_TESTFUNC(count) > { > - odp_cpumask_t mask1; > + _odp_mask_t mask1; > > - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0); > - CU_ASSERT(odp_cpumask_count(&mask1) == 1); > + _odp_mask_from_str(&mask1, TEST_MASK_0); > + CU_ASSERT(_odp_mask_count(&mask1) == 1); > > - odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU); > - CU_ASSERT(odp_cpumask_count(&mask1) == 0); > + _odp_mask_from_str(&mask1, TEST_MASK_NONE); > + CU_ASSERT(_odp_mask_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); > + _odp_mask_from_str(&mask1, TEST_MASK_0_2); > + CU_ASSERT(_odp_mask_count(&mask1) == 2); > } > > -void cpumask_test_odp_cpumask_and(void) > +MASK_TESTFUNC(and) > { > - 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)); > + _odp_mask_t mask1; > + _odp_mask_t mask2; > + _odp_mask_t mask3; > + _odp_mask_t mask4; > + > + _odp_mask_from_str(&mask1, TEST_MASK_0); > + _odp_mask_from_str(&mask2, TEST_MASK_0); > + _odp_mask_from_str(&mask4, TEST_MASK_0); > + _odp_mask_and(&mask3, &mask1, &mask2); > + CU_ASSERT(_odp_mask_equal(&mask3, &mask4)); > + > + _odp_mask_from_str(&mask1, TEST_MASK_NONE); > + _odp_mask_from_str(&mask2, TEST_MASK_0); > + _odp_mask_from_str(&mask4, TEST_MASK_NONE); > + _odp_mask_and(&mask3, &mask1, &mask2); > + CU_ASSERT(_odp_mask_equal(&mask3, &mask4)); > + > + _odp_mask_from_str(&mask1, TEST_MASK_NONE); > + _odp_mask_from_str(&mask2, TEST_MASK_NONE); > + _odp_mask_from_str(&mask4, TEST_MASK_NONE); > + _odp_mask_and(&mask3, &mask1, &mask2); > + CU_ASSERT(_odp_mask_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)); > + _odp_mask_from_str(&mask1, TEST_MASK_0_2); > + _odp_mask_from_str(&mask2, TEST_MASK_1_2); > + _odp_mask_from_str(&mask4, TEST_MASK_2); > + _odp_mask_and(&mask3, &mask1, &mask2); > + CU_ASSERT(_odp_mask_equal(&mask3, &mask4)); > } > > -void cpumask_test_odp_cpumask_or(void) > +MASK_TESTFUNC(or) > { > - 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)); > + _odp_mask_t mask1; > + _odp_mask_t mask2; > + _odp_mask_t mask3; > + _odp_mask_t mask4; > + > + _odp_mask_from_str(&mask1, TEST_MASK_0); > + _odp_mask_from_str(&mask2, TEST_MASK_0); > + _odp_mask_from_str(&mask4, TEST_MASK_0); > + _odp_mask_or(&mask3, &mask1, &mask2); > + CU_ASSERT(_odp_mask_equal(&mask3, &mask4)); > + > + _odp_mask_from_str(&mask1, TEST_MASK_NONE); > + _odp_mask_from_str(&mask2, TEST_MASK_0); > + _odp_mask_from_str(&mask4, TEST_MASK_0); > + _odp_mask_or(&mask3, &mask1, &mask2); > + CU_ASSERT(_odp_mask_equal(&mask3, &mask4)); > + > + _odp_mask_from_str(&mask1, TEST_MASK_NONE); > + _odp_mask_from_str(&mask2, TEST_MASK_NONE); > + _odp_mask_from_str(&mask4, TEST_MASK_NONE); > + _odp_mask_or(&mask3, &mask1, &mask2); > + CU_ASSERT(_odp_mask_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)); > + _odp_mask_from_str(&mask1, TEST_MASK_0_2); > + _odp_mask_from_str(&mask2, TEST_MASK_1); > + _odp_mask_from_str(&mask4, TEST_MASK_0_1_2); > + _odp_mask_or(&mask3, &mask1, &mask2); > + CU_ASSERT(_odp_mask_equal(&mask3, &mask4)); > } > > -void cpumask_test_odp_cpumask_xor(void) > +MASK_TESTFUNC(xor) > { > - 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)); > + _odp_mask_t mask1; > + _odp_mask_t mask2; > + _odp_mask_t mask3; > + _odp_mask_t mask4; > + > + _odp_mask_from_str(&mask1, TEST_MASK_0); > + _odp_mask_from_str(&mask2, TEST_MASK_0); > + _odp_mask_from_str(&mask4, TEST_MASK_NONE); > + _odp_mask_xor(&mask3, &mask1, &mask2); > + CU_ASSERT(_odp_mask_equal(&mask3, &mask4)); > + > + _odp_mask_from_str(&mask1, TEST_MASK_NONE); > + _odp_mask_from_str(&mask2, TEST_MASK_0); > + _odp_mask_from_str(&mask4, TEST_MASK_0); > + _odp_mask_xor(&mask3, &mask1, &mask2); > + CU_ASSERT(_odp_mask_equal(&mask3, &mask4)); > + > + _odp_mask_from_str(&mask1, TEST_MASK_NONE); > + _odp_mask_from_str(&mask2, TEST_MASK_NONE); > + _odp_mask_from_str(&mask4, TEST_MASK_NONE); > + _odp_mask_xor(&mask3, &mask1, &mask2); > + CU_ASSERT(_odp_mask_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)); > + _odp_mask_from_str(&mask1, TEST_MASK_2); > + _odp_mask_from_str(&mask2, TEST_MASK_1_2); > + _odp_mask_from_str(&mask4, TEST_MASK_1); > + _odp_mask_xor(&mask3, &mask1, &mask2); > + CU_ASSERT(_odp_mask_equal(&mask3, &mask4)); > } > > -void cpumask_test_odp_cpumask_copy(void) > +MASK_TESTFUNC(copy) > { > - odp_cpumask_t mask1; > - odp_cpumask_t mask2; > + _odp_mask_t mask1; > + _odp_mask_t mask2; > > - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0); > - odp_cpumask_copy(&mask2, &mask1); > - CU_ASSERT(odp_cpumask_equal(&mask1, &mask2)); > + _odp_mask_from_str(&mask1, TEST_MASK_0); > + _odp_mask_copy(&mask2, &mask1); > + CU_ASSERT(_odp_mask_equal(&mask1, &mask2)); > } > > -void cpumask_test_odp_cpumask_first(void) > +MASK_TESTFUNC(first) > { > - odp_cpumask_t mask1; > + _odp_mask_t mask1; > > /* check when there is no first */ > - odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU); > - CU_ASSERT(odp_cpumask_first(&mask1) == -1); > + _odp_mask_from_str(&mask1, TEST_MASK_NONE); > + CU_ASSERT(_odp_mask_first(&mask1) == -1); > > /* single CPU case: */ > - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0); > - CU_ASSERT(odp_cpumask_first(&mask1) == 0); > + _odp_mask_from_str(&mask1, TEST_MASK_0); > + CU_ASSERT(_odp_mask_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); > + _odp_mask_from_str(&mask1, TEST_MASK_1_3); > + CU_ASSERT(_odp_mask_first(&mask1) == 1); > } > > -void cpumask_test_odp_cpumask_last(void) > +MASK_TESTFUNC(last) > { > - odp_cpumask_t mask1; > + _odp_mask_t mask1; > > /* check when there is no last: */ > - odp_cpumask_from_str(&mask1, TEST_MASK_NO_CPU); > - CU_ASSERT(odp_cpumask_last(&mask1) == -1); > + _odp_mask_from_str(&mask1, TEST_MASK_NONE); > + CU_ASSERT(_odp_mask_last(&mask1) == -1); > > /* single CPU case: */ > - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_0); > - CU_ASSERT(odp_cpumask_last(&mask1) == 0); > + _odp_mask_from_str(&mask1, TEST_MASK_0); > + CU_ASSERT(_odp_mask_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); > + _odp_mask_from_str(&mask1, TEST_MASK_1_3); > + CU_ASSERT(_odp_mask_last(&mask1) == 3); > } > > -void cpumask_test_odp_cpumask_next(void) > +MASK_TESTFUNC(next) > { > unsigned int i; > int expected[] = {1, 3, 3, -1}; > - odp_cpumask_t mask1; > + _odp_mask_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); > + _odp_mask_from_str(&mask1, TEST_MASK_NONE); > + CU_ASSERT(_odp_mask_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); > + _odp_mask_from_str(&mask1, TEST_MASK_0); > + CU_ASSERT(_odp_mask_next(&mask1, -1) == 0); > + CU_ASSERT(_odp_mask_next(&mask1, 0) == -1); > > if (mask_capacity() < 4) > return; > > - odp_cpumask_from_str(&mask1, TEST_MASK_CPU_1_3); > + _odp_mask_from_str(&mask1, TEST_MASK_1_3); > > for (i = 0; i < sizeof(expected) / sizeof(int); i++) > - CU_ASSERT(odp_cpumask_next(&mask1, i) == expected[i]); > + CU_ASSERT(_odp_mask_next(&mask1, i) == expected[i]); > } > > -void cpumask_test_odp_cpumask_setall(void) > +MASK_TESTFUNC(setall) > { > - int num_cpus; > - int max_cpus = mask_capacity(); > - odp_cpumask_t mask; > + int num; > + int max = mask_capacity(); > + _odp_mask_t mask; > > - odp_cpumask_setall(&mask); > - num_cpus = odp_cpumask_count(&mask); > + _odp_mask_setall(&mask); > + num = _odp_mask_count(&mask); > > - CU_ASSERT(num_cpus > 0); > - CU_ASSERT(num_cpus >= max_cpus); > + CU_ASSERT(num > 0); > + CU_ASSERT(num <= max); > } > diff --git a/test/validation/common/mask_common.h > b/test/validation/common/mask_common.h > index 17cae45..7c3637e 100644 > --- a/test/validation/common/mask_common.h > +++ b/test/validation/common/mask_common.h > @@ -7,22 +7,43 @@ > #ifndef ODP_MASK_COMMON_H_ > #define ODP_MASK_COMMON_H_ > > +typedef odp_cpumask_t _odp_mask_t; > +#define MASK_API_PREFIX(n) odp_cpumask_##n > +#define MASK_TESTFUNC(n) void cpumask_test_odp_cpumask_ ## n(void) > + > +#define _odp_mask_from_str MASK_API_PREFIX(from_str) > +#define _odp_mask_to_str MASK_API_PREFIX(to_str) > +#define _odp_mask_equal MASK_API_PREFIX(equal) > +#define _odp_mask_zero MASK_API_PREFIX(zero) > +#define _odp_mask_set MASK_API_PREFIX(set) > +#define _odp_mask_clr MASK_API_PREFIX(clr) > +#define _odp_mask_isset MASK_API_PREFIX(isset) > +#define _odp_mask_count MASK_API_PREFIX(count) > +#define _odp_mask_and MASK_API_PREFIX(and) > +#define _odp_mask_or MASK_API_PREFIX(or) > +#define _odp_mask_xor MASK_API_PREFIX(xor) > +#define _odp_mask_copy MASK_API_PREFIX(copy) > +#define _odp_mask_first MASK_API_PREFIX(first) > +#define _odp_mask_next MASK_API_PREFIX(next) > +#define _odp_mask_last MASK_API_PREFIX(last) > +#define _odp_mask_setall MASK_API_PREFIX(setall) > + > 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); > +MASK_TESTFUNC(to_from_str); > +MASK_TESTFUNC(equal); > +MASK_TESTFUNC(zero); > +MASK_TESTFUNC(set); > +MASK_TESTFUNC(clr); > +MASK_TESTFUNC(isset); > +MASK_TESTFUNC(count); > +MASK_TESTFUNC(and); > +MASK_TESTFUNC(or); > +MASK_TESTFUNC(xor); > +MASK_TESTFUNC(copy); > +MASK_TESTFUNC(first); > +MASK_TESTFUNC(last); > +MASK_TESTFUNC(next); > +MASK_TESTFUNC(setall); > > #endif > diff --git a/test/validation/cpumask/cpumask.h > b/test/validation/cpumask/cpumask.h > index c0d19a9..cb9bc89 100644 > --- a/test/validation/cpumask/cpumask.h > +++ b/test/validation/cpumask/cpumask.h > @@ -4,4 +4,9 @@ > * SPDX-License-Identifier: BSD-3-Clause > */ > > +#ifndef _ODP_CPUMASK_TEST_H_ > +#define _ODP_CPUMASK_TEST_H_ > + > int cpumask_main(void); > + > +#endif > -- > 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
