[API-NEXT,3/6] validation: refactor cpumask tests

Refactor the cpumask tests a bit so that they may be resused to perform
the thrmask testing.

Signed-off-by: Stuart Haslam <stuart.haslam@linaro.org>
---
 test/validation/cpumask/cpumask.c     |   8 +-
 test/validation/cpumask/cpumask.h     |   6 +
 test/validation/cpumask/mask_common.c | 521 +++++++++++++++++-----------------
 test/validation/cpumask/mask_common.h |  55 ++--
 4 files changed, 309 insertions(+), 281 deletions(-)

On 13 July 2015 at 13:53, Stuart Haslam <stuart.haslam@linaro.org> wrote:

> Refactor the cpumask tests a bit so that they may be resused to perform
> the thrmask testing.
>
> Signed-off-by: Stuart Haslam <stuart.haslam@linaro.org>
> ---
>  test/validation/cpumask/cpumask.c     |   8 +-
>  test/validation/cpumask/cpumask.h     |   6 +
>  test/validation/cpumask/mask_common.c | 521
> +++++++++++++++++-----------------
>  test/validation/cpumask/mask_common.h |  55 ++--
>  4 files changed, 309 insertions(+), 281 deletions(-)
>
> diff --git a/test/validation/cpumask/cpumask.c
> b/test/validation/cpumask/cpumask.c
> index c86a6ee..0f5cd78 100644
> --- a/test/validation/cpumask/cpumask.c
> +++ b/test/validation/cpumask/cpumask.c
> @@ -16,7 +16,7 @@
>  static void cpumask_test_odp_cpumask_def_control(void)
>  {
>         int num;
> -       int max_cpus = get_max_number_of_cpus_in_a_mask();
> +       int max_cpus = mask_capacity();
>         odp_cpumask_t mask;
>
>         num = odp_cpumask_def_control(&mask, ALL_AVAILABLE);
> @@ -28,7 +28,7 @@ static void cpumask_test_odp_cpumask_def_control(void)
>  static void cpumask_test_odp_cpumask_def_worker(void)
>  {
>         int num;
> -       int max_cpus = get_max_number_of_cpus_in_a_mask();
> +       int max_cpus = mask_capacity();
>         odp_cpumask_t mask;
>
>         num = odp_cpumask_def_worker(&mask, ALL_AVAILABLE);
> @@ -41,13 +41,13 @@ static void cpumask_test_odp_cpumask_def(void)
>  {
>         int num_worker;
>         int num_control;
> -       int max_cpus = get_max_number_of_cpus_in_a_mask();
> +       int max_cpus = mask_capacity();
>         odp_cpumask_t mask;
>
>         num_worker = odp_cpumask_def_worker(&mask, max_cpus - 1);
>         num_control = odp_cpumask_def_control(&mask, 1);
>
> -       CU_ASSERT((num_control + num_worker) == max_cpus);
> +       CU_ASSERT((num_control + num_worker) <= max_cpus);
>

Bug fix should be its own patch describing why it is needed


>  }
>
>  static CU_TestInfo cpumask_suite[] = {
> diff --git a/test/validation/cpumask/cpumask.h
> b/test/validation/cpumask/cpumask.h
> index c0d19a9..d24ea06 100644
> --- a/test/validation/cpumask/cpumask.h
> +++ b/test/validation/cpumask/cpumask.h
> @@ -4,4 +4,10 @@
>   * SPDX-License-Identifier:     BSD-3-Clause
>   */
>
> +#ifndef _ODP_CPUMASK_TEST_H_
> +#define _ODP_CPUMASK_TEST_H_
> +
> +unsigned max_supported_num_in_mask(void);
>  int cpumask_main(void);
> +
> +#endif
> diff --git a/test/validation/cpumask/mask_common.c
> b/test/validation/cpumask/mask_common.c
> index 0ed38ff..a2b0386 100644
> --- a/test/validation/cpumask/mask_common.c
> +++ b/test/validation/cpumask/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,43 +45,42 @@ 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 */
>  }
>
> -/*
> - * returns the mask size to be tested...
> - * There is a bit of confusion right now about how to get this,
> - * so this is centralized here... in case of change...
> - */
> -unsigned int get_max_number_of_cpus_in_a_mask(void)
> +unsigned mask_capacity(void)
>  {
> -       return odp_cpu_count();
> +       _odp_mask_t mask;
> +
> +       _odp_mask_setall(&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;
> @@ -90,30 +89,30 @@ void cpumask_test_odp_cpumask_to_from_str(void)
>         unsigned int i;
>
>         /* makes sure the mask has room for at least 1 CPU...: */
> -       CU_ASSERT_FATAL(get_max_number_of_cpus_in_a_mask() > 0);
> +       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 = (get_max_number_of_cpus_in_a_mask() >> 2) + 20;
> +       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 < get_max_number_of_cpus_in_a_mask(); cpu++) {
> +       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);
> +               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);
> @@ -130,8 +129,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);
>
> @@ -139,332 +138,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 (get_max_number_of_cpus_in_a_mask() < 4)
> +       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 (get_max_number_of_cpus_in_a_mask() < 8)
> +       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 (get_max_number_of_cpus_in_a_mask() < 4)
> +       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 (get_max_number_of_cpus_in_a_mask() < 4)
> +       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 (get_max_number_of_cpus_in_a_mask() < 4)
> +       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 (get_max_number_of_cpus_in_a_mask() < 4)
> +       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));
> -
> -       if (get_max_number_of_cpus_in_a_mask() < 4)
> +       _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));
> -
> -       if (get_max_number_of_cpus_in_a_mask() < 4)
> +       _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));
> -
> -       if (get_max_number_of_cpus_in_a_mask() < 4)
> +       _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 (get_max_number_of_cpus_in_a_mask() < 4)
> +       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 (get_max_number_of_cpus_in_a_mask() < 4)
> +       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 (get_max_number_of_cpus_in_a_mask() < 4)
> +       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 = get_max_number_of_cpus_in_a_mask();
> -       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/cpumask/mask_common.h
> b/test/validation/cpumask/mask_common.h
> index 49062b5..a8c6ba7 100644
> --- a/test/validation/cpumask/mask_common.h
> +++ b/test/validation/cpumask/mask_common.h
> @@ -7,22 +7,45 @@
>  #ifndef ODP_MASK_COMMON_H_
>  #define ODP_MASK_COMMON_H_
>
> -unsigned int get_max_number_of_cpus_in_a_mask(void);
> +#include "cpumask.h"
>
> -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);
> +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);
> +
> +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
> --
> 2.1.1
>
> _______________________________________________
> lng-odp mailing list
> lng-odp@lists.linaro.org
> https://lists.linaro.org/mailman/listinfo/lng-odp
>

On 07/14/15 18:03, Mike Holmes wrote:
>
>     @@ -41,13 +41,13 @@ static void cpumask_test_odp_cpumask_def(void)
>      {
>             int num_worker;
>             int num_control;
>     -       int max_cpus = get_max_number_of_cpus_in_a_mask();
>     +       int max_cpus = mask_capacity();
>             odp_cpumask_t mask;
>
>             num_worker = odp_cpumask_def_worker(&mask, max_cpus - 1);
>             num_control = odp_cpumask_def_control(&mask, 1);
>
>     -       CU_ASSERT((num_control + num_worker) == max_cpus);
>     +       CU_ASSERT((num_control + num_worker) <= max_cpus);
>
>
> Bug fix should be its own patch describing why it is needed

Agree with Mike.

Also you can add checks that:
num_worker > 0
num_control == 1

And add comment that on some platforms num_workers and num_controls 
might be limited, so that
we can not expect that (num_control + num_worker) == max_cpus.


Thanks,
Maxim.