Cygwin: testsuite: Fix for limited thread priority values

Since commit 4b51e4c1, we return the actual thread priority, not what we
originally stored in the thread attributes.

Windows only supports 7 thread priority levels, which we map onto the 32
required by POSIX.  So, only a subset of values will be returned exactly
by by pthread_getschedparam() after pthread_setschedparam().

Adjust tests priority1, priority2 and inherit1 so they only check for
round-tripping priority values which can be exactly represented.

For CI, this needs to handle process priority class "below normal
priority" as well.

Also check that the range of priority values is at least 32, as required
by POSIX.

Signed-off-by: Jon Turney <jon.turney@dronecode.org.uk>

3 files changed, 62 insertions, 5 deletions

diff --git a/winsup/testsuite/winsup.api/pthread/inherit1.c b/winsup/testsuite/winsup.api/pthread/inherit1.c
index 16c3f53..f036462 100644
--- a/winsup/testsuite/winsup.api/pthread/inherit1.c
+++ b/winsup/testsuite/winsup.api/pthread/inherit1.c
@@ -50,6 +50,23 @@ void * func(void * arg)
   return (void *) (size_t)param.sched_priority;
 }
 
+// Windows only supports 7 thread priority levels, which we map onto the 32
+// required by POSIX.  The exact mapping also depends on the overall process
+// priority class. So only a subset of values will be returned exactly by
+// pthread_getschedparam() after pthread_setschedparam().
+int doable_pri(int pri)
+{
+  switch (GetPriorityClass(GetCurrentProcess()))
+    {
+    case BELOW_NORMAL_PRIORITY_CLASS:
+      return (pri == 2) || (pri ==  8) || (pri == 10) || (pri == 12) || (pri == 14) || (pri == 16) || (pri == 30);
+    case NORMAL_PRIORITY_CLASS:
+      return (pri == 2) || (pri == 12) || (pri == 14) || (pri == 16) || (pri == 18) || (pri == 20) || (pri == 30);
+    }
+
+  return TRUE;
+}
+
 int
 main()
 {
@@ -81,7 +98,9 @@ main()
       assert(pthread_setschedparam(mainThread, SCHED_FIFO, &mainParam) == 0);
       assert(pthread_getschedparam(mainThread, &policy, &mainParam) == 0);
       assert(policy == SCHED_FIFO);
-      assert(mainParam.sched_priority == prio);
+
+      if (doable_pri(prio))
+        assert(mainParam.sched_priority == prio);
 
       for (param.sched_priority = prio;
            param.sched_priority <= maxPrio;
diff --git a/winsup/testsuite/winsup.api/pthread/priority1.c b/winsup/testsuite/winsup.api/pthread/priority1.c
index a1e8d05..135f77d 100644
--- a/winsup/testsuite/winsup.api/pthread/priority1.c
+++ b/winsup/testsuite/winsup.api/pthread/priority1.c
@@ -50,7 +50,24 @@ void * func(void * arg)
   assert(policy == SCHED_FIFO);
   return (void *)(size_t)param.sched_priority;
 }
- 
+
+// Windows only supports 7 thread priority levels, which we map onto the 32
+// required by POSIX.  The exact mapping also depends on the overall process
+// priority class. So only a subset of values will be returned exactly by
+// pthread_getschedparam() after pthread_setschedparam().
+int doable_pri(int pri)
+{
+  switch (GetPriorityClass(GetCurrentProcess()))
+    {
+    case BELOW_NORMAL_PRIORITY_CLASS:
+      return (pri == 2) || (pri ==  8) || (pri == 10) || (pri == 12) || (pri == 14) || (pri == 16) || (pri == 30);
+    case NORMAL_PRIORITY_CLASS:
+      return (pri == 2) || (pri == 12) || (pri == 14) || (pri == 16) || (pri == 18) || (pri == 20) || (pri == 30);
+    }
+
+  return TRUE;
+}
+
 int
 main()
 {
@@ -61,6 +78,8 @@ main()
   int maxPrio = sched_get_priority_max(SCHED_FIFO);
   int minPrio = sched_get_priority_min(SCHED_FIFO);
 
+  assert((maxPrio - minPrio) >= 31);
+
   assert(pthread_attr_init(&attr) == 0);
   assert(pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED) == 0);
 
@@ -71,7 +90,8 @@ main()
       assert(pthread_attr_setschedparam(&attr, &param) == 0);
       assert(pthread_create(&t, &attr, func, NULL) == 0);
       pthread_join(t, &result);
-      assert((int)(size_t) result == param.sched_priority);
+      if (doable_pri(param.sched_priority))
+	assert((int)(size_t) result == param.sched_priority);
     }
 
   return 0;
diff --git a/winsup/testsuite/winsup.api/pthread/priority2.c b/winsup/testsuite/winsup.api/pthread/priority2.c
index 0534e7b..f084efa 100644
--- a/winsup/testsuite/winsup.api/pthread/priority2.c
+++ b/winsup/testsuite/winsup.api/pthread/priority2.c
@@ -54,7 +54,24 @@ void * func(void * arg)
   assert(policy == SCHED_FIFO);
   return (void *) (size_t)param.sched_priority;
 }
- 
+
+// Windows only supports 7 thread priority levels, which we map onto the 32
+// required by POSIX.  The exact mapping also depends on the overall process
+// priority class. So only a subset of values will be returned exactly by
+// pthread_getschedparam() after pthread_setschedparam().
+int doable_pri(int pri)
+{
+  switch (GetPriorityClass(GetCurrentProcess()))
+    {
+    case BELOW_NORMAL_PRIORITY_CLASS:
+      return (pri == 2) || (pri ==  8) || (pri == 10) || (pri == 12) || (pri == 14) || (pri == 16) || (pri == 30);
+    case NORMAL_PRIORITY_CLASS:
+      return (pri == 2) || (pri == 12) || (pri == 14) || (pri == 16) || (pri == 18) || (pri == 20) || (pri == 30);
+    }
+
+  return TRUE;
+}
+
 int
 main()
 {
@@ -73,7 +90,8 @@ main()
       assert(pthread_setschedparam(t, SCHED_FIFO, &param) == 0);
       assert(pthread_mutex_unlock(&startMx) == 0);
       pthread_join(t, &result);
-      assert((int)(size_t)result == param.sched_priority);
+      if (doable_pri(param.sched_priority))
+	assert((int)(size_t)result == param.sched_priority);
     }
 
   return 0;