validation: Refine thread queue timeouts

6 files changed, 2290 insertions, 268 deletions

diff --git a/spec/build/testsuites/validation/validation-no-clock-0.yml b/spec/build/testsuites/validation/validation-no-clock-0.yml
index 97a5eb0f52..21ad0af613 100644
--- a/spec/build/testsuites/validation/validation-no-clock-0.yml
+++ b/spec/build/testsuites/validation/validation-no-clock-0.yml
@@ -51,6 +51,7 @@ source:
 - testsuites/validation/tr-tq-surrender-mrsp.c
 - testsuites/validation/tr-tq-surrender-priority-inherit.c
 - testsuites/validation/tr-tq-timeout.c
+- testsuites/validation/tr-tq-timeout-mrsp.c
 - testsuites/validation/tr-tq-timeout-priority-inherit.c
 - testsuites/validation/ts-validation-no-clock-0.c
 stlib: []
diff --git a/testsuites/validation/tc-sem-timeout.c b/testsuites/validation/tc-sem-timeout.c
index 3859ffa658..254a6be5db 100644
--- a/testsuites/validation/tc-sem-timeout.c
+++ b/testsuites/validation/tc-sem-timeout.c
@@ -55,6 +55,7 @@
 #include <rtems.h>
 #include <string.h>
 
+#include "tr-tq-timeout-mrsp.h"
 #include "tr-tq-timeout-priority-inherit.h"
 #include "tr-tq-timeout.h"
 #include "tx-support.h"
