diff options
Diffstat (limited to 'testsuites/validation/tc-task-set-scheduler.c')
-rw-r--r-- | testsuites/validation/tc-task-set-scheduler.c | 1491 |
1 files changed, 1491 insertions, 0 deletions
diff --git a/testsuites/validation/tc-task-set-scheduler.c b/testsuites/validation/tc-task-set-scheduler.c new file mode 100644 index 0000000000..174aa55736 --- /dev/null +++ b/testsuites/validation/tc-task-set-scheduler.c @@ -0,0 +1,1491 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ + +/** + * @file + * + * @ingroup RtemsTaskReqSetScheduler + */ + +/* + * 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/score/threadimpl.h> + +#include "ts-config.h" +#include "tx-support.h" + +#include <rtems/test.h> + +/** + * @defgroup RtemsTaskReqSetScheduler spec:/rtems/task/req/set-scheduler + * + * @ingroup TestsuitesValidationNoClock0 + * + * @{ + */ + +typedef enum { + RtemsTaskReqSetScheduler_Pre_TaskId_Task, + RtemsTaskReqSetScheduler_Pre_TaskId_Invalid, + RtemsTaskReqSetScheduler_Pre_TaskId_NA +} RtemsTaskReqSetScheduler_Pre_TaskId; + +typedef enum { + RtemsTaskReqSetScheduler_Pre_Scheduler_Home, + RtemsTaskReqSetScheduler_Pre_Scheduler_Other, + RtemsTaskReqSetScheduler_Pre_Scheduler_NA +} RtemsTaskReqSetScheduler_Pre_Scheduler; + +typedef enum { + RtemsTaskReqSetScheduler_Pre_SchedulerHasCPU_Yes, + RtemsTaskReqSetScheduler_Pre_SchedulerHasCPU_No, + RtemsTaskReqSetScheduler_Pre_SchedulerHasCPU_NA +} RtemsTaskReqSetScheduler_Pre_SchedulerHasCPU; + +typedef enum { + RtemsTaskReqSetScheduler_Pre_SchedulerId_Scheduler, + RtemsTaskReqSetScheduler_Pre_SchedulerId_Invalid, + RtemsTaskReqSetScheduler_Pre_SchedulerId_NA +} RtemsTaskReqSetScheduler_Pre_SchedulerId; + +typedef enum { + RtemsTaskReqSetScheduler_Pre_Priority_Valid, + RtemsTaskReqSetScheduler_Pre_Priority_Invalid, + RtemsTaskReqSetScheduler_Pre_Priority_NA +} RtemsTaskReqSetScheduler_Pre_Priority; + +typedef enum { + RtemsTaskReqSetScheduler_Pre_HomePriority_Real, + RtemsTaskReqSetScheduler_Pre_HomePriority_More, + RtemsTaskReqSetScheduler_Pre_HomePriority_NA +} RtemsTaskReqSetScheduler_Pre_HomePriority; + +typedef enum { + RtemsTaskReqSetScheduler_Pre_EligiblePriorities_OnlyOne, + RtemsTaskReqSetScheduler_Pre_EligiblePriorities_More, + RtemsTaskReqSetScheduler_Pre_EligiblePriorities_NA +} RtemsTaskReqSetScheduler_Pre_EligiblePriorities; + +typedef enum { + RtemsTaskReqSetScheduler_Pre_Pinned_Yes, + RtemsTaskReqSetScheduler_Pre_Pinned_No, + RtemsTaskReqSetScheduler_Pre_Pinned_NA +} RtemsTaskReqSetScheduler_Pre_Pinned; + +typedef enum { + RtemsTaskReqSetScheduler_Pre_TaskState_Ready, + RtemsTaskReqSetScheduler_Pre_TaskState_Blocked, + RtemsTaskReqSetScheduler_Pre_TaskState_Enqueued, + RtemsTaskReqSetScheduler_Pre_TaskState_NA +} RtemsTaskReqSetScheduler_Pre_TaskState; + +typedef enum { + RtemsTaskReqSetScheduler_Pre_AffinitySupported_Yes, + RtemsTaskReqSetScheduler_Pre_AffinitySupported_No, + RtemsTaskReqSetScheduler_Pre_AffinitySupported_NA +} RtemsTaskReqSetScheduler_Pre_AffinitySupported; + +typedef enum { + RtemsTaskReqSetScheduler_Post_Status_Ok, + RtemsTaskReqSetScheduler_Post_Status_InvAddr, + RtemsTaskReqSetScheduler_Post_Status_InvId, + RtemsTaskReqSetScheduler_Post_Status_InvPrio, + RtemsTaskReqSetScheduler_Post_Status_InUse, + RtemsTaskReqSetScheduler_Post_Status_Unsat, + RtemsTaskReqSetScheduler_Post_Status_NA +} RtemsTaskReqSetScheduler_Post_Status; + +typedef enum { + RtemsTaskReqSetScheduler_Post_Scheduler_Set, + RtemsTaskReqSetScheduler_Post_Scheduler_Nop, + RtemsTaskReqSetScheduler_Post_Scheduler_NA +} RtemsTaskReqSetScheduler_Post_Scheduler; + +typedef enum { + RtemsTaskReqSetScheduler_Post_Priority_Set, + RtemsTaskReqSetScheduler_Post_Priority_Nop, + RtemsTaskReqSetScheduler_Post_Priority_NA +} RtemsTaskReqSetScheduler_Post_Priority; + +typedef struct { + uint32_t Skip : 1; + uint32_t Pre_TaskId_NA : 1; + uint32_t Pre_Scheduler_NA : 1; + uint32_t Pre_SchedulerHasCPU_NA : 1; + uint32_t Pre_SchedulerId_NA : 1; + uint32_t Pre_Priority_NA : 1; + uint32_t Pre_HomePriority_NA : 1; + uint32_t Pre_EligiblePriorities_NA : 1; + uint32_t Pre_Pinned_NA : 1; + uint32_t Pre_TaskState_NA : 1; + uint32_t Pre_AffinitySupported_NA : 1; + uint32_t Post_Status : 3; + uint32_t Post_Scheduler : 2; + uint32_t Post_Priority : 2; +} RtemsTaskReqSetScheduler_Entry; + +/** + * @brief Test context for spec:/rtems/task/req/set-scheduler test case. + */ +typedef struct { + /** + * @brief This member contains the runner task identifier. + */ + rtems_id runner_id; + + /** + * @brief This member contains the scheduler A identifier. + */ + rtems_id scheduler_a_id; + + /** + * @brief This member contains the scheduler B identifier. + */ + rtems_id scheduler_b_id; + + /** + * @brief This member contains the scheduler D identifier. + */ + rtems_id scheduler_d_id; + + /** + * @brief This member contains the worker task identifiers. + */ + rtems_id worker_id[ 3 ]; + + /** + * @brief This member contains the mutex identifiers. + */ + rtems_id mutex_id[ 2 ]; + + /** + * @brief If this member is true, then the task shall have an additional + * priority for the home scheduler. + */ + bool additional_home_priority; + + /** + * @brief If this member is true, then the task shall have a second eligible + * scheduler. + */ + bool second_eligible_scheduler; + + /** + * @brief If this member is true, then the task shall be pinned to a + * processor. + */ + bool pinned; + + /** + * @brief If this member is true, then the task shall be blocked. + */ + bool blocked; + + /** + * @brief If this member is true, then the task shall be enqueued on a thread + * queue. + */ + bool enqueued; + + /** + * @brief This member specifies the scheduler identifier to set. + */ + rtems_id scheduler_to_set_id; + + /** + * @brief If this member is true, then the affinity of the task shall be + * supported by the scheduler. + */ + bool affinity_supported; + + /** + * @brief This member contains the return value of the + * rtems_task_set_scheduler() call. + */ + rtems_status_code status; + + /** + * @brief This member specifies if the ``task_id`` parameter value. + */ + rtems_id task_id; + + /** + * @brief This member specifies if the ``scheduler_id`` parameter value. + */ + rtems_id scheduler_id; + + /** + * @brief This member specifies if the ``priority`` parameter value. + */ + rtems_task_priority priority; + + /** + * @brief This member contains the identifier of the new scheduler. + */ + rtems_id new_scheduler; + + /** + * @brief This member contains the new priorities of the task. + */ + rtems_task_priority new_priority[ 2 ]; + + struct { + /** + * @brief This member defines the pre-condition indices for the next + * action. + */ + size_t pci[ 10 ]; + + /** + * @brief This member defines the pre-condition states for the next action. + */ + size_t pcs[ 10 ]; + + /** + * @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. + */ + RtemsTaskReqSetScheduler_Entry entry; + + /** + * @brief If this member is true, then the current transition variant + * should be skipped. + */ + bool skip; + } Map; +} RtemsTaskReqSetScheduler_Context; + +static RtemsTaskReqSetScheduler_Context + RtemsTaskReqSetScheduler_Instance; + +static const char * const RtemsTaskReqSetScheduler_PreDesc_TaskId[] = { + "Task", + "Invalid", + "NA" +}; + +static const char * const RtemsTaskReqSetScheduler_PreDesc_Scheduler[] = { + "Home", + "Other", + "NA" +}; + +static const char * const RtemsTaskReqSetScheduler_PreDesc_SchedulerHasCPU[] = { + "Yes", + "No", + "NA" +}; + +static const char * const RtemsTaskReqSetScheduler_PreDesc_SchedulerId[] = { + "Scheduler", + "Invalid", + "NA" +}; + +static const char * const RtemsTaskReqSetScheduler_PreDesc_Priority[] = { + "Valid", + "Invalid", + "NA" +}; + +static const char * const RtemsTaskReqSetScheduler_PreDesc_HomePriority[] = { + "Real", + "More", + "NA" +}; + +static const char * const RtemsTaskReqSetScheduler_PreDesc_EligiblePriorities[] = { + "OnlyOne", + "More", + "NA" +}; + +static const char * const RtemsTaskReqSetScheduler_PreDesc_Pinned[] = { + "Yes", + "No", + "NA" +}; + +static const char * const RtemsTaskReqSetScheduler_PreDesc_TaskState[] = { + "Ready", + "Blocked", + "Enqueued", + "NA" +}; + +static const char * const RtemsTaskReqSetScheduler_PreDesc_AffinitySupported[] = { + "Yes", + "No", + "NA" +}; + +static const char * const * const RtemsTaskReqSetScheduler_PreDesc[] = { + RtemsTaskReqSetScheduler_PreDesc_TaskId, + RtemsTaskReqSetScheduler_PreDesc_Scheduler, + RtemsTaskReqSetScheduler_PreDesc_SchedulerHasCPU, + RtemsTaskReqSetScheduler_PreDesc_SchedulerId, + RtemsTaskReqSetScheduler_PreDesc_Priority, + RtemsTaskReqSetScheduler_PreDesc_HomePriority, + RtemsTaskReqSetScheduler_PreDesc_EligiblePriorities, + RtemsTaskReqSetScheduler_PreDesc_Pinned, + RtemsTaskReqSetScheduler_PreDesc_TaskState, + RtemsTaskReqSetScheduler_PreDesc_AffinitySupported, + NULL +}; + +typedef RtemsTaskReqSetScheduler_Context Context; + +#define EVENT_OBTAIN_MUTEX_A RTEMS_EVENT_0 + +#define EVENT_RELEASE_MUTEX_A RTEMS_EVENT_1 + +#define EVENT_OBTAIN_MUTEX_B RTEMS_EVENT_2 + +#define EVENT_RELEASE_MUTEX_B RTEMS_EVENT_3 + +#define EVENT_PIN RTEMS_EVENT_4 + +#define EVENT_UNPIN RTEMS_EVENT_5 + +#define EVENT_SET_LOW_PRIO RTEMS_EVENT_6 + +#define EVENT_RUNNER_SYNC_0 RTEMS_EVENT_7 + +#define EVENT_RUNNER_SYNC_1 RTEMS_EVENT_8 + +static void Worker( rtems_task_argument arg ) +{ + Context *ctx; + Thread_Control *executing; + + ctx = (Context *) arg; + executing = _Thread_Get_executing(); + + while ( true ) { + rtems_event_set events; + + events = ReceiveAnyEvents(); + + if ( ( events & EVENT_RUNNER_SYNC_0 ) != 0 ) { + SendEvents( ctx->runner_id, EVENT_RUNNER_SYNC_0 ); + } + + if ( ( events & EVENT_OBTAIN_MUTEX_A ) != 0 ) { + ObtainMutex( ctx->mutex_id[ 0 ] ); + } + + if ( ( events & EVENT_RELEASE_MUTEX_A ) != 0 ) { + ReleaseMutex( ctx->mutex_id[ 0 ] ); + } + + if ( ( events & EVENT_OBTAIN_MUTEX_B ) != 0 ) { + ObtainMutex( ctx->mutex_id[ 1 ] ); + } + + if ( ( events & EVENT_RELEASE_MUTEX_B ) != 0 ) { + ReleaseMutex( ctx->mutex_id[ 1 ] ); + } + + if ( ( events & EVENT_PIN ) != 0 ) { + _Thread_Pin( executing ); + } + + if ( ( events & EVENT_UNPIN ) != 0 ) { + _Thread_Unpin( executing, _Per_CPU_Get_snapshot() ); + } + + if ( ( events & EVENT_SET_LOW_PRIO ) != 0 ) { + SetSelfPriority( PRIO_LOW ); + } + + if ( ( events & EVENT_RUNNER_SYNC_1 ) != 0 ) { + SendEvents( ctx->runner_id, EVENT_RUNNER_SYNC_1 ); + } + } +} + +static void RtemsTaskReqSetScheduler_Pre_TaskId_Prepare( + RtemsTaskReqSetScheduler_Context *ctx, + RtemsTaskReqSetScheduler_Pre_TaskId state +) +{ + switch ( state ) { + case RtemsTaskReqSetScheduler_Pre_TaskId_Task: { + /* + * While the ``task_id`` parameter is associated with a task. + */ + ctx->task_id = ctx->worker_id[ 0 ]; + break; + } + + case RtemsTaskReqSetScheduler_Pre_TaskId_Invalid: { + /* + * While the ``task_id`` parameter is not associated with a task. + */ + ctx->task_id = INVALID_ID; + break; + } + + case RtemsTaskReqSetScheduler_Pre_TaskId_NA: + break; + } +} + +static void RtemsTaskReqSetScheduler_Pre_Scheduler_Prepare( + RtemsTaskReqSetScheduler_Context *ctx, + RtemsTaskReqSetScheduler_Pre_Scheduler state +) +{ + switch ( state ) { + case RtemsTaskReqSetScheduler_Pre_Scheduler_Home: { + /* + * While the scheduler specified by the ``scheduler_id`` parameter is the + * home scheduler of the task specified by the ``task_id`` parameter. + */ + ctx->scheduler_to_set_id = ctx->scheduler_a_id; + break; + } + + case RtemsTaskReqSetScheduler_Pre_Scheduler_Other: { + /* + * While the scheduler specified by the ``scheduler_id`` parameter is not + * the home scheduler of the task specified by the ``task_id`` parameter. + */ + ctx->scheduler_to_set_id = ctx->scheduler_b_id; + break; + } + + case RtemsTaskReqSetScheduler_Pre_Scheduler_NA: + break; + } +} + +static void RtemsTaskReqSetScheduler_Pre_SchedulerHasCPU_Prepare( + RtemsTaskReqSetScheduler_Context *ctx, + RtemsTaskReqSetScheduler_Pre_SchedulerHasCPU state +) +{ + switch ( state ) { + case RtemsTaskReqSetScheduler_Pre_SchedulerHasCPU_Yes: { + /* + * While the scheduler specified by the ``scheduler_id`` parameter owns + * at least one processor. + */ + /* Already set by Scheduler pre-condition */ + break; + } + + case RtemsTaskReqSetScheduler_Pre_SchedulerHasCPU_No: { + /* + * While the scheduler specified by the ``scheduler_id`` parameter owns + * no processor. + */ + ctx->scheduler_to_set_id = ctx->scheduler_d_id; + break; + } + + case RtemsTaskReqSetScheduler_Pre_SchedulerHasCPU_NA: + break; + } +} + +static void RtemsTaskReqSetScheduler_Pre_SchedulerId_Prepare( + RtemsTaskReqSetScheduler_Context *ctx, + RtemsTaskReqSetScheduler_Pre_SchedulerId state +) +{ + switch ( state ) { + case RtemsTaskReqSetScheduler_Pre_SchedulerId_Scheduler: { + /* + * While the ``scheduler_id`` parameter is associated with a scheduler. + */ + ctx->scheduler_id = ctx->scheduler_to_set_id; + break; + } + + case RtemsTaskReqSetScheduler_Pre_SchedulerId_Invalid: { + /* + * While the ``scheduler_id`` parameter is not associated with a + * scheduler. + */ + ctx->scheduler_id = INVALID_ID; + break; + } + + case RtemsTaskReqSetScheduler_Pre_SchedulerId_NA: + break; + } +} + +static void RtemsTaskReqSetScheduler_Pre_Priority_Prepare( + RtemsTaskReqSetScheduler_Context *ctx, + RtemsTaskReqSetScheduler_Pre_Priority state +) +{ + switch ( state ) { + case RtemsTaskReqSetScheduler_Pre_Priority_Valid: { + /* + * While the task priority specified by the ``priority`` parameter is + * valid with respect to the scheduler specified by the ``scheduler_id`` + * parameter. + */ + ctx->priority = PRIO_VERY_LOW; + break; + } + + case RtemsTaskReqSetScheduler_Pre_Priority_Invalid: { + /* + * While the task priority specified by the ``priority`` parameter is + * invalid with respect to the scheduler specified by the + * ``scheduler_id`` parameter. + */ + ctx->priority = PRIO_INVALID; + break; + } + + case RtemsTaskReqSetScheduler_Pre_Priority_NA: + break; + } +} + +static void RtemsTaskReqSetScheduler_Pre_HomePriority_Prepare( + RtemsTaskReqSetScheduler_Context *ctx, + RtemsTaskReqSetScheduler_Pre_HomePriority state +) +{ + switch ( state ) { + case RtemsTaskReqSetScheduler_Pre_HomePriority_Real: { + /* + * While the current priority of the task specified by the ``task_id`` + * parameter consists only of the real priority. + */ + ctx->additional_home_priority = false; + break; + } + + case RtemsTaskReqSetScheduler_Pre_HomePriority_More: { + /* + * While the current priority of the task specified by the ``task_id`` + * parameter consists of more than the real priority. + */ + ctx->additional_home_priority = true; + break; + } + + case RtemsTaskReqSetScheduler_Pre_HomePriority_NA: + break; + } +} + +static void RtemsTaskReqSetScheduler_Pre_EligiblePriorities_Prepare( + RtemsTaskReqSetScheduler_Context *ctx, + RtemsTaskReqSetScheduler_Pre_EligiblePriorities state +) +{ + switch ( state ) { + case RtemsTaskReqSetScheduler_Pre_EligiblePriorities_OnlyOne: { + /* + * While the set of eligible priorities of the task specified by the + * ``task_id`` parameter consists of exactly the current priority. + */ + ctx->second_eligible_scheduler = false; + break; + } + + case RtemsTaskReqSetScheduler_Pre_EligiblePriorities_More: { + /* + * While the set of eligible priorities of the task specified by the + * ``task_id`` parameter consists of more than the current priority. + */ + ctx->second_eligible_scheduler = true; + break; + } + + case RtemsTaskReqSetScheduler_Pre_EligiblePriorities_NA: + break; + } +} + +static void RtemsTaskReqSetScheduler_Pre_Pinned_Prepare( + RtemsTaskReqSetScheduler_Context *ctx, + RtemsTaskReqSetScheduler_Pre_Pinned state +) +{ + switch ( state ) { + case RtemsTaskReqSetScheduler_Pre_Pinned_Yes: { + /* + * While the task specified by the ``task_id`` parameter is pinned. + */ + ctx->pinned = true; + break; + } + + case RtemsTaskReqSetScheduler_Pre_Pinned_No: { + /* + * While the task specified by the ``task_id`` parameter is not pinned. + */ + ctx->pinned = false; + break; + } + + case RtemsTaskReqSetScheduler_Pre_Pinned_NA: + break; + } +} + +static void RtemsTaskReqSetScheduler_Pre_TaskState_Prepare( + RtemsTaskReqSetScheduler_Context *ctx, + RtemsTaskReqSetScheduler_Pre_TaskState state +) +{ + switch ( state ) { + case RtemsTaskReqSetScheduler_Pre_TaskState_Ready: { + /* + * While the task specified by the ``task_id`` parameter is ready. + */ + ctx->blocked = false; + ctx->enqueued = false; + break; + } + + case RtemsTaskReqSetScheduler_Pre_TaskState_Blocked: { + /* + * While the task specified by the ``task_id`` parameter is blocked, + * while the task specified by the ``task_id`` parameter is not enqueued + * on a wait queue. + */ + ctx->blocked = true; + ctx->enqueued = false; + break; + } + + case RtemsTaskReqSetScheduler_Pre_TaskState_Enqueued: { + /* + * While the task specified by the ``task_id`` parameter is blocked, + * while the task specified by the ``task_id`` parameter is enqueued on a + * wait queue. + */ + ctx->blocked = true; + ctx->enqueued = true; + break; + } + + case RtemsTaskReqSetScheduler_Pre_TaskState_NA: + break; + } +} + +static void RtemsTaskReqSetScheduler_Pre_AffinitySupported_Prepare( + RtemsTaskReqSetScheduler_Context *ctx, + RtemsTaskReqSetScheduler_Pre_AffinitySupported state +) +{ + switch ( state ) { + case RtemsTaskReqSetScheduler_Pre_AffinitySupported_Yes: { + /* + * While the affinity set of the task specified by the ``task_id`` + * parameter is supported by the scheduler specified by the + * ``scheduler_id`` parameter. + */ + ctx->affinity_supported = true; + break; + } + + case RtemsTaskReqSetScheduler_Pre_AffinitySupported_No: { + /* + * While the affinity set of the task specified by the ``task_id`` + * parameter is not supported by the scheduler specified by the + * ``scheduler_id`` parameter. + */ + ctx->affinity_supported = false; + break; + } + + case RtemsTaskReqSetScheduler_Pre_AffinitySupported_NA: + break; + } +} + +static void RtemsTaskReqSetScheduler_Post_Status_Check( + RtemsTaskReqSetScheduler_Context *ctx, + RtemsTaskReqSetScheduler_Post_Status state +) +{ + switch ( state ) { + case RtemsTaskReqSetScheduler_Post_Status_Ok: { + /* + * The return status of rtems_task_set_scheduler() shall be + * RTEMS_SUCCESSFUL. + */ + T_rsc_success( ctx->status ); + break; + } + + case RtemsTaskReqSetScheduler_Post_Status_InvAddr: { + /* + * The return status of rtems_task_set_scheduler() shall be + * RTEMS_INVALID_ADDRESS. + */ + T_rsc( ctx->status, RTEMS_INVALID_ADDRESS ); + break; + } + + case RtemsTaskReqSetScheduler_Post_Status_InvId: { + /* + * The return status of rtems_task_set_scheduler() shall be + * RTEMS_INVALID_ID. + */ + T_rsc( ctx->status, RTEMS_INVALID_ID ); + break; + } + + case RtemsTaskReqSetScheduler_Post_Status_InvPrio: { + /* + * The return status of rtems_task_set_scheduler() shall be + * RTEMS_INVALID_PRIORITY. + */ + T_rsc( ctx->status, RTEMS_INVALID_PRIORITY ); + break; + } + + case RtemsTaskReqSetScheduler_Post_Status_InUse: { + /* + * The return status of rtems_task_set_scheduler() shall be + * RTEMS_RESOURCE_IN_USE. + */ + T_rsc( ctx->status, RTEMS_RESOURCE_IN_USE ); + break; + } + + case RtemsTaskReqSetScheduler_Post_Status_Unsat: { + /* + * The return status of rtems_task_set_scheduler() shall be + * RTEMS_UNSATISFIED. + */ + T_rsc( ctx->status, RTEMS_UNSATISFIED ); + break; + } + + case RtemsTaskReqSetScheduler_Post_Status_NA: + break; + } +} + +static void RtemsTaskReqSetScheduler_Post_Scheduler_Check( + RtemsTaskReqSetScheduler_Context *ctx, + RtemsTaskReqSetScheduler_Post_Scheduler state +) +{ + switch ( state ) { + case RtemsTaskReqSetScheduler_Post_Scheduler_Set: { + /* + * The home scheduler of the task specified by the ``task_id`` parameter + * shall be set to the scheduler specified by the ``scheduler_id`` + * parameter at some point during the rtems_task_set_scheduler() call. + */ + T_eq_u32( ctx->new_scheduler, ctx->scheduler_to_set_id ); + break; + } + + case RtemsTaskReqSetScheduler_Post_Scheduler_Nop: { + /* + * No home scheduler of a task shall be modified by the + * rtems_task_set_scheduler() call. + */ + T_eq_u32( ctx->new_scheduler, ctx->scheduler_a_id ); + break; + } + + case RtemsTaskReqSetScheduler_Post_Scheduler_NA: + break; + } +} + +static void RtemsTaskReqSetScheduler_Post_Priority_Check( + RtemsTaskReqSetScheduler_Context *ctx, + RtemsTaskReqSetScheduler_Post_Priority state +) +{ + switch ( state ) { + case RtemsTaskReqSetScheduler_Post_Priority_Set: { + /* + * The real priority of the task specified by the ``task_id`` parameter + * shall be set to the priority specified by the ``priority`` parameter + * at some point during the rtems_task_set_scheduler() call. + */ + if ( ctx->scheduler_to_set_id == ctx->scheduler_a_id ) { + T_eq_u32( ctx->new_priority[ 0 ], PRIO_VERY_LOW ); + T_eq_u32( ctx->new_priority[ 1 ], PRIO_INVALID ); + } else { + T_eq_u32( ctx->new_priority[ 0 ], PRIO_INVALID ); + T_eq_u32( ctx->new_priority[ 1 ], PRIO_VERY_LOW ); + } + break; + } + + case RtemsTaskReqSetScheduler_Post_Priority_Nop: { + /* + * No task priority shall be modified by the rtems_task_set_scheduler() + * call. + */ + if ( ctx->blocked ) { + T_eq_u32( ctx->new_priority[ 0 ], PRIO_HIGH ); + } else { + T_eq_u32( ctx->new_priority[ 0 ], PRIO_LOW ); + } + + T_eq_u32( ctx->new_priority[ 1 ], PRIO_INVALID ); + break; + } + + case RtemsTaskReqSetScheduler_Post_Priority_NA: + break; + } +} + +static void RtemsTaskReqSetScheduler_Setup( + RtemsTaskReqSetScheduler_Context *ctx +) +{ + rtems_status_code sc; + size_t i; + + memset( ctx, 0, sizeof( *ctx ) ); + ctx->runner_id = rtems_task_self(); + SetSelfPriority( PRIO_NORMAL ); + + sc = rtems_scheduler_ident( + TEST_SCHEDULER_A_NAME, + &ctx->scheduler_a_id + ); + T_rsc_success( sc ); + + for ( i = 0; i < RTEMS_ARRAY_SIZE( ctx->mutex_id ); ++i ) { + ctx->mutex_id[ i ] = CreateMutex(); + } + + for ( i = 0; i < RTEMS_ARRAY_SIZE( ctx->worker_id ); ++i ) { + ctx->worker_id[ i ] = CreateTask( "WORK", PRIO_HIGH - i ); + StartTask( ctx->worker_id[ i ], Worker, ctx ); + } + + #if defined(RTEMS_SMP) + sc = rtems_scheduler_ident( TEST_SCHEDULER_B_NAME, &ctx->scheduler_b_id ); + T_rsc_success( sc ); + + sc = rtems_scheduler_ident( TEST_SCHEDULER_D_NAME, &ctx->scheduler_d_id ); + T_rsc_success( sc ); + + SetScheduler( ctx->worker_id[ 2 ], ctx->scheduler_b_id, PRIO_NORMAL ); + #else + ctx->scheduler_b_id = INVALID_ID; + #endif +} + +static void RtemsTaskReqSetScheduler_Setup_Wrap( void *arg ) +{ + RtemsTaskReqSetScheduler_Context *ctx; + + ctx = arg; + ctx->Map.in_action_loop = false; + RtemsTaskReqSetScheduler_Setup( ctx ); +} + +static void RtemsTaskReqSetScheduler_Teardown( + RtemsTaskReqSetScheduler_Context *ctx +) +{ + size_t i; + + for ( i = 0; i < RTEMS_ARRAY_SIZE( ctx->worker_id ); ++i ) { + DeleteTask( ctx->worker_id[ i ] ); + } + + for ( i = 0; i < RTEMS_ARRAY_SIZE( ctx->mutex_id ); ++i ) { + DeleteMutex( ctx->mutex_id[ i ] ); + } + + RestoreRunnerPriority(); +} + +static void RtemsTaskReqSetScheduler_Teardown_Wrap( void *arg ) +{ + RtemsTaskReqSetScheduler_Context *ctx; + + ctx = arg; + ctx->Map.in_action_loop = false; + RtemsTaskReqSetScheduler_Teardown( ctx ); +} + +static void RtemsTaskReqSetScheduler_Action( + RtemsTaskReqSetScheduler_Context *ctx +) +{ + rtems_status_code sc; + + if ( ctx->additional_home_priority || ctx->second_eligible_scheduler ) { + SendEvents( ctx->worker_id[ 0 ], EVENT_OBTAIN_MUTEX_A ); + + if ( ctx->additional_home_priority ) { + SendEvents( ctx->worker_id[ 1 ], EVENT_OBTAIN_MUTEX_A ); + } + + if ( ctx->second_eligible_scheduler ) { + SendEvents( + ctx->worker_id[ 2 ], + EVENT_RUNNER_SYNC_0 | EVENT_OBTAIN_MUTEX_A + ); + ReceiveAllEvents( EVENT_RUNNER_SYNC_0 ); + WaitForExecutionStop( ctx->worker_id[ 2 ] ); + } + } + + if ( ctx->blocked && ctx->enqueued ) { + ObtainMutex( ctx->mutex_id[ 1 ] ); + SendEvents( ctx->worker_id[ 0 ], EVENT_OBTAIN_MUTEX_B ); + } + + if ( !ctx->affinity_supported ) { + SetAffinityOne( ctx->worker_id[ 0 ], 0 ); + } + + if ( ctx->pinned ) { + SendEvents( ctx->worker_id[ 0 ], EVENT_PIN ); + } + + if ( !ctx->blocked ) { + SendEvents( ctx->worker_id[ 0 ], EVENT_SET_LOW_PRIO ); + } + + ctx->status = rtems_task_set_scheduler( + ctx->task_id, + ctx->scheduler_id, + ctx->priority + ); + + ctx->new_scheduler = GetScheduler( ctx->worker_id[ 0 ] ); + + if ( ctx->pinned ) { + SendEvents( ctx->worker_id[ 0 ], EVENT_UNPIN ); + } + + if ( !ctx->affinity_supported ) { + SetAffinityAll( ctx->worker_id[ 0 ] ); + } + + if ( ctx->blocked && ctx->enqueued ) { + ReleaseMutex( ctx->mutex_id[ 1 ] ); + SendEvents( ctx->worker_id[ 0 ], EVENT_RELEASE_MUTEX_B ); + } + + if ( ctx->additional_home_priority || ctx->second_eligible_scheduler ) { + SendEvents( ctx->worker_id[ 0 ], EVENT_RELEASE_MUTEX_A ); + + if ( ctx->additional_home_priority ) { + SendEvents( ctx->worker_id[ 1 ], EVENT_RELEASE_MUTEX_A ); + } + + if ( ctx->second_eligible_scheduler ) { + SendEvents( + ctx->worker_id[ 2 ], + EVENT_RELEASE_MUTEX_A | EVENT_RUNNER_SYNC_1 + ); + ReceiveAllEvents( EVENT_RUNNER_SYNC_1 ); + } + } + + sc = rtems_task_get_priority( + ctx->worker_id[ 0 ], + ctx->scheduler_a_id, + &ctx->new_priority[ 0 ] + ); + + if ( sc == RTEMS_NOT_DEFINED ) { + ctx->new_priority[ 0 ] = PRIO_INVALID; + } else { + T_rsc_success( sc ); + } + + #if defined(RTEMS_SMP) + sc = rtems_task_get_priority( + ctx->worker_id[ 0 ], + ctx->scheduler_b_id, + &ctx->new_priority[ 1 ] + ); + + if ( sc == RTEMS_NOT_DEFINED ) { + ctx->new_priority[ 1 ] = PRIO_INVALID; + } else { + T_rsc_success( sc ); + } + #else + ctx->new_priority[ 1 ] = PRIO_INVALID; + #endif + + if ( ctx->status == RTEMS_SUCCESSFUL ) { + SetScheduler( ctx->worker_id[ 0 ], ctx->scheduler_a_id, PRIO_HIGH ); + } else if ( !ctx->blocked ) { + SetPriority( ctx->worker_id[ 0 ], PRIO_HIGH ); + } +} + +static const RtemsTaskReqSetScheduler_Entry +RtemsTaskReqSetScheduler_Entries[] = { +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqSetScheduler_Post_Status_NA, + RtemsTaskReqSetScheduler_Post_Scheduler_NA, + RtemsTaskReqSetScheduler_Post_Priority_NA }, +#else + { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqSetScheduler_Post_Status_NA, + RtemsTaskReqSetScheduler_Post_Scheduler_NA, + RtemsTaskReqSetScheduler_Post_Priority_NA }, +#endif +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqSetScheduler_Post_Status_NA, + RtemsTaskReqSetScheduler_Post_Scheduler_NA, + RtemsTaskReqSetScheduler_Post_Priority_NA }, +#else + { 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, + RtemsTaskReqSetScheduler_Post_Status_InvId, + RtemsTaskReqSetScheduler_Post_Scheduler_Nop, + RtemsTaskReqSetScheduler_Post_Priority_Nop }, +#endif +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqSetScheduler_Post_Status_NA, + RtemsTaskReqSetScheduler_Post_Scheduler_NA, + RtemsTaskReqSetScheduler_Post_Priority_NA }, +#else + { 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, + RtemsTaskReqSetScheduler_Post_Status_InvId, + RtemsTaskReqSetScheduler_Post_Scheduler_Nop, + RtemsTaskReqSetScheduler_Post_Priority_Nop }, +#endif + { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqSetScheduler_Post_Status_NA, + RtemsTaskReqSetScheduler_Post_Scheduler_NA, + RtemsTaskReqSetScheduler_Post_Priority_NA }, +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqSetScheduler_Post_Status_NA, + RtemsTaskReqSetScheduler_Post_Scheduler_NA, + RtemsTaskReqSetScheduler_Post_Priority_NA }, +#else + { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + RtemsTaskReqSetScheduler_Post_Status_InvPrio, + RtemsTaskReqSetScheduler_Post_Scheduler_Nop, + RtemsTaskReqSetScheduler_Post_Priority_Nop }, +#endif +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqSetScheduler_Post_Status_NA, + RtemsTaskReqSetScheduler_Post_Scheduler_NA, + RtemsTaskReqSetScheduler_Post_Priority_NA }, +#else + { 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, + RtemsTaskReqSetScheduler_Post_Status_InvId, + RtemsTaskReqSetScheduler_Post_Scheduler_Nop, + RtemsTaskReqSetScheduler_Post_Priority_Nop }, +#endif +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqSetScheduler_Post_Status_NA, + RtemsTaskReqSetScheduler_Post_Scheduler_NA, + RtemsTaskReqSetScheduler_Post_Priority_NA }, +#else + { 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, + RtemsTaskReqSetScheduler_Post_Status_InvPrio, + RtemsTaskReqSetScheduler_Post_Scheduler_Nop, + RtemsTaskReqSetScheduler_Post_Priority_Nop }, +#endif +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqSetScheduler_Post_Status_NA, + RtemsTaskReqSetScheduler_Post_Scheduler_NA, + RtemsTaskReqSetScheduler_Post_Priority_NA }, +#else + { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + RtemsTaskReqSetScheduler_Post_Status_InUse, + RtemsTaskReqSetScheduler_Post_Scheduler_Nop, + RtemsTaskReqSetScheduler_Post_Priority_Nop }, +#endif + { 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, + RtemsTaskReqSetScheduler_Post_Status_InvId, + RtemsTaskReqSetScheduler_Post_Scheduler_Nop, + RtemsTaskReqSetScheduler_Post_Priority_Nop }, + { 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, + RtemsTaskReqSetScheduler_Post_Status_InvId, + RtemsTaskReqSetScheduler_Post_Scheduler_Nop, + RtemsTaskReqSetScheduler_Post_Priority_Nop }, + { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + RtemsTaskReqSetScheduler_Post_Status_InvPrio, + RtemsTaskReqSetScheduler_Post_Scheduler_Nop, + RtemsTaskReqSetScheduler_Post_Priority_Nop }, +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqSetScheduler_Post_Status_NA, + RtemsTaskReqSetScheduler_Post_Scheduler_NA, + RtemsTaskReqSetScheduler_Post_Priority_NA }, +#else + { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + RtemsTaskReqSetScheduler_Post_Status_Unsat, + RtemsTaskReqSetScheduler_Post_Scheduler_Nop, + RtemsTaskReqSetScheduler_Post_Priority_Nop }, +#endif + { 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, + RtemsTaskReqSetScheduler_Post_Status_InvId, + RtemsTaskReqSetScheduler_Post_Scheduler_Nop, + RtemsTaskReqSetScheduler_Post_Priority_Nop }, + { 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, + RtemsTaskReqSetScheduler_Post_Status_InvPrio, + RtemsTaskReqSetScheduler_Post_Scheduler_Nop, + RtemsTaskReqSetScheduler_Post_Priority_Nop }, + { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + RtemsTaskReqSetScheduler_Post_Status_InUse, + RtemsTaskReqSetScheduler_Post_Scheduler_Nop, + RtemsTaskReqSetScheduler_Post_Priority_Nop }, + { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqSetScheduler_Post_Status_Ok, + RtemsTaskReqSetScheduler_Post_Scheduler_Set, + RtemsTaskReqSetScheduler_Post_Priority_Set }, +#if !defined(RTEMS_SMP) + { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqSetScheduler_Post_Status_NA, + RtemsTaskReqSetScheduler_Post_Scheduler_NA, + RtemsTaskReqSetScheduler_Post_Priority_NA } +#else + { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqSetScheduler_Post_Status_Ok, + RtemsTaskReqSetScheduler_Post_Scheduler_Set, + RtemsTaskReqSetScheduler_Post_Priority_Set } +#endif +}; + +static const uint8_t +RtemsTaskReqSetScheduler_Map[] = { + 7, 0, 7, 0, 7, 0, 15, 3, 15, 3, 14, 3, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 7, + 0, 7, 0, 7, 0, 14, 3, 14, 3, 14, 3, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 4, 0, + 4, 0, 4, 0, 10, 3, 10, 3, 10, 3, 4, 0, 4, 0, 4, 0, 4, 0, 4, 0, 4, 0, 4, 0, 4, + 0, 4, 0, 10, 3, 10, 3, 10, 3, 4, 0, 4, 0, 4, 0, 4, 0, 4, 0, 4, 0, 1, 0, 1, 0, + 1, 0, 8, 3, 8, 3, 8, 3, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, + 8, 3, 8, 3, 8, 3, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 8, 3, + 8, 3, 8, 3, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 8, 3, 8, 3, + 8, 3, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 7, + 7, 7, 7, 7, 16, 11, 16, 11, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 7, 7, 7, 7, 7, 7, 11, 11, 11, 11, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 0, 5, 0, + 5, 0, 12, 3, 12, 3, 12, 3, 5, 0, 5, 0, 5, 0, 5, 0, 5, 0, 5, 0, 5, 0, 5, 0, 5, + 0, 12, 3, 12, 3, 12, 3, 5, 0, 5, 0, 5, 0, 5, 0, 5, 0, 5, 0, 6, 0, 6, 0, 6, 0, + 13, 3, 13, 3, 13, 3, 6, 0, 6, 0, 6, 0, 6, 0, 6, 0, 6, 0, 6, 0, 6, 0, 6, 0, + 13, 3, 13, 3, 13, 3, 6, 0, 6, 0, 6, 0, 6, 0, 6, 0, 6, 0, 2, 0, 2, 0, 2, 0, 9, + 3, 9, 3, 9, 3, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 9, 3, 9, + 3, 9, 3, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 9, 3, 9, 3, 9, + 3, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 9, 3, 9, 3, 9, 3, 2, + 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 +}; + +static size_t RtemsTaskReqSetScheduler_Scope( void *arg, char *buf, size_t n ) +{ + RtemsTaskReqSetScheduler_Context *ctx; + + ctx = arg; + + if ( ctx->Map.in_action_loop ) { + return T_get_scope( + RtemsTaskReqSetScheduler_PreDesc, + buf, + n, + ctx->Map.pcs + ); + } + + return 0; +} + +static T_fixture RtemsTaskReqSetScheduler_Fixture = { + .setup = RtemsTaskReqSetScheduler_Setup_Wrap, + .stop = NULL, + .teardown = RtemsTaskReqSetScheduler_Teardown_Wrap, + .scope = RtemsTaskReqSetScheduler_Scope, + .initial_context = &RtemsTaskReqSetScheduler_Instance +}; + +static inline RtemsTaskReqSetScheduler_Entry RtemsTaskReqSetScheduler_PopEntry( + RtemsTaskReqSetScheduler_Context *ctx +) +{ + size_t index; + + index = ctx->Map.index; + ctx->Map.index = index + 1; + return RtemsTaskReqSetScheduler_Entries[ + RtemsTaskReqSetScheduler_Map[ index ] + ]; +} + +static void RtemsTaskReqSetScheduler_SetPreConditionStates( + RtemsTaskReqSetScheduler_Context *ctx +) +{ + ctx->Map.pcs[ 0 ] = ctx->Map.pci[ 0 ]; + + if ( ctx->Map.entry.Pre_Scheduler_NA ) { + ctx->Map.pcs[ 1 ] = RtemsTaskReqSetScheduler_Pre_Scheduler_NA; + } else { + ctx->Map.pcs[ 1 ] = ctx->Map.pci[ 1 ]; + } + + if ( ctx->Map.entry.Pre_SchedulerHasCPU_NA ) { + ctx->Map.pcs[ 2 ] = RtemsTaskReqSetScheduler_Pre_SchedulerHasCPU_NA; + } else { + ctx->Map.pcs[ 2 ] = ctx->Map.pci[ 2 ]; + } + + ctx->Map.pcs[ 3 ] = ctx->Map.pci[ 3 ]; + + if ( ctx->Map.entry.Pre_Priority_NA ) { + ctx->Map.pcs[ 4 ] = RtemsTaskReqSetScheduler_Pre_Priority_NA; + } else { + ctx->Map.pcs[ 4 ] = ctx->Map.pci[ 4 ]; + } + + if ( ctx->Map.entry.Pre_HomePriority_NA ) { + ctx->Map.pcs[ 5 ] = RtemsTaskReqSetScheduler_Pre_HomePriority_NA; + } else { + ctx->Map.pcs[ 5 ] = ctx->Map.pci[ 5 ]; + } + + if ( ctx->Map.entry.Pre_EligiblePriorities_NA ) { + ctx->Map.pcs[ 6 ] = RtemsTaskReqSetScheduler_Pre_EligiblePriorities_NA; + } else { + ctx->Map.pcs[ 6 ] = ctx->Map.pci[ 6 ]; + } + + if ( ctx->Map.entry.Pre_Pinned_NA ) { + ctx->Map.pcs[ 7 ] = RtemsTaskReqSetScheduler_Pre_Pinned_NA; + } else { + ctx->Map.pcs[ 7 ] = ctx->Map.pci[ 7 ]; + } + + if ( ctx->Map.entry.Pre_TaskState_NA ) { + ctx->Map.pcs[ 8 ] = RtemsTaskReqSetScheduler_Pre_TaskState_NA; + } else { + ctx->Map.pcs[ 8 ] = ctx->Map.pci[ 8 ]; + } + + if ( ctx->Map.entry.Pre_AffinitySupported_NA ) { + ctx->Map.pcs[ 9 ] = RtemsTaskReqSetScheduler_Pre_AffinitySupported_NA; + } else { + ctx->Map.pcs[ 9 ] = ctx->Map.pci[ 9 ]; + } +} + +static void RtemsTaskReqSetScheduler_TestVariant( + RtemsTaskReqSetScheduler_Context *ctx +) +{ + RtemsTaskReqSetScheduler_Pre_TaskId_Prepare( ctx, ctx->Map.pcs[ 0 ] ); + RtemsTaskReqSetScheduler_Pre_Scheduler_Prepare( ctx, ctx->Map.pcs[ 1 ] ); + RtemsTaskReqSetScheduler_Pre_SchedulerHasCPU_Prepare( + ctx, + ctx->Map.pcs[ 2 ] + ); + RtemsTaskReqSetScheduler_Pre_SchedulerId_Prepare( ctx, ctx->Map.pcs[ 3 ] ); + RtemsTaskReqSetScheduler_Pre_Priority_Prepare( ctx, ctx->Map.pcs[ 4 ] ); + RtemsTaskReqSetScheduler_Pre_HomePriority_Prepare( ctx, ctx->Map.pcs[ 5 ] ); + RtemsTaskReqSetScheduler_Pre_EligiblePriorities_Prepare( + ctx, + ctx->Map.pcs[ 6 ] + ); + RtemsTaskReqSetScheduler_Pre_Pinned_Prepare( ctx, ctx->Map.pcs[ 7 ] ); + RtemsTaskReqSetScheduler_Pre_TaskState_Prepare( ctx, ctx->Map.pcs[ 8 ] ); + RtemsTaskReqSetScheduler_Pre_AffinitySupported_Prepare( + ctx, + ctx->Map.pcs[ 9 ] + ); + RtemsTaskReqSetScheduler_Action( ctx ); + RtemsTaskReqSetScheduler_Post_Status_Check( + ctx, + ctx->Map.entry.Post_Status + ); + RtemsTaskReqSetScheduler_Post_Scheduler_Check( + ctx, + ctx->Map.entry.Post_Scheduler + ); + RtemsTaskReqSetScheduler_Post_Priority_Check( + ctx, + ctx->Map.entry.Post_Priority + ); +} + +/** + * @fn void T_case_body_RtemsTaskReqSetScheduler( void ) + */ +T_TEST_CASE_FIXTURE( + RtemsTaskReqSetScheduler, + &RtemsTaskReqSetScheduler_Fixture +) +{ + RtemsTaskReqSetScheduler_Context *ctx; + + ctx = T_fixture_context(); + ctx->Map.in_action_loop = true; + ctx->Map.index = 0; + + for ( + ctx->Map.pci[ 0 ] = RtemsTaskReqSetScheduler_Pre_TaskId_Task; + ctx->Map.pci[ 0 ] < RtemsTaskReqSetScheduler_Pre_TaskId_NA; + ++ctx->Map.pci[ 0 ] + ) { + for ( + ctx->Map.pci[ 1 ] = RtemsTaskReqSetScheduler_Pre_Scheduler_Home; + ctx->Map.pci[ 1 ] < RtemsTaskReqSetScheduler_Pre_Scheduler_NA; + ++ctx->Map.pci[ 1 ] + ) { + for ( + ctx->Map.pci[ 2 ] = RtemsTaskReqSetScheduler_Pre_SchedulerHasCPU_Yes; + ctx->Map.pci[ 2 ] < RtemsTaskReqSetScheduler_Pre_SchedulerHasCPU_NA; + ++ctx->Map.pci[ 2 ] + ) { + for ( + ctx->Map.pci[ 3 ] = RtemsTaskReqSetScheduler_Pre_SchedulerId_Scheduler; + ctx->Map.pci[ 3 ] < RtemsTaskReqSetScheduler_Pre_SchedulerId_NA; + ++ctx->Map.pci[ 3 ] + ) { + for ( + ctx->Map.pci[ 4 ] = RtemsTaskReqSetScheduler_Pre_Priority_Valid; + ctx->Map.pci[ 4 ] < RtemsTaskReqSetScheduler_Pre_Priority_NA; + ++ctx->Map.pci[ 4 ] + ) { + for ( + ctx->Map.pci[ 5 ] = RtemsTaskReqSetScheduler_Pre_HomePriority_Real; + ctx->Map.pci[ 5 ] < RtemsTaskReqSetScheduler_Pre_HomePriority_NA; + ++ctx->Map.pci[ 5 ] + ) { + for ( + ctx->Map.pci[ 6 ] = RtemsTaskReqSetScheduler_Pre_EligiblePriorities_OnlyOne; + ctx->Map.pci[ 6 ] < RtemsTaskReqSetScheduler_Pre_EligiblePriorities_NA; + ++ctx->Map.pci[ 6 ] + ) { + for ( + ctx->Map.pci[ 7 ] = RtemsTaskReqSetScheduler_Pre_Pinned_Yes; + ctx->Map.pci[ 7 ] < RtemsTaskReqSetScheduler_Pre_Pinned_NA; + ++ctx->Map.pci[ 7 ] + ) { + for ( + ctx->Map.pci[ 8 ] = RtemsTaskReqSetScheduler_Pre_TaskState_Ready; + ctx->Map.pci[ 8 ] < RtemsTaskReqSetScheduler_Pre_TaskState_NA; + ++ctx->Map.pci[ 8 ] + ) { + for ( + ctx->Map.pci[ 9 ] = RtemsTaskReqSetScheduler_Pre_AffinitySupported_Yes; + ctx->Map.pci[ 9 ] < RtemsTaskReqSetScheduler_Pre_AffinitySupported_NA; + ++ctx->Map.pci[ 9 ] + ) { + ctx->Map.entry = RtemsTaskReqSetScheduler_PopEntry( + ctx + ); + + if ( ctx->Map.entry.Skip ) { + continue; + } + + RtemsTaskReqSetScheduler_SetPreConditionStates( ctx ); + RtemsTaskReqSetScheduler_TestVariant( ctx ); + } + } + } + } + } + } + } + } + } + } +} + +/** @} */ |