LXR 6.1/​testsuites/​validation/​tr-tq-timeout-priority-inherit.c	Source navigation Diff markup Identifier search General search
	Version: 6.1 Revert   Change

File indexing completed on 2025-05-11 08:24:53

 /* SPDX-License-Identifier: BSD-2-Clause */
 
 /**
  * @file
  *
  * @ingroup ScoreTqReqTimeoutPriorityInherit
  */
 
 /*
  * Copyright (C) 2021 embedded brains GmbH & Co. KG
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
 /*
  * This file is part of the RTEMS quality process and was automatically
  * generated.  If you find something that needs to be fixed or
  * worded better please post a report or patch to an RTEMS mailing list
  * or raise a bug report:
  *
  * https://www.rtems.org/bugs.html
  *
  * For information on updating and regenerating please refer to the How-To
  * section in the Software Requirements Engineering chapter of the
  * RTEMS Software Engineering manual.  The manual is provided as a part of
  * a release.  For development sources please refer to the online
  * documentation at:
  *
  * https://docs.rtems.org
  */
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #include <rtems/score/smpimpl.h>
 #include <rtems/score/threadimpl.h>
 
 #include "tr-tq-timeout-priority-inherit.h"
 #include "tx-support.h"
 
 #include <rtems/test.h>
 
 /**
  * @defgroup ScoreTqReqTimeoutPriorityInherit \
  *   spec:/score/tq/req/timeout-priority-inherit
  *
  * @ingroup TestsuitesValidationNoClock0
  *
  * @{
  */
 
 typedef struct {
   uint32_t Skip : 1;
   uint32_t Pre_HomeScheduler_NA : 1;
   uint32_t Pre_EligibleScheduler_NA : 1;
   uint32_t Pre_Queue_NA : 1;
   uint32_t Pre_OwnerPriority_NA : 1;
   uint32_t Pre_OwnerState_NA : 1;
   uint32_t Pre_OwnerQueue_NA : 1;
   uint32_t Pre_OwnerOwnerPriority_NA : 1;
   uint32_t Pre_WaitState_NA : 1;
   uint32_t Post_Status : 2;
   uint32_t Post_Unblock : 2;
   uint32_t Post_OwnerPriority : 2;
   uint32_t Post_OwnerOwnerPriority : 2;
 } ScoreTqReqTimeoutPriorityInherit_Entry;
 
 /**
  * @brief Test context for spec:/score/tq/req/timeout-priority-inherit test
  *   case.
  */
 typedef struct {
   /**
    * @brief This member contains the call within ISR request.
    */
   CallWithinISRRequest request;
 
   /**
    * @brief This member specifies the scheduler of the thread.
    */
   rtems_id scheduler_id;
 
   /**
    * @brief If this member is true, then the thread shall have at least two
    *   eligible scheduler.
    */
   bool other_scheduler;
 
   /**
    * @brief This member specifies the queue node kind.
    */
   TQNodeKind queue_node;
 
   /**
    * @brief This member specifies the owner priority node kind.
    */
   TQNodeKind owner_node;
 
   /**
    * @brief This member specifies which mutex obtain event shall be used to
    *   block the thread queue owner.
    */
   rtems_event_set owner_obtain;
 
   /**
    * @brief This member specifies which mutex release event shall be used to
    *   unblock the thread queue owner.
    */
   rtems_event_set owner_release;
 
   /**
    * @brief This member specifies the owner queue node kind.
    */
   TQNodeKind owner_queue_node;
 
   /**
    * @brief This member specifies the kind of the priority node of the owner of
    *   the thread queue on which the owner of the thread queue is blocked.
    */
   TQNodeKind owner_owner_node;
 
   /**
    * @brief This member specifies the wait state.
    */
   TQWaitState wait_state;
 
   /**
    * @brief This member contains the thread queue priority.
    */
   rtems_task_priority queue_priority;
 
   /**
    * @brief This member contains the owner priority.
    */
   rtems_task_priority owner_priority;
 
   /**
    * @brief This member contains the owner priority after the timeout or
    *   surrender.
    */
   rtems_task_priority owner_priority_after;
 
   /**
    * @brief This member contains the priority of the thread queue on which the
    *   owner is enqueued.
    */
   rtems_task_priority owner_queue_priority;
 
   /**
    * @brief This member contains the priority of the owner of the thread queue
    *   on which the owner is enqueued.
    */
   rtems_task_priority owner_owner_priority;
 
   /**
    * @brief This member contains the priority after the timeout or surrender of
    *   the owner of the thread queue on which the owner is enqueued.
    */
   rtems_task_priority owner_owner_priority_after;
 
   /**
    * @brief If this member is true, then the queue helper shall surrender the
    *   thread queue.
    */
   bool queue_helper_surrender;
 
   /**
    * @brief If this member is true, then the owner helper shall release mutex
    *   A.
    */
   bool owner_helper_release;
 
   /**
    * @brief If this member is true, then the owner queue helper shall release
    *   the mutex on which the owner is blocked.
    */
   bool owner_queue_helper_release;
 
   /**
    * @brief If this member is true, then helper of the owner of the mutex which
    *   the owner blocked shall release mutex B.
    */
   bool owner_owner_helper_release;
 
   /**
    * @brief This member contains a copy of the corresponding
    *   ScoreTqReqTimeoutPriorityInherit_Run() parameter.
    */
   TQContext *tq_ctx;
 
   struct {
     /**
      * @brief This member defines the pre-condition indices for the next
      *   action.
      */
     size_t pci[ 8 ];
 
     /**
      * @brief This member defines the pre-condition states for the next action.
      */
     size_t pcs[ 8 ];
 
     /**
      * @brief If this member is true, then the test action loop is executed.
      */
     bool in_action_loop;
 
     /**
      * @brief This member contains the next transition map index.
      */
     size_t index;
 
     /**
      * @brief This member contains the current transition map entry.
      */
     ScoreTqReqTimeoutPriorityInherit_Entry entry;
 
     /**
      * @brief If this member is true, then the current transition variant
      *   should be skipped.
      */
     bool skip;
   } Map;
 } ScoreTqReqTimeoutPriorityInherit_Context;
 
 static ScoreTqReqTimeoutPriorityInherit_Context
   ScoreTqReqTimeoutPriorityInherit_Instance;
 
 static const char * const ScoreTqReqTimeoutPriorityInherit_PreDesc_HomeScheduler[] = {
   "Home",
   "Helping",
   "NA"
 };
 
 static const char * const ScoreTqReqTimeoutPriorityInherit_PreDesc_EligibleScheduler[] = {
   "One",
   "More",
   "NA"
 };
 
 static const char * const ScoreTqReqTimeoutPriorityInherit_PreDesc_Queue[] = {
   "Only",
   "Vital",
   "Dispensable",
   "NA"
 };
 
 static const char * const ScoreTqReqTimeoutPriorityInherit_PreDesc_OwnerPriority[] = {
   "Only",
   "Vital",
   "Dispensable",
   "NA"
 };
 
 static const char * const ScoreTqReqTimeoutPriorityInherit_PreDesc_OwnerState[] = {
   "NotEnqueued",
   "FIFO",
   "Priority",
   "PriorityInherit",
   "NA"
 };
 
 static const char * const ScoreTqReqTimeoutPriorityInherit_PreDesc_OwnerQueue[] = {
   "Only",
   "Vital",
   "Dispensable",
   "NA"
 };
 
 static const char * const ScoreTqReqTimeoutPriorityInherit_PreDesc_OwnerOwnerPriority[] = {
   "Only",
   "Vital",
   "Dispensable",
   "NA"
 };
 
 static const char * const ScoreTqReqTimeoutPriorityInherit_PreDesc_WaitState[] = {
   "Blocked",
   "IntendToBlock",
   "ReadyAgain",
   "NA"
 };
 
 static const char * const * const ScoreTqReqTimeoutPriorityInherit_PreDesc[] = {
   ScoreTqReqTimeoutPriorityInherit_PreDesc_HomeScheduler,
   ScoreTqReqTimeoutPriorityInherit_PreDesc_EligibleScheduler,
   ScoreTqReqTimeoutPriorityInherit_PreDesc_Queue,
   ScoreTqReqTimeoutPriorityInherit_PreDesc_OwnerPriority,
   ScoreTqReqTimeoutPriorityInherit_PreDesc_OwnerState,
   ScoreTqReqTimeoutPriorityInherit_PreDesc_OwnerQueue,
   ScoreTqReqTimeoutPriorityInherit_PreDesc_OwnerOwnerPriority,
   ScoreTqReqTimeoutPriorityInherit_PreDesc_WaitState,
   NULL
 };
 
 typedef ScoreTqReqTimeoutPriorityInherit_Context Context;
 
 #define THREAD TQ_BLOCKER_A
 
 #define THREAD_HELPER_A TQ_HELPER_B
 
 #define THREAD_HELPER_B TQ_HELPER_C
 
 #define QUEUE_HELPER TQ_BLOCKER_B
 
 #define OWNER TQ_BLOCKER_C
 
 #define OWNER_HELPER TQ_BLOCKER_D
 
 #define OWNER_QUEUE_HELPER TQ_BLOCKER_E
 
 #define OWNER_OWNER TQ_WORKER_F
 
 #define OWNER_OWNER_HELPER TQ_HELPER_A
 
 static bool GetUnblock( const Context *ctx, size_t *index )
 {
   while ( true ) {
     const T_scheduler_event *event;
 
     event = TQGetNextUnblock( ctx->tq_ctx, index );
 
     if ( event == &T_scheduler_event_null ) {
       return false;
     }
 
     if ( event->thread == ctx->tq_ctx->worker_tcb[ THREAD ] ) {
       return true;
     }
   }
 }
 
 static void Tick( void *arg )
 {
   Context *ctx;
 
   ctx = arg;
   TQSchedulerRecordStart( ctx->tq_ctx );
   FinalClockTick();
   TQSchedulerRecordStop( ctx->tq_ctx );
 }
 
 static void SchedulerBlock(
   void                    *arg,
   const T_scheduler_event *event,
   T_scheduler_when         when
 )
 {
   Context *ctx;
 
   ctx = arg;
 
   if (
     when == T_SCHEDULER_BEFORE &&
     event->operation == T_SCHEDULER_BLOCK &&
     event->thread == ctx->tq_ctx->worker_tcb[ THREAD ]
   ) {
     T_scheduler_set_event_handler( NULL, NULL );
     ctx->request.handler = Tick;
     CallWithinISRSubmit( &ctx->request );
   }
 }
 
 static void ThreadTimeout( void *arg )
 {
   Context *ctx;
 
   ctx = arg;
   TQSchedulerRecordStart( ctx->tq_ctx );
   _Thread_Timeout(
     &ctx->tq_ctx->worker_tcb[ THREAD ]->Timer.Watchdog
   );
   TQSchedulerRecordStop( ctx->tq_ctx );
 }
 
 static void SchedulerUnblock(
   void                    *arg,
   const T_scheduler_event *event,
   T_scheduler_when         when
 )
 {
   Context *ctx;
 
   ctx = arg;
 
   if (
     when == T_SCHEDULER_BEFORE &&
     event->operation == T_SCHEDULER_UNBLOCK &&
     event->thread == ctx->tq_ctx->worker_tcb[ THREAD ]
   ) {
     T_scheduler_set_event_handler( NULL, NULL );
 
     if ( ctx->scheduler_id == SCHEDULER_B_ID ) {
 #if defined(RTEMS_SMP)
       _SMP_Unicast_action( 1, ThreadTimeout, ctx );
 #else
       T_unreachable();
 #endif
     } else {
       ctx->request.handler = ThreadTimeout;
       CallWithinISRSubmit( &ctx->request );
     }
   }
 }
 
 static void GetPriorities( Context *ctx )
 {
   ctx->owner_priority_after = GetPriorityByScheduler(
     ctx->tq_ctx->worker_id[ OWNER ],
     ctx->scheduler_id
   );
   ctx->owner_owner_priority_after = GetPriorityByScheduler(
     ctx->tq_ctx->worker_id[ OWNER_OWNER ],
     ctx->scheduler_id
   );
 }
 
 static void PrepareThread( const Context *ctx )
 {
   if ( ctx->other_scheduler ) {
     rtems_id other_scheduler_id;
 
     if ( ctx->scheduler_id == SCHEDULER_A_ID ) {
       other_scheduler_id = SCHEDULER_B_ID;
     } else {
       other_scheduler_id = SCHEDULER_B_ID;
     }
 
     TQSendAndWaitForExecutionStop(
       ctx->tq_ctx,
       THREAD,
       TQ_EVENT_MUTEX_D_OBTAIN
     );
 
     TQSetScheduler(
       ctx->tq_ctx,
       THREAD_HELPER_A,
       other_scheduler_id,
       PRIO_NEARLY_IDLE - 1
     );
     TQSendAndWaitForExecutionStop(
       ctx->tq_ctx,
       THREAD_HELPER_A,
       TQ_EVENT_MUTEX_D_OBTAIN
     );
 
     if ( rtems_scheduler_get_processor_maximum() >= 3 ) {
       TQSetScheduler(
         ctx->tq_ctx,
         THREAD_HELPER_B,
         SCHEDULER_C_ID,
         PRIO_NORMAL
       );
       TQSendAndWaitForExecutionStop(
         ctx->tq_ctx,
         THREAD_HELPER_B,
         TQ_EVENT_MUTEX_D_OBTAIN
       );
     }
   }
 }
 
 static rtems_task_priority PrepareQueue(
   Context            *ctx,
   rtems_task_priority priority
 )
 {
   switch ( ctx->queue_node ) {
     case TQ_NODE_ONLY:
       ctx->queue_helper_surrender = false;
       break;
     case TQ_NODE_VITAL:
       ctx->queue_helper_surrender = true;
       TQSetScheduler(
         ctx->tq_ctx,
         QUEUE_HELPER,
         ctx->scheduler_id,
         priority + 1
       );
       TQSendAndWaitForExecutionStop(
         ctx->tq_ctx,
         QUEUE_HELPER,
         TQ_EVENT_ENQUEUE
       );
       break;
     case TQ_NODE_DISPENSABLE:
       ctx->queue_helper_surrender = true;
       --priority;
       TQSetScheduler(
         ctx->tq_ctx,
         QUEUE_HELPER,
         ctx->scheduler_id,
         priority
       );
       TQSendAndWaitForExecutionStop(
         ctx->tq_ctx,
         QUEUE_HELPER,
         TQ_EVENT_ENQUEUE
       );
       break;
   }
 
   ctx->queue_priority = priority;
 
   return priority;
 }
 
 static rtems_task_priority PrepareOwner(
   Context            *ctx,
   rtems_task_priority priority
 )
 {
   switch ( ctx->owner_node ) {
     case TQ_NODE_ONLY:
       ctx->owner_helper_release = false;
       TQSetPriority( ctx->tq_ctx, OWNER, PRIO_FLEXIBLE );
       break;
     case TQ_NODE_VITAL:
       if ( ctx->scheduler_id == SCHEDULER_A_ID ) {
         ctx->owner_helper_release = false;
         TQSetPriority( ctx->tq_ctx, OWNER, priority + 1 );
       } else {
         ctx->owner_helper_release = true;
         TQSetPriority( ctx->tq_ctx, OWNER, PRIO_FLEXIBLE );
         TQSetScheduler(
           ctx->tq_ctx,
           OWNER_HELPER,
           ctx->scheduler_id,
           priority + 1
         );
         TQSendAndWaitForExecutionStop(
           ctx->tq_ctx,
           OWNER_HELPER,
           TQ_EVENT_MUTEX_A_OBTAIN
         );
       }
       break;
     case TQ_NODE_DISPENSABLE:
       --priority;
 
       if ( ctx->scheduler_id == SCHEDULER_A_ID ) {
         ctx->owner_helper_release = false;
         TQSetPriority( ctx->tq_ctx, OWNER, priority );
       } else {
         ctx->owner_helper_release = true;
         TQSetPriority( ctx->tq_ctx, OWNER, PRIO_FLEXIBLE );
         TQSetScheduler(
           ctx->tq_ctx,
           OWNER_HELPER,
           ctx->scheduler_id,
           priority
         );
         TQSendAndWaitForExecutionStop(
           ctx->tq_ctx,
           OWNER_HELPER,
           TQ_EVENT_MUTEX_A_OBTAIN
         );
       }
       break;
   }
 
   ctx->owner_priority = priority;
 
   return priority;
 }
 
 static rtems_task_priority PrepareOwnerQueue(
   Context            *ctx,
   rtems_task_priority priority
 )
 {
   if ( ctx->owner_obtain != 0 ) {
     switch ( ctx->owner_queue_node ) {
       case TQ_NODE_ONLY:
         ctx->owner_queue_helper_release = false;
         break;
       case TQ_NODE_VITAL:
         ctx->owner_queue_helper_release = true;
         TQSetScheduler(
           ctx->tq_ctx,
           OWNER_QUEUE_HELPER,
           ctx->scheduler_id,
           priority + 1
         );
         TQSendAndWaitForExecutionStop(
           ctx->tq_ctx,
           OWNER_QUEUE_HELPER,
           ctx->owner_obtain
         );
         break;
       case TQ_NODE_DISPENSABLE:
         ctx->owner_queue_helper_release = true;
         --priority;
         TQSetScheduler(
           ctx->tq_ctx,
           OWNER_QUEUE_HELPER,
           ctx->scheduler_id,
           priority
         );
         TQSendAndWaitForExecutionStop(
           ctx->tq_ctx,
           OWNER_QUEUE_HELPER,
           ctx->owner_obtain
         );
         break;
     }
 
     ctx->owner_queue_priority = priority;
   } else {
     ctx->owner_queue_helper_release = false;
     ctx->owner_queue_priority = PRIO_INVALID;
   }
 
   return priority;
 }
 
 static void PrepareOwnerOwner( Context *ctx, rtems_task_priority priority )
 {
   if ( ctx->owner_obtain != 0 ) {
     switch ( ctx->owner_owner_node ) {
       case TQ_NODE_ONLY:
         ctx->owner_owner_helper_release = false;
         TQSetPriority( ctx->tq_ctx, OWNER_OWNER, PRIO_FLEXIBLE );
         break;
       case TQ_NODE_VITAL:
         if ( ctx->scheduler_id == SCHEDULER_A_ID ) {
           ctx->owner_owner_helper_release = false;
           TQSetPriority( ctx->tq_ctx, OWNER_OWNER, priority + 1 );
         } else {
           ctx->owner_owner_helper_release = true;
           TQSetPriority( ctx->tq_ctx, OWNER_OWNER, PRIO_FLEXIBLE );
           TQSetScheduler(
             ctx->tq_ctx,
             OWNER_OWNER_HELPER,
             ctx->scheduler_id,
             priority + 1
           );
           TQSendAndWaitForExecutionStop(
             ctx->tq_ctx,
             OWNER_OWNER_HELPER,
             TQ_EVENT_MUTEX_B_OBTAIN
           );
         }
         break;
       case TQ_NODE_DISPENSABLE:
         --priority;
 
         if ( ctx->scheduler_id == SCHEDULER_A_ID ) {
           ctx->owner_owner_helper_release = false;
           TQSetPriority( ctx->tq_ctx, OWNER_OWNER, priority );
         } else {
           ctx->owner_owner_helper_release = true;
           TQSetPriority( ctx->tq_ctx, OWNER_OWNER, PRIO_FLEXIBLE );
           TQSetScheduler(
             ctx->tq_ctx,
             OWNER_OWNER_HELPER,
             ctx->scheduler_id,
             priority
           );
           TQSendAndWaitForExecutionStop(
             ctx->tq_ctx,
             OWNER_OWNER_HELPER,
             TQ_EVENT_MUTEX_B_OBTAIN
           );
         }
         break;
     }
 
     ctx->owner_owner_priority = priority;
   } else {
     ctx->owner_owner_helper_release = false;
     ctx->owner_owner_priority = PRIO_INVALID;
   }
 }
 
 static void ScoreTqReqTimeoutPriorityInherit_Pre_HomeScheduler_Prepare(
   ScoreTqReqTimeoutPriorityInherit_Context          *ctx,
   ScoreTqReqTimeoutPriorityInherit_Pre_HomeScheduler state
 )
 {
   switch ( state ) {
     case ScoreTqReqTimeoutPriorityInherit_Pre_HomeScheduler_Home: {
       /*
        * While the home scheduler of the thread is the home scheduler of the
        * thread queue owner.
        */
       ctx->scheduler_id = SCHEDULER_A_ID;
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Pre_HomeScheduler_Helping: {
       /*
        * While the home scheduler of the thread is a helping scheduler of the
        * thread queue owner.
        */
       ctx->scheduler_id = SCHEDULER_B_ID;
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Pre_HomeScheduler_NA:
       break;
   }
 }
 
 static void ScoreTqReqTimeoutPriorityInherit_Pre_EligibleScheduler_Prepare(
   ScoreTqReqTimeoutPriorityInherit_Context              *ctx,
   ScoreTqReqTimeoutPriorityInherit_Pre_EligibleScheduler state
 )
 {
   switch ( state ) {
     case ScoreTqReqTimeoutPriorityInherit_Pre_EligibleScheduler_One: {
       /*
        * While the thread has exactly one eligible scheduler.
        */
       ctx->other_scheduler = false;
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Pre_EligibleScheduler_More: {
       /*
        * While the thread has at least two eligible scheduler.
        */
       ctx->other_scheduler = true;
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Pre_EligibleScheduler_NA:
       break;
   }
 }
 
 static void ScoreTqReqTimeoutPriorityInherit_Pre_Queue_Prepare(
   ScoreTqReqTimeoutPriorityInherit_Context  *ctx,
   ScoreTqReqTimeoutPriorityInherit_Pre_Queue state
 )
 {
   switch ( state ) {
     case ScoreTqReqTimeoutPriorityInherit_Pre_Queue_Only: {
       /*
        * While the priority node of the thread is the only priority node in the
        * priority queue associated with the scheduler of the thread queue.
        */
       ctx->queue_node = TQ_NODE_ONLY;
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Pre_Queue_Vital: {
       /*
        * While the priority node of the thread is not the only priority node in
        * the priority queue associated with the scheduler of the thread queue,
        * while the priority node of the thread is the highest priority node in
        * the priority queue.
        */
       ctx->queue_node = TQ_NODE_VITAL;
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Pre_Queue_Dispensable: {
       /*
        * While the priority node of the thread is not the only priority node in
        * the priority queue associated with the scheduler of the thread queue,
        * while the priority node of the thread is not the highest priority node
        * in the priority queue.
        */
       ctx->queue_node = TQ_NODE_DISPENSABLE;
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Pre_Queue_NA:
       break;
   }
 }
 
 static void ScoreTqReqTimeoutPriorityInherit_Pre_OwnerPriority_Prepare(
   ScoreTqReqTimeoutPriorityInherit_Context          *ctx,
   ScoreTqReqTimeoutPriorityInherit_Pre_OwnerPriority state
 )
 {
   switch ( state ) {
     case ScoreTqReqTimeoutPriorityInherit_Pre_OwnerPriority_Only: {
       /*
        * While the priority node of the thread queue is the only priority node
        * associated with the scheduler available to the owner.
        */
       ctx->owner_node = TQ_NODE_ONLY;
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Pre_OwnerPriority_Vital: {
       /*
        * While the priority node of the thread queue is not the only priority
        * node associated with the scheduler available to the owner, while the
        * priority node of the thread queue is the highest priority node
        * available to the owner.
        */
       ctx->owner_node = TQ_NODE_VITAL;
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Pre_OwnerPriority_Dispensable: {
       /*
        * While the priority node of the thread queue is not the only priority
        * node associated with the scheduler available to the owner, while the
        * priority node of the thread queue is not the highest priority node
        * available to the owner.
        */
       ctx->owner_node = TQ_NODE_DISPENSABLE;
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Pre_OwnerPriority_NA:
       break;
   }
 }
 
 static void ScoreTqReqTimeoutPriorityInherit_Pre_OwnerState_Prepare(
   ScoreTqReqTimeoutPriorityInherit_Context       *ctx,
   ScoreTqReqTimeoutPriorityInherit_Pre_OwnerState state
 )
 {
   switch ( state ) {
     case ScoreTqReqTimeoutPriorityInherit_Pre_OwnerState_NotEnqueued: {
       /*
        * While the owner of the thread queue is not enqueued on a thread queue.
        */
       ctx->owner_obtain = 0;
       ctx->owner_release = 0;
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Pre_OwnerState_FIFO: {
       /*
        * While the owner of the thread queue is enqueued on a thread queue in
        * FIFO order.
        */
       ctx->owner_obtain = TQ_EVENT_MUTEX_FIFO_OBTAIN;
       ctx->owner_release = TQ_EVENT_MUTEX_FIFO_RELEASE;
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Pre_OwnerState_Priority: {
       /*
        * While the owner of the thread queue is enqueued on a thread queue in
        * priority order.
        */
       ctx->owner_obtain = TQ_EVENT_MUTEX_NO_PROTOCOL_OBTAIN;
       ctx->owner_release = TQ_EVENT_MUTEX_NO_PROTOCOL_RELEASE;
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Pre_OwnerState_PriorityInherit: {
       /*
        * While the owner of the thread queue is enqueued on a thread queue in
        * priority order with priority inheritance.
        */
       ctx->owner_obtain = TQ_EVENT_MUTEX_C_OBTAIN;
       ctx->owner_release = TQ_EVENT_MUTEX_C_RELEASE;
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Pre_OwnerState_NA:
       break;
   }
 }
 
 static void ScoreTqReqTimeoutPriorityInherit_Pre_OwnerQueue_Prepare(
   ScoreTqReqTimeoutPriorityInherit_Context       *ctx,
   ScoreTqReqTimeoutPriorityInherit_Pre_OwnerQueue state
 )
 {
   switch ( state ) {
     case ScoreTqReqTimeoutPriorityInherit_Pre_OwnerQueue_Only: {
       /*
        * While the priority node of the owner is the only priority node in the
        * priority queue associated with the scheduler of the thread queue on
        * which the owner is enqueued.
        */
       ctx->owner_queue_node = TQ_NODE_ONLY;
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Pre_OwnerQueue_Vital: {
       /*
        * While the priority node of the owner is not the only priority node in
        * the priority queue associated with the scheduler of the thread queue
        * on which the owner is enqueued, while the priority node of the owner
        * is the highest priority node in the priority queue.
        */
       ctx->owner_queue_node = TQ_NODE_VITAL;
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Pre_OwnerQueue_Dispensable: {
       /*
        * While the priority node of the owner is not the only priority node in
        * the priority queue associated with the scheduler of the thread queue
        * on which the owner is enqueued, while the priority node of the owner
        * is not the highest priority node in the priority queue.
        */
       ctx->owner_queue_node = TQ_NODE_DISPENSABLE;
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Pre_OwnerQueue_NA:
       break;
   }
 }
 
 static void ScoreTqReqTimeoutPriorityInherit_Pre_OwnerOwnerPriority_Prepare(
   ScoreTqReqTimeoutPriorityInherit_Context               *ctx,
   ScoreTqReqTimeoutPriorityInherit_Pre_OwnerOwnerPriority state
 )
 {
   switch ( state ) {
     case ScoreTqReqTimeoutPriorityInherit_Pre_OwnerOwnerPriority_Only: {
       /*
        * While the priority node of the thread queue on which the owner is
        * enqueued is the only priority node associated with the scheduler
        * available to the owner of the thread queue on which the owner is
        * enqueued.
        */
       ctx->owner_owner_node = TQ_NODE_ONLY;
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Pre_OwnerOwnerPriority_Vital: {
       /*
        * While the priority node of the thread queue on which the owner is
        * enqueued is not the only priority node associated with the scheduler
        * available to the owner of the thread queue on which the owner is
        * enqueued, while the priority node of the thread queue on which the
        * owner is enqueued is the highest priority node available to the owner
        * of the thread queue on which the owner is enqueued.
        */
       ctx->owner_owner_node = TQ_NODE_VITAL;
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Pre_OwnerOwnerPriority_Dispensable: {
       /*
        * While the priority node of the thread queue on which the owner is
        * enqueued is not the only priority node associated with the scheduler
        * available to the owner of the thread queue on which the owner is
        * enqueued, while the priority node of the thread queue is on which the
        * owner is enqueued not the highest priority node available to the owner
        * of the thread queue on which the owner is enqueued.
        */
       ctx->owner_owner_node = TQ_NODE_DISPENSABLE;
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Pre_OwnerOwnerPriority_NA:
       break;
   }
 }
 
 static void ScoreTqReqTimeoutPriorityInherit_Pre_WaitState_Prepare(
   ScoreTqReqTimeoutPriorityInherit_Context      *ctx,
   ScoreTqReqTimeoutPriorityInherit_Pre_WaitState state
 )
 {
   switch ( state ) {
     case ScoreTqReqTimeoutPriorityInherit_Pre_WaitState_Blocked: {
       /*
        * While the thread is in the blocked wait state.
        */
       ctx->wait_state = TQ_WAIT_STATE_BLOCKED;
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Pre_WaitState_IntendToBlock: {
       /*
        * While the thread is in the intend to block wait state.
        */
       ctx->wait_state = TQ_WAIT_STATE_INTEND_TO_BLOCK;
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Pre_WaitState_ReadyAgain: {
       /*
        * While the thread is in the ready again wait state.
        */
       ctx->wait_state = TQ_WAIT_STATE_READY_AGAIN;
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Pre_WaitState_NA:
       break;
   }
 }
 
 static void ScoreTqReqTimeoutPriorityInherit_Post_Status_Check(
   ScoreTqReqTimeoutPriorityInherit_Context    *ctx,
   ScoreTqReqTimeoutPriorityInherit_Post_Status state
 )
 {
   switch ( state ) {
     case ScoreTqReqTimeoutPriorityInherit_Post_Status_Ok: {
       /*
        * The return status of the directive call shall be derived from
        * STATUS_SUCCESSFUL.
        */
       T_eq_int(
         ctx->tq_ctx->status[ THREAD ],
         TQConvertStatus( ctx->tq_ctx, STATUS_SUCCESSFUL )
       );
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout: {
       /*
        * The return status of the directive call shall be derived from
        * STATUS_TIMEOUT.
        */
       T_eq_int(
         ctx->tq_ctx->status[ THREAD ],
         TQConvertStatus( ctx->tq_ctx, STATUS_TIMEOUT )
       );
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Post_Status_NA:
       break;
   }
 }
 
 static void ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Check(
   ScoreTqReqTimeoutPriorityInherit_Context     *ctx,
   ScoreTqReqTimeoutPriorityInherit_Post_Unblock state
 )
 {
   size_t i;
 
   i = 0;
 
   switch ( state ) {
     case ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes: {
       /*
        * The thread shall be unblocked by the timeout operation.
        */
       T_true( GetUnblock( ctx, &i ) );
       T_false( GetUnblock( ctx, &i ) );
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No: {
       /*
        * The thread shall not be unblocked by the timeout operation.
        */
       T_false( GetUnblock( ctx, &i ) );
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA:
       break;
   }
 }
 
 static void ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Check(
   ScoreTqReqTimeoutPriorityInherit_Context           *ctx,
   ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority state
 )
 {
   switch ( state ) {
     case ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Nop: {
       /*
        * The priority of the owner with respect to the scheduler shall not
        * change by the timeout operation.
        */
       T_eq_u32( ctx->owner_priority_after, ctx->owner_priority );
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower: {
       /*
        * The priority of the owner with respect to the scheduler shall be
        * lowered to the next highest priority.
        */
       T_eq_u32( ctx->owner_priority_after, ctx->owner_priority + 1 );
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Drop: {
       /*
        * The owner shall not have a priority with respect to the scheduler.
        */
       T_eq_u32( ctx->owner_priority_after, PRIO_INVALID );
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA:
       break;
   }
 }
 
 static void ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Check(
   ScoreTqReqTimeoutPriorityInherit_Context                *ctx,
   ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority state
 )
 {
   switch ( state ) {
     case ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Nop: {
       /*
        * The priority of the owner of the thread queue on which the owner is
        * enqueued with respect to the scheduler shall not change by the timeout
        * operation.
        */
       T_eq_u32( ctx->owner_owner_priority_after, ctx->owner_owner_priority );
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Lower: {
       /*
        * The priority of the owner of the thread queue on which the owner is
        * enqueued with respect to the scheduler shall be lowered to the next
        * highest priority.
        */
       T_eq_u32( ctx->owner_owner_priority_after, ctx->owner_owner_priority + 1 );
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Drop: {
       /*
        * The owner of the thread queue on which the owner is enqueued shall not
        * have a priority with respect to the scheduler.
        */
       T_eq_u32( ctx->owner_owner_priority_after, PRIO_INVALID );
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA:
       break;
   }
 }
 
 static void ScoreTqReqTimeoutPriorityInherit_Setup(
   ScoreTqReqTimeoutPriorityInherit_Context *ctx
 )
 {
   ctx->request.arg = ctx;
   TQReset( ctx->tq_ctx );
   SetSelfPriority( PRIO_NEARLY_IDLE );
 }
 
 static void ScoreTqReqTimeoutPriorityInherit_Setup_Wrap( void *arg )
 {
   ScoreTqReqTimeoutPriorityInherit_Context *ctx;
 
   ctx = arg;
   ctx->Map.in_action_loop = false;
   ScoreTqReqTimeoutPriorityInherit_Setup( ctx );
 }
 
 static void ScoreTqReqTimeoutPriorityInherit_Teardown(
   ScoreTqReqTimeoutPriorityInherit_Context *ctx
 )
 {
   TQReset( ctx->tq_ctx );
 }
 
 static void ScoreTqReqTimeoutPriorityInherit_Teardown_Wrap( void *arg )
 {
   ScoreTqReqTimeoutPriorityInherit_Context *ctx;
 
   ctx = arg;
   ctx->Map.in_action_loop = false;
   ScoreTqReqTimeoutPriorityInherit_Teardown( ctx );
 }
 
 static void ScoreTqReqTimeoutPriorityInherit_Prepare(
   ScoreTqReqTimeoutPriorityInherit_Context *ctx
 )
 {
   ctx->queue_helper_surrender = false;
   ctx->owner_helper_release = false;
   ctx->owner_queue_helper_release = false;
   ctx->owner_owner_helper_release = false;
 }
 
 static void ScoreTqReqTimeoutPriorityInherit_Action(
   ScoreTqReqTimeoutPriorityInherit_Context *ctx
 )
 {
   rtems_task_priority priority;
 
   priority = PRIO_FLEXIBLE;
   TQSetScheduler( ctx->tq_ctx, THREAD, ctx->scheduler_id, priority );
 
   TQSend(
     ctx->tq_ctx,
     OWNER,
     TQ_EVENT_MUTEX_A_OBTAIN | TQ_EVENT_ENQUEUE
   );
 
   if ( ctx->owner_obtain != 0 ) {
     TQSend(
       ctx->tq_ctx,
       OWNER_OWNER,
       TQ_EVENT_MUTEX_B_OBTAIN | ctx->owner_obtain
     );
     TQSend( ctx->tq_ctx, OWNER, ctx->owner_obtain | ctx->owner_release );
   }
 
   PrepareThread( ctx );
   priority = PrepareQueue( ctx, priority );
   priority = PrepareOwner( ctx, priority );
   priority = PrepareOwnerQueue( ctx, priority );
   PrepareOwnerOwner( ctx, priority );
 
   TQClearDone( ctx->tq_ctx, THREAD );
 
   switch ( ctx->wait_state ) {
     case TQ_WAIT_STATE_BLOCKED:
       TQSendAndWaitForExecutionStop(
         ctx->tq_ctx,
         THREAD,
         TQ_EVENT_ENQUEUE_TIMED
       );
       Tick( ctx );
       GetPriorities( ctx );
       TQSend( ctx->tq_ctx, OWNER, TQ_EVENT_SURRENDER );
       break;
     case TQ_WAIT_STATE_INTEND_TO_BLOCK:
       T_scheduler_set_event_handler( SchedulerBlock, ctx );
       TQSendAndWaitForExecutionStop(
         ctx->tq_ctx,
         THREAD,
         TQ_EVENT_ENQUEUE_TIMED
       );
       GetPriorities( ctx );
       TQSend( ctx->tq_ctx, OWNER, TQ_EVENT_SURRENDER );
       break;
     case TQ_WAIT_STATE_READY_AGAIN:
       TQSendAndWaitForExecutionStop(
         ctx->tq_ctx,
         THREAD,
         TQ_EVENT_ENQUEUE_TIMED
       );
       T_scheduler_set_event_handler( SchedulerUnblock, ctx );
       TQSend( ctx->tq_ctx, OWNER, TQ_EVENT_SURRENDER );
       GetPriorities( ctx );
       TQSend( ctx->tq_ctx, THREAD, TQ_EVENT_SURRENDER );
       break;
   }
 
   TQWaitForDone( ctx->tq_ctx, THREAD );
   TQWaitForExecutionStop( ctx->tq_ctx, THREAD );
 }
 
 static void ScoreTqReqTimeoutPriorityInherit_Cleanup(
   ScoreTqReqTimeoutPriorityInherit_Context *ctx
 )
 {
   if ( ctx->owner_obtain != 0 ) {
     TQSend(
       ctx->tq_ctx,
       OWNER_OWNER,
       TQ_EVENT_MUTEX_B_RELEASE | ctx->owner_release
     );
 
     if ( ctx->owner_queue_helper_release ) {
       TQSendAndWaitForExecutionStop(
         ctx->tq_ctx,
         OWNER_QUEUE_HELPER,
         ctx->owner_release
       );
     }
 
     if ( ctx->owner_owner_helper_release ) {
       TQSendAndWaitForExecutionStop(
         ctx->tq_ctx,
         OWNER_OWNER_HELPER,
         TQ_EVENT_MUTEX_B_RELEASE
       );
     }
   }
 
   TQSend( ctx->tq_ctx, OWNER, TQ_EVENT_MUTEX_A_RELEASE );
 
   if ( ctx->queue_helper_surrender ) {
     TQSendAndWaitForExecutionStop(
       ctx->tq_ctx,
       QUEUE_HELPER,
       TQ_EVENT_SURRENDER
     );
   }
 
   if ( ctx->owner_helper_release ) {
     TQSendAndWaitForExecutionStop(
       ctx->tq_ctx,
       OWNER_HELPER,
       TQ_EVENT_MUTEX_A_RELEASE
     );
   }
 
   if ( ctx->other_scheduler ) {
     TQSendAndWaitForExecutionStop(
       ctx->tq_ctx,
       THREAD,
       TQ_EVENT_MUTEX_D_RELEASE
     );
     TQSendAndWaitForExecutionStop(
       ctx->tq_ctx,
       THREAD_HELPER_A,
       TQ_EVENT_MUTEX_D_RELEASE
     );
 
     if ( rtems_scheduler_get_processor_maximum() >= 3 ) {
       TQSendAndWaitForExecutionStop(
         ctx->tq_ctx,
         THREAD_HELPER_B,
         TQ_EVENT_MUTEX_D_RELEASE
       );
     }
   }
 }
 
 static const ScoreTqReqTimeoutPriorityInherit_Entry
 ScoreTqReqTimeoutPriorityInherit_Entries[] = {
 #if !defined(RTEMS_SMP)
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #else
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #endif
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #if !defined(RTEMS_SMP)
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #else
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #endif
 #if !defined(RTEMS_SMP)
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #else
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #endif
 #if !defined(RTEMS_SMP)
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #else
   { 0, 0, 0, 0, 0, 0, 1, 1, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #endif
 #if !defined(RTEMS_SMP)
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #else
   { 0, 0, 0, 0, 0, 0, 1, 1, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #endif
 #if !defined(RTEMS_SMP)
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #else
   { 0, 0, 0, 0, 0, 0, 1, 1, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Nop,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #endif
 #if !defined(RTEMS_SMP)
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #else
   { 0, 0, 0, 0, 0, 0, 1, 1, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Nop,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #endif
 #if !defined(RTEMS_SMP)
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #else
   { 0, 0, 0, 0, 0, 0, 0, 1, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #endif
 #if !defined(RTEMS_SMP)
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #else
   { 0, 0, 0, 0, 0, 0, 0, 1, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #endif
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #if !defined(RTEMS_SMP)
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #else
   { 0, 0, 0, 0, 0, 0, 1, 1, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_Ok,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #endif
 #if !defined(RTEMS_SMP)
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #else
   { 0, 0, 0, 0, 0, 0, 0, 1, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Nop,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #endif
 #if !defined(RTEMS_SMP)
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #else
   { 0, 0, 0, 0, 0, 0, 0, 1, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Nop,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #endif
 #if !defined(RTEMS_SMP)
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #else
   { 0, 0, 0, 0, 0, 0, 0, 0, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Nop,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Nop },
 #endif
 #if !defined(RTEMS_SMP)
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #else
   { 0, 0, 0, 0, 0, 0, 0, 0, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Nop,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Nop },
 #endif
 #if !defined(RTEMS_SMP)
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #else
   { 0, 0, 0, 0, 0, 0, 1, 1, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Drop,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #endif
 #if !defined(RTEMS_SMP)
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #else
   { 0, 0, 0, 0, 0, 0, 1, 1, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Drop,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #endif
 #if !defined(RTEMS_SMP)
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #else
   { 0, 0, 0, 0, 0, 0, 1, 1, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_Ok,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Drop,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #endif
 #if !defined(RTEMS_SMP)
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #else
   { 0, 0, 0, 0, 0, 0, 0, 0, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Nop },
 #endif
 #if !defined(RTEMS_SMP)
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #else
   { 0, 0, 0, 0, 0, 0, 0, 0, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Nop },
 #endif
 #if !defined(RTEMS_SMP)
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #else
   { 0, 0, 0, 0, 0, 0, 0, 0, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Lower },
 #endif
 #if !defined(RTEMS_SMP)
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #else
   { 0, 0, 0, 0, 0, 0, 0, 0, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Lower },
 #endif
   { 0, 0, 0, 0, 0, 0, 1, 1, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
   { 0, 0, 0, 0, 0, 0, 1, 1, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #if !defined(RTEMS_SMP)
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #else
   { 0, 0, 0, 0, 0, 0, 1, 1, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_Ok,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Nop,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #endif
 #if !defined(RTEMS_SMP)
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #else
   { 0, 0, 0, 0, 0, 0, 0, 1, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Drop,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #endif
 #if !defined(RTEMS_SMP)
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #else
   { 0, 0, 0, 0, 0, 0, 0, 1, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Drop,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #endif
   { 0, 0, 0, 0, 0, 0, 1, 1, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Nop,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
   { 0, 0, 0, 0, 0, 0, 1, 1, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Nop,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
   { 0, 0, 0, 0, 0, 0, 1, 1, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_Ok,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
   { 0, 0, 0, 0, 0, 0, 0, 1, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
   { 0, 0, 0, 0, 0, 0, 0, 1, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #if !defined(RTEMS_SMP)
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #else
   { 0, 0, 0, 0, 0, 0, 0, 0, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Drop,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Nop },
 #endif
 #if !defined(RTEMS_SMP)
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #else
   { 0, 0, 0, 0, 0, 0, 0, 0, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Drop,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Nop },
 #endif
   { 0, 0, 0, 0, 0, 0, 0, 0, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Nop },
   { 0, 0, 0, 0, 0, 0, 0, 0, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Nop },
   { 0, 0, 0, 0, 0, 0, 0, 1, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Nop,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
   { 0, 0, 0, 0, 0, 0, 0, 1, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Nop,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
   { 0, 0, 0, 0, 0, 0, 0, 0, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Nop,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Nop },
   { 0, 0, 0, 0, 0, 0, 0, 0, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Nop,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Nop },
 #if !defined(RTEMS_SMP)
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #else
   { 0, 0, 0, 0, 0, 0, 0, 0, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Drop,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Lower },
 #endif
 #if !defined(RTEMS_SMP)
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #else
   { 0, 0, 0, 0, 0, 0, 0, 0, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Drop,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Lower },
 #endif
   { 0, 0, 0, 0, 0, 0, 0, 0, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Lower },
   { 0, 0, 0, 0, 0, 0, 0, 0, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Lower },
   { 0, 0, 0, 0, 0, 0, 1, 1, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_Ok,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Nop,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #if !defined(RTEMS_SMP)
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA },
 #else
   { 0, 0, 0, 0, 0, 0, 0, 0, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Drop,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Drop },
 #endif
 #if !defined(RTEMS_SMP)
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA }
 #else
   { 0, 0, 0, 0, 0, 0, 0, 0, 0,
     ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
     ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Drop,
     ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Drop }
 #endif
 };
 
 static const uint8_t
 ScoreTqReqTimeoutPriorityInherit_Map[] = {
   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 2, 2,
   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 2,
   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1,
   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1,
   1, 2, 2, 2, 2, 2, 2, 24, 25, 31, 24, 25, 31, 2, 2, 2, 24, 25, 31, 24, 25, 31,
   2, 2, 2, 1, 1, 1, 24, 25, 31, 2, 2, 2, 24, 25, 11, 24, 25, 11, 2, 2, 2, 24,
   25, 11, 24, 25, 11, 2, 2, 2, 1, 1, 1, 24, 25, 11, 2, 2, 2, 32, 33, 11, 32,
   33, 11, 2, 2, 2, 32, 33, 11, 32, 33, 11, 2, 2, 2, 1, 1, 1, 32, 33, 11, 2, 2,
   2, 44, 45, 11, 36, 37, 11, 2, 2, 2, 44, 45, 11, 36, 37, 11, 2, 2, 2, 1, 1, 1,
   36, 37, 11, 2, 2, 2, 1, 1, 1, 29, 30, 46, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
   1, 1, 1, 29, 30, 46, 2, 2, 2, 1, 1, 1, 29, 30, 11, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   2, 2, 2, 1, 1, 1, 29, 30, 11, 2, 2, 2, 1, 1, 1, 38, 39, 11, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 2, 2, 2, 1, 1, 1, 38, 39, 11, 2, 2, 2, 1, 1, 1, 40, 41, 11, 1, 1, 1,
   1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 40, 41, 11, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 2, 2, 2, 2, 2, 2, 24, 25,
   31, 24, 25, 31, 2, 2, 2, 24, 25, 31, 24, 25, 31, 2, 2, 2, 1, 1, 1, 24, 25,
   31, 2, 2, 2, 24, 25, 11, 24, 25, 11, 2, 2, 2, 24, 25, 11, 24, 25, 11, 2, 2,
   2, 1, 1, 1, 24, 25, 11, 2, 2, 2, 32, 33, 11, 32, 33, 11, 2, 2, 2, 32, 33, 11,
   32, 33, 11, 2, 2, 2, 1, 1, 1, 32, 33, 11, 2, 2, 2, 44, 45, 11, 36, 37, 11, 2,
   2, 2, 44, 45, 11, 36, 37, 11, 2, 2, 2, 1, 1, 1, 36, 37, 11, 2, 2, 2, 1, 1, 1,
   29, 30, 46, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 29, 30, 46, 2, 2, 2,
   1, 1, 1, 29, 30, 11, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 29, 30, 11,
   2, 2, 2, 1, 1, 1, 38, 39, 11, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1,
   38, 39, 11, 2, 2, 2, 1, 1, 1, 40, 41, 11, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
   1, 1, 1, 40, 41, 11, 2, 2, 2, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2,
   2, 2, 1, 1, 1, 2, 2, 2, 2, 2, 2, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   2, 2, 2, 1, 1, 1, 2, 2, 2, 2, 2, 2, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 2, 2, 2, 1, 1, 1, 2, 2, 2, 2, 2, 2, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1,
   1, 1, 2, 2, 2, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 29, 30, 11, 1,
   1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 29, 30, 11, 2, 2, 2, 1, 1, 1, 29,
   30, 11, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 29, 30, 11, 2, 2, 2, 1,
   1, 1, 38, 39, 11, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 38, 39, 11, 2,
   2, 2, 1, 1, 1, 40, 41, 11, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 40,
   41, 11, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0,
   0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0,
   0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
   0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
   3, 0, 0, 0, 3, 3, 3, 3, 3, 3, 5, 6, 12, 5, 6, 12, 3, 3, 3, 5, 6, 12, 5, 6,
   12, 3, 3, 3, 0, 0, 0, 5, 6, 12, 3, 3, 3, 5, 6, 4, 5, 6, 4, 3, 3, 3, 5, 6, 4,
   5, 6, 4, 3, 3, 3, 0, 0, 0, 5, 6, 4, 3, 3, 3, 9, 10, 4, 9, 10, 4, 3, 3, 3, 9,
   10, 4, 9, 10, 4, 3, 3, 3, 0, 0, 0, 9, 10, 4, 3, 3, 3, 22, 23, 4, 20, 21, 4,
   3, 3, 3, 22, 23, 4, 20, 21, 4, 3, 3, 3, 0, 0, 0, 20, 21, 4, 3, 3, 3, 0, 0, 0,
   7, 8, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 7, 8, 26, 3, 3, 3, 0,
   0, 0, 7, 8, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 7, 8, 4, 3, 3, 3,
   0, 0, 0, 13, 14, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 13, 14, 4,
   3, 3, 3, 0, 0, 0, 15, 16, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 15,
   16, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0,
   0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0,
   0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
   0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
   3, 0, 0, 0, 3, 3, 3, 3, 3, 3, 5, 6, 12, 5, 6, 12, 3, 3, 3, 5, 6, 12, 5, 6,
   12, 3, 3, 3, 0, 0, 0, 5, 6, 12, 3, 3, 3, 5, 6, 4, 5, 6, 4, 3, 3, 3, 5, 6, 4,
   5, 6, 4, 3, 3, 3, 0, 0, 0, 5, 6, 4, 3, 3, 3, 9, 10, 4, 9, 10, 4, 3, 3, 3, 9,
   10, 4, 9, 10, 4, 3, 3, 3, 0, 0, 0, 9, 10, 4, 3, 3, 3, 22, 23, 4, 20, 21, 4,
   3, 3, 3, 22, 23, 4, 20, 21, 4, 3, 3, 3, 0, 0, 0, 20, 21, 4, 3, 3, 3, 0, 0, 0,
   7, 8, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 7, 8, 26, 3, 3, 3, 0,
   0, 0, 7, 8, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 7, 8, 4, 3, 3, 3,
   0, 0, 0, 13, 14, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 13, 14, 4,
   3, 3, 3, 0, 0, 0, 15, 16, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 15,
   16, 4, 3, 3, 3, 0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0,
   0, 3, 3, 3, 3, 3, 3, 0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0,
   0, 0, 3, 3, 3, 3, 3, 3, 0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3,
   0, 0, 0, 3, 3, 3, 3, 3, 3, 0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3,
   3, 0, 0, 0, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 7, 8, 4, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 3, 3, 3, 0, 0, 0, 7, 8, 4, 3, 3, 3, 0, 0, 0, 7, 8, 4, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 7, 8, 4, 3, 3, 3, 0, 0, 0, 13, 14, 4, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 13, 14, 4, 3, 3, 3, 0, 0, 0, 15, 16, 4,
   0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 0, 0, 0, 15, 16, 4, 17, 18, 19, 17, 18,
   19, 17, 18, 19, 17, 18, 19, 17, 18, 19, 17, 18, 19, 17, 18, 19, 0, 0, 0, 17,
   18, 19, 17, 18, 4, 17, 18, 4, 17, 18, 4, 17, 18, 4, 17, 18, 4, 17, 18, 4, 17,
   18, 4, 0, 0, 0, 17, 18, 4, 27, 28, 4, 27, 28, 4, 27, 28, 4, 27, 28, 4, 27,
   28, 4, 27, 28, 4, 27, 28, 4, 0, 0, 0, 27, 28, 4, 47, 48, 4, 42, 43, 4, 34,
   35, 4, 42, 43, 4, 42, 43, 4, 34, 35, 4, 34, 35, 4, 0, 0, 0, 34, 35, 4, 5, 6,
   12, 5, 6, 12, 5, 6, 12, 5, 6, 12, 5, 6, 12, 5, 6, 12, 5, 6, 12, 0, 0, 0, 5,
   6, 12, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 0, 0,
   0, 5, 6, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9,
   10, 4, 0, 0, 0, 9, 10, 4, 22, 23, 4, 22, 23, 4, 20, 21, 4, 22, 23, 4, 22, 23,
   4, 20, 21, 4, 20, 21, 4, 0, 0, 0, 20, 21, 4, 7, 8, 26, 0, 0, 0, 7, 8, 26, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 26, 0, 0, 0, 7, 8, 26, 7, 8, 4, 0, 0, 0, 7, 8,
   4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 4, 0, 0, 0, 7, 8, 4, 13, 14, 4, 0, 0, 0,
   13, 14, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 14, 4, 0, 0, 0, 13, 14, 4, 15, 16,
   4, 0, 0, 0, 15, 16, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 16, 4, 0, 0, 0, 15, 16,
   4, 5, 6, 19, 5, 6, 19, 5, 6, 19, 5, 6, 19, 5, 6, 19, 5, 6, 19, 5, 6, 19, 0,
   0, 0, 5, 6, 19, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6,
   4, 0, 0, 0, 5, 6, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10,
   4, 9, 10, 4, 0, 0, 0, 9, 10, 4, 22, 23, 4, 22, 23, 4, 20, 21, 4, 22, 23, 4,
   22, 23, 4, 20, 21, 4, 20, 21, 4, 0, 0, 0, 20, 21, 4, 5, 6, 12, 5, 6, 12, 5,
   6, 12, 5, 6, 12, 5, 6, 12, 5, 6, 12, 5, 6, 12, 0, 0, 0, 5, 6, 12, 5, 6, 4, 5,
   6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 0, 0, 0, 5, 6, 4, 9, 10,
   4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 0, 0, 0, 9,
   10, 4, 22, 23, 4, 22, 23, 4, 20, 21, 4, 22, 23, 4, 22, 23, 4, 20, 21, 4, 20,
   21, 4, 0, 0, 0, 20, 21, 4, 7, 8, 26, 0, 0, 0, 7, 8, 26, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 7, 8, 26, 0, 0, 0, 7, 8, 26, 7, 8, 4, 0, 0, 0, 7, 8, 4, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 7, 8, 4, 0, 0, 0, 7, 8, 4, 13, 14, 4, 0, 0, 0, 13, 14, 4, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 13, 14, 4, 0, 0, 0, 13, 14, 4, 15, 16, 4, 0, 0, 0, 15,
   16, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 16, 4, 0, 0, 0, 15, 16, 4, 7, 8, 4, 0,
   0, 0, 7, 8, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 4, 0, 0, 0, 7, 8, 4, 7, 8, 4,
   0, 0, 0, 7, 8, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 4, 0, 0, 0, 7, 8, 4, 13,
   14, 4, 0, 0, 0, 13, 14, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 14, 4, 0, 0, 0, 13,
   14, 4, 15, 16, 4, 0, 0, 0, 15, 16, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 16, 4,
   0, 0, 0, 15, 16, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 4, 0, 0, 0, 7, 8, 4, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 7, 8, 4, 0, 0, 0, 7, 8, 4, 7, 8, 4, 0, 0, 0, 7, 8, 4, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 7, 8, 4, 0, 0, 0, 7, 8, 4, 13, 14, 4, 0, 0, 0, 13, 14, 4, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 13, 14, 4, 0, 0, 0, 13, 14, 4, 15, 16, 4, 0, 0, 0, 15,
   16, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 16, 4, 0, 0, 0, 15, 16, 4, 17, 18, 19,
   17, 18, 19, 17, 18, 19, 17, 18, 19, 17, 18, 19, 17, 18, 19, 17, 18, 19, 0, 0,
   0, 17, 18, 19, 17, 18, 4, 17, 18, 4, 17, 18, 4, 17, 18, 4, 17, 18, 4, 17, 18,
   4, 17, 18, 4, 0, 0, 0, 17, 18, 4, 27, 28, 4, 27, 28, 4, 27, 28, 4, 27, 28, 4,
   27, 28, 4, 27, 28, 4, 27, 28, 4, 0, 0, 0, 27, 28, 4, 47, 48, 4, 42, 43, 4,
   34, 35, 4, 42, 43, 4, 42, 43, 4, 34, 35, 4, 34, 35, 4, 0, 0, 0, 34, 35, 4, 5,
   6, 12, 5, 6, 12, 5, 6, 12, 5, 6, 12, 5, 6, 12, 5, 6, 12, 5, 6, 12, 0, 0, 0,
   5, 6, 12, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 0,
   0, 0, 5, 6, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9,
   10, 4, 0, 0, 0, 9, 10, 4, 22, 23, 4, 22, 23, 4, 20, 21, 4, 22, 23, 4, 22, 23,
   4, 20, 21, 4, 20, 21, 4, 0, 0, 0, 20, 21, 4, 7, 8, 26, 0, 0, 0, 7, 8, 26, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 26, 0, 0, 0, 7, 8, 26, 7, 8, 4, 0, 0, 0, 7, 8,
   4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 4, 0, 0, 0, 7, 8, 4, 13, 14, 4, 0, 0, 0,
   13, 14, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 14, 4, 0, 0, 0, 13, 14, 4, 15, 16,
   4, 0, 0, 0, 15, 16, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 16, 4, 0, 0, 0, 15, 16,
   4, 5, 6, 19, 5, 6, 19, 5, 6, 19, 5, 6, 19, 5, 6, 19, 5, 6, 19, 5, 6, 19, 0,
   0, 0, 5, 6, 19, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6,
   4, 0, 0, 0, 5, 6, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10,
   4, 9, 10, 4, 0, 0, 0, 9, 10, 4, 22, 23, 4, 22, 23, 4, 20, 21, 4, 22, 23, 4,
   22, 23, 4, 20, 21, 4, 20, 21, 4, 0, 0, 0, 20, 21, 4, 5, 6, 12, 5, 6, 12, 5,
   6, 12, 5, 6, 12, 5, 6, 12, 5, 6, 12, 5, 6, 12, 0, 0, 0, 5, 6, 12, 5, 6, 4, 5,
   6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 5, 6, 4, 0, 0, 0, 5, 6, 4, 9, 10,
   4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 9, 10, 4, 0, 0, 0, 9,
   10, 4, 22, 23, 4, 22, 23, 4, 20, 21, 4, 22, 23, 4, 22, 23, 4, 20, 21, 4, 20,
   21, 4, 0, 0, 0, 20, 21, 4, 7, 8, 26, 0, 0, 0, 7, 8, 26, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 7, 8, 26, 0, 0, 0, 7, 8, 26, 7, 8, 4, 0, 0, 0, 7, 8, 4, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 7, 8, 4, 0, 0, 0, 7, 8, 4, 13, 14, 4, 0, 0, 0, 13, 14, 4, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 13, 14, 4, 0, 0, 0, 13, 14, 4, 15, 16, 4, 0, 0, 0, 15,
   16, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 16, 4, 0, 0, 0, 15, 16, 4, 7, 8, 4, 0,
   0, 0, 7, 8, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 4, 0, 0, 0, 7, 8, 4, 7, 8, 4,
   0, 0, 0, 7, 8, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 4, 0, 0, 0, 7, 8, 4, 13,
   14, 4, 0, 0, 0, 13, 14, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 14, 4, 0, 0, 0, 13,
   14, 4, 15, 16, 4, 0, 0, 0, 15, 16, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 16, 4,
   0, 0, 0, 15, 16, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 4, 0, 0, 0, 7, 8, 4, 0, 0, 0, 0, 0, 0,
   0, 0, 0, 7, 8, 4, 0, 0, 0, 7, 8, 4, 7, 8, 4, 0, 0, 0, 7, 8, 4, 0, 0, 0, 0, 0,
   0, 0, 0, 0, 7, 8, 4, 0, 0, 0, 7, 8, 4, 13, 14, 4, 0, 0, 0, 13, 14, 4, 0, 0,
   0, 0, 0, 0, 0, 0, 0, 13, 14, 4, 0, 0, 0, 13, 14, 4, 15, 16, 4, 0, 0, 0, 15,
   16, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 16, 4, 0, 0, 0, 15, 16, 4
 };
 
 static size_t ScoreTqReqTimeoutPriorityInherit_Scope(
   void  *arg,
   char  *buf,
   size_t n
 )
 {
   ScoreTqReqTimeoutPriorityInherit_Context *ctx;
 
   ctx = arg;
 
   if ( ctx->Map.in_action_loop ) {
     return T_get_scope(
       ScoreTqReqTimeoutPriorityInherit_PreDesc,
       buf,
       n,
       ctx->Map.pcs
     );
   }
 
   return 0;
 }
 
 static T_fixture ScoreTqReqTimeoutPriorityInherit_Fixture = {
   .setup = ScoreTqReqTimeoutPriorityInherit_Setup_Wrap,
   .stop = NULL,
   .teardown = ScoreTqReqTimeoutPriorityInherit_Teardown_Wrap,
   .scope = ScoreTqReqTimeoutPriorityInherit_Scope,
   .initial_context = &ScoreTqReqTimeoutPriorityInherit_Instance
 };
 
 static inline ScoreTqReqTimeoutPriorityInherit_Entry
 ScoreTqReqTimeoutPriorityInherit_PopEntry(
   ScoreTqReqTimeoutPriorityInherit_Context *ctx
 )
 {
   size_t index;
 
   index = ctx->Map.index;
   ctx->Map.index = index + 1;
   return ScoreTqReqTimeoutPriorityInherit_Entries[
     ScoreTqReqTimeoutPriorityInherit_Map[ index ]
   ];
 }
 
 static void ScoreTqReqTimeoutPriorityInherit_SetPreConditionStates(
   ScoreTqReqTimeoutPriorityInherit_Context *ctx
 )
 {
   ctx->Map.pcs[ 0 ] = ctx->Map.pci[ 0 ];
   ctx->Map.pcs[ 1 ] = ctx->Map.pci[ 1 ];
   ctx->Map.pcs[ 2 ] = ctx->Map.pci[ 2 ];
   ctx->Map.pcs[ 3 ] = ctx->Map.pci[ 3 ];
   ctx->Map.pcs[ 4 ] = ctx->Map.pci[ 4 ];
 
   if ( ctx->Map.entry.Pre_OwnerQueue_NA ) {
     ctx->Map.pcs[ 5 ] = ScoreTqReqTimeoutPriorityInherit_Pre_OwnerQueue_NA;
   } else {
     ctx->Map.pcs[ 5 ] = ctx->Map.pci[ 5 ];
   }
 
   if ( ctx->Map.entry.Pre_OwnerOwnerPriority_NA ) {
     ctx->Map.pcs[ 6 ] = ScoreTqReqTimeoutPriorityInherit_Pre_OwnerOwnerPriority_NA;
   } else {
     ctx->Map.pcs[ 6 ] = ctx->Map.pci[ 6 ];
   }
 
   ctx->Map.pcs[ 7 ] = ctx->Map.pci[ 7 ];
 }
 
 static void ScoreTqReqTimeoutPriorityInherit_TestVariant(
   ScoreTqReqTimeoutPriorityInherit_Context *ctx
 )
 {
   ScoreTqReqTimeoutPriorityInherit_Pre_HomeScheduler_Prepare(
     ctx,
     ctx->Map.pcs[ 0 ]
   );
   ScoreTqReqTimeoutPriorityInherit_Pre_EligibleScheduler_Prepare(
     ctx,
     ctx->Map.pcs[ 1 ]
   );
   ScoreTqReqTimeoutPriorityInherit_Pre_Queue_Prepare( ctx, ctx->Map.pcs[ 2 ] );
   ScoreTqReqTimeoutPriorityInherit_Pre_OwnerPriority_Prepare(
     ctx,
     ctx->Map.pcs[ 3 ]
   );
   ScoreTqReqTimeoutPriorityInherit_Pre_OwnerState_Prepare(
     ctx,
     ctx->Map.pcs[ 4 ]
   );
   ScoreTqReqTimeoutPriorityInherit_Pre_OwnerQueue_Prepare(
     ctx,
     ctx->Map.pcs[ 5 ]
   );
   ScoreTqReqTimeoutPriorityInherit_Pre_OwnerOwnerPriority_Prepare(
     ctx,
     ctx->Map.pcs[ 6 ]
   );
   ScoreTqReqTimeoutPriorityInherit_Pre_WaitState_Prepare(
     ctx,
     ctx->Map.pcs[ 7 ]
   );
   ScoreTqReqTimeoutPriorityInherit_Action( ctx );
   ScoreTqReqTimeoutPriorityInherit_Post_Status_Check(
     ctx,
     ctx->Map.entry.Post_Status
   );
   ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Check(
     ctx,
     ctx->Map.entry.Post_Unblock
   );
   ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Check(
     ctx,
     ctx->Map.entry.Post_OwnerPriority
   );
   ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Check(
     ctx,
     ctx->Map.entry.Post_OwnerOwnerPriority
   );
 }
 
 static T_fixture_node ScoreTqReqTimeoutPriorityInherit_Node;
 
 static T_remark ScoreTqReqTimeoutPriorityInherit_Remark = {
   .next = NULL,
   .remark = "ScoreTqReqTimeoutPriorityInherit"
 };
 
 void ScoreTqReqTimeoutPriorityInherit_Run( TQContext *tq_ctx )
 {
   ScoreTqReqTimeoutPriorityInherit_Context *ctx;
 
   ctx = &ScoreTqReqTimeoutPriorityInherit_Instance;
   ctx->tq_ctx = tq_ctx;
 
   ctx = T_push_fixture(
     &ScoreTqReqTimeoutPriorityInherit_Node,
     &ScoreTqReqTimeoutPriorityInherit_Fixture
   );
   ctx->Map.in_action_loop = true;
   ctx->Map.index = 0;
 
   for (
     ctx->Map.pci[ 0 ] = ScoreTqReqTimeoutPriorityInherit_Pre_HomeScheduler_Home;
     ctx->Map.pci[ 0 ] < ScoreTqReqTimeoutPriorityInherit_Pre_HomeScheduler_NA;
     ++ctx->Map.pci[ 0 ]
   ) {
     for (
       ctx->Map.pci[ 1 ] = ScoreTqReqTimeoutPriorityInherit_Pre_EligibleScheduler_One;
       ctx->Map.pci[ 1 ] < ScoreTqReqTimeoutPriorityInherit_Pre_EligibleScheduler_NA;
       ++ctx->Map.pci[ 1 ]
     ) {
       for (
         ctx->Map.pci[ 2 ] = ScoreTqReqTimeoutPriorityInherit_Pre_Queue_Only;
         ctx->Map.pci[ 2 ] < ScoreTqReqTimeoutPriorityInherit_Pre_Queue_NA;
         ++ctx->Map.pci[ 2 ]
       ) {
         for (
           ctx->Map.pci[ 3 ] = ScoreTqReqTimeoutPriorityInherit_Pre_OwnerPriority_Only;
           ctx->Map.pci[ 3 ] < ScoreTqReqTimeoutPriorityInherit_Pre_OwnerPriority_NA;
           ++ctx->Map.pci[ 3 ]
         ) {
           for (
             ctx->Map.pci[ 4 ] = ScoreTqReqTimeoutPriorityInherit_Pre_OwnerState_NotEnqueued;
             ctx->Map.pci[ 4 ] < ScoreTqReqTimeoutPriorityInherit_Pre_OwnerState_NA;
             ++ctx->Map.pci[ 4 ]
           ) {
             for (
               ctx->Map.pci[ 5 ] = ScoreTqReqTimeoutPriorityInherit_Pre_OwnerQueue_Only;
               ctx->Map.pci[ 5 ] < ScoreTqReqTimeoutPriorityInherit_Pre_OwnerQueue_NA;
               ++ctx->Map.pci[ 5 ]
             ) {
               for (
                 ctx->Map.pci[ 6 ] = ScoreTqReqTimeoutPriorityInherit_Pre_OwnerOwnerPriority_Only;
                 ctx->Map.pci[ 6 ] < ScoreTqReqTimeoutPriorityInherit_Pre_OwnerOwnerPriority_NA;
                 ++ctx->Map.pci[ 6 ]
               ) {
                 for (
                   ctx->Map.pci[ 7 ] = ScoreTqReqTimeoutPriorityInherit_Pre_WaitState_Blocked;
                   ctx->Map.pci[ 7 ] < ScoreTqReqTimeoutPriorityInherit_Pre_WaitState_NA;
                   ++ctx->Map.pci[ 7 ]
                 ) {
                   ctx->Map.entry = ScoreTqReqTimeoutPriorityInherit_PopEntry(
                     ctx
                   );
 
                   if ( ctx->Map.entry.Skip ) {
                     continue;
                   }
 
                   ScoreTqReqTimeoutPriorityInherit_SetPreConditionStates(
                     ctx
                   );
                   ScoreTqReqTimeoutPriorityInherit_Prepare( ctx );
                   ScoreTqReqTimeoutPriorityInherit_TestVariant( ctx );
                   ScoreTqReqTimeoutPriorityInherit_Cleanup( ctx );
                 }
               }
             }
           }
         }
       }
     }
   }
 
   T_add_remark( &ScoreTqReqTimeoutPriorityInherit_Remark );
   T_pop_fixture();
 }
 
 /** @} */

This page was automatically generated by the 2.3.7 LXR engine. The LXR team