validation: Add signal manager tests

Update #4244.

4 files changed, 2167 insertions, 0 deletions

diff --git a/spec/build/testsuites/validation/validation-0.yml b/spec/build/testsuites/validation/validation-0.yml
index 70448cb091..02e5744145 100644
--- a/spec/build/testsuites/validation/validation-0.yml
+++ b/spec/build/testsuites/validation/validation-0.yml
@@ -17,6 +17,8 @@ source:
 - testsuites/validation/tc-barrier-wait.c
 - testsuites/validation/tc-message-construct-errors.c
 - testsuites/validation/tc-object.c
+- testsuites/validation/tc-signal-catch.c
+- testsuites/validation/tc-signal-send.c
 - testsuites/validation/tc-task-construct-errors.c
 - testsuites/validation/ts-validation-0.c
 stlib: []
diff --git a/spec/build/testsuites/validation/validation-1.yml b/spec/build/testsuites/validation/validation-1.yml
index 4972e45034..fa61c96c2f 100644
--- a/spec/build/testsuites/validation/validation-1.yml
+++ b/spec/build/testsuites/validation/validation-1.yml
@@ -11,6 +11,8 @@ includes: []
 ldflags: []
 links: []
 source:
+- testsuites/validation/tc-signal-catch.c
+- testsuites/validation/tc-signal-send.c
 - testsuites/validation/ts-validation-1.c
 stlib: []
 target: testsuites/validation/ts-validation-1.exe
