Google Git
Sign in
eclipse / titan / titan.Libraries.CLL / refs/tags/LPA108463_R17A04 / . / src / ExecCtrl / EPTF_CLL_ExecCtrl_Definitions.ttcn
blob: 87a5a8c63498e734483e887d5c471f2fabdcb091 [file] [log] [blame]
///////////////////////////////////////////////////////////////////////////////
// //
// Copyright (c) 2000-2019 Ericsson Telecom AB //
// //
// All rights reserved. This program and the accompanying materials //
// are made available under the terms of the Eclipse Public License v2.0 //
// which accompanies this distribution, and is available at //
// https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html //
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
// Module: EPTF_CLL_ExecCtrl_Definitions
//
// Purpose:
// This module contains type definitions for EPTF_CLL_ExecCtrl implementation.
//
// Module depends on:
// <EPTF_CLL_Common_Definitions>
// <EPTF_CLL_Base_Definitions>
// <EPTF_CLL_FBQ_Definitions>
// <EPTF_CLL_LGenBase_Definitions>
// <EPTF_CLL_LGenBase_ConfigDefinitions>
// <EPTF_CLL_LGenBase_PhaseDefinitions>
// <EPTF_CLL_ExecCtrl_ScenarioDefinitions>
// <EPTF_CLL_ExecCtrlTimeProfile_Definitions>
// <EPTF_CLL_RBTScheduler_Definitions>
// <EPTF_CLL_Variable_Definitions>
// <EPTF_CLL_LGenBaseStats_Definitions>
// <EPTF_CLL_Logging_Definitions>
// <EPTF_CLL_StatMeasure_Definitions>
// <EPTF_CLL_StatHandler_Definitions>
// <EPTF_CLL_StatHandlerClient_Definitions>
// <EPTF_CLL_HashMap_Definitions>
//
// Module Parameters:
// tsp_EPTF_ExecCtrl_Scenario2EntityGroupList - <EPTF_ExecCtrl_ScenarioInstanceTypeList> - Scenario-EntityGroup assignment
// tsp_ExecCtrl_ignoreOutOfResource - *boolean* - set the behavior if the LGen is unable to create as many entities as requested
// tsp_ExecCtrl_manualControl - *boolean* - selects between automatic/manual scenario control (start/stop)
// tsp_EPTF_ExecCtrl_TimeProfileDescrList - <EPTF_ExecCtrl_TimeProfileDescrList> - the time profiles
// tsp_EPTF_ExecCtrl_TimeProfile2TcList - <EPTF_ExecCtrl_TimeProfile2TcList> - traffic case to time profile assignment
// tsp_EPTF_ExecCtrl_StartStopScenarioDisable - <EPTF_ExecCtrl_StartStopScenarioDisable> - enable/disable start/stop scenario buttons
// tsp_EPTF_ExecCtrl_StartStopTCDisable - <EPTF_ExecCtrl_StartStopTCDisable> - enable/disable start/stop traffic case buttons
// tsp_EPTF_ExecCtrl_loggingComponentMask - *charstring* - component-type mask for logging, default value: "EPTF_ExecCtrl"
// tsp_EPTF_ExecCtrlClient_loggingComponentMask - *charstring* - component-type mask for logging, default value: "EPTF_ExecCtrlClient"
// tsp_EPTF_ExecCtrl_PhaseList_Declarators - <EPTF_LGenBase_PhaseList_Declarators> - the phase list declarators
// tsp_EPTF_ExecCtrl_ScenarioGroup_Declarators - <EPTF_ExecCtrl_ScenarioGroup_Declarators> - Scenario group declarators
// <tsp_EPTF_ExecCtrl_EntityGroup2LGenPool_List> - <EPTF_ExecCtrl_EntityGroup2LGenPool_List> - Entity group distribution (Default empty list)
// <tsp_EPTF_ExecCtrl_LGenPool_Declarators> - <EPTF_ExecCtrl_LGenPool_Declarators> - The LGen pool declarators
// <tsp_EPTF_ExecCtrl_EntityGroupDistributionDeclarators> - <EPTF_ExecCtrl_EntityGroupDistributionTypeList> - defines the entity group distribution on LGens.
// If not specified, automatic method is used
//
// Current Owner:
// Jozsef Gyurusi (ethjgi)
//
// Last Review Date:
// 2009-02-03
//
// Detailed Comments:
// This module contains type definitions for EPTF_CLL_ExecCtrl implementation.
//
///////////////////////////////////////////////////////////////
module EPTF_CLL_ExecCtrl_Definitions {
//=========================================================================
// Import Part
//=========================================================================
import from EPTF_CLL_Common_Definitions all;
import from EPTF_CLL_Base_Definitions all;
import from EPTF_CLL_FBQ_Definitions all;
import from EPTF_CLL_LGenBase_Definitions all;
import from EPTF_CLL_LGenBase_ConfigDefinitions all;
import from EPTF_CLL_ExecCtrl_ScenarioDefinitions all;
import from EPTF_CLL_ExecCtrlTimeProfile_Definitions all;
import from EPTF_CLL_RBTScheduler_Definitions all;
import from EPTF_CLL_Variable_Definitions all;
import from EPTF_CLL_LGenBaseStats_Definitions all;
import from EPTF_CLL_LGenBase_PhaseDefinitions all;
import from EPTF_CLL_Logging_Definitions all;
import from EPTF_CLL_ExecCtrl_PhaseDefinitions all;
import from EPTF_CLL_StatMeasure_Definitions all;
import from EPTF_CLL_StatHandler_Definitions all;
import from EPTF_CLL_StatHandlerClient_Definitions all;
import from EPTF_CLL_DataSource_Definitions all;
import from EPTF_CLL_StatManager_Definitions all;
import from EPTF_CLL_HashMap_Definitions all;
modulepar boolean tsp_ExecCtrl_ignoreOutOfResource := true;
modulepar boolean tsp_ExecCtrl_manualControl := false;
modulepar EPTF_ExecCtrl_RegulatorNames tsp_EPTF_ExecCtrl_RegulatorNames := {};
modulepar EPTF_ExecCtrl_RegulatedItems tsp_EPTF_ExecCtrl_RegulatedItems := {};
modulepar EPTF_ExecCtrl_StartStopScenarioDisable tsp_EPTF_ExecCtrl_StartStopScenarioDisable := {};
modulepar EPTF_ExecCtrl_StartStopTCDisable tsp_EPTF_ExecCtrl_StartStopTCDisable := {}
modulepar charstring tsp_EPTF_ExecCtrl_loggingComponentMask := "EPTF_ExecCtrl";
modulepar charstring tsp_EPTF_ExecCtrlClient_loggingComponentMask := "EPTF_ExecCtrlClient";
// FIXME: This should be in LGenBase:
modulepar EPTF_ExecCtrl_ScenarioInstanceTypeList tsp_EPTF_ExecCtrl_Scenario2EntityGroupList := {};
modulepar EPTF_LGenBase_PhaseList_Declarators tsp_EPTF_ExecCtrl_PhaseList_Declarators := {};
modulepar
{
EPTF_ExecCtrl_ScenarioGroup_Declarators tsp_EPTF_ExecCtrl_ScenarioGroup_Declarators := {};
EPTF_ExecCtrl_LGenPool_Declarators tsp_EPTF_ExecCtrl_LGenPool_Declarators := {};
}
modulepar EPTF_ExecCtrl_EntityGroup2LGenPool_List tsp_EPTF_ExecCtrl_EntityGroup2LGenPool_List := {};
modulepar EPTF_ExecCtrl_EntityGroupDistributionTypeList tsp_EPTF_ExecCtrl_EntityGroupDistributionDeclarators := {};
modulepar EPTF_ExecCtrl_timeFormat tsp_EPTF_ExecCtrl_timeFormat := SECONDS; // declares the time format on the GUI
modulepar float tsp_EPTF_ExecCtrl_timePeriodForTcDeltaStats := 3.0; // Time period when delta stats are refreshed.
modulepar float tsp_EPTF_ExecCtrl_GroupFinishedGuardTime := 5.0; // max wait time in seconds until all LGens report GroupFinish for the same condition (-1 for infinity)
//=========================================================================
// Data Types
//=========================================================================
const integer c_ExecCtrl_invalidIdx := -1;
const integer c_ExecCtrl_unlimitedNrOfEntities := -1;
const charstring c_ExecCtrl_Cfg_WAITFOR_INIT := "WAITFOR_INIT";
const charstring c_ExecCtrl_Cfg_CONFIGURED := "CONFIGURED";
// Stat Names:
const integer c_EPTF_ExecCtrl_tcStatId_Unknown := -1;
const integer c_EPTF_ExecCtrl_tcStatId_CurrentCPS := 0;
const integer c_EPTF_ExecCtrl_tcStatId_Running := 1;
const integer c_EPTF_ExecCtrl_tcStatId_Available := 2;
const integer c_EPTF_ExecCtrl_tcStatId_FinTraffic := 3;
const integer c_EPTF_ExecCtrl_tcStatId_MaxBusy := 4;
const integer c_EPTF_ExecCtrl_tcStatId_MaxRunning := 5;
const integer c_EPTF_ExecCtrl_tcStatId_MinAvailable := 6;
const integer c_EPTF_ExecCtrl_tcStatId_NotFinished := 7;
const integer c_EPTF_ExecCtrl_tcStatId_RangeLoops := 8;
const integer c_EPTF_ExecCtrl_tcStatId_Starts := 9;
const integer c_EPTF_ExecCtrl_tcStatId_Success := 10;
const integer c_EPTF_ExecCtrl_tcStatId_Fail := 11;
const integer c_EPTF_ExecCtrl_tcStatId_Timeout := 12;
const integer c_EPTF_ExecCtrl_tcStatId_Error := 13;
const integer c_EPTF_ExecCtrl_tcStatId_ExecTime := 14;
type integer EPTF_ExecCtrl_TcStatId(
c_EPTF_ExecCtrl_tcStatId_Unknown,
c_EPTF_ExecCtrl_tcStatId_CurrentCPS,
c_EPTF_ExecCtrl_tcStatId_Running,
c_EPTF_ExecCtrl_tcStatId_Available,
c_EPTF_ExecCtrl_tcStatId_FinTraffic,
c_EPTF_ExecCtrl_tcStatId_MaxBusy,
c_EPTF_ExecCtrl_tcStatId_MaxRunning,
c_EPTF_ExecCtrl_tcStatId_MinAvailable,
c_EPTF_ExecCtrl_tcStatId_NotFinished,
c_EPTF_ExecCtrl_tcStatId_RangeLoops,
c_EPTF_ExecCtrl_tcStatId_Starts,
c_EPTF_ExecCtrl_tcStatId_Success,
c_EPTF_ExecCtrl_tcStatId_Fail,
c_EPTF_ExecCtrl_tcStatId_Timeout,
c_EPTF_ExecCtrl_tcStatId_Error,
c_EPTF_ExecCtrl_tcStatId_ExecTime
);
const EPTF_CharstringList c_EPTF_ExecCtrl_tcStatNames := {
"CurrentCPS",
"Running",
"Available",
"FinTraffic",
"MaxBusy",
"MaxRunning",
"MinAvailable",
"NotFinished",
"RangeLoops",
"Starts",
"Success",
"Fail",
"Timeout",
"Error",
"ExecTime"
};
const EPTF_CharstringList c_EPTF_ExecCtrl_tcStatVarNamesInLGen := {
c_EPTF_LGenBaseStats_nameOfTcLastCps,
c_EPTF_LGenBaseStats_nameOfTcNrOfRunningEntities,
c_EPTF_LGenBaseStats_nameOfTcNrOfAvailableEntities,
c_EPTF_LGenBaseStats_nameOfTcReceivedAnswers,
c_EPTF_LGenBaseStats_nameOfTcMaxBusy,
c_EPTF_LGenBaseStats_nameOfTcMaxRunning,
c_EPTF_LGenBaseStats_nameOfTcMinAvailable,
c_EPTF_LGenBaseStats_nameOfTcNrOfNotFinishedEntities,
c_EPTF_LGenBaseStats_nameOfTcRangeLoops,
c_EPTF_LGenBaseStats_nameOfTcNrOfStarts,
c_EPTF_LGenBaseStats_nameOfTcNrOfSuccesses,
c_EPTF_LGenBaseStats_nameOfTcNrOfFails,
c_EPTF_LGenBaseStats_nameOfTcNrOfTimeouts,
c_EPTF_LGenBaseStats_nameOfTcNrOfErrors
};
// {Delta statistics}: LGen Variables for delta statistics
type record of EPTF_ExecCtrl_TcStatId ExecCtrl_TcStatIdList;
const ExecCtrl_TcStatIdList c_EPTF_ExecCtrl_tcDeltaStatVarIds := {
c_EPTF_ExecCtrl_tcStatId_Starts,
c_EPTF_ExecCtrl_tcStatId_Success,
c_EPTF_ExecCtrl_tcStatId_Fail,
c_EPTF_ExecCtrl_tcStatId_Timeout,
c_EPTF_ExecCtrl_tcStatId_Error
};
const EPTF_CharstringList c_EPTF_ExecCtrl_globalStatNames := {
"Starts",
"Success",
"Fail",
"Timeout",
"Error"
};
// Prefix for ExecCtrl Statistics variables and widgets
const charstring c_EPTF_ExecCtrl_statisticsRoot := "EPTF_ExecCtrl.Statistics";
template charstring t_ExecCtrl_scenarioReadyToStart := ("Idle","Stopped","Finished","Terminated","Aborted"); // support for "FINISHED" will be added later
template charstring t_ExecCtrl_scenarioReadyToStop := ("Running","Paused");
///////////////////////////////////////////////////////////////////////////////
// Type: EPTF_ExecCtr_timeFormat
//
// Purpose:
// Type for declaring time format representation on the GUI
//
// Elements:
// - SECONDS
// - HH_MM_SS
//
///////////////////////////////////////////////////////////////////////////////
type enumerated EPTF_ExecCtrl_timeFormat
{
SECONDS,
HH_MM_SS
}
///////////////////////////////////////////////////////////
// Type: EPTF_FloatTable
//
// Purpose:
// Type for storing list of <EPTF_FloatList> items (2D float table)
//
// Elements:
// <EPTF_FloatList>
///////////////////////////////////////////////////////////
type record of EPTF_FloatList EPTF_FloatTable;
///////////////////////////////////////////////////////////
// Function: EPTF_ExecCtrl_ScenarioStateChangedCallbackFn
//
// Purpose:
// Callback function type for scenarioStateChange
//
// Parameters:
// - pl_eGrpName - *in charstring* - name of the entity group
// - pl_scName - *in charstring* - name of the scenario
// - pl_state - *in charstring* - state of the scenario (see <c_EPTF_LGenBase_stateNames> in <EPTF_CLL_LGenBase_Definitions> for possible values)
//
// Return Value:
// -
//
// Errors & assertions:
// -
//
// Detailed Comments:
//
//
///////////////////////////////////////////////////////////
type function EPTF_ExecCtrl_ScenarioStateChangedCallbackFn(in charstring pl_eGrpName, in charstring pl_scName, in charstring pl_state) runs on self;
///////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_ScenarioStateChangedCallbackFns
//
// Purpose:
// List of <EPTF_ExecCtrl_ScenarioStateChangedCallbackFn>-s
//
//
///////////////////////////////////////////////////////////
type record of EPTF_ExecCtrl_ScenarioStateChangedCallbackFn EPTF_ExecCtrl_ScenarioStateChangedCallbackFns;
///////////////////////////////////////////////////////////
// Function: EPTF_ExecCtrl_TrafficCaseStateChangedCallbackFn
//
// Purpose:
// Callback function type for trafficCaseStateChange
//
// Parameters:
// - pl_eGrpName - *in charstring* - name of the entity group
// - pl_scName - *in charstring* - name of the scenario
// - pl_tcName - *in charstring* - name of the trafficCase
// - pl_state - *in charstring* - state of the trafficCase (see <c_EPTF_LGenBase_stateNames> in <EPTF_CLL_LGenBase_Definitions> for possible values)
//
// Return Value:
// -
//
// Errors & assertions:
// -
//
// Detailed Comments:
//
//
///////////////////////////////////////////////////////////
type function EPTF_ExecCtrl_TrafficCaseStateChangedCallbackFn(in charstring pl_eGrpName, in charstring pl_scName, in charstring pl_tcName, in charstring pl_state) runs on self;
///////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_TrafficCaseStateChangedCallbackFns
//
// Purpose:
// List of <EPTF_ExecCtrl_TrafficCaseStateChangedCallbackFn>-s
//
//
///////////////////////////////////////////////////////////
type record of EPTF_ExecCtrl_TrafficCaseStateChangedCallbackFn EPTF_ExecCtrl_TrafficCaseStateChangedCallbackFns;
///////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_OnGroupFinishCallback_FT
//
// Purpose:
// Function type for group finish callback functions
//
// Parameters:
// pl_tcIdx - *in integer* - the traffic case instance index for which the callback is called
// pl_conditionType - *in* <EPTF_ExecCtrl_GrpFinishConditionType> - group finish condition type that fired
//
// Detailed Comments:
// This type of function can be registered by <f_EPTF_ExecCtrl_registerGroupFinishCallbackFn> to be called
// when the group finish state of the traffic case changes.
// The group finish state change event is when any of the onGroupFinish conditions
// becomes true (fired), or when all becomes false (none fired) in the traffic case.
// If any of the onGroupFinishCondition is fired or not can be checked by <f_EPTF_ExecCtrl_checkOnGroupFinished>.
// If the group finish condition type can be determined when the condition fired,
// pl_conditionType gives the type of the condition that fired, otherwise it is set to c_EPTF_ExecCtrl_groupFinishConditionUnknown.
///////////////////////////////////////////////////////////
type function EPTF_ExecCtrl_OnGroupFinishCallback_FT(
in integer pl_tcIdx,
in EPTF_ExecCtrl_GrpFinishConditionType pl_conditionType
) runs on self;
///////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_OnGroupFinishCallbackFns
//
// Purpose:
// List of <EPTF_ExecCtrl_OnGroupFinishCallback_FT>-s. This is the type of the groupFinishCallback database
//
//
///////////////////////////////////////////////////////////
type record of EPTF_ExecCtrl_OnGroupFinishCallback_FT EPTF_ExecCtrl_OnGroupFinishCallbackFns;
group EPTF_ExecCtrl_Regulator {
type record EPTF_ExecCtrl_TC {
integer grpidx,
integer scenidx,
integer tcidx
}
type record EPTF_ExecCtrl_SC {
integer grpidx,
integer scenidx
}
type record EPTF_ExecCtrl_TCInPhase {
integer grpidx,
integer scenidx,
integer tcidx,
charstring phase
}
type record EPTF_ExecCtrl_SCInPhase {
integer grpidx,
integer scenidx,
charstring phase
}
///////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_TCName
//
// Purpose:
// Type for identify a traffic case by names
//
// Elements:
// - eGrpName - *charstring* - the name of entity group
// - scName - *charstring* - the name of scenario
// - tcName - *charstring* - the name of traffic case
//
///////////////////////////////////////////////////////////
type record EPTF_ExecCtrl_TCName {
charstring eGrpName,
charstring scName,
charstring tcName
}
///////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_SCName
//
// Purpose:
// Type for identify a scenario by names
//
// Elements:
// - eGrpName - *charstring* - the name of entity group
// - scName - *charstring* - the name of scenario
//
///////////////////////////////////////////////////////////
type record EPTF_ExecCtrl_SCName {
charstring eGrpName,
charstring scName
}
type record EPTF_ExecCtrl_TCNameInPhase {
charstring eGrpName,
charstring scName,
charstring tcName,
charstring phase // only in the given phase
}
type record EPTF_ExecCtrl_SCNameInPhase {
charstring eGrpName,
charstring scName,
charstring phase // only in the given phase
}
// this type is only used in CFG
type union EPTF_ExecCtrl_RegulatedItemName {
EPTF_ExecCtrl_TCName cps_TC, // regulation works for all phases
EPTF_ExecCtrl_SCName cps_SC, // regulation works for all phases
EPTF_ExecCtrl_TCNameInPhase cps_TCInPhase,// regulation works only in the given phase
EPTF_ExecCtrl_SCNameInPhase cps_SCInPhase // regulation works only in the given phase
}
type union EPTF_ExecCtrl_RegulatedItemId {
EPTF_ExecCtrl_TC cps_TC,
EPTF_ExecCtrl_SC cps_SC,
EPTF_ExecCtrl_TCInPhase cps_TCInPhase,
EPTF_ExecCtrl_SCInPhase cps_SCInPhase
}
type record EPTF_ExecCtrl_RegulatedItem {
EPTF_ExecCtrl_RegulatedItemName idName,
float weight, // used to determine part of the total value
boolean enabled, // regulation enabled
charstring regulatorName // name in EPTF_ExecCtrl_Regulators: this regulator regulates this item
}
// type of the database and tsp:
type EPTF_CharstringList EPTF_ExecCtrl_RegulatorNames; // type of regulator names
type record of EPTF_ExecCtrl_RegulatedItem EPTF_ExecCtrl_RegulatedItems; // database of the regulated items
type record of EPTF_ExecCtrl_RegulatedItemId EPTF_ExecCtrl_RegulatedItemIds; // parallel database for storing the Ids for faster access
// type of the regulator:
type record EPTF_ExecCtrl_Regulator {
charstring name,
EPTF_IntegerList regulatedItemIds, // idx-es in EPTF_ExecCtrl_RegulatedItems and EPTF_ExecCtrl_RegulatedItemIds
integer totalValueIdx, // the id of the EPTF Variable that can be used to adjust the totalValue (e.g. totalCPS)
integer targetLoadIdx,
integer currentLoadIdx,
integer statusIdx,
integer enableIdx
//,ft_EPTF_LoadRegulator_getSUTLoad getSutLoad_Fn
//,float targetValue
}
// regulator database:
type record of EPTF_ExecCtrl_Regulator EPTF_ExecCtrl_Regulators;
} // group EPTF_ExecCtrl_Regulator
type record EPTF_ExecCtrl_StartStopScenarioDisableItem {
EPTF_ExecCtrl_SCName scIdName,
boolean disabled
}
type record of EPTF_ExecCtrl_StartStopScenarioDisableItem EPTF_ExecCtrl_StartStopScenarioDisable; // database for enable/disable start/stop scenario buttons on traffic case tab
type record EPTF_ExecCtrl_StartStopTCDisableItem {
EPTF_ExecCtrl_TCName tcIdName,
boolean disabled
}
type record of EPTF_ExecCtrl_StartStopTCDisableItem EPTF_ExecCtrl_StartStopTCDisable; // database for enable/disable start/stop TC buttons on traffic case tab
type record EPTF_ExecCtrl_EntityResourceInfo_BufferItem {
EPTF_ExecCtrlClient_CT client,
EPTF_ExecCtrl_EntityResourceInfo msg
}
type record of EPTF_ExecCtrl_EntityResourceInfo_BufferItem EPTF_ExecCtrl_EntityResourceInfo_Buffer;
///////////////////////////////////////////////////////////
// Group: ExecCtrl_MgmtInterface
//
// Purpose:
// Grouping data types for the ExecCtrl management interface
//
///////////////////////////////////////////////////////////
group ExecCtrl_MgmtInterface {
/*
///////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_CpsOfTc
//
// Purpose:
// Data type for describe traffic case - cps value associations
//
// Elements:
// - tcName - *charstring* - the name of the traffic case
// - cpsToReach - *float* - the related cps value
//
///////////////////////////////////////////////////////////
type record EPTF_ExecCtrl_CpsOfTc
{
charstring tcName,
float cpsToReach
}
//////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_CpsOfTcList
//
// Purpose:
// Type for storing list of references to traffic case - cps value associations
//
// Elements:
// <EPTF_ExecCtrl_CpsOfTc>
///////////////////////////////////////////////////////////
type record of EPTF_ExecCtrl_CpsOfTc EPTF_ExecCtrl_CpsOfTcList;
*/
///////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_UpdateActiveEntities
//
// Purpose:
// Message type for update number of active entity values on LGen
//
// Elements:
// - eGrpName - *charstring* - the name of entity group
// - activeEntities - *integer* - number of active entities
//
///////////////////////////////////////////////////////////
type record EPTF_ExecCtrl_UpdateActiveEntities
{
charstring eGrpName,
integer activeEntities
}
///////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_UpdateCps
//
// Purpose:
// Message type for update cps values on LGen
//
// Elements:
// - eGrpName - *charstring* - the name of entity group
// - scenName - *charstring* - the name of traffic scenario
// - tcName - *charstring* - the name of the traffic case inside the scenario
// - cps - *float* - cps
//
///////////////////////////////////////////////////////////
type record EPTF_ExecCtrl_UpdateCps
{
charstring eGrpName,
charstring scenName,
charstring tcName,
float cps
}
///////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_UpdateScenarioCps
//
// Purpose:
// Message type for update scenario cps value on LGen
//
// Elements:
// - eGrpName - *charstring* - the name of entity group
// - scenName - *charstring* - the name of traffic scenario
// - cps - *float* - cps value
//
///////////////////////////////////////////////////////////
type record EPTF_ExecCtrl_UpdateScenarioCps
{
charstring eGrpName,
charstring scenName,
float cps
}
///////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_UpdateStartDelay
//
// Purpose:
// Message type for update startDelay values on LGen
//
// Elements:
// - eGrpName - *charstring* - the name of entity group
// - scenName - *charstring* - the name of traffic scenario
// - tcName - *charstring* - the name of the traffic case inside the scenario
// - startDelay - *float* - startDelay
//
///////////////////////////////////////////////////////////
type record EPTF_ExecCtrl_UpdateStartDelay
{
charstring eGrpName,
charstring scenName,
charstring tcName,
float startDelay
}
///////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrlClient_GroupFinished
//
// Purpose:
// Message type to notify ExecCtrl/ExecCtrlClient that the groupFinish condition fired locally/globally
//
// Elements:
// - tcId - <EPTF_ExecCtrl_TCName> - tc id : { eGrpName,scName,tcName}
// - condition - <EPTF_LGenBase_ConditionTrue> - the reason of the groupFinish
// the fired conditons flags are set true
// - thresholds - <EPTF_IntegerList> - set new thresholds for the fulfilled conditions
//
///////////////////////////////////////////////////////////
type record EPTF_ExecCtrlClient_GroupFinished {
EPTF_ExecCtrl_TCName tcId,
EPTF_LGenBase_ConditionTrue condition,
EPTF_IntegerList thresholds
}
///////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrlClient_PauseTC
//
// Purpose:
// Message type to notify ExecCtrlClient to pause the traffic case
//
// Elements:
// - tcId - <EPTF_ExecCtrl_TCName> - tc id : { eGrpName,scName,tcName}
// - conditionType - <EPTF_ExecCtrl_GrpFinishConditionType> - when sent from ExecCtrl to ExecCtrlClient
// it contains the condition type id for which the counter should be returned
// - counter - *integer* - when sent from ExecCtrlClient to ExecCtrl
// it contains the current value of the condition counter
//
///////////////////////////////////////////////////////////
type record EPTF_ExecCtrlClient_PauseTC {
EPTF_ExecCtrl_TCName tcId,
EPTF_ExecCtrl_GrpFinishConditionType conditionType,
EPTF_IntegerList counters
}
//////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_ParamRangeDeclaratorTable
//
// Purpose:
// Type for storing list of references to parameter range declarators (2D table)
//
// Elements:
// <EPTF_LGenBase_TcMgmt_ParamRangeDeclaratorList>
///////////////////////////////////////////////////////////
type record of EPTF_LGenBase_TcMgmt_ParamRangeDeclaratorList EPTF_ExecCtrl_ParamRangeDeclaratorTable; // 2D
//////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_ParamRangeDeclaratorTableList
//
// Purpose:
// Type for storing list of references to parameter range declarators tables (3D table)
//
// Elements:
// <EPTF_LGenBase_TcMgmt_ParamRangeDeclaratorTable>
///////////////////////////////////////////////////////////
type record of EPTF_ExecCtrl_ParamRangeDeclaratorTable EPTF_ExecCtrl_ParamRangeDeclaratorTableList; // 3D
//////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_TrafficStartFinishConditionsInternalDeclaratorTable
//
// Purpose:
// Type for storing list of references to TrafficStartFinishConditions (2D table)
//
// Elements:
// <EPTF_LGenBase_TrafficStartFinishConditionsInternalDeclarator>
///////////////////////////////////////////////////////////
type record of EPTF_LGenBase_TrafficStartFinishConditionsInternalDeclarator EPTF_ExecCtrl_TrafficStartFinishConditionsInternalDeclaratorTable; // 2D
//////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_TrafficStartFinishConditionsInternalDeclaratorTableList
//
// Purpose:
// Type for storing list of references to TrafficStartFinishConditions (3D table)
//
// Elements:
// <EPTF_ExecCtrl_TrafficStartFinishConditionsInternalDeclaratorTable>
///////////////////////////////////////////////////////////
type record of EPTF_ExecCtrl_TrafficStartFinishConditionsInternalDeclaratorTable EPTF_ExecCtrl_TrafficStartFinishConditionsInternalDeclaratorTableList; // 3D
//////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_DeclareTc
//
// Purpose:
// Type alias of <EPTF_LGenBase_TcMgmt_tcTypeDeclarator2>,
// message type for declare a traffic case type on LGen
//
// Elements:
// <EPTF_LGenBase_TcMgmt_tcTypeDeclarator2>
///////////////////////////////////////////////////////////
type EPTF_LGenBase_TrafficCaseTypeInternalDeclarator EPTF_ExecCtrl_DeclareTc; // alias
//////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_DeclareScenario2
//
// Purpose:
// Type alias of <EPTF_LGenBase_TcMgmt_ScenarioDeclarator2>,
// message type for declare a scenario on LGen
//
// Elements:
// <EPTF_LGenBase_TcMgmt_ScenarioDeclarator2>
///////////////////////////////////////////////////////////
type EPTF_LGenBase_TcMgmt_ScenarioDeclarator2 EPTF_ExecCtrl_DeclareScenario2; // alias
//////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_DeclareScenario3
//
// Purpose:
// Type alias of <EPTF_LGenBase_TcMgmt_WeightedScenarioDeclarator>,
// message type for declare a scenario on LGen
//
// Elements:
// <EPTF_LGenBase_TcMgmt_ScenarioDeclarator2>
///////////////////////////////////////////////////////////
type EPTF_LGenBase_TcMgmt_WeightedScenarioDeclarator EPTF_ExecCtrl_DeclareScenario3; // alias
//////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_ScenarioStatus
//
// Purpose:
// Data type for describe a scenario execution status
//
// Elements:
// - scenarioDesc - <EPTF_LGenBase_Scenario2Grp> - scenario descriptor
// - scenStatus - *charstring* - the scenario status in cleartext
//
///////////////////////////////////////////////////////////
type record EPTF_ExecCtrl_ScenarioStatus
{
EPTF_LGenBase_Scenario2Grp scenarioDesc,
charstring scenStatus
}
//////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_ScenarioStatusList
//
// Purpose:
// Type for storing list of references to scenario execution status info
//
// Elements:
// <EPTF_ExecCtrl_ScenarioStatus>
///////////////////////////////////////////////////////////
type record of EPTF_ExecCtrl_ScenarioStatus EPTF_ExecCtrl_ScenarioStatusList;
//////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_StartScenario
//
// Purpose:
// Message type for indicate a scenario execution start on LGen
//
// Elements:
// - eGrpName - *charstring* - the name of the entity group
// - scenarioName - *charstring* - the name of scenario
//
///////////////////////////////////////////////////////////
type record EPTF_ExecCtrl_StartScenario
{
charstring eGrpName,
charstring scenarioName
}
//////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_StartTrafficCase
//
// Purpose:
// Message type for indicate a traffic case execution start on LGen
//
// Elements:
// - eGrpName - *charstring* - the name of the entity group
// - scenName - *charstring* - the name of scenario
// - tcName - *charstring* - the name of traffic case
//
///////////////////////////////////////////////////////////
type record EPTF_ExecCtrl_StartTrafficCase {
charstring eGrpName,
charstring scenName,
charstring tcName
}
//////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_StopTrafficCase
//
// Purpose:
// Message type for indicate a traffic case execution start on LGen
//
// Elements:
// - eGrpName - *charstring* - the name of the entity group
// - scenName - *charstring* - the name of scenario
// - tcName - *charstring* - the name of traffic case
//
///////////////////////////////////////////////////////////
type record EPTF_ExecCtrl_StopTrafficCase {
charstring eGrpName,
charstring scenName,
charstring tcName
}
//////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_StopScenario
//
// Purpose:
// Message type for indicate a scenario execution stop on LGen
//
// Elements:
// - eGrpName - *charstring* - the name of the entity group
// - scenarioName - *charstring* - the name of scenario
//
///////////////////////////////////////////////////////////
type record EPTF_ExecCtrl_StopScenario
{
charstring eGrpName,
charstring scenarioName
}
group R3 {
type record EPTF_ExecCtrl_EntityResourceInfo {
charstring lgenName, // name of the LGen
EPTF_ExecCtrl_LGenResourceInfoList available // the available entity resources
}
type record EPTF_ExecCtrl_CreateEntityGrp {
charstring name,
charstring eType,
integer gOffset, // global offset of the first entity of the entity group
integer gCount, // size of the entity group
integer eOffset, // global offset of the first entity of the deployed entity group on the LGen
integer eCount,
float trafficCorrigation // traffic corrigation factor (=LGenIdx/LGenNum). Needed to set the startTime and initial burstError differently on the LGens
// The value for each LGen is different (0<=, <1) and it is increased in equal steps.
}
type EPTF_LGenBase_PhaseList_Declarators EPTF_ExecCtrl_DeclarePhaseLists;
type record of EPTF_ExecCtrl_CreateEntityGrp EPTF_ExecCtrl_CreateEntityGrpList;
type record of EPTF_ExecCtrl_DeclareTc EPTF_ExecCtrl_DeclareTcs;
type record EPTF_ExecCtrl_EndOfConfig {
EPTF_DataSource_CT dataSourceCompRef // component reference of the datasource used by execCtrl
}
type record EPTF_ExecCtrl_GuiDone {
boolean guiPresent // true if ExecCtrl GUI is present, false if not
}
type record EPTF_ExecCtrl_ResetScenario {
charstring eGrpName,
charstring scenName
}
type record EPTF_ExecCtrl_ResetStats {
}
type record EPTF_ExecCtrl_ReadyToRun {
}
type record EPTF_ExecCtrl_Bye {
}
type record EPTF_ExecCtrl_ByeAck {
}
type record EPTF_ExecCtrl_SingleShotTc {
charstring eGrpName,
charstring scName,
charstring tcName,
integer eIdx, // relative index of the entity in the entity group (relative to the eGrpOffset)
boolean enableLog // true if logging should be enabled for single-shot
}
type record of EPTF_ExecCtrl_ScenarioTypeList EPTF_ExecCtrl_ScenarioTypeLists;
type record of EPTF_ExecCtrl_NamesInScenario EPTF_ExecCtrl_NamesInScenarioList;
type record EPTF_ExecCtrl_NamesInScenario {
charstring eGrpName,
charstring scTypeName,
EPTF_CharstringList tcNames
}
type record EPTF_ExecCtrl_CreateScenario {
EPTF_LGenBase_ScenarioTypeInternalDeclaratorList scList, // list of latest scenario declarator type
EPTF_ExecCtrl_NamesInScenarioList scNames
}
type EPTF_LGenBase_StatisticListOfTCList EPTF_ExecCtrl_CreateFSMStats;
type record EPTF_ExecCtrlClient_LoadConfig {
EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList pl_EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList,
EPTF_LGenBase_TcMgmt_Scenarios2GrpList pl_EPTF_LGenBase_TcMgmt_Scenarios2GrpList,
EPTF_LGenBase_ScenarioDeclaratorList pl_EPTF_LGenBase_ScenarioDeclaratorList,
EPTF_LGenBase_tcTypeDeclaratorList pl_EPTF_LGenBase_tcTypeDeclaratorList,
EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList pl_EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList,
EPTF_LGenBase_TcMgmt_ScenarioDeclaratorList pl_EPTF_LGenBase_TcMgmt_ScenarioDeclaratorList,
EPTF_LGenBase_TcMgmt_WeightedScenarioDeclaratorList pl_EPTF_LGenBase_TcMgmt_WeightedScenarioDeclaratorList,
EPTF_ExecCtrl_TimeProfileDescrList pl_EPTF_ExecCtrl_TimeProfileDescrList,
EPTF_ExecCtrl_TimeProfileList pl_EPTF_ExecCtrl_TimeProfileList,
EPTF_ExecCtrl_TimeProfile2TcList pl_EPTF_ExecCtrl_TimeProfile2TcList,
EPTF_LGenBase_ScenarioTypeDeclaratorList pl_EPTF_LGenBase_ScenarioTypeDeclaratorList,
EPTF_ExecCtrl_ScenarioInstanceTypeList pl_EPTF_ExecCtrl_ScenarioInstanceTypeList,
EPTF_ExecCtrl_LGenPool_Declarators pl_EPTF_ExecCtrl_LGenPool_Declarators,
EPTF_ExecCtrl_EntityGroup2LGenPool_List pl_EPTF_ExecCtrl_EntityGroup2LGenPool_List,
//EPTF_ExecCtrl_LGenFunction_Entry_List pl_EPTF_ExecCtrl_LGenFunction_Entry_List, // cannot be sent over a test port!
EPTF_LGenBase_PhaseList_Declarators pl_EPTF_ExecCtrl_PhaseList_Declarators,
EPTF_ExecCtrl_ScenarioGroup_Declarators pl_EPTF_ExecCtrl_ScenarioGroup_Declarators,
EPTF_ExecCtrl_RegulatorNames pl_EPTF_ExecCtrl_RegulatorNames,
EPTF_ExecCtrl_RegulatedItems pl_EPTF_ExecCtrl_RegulatedItems,
EPTF_ExecCtrl_EntityGroupDistributionTypeList pl_EPTF_ExecCtrl_EntityGroupDistributionTypeList
}
const EPTF_ExecCtrlClient_LoadConfig c_EPTF_ExecCtrlClient_LoadConfig_default := {
pl_EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList:={},
pl_EPTF_LGenBase_TcMgmt_Scenarios2GrpList:={},
pl_EPTF_LGenBase_ScenarioDeclaratorList:={},
pl_EPTF_LGenBase_tcTypeDeclaratorList:={},
pl_EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList:={},
pl_EPTF_LGenBase_TcMgmt_ScenarioDeclaratorList:={},
pl_EPTF_LGenBase_TcMgmt_WeightedScenarioDeclaratorList:={},
pl_EPTF_ExecCtrl_TimeProfileDescrList:={},
pl_EPTF_ExecCtrl_TimeProfileList:={},
pl_EPTF_ExecCtrl_TimeProfile2TcList:={},
pl_EPTF_LGenBase_ScenarioTypeDeclaratorList:={},
pl_EPTF_ExecCtrl_ScenarioInstanceTypeList:={},
pl_EPTF_ExecCtrl_LGenPool_Declarators:={},
pl_EPTF_ExecCtrl_EntityGroup2LGenPool_List:={},
//pl_EPTF_ExecCtrl_LGenFunction_Entry_List:={},
pl_EPTF_ExecCtrl_PhaseList_Declarators:={},
pl_EPTF_ExecCtrl_ScenarioGroup_Declarators:={},
pl_EPTF_ExecCtrl_RegulatorNames:={},
pl_EPTF_ExecCtrl_RegulatedItems:={},
pl_EPTF_ExecCtrl_EntityGroupDistributionTypeList:={}
}
} // group R3
///////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_Mgmt_PT
//
// Purpose:
// The interface port of EPTF LGenHandler communication
//
// Elements:
// -
// Detailed Comments:
//
///////////////////////////////////////////////////////////
type port EPTF_ExecCtrl_Mgmt_PT message {
inout EPTF_ExecCtrl_StartScenario; // EC ---> ECC/LGen
inout EPTF_ExecCtrl_StopScenario; // EC ---> ECC/LGen
inout EPTF_ExecCtrl_StartTrafficCase; // EC ---> ECC/LGen
inout EPTF_ExecCtrl_StopTrafficCase; // EC ---> ECC/LGen
inout EPTF_ExecCtrl_SingleShotTc; // EC ---> ECC/LGen
inout EPTF_ExecCtrl_UpdateActiveEntities; // EC ---> ECC/LGen
inout EPTF_ExecCtrl_UpdateCps; // EC ---> ECC/LGen
inout EPTF_ExecCtrl_UpdateScenarioCps; // EC ---> ECC/LGen
inout EPTF_ExecCtrl_UpdateStartDelay; // EC ---> ECC/LGen
inout EPTF_ExecCtrlClient_GroupFinished; // EC <--> ECC/LGen
inout EPTF_ExecCtrlClient_PauseTC; // EC ---> ECC/LGen
// R3 Messages:
inout EPTF_ExecCtrl_EntityResourceInfo; // EC <--- ECC/LGen
inout EPTF_ExecCtrl_CreateEntityGrp; // EC ---> ECC/LGen
inout EPTF_ExecCtrl_DeclarePhaseLists; // EC ---> ECC/LGen
inout EPTF_ExecCtrl_CreateEntityGrpList; // EC ---> ECC/LGen
inout EPTF_ExecCtrl_DeclareTcs; // EC ---> ECC/LGen
inout EPTF_ExecCtrl_CreateScenario; // EC ---> ECC/LGen
inout EPTF_ExecCtrl_EndOfConfig; // EC ---> ECC/LGen
inout EPTF_ExecCtrl_CreateFSMStats; // EC <--- ECC/LGen
inout EPTF_ExecCtrl_GuiDone; // EC <--> ECC/LGen
inout EPTF_ExecCtrl_ReadyToRun; // EC <--- ECC/LGen
inout EPTF_ExecCtrl_ResetScenario; // EC ---> ECC/LGen
inout EPTF_ExecCtrl_ResetStats; // EC ---> ECC/LGen
inout EPTF_ExecCtrl_Bye; // EC <--> ECC/LGen
inout EPTF_ExecCtrl_ByeAck; // EC <--> ECC/LGen
inout EPTF_ExecCtrl_EofTest; // EC <--> ECC/LGen
inout EPTF_ExecCtrl_EofTestDone; // EC <-- ECC/LGen
inout EPTF_ExecCtrlClient_LoadConfig; // EC <-- ECC/LGen
// R3 Phase messages
inout EPTF_ExecCtrl_PhaseStartReq;
inout EPTF_ExecCtrl_PhaseStatusRsp;
inout EPTF_ExecCtrl_PhaseStopReq;
inout EPTF_ExecCtrl_PhaseStopTestReq;
inout EPTF_ExecCtrl_PhaseResetReq;
} with {extension "internal"}
} // group
group ToBeDeleted {
///////////////////////////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_UIVars_CPSDatabase
//
// Purpose:
// Alias for <EPTF_IntegerList>
//
// Elements:
// *record of* <EPTF_IntegerList>
//
// Detailed Comments:
// Stores indices for variables subscribet to CPS widgets (scebnario/TC)
//
///////////////////////////////////////////////////////////////////////////////
type record of EPTF_IntegerList EPTF_ExecCtrl_UIVars_CPSDatabase;
/*/////////////////// Traffic cases /////////////
///////////////////////////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_UIVars_TCScenarioState
//
// Purpose:
// Store variable indices for an scenario name, scenario group and
// scenario status
//
// Elements:
// scenName_k - *integer* - index of scenario name
// scenGrp_k - *integer* - index of scenario group
// scenStatus_k - *integer* - index of scenario status
//
// Detailed Comments:
// -
//
///////////////////////////////////////////////////////////////////////////////
type record EPTF_ExecCtrl_UIVars_TCScenarioState {
integer trafficCases_k,
integer startDelay_k,
integer targetCPS_k,
integer enableEntities_k,
integer enable_k
}
///////////////////////////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_UIVars_TCScenarioStateList
//
// Purpose:
// Store a list of <EPTF_ExecCtrl_UIVars_ScenarioState>
//
// Elements:
// *record of* <EPTF_ExecCtrl_UIVars_ScenarioState>
//
// Detailed Comments:
// -
//
///////////////////////////////////////////////////////////////////////////////
type record of EPTF_ExecCtrl_UIVars_TCScenarioState EPTF_ExecCtrl_UIVars_TCScenarioStateList;
///////////////////////////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_UIVars_TrafficCaseScenario
//
// Purpose:
// Store EPTF variable indices for load generator name and corresponding
// scenario information
//
// Elements:
// lgen_k - *integer* - index of the load generator name
// scenStatus - <EPTF_ExecCtrl_UIVars_ScenarioStateList> - scenario information list
//
// Detailed Comments:
// -
//
///////////////////////////////////////////////////////////////////////////////
type record EPTF_ExecCtrl_UIVars_TrafficCaseScenario {
integer scen_k,
EPTF_ExecCtrl_UIVars_TCScenarioStateList tcScenStatus
}
///////////////////////////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_UIVars_TrafficCaseDB
//
// Purpose:
// Scenario database
//
// Elements:
// *record of* <EPTF_ExecCtrl_UIVars_ScenarioLGen>
//
// Detailed Comments:
// This database stores scenario information for all load
// generators and for all scenarios
//
///////////////////////////////////////////////////////////////////////////////
type record of EPTF_ExecCtrl_UIVars_TrafficCaseScenario EPTF_ExecCtrl_UIVars_TrafficCaseDB;
*/
/////////////////////////// Buttons ///////////////////////////////////////////
const charstring c_EPTF_ExecCtrl_Exit := "EPTF_ExecCtrl_Exit";
const charstring c_EPTF_ExecCtrl_Start := "EPTF_ExecCtrl_Start";
const charstring c_EPTF_ExecCtrl_Stop := "EPTF_ExecCtrl_Stop";
const charstring c_EPTF_ExecCtrl_TimeElapsed := "timeElapsed";
const charstring c_EPTF_ExecCtrl_Terminate := "EPTF_ExecCtrl_Terminate";
const charstring c_EPTF_ExecCtrl_Snapshot := "EPTF_ExecCtrl_Snapshot";
} // group ToBeDeleted
// this component calculates the ExecCtrl statistics
type component EPTF_ExecCtrl_StatHandler_CT extends EPTF_StatHandler_CT, EPTF_StatManager_CT {
}
type record of EPTF_StatHandler_CT EPTF_StatHandler_CT_List;
///////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_CT
//
// Purpose:
// The component that implements the EPTF Execution Control
//
// Elements:
// ExecCtrl_MgmtIf_CP - <EPTF_ExecCtrl_Mgmt_PT> - the management port
// v_EPTF_ExecCtrl_defaultAltstep - *default* - reference to the default altstep
// v_ExecCtrl_initialized - *boolean* - prevents multiple init by calling <f_EPTF_ExecCtrl_init> several times
// v_ExecCtrl_nrOfClients - *integer - expected number of ExecCtrlClients
// v_EPTF_ExecCtrl_EntityResourceInfo_Buffer - <EPTF_ExecCtrl_EntityResourceInfo_Buffer> - buffer to store EntityResourceInfo messages before ExecCtrl was started
// v_ExecCtrl_started - *boolean - true after <f_EPTF_ExecCtrl_start> is called: needed by EntityResourceInfo handling before start
// v_ExecCtrl_allLGensCreated - *boolean - true if all LGens are created
// t_ExecCtrl_allLGensCreated - *timer* - semaphore timer to catch the allLGensCreated event
// v_ExecCtrl_readyToRun - *boolean - this is set true, when the readyToRun event occurs (all LGens are ready to run). Can be used in callback handling above ExecCtrl
// v_ExecCtrl_cfgState - *charstring* - state of configuration
// v_ExecCtrl_manualControl - *boolean* - variable to store manual control configuration data
// v_ExecCtrl_EntityGrpDeclarators - <EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList> - variable to store entity group configuration data
// v_ExecCtrl_ScenarioDeclarators - <EPTF_LGenBase_ScenarioDeclaratorList> - variable to store traffic scenario type configuration data
// v_ExecCtrl_tcTypeDeclarators - <EPTF_LGenBase_tcTypeDeclaratorList> - variable to store traffic case type configuration data
// v_ExecCtrl_ScenarioDeclarators2 - <EPTF_LGenBase_TcMgmt_ScenarioDeclaratorList> - variable to store traffic scenario type 2 configuration data
// v_ExecCtrl_tcTypeDeclarators2 - <EPTF_LGenBase_tcTypeDeclaratorList> - variable to store traffic case type 2 configuration data
// v_ExecCtrl_ScenarioDeclarators3 - <EPTF_LGenBase_TcMgmt_WeightedScenarioDeclaratorList> - variable to store weighted scenario type configuration data
// v_ExecCtrl_ScenarioDeclaratorsR3 - <EPTF_LGenBase_ScenarioTypeInternalDeclaratorList> - variable to store traffic scenario type R3 configuration data
//
// v_ExecCtrl_Scenarios2Grps - <EPTF_LGenBase_TcMgmt_Scenarios2GrpList> - variable to store entity group/scenario associations
// v_ExecCtrl_scenario2EntityGroups - <EPTF_ExecCtrl_ScenarioInstanceTypeList> - variable to store entity group/scenario associations with scenario instance names
//
// v_EPTF_ExecCtrl_ScTimeProfileDB - <EPTF_ExecCtrl_ScTimeProfile> - time profile database
// v_EPTF_ExecCtrl_startTime - *float* - time when the start button is pressed
// v_EPTF_ExecCtrl_TimeProfile2TcList - <EPTF_ExecCtrl_TimeProfile2TcList> - time profiles for all tcs
// v_EPTF_ExecCtrl_TimeProfileList - <EPTF_ExecCtrl_TimeProfileList> - the list of time profiles
// v_EPTF_ExecCtrl_TimeProfileDescrList - <EPTF_ExecCtrl_TimeProfileDescrList> - time profiles
//
// v_EPTF_ExecCtrl_RegulatorNames - <EPTF_ExecCtrl_RegulatorNames> - list of the allowed regulator names from configuration data
// v_EPTF_ExecCtrl_RegulatedItemsCFG - <EPTF_ExecCtrl_RegulatedItems> - variable to store the regulated items configuration
// v_EPTF_ExecCtrl_RegulatedItems - <EPTF_ExecCtrl_RegulatedItems> - variable to store the regulated items
// v_EPTF_ExecCtrl_RegulatedItemIdsDB - <EPTF_ExecCtrl_RegulatedItemIds> - parallel database for quick data access
// v_EPTF_ExecCtrl_Regulators - <EPTF_ExecCtrl_Regulators> - database of the regulators
//
// v_EPTF_ExecCtrl_ScenarioGroupPhaseChangedCallbackFns - <EPTF_ExecCtrl_ScenarioGroupPhaseChangedCallbackFns> - container for scenarioGroupPhaseChangeCallback functions
// v_EPTF_ExecCtrl_ScenarioStateChangedCallbackFns - <EPTF_ExecCtrl_ScenarioStateChangedCallbackFns> - container for scenarioStateChangeCallback functions
// v_EPTF_ExecCtrl_TrafficCaseStateChangedCallbackFns - <EPTF_ExecCtrl_TrafficCaseStateChangedCallbackFns> - container for trafficCaseStateChangeCallback functions
// v_EPTF_ExecCtrl_onGroupFinishCallbackFns - <EPTF_ExecCtrl_OnGroupFinishCallbackFns> - container for groupFinishCallback functions
// v_f_EPTF_ExecCtrl_removeStatisticsDependencyOfLGen - <f_EPTF_ExecCtrl_removeStatisticsDependencyOfLGen_FT> - callback for the ExecCtrlUIHandler to remove statistics dependency of an LGen
// v_EPTF_ExecCtrl_finalTestReportGeneratorFns - <EPTF_ExecCtrl_FinalTestReportGeneratorFns> - container for final test report generator functions
// v_EPTF_ExecCtrl_finalTestReport - *charstring* - this collects the final test report string
// v_ExecCtrl_endOfTest - *boolean* - becomes true when end of test is detected and f_EPTF_ExecCtrl_generateFinalTestReport is called
//
// v_EPTF_ExecCtrl_StartStopScenarioDisable - <EPTF_ExecCtrl_StartStopScenarioDisable> - enable/disable start/stop scenario buttons
// v_EPTF_ExecCtrl_StartStopTCDisable - <EPTF_ExecCtrl_StartStopTCDisable> - enable/disable start/stop TC buttons
//
// v_ExecCtrl_loggingMaskId - *integer* - logging component mask ID
//
// v_ExecCtrl_FSMStats - <EPTF_ExecCtrl_CreateFSMStats> - the created FSMStats in all traffic cases
// v_EPTF_ExecCtrl_fsmStatsCreatedCallbackFns - <EPTF_ExecCtrl_FSMStatsCreatedCallbackFns> - The database of FSMStatsCreated callback functions
//
// v_ExecCtrl_tcTypes - <EPTF_ExecCtrl_TcTypeList> - traffic case type db
// v_ExecCtrl_tcTypesHash - *integer* - hash table id for traffic case types
// v_ExecCtrl_scenarioTypes - <EPTF_ExecCtrl_ScenarioTypeList> - scenario type db
// v_ExecCtrl_scenarioTypesHash - *integer* - hash table id for scenario types
//
// v_ExecCtrl_entityGroups - <EPTF_ExecCtrl_EntityGroupList> - entity group instance db
// v_ExecCtrl_entityGroupsHash - *integer* - hash table id for entity group instances
// v_ExecCtrl_entityCounter - *integer* - total number of entities
// v_ExecCtrl_scenarios - <EPTF_ExecCtrl_ScenarioList> - scenario instance db
// v_ExecCtrl_scenariosHash - *integer* - hash table id for scenario instances
// v_ExecCtrl_trafficCases - <EPTF_ExecCtrl_TrafficCaseList> - traffic case instance db
// v_ExecCtrl_trafficCasesHash - *integer* - hash table id for traffic case instances
// v_ExecCtrl_lgens - <EPTF_ExecCtrl_LGenList> - lgen instance db
// v_ExecCtrl_lgensHash - *integer* - hash table id for lgen instances
//
// v_ExecCtrl_pendingMsgCounter - *integer* - number of pending messages
// v_ExecCtrl_pendingByeCounter - *integer* - number of pending bye messages
//
// v_ExecCtrl_PhaseListDeclaratorDB - <EPTF_ExecCtrl_PhaseListDeclaratorDB> - phase list declarator db
// v_ExecCtrl_ScenarioGroupInstanceDB - <EPTF_ExecCtrl_ScenarioGroupInstanceDB> - scenario group instance db
// v_ExecCtrl_PhasePDU - <EPTF_ExecCtrl_PhasePDU> - variable needed for phase handling
//
// v_EPTF_ExecCtrl_lgenCreatorFn_list - <EPTF_ExecCtrl_LGenFunction_Entry_List> - lgen creator function declarators
// v_EPTF_ExecCtrl_LGenPool_Declarators - <EPTF_ExecCtrl_LGenPool_Declarators> - lgen pool declarator db
// v_EPTF_ExecCtrl_EntityGroup2LGenPools - <EPTF_ExecCtrl_EntityGroup2LGenPool_List> - entity group to lgen pool assignement declarator db
// v_EPTF_ExecCtrl_lgenFunctions - <EPTF_ExecCtrl_LGenFunctionList> - lgen creator function db
// v_EPTF_ExecCtrl_lgenFunctionsHash - *integer* - hash table id for lgen creator functions
// v_EPTF_ExecCtrl_lgenPools - <EPTF_ExecCtrl_LGenPoolList> - lgen pool instance db
// v_EPTF_ExecCtrl_lgenPoolsHash - *integer* - hash table id for lgen pool instances
// v_EPTF_ExecCtrl_lgenPoolCompRefHash - *integer* - hash table id for lgen pool component references
//
// v_EPTF_ExecCtrl_entityGroupDistributionCFG - <EPTF_ExecCtrl_EntityGroupDistributionTypeList> - the entity group distribution configuration
// v_EPTF_ExecCtrl_entityGroupDistribution - <EPTF_ExecCtrl_EntityGroupDistributionTypeList> - the entity group distribution database
//
// v_ExecCtrl_regulatedItemsHash - *integer* - hash table id for regulated items
// v_ExecCtrl_dataSourceCompRef - <EPTF_DataSource_CT> - DataSource component reference
//
// v_ExecCtrl_progressBarUIHandler_Idx - *integer* - UIhandler progressBar variable idx
//
// Detailed Comments:
//
//
///////////////////////////////////////////////////////////
type component EPTF_ExecCtrl_CT extends EPTF_Base_CT, EPTF_Scheduler_CT, EPTF_Var_CT, EPTF_Logging_CT, EPTF_StatMeasure_CT,
EPTF_ExecCtrl_StatHandler_CT, EPTF_StatHandlerClient_CT, EPTF_DataSourceClient_CT, EPTF_HashMap_CT, EPTF_FBQ_CT
{
private var boolean v_ExecCtrl_initialized := false; // prevents multiple init by calling <f_EPTF_ExecCtrl_init> several times
private var integer v_ExecCtrl_nrOfClients := 0;
private var EPTF_ExecCtrl_EntityResourceInfo_Buffer v_EPTF_ExecCtrl_EntityResourceInfo_Buffer := {}; // buffer to store EntityResourceInfo messages before ExecCtrl was started
private var boolean v_ExecCtrl_started := false; // true after <f_EPTF_ExecCtrl_start> is called: needed by EntityResourceInfo handling before start
private var boolean v_ExecCtrl_allLGensCreated := false; // true if all LGens are created
private timer t_ExecCtrl_allLGensCreated := 0.0; // semaphore for allLGensCreated
// variables for event handling:
private var boolean v_ExecCtrl_readyToRun := false; // this is set true, when the readyToRun event occurs (all LGens are ready to run). Can be used in callback handling above ExecCtrl
// by the time it is true all varibles had been created, and subscribes had been done for variables in all ExecCtrlClients
private var charstring v_ExecCtrl_cfgState := c_ExecCtrl_Cfg_WAITFOR_INIT;
private port EPTF_ExecCtrl_Mgmt_PT ExecCtrl_MgmtIf_CP; // management interface
private var default v_EPTF_ExecCtrl_defaultAltstep := null;
private var EPTF_ExecCtrl_ScTimeProfile v_EPTF_ExecCtrl_ScTimeProfileDB := {}; // database for cps time profiles
private var float v_EPTF_ExecCtrl_startTime := -1.0; // time when the start button is pressed (-1 is used when timeProfiles are stopped)
// Assign config params to component variables
private var boolean v_ExecCtrl_manualControl := tsp_ExecCtrl_manualControl;
private var EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList v_ExecCtrl_EntityGrpDeclarators := {};//tsp_LGenBase_EntityGrpDeclarators;
private var EPTF_LGenBase_TcMgmt_Scenarios2GrpList v_ExecCtrl_Scenarios2Grps := {};//tsp_LGenBase_Scenarios2Grps;
private var EPTF_ExecCtrl_ScenarioInstanceTypeList v_ExecCtrl_scenario2EntityGroups:= {};//tsp_EPTF_ExecCtrl_Scenario2EntityGroupList;
private var EPTF_LGenBase_ScenarioDeclaratorList v_ExecCtrl_ScenarioDeclarators := {};//tsp_LGenBase_ScenarioDeclarators;
private var EPTF_LGenBase_tcTypeDeclaratorList v_ExecCtrl_tcTypeDeclarators := {};//tsp_LGenBase_tcTypeDeclarators;
// Declarator2
private var EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList v_ExecCtrl_tcTypeDeclarators2 := {};//tsp_LGenBase_TcMgmt_tcTypeDeclarators2;
private var EPTF_LGenBase_TcMgmt_ScenarioDeclaratorList v_ExecCtrl_ScenarioDeclarators2 := {};//tsp_LGenBase_TcMgmt_ScenarioDeclarators2;
// Declarator3
private var EPTF_LGenBase_TcMgmt_WeightedScenarioDeclaratorList v_ExecCtrl_ScenarioDeclarators3 := {};//tsp_LGenBase_TcMgmt_WeightedScenarioDeclarators;
// Declarator R3
private var EPTF_LGenBase_ScenarioTypeDeclaratorList v_ExecCtrl_ScenarioDeclaratorsR3 := {};//tsp_LGenBase_TcMgmt_ScenarioDeclarators3;
private var EPTF_ExecCtrl_TimeProfile2TcList v_EPTF_ExecCtrl_TimeProfile2TcList := {};//tsp_EPTF_ExecCtrl_TimeProfile2TcList;
private var EPTF_ExecCtrl_TimeProfileList v_EPTF_ExecCtrl_TimeProfileList := {};//tsp_EPTF_ExecCtrl_TimeProfileList;
private var EPTF_ExecCtrl_TimeProfileDescrList v_EPTF_ExecCtrl_TimeProfileDescrList := {};//tsp_EPTF_ExecCtrl_TimeProfileDescrList;
// Regulator:
private var EPTF_ExecCtrl_RegulatorNames v_EPTF_ExecCtrl_RegulatorNames := {};//tsp_EPTF_ExecCtrl_RegulatorNames; // list of the allowed regulator names
private var EPTF_ExecCtrl_RegulatedItems v_EPTF_ExecCtrl_RegulatedItemsCFG := {};//tsp_EPTF_ExecCtrl_RegulatedItems;
private var EPTF_ExecCtrl_RegulatedItems v_EPTF_ExecCtrl_RegulatedItems := {};
private var EPTF_ExecCtrl_RegulatedItemIds v_EPTF_ExecCtrl_RegulatedItemIdsDB := {}; // parallel database for quick data access
private var EPTF_ExecCtrl_Regulators v_EPTF_ExecCtrl_Regulators := {};
// scenarioGroup phaseChange callbacks:
private var EPTF_ExecCtrl_ScenarioGroupPhaseChangedCallbackFns v_EPTF_ExecCtrl_ScenarioGroupPhaseChangedCallbackFns := {}
// scenario stateChange callbacks:
private var EPTF_ExecCtrl_ScenarioStateChangedCallbackFns v_EPTF_ExecCtrl_ScenarioStateChangedCallbackFns := {};
// trafficCase stateChange callbacks:
private var EPTF_ExecCtrl_TrafficCaseStateChangedCallbackFns v_EPTF_ExecCtrl_TrafficCaseStateChangedCallbackFns := {};
// groupFinishCallbacks:
private var EPTF_ExecCtrl_OnGroupFinishCallbackFns v_EPTF_ExecCtrl_onGroupFinishCallbackFns := {};
// callback for the ExecCtrlUIHandler to remove statistics dependency of an LGen:
private var f_EPTF_ExecCtrl_removeStatisticsDependencyOfLGen_FT v_f_EPTF_ExecCtrl_removeStatisticsDependencyOfLGen := null;
// FinalTestReportGenerator callbacks:
private var EPTF_ExecCtrl_FinalTestReportGeneratorFns v_EPTF_ExecCtrl_finalTestReportGeneratorFns := {};
private var charstring v_EPTF_ExecCtrl_finalTestReport := ""; // this collects the final test report string
private var boolean v_ExecCtrl_endOfTest := false; // becomes true when end of test is detected and f_EPTF_ExecCtrl_generateFinalTestReport is called
// scenario start/stop enable:
private var EPTF_ExecCtrl_StartStopScenarioDisable v_EPTF_ExecCtrl_StartStopScenarioDisable := {};//tsp_EPTF_ExecCtrl_StartStopScenarioDisable;
private var EPTF_ExecCtrl_StartStopTCDisable v_EPTF_ExecCtrl_StartStopTCDisable := {};//tsp_EPTF_ExecCtrl_StartStopTCDisable;
// logging
private var integer v_ExecCtrl_loggingMaskId := c_EPTF_Logging_invalidMaskId;
// FSMStats:
private var EPTF_ExecCtrl_CreateFSMStats v_ExecCtrl_FSMStats := {};
private var EPTF_ExecCtrl_FSMStatsCreatedCallbackFns v_EPTF_ExecCtrl_fsmStatsCreatedCallbackFns := {};
private var boolean v_ExecCtrl_processingCreateFSMStats := false; // flag to prevent simultaneous processing of createFSMStats (that would cause long callstack and increased memory usage)
// EPTF R3 TypeDB
private var EPTF_ExecCtrl_TcTypeList v_ExecCtrl_tcTypes := {};
private var integer v_ExecCtrl_tcTypesHash := c_ExecCtrl_invalidIdx;
private var EPTF_ExecCtrl_ScenarioTypeList v_ExecCtrl_scenarioTypes := {};
private var integer v_ExecCtrl_scenarioTypesHash := c_ExecCtrl_invalidIdx;
// EPTF R3 InstanceDB
private var EPTF_ExecCtrl_EntityGroupList v_ExecCtrl_entityGroups := {};
private var integer v_ExecCtrl_entityCounter := 0;
private var integer v_ExecCtrl_entityGroupsHash := c_ExecCtrl_invalidIdx;
private var EPTF_ExecCtrl_ScenarioList v_ExecCtrl_scenarios := {};
private var integer v_ExecCtrl_scenariosHash := c_ExecCtrl_invalidIdx;
private var EPTF_ExecCtrl_TrafficCaseList v_ExecCtrl_trafficCases := {};
private var integer v_ExecCtrl_trafficCasesHash := c_ExecCtrl_invalidIdx;
private var EPTF_ExecCtrl_LGenList v_ExecCtrl_lgens := {}
private var integer v_ExecCtrl_lgensHash := c_ExecCtrl_invalidIdx;
private var integer v_ExecCtrl_pendingMsgCounter := 0;
private var integer v_ExecCtrl_pendingByeCounter := 0;
// EPTF R3 Phases
private var EPTF_LGenBase_PhaseList_Declarators v_EPTF_ExecCtrl_PhaseList_Declarators := {};//tsp_EPTF_ExecCtrl_PhaseList_Declarators;
private var EPTF_ExecCtrl_ScenarioGroup_Declarators v_EPTF_ExecCtrl_ScenarioGroup_Declarators := {};//tsp_EPTF_ExecCtrl_ScenarioGroup_Declarators;
private var EPTF_ExecCtrl_PhaseListDeclaratorDB v_ExecCtrl_PhaseListDeclaratorDB := c_ExecCtrl_PhaseListDeclaratorDB_initValue;
private var EPTF_ExecCtrl_ScenarioGroupInstanceDB v_ExecCtrl_ScenarioGroupInstanceDB := c_ExecCtrl_ScenarioGroupInstanceDB_initValue;
private var EPTF_ExecCtrl_PhasePDU v_ExecCtrl_PhasePDU;
// EPTF_ R3 LGenPools
// LGenPool declarators:
private var EPTF_ExecCtrl_LGenFunction_Entry_List v_EPTF_ExecCtrl_lgenCreatorFn_list := {}; // "declarators"
private var EPTF_ExecCtrl_LGenPool_Declarators v_EPTF_ExecCtrl_LGenPool_Declarators := {};//tsp_EPTF_ExecCtrl_LGenPool_Declarators;
private var EPTF_ExecCtrl_EntityGroup2LGenPool_List v_EPTF_ExecCtrl_EntityGroup2LGenPools := {};//tsp_EPTF_ExecCtrl_EntityGroup2LGenPool_List;
// LGenPool InstanceDB:
private var EPTF_ExecCtrl_LGenFunctionList v_EPTF_ExecCtrl_lgenFunctions := {};
private var integer v_EPTF_ExecCtrl_lgenFunctionsHash := c_ExecCtrl_invalidIdx;
private var EPTF_ExecCtrl_LGenPoolList v_EPTF_ExecCtrl_lgenPools := {};
private var integer v_EPTF_ExecCtrl_lgenPoolsHash := c_ExecCtrl_invalidIdx;
private var integer v_EPTF_ExecCtrl_lgenPoolCompRefHash := c_ExecCtrl_invalidIdx;
//EntityGroupDistribution:
private var EPTF_ExecCtrl_EntityGroupDistributionTypeList v_EPTF_ExecCtrl_entityGroupDistributionCFG := {}; // tsp_EPTF_ExecCtrl_EntityGroupDistributionDeclarators
// instanceDB
private var EPTF_ExecCtrl_EntityGroupDistributionTypeList v_EPTF_ExecCtrl_entityGroupDistribution := {};
private var EPTF_ExecCtrl_timeFormat v_EPTF_ExecCtrl_timeFormat := tsp_EPTF_ExecCtrl_timeFormat;
/*var EPTF_ExecCtrl_UIVars_TrafficCaseDB vg_EPTF_ExecCtrl_UIVars_TrafficCaseDB*/
private var EPTF_ExecCtrl_UIVars_CPSDatabase vg_ExecCtrl_UIVars_cpsDB;
private var integer v_ExecCtrl_regulatedItemsHash := c_ExecCtrl_invalidIdx;
private var EPTF_DataSource_CT v_ExecCtrl_dataSourceCompRef := null;
private var integer v_ExecCtrl_progressBarUIHandler_Idx := -1;// UIHandler progressBar variable idx
private var boolean v_ExecCtrl_progressEnabled := true; // enable updating of UIHandler progressbar
private var integer v_ExecCtrl_nrOfExpectedClients := -1;
private var boolean v_EPTF_ExecCtrl_generateOwnReport := false;
private var boolean v_ExecCtrl_progressBarUIHandler_updateSent := false; // true if progress sent: prevent too many progress info
// {Delta statistics}: Time period when delta stats are refreshed.
private var float v_EPTF_ExecCtrl_timePeriodForTcDeltaStats := 3.0;
private var integer vl_eventIndexUpdateEvent := -1; // update event idx for delta statistics
// TR HQ88308 - Sampled & sync variables on old GUI for refresh
private var EPTF_IntegerList v_EPTF_ExecCtrl_SampledAtSync_vars := {};
private var EPTF_StatHandler_CT_List v_EPTF_ExecCtrl_statHandler_comprefList := {};
private var integer v_EPTF_ExecCtrl_nofExternalStatHandlers := 0; // if 0: use ExecCtrl as StatHandler, otherwise create StatHandlers dynamically
private var integer v_EPTF_ExecCtrl_statHandler_autoSelector := 0; // the selected external statHandler index will be determined by `autoSelector mod nofExternalStatHandlers`
private var integer v_ExecCtrl_statHandlerHash := c_ExecCtrl_invalidIdx; // hashmap to store the statHandler compRefs for the statistics
private var boolean v_ExecCtrl_usePullModeForStats := false; // if true pull mode is used for StatHandler statistics calculation
}
const charstring c_ExecCtrl_regulatedItemsHashMapName := "ExecCtrl_regulatedItemsHashMapName";
const charstring c_ExecCtrl_statHandlerHashMapName := "ExecCtrl_statHandlerHashMapName";
type function f_EPTF_ExecCtrlClient_scenarioInitialized_fcb_FT(in EPTF_LGenBase_Scenario2Grp pl_scenario) runs on self;
type function EPTF_ExecCtrlClient_EndOfConfigCallbackFn() runs on self;
type record of EPTF_ExecCtrlClient_EndOfConfigCallbackFn EPTF_ExecCtrlClient_EndOfConfigCallbackFns;
type function EPTF_ExecCtrlClient_GuiDoneCallbackFn() runs on self;
type record of EPTF_ExecCtrlClient_GuiDoneCallbackFn EPTF_ExecCtrlClient_GuiDoneCallbackFns;
const charstring c_ExecCtrlClient_eGrpHashMapName := "ExecCtrlClient_eGrpHashMapName";
type function f_EPTF_ExecCtrl_removeStatisticsDependencyOfLGen_FT(in integer pl_lgenIdx) runs on self;
type function EPTF_ExecCtrl_FSMStatsCreatedCallbackFn(in EPTF_ExecCtrl_CreateFSMStats pl_createFSMStats) runs on self;
type record of EPTF_ExecCtrl_FSMStatsCreatedCallbackFn EPTF_ExecCtrl_FSMStatsCreatedCallbackFns;
type record EPTF_ExecCtrlClient_PauseData {
boolean pausing, // pause in progress, waiting pause to finish
EPTF_ExecCtrl_GrpFinishConditionType groupFinishConditionType, // condition type of the group finish condition
EPTF_LGenBase_ConditionTrue groupFinishedDetected // only continue when all detected thresholds have been updated
}
const EPTF_ExecCtrlClient_PauseData c_EPTF_ExecCtrlClient_PauseData_default := {
false,
c_EPTF_ExecCtrl_groupFinishConditionUnknown,
c_EPTF_LGenBase_emptyConditionTrue
}
type record of EPTF_ExecCtrlClient_PauseData EPTF_ExecCtrlClient_PauseDataForTCs; // indexed by TcIdx
///////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrlClient_CT
//
// Purpose:
// The component that implements the EPTF ExecCtrl client
//
// Elements:
// ExecCtrl_MgmtIf_CP - <EPTF_ExecCtrl_Mgmt_PT> - the management port
// vl_EPTF_ExecCtrlClient_def - *default* - default altstep
// v_ExecCtrlClient_initialized - *boolean* - prevents multiple init by calling <f_EPTF_ExecCtrlClient_init> several times
// v_ExecCtrl_execCtrlMasterCompRef - <EPTF_ExecCtrl_CT> - the component reference of the EPTF_ExecCtrl component instance
// v_ExecCtrlClient_scenarioInitialized_fcb - <f_EPTF_ExecCtrlClient_scenarioInitialized_fcb_FT> - this function is called when the EPTF_ExecCtrl_AddScenarioToEntityGroup is received (scenario initialized)
// v_ExecCtrlClient_semaphore_DeclareScenario - *integer* - semaphore for all scenarios declared
// v_ExecCtrlClient_semaphore_EndOfConfig - *boolean* - semaphore for receiving the EndOfConfig message
// v_ExecCtrlClient_EndOfConfigCallbackFns - <EPTF_ExecCtrlClient_EndOfConfigCallbackFns> - list of functions that are called when the configuration of the client is finished
// v_ExecCtrlClient_GuiDoneCallbackFns - <EPTF_ExecCtrlClient_GuiDoneCallbackFns> - list of functions that are called when the ExecCtrl Gui is ready
// v_EPTF_ExecCtrlClient_GuiDoneCallbackFn - <EPTF_ExecCtrlClient_GuiDoneCallbackFn> - stores the f_ExecCtrlClient_UIVars_bindFSMStatsToWidget if exists
// v_EPTF_ExecCtrlClient_guiPresent - *boolean* - true of ExecCtrl GUI is present, false if not
// v_EPTF_ExecCtrlClient_guiDone - *boolean* - semaphore for receiving the GUIDone message
// v_EPTF_ExecCtrlClient_autoReportGuiDone - *boolean* - when false, the GUIDone event has to be reported to ExecCtrl manually by <f_EPTF_ExecCtrlClient_reportGUIDone>
// v_EPTF_ExecCtrlClient_guiDoneReported - *boolean* - set to true when client reported GUIDone towards ExecCtrl
// v_ExecCtrlClient_LGenBase_groupFinishedDetectedFn - <EPTF_LGenBase_groupFinishedDetected_FT> - the original value of v_LGenBase_groupFinishedDetectedFn
// v_EPTF_ExecCtrlClient_finalTestReportGeneratorFns - <EPTF_ExecCtrl_FinalTestReportGeneratorFns> - list of functions thar are called when the end of test is detected to generate final test report
// v_ExecCtrlClient_started - *boolean* - true if <f_EPTF_ExecCtrlClient_readyToStart> is called: needed by <f_EPTF_ExecCtrlClient_loadConfig>
// v_ExecCtrlClient_byeAckReceived - *boolean* - true if byeAck is received: needed be cleanup
// v_ExecCtrlClient_byeReceived - *boolean* - true if bye is received: needed be cleanup (no bye after this)
// v_ExecCtrlClient_loggingMaskId - *integer* - logging component mask ID
//
// Detailed Comments:
// To use the EPTF execution control functionality on an LGen,
// extend your client component with <EPTF_ExecCtrlClient_CT>
//
///////////////////////////////////////////////////////////
type component EPTF_ExecCtrlClient_CT extends EPTF_LGenBase_CT, EPTF_LGenBaseStats_CT, EPTF_Logging_CT {
private var boolean v_ExecCtrlClient_initialized := false; // prevents multiple init by calling <f_EPTF_ExecCtrlClient_init_CT> several times
private var EPTF_ExecCtrl_CT v_ExecCtrl_execCtrlMasterCompRef := null;
private port EPTF_ExecCtrl_Mgmt_PT ExecCtrlClient_MgmtIf_CP;
private var default vl_EPTF_ExecCtrlClient_def := null; // default altstep
private var f_EPTF_ExecCtrlClient_scenarioInitialized_fcb_FT v_ExecCtrlClient_scenarioInitialized_fcb := null; // this function is called when the EPTF_ExecCtrl_AddScenarioToEntityGroup is received (scenario initialized)
private var integer v_ExecCtrlClient_semaphore_DeclareScenario := 0; // semaphore for all scenarios declared:
private timer t_EPTF_ExecCtrlClient_semaphoreTimer := 0.0;
// used to prevent readyToRun from being sent before all scenarios created (callbacks can block execution during endOFConfig is received!!!)
private var boolean v_ExecCtrlClient_semaphore_EndOfConfig := false; // semaphore for receiving the EndOfConfig message
private var boolean v_EPTF_ExecCtrlClient_guiPresent := false; //true of ExecCtrl GUI is present, false if not
private var boolean v_EPTF_ExecCtrlClient_guiDone := false; // semaphore for receiving the GUIDone message, set to true when the creation of the gui is finished.
private var boolean v_EPTF_ExecCtrlClient_autoReportGuiDone := true; // when false, the GUIDone event has to be reported to ExecCtrl manually by <f_EPTF_ExecCtrlClient_reportGUIDone>
private var boolean v_EPTF_ExecCtrlClient_guiDoneReported := false; // set to true when client reported GUIDone towards ExecCtrl
// entity group database:
private var integer v_EPTF_ExecCtrlClient_eGrpHash := c_ExecCtrl_invalidIdx;
// stores the EndOfConfig callback functions:
private var EPTF_ExecCtrlClient_EndOfConfigCallbackFns v_ExecCtrlClient_EndOfConfigCallbackFns := {};
// stores the GuiDone callback functions:
private var EPTF_ExecCtrlClient_GuiDoneCallbackFns v_ExecCtrlClient_GuiDoneCallbackFns := {};
private var EPTF_ExecCtrlClient_GuiDoneCallbackFn v_EPTF_ExecCtrlClient_GuiDoneCallbackFn := null; // stores the f_ExecCtrlClient_UIVars_bindFSMStatsToWidget if exists
// var EPTF_LGenBase_groupFinished_FT v_ExecCtrlClient_LGenBase_groupFinishedFn := null; // the original value of v_LGenBase_groupFinishedFn
private var EPTF_LGenBase_GroupFinishedDetected_FT v_ExecCtrlClient_LGenBase_groupFinishedDetectedFn := null; // the original value of v_LGenBase_groupFinishedDetectedFn
private var boolean v_ExecCtrlClient_abortNextGroupFinish := true; // f_EPTF_ExecCtrlClient_groupFinishedDetectedFn will abort the next group finish if this var is true
private var EPTF_ExecCtrlClient_PauseDataForTCs v_ExecCtrlClient_pauseDataForTCs := {}; // indexed by LGenBase tcIdx, and gives true if ExecCtrl requested pause for the traffic case
// FinalTestReportGenerator callbacks:
private var EPTF_ExecCtrl_FinalTestReportGeneratorFns v_EPTF_ExecCtrlClient_finalTestReportGeneratorFns := {};
private var boolean v_ExecCtrlClient_started := false; // true if <f_EPTF_ExecCtrlClient_readyToStart> is called: needed by <f_EPTF_ExecCtrlClient_loadConfig>
private var boolean v_ExecCtrlClient_byeAckReceived := false; // true if byeAck is received: needed by cleanup
private var boolean v_ExecCtrlClient_byeReceived := false; // true if bye is received: needed be cleanup (no bye after this)
// logging
private var integer v_ExecCtrlClient_loggingMaskId := c_EPTF_Logging_invalidMaskId;
// R3 phase handling
private var EPTF_ExecCtrl_PhasePDU v_ExecCtrlClient_PhasePDU;
}
///////////////////////////////////////////////////////////
// Constant: c_EPTF_ExecCtrl_loggingEventClasses
//
// Purpose:
// list of logging event class names used on the ExecCtrl
//
// Detailed Comments:
// <EPTF_Logging_EventClassPrefixList> { "Warning", "Debug" }
///////////////////////////////////////////////////////////
const EPTF_Logging_EventClassPrefixList c_EPTF_ExecCtrl_loggingEventClasses := { "Warning", "Debug" };
///////////////////////////////////////////////////////////
// Constant: c_EPTF_ExecCtrl_loggingClassIdx_Warning
//
// Purpose:
// logging class index for Error
//
// Detailed Comments:
// *0*
///////////////////////////////////////////////////////////
const integer c_EPTF_ExecCtrl_loggingClassIdx_Warning := 0;
///////////////////////////////////////////////////////////
// Constant: c_EPTF_ExecCtrl_loggingClassIdx_Debug
//
// Purpose:
// logging class index for Error
//
// Detailed Comments:
// *1*
///////////////////////////////////////////////////////////
const integer c_EPTF_ExecCtrl_loggingClassIdx_Debug := 1;
// EPTF R3
/*
group EPTF_ExecCtrl_LGenPools {
///////////////////////////////////////
// configuration
type record EPTF_ExecCtrl_LGenPoolCfg {
charstring name,
charstring creatorFunction,
EPTF_ExecCtrl_LGenDistributionCfgList distribution
}
type record of EPTF_ExecCtrl_LGenPoolCfg EPTF_ExecCtrl_LGenPoolCfgList;
type record EPTF_ExecCtrl_LGenDistributionCfg {
charstring host,
integer count
}
type record of EPTF_ExecCtrl_LGenDistributionCfg EPTF_ExecCtrl_LGenDistributionCfgList;
///////////////////////////////////////
// internal database
type record EPTF_ExecCtrl_LGenInsance {
charstring name,
integer poolBackref,
EPTF_ExecCtrlClient_CT compRef,
// fixme: resource availablility/usage
}
type record of EPTF_ExecCtrl_LGenInsance EPTF_ExecCtrl_LGenList;
type record EPTF_ExecCtrl_LGenPool {
charstring name,
EPTF_IntegerList lgenIdxs
}
type function EPTF_ExecCtrl_CreateLGen_FT(
in charstring pl_hostname,
in charstring pl_compName)
runs on self
return EPTF_ExecCtrlClient_CT;
type union EPTF_ExecCtrl_RegisteredFuncitons {
EPTF_ExecCtrl_CreateLGen_FT lgenCreatorFn
}
// note: references shall be stored in an str2int hashmap
type record of EPTF_ExecCtrl_RegisteredFuncitons EPTF_ExecCtrl_RegisteredFuncitonsList;
} // group EPTF_ExecCtrl_LGenPools
*/
// ~EPTF R3
group EPTF_ExecCtrl_FinalTestReport {
///////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_FinalTestReportGenerator_FT
//
// Purpose:
// function type of the final test report generator function
//
// Parameters:
// pl_report - *inout charstring* - the report
//
// Return Value:
// -
//
// Detailed Comments:
// These type of functions can be registered in ExecCtrl and in ExecCtrlClients
// The generated report strings are concatenated into a big string and written into a file.
//
///////////////////////////////////////////////////////////
type function EPTF_ExecCtrl_FinalTestReportGenerator_FT(inout charstring pl_report) runs on self;
///////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_FinalTestReportGeneratorFns
//
// Purpose:
// List of <EPTF_ExecCtrl_FinalTestReportGenerator_FT>-s
//
//
///////////////////////////////////////////////////////////
type record of EPTF_ExecCtrl_FinalTestReportGenerator_FT EPTF_ExecCtrl_FinalTestReportGeneratorFns;
// end of test notification message
type record EPTF_ExecCtrl_EofTest {}
// end of test done message contaning the report
type record EPTF_ExecCtrl_EofTestDone {
charstring report
}
}
group EPTF_ExecCtrl_LGenPools
{
// Declarators
///////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_CreateLGen_FT
//
// Purpose:
// function type for the LGen creator function used when the LGen pools are created.
//
// Parameters:
// pl_hostname - *charstring* - name of the host where the LGen should be created
// pl_componentName - *charstring* - name of created LGen component (selfname)
// pl_ExecCtrl - <EPTF_ExecCtrl_CT> - reference to the ExecCtrl component
//
// Return Value:
// - <EPTF_ExecCtrlClient_CT> - reference to the created component, null if creation failed
//
// Detailed Comments:
// The created component shall extend <EPTF_ExecCtrlClient_CT>
//
///////////////////////////////////////////////////////////
type function EPTF_ExecCtrl_CreateLGen_FT
(
in charstring pl_hostname,
in charstring pl_componentName
)
runs on self // but should extend EPTF_ExecCtrl_CT at least
return EPTF_ExecCtrlClient_CT;
///////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_LGenPoolItem
//
// Purpose:
// Defines one item in the LGen pool declarator
//
// Elements:
// hostname - *charstring* - name of the host where the LGen should be created
// num - *integer* - number of LGens that will be created on this host
// createFunctionName - *charstring* - name of the creator function
//
// Return Value:
//
// Detailed Comments:
// The creator function shall be registered in <f_EPTF_ExecCtrl_LGenFunctions_addFromDeclarators>
//
///////////////////////////////////////////////////////////
type record EPTF_ExecCtrl_LGenPoolItem
{
charstring hostname,
integer num,
charstring createFunctionName // name of a function with type <EPTF_ExecCtrl_CreateLGen_FT>
}
///////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_LGenPoolItems
//
// Purpose:
// List of <EPTF_ExecCtrl_LGenPoolItem>
//
// Detailed Comments:
// used in <EPTF_ExecCtrl_LGenPool_Declarator>
//
///////////////////////////////////////////////////////////
type record of EPTF_ExecCtrl_LGenPoolItem EPTF_ExecCtrl_LGenPoolItems;
///////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_LGenPool_Declarator
//
// Purpose:
// Type of one LGenPool declarator
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
type record EPTF_ExecCtrl_LGenPool_Declarator
{
charstring name,
EPTF_ExecCtrl_LGenPoolItems lgenPoolItems
}
///////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_LGenPool_Declarators
//
// Purpose:
// Type of one LGenPool declarators module par <tsp_EPTF_ExecCtrl_LGenPool_Declarators>
//
// Elements:
// List of <EPTF_ExecCtrl_LGenPool_Declarator>
//
///////////////////////////////////////////////////////////
type record of EPTF_ExecCtrl_LGenPool_Declarator EPTF_ExecCtrl_LGenPool_Declarators; // TSP
const charstring c_ExecCtrl_lgenPoolsHashMapName := "ExecCtrl_lgenPoolsHashMap";
const charstring c_ExecCtrl_lgenPoolCompRefHashMapName := "ExecCtrl_lgenPoolCompRefHashMapName";
///////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_EntityGroup2LgenPool
//
// Purpose:
// Type to assign an LGenPool to one or more entity groups.
//
// Elements:
// - eGroupName -*charstring* - name of entityGroup
// - lgenPool - *charstring* - name of the LGen pool this entry corresponds
//
// Detailed Comments:
// -
///////////////////////////////////////////////////////////
type record EPTF_ExecCtrl_EntityGroup2LgenPool {
charstring eGrpName, // name of entityGroup
charstring lgenPoolName // name of the LGen pool this entry corresponds
}
///////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_EntityGroup2LGenPool_List
//
// Purpose:
// List of <EPTF_ExecCtrl_EntityGroup2LgenPool>.
//
// Elements:
//
// Detailed Comments:
// -
///////////////////////////////////////////////////////////
type record of EPTF_ExecCtrl_EntityGroup2LgenPool EPTF_ExecCtrl_EntityGroup2LGenPool_List; // TSP
// instance Database
///////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_LGenPool
//
// Purpose:
// Type of an LGen pool instance
//
// Elements:
// name - *charstring* - name of the LGen pool
// lgens - <EPTF_IntegerList> - index into EPTF_ExecCtrl_LGenList
// lgenPoolItems - <EPTF_ExecCtrl_LGenPoolItems> - data from the declarator
//
// Detailed Comments:
// -
///////////////////////////////////////////////////////////
type record EPTF_ExecCtrl_LGenPool {
charstring name, // name of the LGen pool
EPTF_IntegerList lgens, // index into EPTF_ExecCtrl_LGenList
EPTF_ExecCtrl_LGenPoolItems lgenPoolItems // data from the declarator
}
///////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_LGenPoolList
//
// Purpose:
// Type of the LGen pool instance DB
//
// Elements:
// list of <EPTF_ExecCtrl_LGenPool>
//
// Detailed Comments:
// -
///////////////////////////////////////////////////////////
type record of EPTF_ExecCtrl_LGenPool EPTF_ExecCtrl_LGenPoolList; // LGenPool instance DB
// LGenFunction
///////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_LGenFunction_Entry
//
// Purpose:
// Defines the type of the LGen Creator function declarator.
//
// Elements:
// name - *charstring optional* - name to associate to this function
// fn - <EPTF_ExecCtrl_CreateLGen_FT> - the LGen creator function to register
//
// Detailed Comments:
// Note, that the name is optional. If the
// name is not specified, the function is registered with the
// auto-generated name only. The automatic name is generated in the format:
// ModuleName.FunctionName, where ModuleName is the TTCN3 module that
// contains the function, and FunctionName is the name of the
// registered function. This autogenerated name can always be used
// to identify the function (in the <tsp_EPTF_ExecCtrl_LGenPool_Declarators>),
// but if the name is specified, the function can be found by using the specified name too.
///////////////////////////////////////////////////////////
type record EPTF_ExecCtrl_LGenFunction_Entry
{
charstring name optional,
EPTF_ExecCtrl_CreateLGen_FT fn
}
///////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_LGenFunction_Entry_List
//
// Purpose:
// List of LGen creator functions
//
// Elements:
// list of <EPTF_ExecCtrl_LGenFunction_Entry>
//
// Detailed Comments:
// This type is used to define the list of LGen creator functions
// to register into ExecCtrl
///////////////////////////////////////////////////////////
type record of EPTF_ExecCtrl_LGenFunction_Entry EPTF_ExecCtrl_LGenFunction_Entry_List;
///////////////////////////////////////////////////////////
// Type: EPTF_ExecCtrl_LGenFunctionList
//
// Purpose:
// Type of the LGen creator function instance DB
//
// Elements:
// list of <EPTF_ExecCtrl_CreateLGen_FT>
//
// Detailed Comments:
// This type is used to define the list of LGen creator functions
// to register into ExecCtrl
///////////////////////////////////////////////////////////
type record of EPTF_ExecCtrl_CreateLGen_FT EPTF_ExecCtrl_LGenFunctionList; // LGenPool EPTF_ExecCtrl_CreateLGen_FT DB
const charstring c_EPTF_ExecCtrl_LGenFunctionsDB_HashName := "EPTF_ExecCtrl_LGenFunctionsDB_Hash";
} // group EPTF_ExecCtrl_LGenPools
///////////////////////////////////////////////////////////
// Group: EPTF_ExecCtrl_DataSource
//
// Purpose:
// Grouping data types for the ExecCtrl DataSource.
// This group contains the list of iterator names,
// data elements and their parameters.
// These items can be used in the GUI XML as iterators
// an external data.
//
///////////////////////////////////////////////////////////
group EPTF_ExecCtrl_DataSource {
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_DS_iteratorVar_prefix
//
// Purpose:
// This is the prefix for ExecCtrl iterator variables
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_DS_iteratorVar_prefix := "EPTF_ExecCtrl_DS_iterator_";
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_DataSource_sourceId
//
// Purpose:
// ExecCtrl iterators and data elements belond to this dataSource name
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_DataSource_sourceId := "ExecCtrl";
///////////////////////////////////////////////////////////////////////////////
// Constant: c_EPTF_ExecCtrl_dataElement_Help
//
// Purpose:
// This data element returns the help information about
// all dataElements supported.
// ValueType: charstring
//
// Parameters:
// - <c_EPTF_DataSource_paramNameHelpFormat> - the format of the output
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_EPTF_ExecCtrl_dataElement_help := c_EPTF_DataSource_dataElement_Help
const EPTF_DataSource_Help_DataElement c_EPTF_ExecCtrl_Help_dataElement_help := c_EPTF_DataSource_Help_dataElement_genericHelp;
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_iteratorEntityGroups
//
// Purpose:
// This iterator enlists the entity groups of the configuration
//
// Parameters:
// - <c_ExecCtrl_paramNameLGen> - the name of the ExecCtrl client load generator PTC
// - If the Client parameter is not present, the iterator returns
// the list of entity groups in the whole configuration
// - If the Client parameter is present, the iterator returns
// the list of entity groups deployed onto the specified client PTC
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_iteratorEntityGroups := "EntityGroups"
const charstring c_ExecCtrl_iteratorEntityGroups_varName := "EntityGroups"
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_iteratorEntityGroups := {
name := c_ExecCtrl_iteratorEntityGroups,
valueType := charstringlistType,
typeDescriptor := {
isListOf := true,
typeName := "EntityGroup"
},
description := "This iterator enlists the entity groups of the whole configuration."
}
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_iteratorEntityGroupsClient := {
name := c_ExecCtrl_iteratorEntityGroups,
valueType := charstringlistType,
typeDescriptor := {
isListOf := true,
typeName := "EntityGroup"
},
description := "This iterator enlists the entity groups deployed onto the specified client PTC.",
parameters := {
c_ExecCtrl_standardLGenParam
}
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_iteratorLGens
//
// Purpose:
// This iterator enlists the ExecCtrl clients (usually load generators)
// If the entity group parameter is specified, it lists the LGens
// that the entity group is distributed on, otherwise it lists all LGens.
//
// Parameters:
// - <c_ExecCtrl_paramNameEntityGroup> - *optional* - the name of the entity group
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_iteratorLGens := "Clients"
const charstring c_ExecCtrl_iteratorLGens_varName := c_ExecCtrl_iteratorLGens
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_iteratorLGens := {
name := c_ExecCtrl_iteratorLGens,
valueType := charstringlistType,
typeDescriptor := {
isListOf := true,
typeName := "LGen"
},
description := "This iterator enlists all the ExecCtrl clients (usually load generators)."
}
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_iteratorLGensEGrp := {
name := c_ExecCtrl_iteratorLGens,
valueType := charstringlistType,
typeDescriptor := {
isListOf := true,
typeName := "LGen"
},
description := "This iterator enlists the ExecCtrl clients (usually load generators) that the entity group is distributed on.",
parameters := {
c_ExecCtrl_standardEntityGroupParam
}
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_iteratorEGrpsOnClients
//
// Purpose:
// This iterator enlists all EntityGroups on all Clients.
// One item of this iterator is an EntityGoup deployed on an LGen.
// This entity group name and the LGen name can be returned by the dataElements:
// < c_ExecCtrl_dataElementEntityGroupOfEGrpsOnClients> and
// < c_ExecCtrl_dataElementClientOfEGrpsOnClients>
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_iteratorEGrpsOnClients := "EGrpsOnClients"
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_iteratorEGrpsOnClients := {
name := c_ExecCtrl_iteratorEGrpsOnClients,
valueType := charstringlistType,
typeDescriptor := {
isListOf := true,
typeName := "EGrpOnClient"
},
description := "This iterator enlists all the EntityGroups on all Clients."
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_iteratorEntityTypesForLGenOnClients
//
// Purpose:
// This iterator enlists all EntityTypes on all Clients.
// One item of this iterator is an EntityType supported by an LGen.
// This entity type and the LGen name can be returned by the dataElements:
// < c_ExecCtrl_dataElementEntityTypeOfEntityTypesForLGenOnClients> and
// < c_ExecCtrl_dataElementClientOfEntityTypesForLGenOnClients>
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_iteratorEntityTypesForLGenOnClients := "EntityTypesForLGenOnClients"
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_iteratorEntityTypesForLGenOnClients := {
name := c_ExecCtrl_iteratorEntityTypesForLGenOnClients,
valueType := charstringlistType,
typeDescriptor := {
isListOf := true,
typeName := "EntityTypeForLGenOnClient"
},
description := "This iterator enlists all the EntityTypes on all Clients."
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_iteratorScenariosOnClients
//
// Purpose:
// This iterator enlists all Scenarios of all EntityGroups on all Clients.
// One item of this iterator is a Scenario of an EntityGroup deployed on an LGen.
// This Scenario, the EntityGroup and the LGen name can be returned by the dataElements:
// < c_ExecCtrl_dataElementScenarioOfScenariosOnClients> and
// < c_ExecCtrl_dataElementEntityGroupOfScenariosOnClients> and
// < c_ExecCtrl_dataElementClientOfScenariosOnClients>
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_iteratorScenariosOnClients := "ScenariosOnClients"
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_iteratorScenariosOnClients := {
name := c_ExecCtrl_iteratorScenariosOnClients,
valueType := charstringlistType,
typeDescriptor := {
isListOf := true,
typeName := "ScenarioOnClient"
},
description := "This iterator enlists all the Scenarios on all EntityGroups of all Clients."
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_iteratorTrafficCasesOfScenarios
//
// Purpose:
// This iterator enlists all TrafficCases of all Scenarios.
// One item of this iterator is a TrafficCase of a ScenarioInstance.
// This Scenario, and the TrafficCase name can be returned by the dataElements:
// < c_ExecCtrl_dataElementScenarioOfTrafficCasesOfScenarios> and
// < c_ExecCtrl_dataElementTrafficCaseOfTrafficCasesOfScenarios>
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_iteratorTrafficCasesOfScenarios := "TrafficCasesOfScenarios"
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_iteratorTrafficCasesOfScenarios := {
name := c_ExecCtrl_iteratorTrafficCasesOfScenarios,
valueType := charstringlistType,
typeDescriptor := {
isListOf := true,
typeName := "TrafficCaseOfScenario"
},
description := "This iterator enlists all the TrafficCases of all Scenarios."
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_iteratorFSMStatsOfTrafficCases
//
// Purpose:
// This iterator enlists all available FSMStats of all TrafficCases of all Scenarios.
// One item of this iterator is an FSMStat of a TrafficCase of a ScenarioInstance.
// This Scenario, the TrafficCase and FSMStat names can be returned by the dataElements:
// < c_ExecCtrl_dataElementScenarioOfFSMStatsOfTrafficCases> and
// < c_ExecCtrl_dataElementTrafficCaseOfFSMStatsOfTrafficCases> and
// < c_ExecCtrl_dataElementFSMStatOfFSMStatsOfTrafficCases>
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_iteratorFSMStatsOfTrafficCases := "FSMStatsOfTrafficCases"
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_iteratorFSMStatsOfTrafficCases := {
name := c_ExecCtrl_iteratorFSMStatsOfTrafficCases,
valueType := charstringlistType,
typeDescriptor := {
isListOf := true,
typeName := "FSMStatOfTrafficCases"
},
description := "This iterator enlists all available FSMStats of all TrafficCases of all Scenarios."
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_iteratorScenariosOfScenarioGroupsWithPhaseList
//
// Purpose:
// This iterator enlists all Scenarios of ScenariosGroups with given PhaseList.
// One item of this iterator is a Scenario of a ScenarioGroup.
// This Scenario, and the ScenarioGroup name can be returned by the dataElements:
// < c_ExecCtrl_dataElementScenarioOfScenariosOfScenarioGroupsWithPhaseList> and
// < c_ExecCtrl_dataElementScenarioGroupOfScenariosOfScenarioGroupsWithPhaseList>
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_iteratorScenariosOfScenarioGroupsWithPhaseList := "ScenariosOfScenarioGroupsWithPhaseList"
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_iteratorScenariosOfScenarioGroupsWithPhaseList := {
name := c_ExecCtrl_iteratorScenariosOfScenarioGroupsWithPhaseList,
valueType := charstringlistType,
typeDescriptor := {
isListOf := true,
typeName := "ScenarioOfScenarioGroup"
},
description := "This iterator enlists all Scenarios of the ScenarioGroups with the given PhaseList.",
parameters := {
c_ExecCtrl_standardPhaseListParam
}
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_iteratorRegulators
//
// Purpose:
// This iterator enlists the regulators appearing in the configuration
//
// Parameters:
// There are no parameters for this iterator
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_iteratorRegulators := "Regulators"
const charstring c_ExecCtrl_iteratorRegulators_varName := c_ExecCtrl_iteratorRegulators
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_iteratorRegulators := {
name := c_ExecCtrl_iteratorRegulators,
valueType := charstringlistType,
typeDescriptor := {
isListOf := true,
typeName := "RegulatorName"
},
description := "This iterator enlists the regulators appearing in the configuration."
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_iteratorScenarios
//
// Purpose:
// This iterator enlists the scenarios of an entity group or scenario group
// Only one of the two parameters can be specified at once
// For scenario groups it returns the scenario instance name
//
// Parameters:
// - <c_ExecCtrl_paramNameEntityGroup> - the name of the entity group
// or
// - <c_ExecCtrl_paramNameScenarioGroup> - scenario group
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_iteratorScenarios := "Scenarios"
const charstring c_ExecCtrl_iteratorScenarios_varName := c_ExecCtrl_iteratorScenarios
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_iteratorScenariosEGrp := {
name := c_ExecCtrl_iteratorScenarios,
valueType := charstringlistType,
typeDescriptor := {
isListOf := true,
typeName := "Scenario"
},
description := "This iterator enlists the scenarios of an entity group.",
parameters := {
c_ExecCtrl_standardEntityGroupParam
}
}
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_iteratorScenariosScGrp := {
name := c_ExecCtrl_iteratorScenarios,
valueType := charstringlistType,
typeDescriptor := {
isListOf := true,
typeName := "ScenarioInstance"
},
description := "This iterator enlists the scenarios of a scenario group. Returns the scenario instance name",
parameters := {
c_ExecCtrl_standardScenarioGroupParam
}
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_iteratorTrafficCases
//
// Purpose:
// This iterator enlists the traffic cases of a scenario
//
// Parameters:
// - <c_ExecCtrl_paramNameEntityGroup> - the name of the entity group
// - <c_ExecCtrl_paramNameScenario> - the name of the scenario of an entity group
// or
// - <c_ExecCtrl_paramNameScenarioInstance> - the name of the scenario instance
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_iteratorTrafficCases := "TrafficCases"
const charstring c_ExecCtrl_iteratorTrafficCases_varName :="TrafficCases"
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_iteratorTrafficCases := {
name := c_ExecCtrl_iteratorTrafficCases,
valueType := charstringlistType,
typeDescriptor := {
isListOf := true,
typeName := "TrafficCase"
},
description := "This iterator enlists the traffic cases of a scenario.",
parameters := {
c_ExecCtrl_standardEntityGroupParam,
c_ExecCtrl_standardScenarioParam
}
}
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_iteratorTrafficCasesScInstance := {
name := c_ExecCtrl_iteratorTrafficCases,
valueType := charstringlistType,
typeDescriptor := {
isListOf := true,
typeName := "TrafficCase"
},
description := "This iterator enlists the traffic cases of a scenario instance.",
parameters := {
c_ExecCtrl_standardScenarioInstanceParam
}
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_iteratorPhaseLists
//
// Purpose:
// This iterator enlists the phaselists.
//
// Parameters:
// -
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_iteratorPhaseLists := "PhaseLists"
const charstring c_ExecCtrl_iteratorPhaseLists_varName :=c_ExecCtrl_iteratorPhaseLists
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_iteratorPhaseList := {
name := c_ExecCtrl_iteratorPhaseLists,
valueType := charstringlistType,
typeDescriptor := {
isListOf := true,
typeName := "PhaseList"
},
description := "This iterator enlists the phaselists."
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_iteratorPhases
//
// Purpose:
// This iterator enlists the phases of a scenario group.
//
// Parameters:
// No parameters,
// or
// - <c_ExecCtrl_paramNamePhaseList> - the name of the phaselist
// or
// - <c_ExecCtrl_paramNameScenarioGroup> - the name of the scenario group
// - <c_ExecCtrl_paramNamePhaseList> - the name of the phaselist
// or
// - <c_ExecCtrl_paramNameEntityGroup> - the name of the entity group
// - <c_ExecCtrl_paramNameScenario> - the name of the scenario of an entity group
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_iteratorPhases := "Phases"
const charstring c_ExecCtrl_iteratorPhases_varName :=c_ExecCtrl_iteratorPhases
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_iteratorPhases := {
name := c_ExecCtrl_iteratorPhases,
valueType := charstringlistType,
typeDescriptor := {
isListOf := true,
typeName := "Phase"
},
description := "This iterator enlists the phases."
}
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_iteratorPhasesPList := {
name := c_ExecCtrl_iteratorPhases,
valueType := charstringlistType,
typeDescriptor := {
isListOf := true,
typeName := "Phase"
},
description := "This iterator enlists the phases of phaselist.",
parameters := {
c_ExecCtrl_standardPhaseListParam
}
}
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_iteratorPhasesScGrp := {
name := c_ExecCtrl_iteratorPhases,
valueType := charstringlistType,
typeDescriptor := {
isListOf := true,
typeName := "Phase"
},
description := "This iterator enlists the phases of a scenario group.",
parameters := {
c_ExecCtrl_standardScenarioGroupParam,
c_ExecCtrl_standardPhaseListParam
}
}
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_iteratorPhasesEGrp := {
name := c_ExecCtrl_iteratorPhases,
valueType := charstringlistType,
typeDescriptor := {
isListOf := true,
typeName := "Phase"
},
description := "This iterator enlists the phases of a scenario.",
parameters := {
c_ExecCtrl_standardEntityGroupParam,
c_ExecCtrl_standardScenarioParam
}
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_iteratorScenarioGroups
//
// Purpose:
// This iterator enlists the scenario groups of a configuration
//
// Parameters:
// No parameters
// or
// - <c_ExecCtrl_paramNamePhaseList> - the name of the phaselist
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_iteratorScenarioGroups := "ScenarioGroups"
const charstring c_ExecCtrl_iteratorScenarioGroups_varName :="ScenarioGroups"
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_iteratorScenarioGroups := {
name := c_ExecCtrl_iteratorScenarioGroups,
valueType := charstringlistType,
typeDescriptor := {
isListOf := true,
typeName := "ScenarioGroup"
},
description := "This iterator enlists the scenario groups of a configuration."
}
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_iteratorScenarioGroupsPList := {
name := c_ExecCtrl_iteratorScenarioGroups,
valueType := charstringlistType,
typeDescriptor := {
isListOf := true,
typeName := "ScenarioGroup"
},
description := "This iterator enlists the scenario groups of a configuration for a given phase list.",
parameters := {
c_ExecCtrl_standardPhaseListParam
}
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_iteratorTcStats
//
// Purpose:
// This iterator enlists the TC scope statistics of the FSMs of the traffic cases
// Not implemented yet
//
// Parameters:
// -
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_iteratorTcStats := "TcStats"
const charstring c_ExecCtrl_iteratorTcStats_varName := c_ExecCtrl_iteratorTcStats
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_iteratorTcStats := {
name := c_ExecCtrl_iteratorTcStats,
valueType := charstringlistType,
typeDescriptor := {
isListOf := true,
typeName := "Statistic"
},
description := "This iterator enlists the TC scope statistics of the given traffic cases.",
parameters := {
}
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_iteratorFSMStats
//
// Purpose:
// This iterator enlists the TC scope statistics of the FSMs of the traffic cases
//
// Parameters:
// - <c_ExecCtrl_paramNameEntityGroup> - the name of the entity group
// - <c_ExecCtrl_paramNameScenario> - the name of the scenario of an entity group
// - <c_ExecCtrl_paramNameTrafficCase> - the name of the traffic case of a scenario
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_iteratorFSMStats := "FsmStats"
const charstring c_ExecCtrl_iteratorFSMStats_varName := c_ExecCtrl_iteratorFSMStats
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_iteratorFSMStats := {
name := c_ExecCtrl_iteratorFSMStats,
valueType := charstringlistType,
typeDescriptor := {
isListOf := true,
typeName := "FSMStatistic"
},
description := "This iterator enlists the TC scope statistics of the FSMs of the given traffic cases.",
parameters := {
c_ExecCtrl_standardEntityGroupParam,
c_ExecCtrl_standardScenarioParam,
c_ExecCtrl_standardTrafficCaseParam
}
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_iteratorGlobalStats
//
// Purpose:
// This iterator enlists the global scope statistics
//
// Parameters:
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_iteratorGlobalStats := "GlobalStats"
const charstring c_ExecCtrl_iteratorGlobalStats_varName := c_ExecCtrl_iteratorGlobalStats
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_iteratorGlobalStats := {
name := c_ExecCtrl_iteratorGlobalStats,
valueType := charstringlistType,
typeDescriptor := {
isListOf := true,
typeName := "GlobalStatistic"
},
description := "This iterator enlists the global scope statistic."
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_iteratorEntityTypesForLGen
//
// Purpose:
// This iterator enlists the supported entity types of the load generator clients
//
// Parameters:
// - <c_ExecCtrl_paramNameLGen> - the name of the client
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_iteratorEntityTypesForLGen := "EntityTypesForLGen"
const charstring c_ExecCtrl_iteratorEntityTypesForLGen_varName := c_ExecCtrl_iteratorEntityTypesForLGen
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_iteratorEntityTypesForLGen := {
name := c_ExecCtrl_iteratorEntityTypesForLGen,
valueType := charstringlistType,
typeDescriptor := {
isListOf := true,
typeName := "EntityType"
},
description := "This iterator enlists the supported entity types of the load generator clients.",
parameters := {
c_ExecCtrl_standardLGenParam
}
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_iteratorRegulatedItems
//
// Purpose:
// This iterator enlists the regulated items in the configuration
//
// Parameters:
// There are no parameters for this iterator
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_iteratorRegulatedItems := "RegulatedItems"
const charstring c_ExecCtrl_iteratorRegulatedItems_varName := c_ExecCtrl_iteratorRegulatedItems
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_iteratorRegulatedItems := {
name := c_ExecCtrl_iteratorRegulatedItems,
valueType := charstringlistType,
typeDescriptor := {
isListOf := true,
typeName := "RegulatedItemId"
},
description := "This iterator enlists the regulated items in the configuration."
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_paramNameEntityGroup
//
// Purpose:
// Specifies an entity group from the configuration
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_paramNameEntityGroup := "EntityGroup"
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_paramNameEntityType
//
// Purpose:
// Specifies an entity type implemented by a load generator
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_paramNameEntityType := "EntityType"
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_paramNameScenario
//
// Purpose:
// Specifies a scenario contained by an entity group
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_paramNameScenario := "Scenario"
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_paramNameScenarioInstance
//
// Purpose:
// Specifies a scenario instance
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_paramNameScenarioInstance := "ScenarioInstance"
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_paramNameScenarioGroup
//
// Purpose:
// Specifies a scenario group
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_paramNameScenarioGroup := "ScenarioGroup"
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_paramNameLGen
//
// Purpose:
// Specifies an ExecCtrl client load generator
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_paramNameLGen := "LGen"
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_paramNameEGrpOnClient
//
// Purpose:
// Specifies an ExecCtrl entity group and client load generator pair
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_paramNameEGrpOnClient := "EGrpOnClient"
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_paramNameEntityTypeForLGenOnClient
//
// Purpose:
// Specifies an ExecCtrl entity type and client load generator pair
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_paramNameEntityTypeForLGenOnClient := "EntityTypeForLGenOnClient"
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_paramNameScenarioOnClient
//
// Purpose:
// Specifies an ExecCtrl Scenario, EntityGroup and client load generator triple
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_paramNameScenarioOnClient := "ScenarioOnClient"
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_paramNameTrafficCaseOfScenario
//
// Purpose:
// Specifies an ExecCtrl Scenario and TrafficCase pair
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_paramNameFSMStatsOfTrafficCase := "FSMStatsOfTrafficCase"
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_paramNameTrafficCaseOfScenario
//
// Purpose:
// Specifies an ExecCtrl Scenario and TrafficCase pair
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_paramNameTrafficCaseOfScenario := "TrafficCaseOfScenario"
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_paramNameScenarioOfScenarioGroup
//
// Purpose:
// Specifies an ExecCtrl ScenarioGroup and ScenarioInstance pair
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_paramNameScenarioOfScenarioGroup := "ScenarioOfScenarioGroup"
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_paramNameTrafficCase
//
// Purpose:
// Specifies a traffic case contained by a scenario
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_paramNameTrafficCase := "TrafficCase"
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_paramNameCondition
//
// Purpose:
// Specifies a group finish condition of a traffic case
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_paramNameCondition := "Condition"
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_paramNameStatistic
//
// Purpose:
// Specifies the parameter name of the Statistics parameter
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_paramNameStatistic := "Statistic"
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_paramNamePhaseList
//
// Purpose:
// Specifies the parameter name of the PhaseList parameter
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_paramNamePhaseList := "PhaseList"
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_paramNamePhase
//
// Purpose:
// Specifies the parameter name of the Phase parameter
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_paramNamePhase := "Phase"
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_paramNameRegulatedItemId
//
// Purpose:
// Specifies the parameter name of the Regulated item Id
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_paramNameRegulatedItemId := "RegulatedItemId"
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_paramNameRegulatorName
//
// Purpose:
// Specifies the parameter name of the Regulator name
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_paramNameRegulatorName := "RegulatorName"
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_paramNameTrafficType
//
// Purpose:
// Specifies the parameter name of the trafficType. It can be originating or terminating
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_paramNameTrafficType := "trafficType"
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_paramNameExecutable
//
// Purpose:
// Specifies the parameter name of the Executable.
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_paramNameExecutable := "Executable"
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_paramNameConfigFile
//
// Purpose:
// Specifies the parameter name of the Configuration File.
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_paramNameConfigFile := "ConfigFile"
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_paramNameTestCases
//
// Purpose:
// Specifies the parameter name of the TestCases.
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_paramNameTestCases := "TestCases"
///////////////////////////////////////////////////////////////////////////////
// Constants for Data Elements
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementProgressbar
//
// Purpose:
// This dataElement returns the ProgressBar variable
// ValueType: charstring
// Shows the progress as a percentage value
//
// Parameters:
// -
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementProgressbar := "Progressbar";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementProgressbar := {
name := c_ExecCtrl_dataElementProgressbar,
valueType := charstringType,
description := "This dataElement returns the ProgressBar variable. Shows the progress as a percentage value."
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementProgressbarText
//
// Purpose:
// This dataElement returns the ProgressBar text variable
// ValueType: charstring
// It contains a text of what is in progress
//
// Parameters:
// -
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementProgressbarText := "ProgressbarText";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementProgressbarText := {
name := c_ExecCtrl_dataElementProgressbarText,
valueType := charstringType,
description := "This dataElement returns the ProgressBar text variable. It contains a text of what is in progress."
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementGlobalProgressbar
//
// Purpose:
// This dataElement returns the GlobalProgressBar variable
// ValueType: charstring
// Shows the global progress as a percentage value
//
// Parameters:
// -
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementGlobalProgressbar := "GlobalProgressbar";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementGlobalProgressbar := {
name := c_ExecCtrl_dataElementGlobalProgressbar,
valueType := charstringType,
description := "This dataElement returns the Global ProgressBar variable. Shows the global progress as a percentage value."
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementExit
//
// Purpose:
// This dataElement returns the ExitButton variable
// ValueType: integer
// When its value is changed, the button is pressed
//
// Parameters:
// -
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementExit := "Exit";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementExit := {
name := c_ExecCtrl_dataElementExit,
valueType := intType,
description := "This dataElement returns the ExitButton variable. When its value is changed, the button is pressed."
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementEndOfConfig
//
// Purpose:
// This dataElement returns the EndOfConfig variable
// ValueType: EPTF_StatusLED
// Green LED indicates when the configuration is finished
//
// Parameters:
// -
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementEndOfConfig := "EndOfConfig";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementEndOfConfig := {
name := c_ExecCtrl_dataElementEndOfConfig,
valueType := statusLEDType,
description := "This dataElement returns the EndOfConfig variable. Green LED indicates when the configuration is finished."
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementReadyToRun
//
// Purpose:
// This dataElement returns the ReadyToRun variable
// ValueType: EPTF_StatusLED
// Green LED indicates when the traffic cases are ready to run
//
// Parameters:
// -
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementReadyToRun := "ReadyToRun";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementReadyToRun := {
name := c_ExecCtrl_dataElementReadyToRun,
valueType := statusLEDType,
description := "This dataElement returns the ReadyToRun variable. Green LED indicates when the traffic cases are ready to run."
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementGUIDone
//
// Purpose:
// This dataElement returns the GUIDone variable
// ValueType: EPTF_StatusLED
// Green LED indicates when the GUI is ready
//
// Parameters:
// -
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementGUIDone := "GUIDone";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementGUIDone := {
name := c_ExecCtrl_dataElementGUIDone,
valueType := statusLEDType,
description := "This dataElement returns the GUIDone variable. Green LED indicates when the GUI is ready."
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementEndOfTest
//
// Purpose:
// This dataElement returns the EndOfTest variable
// ValueType: EPTF_StatusLED
// Green LED indicates when the Test is done, and
// the test report is generated
//
// Parameters:
// -
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementEndOfTest := "EndOfTest";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementEndOfTest := {
name := c_ExecCtrl_dataElementEndOfTest,
valueType := statusLEDType,
description := "This dataElement returns the EndOfTest variable. Green LED indicates when the Test is done, and the test report is generated."
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementTimeElapsed
//
// Purpose:
// This dataElement returns the TimeElapsed variable
// ValueType: charstring
// Its value shows the elapsed time since the main StartButton was pressed
//
// Parameters:
// -
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementTimeElapsed := "TimeElapsed";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementTimeElapsed := {
name := c_ExecCtrl_dataElementTimeElapsed,
valueType := charstringType,
description := "This dataElement returns the TimeElapsed variable. Its value shows the elapsed time since the main StartButton was pressed."
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementStart
//
// Purpose:
// This dataElement returns the Start test variable
// ValueType: integer
// The main StartButton can be pressed by changing the value of this variable
//
// Parameters:
// -
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementStart := "Start";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementStart := {
name := c_ExecCtrl_dataElementStart,
valueType := intType,
description := "This dataElement returns the Start test variable. The main StartButton can be pressed by changing the value of this variable."
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementStop
//
// Purpose:
// This dataElement returns the Stop test variable
// ValueType: integer
// The main StopButton can be pressed by changing the value of this variable
//
// Parameters:
// -
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementStop := "Stop";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementStop := {
name := c_ExecCtrl_dataElementStop,
valueType := intType,
description := "This dataElement returns the Stop test variable. The main StopButton can be pressed by changing the value of this variable."
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementTerminate
//
// Purpose:
// This dataElement returns the Terminate test variable
// ValueType: integer
// The main TerminateButton can be pressed by changing the value of this variable
//
// Parameters:
// -
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementTerminate := "Terminate";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementTerminate := {
name := c_ExecCtrl_dataElementTerminate,
valueType := intType,
description := "This dataElement returns the Terminate test variable. The main TerminateButton can be pressed by changing the value of this variable."
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementSnapshot
//
// Purpose:
// This dataElement returns the Snapshot test variable
// ValueType: integer
// The main SnapshotButton can be pressed by changing the value of this variable
//
// Parameters:
// -
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementSnapshot := "Snapshot";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementSnapshot := {
name := c_ExecCtrl_dataElementSnapshot,
valueType := intType,
description := "This dataElement returns the Snapshot test variable. The main SnapshotButton can be pressed by changing the value of this variable."
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementRestart
//
// Purpose:
// This dataElement restarts the application
// ValueType: integer
//
// Parameters:
// - <c_ExecCtrl_paramNameExecutable> - the name of the executable
// - <c_ExecCtrl_paramNameConfigFile> - the name of the configuration file
// - <c_ExecCtrl_paramNameTestCases> - the name of the test cases separated by space
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementRestart := "Restart";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementRestart := {
name := c_ExecCtrl_dataElementRestart,
valueType := intType,
description := "This dataElement restarts the application.",
parameters := {
c_ExecCtrl_standardExecutableParam,
c_ExecCtrl_standardConfigFileParam,
c_ExecCtrl_standardTestCasesParam
}
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementGetStartCommand
//
// Purpose:
// This dataElement returns the Start Command of the application
// ValueType: charstring
//
// Parameters:
// -
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementGetStartCommand := "StartCommand";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementGetStartCommand := {
name := c_ExecCtrl_dataElementGetStartCommand,
valueType := charstringType,
description := "This dataElement returns the Start Command of the application."
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementGetExecutable
//
// Purpose:
// This dataElement returns the Executable of the application
// ValueType: charstring
//
// Parameters:
// -
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementGetExecutable := "Executable";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementGetExecutable := {
name := c_ExecCtrl_dataElementGetExecutable,
valueType := charstringType,
description := "This dataElement returns the Executable of the application."
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementGetExecutable
//
// Purpose:
// This dataElement returns the ConfigFile of the application
// ValueType: charstring
//
// Parameters:
// -
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementGetConfigFile := "ConfigFile";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementGetConfigFile := {
name := c_ExecCtrl_dataElementGetConfigFile,
valueType := charstringType,
description := "This dataElement returns the ConfigFile of the application."
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementGetTestCases
//
// Purpose:
// This dataElement returns the TestCases of the application
// ValueType: charstring
//
// Parameters:
// -
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementGetTestCases := "TestCases";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementGetTestCases := {
name := c_ExecCtrl_dataElementGetTestCases,
valueType := charstringType,
description := "This dataElement returns the TestCases of the application."
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementEGrpType
//
// Purpose:
// This dataElement returns the Entity Type of an Entity Group
// ValueType: charstring
//
// Parameters:
// - <c_ExecCtrl_paramNameEntityGroup> - the name of the entity group
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementEGrpType := "EGrpType";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementEGrpType := {
name := c_ExecCtrl_dataElementEGrpType,
valueType := charstringType,
description := "This dataElement returns the Entity Type of an Entity Group.",
parameters := {
c_ExecCtrl_standardEntityGroupParam
}
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementEGrpSize
//
// Purpose:
// This dataElement returns the size of an Entity Group
// ValueType: integer
//
// Parameters:
// - <c_ExecCtrl_paramNameEntityGroup> - the size of the entity group
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementEGrpSize := "EGrpSize";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementEGrpSize := {
name := c_ExecCtrl_dataElementEGrpSize,
valueType := intType,
description := "This dataElement returns the size of an Entity Group.",
parameters := {
c_ExecCtrl_standardEntityGroupParam
}
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementNofMaxAvailEntitiesForLGen
//
// Purpose:
// This dataElement returns the number of max available entities for an LGen
// for a given entity type
// ValueType: integer
//
// Parameters:
// - <c_ExecCtrl_paramNameLGen> - the name of the LGen
// - <c_ExecCtrl_paramNameEntityType> - the entity type
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementNofMaxAvailEntitiesForLGen := "NofMaxAvailEntitiesForLGen";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementNofMaxAvailEntitiesForLGen := {
name := c_ExecCtrl_dataElementNofMaxAvailEntitiesForLGen,
valueType := intType,
description := "This dataElement returns the number of max available entities for an LGen for a given entity type.",
parameters := {
c_ExecCtrl_standardLGenParam,
c_ExecCtrl_standardEntityTypeParam
}
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementNofCurrentAvailEntitiesForLGen
//
// Purpose:
// This dataElement returns the number of current available entities for an LGen
// for a given entity type
// ValueType: integer
//
// Parameters:
// - <c_ExecCtrl_paramNameLGen> - the name of the LGen
// - <c_ExecCtrl_paramNameEntityType> - the entity type
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementNofCurrentAvailEntitiesForLGen := "NofCurrentAvailEntitiesForLGen";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementNofCurrentAvailEntitiesForLGen := {
name := c_ExecCtrl_dataElementNofCurrentAvailEntitiesForLGen,
valueType := intType,
description := "This dataElement returns the number of current available entities for an LGen for a given entity type.",
parameters := {
c_ExecCtrl_standardLGenParam,
c_ExecCtrl_standardEntityTypeParam
}
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementEGrpSizeForLGen
//
// Purpose:
// This dataElement returns the size of that part of the entity group which
// is allocated on the given LGen
// ValueType: integer
//
// Parameters:
// - <c_ExecCtrl_paramNameLGen> - the name of the LGen
// - <c_ExecCtrl_paramNameEntityGroup> - the entity group
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementEGrpSizeForLGen := "EGrpSizeForLGen";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementEGrpSizeForLGen := {
name := c_ExecCtrl_dataElementEGrpSizeForLGen,
valueType := intType,
description := "This dataElement returns the size of that part of the entity group which is allocated on the given LGen.",
parameters := {
c_ExecCtrl_standardLGenParam,
c_ExecCtrl_standardEntityGroupParam
}
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementEGrpOffsetForLGen
//
// Purpose:
// This dataElement returns the offset of the first entity of the entity group which
// on the given LGen
// ValueType: integer
//
// Parameters:
// - <c_ExecCtrl_paramNameLGen> - the name of the LGen
// - <c_ExecCtrl_paramNameEntityGroup> - the entity group
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementEGrpOffsetForLGen := "EGrpOffsetForLGen";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementEGrpOffsetForLGen := {
name := c_ExecCtrl_dataElementEGrpOffsetForLGen,
valueType := intType,
description := "This dataElement returns the offset of the first entity of the entity group which is allocated on the given LGen.",
parameters := {
c_ExecCtrl_standardLGenParam,
c_ExecCtrl_standardEntityGroupParam
}
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementScStatusForLGen
//
// Purpose:
// This dataElement returns the status of the scenario on the given LGen
// ValueType: EPTF_StatusLED
//
// Parameters:
// - <c_ExecCtrl_paramNameLGen> - the name of the LGen
// - <c_ExecCtrl_paramNameEntityGroup> - the entity group name
// - <c_ExecCtrl_paramNameScenario> - the scenario type name
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementScStatusForLGen := "ScStatusForLGen";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementScStatusForLGen := {
name := c_ExecCtrl_dataElementScStatusForLGen,
valueType := statusLEDType,
description := "This dataElement returns the status of the scenario on the given LGen.",
parameters := {
c_ExecCtrl_standardLGenParam,
c_ExecCtrl_standardEntityGroupParam,
c_ExecCtrl_standardScenarioParam
}
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementScIsWeighted
//
// Purpose:
// This dataElement returns "Decl" if the scenario is non-weighted,
// "Weighted" if the scenario is weighted
// ValueType: charstring
//
// Parameters:
// - <c_ExecCtrl_paramNameEntityGroup> - the entity group name
// - <c_ExecCtrl_paramNameScenario> - the scenario type name
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementScIsWeighted := "ScIsWeighted";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementScIsWeighted := {
name := c_ExecCtrl_dataElementScIsWeighted,
valueType := charstringType,
description := "This dataElement returns \"Decl\" if the scenario is non-weighted, \"Weighted\" if the scenario is weighted.",
parameters := {
c_ExecCtrl_standardEntityGroupParam,
c_ExecCtrl_standardScenarioParam
}
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementScStatus
//
// Purpose:
// This dataElement returns status of the scenario
// ValueType: EPTF_StatusLED
//
// Parameters:
// - <c_ExecCtrl_paramNameEntityGroup> - the entity group name
// - <c_ExecCtrl_paramNameScenario> - the scenario type name
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementScStatus := "ScStatus";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementScStatus := {
name := c_ExecCtrl_dataElementScStatus,
valueType := statusLEDType,
description := "This dataElement returns the status of the scenario.",
parameters := {
c_ExecCtrl_standardEntityGroupParam,
c_ExecCtrl_standardScenarioParam
}
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementScStart
//
// Purpose:
// This dataElement returns the start checkbox of the scenario
// ValueType: boolean
//
// Parameters:
// - <c_ExecCtrl_paramNameEntityGroup> - the entity group name
// - <c_ExecCtrl_paramNameScenario> - the scenario type name
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementScStart := "ScStart";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementScStart := {
name := c_ExecCtrl_dataElementScStart,
valueType := boolType,
description := "This dataElement returns the start checkbox of the scenario.",
parameters := {
c_ExecCtrl_standardEntityGroupParam,
c_ExecCtrl_standardScenarioParam
}
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementScStop
//
// Purpose:
// This dataElement returns the stop checkbox of the scenario
// ValueType: boolean
//
// Parameters:
// - <c_ExecCtrl_paramNameEntityGroup> - the entity group name
// - <c_ExecCtrl_paramNameScenario> - the scenario type name
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementScStop := "ScStop";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementScStop := {
name := c_ExecCtrl_dataElementScStop,
valueType := boolType,
description := "This dataElement returns the stop checkbox of the scenario.",
parameters := {
c_ExecCtrl_standardEntityGroupParam,
c_ExecCtrl_standardScenarioParam
}
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementScCPS
//
// Purpose:
// This dataElement returns the scenario CPS of the weighted scenario
// ValueType: float
//
// Parameters:
// - <c_ExecCtrl_paramNameEntityGroup> - the entity group name
// - <c_ExecCtrl_paramNameScenario> - the scenario type name
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementScCPS := "ScCPS";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementScCPS := {
name := c_ExecCtrl_dataElementScCPS,
valueType := floatType,
description := "This dataElement returns the scenario CPS of the weighted scenario.",
parameters := {
c_ExecCtrl_standardEntityGroupParam,
c_ExecCtrl_standardScenarioParam
}
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementTcStart
//
// Purpose:
// This dataElement returns the start checkbox of the traffic case
// ValueType: boolean
//
// Parameters:
// - <c_ExecCtrl_paramNameEntityGroup> - the entity group name
// - <c_ExecCtrl_paramNameScenario> - the scenario type name
// - <c_ExecCtrl_paramNameTrafficCase> - the traffic case name
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementTcStart := "TcStart";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementTcStart := {
name := c_ExecCtrl_dataElementTcStart,
valueType := boolType,
description := "This dataElement returns the start checkbox of the traffic case.",
parameters := {
c_ExecCtrl_standardEntityGroupParam,
c_ExecCtrl_standardScenarioParam,
c_ExecCtrl_standardTrafficCaseParam
}
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementTcStop
//
// Purpose:
// This dataElement returns the stop checkbox of the traffic case
// ValueType: boolean
//
// Parameters:
// - <c_ExecCtrl_paramNameEntityGroup> - the entity group name
// - <c_ExecCtrl_paramNameScenario> - the scenario type name
// - <c_ExecCtrl_paramNameTrafficCase> - the traffic case name
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementTcStop := "TcStop";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementTcStop := {
name := c_ExecCtrl_dataElementTcStop,
valueType := boolType,
description := "This dataElement returns the stop checkbox of the traffic case.",
parameters := {
c_ExecCtrl_standardEntityGroupParam,
c_ExecCtrl_standardScenarioParam,
c_ExecCtrl_standardTrafficCaseParam
}
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementTcResetStats
//
// Purpose:
// This dataElement resets the following statistics of the traffic case
// -Start
// -Success
// -Fail
// -Timeout
// -Error
// ValueType: boolean
//
// Parameters:
// - <c_ExecCtrl_paramNameEntityGroup> - the entity group name
// - <c_ExecCtrl_paramNameScenario> - the scenario type name
// - <c_ExecCtrl_paramNameTrafficCase> - the traffic case name
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementTcResetStats := "TcResetStats";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementTcResetStats := {
name := c_ExecCtrl_dataElementTcResetStats,
valueType := intType,
description := "This dataElement returns the resetStats button of the traffic case. This button resets the " &
"following statistics: Start, Success, Fail, Timeout, Error",
parameters := {
c_ExecCtrl_standardEntityGroupParam,
c_ExecCtrl_standardScenarioParam,
c_ExecCtrl_standardTrafficCaseParam
}
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementTcResetFSMStats
//
// Purpose:
// This dataElement resets all FSM statistics of the traffic case
// ValueType: boolean
//
// Parameters:
// - <c_ExecCtrl_paramNameEntityGroup> - the entity group name
// - <c_ExecCtrl_paramNameScenario> - the scenario type name
// - <c_ExecCtrl_paramNameTrafficCase> - the traffic case name
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementTcResetFSMStats := "TcResetFSMStats";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementTcResetFSMStats := {
name := c_ExecCtrl_dataElementTcResetFSMStats,
valueType := intType,
description := "This dataElement returns the resetStats button of the traffic case. This button resets the " &
"FSM statistics",
parameters := {
c_ExecCtrl_standardEntityGroupParam,
c_ExecCtrl_standardScenarioParam,
c_ExecCtrl_standardTrafficCaseParam
}
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementAllTcResetStats
//
// Purpose:
// This dataElement resets the following statistics of every traffic case
// -Start
// -Success
// -Fail
// -Timeout
// -Error
// ValueType: boolean
//
// Parameters:
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementAllTcResetStats := "AllTcResetStats";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementAllTcResetStats := {
name := c_ExecCtrl_dataElementAllTcResetStats,
valueType := intType,
description := "This dataElement returns the resetStats button that can be used to reset the following statistics of traffic cases: " &
"Start, Success, Fail, Timeout, Error",
parameters := {
}
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementAllTcResetFSMStats
//
// Purpose:
// This dataElement resets all FSM statistics of every traffic case
// ValueType: boolean
//
// Parameters:
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementAllTcResetFSMStats := "AllTcResetFSMStats";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementAllTcResetFSMStats := {
name := c_ExecCtrl_dataElementAllTcResetFSMStats,
valueType := intType,
description := "This dataElement returns the resetFSMStats button that can be used to reset all FSM statistics of every traffic case",
parameters := {
}
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementTcStartButton
//
// Purpose:
// This dataElement returns the start button of the traffic case
// ValueType: integer
//
// Parameters:
// - <c_ExecCtrl_paramNameEntityGroup> - the entity group name
// - <c_ExecCtrl_paramNameScenario> - the scenario type name
// - <c_ExecCtrl_paramNameTrafficCase> - the traffic case name
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementTcStartButton := "TcStartButton";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementTcStartButton := {
name := c_ExecCtrl_dataElementTcStartButton,
valueType := intType,
description := "This dataElement returns the start button of the traffic case.",
parameters := {
c_ExecCtrl_standardEntityGroupParam,
c_ExecCtrl_standardScenarioParam,
c_ExecCtrl_standardTrafficCaseParam
}
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementTcStopButton
//
// Purpose:
// This dataElement returns the stop button of the traffic case
// ValueType: integer
//
// Parameters:
// - <c_ExecCtrl_paramNameEntityGroup> - the entity group name
// - <c_ExecCtrl_paramNameScenario> - the scenario type name
// - <c_ExecCtrl_paramNameTrafficCase> - the traffic case name
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementTcStopButton := "TcStopButton";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementTcStopButton := {
name := c_ExecCtrl_dataElementTcStopButton,
valueType := intType,
description := "This dataElement returns the stop button of the traffic case.",
parameters := {
c_ExecCtrl_standardEntityGroupParam,
c_ExecCtrl_standardScenarioParam,
c_ExecCtrl_standardTrafficCaseParam
}
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementTcStartDelay
//
// Purpose:
// This dataElement returns the start delay of the traffic case
// ValueType: float
//
// Parameters:
// - <c_ExecCtrl_paramNameEntityGroup> - the entity group name
// - <c_ExecCtrl_paramNameScenario> - the scenario type name
// - <c_ExecCtrl_paramNameTrafficCase> - the traffic case name
//
///////////////////////////////////////////////////////////////////////////////
const charstring c_ExecCtrl_dataElementTcStartDelay := "TcStartDelay";
const EPTF_DataSource_Help_DataElement c_ExecCtrl_Help_dataElementTcStartDelay := {
name := c_ExecCtrl_dataElementTcStartDelay,
valueType := floatType,
description := "This dataElement returns the start delay of the traffic case.",
parameters := {
c_ExecCtrl_standardEntityGroupParam,
c_ExecCtrl_standardScenarioParam,
c_ExecCtrl_standardTrafficCaseParam
}
}
///////////////////////////////////////////////////////////////////////////////
// Constant: c_ExecCtrl_dataElementTcTargetCPSOrWeight
//