Imagelibrary/rtems
1
0
Fork 1
mirror of https://gitlab.rtems.org/rtems/rtos/rtems.git synced 2025-12-26 06:08:20 +00:00
Code Issues Packages Projects Releases Wiki Activity

validation: Test Timer Manager

Browse Source 
The test source code is generated from specification items
by the "./spec2modules.py" script contained in the
git://git.rtems.org/rtems-central.git Git repository.

Please read the "How-To" section in the "Software Requirements Engineering"
chapter of the RTEMS Software Engineering manual to get more information about
the process.

Update #3716.
This commit is contained in:
Frank Kühndel
2021-12-09 16:17:07 +01:00
committed by Sebastian Huber
parent 6b29390484
commit 565a7e6654
12 changed files with 9084 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
spec/build/testsuites/validation/validation-no-clock-0.yml
View File

@@ -93,6 +93,17 @@ source:
- testsuites/validation/tc-task-suspend.c
- testsuites/validation/tc-task-wake-after.c
- testsuites/validation/tc-task-wake-when.c
- testsuites/validation/tc-timer.c
- testsuites/validation/tc-timer-cancel.c
- testsuites/validation/tc-timer-create.c
- testsuites/validation/tc-timer-delete.c
- testsuites/validation/tc-timer-fire-after.c
- testsuites/validation/tc-timer-fire-when.c
- testsuites/validation/tc-timer-ident.c
- testsuites/validation/tc-timer-initiate-server.c
- testsuites/validation/tc-timer-reset.c
- testsuites/validation/tc-timer-server-fire-after.c
- testsuites/validation/tc-timer-server-fire-when.c
- testsuites/validation/tr-event-constant.c
- testsuites/validation/tr-mtx-seize-try.c
- testsuites/validation/tr-mtx-seize-wait.c

813
testsuites/validation/tc-timer-cancel.c Normal file
View File