diff --git a/testsuites/validation/tc-signal-catch.c b/testsuites/validation/tc-signal-catch.c
new file mode 100644
index 0000000000..9c14cc93a3
--- /dev/null
+++ b/testsuites/validation/tc-signal-catch.c
@@ -0,0 +1,1017 @@
+/* SPDX-License-Identifier: BSD-2-Clause */
+
+/**
+ * @file
+ *
+ * @ingroup RTEMSTestCaseRtemsSignalReqCatch
+ */
+
+/*
+ * 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.h>
+
+#include <rtems/test.h>
+
+/**
+ * @defgroup RTEMSTestCaseRtemsSignalReqCatch spec:/rtems/signal/req/catch
+ *
+ * @ingroup RTEMSTestSuiteTestsuitesValidation0
+ * @ingroup RTEMSTestSuiteTestsuitesValidation1
+ *
+ * @{
+ */
+
+typedef enum {
+  RtemsSignalReqCatch_Pre_Handler_Invalid,
+  RtemsSignalReqCatch_Pre_Handler_Valid,
+  RtemsSignalReqCatch_Pre_Handler_NA
+} RtemsSignalReqCatch_Pre_Handler;
+
+typedef enum {
+  RtemsSignalReqCatch_Pre_Preempt_Yes,
+  RtemsSignalReqCatch_Pre_Preempt_No,
+  RtemsSignalReqCatch_Pre_Preempt_NA
+} RtemsSignalReqCatch_Pre_Preempt;
+
+typedef enum {
+  RtemsSignalReqCatch_Pre_Timeslice_Yes,
+  RtemsSignalReqCatch_Pre_Timeslice_No,
+  RtemsSignalReqCatch_Pre_Timeslice_NA
+} RtemsSignalReqCatch_Pre_Timeslice;
+
+typedef enum {
+  RtemsSignalReqCatch_Pre_ASR_Yes,
+  RtemsSignalReqCatch_Pre_ASR_No,
+  RtemsSignalReqCatch_Pre_ASR_NA
+} RtemsSignalReqCatch_Pre_ASR;
+
+typedef enum {
+  RtemsSignalReqCatch_Pre_IntLvl_Zero,
+  RtemsSignalReqCatch_Pre_IntLvl_Positive,
+  RtemsSignalReqCatch_Pre_IntLvl_NA
+} RtemsSignalReqCatch_Pre_IntLvl;
+
+typedef enum {
+  RtemsSignalReqCatch_Post_Status_Ok,
+  RtemsSignalReqCatch_Post_Status_NotImplNoPreempt,
+  RtemsSignalReqCatch_Post_Status_NotImplIntLvl,
+  RtemsSignalReqCatch_Post_Status_NA
+} RtemsSignalReqCatch_Post_Status;
+
+typedef enum {
+  RtemsSignalReqCatch_Post_Send_New,
+  RtemsSignalReqCatch_Post_Send_NotDef,
+  RtemsSignalReqCatch_Post_Send_NA
+} RtemsSignalReqCatch_Post_Send;
+
+typedef enum {
+  RtemsSignalReqCatch_Post_Preempt_Yes,
+  RtemsSignalReqCatch_Post_Preempt_No,
+  RtemsSignalReqCatch_Post_Preempt_NA
+} RtemsSignalReqCatch_Post_Preempt;
+
+typedef enum {
+  RtemsSignalReqCatch_Post_Timeslice_Yes,
+  RtemsSignalReqCatch_Post_Timeslice_No,
+  RtemsSignalReqCatch_Post_Timeslice_NA
+} RtemsSignalReqCatch_Post_Timeslice;
+
+typedef enum {
+  RtemsSignalReqCatch_Post_ASR_Yes,
+  RtemsSignalReqCatch_Post_ASR_No,
+  RtemsSignalReqCatch_Post_ASR_NA
+} RtemsSignalReqCatch_Post_ASR;
+
+typedef enum {
+  RtemsSignalReqCatch_Post_IntLvl_Zero,
+  RtemsSignalReqCatch_Post_IntLvl_Positive,
+  RtemsSignalReqCatch_Post_IntLvl_NA
+} RtemsSignalReqCatch_Post_IntLvl;
+
+/**
+ * @brief Test context for spec:/rtems/signal/req/catch test case.
+ */
+typedef struct {
+  uint32_t default_handler_calls;
+
+  uint32_t handler_calls;
+
+  rtems_mode handler_mode;
+
+  rtems_mode normal_mode;
+
+  rtems_asr_entry handler;
+
+  rtems_mode mode;
+
+  rtems_status_code catch_status;
+
+  rtems_status_code send_status;
+
+  /**
+   * @brief This member defines the pre-condition states for the next action.
+   */
+  size_t pcs[ 5 ];
+
+  /**
+   * @brief This member indicates if the test action loop is currently
+   *   executed.
+   */
+  bool in_action_loop;
+} RtemsSignalReqCatch_Context;
+
+static RtemsSignalReqCatch_Context
+  RtemsSignalReqCatch_Instance;
+
+static const char * const RtemsSignalReqCatch_PreDesc_Handler[] = {
+  "Invalid",
+  "Valid",
+  "NA"
+};
+
+static const char * const RtemsSignalReqCatch_PreDesc_Preempt[] = {
+  "Yes",
+  "No",
+  "NA"
+};
+
+static const char * const RtemsSignalReqCatch_PreDesc_Timeslice[] = {
+  "Yes",
+  "No",
+  "NA"
+};
+
+static const char * const RtemsSignalReqCatch_PreDesc_ASR[] = {
+  "Yes",
+  "No",
+  "NA"
+};
+
+static const char * const RtemsSignalReqCatch_PreDesc_IntLvl[] = {
+  "Zero",
+  "Positive",
+  "NA"
+};
+
+static const char * const * const RtemsSignalReqCatch_PreDesc[] = {
+  RtemsSignalReqCatch_PreDesc_Handler,
+  RtemsSignalReqCatch_PreDesc_Preempt,
+  RtemsSignalReqCatch_PreDesc_Timeslice,
+  RtemsSignalReqCatch_PreDesc_ASR,
+  RtemsSignalReqCatch_PreDesc_IntLvl,
+  NULL
+};
+
+typedef RtemsSignalReqCatch_Context Context;
+
+static void DefaultHandler( rtems_signal_set signal_set )
+{
+  Context *ctx;
+
+  ctx = T_fixture_context();
+  ++ctx->default_handler_calls;
+
+  T_eq_u32( signal_set, 0xdeadbeef );
+}
+
+static void SignalHandler( rtems_signal_set signal_set )
+{
+  Context          *ctx;
+  rtems_status_code sc;
+
+  ctx = T_fixture_context();
+  ++ctx->handler_calls;
+
+  sc = rtems_task_mode(
+    RTEMS_DEFAULT_MODES,
+    RTEMS_CURRENT_MODE,
+    &ctx->handler_mode
+  );
+  T_rsc_success( sc );
+
+  T_eq_u32( signal_set, 0xdeadbeef );
+}
+
+static void CheckHandlerMode( Context *ctx, rtems_mode mask, rtems_mode mode )
+{
+  if ( ctx->catch_status == RTEMS_SUCCESSFUL && ctx->handler != NULL ) {
+    T_ne_u32( ctx->handler_mode, 0xffffffff );
+    T_eq_u32( ctx->handler_mode & mask, mode );
+  }
+}
+
+static void RtemsSignalReqCatch_Pre_Handler_Prepare(
+  RtemsSignalReqCatch_Context    *ctx,
+  RtemsSignalReqCatch_Pre_Handler state
+)
+{
+  switch ( state ) {
+    case RtemsSignalReqCatch_Pre_Handler_Invalid: {
+      ctx->handler = NULL;
+      break;
+    }
+
+    case RtemsSignalReqCatch_Pre_Handler_Valid: {
+      ctx->handler = SignalHandler;
+      break;
+    }
+
+    case RtemsSignalReqCatch_Pre_Handler_NA:
+      break;
+  }
+}
+
+static void RtemsSignalReqCatch_Pre_Preempt_Prepare(
+  RtemsSignalReqCatch_Context    *ctx,
+  RtemsSignalReqCatch_Pre_Preempt state
+)
+{
+  switch ( state ) {
+    case RtemsSignalReqCatch_Pre_Preempt_Yes: {
+      #if defined(RTEMS_SMP)
+      if ( rtems_configuration_get_maximum_processors() == 1 ) {
+        ctx->normal_mode |= RTEMS_NO_PREEMPT;
+      }
+      #else
+      ctx->normal_mode |= RTEMS_NO_PREEMPT;
+      #endif
+      break;
+    }
+
+    case RtemsSignalReqCatch_Pre_Preempt_No: {
+      ctx->mode |= RTEMS_NO_PREEMPT;
+      break;
+    }
+
+    case RtemsSignalReqCatch_Pre_Preempt_NA:
+      break;
+  }
+}
+
+static void RtemsSignalReqCatch_Pre_Timeslice_Prepare(
+  RtemsSignalReqCatch_Context      *ctx,
+  RtemsSignalReqCatch_Pre_Timeslice state
+)
+{
+  switch ( state ) {
+    case RtemsSignalReqCatch_Pre_Timeslice_Yes: {
+      ctx->mode |= RTEMS_TIMESLICE;
+      break;
+    }
+
+    case RtemsSignalReqCatch_Pre_Timeslice_No: {
+      ctx->normal_mode |= RTEMS_TIMESLICE;
+      break;
+    }
+
+    case RtemsSignalReqCatch_Pre_Timeslice_NA:
+      break;
+  }
+}
+
+static void RtemsSignalReqCatch_Pre_ASR_Prepare(
+  RtemsSignalReqCatch_Context *ctx,
+  RtemsSignalReqCatch_Pre_ASR  state
+)
+{
+  switch ( state ) {
+    case RtemsSignalReqCatch_Pre_ASR_Yes: {
+      /* We cannot disable ASR processing at normal task level for this test */
+      break;
+    }
+
+    case RtemsSignalReqCatch_Pre_ASR_No: {
+      ctx->mode |= RTEMS_NO_ASR;
+      break;
+    }
+
+    case RtemsSignalReqCatch_Pre_ASR_NA:
+      break;
+  }
+}
+
+static void RtemsSignalReqCatch_Pre_IntLvl_Prepare(
+  RtemsSignalReqCatch_Context   *ctx,
+  RtemsSignalReqCatch_Pre_IntLvl state
+)
+{
+  switch ( state ) {
+    case RtemsSignalReqCatch_Pre_IntLvl_Zero: {
+      #if !defined(RTEMS_SMP) && CPU_ENABLE_ROBUST_THREAD_DISPATCH == FALSE
+      ctx->normal_mode |= RTEMS_INTERRUPT_LEVEL( 1 );
+      #endif
+      break;
+    }
+
+    case RtemsSignalReqCatch_Pre_IntLvl_Positive: {
+      ctx->mode |= RTEMS_INTERRUPT_LEVEL( 1 );
+      break;
+    }
+
+    case RtemsSignalReqCatch_Pre_IntLvl_NA:
+      break;
+  }
+}
+
+static void RtemsSignalReqCatch_Post_Status_Check(
+  RtemsSignalReqCatch_Context    *ctx,
+  RtemsSignalReqCatch_Post_Status state
+)
+{
+  switch ( state ) {
+    case RtemsSignalReqCatch_Post_Status_Ok: {
+      T_rsc_success( ctx->catch_status );
+      break;
+    }
+
+    case RtemsSignalReqCatch_Post_Status_NotImplNoPreempt: {
+      #if defined(RTEMS_SMP)
+      if ( rtems_configuration_get_maximum_processors() > 1 ) {
+        T_rsc( ctx->catch_status, RTEMS_NOT_IMPLEMENTED );
+      } else {
+        T_rsc_success( ctx->catch_status );
+      }
+      #else
+      T_rsc_success( ctx->catch_status );
+      #endif
+      break;
+    }
+
+    case RtemsSignalReqCatch_Post_Status_NotImplIntLvl: {
+      #if CPU_ENABLE_ROBUST_THREAD_DISPATCH == TRUE
+      T_rsc( ctx->catch_status, RTEMS_NOT_IMPLEMENTED );
+      #elif defined(RTEMS_SMP)
+      if ( rtems_configuration_get_maximum_processors() > 1 ) {
+        T_rsc( ctx->catch_status, RTEMS_NOT_IMPLEMENTED );
+      } else {
+        T_rsc_success( ctx->catch_status );
+      }
+      #else
+      T_rsc_success( ctx->catch_status );
+      #endif
+      break;
+    }
+
+    case RtemsSignalReqCatch_Post_Status_NA:
+      break;
+  }
+}
+
+static void RtemsSignalReqCatch_Post_Send_Check(
+  RtemsSignalReqCatch_Context  *ctx,
+  RtemsSignalReqCatch_Post_Send state
+)
+{
+  switch ( state ) {
+    case RtemsSignalReqCatch_Post_Send_New: {
+      T_rsc_success( ctx->send_status );
+
+      if ( ctx->catch_status == RTEMS_SUCCESSFUL ) {
+        T_eq_u32( ctx->default_handler_calls, 0 );
+        T_eq_u32( ctx->handler_calls, 1 );
+        T_ne_u32( ctx->handler_mode, 0xffffffff );
+      } else {
+        T_eq_u32( ctx->default_handler_calls, 1 );
+        T_eq_u32( ctx->handler_calls, 0 );
+        T_eq_u32( ctx->handler_mode, 0xffffffff );
+      }
+      break;
+    }
+
+    case RtemsSignalReqCatch_Post_Send_NotDef: {
+      if ( ctx->catch_status == RTEMS_SUCCESSFUL ) {
+        T_rsc( ctx->send_status, RTEMS_NOT_DEFINED );
+        T_eq_u32( ctx->default_handler_calls, 0 );
+        T_eq_u32( ctx->handler_calls, 0 );
+        T_eq_u32( ctx->handler_mode, 0xffffffff );
+      } else {
+        T_rsc_success( ctx->send_status );
+        T_eq_u32( ctx->default_handler_calls, 1 );
+        T_eq_u32( ctx->handler_calls, 0 );
+        T_eq_u32( ctx->handler_mode, 0xffffffff );
+      }
+      break;
+    }
+
+    case RtemsSignalReqCatch_Post_Send_NA:
+      break;
+  }
+}
+
+static void RtemsSignalReqCatch_Post_Preempt_Check(
+  RtemsSignalReqCatch_Context     *ctx,
+  RtemsSignalReqCatch_Post_Preempt state
+)
+{
+  switch ( state ) {
+    case RtemsSignalReqCatch_Post_Preempt_Yes: {
+      CheckHandlerMode( ctx, RTEMS_PREEMPT_MASK, RTEMS_PREEMPT );
+      break;
+    }
+
+    case RtemsSignalReqCatch_Post_Preempt_No: {
+      CheckHandlerMode( ctx, RTEMS_PREEMPT_MASK, RTEMS_NO_PREEMPT );
+      break;
+    }
+
+    case RtemsSignalReqCatch_Post_Preempt_NA:
+      break;
+  }
+}
+
+static void RtemsSignalReqCatch_Post_Timeslice_Check(
+  RtemsSignalReqCatch_Context       *ctx,
+  RtemsSignalReqCatch_Post_Timeslice state
+)
+{
+  switch ( state ) {
+    case RtemsSignalReqCatch_Post_Timeslice_Yes: {
+      CheckHandlerMode( ctx, RTEMS_TIMESLICE_MASK, RTEMS_TIMESLICE );
+      break;
+    }
+
+    case RtemsSignalReqCatch_Post_Timeslice_No: {
+      CheckHandlerMode( ctx, RTEMS_TIMESLICE_MASK, RTEMS_NO_TIMESLICE );
+      break;
+    }
+
+    case RtemsSignalReqCatch_Post_Timeslice_NA:
+      break;
+  }
+}
+
+static void RtemsSignalReqCatch_Post_ASR_Check(
+  RtemsSignalReqCatch_Context *ctx,
+  RtemsSignalReqCatch_Post_ASR state
+)
+{
+  switch ( state ) {
+    case RtemsSignalReqCatch_Post_ASR_Yes: {
+      CheckHandlerMode( ctx, RTEMS_ASR_MASK, RTEMS_ASR );
+      break;
+    }
+
+    case RtemsSignalReqCatch_Post_ASR_No: {
+      CheckHandlerMode( ctx, RTEMS_ASR_MASK, RTEMS_NO_ASR );
+      break;
+    }
+
+    case RtemsSignalReqCatch_Post_ASR_NA:
+      break;
+  }
+}
+
+static void RtemsSignalReqCatch_Post_IntLvl_Check(
+  RtemsSignalReqCatch_Context    *ctx,
+  RtemsSignalReqCatch_Post_IntLvl state
+)
+{
+  switch ( state ) {
+    case RtemsSignalReqCatch_Post_IntLvl_Zero: {
+      CheckHandlerMode( ctx, RTEMS_INTERRUPT_MASK, RTEMS_INTERRUPT_LEVEL( 0 ) );
+      break;
+    }
+
+    case RtemsSignalReqCatch_Post_IntLvl_Positive: {
+      CheckHandlerMode( ctx, RTEMS_INTERRUPT_MASK, RTEMS_INTERRUPT_LEVEL( 1 ) );
+      break;
+    }
+
+    case RtemsSignalReqCatch_Post_IntLvl_NA:
+      break;
+  }
+}
+
+static void RtemsSignalReqCatch_Teardown( RtemsSignalReqCatch_Context *ctx )
+{
+  rtems_status_code sc;
+
+  sc = rtems_signal_catch( NULL, RTEMS_DEFAULT_MODES );
+  T_rsc_success( sc );
+}
+
+static void RtemsSignalReqCatch_Teardown_Wrap( void *arg )
+{
+  RtemsSignalReqCatch_Context *ctx;
+
+  ctx = arg;
+  ctx->in_action_loop = false;
+  RtemsSignalReqCatch_Teardown( ctx );
+}
+
+static size_t RtemsSignalReqCatch_Scope( void *arg, char *buf, size_t n )
+{
+  RtemsSignalReqCatch_Context *ctx;
+
+  ctx = arg;
+
+  if ( ctx->in_action_loop ) {
+    return T_get_scope( RtemsSignalReqCatch_PreDesc, buf, n, ctx->pcs );
+  }
+
+  return 0;
+}
+
+static T_fixture RtemsSignalReqCatch_Fixture = {
+  .setup = NULL,
+  .stop = NULL,
+  .teardown = RtemsSignalReqCatch_Teardown_Wrap,
+  .scope = RtemsSignalReqCatch_Scope,
+  .initial_context = &RtemsSignalReqCatch_Instance
+};
+
+static const uint8_t RtemsSignalReqCatch_TransitionMap[][ 6 ] = {
+  {
+    RtemsSignalReqCatch_Post_Status_Ok,
+    RtemsSignalReqCatch_Post_Send_NotDef,
+    RtemsSignalReqCatch_Post_Preempt_Yes,
+    RtemsSignalReqCatch_Post_Timeslice_Yes,
+    RtemsSignalReqCatch_Post_ASR_Yes,
+    RtemsSignalReqCatch_Post_IntLvl_Zero
+  }, {
+    RtemsSignalReqCatch_Post_Status_NotImplIntLvl,
+    RtemsSignalReqCatch_Post_Send_NotDef,
+    RtemsSignalReqCatch_Post_Preempt_Yes,
+    RtemsSignalReqCatch_Post_Timeslice_Yes,
+    RtemsSignalReqCatch_Post_ASR_Yes,
+    RtemsSignalReqCatch_Post_IntLvl_Positive
+  }, {
+    RtemsSignalReqCatch_Post_Status_Ok,
+    RtemsSignalReqCatch_Post_Send_NotDef,
+    RtemsSignalReqCatch_Post_Preempt_Yes,
+    RtemsSignalReqCatch_Post_Timeslice_Yes,
+    RtemsSignalReqCatch_Post_ASR_No,
+    RtemsSignalReqCatch_Post_IntLvl_Zero
+  }, {
+    RtemsSignalReqCatch_Post_Status_NotImplIntLvl,
+    RtemsSignalReqCatch_Post_Send_NotDef,
+    RtemsSignalReqCatch_Post_Preempt_Yes,
+    RtemsSignalReqCatch_Post_Timeslice_Yes,
+    RtemsSignalReqCatch_Post_ASR_No,
+    RtemsSignalReqCatch_Post_IntLvl_Positive
+  }, {
+    RtemsSignalReqCatch_Post_Status_Ok,
+    RtemsSignalReqCatch_Post_Send_NotDef,
+    RtemsSignalReqCatch_Post_Preempt_Yes,
+    RtemsSignalReqCatch_Post_Timeslice_No,
+    RtemsSignalReqCatch_Post_ASR_Yes,
+    RtemsSignalReqCatch_Post_IntLvl_Zero
+  }, {
+    RtemsSignalReqCatch_Post_Status_NotImplIntLvl,
+    RtemsSignalReqCatch_Post_Send_NotDef,
+    RtemsSignalReqCatch_Post_Preempt_Yes,
+    RtemsSignalReqCatch_Post_Timeslice_No,
+    RtemsSignalReqCatch_Post_ASR_Yes,
+    RtemsSignalReqCatch_Post_IntLvl_Positive
+  }, {
+    RtemsSignalReqCatch_Post_Status_Ok,
+    RtemsSignalReqCatch_Post_Send_NotDef,
+    RtemsSignalReqCatch_Post_Preempt_Yes,
+    RtemsSignalReqCatch_Post_Timeslice_No,
+    RtemsSignalReqCatch_Post_ASR_No,
+    RtemsSignalReqCatch_Post_IntLvl_Zero
+  }, {
+    RtemsSignalReqCatch_Post_Status_NotImplIntLvl,
+    RtemsSignalReqCatch_Post_Send_NotDef,
+    RtemsSignalReqCatch_Post_Preempt_Yes,
+    RtemsSignalReqCatch_Post_Timeslice_No,
+    RtemsSignalReqCatch_Post_ASR_No,
+    RtemsSignalReqCatch_Post_IntLvl_Positive
+  }, {
+    RtemsSignalReqCatch_Post_Status_NotImplNoPreempt,
+    RtemsSignalReqCatch_Post_Send_NotDef,
+    RtemsSignalReqCatch_Post_Preempt_No,
+    RtemsSignalReqCatch_Post_Timeslice_Yes,
+    RtemsSignalReqCatch_Post_ASR_Yes,
+    RtemsSignalReqCatch_Post_IntLvl_Zero
+  }, {
+    RtemsSignalReqCatch_Post_Status_NotImplIntLvl,
+    RtemsSignalReqCatch_Post_Send_NotDef,
+    RtemsSignalReqCatch_Post_Preempt_No,
+    RtemsSignalReqCatch_Post_Timeslice_Yes,
+    RtemsSignalReqCatch_Post_ASR_Yes,
+    RtemsSignalReqCatch_Post_IntLvl_Positive
+  }, {
+    RtemsSignalReqCatch_Post_Status_NotImplNoPreempt,
+    RtemsSignalReqCatch_Post_Send_NotDef,
+    RtemsSignalReqCatch_Post_Preempt_No,
+    RtemsSignalReqCatch_Post_Timeslice_Yes,
+    RtemsSignalReqCatch_Post_ASR_No,
+    RtemsSignalReqCatch_Post_IntLvl_Zero
+  }, {
+    RtemsSignalReqCatch_Post_Status_NotImplIntLvl,
+    RtemsSignalReqCatch_Post_Send_NotDef,
+    RtemsSignalReqCatch_Post_Preempt_No,
+    RtemsSignalReqCatch_Post_Timeslice_Yes,
+    RtemsSignalReqCatch_Post_ASR_No,
+    RtemsSignalReqCatch_Post_IntLvl_Positive
+  }, {
+    RtemsSignalReqCatch_Post_Status_NotImplNoPreempt,
+    RtemsSignalReqCatch_Post_Send_NotDef,
+    RtemsSignalReqCatch_Post_Preempt_No,
+    RtemsSignalReqCatch_Post_Timeslice_No,
+    RtemsSignalReqCatch_Post_ASR_Yes,
+    RtemsSignalReqCatch_Post_IntLvl_Zero
+  }, {
+    RtemsSignalReqCatch_Post_Status_NotImplIntLvl,
+    RtemsSignalReqCatch_Post_Send_NotDef,
+    RtemsSignalReqCatch_Post_Preempt_No,
+    RtemsSignalReqCatch_Post_Timeslice_No,
+    RtemsSignalReqCatch_Post_ASR_Yes,
+    RtemsSignalReqCatch_Post_IntLvl_Positive
+  }, {
+    RtemsSignalReqCatch_Post_Status_NotImplNoPreempt,
+    RtemsSignalReqCatch_Post_Send_NotDef,
+    RtemsSignalReqCatch_Post_Preempt_No,
+    RtemsSignalReqCatch_Post_Timeslice_No,
+    RtemsSignalReqCatch_Post_ASR_No,
+    RtemsSignalReqCatch_Post_IntLvl_Zero
+  }, {
+    RtemsSignalReqCatch_Post_Status_NotImplIntLvl,
+    RtemsSignalReqCatch_Post_Send_NotDef,
+    RtemsSignalReqCatch_Post_Preempt_No,
+    RtemsSignalReqCatch_Post_Timeslice_No,
+    RtemsSignalReqCatch_Post_ASR_No,
+    RtemsSignalReqCatch_Post_IntLvl_Positive
+  }, {
+    RtemsSignalReqCatch_Post_Status_Ok,
+    RtemsSignalReqCatch_Post_Send_New,
+    RtemsSignalReqCatch_Post_Preempt_Yes,
+    RtemsSignalReqCatch_Post_Timeslice_Yes,
+    RtemsSignalReqCatch_Post_ASR_Yes,
+    RtemsSignalReqCatch_Post_IntLvl_Zero
+  }, {
+    RtemsSignalReqCatch_Post_Status_NotImplIntLvl,
+    RtemsSignalReqCatch_Post_Send_New,
+    RtemsSignalReqCatch_Post_Preempt_Yes,
+    RtemsSignalReqCatch_Post_Timeslice_Yes,
+    RtemsSignalReqCatch_Post_ASR_Yes,
+    RtemsSignalReqCatch_Post_IntLvl_Positive
+  }, {
+    RtemsSignalReqCatch_Post_Status_Ok,
+    RtemsSignalReqCatch_Post_Send_New,
+    RtemsSignalReqCatch_Post_Preempt_Yes,
+    RtemsSignalReqCatch_Post_Timeslice_Yes,
+    RtemsSignalReqCatch_Post_ASR_No,
+    RtemsSignalReqCatch_Post_IntLvl_Zero
+  }, {
+    RtemsSignalReqCatch_Post_Status_NotImplIntLvl,
+    RtemsSignalReqCatch_Post_Send_New,
+    RtemsSignalReqCatch_Post_Preempt_Yes,
+    RtemsSignalReqCatch_Post_Timeslice_Yes,
+    RtemsSignalReqCatch_Post_ASR_No,
+    RtemsSignalReqCatch_Post_IntLvl_Positive
+  }, {
+    RtemsSignalReqCatch_Post_Status_Ok,
+    RtemsSignalReqCatch_Post_Send_New,
+    RtemsSignalReqCatch_Post_Preempt_Yes,
+    RtemsSignalReqCatch_Post_Timeslice_No,
+    RtemsSignalReqCatch_Post_ASR_Yes,
+    RtemsSignalReqCatch_Post_IntLvl_Zero
+  }, {
+    RtemsSignalReqCatch_Post_Status_NotImplIntLvl,
+    RtemsSignalReqCatch_Post_Send_New,
+    RtemsSignalReqCatch_Post_Preempt_Yes,
+    RtemsSignalReqCatch_Post_Timeslice_No,
+    RtemsSignalReqCatch_Post_ASR_Yes,
+    RtemsSignalReqCatch_Post_IntLvl_Positive
+  }, {
+    RtemsSignalReqCatch_Post_Status_Ok,
+    RtemsSignalReqCatch_Post_Send_New,
+    RtemsSignalReqCatch_Post_Preempt_Yes,
+    RtemsSignalReqCatch_Post_Timeslice_No,
+    RtemsSignalReqCatch_Post_ASR_No,
+    RtemsSignalReqCatch_Post_IntLvl_Zero
+  }, {
+    RtemsSignalReqCatch_Post_Status_NotImplIntLvl,
+    RtemsSignalReqCatch_Post_Send_New,
+    RtemsSignalReqCatch_Post_Preempt_Yes,
+    RtemsSignalReqCatch_Post_Timeslice_No,
+    RtemsSignalReqCatch_Post_ASR_No,
+    RtemsSignalReqCatch_Post_IntLvl_Positive
+  }, {
+    RtemsSignalReqCatch_Post_Status_NotImplNoPreempt,
+    RtemsSignalReqCatch_Post_Send_New,
+    RtemsSignalReqCatch_Post_Preempt_No,
+    RtemsSignalReqCatch_Post_Timeslice_Yes,
+    RtemsSignalReqCatch_Post_ASR_Yes,
+    RtemsSignalReqCatch_Post_IntLvl_Zero
+  }, {
+    RtemsSignalReqCatch_Post_Status_NotImplIntLvl,
+    RtemsSignalReqCatch_Post_Send_New,
+    RtemsSignalReqCatch_Post_Preempt_No,
+    RtemsSignalReqCatch_Post_Timeslice_Yes,
+    RtemsSignalReqCatch_Post_ASR_Yes,
+    RtemsSignalReqCatch_Post_IntLvl_Positive
+  }, {
+    RtemsSignalReqCatch_Post_Status_NotImplNoPreempt,
+    RtemsSignalReqCatch_Post_Send_New,
+    RtemsSignalReqCatch_Post_Preempt_No,
+    RtemsSignalReqCatch_Post_Timeslice_Yes,
+    RtemsSignalReqCatch_Post_ASR_No,
+    RtemsSignalReqCatch_Post_IntLvl_Zero
+  }, {
+    RtemsSignalReqCatch_Post_Status_NotImplIntLvl,
+    RtemsSignalReqCatch_Post_Send_New,
+    RtemsSignalReqCatch_Post_Preempt_No,
+    RtemsSignalReqCatch_Post_Timeslice_Yes,
+    RtemsSignalReqCatch_Post_ASR_No,
+    RtemsSignalReqCatch_Post_IntLvl_Positive
+  }, {
+    RtemsSignalReqCatch_Post_Status_NotImplNoPreempt,
+    RtemsSignalReqCatch_Post_Send_New,
+    RtemsSignalReqCatch_Post_Preempt_No,
+    RtemsSignalReqCatch_Post_Timeslice_No,
+    RtemsSignalReqCatch_Post_ASR_Yes,
+    RtemsSignalReqCatch_Post_IntLvl_Zero
+  }, {
+    RtemsSignalReqCatch_Post_Status_NotImplIntLvl,
+    RtemsSignalReqCatch_Post_Send_New,
+    RtemsSignalReqCatch_Post_Preempt_No,
+    RtemsSignalReqCatch_Post_Timeslice_No,
+    RtemsSignalReqCatch_Post_ASR_Yes,
+    RtemsSignalReqCatch_Post_IntLvl_Positive
+  }, {
+    RtemsSignalReqCatch_Post_Status_NotImplNoPreempt,
+    RtemsSignalReqCatch_Post_Send_New,
+    RtemsSignalReqCatch_Post_Preempt_No,
+    RtemsSignalReqCatch_Post_Timeslice_No,
+    RtemsSignalReqCatch_Post_ASR_No,
+    RtemsSignalReqCatch_Post_IntLvl_Zero
+  }, {
+    RtemsSignalReqCatch_Post_Status_NotImplIntLvl,
+    RtemsSignalReqCatch_Post_Send_New,
+    RtemsSignalReqCatch_Post_Preempt_No,
+    RtemsSignalReqCatch_Post_Timeslice_No,
+    RtemsSignalReqCatch_Post_ASR_No,
+    RtemsSignalReqCatch_Post_IntLvl_Positive
+  }
+};
+
+static const struct {
+  uint8_t Skip : 1;
+  uint8_t Pre_Handler_NA : 1;
+  uint8_t Pre_Preempt_NA : 1;
+  uint8_t Pre_Timeslice_NA : 1;
+  uint8_t Pre_ASR_NA : 1;
+  uint8_t Pre_IntLvl_NA : 1;
+} RtemsSignalReqCatch_TransitionInfo[] = {
+  {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }
+};
+
+static void RtemsSignalReqCatch_Prepare( RtemsSignalReqCatch_Context *ctx )
+{
+  rtems_status_code sc;
+
+  ctx->default_handler_calls = 0;
+  ctx->handler_calls = 0;
+  ctx->handler_mode = 0xffffffff;
+  ctx->normal_mode = RTEMS_DEFAULT_MODES;
+  ctx->handler = NULL;
+  ctx->mode = RTEMS_DEFAULT_MODES;
+
+  sc = rtems_signal_catch( DefaultHandler, RTEMS_NO_ASR );
+  T_rsc_success( sc );
+}
+
+static void RtemsSignalReqCatch_Action( RtemsSignalReqCatch_Context *ctx )
+{
+  rtems_status_code sc;
+  rtems_mode        mode;
+
+  ctx->catch_status = rtems_signal_catch( ctx->handler, ctx->mode );
+
+  sc = rtems_task_mode( ctx->normal_mode, RTEMS_ALL_MODE_MASKS, &mode );
+  T_rsc_success( sc );
+
+  ctx->send_status = rtems_signal_send( RTEMS_SELF, 0xdeadbeef );
+
+  sc = rtems_task_mode( mode, RTEMS_ALL_MODE_MASKS, &mode );
+  T_rsc_success( sc );
+}
+
+/**
+ * @fn void T_case_body_RtemsSignalReqCatch( void )
+ */
+T_TEST_CASE_FIXTURE( RtemsSignalReqCatch, &RtemsSignalReqCatch_Fixture )
+{
+  RtemsSignalReqCatch_Context *ctx;
+  size_t index;
+
+  ctx = T_fixture_context();
+  ctx->in_action_loop = true;
+  index = 0;
+
+  for (
+    ctx->pcs[ 0 ] = RtemsSignalReqCatch_Pre_Handler_Invalid;
+    ctx->pcs[ 0 ] < RtemsSignalReqCatch_Pre_Handler_NA;
+    ++ctx->pcs[ 0 ]
+  ) {
+    if ( RtemsSignalReqCatch_TransitionInfo[ index ].Pre_Handler_NA ) {
+      ctx->pcs[ 0 ] = RtemsSignalReqCatch_Pre_Handler_NA;
+      index += ( RtemsSignalReqCatch_Pre_Handler_NA - 1 )
+        * RtemsSignalReqCatch_Pre_Preempt_NA
+        * RtemsSignalReqCatch_Pre_Timeslice_NA
+        * RtemsSignalReqCatch_Pre_ASR_NA
+        * RtemsSignalReqCatch_Pre_IntLvl_NA;
+    }
+
+    for (
+      ctx->pcs[ 1 ] = RtemsSignalReqCatch_Pre_Preempt_Yes;
+      ctx->pcs[ 1 ] < RtemsSignalReqCatch_Pre_Preempt_NA;
+      ++ctx->pcs[ 1 ]
+    ) {
+      if ( RtemsSignalReqCatch_TransitionInfo[ index ].Pre_Preempt_NA ) {
+        ctx->pcs[ 1 ] = RtemsSignalReqCatch_Pre_Preempt_NA;
+        index += ( RtemsSignalReqCatch_Pre_Preempt_NA - 1 )
+          * RtemsSignalReqCatch_Pre_Timeslice_NA
+          * RtemsSignalReqCatch_Pre_ASR_NA
+          * RtemsSignalReqCatch_Pre_IntLvl_NA;
+      }
+
+      for (
+        ctx->pcs[ 2 ] = RtemsSignalReqCatch_Pre_Timeslice_Yes;
+        ctx->pcs[ 2 ] < RtemsSignalReqCatch_Pre_Timeslice_NA;
+        ++ctx->pcs[ 2 ]
+      ) {
+        if ( RtemsSignalReqCatch_TransitionInfo[ index ].Pre_Timeslice_NA ) {
+          ctx->pcs[ 2 ] = RtemsSignalReqCatch_Pre_Timeslice_NA;
+          index += ( RtemsSignalReqCatch_Pre_Timeslice_NA - 1 )
+            * RtemsSignalReqCatch_Pre_ASR_NA
+            * RtemsSignalReqCatch_Pre_IntLvl_NA;
+        }
+
+        for (
+          ctx->pcs[ 3 ] = RtemsSignalReqCatch_Pre_ASR_Yes;
+          ctx->pcs[ 3 ] < RtemsSignalReqCatch_Pre_ASR_NA;
+          ++ctx->pcs[ 3 ]
+        ) {
+          if ( RtemsSignalReqCatch_TransitionInfo[ index ].Pre_ASR_NA ) {
+            ctx->pcs[ 3 ] = RtemsSignalReqCatch_Pre_ASR_NA;
+            index += ( RtemsSignalReqCatch_Pre_ASR_NA - 1 )
+              * RtemsSignalReqCatch_Pre_IntLvl_NA;
+          }
+
+          for (
+            ctx->pcs[ 4 ] = RtemsSignalReqCatch_Pre_IntLvl_Zero;
+            ctx->pcs[ 4 ] < RtemsSignalReqCatch_Pre_IntLvl_NA;
+            ++ctx->pcs[ 4 ]
+          ) {
+            if ( RtemsSignalReqCatch_TransitionInfo[ index ].Pre_IntLvl_NA ) {
+              ctx->pcs[ 4 ] = RtemsSignalReqCatch_Pre_IntLvl_NA;
+              index += ( RtemsSignalReqCatch_Pre_IntLvl_NA - 1 );
+            }
+
+            if ( RtemsSignalReqCatch_TransitionInfo[ index ].Skip ) {
+              ++index;
+              continue;
+            }
+
+            RtemsSignalReqCatch_Prepare( ctx );
+            RtemsSignalReqCatch_Pre_Handler_Prepare( ctx, ctx->pcs[ 0 ] );
+            RtemsSignalReqCatch_Pre_Preempt_Prepare( ctx, ctx->pcs[ 1 ] );
+            RtemsSignalReqCatch_Pre_Timeslice_Prepare( ctx, ctx->pcs[ 2 ] );
+            RtemsSignalReqCatch_Pre_ASR_Prepare( ctx, ctx->pcs[ 3 ] );
+            RtemsSignalReqCatch_Pre_IntLvl_Prepare( ctx, ctx->pcs[ 4 ] );
+            RtemsSignalReqCatch_Action( ctx );
+            RtemsSignalReqCatch_Post_Status_Check(
+              ctx,
+              RtemsSignalReqCatch_TransitionMap[ index ][ 0 ]
+            );
+            RtemsSignalReqCatch_Post_Send_Check(
+              ctx,
+              RtemsSignalReqCatch_TransitionMap[ index ][ 1 ]
+            );
+            RtemsSignalReqCatch_Post_Preempt_Check(
+              ctx,
+              RtemsSignalReqCatch_TransitionMap[ index ][ 2 ]
+            );
+            RtemsSignalReqCatch_Post_Timeslice_Check(
+              ctx,
+              RtemsSignalReqCatch_TransitionMap[ index ][ 3 ]
+            );
+            RtemsSignalReqCatch_Post_ASR_Check(
+              ctx,
+              RtemsSignalReqCatch_TransitionMap[ index ][ 4 ]
+            );
+            RtemsSignalReqCatch_Post_IntLvl_Check(
+              ctx,
+              RtemsSignalReqCatch_TransitionMap[ index ][ 5 ]
+            );
+            ++index;
+          }
+        }
+      }
+    }
+  }
+}
+
+/** @} */
diff --git a/testsuites/validation/tc-signal-send.c b/testsuites/validation/tc-signal-send.c
new file mode 100644
index 0000000000..a4232efbae
--- /dev/null
+++ b/testsuites/validation/tc-signal-send.c
@@ -0,0 +1,1146 @@
+/* SPDX-License-Identifier: BSD-2-Clause */
+
+/**
+ * @file
+ *
+ * @ingroup RTEMSTestCaseRtemsSignalReqSend
+ */
+
+/*
+ * 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.h>
+
+#include <rtems/test.h>
+
+/**
+ * @defgroup RTEMSTestCaseRtemsSignalReqSend spec:/rtems/signal/req/send
+ *
+ * @ingroup RTEMSTestSuiteTestsuitesValidation0
+ * @ingroup RTEMSTestSuiteTestsuitesValidation1
+ *
+ * @{
+ */
+
+typedef enum {
+  RtemsSignalReqSend_Pre_Task_NoObj,
+  RtemsSignalReqSend_Pre_Task_Self,
+  RtemsSignalReqSend_Pre_Task_Other,
+  RtemsSignalReqSend_Pre_Task_NA
+} RtemsSignalReqSend_Pre_Task;
+
+typedef enum {
+  RtemsSignalReqSend_Pre_Set_Zero,
+  RtemsSignalReqSend_Pre_Set_NonZero,
+  RtemsSignalReqSend_Pre_Set_NA
+} RtemsSignalReqSend_Pre_Set;
+
+typedef enum {
+  RtemsSignalReqSend_Pre_Handler_Invalid,
+  RtemsSignalReqSend_Pre_Handler_Valid,
+  RtemsSignalReqSend_Pre_Handler_NA
+} RtemsSignalReqSend_Pre_Handler;
+
+typedef enum {
+  RtemsSignalReqSend_Pre_ASR_Enabled,
+  RtemsSignalReqSend_Pre_ASR_Disabled,
+  RtemsSignalReqSend_Pre_ASR_NA
+} RtemsSignalReqSend_Pre_ASR;
+
+typedef enum {
+  RtemsSignalReqSend_Pre_Nested_Yes,
+  RtemsSignalReqSend_Pre_Nested_No,
+  RtemsSignalReqSend_Pre_Nested_NA
+} RtemsSignalReqSend_Pre_Nested;
+
+typedef enum {
+  RtemsSignalReqSend_Post_Status_Ok,
+  RtemsSignalReqSend_Post_Status_InvNum,
+  RtemsSignalReqSend_Post_Status_InvId,
+  RtemsSignalReqSend_Post_Status_NotDef,
+  RtemsSignalReqSend_Post_Status_NA
+} RtemsSignalReqSend_Post_Status;
+
+typedef enum {
+  RtemsSignalReqSend_Post_Handler_NoCall,
+  RtemsSignalReqSend_Post_Handler_DuringSend,
+  RtemsSignalReqSend_Post_Handler_AfterDispatch,
+  RtemsSignalReqSend_Post_Handler_AfterEnable,
+  RtemsSignalReqSend_Post_Handler_NA
+} RtemsSignalReqSend_Post_Handler;
+
+typedef enum {
+  RtemsSignalReqSend_Post_Recursive_Yes,
+  RtemsSignalReqSend_Post_Recursive_No,
+  RtemsSignalReqSend_Post_Recursive_NA
+} RtemsSignalReqSend_Post_Recursive;
+
+/**
+ * @brief Test context for spec:/rtems/signal/req/send test case.
+ */
+typedef struct {
+  rtems_id runner_id;
+
+  rtems_id worker_id;
+
+  rtems_asr_entry handler;
+
+  size_t nested;
+
+  size_t handler_calls;
+
+  size_t calls_after_send;
+
+  size_t calls_after_dispatch;
+
+  size_t calls_after_enable;
+
+  rtems_signal_set processed_signal_sets[ 2 ];
+
+  uintptr_t stack_pointers[ 2 ];;
+
+  rtems_mode mode;;
+
+  rtems_status_code status;
+
+  rtems_id id;
+
+  rtems_signal_set signal_set;
+
+  /**
+   * @brief This member defines the pre-condition states for the next action.
+   */
+  size_t pcs[ 5 ];
+
+  /**
+   * @brief This member indicates if the test action loop is currently
+   *   executed.
+   */
+  bool in_action_loop;
+} RtemsSignalReqSend_Context;
+
+static RtemsSignalReqSend_Context
+  RtemsSignalReqSend_Instance;
+
+static const char * const RtemsSignalReqSend_PreDesc_Task[] = {
+  "NoObj",
+  "Self",
+  "Other",
+  "NA"
+};
+
+static const char * const RtemsSignalReqSend_PreDesc_Set[] = {
+  "Zero",
+  "NonZero",
+  "NA"
+};
+
+static const char * const RtemsSignalReqSend_PreDesc_Handler[] = {
+  "Invalid",
+  "Valid",
+  "NA"
+};
+
+static const char * const RtemsSignalReqSend_PreDesc_ASR[] = {
+  "Enabled",
+  "Disabled",
+  "NA"
+};
+
+static const char * const RtemsSignalReqSend_PreDesc_Nested[] = {
+  "Yes",
+  "No",
+  "NA"
+};
+
+static const char * const * const RtemsSignalReqSend_PreDesc[] = {
+  RtemsSignalReqSend_PreDesc_Task,
+  RtemsSignalReqSend_PreDesc_Set,
+  RtemsSignalReqSend_PreDesc_Handler,
+  RtemsSignalReqSend_PreDesc_ASR,
+  RtemsSignalReqSend_PreDesc_Nested,
+  NULL
+};
+
+#define EVENT_START RTEMS_EVENT_0
+
+#define EVENT_SEND_DONE RTEMS_EVENT_1
+
+#define EVENT_DO_ENABLE RTEMS_EVENT_2
+
+#define EVENT_END RTEMS_EVENT_3
+
+#define EVENT_WORKER_DONE RTEMS_EVENT_4
+
+typedef RtemsSignalReqSend_Context Context;
+
+typedef enum {
+  PRIO_HIGH = 1,
+  PRIO_NORMAL
+} Priorities;
+
+static rtems_event_set Wait( void )
+{
+  rtems_status_code sc;
+  rtems_event_set   events;
+
+  events = 0;
+  sc = rtems_event_receive(
+    RTEMS_ALL_EVENTS,
+    RTEMS_EVENT_ANY | RTEMS_WAIT,
+    RTEMS_NO_TIMEOUT,
+    &events
+  );
+  T_rsc_success( sc );
+
+  return events;
+}
+
+static void SendEvents( rtems_id id, rtems_event_set events )
+{
+  rtems_status_code sc;
+
+  sc = rtems_event_send( id, events );
+  T_rsc_success( sc );
+}
+
+static void WorkerDone( const Context *ctx )
+{
+#if defined(RTEMS_SMP)
+  if ( rtems_scheduler_get_processor_maximum() > 1 ) {
+    SendEvents( ctx->runner_id, EVENT_WORKER_DONE );
+  }
+#endif
+}
+
+static void SendEventsToWorker( const Context *ctx, rtems_event_set events )
+{
+  SendEvents( ctx->worker_id, events );
+
+#if defined(RTEMS_SMP)
+  if ( rtems_scheduler_get_processor_maximum() > 1 ) {
+    events = Wait();
+    T_eq_u32( events, EVENT_WORKER_DONE );
+  }
+#endif
+}
+
+static void SignalHandler( rtems_signal_set signal_set )
+{
+  Context *ctx;
+  size_t   i;
+  size_t   n;
+
+  ctx = T_fixture_context();
+  i = ctx->handler_calls;
+  n = RTEMS_ARRAY_SIZE( ctx->processed_signal_sets );
+  ctx->processed_signal_sets[ i % n ] = signal_set;
+  ctx->stack_pointers[ i % n ] = (uintptr_t) __builtin_frame_address( 0 );
+  T_lt_sz( i, n );
+  ctx->handler_calls = i + 1;
+
+  if ( ctx->nested != 0 && i == 0 ) {
+    rtems_status_code sc;
+
+    if ( ctx->id == ctx->worker_id ) {
+      rtems_event_set events;
+
+      sc = rtems_signal_catch( ctx->handler, RTEMS_NO_ASR );
+      T_rsc_success( sc );
+
+      WorkerDone( ctx );
+
+      events = Wait();
+      T_eq_u32( events, EVENT_SEND_DONE );
+
+      WorkerDone( ctx );
+
+      events = Wait();
+      T_eq_u32( events, EVENT_DO_ENABLE );
+    } else {
+      sc = rtems_signal_catch( ctx->handler, RTEMS_NO_ASR );
+      T_rsc_success( sc );
+
+      ctx->status = rtems_signal_send( ctx->id, ctx->signal_set );
+      ctx->calls_after_send = ctx->handler_calls;
+      ctx->calls_after_dispatch = ctx->handler_calls;
+    }
+  }
+}
+
+static void Worker( rtems_task_argument arg )
+{
+  Context *ctx;
+
+  ctx = (Context *) arg;
+
+  while ( true ) {
+    rtems_status_code sc;
+    rtems_event_set   events;
+
+    events = Wait();
+    T_eq_u32( events, EVENT_START );
+
+    if ( ctx->nested != 0 ) {
+      sc = rtems_signal_catch( SignalHandler, ctx->mode );
+      T_rsc_success( sc );
+
+      sc = rtems_signal_send( RTEMS_SELF, 0x600df00d );
+      T_rsc_success( sc );
+
+      WorkerDone( ctx );
+    } else {
+      rtems_mode mode;
+
+      sc = rtems_task_mode( ctx->mode, RTEMS_ASR_MASK, &mode );
+      T_rsc_success( sc );
+
+      sc = rtems_signal_catch( ctx->handler, RTEMS_NO_ASR );
+      T_rsc_success( sc );
+
+      WorkerDone( ctx );
+
+      events = Wait();
+      T_eq_u32( events, EVENT_SEND_DONE );
+
+      WorkerDone( ctx );
+
+      events = Wait();
+      T_eq_u32( events, EVENT_DO_ENABLE );
+
+      sc = rtems_task_mode( mode, RTEMS_ASR_MASK, &mode );
+      T_rsc_success( sc );
+
+      WorkerDone( ctx );
+    }
+
+    events = Wait();
+    T_eq_u32( events, EVENT_END );
+
+    WorkerDone( ctx );
+  }
+}
+
+static void RtemsSignalReqSend_Pre_Task_Prepare(
+  RtemsSignalReqSend_Context *ctx,
+  RtemsSignalReqSend_Pre_Task state
+)
+{
+  switch ( state ) {
+    case RtemsSignalReqSend_Pre_Task_NoObj: {
+      ctx->id = 0xffffffff;
+      break;
+    }
+
+    case RtemsSignalReqSend_Pre_Task_Self: {
+      ctx->id = RTEMS_SELF;
+      break;
+    }
+
+    case RtemsSignalReqSend_Pre_Task_Other: {
+      ctx->id = ctx->worker_id;
+      break;
+    }
+
+    case RtemsSignalReqSend_Pre_Task_NA:
+      break;
+  }
+}
+
+static void RtemsSignalReqSend_Pre_Set_Prepare(
+  RtemsSignalReqSend_Context *ctx,
+  RtemsSignalReqSend_Pre_Set  state
+)
+{
+  switch ( state ) {
+    case RtemsSignalReqSend_Pre_Set_Zero: {
+      ctx->signal_set = 0;
+      break;
+    }
+
+    case RtemsSignalReqSend_Pre_Set_NonZero: {
+      ctx->signal_set = 0xdeadbeef;
+      break;
+    }
+
+    case RtemsSignalReqSend_Pre_Set_NA:
+      break;
+  }
+}
+
+static void RtemsSignalReqSend_Pre_Handler_Prepare(
+  RtemsSignalReqSend_Context    *ctx,
+  RtemsSignalReqSend_Pre_Handler state
+)
+{
+  switch ( state ) {
+    case RtemsSignalReqSend_Pre_Handler_Invalid: {
+      ctx->handler = NULL;
+      break;
+    }
+
+    case RtemsSignalReqSend_Pre_Handler_Valid: {
+      ctx->handler = SignalHandler;
+      break;
+    }
+
+    case RtemsSignalReqSend_Pre_Handler_NA:
+      break;
+  }
+}
+
+static void RtemsSignalReqSend_Pre_ASR_Prepare(
+  RtemsSignalReqSend_Context *ctx,
+  RtemsSignalReqSend_Pre_ASR  state
+)
+{
+  switch ( state ) {
+    case RtemsSignalReqSend_Pre_ASR_Enabled: {
+      ctx->mode = RTEMS_DEFAULT_MODES;
+      break;
+    }
+
+    case RtemsSignalReqSend_Pre_ASR_Disabled: {
+      ctx->mode = RTEMS_NO_ASR;
+      break;
+    }
+
+    case RtemsSignalReqSend_Pre_ASR_NA:
+      break;
+  }
+}
+
+static void RtemsSignalReqSend_Pre_Nested_Prepare(
+  RtemsSignalReqSend_Context   *ctx,
+  RtemsSignalReqSend_Pre_Nested state
+)
+{
+  switch ( state ) {
+    case RtemsSignalReqSend_Pre_Nested_Yes: {
+      ctx->nested = 1;
+      break;
+    }
+
+    case RtemsSignalReqSend_Pre_Nested_No: {
+      ctx->nested = 0;
+      break;
+    }
+
+    case RtemsSignalReqSend_Pre_Nested_NA:
+      break;
+  }
+}
+
+static void RtemsSignalReqSend_Post_Status_Check(
+  RtemsSignalReqSend_Context    *ctx,
+  RtemsSignalReqSend_Post_Status state
+)
+{
+  switch ( state ) {
+    case RtemsSignalReqSend_Post_Status_Ok: {
+      T_rsc_success( ctx->status );
+      break;
+    }
+
+    case RtemsSignalReqSend_Post_Status_InvNum: {
+      T_rsc( ctx->status, RTEMS_INVALID_NUMBER );
+      break;
+    }
+
+    case RtemsSignalReqSend_Post_Status_InvId: {
+      T_rsc( ctx->status, RTEMS_INVALID_ID );
+      break;
+    }
+
+    case RtemsSignalReqSend_Post_Status_NotDef: {
+      T_rsc( ctx->status, RTEMS_NOT_DEFINED );
+      break;
+    }
+
+    case RtemsSignalReqSend_Post_Status_NA:
+      break;
+  }
+}
+
+static void RtemsSignalReqSend_Post_Handler_Check(
+  RtemsSignalReqSend_Context     *ctx,
+  RtemsSignalReqSend_Post_Handler state
+)
+{
+  size_t expected_calls;
+
+  expected_calls = ctx->nested;
+
+  switch ( state ) {
+    case RtemsSignalReqSend_Post_Handler_NoCall: {
+      T_eq_sz( ctx->calls_after_send, ctx->nested );
+      T_eq_sz( ctx->calls_after_dispatch, ctx->nested );
+      T_eq_sz( ctx->calls_after_enable, ctx->nested );
+      break;
+    }
+
+    case RtemsSignalReqSend_Post_Handler_DuringSend: {
+      ++expected_calls;
+      T_eq_sz( ctx->calls_after_send, ctx->nested + 1 );
+      T_eq_sz( ctx->calls_after_dispatch, ctx->nested + 1 );
+      T_eq_sz( ctx->calls_after_enable, ctx->nested + 1 );
+      break;
+    }
+
+    case RtemsSignalReqSend_Post_Handler_AfterDispatch: {
+      ++expected_calls;
+      T_eq_sz( ctx->calls_after_send, ctx->nested );
+      T_eq_sz( ctx->calls_after_dispatch, ctx->nested + 1 );
+      T_eq_sz( ctx->calls_after_enable, ctx->nested + 1 );
+      break;
+    }
+
+    case RtemsSignalReqSend_Post_Handler_AfterEnable: {
+      ++expected_calls;
+      T_eq_sz( ctx->calls_after_send, ctx->nested );
+      T_eq_sz( ctx->calls_after_dispatch, ctx->nested );
+      T_eq_sz( ctx->calls_after_enable, ctx->nested + 1 );
+      break;
+    }
+
+    case RtemsSignalReqSend_Post_Handler_NA:
+      break;
+  }
+
+  T_eq_sz( ctx->handler_calls, expected_calls );
+
+  if ( ctx->nested != 0 ) {
+    T_eq_u32( ctx->processed_signal_sets[ 0 ], 0x600df00d );
+  }
+
+  if ( expected_calls > ctx->nested ) {
+    T_eq_u32( ctx->processed_signal_sets[ ctx->nested ], 0xdeadbeef );
+  }
+}
+
+static void RtemsSignalReqSend_Post_Recursive_Check(
+  RtemsSignalReqSend_Context       *ctx,
+  RtemsSignalReqSend_Post_Recursive state
+)
+{
+  switch ( state ) {
+    case RtemsSignalReqSend_Post_Recursive_Yes: {
+      T_eq_sz( ctx->handler_calls, 2 );
+      T_ne_uptr( ctx->stack_pointers[ 0 ], 0 );
+      T_ne_uptr( ctx->stack_pointers[ 1 ], 0 );
+      T_ne_uptr( ctx->stack_pointers[ 0 ], ctx->stack_pointers[ 1 ] );
+      break;
+    }
+
+    case RtemsSignalReqSend_Post_Recursive_No: {
+      if ( ctx->handler_calls == 2 ) {
+        T_ne_uptr( ctx->stack_pointers[ 0 ], 0 );
+        T_ne_uptr( ctx->stack_pointers[ 1 ], 0 );
+        T_eq_uptr( ctx->stack_pointers[ 0 ], ctx->stack_pointers[ 1 ] );
+      }
+      break;
+    }
+
+    case RtemsSignalReqSend_Post_Recursive_NA:
+      break;
+  }
+}
+
+static void RtemsSignalReqSend_Setup( RtemsSignalReqSend_Context *ctx )
+{
+  rtems_status_code   sc;
+  rtems_task_priority prio;
+
+  memset( ctx, 0, sizeof( *ctx ) );
+  ctx->runner_id = rtems_task_self();
+
+  prio = 0;
+  sc = rtems_task_set_priority( RTEMS_SELF, PRIO_NORMAL, &prio );
+  T_rsc_success( sc );
+  T_eq_u32( prio, PRIO_HIGH );
+
+  sc = rtems_task_create(
+    rtems_build_name( 'W', 'O', 'R', 'K' ),
+    PRIO_HIGH,
+    RTEMS_MINIMUM_STACK_SIZE,
+    RTEMS_DEFAULT_MODES,
+    RTEMS_DEFAULT_ATTRIBUTES,
+    &ctx->worker_id
+  );
+  T_assert_rsc_success( sc );
+
+  #if defined(RTEMS_SMP)
+  if ( rtems_scheduler_get_processor_maximum() > 1 ) {
+    rtems_id scheduler_id;
+
+    sc = rtems_scheduler_ident_by_processor( 1, &scheduler_id );
+    T_assert_rsc_success( sc );
+
+    sc = rtems_task_set_scheduler( ctx->worker_id, scheduler_id, PRIO_HIGH );
+    T_assert_rsc_success( sc );
+  }
+  #endif
+
+  sc = rtems_task_start( ctx->worker_id, Worker, (rtems_task_argument) ctx );
+  T_assert_rsc_success( sc );
+}
+
+static void RtemsSignalReqSend_Setup_Wrap( void *arg )
+{
+  RtemsSignalReqSend_Context *ctx;
+
+  ctx = arg;
+  ctx->in_action_loop = false;
+  RtemsSignalReqSend_Setup( ctx );
+}
+
+static void RtemsSignalReqSend_Teardown( RtemsSignalReqSend_Context *ctx )
+{
+  rtems_status_code   sc;
+  rtems_task_priority prio;
+
+  prio = 0;
+  sc = rtems_task_set_priority( RTEMS_SELF, PRIO_HIGH, &prio );
+  T_rsc_success( sc );
+  T_eq_u32( prio, PRIO_NORMAL );
+
+  if ( ctx->worker_id != 0 ) {
+    sc = rtems_task_delete( ctx->worker_id );
+    T_rsc_success( sc );
+  }
+}
+
+static void RtemsSignalReqSend_Teardown_Wrap( void *arg )
+{
+  RtemsSignalReqSend_Context *ctx;
+
+  ctx = arg;
+  ctx->in_action_loop = false;
+  RtemsSignalReqSend_Teardown( ctx );
+}
+
+static size_t RtemsSignalReqSend_Scope( void *arg, char *buf, size_t n )
+{
+  RtemsSignalReqSend_Context *ctx;
+
+  ctx = arg;
+
+  if ( ctx->in_action_loop ) {
+    return T_get_scope( RtemsSignalReqSend_PreDesc, buf, n, ctx->pcs );
+  }
+
+  return 0;
+}
+
+static T_fixture RtemsSignalReqSend_Fixture = {
+  .setup = RtemsSignalReqSend_Setup_Wrap,
+  .stop = NULL,
+  .teardown = RtemsSignalReqSend_Teardown_Wrap,
+  .scope = RtemsSignalReqSend_Scope,
+  .initial_context = &RtemsSignalReqSend_Instance
+};
+
+static const uint8_t RtemsSignalReqSend_TransitionMap[][ 3 ] = {
+  {
+    RtemsSignalReqSend_Post_Status_InvNum,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_InvNum,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_InvNum,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_InvNum,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_InvNum,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_InvNum,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_InvNum,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_InvNum,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_InvId,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_InvId,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_InvId,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_InvId,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_InvId,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_InvId,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_InvId,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_InvId,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_InvNum,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_InvNum,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_InvNum,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_InvNum,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_InvNum,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_InvNum,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_InvNum,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_InvNum,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_NotDef,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_NotDef,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_NotDef,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_NotDef,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_Ok,
+    RtemsSignalReqSend_Post_Handler_DuringSend,
+    RtemsSignalReqSend_Post_Recursive_Yes
+  }, {
+    RtemsSignalReqSend_Post_Status_Ok,
+    RtemsSignalReqSend_Post_Handler_DuringSend,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_Ok,
+    RtemsSignalReqSend_Post_Handler_AfterEnable,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_Ok,
+    RtemsSignalReqSend_Post_Handler_AfterEnable,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_InvNum,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_InvNum,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_InvNum,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_InvNum,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_InvNum,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_InvNum,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_InvNum,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_InvNum,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_NotDef,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_NotDef,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_NotDef,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_NotDef,
+    RtemsSignalReqSend_Post_Handler_NoCall,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_Ok,
+    RtemsSignalReqSend_Post_Handler_AfterDispatch,
+    RtemsSignalReqSend_Post_Recursive_Yes
+  }, {
+    RtemsSignalReqSend_Post_Status_Ok,
+    RtemsSignalReqSend_Post_Handler_AfterDispatch,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_Ok,
+    RtemsSignalReqSend_Post_Handler_AfterEnable,
+    RtemsSignalReqSend_Post_Recursive_No
+  }, {
+    RtemsSignalReqSend_Post_Status_Ok,
+    RtemsSignalReqSend_Post_Handler_AfterEnable,
+    RtemsSignalReqSend_Post_Recursive_No
+  }
+};
+
+static const struct {
+  uint8_t Skip : 1;
+  uint8_t Pre_Task_NA : 1;
+  uint8_t Pre_Set_NA : 1;
+  uint8_t Pre_Handler_NA : 1;
+  uint8_t Pre_ASR_NA : 1;
+  uint8_t Pre_Nested_NA : 1;
+} RtemsSignalReqSend_TransitionInfo[] = {
+  {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }, {
+    0, 0, 0, 0, 0, 0
+  }
+};
+
+static void RtemsSignalReqSend_Prepare( RtemsSignalReqSend_Context *ctx )
+{
+  ctx->handler_calls = 0;
+  ctx->calls_after_send = 0;
+  ctx->calls_after_dispatch = 0;
+  ctx->calls_after_enable = 0;
+  memset( &ctx->processed_signal_sets, 0, sizeof( ctx->processed_signal_sets ) );
+  memset( &ctx->stack_pointers, 0, sizeof( ctx->stack_pointers ) );
+}
+
+static void RtemsSignalReqSend_Action( RtemsSignalReqSend_Context *ctx )
+{
+  rtems_status_code sc;
+
+  if ( ctx->id == ctx->worker_id ) {
+    SendEventsToWorker( ctx, EVENT_START );
+
+    ctx->status = rtems_signal_send( ctx->id, ctx->signal_set );
+    ctx->calls_after_send = ctx->handler_calls;
+
+    SendEventsToWorker( ctx, EVENT_SEND_DONE );
+    ctx->calls_after_dispatch = ctx->handler_calls;
+    SendEventsToWorker( ctx, EVENT_DO_ENABLE );
+    ctx->calls_after_enable = ctx->handler_calls;
+    SendEventsToWorker( ctx, EVENT_END );
+  } else if ( ctx->nested != 0 ) {
+    sc = rtems_signal_catch( SignalHandler, ctx->mode );
+    T_rsc_success( sc );
+
+    sc = rtems_signal_send( RTEMS_SELF, 0x600df00d );
+    T_rsc_success( sc );
+
+    ctx->calls_after_enable = ctx->handler_calls;
+  } else {
+    rtems_mode mode;
+
+    sc = rtems_task_mode( ctx->mode, RTEMS_ASR_MASK, &mode );
+    T_rsc_success( sc );
+
+    sc = rtems_signal_catch( ctx->handler, RTEMS_NO_ASR );
+    T_rsc_success( sc );
+
+    ctx->status = rtems_signal_send( ctx->id, ctx->signal_set );
+    ctx->calls_after_send = ctx->handler_calls;
+    ctx->calls_after_dispatch = ctx->handler_calls;
+
+    sc = rtems_task_mode( mode, RTEMS_ASR_MASK, &mode );
+    T_rsc_success( sc );
+
+    ctx->calls_after_enable = ctx->handler_calls;
+  }
+}
+
+/**
+ * @fn void T_case_body_RtemsSignalReqSend( void )
+ */
+T_TEST_CASE_FIXTURE( RtemsSignalReqSend, &RtemsSignalReqSend_Fixture )
+{
+  RtemsSignalReqSend_Context *ctx;
+  size_t index;
+
+  ctx = T_fixture_context();
+  ctx->in_action_loop = true;
+  index = 0;
+
+  for (
+    ctx->pcs[ 0 ] = RtemsSignalReqSend_Pre_Task_NoObj;
+    ctx->pcs[ 0 ] < RtemsSignalReqSend_Pre_Task_NA;
+    ++ctx->pcs[ 0 ]
+  ) {
+    if ( RtemsSignalReqSend_TransitionInfo[ index ].Pre_Task_NA ) {
+      ctx->pcs[ 0 ] = RtemsSignalReqSend_Pre_Task_NA;
+      index += ( RtemsSignalReqSend_Pre_Task_NA - 1 )
+        * RtemsSignalReqSend_Pre_Set_NA
+        * RtemsSignalReqSend_Pre_Handler_NA
+        * RtemsSignalReqSend_Pre_ASR_NA
+        * RtemsSignalReqSend_Pre_Nested_NA;
+    }
+
+    for (
+      ctx->pcs[ 1 ] = RtemsSignalReqSend_Pre_Set_Zero;
+      ctx->pcs[ 1 ] < RtemsSignalReqSend_Pre_Set_NA;
+      ++ctx->pcs[ 1 ]
+    ) {
+      if ( RtemsSignalReqSend_TransitionInfo[ index ].Pre_Set_NA ) {
+        ctx->pcs[ 1 ] = RtemsSignalReqSend_Pre_Set_NA;
+        index += ( RtemsSignalReqSend_Pre_Set_NA - 1 )
+          * RtemsSignalReqSend_Pre_Handler_NA
+          * RtemsSignalReqSend_Pre_ASR_NA
+          * RtemsSignalReqSend_Pre_Nested_NA;
+      }
+
+      for (
+        ctx->pcs[ 2 ] = RtemsSignalReqSend_Pre_Handler_Invalid;
+        ctx->pcs[ 2 ] < RtemsSignalReqSend_Pre_Handler_NA;
+        ++ctx->pcs[ 2 ]
+      ) {
+        if ( RtemsSignalReqSend_TransitionInfo[ index ].Pre_Handler_NA ) {
+          ctx->pcs[ 2 ] = RtemsSignalReqSend_Pre_Handler_NA;
+          index += ( RtemsSignalReqSend_Pre_Handler_NA - 1 )
+            * RtemsSignalReqSend_Pre_ASR_NA
+            * RtemsSignalReqSend_Pre_Nested_NA;
+        }
+
+        for (
+          ctx->pcs[ 3 ] = RtemsSignalReqSend_Pre_ASR_Enabled;
+          ctx->pcs[ 3 ] < RtemsSignalReqSend_Pre_ASR_NA;
+          ++ctx->pcs[ 3 ]
+        ) {
+          if ( RtemsSignalReqSend_TransitionInfo[ index ].Pre_ASR_NA ) {
+            ctx->pcs[ 3 ] = RtemsSignalReqSend_Pre_ASR_NA;
+            index += ( RtemsSignalReqSend_Pre_ASR_NA - 1 )
+              * RtemsSignalReqSend_Pre_Nested_NA;
+          }
+
+          for (
+            ctx->pcs[ 4 ] = RtemsSignalReqSend_Pre_Nested_Yes;
+            ctx->pcs[ 4 ] < RtemsSignalReqSend_Pre_Nested_NA;
+            ++ctx->pcs[ 4 ]
+          ) {
+            if ( RtemsSignalReqSend_TransitionInfo[ index ].Pre_Nested_NA ) {
+              ctx->pcs[ 4 ] = RtemsSignalReqSend_Pre_Nested_NA;
+              index += ( RtemsSignalReqSend_Pre_Nested_NA - 1 );
+            }
+
+            if ( RtemsSignalReqSend_TransitionInfo[ index ].Skip ) {
+              ++index;
+              continue;
+            }
+
+            RtemsSignalReqSend_Prepare( ctx );
+            RtemsSignalReqSend_Pre_Task_Prepare( ctx, ctx->pcs[ 0 ] );
+            RtemsSignalReqSend_Pre_Set_Prepare( ctx, ctx->pcs[ 1 ] );
+            RtemsSignalReqSend_Pre_Handler_Prepare( ctx, ctx->pcs[ 2 ] );
+            RtemsSignalReqSend_Pre_ASR_Prepare( ctx, ctx->pcs[ 3 ] );
+            RtemsSignalReqSend_Pre_Nested_Prepare( ctx, ctx->pcs[ 4 ] );
+            RtemsSignalReqSend_Action( ctx );
+            RtemsSignalReqSend_Post_Status_Check(
+              ctx,
+              RtemsSignalReqSend_TransitionMap[ index ][ 0 ]
+            );
+            RtemsSignalReqSend_Post_Handler_Check(
+              ctx,
+              RtemsSignalReqSend_TransitionMap[ index ][ 1 ]
+            );
+            RtemsSignalReqSend_Post_Recursive_Check(
+              ctx,
+              RtemsSignalReqSend_TransitionMap[ index ][ 2 ]
+            );
+            ++index;
+          }
+        }
+      }
+    }
+  }
+}
+
+/** @} */