[PATCH 02/13] validation: Add signal manager tests
Sebastian Huber
sebastian.huber at embedded-brains.de
Wed Feb 17 19:30:17 UTC 2021
Update #4244.
---
.../testsuites/validation/validation-0.yml | 2 +
.../testsuites/validation/validation-1.yml | 2 +
testsuites/validation/tc-signal-catch.c | 1017 +++++++++++++++
testsuites/validation/tc-signal-send.c | 1146 +++++++++++++++++
4 files changed, 2167 insertions(+)
create mode 100644 testsuites/validation/tc-signal-catch.c
create mode 100644 testsuites/validation/tc-signal-send.c
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;
+ }
+ }
+ }
+ }
+ }
+}
+
+/** @} */
--
2.26.2
More information about the devel
mailing list