testsuites/validation/tc-task-set-priority.c

2 files changed, 269 insertions, 44 deletions

diff --git a/spec/build/testsuites/validation/validation-one-cpu-0.yml b/spec/build/testsuites/validation/validation-one-cpu-0.yml
index e4eea8cf15..5cb2d20636 100644
--- a/spec/build/testsuites/validation/validation-one-cpu-0.yml
+++ b/spec/build/testsuites/validation/validation-one-cpu-0.yml
@@ -22,6 +22,7 @@ source:
 - testsuites/validation/tc-task-create-errors.c
 - testsuites/validation/tc-task-mode.c
 - testsuites/validation/tc-task-set-affinity.c
+- testsuites/validation/tc-task-set-priority.c
 - testsuites/validation/tc-task-wake-after.c
 - testsuites/validation/ts-validation-one-cpu-0.c
 stlib: []
diff --git a/testsuites/validation/tc-task-set-priority.c b/testsuites/validation/tc-task-set-priority.c
index 27578a5b65..fbcc0f6b43 100644
--- a/testsuites/validation/tc-task-set-priority.c
+++ b/testsuites/validation/tc-task-set-priority.c
@@ -63,6 +63,7 @@
  *   spec:/rtems/task/req/set-priority
  *
  * @ingroup RTEMSTestSuiteTestsuitesValidation0