@@ -0,0 +1,813 @@
/* SPDX-License-Identifier: BSD-2-Clause */
/**
* @file
*
* @ingroup RTEMSTestCaseRtemsTimerReqCancel
*/
/*
* 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 "tx-support.h"
#include <rtems/test.h>
/**
* @defgroup RTEMSTestCaseRtemsTimerReqCancel spec:/rtems/timer/req/cancel
*
* @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0
*
* @{
*/
typedef enum {
RtemsTimerReqCancel_Pre_Id_Valid,
RtemsTimerReqCancel_Pre_Id_Invalid,
RtemsTimerReqCancel_Pre_Id_NA
} RtemsTimerReqCancel_Pre_Id;
typedef enum {
RtemsTimerReqCancel_Pre_Context_None,
RtemsTimerReqCancel_Pre_Context_Interrupt,
RtemsTimerReqCancel_Pre_Context_Server,
RtemsTimerReqCancel_Pre_Context_NA
} RtemsTimerReqCancel_Pre_Context;
typedef enum {
RtemsTimerReqCancel_Pre_Clock_None,
RtemsTimerReqCancel_Pre_Clock_Ticks,
RtemsTimerReqCancel_Pre_Clock_Realtime,
RtemsTimerReqCancel_Pre_Clock_NA
} RtemsTimerReqCancel_Pre_Clock;
typedef enum {
RtemsTimerReqCancel_Pre_State_Inactive,
RtemsTimerReqCancel_Pre_State_Scheduled,
RtemsTimerReqCancel_Pre_State_Pending,
RtemsTimerReqCancel_Pre_State_NA
} RtemsTimerReqCancel_Pre_State;
typedef enum {
RtemsTimerReqCancel_Post_Status_Ok,
RtemsTimerReqCancel_Post_Status_InvId,
RtemsTimerReqCancel_Post_Status_NA
} RtemsTimerReqCancel_Post_Status;
typedef enum {
RtemsTimerReqCancel_Post_Context_None,
RtemsTimerReqCancel_Post_Context_Interrupt,
RtemsTimerReqCancel_Post_Context_Server,
RtemsTimerReqCancel_Post_Context_Nop,
RtemsTimerReqCancel_Post_Context_NA
} RtemsTimerReqCancel_Post_Context;
typedef enum {
RtemsTimerReqCancel_Post_Clock_None,
RtemsTimerReqCancel_Post_Clock_Ticks,
RtemsTimerReqCancel_Post_Clock_Realtime,
RtemsTimerReqCancel_Post_Clock_Nop,
RtemsTimerReqCancel_Post_Clock_NA
} RtemsTimerReqCancel_Post_Clock;
typedef enum {
RtemsTimerReqCancel_Post_State_Inactive,
RtemsTimerReqCancel_Post_State_Nop,
RtemsTimerReqCancel_Post_State_NA
} RtemsTimerReqCancel_Post_State;
typedef struct {
uint16_t Skip : 1;
uint16_t Pre_Id_NA : 1;
uint16_t Pre_Context_NA : 1;
uint16_t Pre_Clock_NA : 1;
uint16_t Pre_State_NA : 1;
uint16_t Post_Status : 2;
uint16_t Post_Context : 3;
uint16_t Post_Clock : 3;
uint16_t Post_State : 2;
} RtemsTimerReqCancel_Entry;
typedef enum {
PRE_NONE = 0,
PRE_INTERRUPT = 1,
PRE_SERVER = 2
} PreConditionContext;
/**
* @brief Test context for spec:/rtems/timer/req/cancel test case.
*/
typedef struct {
/**
* @brief This member contains a valid id of a timer.
*/
rtems_id timer_id;
/**
* @brief This member specifies the ``id`` parameter for the action.
*/
rtems_id id_param;
/**
* @brief This member contains the return status of the action.
*/
rtems_status_code status;
/**
* @brief This member contains the counter for invocations of the Timer
* Service Routine.
*/
int invocations;
/**
* @brief This member specifies which pre-condition context (none, interrupt
* context, server context) must be created before the cancel action gets
* executed.
*/
PreConditionContext pre_cond_contex;
/**
* @brief This member stores RTEMS internal clock and context settings of the
* timer before the execution of the test action.
*/
Timer_Classes pre_class;
/**
* @brief This member stores the state of the timer before the execution of
* the test action.
*/
Timer_States pre_state;
/**
* @brief This member stores the state of the timer after the execution of
* the test action.
*/
Timer_States post_state;
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.
*/
RtemsTimerReqCancel_Entry entry;
/**
* @brief If this member is true, then the current transition variant
* should be skipped.
*/
bool skip;
} Map;
} RtemsTimerReqCancel_Context;
static RtemsTimerReqCancel_Context
RtemsTimerReqCancel_Instance;
static const char * const RtemsTimerReqCancel_PreDesc_Id[] = {
"Valid",
"Invalid",
"NA"
};
static const char * const RtemsTimerReqCancel_PreDesc_Context[] = {
"None",
"Interrupt",
"Server",
"NA"
};
static const char * const RtemsTimerReqCancel_PreDesc_Clock[] = {
"None",
"Ticks",
"Realtime",
"NA"
};
static const char * const RtemsTimerReqCancel_PreDesc_State[] = {
"Inactive",
"Scheduled",
"Pending",
"NA"
};
static const char * const * const RtemsTimerReqCancel_PreDesc[] = {
RtemsTimerReqCancel_PreDesc_Id,
RtemsTimerReqCancel_PreDesc_Context,
RtemsTimerReqCancel_PreDesc_Clock,
RtemsTimerReqCancel_PreDesc_State,
NULL
};
static const rtems_time_of_day tod_now = { 2000, 1, 1, 0, 0, 0, 0 };
static const rtems_time_of_day tod_schedule = { 2000, 1, 1, 1, 0, 0, 0 };
static const rtems_time_of_day tod_fire = { 2000, 1, 2, 0, 0, 0, 0 };
static void TriggerTimer( void )
{
/* Fire the timer service routine for ticks and realtime clock */
int i;
for ( i = 0; i < 5; i++ ) {
ClockTick();
}
T_rsc_success( rtems_clock_set( &tod_fire ) );
}
static void TimerServiceRoutine(
rtems_id timer_id,
void *user_data
)
{
RtemsTimerReqCancel_Context *ctx = user_data;
++( ctx->invocations );
}
static void RtemsTimerReqCancel_Pre_Id_Prepare(
RtemsTimerReqCancel_Context *ctx,
RtemsTimerReqCancel_Pre_Id state
)
{
switch ( state ) {
case RtemsTimerReqCancel_Pre_Id_Valid: {
/*
* While the ``id`` parameter is valid.
*/
ctx->id_param = ctx->timer_id;
break;
}
case RtemsTimerReqCancel_Pre_Id_Invalid: {
/*
* While the ``id`` parameter is invalid.
*/
ctx->id_param = RTEMS_ID_NONE;
break;
}
case RtemsTimerReqCancel_Pre_Id_NA:
break;
}
}
static void RtemsTimerReqCancel_Pre_Context_Prepare(
RtemsTimerReqCancel_Context *ctx,
RtemsTimerReqCancel_Pre_Context state
)
{
switch ( state ) {
case RtemsTimerReqCancel_Pre_Context_None: {
/*
* While the Timer Service Routine has never been scheduled since
* creation of the timer. See also none.
*/
ctx->pre_cond_contex = PRE_NONE;
break;
}
case RtemsTimerReqCancel_Pre_Context_Interrupt: {
/*
* While the timer is in interrupt context.
*/
ctx->pre_cond_contex = PRE_INTERRUPT;
break;
}
case RtemsTimerReqCancel_Pre_Context_Server: {
/*
* While the timer is in server context.
*/
ctx->pre_cond_contex = PRE_SERVER;
break;
}
case RtemsTimerReqCancel_Pre_Context_NA:
break;
}
}
static void RtemsTimerReqCancel_Pre_Clock_Prepare(
RtemsTimerReqCancel_Context *ctx,
RtemsTimerReqCancel_Pre_Clock state
)
{
switch ( state ) {
case RtemsTimerReqCancel_Pre_Clock_None: {
/*
* While the timer has never been scheduled since creation of the timer.
*/
T_eq_int( ctx->pre_cond_contex, PRE_NONE );
break;
}
case RtemsTimerReqCancel_Pre_Clock_Ticks: {
/*
* While the clock used to determine when the timer will fire is the
* ticks based clock.
*/
rtems_status_code status;
if ( ctx->pre_cond_contex == PRE_INTERRUPT ) {
status = rtems_timer_fire_after(
ctx->timer_id,
1,
TimerServiceRoutine,
ctx
);
} else {
status = rtems_timer_server_fire_after(
ctx->timer_id,
1,
TimerServiceRoutine,
ctx
);
}
T_rsc_success( status );
break;
}
case RtemsTimerReqCancel_Pre_Clock_Realtime: {
/*
* While the clock used to determine when the timer will fire is the
* realtime clock.
*/
rtems_status_code status;
if ( ctx->pre_cond_contex == PRE_INTERRUPT ) {
status = rtems_timer_fire_when(
ctx->timer_id,
&tod_schedule,
TimerServiceRoutine,
ctx
);
} else {
status = rtems_timer_server_fire_when(
ctx->timer_id,
&tod_schedule,
TimerServiceRoutine,
ctx
);
}
T_rsc_success( status );
break;
}
case RtemsTimerReqCancel_Pre_Clock_NA:
break;
}
}
static void RtemsTimerReqCancel_Pre_State_Prepare(
RtemsTimerReqCancel_Context *ctx,
RtemsTimerReqCancel_Pre_State state
)
{
switch ( state ) {
case RtemsTimerReqCancel_Pre_State_Inactive: {
/*
* While the timer is in inactive state.
*/
TriggerTimer();
T_eq_int(
ctx->invocations,
( ctx->pre_cond_contex == PRE_NONE ) ? 0 : 1
);
ctx->invocations = 0;
ctx->pre_state = TIMER_INACTIVE;
break;
}
case RtemsTimerReqCancel_Pre_State_Scheduled: {
/*
* While the timer is in scheduled state.
*/
/* The timer was already scheduled in the "Clock" pre-conditions. */
ctx->pre_state = TIMER_SCHEDULED;
break;
}
case RtemsTimerReqCancel_Pre_State_Pending: {
/*
* While the timer is in pending state.
*/
T_rsc_success( rtems_task_suspend( GetTimerServerTaskId() ) );
TriggerTimer();
T_eq_int( ctx->invocations, 0 );
ctx->pre_state = TIMER_PENDING;
break;
}
case RtemsTimerReqCancel_Pre_State_NA:
break;
}
}
static void RtemsTimerReqCancel_Post_Status_Check(
RtemsTimerReqCancel_Context *ctx,
RtemsTimerReqCancel_Post_Status state
)
{
switch ( state ) {
case RtemsTimerReqCancel_Post_Status_Ok: {
/*
* The return status of rtems_timer_cancel() shall be RTEMS_SUCCESSFUL.
*/
T_rsc_success( ctx->status );
break;
}
case RtemsTimerReqCancel_Post_Status_InvId: {
/*
* The return status of rtems_timer_cancel() shall be RTEMS_INVALID_ID.
*/
T_rsc( ctx->status, RTEMS_INVALID_ID );
break;
}
case RtemsTimerReqCancel_Post_Status_NA:
break;
}
}
static void RtemsTimerReqCancel_Post_Context_Check(
RtemsTimerReqCancel_Context *ctx,
RtemsTimerReqCancel_Post_Context state
)
{
Timer_Classes class;
class = GetTimerClass( ctx->timer_id );
switch ( state ) {
case RtemsTimerReqCancel_Post_Context_None: {
/*
* The timer shall have never been scheduled. See also none.
*/
T_eq_int( class, TIMER_DORMANT );
break;
}
case RtemsTimerReqCancel_Post_Context_Interrupt: {
/*
* The timer shall be in interrupt context.
*/
T_eq_int( class & TIMER_CLASS_BIT_ON_TASK, 0 );
break;
}
case RtemsTimerReqCancel_Post_Context_Server: {
/*
* The timer shall be in server context.
*/
T_eq_int( class & TIMER_CLASS_BIT_ON_TASK, TIMER_CLASS_BIT_ON_TASK );
break;
}
case RtemsTimerReqCancel_Post_Context_Nop: {
/*
* Objects referenced by the ``id`` parameter in past call to
* rtems_timer_cancel() shall not be accessed by the rtems_timer_cancel()
* call. See also Nop.
*/
T_eq_int( class, ctx->pre_class );
break;
}
case RtemsTimerReqCancel_Post_Context_NA:
break;
}
}
static void RtemsTimerReqCancel_Post_Clock_Check(
RtemsTimerReqCancel_Context *ctx,
RtemsTimerReqCancel_Post_Clock state
)
{
Timer_Classes class;
class = GetTimerClass( ctx->timer_id );
switch ( state ) {
case RtemsTimerReqCancel_Post_Clock_None: {
/*
* The timer shall have never been scheduled.
*/
T_eq_int( class, TIMER_DORMANT );
break;
}
case RtemsTimerReqCancel_Post_Clock_Ticks: {
/*
* The timer shall use the ticks based clock.
*/
T_eq_int( class & TIMER_CLASS_BIT_TIME_OF_DAY, 0 );
break;
}
case RtemsTimerReqCancel_Post_Clock_Realtime: {
/*
* The timer shall use the realtime clock.
*/
T_eq_int(
class & TIMER_CLASS_BIT_TIME_OF_DAY,
TIMER_CLASS_BIT_TIME_OF_DAY
);
break;
}
case RtemsTimerReqCancel_Post_Clock_Nop: {
/*
* Objects referenced by the ``id`` parameter in past call to
* rtems_timer_cancel() shall not be accessed by the rtems_timer_cancel()
* call.
*/
T_eq_int( class, ctx->pre_class );
break;
}
case RtemsTimerReqCancel_Post_Clock_NA:
break;
}
}
static void RtemsTimerReqCancel_Post_State_Check(
RtemsTimerReqCancel_Context *ctx,
RtemsTimerReqCancel_Post_State state
)
{
switch ( state ) {
case RtemsTimerReqCancel_Post_State_Inactive: {
/*
* The timer shall be in inactive state.
*/
/* Try to fire the timer service routine - which should not fire. */
TriggerTimer();
T_eq_int( ctx->invocations, 0 );
break;
}
case RtemsTimerReqCancel_Post_State_Nop: {
/*
* Objects referenced by the ``id`` parameter in past call to
* rtems_timer_cancel() shall not be accessed by the rtems_timer_cancel()
* call.
*/
T_eq_int( ctx->post_state, ctx->pre_state );
break;
}
case RtemsTimerReqCancel_Post_State_NA:
break;
}
}
static void RtemsTimerReqCancel_Setup( RtemsTimerReqCancel_Context *ctx )
{
rtems_status_code status;
status = rtems_timer_initiate_server(
RTEMS_TIMER_SERVER_DEFAULT_PRIORITY,
RTEMS_MINIMUM_STACK_SIZE,
RTEMS_DEFAULT_ATTRIBUTES
);
T_rsc_success( status );
}
static void RtemsTimerReqCancel_Setup_Wrap( void *arg )
{
RtemsTimerReqCancel_Context *ctx;
ctx = arg;
ctx->Map.in_action_loop = false;
RtemsTimerReqCancel_Setup( ctx );
}
/**
* @brief Make sure the timer server is not running and the realtime clock is
* not set after this test.
*/
static void RtemsTimerReqCancel_Teardown( RtemsTimerReqCancel_Context *ctx )
{
DeleteTimerServer();
UnsetClock();
}
static void RtemsTimerReqCancel_Teardown_Wrap( void *arg )
{
RtemsTimerReqCancel_Context *ctx;
ctx = arg;
ctx->Map.in_action_loop = false;
RtemsTimerReqCancel_Teardown( ctx );
}
static void RtemsTimerReqCancel_Prepare( RtemsTimerReqCancel_Context *ctx )
{
rtems_status_code status;
status = rtems_timer_create(
rtems_build_name( 'T', 'I', 'M', 'E' ),
&ctx->timer_id
);
T_rsc_success( status );
ctx->invocations = 0;
T_rsc_success( rtems_clock_set( &tod_now ) );
}
static void RtemsTimerReqCancel_Action( RtemsTimerReqCancel_Context *ctx )
{
ctx->pre_class = GetTimerClass( ctx->timer_id );
ctx->status = rtems_timer_cancel( ctx->id_param );
ctx->post_state = GetTimerState( ctx->timer_id );
/* Ignoring return status: the timer server task may be suspended or not. */
rtems_task_resume( GetTimerServerTaskId() );
}
static void RtemsTimerReqCancel_Cleanup( RtemsTimerReqCancel_Context *ctx )
{
T_rsc_success( rtems_timer_delete( ctx->timer_id ) );
}
static const RtemsTimerReqCancel_Entry
RtemsTimerReqCancel_Entries[] = {
{ 1, 0, 0, 0, 0, RtemsTimerReqCancel_Post_Status_NA,
RtemsTimerReqCancel_Post_Context_NA, RtemsTimerReqCancel_Post_Clock_NA,
RtemsTimerReqCancel_Post_State_NA },
{ 0, 0, 0, 0, 0, RtemsTimerReqCancel_Post_Status_InvId,
RtemsTimerReqCancel_Post_Context_Nop, RtemsTimerReqCancel_Post_Clock_Nop,
RtemsTimerReqCancel_Post_State_Nop },
{ 0, 0, 0, 0, 0, RtemsTimerReqCancel_Post_Status_Ok,
RtemsTimerReqCancel_Post_Context_Server,
RtemsTimerReqCancel_Post_Clock_Ticks,
RtemsTimerReqCancel_Post_State_Inactive },
{ 0, 0, 0, 0, 0, RtemsTimerReqCancel_Post_Status_Ok,
RtemsTimerReqCancel_Post_Context_Server,
RtemsTimerReqCancel_Post_Clock_Realtime,
RtemsTimerReqCancel_Post_State_Inactive },
{ 0, 0, 0, 0, 0, RtemsTimerReqCancel_Post_Status_Ok,
RtemsTimerReqCancel_Post_Context_Interrupt,
RtemsTimerReqCancel_Post_Clock_Ticks,
RtemsTimerReqCancel_Post_State_Inactive },
{ 0, 0, 0, 0, 0, RtemsTimerReqCancel_Post_Status_Ok,
RtemsTimerReqCancel_Post_Context_Interrupt,
RtemsTimerReqCancel_Post_Clock_Realtime,
RtemsTimerReqCancel_Post_State_Inactive },
{ 0, 0, 0, 0, 0, RtemsTimerReqCancel_Post_Status_Ok,
RtemsTimerReqCancel_Post_Context_None, RtemsTimerReqCancel_Post_Clock_None,
RtemsTimerReqCancel_Post_State_Inactive }
};
static const uint8_t
RtemsTimerReqCancel_Map[] = {
6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 5, 5, 0, 0, 0, 0, 2, 2, 2, 3, 3,
3, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1,
1, 1
};
static size_t RtemsTimerReqCancel_Scope( void *arg, char *buf, size_t n )
{
RtemsTimerReqCancel_Context *ctx;
ctx = arg;
if ( ctx->Map.in_action_loop ) {
return T_get_scope( RtemsTimerReqCancel_PreDesc, buf, n, ctx->Map.pcs );
}
return 0;
}
static T_fixture RtemsTimerReqCancel_Fixture = {
.setup = RtemsTimerReqCancel_Setup_Wrap,
.stop = NULL,
.teardown = RtemsTimerReqCancel_Teardown_Wrap,
.scope = RtemsTimerReqCancel_Scope,
.initial_context = &RtemsTimerReqCancel_Instance
};
static inline RtemsTimerReqCancel_Entry RtemsTimerReqCancel_PopEntry(
RtemsTimerReqCancel_Context *ctx
)
{
size_t index;
index = ctx->Map.index;
ctx->Map.index = index + 1;
return RtemsTimerReqCancel_Entries[
RtemsTimerReqCancel_Map[ index ]
];
}
static void RtemsTimerReqCancel_TestVariant( RtemsTimerReqCancel_Context *ctx )
{
RtemsTimerReqCancel_Pre_Id_Prepare( ctx, ctx->Map.pcs[ 0 ] );
RtemsTimerReqCancel_Pre_Context_Prepare( ctx, ctx->Map.pcs[ 1 ] );
RtemsTimerReqCancel_Pre_Clock_Prepare( ctx, ctx->Map.pcs[ 2 ] );
RtemsTimerReqCancel_Pre_State_Prepare( ctx, ctx->Map.pcs[ 3 ] );
RtemsTimerReqCancel_Action( ctx );
RtemsTimerReqCancel_Post_Status_Check( ctx, ctx->Map.entry.Post_Status );
RtemsTimerReqCancel_Post_Context_Check( ctx, ctx->Map.entry.Post_Context );
RtemsTimerReqCancel_Post_Clock_Check( ctx, ctx->Map.entry.Post_Clock );
RtemsTimerReqCancel_Post_State_Check( ctx, ctx->Map.entry.Post_State );
}
/**
* @fn void T_case_body_RtemsTimerReqCancel( void )
*/
T_TEST_CASE_FIXTURE( RtemsTimerReqCancel, &RtemsTimerReqCancel_Fixture )
{
RtemsTimerReqCancel_Context *ctx;
ctx = T_fixture_context();
ctx->Map.in_action_loop = true;
ctx->Map.index = 0;
for (
ctx->Map.pcs[ 0 ] = RtemsTimerReqCancel_Pre_Id_Valid;
ctx->Map.pcs[ 0 ] < RtemsTimerReqCancel_Pre_Id_NA;
++ctx->Map.pcs[ 0 ]
) {
for (
ctx->Map.pcs[ 1 ] = RtemsTimerReqCancel_Pre_Context_None;
ctx->Map.pcs[ 1 ] < RtemsTimerReqCancel_Pre_Context_NA;
++ctx->Map.pcs[ 1 ]
) {
for (
ctx->Map.pcs[ 2 ] = RtemsTimerReqCancel_Pre_Clock_None;
ctx->Map.pcs[ 2 ] < RtemsTimerReqCancel_Pre_Clock_NA;
++ctx->Map.pcs[ 2 ]
) {
for (
ctx->Map.pcs[ 3 ] = RtemsTimerReqCancel_Pre_State_Inactive;
ctx->Map.pcs[ 3 ] < RtemsTimerReqCancel_Pre_State_NA;
++ctx->Map.pcs[ 3 ]
) {
ctx->Map.entry = RtemsTimerReqCancel_PopEntry( ctx );
if ( ctx->Map.entry.Skip ) {
continue;
}
RtemsTimerReqCancel_Prepare( ctx );
RtemsTimerReqCancel_TestVariant( ctx );
RtemsTimerReqCancel_Cleanup( ctx );
}
}
}
}
}
/** @} */

