From 6bb40039a74c8243bbbca38330573c3a509d13e1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Frank=20K=C3=BChndel?= Date: Mon, 19 Apr 2021 12:19:05 +0200 Subject: validation: Test rtems_timer_initiate_server() --- spec/build/testsuites/validation/validation-2.yml | 1 + testsuites/validation/tc-timer-initiate-server.c | 876 ++++++++++++++++++++++ 2 files changed, 877 insertions(+) create mode 100644 testsuites/validation/tc-timer-initiate-server.c 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 +#include + +#include "tx-support.h" + +#include + +/** + * @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 ); + } + } + } + } + } +} + +/** @} */ -- cgit v1.2.3