diff options
Diffstat (limited to 'testsuites/validation/tc-timer-initiate-server.c')
| -rw-r--r-- | testsuites/validation/tc-timer-initiate-server.c | 816 |
1 files changed, 816 insertions, 0 deletions
diff --git a/testsuites/validation/tc-timer-initiate-server.c b/testsuites/validation/tc-timer-initiate-server.c new file mode 100644 index 0000000000..7a21a3a10b --- /dev/null +++ b/testsuites/validation/tc-timer-initiate-server.c @@ -0,0 +1,816 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup RtemsTimerReqInitiateServer + */ + +/* + * Copyright (C) 2021 embedded brains GmbH & Co. KG + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +/* + * This file is part of the RTEMS quality process and was automatically + * generated. If you find something that needs to be fixed or + * worded better please post a report or patch to an RTEMS mailing list + * or raise a bug report: + * + * https://www.rtems.org/bugs.html + * + * For information on updating and regenerating please refer to the How-To + * section in the Software Requirements Engineering chapter of the + * RTEMS Software Engineering manual. The manual is provided as a part of + * a release. For development sources please refer to the online + * documentation at: + * + * https://docs.rtems.org + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <rtems.h> +#include <rtems/rtems/timerimpl.h> + +#include "tx-support.h" + +#include <rtems/test.h> + +/** + * @defgroup RtemsTimerReqInitiateServer spec:/rtems/timer/req/initiate-server + * + * @ingroup TestsuitesValidationNoClock0 + * + * @{ + */ + +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_Allocatable, + RtemsTimerReqInitiateServer_Pre_Stack_TooLarge, + RtemsTimerReqInitiateServer_Pre_Stack_NA +} RtemsTimerReqInitiateServer_Pre_Stack; + +typedef enum { + RtemsTimerReqInitiateServer_Pre_Started_Yes, + RtemsTimerReqInitiateServer_Pre_Started_No, + RtemsTimerReqInitiateServer_Pre_Started_NA +} RtemsTimerReqInitiateServer_Pre_Started; + +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_Started_Yes, + RtemsTimerReqInitiateServer_Post_Started_No, + RtemsTimerReqInitiateServer_Post_Started_NA +} RtemsTimerReqInitiateServer_Post_Started; + +typedef enum { + RtemsTimerReqInitiateServer_Post_TaskPrio_Set, + RtemsTimerReqInitiateServer_Post_TaskPrio_Nop, + RtemsTimerReqInitiateServer_Post_TaskPrio_NA +} RtemsTimerReqInitiateServer_Post_TaskPrio; + +typedef enum { + RtemsTimerReqInitiateServer_Post_TaskStack_Set, + RtemsTimerReqInitiateServer_Post_TaskStack_Nop, + RtemsTimerReqInitiateServer_Post_TaskStack_NA +} RtemsTimerReqInitiateServer_Post_TaskStack; + +typedef enum { + RtemsTimerReqInitiateServer_Post_TaskAttr_Set, + RtemsTimerReqInitiateServer_Post_TaskAttr_Nop, + RtemsTimerReqInitiateServer_Post_TaskAttr_NA +} RtemsTimerReqInitiateServer_Post_TaskAttr; + +typedef struct { + uint16_t Skip : 1; + uint16_t Pre_Priority_NA : 1; + uint16_t Pre_Stack_NA : 1; + uint16_t Pre_Started_NA : 1; + uint16_t Pre_TaskObj_NA : 1; + uint16_t Post_Status : 3; + uint16_t Post_Started : 2; + uint16_t Post_TaskPrio : 2; + uint16_t Post_TaskStack : 2; + uint16_t Post_TaskAttr : 2; +} RtemsTimerReqInitiateServer_Entry; + +/** + * @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 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; + + struct { + /** + * @brief This member defines the pre-condition states for the next action. + */ + size_t pcs[ 4 ]; + + /** + * @brief If this member is true, then the test action loop is executed. + */ + bool in_action_loop; + + /** + * @brief This member contains the next transition map index. + */ + size_t index; + + /** + * @brief This member contains the current transition map entry. + */ + RtemsTimerReqInitiateServer_Entry entry; + + /** + * @brief If this member is true, then the current transition variant + * should be skipped. + */ + bool skip; + } Map; +} 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[] = { + "Allocatable", + "TooLarge", + "NA" +}; + +static const char * const RtemsTimerReqInitiateServer_PreDesc_Started[] = { + "Yes", + "No", + "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_Started, + 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 is equal to + * 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_Allocatable: { + /* + * While the ``stack_size`` parameter specifies a task stack size which + * is allocatable by the system. + */ + ctx->stack_size = RTEMS_MINIMUM_STACK_SIZE; + break; + } + + case RtemsTimerReqInitiateServer_Pre_Stack_TooLarge: { + /* + * While the ``stack_size`` parameter specifies a task stack size which + * is not allocatable by the system. + */ + ctx->stack_size = SIZE_MAX; + break; + } + + case RtemsTimerReqInitiateServer_Pre_Stack_NA: + break; + } +} + +static void RtemsTimerReqInitiateServer_Pre_Started_Prepare( + RtemsTimerReqInitiateServer_Context *ctx, + RtemsTimerReqInitiateServer_Pre_Started state +) +{ + switch ( state ) { + case RtemsTimerReqInitiateServer_Pre_Started_Yes: { + /* + * While the Timer Server task is 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_Started_No: { + /* + * While the Timer Server task is not started. + */ + DeleteTimerServer(); + break; + } + + case RtemsTimerReqInitiateServer_Pre_Started_NA: + break; + } +} + +static void RtemsTimerReqInitiateServer_Pre_TaskObj_Prepare( + RtemsTimerReqInitiateServer_Context *ctx, + RtemsTimerReqInitiateServer_Pre_TaskObj state +) +{ + switch ( state ) { + case RtemsTimerReqInitiateServer_Pre_TaskObj_Available: { + /* + * While the system has at least one inactive task object available. + */ + /* The test clean up ensures that all tasks objects are free. */ + break; + } + + case RtemsTimerReqInitiateServer_Pre_TaskObj_Unavailable: { + /* + * While the system has no inactive task object available. + */ + 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_Started_Check( + RtemsTimerReqInitiateServer_Context *ctx, + RtemsTimerReqInitiateServer_Post_Started state +) +{ + switch ( state ) { + case RtemsTimerReqInitiateServer_Post_Started_Yes: { + /* + * The Timer Server task shall be started after the + * rtems_timer_initiate_server() call. + */ + T_true( ExistTimerServer() ); + break; + } + + case RtemsTimerReqInitiateServer_Post_Started_No: { + /* + * The Timer Server task shall not be started after the + * rtems_timer_initiate_server() call. + */ + T_false( ExistTimerServer() ); + break; + } + + case RtemsTimerReqInitiateServer_Post_Started_NA: + break; + } +} + +static void RtemsTimerReqInitiateServer_Post_TaskPrio_Check( + RtemsTimerReqInitiateServer_Context *ctx, + RtemsTimerReqInitiateServer_Post_TaskPrio state +) +{ + switch ( state ) { + case RtemsTimerReqInitiateServer_Post_TaskPrio_Set: { + /* + * The priority of the Timer Server task shall be equal to 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_Nop: { + /* + * The priority of the Timer Server task shall not be modified 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 stack size of the Timer Server task shall be greater than or equal + * to the stack size 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_Nop: { + /* + * The stack size of the Timer Server task shall not be modified 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_Set: { + /* + * The task attributes of the Timer Server task shall be specified by the + * ``attribute_set`` parameter in the rtems_timer_initiate_server() call. + */ + T_true( HasTimerServerFloatingPoint() ); + break; + } + + case RtemsTimerReqInitiateServer_Post_TaskAttr_Nop: { + /* + * The task attributes of the Timer Server task shall not be modified 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->Map.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->Map.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, + RTEMS_FLOATING_POINT + ); +} + +static void RtemsTimerReqInitiateServer_Cleanup( + RtemsTimerReqInitiateServer_Context *ctx +) +{ + T_surrender_objects( &ctx->task_objects, rtems_task_delete ); +} + +static const RtemsTimerReqInitiateServer_Entry +RtemsTimerReqInitiateServer_Entries[] = { + { 0, 0, 0, 0, 0, RtemsTimerReqInitiateServer_Post_Status_IncStat, + RtemsTimerReqInitiateServer_Post_Started_Yes, + RtemsTimerReqInitiateServer_Post_TaskPrio_Nop, + RtemsTimerReqInitiateServer_Post_TaskStack_Nop, + RtemsTimerReqInitiateServer_Post_TaskAttr_Nop }, + { 0, 0, 0, 0, 0, RtemsTimerReqInitiateServer_Post_Status_TooMany, + RtemsTimerReqInitiateServer_Post_Started_No, + RtemsTimerReqInitiateServer_Post_TaskPrio_NA, + RtemsTimerReqInitiateServer_Post_TaskStack_NA, + RtemsTimerReqInitiateServer_Post_TaskAttr_NA }, + { 0, 0, 0, 0, 0, RtemsTimerReqInitiateServer_Post_Status_InvPrio, + RtemsTimerReqInitiateServer_Post_Started_No, + RtemsTimerReqInitiateServer_Post_TaskPrio_NA, + RtemsTimerReqInitiateServer_Post_TaskStack_NA, + RtemsTimerReqInitiateServer_Post_TaskAttr_NA }, + { 0, 0, 0, 0, 0, RtemsTimerReqInitiateServer_Post_Status_Ok, + RtemsTimerReqInitiateServer_Post_Started_Yes, + RtemsTimerReqInitiateServer_Post_TaskPrio_Set, + RtemsTimerReqInitiateServer_Post_TaskStack_Set, + RtemsTimerReqInitiateServer_Post_TaskAttr_Set }, + { 0, 0, 0, 0, 0, RtemsTimerReqInitiateServer_Post_Status_Unsat, + RtemsTimerReqInitiateServer_Post_Started_No, + RtemsTimerReqInitiateServer_Post_TaskPrio_NA, + RtemsTimerReqInitiateServer_Post_TaskStack_NA, + RtemsTimerReqInitiateServer_Post_TaskAttr_NA } +}; + +static const uint8_t +RtemsTimerReqInitiateServer_Map[] = { + 0, 0, 3, 1, 0, 0, 4, 1, 0, 0, 3, 1, 0, 0, 4, 1, 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->Map.in_action_loop ) { + return T_get_scope( + RtemsTimerReqInitiateServer_PreDesc, + buf, + n, + ctx->Map.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_PopEntry( + RtemsTimerReqInitiateServer_Context *ctx +) +{ + size_t index; + + index = ctx->Map.index; + ctx->Map.index = index + 1; + return RtemsTimerReqInitiateServer_Entries[ + RtemsTimerReqInitiateServer_Map[ index ] + ]; +} + +static void RtemsTimerReqInitiateServer_TestVariant( + RtemsTimerReqInitiateServer_Context *ctx +) +{ + RtemsTimerReqInitiateServer_Pre_Priority_Prepare( ctx, ctx->Map.pcs[ 0 ] ); + RtemsTimerReqInitiateServer_Pre_Stack_Prepare( ctx, ctx->Map.pcs[ 1 ] ); + RtemsTimerReqInitiateServer_Pre_Started_Prepare( ctx, ctx->Map.pcs[ 2 ] ); + RtemsTimerReqInitiateServer_Pre_TaskObj_Prepare( ctx, ctx->Map.pcs[ 3 ] ); + RtemsTimerReqInitiateServer_Action( ctx ); + RtemsTimerReqInitiateServer_Post_Status_Check( + ctx, + ctx->Map.entry.Post_Status + ); + RtemsTimerReqInitiateServer_Post_Started_Check( + ctx, + ctx->Map.entry.Post_Started + ); + RtemsTimerReqInitiateServer_Post_TaskPrio_Check( + ctx, + ctx->Map.entry.Post_TaskPrio + ); + RtemsTimerReqInitiateServer_Post_TaskStack_Check( + ctx, + ctx->Map.entry.Post_TaskStack + ); + RtemsTimerReqInitiateServer_Post_TaskAttr_Check( + ctx, + ctx->Map.entry.Post_TaskAttr + ); +} + +/** + * @fn void T_case_body_RtemsTimerReqInitiateServer( void ) + */ +T_TEST_CASE_FIXTURE( + RtemsTimerReqInitiateServer, + &RtemsTimerReqInitiateServer_Fixture +) +{ + RtemsTimerReqInitiateServer_Context *ctx; + + ctx = T_fixture_context(); + ctx->Map.in_action_loop = true; + ctx->Map.index = 0; + + for ( + ctx->Map.pcs[ 0 ] = RtemsTimerReqInitiateServer_Pre_Priority_Valid; + ctx->Map.pcs[ 0 ] < RtemsTimerReqInitiateServer_Pre_Priority_NA; + ++ctx->Map.pcs[ 0 ] + ) { + for ( + ctx->Map.pcs[ 1 ] = RtemsTimerReqInitiateServer_Pre_Stack_Allocatable; + ctx->Map.pcs[ 1 ] < RtemsTimerReqInitiateServer_Pre_Stack_NA; + ++ctx->Map.pcs[ 1 ] + ) { + for ( + ctx->Map.pcs[ 2 ] = RtemsTimerReqInitiateServer_Pre_Started_Yes; + ctx->Map.pcs[ 2 ] < RtemsTimerReqInitiateServer_Pre_Started_NA; + ++ctx->Map.pcs[ 2 ] + ) { + for ( + ctx->Map.pcs[ 3 ] = RtemsTimerReqInitiateServer_Pre_TaskObj_Available; + ctx->Map.pcs[ 3 ] < RtemsTimerReqInitiateServer_Pre_TaskObj_NA; + ++ctx->Map.pcs[ 3 ] + ) { + ctx->Map.entry = RtemsTimerReqInitiateServer_PopEntry( ctx ); + RtemsTimerReqInitiateServer_TestVariant( ctx ); + RtemsTimerReqInitiateServer_Cleanup( ctx ); + } + } + } + } +} + +/** @} */ |