535
testsuites/validation/tc-timer-create.c Normal file
View File

@@ -0,0 +1,535 @@
/* SPDX-License-Identifier: BSD-2-Clause */
/**
* @file
*
* @ingroup RTEMSTestCaseRtemsTimerReqCreate
*/
/*
* 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 <string.h>
#include "tx-support.h"
#include <rtems/test.h>
/**
* @defgroup RTEMSTestCaseRtemsTimerReqCreate spec:/rtems/timer/req/create
*
* @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0
*
* @{
*/
typedef enum {
RtemsTimerReqCreate_Pre_Name_Valid,
RtemsTimerReqCreate_Pre_Name_Invalid,
RtemsTimerReqCreate_Pre_Name_NA
} RtemsTimerReqCreate_Pre_Name;
typedef enum {
RtemsTimerReqCreate_Pre_Id_Valid,
RtemsTimerReqCreate_Pre_Id_Null,
RtemsTimerReqCreate_Pre_Id_NA
} RtemsTimerReqCreate_Pre_Id;
typedef enum {
RtemsTimerReqCreate_Pre_Free_Yes,
RtemsTimerReqCreate_Pre_Free_No,
RtemsTimerReqCreate_Pre_Free_NA
} RtemsTimerReqCreate_Pre_Free;
typedef enum {
RtemsTimerReqCreate_Post_Status_Ok,
RtemsTimerReqCreate_Post_Status_InvName,
RtemsTimerReqCreate_Post_Status_InvAddr,
RtemsTimerReqCreate_Post_Status_TooMany,
RtemsTimerReqCreate_Post_Status_NA
} RtemsTimerReqCreate_Post_Status;
typedef enum {
RtemsTimerReqCreate_Post_Name_Valid,
RtemsTimerReqCreate_Post_Name_Invalid,
RtemsTimerReqCreate_Post_Name_NA
} RtemsTimerReqCreate_Post_Name;
typedef enum {
RtemsTimerReqCreate_Post_IdVar_Set,
RtemsTimerReqCreate_Post_IdVar_Nop,
RtemsTimerReqCreate_Post_IdVar_NA
} RtemsTimerReqCreate_Post_IdVar;
typedef struct {
uint16_t Skip : 1;
uint16_t Pre_Name_NA : 1;
uint16_t Pre_Id_NA : 1;
uint16_t Pre_Free_NA : 1;
uint16_t Post_Status : 3;
uint16_t Post_Name : 2;
uint16_t Post_IdVar : 2;
} RtemsTimerReqCreate_Entry;
/**
* @brief Test context for spec:/rtems/timer/req/create test case.
*/
typedef struct {
/**
* @brief This member is used by the T_seize_objects() and
* T_surrender_objects() support functions.
*/
void *seized_objects;
/**
* @brief This member may contain the object identifier returned by
* rtems_timer_create().
*/
rtems_id id_value;
/**
* @brief This member specifies the ``name`` parameter for the action.
*/
rtems_name name;
/**
* @brief This member specifies the ``id`` parameter for the action.
*/
rtems_id *id;
/**
* @brief This member contains the return status of the action.
*/
rtems_status_code status;
struct {
/**
* @brief This member defines the pre-condition states for the next action.
*/
size_t pcs[ 3 ];
/**
* @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.
*/
RtemsTimerReqCreate_Entry entry;
/**
* @brief If this member is true, then the current transition variant
* should be skipped.
*/
bool skip;
} Map;
} RtemsTimerReqCreate_Context;
static RtemsTimerReqCreate_Context
RtemsTimerReqCreate_Instance;
static const char * const RtemsTimerReqCreate_PreDesc_Name[] = {
"Valid",
"Invalid",
"NA"
};
static const char * const RtemsTimerReqCreate_PreDesc_Id[] = {
"Valid",
"Null",
"NA"
};
static const char * const RtemsTimerReqCreate_PreDesc_Free[] = {
"Yes",
"No",
"NA"
};
static const char * const * const RtemsTimerReqCreate_PreDesc[] = {
RtemsTimerReqCreate_PreDesc_Name,
RtemsTimerReqCreate_PreDesc_Id,
RtemsTimerReqCreate_PreDesc_Free,
NULL
};
#define NAME rtems_build_name( 'T', 'E', 'S', 'T' )
static rtems_status_code Create( void *arg, uint32_t *id )
{
return rtems_timer_create( rtems_build_name( 'S', 'I', 'Z', 'E' ), id );
}
static void RtemsTimerReqCreate_Pre_Name_Prepare(
RtemsTimerReqCreate_Context *ctx,
RtemsTimerReqCreate_Pre_Name state
)
{
switch ( state ) {
case RtemsTimerReqCreate_Pre_Name_Valid: {
/*
* While the ``name`` parameter is valid.
*/
ctx->name = NAME;
break;
}
case RtemsTimerReqCreate_Pre_Name_Invalid: {
/*
* While the ``name`` parameter is invalid.
*/
ctx->name = 0;
break;
}
case RtemsTimerReqCreate_Pre_Name_NA:
break;
}
}
static void RtemsTimerReqCreate_Pre_Id_Prepare(
RtemsTimerReqCreate_Context *ctx,
RtemsTimerReqCreate_Pre_Id state
)
{
switch ( state ) {
case RtemsTimerReqCreate_Pre_Id_Valid: {
/*
* While the ``id`` parameter references an object of type rtems_id.
*/
ctx->id = &ctx->id_value;
break;
}
case RtemsTimerReqCreate_Pre_Id_Null: {
/*
* While the ``id`` parameter is NULL.
*/
ctx->id = NULL;
break;
}
case RtemsTimerReqCreate_Pre_Id_NA:
break;
}
}
static void RtemsTimerReqCreate_Pre_Free_Prepare(
RtemsTimerReqCreate_Context *ctx,
RtemsTimerReqCreate_Pre_Free state
)
{
switch ( state ) {
case RtemsTimerReqCreate_Pre_Free_Yes: {
/*
* While the system has at least one inactive timer object available.
*/
/* Ensured by the test suite configuration */
break;
}
case RtemsTimerReqCreate_Pre_Free_No: {
/*
* While the system has no inactive timer object available.
*/
ctx->seized_objects = T_seize_objects( Create, NULL );
break;
}
case RtemsTimerReqCreate_Pre_Free_NA:
break;
}
}
static void RtemsTimerReqCreate_Post_Status_Check(
RtemsTimerReqCreate_Context *ctx,
RtemsTimerReqCreate_Post_Status state
)
{
switch ( state ) {
case RtemsTimerReqCreate_Post_Status_Ok: {
/*
* The return status of rtems_timer_create() shall be RTEMS_SUCCESSFUL.
*/
T_rsc_success( ctx->status );
break;
}
case RtemsTimerReqCreate_Post_Status_InvName: {
/*
* The return status of rtems_timer_create() shall be RTEMS_INVALID_NAME.
*/
T_rsc( ctx->status, RTEMS_INVALID_NAME );
break;
}
case RtemsTimerReqCreate_Post_Status_InvAddr: {
/*
* The return status of rtems_timer_create() shall be
* RTEMS_INVALID_ADDRESS.
*/
T_rsc( ctx->status, RTEMS_INVALID_ADDRESS );
break;
}
case RtemsTimerReqCreate_Post_Status_TooMany: {
/*
* The return status of rtems_timer_create() shall be RTEMS_TOO_MANY.
*/
T_rsc( ctx->status, RTEMS_TOO_MANY );
break;
}
case RtemsTimerReqCreate_Post_Status_NA:
break;
}
}
static void RtemsTimerReqCreate_Post_Name_Check(
RtemsTimerReqCreate_Context *ctx,
RtemsTimerReqCreate_Post_Name state
)
{
rtems_status_code sc;
rtems_id id;
switch ( state ) {
case RtemsTimerReqCreate_Post_Name_Valid: {
/*
* The unique object name shall identify the timer created by the
* rtems_timer_create() call.
*/
id = 0;
sc = rtems_timer_ident( NAME, &id );
T_rsc_success( sc );
T_eq_u32( id, ctx->id_value );
break;
}
case RtemsTimerReqCreate_Post_Name_Invalid: {
/*
* The unique object name shall not identify a timer.
*/
sc = rtems_timer_ident( NAME, &id );
T_rsc( sc, RTEMS_INVALID_NAME );
break;
}
case RtemsTimerReqCreate_Post_Name_NA:
break;
}
}
static void RtemsTimerReqCreate_Post_IdVar_Check(
RtemsTimerReqCreate_Context *ctx,
RtemsTimerReqCreate_Post_IdVar state
)
{
switch ( state ) {
case RtemsTimerReqCreate_Post_IdVar_Set: {
/*
* The value of the object referenced by the ``id`` parameter shall be
* set to the object identifier of the created timer after the return of
* the rtems_timer_create() call.
*/
T_eq_ptr( ctx->id, &ctx->id_value );
T_ne_u32( ctx->id_value, INVALID_ID );
break;
}
case RtemsTimerReqCreate_Post_IdVar_Nop: {
/*
* Objects referenced by the ``id`` parameter in past calls to
* rtems_timer_create() shall not be accessed by the rtems_timer_create()
* call.
*/
T_eq_u32( ctx->id_value, INVALID_ID );
break;
}
case RtemsTimerReqCreate_Post_IdVar_NA:
break;
}
}
static void RtemsTimerReqCreate_Setup( RtemsTimerReqCreate_Context *ctx )
{
memset( ctx, 0, sizeof( *ctx ) );
ctx->id_value = INVALID_ID;
}
static void RtemsTimerReqCreate_Setup_Wrap( void *arg )
{
RtemsTimerReqCreate_Context *ctx;
ctx = arg;
ctx->Map.in_action_loop = false;
RtemsTimerReqCreate_Setup( ctx );
}
static void RtemsTimerReqCreate_Action( RtemsTimerReqCreate_Context *ctx )
{
ctx->status = rtems_timer_create( ctx->name, ctx->id );
}
static void RtemsTimerReqCreate_Cleanup( RtemsTimerReqCreate_Context *ctx )
{
if ( ctx->id_value != INVALID_ID ) {
rtems_status_code sc;
sc = rtems_timer_delete( ctx->id_value );
T_rsc_success( sc );
ctx->id_value = INVALID_ID;
}
T_surrender_objects( &ctx->seized_objects, rtems_timer_delete );
}
static const RtemsTimerReqCreate_Entry
RtemsTimerReqCreate_Entries[] = {
{ 0, 0, 0, 0, RtemsTimerReqCreate_Post_Status_InvName,
RtemsTimerReqCreate_Post_Name_Invalid, RtemsTimerReqCreate_Post_IdVar_Nop },
{ 0, 0, 0, 0, RtemsTimerReqCreate_Post_Status_InvAddr,
RtemsTimerReqCreate_Post_Name_Invalid, RtemsTimerReqCreate_Post_IdVar_Nop },
{ 0, 0, 0, 0, RtemsTimerReqCreate_Post_Status_Ok,
RtemsTimerReqCreate_Post_Name_Valid, RtemsTimerReqCreate_Post_IdVar_Set },
{ 0, 0, 0, 0, RtemsTimerReqCreate_Post_Status_TooMany,
RtemsTimerReqCreate_Post_Name_Invalid, RtemsTimerReqCreate_Post_IdVar_Nop }
};
static const uint8_t
RtemsTimerReqCreate_Map[] = {
2, 3, 1, 1, 0, 0, 0, 0
};
static size_t RtemsTimerReqCreate_Scope( void *arg, char *buf, size_t n )
{
RtemsTimerReqCreate_Context *ctx;
ctx = arg;
if ( ctx->Map.in_action_loop ) {
return T_get_scope( RtemsTimerReqCreate_PreDesc, buf, n, ctx->Map.pcs );
}
return 0;
}
static T_fixture RtemsTimerReqCreate_Fixture = {
.setup = RtemsTimerReqCreate_Setup_Wrap,
.stop = NULL,
.teardown = NULL,
.scope = RtemsTimerReqCreate_Scope,
.initial_context = &RtemsTimerReqCreate_Instance
};
static inline RtemsTimerReqCreate_Entry RtemsTimerReqCreate_PopEntry(
RtemsTimerReqCreate_Context *ctx
)
{
size_t index;
index = ctx->Map.index;
ctx->Map.index = index + 1;
return RtemsTimerReqCreate_Entries[
RtemsTimerReqCreate_Map[ index ]
];
}
static void RtemsTimerReqCreate_TestVariant( RtemsTimerReqCreate_Context *ctx )
{
RtemsTimerReqCreate_Pre_Name_Prepare( ctx, ctx->Map.pcs[ 0 ] );
RtemsTimerReqCreate_Pre_Id_Prepare( ctx, ctx->Map.pcs[ 1 ] );
RtemsTimerReqCreate_Pre_Free_Prepare( ctx, ctx->Map.pcs[ 2 ] );
RtemsTimerReqCreate_Action( ctx );
RtemsTimerReqCreate_Post_Status_Check( ctx, ctx->Map.entry.Post_Status );
RtemsTimerReqCreate_Post_Name_Check( ctx, ctx->Map.entry.Post_Name );
RtemsTimerReqCreate_Post_IdVar_Check( ctx, ctx->Map.entry.Post_IdVar );
}
/**
* @fn void T_case_body_RtemsTimerReqCreate( void )
*/
T_TEST_CASE_FIXTURE( RtemsTimerReqCreate, &RtemsTimerReqCreate_Fixture )
{
RtemsTimerReqCreate_Context *ctx;
ctx = T_fixture_context();
ctx->Map.in_action_loop = true;
ctx->Map.index = 0;
for (
ctx->Map.pcs[ 0 ] = RtemsTimerReqCreate_Pre_Name_Valid;
ctx->Map.pcs[ 0 ] < RtemsTimerReqCreate_Pre_Name_NA;
++ctx->Map.pcs[ 0 ]
) {
for (
ctx->Map.pcs[ 1 ] = RtemsTimerReqCreate_Pre_Id_Valid;
ctx->Map.pcs[ 1 ] < RtemsTimerReqCreate_Pre_Id_NA;
++ctx->Map.pcs[ 1 ]
) {
for (
ctx->Map.pcs[ 2 ] = RtemsTimerReqCreate_Pre_Free_Yes;
ctx->Map.pcs[ 2 ] < RtemsTimerReqCreate_Pre_Free_NA;
++ctx->Map.pcs[ 2 ]
) {
ctx->Map.entry = RtemsTimerReqCreate_PopEntry( ctx );
RtemsTimerReqCreate_TestVariant( ctx );
RtemsTimerReqCreate_Cleanup( ctx );
}
}
}
}
/** @} */