+ * @ingroup RTEMSTestSuiteTestsuitesValidationOneCpu0
  *
  * @{
  */
@@ -74,13 +75,28 @@ typedef enum {
 } RtemsTaskReqSetPriority_Pre_Id;
 
 typedef enum {
+  RtemsTaskReqSetPriority_Pre_State_Dormant,
+  RtemsTaskReqSetPriority_Pre_State_Ready,
+  RtemsTaskReqSetPriority_Pre_State_Scheduled,
+  RtemsTaskReqSetPriority_Pre_State_Blocked,
+  RtemsTaskReqSetPriority_Pre_State_NA
+} RtemsTaskReqSetPriority_Pre_State;
+
+typedef enum {
   RtemsTaskReqSetPriority_Pre_NewPriority_Current,
-  RtemsTaskReqSetPriority_Pre_NewPriority_Valid,
-  RtemsTaskReqSetPriority_Pre_NewPriority_Invalid,
+  RtemsTaskReqSetPriority_Pre_NewPriority_Other,
   RtemsTaskReqSetPriority_Pre_NewPriority_NA
 } RtemsTaskReqSetPriority_Pre_NewPriority;
 
 typedef enum {
+  RtemsTaskReqSetPriority_Pre_TaskPriority_High,
+  RtemsTaskReqSetPriority_Pre_TaskPriority_Equal,
+  RtemsTaskReqSetPriority_Pre_TaskPriority_Low,
+  RtemsTaskReqSetPriority_Pre_TaskPriority_Invalid,
+  RtemsTaskReqSetPriority_Pre_TaskPriority_NA
+} RtemsTaskReqSetPriority_Pre_TaskPriority;
+
+typedef enum {
   RtemsTaskReqSetPriority_Pre_OldPriority_Valid,
   RtemsTaskReqSetPriority_Pre_OldPriority_Null,
   RtemsTaskReqSetPriority_Pre_OldPriority_NA
@@ -109,7 +125,9 @@ typedef enum {
 typedef struct {
   uint16_t Skip : 1;
   uint16_t Pre_Id_NA : 1;
+  uint16_t Pre_State_NA : 1;
   uint16_t Pre_NewPriority_NA : 1;
+  uint16_t Pre_TaskPriority_NA : 1;
   uint16_t Pre_OldPriority_NA : 1;
   uint16_t Post_Status : 3;
   uint16_t Post_Priority : 2;
@@ -126,6 +144,16 @@ typedef struct {
   rtems_id worker_id;
 
   /**
+   * @brief If this member is true, then the task shall be started.
+   */
+  bool started;
+
+  /**
+   * @brief If this member is true, then the task shall be blocked.
+   */
+  bool blocked;
+
+  /**
    * @brief This member provides the object referenced by the ``old_priority``
    *   parameter.
    */
@@ -157,12 +185,12 @@ typedef struct {
      * @brief This member defines the pre-condition indices for the next
      *   action.
      */
-    size_t pci[ 3 ];
+    size_t pci[ 5 ];
 
     /**
      * @brief This member defines the pre-condition states for the next action.
      */
-    size_t pcs[ 3 ];
+    size_t pcs[ 5 ];
 
     /**
      * @brief If this member is true, then the test action loop is executed.
@@ -196,9 +224,24 @@ static const char * const RtemsTaskReqSetPriority_PreDesc_Id[] = {
   "NA"
 };
 
+static const char * const RtemsTaskReqSetPriority_PreDesc_State[] = {
+  "Dormant",
+  "Ready",
+  "Scheduled",
+  "Blocked",
+  "NA"
+};
+
 static const char * const RtemsTaskReqSetPriority_PreDesc_NewPriority[] = {
   "Current",
-  "Valid",
+  "Other",
+  "NA"
+};
+
+static const char * const RtemsTaskReqSetPriority_PreDesc_TaskPriority[] = {
+  "High",
+  "Equal",
+  "Low",
   "Invalid",
   "NA"
 };
@@ -211,11 +254,19 @@ static const char * const RtemsTaskReqSetPriority_PreDesc_OldPriority[] = {
 
 static const char * const * const RtemsTaskReqSetPriority_PreDesc[] = {
   RtemsTaskReqSetPriority_PreDesc_Id,
+  RtemsTaskReqSetPriority_PreDesc_State,
   RtemsTaskReqSetPriority_PreDesc_NewPriority,
+  RtemsTaskReqSetPriority_PreDesc_TaskPriority,
   RtemsTaskReqSetPriority_PreDesc_OldPriority,
   NULL
 };
 
+static void Worker( rtems_task_argument arg )
+{
+  (void) ReceiveAnyEvents();
+  (void) ReceiveAnyEvents();
+}
+
 static void RtemsTaskReqSetPriority_Pre_Id_Prepare(
   RtemsTaskReqSetPriority_Context *ctx,
   RtemsTaskReqSetPriority_Pre_Id   state
@@ -243,6 +294,52 @@ static void RtemsTaskReqSetPriority_Pre_Id_Prepare(
   }
 }
 
+static void RtemsTaskReqSetPriority_Pre_State_Prepare(
+  RtemsTaskReqSetPriority_Context  *ctx,
+  RtemsTaskReqSetPriority_Pre_State state
+)
+{
+  switch ( state ) {
+    case RtemsTaskReqSetPriority_Pre_State_Dormant: {
+      /*
+       * While the task specified by the ``id`` parameter is dormant.
+       */
+      ctx->started = false;
+      break;
+    }
+
+    case RtemsTaskReqSetPriority_Pre_State_Ready: {
+      /*
+       * While the task specified by the ``id`` parameter is ready.
+       */
+      ctx->started = true;
+      ctx->blocked = false;
+      break;
+    }
+
+    case RtemsTaskReqSetPriority_Pre_State_Scheduled: {
+      /*
+       * While the task specified by the ``id`` parameter is scheduled.
+       */
+      ctx->started = false;
+      ctx->id = rtems_task_self();
+      break;
+    }
+
+    case RtemsTaskReqSetPriority_Pre_State_Blocked: {
+      /*
+       * While the task specified by the ``id`` parameter is blocked.
+       */
+      ctx->started = true;
+      ctx->blocked = true;
+      break;
+    }
+
+    case RtemsTaskReqSetPriority_Pre_State_NA:
+      break;
+  }
+}
+
 static void RtemsTaskReqSetPriority_Pre_NewPriority_Prepare(
   RtemsTaskReqSetPriority_Context        *ctx,
   RtemsTaskReqSetPriority_Pre_NewPriority state
@@ -258,31 +355,76 @@ static void RtemsTaskReqSetPriority_Pre_NewPriority_Prepare(
       break;
     }
 
-    case RtemsTaskReqSetPriority_Pre_NewPriority_Valid: {
+    case RtemsTaskReqSetPriority_Pre_NewPriority_Other: {
       /*
        * While the value of the ``new_priority`` parameter is not equal to
-       * RTEMS_CURRENT_PRIORITY, while the value of the ``new_priority``
-       * parameter is a valid task priority with respect to the home scheduler
-       * of the task specified by the ``id`` parameter at some point during the
-       * rtems_task_set_priority() call.
+       * RTEMS_CURRENT_PRIORITY.
+       */
+      ctx->new_priority = PRIO_NORMAL;
+      break;
+    }
+
+    case RtemsTaskReqSetPriority_Pre_NewPriority_NA:
+      break;
+  }
+}
+
+static void RtemsTaskReqSetPriority_Pre_TaskPriority_Prepare(
+  RtemsTaskReqSetPriority_Context         *ctx,
+  RtemsTaskReqSetPriority_Pre_TaskPriority state
+)
+{
+  switch ( state ) {
+    case RtemsTaskReqSetPriority_Pre_TaskPriority_High: {
+      /*
+       * While the value of the ``new_priority`` parameter is a valid task
+       * priority with respect to the home scheduler of the task specified by
+       * the ``id`` parameter when the new priority is set, while the value of
+       * the ``new_priority`` parameter is higher than the task priority with
+       * respect to the home scheduler of the task specified by the ``id``
+       * parameter at time when the scheduler evaluates the new priority.
        */
       ctx->new_priority = PRIO_HIGH;
       break;
     }
 
-    case RtemsTaskReqSetPriority_Pre_NewPriority_Invalid: {
+    case RtemsTaskReqSetPriority_Pre_TaskPriority_Equal: {
       /*
-       * While the value of the ``new_priority`` parameter is not equal to
-       * RTEMS_CURRENT_PRIORITY, while the value of the ``new_priority``
-       * parameter is an invalid task priority with respect to the home
-       * scheduler of the task specified by the ``id`` parameter at some point
-       * during the rtems_task_set_priority() call.
+       * While the value of the ``new_priority`` parameter is a valid task
+       * priority with respect to the home scheduler of the task specified by
+       * the ``id`` parameter when the new priority is set, while the value of
+       * the ``new_priority`` parameter is equal to the task priority with
+       * respect to the home scheduler of the task specified by the ``id``
+       * parameter at time when the scheduler evaluates the new priority.
+       */
+      ctx->new_priority = PRIO_NORMAL;
+      break;
+    }
+
+    case RtemsTaskReqSetPriority_Pre_TaskPriority_Low: {
+      /*
+       * While the value of the ``new_priority`` parameter is a valid task
+       * priority with respect to the home scheduler of the task specified by
+       * the ``id`` parameter when the new priority is set, while the value of
+       * the ``new_priority`` parameter is lower than the task priority with
+       * respect to the home scheduler of the task specified by the ``id``
+       * parameter at time when the scheduler evaluates the new priority.
+       */
+      ctx->new_priority = PRIO_LOW;
+      break;
+    }
+
+    case RtemsTaskReqSetPriority_Pre_TaskPriority_Invalid: {
+      /*
+       * While the value of the ``new_priority`` parameter is an invalid task
+       * priority with respect to the home scheduler of the task specified by
+       * the ``id`` parameter when the new priority is evaluated.
        */
       ctx->new_priority = PRIO_INVALID;
       break;
     }
 
-    case RtemsTaskReqSetPriority_Pre_NewPriority_NA:
+    case RtemsTaskReqSetPriority_Pre_TaskPriority_NA:
       break;
   }
 }
@@ -374,7 +516,7 @@ static void RtemsTaskReqSetPriority_Post_Priority_Check(
        * be set to the value specified by the ``new_priority`` parameter at
        * some point during the rtems_task_set_priority() call.
        */
-      T_eq_u32( GetPriority( ctx->worker_id ), PRIO_HIGH );
+      T_eq_u32( GetPriority( ctx->id ), ctx->new_priority );
       break;
     }
 
@@ -383,7 +525,7 @@ static void RtemsTaskReqSetPriority_Post_Priority_Check(
        * No real priority of a task shall be modified by the
        * rtems_task_set_priority() call.
        */
-      T_eq_u32( GetPriority( ctx->worker_id ), PRIO_LOW );
+      T_eq_u32( GetPriority( ctx->worker_id ), PRIO_NORMAL );
       break;
     }
 
@@ -406,7 +548,7 @@ static void RtemsTaskReqSetPriority_Post_OldPriorityObj_Check(
        * some point during the call and before the real priority is modified by
        * the call if it is modified by the call.
        */
-      T_eq_u32( ctx->old_priority_obj, PRIO_LOW );
+      T_eq_u32( ctx->old_priority_obj, PRIO_NORMAL );
       break;
     }
 
@@ -425,22 +567,75 @@ static void RtemsTaskReqSetPriority_Post_OldPriorityObj_Check(
   }
 }
 
+static void RtemsTaskReqSetPriority_Setup(
+  RtemsTaskReqSetPriority_Context *ctx
+)
+{
+  SetSelfPriority( PRIO_ULTRA_HIGH );
+}
+
+static void RtemsTaskReqSetPriority_Setup_Wrap( void *arg )
+{
+  RtemsTaskReqSetPriority_Context *ctx;
+
+  ctx = arg;
+  ctx->Map.in_action_loop = false;
+  RtemsTaskReqSetPriority_Setup( ctx );
+}
+
+static void RtemsTaskReqSetPriority_Teardown(
+  RtemsTaskReqSetPriority_Context *ctx
+)
+{
+  RestoreRunnerPriority();
+}
+
+static void RtemsTaskReqSetPriority_Teardown_Wrap( void *arg )
+{
+  RtemsTaskReqSetPriority_Context *ctx;
+
+  ctx = arg;
+  ctx->Map.in_action_loop = false;
+  RtemsTaskReqSetPriority_Teardown( ctx );
+}
+
 static void RtemsTaskReqSetPriority_Prepare(
   RtemsTaskReqSetPriority_Context *ctx
 )
 {
-  ctx->old_priority_obj = PRIO_INVALID; ctx->worker_id = CreateTask( "WORK", PRIO_LOW );
+  ctx->old_priority_obj = PRIO_INVALID;
+  ctx->worker_id = CreateTask( "WORK", PRIO_NORMAL );
+  ctx->started = false;
+  ctx->blocked = false;
 }
 
 static void RtemsTaskReqSetPriority_Action(
   RtemsTaskReqSetPriority_Context *ctx
 )
 {
+  if ( ctx->started ) {
+    SetSelfPriority( PRIO_ULTRA_HIGH );
+    StartTask( ctx->worker_id, Worker, NULL );
+
+    if ( ctx->blocked ) {
+      SetSelfPriority( PRIO_ULTRA_LOW );
+      SetSelfPriority( PRIO_ULTRA_HIGH );
+    }
+  } else {
+    SetSelfPriority( PRIO_NORMAL );
+  }
+
   ctx->status = rtems_task_set_priority(
     ctx->id,
     ctx->new_priority,
     ctx->old_priority
   );
+
+  if ( ctx->started ) {
+    SendEvents( ctx->worker_id, RTEMS_EVENT_0 );
+    SetSelfPriority( PRIO_ULTRA_LOW );
+    SetSelfPriority( PRIO_ULTRA_HIGH );
+  }
 }
 
 static void RtemsTaskReqSetPriority_Cleanup(
@@ -452,29 +647,36 @@ static void RtemsTaskReqSetPriority_Cleanup(
 
 static const RtemsTaskReqSetPriority_Entry
 RtemsTaskReqSetPriority_Entries[] = {
-  { 0, 0, 0, 0, RtemsTaskReqSetPriority_Post_Status_InvId,
+  { 0, 0, 1, 0, 1, 0, RtemsTaskReqSetPriority_Post_Status_InvId,
     RtemsTaskReqSetPriority_Post_Priority_Nop,
     RtemsTaskReqSetPriority_Post_OldPriorityObj_Nop },
-  { 0, 0, 1, 0, RtemsTaskReqSetPriority_Post_Status_InvAddr,
+  { 0, 0, 1, 0, 1, 0, RtemsTaskReqSetPriority_Post_Status_InvAddr,
     RtemsTaskReqSetPriority_Post_Priority_Nop,
     RtemsTaskReqSetPriority_Post_OldPriorityObj_Nop },
-  { 0, 0, 0, 0, RtemsTaskReqSetPriority_Post_Status_InvAddr,
+  { 0, 0, 0, 0, 1, 0, RtemsTaskReqSetPriority_Post_Status_Ok,
+    RtemsTaskReqSetPriority_Post_Priority_Nop,
+    RtemsTaskReqSetPriority_Post_OldPriorityObj_Set },
+  { 0, 0, 0, 0, 1, 0, RtemsTaskReqSetPriority_Post_Status_InvAddr,
     RtemsTaskReqSetPriority_Post_Priority_Nop,
     RtemsTaskReqSetPriority_Post_OldPriorityObj_Nop },
-  { 0, 0, 0, 0, RtemsTaskReqSetPriority_Post_Status_Ok,
+  { 0, 0, 0, 0, 0, 0, RtemsTaskReqSetPriority_Post_Status_InvAddr,
     RtemsTaskReqSetPriority_Post_Priority_Nop,
-    RtemsTaskReqSetPriority_Post_OldPriorityObj_Set },
-  { 0, 0, 0, 0, RtemsTaskReqSetPriority_Post_Status_Ok,
+    RtemsTaskReqSetPriority_Post_OldPriorityObj_Nop },
+  { 0, 0, 0, 0, 0, 0, RtemsTaskReqSetPriority_Post_Status_Ok,
     RtemsTaskReqSetPriority_Post_Priority_Set,
     RtemsTaskReqSetPriority_Post_OldPriorityObj_Set },
-  { 0, 0, 0, 0, RtemsTaskReqSetPriority_Post_Status_InvPrio,
+  { 0, 0, 0, 0, 0, 0, RtemsTaskReqSetPriority_Post_Status_InvPrio,
     RtemsTaskReqSetPriority_Post_Priority_Nop,
     RtemsTaskReqSetPriority_Post_OldPriorityObj_Set }
 };
 
 static const uint8_t
 RtemsTaskReqSetPriority_Map[] = {
-  0, 1, 0, 1, 0, 1, 3, 2, 4, 2, 5, 2
+  0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,
+  0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,
+  0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 2, 3, 2, 3, 2, 3, 2, 3, 5, 4, 5, 4, 5, 4,
+  6, 4, 2, 3, 2, 3, 2, 3, 2, 3, 5, 4, 5, 4, 5, 4, 6, 4, 2, 3, 2, 3, 2, 3, 2, 3,
+  5, 4, 5, 4, 5, 4, 6, 4, 2, 3, 2, 3, 2, 3, 2, 3, 5, 4, 5, 4, 5, 4, 6, 4
 };
 
 static size_t RtemsTaskReqSetPriority_Scope( void *arg, char *buf, size_t n )
@@ -496,9 +698,9 @@ static size_t RtemsTaskReqSetPriority_Scope( void *arg, char *buf, size_t n )
 }
 
 static T_fixture RtemsTaskReqSetPriority_Fixture = {
-  .setup = NULL,
+  .setup = RtemsTaskReqSetPriority_Setup_Wrap,
   .stop = NULL,
-  .teardown = NULL,
+  .teardown = RtemsTaskReqSetPriority_Teardown_Wrap,
   .scope = RtemsTaskReqSetPriority_Scope,
   .initial_context = &RtemsTaskReqSetPriority_Instance
 };
@@ -522,13 +724,21 @@ static void RtemsTaskReqSetPriority_SetPreConditionStates(
 {
   ctx->Map.pcs[ 0 ] = ctx->Map.pci[ 0 ];
 
-  if ( ctx->Map.entry.Pre_NewPriority_NA ) {
-    ctx->Map.pcs[ 1 ] = RtemsTaskReqSetPriority_Pre_NewPriority_NA;
+  if ( ctx->Map.entry.Pre_State_NA ) {
+    ctx->Map.pcs[ 1 ] = RtemsTaskReqSetPriority_Pre_State_NA;
   } else {
     ctx->Map.pcs[ 1 ] = ctx->Map.pci[ 1 ];
   }
 
   ctx->Map.pcs[ 2 ] = ctx->Map.pci[ 2 ];
+
+  if ( ctx->Map.entry.Pre_TaskPriority_NA ) {
+    ctx->Map.pcs[ 3 ] = RtemsTaskReqSetPriority_Pre_TaskPriority_NA;
+  } else {
+    ctx->Map.pcs[ 3 ] = ctx->Map.pci[ 3 ];
+  }
+
+  ctx->Map.pcs[ 4 ] = ctx->Map.pci[ 4 ];
 }
 
 static void RtemsTaskReqSetPriority_TestVariant(
@@ -536,8 +746,10 @@ static void RtemsTaskReqSetPriority_TestVariant(
 )
 {
   RtemsTaskReqSetPriority_Pre_Id_Prepare( ctx, ctx->Map.pcs[ 0 ] );
-  RtemsTaskReqSetPriority_Pre_NewPriority_Prepare( ctx, ctx->Map.pcs[ 1 ] );
-  RtemsTaskReqSetPriority_Pre_OldPriority_Prepare( ctx, ctx->Map.pcs[ 2 ] );
+  RtemsTaskReqSetPriority_Pre_State_Prepare( ctx, ctx->Map.pcs[ 1 ] );
+  RtemsTaskReqSetPriority_Pre_NewPriority_Prepare( ctx, ctx->Map.pcs[ 2 ] );
+  RtemsTaskReqSetPriority_Pre_TaskPriority_Prepare( ctx, ctx->Map.pcs[ 3 ] );
+  RtemsTaskReqSetPriority_Pre_OldPriority_Prepare( ctx, ctx->Map.pcs[ 4 ] );
   RtemsTaskReqSetPriority_Action( ctx );
   RtemsTaskReqSetPriority_Post_Status_Check( ctx, ctx->Map.entry.Post_Status );
   RtemsTaskReqSetPriority_Post_Priority_Check(
@@ -570,20 +782,32 @@ T_TEST_CASE_FIXTURE(
     ++ctx->Map.pci[ 0 ]
   ) {
     for (
-      ctx->Map.pci[ 1 ] = RtemsTaskReqSetPriority_Pre_NewPriority_Current;
-      ctx->Map.pci[ 1 ] < RtemsTaskReqSetPriority_Pre_NewPriority_NA;
+      ctx->Map.pci[ 1 ] = RtemsTaskReqSetPriority_Pre_State_Dormant;
+      ctx->Map.pci[ 1 ] < RtemsTaskReqSetPriority_Pre_State_NA;
       ++ctx->Map.pci[ 1 ]
     ) {
       for (
-        ctx->Map.pci[ 2 ] = RtemsTaskReqSetPriority_Pre_OldPriority_Valid;
-        ctx->Map.pci[ 2 ] < RtemsTaskReqSetPriority_Pre_OldPriority_NA;
+        ctx->Map.pci[ 2 ] = RtemsTaskReqSetPriority_Pre_NewPriority_Current;
+        ctx->Map.pci[ 2 ] < RtemsTaskReqSetPriority_Pre_NewPriority_NA;
         ++ctx->Map.pci[ 2 ]
       ) {
-        ctx->Map.entry = RtemsTaskReqSetPriority_PopEntry( ctx );
-        RtemsTaskReqSetPriority_SetPreConditionStates( ctx );
-        RtemsTaskReqSetPriority_Prepare( ctx );
-        RtemsTaskReqSetPriority_TestVariant( ctx );
-        RtemsTaskReqSetPriority_Cleanup( ctx );
+        for (
+          ctx->Map.pci[ 3 ] = RtemsTaskReqSetPriority_Pre_TaskPriority_High;
+          ctx->Map.pci[ 3 ] < RtemsTaskReqSetPriority_Pre_TaskPriority_NA;
+          ++ctx->Map.pci[ 3 ]
+        ) {
+          for (
+            ctx->Map.pci[ 4 ] = RtemsTaskReqSetPriority_Pre_OldPriority_Valid;
+            ctx->Map.pci[ 4 ] < RtemsTaskReqSetPriority_Pre_OldPriority_NA;
+            ++ctx->Map.pci[ 4 ]
+          ) {
+            ctx->Map.entry = RtemsTaskReqSetPriority_PopEntry( ctx );
+            RtemsTaskReqSetPriority_SetPreConditionStates( ctx );
+            RtemsTaskReqSetPriority_Prepare( ctx );
+            RtemsTaskReqSetPriority_TestVariant( ctx );
+            RtemsTaskReqSetPriority_Cleanup( ctx );
+          }
+        }
       }
     }
   }