Google Git
Sign in
eclipse / titan / titan.Libraries.CLL / refs/tags/LPA108463_R17A04 / . / src / ExecCtrl / EPTF_CLL_ExecCtrlClient_Functions.ttcn
blob: 15609855d16c6da1d16f9401f41538ceb9a3dc79 [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_ExecCtrlClient_Functions
//
// Purpose:
// This module contains the implementation of EPTF_CLL_ExecCtrlClient functions.
//
// Module depends on:
// <EPTF_CLL_Common_Definitions>
// <EPTF_CLL_Base_Functions>
// <EPTF_CLL_LGenBase_Definitions>
// <EPTF_CLL_LGenBase_ConfigDefinitions>
// <EPTF_CLL_LGenBase_Functions>
// <EPTF_CLL_LGenBase_ConfigFunctions>
// <EPTF_CLL_LGenBase_TrafficFunctions>
// <EPTF_CLL_LGenBase_PhaseDefinitions>
// <EPTF_CLL_LGenBase_PhaseConfigFunctions>
// <EPTF_CLL_LGenBaseStats_Definitions>
// <EPTF_CLL_LGenBaseStats_Functions>
// <EPTF_CLL_LGenBase_EventHandlingFunctions>
// <EPTF_CLL_StatHandlerClient_Functions>
// <EPTF_CLL_StatHandlerClient_Definitions>
// <EPTF_CLL_Variable_Definitions>
// <EPTF_CLL_Variable_Functions>
// <EPTF_CLL_Logging_Definitions>
// <EPTF_CLL_Logging_Functions>
// <EPTF_CLL_ExecCtrl_Definitions>
// <EPTF_CLL_ExecCtrl_PhaseFunctions>
// <EPTF_CLL_ExecCtrl_LoggingFunctions>
// <EPTF_CLL_ExecCtrl_ScenarioDefinitions>
// <EPTF_CLL_ExecCtrlTimeProfile_Definitions>
// <EPTF_CLL_ExecCtrl_PhaseDefinitions>
// <EPTF_CLL_HashMapStr2Int_Functions>
// <EPTF_CLL_HashMap_Functions>
//
// Module Parameters:
// tsp_debug_EPTF_ExecCtrlClient_Functions - boolean
//
// Current Owner:
// Jozsef Gyurusi (ETHJGI)
//
// Last Review Date:
// 2009-02-03
//
// Detailed Comments:
// This module contains the interface functions for the EPTF_CLL_ExecCtrlClient.
//
// Public functions:
// <f_EPTF_ExecCtrlClient_init_CT>
// <f_EPTF_ExecCtrlClient_loadConfig>
// <f_EPTF_ExecCtrlClient_set_scenarioInitialized_fcb>
// <f_EPTF_ExecCtrlClient_registerEndOfConfigCallback>
// <f_EPTF_ExecCtrlClient_registerGuiDoneCallback>
// <f_EPTF_ExecCtrlClient_checkGuiDone>
// <f_EPTF_ExecCtrlClient_checkGuiDoneReported>
// <f_EPTF_ExecCtrlClient_reportGUIDone>
// <f_EPTF_ExecCtrlClient_readyToStart>
// <f_EPTF_ExecCtrlClient_checkEndOfConfig>
// <f_EPTF_ExecCtrlClient_getFirstEntityGlobalOffset>
// <f_EPTF_ExecCtrlClient_getEntityGroupGlobalOffset>
// <f_EPTF_ExecCtrlClient_getFirstEntityOffsetInEGrp>
// <f_EPTF_ExecCtrlClient_getEntityGroupSize>
// <f_EPTF_ExecCtrlClient_registerFinalTestReportGeneratorFn>
// <f_EPTF_ExecCtrlClient_deregisterFinalTestReportGeneratorFn>
//
// All other functions in this module are private!
//
///////////////////////////////////////////////////////////////
module EPTF_CLL_ExecCtrlClient_Functions {
import from EPTF_CLL_ExecCtrl_Definitions all;
import from EPTF_CLL_ExecCtrl_LoggingFunctions all;
import from EPTF_CLL_ExecCtrl_PhaseFunctions all;
import from EPTF_CLL_ExecCtrl_ScenarioDefinitions all;
import from EPTF_CLL_ExecCtrlTimeProfile_Definitions all;
import from EPTF_CLL_ExecCtrl_PhaseDefinitions all;
import from EPTF_CLL_ExecCtrl_ScenarioFunctions all;
import from EPTF_CLL_ExecCtrl_Functions all;
import from EPTF_CLL_LGenBase_Definitions all;
import from EPTF_CLL_LGenBase_Functions all;
import from EPTF_CLL_LGenBase_ConfigDefinitions all;
import from EPTF_CLL_LGenBase_TrafficFunctions all;
import from EPTF_CLL_LGenBase_ConfigFunctions all;
import from EPTF_CLL_LGenBaseStats_Definitions all;
import from EPTF_CLL_LGenBaseStats_Functions all;
import from EPTF_CLL_LGenBase_PhaseDefinitions all;
import from EPTF_CLL_LGenBase_PhaseConfigFunctions all;
import from EPTF_CLL_LGenBase_EventHandlingFunctions all;
import from EPTF_CLL_Variable_Definitions all;
import from EPTF_CLL_Variable_Functions all;
import from EPTF_CLL_Base_Functions all;
import from EPTF_CLL_Logging_Definitions all;
import from EPTF_CLL_Logging_Functions all;
import from EPTF_CLL_Common_Definitions all;
import from EPTF_CLL_HashMapStr2Int_Functions all;
import from EPTF_CLL_HashMap_Functions all;
modulepar boolean tsp_debug_EPTF_ExecCtrlClient_Functions := false;
modulepar boolean tsp_EPTF_ExecCtrlClient_terminateIfExecCtrlTerminates := true;
friend module EPTF_CLL_ExecCtrlUIHandler_Functions;
///////////////////////////////////////////////////////////
// Function: f_EPTF_ExecCtrlClient_init_CT
//
// Purpose:
// Init EPTF_ExecCtrlClient feature
//
// Parameters:
// - pl_selfName - *in charstring* - the name of the component
// - pl_execCtrlCompRef - *in* <EPTF_ExecCtrl_CT> - the component reference of EPTF_ExecCtrl component
// - pl_reportReady - *in boolean* - if true: the client automatically sends "I am ready to start" message to the ExecCtrl
// default: true. To send "I am ready to start" manually (false setting), call <f_EPTF_ExecCtrlClient_readyToStart>
// - pl_reportGUIDone - *in boolean* - if true, GUIDone is reported automatically to ExecCtrl when the ExecCtrl client GUI is ready
// To report GUIDone at custom time, set this parameter to false and call <f_EPTF_ExecCtrlClient_reportGUIDone> later
//
// Return Value:
// -
//
// Errors & assertions:
//
//
// Detailed Comments:
//
//
///////////////////////////////////////////////////////////
public function f_EPTF_ExecCtrlClient_init_CT(in charstring pl_selfName, in EPTF_ExecCtrl_CT pl_execCtrlCompRef,
in boolean pl_reportReady := true,
in boolean pl_reportGUIDone := true
) runs on EPTF_ExecCtrlClient_CT {
// f_EPTF_ExecCtrlClient_debug(%definitionId&": started...");
if (v_ExecCtrlClient_initialized) {
return;
}
f_EPTF_HashMap_init_CT (pl_selfName);
f_EPTF_Logging_init_CT(pl_selfName);
v_ExecCtrlClient_loggingMaskId := f_EPTF_Logging_registerComponentMasks(
tsp_EPTF_ExecCtrlClient_loggingComponentMask,
c_EPTF_ExecCtrl_loggingEventClasses,
EPTF_Logging_CLL);
if(tsp_debug_EPTF_ExecCtrlClient_Functions) {
f_EPTF_Logging_enableLocalMask(v_ExecCtrlClient_loggingMaskId, c_EPTF_ExecCtrl_loggingClassIdx_Debug);
} else {
f_EPTF_Logging_disableLocalMask(v_ExecCtrlClient_loggingMaskId, c_EPTF_ExecCtrl_loggingClassIdx_Debug);
}
vl_EPTF_ExecCtrlClient_def := activate(as_EPTF_ExecCtrlClient_MgmtIf());
f_EPTF_Base_assert(%definitionId&": LGenBase should be initialized before ExecCtrlClient", f_EPTF_LGenBase_initialized() or not pl_reportReady);
v_ExecCtrl_execCtrlMasterCompRef := pl_execCtrlCompRef;
f_EPTF_LGenBase_init(pl_selfName, 0, "");
f_EPTF_LGenBaseStats_init(pl_selfName,"");
// add listener to detect test finished:
if (-1!=f_EPTF_LGenBase_addGeneralEventListener(
c_EPTF_LGenBase_bIdx,
c_EPTF_LGenBase_inputIdx_testMgmt_testFinished,
refers(f_EPTF_ExecCtrlClient_testFinishedListener), {}
)) {}
f_EPTF_ExecCtrlClient_debug(%definitionId&": fill resource DB...");
// f_EPTF_ExecCtrlClient_fillResourceDB(); obsolated
f_EPTF_ExecCtrlClient_debug(%definitionId&": connecting to ExecCtrl...");
connect(self:ExecCtrlClient_MgmtIf_CP, v_ExecCtrl_execCtrlMasterCompRef:ExecCtrl_MgmtIf_CP);
f_EPTF_ExecCtrlClient_debug(%definitionId&": sending initial resource availability msg to ExecCtrl");
v_ExecCtrlClient_semaphore_DeclareScenario := 0;
v_ExecCtrlClient_semaphore_EndOfConfig := false;
t_EPTF_ExecCtrlClient_semaphoreTimer.start(0.0);
v_EPTF_ExecCtrlClient_guiPresent := false;
v_EPTF_ExecCtrlClient_guiDone := false;
v_EPTF_ExecCtrlClient_autoReportGuiDone := pl_reportGUIDone;
v_EPTF_ExecCtrlClient_guiDoneReported := false;
f_EPTF_ExecCtrlClient_initEGrpDB();
// replace with my groupFinishedFn:
//v_ExecCtrlClient_LGenBase_groupFinishedFn := v_LGenBase_groupFinishedFn;
v_ExecCtrlClient_LGenBase_groupFinishedDetectedFn :=
f_EPTF_LGenBase_setGroupFinishedDetectedFn(refers(f_EPTF_ExecCtrlClient_groupFinishedDetectedFn))
v_ExecCtrlClient_abortNextGroupFinish := true;
v_ExecCtrlClient_pauseDataForTCs := {};
f_EPTF_ExecCtrlClient_registerEndOfConfigCallback(refers(f_EPTF_ExecCtrlClient_registerFSMStats));
f_EPTF_LGenBase_registerTcStateChangedCallback(refers(f_EPTF_ExecCtrlClient_tcStateChanged_handlePaused));
f_EPTF_Base_registerCleanup(refers(f_EPTF_ExecCtrlClient_cleanup_CT));
v_ExecCtrlClient_started := false;
v_ExecCtrlClient_byeAckReceived := false;
v_ExecCtrlClient_byeReceived := false;
v_ExecCtrlClient_initialized := true;
// Client is ready:
if (pl_reportReady) {
f_EPTF_ExecCtrlClient_readyToStart();
}
f_EPTF_ExecCtrlClient_debug(%definitionId&": finished");
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_ExecCtrlClient_cleanup_CT
//
// Purpose:
// Cleanup EPTF_ExecCtrlClient feature
//
// Parameters:
// -
//
// Return Value:
// -
//
// Errors & assertions:
// -
//
// Detailed Comments:
//
//
///////////////////////////////////////////////////////////
private function f_EPTF_ExecCtrlClient_cleanup_CT() runs on EPTF_ExecCtrlClient_CT {
if (not v_ExecCtrlClient_initialized) {
return;
}
v_ExecCtrlClient_initialized := false;
f_EPTF_ExecCtrlClient_debug(%definitionId&": started");
// send bye only if ExecCtrl did not sent bye to me before
if (not v_ExecCtrlClient_byeReceived) {
ExecCtrlClient_MgmtIf_CP.send(EPTF_ExecCtrl_Bye:{});
f_EPTF_ExecCtrlClient_waitForByeAck();
}
disconnect(self:ExecCtrlClient_MgmtIf_CP, v_ExecCtrl_execCtrlMasterCompRef:ExecCtrl_MgmtIf_CP);
v_ExecCtrlClient_started := false;
v_ExecCtrlClient_byeAckReceived := false;
v_ExecCtrlClient_byeReceived := false;
v_ExecCtrlClient_semaphore_DeclareScenario := 0;
v_ExecCtrlClient_semaphore_EndOfConfig := false;
v_EPTF_ExecCtrlClient_guiDone := false;
v_EPTF_ExecCtrlClient_autoReportGuiDone := true;
v_EPTF_ExecCtrlClient_guiDoneReported := false;
f_EPTF_ExecCtrlClient_cleanupEGrpDB();
v_ExecCtrlClient_EndOfConfigCallbackFns := {};
v_ExecCtrlClient_GuiDoneCallbackFns := {};
v_EPTF_ExecCtrlClient_GuiDoneCallbackFn := null;
v_EPTF_ExecCtrlClient_finalTestReportGeneratorFns := {};
deactivate(vl_EPTF_ExecCtrlClient_def)
f_EPTF_ExecCtrlClient_debug(%definitionId&": finished");
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_ExecCtrlClient_loadConfig
//
// Purpose:
// Loads additional config data and appends them to existing data
//
// Parameters:
// pl_EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList - *in* <EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList>
// pl_EPTF_LGenBase_TcMgmt_Scenarios2GrpList - *in* <EPTF_LGenBase_TcMgmt_Scenarios2GrpList>
//
// pl_EPTF_LGenBase_ScenarioDeclaratorList - *in* <EPTF_LGenBase_ScenarioDeclaratorList>
// pl_EPTF_LGenBase_tcTypeDeclaratorList - *in* <EPTF_LGenBase_tcTypeDeclaratorList>
//
// pl_EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList - *in* <EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList>
// pl_EPTF_LGenBase_TcMgmt_ScenarioDeclaratorList - *in* <EPTF_LGenBase_TcMgmt_ScenarioDeclaratorList>
//
// pl_EPTF_LGenBase_TcMgmt_WeightedScenarioDeclaratorList - *in* <EPTF_LGenBase_TcMgmt_WeightedScenarioDeclaratorList>
//
// pl_EPTF_ExecCtrl_TimeProfileDescrList - *in* <EPTF_ExecCtrl_TimeProfileDescrList>
// pl_EPTF_ExecCtrl_TimeProfileList - *in* <EPTF_ExecCtrl_TimeProfileList>
// pl_EPTF_ExecCtrl_TimeProfile2TcList - *in* <EPTF_ExecCtrl_TimeProfile2TcList>
//
// pl_EPTF_LGenBase_ScenarioTypeDeclaratorList - *in* <EPTF_LGenBase_ScenarioTypeDeclaratorList> *optional* - Scenario Declator appeared in R3
// pl_EPTF_ExecCtrl_ScenarioInstanceTypeList - *in* <EPTF_ExecCtrl_ScenarioInstanceTypeList> - scenario instance decl
//
// pl_EPTF_ExecCtrl_LGenPool_Declarators - *in* <EPTF_ExecCtrl_LGenPool_Declarators> - LGen Pool declarators
// pl_EPTF_ExecCtrl_EntityGroup2LGenPool_List - *in* <EPTF_ExecCtrl_EntityGroup2LGenPool_List> - Entity group to LGen Pool declarators
//
// pl_EPTF_ExecCtrl_LGenFunction_Entry_List - *in* <EPTF_ExecCtrl_LGenFunction_Entry_List> - the LGen creator functions to register
//
// pl_EPTF_ExecCtrl_PhaseList_Declarators - *in* <EPTF_LGenBase_PhaseList_Declarators> - list of phaseLists
// pl_EPTF_ExecCtrl_ScenarioGroup_Declarators - *in* <EPTF_ExecCtrl_ScenarioGroup_Declarators> - list of scenario groups
//
// pl_EPTF_ExecCtrl_RegulatorNames - *in* <EPTF_ExecCtrl_RegulatorNames> - list of regulator names
// pl_EPTF_ExecCtrl_RegulatedItems - *in* <EPTF_ExecCtrl_RegulatedItems> - list of regulated items
//
// pl_EPTF_ExecCtrl_EntityGroupDistributionTypeList - *in* <EPTF_ExecCtrl_EntityGroupDistributionTypeList> - list of entity group distributions
//
// Return Value:
// -
//
// Errors & assertions:
//
// Detailed Comments:
// This function forwards the specified configuration data to ExecCtrl and calls the <f_EPTF_ExecCtrl_loadConfig> function with them.
// All parameters are optional. If specified, the value of that parameter is appended to the corresponding data already loaded.
// This function can be called more than once with different arguments.
// If you have your own tsp-s, this function can be used to load them into the ExecCtrl database from the LGen. The ExecCtr
// should know about all declarators in the system before it is started.
// The configuration can be loaded on an LGen if the LGen is not in an LGen-pool, because LGens in LGen pool are
// created after configuration data is loaded and ExecCtrl was started. Only from LGens created 'manually' is possible
// to load configuration data to ExecCtrl.
// This function should be called before the <f_EPTF_ExecCtrl_start> function is called (after which the configuration data is
// processed) on the ExecCtrl component and before the <f_EPTF_ExecCtrlClient_readyToStart> function is called.
//
///////////////////////////////////////////////////////////
public function f_EPTF_ExecCtrlClient_loadConfig(
in EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList pl_EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList :={},
in EPTF_LGenBase_TcMgmt_Scenarios2GrpList pl_EPTF_LGenBase_TcMgmt_Scenarios2GrpList :={},
in EPTF_LGenBase_ScenarioDeclaratorList pl_EPTF_LGenBase_ScenarioDeclaratorList :={},
in EPTF_LGenBase_tcTypeDeclaratorList pl_EPTF_LGenBase_tcTypeDeclaratorList :={},
in EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList pl_EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList :={},
in EPTF_LGenBase_TcMgmt_ScenarioDeclaratorList pl_EPTF_LGenBase_TcMgmt_ScenarioDeclaratorList :={},
in EPTF_LGenBase_TcMgmt_WeightedScenarioDeclaratorList pl_EPTF_LGenBase_TcMgmt_WeightedScenarioDeclaratorList :={},
in EPTF_ExecCtrl_TimeProfileDescrList pl_EPTF_ExecCtrl_TimeProfileDescrList := {},
in EPTF_ExecCtrl_TimeProfileList pl_EPTF_ExecCtrl_TimeProfileList := {},
in EPTF_ExecCtrl_TimeProfile2TcList pl_EPTF_ExecCtrl_TimeProfile2TcList := {},
in EPTF_LGenBase_ScenarioTypeDeclaratorList pl_EPTF_LGenBase_ScenarioTypeDeclaratorList := {},
in EPTF_ExecCtrl_ScenarioInstanceTypeList pl_EPTF_ExecCtrl_ScenarioInstanceTypeList := {},
in EPTF_ExecCtrl_LGenPool_Declarators pl_EPTF_ExecCtrl_LGenPool_Declarators := {},
in EPTF_ExecCtrl_EntityGroup2LGenPool_List pl_EPTF_ExecCtrl_EntityGroup2LGenPool_List := {},
//in EPTF_ExecCtrl_LGenFunction_Entry_List pl_EPTF_ExecCtrl_LGenFunction_Entry_List := {},
in EPTF_LGenBase_PhaseList_Declarators pl_EPTF_ExecCtrl_PhaseList_Declarators := {},
in EPTF_ExecCtrl_ScenarioGroup_Declarators pl_EPTF_ExecCtrl_ScenarioGroup_Declarators := {},
in EPTF_ExecCtrl_RegulatorNames pl_EPTF_ExecCtrl_RegulatorNames := {},
in EPTF_ExecCtrl_RegulatedItems pl_EPTF_ExecCtrl_RegulatedItems := {},
in EPTF_ExecCtrl_EntityGroupDistributionTypeList pl_EPTF_ExecCtrl_EntityGroupDistributionTypeList := {}
) runs on EPTF_ExecCtrlClient_CT {
f_EPTF_ExecCtrlClient_debug(%definitionId&": started...");
if (v_ExecCtrlClient_byeReceived) {
f_EPTF_ExecCtrlClient_debug(log2str(%definitionId&": Config not loaded: ExecCtrl terminated."));
return;
}
if (v_ExecCtrlClient_started) {
f_EPTF_ExecCtrlClient_warning(log2str(%definitionId&": Config not loaded: ExecCtrlClient was already started"));
return;
}
var EPTF_ExecCtrlClient_LoadConfig vl_EPTF_ExecCtrlClient_LoadConfig := c_EPTF_ExecCtrlClient_LoadConfig_default;
vl_EPTF_ExecCtrlClient_LoadConfig := {
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
}
ExecCtrlClient_MgmtIf_CP.send(EPTF_ExecCtrlClient_LoadConfig:vl_EPTF_ExecCtrlClient_LoadConfig);
f_EPTF_ExecCtrlClient_debug(%definitionId&": finished...");
}
friend function f_EPTF_ExecCtrlClient_execCtrlMasterCompRef() runs on EPTF_ExecCtrlClient_CT return EPTF_ExecCtrl_CT {
return v_ExecCtrl_execCtrlMasterCompRef;
}
// declares and registers FSM Stats into the StatHandler in ExecCtrl
private function f_EPTF_ExecCtrlClient_registerFSMStats() runs on EPTF_ExecCtrlClient_CT {
// get statList
var EPTF_LGenBase_StatisticListOfTCList vl_statList;
f_EPTF_LGenBase_getStatisticsOfTcs(vl_statList);
f_EPTF_ExecCtrlClient_debug(log2str(%definitionId&": vl_statList: ", vl_statList));
// notify ExecCtrl about the new stats
f_EPTF_ExecCtrlClient_createFSMStats(vl_statList);
}
// notifies ExecCtrl about the FSM stats in LGen
private function f_EPTF_ExecCtrlClient_createFSMStats(in EPTF_ExecCtrl_CreateFSMStats pl_createFSMStats) runs on EPTF_ExecCtrlClient_CT {
if (v_ExecCtrlClient_byeReceived) {
f_EPTF_ExecCtrlClient_debug(log2str("CreateFSMStats is not sent: ExecCtrl terminated."));
return;
}
ExecCtrlClient_MgmtIf_CP.send(EPTF_ExecCtrl_CreateFSMStats:pl_createFSMStats);
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_ExecCtrlClient_set_scenarioInitialized_fcb
//
// Purpose:
// Function to set scenarioInitialized callback function
//
// Parameters:
// -
//
// Return Value:
// -
//
// Errors & assertions:
// -
//
// Detailed Comments:
//
//
///////////////////////////////////////////////////////////
public function f_EPTF_ExecCtrlClient_set_scenarioInitialized_fcb(in f_EPTF_ExecCtrlClient_scenarioInitialized_fcb_FT pl_scenarioInitialized_fcb) runs on EPTF_ExecCtrlClient_CT {
v_ExecCtrlClient_scenarioInitialized_fcb := pl_scenarioInitialized_fcb;
}
//====================================================
// f_EPTF_ExecCtrlClient_groupFinishedDetectedFn
// send groupFinish event to ExecCtrl:
//====================================================
private function f_EPTF_ExecCtrlClient_groupFinishedDetectedFn(
in integer pl_tcIdx,
in EPTF_LGenBase_ConditionTrue pl_condition,
out boolean pl_abortGroupFinished
) runs on EPTF_ExecCtrlClient_CT {
if (v_ExecCtrlClient_byeReceived) {
f_EPTF_ExecCtrlClient_debug(log2str("GroupFinished not sent: ExecCtrl terminated."));
pl_abortGroupFinished := true;
return;
}
pl_abortGroupFinished := v_ExecCtrlClient_abortNextGroupFinish;//(f_EPTF_LGenBase_getTrafficStartFinishConditionCounter(pl_tcIdx,nrOfExecStart) < 100);
if (v_ExecCtrlClient_abortNextGroupFinish) {
var charstring vl_eGrpName;
var charstring vl_scName;
var charstring vl_tcName;
f_EPTF_LGenBase_trafficCaseIdNames(pl_tcIdx,vl_eGrpName,vl_scName,vl_tcName);
var EPTF_ExecCtrl_GrpFinishConditionTypes vl_grpFinishConditionTypes := f_EPTF_ExecCtrl_condition2GrpFinishConditionType(pl_condition);
var EPTF_IntegerList vl_counters := {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
for(var integer i:=0; i<sizeof(vl_grpFinishConditionTypes); i:=i+1) {
vl_counters[vl_grpFinishConditionTypes[i]] := f_EPTF_ExecCtrlClient_getCounterForGroupFinishConditionType(pl_tcIdx,vl_grpFinishConditionTypes[i]);
}
f_EPTF_ExecCtrl_accumulateConditions(pl_condition,v_ExecCtrlClient_pauseDataForTCs[pl_tcIdx].groupFinishedDetected);
// always fill the counters:
vl_counters[c_EPTF_ExecCtrl_groupFinishNofExecStartIdx] := f_EPTF_ExecCtrlClient_getCounterForGroupFinishConditionType(pl_tcIdx,c_EPTF_ExecCtrl_groupFinishNofExecStartIdx);
vl_counters[c_EPTF_ExecCtrl_groupFinishNofSuccessIdx] := f_EPTF_ExecCtrlClient_getCounterForGroupFinishConditionType(pl_tcIdx,c_EPTF_ExecCtrl_groupFinishNofSuccessIdx);
vl_counters[c_EPTF_ExecCtrl_groupFinishNofFailIdx] := f_EPTF_ExecCtrlClient_getCounterForGroupFinishConditionType(pl_tcIdx,c_EPTF_ExecCtrl_groupFinishNofFailIdx);
vl_counters[c_EPTF_ExecCtrl_groupFinishNofTimeoutIdx] := f_EPTF_ExecCtrlClient_getCounterForGroupFinishConditionType(pl_tcIdx,c_EPTF_ExecCtrl_groupFinishNofTimeoutIdx);
vl_counters[c_EPTF_ExecCtrl_groupFinishNofErrorIdx] := f_EPTF_ExecCtrlClient_getCounterForGroupFinishConditionType(pl_tcIdx,c_EPTF_ExecCtrl_groupFinishNofErrorIdx);
vl_counters[c_EPTF_ExecCtrl_groupFinish_RangeLoops] := f_EPTF_ExecCtrlClient_getCounterForGroupFinishConditionType(pl_tcIdx,c_EPTF_ExecCtrl_groupFinish_RangeLoops);
ExecCtrlClient_MgmtIf_CP.send(EPTF_ExecCtrlClient_GroupFinished:{tcId := {vl_eGrpName,vl_scName,vl_tcName}, condition := pl_condition, thresholds := vl_counters});
if (f_EPTF_LGenBase_getTcState(pl_tcIdx) == c_EPTF_LGenBase_tcStateRunning) {
f_EPTF_LGenBase_pauseTrafficCaseByIdx(pl_tcIdx);
}
} else {
v_ExecCtrlClient_abortNextGroupFinish := true; // next group finish will be aborted by default
}
}
//====================================================
// f_EPTF_ExecCtrlClient_processGroupFinished
// TR HL56376: fixed by ETHBAAT
//====================================================
private function f_EPTF_ExecCtrlClient_processGroupFinished(
in integer pl_tcIdx,
in EPTF_LGenBase_ConditionTrue pl_condition,
in EPTF_IntegerList pl_newConditionCounters
) runs on EPTF_ExecCtrlClient_CT {
if (not pl_condition.anythingFinished) {
//increase condition change condition:
f_EPTF_ExecCtrlClient_setNewConditionCounters(pl_tcIdx, pl_condition,pl_newConditionCounters);
f_EPTF_ExecCtrl_clearGroupFinishConditionFired(pl_condition,v_ExecCtrlClient_pauseDataForTCs[pl_tcIdx].groupFinishedDetected);
if (not f_EPTF_ExecCtrl_checkGroupFinishConditionFired(v_ExecCtrlClient_pauseDataForTCs[pl_tcIdx].groupFinishedDetected)) {
// all conditions are updated
// reset my flags:
v_ExecCtrlClient_pauseDataForTCs[pl_tcIdx].groupFinishedDetected := c_EPTF_LGenBase_emptyConditionTrue;
// reset LGenBase groupFinishedCondition flags so that it could detect them again
f_EPTF_LGenBase_resetTcGroupFinishConditionDetected(pl_tcIdx);
// only start if all conditions that had been fullfilled were updated:
// resume the traffic case:
f_EPTF_LGenBase_resumeTrafficCaseByIdx(pl_tcIdx);
}
} else {
f_EPTF_ExecCtrlClient_setNewConditionCounters(pl_tcIdx, pl_condition,pl_newConditionCounters); // set counters to final values
v_ExecCtrlClient_abortNextGroupFinish := false; // allow LGenBase to detect group finish:
f_EPTF_LGenBase_groupFinishedDetected(pl_tcIdx,pl_condition);
}
}//f_
private function f_EPTF_ExecCtrlClient_setNewConditionCounters(
in integer pl_tcIdx,
in EPTF_LGenBase_ConditionTrue pl_condition,
in EPTF_IntegerList pl_newConditionCounters
) runs on EPTF_ExecCtrlClient_CT {
if(pl_condition.nrOfExecStart
and isbound(pl_newConditionCounters[c_EPTF_ExecCtrl_groupFinishNofExecStartIdx])
and pl_newConditionCounters[c_EPTF_ExecCtrl_groupFinishNofExecStartIdx]>=0) {
f_EPTF_LGenBase_setTrafficStartFinishConditionCounter(pl_tcIdx,nrOfExecStart,pl_newConditionCounters[c_EPTF_ExecCtrl_groupFinishNofExecStartIdx]);
}
if(pl_condition.nrOfSuccesses
and isbound(pl_newConditionCounters[c_EPTF_ExecCtrl_groupFinishNofSuccessIdx])
and pl_newConditionCounters[c_EPTF_ExecCtrl_groupFinishNofSuccessIdx]>=0) {
f_EPTF_LGenBase_setTrafficStartFinishConditionCounter(pl_tcIdx,nrOfSuccesses,pl_newConditionCounters[c_EPTF_ExecCtrl_groupFinishNofSuccessIdx]);
}
if(pl_condition.nrOfFails
and isbound(pl_newConditionCounters[c_EPTF_ExecCtrl_groupFinishNofFailIdx])
and pl_newConditionCounters[c_EPTF_ExecCtrl_groupFinishNofFailIdx]>=0) {
f_EPTF_LGenBase_setTrafficStartFinishConditionCounter(pl_tcIdx,nrOfFails,pl_newConditionCounters[c_EPTF_ExecCtrl_groupFinishNofFailIdx]);
}
if(pl_condition.nrOfErrors
and isbound(pl_newConditionCounters[c_EPTF_ExecCtrl_groupFinishNofErrorIdx])
and pl_newConditionCounters[c_EPTF_ExecCtrl_groupFinishNofErrorIdx]>=0) {
f_EPTF_LGenBase_setTrafficStartFinishConditionCounter(pl_tcIdx,nrOfErrors,pl_newConditionCounters[c_EPTF_ExecCtrl_groupFinishNofErrorIdx]);
}
if(pl_condition.nrOfTimeouts
and isbound(pl_newConditionCounters[c_EPTF_ExecCtrl_groupFinishNofTimeoutIdx])
and pl_newConditionCounters[c_EPTF_ExecCtrl_groupFinishNofTimeoutIdx]>=0) {
f_EPTF_LGenBase_setTrafficStartFinishConditionCounter(pl_tcIdx,nrOfTimeouts,pl_newConditionCounters[c_EPTF_ExecCtrl_groupFinishNofTimeoutIdx]);
}
if(pl_condition.nrOfRangeLoop
and isbound(pl_newConditionCounters[c_EPTF_ExecCtrl_groupFinish_RangeLoops])
and pl_newConditionCounters[c_EPTF_ExecCtrl_groupFinish_RangeLoops]>=0) {
f_EPTF_LGenBase_setTrafficStartFinishConditionCounter(pl_tcIdx,nrOfRangeLoop,pl_newConditionCounters[c_EPTF_ExecCtrl_groupFinish_RangeLoops]);
}
}
// receive groupFinished from ExecCtrl:
private altstep as_EPTF_ExecCtrlClient_MgmtIf_groupFinished() runs on EPTF_ExecCtrlClient_CT {
var EPTF_ExecCtrlClient_GroupFinished vl_msg;
[] ExecCtrlClient_MgmtIf_CP.receive(EPTF_ExecCtrlClient_GroupFinished:?) -> value vl_msg {
f_EPTF_ExecCtrlClient_debug("EPTF_ExecCtrlClient_GroupFinished received...");
// calling original groupFinish handler:
var integer vl_tcIdx := f_EPTF_LGenBase_trafficCaseId(vl_msg.tcId.eGrpName,vl_msg.tcId.scName,vl_msg.tcId.tcName);
f_EPTF_ExecCtrlClient_processGroupFinished(vl_tcIdx,vl_msg.condition,vl_msg.thresholds);
repeat;
}
}
//====================================================
// f_EPTF_ExecCtrl_processPauseTC
//====================================================
private function f_EPTF_ExecCtrl_processPauseTC(
in integer pl_tcIdx,
in EPTF_ExecCtrl_GrpFinishConditionType pl_groupFinishConditionType
) runs on EPTF_ExecCtrlClient_CT {
v_ExecCtrlClient_pauseDataForTCs[pl_tcIdx].pausing := true;
v_ExecCtrlClient_pauseDataForTCs[pl_tcIdx].groupFinishConditionType := pl_groupFinishConditionType;
var EPTF_LGenBase_ConditionTrue vl_cause := f_EPTF_ExecCtrl_grpFinishConditionType2Condition(pl_groupFinishConditionType);
f_EPTF_ExecCtrl_accumulateConditions(vl_cause,v_ExecCtrlClient_pauseDataForTCs[pl_tcIdx].groupFinishedDetected);
if (f_EPTF_LGenBase_getTcState(pl_tcIdx)==c_EPTF_LGenBase_tcStatePaused) {
// call handler here:
f_EPTF_ExecCtrlClient_tcStateChanged_handlePaused(pl_tcIdx);
} else {
// pause the given traffic case:
f_EPTF_LGenBase_pauseTrafficCaseByIdx(pl_tcIdx);
//the registered handler <f_EPTF_ExecCtrlClient_tcStateChanged_handlePaused> will send pausedTC to ExecCtrl with the given counter when TC is paused
}
}//f_
// receive pauseTC from ExecCtrl:
private altstep as_EPTF_ExecCtrlClient_MgmtIf_pauseTC() runs on EPTF_ExecCtrlClient_CT {
var EPTF_ExecCtrlClient_PauseTC vl_msg;
[] ExecCtrlClient_MgmtIf_CP.receive(EPTF_ExecCtrlClient_PauseTC:?) -> value vl_msg {
f_EPTF_ExecCtrlClient_debug("EPTF_ExecCtrlClient_PauseTC received...");
// calling original groupFinish handler:
var integer vl_tcIdx := f_EPTF_LGenBase_trafficCaseId(vl_msg.tcId.eGrpName,vl_msg.tcId.scName,vl_msg.tcId.tcName);
f_EPTF_ExecCtrl_processPauseTC(vl_tcIdx,vl_msg.conditionType);
repeat;
}
}
function f_EPTF_ExecCtrlClient_tcStateChanged_handlePaused(in integer pl_tcIdx) runs on EPTF_ExecCtrlClient_CT {
// if tc gets paused
if (f_EPTF_LGenBase_getTcState(pl_tcIdx)==c_EPTF_LGenBase_tcStatePaused) {
// if pause was requested by ExecCtrl:
if (isbound(v_ExecCtrlClient_pauseDataForTCs[pl_tcIdx].pausing) and v_ExecCtrlClient_pauseDataForTCs[pl_tcIdx].pausing == true) {
// send paused to ExecCtrl
v_ExecCtrlClient_pauseDataForTCs[pl_tcIdx].pausing := false;
// get counter value for v_ExecCtrlClient_pauseDataForTCs[pl_tcIdx].onGroupFinishCounterId
var charstring vl_eGrpName;
var charstring vl_scName;
var charstring vl_tcName;
f_EPTF_LGenBase_trafficCaseIdNames(pl_tcIdx,vl_eGrpName,vl_scName,vl_tcName);
var EPTF_IntegerList vl_counters := {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
var integer vl_counter := f_EPTF_ExecCtrlClient_getCounterForGroupFinishConditionType(pl_tcIdx,v_ExecCtrlClient_pauseDataForTCs[pl_tcIdx].groupFinishConditionType);
vl_counters[v_ExecCtrlClient_pauseDataForTCs[pl_tcIdx].groupFinishConditionType] := vl_counter;
// always fill the counters:
vl_counters[c_EPTF_ExecCtrl_groupFinishNofExecStartIdx] := f_EPTF_ExecCtrlClient_getCounterForGroupFinishConditionType(pl_tcIdx,c_EPTF_ExecCtrl_groupFinishNofExecStartIdx);
vl_counters[c_EPTF_ExecCtrl_groupFinishNofSuccessIdx] := f_EPTF_ExecCtrlClient_getCounterForGroupFinishConditionType(pl_tcIdx,c_EPTF_ExecCtrl_groupFinishNofSuccessIdx);
vl_counters[c_EPTF_ExecCtrl_groupFinishNofFailIdx] := f_EPTF_ExecCtrlClient_getCounterForGroupFinishConditionType(pl_tcIdx,c_EPTF_ExecCtrl_groupFinishNofFailIdx);
vl_counters[c_EPTF_ExecCtrl_groupFinishNofTimeoutIdx] := f_EPTF_ExecCtrlClient_getCounterForGroupFinishConditionType(pl_tcIdx,c_EPTF_ExecCtrl_groupFinishNofTimeoutIdx);
vl_counters[c_EPTF_ExecCtrl_groupFinishNofErrorIdx] := f_EPTF_ExecCtrlClient_getCounterForGroupFinishConditionType(pl_tcIdx,c_EPTF_ExecCtrl_groupFinishNofErrorIdx);
vl_counters[c_EPTF_ExecCtrl_groupFinish_RangeLoops] := f_EPTF_ExecCtrlClient_getCounterForGroupFinishConditionType(pl_tcIdx,c_EPTF_ExecCtrl_groupFinish_RangeLoops);
// send current values for all conditions
ExecCtrlClient_MgmtIf_CP.send(EPTF_ExecCtrlClient_PauseTC:{
tcId := {
eGrpName := vl_eGrpName,
scName := vl_scName,
tcName := vl_tcName
},
conditionType := v_ExecCtrlClient_pauseDataForTCs[pl_tcIdx].groupFinishConditionType,
counters := vl_counters
});
}
}
}
private function f_EPTF_ExecCtrlClient_getCounterForGroupFinishConditionType(
in integer pl_tcIdx,
in EPTF_ExecCtrl_GrpFinishConditionType pl_groupFinishConditionType
) runs on EPTF_ExecCtrlClient_CT return integer {
var integer vl_counter;
if(pl_groupFinishConditionType==c_EPTF_ExecCtrl_groupFinishNofExecStartIdx) {
vl_counter := f_EPTF_LGenBase_getTcStarts(pl_tcIdx);
} else if(pl_groupFinishConditionType==c_EPTF_ExecCtrl_groupFinishNofSuccessIdx) {
vl_counter := f_EPTF_LGenBase_getTcSuccesses(pl_tcIdx);
} else if(pl_groupFinishConditionType==c_EPTF_ExecCtrl_groupFinishNofFailIdx) {
vl_counter := f_EPTF_LGenBase_getTcFails(pl_tcIdx);
} else if(pl_groupFinishConditionType==c_EPTF_ExecCtrl_groupFinishNofErrorIdx) {
vl_counter := f_EPTF_LGenBase_getTcErrors(pl_tcIdx);
} else if(pl_groupFinishConditionType==c_EPTF_ExecCtrl_groupFinishNofTimeoutIdx) {
vl_counter := f_EPTF_LGenBase_getTcTimeouts(pl_tcIdx);
} else if(pl_groupFinishConditionType==c_EPTF_ExecCtrl_groupFinish_RangeLoops) {
var charstring vl_eGrpName;
var charstring vl_scName;
var charstring vl_tcName;
f_EPTF_LGenBase_trafficCaseIdNames(pl_tcIdx,vl_eGrpName,vl_scName,vl_tcName);
var charstring vl_varNameBase := f_EPTF_LGenBase_getNamePrefix(vl_eGrpName,vl_scName,vl_tcName);
vl_counter := f_EPTF_Var_getIntValue(f_EPTF_Var_getId(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcRangeLoops));
} else if(pl_groupFinishConditionType==c_EPTF_ExecCtrl_groupFinish_ExecTime) {
vl_counter := 1;
} else if(pl_groupFinishConditionType==c_EPTF_ExecCtrl_groupFinish_EntitiesFinished) {
vl_counter := 1;//f_EPTF_LGenBase_getTcAllEntities(pl_tcIdx) - f_EPTF_LGenBase_getTcNotFinishedEntities(pl_tcIdx);
} else if(pl_groupFinishConditionType==c_EPTF_ExecCtrl_groupFinish_AvailableEntitiesFinished) {
vl_counter := 1;//f_EPTF_LGenBase_getTcAvailable(pl_tcIdx);
} else if(pl_groupFinishConditionType==c_EPTF_ExecCtrl_groupFinish_Custom) {
vl_counter := 1;
} else if(pl_groupFinishConditionType==c_EPTF_ExecCtrl_groupFinishConditionUnknown) {
vl_counter := -1;
} else {
vl_counter := -1;
}
return vl_counter;
}
///////////////////////////////////////////////////////////
// Altstep: as_EPTF_ExecCtrlClient_MgmtIf_UpdateActiveEntities
//
// Purpose:
// Handles EPTF_ExecCtrl_UpdateCps messages from ExecCtrl
//
// Parameters:
// -
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
//
///////////////////////////////////////////////////////////
private altstep as_EPTF_ExecCtrlClient_MgmtIf_UpdateActiveEntities() runs on EPTF_ExecCtrlClient_CT
{
var EPTF_ExecCtrl_UpdateActiveEntities vl_updateActiveEntities_msg;
[] ExecCtrlClient_MgmtIf_CP.receive(EPTF_ExecCtrl_UpdateActiveEntities:?) -> value vl_updateActiveEntities_msg
{
//Note: Don't change the log string! There is a regression test based on it!
f_EPTF_ExecCtrlClient_debug("EPTF_ExecCtrl_UpdateActiveEntities received...");
var integer vl_eGrpIdx := f_EPTF_LGenBase_entityGrpNameIndex(vl_updateActiveEntities_msg.eGrpName);
var integer vl_activeEntities := vl_updateActiveEntities_msg.activeEntities;
f_EPTF_LGenBase_limitExecution(vl_eGrpIdx,vl_activeEntities);
repeat;
}
}
///////////////////////////////////////////////////////////
// Altstep: as_EPTF_ExecCtrlClient_MgmtIf_UpdateCps
//
// Purpose:
// Handles EPTF_ExecCtrl_UpdateCps messages from ExecCtrl
//
// Parameters:
// -
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
//
///////////////////////////////////////////////////////////
private altstep as_EPTF_ExecCtrlClient_MgmtIf_UpdateCps() runs on EPTF_ExecCtrlClient_CT
{
var EPTF_ExecCtrl_UpdateCps vl_updateCps_msg;
[] ExecCtrlClient_MgmtIf_CP.receive(EPTF_ExecCtrl_UpdateCps:?) -> value vl_updateCps_msg
{
f_EPTF_ExecCtrlClient_debug("EPTF_ExecCtrl_UpdateCps received...");
/* f_EPTF_LGenBase_setCpsOrWeightOfTcByNames(
vl_updateCps_msg.eGrpName,
vl_updateCps_msg.scenName,
vl_updateCps_msg.cpsList[tcidx].tcName,
vl_updateCps_msg.cpsList[tcidx].cpsToReach);*/
// new code performs the update via the variable feature, resulting in proper GUI refresh:
// // this code does not update the GUI:
// f_EPTF_LGenBase_setCPSByNames(
// vl_updateCps_msg.eGrpName,
// vl_updateCps_msg.scenName,
// vl_updateCps_msg.tcName,
// vl_updateCps_msg.cps
// );
var integer vl_eGrpIdx := f_EPTF_LGenBase_entityGrpNameIndex(vl_updateCps_msg.eGrpName);
var integer vl_scInGrpIdx := f_EPTF_LGenBase_scNameIndexInEG(vl_eGrpIdx, vl_updateCps_msg.scenName);
var integer vl_varIdx := -1;
var charstring vl_varNameBase := f_EPTF_LGenBaseStats_getNamePrefix(
vl_updateCps_msg.eGrpName,
vl_updateCps_msg.scenName,
vl_updateCps_msg.tcName
);
if (f_EPTF_LGenBase_isWeightedScenario(vl_eGrpIdx,vl_scInGrpIdx)) {
// update traffic weight:
vl_varIdx := f_EPTF_Var_getId(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcWeight);
} else {
// update cpsToReach
vl_varIdx := f_EPTF_Var_getId(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcCpsToReach);
}
if(vl_varIdx >= 0) {
f_EPTF_Var_adjustContent(vl_varIdx, {floatVal := vl_updateCps_msg.cps});
}
repeat;
}
}
///////////////////////////////////////////////////////////
// Altstep: as_EPTF_ExecCtrlClient_MgmtIf_UpdateStartDelay
//
// Purpose:
// Handles EPTF_ExecCtrl_UpdateStartDelay messages from ExecCtrl
//
// Parameters:
// -
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
//
///////////////////////////////////////////////////////////
private altstep as_EPTF_ExecCtrlClient_MgmtIf_UpdateStartDelay() runs on EPTF_ExecCtrlClient_CT
{
var EPTF_ExecCtrl_UpdateStartDelay vl_msg;
[] ExecCtrlClient_MgmtIf_CP.receive(EPTF_ExecCtrl_UpdateStartDelay:?) -> value vl_msg
{
f_EPTF_ExecCtrlClient_debug("EPTF_ExecCtrl_UpdateStartDelay received...");
f_EPTF_LGenBase_setTCStartDelay(f_EPTF_LGenBase_trafficCaseId(vl_msg.eGrpName, vl_msg.scenName, vl_msg.tcName),vl_msg.startDelay);
repeat;
}
}
///////////////////////////////////////////////////////////
// Altstep: as_EPTF_ExecCtrlClient_MgmtIf_UpdateScenarioCps
//
// Purpose:
// Handles EPTF_ExecCtrl_UpdateScenarioCps messages from ExecCtrl
//
// Parameters:
// -
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
//
///////////////////////////////////////////////////////////
private altstep as_EPTF_ExecCtrlClient_MgmtIf_UpdateScenarioCps() runs on EPTF_ExecCtrlClient_CT
{
var EPTF_ExecCtrl_UpdateScenarioCps vl_updateCps_msg;
[] ExecCtrlClient_MgmtIf_CP.receive(EPTF_ExecCtrl_UpdateScenarioCps:?) -> value vl_updateCps_msg
{
f_EPTF_ExecCtrlClient_debug("EPTF_ExecCtrl_UpdateScenarioCps received...");
var integer vl_eGrpIdx := f_EPTF_LGenBase_entityGrpNameIndex(vl_updateCps_msg.eGrpName);
var integer vl_scInGrpIdx := f_EPTF_LGenBase_scNameIndexInEG(vl_eGrpIdx, vl_updateCps_msg.scenName);
f_EPTF_LGenBase_setScenarioCPSByIdx(
vl_eGrpIdx,
vl_scInGrpIdx,
vl_updateCps_msg.cps);
var integer vl_varIdx := -1;
var charstring vl_varNameBase;
if (f_EPTF_LGenBase_isWeightedScenario(vl_eGrpIdx,vl_scInGrpIdx)) {
vl_varNameBase := f_EPTF_LGenBaseStats_getScNamePrefix(vl_updateCps_msg.eGrpName,vl_updateCps_msg.scenName);
} else {
f_EPTF_Base_assert(log2str("Cannot set CPS of the scenario ",vl_updateCps_msg.scenName,
": The scenario is not weighted! EGrpName:",vl_updateCps_msg.eGrpName," scenName: ",vl_updateCps_msg.scenName),
false);
}
vl_varIdx := f_EPTF_Var_getId(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcCpsToReach);
if(vl_varIdx >= 0) {
f_EPTF_Var_refreshContent(vl_varIdx);
}
repeat;
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_ExecCtrlClient_registerEndOfConfigCallback
//
// Purpose:
// Register an EndOfConfig callback function, that is called when all of the scenarios in the current LGEn are created
// and the configuration of the client is finished
//
// Parameters:
// - pl_EndOfConfigCallback - *in* <EPTF_ExecCtrlClient_EndOfConfigCallbackFn> - reference to the callback function
//
// Return Value:
// -
//
// Errors & assertions:
// -
//
// Detailed Comments:
//
//
///////////////////////////////////////////////////////////
public function f_EPTF_ExecCtrlClient_registerEndOfConfigCallback(in EPTF_ExecCtrlClient_EndOfConfigCallbackFn pl_EndOfConfigCallback) runs on EPTF_ExecCtrlClient_CT {
v_ExecCtrlClient_EndOfConfigCallbackFns[sizeof(v_ExecCtrlClient_EndOfConfigCallbackFns)] := pl_EndOfConfigCallback;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_ExecCtrlClient_callEndOfConfigCallbacks
//
// Purpose:
// Calls all EndOfConfig callback functions
//
// Parameters:
//
// Return Value:
// -
//
// Errors & assertions:
// -
//
// Detailed Comments:
//
//
///////////////////////////////////////////////////////////
private function f_EPTF_ExecCtrlClient_callEndOfConfigCallbacks() runs on EPTF_ExecCtrlClient_CT {
for(var integer i:=0; i<sizeof(v_ExecCtrlClient_EndOfConfigCallbackFns);i:=i+1) {
f_EPTF_ExecCtrlClient_debug(log2str("ExeCtrlClient: EndOfConfigCallback: ", v_ExecCtrlClient_EndOfConfigCallbackFns[i], " called"));
if (v_ExecCtrlClient_EndOfConfigCallbackFns[i]!=null) {
v_ExecCtrlClient_EndOfConfigCallbackFns[i].apply();
}
f_EPTF_ExecCtrlClient_debug(log2str("ExeCtrlClient: EndOfConfigCallback: ", v_ExecCtrlClient_EndOfConfigCallbackFns[i], " done"));
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_ExecCtrlClient_registerGuiDoneCallback
//
// Purpose:
// Register a GuiDone callback function, that is called when the ExecCtrl gui is ready
//
// Parameters:
// - pl_guiDoneCallback - *in* <EPTF_ExecCtrlClient_GuiDoneCallbackFn> - reference to the callback function
//
// Return Value:
// -
//
// Errors & assertions:
// -
//
// Detailed Comments:
//
//
///////////////////////////////////////////////////////////
public function f_EPTF_ExecCtrlClient_registerGuiDoneCallback(in EPTF_ExecCtrlClient_GuiDoneCallbackFn pl_guiDoneCallback) runs on EPTF_ExecCtrlClient_CT {
v_ExecCtrlClient_GuiDoneCallbackFns[sizeof(v_ExecCtrlClient_GuiDoneCallbackFns)] := pl_guiDoneCallback;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_ExecCtrlClient_callGuiDoneCallbacks
//
// Purpose:
// Calls all GuiDone callback functions
//
// Parameters:
//
// Return Value:
// -
//
// Errors & assertions:
// -
//
// Detailed Comments:
//
//
///////////////////////////////////////////////////////////
private function f_EPTF_ExecCtrlClient_callGuiDoneCallbacks() runs on EPTF_ExecCtrlClient_CT {
for(var integer i:=0; i<sizeof(v_ExecCtrlClient_GuiDoneCallbackFns);i:=i+1) {
f_EPTF_ExecCtrlClient_debug(log2str("ExeCtrlClient: GuiDoneCallback: ", v_ExecCtrlClient_GuiDoneCallbackFns[i], " called"));
if (v_ExecCtrlClient_GuiDoneCallbackFns[i]!=null) {
v_ExecCtrlClient_GuiDoneCallbackFns[i].apply();
}
f_EPTF_ExecCtrlClient_debug(log2str("ExeCtrlClient: GuiDoneCallback: ", v_ExecCtrlClient_GuiDoneCallbackFns[i], " done"));
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_ExecCtrlClient_registerGuiDoneCallbackForFSMStats
//
// Purpose:
// used by ExecCtrlClient_UIHandler to register the f_ExecCtrlClient_UIHandler_bindFSMStatsToWidget callback function, that is called when the ExecCtrl gui is ready
//
// Parameters:
// - pl_guiDoneCallback - *in* <EPTF_ExecCtrlClient_GuiDoneCallbackFn> - reference to the callback function
//
// Return Value:
// -
//
// Errors & assertions:
// -
//
// Detailed Comments:
//
//
///////////////////////////////////////////////////////////
friend function f_EPTF_ExecCtrlClient_registerGuiDoneCallbackForFSMStats(in EPTF_ExecCtrlClient_GuiDoneCallbackFn pl_guiDoneCallback) runs on EPTF_ExecCtrlClient_CT {
v_EPTF_ExecCtrlClient_GuiDoneCallbackFn := pl_guiDoneCallback;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_ExecCtrlClient_callGuiDoneCallbackForFSMStats
//
// Purpose:
// Calls all GuiDone callback function for FSMStats
//
// Parameters:
//
// Return Value:
// -
//
// Errors & assertions:
// -
//
// Detailed Comments:
//
//
///////////////////////////////////////////////////////////
private function f_EPTF_ExecCtrlClient_callGuiDoneCallbackForFSMStats() runs on EPTF_ExecCtrlClient_CT {
f_EPTF_ExecCtrlClient_debug(log2str("ExeCtrlClient: GuiDoneCallbackForFSMStats: ", v_EPTF_ExecCtrlClient_GuiDoneCallbackFn, " called"));
if (v_EPTF_ExecCtrlClient_GuiDoneCallbackFn!=null) {
v_EPTF_ExecCtrlClient_GuiDoneCallbackFn.apply();
}
f_EPTF_ExecCtrlClient_debug(log2str("ExeCtrlClient: GuiDoneCallbackForFSMStats: ", v_EPTF_ExecCtrlClient_GuiDoneCallbackFn, " done"));
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_ExecCtrlClient_scenarioStateCalcFn
//
// Purpose:
// CalcFn function to copy the scenario state from LGBaseStats to this variable
//
// Parameters:
// -
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
// pl_argList[0] : vl_lgenBaseVarIdx to copy the state from
//
///////////////////////////////////////////////////////////
private function f_EPTF_ExecCtrlClient_scenarioStateCalcFn(
in integer pl_idx,
in EPTF_IntegerList pl_argList,
in EPTF_IntegerList pl_nonVarArgList,
inout EPTF_Var_DirectContent pl_retVal
) runs on EPTF_ExecCtrlClient_CT {
f_EPTF_Var_getContent(pl_argList[0],pl_retVal);
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_ExecCtrlClient_startScenario
//
// Purpose:
// Enables a scenario on an Entity Group and restores and starts
//
// Detailed Comments:
// Wrapper to f_EPTF_LGenBase_enableScenarioOnEntityGroup
///////////////////////////////////////////////////////////
private function f_EPTF_ExecCtrlClient_startScenario(
in integer pl_eGrpIdx, //entity group
in integer pl_scIdxInGrp, //scenario index in group
in boolean pl_autoStart := true)
runs on EPTF_ExecCtrlClient_CT{
var EPTF_LGenBase_tcState vl_scStatePrev := f_EPTF_LGenBase_getScState(pl_eGrpIdx,pl_scIdxInGrp)
if(c_EPTF_LGenBase_tcStateStopped == vl_scStatePrev or
c_EPTF_LGenBase_tcStateAborted == vl_scStatePrev or
c_EPTF_LGenBase_tcStateTerminated == vl_scStatePrev) {
if(not f_EPTF_LGenBase_restoreScenarioByIdx(pl_eGrpIdx, pl_scIdxInGrp, false)) {
f_EPTF_ExecCtrlClient_debug(log2str("Restoring scenario with state ", vl_scStatePrev, " failed."));
}
}
f_EPTF_LGenBase_enableScenarioOnEntityGroup(pl_eGrpIdx,pl_scIdxInGrp,pl_autoStart);
}
private function f_EPTF_ExecCtrlClient_restoreScenarioData(
in integer pl_eGrpIdx, //entity group
in integer pl_scIdxInGrp //scenario index in group
) runs on EPTF_ExecCtrlClient_CT {
// reset v_ExecCtrlClient_pauseDataForTCs for all TCs in the scenario:
var EPTF_IntegerList vl_tcIdxList;
f_EPTF_LGenBase_tcIdxListOfScenario(pl_eGrpIdx,pl_scIdxInGrp,vl_tcIdxList);
for(var integer i:=0; i<sizeof(vl_tcIdxList); i:=i+1) {
f_EPTF_ExecCtrlClient_restoreTCData(vl_tcIdxList[i]);
}
}
private function f_EPTF_ExecCtrlClient_restoreTCData(
in integer pl_tcIdx //traffic case abs index in LGenBase
) runs on EPTF_ExecCtrlClient_CT {
v_ExecCtrlClient_pauseDataForTCs[pl_tcIdx] := c_EPTF_ExecCtrlClient_PauseData_default;
}
///////////////////////////////////////////////////////////
// Altstep: as_EPTF_ExecCtrlClient_MgmtIf_StartScenario
//
// Purpose:
// Handles <EPTF_ExecCtrl_StartScenario> messages from ExecCtrl
//
// Parameters:
// -
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
//
///////////////////////////////////////////////////////////
private altstep as_EPTF_ExecCtrlClient_MgmtIf_StartScenario() runs on EPTF_ExecCtrlClient_CT
{
var EPTF_ExecCtrl_StartScenario vl_StartScenario_msg;
[] ExecCtrlClient_MgmtIf_CP.receive(EPTF_ExecCtrl_StartScenario:?) -> value vl_StartScenario_msg
{
f_EPTF_ExecCtrlClient_debug("EPTF_ExecCtrl_StartScenario received...");
if (not f_EPTF_LGenBase_restoreScenario(vl_StartScenario_msg.eGrpName, vl_StartScenario_msg.scenarioName, false)) {/*to remove the warning*/};
var integer vl_eGrpIdx := f_EPTF_LGenBase_entityGrpNameIndex(vl_StartScenario_msg.eGrpName);
var integer vl_scIdx := f_EPTF_LGenBase_scNameIndexInEG(vl_eGrpIdx,vl_StartScenario_msg.scenarioName)
f_EPTF_ExecCtrlClient_restoreScenarioData(vl_eGrpIdx, vl_scIdx);
f_EPTF_ExecCtrlClient_startScenario(vl_eGrpIdx, vl_scIdx,true);
repeat;
}
}
///////////////////////////////////////////////////////////
// Altstep: as_EPTF_ExecCtrlClient_MgmtIf_StopScenario
//
// Purpose:
// Handles <EPTF_ExecCtrl_StopScenario> messages from ExecCtrl
//
// Parameters:
// -
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
//
///////////////////////////////////////////////////////////
private altstep as_EPTF_ExecCtrlClient_MgmtIf_StopScenario() runs on EPTF_ExecCtrlClient_CT
{
var EPTF_ExecCtrl_StopScenario vl_StopScenario_msg;
[] ExecCtrlClient_MgmtIf_CP.receive(EPTF_ExecCtrl_StopScenario:?) -> value vl_StopScenario_msg
{
f_EPTF_ExecCtrlClient_debug("EPTF_ExecCtrl_StopScenario received...");
var integer vl_eGrpIdx := f_EPTF_LGenBase_entityGrpNameIndex(vl_StopScenario_msg.eGrpName)
var integer vl_scIdx := f_EPTF_LGenBase_scNameIndexInEG(vl_eGrpIdx, vl_StopScenario_msg.scenarioName);
if(f_EPTF_LGenBase_isWeightedScenario(vl_eGrpIdx, vl_scIdx)) {
f_EPTF_LGenBase_stopWeightedScenarioByIdx(vl_eGrpIdx, vl_scIdx);
} else {
f_EPTF_LGenBase_stopScenarioByIdx(vl_eGrpIdx, vl_scIdx);
}
/*var integer vl_scenidx := f_EPTF_LGenBase_scenarioNameIndex(vl_StopScenario_msg.scenarioName);
for (var integer tcidx:=0;tcidx<sizeof(v_LGenBase_scenarioTypes[vl_scenidx].trafficCases);tcidx:=tcidx+1) {
f_EPTF_LGenBase_stopTrafficCase(
vl_StopScenario_msg.eGrpName,
vl_StopScenario_msg.scenarioName,
v_LGenBase_trafficCaseTypes[v_LGenBase_scenarioTypes[vl_scenidx].trafficCases[tcidx].tcTypeIdx].name // tcname
);
}*/
var EPTF_LGenBase_Scenario2Grp vl_scenario2Grp := {
eGrpName := vl_StopScenario_msg.eGrpName,
scenarioName := vl_StopScenario_msg.scenarioName
}
repeat;
}
}
///////////////////////////////////////////////////////////
// Altstep: as_EPTF_ExecCtrlClient_MgmtIf_ResetScenario
//
// Purpose:
// Handles <EPTF_ExecCtrl_ResetScenario> messages from ExecCtrl
//
// Parameters:
// -
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
//
///////////////////////////////////////////////////////////
private altstep as_EPTF_ExecCtrlClient_MgmtIf_ResetScenario() runs on EPTF_ExecCtrlClient_CT
{
var EPTF_ExecCtrl_ResetScenario vl_msg;
[] ExecCtrlClient_MgmtIf_CP.receive(EPTF_ExecCtrl_ResetScenario:?) -> value vl_msg
{
f_EPTF_ExecCtrlClient_debug("EPTF_ExecCtrl_ResetScenario received...");
if (not f_EPTF_LGenBase_restoreScenario(vl_msg.eGrpName, vl_msg.scenName, false)) {/*to remove the warning*/};
var integer vl_eGrpIdx := f_EPTF_LGenBase_entityGrpNameIndex(vl_msg.eGrpName)
var integer vl_scIdx := f_EPTF_LGenBase_scNameIndexInEG(vl_eGrpIdx, vl_msg.scenName);
f_EPTF_ExecCtrlClient_restoreScenarioData(vl_eGrpIdx, vl_scIdx);
repeat;
}
}
///////////////////////////////////////////////////////////
// Altstep: as_EPTF_ExecCtrlClient_MgmtIf_ResetStats
//
// Purpose:
// Handles <EPTF_ExecCtrl_ResetStats> messages from ExecCtrl
//
// Parameters:
// -
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
//
///////////////////////////////////////////////////////////
private altstep as_EPTF_ExecCtrlClient_MgmtIf_ResetStats() runs on EPTF_ExecCtrlClient_CT
{
var EPTF_ExecCtrl_ResetStats vl_msg;
[] ExecCtrlClient_MgmtIf_CP.receive(EPTF_ExecCtrl_ResetStats:?) -> value vl_msg
{
f_EPTF_ExecCtrlClient_debug("EPTF_ExecCtrl_ResetStats received...");
f_EPTF_LGenBase_resetStats();
repeat;
}
}
///////////////////////////////////////////////////////////
// Altstep: as_EPTF_ExecCtrlClient_MgmtIf_StartTrafficCase
//
// Purpose:
// Handles <EPTF_ExecCtrl_StartTrafficCase> messages from ExecCtrl
//
// Parameters:
// -
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
//
///////////////////////////////////////////////////////////
private altstep as_EPTF_ExecCtrlClient_MgmtIf_StartTrafficCase() runs on EPTF_ExecCtrlClient_CT
{
var EPTF_ExecCtrl_StartTrafficCase vl_StartTC_msg;
[] ExecCtrlClient_MgmtIf_CP.receive(EPTF_ExecCtrl_StartTrafficCase:?) -> value vl_StartTC_msg
{
f_EPTF_ExecCtrlClient_debug("EPTF_ExecCtrl_StartTrafficCase received...");
if (f_EPTF_LGenBase_get_restoreTCAtStartTC(
vl_StartTC_msg.eGrpName,
vl_StartTC_msg.scenName,
vl_StartTC_msg.tcName
)) {
if (not f_EPTF_LGenBase_restoreTC(
vl_StartTC_msg.eGrpName,
vl_StartTC_msg.scenName,
vl_StartTC_msg.tcName
)) {/*to remove the warning*/};
}
var integer vl_tcAbsIdx := f_EPTF_LGenBase_trafficCaseId(vl_StartTC_msg.eGrpName, vl_StartTC_msg.scenName, vl_StartTC_msg.tcName);
f_EPTF_ExecCtrlClient_restoreTCData(vl_tcAbsIdx);
f_EPTF_LGenBase_startTrafficCase(
vl_StartTC_msg.eGrpName,
vl_StartTC_msg.scenName,
vl_StartTC_msg.tcName
);
repeat;
}
}
///////////////////////////////////////////////////////////
// Altstep: as_EPTF_ExecCtrlClient_MgmtIf_StopTrafficCase
//
// Purpose:
// Handles <EPTF_ExecCtrl_StopTrafficCase> messages from ExecCtrl
//
// Parameters:
// -
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
//
///////////////////////////////////////////////////////////
private altstep as_EPTF_ExecCtrlClient_MgmtIf_StopTrafficCase() runs on EPTF_ExecCtrlClient_CT
{
var EPTF_ExecCtrl_StopTrafficCase vl_StopTC_msg;
[] ExecCtrlClient_MgmtIf_CP.receive(EPTF_ExecCtrl_StopTrafficCase:?) -> value vl_StopTC_msg
{
f_EPTF_ExecCtrlClient_debug("EPTF_ExecCtrl_StopTrafficCase received...");
f_EPTF_LGenBase_stopTrafficCase(
vl_StopTC_msg.eGrpName,
vl_StopTC_msg.scenName,
vl_StopTC_msg.tcName
);
repeat;
}
}
///////////////////////////////////////////////////////////
// Altstep: as_EPTF_ExecCtrlClient_MgmtIf_SingleShotTc
//
// Purpose:
// Handles <EPTF_ExecCtrl_SingleShotTc> messages from ExecCtrl
//
// Parameters:
// -
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
//
///////////////////////////////////////////////////////////
private altstep as_EPTF_ExecCtrlClient_MgmtIf_SingleShotTc() runs on EPTF_ExecCtrlClient_CT
{
var EPTF_ExecCtrl_SingleShotTc vl_msg;
[] ExecCtrlClient_MgmtIf_CP.receive(EPTF_ExecCtrl_SingleShotTc:?) -> value vl_msg
{
f_EPTF_ExecCtrlClient_debug("EPTF_ExecCtrl_SingleShotTc received...");
f_EPTF_LGenBase_singleShotTc(
vl_msg.eGrpName,
vl_msg.scName,
vl_msg.tcName,
vl_msg.eIdx//,
//vl_msg.enableLog
);
repeat;
}
}
///////////////////////////////////////////////////////////
// Altstep: as_EPTF_ExecCtrlClient_MgmtIf_Bye
//
// Purpose:
// Handles <EPTF_ExecCtrl_Bye> messages from ExecCtrl
//
// Parameters:
// -
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
//
///////////////////////////////////////////////////////////
private altstep as_EPTF_ExecCtrlClient_MgmtIf_Bye() runs on EPTF_ExecCtrlClient_CT
{
[] ExecCtrlClient_MgmtIf_CP.receive(EPTF_ExecCtrl_Bye:?)
{
f_EPTF_ExecCtrlClient_debug("EPTF_ExecCtrl_Bye received...");
ExecCtrlClient_MgmtIf_CP.send(EPTF_ExecCtrl_ByeAck:{});
v_ExecCtrlClient_byeReceived := true;
// if cleanup is not in progress and termination enabled:
if (v_ExecCtrlClient_initialized and tsp_EPTF_ExecCtrlClient_terminateIfExecCtrlTerminates) {
f_EPTF_Base_stop(none);
}
repeat;
}
}
///////////////////////////////////////////////////////////
// Altstep: as_EPTF_ExecCtrlClient_MgmtIf_ByeAck
//
// Purpose:
// Handles <EPTF_ExecCtrl_ByeAck> messages from ExecCtrl
//
// Parameters:
// -
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
//
///////////////////////////////////////////////////////////
private altstep as_EPTF_ExecCtrlClient_MgmtIf_ByeAck() runs on EPTF_ExecCtrlClient_CT
{
[] ExecCtrlClient_MgmtIf_CP.receive(EPTF_ExecCtrl_ByeAck:?)
{
f_EPTF_ExecCtrlClient_debug("EPTF_ExecCtrl_ByeAck received...");
v_ExecCtrlClient_byeAckReceived := true;
repeat;
}
}
private function f_EPTF_ExecCtrlClient_waitForByeAck() runs on EPTF_ExecCtrlClient_CT {
timer t_wait := 0.0;
t_wait.start;
alt {
[v_ExecCtrlClient_byeAckReceived] t_wait.timeout;
}
}
///////////////////////////////////////////////////////////
// Altstep: as_EPTF_ExecCtrlClient_MgmtIf_unhandledMsg
//
// Purpose:
// Catch unhandled messages of <EPTF_ExecCtrl_Mgmt_PT>
//
// Parameters:
// -
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
//
///////////////////////////////////////////////////////////
private altstep as_EPTF_ExecCtrlClient_MgmtIf_unhandledMsg() runs on EPTF_ExecCtrlClient_CT
{
[] ExecCtrlClient_MgmtIf_CP.receive
{
f_EPTF_ExecCtrlClient_error("************* Unhandled ExecCtrl message received *************");
//f_EPTF_Base_stopAll();
}
}
///////////////////////////////////////////////////////////
// Altstep: as_EPTF_ExecCtrlClient_MgmtIf
//
// Purpose:
// Management interface handler of EPTF_ExecCtrlClient feature
//
// Parameters:
// -
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
//
///////////////////////////////////////////////////////////
private altstep as_EPTF_ExecCtrlClient_MgmtIf() runs on EPTF_ExecCtrlClient_CT
{
[] as_EPTF_ExecCtrlClient_MgmtIf_UpdateActiveEntities() {};
[] as_EPTF_ExecCtrlClient_MgmtIf_UpdateCps() {}
[] as_EPTF_ExecCtrlClient_MgmtIf_UpdateScenarioCps();
[] as_EPTF_ExecCtrlClient_MgmtIf_UpdateStartDelay();
[] as_EPTF_ExecCtrlClient_MgmtIf_StartScenario() {}
[] as_EPTF_ExecCtrlClient_MgmtIf_StopScenario() {}
[] as_EPTF_ExecCtrlClient_MgmtIf_ResetScenario();
[] as_EPTF_ExecCtrlClient_MgmtIf_ResetStats();
[] as_EPTF_ExecCtrlClient_MgmtIf_StartTrafficCase();
[] as_EPTF_ExecCtrlClient_MgmtIf_StopTrafficCase();
[] as_EPTF_ExecCtrlClient_MgmtIf_SingleShotTc();
[] as_EPTF_ExecCtrlClient_MgmtIf_groupFinished();
[] as_EPTF_ExecCtrlClient_MgmtIf_pauseTC();
// R3 handlers:
[] as_EPTF_ExecCtrlClient_MgmtIf_CreateEntityGrp();
[] as_EPTF_ExecCtrlClient_MgmtIf_CreateEntityGrpList();
[] as_EPTF_ExecCtrlClient_MgmtIf_DeclarePhaseLists();
[] as_EPTF_ExecCtrlClient_MgmtIf_DeclareTcs();
[] as_EPTF_ExecCtrlClient_MgmtIf_CreateScenario();
[] as_EPTF_ExecCtrlClient_MgmtIf_handlePhaseMsgs(); // R3 phase handling
[] as_EPTF_ExecCtrlClient_MgmtIf_handleEndOfConfig();
[] as_EPTF_ExecCtrlClient_MgmtIf_handleGuiDone();
[] as_EPTF_ExecCtrlClient_MgmtIf_Bye();
[] as_EPTF_ExecCtrlClient_MgmtIf_ByeAck();
[] as_EPTF_ExecCtrlClient_MgmtIf_EofTest();
[] as_EPTF_ExecCtrlClient_MgmtIf_unhandledMsg() {}
}
// Functions using the R3 database
group R3 {
///////////////////////////////////////////////////////////
// Function: f_EPTF_ExecCtrlClient_readyToStart
//
// Purpose:
// sends "I am ready to start" message to ExecCtrl.
// The ExecCtrl will configure the clients if all LGens are ready to start
//
// Parameters:
// -
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
//
///////////////////////////////////////////////////////////
public function f_EPTF_ExecCtrlClient_readyToStart() runs on EPTF_ExecCtrlClient_CT {
f_EPTF_ExecCtrlClient_sendEntityResourceInfo();
v_ExecCtrlClient_started := true;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_ExecCtrlClient_sendEntityResourceInfo
//
// Purpose:
// Function for sending the LGen's resource availability
// list <EPTF_ExecCtrl_LGenResourceList> to EPTF_ExecCtrl
// component
//
// Parameters:
// -
//
// Return Value:
// -
//
// Errors & assertions:
// -
//
// Detailed Comments:
// Replaces f_EPTF_ExecCtrlClient_sendAvailableResourceList
//
///////////////////////////////////////////////////////////
private function f_EPTF_ExecCtrlClient_sendEntityResourceInfo() runs on EPTF_ExecCtrlClient_CT
{
f_EPTF_ExecCtrlClient_debug(%definitionId&": started...");
if (v_ExecCtrlClient_byeReceived) {
f_EPTF_ExecCtrlClient_debug(log2str("ResourceInfo not sent: ExecCtrl terminated."));
return;
}
//FIXME Is it required?
//f_EPTF_ExecCtrlClient_debug(log2str("v_LGenBase_entityTypes = ", v_LGenBase_entityTypes));
//f_EPTF_ExecCtrlClient_debug(log2str("v_LGenBase_behaviorTypes = ", v_LGenBase_behaviorTypes));
// FIXME: replace the code below to an LGenBase function call
var EPTF_ExecCtrl_LGenResourceInfoList tmp_rList := {};
var integer minOf_availCount := 0;
// var integer maxOf_usageCount := 0;
var integer minOf_maxCount := 0;
var integer availCount := 0;
// var integer usageCount := 0;
var integer maxCount := 0;
for (var integer i:=0;i<f_EPTF_LGenBase_getETypeCount();i:=i+1) {
tmp_rList[i].eType := f_EPTF_LGenBase_getETypeName(i);
tmp_rList[i].eAvail := f_EPTF_LGenBase_getETypeAvailableByIdx(i);//minOf_availCount;
tmp_rList[i].eMaxCount := f_EPTF_LGenBase_getETypeMaxCountByIdx(i);//minOf_maxCount;
}
f_EPTF_ExecCtrlClient_debug(log2str("tmp_rList = ", tmp_rList));
if (sizeof(tmp_rList)>0) {
f_EPTF_ExecCtrlClient_debug(log2str("Sending resource list: ", tmp_rList));
} else {
f_EPTF_ExecCtrlClient_debug("empty resource list");
}
ExecCtrlClient_MgmtIf_CP.send(EPTF_ExecCtrl_EntityResourceInfo:{
lgenName := f_EPTF_Base_selfName(),
available := tmp_rList
});
f_EPTF_ExecCtrlClient_debug(%definitionId&": finished...");
}
private altstep as_EPTF_ExecCtrlClient_MgmtIf_CreateEntityGrp() runs on EPTF_ExecCtrlClient_CT
{
var EPTF_ExecCtrl_CreateEntityGrp vl_msg;
[] ExecCtrlClient_MgmtIf_CP.receive(EPTF_ExecCtrl_CreateEntityGrp:?) -> value vl_msg
{
f_EPTF_ExecCtrlClient_debug("EPTF_ExecCtrl_CreateEntityGrp received...");
// create Entity Group
var integer myETypeIdx;
myETypeIdx := f_EPTF_LGenBase_entityTypeNameIndex(vl_msg.eType);
if (myETypeIdx<0) {
f_EPTF_ExecCtrlClient_error(log2str("ERROR: unknown entityType in create entity group ",vl_msg,": ", vl_msg.eType));
//f_EPTF_Base_stopAll();
} else {
f_EPTF_ExecCtrlClient_debug(log2str("creating entityGroup: ", vl_msg));
// store entity group data:
f_EPTF_ExecCtrlClient_storeEGrpData(vl_msg);
var integer vl_grpSize := f_EPTF_LGenBase_createEntityGroup(
{
vl_msg.name,
vl_msg.eType,
vl_msg.eCount
}
);
f_EPTF_LGenBase_setTrafficCorrigationForEGrp(vl_msg.name,vl_msg.trafficCorrigation);
f_EPTF_ExecCtrlClient_debug(log2str("size of created entity group ", vl_msg.name, ": ", vl_grpSize));
}
f_EPTF_ExecCtrlClient_sendEntityResourceInfo();
//FIXME
//f_EPTF_ExecCtrlClient_debug(log2str("v_LGenBase_entityGroups = ", v_LGenBase_entityGroups));
repeat;
}
}
// initializes eGrp database
private function f_EPTF_ExecCtrlClient_initEGrpDB()
runs on EPTF_ExecCtrlClient_CT {
v_EPTF_ExecCtrlClient_eGrpHash := f_EPTF_str2int_HashMap_New(c_ExecCtrlClient_eGrpHashMapName);
}
// cleans up eGrp database
private function f_EPTF_ExecCtrlClient_cleanupEGrpDB()
runs on EPTF_ExecCtrlClient_CT {
f_EPTF_str2int_HashMap_Delete(c_ExecCtrlClient_eGrpHashMapName);
v_EPTF_ExecCtrlClient_eGrpHash := c_ExecCtrl_invalidIdx;
}
// stores the offsets of the entityGroup
private function f_EPTF_ExecCtrlClient_storeEGrpData(in EPTF_ExecCtrl_CreateEntityGrp pl_eGrpData) runs on EPTF_ExecCtrlClient_CT {
f_EPTF_str2int_HashMap_Insert(v_EPTF_ExecCtrlClient_eGrpHash, pl_eGrpData.name&".gOffset", pl_eGrpData.gOffset);
f_EPTF_str2int_HashMap_Insert(v_EPTF_ExecCtrlClient_eGrpHash, pl_eGrpData.name&".gCount", pl_eGrpData.gCount);
f_EPTF_str2int_HashMap_Insert(v_EPTF_ExecCtrlClient_eGrpHash, pl_eGrpData.name&".eOffset", pl_eGrpData.eOffset);
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_ExecCtrlClient_getFirstEntityGlobalOffset
//
// Purpose:
// returns the global offset of the first entity of the entity group deployed on this LGen
//
// Parameters:
// -
//
// Return Value:
// integer - the global offset of the first entity of the entity group deployed on this LGen, -1 if not found
//
// Errors:
// -
//
// Detailed Comments:
//
//
///////////////////////////////////////////////////////////
public function f_EPTF_ExecCtrlClient_getFirstEntityGlobalOffset(in charstring pl_eGrpName)
runs on EPTF_ExecCtrlClient_CT
return integer {
var integer vl_idx := -1;
if (not f_EPTF_str2int_HashMap_Find(
v_EPTF_ExecCtrlClient_eGrpHash,
pl_eGrpName&".eOffset",
vl_idx)) {
f_EPTF_ExecCtrlClient_warning(%definitionId&": Cannot find first entity global offset for entity group "&pl_eGrpName&" in database.");
return -1;
}
return vl_idx;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_ExecCtrlClient_getEntityGroupGlobalOffset
//
// Purpose:
// returns the global offset of the first entity of the entity group
//
// Parameters:
// -
//
// Return Value:
// integer - the global offset of the first entity of the entity group, -1 if not found
//
// Errors:
// -
//
// Detailed Comments:
//
//
///////////////////////////////////////////////////////////
public function f_EPTF_ExecCtrlClient_getEntityGroupGlobalOffset(in charstring pl_eGrpName)
runs on EPTF_ExecCtrlClient_CT
return integer {
var integer vl_idx := -1;
if (not f_EPTF_str2int_HashMap_Find(
v_EPTF_ExecCtrlClient_eGrpHash,
pl_eGrpName&".gOffset",
vl_idx)) {
f_EPTF_ExecCtrlClient_warning(%definitionId&": Cannot find global offset for entity group "&pl_eGrpName&" in database.");
return -1;
}
return vl_idx;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_ExecCtrlClient_getFirstEntityOffsetInEGrp
//
// Purpose:
// returns the relative offset of the first entity of the entity group deployed on this LGen in the entity group
//
// Parameters:
// -
//
// Return Value:
// integer - the relative offset of the first entity of the entity group deployed on this LGen in the entity group, -1 if not found
//
// Errors:
// -
//
// Detailed Comments:
// The returned index will be in the range: 0-eGrpSize, or -1 if not found
//
//
///////////////////////////////////////////////////////////
public function f_EPTF_ExecCtrlClient_getFirstEntityOffsetInEGrp(in charstring pl_eGrpName)
runs on EPTF_ExecCtrlClient_CT
return integer {
var integer vl_idx := -1;
var integer gOffset := f_EPTF_ExecCtrlClient_getEntityGroupGlobalOffset(pl_eGrpName);
var integer eOffset := f_EPTF_ExecCtrlClient_getFirstEntityGlobalOffset(pl_eGrpName);
if (gOffset==-1 or eOffset==-1) {
f_EPTF_ExecCtrlClient_warning(%definitionId&": Cannot find relative offset of the first entity in the entity group "&pl_eGrpName&" in database.");
return -1;
}
return eOffset-gOffset;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_ExecCtrlClient_getEntityGroupSize
//
// Purpose:
// returns the size of the of the entity group
//
// Parameters:
// -
//
// Return Value:
// integer - the size of the of the entity group, -1 if not found
//
// Errors:
// -
//
// Detailed Comments:
//
//
///////////////////////////////////////////////////////////
public function f_EPTF_ExecCtrlClient_getEntityGroupSize(in charstring pl_eGrpName)
runs on EPTF_ExecCtrlClient_CT
return integer {
var integer vl_idx := -1;
if (not f_EPTF_str2int_HashMap_Find(
v_EPTF_ExecCtrlClient_eGrpHash,
pl_eGrpName&".gCount",
vl_idx)) {
f_EPTF_ExecCtrlClient_warning(%definitionId&": Cannot find size for entity group "&pl_eGrpName&" in database.");
return -1;
}
return vl_idx;
}
private altstep as_EPTF_ExecCtrlClient_MgmtIf_CreateEntityGrpList() runs on EPTF_ExecCtrlClient_CT
{
var EPTF_ExecCtrl_CreateEntityGrpList vl_msg;
[] ExecCtrlClient_MgmtIf_CP.receive(EPTF_ExecCtrl_CreateEntityGrpList:?) -> value vl_msg
{
f_EPTF_ExecCtrlClient_debug("EPTF_ExecCtrl_CreateEntityGrpList received...");
for(var integer i:=0; i<sizeof(vl_msg); i:=i+1) {
// create Entity Group
var integer myETypeIdx;
myETypeIdx := f_EPTF_LGenBase_entityTypeNameIndex(vl_msg[i].eType);
if (myETypeIdx<0) {
f_EPTF_ExecCtrlClient_error(log2str("ERROR: unknown entityType in create entity group ",vl_msg[i],": ", vl_msg[i].eType));
//f_EPTF_Base_stopAll();
} else {
f_EPTF_ExecCtrlClient_debug(log2str("creating entityGroup: ", vl_msg[i]));
// store entity group data:
f_EPTF_ExecCtrlClient_storeEGrpData(vl_msg[i]);
var integer vl_grpSize := f_EPTF_LGenBase_createEntityGroup(
{
vl_msg[i].name,
vl_msg[i].eType,
vl_msg[i].eCount
}
);
f_EPTF_LGenBase_setTrafficCorrigationForEGrp(vl_msg[i].name,vl_msg[i].trafficCorrigation);
f_EPTF_ExecCtrlClient_debug(log2str("size of created entity group ", vl_msg[i].name, ": ", vl_grpSize));
}
}
f_EPTF_ExecCtrlClient_sendEntityResourceInfo();
//FIXME
//f_EPTF_ExecCtrlClient_debug(log2str("v_LGenBase_entityGroups = ", v_LGenBase_entityGroups));
repeat;
}
}
private altstep as_EPTF_ExecCtrlClient_MgmtIf_DeclarePhaseLists() runs on EPTF_ExecCtrlClient_CT
{
var EPTF_ExecCtrl_DeclarePhaseLists vl_msg;
[] ExecCtrlClient_MgmtIf_CP.receive(EPTF_ExecCtrl_DeclarePhaseLists:?) -> value vl_msg
{
f_EPTF_ExecCtrlClient_debug("EPTF_ExecCtrl_DeclarePhaseLists received...");
f_EPTF_LGenBase_PhaseList_Declarators_store(vl_msg);
f_EPTF_ExecCtrlClient_debug(log2str("PhaseLists declared ", vl_msg));
repeat;
}
}
private altstep as_EPTF_ExecCtrlClient_MgmtIf_DeclareTcs() runs on EPTF_ExecCtrlClient_CT
{
var EPTF_ExecCtrl_DeclareTcs vl_msg;
[] ExecCtrlClient_MgmtIf_CP.receive(EPTF_ExecCtrl_DeclareTcs:?) -> value vl_msg
{
f_EPTF_ExecCtrlClient_debug("EPTF_ExecCtrl_DeclareTcs received...");
for(var integer i:=0; i<sizeof(vl_msg); i:=i+1) {
// declare traffic case
if (-1==f_EPTF_LGenBase_declareTrafficCaseTypeInternal(vl_msg[i])) {/*to remove the warning*/};
f_EPTF_ExecCtrlClient_debug(log2str("Traffic case declared ", vl_msg[i]));
}
repeat;
}
}
// notifies ExecCtrl that I am ready to run
private function f_EPTF_ExecCtrlClient_readyToRun() runs on EPTF_ExecCtrlClient_CT {
if (v_ExecCtrlClient_byeReceived) {
f_EPTF_ExecCtrlClient_debug(log2str("ReadyToRun not sent: ExecCtrl terminated."));
return;
}
ExecCtrlClient_MgmtIf_CP.send(EPTF_ExecCtrl_ReadyToRun:{});
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_ExecCtrlClient_checkEndOfConfig
//
// Purpose:
// Returns true when the configuration of the ExecCtrlClient is finished,
// and all scenarioInitializedCallback function registered by <f_EPTF_ExecCtrlClient_set_scenarioInitialized_fcb>
// finished its operation
//
// Parameters:
// -
//
// Return Value:
// boolean - true when the configuration of the ExecCtrlClient is finished
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_ExecCtrlClient_checkEndOfConfig() runs on EPTF_ExecCtrlClient_CT return boolean {
return (v_ExecCtrlClient_semaphore_EndOfConfig and v_ExecCtrlClient_semaphore_DeclareScenario==0);
}
private altstep as_EPTF_ExecCtrlClient_MgmtIf_handleEndOfConfig() runs on EPTF_ExecCtrlClient_CT {
var EPTF_ExecCtrl_EndOfConfig vl_msg;
[] ExecCtrlClient_MgmtIf_CP.receive(EPTF_ExecCtrl_EndOfConfig:?) -> value vl_msg {
if(f_EPTF_Base_cleanupIsInProgress()){
// cleanup is not in progress.
f_EPTF_ExecCtrlClient_debug("EPTF_ExecCtrl_EndOfConfig received...");
v_ExecCtrlClient_semaphore_EndOfConfig := true;
f_EPTF_LGenBase_setDataSource(vl_msg.dataSourceCompRef);
} else {
// cleanup is in progress.
f_EPTF_ExecCtrlClient_debug("EPTF_ExecCtrl_EndOfConfig received, but cleanup is already running...");
}
repeat;
}
// wait until all scenarios are created and EPTF_ExecCtrl_EndOfConfig is received:
[f_EPTF_ExecCtrlClient_checkEndOfConfig()] t_EPTF_ExecCtrlClient_semaphoreTimer.timeout {
f_EPTF_ExecCtrlClient_debug("All scenarios are declared, configuration ended.");
// all scenarios are ready.
f_EPTF_ExecCtrlClient_callEndOfConfigCallbacks();
f_EPTF_ExecCtrlClient_readyToRun();
repeat;
}
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_ExecCtrlClient_checkGuiDone
//
// Purpose:
// Returns true when the creation of the GUI is finished
//
// Parameters:
// -
//
// Return Value:
// boolean - true when the creation of the GUI is finished
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_ExecCtrlClient_checkGuiDone()
runs on EPTF_ExecCtrlClient_CT
return boolean {
return v_EPTF_ExecCtrlClient_guiDone;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_ExecCtrlClient_checkGuiDoneReported
//
// Purpose:
// Returns true when the GUIDone was reported to ExecCtrl by <f_EPTF_ExecCtrlClient_reportGUIDone>
//
// Parameters:
// -
//
// Return Value:
// boolean - true when the creation of the GUI is finished
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_ExecCtrlClient_checkGuiDoneReported()
runs on EPTF_ExecCtrlClient_CT
return boolean {
return v_EPTF_ExecCtrlClient_guiDoneReported;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_ExecCtrlClient_reportGUIDone
//
// Purpose:
// Reports GUIDone to ExecCtrl
//
// Parameters:
// -
//
// Return Value:
// -
//
// Errors:
// -
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_ExecCtrlClient_reportGUIDone() runs on EPTF_ExecCtrlClient_CT {
if (v_EPTF_ExecCtrlClient_guiDoneReported or not v_EPTF_ExecCtrlClient_guiDone) {
return; // prevent reporting multiple times or before ExecCtrl GUI is ready
}
if (not v_ExecCtrlClient_byeReceived) {
ExecCtrlClient_MgmtIf_CP.send(EPTF_ExecCtrl_GuiDone:{v_EPTF_ExecCtrlClient_guiPresent});
} else {
f_EPTF_ExecCtrlClient_debug(log2str("GUIDone not sent: ExecCtrl terminated."));
}
v_EPTF_ExecCtrlClient_guiDoneReported := true;
}
private altstep as_EPTF_ExecCtrlClient_MgmtIf_handleGuiDone() runs on EPTF_ExecCtrlClient_CT {
var EPTF_ExecCtrl_GuiDone vl_guiDone;
[] ExecCtrlClient_MgmtIf_CP.receive(EPTF_ExecCtrl_GuiDone:?) -> value vl_guiDone {
v_EPTF_ExecCtrlClient_guiPresent := vl_guiDone.guiPresent;
f_EPTF_ExecCtrlClient_debug("EPTF_ExecCtrl_GuiDone received...");
f_EPTF_ExecCtrlClient_callGuiDoneCallbackForFSMStats();
// call user callbacks:
f_EPTF_ExecCtrlClient_callGuiDoneCallbacks();
v_EPTF_ExecCtrlClient_guiDone := true;
// send gui done to execCtrl to synchronize:
if (v_EPTF_ExecCtrlClient_autoReportGuiDone) {
f_EPTF_ExecCtrlClient_reportGUIDone(); // GUIDone is reported automatically
}
repeat;
}
}
friend function f_EPTF_ExecCtrlClient_guiPresent() runs on EPTF_ExecCtrlClient_CT return boolean {
return v_EPTF_ExecCtrlClient_guiPresent
}
private function f_EPTF_ExecCtrlClient_createScenarioStatusVar(in charstring pl_eGrpName, in charstring pl_scName) runs on EPTF_ExecCtrlClient_CT {
// create new alias variable for scenario status:
var charstring vl_varName := "ExecCtrlClient.scenarioStatus."&pl_eGrpName&"."&pl_scName;
var integer vl_idx;
vl_idx := f_EPTF_Var_getId(vl_varName);
if (vl_idx != -1) {
return; // already exists
}
f_EPTF_Var_newCharstring(vl_varName,"",vl_idx);
// connect it to the LGenBaseStats scenario state:
var charstring vl_varNameBase := f_EPTF_LGenBaseStats_getScNamePrefix(pl_eGrpName,pl_scName);
vl_varName := vl_varNameBase&c_EPTF_LGenBaseStats_nameOfScStateName;
var integer vl_lgenBaseVarIdx := f_EPTF_Var_getId(vl_varName);
// this is never true, but kept for safety:
if (vl_lgenBaseVarIdx==-1) {
f_EPTF_ExecCtrlClient_debug(log2str("You should not see this: ", vl_varName, "!"));
f_EPTF_Var_adjustContent(vl_idx,{charstringVal := "StateUpdateError"});
return;
}
f_EPTF_Var_subscribeLocal(
vl_idx,
{
calcFn := {
funcRef := refers(f_EPTF_ExecCtrlClient_scenarioStateCalcFn),
argList := {vl_lgenBaseVarIdx},
nonVarArgList := {}
}
}
);
}
private function f_EPTF_ExecCtrlClient_createTrafficCaseStatusVar(in charstring pl_eGrpName, in charstring pl_scName, in charstring pl_tcName) runs on EPTF_ExecCtrlClient_CT {
// create new alias variable for scenario status:
var charstring vl_varName := "ExecCtrlClient.trafficCaseStatus."&pl_eGrpName&"."&pl_scName&"."&pl_tcName;
var integer vl_idx;
vl_idx := f_EPTF_Var_getId(vl_varName);
if (vl_idx != -1) {
return; // already exists
}
f_EPTF_Var_newCharstring(vl_varName,"",vl_idx);
// connect it to the LGenBaseStats scenario state:
var charstring vl_varNameBase := f_EPTF_LGenBaseStats_getNamePrefix(pl_eGrpName,pl_scName,pl_tcName);
vl_varName := vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcStateName;
var integer vl_lgenBaseVarIdx := f_EPTF_Var_getId(vl_varName);
// this is never true, but kept for safety:
if (vl_lgenBaseVarIdx==-1) {
f_EPTF_ExecCtrlClient_debug(log2str("You should not see this: ", vl_varName, "!"));
f_EPTF_Var_adjustContent(vl_idx,{charstringVal := "StateUpdateError"});
return;
}
f_EPTF_Var_subscribeLocal(
vl_idx,
{
calcFn := {
funcRef := refers(f_EPTF_ExecCtrlClient_scenarioStateCalcFn),
argList := {vl_lgenBaseVarIdx},
nonVarArgList := {}
}
}
);
}
private function f_EPTF_ExecCtrlClient_declareScenario(in EPTF_LGenBase_ScenarioTypeInternalDeclarator vl_scType, in EPTF_ExecCtrl_NamesInScenario pl_scNames) runs on EPTF_ExecCtrlClient_CT {
/*
// convert universal declarator to decl2 or weighted decl:
if (ispresent(vl_scType.weightedScData)) {
var EPTF_ExecCtrl_DeclareScenario3 vl_declareScenario3 := {
name := vl_scType.name,
enabled := vl_scType.enabled,
cpsToReach := vl_scType.weightedScData.cpsToReach,
lockCPS := false,
weightedScData := {
deterministicMix := vl_scType.weightedScData.deterministicMix
},
tcList := {}
};
for(var integer tc:=0; tc<sizeof(vl_scType.tcList);tc:=tc+1) {
vl_declareScenario3.tcList[tc] := {
tcName := pl_scNames.tcNames[tc],
//float startDelay,
tcWeight := vl_scType.tcList[tc].target.trafficWeight,
enableEntities := vl_scType.tcList[tc].enableEntities,
enable := vl_scType.tcList[tc].enable,
ranges := vl_scType.tcList[tc].ranges,
params := vl_scType.tcList[tc].params,
//finishConditions
groupFinishConditions := vl_scType.tcList[tc].groupFinishConditions,
entityFinishConditions := vl_scType.tcList[tc].entityFinishConditions,
//actionLists
entityFinishActions := vl_scType.tcList[tc].entityFinishActions,
tcFinishActions := vl_scType.tcList[tc].tcFinishActions
}
}
f_EPTF_LGenBase_declareWeightedScenarioType(vl_declareScenario3);
} else {
var EPTF_ExecCtrl_DeclareScenario2 vl_declareScenario2 := {
name := vl_scType.name,
tcList := {}
};
for(var integer tc:=0; tc<sizeof(vl_scType.tcList);tc:=tc+1) {
vl_declareScenario2.tcList[tc] := {
tcName := pl_scNames.tcNames[tc],
startDelay := vl_scType.tcList[tc].startDelay,
cpsToReach := vl_scType.tcList[tc].target.cpsToReach,
enableEntities := vl_scType.tcList[tc].enableEntities,
enable := vl_scType.tcList[tc].enable,
ranges := vl_scType.tcList[tc].ranges,
params := vl_scType.tcList[tc].params,
//finishConditions
groupFinishConditions := vl_scType.tcList[tc].groupFinishConditions,
entityFinishConditions := vl_scType.tcList[tc].entityFinishConditions,
//actionLists
entityFinishActions := vl_scType.tcList[tc].entityFinishActions,
tcFinishActions := vl_scType.tcList[tc].tcFinishActions
}
}
f_EPTF_LGenBase_declareScenarioType2(vl_declareScenario2);
}
*/
// declare scenario using the latest declararor type:
f_EPTF_ExecCtrlClient_debug(log2str("Declaring Scenario ", vl_scType, " names: ", pl_scNames));
v_ExecCtrlClient_semaphore_DeclareScenario := v_ExecCtrlClient_semaphore_DeclareScenario + 1;
if (-1==f_EPTF_LGenBase_declareScenarioTypeInternal(vl_scType)) {
/*to remove the warning*/
}
f_EPTF_LGenBase_createScenario2EntityGroup(
{pl_scNames.eGrpName,pl_scNames.scTypeName},
false
);
if (v_ExecCtrlClient_scenarioInitialized_fcb!=null) {
f_EPTF_ExecCtrlClient_debug(log2str("Calling callback fn: ", v_ExecCtrlClient_scenarioInitialized_fcb));
v_ExecCtrlClient_scenarioInitialized_fcb.apply({pl_scNames.eGrpName,pl_scNames.scTypeName});
}
v_ExecCtrlClient_semaphore_DeclareScenario := v_ExecCtrlClient_semaphore_DeclareScenario - 1;
f_EPTF_ExecCtrlClient_debug(log2str("Scenario ", pl_scNames.scTypeName, " added to eGrp: ", pl_scNames.eGrpName));
}
private altstep as_EPTF_ExecCtrlClient_MgmtIf_CreateScenario() runs on EPTF_ExecCtrlClient_CT
{
var EPTF_ExecCtrl_CreateScenario vl_msg;
[] ExecCtrlClient_MgmtIf_CP.receive(EPTF_ExecCtrl_CreateScenario:?) -> value vl_msg
{
f_EPTF_ExecCtrlClient_debug("EPTF_ExecCtrl_CreateScenario received...");
for(var integer sc:=0; sc<sizeof(vl_msg.scList); sc:=sc+1) {
f_EPTF_ExecCtrlClient_declareScenario(vl_msg.scList[sc],vl_msg.scNames[sc]);
f_EPTF_ExecCtrlClient_createScenarioStatusVar(vl_msg.scNames[sc].eGrpName,vl_msg.scNames[sc].scTypeName);
for(var integer tc:=0; tc<sizeof(vl_msg.scNames[sc].tcNames);tc:=tc+1) {
f_EPTF_ExecCtrlClient_createTrafficCaseStatusVar(vl_msg.scNames[sc].eGrpName,vl_msg.scNames[sc].scTypeName,vl_msg.scNames[sc].tcNames[tc]);
}
}
repeat;
}
}
// R3: final test report generation
group EPTF_ExecCtrlClient_FinalTestReport {
///////////////////////////////////////////////////////////
// Function: f_EPTF_ExecCtrlClient_registerFinalTestReportGeneratorFn
//
// Purpose:
// registers callback function to generate final test report
//
// Parameters:
// pl_reportGeneratorFn - in <EPTF_ExecCtrl_FinalTestReportGenerator_FT> - the report generator fn to register
//
// Return Value:
//
// Errors:
//
// Detailed Comments:
// called when the end of test execution detected:
// exit event detected in any of the LGens, or the Exit button pressed
//
///////////////////////////////////////////////////////////
public function f_EPTF_ExecCtrlClient_registerFinalTestReportGeneratorFn(in EPTF_ExecCtrl_FinalTestReportGenerator_FT pl_reportGeneratorFn)
runs on EPTF_ExecCtrlClient_CT {
v_EPTF_ExecCtrlClient_finalTestReportGeneratorFns[sizeof(v_EPTF_ExecCtrlClient_finalTestReportGeneratorFns)] := pl_reportGeneratorFn;
}
///////////////////////////////////////////////////////////
// Function: f_EPTF_ExecCtrlClient_deregisterFinalTestReportGeneratorFn
//
// Purpose:
// removes the callback function registered earlier by <f_EPTF_ExecCtrl_registerFinalTestReportGeneratorFn>
//
// Parameters:
// pl_reportGeneratorFn - in <EPTF_ExecCtrl_FinalTestReportGenerator_FT> - the report generator fn to deregister
//
// Return Value:
//
// Errors:
//
// Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_ExecCtrlClient_deregisterFinalTestReportGeneratorFn(in EPTF_ExecCtrl_FinalTestReportGenerator_FT pl_reportGeneratorFn)
runs on EPTF_ExecCtrlClient_CT {
for(var integer i:=0; i<sizeof(v_EPTF_ExecCtrlClient_finalTestReportGeneratorFns); i:=i+1) {
if(v_EPTF_ExecCtrlClient_finalTestReportGeneratorFns[i]==pl_reportGeneratorFn) {
v_EPTF_ExecCtrlClient_finalTestReportGeneratorFns[i] := null;
}
}
}
// calls all F.T.R. generator functions
private function f_EPTF_ExecCtrlClient_callFinalTestReportGeneratorFns(inout charstring pl_report)
runs on EPTF_ExecCtrlClient_CT {
for(var integer i:=0; i<sizeof(v_EPTF_ExecCtrlClient_finalTestReportGeneratorFns); i:=i+1) {
if(v_EPTF_ExecCtrlClient_finalTestReportGeneratorFns[i]!=null) {
f_EPTF_ExecCtrlClient_debug(log2str(%definitionId&": Calling final test report generator function: ",v_EPTF_ExecCtrlClient_finalTestReportGeneratorFns[i]));
v_EPTF_ExecCtrlClient_finalTestReportGeneratorFns[i].apply(pl_report);
f_EPTF_ExecCtrlClient_debug(log2str(%definitionId&": Final test report generator function finished: ",v_EPTF_ExecCtrlClient_finalTestReportGeneratorFns[i]));
}
}
}
// sends EofTest request to ExecCtrl
private function f_EPTF_ExecCtrlClient_sendEofTest()
runs on EPTF_ExecCtrlClient_CT {
if (v_ExecCtrlClient_byeReceived) {
f_EPTF_ExecCtrlClient_debug(log2str("EofTest not sent: ExecCtrl terminated."));
return;
}
ExecCtrlClient_MgmtIf_CP.send(EPTF_ExecCtrl_EofTest:{});
}
// sends EofTestDone to ExecCtrl
private function f_EPTF_ExecCtrlClient_sendEofTestDone(in charstring pl_reportMsg)
runs on EPTF_ExecCtrlClient_CT {
if (v_ExecCtrlClient_byeReceived) {
f_EPTF_ExecCtrlClient_debug(log2str("EofTestDone not sent: ExecCtrl terminated."));
return;
}
ExecCtrlClient_MgmtIf_CP.send(EPTF_ExecCtrl_EofTestDone:{pl_reportMsg});
}
private function f_EPTF_ExecCtrlClient_testFinishedListener(
EPTF_LGenBase_ReportedEventDescriptor pl_event,
EPTF_IntegerList pl_listenerArgs)
runs on EPTF_ExecCtrlClient_CT{
//v_ExecCtrlClient_testFinished := true;
f_EPTF_ExecCtrlClient_debug(log2str("Test finished in ",f_EPTF_Base_selfName()));
// send EofTest to ExecCtrl
f_EPTF_ExecCtrlClient_sendEofTest();
}
// handles EofTest/EofTestDone messages coming from the ExecCtrl
private altstep as_EPTF_ExecCtrlClient_MgmtIf_EofTest() runs on EPTF_ExecCtrlClient_CT
{
var EPTF_ExecCtrl_EofTest vl_msg;
[] ExecCtrlClient_MgmtIf_CP.receive(EPTF_ExecCtrl_EofTest:?) -> value vl_msg {
var charstring vl_reportMsg := "";
f_EPTF_ExecCtrlClient_callFinalTestReportGeneratorFns(vl_reportMsg);
f_EPTF_ExecCtrlClient_sendEofTestDone(vl_reportMsg);
repeat;
}
}
}
} // group R3
} // module