362
testsuites/validation/tc-timer-delete.c Normal file
View File

@@ -0,0 +1,362 @@
/* SPDX-License-Identifier: BSD-2-Clause */
/**
* @file
*
* @ingroup RTEMSTestCaseRtemsTimerReqDelete
*/
/*
* 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 <string.h>
#include <rtems/test.h>
/**
* @defgroup RTEMSTestCaseRtemsTimerReqDelete spec:/rtems/timer/req/delete
*
* @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0
*
* @{
*/
typedef enum {
RtemsTimerReqDelete_Pre_Id_NoObj,
RtemsTimerReqDelete_Pre_Id_Timer,
RtemsTimerReqDelete_Pre_Id_NA
} RtemsTimerReqDelete_Pre_Id;
typedef enum {
RtemsTimerReqDelete_Post_Status_Ok,
RtemsTimerReqDelete_Post_Status_InvId,
RtemsTimerReqDelete_Post_Status_NA
} RtemsTimerReqDelete_Post_Status;
typedef enum {
RtemsTimerReqDelete_Post_Name_Valid,
RtemsTimerReqDelete_Post_Name_Invalid,
RtemsTimerReqDelete_Post_Name_NA
} RtemsTimerReqDelete_Post_Name;
typedef struct {
uint8_t Skip : 1;
uint8_t Pre_Id_NA : 1;
uint8_t Post_Status : 2;
uint8_t Post_Name : 2;
} RtemsTimerReqDelete_Entry;
/**
* @brief Test context for spec:/rtems/timer/req/delete test case.
*/
typedef struct {
rtems_id timer_id;
rtems_id id;
rtems_status_code status;
struct {
/**
* @brief This member defines the pre-condition states for the next action.
*/
size_t pcs[ 1 ];
/**
* @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.
*/
RtemsTimerReqDelete_Entry entry;
/**
* @brief If this member is true, then the current transition variant
* should be skipped.
*/
bool skip;
} Map;
} RtemsTimerReqDelete_Context;
static RtemsTimerReqDelete_Context
RtemsTimerReqDelete_Instance;
static const char * const RtemsTimerReqDelete_PreDesc_Id[] = {
"NoObj",
"Timer",
"NA"
};
static const char * const * const RtemsTimerReqDelete_PreDesc[] = {
RtemsTimerReqDelete_PreDesc_Id,
NULL
};
#define NAME rtems_build_name( 'T', 'E', 'S', 'T' )
static void RtemsTimerReqDelete_Pre_Id_Prepare(
RtemsTimerReqDelete_Context *ctx,
RtemsTimerReqDelete_Pre_Id state
)
{
switch ( state ) {
case RtemsTimerReqDelete_Pre_Id_NoObj: {
/*
* While the ``id`` parameter is not associated with a timer.
*/
ctx->id = 0;
break;
}
case RtemsTimerReqDelete_Pre_Id_Timer: {
/*
* While the ``id`` parameter is associated with a timer.
*/
ctx->id = ctx->timer_id;
break;
}
case RtemsTimerReqDelete_Pre_Id_NA:
break;
}
}
static void RtemsTimerReqDelete_Post_Status_Check(
RtemsTimerReqDelete_Context *ctx,
RtemsTimerReqDelete_Post_Status state
)
{
switch ( state ) {
case RtemsTimerReqDelete_Post_Status_Ok: {
/*
* The return status of rtems_timer_delete() shall be RTEMS_SUCCESSFUL.
*/
ctx->timer_id = 0;
T_rsc_success( ctx->status );
break;
}
case RtemsTimerReqDelete_Post_Status_InvId: {
/*
* The return status of rtems_timer_delete() shall be RTEMS_INVALID_ID.
*/
T_rsc( ctx->status, RTEMS_INVALID_ID );
break;
}
case RtemsTimerReqDelete_Post_Status_NA:
break;
}
}
static void RtemsTimerReqDelete_Post_Name_Check(
RtemsTimerReqDelete_Context *ctx,
RtemsTimerReqDelete_Post_Name state
)
{
rtems_status_code sc;
rtems_id id;
switch ( state ) {
case RtemsTimerReqDelete_Post_Name_Valid: {
/*
* The unique object name shall identify a timer.
*/
id = 0;
sc = rtems_timer_ident( NAME, &id );
T_rsc_success( sc );
T_eq_u32( id, ctx->timer_id );
break;
}
case RtemsTimerReqDelete_Post_Name_Invalid: {
/*
* The unique object name shall not identify a timer.
*/
sc = rtems_timer_ident( NAME, &id );
T_rsc( sc, RTEMS_INVALID_NAME );
break;
}
case RtemsTimerReqDelete_Post_Name_NA:
break;
}
}
static void RtemsTimerReqDelete_Setup( RtemsTimerReqDelete_Context *ctx )
{
memset( ctx, 0, sizeof( *ctx ) );
}
static void RtemsTimerReqDelete_Setup_Wrap( void *arg )
{
RtemsTimerReqDelete_Context *ctx;
ctx = arg;
ctx->Map.in_action_loop = false;
RtemsTimerReqDelete_Setup( ctx );
}
static void RtemsTimerReqDelete_Teardown( RtemsTimerReqDelete_Context *ctx )
{
if ( ctx->timer_id != 0 ) {
rtems_status_code sc;
sc = rtems_timer_delete( ctx->timer_id );
T_rsc_success( sc );
}
}
static void RtemsTimerReqDelete_Teardown_Wrap( void *arg )
{
RtemsTimerReqDelete_Context *ctx;
ctx = arg;
ctx->Map.in_action_loop = false;
RtemsTimerReqDelete_Teardown( ctx );
}
static void RtemsTimerReqDelete_Prepare( RtemsTimerReqDelete_Context *ctx )
{
if ( ctx->timer_id == 0 ) {
rtems_status_code sc;
sc = rtems_timer_create( NAME, &ctx->timer_id );
T_rsc_success( sc );
}
}
static void RtemsTimerReqDelete_Action( RtemsTimerReqDelete_Context *ctx )
{
ctx->status = rtems_timer_delete( ctx->id );
}
static const RtemsTimerReqDelete_Entry
RtemsTimerReqDelete_Entries[] = {
{ 0, 0, RtemsTimerReqDelete_Post_Status_InvId,
RtemsTimerReqDelete_Post_Name_Valid },
{ 0, 0, RtemsTimerReqDelete_Post_Status_Ok,
RtemsTimerReqDelete_Post_Name_Invalid }
};
static const uint8_t
RtemsTimerReqDelete_Map[] = {
0, 1
};
static size_t RtemsTimerReqDelete_Scope( void *arg, char *buf, size_t n )
{
RtemsTimerReqDelete_Context *ctx;
ctx = arg;
if ( ctx->Map.in_action_loop ) {
return T_get_scope( RtemsTimerReqDelete_PreDesc, buf, n, ctx->Map.pcs );
}
return 0;
}
static T_fixture RtemsTimerReqDelete_Fixture = {
.setup = RtemsTimerReqDelete_Setup_Wrap,
.stop = NULL,
.teardown = RtemsTimerReqDelete_Teardown_Wrap,
.scope = RtemsTimerReqDelete_Scope,
.initial_context = &RtemsTimerReqDelete_Instance
};
static inline RtemsTimerReqDelete_Entry RtemsTimerReqDelete_PopEntry(
RtemsTimerReqDelete_Context *ctx
)
{
size_t index;
index = ctx->Map.index;
ctx->Map.index = index + 1;
return RtemsTimerReqDelete_Entries[
RtemsTimerReqDelete_Map[ index ]
];
}
static void RtemsTimerReqDelete_TestVariant( RtemsTimerReqDelete_Context *ctx )
{
RtemsTimerReqDelete_Pre_Id_Prepare( ctx, ctx->Map.pcs[ 0 ] );
RtemsTimerReqDelete_Action( ctx );
RtemsTimerReqDelete_Post_Status_Check( ctx, ctx->Map.entry.Post_Status );
RtemsTimerReqDelete_Post_Name_Check( ctx, ctx->Map.entry.Post_Name );
}
/**
* @fn void T_case_body_RtemsTimerReqDelete( void )
*/
T_TEST_CASE_FIXTURE( RtemsTimerReqDelete, &RtemsTimerReqDelete_Fixture )
{
RtemsTimerReqDelete_Context *ctx;
ctx = T_fixture_context();
ctx->Map.in_action_loop = true;
ctx->Map.index = 0;
for (
ctx->Map.pcs[ 0 ] = RtemsTimerReqDelete_Pre_Id_NoObj;
ctx->Map.pcs[ 0 ] < RtemsTimerReqDelete_Pre_Id_NA;
++ctx->Map.pcs[ 0 ]
) {
ctx->Map.entry = RtemsTimerReqDelete_PopEntry( ctx );
RtemsTimerReqDelete_Prepare( ctx );
RtemsTimerReqDelete_TestVariant( ctx );
}
}
/** @} */