@@ -88,6 +89,7 @@ typedef enum {
 
 typedef enum {
   RtemsSemReqTimeout_Post_Action_Timeout,
+  RtemsSemReqTimeout_Post_Action_TimeoutMrsP,
   RtemsSemReqTimeout_Post_Action_TimeoutPriorityInherit,
   RtemsSemReqTimeout_Post_Action_NA
 } RtemsSemReqTimeout_Post_Action;
@@ -273,15 +275,27 @@ static void RtemsSemReqTimeout_Post_Action_Check(
        * The semaphore obtain timeout actions shall be done as specified by
        * /score/tq/req/timeout.
        */
+      ctx->tq_ctx.wait = TQ_WAIT_TIMED;
       ScoreTqReqTimeout_Run( &ctx->tq_ctx );
       break;
     }
 
+    case RtemsSemReqTimeout_Post_Action_TimeoutMrsP: {
+      /*
+       * The semaphore obtain timeout actions shall be done as specified by
+       * /score/tq/req/timeout-mrsp.
+       */
+      ctx->tq_ctx.wait = TQ_WAIT_TIMED;
+      ScoreTqReqTimeoutMrsp_Run( &ctx->tq_ctx );
+      break;
+    }
+
     case RtemsSemReqTimeout_Post_Action_TimeoutPriorityInherit: {
       /*
        * The semaphore obtain timeout actions shall be done as specified by
        * /score/tq/req/timeout-priority-inherit.
        */
+      ctx->tq_ctx.wait = TQ_WAIT_FOREVER;
       ScoreTqReqTimeoutPriorityInherit_Run( &ctx->tq_ctx );
       break;
     }
@@ -294,7 +308,6 @@ static void RtemsSemReqTimeout_Post_Action_Check(
 static void RtemsSemReqTimeout_Setup( RtemsSemReqTimeout_Context *ctx )
 {
   memset( ctx, 0, sizeof( *ctx ) );
-  ctx->tq_ctx.wait = TQ_WAIT_TIMED;
   ctx->tq_ctx.enqueue_prepare = TQEnqueuePrepareDefault;
   ctx->tq_ctx.enqueue_done = TQEnqueueDoneDefault;
   ctx->tq_ctx.enqueue = TQEnqueueClassicSem;
@@ -360,7 +373,7 @@ RtemsSemReqTimeout_Entries[] = {
 #if !defined(RTEMS_SMP)
   { 1, 0, 0, RtemsSemReqTimeout_Post_Action_NA }
 #else
-  { 0, 0, 0, RtemsSemReqTimeout_Post_Action_TimeoutPriorityInherit }
+  { 0, 0, 0, RtemsSemReqTimeout_Post_Action_TimeoutMrsP }
 #endif
 };
 
diff --git a/testsuites/validation/tr-tq-timeout-mrsp.c b/testsuites/validation/tr-tq-timeout-mrsp.c
new file mode 100644
index 0000000000..2ee4960495
--- /dev/null
+++ b/testsuites/validation/tr-tq-timeout-mrsp.c
@@ -0,0 +1,476 @@
+/* SPDX-License-Identifier: BSD-2-Clause */
+
+/**
+ * @file
+ *
+ * @ingroup RTEMSTestCaseScoreTqReqTimeoutMrsp
+ */
+
+/*
+ * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de)
+ *
+ * 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-mrsp.h"
+#include "tx-support.h"
+
+#include <rtems/test.h>
+
+/**
+ * @defgroup RTEMSTestCaseScoreTqReqTimeoutMrsp spec:/score/tq/req/timeout-mrsp
+ *
+ * @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0
+ *
+ * @{
+ */
+
+typedef struct {
+  uint8_t Skip : 1;
+  uint8_t Pre_Scheduler_NA : 1;
+  uint8_t Pre_WaitState_NA : 1;
+  uint8_t Post_Status : 2;
+  uint8_t Post_Unblock : 1;
+} ScoreTqReqTimeoutMrsp_Entry;
+
+/**
+ * @brief Test context for spec:/score/tq/req/timeout-mrsp test case.
+ */
+typedef struct {
+  /**
+   * @brief If this member is true, then the enqueued thread shall use a home
+   *   scheduler other than the home scheduler of the owner.
+   */
+  bool other_scheduler;
+
+  /**
+   * @brief If this member is true, then the processor set of the schedulers
+   *   shall be restored.
+   */
+  bool restore_scheduler;
+
+  /**
+   * @brief This member contains a copy of the corresponding
+   *   ScoreTqReqTimeoutMrsp_Run() parameter.
+   */
+  TQContext *tq_ctx;
+
+  struct {
+    /**
+     * @brief This member defines the pre-condition states for the next action.
+     */
+    size_t pcs[ 2 ];
+
+    /**
+     * @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.
+     */
+    ScoreTqReqTimeoutMrsp_Entry entry;
+
+    /**
+     * @brief If this member is true, then the current transition variant
+     *   should be skipped.
+     */
+    bool skip;
+  } Map;
+} ScoreTqReqTimeoutMrsp_Context;
+
+static ScoreTqReqTimeoutMrsp_Context
+  ScoreTqReqTimeoutMrsp_Instance;
+
+static const char * const ScoreTqReqTimeoutMrsp_PreDesc_Scheduler[] = {
+  "Same",
+  "Other",
+  "NA"
+};
+
+static const char * const ScoreTqReqTimeoutMrsp_PreDesc_WaitState[] = {
+  "IntendToBlock",
+  "ReadyAgain",
+  "NA"
+};
+
+static const char * const * const ScoreTqReqTimeoutMrsp_PreDesc[] = {
+  ScoreTqReqTimeoutMrsp_PreDesc_Scheduler,
+  ScoreTqReqTimeoutMrsp_PreDesc_WaitState,
+  NULL
+};
+
+typedef ScoreTqReqTimeoutMrsp_Context Context;
+
+static const rtems_tcb *GetUnblock( Context *ctx, size_t *index )
+{
+  return TQGetNextUnblock( ctx->tq_ctx, index )->thread;
+}
+
+static void Tick( void *arg )
+{
+  Context *ctx;
+
+  ctx = arg;
+  TQSchedulerRecordStart( ctx->tq_ctx );
+  FinalClockTick();
+  TQSchedulerRecordStop( ctx->tq_ctx );
+}
+
+static void ScoreTqReqTimeoutMrsp_Pre_Scheduler_Prepare(
+  ScoreTqReqTimeoutMrsp_Context      *ctx,
+  ScoreTqReqTimeoutMrsp_Pre_Scheduler state
+)
+{
+  switch ( state ) {
+    case ScoreTqReqTimeoutMrsp_Pre_Scheduler_Same: {
+      /*
+       * While the home scheduler of the thread is equal to the home scheduler
+       * of the thread queue owner.
+       */
+      ctx->other_scheduler = false;
+
+      TQSetScheduler(
+        ctx->tq_ctx,
+        TQ_BLOCKER_A,
+        SCHEDULER_A_ID,
+        PRIO_LOW
+      );
+      RemoveProcessor( SCHEDULER_B_ID, 1 );
+      AddProcessor( SCHEDULER_A_ID, 1 );
+      ctx->restore_scheduler = true;
+      break;
+    }
+
+    case ScoreTqReqTimeoutMrsp_Pre_Scheduler_Other: {
+      /*
+       * While the home scheduler of the thread is not equal to the home
+       * scheduler of the thread queue owner.
+       */
+      ctx->other_scheduler = true;
+
+      TQSetScheduler(
+        ctx->tq_ctx,
+        TQ_BLOCKER_A,
+        SCHEDULER_B_ID,
+        PRIO_NORMAL
+      );
+      break;
+    }
+
+    case ScoreTqReqTimeoutMrsp_Pre_Scheduler_NA:
+      break;
+  }
+}
+
+static void ScoreTqReqTimeoutMrsp_Pre_WaitState_Prepare(
+  ScoreTqReqTimeoutMrsp_Context      *ctx,
+  ScoreTqReqTimeoutMrsp_Pre_WaitState state
+)
+{
+  switch ( state ) {
+    case ScoreTqReqTimeoutMrsp_Pre_WaitState_IntendToBlock: {
+      /*
+       * While the thread of the timeout operation is in the intend to block
+       * wait state.
+       */
+      Per_CPU_Control *cpu;
+
+      TQEnqueuePrepare( ctx->tq_ctx );
+      TQSendAndWaitForIntendToBlock(
+        ctx->tq_ctx,
+        TQ_BLOCKER_A,
+        TQ_EVENT_ENQUEUE
+      );
+      cpu = _Thread_Get_CPU( ctx->tq_ctx->worker_tcb[ TQ_BLOCKER_A ] );
+
+      /*
+       * We have to make sure that the worker thread inserted its thread
+       * timer.  Checking the intend to block wait state is not enough to
+       * ensure this.
+       */
+      while ( cpu->thread_dispatch_disable_level != 0 ) {
+        /* Wait */
+      }
+
+      Tick( ctx );
+      WaitForExecutionStop( ctx->tq_ctx->worker_id[ TQ_BLOCKER_A ] );
+      TQEnqueueDone( ctx->tq_ctx );
+      break;
+    }
+
+    case ScoreTqReqTimeoutMrsp_Pre_WaitState_ReadyAgain: {
+      /*
+       * While the thread of the timeout operation is in the ready again wait
+       * state.
+       */
+      TQEnqueuePrepare( ctx->tq_ctx );
+      TQSendAndWaitForIntendToBlock(
+        ctx->tq_ctx,
+        TQ_BLOCKER_A,
+        TQ_EVENT_ENQUEUE | TQ_EVENT_TIMEOUT | TQ_EVENT_SURRENDER |
+          TQ_EVENT_SCHEDULER_RECORD_STOP
+      );
+      TQSchedulerRecordStart( ctx->tq_ctx );
+      TQEnqueueDone( ctx->tq_ctx );
+      WaitForExecutionStop( ctx->tq_ctx->worker_id[ TQ_BLOCKER_A ] );
+      break;
+    }
+
+    case ScoreTqReqTimeoutMrsp_Pre_WaitState_NA:
+      break;
+  }
+}
+
+static void ScoreTqReqTimeoutMrsp_Post_Status_Check(
+  ScoreTqReqTimeoutMrsp_Context    *ctx,
+  ScoreTqReqTimeoutMrsp_Post_Status state
+)
+{
+  switch ( state ) {
+    case ScoreTqReqTimeoutMrsp_Post_Status_Ok: {
+      /*
+       * The return status of the directive call shall be derived from
+       * STATUS_SUCCESSFUL.
+       */
+      T_eq_int(
+        ctx->tq_ctx->status[ TQ_BLOCKER_A ],
+        TQConvertStatus( ctx->tq_ctx, STATUS_SUCCESSFUL )
+      );
+      break;
+    }
+
+    case ScoreTqReqTimeoutMrsp_Post_Status_Timeout: {
+      /*
+       * The return status of the directive call shall be derived from
+       * STATUS_TIMEOUT.
+       */
+      T_eq_int(
+        ctx->tq_ctx->status[ TQ_BLOCKER_A ],
+        TQConvertStatus( ctx->tq_ctx, STATUS_TIMEOUT )
+      );
+      break;
+    }
+
+    case ScoreTqReqTimeoutMrsp_Post_Status_NA:
+      break;
+  }
+}
+
+static void ScoreTqReqTimeoutMrsp_Post_Unblock_Check(
+  ScoreTqReqTimeoutMrsp_Context     *ctx,
+  ScoreTqReqTimeoutMrsp_Post_Unblock state
+)
+{
+  size_t i;
+
+  i = 0;
+
+  switch ( state ) {
+    case ScoreTqReqTimeoutMrsp_Post_Unblock_No: {
+      /*
+       * The thread of the timeout operation shall not be unblocked by the
+       * timeout operation.
+       */
+      T_eq_ptr( GetUnblock( ctx, &i ), NULL );
+      break;
+    }
+
+    case ScoreTqReqTimeoutMrsp_Post_Unblock_NA:
+      break;
+  }
+}
+
+static void ScoreTqReqTimeoutMrsp_Setup( ScoreTqReqTimeoutMrsp_Context *ctx )
+{
+  TQReset( ctx->tq_ctx );
+}
+
+static void ScoreTqReqTimeoutMrsp_Setup_Wrap( void *arg )
+{
+  ScoreTqReqTimeoutMrsp_Context *ctx;
+
+  ctx = arg;
+  ctx->Map.in_action_loop = false;
+  ScoreTqReqTimeoutMrsp_Setup( ctx );
+}
+
+static void ScoreTqReqTimeoutMrsp_Teardown(
+  ScoreTqReqTimeoutMrsp_Context *ctx
+)
+{
+  TQReset( ctx->tq_ctx );
+}
+
+static void ScoreTqReqTimeoutMrsp_Teardown_Wrap( void *arg )
+{
+  ScoreTqReqTimeoutMrsp_Context *ctx;
+
+  ctx = arg;
+  ctx->Map.in_action_loop = false;
+  ScoreTqReqTimeoutMrsp_Teardown( ctx );
+}
+
+static void ScoreTqReqTimeoutMrsp_Prepare( ScoreTqReqTimeoutMrsp_Context *ctx )
+{
+  ctx->restore_scheduler = false;
+}
+
+static void ScoreTqReqTimeoutMrsp_Action( ScoreTqReqTimeoutMrsp_Context *ctx )
+{
+  /*
+   * The action is performed by the ``WaitState`` pre-condition preparation.
+   */
+}
+
+static void ScoreTqReqTimeoutMrsp_Cleanup( ScoreTqReqTimeoutMrsp_Context *ctx )
+{
+  if ( ctx->restore_scheduler ) {
+    RemoveProcessor( SCHEDULER_A_ID, 1 );
+    AddProcessor( SCHEDULER_B_ID, 1 );
+  }
+}
+
+static const ScoreTqReqTimeoutMrsp_Entry
+ScoreTqReqTimeoutMrsp_Entries[] = {
+  { 0, 0, 0, ScoreTqReqTimeoutMrsp_Post_Status_Timeout,
+    ScoreTqReqTimeoutMrsp_Post_Unblock_No },
+  { 0, 0, 0, ScoreTqReqTimeoutMrsp_Post_Status_Ok,
+    ScoreTqReqTimeoutMrsp_Post_Unblock_No }
+};
+
+static const uint8_t
+ScoreTqReqTimeoutMrsp_Map[] = {
+  0, 1, 0, 1
+};
+
+static size_t ScoreTqReqTimeoutMrsp_Scope( void *arg, char *buf, size_t n )
+{
+  ScoreTqReqTimeoutMrsp_Context *ctx;
+
+  ctx = arg;
+
+  if ( ctx->Map.in_action_loop ) {
+    return T_get_scope( ScoreTqReqTimeoutMrsp_PreDesc, buf, n, ctx->Map.pcs );
+  }
+
+  return 0;
+}
+
+static T_fixture ScoreTqReqTimeoutMrsp_Fixture = {
+  .setup = ScoreTqReqTimeoutMrsp_Setup_Wrap,
+  .stop = NULL,
+  .teardown = ScoreTqReqTimeoutMrsp_Teardown_Wrap,
+  .scope = ScoreTqReqTimeoutMrsp_Scope,
+  .initial_context = &ScoreTqReqTimeoutMrsp_Instance
+};
+
+static inline ScoreTqReqTimeoutMrsp_Entry ScoreTqReqTimeoutMrsp_PopEntry(
+  ScoreTqReqTimeoutMrsp_Context *ctx
+)
+{
+  size_t index;
+
+  index = ctx->Map.index;
+  ctx->Map.index = index + 1;
+  return ScoreTqReqTimeoutMrsp_Entries[
+    ScoreTqReqTimeoutMrsp_Map[ index ]
+  ];
+}
+
+static void ScoreTqReqTimeoutMrsp_TestVariant(
+  ScoreTqReqTimeoutMrsp_Context *ctx
+)
+{
+  ScoreTqReqTimeoutMrsp_Pre_Scheduler_Prepare( ctx, ctx->Map.pcs[ 0 ] );
+  ScoreTqReqTimeoutMrsp_Pre_WaitState_Prepare( ctx, ctx->Map.pcs[ 1 ] );
+  ScoreTqReqTimeoutMrsp_Action( ctx );
+  ScoreTqReqTimeoutMrsp_Post_Status_Check( ctx, ctx->Map.entry.Post_Status );
+  ScoreTqReqTimeoutMrsp_Post_Unblock_Check( ctx, ctx->Map.entry.Post_Unblock );
+}
+
+static T_fixture_node ScoreTqReqTimeoutMrsp_Node;
+
+void ScoreTqReqTimeoutMrsp_Run( TQContext *tq_ctx )
+{
+  ScoreTqReqTimeoutMrsp_Context *ctx;
+
+  ctx = &ScoreTqReqTimeoutMrsp_Instance;
+  ctx->tq_ctx = tq_ctx;
+
+  ctx = T_push_fixture(
+    &ScoreTqReqTimeoutMrsp_Node,
+    &ScoreTqReqTimeoutMrsp_Fixture
+  );
+  ctx->Map.in_action_loop = true;
+  ctx->Map.index = 0;
+
+  for (
+    ctx->Map.pcs[ 0 ] = ScoreTqReqTimeoutMrsp_Pre_Scheduler_Same;
+    ctx->Map.pcs[ 0 ] < ScoreTqReqTimeoutMrsp_Pre_Scheduler_NA;
+    ++ctx->Map.pcs[ 0 ]
+  ) {
+    for (
+      ctx->Map.pcs[ 1 ] = ScoreTqReqTimeoutMrsp_Pre_WaitState_IntendToBlock;
+      ctx->Map.pcs[ 1 ] < ScoreTqReqTimeoutMrsp_Pre_WaitState_NA;
+      ++ctx->Map.pcs[ 1 ]
+    ) {
+      ctx->Map.entry = ScoreTqReqTimeoutMrsp_PopEntry( ctx );
+      ScoreTqReqTimeoutMrsp_Prepare( ctx );
+      ScoreTqReqTimeoutMrsp_TestVariant( ctx );
+      ScoreTqReqTimeoutMrsp_Cleanup( ctx );
+    }
+  }
+
+  T_pop_fixture();
+}
+
+/** @} */
diff --git a/testsuites/validation/tr-tq-timeout-mrsp.h b/testsuites/validation/tr-tq-timeout-mrsp.h
new file mode 100644
index 0000000000..a08ef170c5
--- /dev/null
+++ b/testsuites/validation/tr-tq-timeout-mrsp.h
@@ -0,0 +1,102 @@
+/* SPDX-License-Identifier: BSD-2-Clause */
+
+/**
+ * @file
+ *
+ * @ingroup RTEMSTestCaseScoreTqReqTimeoutMrsp
+ */
+
+/*
+ * Copyright (C) 2021 embedded brains GmbH (http://www.embedded-brains.de)
+ *
+ * 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
+ */
+
+#ifndef _TR_TQ_TIMEOUT_MRSP_H
+#define _TR_TQ_TIMEOUT_MRSP_H
+
+#include "tx-thread-queue.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @addtogroup RTEMSTestCaseScoreTqReqTimeoutMrsp
+ *
+ * @{
+ */
+
+typedef enum {
+  ScoreTqReqTimeoutMrsp_Pre_Scheduler_Same,
+  ScoreTqReqTimeoutMrsp_Pre_Scheduler_Other,
+  ScoreTqReqTimeoutMrsp_Pre_Scheduler_NA
+} ScoreTqReqTimeoutMrsp_Pre_Scheduler;
+
+typedef enum {
+  ScoreTqReqTimeoutMrsp_Pre_WaitState_IntendToBlock,
+  ScoreTqReqTimeoutMrsp_Pre_WaitState_ReadyAgain,
+  ScoreTqReqTimeoutMrsp_Pre_WaitState_NA
+} ScoreTqReqTimeoutMrsp_Pre_WaitState;
+
+typedef enum {
+  ScoreTqReqTimeoutMrsp_Post_Status_Ok,
+  ScoreTqReqTimeoutMrsp_Post_Status_Timeout,
+  ScoreTqReqTimeoutMrsp_Post_Status_NA
+} ScoreTqReqTimeoutMrsp_Post_Status;
+
+typedef enum {
+  ScoreTqReqTimeoutMrsp_Post_Unblock_No,
+  ScoreTqReqTimeoutMrsp_Post_Unblock_NA
+} ScoreTqReqTimeoutMrsp_Post_Unblock;
+
+/**
+ * @brief Runs the parameterized test case.
+ *
+ * @param[in,out] tq_ctx is the thread queue test context.
+ */
+void ScoreTqReqTimeoutMrsp_Run( TQContext *tq_ctx );
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _TR_TQ_TIMEOUT_MRSP_H */
diff --git a/testsuites/validation/tr-tq-timeout-priority-inherit.c b/testsuites/validation/tr-tq-timeout-priority-inherit.c
index bfc4a90965..6e744ba7d9 100644
--- a/testsuites/validation/tr-tq-timeout-priority-inherit.c
+++ b/testsuites/validation/tr-tq-timeout-priority-inherit.c
@@ -70,12 +70,19 @@
  */
 
 typedef struct {
-  uint8_t Skip : 1;
-  uint8_t Pre_EnqueueVariant_NA : 1;
-  uint8_t Pre_Scheduler_NA : 1;
-  uint8_t Pre_WaitState_NA : 1;
-  uint8_t Post_Status : 2;
-  uint8_t Post_Unblock : 2;
+  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;
 
 /**
@@ -89,16 +96,111 @@ typedef struct {
   CallWithinISRRequest request;;
 
   /**
-   * @brief If this member is true, then the enqueued thread shall use a home
-   *   scheduler other than the home scheduler of the owner.
+   * @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 If this member is true, then the processor set of the schedulers
-   *   shall be restored.
+   * @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 restore_scheduler;
+  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
@@ -108,9 +210,15 @@ typedef struct {
 
   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[ 3 ];
+    size_t pcs[ 8 ];
 
     /**
      * @brief If this member is true, then the test action loop is executed.
@@ -138,15 +246,51 @@ typedef struct {
 static ScoreTqReqTimeoutPriorityInherit_Context
   ScoreTqReqTimeoutPriorityInherit_Instance;
 
-static const char * const ScoreTqReqTimeoutPriorityInherit_PreDesc_EnqueueVariant[] = {
-  "Blocking",
-  "Sticky",
+static const char * const ScoreTqReqTimeoutPriorityInherit_PreDesc_HomeScheduler[] = {
+  "Home",
+  "Helping",
   "NA"
 };
 
-static const char * const ScoreTqReqTimeoutPriorityInherit_PreDesc_Scheduler[] = {
-  "Same",
-  "Other",
+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"
 };
 
@@ -158,22 +302,52 @@ static const char * const ScoreTqReqTimeoutPriorityInherit_PreDesc_WaitState[] =
 };
 
 static const char * const * const ScoreTqReqTimeoutPriorityInherit_PreDesc[] = {
-  ScoreTqReqTimeoutPriorityInherit_PreDesc_EnqueueVariant,
-  ScoreTqReqTimeoutPriorityInherit_PreDesc_Scheduler,
+  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;
 
-static const rtems_tcb *GetUnblock( Context *ctx, size_t *index )
-{
-  return TQGetNextUnblock( ctx->tq_ctx, index )->thread;
-}
+#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 const rtems_tcb *GetTCB( Context *ctx, TQWorkerKind worker )
+static bool GetUnblock( const Context *ctx, size_t *index )
 {
-  return ctx->tq_ctx->worker_tcb[ worker ];
+  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 )
@@ -198,7 +372,8 @@ static void SchedulerBlock(
 
   if (
     when == T_SCHEDULER_BEFORE &&
-    event->operation == T_SCHEDULER_BLOCK
+    event->operation == T_SCHEDULER_BLOCK &&
+    event->thread == ctx->tq_ctx->worker_tcb[ THREAD ]
   ) {
     T_scheduler_set_event_handler( NULL, NULL );
     ctx->request.handler = Tick;
@@ -213,7 +388,7 @@ static void ThreadTimeout( void *arg )
   ctx = arg;
   TQSchedulerRecordStart( ctx->tq_ctx );
   _Thread_Timeout(
-    &ctx->tq_ctx->worker_tcb[ TQ_BLOCKER_A ]->Timer.Watchdog
+    &ctx->tq_ctx->worker_tcb[ THREAD ]->Timer.Watchdog
   );
   TQSchedulerRecordStop( ctx->tq_ctx );
 }
@@ -230,11 +405,12 @@ static void SchedulerUnblock(
 
   if (
     when == T_SCHEDULER_BEFORE &&
-    event->operation == T_SCHEDULER_UNBLOCK
+    event->operation == T_SCHEDULER_UNBLOCK &&
+    event->thread == ctx->tq_ctx->worker_tcb[ THREAD ]
   ) {
     T_scheduler_set_event_handler( NULL, NULL );
 
-    if ( ctx->other_scheduler ) {
+    if ( ctx->scheduler_id == SCHEDULER_B_ID ) {
 #if defined(RTEMS_SMP)
       _SMP_Unicast_action( 1, ThreadTimeout, ctx );
 #else
@@ -247,88 +423,553 @@ static void SchedulerUnblock(
   }
 }
 
-static void ScoreTqReqTimeoutPriorityInherit_Pre_EnqueueVariant_Prepare(
-  ScoreTqReqTimeoutPriorityInherit_Context           *ctx,
-  ScoreTqReqTimeoutPriorityInherit_Pre_EnqueueVariant state
+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_EnqueueVariant_Blocking: {
+    case ScoreTqReqTimeoutPriorityInherit_Pre_HomeScheduler_Home: {
       /*
-       * Where the thread queue enqueue operation is blocking.
+       * While the home scheduler of the thread is the home scheduler of the
+       * thread queue owner.
        */
-      if ( ctx->tq_ctx->enqueue_variant != TQ_ENQUEUE_BLOCKS ) {
-        ctx->Map.skip = true;
-      }
+      ctx->scheduler_id = SCHEDULER_A_ID;
       break;
     }
 
-    case ScoreTqReqTimeoutPriorityInherit_Pre_EnqueueVariant_Sticky: {
+    case ScoreTqReqTimeoutPriorityInherit_Pre_HomeScheduler_Helping: {
       /*
-       * Where the thread queue enqueue operation is sticky.
+       * While the home scheduler of the thread is a helping scheduler of the
+       * thread queue owner.
        */
-      if ( ctx->tq_ctx->enqueue_variant != TQ_ENQUEUE_STICKY ) {
-        ctx->Map.skip = true;
-      }
+      ctx->scheduler_id = SCHEDULER_B_ID;
       break;
     }
 
-    case ScoreTqReqTimeoutPriorityInherit_Pre_EnqueueVariant_NA:
+    case ScoreTqReqTimeoutPriorityInherit_Pre_HomeScheduler_NA:
       break;
   }
 }
 
-static void ScoreTqReqTimeoutPriorityInherit_Pre_Scheduler_Prepare(
-  ScoreTqReqTimeoutPriorityInherit_Context      *ctx,
-  ScoreTqReqTimeoutPriorityInherit_Pre_Scheduler state
+static void ScoreTqReqTimeoutPriorityInherit_Pre_EligibleScheduler_Prepare(
+  ScoreTqReqTimeoutPriorityInherit_Context              *ctx,
+  ScoreTqReqTimeoutPriorityInherit_Pre_EligibleScheduler state
 )
 {
   switch ( state ) {
-    case ScoreTqReqTimeoutPriorityInherit_Pre_Scheduler_Same: {
+    case ScoreTqReqTimeoutPriorityInherit_Pre_EligibleScheduler_One: {
       /*
-       * While the home scheduler of the thread is equal to the home scheduler
-       * of the thread queue owner.
+       * While the thread has exactly one eligible scheduler.
        */
       ctx->other_scheduler = false;
-
-      if ( ctx->tq_ctx->enqueue_variant == TQ_ENQUEUE_STICKY ) {
-        TQSetScheduler(
-          ctx->tq_ctx,
-          TQ_BLOCKER_A,
-          SCHEDULER_A_ID,
-          PRIO_LOW
-        );
-        RemoveProcessor( SCHEDULER_B_ID, 1 );
-        AddProcessor( SCHEDULER_A_ID, 1 );
-        ctx->restore_scheduler = true;
-      } else {
-        TQSetScheduler(
-          ctx->tq_ctx,
-          TQ_BLOCKER_A,
-          SCHEDULER_A_ID,
-          PRIO_ULTRA_HIGH
-        );
-      }
       break;
     }
 
-    case ScoreTqReqTimeoutPriorityInherit_Pre_Scheduler_Other: {
+    case ScoreTqReqTimeoutPriorityInherit_Pre_EligibleScheduler_More: {
       /*
-       * While the home scheduler of the thread is not equal to the home
-       * scheduler of the thread queue owner.
+       * While the thread has at least two eligible scheduler.
        */
       ctx->other_scheduler = true;
+      break;
+    }
 
-      TQSetScheduler(
-        ctx->tq_ctx,
-        TQ_BLOCKER_A,
-        SCHEDULER_B_ID,
-        PRIO_NORMAL
-      );
+    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_Scheduler_NA:
+    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;
   }
 }
@@ -341,98 +982,25 @@ static void ScoreTqReqTimeoutPriorityInherit_Pre_WaitState_Prepare(
   switch ( state ) {
     case ScoreTqReqTimeoutPriorityInherit_Pre_WaitState_Blocked: {
       /*
-       * While the thread of the timeout operation is in the blocked wait
-       * state.
+       * While the thread is in the blocked wait state.
        */
-      if ( ctx->tq_ctx->enqueue_variant == TQ_ENQUEUE_STICKY ) {
-        T_unreachable();
-      } else {
-        TQEnqueuePrepare( ctx->tq_ctx );
-        TQClearDone( ctx->tq_ctx, TQ_BLOCKER_A );
-        TQSendAndWaitForExecutionStop(
-          ctx->tq_ctx,
-          TQ_BLOCKER_A,
-          TQ_EVENT_ENQUEUE
-        );
-        Tick( ctx );
-        TQWaitForDone( ctx->tq_ctx, TQ_BLOCKER_A );
-        TQEnqueueDone( ctx->tq_ctx );
-      }
+      ctx->wait_state = TQ_WAIT_STATE_BLOCKED;
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Pre_WaitState_IntendToBlock: {
       /*
-       * While the thread of the timeout operation is in the intend to block
-       * wait state.
+       * While the thread is in the intend to block wait state.
        */
-      TQEnqueuePrepare( ctx->tq_ctx );
-
-      if ( ctx->tq_ctx->enqueue_variant == TQ_ENQUEUE_STICKY ) {
-        Per_CPU_Control *cpu;
-
-        TQSendAndWaitForIntendToBlock(
-          ctx->tq_ctx,
-          TQ_BLOCKER_A,
-          TQ_EVENT_ENQUEUE
-        );
-        cpu = _Thread_Get_CPU( ctx->tq_ctx->worker_tcb[ TQ_BLOCKER_A ] );
-
-        /*
-         * We have to make sure that the worker thread inserted its thread
-         * timer.  Checking the intend to block wait state is not enough to
-         * ensure this.
-         */
-        while ( cpu->thread_dispatch_disable_level != 0 ) {
-          /* Wait */
-        }
-
-        Tick( ctx );
-        WaitForExecutionStop( ctx->tq_ctx->worker_id[ TQ_BLOCKER_A ] );
-      } else {
-        T_scheduler_set_event_handler( SchedulerBlock, ctx );
-        TQSendAndWaitForExecutionStop(
-          ctx->tq_ctx,
-          TQ_BLOCKER_A,
-          TQ_EVENT_ENQUEUE
-        );
-      }
-
-      TQEnqueueDone( ctx->tq_ctx );
+      ctx->wait_state = TQ_WAIT_STATE_INTEND_TO_BLOCK;
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Pre_WaitState_ReadyAgain: {
       /*
-       * While the thread of the timeout operation is in the ready again wait
-       * state.
+       * While the thread is in the ready again wait state.
        */
-      TQEnqueuePrepare( ctx->tq_ctx );
-
-      if ( ctx->tq_ctx->enqueue_variant == TQ_ENQUEUE_STICKY ) {
-        TQSendAndWaitForIntendToBlock(
-          ctx->tq_ctx,
-          TQ_BLOCKER_A,
-          TQ_EVENT_ENQUEUE | TQ_EVENT_TIMEOUT | TQ_EVENT_SURRENDER |
-            TQ_EVENT_SCHEDULER_RECORD_STOP
-        );
-        TQSchedulerRecordStart( ctx->tq_ctx );
-        TQEnqueueDone( ctx->tq_ctx );
-        WaitForExecutionStop( ctx->tq_ctx->worker_id[ TQ_BLOCKER_A ] );
-      } else {
-        TQSendAndWaitForExecutionStop(
-          ctx->tq_ctx,
-          TQ_BLOCKER_A,
-          TQ_EVENT_ENQUEUE
-        );
-        T_scheduler_set_event_handler( SchedulerUnblock, ctx );
-        TQEnqueueDone( ctx->tq_ctx );
-        TQSendAndWaitForExecutionStop(
-          ctx->tq_ctx,
-          TQ_BLOCKER_A,
-          TQ_EVENT_SURRENDER
-        );
-      }
+      ctx->wait_state = TQ_WAIT_STATE_READY_AGAIN;
       break;
     }
 
@@ -453,7 +1021,7 @@ static void ScoreTqReqTimeoutPriorityInherit_Post_Status_Check(
        * STATUS_SUCCESSFUL.
        */
       T_eq_int(
-        ctx->tq_ctx->status[ TQ_BLOCKER_A ],
+        ctx->tq_ctx->status[ THREAD ],
         TQConvertStatus( ctx->tq_ctx, STATUS_SUCCESSFUL )
       );
       break;
@@ -465,7 +1033,7 @@ static void ScoreTqReqTimeoutPriorityInherit_Post_Status_Check(
        * STATUS_TIMEOUT.
        */
       T_eq_int(
-        ctx->tq_ctx->status[ TQ_BLOCKER_A ],
+        ctx->tq_ctx->status[ THREAD ],
         TQConvertStatus( ctx->tq_ctx, STATUS_TIMEOUT )
       );
       break;
@@ -488,20 +1056,18 @@ static void ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Check(
   switch ( state ) {
     case ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes: {
       /*
-       * The thread of the timeout operation shall be unblocked by the timeout
-       * operation.
+       * The thread shall be unblocked by the timeout operation.
        */
-      T_eq_ptr( GetUnblock( ctx, &i ), GetTCB( ctx, TQ_BLOCKER_A ) );
-      T_eq_ptr( GetUnblock( ctx, &i ), NULL );
+      T_true( GetUnblock( ctx, &i ) );
+      T_false( GetUnblock( ctx, &i ) );
       break;
     }
 
     case ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No: {
       /*
-       * The thread of the timeout operation shall not be unblocked by the
-       * timeout operation.
+       * The thread shall not be unblocked by the timeout operation.
        */
-      T_eq_ptr( GetUnblock( ctx, &i ), NULL );
+      T_false( GetUnblock( ctx, &i ) );
       break;
     }
 
@@ -510,12 +1076,90 @@ static void ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Check(
   }
 }
 
+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 )
@@ -547,71 +1191,761 @@ static void ScoreTqReqTimeoutPriorityInherit_Prepare(
   ScoreTqReqTimeoutPriorityInherit_Context *ctx
 )
 {
-  ctx->restore_scheduler = false;
+  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
 )
 {
-  /*
-   * The action is performed by the ``WaitState`` pre-condition preparation.
-   */
+  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->restore_scheduler ) {
-    RemoveProcessor( SCHEDULER_A_ID, 1 );
-    AddProcessor( SCHEDULER_B_ID, 1 );
+  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[] = {
-  { 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
-    ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No },
-  { 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_Ok,
-    ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No },
 #if !defined(RTEMS_SMP)
-  { 1, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
-    ScoreTqReqTimeoutPriorityInherit_Post_Unblock_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 },
+#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, ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
-    ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No },
+  { 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, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
-    ScoreTqReqTimeoutPriorityInherit_Post_Unblock_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 },
 #else
-  { 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_Ok,
-    ScoreTqReqTimeoutPriorityInherit_Post_Unblock_No },
+  { 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
-  { 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
-    ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes },
 #if !defined(RTEMS_SMP)
-  { 1, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
-    ScoreTqReqTimeoutPriorityInherit_Post_Unblock_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 },
 #else
-  { 0, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_Timeout,
-    ScoreTqReqTimeoutPriorityInherit_Post_Unblock_Yes },
+  { 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
-  { 1, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
-    ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA },
 #if !defined(RTEMS_SMP)
-  { 1, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
-    ScoreTqReqTimeoutPriorityInherit_Post_Unblock_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 },
 #else
-  { 1, 0, 0, 0, ScoreTqReqTimeoutPriorityInherit_Post_Status_NA,
-    ScoreTqReqTimeoutPriorityInherit_Post_Unblock_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 },
+#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[] = {
-  4, 0, 1, 5, 2, 3, 6, 0, 1, 7, 2, 3
+  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(
@@ -644,25 +1978,6 @@ static T_fixture ScoreTqReqTimeoutPriorityInherit_Fixture = {
   .initial_context = &ScoreTqReqTimeoutPriorityInherit_Instance
 };
 
-static const uint8_t ScoreTqReqTimeoutPriorityInherit_Weights[] = {
-  6, 3, 1
-};
-
-static void ScoreTqReqTimeoutPriorityInherit_Skip(
-  ScoreTqReqTimeoutPriorityInherit_Context *ctx,
-  size_t                                    index
-)
-{
-  switch ( index + 1 ) {
-    case 1:
-      ctx->Map.pcs[ 1 ] = ScoreTqReqTimeoutPriorityInherit_Pre_Scheduler_NA - 1;
-      /* Fall through */
-    case 2:
-      ctx->Map.pcs[ 2 ] = ScoreTqReqTimeoutPriorityInherit_Pre_WaitState_NA - 1;
-      break;
-  }
-}
-
 static inline ScoreTqReqTimeoutPriorityInherit_Entry
 ScoreTqReqTimeoutPriorityInherit_PopEntry(
   ScoreTqReqTimeoutPriorityInherit_Context *ctx
@@ -670,47 +1985,70 @@ ScoreTqReqTimeoutPriorityInherit_PopEntry(
 {
   size_t index;
 
-  if ( ctx->Map.skip ) {
-    size_t i;
-
-    ctx->Map.skip = false;
-    index = 0;
+  index = ctx->Map.index;
+  ctx->Map.index = index + 1;
+  return ScoreTqReqTimeoutPriorityInherit_Entries[
+    ScoreTqReqTimeoutPriorityInherit_Map[ index ]
+  ];
+}
 
-    for ( i = 0; i < 3; ++i ) {
-      index += ScoreTqReqTimeoutPriorityInherit_Weights[ i ] * ctx->Map.pcs[ i ];
-    }
+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 {
-    index = ctx->Map.index;
+    ctx->Map.pcs[ 5 ] = ctx->Map.pci[ 5 ];
   }
 
-  ctx->Map.index = index + 1;
+  if ( ctx->Map.entry.Pre_OwnerOwnerPriority_NA ) {
+    ctx->Map.pcs[ 6 ] = ScoreTqReqTimeoutPriorityInherit_Pre_OwnerOwnerPriority_NA;
+  } else {
+    ctx->Map.pcs[ 6 ] = ctx->Map.pci[ 6 ];
+  }
 
-  return ScoreTqReqTimeoutPriorityInherit_Entries[
-    ScoreTqReqTimeoutPriorityInherit_Map[ index ]
-  ];
+  ctx->Map.pcs[ 7 ] = ctx->Map.pci[ 7 ];
 }
 
 static void ScoreTqReqTimeoutPriorityInherit_TestVariant(
   ScoreTqReqTimeoutPriorityInherit_Context *ctx
 )
 {
-  ScoreTqReqTimeoutPriorityInherit_Pre_EnqueueVariant_Prepare(
+  ScoreTqReqTimeoutPriorityInherit_Pre_HomeScheduler_Prepare(
     ctx,
     ctx->Map.pcs[ 0 ]
   );
-
-  if ( ctx->Map.skip ) {
-    ScoreTqReqTimeoutPriorityInherit_Skip( ctx, 0 );
-    return;
-  }
-
-  ScoreTqReqTimeoutPriorityInherit_Pre_Scheduler_Prepare(
+  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[ 2 ]
+    ctx->Map.pcs[ 7 ]
   );
   ScoreTqReqTimeoutPriorityInherit_Action( ctx );
   ScoreTqReqTimeoutPriorityInherit_Post_Status_Check(
@@ -721,6 +2059,14 @@ static void ScoreTqReqTimeoutPriorityInherit_TestVariant(
     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;
@@ -738,32 +2084,66 @@ void ScoreTqReqTimeoutPriorityInherit_Run( TQContext *tq_ctx )
   );
   ctx->Map.in_action_loop = true;
   ctx->Map.index = 0;
-  ctx->Map.skip = false;
 
   for (
-    ctx->Map.pcs[ 0 ] = ScoreTqReqTimeoutPriorityInherit_Pre_EnqueueVariant_Blocking;
-    ctx->Map.pcs[ 0 ] < ScoreTqReqTimeoutPriorityInherit_Pre_EnqueueVariant_NA;
-    ++ctx->Map.pcs[ 0 ]
+    ctx->Map.pci[ 0 ] = ScoreTqReqTimeoutPriorityInherit_Pre_HomeScheduler_Home;
+    ctx->Map.pci[ 0 ] < ScoreTqReqTimeoutPriorityInherit_Pre_HomeScheduler_NA;
+    ++ctx->Map.pci[ 0 ]
   ) {
     for (
-      ctx->Map.pcs[ 1 ] = ScoreTqReqTimeoutPriorityInherit_Pre_Scheduler_Same;
-      ctx->Map.pcs[ 1 ] < ScoreTqReqTimeoutPriorityInherit_Pre_Scheduler_NA;
-      ++ctx->Map.pcs[ 1 ]
+      ctx->Map.pci[ 1 ] = ScoreTqReqTimeoutPriorityInherit_Pre_EligibleScheduler_One;
+      ctx->Map.pci[ 1 ] < ScoreTqReqTimeoutPriorityInherit_Pre_EligibleScheduler_NA;
+      ++ctx->Map.pci[ 1 ]
     ) {
       for (
-        ctx->Map.pcs[ 2 ] = ScoreTqReqTimeoutPriorityInherit_Pre_WaitState_Blocked;
-        ctx->Map.pcs[ 2 ] < ScoreTqReqTimeoutPriorityInherit_Pre_WaitState_NA;
-        ++ctx->Map.pcs[ 2 ]
+        ctx->Map.pci[ 2 ] = ScoreTqReqTimeoutPriorityInherit_Pre_Queue_Only;
+        ctx->Map.pci[ 2 ] < ScoreTqReqTimeoutPriorityInherit_Pre_Queue_NA;
+        ++ctx->Map.pci[ 2 ]
       ) {
-        ctx->Map.entry = ScoreTqReqTimeoutPriorityInherit_PopEntry( ctx );
-
-        if ( ctx->Map.entry.Skip ) {
-          continue;
+        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 );
+                }
+              }
+            }
+          }
         }
-
-        ScoreTqReqTimeoutPriorityInherit_Prepare( ctx );
-        ScoreTqReqTimeoutPriorityInherit_TestVariant( ctx );
-        ScoreTqReqTimeoutPriorityInherit_Cleanup( ctx );
       }
     }
   }
diff --git a/testsuites/validation/tr-tq-timeout-priority-inherit.h b/testsuites/validation/tr-tq-timeout-priority-inherit.h
index 5e98c92cde..a75665f659 100644
--- a/testsuites/validation/tr-tq-timeout-priority-inherit.h
+++ b/testsuites/validation/tr-tq-timeout-priority-inherit.h
@@ -64,16 +64,52 @@ extern "C" {
  */
 
 typedef enum {
-  ScoreTqReqTimeoutPriorityInherit_Pre_EnqueueVariant_Blocking,
-  ScoreTqReqTimeoutPriorityInherit_Pre_EnqueueVariant_Sticky,
-  ScoreTqReqTimeoutPriorityInherit_Pre_EnqueueVariant_NA
-} ScoreTqReqTimeoutPriorityInherit_Pre_EnqueueVariant;
+  ScoreTqReqTimeoutPriorityInherit_Pre_HomeScheduler_Home,
+  ScoreTqReqTimeoutPriorityInherit_Pre_HomeScheduler_Helping,
+  ScoreTqReqTimeoutPriorityInherit_Pre_HomeScheduler_NA
+} ScoreTqReqTimeoutPriorityInherit_Pre_HomeScheduler;
 
 typedef enum {
-  ScoreTqReqTimeoutPriorityInherit_Pre_Scheduler_Same,
-  ScoreTqReqTimeoutPriorityInherit_Pre_Scheduler_Other,
-  ScoreTqReqTimeoutPriorityInherit_Pre_Scheduler_NA
-} ScoreTqReqTimeoutPriorityInherit_Pre_Scheduler;
+  ScoreTqReqTimeoutPriorityInherit_Pre_EligibleScheduler_One,
+  ScoreTqReqTimeoutPriorityInherit_Pre_EligibleScheduler_More,
+  ScoreTqReqTimeoutPriorityInherit_Pre_EligibleScheduler_NA
+} ScoreTqReqTimeoutPriorityInherit_Pre_EligibleScheduler;
+
+typedef enum {
+  ScoreTqReqTimeoutPriorityInherit_Pre_Queue_Only,
+  ScoreTqReqTimeoutPriorityInherit_Pre_Queue_Vital,
+  ScoreTqReqTimeoutPriorityInherit_Pre_Queue_Dispensable,
+  ScoreTqReqTimeoutPriorityInherit_Pre_Queue_NA
+} ScoreTqReqTimeoutPriorityInherit_Pre_Queue;
+
+typedef enum {
+  ScoreTqReqTimeoutPriorityInherit_Pre_OwnerPriority_Only,
+  ScoreTqReqTimeoutPriorityInherit_Pre_OwnerPriority_Vital,
+  ScoreTqReqTimeoutPriorityInherit_Pre_OwnerPriority_Dispensable,
+  ScoreTqReqTimeoutPriorityInherit_Pre_OwnerPriority_NA
+} ScoreTqReqTimeoutPriorityInherit_Pre_OwnerPriority;
+
+typedef enum {
+  ScoreTqReqTimeoutPriorityInherit_Pre_OwnerState_NotEnqueued,
+  ScoreTqReqTimeoutPriorityInherit_Pre_OwnerState_FIFO,
+  ScoreTqReqTimeoutPriorityInherit_Pre_OwnerState_Priority,
+  ScoreTqReqTimeoutPriorityInherit_Pre_OwnerState_PriorityInherit,
+  ScoreTqReqTimeoutPriorityInherit_Pre_OwnerState_NA
+} ScoreTqReqTimeoutPriorityInherit_Pre_OwnerState;
+
+typedef enum {
+  ScoreTqReqTimeoutPriorityInherit_Pre_OwnerQueue_Only,
+  ScoreTqReqTimeoutPriorityInherit_Pre_OwnerQueue_Vital,
+  ScoreTqReqTimeoutPriorityInherit_Pre_OwnerQueue_Dispensable,
+  ScoreTqReqTimeoutPriorityInherit_Pre_OwnerQueue_NA
+} ScoreTqReqTimeoutPriorityInherit_Pre_OwnerQueue;
+
+typedef enum {
+  ScoreTqReqTimeoutPriorityInherit_Pre_OwnerOwnerPriority_Only,
+  ScoreTqReqTimeoutPriorityInherit_Pre_OwnerOwnerPriority_Vital,
+  ScoreTqReqTimeoutPriorityInherit_Pre_OwnerOwnerPriority_Dispensable,
+  ScoreTqReqTimeoutPriorityInherit_Pre_OwnerOwnerPriority_NA
+} ScoreTqReqTimeoutPriorityInherit_Pre_OwnerOwnerPriority;
 
 typedef enum {
   ScoreTqReqTimeoutPriorityInherit_Pre_WaitState_Blocked,
@@ -94,6 +130,20 @@ typedef enum {
   ScoreTqReqTimeoutPriorityInherit_Post_Unblock_NA
 } ScoreTqReqTimeoutPriorityInherit_Post_Unblock;
 
+typedef enum {
+  ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Nop,
+  ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Lower,
+  ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_Drop,
+  ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority_NA
+} ScoreTqReqTimeoutPriorityInherit_Post_OwnerPriority;
+
+typedef enum {
+  ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Nop,
+  ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Lower,
+  ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_Drop,
+  ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority_NA
+} ScoreTqReqTimeoutPriorityInherit_Post_OwnerOwnerPriority;
+
 /**
  * @brief Runs the parameterized test case.
  *