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);
 }
 
 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