1162
testsuites/validation/tc-timer-fire-after.c Normal file
View File

File diff suppressed because it is too large Load Diff

1286
testsuites/validation/tc-timer-fire-when.c Normal file
View File

File diff suppressed because it is too large Load Diff

114
testsuites/validation/tc-timer-ident.c Normal file
View File

@@ -0,0 +1,114 @@
/* SPDX-License-Identifier: BSD-2-Clause */
/**
* @file
*
* @ingroup RTEMSTestCaseRtemsTimerValIdent
*/
/*
* Copyright (C) 2020 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 "tr-object-ident-local.h"
#include <rtems/test.h>
/**
* @defgroup RTEMSTestCaseRtemsTimerValIdent spec:/rtems/timer/val/ident
*
* @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0
*
* @brief Test the rtems_timer_ident() directive.
*
* This test case performs the following actions:
*
* - Run the generic object identification tests for Classic API timer class
* objects defined by /rtems/req/ident-local.
*
* @{
*/
static rtems_status_code ClassicTimerIdentAction(
rtems_name name,
rtems_id *id
)
{
return rtems_timer_ident( name, id );
}
/**
* @brief Run the generic object identification tests for Classic API timer
* class objects defined by /rtems/req/ident-local.
*/
static void RtemsTimerValIdent_Action_0( void )
{
rtems_status_code sc;
rtems_id id_local_object;
sc = rtems_timer_create(
ClassicObjectLocalIdentName,
&id_local_object
);
T_assert_rsc_success( sc );
RtemsReqIdentLocal_Run(
id_local_object,
ClassicTimerIdentAction
);
sc = rtems_timer_delete( id_local_object );
T_rsc_success( sc );
}
/**
* @fn void T_case_body_RtemsTimerValIdent( void )
*/
T_TEST_CASE( RtemsTimerValIdent )
{
RtemsTimerValIdent_Action_0();
}
/** @} */

