validation: Test rtems_timer_initiate_server()

2 files changed, 877 insertions, 0 deletions

diff --git a/spec/build/testsuites/validation/validation-2.yml b/spec/build/testsuites/validation/validation-2.yml
index 2d9a464253..808a78fcac 100644
--- a/spec/build/testsuites/validation/validation-2.yml
+++ b/spec/build/testsuites/validation/validation-2.yml
@@ -12,6 +12,7 @@ ldflags: []
 links: []
 source:
 - testsuites/validation/ts-validation-2.c
+- testsuites/validation/tc-timer-initiate-server.c
 stlib: []
 target: testsuites/validation/ts-validation-2.exe
 type: build
diff --git a/testsuites/validation/tc-timer-initiate-server.c b/testsuites/validation/tc-timer-initiate-server.c
new file mode 100644
index 0000000000..62587be706
--- /dev/null
+++ b/testsuites/validation/tc-timer-initiate-server.c
@@ -0,0 +1,876 @@
+/* SPDX-License-Identifier: BSD-2-Clause */
+
+/**
+ * @file
+ *
+ * @ingroup RTEMSTestCaseRtemsTimerReqInitiateServer
+ */
+
+/*
+ * 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/rtems/timerimpl.h>
+
+#include "tx-support.h"
+
+#include <rtems/test.h>
+
+/**
+ * @defgroup RTEMSTestCaseRtemsTimerReqInitiateServer \
+ *   spec:/rtems/timer/req/initiate-server
+ *
+ * @ingroup RTEMSTestSuiteTestsuitesValidation2
+ *
+ * @{
+ */
+
+typedef enum {
+  RtemsTimerReqInitiateServer_Pre_Priority_Valid,
+  RtemsTimerReqInitiateServer_Pre_Priority_Default,
+  RtemsTimerReqInitiateServer_Pre_Priority_Invalid,
+  RtemsTimerReqInitiateServer_Pre_Priority_NA
+} RtemsTimerReqInitiateServer_Pre_Priority;
+
+typedef enum {
+  RtemsTimerReqInitiateServer_Pre_Stack_RtemsMin,
+  RtemsTimerReqInitiateServer_Pre_Stack_TooLarge,
+  RtemsTimerReqInitiateServer_Pre_Stack_NA
+} RtemsTimerReqInitiateServer_Pre_Stack;
+
+typedef enum {
+  RtemsTimerReqInitiateServer_Pre_Attr_Default,
+  RtemsTimerReqInitiateServer_Pre_Attr_Float,
+  RtemsTimerReqInitiateServer_Pre_Attr_NA
+} RtemsTimerReqInitiateServer_Pre_Attr;
+
+typedef enum {
+  RtemsTimerReqInitiateServer_Pre_Server_Running,
+  RtemsTimerReqInitiateServer_Pre_Server_NoExist,
+  RtemsTimerReqInitiateServer_Pre_Server_NA
+} RtemsTimerReqInitiateServer_Pre_Server;
+
+typedef enum {
+  RtemsTimerReqInitiateServer_Pre_TaskObj_Available,
+  RtemsTimerReqInitiateServer_Pre_TaskObj_Unavailable,
+  RtemsTimerReqInitiateServer_Pre_TaskObj_NA
+} RtemsTimerReqInitiateServer_Pre_TaskObj;
+
+typedef enum {
+  RtemsTimerReqInitiateServer_Post_Status_Ok,
+  RtemsTimerReqInitiateServer_Post_Status_IncStat,
+  RtemsTimerReqInitiateServer_Post_Status_InvPrio,
+  RtemsTimerReqInitiateServer_Post_Status_TooMany,
+  RtemsTimerReqInitiateServer_Post_Status_Unsat,
+  RtemsTimerReqInitiateServer_Post_Status_NA
+} RtemsTimerReqInitiateServer_Post_Status;
+
+typedef enum {
+  RtemsTimerReqInitiateServer_Post_Server_Running,
+  RtemsTimerReqInitiateServer_Post_Server_NoExist,
+  RtemsTimerReqInitiateServer_Post_Server_NA
+} RtemsTimerReqInitiateServer_Post_Server;
+
+typedef enum {
+  RtemsTimerReqInitiateServer_Post_TaskPrio_Set,
+  RtemsTimerReqInitiateServer_Post_TaskPrio_Unchanged,
+  RtemsTimerReqInitiateServer_Post_TaskPrio_NA
+} RtemsTimerReqInitiateServer_Post_TaskPrio;
+
+typedef enum {
+  RtemsTimerReqInitiateServer_Post_TaskStack_Set,
+  RtemsTimerReqInitiateServer_Post_TaskStack_Unchanged,
+  RtemsTimerReqInitiateServer_Post_TaskStack_NA
+} RtemsTimerReqInitiateServer_Post_TaskStack;
+
+typedef enum {
+  RtemsTimerReqInitiateServer_Post_TaskAttr_NoFloat,
+  RtemsTimerReqInitiateServer_Post_TaskAttr_Float,
+  RtemsTimerReqInitiateServer_Post_TaskAttr_Unchanged,
+  RtemsTimerReqInitiateServer_Post_TaskAttr_NA
+} RtemsTimerReqInitiateServer_Post_TaskAttr;
+
+/**
+ * @brief Test context for spec:/rtems/timer/req/initiate-server test case.
+ */
+typedef struct {
+  /**
+   * @brief If the Timer Server task exists before the action, its priority
+   *   before the action.
+   */
+  rtems_task_priority before_priority;
+
+  /**
+   * @brief If the Timer Server task exists before the action, its stack size
+   *   before the action.
+   */
+  size_t before_stack_size;
+
+  /**
+   * @brief If the Timer Server task exists before the action, whether the
+   *   floating point attribute is set before the action.
+   */
+  bool before_has_floating_point;
+
+  /**
+   * @brief The ``priority`` parameter for the action.
+   */
+  rtems_task_priority priority;
+
+  /**
+   * @brief The ``stack_size`` parameter for the action.
+   */
+  size_t stack_size;
+
+  /**
+   * @brief The ``attribute_set`` parameter for the action.
+   */
+  rtems_attribute attribute_set;
+
+  /**
+   * @brief The status value returned by the action
+   *   rtems_timer_initiate_server().
+   */
+  rtems_status_code status;
+
+  /**
+   * @brief This member is used by the T_seize_objects() and
+   *   T_surrender_objects() support functions.
+   */
+  void *task_objects;
+
+  /**
+   * @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;
+} RtemsTimerReqInitiateServer_Context;
+
+static RtemsTimerReqInitiateServer_Context
+  RtemsTimerReqInitiateServer_Instance;
+
+static const char * const RtemsTimerReqInitiateServer_PreDesc_Priority[] = {
+  "Valid",
+  "Default",
+  "Invalid",
+  "NA"
+};
+
+static const char * const RtemsTimerReqInitiateServer_PreDesc_Stack[] = {
+  "RtemsMin",
+  "TooLarge",
+  "NA"
+};
+
+static const char * const RtemsTimerReqInitiateServer_PreDesc_Attr[] = {
+  "Default",
+  "Float",
+  "NA"
+};
+
+static const char * const RtemsTimerReqInitiateServer_PreDesc_Server[] = {
+  "Running",
+  "NoExist",
+  "NA"
+};
+
+static const char * const RtemsTimerReqInitiateServer_PreDesc_TaskObj[] = {
+  "Available",
+  "Unavailable",
+  "NA"
+};
+
+static const char * const * const RtemsTimerReqInitiateServer_PreDesc[] = {
+  RtemsTimerReqInitiateServer_PreDesc_Priority,
+  RtemsTimerReqInitiateServer_PreDesc_Stack,
+  RtemsTimerReqInitiateServer_PreDesc_Attr,
+  RtemsTimerReqInitiateServer_PreDesc_Server,
+  RtemsTimerReqInitiateServer_PreDesc_TaskObj,
+  NULL
+};
+
+static bool ExistTimerServer( void )
+{
+  return GetTimerServerTaskId() != RTEMS_INVALID_ID;
+}
+
+static rtems_task_priority GetTimerServerPriority( void )
+{
+  return GetPriority( GetTimerServerTaskId() );
+}
+
+static size_t GetTimerServerStackSize( void )
+{
+  rtems_tcb *tcb;
+  rtems_id server_task_id;
+  server_task_id = GetTimerServerTaskId();
+  T_ne_u32( server_task_id, RTEMS_INVALID_ID );
+  tcb = GetThread( server_task_id );
+  T_not_null( tcb );
+  return tcb->Start.Initial_stack.size;
+}
+
+static bool HasTimerServerFloatingPoint( void )
+{
+  rtems_tcb *tcb;
+  rtems_id server_task_id;
+  server_task_id = GetTimerServerTaskId();
+  T_ne_u32( server_task_id, RTEMS_INVALID_ID );
+  tcb = GetThread( server_task_id );
+  T_not_null( tcb );
+  return tcb->is_fp;
+}
+
+static rtems_status_code AllocateTaskObject( void *arg, rtems_id *task_id )
+{
+  (void) arg;
+
+  return rtems_task_create(
+    rtems_build_name( 'T', 'A', ' ', 'N' ),
+    PRIO_LOW,
+    RTEMS_MINIMUM_STACK_SIZE,
+    RTEMS_DEFAULT_MODES,
+    RTEMS_DEFAULT_ATTRIBUTES,
+    task_id
+  );
+}
+
+static void RtemsTimerReqInitiateServer_Pre_Priority_Prepare(
+  RtemsTimerReqInitiateServer_Context     *ctx,
+  RtemsTimerReqInitiateServer_Pre_Priority state
+)
+{
+  switch ( state ) {
+    case RtemsTimerReqInitiateServer_Pre_Priority_Valid: {
+      /*
+       * While the ``priority`` parameter is valid.
+       */
+      ctx->priority = 13;
+      break;
+    }
+
+    case RtemsTimerReqInitiateServer_Pre_Priority_Default: {
+      /*
+       * While the ``priority`` parameter has the value
+       * RTEMS_TIMER_SERVER_DEFAULT_PRIORITY.
+       */
+      ctx->priority = RTEMS_TIMER_SERVER_DEFAULT_PRIORITY;
+      break;
+    }
+
+    case RtemsTimerReqInitiateServer_Pre_Priority_Invalid: {
+      /*
+       * While the ``priority`` parameter is invalid.
+       */
+      ctx->priority = PRIO_INVALID;
+      break;
+    }
+
+    case RtemsTimerReqInitiateServer_Pre_Priority_NA:
+      break;
+  }
+}
+
+static void RtemsTimerReqInitiateServer_Pre_Stack_Prepare(
+  RtemsTimerReqInitiateServer_Context  *ctx,
+  RtemsTimerReqInitiateServer_Pre_Stack state
+)
+{
+  switch ( state ) {
+    case RtemsTimerReqInitiateServer_Pre_Stack_RtemsMin: {
+      /*
+       * While the ``stack_size`` parameter has the value
+       * RTEMS_MINIMUM_STACK_SIZE.
+       */
+      ctx->stack_size = RTEMS_MINIMUM_STACK_SIZE;
+      break;
+    }
+
+    case RtemsTimerReqInitiateServer_Pre_Stack_TooLarge: {
+      /*
+       * While the ``stack_size`` parameter has a value which exceeds the size
+       * of the available memory.
+       */
+      ctx->stack_size = SIZE_MAX;
+      break;
+    }
+
+    case RtemsTimerReqInitiateServer_Pre_Stack_NA:
+      break;
+  }
+}
+
+static void RtemsTimerReqInitiateServer_Pre_Attr_Prepare(
+  RtemsTimerReqInitiateServer_Context *ctx,
+  RtemsTimerReqInitiateServer_Pre_Attr state
+)
+{
+  switch ( state ) {
+    case RtemsTimerReqInitiateServer_Pre_Attr_Default: {
+      /*
+       * While the ``attribute_set`` parameter has the value
+       * RTEMS_DEFAULT_ATTRIBUTES.
+       */
+      ctx->attribute_set = RTEMS_DEFAULT_ATTRIBUTES;
+      break;
+    }
+
+    case RtemsTimerReqInitiateServer_Pre_Attr_Float: {
+      /*
+       * While the ``attribute_set`` parameter has the value
+       * RTEMS_FLOATING_POINT.
+       */
+      ctx->attribute_set = RTEMS_FLOATING_POINT;
+      break;
+    }
+
+    case RtemsTimerReqInitiateServer_Pre_Attr_NA:
+      break;
+  }
+}
+
+static void RtemsTimerReqInitiateServer_Pre_Server_Prepare(
+  RtemsTimerReqInitiateServer_Context   *ctx,
+  RtemsTimerReqInitiateServer_Pre_Server state
+)
+{
+  switch ( state ) {
+    case RtemsTimerReqInitiateServer_Pre_Server_Running: {
+      /*
+       * While the rtems_timer_initiate_server() has been invoked before (i.e.
+       * the time server task has already been started).
+       */
+      rtems_status_code status;
+
+      if ( !ExistTimerServer() ) {
+        status = rtems_timer_initiate_server(
+          RTEMS_TIMER_SERVER_DEFAULT_PRIORITY,
+          RTEMS_MINIMUM_STACK_SIZE,
+          RTEMS_DEFAULT_ATTRIBUTES
+        );
+        T_rsc_success( status );
+      }
+      break;
+    }
+
+    case RtemsTimerReqInitiateServer_Pre_Server_NoExist: {
+      /*
+       * While the rtems_timer_initiate_server() has not been invoked before.
+       */
+      DeleteTimerServer();
+      break;
+    }
+
+    case RtemsTimerReqInitiateServer_Pre_Server_NA:
+      break;
+  }
+}
+
+static void RtemsTimerReqInitiateServer_Pre_TaskObj_Prepare(
+  RtemsTimerReqInitiateServer_Context    *ctx,
+  RtemsTimerReqInitiateServer_Pre_TaskObj state
+)
+{
+  switch ( state ) {
+    case RtemsTimerReqInitiateServer_Pre_TaskObj_Available: {
+      /*
+       * While there is at least one free task object.
+       */
+      /* The test clean up ensures that all tasks objects are free. */
+      break;
+    }
+
+    case RtemsTimerReqInitiateServer_Pre_TaskObj_Unavailable: {
+      /*
+       * While there is no free task object.
+       */
+      ctx->task_objects = T_seize_objects(
+        AllocateTaskObject,
+        NULL
+      );
+      break;
+    }
+
+    case RtemsTimerReqInitiateServer_Pre_TaskObj_NA:
+      break;
+  }
+}
+
+static void RtemsTimerReqInitiateServer_Post_Status_Check(
+  RtemsTimerReqInitiateServer_Context    *ctx,
+  RtemsTimerReqInitiateServer_Post_Status state
+)
+{
+  switch ( state ) {
+    case RtemsTimerReqInitiateServer_Post_Status_Ok: {
+      /*
+       * The return status of rtems_timer_initiate_server() shall be
+       * RTEMS_SUCCESSFUL.
+       */
+      T_rsc_success( ctx->status );
+      break;
+    }
+
+    case RtemsTimerReqInitiateServer_Post_Status_IncStat: {
+      /*
+       * The return status of rtems_timer_initiate_server() shall be
+       * RTEMS_INCORRECT_STATE
+       */
+      T_rsc( ctx->status, RTEMS_INCORRECT_STATE );
+      break;
+    }
+
+    case RtemsTimerReqInitiateServer_Post_Status_InvPrio: {
+      /*
+       * The return status of rtems_timer_initiate_server() shall be
+       * RTEMS_INVALID_PRIORITY.
+       */
+      T_rsc( ctx->status, RTEMS_INVALID_PRIORITY );
+      break;
+    }
+
+    case RtemsTimerReqInitiateServer_Post_Status_TooMany: {
+      /*
+       * The return status of rtems_timer_initiate_server() shall be
+       * RTEMS_TOO_MANY.
+       */
+      T_rsc( ctx->status, RTEMS_TOO_MANY );
+      break;
+    }
+
+    case RtemsTimerReqInitiateServer_Post_Status_Unsat: {
+      /*
+       * The return status of rtems_timer_initiate_server() shall be
+       * RTEMS_UNSATISFIED.
+       */
+      T_rsc( ctx->status, RTEMS_UNSATISFIED  );
+      break;
+    }
+
+    case RtemsTimerReqInitiateServer_Post_Status_NA:
+      break;
+  }
+}
+
+static void RtemsTimerReqInitiateServer_Post_Server_Check(
+  RtemsTimerReqInitiateServer_Context    *ctx,
+  RtemsTimerReqInitiateServer_Post_Server state
+)
+{
+  switch ( state ) {
+    case RtemsTimerReqInitiateServer_Post_Server_Running: {
+      /*
+       * The Timer Server task shall be initialized and existing after the
+       * rtems_timer_initiate_server() call.
+       */
+      T_true( ExistTimerServer() );
+      break;
+    }
+
+    case RtemsTimerReqInitiateServer_Post_Server_NoExist: {
+      /*
+       * The Timer Server task shall not exist.
+       */
+      T_false( ExistTimerServer() );
+      break;
+    }
+
+    case RtemsTimerReqInitiateServer_Post_Server_NA:
+      break;
+  }
+}
+
+static void RtemsTimerReqInitiateServer_Post_TaskPrio_Check(
+  RtemsTimerReqInitiateServer_Context      *ctx,
+  RtemsTimerReqInitiateServer_Post_TaskPrio state
+)
+{
+  switch ( state ) {
+    case RtemsTimerReqInitiateServer_Post_TaskPrio_Set: {
+      /*
+       * The Timer Server task shall have the priority specified by the
+       * ``priority`` parameter in the rtems_timer_initiate_server() call.
+       */
+      if ( ctx->priority == RTEMS_TIMER_SERVER_DEFAULT_PRIORITY ) {
+        T_eq_u32( GetTimerServerPriority(), 0 );
+      } else {
+        T_eq_u32( GetTimerServerPriority(), ctx->priority );
+      }
+      break;
+    }
+
+    case RtemsTimerReqInitiateServer_Post_TaskPrio_Unchanged: {
+      /*
+       * The priority of the Timer Server task shall be unchanged by the
+       * rtems_timer_initiate_server() call.
+       */
+      T_eq_u32( GetTimerServerPriority(), ctx->before_priority );
+      break;
+    }
+
+    case RtemsTimerReqInitiateServer_Post_TaskPrio_NA:
+      break;
+  }
+}
+
+static void RtemsTimerReqInitiateServer_Post_TaskStack_Check(
+  RtemsTimerReqInitiateServer_Context       *ctx,
+  RtemsTimerReqInitiateServer_Post_TaskStack state
+)
+{
+  switch ( state ) {
+    case RtemsTimerReqInitiateServer_Post_TaskStack_Set: {
+      /*
+       * The Timer Server task shall have the same or larger stack size than
+       * specified by the ``stack_size`` parameter in the
+       * rtems_timer_initiate_server() call.
+       */
+      T_ge_sz( GetTimerServerStackSize(), ctx->stack_size );
+      break;
+    }
+
+    case RtemsTimerReqInitiateServer_Post_TaskStack_Unchanged: {
+      /*
+       * The stack size of the Timer Server task shall be unchanged by the
+       * rtems_timer_initiate_server() call.
+       */
+      T_ge_sz( GetTimerServerStackSize(), ctx->before_stack_size );
+      break;
+    }
+
+    case RtemsTimerReqInitiateServer_Post_TaskStack_NA:
+      break;
+  }
+}
+
+static void RtemsTimerReqInitiateServer_Post_TaskAttr_Check(
+  RtemsTimerReqInitiateServer_Context      *ctx,
+  RtemsTimerReqInitiateServer_Post_TaskAttr state
+)
+{
+  switch ( state ) {
+    case RtemsTimerReqInitiateServer_Post_TaskAttr_NoFloat: {
+      /*
+       * The task attribute RTEMS_FLOATING_POINT shall be unset for the Timer
+       * Server task.
+       */
+      T_true( HasTimerServerFloatingPoint() ==
+        ( ( ctx->attribute_set & RTEMS_FLOATING_POINT ) != 0 ) );
+      break;
+    }
+
+    case RtemsTimerReqInitiateServer_Post_TaskAttr_Float: {
+      /*
+       * The task attribute RTEMS_FLOATING_POINT shall be set for the Timer
+       * Server task.
+       */
+      T_true( HasTimerServerFloatingPoint() ==
+        ( ( ctx->attribute_set & RTEMS_FLOATING_POINT ) != 0 ) );
+      break;
+    }
+
+    case RtemsTimerReqInitiateServer_Post_TaskAttr_Unchanged: {
+      /*
+       * The task attributes of the Timer Server task shall be unchanged by the
+       * rtems_timer_initiate_server() call.
+       */
+      T_true( HasTimerServerFloatingPoint() == ctx->before_has_floating_point );
+      break;
+    }
+
+    case RtemsTimerReqInitiateServer_Post_TaskAttr_NA:
+      break;
+  }
+}
+
+static void RtemsTimerReqInitiateServer_Setup(
+  RtemsTimerReqInitiateServer_Context *ctx
+)
+{
+  ctx->task_objects = NULL;
+}
+
+static void RtemsTimerReqInitiateServer_Setup_Wrap( void *arg )
+{
+  RtemsTimerReqInitiateServer_Context *ctx;
+
+  ctx = arg;
+  ctx->in_action_loop = false;
+  RtemsTimerReqInitiateServer_Setup( ctx );
+}
+
+/**
+ * @brief Make sure the time server in not running after this test.
+ */
+static void RtemsTimerReqInitiateServer_Teardown(
+  RtemsTimerReqInitiateServer_Context *ctx
+)
+{
+  DeleteTimerServer();
+}
+
+static void RtemsTimerReqInitiateServer_Teardown_Wrap( void *arg )
+{
+  RtemsTimerReqInitiateServer_Context *ctx;
+
+  ctx = arg;
+  ctx->in_action_loop = false;
+  RtemsTimerReqInitiateServer_Teardown( ctx );
+}
+
+static void RtemsTimerReqInitiateServer_Action(
+  RtemsTimerReqInitiateServer_Context *ctx
+)
+{
+  if ( ExistTimerServer() ) {
+    ctx->before_priority = GetTimerServerPriority();
+    ctx->before_stack_size = GetTimerServerStackSize();
+    ctx->before_has_floating_point = HasTimerServerFloatingPoint();
+  }
+
+  ctx->status = rtems_timer_initiate_server(
+    ctx->priority,
+    ctx->stack_size,
+    ctx->attribute_set
+  );
+}
+
+static void RtemsTimerReqInitiateServer_Cleanup(
+  RtemsTimerReqInitiateServer_Context *ctx
+)
+{
+  T_surrender_objects( &ctx->task_objects, rtems_task_delete );
+}
+
+typedef struct {
+  uint32_t Skip : 1;
+  uint32_t Pre_Priority_NA : 1;
+  uint32_t Pre_Stack_NA : 1;
+  uint32_t Pre_Attr_NA : 1;
+  uint32_t Pre_Server_NA : 1;
+  uint32_t Pre_TaskObj_NA : 1;
+  uint32_t Post_Status : 3;
+  uint32_t Post_Server : 2;
+  uint32_t Post_TaskPrio : 2;
+  uint32_t Post_TaskStack : 2;
+  uint32_t Post_TaskAttr : 2;
+} RtemsTimerReqInitiateServer_Entry;
+
+static const RtemsTimerReqInitiateServer_Entry
+RtemsTimerReqInitiateServer_Entries[] = {
+  { 0, 0, 0, 0, 0, 0, RtemsTimerReqInitiateServer_Post_Status_IncStat,
+    RtemsTimerReqInitiateServer_Post_Server_Running,
+    RtemsTimerReqInitiateServer_Post_TaskPrio_Unchanged,
+    RtemsTimerReqInitiateServer_Post_TaskStack_Unchanged,
+    RtemsTimerReqInitiateServer_Post_TaskAttr_Unchanged },
+  { 0, 0, 0, 0, 0, 0, RtemsTimerReqInitiateServer_Post_Status_TooMany,
+    RtemsTimerReqInitiateServer_Post_Server_NoExist,
+    RtemsTimerReqInitiateServer_Post_TaskPrio_NA,
+    RtemsTimerReqInitiateServer_Post_TaskStack_NA,
+    RtemsTimerReqInitiateServer_Post_TaskAttr_NA },
+  { 0, 0, 0, 0, 0, 0, RtemsTimerReqInitiateServer_Post_Status_InvPrio,
+    RtemsTimerReqInitiateServer_Post_Server_NoExist,
+    RtemsTimerReqInitiateServer_Post_TaskPrio_NA,
+    RtemsTimerReqInitiateServer_Post_TaskStack_NA,
+    RtemsTimerReqInitiateServer_Post_TaskAttr_NA },
+  { 0, 0, 0, 0, 0, 0, RtemsTimerReqInitiateServer_Post_Status_Unsat,
+    RtemsTimerReqInitiateServer_Post_Server_NoExist,
+    RtemsTimerReqInitiateServer_Post_TaskPrio_NA,
+    RtemsTimerReqInitiateServer_Post_TaskStack_NA,
+    RtemsTimerReqInitiateServer_Post_TaskAttr_NA },
+  { 0, 0, 0, 0, 0, 0, RtemsTimerReqInitiateServer_Post_Status_Ok,
+    RtemsTimerReqInitiateServer_Post_Server_Running,
+    RtemsTimerReqInitiateServer_Post_TaskPrio_Set,
+    RtemsTimerReqInitiateServer_Post_TaskStack_Set,
+    RtemsTimerReqInitiateServer_Post_TaskAttr_NoFloat },
+  { 0, 0, 0, 0, 0, 0, RtemsTimerReqInitiateServer_Post_Status_Ok,
+    RtemsTimerReqInitiateServer_Post_Server_Running,
+    RtemsTimerReqInitiateServer_Post_TaskPrio_Set,
+    RtemsTimerReqInitiateServer_Post_TaskStack_Set,
+    RtemsTimerReqInitiateServer_Post_TaskAttr_Float }
+};
+
+static const uint8_t
+RtemsTimerReqInitiateServer_Map[] = {
+  0, 0, 4, 1, 0, 0, 5, 1, 0, 0, 3, 1, 0, 0, 3, 1, 0, 0, 4, 1, 0, 0, 5, 1, 0, 0,
+  3, 1, 0, 0, 3, 1, 0, 0, 2, 2, 0, 0, 2, 2, 0, 0, 2, 2, 0, 0, 2, 2
+};
+
+static size_t RtemsTimerReqInitiateServer_Scope(
+  void  *arg,
+  char  *buf,
+  size_t n
+)
+{
+  RtemsTimerReqInitiateServer_Context *ctx;
+
+  ctx = arg;
+
+  if ( ctx->in_action_loop ) {
+    return T_get_scope(
+      RtemsTimerReqInitiateServer_PreDesc,
+      buf,
+      n,
+      ctx->pcs
+    );
+  }
+
+  return 0;
+}
+
+static T_fixture RtemsTimerReqInitiateServer_Fixture = {
+  .setup = RtemsTimerReqInitiateServer_Setup_Wrap,
+  .stop = NULL,
+  .teardown = RtemsTimerReqInitiateServer_Teardown_Wrap,
+  .scope = RtemsTimerReqInitiateServer_Scope,
+  .initial_context = &RtemsTimerReqInitiateServer_Instance
+};
+
+static inline RtemsTimerReqInitiateServer_Entry
+RtemsTimerReqInitiateServer_GetEntry( size_t index )
+{
+  return RtemsTimerReqInitiateServer_Entries[
+    RtemsTimerReqInitiateServer_Map[ index ]
+  ];
+}
+
+/**
+ * @fn void T_case_body_RtemsTimerReqInitiateServer( void )
+ */
+T_TEST_CASE_FIXTURE(
+  RtemsTimerReqInitiateServer,
+  &RtemsTimerReqInitiateServer_Fixture
+)
+{
+  RtemsTimerReqInitiateServer_Context *ctx;
+  size_t index;
+
+  ctx = T_fixture_context();
+  ctx->in_action_loop = true;
+  index = 0;
+
+  for (
+    ctx->pcs[ 0 ] = RtemsTimerReqInitiateServer_Pre_Priority_Valid;
+    ctx->pcs[ 0 ] < RtemsTimerReqInitiateServer_Pre_Priority_NA;
+    ++ctx->pcs[ 0 ]
+  ) {
+    for (
+      ctx->pcs[ 1 ] = RtemsTimerReqInitiateServer_Pre_Stack_RtemsMin;
+      ctx->pcs[ 1 ] < RtemsTimerReqInitiateServer_Pre_Stack_NA;
+      ++ctx->pcs[ 1 ]
+    ) {
+      for (
+        ctx->pcs[ 2 ] = RtemsTimerReqInitiateServer_Pre_Attr_Default;
+        ctx->pcs[ 2 ] < RtemsTimerReqInitiateServer_Pre_Attr_NA;
+        ++ctx->pcs[ 2 ]
+      ) {
+        for (
+          ctx->pcs[ 3 ] = RtemsTimerReqInitiateServer_Pre_Server_Running;
+          ctx->pcs[ 3 ] < RtemsTimerReqInitiateServer_Pre_Server_NA;
+          ++ctx->pcs[ 3 ]
+        ) {
+          for (
+            ctx->pcs[ 4 ] = RtemsTimerReqInitiateServer_Pre_TaskObj_Available;
+            ctx->pcs[ 4 ] < RtemsTimerReqInitiateServer_Pre_TaskObj_NA;
+            ++ctx->pcs[ 4 ]
+          ) {
+            RtemsTimerReqInitiateServer_Entry entry;
+
+            entry = RtemsTimerReqInitiateServer_GetEntry( index );
+            ++index;
+
+            RtemsTimerReqInitiateServer_Pre_Priority_Prepare(
+              ctx,
+              ctx->pcs[ 0 ]
+            );
+            RtemsTimerReqInitiateServer_Pre_Stack_Prepare(
+              ctx,
+              ctx->pcs[ 1 ]
+            );
+            RtemsTimerReqInitiateServer_Pre_Attr_Prepare( ctx, ctx->pcs[ 2 ] );
+            RtemsTimerReqInitiateServer_Pre_Server_Prepare(
+              ctx,
+              ctx->pcs[ 3 ]
+            );
+            RtemsTimerReqInitiateServer_Pre_TaskObj_Prepare(
+              ctx,
+              ctx->pcs[ 4 ]
+            );
+            RtemsTimerReqInitiateServer_Action( ctx );
+            RtemsTimerReqInitiateServer_Post_Status_Check(
+              ctx,
+              entry.Post_Status
+            );
+            RtemsTimerReqInitiateServer_Post_Server_Check(
+              ctx,
+              entry.Post_Server
+            );
+            RtemsTimerReqInitiateServer_Post_TaskPrio_Check(
+              ctx,
+              entry.Post_TaskPrio
+            );
+            RtemsTimerReqInitiateServer_Post_TaskStack_Check(
+              ctx,
+              entry.Post_TaskStack
+            );
+            RtemsTimerReqInitiateServer_Post_TaskAttr_Check(
+              ctx,
+              entry.Post_TaskAttr
+            );
+            RtemsTimerReqInitiateServer_Cleanup( ctx );
+          }
+        }
+      }
+    }
+  }
+}
+
+/** @} */