@@ -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
@@ -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);
}
@@ -7,22 +7,44 @@
#ifndef ODP_MASK_COMMON_H_
#define ODP_MASK_COMMON_H_
+#include "cpumask.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
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.h | 6 + test/validation/cpumask/mask_common.c | 478 +++++++++++++++++----------------- test/validation/cpumask/mask_common.h | 52 ++-- 3 files changed, 282 insertions(+), 254 deletions(-)