817
testsuites/validation/tc-timer-initiate-server.c Normal file
View File

@@ -0,0 +1,817 @@
/* 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 RTEMSTestSuiteTestsuitesValidationNoClock0
*
* @{
*/
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 );
}
}
}
}
}
/** @} */

1058
testsuites/validation/tc-timer-reset.c Normal file
View File

File diff suppressed because it is too large Load Diff

1301
testsuites/validation/tc-timer-server-fire-after.c Normal file
View File

File diff suppressed because it is too large Load Diff

1417
testsuites/validation/tc-timer-server-fire-when.c Normal file
View File

File diff suppressed because it is too large Load Diff

208
testsuites/validation/tc-timer.c Normal file
View File

@@ -0,0 +1,208 @@
/* SPDX-License-Identifier: BSD-2-Clause */
/**
* @file
*
* @ingroup RTEMSTestCaseRtemsTimerValTimer
*/
/*
* 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/score/atomic.h>
#include "ts-config.h"
#include "tx-support.h"
#include <rtems/test.h>
/**
* @defgroup RTEMSTestCaseRtemsTimerValTimer spec:/rtems/timer/val/timer
*
* @ingroup RTEMSTestSuiteTestsuitesValidationNoClock0
*
* @brief Tests general timer behaviour.
*
* This test case performs the following actions:
*
* - Create a couple of timers.
*
* - Schedule some timers at the same time point.
*
* - Fire the timers and check that they fired in the expected order.
*
* - Clean up all used resources.
*
* @{
*/
/**
* @brief Test context for spec:/rtems/timer/val/timer test case.
*/
typedef struct {
/**
* @brief This member contains the timer identifiers.
*/
rtems_id timer_ids[ TEST_MAXIMUM_TIMERS ];
/**
* @brief This member contains the counter.
*/
Atomic_Uint counter;
/**
* @brief This member contains the timer counter snapshots.
*/
unsigned int counter_snapshots[ TEST_MAXIMUM_TIMERS ];
} RtemsTimerValTimer_Context;
static RtemsTimerValTimer_Context
RtemsTimerValTimer_Instance;
typedef RtemsTimerValTimer_Context Context;
static void Timer( rtems_id timer, void *arg )
{
Context *ctx;
unsigned int *counter;
ctx = T_fixture_context();
counter = arg;
*counter = _Atomic_Fetch_add_uint(
&ctx->counter,
1,
ATOMIC_ORDER_RELAXED
) + 1;
}
static void Fire( Context *ctx, size_t i, rtems_interval ticks )
{
rtems_status_code sc;
ctx->counter_snapshots[ i ] = 0;
sc = rtems_timer_fire_after(
ctx->timer_ids[ i ],
ticks,
Timer,
&ctx->counter_snapshots[ i ]
);
T_rsc_success( sc );
}
static T_fixture RtemsTimerValTimer_Fixture = {
.setup = NULL,
.stop = NULL,
.teardown = NULL,
.scope = NULL,
.initial_context = &RtemsTimerValTimer_Instance
};
/**
* @brief Create a couple of timers.
*/
static void RtemsTimerValTimer_Action_0( RtemsTimerValTimer_Context *ctx )
{
rtems_status_code sc;
size_t i;
T_assert_eq_sz( TEST_MAXIMUM_TIMERS, 10 );
_Atomic_Init_uint( &ctx->counter, 0 );
for ( i = 0; i < TEST_MAXIMUM_TIMERS ; ++i ) {
sc = rtems_timer_create(
rtems_build_name( 'T', 'E', 'S', 'T' ),
&ctx->timer_ids[ i ]
);
T_rsc_success( sc );
}
/*
* Schedule some timers at the same time point.
*/
Fire( ctx, 3, 2 );
Fire( ctx, 0, 1 );
Fire( ctx, 7, 3 );
Fire( ctx, 4, 2 );
Fire( ctx, 5, 2 );
Fire( ctx, 8, 3 );
Fire( ctx, 9, 3 );
Fire( ctx, 1, 1 );
Fire( ctx, 2, 1 );
Fire( ctx, 6, 2 );
/*
* Fire the timers and check that they fired in the expected order.
*/
FinalClockTick();
for ( i = 0; i < TEST_MAXIMUM_TIMERS ; ++i ) {
T_eq_sz( ctx->counter_snapshots[ i ], i + 1 );
}
/*
* Clean up all used resources.
*/
for ( i = 0; i < TEST_MAXIMUM_TIMERS ; ++i ) {
sc = rtems_timer_delete( ctx->timer_ids[ i ] );
T_rsc_success( sc );
}
}
/**
* @fn void T_case_body_RtemsTimerValTimer( void )
*/
T_TEST_CASE_FIXTURE( RtemsTimerValTimer, &RtemsTimerValTimer_Fixture )
{
RtemsTimerValTimer_Context *ctx;
ctx = T_fixture_context();
RtemsTimerValTimer_Action_0( ctx );
}
/** @} */