test/ExecCtrl/EPTF_ExecCtrl_Test_Functions.ttcn

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// 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_ExecCtrl_Test_Functions
//
//  Purpose:
//    This module contains the functions of the EPTF ExecCtrl test enviroment.
//
//  Module depends on:
//   <EPTF_CLL_Base_Definitions>
//   <EPTF_CLL_Base_Functions>
//   <EPTF_CLL_Common_Definitions>
//   <EPTF_CLL_LGenBase_Definitions>
//   <EPTF_CLL_LGenBase_Functions>
//   <EPTF_CLL_LGenBase_ConfigDefinitions>
//   <EPTF_CLL_LGenBase_ConfigFunctions>
//   <EPTF_CLL_LGenBase_PhaseFunctions>
//   <EPTF_CLL_LGenBase_PhaseDefinitions>
//   <EPTF_CLL_LGenBase_TrafficFunctions>
//   <EPTF_CLL_LGenBase_StepFunctions>
//   <EPTF_CLL_LGenBaseStats_Functions>
//   <EPTF_CLL_LGenBaseStats_Definitions>
//   <EPTF_CLL_LoadRegulator_Functions>
//   <EPTF_CLL_ExecCtrlTimeProfile_Definitions>
//   <EPTF_CLL_ExecCtrl_Functions>
//   <EPTF_CLL_ExecCtrl_Definitions>
//   <EPTF_CLL_HashMapStr2Int_Functions>
//   <EPTF_CLL_UIHandler_Definitions>
//   <EPTF_CLL_ExecCtrlUIHandler_Definitions>
//   <EPTF_CLL_ExecCtrlUIHandler_Functions>
//   <EPTF_CLL_ExecCtrlClient_Functions>
//   <EPTF_CLL_ExecCtrl_ScenarioFunctions>
//   <EPTF_CLL_ExecCtrl_ScenarioDefinitions>
//   <EPTF_CLL_ExecCtrl_PhaseFunctions>
//   <EPTF_CLL_UIHandler_WidgetFunctions>
//   <EPTF_CLL_UIHandlerClient_Functions>
//   <EPTF_CLL_Variable_Definitions>
//   <EPTF_CLL_Variable_Functions>
//   <EPTF_CLL_Logging_Functions>
//   <EPTF_CLL_StatHandler_Definitions>
//
//  Current Owner:
//    Balazs Barcsik (EBALBAR)
//
//  Last Review Date:
//    2007-xx-xx
//
//  Detailed Comments:
//    -
//
///////////////////////////////////////////////////////////////
module EPTF_ExecCtrl_Test_Functions {

//=========================================================================
// Import Part
//=========================================================================

import from EPTF_ExecCtrl_Test_Definitions all;

import from EPTF_CLL_Base_Definitions all;
import from EPTF_CLL_Base_Functions all;
import from EPTF_CLL_Common_Definitions 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_ConfigFunctions all;
import from EPTF_CLL_LGenBase_PhaseFunctions all;
import from EPTF_CLL_LGenBase_PhaseDefinitions all;
import from EPTF_CLL_LGenBase_TrafficFunctions all;
import from EPTF_CLL_LGenBase_StepFunctions all;
import from EPTF_CLL_LGenBaseStats_Functions all;
import from EPTF_CLL_LGenBaseStats_Definitions all;
import from EPTF_CLL_LoadRegulator_Functions all;
import from EPTF_CLL_LoadRegulator_Definitions all;
import from EPTF_CLL_ExecCtrlTimeProfile_Definitions all;
import from EPTF_CLL_LGenBase_EventHandlingFunctions all;
import from EPTF_CLL_ExecCtrl_Functions all;
import from EPTF_CLL_ExecCtrl_Definitions all;
import from EPTF_CLL_ExecCtrlClient_Functions all;
import from EPTF_CLL_ExecCtrl_ScenarioFunctions all;
import from EPTF_CLL_ExecCtrl_ScenarioDefinitions all;
import from EPTF_CLL_ExecCtrl_PhaseDefinitions all;
import from EPTF_CLL_ExecCtrl_PhaseFunctions all;
import from EPTF_CLL_HashMapStr2Int_Functions all;
import from EPTF_CLL_UIHandler_Definitions all;
import from EPTF_CLL_ExecCtrlUIHandler_Definitions all;
import from EPTF_CLL_ExecCtrlUIHandler_Functions all;
import from EPTF_CLL_UIHandler_WidgetFunctions all;
import from EPTF_CLL_UIHandler_XULFunctions all;

import from EPTF_CLL_UIHandlerClient_Functions all;
import from EPTF_CLL_Variable_Definitions all;
import from EPTF_CLL_Variable_Functions all;

import from EPTF_CLL_StatHandlerClient_Definitions all;

import from EPTF_CLL_UIHandlerCLI_Definitions all;
import from EPTF_CLL_DataSource_Definitions all;
import from EPTF_CLL_DataSource_Functions all;
import from EPTF_CLL_DataSourceClient_Functions all;
import from EPTF_CLL_StatMeasure_Functions all;
import from EPTF_CLL_Logging_Functions all;
import from EPTF_CLL_StatHandler_Definitions all;
import from TCCConversion_Functions all;
import from ttcn_ericsson_se_protocolModules_xtdp_xtdl all;


group DefaultLGen {

  function f_EPTF_ExecCtrl_CLITest_defaultLGenBehaviour(
    in charstring pl_name,
    in EPTF_ExecCtrl_CT pl_execCtrlCompRef)
  runs on EPTF_ExecCtrlClient_CT {
    f_EPTF_LGenBase_init(pl_name);
    f_EPTF_LGenBase_declareBehaviorType(c_EPTF_ExecCtrl_Test_defaultBehaviorName, -1, null, null, null);
    f_EPTF_LGenBase_declareEntityType(c_EPTF_ExecCtrl_Test_defaultETypeName, {c_EPTF_ExecCtrl_Test_defaultBehaviorName});
    f_EPTF_LGenBase_declareFSMTable(c_EPTF_ExecCtrl_Test_defaultFSM);
    f_EPTF_ExecCtrlClient_init_CT(pl_name, pl_execCtrlCompRef);
    f_EPTF_Base_wait4Shutdown();
  }

  function f_EPTF_ExecCtrl_CLITest_defaultLGenBehaviourWithFSMStats(
    in charstring pl_name,
    in EPTF_ExecCtrl_CT pl_execCtrlCompRef)
  runs on EPTF_ExecCtrlClient_UIHandler_CT {
    f_EPTF_LGenBase_init(pl_name);
    f_EPTF_LGenBase_declareBehaviorType(c_EPTF_ExecCtrl_Test_defaultBehaviorName, -1, null, null, null);
    f_EPTF_LGenBase_declareEntityType(c_EPTF_ExecCtrl_Test_defaultETypeName, {c_EPTF_ExecCtrl_Test_defaultBehaviorName});
    f_EPTF_LGenBase_declareFSMTable(c_EPTF_ExecCtrl_Test_defaultFSMWithFSMStats);
    f_EPTF_ExecCtrlClient_UIHandler_init_CT(pl_name, pl_execCtrlCompRef,mtc);
    f_EPTF_Base_wait4Shutdown();
  }

  function f_EPTF_ExecCtrl_CLITest_defaultLGenBehaviourWithFSMStatsLive(
    in charstring pl_name,
    in EPTF_ExecCtrl_CT pl_execCtrlCompRef)
  runs on EPTF_ExecCtrlClient_UIHandler_CT {
    f_EPTF_LGenBase_init(pl_name);
    f_EPTF_LGenBase_declareBehaviorType(c_EPTF_ExecCtrl_Test_defaultBehaviorName, -1, null, null, null);
    f_EPTF_LGenBase_declareEntityType(c_EPTF_ExecCtrl_Test_defaultETypeName, {c_EPTF_ExecCtrl_Test_defaultBehaviorName});
    f_EPTF_LGenBase_declareFSMTable(c_EPTF_ExecCtrl_Test_defaultFSMWithFSMStatsLive);
    f_EPTF_ExecCtrlClient_UIHandler_init_CT(pl_name, pl_execCtrlCompRef,mtc);
    f_EPTF_Base_wait4Shutdown();
  }

  function f_ExecCtrl_Test_createDefaultLGen  (
    in charstring pl_hostname,
    in charstring pl_componentName
  ) runs on EPTF_ExecCtrl_CT return EPTF_ExecCtrlClient_CT
  {
    var EPTF_ExecCtrlClient_CT vl_lgen := EPTF_ExecCtrlClient_CT.create;
    vl_lgen.start( f_EPTF_ExecCtrl_CLITest_defaultLGenBehaviour("ExecCtrl_DefaultLGen_"&log2str(vl_lgen),self) );
    return vl_lgen;
  }

  function f_ExecCtrl_Test_createDefaultLGenWithSpeed  (
    in charstring pl_hostname,
    in charstring pl_componentName
  ) runs on EPTF_ExecCtrl_CT return EPTF_ExecCtrlClient_CT
  {
    var EPTF_ExecCtrlClient_CT vl_lgen := EPTF_ExecCtrlClient_CT.create;
    vl_lgen.start( f_EPTF_ExecCtrl_CLITest_defaultLGenBehaviour("ExecCtrl_DefaultLGen_"&log2str(vl_lgen),self) );
    if("LGen2.LGenDefaultPool.localhost" == pl_componentName){
      action("Slow is running");
      timer t;
      t.start(10.0);
      t.timeout;
      action("Slow ends");
    }
    return vl_lgen;
  }

  function f_ExecCtrl_Test_createDefaultLGenWithSpecId  (
    in charstring pl_hostname,
    in charstring pl_componentName
  ) runs on ExecCtrlDSClient_Test_CT return EPTF_ExecCtrlClient_CT
  {
    var EPTF_ExecCtrlClient_CT vl_lgen := EPTF_ExecCtrlClient_CT.create;
    vl_lgen.start( f_EPTF_ExecCtrl_CLITest_defaultLGenBehaviour("ExecCtrl_DefaultLGen_"&log2str(v_lgenId),self) );
    v_lgenId := v_lgenId + 1;
    return vl_lgen;
  }

  function f_ExecCtrl_Test_createDefaultLGenWithSpecIdWithFSMStats  (
    in charstring pl_hostname,
    in charstring pl_componentName
  ) runs on ExecCtrlDSClient_Test_CT return EPTF_ExecCtrlClient_CT
  {
    var EPTF_ExecCtrlClient_UIHandler_CT vl_lgen := EPTF_ExecCtrlClient_UIHandler_CT.create;
    vl_lgen.start( f_EPTF_ExecCtrl_CLITest_defaultLGenBehaviourWithFSMStats("ExecCtrl_DefaultLGen_"&log2str(v_lgenId),self) );
    v_lgenId := v_lgenId + 1;
    return vl_lgen;
  }

  function f_ExecCtrl_Test_createDefaultLGenWithSpecIdWithFSMStatsLive  (
    in charstring pl_hostname,
    in charstring pl_componentName
  ) runs on ExecCtrlDSClient_Test_CT return EPTF_ExecCtrlClient_CT
  {
    var EPTF_ExecCtrlClient_UIHandler_CT vl_lgen := EPTF_ExecCtrlClient_UIHandler_CT.create;
    vl_lgen.start( f_EPTF_ExecCtrl_CLITest_defaultLGenBehaviourWithFSMStatsLive("ExecCtrl_DefaultLGen_"&log2str(v_lgenId),self) );
    v_lgenId := v_lgenId + 1;
    return vl_lgen;
  }

  // const EPTF_ExecCtrl_LGenFunction_Entry c_EPTF_ExecCtrl_defaultLGenCreatorFunction := {
  //   name := "createDefaultLGen",
  //   fn := refers(f_ExecCtrl_Test_createDefaultLGen)
  // }

} // ~group DefaultLGen

//=========================================================================
// Functions
//=========================================================================
function f_EPTF_ExecCtrlTest_isWeightedScenariobyName(
  in charstring pl_eGrpName,
  in charstring pl_scName)
runs on EPTF_LGenBase_CT return boolean
{
  var integer vl_eGrpIdx := f_EPTF_LGenBase_entityGrpNameIndex(pl_eGrpName);
  f_EPTF_Base_assert(%definitionId&": Invalid entity group name: "&pl_eGrpName,-1 != vl_eGrpIdx);
  var integer vl_scIdx := f_EPTF_LGenBase_scNameIndexInEG(vl_eGrpIdx, pl_scName);
  f_EPTF_Base_assert(%definitionId&": Invalid scenario name: "&pl_scName,-1 != vl_scIdx);
  return f_EPTF_LGenBase_isWeightedScenario(vl_eGrpIdx, vl_scIdx);
}
/*function f_EPTF_ExecCtrlTest_getWeightedScenarioCps(
in charstring pl_eGrpName,
in charstring pl_scName)
runs on EPTF_LGenBase_CT return float
{
var float vl_scenCPS := 0.0;
var integer vl_eGrpIdx := f_EPTF_LGenBase_entityGrpNameIndex(pl_eGrpName);
f_EPTF_Base_assert(%definitionId&": Invalid entity group name: "&pl_eGrpName,-1 != vl_eGrpIdx);
var integer vl_scIdx := f_EPTF_LGenBase_scNameIndexInEG(vl_eGrpIdx, pl_scName);
f_EPTF_Base_assert(%definitionId&": Invalid scenario name: "&pl_scName,-1 != vl_scIdx);
// NOTE/FIXME: f_EPTF_LGenBase_getCPS keeps returning the last non-zero CPS for weighted TCs if the targetCPS was set to 0.0
//  for (var integer i := 0; i < sizeof(v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdx].tcIdxList); i := i + 1) {
//    vl_scenCPS := vl_scenCPS + f_EPTF_LGenBase_getCPS(v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdx].tcIdxList[i]);
//  }
for (var integer i := 0; i < sizeof(v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdx].tcIdxList); i := i + 1) {
var integer vl_tcIdx := v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdx].tcIdxList[i];
var charstring vl_varNameBase := f_EPTF_LGenBaseStats_getNamePrefix(pl_eGrpName, pl_scName, v_LGenBase_trafficCases[vl_tcIdx].privateName);
var EPTF_Var_DirectContent vl_Var_content;
var charstring vl_varName := vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcLastCps;
var integer vl_varID := f_EPTF_Var_getId(vl_varName);
if(vl_varID != -1) {
f_EPTF_Var_refreshContent(vl_varID);
f_EPTF_Var_getContent(vl_varID, vl_Var_content);
vl_scenCPS := vl_scenCPS + vl_Var_content.floatVal;
} else {
log(%definitionId & ": EPTF Variable doesn't exist: ", vl_varName);
f_EPTF_Base_stopAll();
}
}
return vl_scenCPS;
}*/
function f_EPTF_ExecCtrlTest_getWeightedScenarioCps(
  in charstring pl_eGrpName,
  in charstring pl_scName)
runs on EPTF_LGenBase_CT return float {
  return f_EPTF_LGenBase_getScCpsSoReachByName(pl_eGrpName,pl_scName);
}

function f_EPTF_ExecCtrl_Regulator_getRegulatorNames()
runs on EPTF_ExecCtrl_CT
return EPTF_CharstringList
{
  return v_EPTF_ExecCtrl_RegulatorNames;
}

function f_EPTF_ExecCtrl_Regulator_getRegulatorIdByName(
  in charstring pl_regulatorName)
runs on EPTF_ExecCtrl_CT return integer
{
  var EPTF_CharstringList vl_regulatorNames;
  vl_regulatorNames := f_EPTF_ExecCtrl_Regulator_getRegulatorNames();
  for (var integer i := 0; i < sizeof(vl_regulatorNames); i := i + 1) {

    if ( vl_regulatorNames[i] == pl_regulatorName ) {
      return i;
    }
  }
  return -1;
}

function f_EPTF_ExecCtrl_getScenarioTypeByName(in charstring pl_scenName) runs on EPTF_ExecCtrl_CT return integer {
  for (var integer i := 0; i < sizeof(v_ExecCtrl_ScenarioDeclarators); i := i + 1)
  {
    if(v_ExecCtrl_ScenarioDeclarators[i].name == pl_scenName) {
      return 1;
    }
  }
  for (var integer i := 0; i < sizeof(v_ExecCtrl_ScenarioDeclarators2); i := i + 1)
  {
    if(v_ExecCtrl_ScenarioDeclarators2[i].name == pl_scenName) {
      return 2;
    }
  }
  for (var integer i := 0; i < sizeof(v_ExecCtrl_ScenarioDeclarators3); i := i + 1)
  {
    if(v_ExecCtrl_ScenarioDeclarators3[i].name == pl_scenName) {
      return 3;
    }
  }
  return -1;

}

function f_EPTF_ExecCtrl_getScenarioIdxByName(in charstring pl_scenName) runs on EPTF_ExecCtrl_CT return integer
{
  for (var integer i := 0; i < sizeof(v_ExecCtrl_ScenarioDeclarators); i := i + 1)
  {
    if(v_ExecCtrl_ScenarioDeclarators[i].name == pl_scenName) {
      return i;
    }
  }
  for (var integer i := 0; i < sizeof(v_ExecCtrl_ScenarioDeclarators2); i := i + 1)
  {
    if(v_ExecCtrl_ScenarioDeclarators2[i].name == pl_scenName) {
      return i;
    }
  }
  for (var integer i := 0; i < sizeof(v_ExecCtrl_ScenarioDeclarators3); i := i + 1)
  {
    if(v_ExecCtrl_ScenarioDeclarators3[i].name == pl_scenName) {
      return i;
    }
  }
  return -1;
}
function f_EPTF_ExecCtrl_getTimeProfileDescrByName(
  in  charstring pl_name,
  out EPTF_ExecCtrl_TimeProfileItemList pl_timeProfile
) runs on EPTF_ExecCtrl_CT
{
  for (var integer i := 0; i < sizeof(v_EPTF_ExecCtrl_TimeProfileDescrList); i := i + 1)
  {
    log("v_EPTF_ExecCtrl_TimeProfileDescrList", v_EPTF_ExecCtrl_TimeProfileDescrList[i]);
    if (v_EPTF_ExecCtrl_TimeProfileDescrList[i].name == pl_name)
    {
      pl_timeProfile := v_EPTF_ExecCtrl_TimeProfileDescrList[i].timeProfileData
    }

  }
}

function f_EPTF_ExecCtrl_getTimeProfileListByName(
  in charstring pl_name,
  out EPTF_ExecCtrl_TimeProfileDataList pl_profileList) runs on EPTF_ExecCtrl_CT
{
  for (var integer i := 0; i < sizeof(v_EPTF_ExecCtrl_TimeProfileList); i := i + 1)
  {
    if (v_EPTF_ExecCtrl_TimeProfileList[i].name == pl_name)
    {
      pl_profileList := v_EPTF_ExecCtrl_TimeProfileList[i].timeProfileList
    }

  }
}


function f_EPTF_ExecCtrl_set_StartStopScenarioDisable(
  in EPTF_ExecCtrl_StartStopScenarioDisableItem pl_disable) runs on EPTF_ExecCtrl_CT
{
  v_EPTF_ExecCtrl_StartStopScenarioDisable[sizeof(v_EPTF_ExecCtrl_StartStopScenarioDisable)] := pl_disable;
}

function f_EPTF_ExecCtrl_set_StartStopTCDisable(
  in EPTF_ExecCtrl_StartStopTCDisableItem pl_disable) runs on EPTF_ExecCtrl_CT
{
  v_EPTF_ExecCtrl_StartStopTCDisable[sizeof(v_EPTF_ExecCtrl_StartStopTCDisable)] := pl_disable;
}

function f_EPTF_ExecCtrl_Test_setManualControlTrue() runs on EPTF_ExecCtrl_CT
{
  f_EPTF_ExecCtrl_setManualControl(true);
}

function f_EPTF_ExecCtrl_Test_setManualControlFalse() runs on EPTF_ExecCtrl_CT
{
  f_EPTF_ExecCtrl_setManualControl(false);
}

function f_EPTF_ExecCtrl_getManualControl() runs on EPTF_ExecCtrl_CT return boolean
{
  return v_ExecCtrl_manualControl;
}

function f_EPTF_ExecCtrl_get_Scenarios2Grps(
  out EPTF_LGenBase_TcMgmt_Scenarios2GrpList pl_scenario2Grps)
runs on EPTF_ExecCtrl_CT
{
  pl_scenario2Grps := v_ExecCtrl_Scenarios2Grps;
}
function f_EPTF_ExecCtrl_get_ScenarioDeclarators(
  out EPTF_LGenBase_ScenarioDeclaratorList pl_scenarioDeclarators)
runs on EPTF_ExecCtrl_CT
{
  pl_scenarioDeclarators := v_ExecCtrl_ScenarioDeclarators;
}

function f_EPTF_ExecCtrl_get_tcTypeDeclarators(out EPTF_LGenBase_tcTypeDeclaratorList pl_tcTypeDeclarators)
runs on EPTF_ExecCtrl_CT
{
  pl_tcTypeDeclarators := v_ExecCtrl_tcTypeDeclarators;
}

function f_EPTF_ExecCtrl_get_entityGrpDeclarators(
  out EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList pl_entityGrpDeclarators)
runs on EPTF_ExecCtrl_CT
{
  pl_entityGrpDeclarators := v_ExecCtrl_EntityGrpDeclarators;
}

function f_EPTF_ExecCtrl_get_TimeProfile2TcList(
  out EPTF_ExecCtrl_TimeProfile2TcList pl_timeProfile2TcList)
runs on EPTF_ExecCtrl_CT
{
  pl_timeProfile2TcList := v_EPTF_ExecCtrl_TimeProfile2TcList;
}
function f_setCPStoClients(inout EPTF_ExecCtrl_Test_SCDataList pl_scens, in integer pl_nofClients)
{
  for (var integer i := 0; i < sizeof(pl_scens); i := i + 1)
  {
    for (var integer j := 0; j < sizeof(pl_scens[i].timeProfile); j := j + 1)
    {
      pl_scens[i].timeProfile[j].targetValue := pl_scens[i].timeProfile[j].targetValue / int2float(pl_nofClients);
    }
  }
}
function f_setCPSforLGens(in EPTF_ExecCtrl_Test_SCDataList pl_scens, in integer pl_nofLGens) return EPTF_ExecCtrl_Test_SCDataList
{
  var EPTF_ExecCtrl_Test_SCDataList vl_scens := pl_scens;

  for (var integer i := 0; i < sizeof(pl_scens); i := i + 1)
  {
    for (var integer j := 0; j < sizeof(pl_scens[i].timeProfile); j := j + 1)
    {
      vl_scens[i].timeProfile[j].targetValue := pl_scens[i].timeProfile[j].targetValue / int2float(pl_nofLGens);
    }
  }
  return vl_scens;
}

function f_ExecCtrl_Test_initGui() runs on myMTC_UI {

  var Widgets execCtrlMainWindow := {
    tabpage := {
      customclass := omit,
      disabledongui := omit,
      id := omit,
      label_ := "",
      maxheight := omit,
      orientation := vertical,
      tooltiptext := omit,
      embeddedwidgets := {
        {
         {
          hbox := {
            customclass := omit,
            disabled := omit,
            disabledongui := omit,
            fixedposition := omit,
            flex := omit,
            id := omit,
            orientation := horizontal,
            scrollable := omit,
            embeddedwidgets := {
              {
               {
                hbox := {
                  customclass := omit,
                  disabled := omit,
                  disabledongui := omit,
                  fixedposition := omit,
                  flex := omit,
                  id := omit,
                  orientation := vertical,
                  scrollable := omit,
                  embeddedwidgets := {
                    {
                     {
                      tabpages := {
                        customclass := omit,
                        disabled := omit,
                        disabledongui := omit,
                        flex := omit,
                        id := c_EPTF_GUI_Main_Tabbox_WidgetId,
                        layout := omit,
                        tabpagegroups := {
                          tabpagegroup_list := {}
                        }
                      }
                    }
                   }
                  }
                }
              }
             }
            }
          }
        }
       }
      }
    }
  };

  var boolean widgetExist := false;
  log("execCtrlMainWindow: ", execCtrlMainWindow);
  f_EPTF_UIHandler_XSD_addElementToGui(
    execCtrlMainWindow,
    "",
    widgetExist);
}
function f_ExecCtrl_Test_storeDataFromTspScenario2Grps() runs on EPTF_ExecCtrl_Test_CT {

  var integer vl_idx := 0;
  var EPTF_LGenBase_TcMgmt_Scenarios2GrpList vl_scenario2Grps;
  f_EPTF_ExecCtrl_get_Scenarios2Grps(vl_scenario2Grps);

  for (var integer i := 0; i < sizeof(vl_scenario2Grps); i := i + 1) {
    for (var integer j := 0; j < sizeof(vl_scenario2Grps[i].scenarioNames); j := j + 1) {
      vl_idx := sizeof(v_EPTF_ExecCtrl_Test_scenarios);
      v_EPTF_ExecCtrl_Test_scenarios[vl_idx].scenName := vl_scenario2Grps[i].scenarioNames[j];
      v_EPTF_ExecCtrl_Test_scenarios[vl_idx].eGrpName := vl_scenario2Grps[i].eGrpName;
      v_EPTF_ExecCtrl_Test_scenarios[vl_idx].state := -1;
      v_EPTF_ExecCtrl_Test_scenarios[vl_idx].timeProfile := {};
      v_EPTF_ExecCtrl_Test_scenarios[vl_idx].tcName := "";
    }
  }
}

function f_ExecCtrl_Test_convertScenarioType(in integer pl_type) runs on EPTF_ExecCtrl_Test_CT return charstring {

  select (pl_type) {
    case (1) { return ""}
    case (2)  { return "SC2"}
    case (3)  { return "SC3"}
  }
  return "Error";
}

function f_myApplib_init(in integer pl_eCount := tsp_behaviorTypes[0].eCount)
runs on EPTF_ExecCtrlClient_Test_CT {

  v_myBIdx := f_EPTF_LGenBase_declareBehaviorType(tsp_behaviorTypes[0].bName, pl_eCount, null, null, null);

  if(//steps
    c_myApplib_stepIdx_action1 !=f_EPTF_LGenBase_declareStep(tsp_behaviorTypes[0].bName, {c_myApplib_stepName_action1,refers(f_myApplib_step_action1)})
    or c_myApplib_stepIdx_action2 !=f_EPTF_LGenBase_declareStep(tsp_behaviorTypes[0].bName, {c_myApplib_stepName_action2,refers(f_myApplib_step_action2)})

    //inputs
    or c_myApplib_inputIdx_doAction1 != f_EPTF_LGenBase_declareFsmEvent(tsp_behaviorTypes[0].bName,c_myApplib_inputName_doAction1)//0

    //fsms
    or c_myApplib_fsmIdx_basicFSM != f_EPTF_LGenBase_declareCompactFsmTable(
      f_myApplib_return_compactFsm_BasicFSM())
    or c_myApplib_fsmIdx_basicFSM2 != f_EPTF_LGenBase_declareCompactFsmTable(
      f_myApplib_return_compactFsm_BasicFSM2())
  ) {
    //fixme
    f_EPTF_LGenBase_log();
    log("error"); mtc.stop
  }
}

function f_myApplibB_init(in integer pl_eCount := tsp_behaviorTypes[1].eCount)
runs on EPTF_ExecCtrlClient_Test_CT {

  v_myBIdx := f_EPTF_LGenBase_declareBehaviorType(tsp_behaviorTypes[1].bName, pl_eCount, null, null, null);
}
function f_myApplib_step_action1(in EPTF_LGenBase_TestStepArgs pl_ptr)
runs on EPTF_ExecCtrlClient_Test_CT
{
  //log(%definitionId, " started...");
  v_trafficCount := v_trafficCount + 1;
}

function f_myApplib_step_action2(in EPTF_LGenBase_TestStepArgs pl_ptr)
runs on EPTF_ExecCtrlClient_Test_CT
{
  //log(%definitionId, " started...");
  v_trafficCount := v_trafficCount + 1;
}

function f_myApplib_return_compactFsm_BasicFSM()
runs on EPTF_ExecCtrlClient_Test_CT return EPTF_LGenBase_CompactFsmTable
{
  return {
    name := "DUMMY_FSM",
    //             [0]
    stateList := {"idle1","waiting1"}, //note: state==idle is unnecessary
    timerList := {{"T_Progress1",1.0}},
    table := {
      {eventToListen := {c_EPTF_LGenBase_bIdx,c_EPTF_LGenBase_inputIdx_testMgmt_startTC,fsm},
        cellRow := {
          //state[0]==idle
          {{{refers(f_myApplib_step_action1),{}},
              {refers(f_EPTF_LGenBase_step_timerStart),{0}}}, omit,1},
          //state[1]==waiting
          {omit,omit,omit}
        }
      },
      {eventToListen := {c_EPTF_LGenBase_specialBIdx_timerTimeout,0,fsm},
        cellRow := {
          //state[0]==idle
          {omit,omit,omit},
          //state[1]==waiting
          {{
              {refers(f_EPTF_LGenBase_step_trafficSuccess),{}}}, omit,0}
        }
      },
      {eventToListen := {c_EPTF_LGenBase_bIdx,c_EPTF_LGenBase_inputIdx_testMgmt_stopTC,fsm},
        cellRow := {
          //state[0]==idle
          {{
              {refers(f_EPTF_LGenBase_step_timerCancelIfRunning),{0}},
              {refers(f_EPTF_LGenBase_step_entityStopped),{}}
          }, omit,0},
          //state[1]==waiting
          {{
              {refers(f_EPTF_LGenBase_step_timerCancelIfRunning),{0}},
              //{refers(f_EPTF_LGenBase_step_trafficFailed),{}},
              {refers(f_EPTF_LGenBase_step_entityStopped),{}}
          }, omit,0}
        }
      },
      {eventToListen := {c_EPTF_LGenBase_bIdx,c_EPTF_LGenBase_inputIdx_testMgmt_abortTC,fsm},
        cellRow := {
          //state[0]==idle
          {{
              {refers(f_EPTF_LGenBase_step_timerCancelIfRunning),{0}}
          }, omit,0},
          //state[1]==waiting
          {{
              {refers(f_EPTF_LGenBase_step_timerCancelIfRunning),{0}}
          }, omit,0}
        }
      }
    }
  }
}

function f_myApplib_return_compactFsm_BasicFSM2()
runs on EPTF_ExecCtrlClient_Test_CT return EPTF_LGenBase_CompactFsmTable
{
  return {
    name := "DUMMY_FSM2",
    //             [0]
    stateList := {"idle","waiting"}, //note: state==idle is unnecessary
    timerList := {{"T_Progress",1.0}},
    table := {
      {eventToListen := {c_EPTF_LGenBase_bIdx,c_EPTF_LGenBase_inputIdx_testMgmt_startTC,fsm},
        cellRow := {
          //state[0]==idle
          {{{refers(f_myApplib_step_action2),{}},
              {refers(f_EPTF_LGenBase_step_timerStart),{0}}}, omit,1},
          //state[1]==waiting
          {omit,omit,omit}
        }
      },
      {eventToListen := {c_EPTF_LGenBase_specialBIdx_timerTimeout,0,fsm},
        cellRow := {
          //state[0]==idle
          {omit,omit,omit},
          //state[1]==waiting
          {{
              {refers(f_EPTF_LGenBase_step_trafficSuccess),{}}}, omit,0}
        }
      },
      {eventToListen := {c_EPTF_LGenBase_bIdx,c_EPTF_LGenBase_inputIdx_testMgmt_stopTC,fsm},
        cellRow := {
          //state[0]==idle
          {{
              {refers(f_EPTF_LGenBase_step_timerCancelIfRunning),{0}},
              {refers(f_EPTF_LGenBase_step_entityStopped),{}}
          }, omit,0},
          //state[1]==waiting
          {{
              {refers(f_EPTF_LGenBase_step_timerCancelIfRunning),{0}},
              {refers(f_EPTF_LGenBase_step_entityStopped),{}}
          }, omit,0}
        }
      },
      {eventToListen := {c_EPTF_LGenBase_bIdx,c_EPTF_LGenBase_inputIdx_testMgmt_abortTC,fsm},
        cellRow := {
          //state[0]==idle
          {{
              {refers(f_EPTF_LGenBase_step_timerCancelIfRunning),{0}}
          }, omit,0},
          //state[1]==waiting
          {{
              {refers(f_EPTF_LGenBase_step_timerCancelIfRunning),{0}}
          }, omit,0}
        }
      }
    }
  }
}

function f_EPTF_ExecCtrlClient_Test_init(
  in charstring pl_selfName,
  in EPTF_ExecCtrl_Test_CT pl_ExecCtrlRef, in integer pl_eCount := -1,
  in boolean pl_reportReady := true)
runs on EPTF_ExecCtrlClient_Test_CT
{
  if(not v_EPTF_ExecCtrlClient_Test_initialized) {

    f_EPTF_LGenBase_init(pl_selfName, 0, "DemoEntity#");
    if (pl_eCount == -1) {
      f_myApplib_init(); //behavior type index==1
      f_myApplibB_init();
    } else {
      f_myApplib_init(pl_eCount); //behavior type index==1
      f_myApplibB_init(pl_eCount);
    }
    var integer vl_eTypeIdx;

    for (var integer i := 0; i < sizeof(tsp_entityTypes); i := i + 1) {
      vl_eTypeIdx := f_EPTF_LGenBase_declareEntityType(tsp_entityTypes[i].eType, tsp_entityTypes[i].behaviors);
    }

    //log("DEBUG: v_LGenBase_entityTypes = ", v_LGenBase_entityTypes);

    //connect(self:port_A,self:port_A);

    f_EPTF_ExecCtrlClient_init_CT(pl_selfName, pl_ExecCtrlRef, pl_reportReady);   // Only after library init(s)

    //log("DEBUG: v_LGenBase_behaviorTypes = ", v_LGenBase_behaviorTypes);
    v_EPTF_ExecCtrlClient_Test_initialized := true;
  }
}

function f_ExecCtrlClient_Test_behaviour( in charstring pl_selfName,
  in EPTF_ExecCtrl_Test_CT pl_ExecCtrlRef,
  in boolean pl_cleanupNeeded := false,
  in boolean pl_reportReady := true)
runs on EPTF_ExecCtrlClient_Test_CT
{
  f_EPTF_ExecCtrlClient_Test_init(pl_selfName, pl_ExecCtrlRef, -, pl_reportReady);
  if(pl_cleanupNeeded){
    f_EPTF_Base_registerCleanup(refers(f_EPTF_ExecCtrlClient_Test_cleanupWaiting));
  }
  f_EPTF_Base_wait4Shutdown();
}

function f_EPTF_ExecCtrlClient_UIHandler_Test_init(
  in charstring pl_selfName,
  in EPTF_ExecCtrl_Test_CT pl_ExecCtrlRef)
runs on EPTF_ExecCtrlClient_UIHandler_Test_CT
{
  f_EPTF_LGenBase_init(pl_selfName, 0, "DemoEntity#");
  f_myApplib_init(); //behavior type index==1
  f_myApplibB_init();
  var integer vl_eTypeIdx;

  for (var integer i := 0; i < sizeof(tsp_entityTypes); i := i + 1) {
    vl_eTypeIdx := f_EPTF_LGenBase_declareEntityType(tsp_entityTypes[i].eType, tsp_entityTypes[i].behaviors);
  }
  //log("DEBUG: v_LGenBase_entityTypes = ", v_LGenBase_entityTypes);

  //connect(self:port_A,self:port_A);

  f_EPTF_ExecCtrlClient_init_CT(pl_selfName, pl_ExecCtrlRef);   // Only after library init(s)

  //log("DEBUG: v_LGenBase_behaviorTypes = ", v_LGenBase_behaviorTypes);
  f_EPTF_ExecCtrlClient_UIHandler_init_CT(pl_selfName,pl_ExecCtrlRef,mtc);
}

function f_EPTF_ExecCtrl_Test_checkInit(in integer pl_nOfClients)
runs on EPTF_ExecCtrl_Test_CT
{
  if (f_EPTF_ExecCtrl_nrOfClients() == pl_nOfClients) {
    setverdict(pass);
  } else {
    //log(%definitionId,": incorrect v_ExecCtrl_nrOfClients value: ", f_EPTF_ExecCtrl_nrOfClients(), " expected: ", pl_nOfClients);
    setverdict(fail);
  }

  f_EPTF_ExecCtrl_Test_checkRegulatorInit(
    tsp_EPTF_ExecCtrl_RegulatorNames,
    tsp_EPTF_ExecCtrl_RegulatedItems);
  // FIXME: update this for R3

  /*  if (v_ExecCtrl_nrOfPendingResourceStatusMsgs ==pl_nOfClients){
  setverdict(pass);
  } else {
  log(%definitionId,": incorrect v_ExecCtrl_nrOfPendingResourceStatusMsgs value: ", v_ExecCtrl_nrOfPendingResourceStatusMsgs, " expected: ", pl_nOfClients);
  setverdict(fail);
  }*/

  /*  if (v_ExecCtrl_scenNamesHash != c_ExecCtrl_invalidIdx)
  {setverdict(pass);
  } else {
  log(%definitionId,": incorrect v_ExecCtrl_scenNamesHash", v_ExecCtrl_scenNamesHash, " expected value must be different from it");
  setverdict(fail);
  }
  if (v_ExecCtrl_scenNames2Hash != c_ExecCtrl_invalidIdx) {
  setverdict(pass);
  } else{
  log(%definitionId,": incorrect v_ExecCtrl_scenNamesHash", v_ExecCtrl_scenNames2Hash, " expected value must be different from it");
  setverdict(fail);
  }
  if (v_ExecCtrl_scenNames3Hash != c_ExecCtrl_invalidIdx) {
  setverdict(pass);
  } else{
  log(%definitionId,": incorrect v_ExecCtrl_scenNamesHash", v_ExecCtrl_scenNames3Hash, " expected value must be different from it");
  setverdict(fail);
  }
  if (v_ExecCtrl_grpNamesHash != c_ExecCtrl_invalidIdx){
  setverdict(pass);
  } else{
  log(%definitionId,": incorrect v_ExecCtrl_scenNamesHash", v_ExecCtrl_grpNamesHash, " expected value must be different from it");
  setverdict(fail);
  }*/
  //  if (sizeof(v_EPTF_ExecCtrl_ScenarioStateChangedCallbackFns) != 0){
  //    setverdict(pass);
  //  } else{
  //    log(%definitionId,": incorrect v_EPTF_ExecCtrl_ScenarioStateChangedCallbackFns value, ", v_EPTF_ExecCtrl_ScenarioStateChangedCallbackFns, " expected value must be nonzero");
  //    setverdict(fail);
  //  }
  //  if (sizeof(v_EPTF_ExecCtrl_ScenarioStateChangedCallbackFns) != 0) {
  //    setverdict(pass);
  //  } else {
  //    log("error: v_EPTF_ExecCtrl_ScenarioStateChangedCallbackFns is empty");
  //    setverdict(fail);
  //  }
  var integer vl_expectedSize:=-1;
  f_EPTF_ExecCtrl_Test_countExpectedScenario2GrpsSize(vl_expectedSize);
  //  if (sizeof(v_ExecCtrl_Scenarios2Grps) == vl_expectedSize){
  //    setverdict(pass);
  //  } else{
  //    log(%definitionId,": incorrect v_ExecCtrl_Scenarios2Grps size, ", sizeof(v_ExecCtrl_Scenarios2Grps), " expected value: ", vl_expectedSize);
  //    setverdict(fail);
  //  }
}

function f_EPTF_ExecCtrl_Test_init_CT(in integer pl_nOfClients)
runs on EPTF_ExecCtrl_Test_CT
{
  if(v_EPTF_ExecCtrl_Test_initialized) { return;}

  f_EPTF_ExecCtrl_init_CT("ExecCtrl", pl_nOfClients);
  v_EPTF_ExecCtrl_Test_statError:=0;
  v_EPTF_ExecCtrl_Test_scenarios := {};
  v_steps := 0;
  v_EPTF_ExecCtrl_Test_CPSChangedCallback_Called := false;

  f_EPTF_ExecCtrl_Test_checkInit(pl_nOfClients);
}

function f_EPTF_ExecCtrl_Test_checkCleanup() runs on EPTF_ExecCtrl_Test_CT
{

  // FIXME: update this for R3

  var integer vl_id := 0;
  if (f_EPTF_str2int_HashMap_GetID(c_EPTF_ExecCtrl_ScenarioGroupInstanceDB_HashName, vl_id) == false) {
    setverdict(pass);
  } else {
    log(%definitionId,": error: ScenarioGroupInstanceDB was not cleaned up, id: ", vl_id);
    setverdict(fail);
  }
  vl_id := 0;
  if (f_EPTF_str2int_HashMap_GetID(c_EPTF_ExecCtrl_PhaseListDeclaratorDB_HashName, vl_id) == false) {
    setverdict(pass);
  } else {
    log(%definitionId,": error: PhaseListDeclaratorDB was not cleaned up, id: ", vl_id);
    setverdict(fail);
  }


  /*  var integer vl_tempHashID;

  if (sizeof(v_ExecCtrl_LGenResourceDB) == 0) {
  setverdict(pass);
  } else {
  log(%definitionId,": error: v_ExecCtrl_LGenResourceDB not empty: ", v_ExecCtrl_LGenResourceDB);
  setverdict(fail);
  }
  if (not f_EPTF_str2int_HashMap_GetID(c_ExecCtrl_scenarioNames, vl_tempHashID)) {
  setverdict(pass);
  } else {
  log("error: ",c_ExecCtrl_scenarioNames, " hash table not deleted");
  setverdict(fail);
  }
  if (not f_EPTF_str2int_HashMap_GetID(c_ExecCtrl_scenarioNames2, vl_tempHashID)) {
  setverdict(pass);
  } else {
  log("error: ",c_ExecCtrl_scenarioNames2, " hash table not deleted");
  setverdict(fail);
  }
  if (not f_EPTF_str2int_HashMap_GetID(c_ExecCtrl_scenarioNames3, vl_tempHashID)) {
  setverdict(pass);
  } else {
  log("error: ",c_ExecCtrl_scenarioNames3, " hash table not deleted");
  setverdict(fail);
  }
  if (not f_EPTF_str2int_HashMap_GetID(c_ExecCtrl_grpNames, vl_tempHashID)) {
  setverdict(pass);
  } else {
  log("error: ",c_ExecCtrl_grpNames, " hash table not deleted");
  setverdict(fail);
  }*/
}

function f_EPTF_ExecCtrl_Test_initScTimeProfileListDB(
  in EPTF_ExecCtrl_TimeProfileDescrList pl_TimeProfileDescrList,
  in EPTF_ExecCtrl_TimeProfileList pl_TimeProfileList,
  in EPTF_ExecCtrl_TimeProfile2TcList pl_TimeProfile2TcList)
runs on EPTF_ExecCtrl_Test_CT
{
  var EPTF_ExecCtrl_TimeProfileItemList vl_timeProfileDescr := {};
  var EPTF_ExecCtrl_TimeProfileDataList vl_timeProfileDataList := {};
  var EPTF_ExecCtrl_TimeProfile_TCName  vl_TcId := {
    eGrpName := "",
    scName := "",
    tcName := ""
  };

  f_EPTF_ExecCtrl_getTimeProfileDescrByName("monday", vl_timeProfileDescr);
  if(sizeof(vl_timeProfileDescr) != 0){
    setverdict(pass);
  }else {
    log("Wrong time profile initiation");
    setverdict(fail);
  }

  f_EPTF_ExecCtrl_getTimeProfileListByName("Days", vl_timeProfileDataList);
  if (sizeof(vl_timeProfileDataList) != 0){
    setverdict(pass);
  }else {
    log("Wrong time profile initiation");
    setverdict(fail);
  }

}

function f_EPTF_ExecCtrl_Test_checkRegulatorInit(
  in EPTF_CharstringList pl_regulatorNames,
  in EPTF_ExecCtrl_RegulatedItems pl_regulatorItems)
runs on EPTF_ExecCtrl_Test_CT
{
  for(var integer i := 1; i < sizeof(pl_regulatorNames); i := i +1 )
  {
    var integer vl_regulatorId :=
    f_EPTF_ExecCtrl_Regulator_getRegulatorId(pl_regulatorNames[i]);
    if (vl_regulatorId != -1) {
      setverdict(pass);
    } else {
      log("Error: There is no regulator Id with this name - ", pl_regulatorNames[i]);
      setverdict(fail);
    }
  }
}


function f_EPTF_ExecCtrl_Test_countExpectedScenario2GrpsSize(
  out integer pl_grp)
runs on EPTF_ExecCtrl_Test_CT
{
  pl_grp := 0;
  for(var integer i:=0; i<sizeof(tsp_LGenBase_Scenarios2Grps); i:=i+1) {
    for(var integer j:=0; j<sizeof(tsp_LGenBase_Scenarios2Grps[i].scenarioNames);j:=j+1) {
      pl_grp := pl_grp + 1;
    }
  }
}

function f_EPTF_ExecCtrl_Test_StartScenario(
  in charstring pl_eGrpName,
  in charstring pl_scenName,
  in charstring pl_state)
runs on EPTF_ExecCtrl_Test_CT
{

  for (var integer i := 0; i < sizeof(v_EPTF_ExecCtrl_Test_scenarios); i := i + 1) {

    if (pl_eGrpName == v_EPTF_ExecCtrl_Test_scenarios[i].eGrpName and
      pl_scenName == v_EPTF_ExecCtrl_Test_scenarios[i].scenName and
      pl_state == "Idle"  and
      v_EPTF_ExecCtrl_Test_scenarios[i].state == -1)
    {
      log("-1 -> Idle");
      f_EPTF_ExecCtrl_startScenarioOnLGensByName(pl_eGrpName,pl_scenName);
      v_EPTF_ExecCtrl_Test_scenarios[i].state := c_EPTF_LGenBase_tcStateIdle;
    }
  }
}

function f_EPTF_ExecCtrl_Test_StartTC(
  in charstring pl_eGrpName,
  in charstring pl_scenName,
  in charstring pl_tcName,
  in charstring pl_state)
runs on EPTF_ExecCtrl_Test_CT
{
  var integer vl_sIdx;
  var integer vl_tcInstanceIdx;
  var integer vl_tcIdx;

  for (var integer i := 0; i < sizeof(v_EPTF_ExecCtrl_Test_scenarios); i := i + 1) {

    if (pl_eGrpName == v_EPTF_ExecCtrl_Test_scenarios[i].eGrpName and
      pl_scenName == v_EPTF_ExecCtrl_Test_scenarios[i].scenName and
      v_EPTF_ExecCtrl_Test_scenarios[i].tcName == pl_tcName and
      pl_state == "Idle"  and
      v_EPTF_ExecCtrl_Test_scenarios[i].state == -1)
    {
      vl_sIdx := f_EPTF_ExecCtrl_getScenarioIdx(v_EPTF_ExecCtrl_Test_scenarios[i].eGrpName,v_EPTF_ExecCtrl_Test_scenarios[i].scenName);
      vl_tcInstanceIdx := f_EPTF_ExecCtrl_getTrafficCaseIdx(v_EPTF_ExecCtrl_Test_scenarios[i].eGrpName,v_EPTF_ExecCtrl_Test_scenarios[i].scenName,v_EPTF_ExecCtrl_Test_scenarios[i].tcName);
      vl_tcIdx := f_EPTF_ExecCtrl_getTcOfScenarioIdx(vl_tcInstanceIdx);
      log("-1 -> Idle");
      f_EPTF_ExecCtrl_startTCOnLGens(vl_sIdx, vl_tcIdx);

      v_EPTF_ExecCtrl_Test_scenarios[i].state := c_EPTF_LGenBase_tcStateIdle;
    }
  }
}

function f_EPTF_ExecCtrl_Test_UpdateScenarioState(
  in charstring pl_eGrpName,
  in charstring pl_scenName,
  in charstring pl_state)
runs on EPTF_ExecCtrl_Test_CT
{

  for (var integer i := 0; i < sizeof(v_EPTF_ExecCtrl_Test_scenarios); i := i + 1) {
    if (pl_eGrpName == v_EPTF_ExecCtrl_Test_scenarios[i].eGrpName and
      pl_scenName == v_EPTF_ExecCtrl_Test_scenarios[i].scenName) {
      log("### v_EPTF_ExecCtrl_Test_scenarios[i].scenName: ", v_EPTF_ExecCtrl_Test_scenarios[i].scenName);
      log("### old v_EPTF_ExecCtrl_Test_scenarios[i].sate: ", v_EPTF_ExecCtrl_Test_scenarios[i].state);
      if (pl_state == "Off") {
        v_EPTF_ExecCtrl_Test_scenarios[i].state := c_EPTF_LGenBase_tcStateCount;
        //log("### new v_EPTF_ExecCtrl_Test_scenarios[i].state: Off");
      } else {
        for(var integer j:=0; j<sizeof(c_EPTF_LGenBase_stateNames); j:=j+1) {
          if(c_EPTF_LGenBase_stateNames[j] == pl_state) {

            v_EPTF_ExecCtrl_Test_scenarios[i].state := j;
            log("### new v_EPTF_ExecCtrl_Test_scenarios[i].state: ", c_EPTF_LGenBase_stateNames[j]);
            //          found := true;
          }
        }
      }
    }
  }

}

function f_EPTF_ExecCtrl_Test_UpdateTCState(
  in charstring pl_eGrpName,
  in charstring pl_scenName,
  in charstring pl_tcName,
  in charstring pl_state)
runs on EPTF_ExecCtrl_Test_CT
{

  for (var integer i := 0; i < sizeof(v_EPTF_ExecCtrl_Test_scenarios); i := i + 1) {
    if (pl_eGrpName == v_EPTF_ExecCtrl_Test_scenarios[i].eGrpName and
      pl_scenName == v_EPTF_ExecCtrl_Test_scenarios[i].scenName and
      pl_tcName == v_EPTF_ExecCtrl_Test_scenarios[i].tcName) {
      log("### v_EPTF_ExecCtrl_Test_scenarios[i].scenName: ", v_EPTF_ExecCtrl_Test_scenarios[i].tcName);
      log("### old v_EPTF_ExecCtrl_Test_scenarios[i].sate: ", v_EPTF_ExecCtrl_Test_scenarios[i].state);
      if (pl_state == "Off") {
        v_EPTF_ExecCtrl_Test_scenarios[i].state := c_EPTF_LGenBase_tcStateCount;
        log("### new v_EPTF_ExecCtrl_Test_scenarios[i].state: Off");
      } else {
        for(var integer j:=0; j<sizeof(c_EPTF_LGenBase_stateNames); j:=j+1) {
          if(c_EPTF_LGenBase_stateNames[j] == pl_state) {

            v_EPTF_ExecCtrl_Test_scenarios[i].state := j;
            log("### new v_EPTF_ExecCtrl_Test_scenarios[i].state: ", c_EPTF_LGenBase_stateNames[j]);
            //          found := true;
          }
        }
      }
    }
  }

}

function f_EPTF_ExecCtrl_Test_checkScOff(in EPTF_ExecCtrl_Test_SCData pl_scenario)
runs on EPTF_ExecCtrl_Test_CT {
  var integer state := -1;
  for(var integer i:=0; i<sizeof(v_EPTF_ExecCtrl_Test_scenarios); i:=i+1) {
    if(pl_scenario.eGrpName == v_EPTF_ExecCtrl_Test_scenarios[i].eGrpName and
      pl_scenario.scenName == v_EPTF_ExecCtrl_Test_scenarios[i].scenName) {
      state := v_EPTF_ExecCtrl_Test_scenarios[i].state;
    }
  }
  if(state == c_EPTF_LGenBase_tcStateCount) {
    setverdict(pass);
  } else {
    if(state < c_EPTF_LGenBase_tcStateCount and state > -1) {
      log(%definitionId,": scenario (", pl_scenario.eGrpName, ",", pl_scenario.scenName,
        ") state is ", c_EPTF_LGenBase_stateNames[state]);
    } else {
      log(%definitionId,": scenario (", pl_scenario.eGrpName, ",", pl_scenario.scenName,
        ") state is unknown");


    }
    setverdict(fail);
  }
}

function f_EPTF_ExecCtrl_Test_checkScRunning_withRetVal(in EPTF_ExecCtrl_Test_SCData pl_scenario)
runs on EPTF_ExecCtrl_Test_CT return boolean {
  var integer state := -2;
  for(var integer i:=0; i<sizeof(v_EPTF_ExecCtrl_Test_scenarios); i:=i+1) {
    if(pl_scenario.eGrpName == v_EPTF_ExecCtrl_Test_scenarios[i].eGrpName and
      pl_scenario.scenName == v_EPTF_ExecCtrl_Test_scenarios[i].scenName) {
      state := v_EPTF_ExecCtrl_Test_scenarios[i].state;
    }
  }
  if(state == c_EPTF_LGenBase_tcStateRunning) {
   return true;
  }

  return false;
}

function f_EPTF_ExecCtrl_Test_checkScRunning(in EPTF_ExecCtrl_Test_SCData pl_scenario)
runs on EPTF_ExecCtrl_Test_CT {
  var integer state := -2;
  for(var integer i:=0; i<sizeof(v_EPTF_ExecCtrl_Test_scenarios); i:=i+1) {
    if(pl_scenario.eGrpName == v_EPTF_ExecCtrl_Test_scenarios[i].eGrpName and
      pl_scenario.scenName == v_EPTF_ExecCtrl_Test_scenarios[i].scenName) {
      state := v_EPTF_ExecCtrl_Test_scenarios[i].state;
    }
  }
  if(state == c_EPTF_LGenBase_tcStateRunning) {
    setverdict(pass);
  } else {
    if(state < c_EPTF_LGenBase_tcStateCount and state > -1) {
      log(%definitionId,": scenario (", pl_scenario.eGrpName, ",", pl_scenario.scenName,
        ") state is ", c_EPTF_LGenBase_stateNames[state]);
    } else {
      if (state >= c_EPTF_LGenBase_tcStateCount) {
        log(%definitionId,": scenario (", pl_scenario.eGrpName, ",", pl_scenario.scenName,
          ") state is Off");
      } else {
        log(%definitionId,": scenario (", pl_scenario.eGrpName, ",", pl_scenario.scenName,
          ") state is unknown");

      }
    }
    setverdict(fail);
  }
}

function f_EPTF_ExecCtrl_Test_checkScNotRunning(in EPTF_ExecCtrl_Test_SCData pl_scenario)
runs on EPTF_ExecCtrl_Test_CT {
  var integer state := -2;
  for(var integer i:=0; i<sizeof(v_EPTF_ExecCtrl_Test_scenarios); i:=i+1) {
    if(pl_scenario.eGrpName == v_EPTF_ExecCtrl_Test_scenarios[i].eGrpName and
      pl_scenario.scenName == v_EPTF_ExecCtrl_Test_scenarios[i].scenName) {
      state := v_EPTF_ExecCtrl_Test_scenarios[i].state;
    }
  }
  if(state == -2) {
    log(%definitionId,": scenario (", pl_scenario.eGrpName, ",", pl_scenario.scenName,
      ") not found in v_EPTF_ExecCtrl_Test_scenarios: ", v_EPTF_ExecCtrl_Test_scenarios);
    //setverdict(fail); - done by stopAll
    f_EPTF_Base_stopAll();
  } else if (state == -1) {
    log("Error: scenario state not initiated.");
    setverdict(fail);
  } else if (state >= c_EPTF_LGenBase_tcStateCount) {
    log("Expected Scenario State: Off");
    setverdict(pass);
  }

  else if(state != c_EPTF_LGenBase_tcStateRunning) {
    log("Expected Scenario State: ", c_EPTF_LGenBase_stateNames[state])
    setverdict(pass);
  } else {
    log(%definitionId,": scenario (", pl_scenario.eGrpName, ",", pl_scenario.scenName,
      ") is running");
    setverdict(fail);
  }
}

function f_EPTF_ExecCtrlClient_Test_allScenarioCreated() runs on EPTF_ExecCtrlClient_Test_CT
{
  log(%definitionId," Called");
  setverdict(pass);
}

function f_EPTF_ExecCtrlClient_Test_scenarioInitialized(
  in EPTF_LGenBase_Scenario2Grp pl_scenario) runs on EPTF_ExecCtrlClient_Test_CT
{
  log(%definitionId," Called: ", pl_scenario);
  setverdict(pass);
}

/*
function f_EPTF_ExecCtrl_Test_getTypeFromGroup(
in charstring pl_name,
in integer pl_nOfClients, in float pl_time)
runs on EPTF_ExecCtrl_Test_CT
{
var charstring vl_grp := "grp0";
var charstring vl_type;

t_test.start(pl_time);
f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients);
alt {
[] t_test.timeout {
f_EPTF_ExecCtrl_getTypeFromGroup(vl_grp, vl_type);
if (vl_type == "Entity_A") {
setverdict(pass);
} else {
log(vl_type, " - Wrong Entity type for grp0, it must be Entity_A.")
setverdict(fail);
}
repeat;
}
}
}*/
/*
function f_EPTF_ExecCtrl_Test_getETypeFromScenario(
in charstring pl_name,
in integer pl_nOfClients, in float pl_time)
runs on EPTF_ExecCtrl_Test_CT
{

t_test.start(pl_time);
f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients);
alt {
[] t_test.timeout {

if (f_EPTF_ExecCtrl_getETypeFromScenario(0, "Entity_A")) {
setverdict(pass);
} else {
log("Wrong Entity type for Scenario 0")
setverdict(fail);
}
if (f_EPTF_ExecCtrl_getETypeFromScenario(0, "Entity_B")) {
log("Wrong Entity type for Scenario 0")
setverdict(fail);
} else {
setverdict(pass);
}
if (f_EPTF_ExecCtrl_getETypeFromScenario(10, "Entity_B")) {
log("Wrong Entity type for Scenario 10")
setverdict(fail);
} else {
setverdict(pass);
}
repeat;
}
}
}*/
/*
function f_EPTF_ExecCtrl_Test_getTcIdx(
in charstring pl_name,
in integer pl_nOfClients, in float pl_time)
runs on EPTF_ExecCtrl_Test_CT
{

t_test.start(pl_time);
f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients);
var integer vl_tcIdx;
alt {
[] t_test.timeout {
vl_tcIdx := f_EPTF_ExecCtrl_getTcIdx("scenario_0", "TC1");
if (vl_tcIdx == 1) {
setverdict(pass);
} else {
log("Wrong TC index in scenario_0: ", vl_tcIdx);
setverdict(fail);
}
vl_tcIdx := f_EPTF_ExecCtrl_getTcIdx("scenario_0_declarator2", "TC0_declarator2");
if (vl_tcIdx == 0) {
setverdict(pass);
} else {
log("Wrong TC index in scenario_0_declarator2: ", vl_tcIdx);
setverdict(fail);
}
vl_tcIdx := f_EPTF_ExecCtrl_getTcIdx("scenario_0_declarator3","TC0_declarator2");
if (vl_tcIdx == 0) {
setverdict(pass);
} else {
log("Wrong TC index in scenario_0_declarator3: ", vl_tcIdx);
setverdict(fail);
}
vl_tcIdx := f_EPTF_ExecCtrl_getTcIdx("scenario_0_declarator3", "TC0_declarator2");
if (vl_tcIdx == 1) {
log("Wrong TC index in scenario_0_declarator3: ", vl_tcIdx);
setverdict(fail);
} else {
setverdict(pass);
}

repeat;
}
}
}*/

function f_EPTF_ExecCtrl_Test_scenarioEnabled(
  in charstring pl_name,
  in integer pl_nOfClients, in float pl_time)
runs on EPTF_ExecCtrl_Test_CT
{

  f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients);
  t_test.start(pl_time);

  alt {
    [] t_test.timeout {
      if (f_EPTF_ExecCtrl_scenarioEnabled(1)) {
        setverdict(pass);
      } else {
        log("Scenario should be disabled: scenario_0_declarator3");
        setverdict(fail);
      }
      repeat;
    }
  }
}
/*
function f_EPTF_ExecCtrl_Test_getTcName(
in charstring pl_name,
in integer pl_nOfClients, in float pl_time)
runs on EPTF_ExecCtrl_Test_CT
{

t_test.start(pl_time);
f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients);
var charstring vl_tcName;
alt {
[] t_test.timeout {
vl_tcName := f_EPTF_ExecCtrl_getTcName("scenario_0",1);
if (vl_tcName == "TC1") {
setverdict(pass);
} else {
log("Wrong TC Name in scenario_0: ", vl_tcName);
setverdict(fail);
}
vl_tcName := f_EPTF_ExecCtrl_getTcName("scenario_0_declarator2",0);
if (vl_tcName == "TC0_declarator2") {
setverdict(pass);
} else {
log("Wrong TC Name in scenario_0_declarator2: ", vl_tcName);
setverdict(fail);
}
vl_tcName := f_EPTF_ExecCtrl_getTcName("scenario_0_declarator3",0);
if (vl_tcName == "TC0_declarator2") {
setverdict(pass);
} else {
log("Wrong TC Name in scenario_0_declarator3: ", vl_tcName);
setverdict(fail);
}
vl_tcName := f_EPTF_ExecCtrl_getTcName("scenario_0_declarator3", 1);
if (vl_tcName == "TC0_declarator2") {
log("Wrong TC Name in scenario_0_declarator3: ", vl_tcName);
setverdict(fail);
} else {
setverdict(pass);
}

repeat;
}
}
}*/

/*
This test makes no sense
function f_EPTF_ExecCtrl_Test_getScenGrpIdx(
in charstring pl_name,
in integer pl_nOfClients, in float pl_time)
runs on EPTF_ExecCtrl_Test_CT
{
t_test.start(pl_time);
f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients);
var integer vl_ScenGrpIdx;
alt {
[] t_test.timeout {
vl_ScenGrpIdx := f_EPTF_ExecCtrl_ScenarioGroup_getIdx("scenario_0_declarator2");
if (vl_ScenGrpIdx == 0) {
setverdict(pass);
} else {
log("Wrong TC Name in scenario_0: ", vl_ScenGrpIdx);
setverdict(fail);
}
vl_ScenGrpIdx := f_EPTF_ExecCtrl_ScenarioGroup_getIdx("scenario_0");
if (vl_ScenGrpIdx == 0) {
setverdict(pass);
} else {
log("Wrong TC Name in scenario_0: ", vl_ScenGrpIdx);
setverdict(fail);
}
repeat;
}
}
}*/
function f_EPTF_ExecCtrl_Test_manualControlTrue(
  in charstring pl_name,
  in integer pl_nOfClients,
  in EPTF_ExecCtrl_Test_SCDataList pl_scens,
  in float pl_time)
runs on EPTF_ExecCtrl_Test_CT {

  f_EPTF_ExecCtrl_setManualControl(true);
  f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients);
  t_test.start(pl_time);

  v_EPTF_ExecCtrl_Test_scenarios := pl_scens;
  f_EPTF_ExecCtrl_registerScenarioStateChangedCallback(refers(f_EPTF_ExecCtrl_Test_UpdateScenarioState));

  alt
  {
    [] t_test.timeout {
      for (var integer i := 0; i < sizeof(pl_scens); i := i + 1) {
        f_EPTF_ExecCtrl_Test_checkScNotRunning(pl_scens[i]);
      }
      repeat;
    }
  } // alt
}

function f_EPTF_ExecCtrl_Test_manualControlFalse(
  in charstring pl_name,
  in integer pl_nOfClients,
  in EPTF_ExecCtrl_Test_SCDataList pl_scens,
  in float pl_time)
runs on EPTF_ExecCtrl_Test_CT {

  f_EPTF_ExecCtrl_setManualControl(false);
  f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients);
  t_test.start(pl_time);

  v_EPTF_ExecCtrl_Test_scenarios := pl_scens;
  f_EPTF_ExecCtrl_registerScenarioStateChangedCallback(refers(f_EPTF_ExecCtrl_Test_UpdateScenarioState));

  alt
  {
    [] t_test.timeout {
      for (var integer i := 0; i < sizeof(pl_scens); i := i + 1) {
        f_EPTF_ExecCtrl_Test_checkScRunning(pl_scens[i]);
      }
      repeat;
    }
  } // alt
}

function f_EPTF_ExecCtrl_Test_startScenarioOnLGens(
  in charstring pl_name,
  in integer pl_nOfClients,
  in EPTF_ExecCtrl_Test_SCDataList pl_scens,
  in float pl_time)
runs on EPTF_ExecCtrl_Test_CT
{
  f_EPTF_ExecCtrl_setManualControl(true);
  v_EPTF_ExecCtrl_Test_scenarios := pl_scens;
  f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients);

  t_test.start(pl_time);
  f_EPTF_ExecCtrl_registerScenarioStateChangedCallback(refers(f_EPTF_ExecCtrl_Test_StartScenario));
  v_EPTF_ExecCtrl_Test_scenarios := pl_scens;
  f_EPTF_ExecCtrl_registerScenarioStateChangedCallback(refers(f_EPTF_ExecCtrl_Test_UpdateScenarioState));
  alt
  {
    [] t_test.timeout {

      for (var integer i := 0; i < sizeof(pl_scens); i := i + 1) {
        f_EPTF_ExecCtrl_Test_checkScRunning(pl_scens[i]);
      }
      repeat;
    }
  } // alt

}

function f_EPTF_ExecCtrl_Test_stopScenarioOnLGens(
  in charstring pl_name,
  in integer pl_nOfClients,  in EPTF_ExecCtrl_Test_SCDataList pl_scens, in float pl_time)
runs on EPTF_ExecCtrl_Test_CT
{
  v_EPTF_ExecCtrl_Test_scenarios := pl_scens;
  f_EPTF_ExecCtrl_setManualControl(true);
  f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients);

  t_test.start(pl_time);
  f_EPTF_ExecCtrl_registerScenarioStateChangedCallback(refers(f_EPTF_ExecCtrl_Test_StartScenario));
  v_EPTF_ExecCtrl_Test_scenarios := pl_scens;
  f_EPTF_ExecCtrl_registerScenarioStateChangedCallback(refers(f_EPTF_ExecCtrl_Test_UpdateScenarioState));
  alt
  {
    [] t_test.timeout {
      for (var integer i := 0; i < sizeof(pl_scens); i := i + 1) {
        f_EPTF_ExecCtrl_Test_checkScRunning(pl_scens[i]);
        f_EPTF_ExecCtrl_stopScenarioOnLGensByName(pl_scens[i].eGrpName, pl_scens[i].scenName);
      }

      t_test.start(tsp_EPTF_Var_SyncInterval+2.0);
      t_test.timeout;
      for (var integer i := 0; i < sizeof(pl_scens); i := i + 1) {
        f_EPTF_ExecCtrl_Test_checkScNotRunning(pl_scens[i]);
      }
      repeat;
    }
  } // alt
}

function f_EPTF_ExecCtrl_Test_startTCOnLGens(
  in charstring pl_name,
  in integer pl_nOfClients,  in EPTF_ExecCtrl_Test_SCDataList pl_scens, in float pl_time)
runs on EPTF_ExecCtrl_Test_CT
{
  f_EPTF_ExecCtrl_setManualControl(true);
  f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients);

  v_EPTF_ExecCtrl_Test_scenarios := pl_scens;
  f_EPTF_ExecCtrl_registerScenarioStateChangedCallback(refers(f_EPTF_ExecCtrl_Test_UpdateScenarioState));

  t_test.start(pl_time);
  alt
  {
    [] t_test.timeout {
      for (var integer i := 0; i < sizeof(pl_scens); i := i + 1) {
        f_EPTF_ExecCtrl_Test_checkScNotRunning(pl_scens[i]);
        //          f_EPTF_ExecCtrl_startTCOnLGens(f_EPTF_ExecCtrl_getScenarioIdx(pl_scens[i].scenName), f_EPTF_ExecCtrl_getTrafficCaseIdx(pl_scens[i].tcName));
        f_EPTF_ExecCtrl_startTCOnLGens(
          f_EPTF_ExecCtrl_getScenarioIdx(pl_scens[i].eGrpName,pl_scens[i].scenName),
          f_EPTF_ExecCtrl_getTcOfScenarioIdx(f_EPTF_ExecCtrl_getTrafficCaseIdx(pl_scens[i].eGrpName,pl_scens[i].scenName,pl_scens[i].tcName))
        );
      }

      t_test.start(tsp_EPTF_Var_SyncInterval+2.0);
      t_test.timeout;
      for (var integer i := 0; i < sizeof(pl_scens); i := i + 1) {
        f_EPTF_ExecCtrl_Test_checkScRunning(pl_scens[i]);
      }
      f_EPTF_ExecCtrl_stopAllScenarios();
      repeat;
    }
  }
}

function f_EPTF_ExecCtrl_Test_stopTCOnLGensByName(
  in charstring pl_name,
  in integer pl_nOfClients, in EPTF_ExecCtrl_Test_SCDataList pl_scens, in float pl_time)
runs on EPTF_ExecCtrl_Test_CT
{
  f_EPTF_ExecCtrl_setManualControl(true);
  f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients);

  v_EPTF_ExecCtrl_Test_scenarios := pl_scens;
  f_EPTF_ExecCtrl_registerScenarioStateChangedCallback(refers(f_EPTF_ExecCtrl_Test_UpdateScenarioState));

  t_test.start(pl_time);

  alt
  {
    [] t_test.timeout {
      for (var integer i := 0; i < sizeof(pl_scens); i := i + 1) {
        f_EPTF_ExecCtrl_Test_checkScNotRunning(pl_scens[i]);
        //          f_EPTF_ExecCtrl_startTCOnLGens(f_EPTF_ExecCtrl_getScenarioIdx(pl_scens[i].scenName),f_EPTF_ExecCtrl_getTrafficCaseIdx(pl_scens[i].tcName));
        f_EPTF_ExecCtrl_startTCOnLGens(
          f_EPTF_ExecCtrl_getScenarioIdx(pl_scens[i].eGrpName,pl_scens[i].scenName),
          f_EPTF_ExecCtrl_getTcOfScenarioIdx(f_EPTF_ExecCtrl_getTrafficCaseIdx(pl_scens[i].eGrpName,pl_scens[i].scenName,pl_scens[i].tcName))
        );
        //          f_EPTF_ExecCtrl_stopTCOnLGens(f_EPTF_ExecCtrl_getScenarioIdx(pl_scens[i].scenName),f_EPTF_ExecCtrl_getTrafficCaseIdx(pl_scens[i].tcName));
        f_EPTF_ExecCtrl_stopTCOnLGens(
          f_EPTF_ExecCtrl_getScenarioIdx(pl_scens[i].eGrpName,pl_scens[i].scenName),
          f_EPTF_ExecCtrl_getTcOfScenarioIdx(f_EPTF_ExecCtrl_getTrafficCaseIdx(pl_scens[i].eGrpName,pl_scens[i].scenName,pl_scens[i].tcName))
        );
      }

      t_test.start(tsp_EPTF_Var_SyncInterval+2.0);
      t_test.timeout;
      for (var integer i := 0; i < sizeof(pl_scens); i := i + 1) {
        f_EPTF_ExecCtrl_Test_checkScNotRunning(pl_scens[i]);
      }
      repeat;
    }
  } //alt
}

function f_EPTF_ExecCtrl_Test_checkScenarioStatus(
  in charstring pl_name,
  in integer pl_nOfClients, in EPTF_ExecCtrl_Test_SCDataList pl_scens, in float pl_time)
runs on EPTF_ExecCtrl_Test_CT
{

  v_EPTF_ExecCtrl_Test_scenarios := pl_scens;

  f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients);
  f_EPTF_ExecCtrl_registerScenarioStateChangedCallback(refers(f_EPTF_ExecCtrl_Test_StartScenario));
  v_EPTF_ExecCtrl_Test_scenarios := pl_scens;
  f_EPTF_ExecCtrl_registerScenarioStateChangedCallback(refers(f_EPTF_ExecCtrl_Test_UpdateScenarioState));

  t_test.start(pl_time);

  alt
  {
    [] t_test.timeout {
      for (var integer i := 0; i < sizeof(pl_scens); i := i + 1) {
        f_EPTF_ExecCtrl_Test_checkScRunning(pl_scens[i]);
      }
      repeat;
    }
  } // alt
}

function f_EPTF_ExecCtrl_Test_stopAllScenarios(
  in charstring pl_name,
  in integer pl_nOfClients, in EPTF_ExecCtrl_Test_SCDataList pl_scens, in float pl_time)
runs on EPTF_ExecCtrl_Test_CT
{
  f_EPTF_ExecCtrl_setManualControl(true);
  f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients);
  v_EPTF_ExecCtrl_Test_scenarios := pl_scens;
  f_EPTF_ExecCtrl_registerScenarioStateChangedCallback(refers(f_EPTF_ExecCtrl_Test_StartScenario));
  f_EPTF_ExecCtrl_registerScenarioStateChangedCallback(refers(f_EPTF_ExecCtrl_Test_UpdateScenarioState));

  t_test.start(pl_time);

  alt
  {
    [] t_test.timeout {
      f_EPTF_ExecCtrl_stopAllScenarios();
      t_test.start(tsp_EPTF_Var_SyncInterval+2.0);
      t_test.timeout;
      for (var integer i := 0; i < sizeof(pl_scens); i := i + 1) {
        f_EPTF_ExecCtrl_Test_checkScNotRunning(pl_scens[i]);
      }
      repeat;
    }
  } //alt
}

function f_EPTF_ExecCtrl_Test_startAllScenarios(
  in charstring pl_name,
  in integer pl_nOfClients, in EPTF_ExecCtrl_Test_SCDataList pl_scens, in float pl_time)
runs on EPTF_ExecCtrl_Test_CT
{
  f_EPTF_ExecCtrl_setManualControl(true);
  f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients);

  v_EPTF_ExecCtrl_Test_scenarios := pl_scens;
  f_EPTF_ExecCtrl_registerScenarioStateChangedCallback(refers(f_EPTF_ExecCtrl_Test_UpdateScenarioState));

  t_test.start(pl_time);

  alt
  {
    [] t_test.timeout {
      f_EPTF_ExecCtrl_startAllScenarios();
      t_test.start(tsp_EPTF_Var_SyncInterval+2.0);
      t_test.timeout;
      for (var integer i := 0; i < sizeof(pl_scens); i := i + 1) {
        f_EPTF_ExecCtrl_Test_checkScRunning(pl_scens[i]);
      }
      f_EPTF_Base_stopAll(none);
      repeat;
    }
  } //alt
}

function f_EPTF_ExecCtrl_Test_checkAllScenarios(
  in charstring pl_name,
  in integer pl_nOfClients, in EPTF_ExecCtrl_Test_SCDataList pl_scens, in float pl_time)
runs on EPTF_ExecCtrl_Test_CT
{
  f_EPTF_ExecCtrl_setManualControl(true);
  f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients);
  template charstring t_runningState := ("Running");
  template charstring t_notRunningState := ("Finished","Stopped","Idle");

  v_EPTF_ExecCtrl_Test_scenarios := pl_scens;
  f_EPTF_ExecCtrl_registerScenarioStateChangedCallback(refers(f_EPTF_ExecCtrl_Test_UpdateScenarioState));
  //f_EPTF_ExecCtrl_registerScenarioStateChangedCallback(refers(f_EPTF_ExecCtrl_Test_StartScenario));

  t_test.start(pl_time);

  alt
  {
    [] t_test.timeout {
      //Check runnning scenarios
      f_EPTF_ExecCtrl_startAllScenarios();
      t_test.start(tsp_EPTF_Var_SyncInterval+2.0);
      t_test.timeout;
      for (var integer i := 0; i < sizeof(pl_scens); i := i + 1) {
        f_EPTF_ExecCtrl_Test_checkScRunning(pl_scens[i]);
      }
      //Check scenario statuses with new function
      if(f_EPTF_ExecCtrl_checkAllScenarios(t_runningState)) {setverdict(pass);} else {setverdict(fail);}

      //Check stopped scenarios
      f_EPTF_ExecCtrl_stopAllScenarios();
      t_test.start(tsp_EPTF_Var_SyncInterval+2.0);
      t_test.timeout;
      for (var integer i := 0; i < sizeof(pl_scens); i := i + 1) {
        f_EPTF_ExecCtrl_Test_checkScNotRunning(pl_scens[i]);
      }
      //Check scenario statuses with new function
      if(f_EPTF_ExecCtrl_checkAllScenarios(t_notRunningState)) {setverdict(pass);} else {setverdict(fail);}

      f_EPTF_Base_stopAll(none);
      repeat;
    }
  } //alt
}

function f_EPTF_ExecCtrl_Test_setCps_TC(
  in charstring pl_name,
  in integer pl_nOfClients, in EPTF_ExecCtrl_Test_SCDataList pl_scens, in float pl_time)
runs on EPTF_ExecCtrl_Test_CT
{
  var integer vl_sIdx;
  var integer vl_tcIdx;
  var float vl_cps;
  var integer vl_count := 0;

  f_EPTF_ExecCtrl_setManualControl(true);
  v_EPTF_ExecCtrl_Test_scenarios := pl_scens;

  f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients);
  f_EPTF_Var_setSyncInterval(1.5)
  //f_EPTF_ExecCtrl_registerScenarioStateChangedCallback(refers(f_EPTF_ExecCtrl_Test_StartScenario));
  f_EPTF_ExecCtrl_registerTrafficCaseStateChangedCallback(refers(f_EPTF_ExecCtrl_Test_StartTC));
  f_EPTF_ExecCtrl_registerTrafficCaseStateChangedCallback(refers(f_EPTF_ExecCtrl_Test_UpdateTCState));


  t_test.start(pl_scens[0].timeProfile[vl_count].time);

  alt
  {
    [] t_test.timeout {


      for (var integer i := 0; i < sizeof(pl_scens); i := i + 1)
      {
        vl_sIdx := f_EPTF_ExecCtrl_getScenarioIdx(pl_scens[i].eGrpName,pl_scens[i].scenName);
        var integer vl_tcInstanceIdx := f_EPTF_ExecCtrl_getTrafficCaseIdx(pl_scens[i].eGrpName,pl_scens[i].scenName,pl_scens[i].tcName);
        vl_tcIdx := f_EPTF_ExecCtrl_getTcOfScenarioIdx(vl_tcInstanceIdx);
        vl_cps := pl_scens[i].timeProfile[vl_count].targetValue;
        f_EPTF_ExecCtrl_setCps_TC(vl_sIdx, vl_tcIdx, vl_cps);
        f_EPTF_ExecCtrl_Test_checkScRunning(pl_scens[i]);
      }
      vl_count := vl_count + 1;
      if (vl_count < sizeof(pl_scens[0].timeProfile)) {
        t_test.start(pl_scens[0].timeProfile[vl_count].time - pl_scens[0].timeProfile[vl_count - 1].time);
      }
      repeat;
    }
  } // alt
}

function f_EPTF_ExecCtrl_Test_trafficCaseCPSChangedCallbackFn(in float pl_cps, in integer pl_tcIdx) runs on EPTF_ExecCtrl_Test_CT {
  v_EPTF_ExecCtrl_Test_CPSChangedCallback_Called := true;
  log(%definitionId&" TrafficCaseCPSChanged callback called with pl_cps: ", pl_cps, ", pl_tcIdx: ", pl_tcIdx, ", TC name: ", f_EPTF_ExecCtrl_getTrafficCaseName(pl_tcIdx));
}

function f_EPTF_ExecCtrl_Test_setCps_TCCPSChangedCallback(
  in charstring pl_name,
  in integer pl_nOfClients, in EPTF_ExecCtrl_Test_SCDataList pl_scens, in float pl_time)
runs on EPTF_ExecCtrl_Test_CT
{
  var integer vl_sIdx;
  var integer vl_tcIdx;
  var float vl_cps;
  var integer vl_count := 0;

  f_EPTF_ExecCtrl_setManualControl(true);
  v_EPTF_ExecCtrl_Test_scenarios := pl_scens;

  f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients);

  //f_EPTF_ExecCtrl_registerScenarioStateChangedCallback(refers(f_EPTF_ExecCtrl_Test_StartScenario));
  f_EPTF_ExecCtrl_registerTrafficCaseStateChangedCallback(refers(f_EPTF_ExecCtrl_Test_StartTC));
  f_EPTF_ExecCtrl_registerTrafficCaseStateChangedCallback(refers(f_EPTF_ExecCtrl_Test_UpdateTCState));

  for (var integer i := 0; i < sizeof(pl_scens); i := i + 1) {
    f_EPTF_ExecCtrl_registerCPSChangedCallback_TC(
      f_EPTF_ExecCtrl_getTrafficCaseIdx(pl_scens[i].eGrpName,pl_scens[i].scenName,pl_scens[i].tcName),
      refers(f_EPTF_ExecCtrl_Test_trafficCaseCPSChangedCallbackFn)
    )
  }


  t_test.start(pl_scens[0].timeProfile[vl_count].time);

  alt
  {
    [] t_test.timeout {


      for (var integer i := 0; i < sizeof(pl_scens); i := i + 1)
      {
        vl_sIdx := f_EPTF_ExecCtrl_getScenarioIdx(pl_scens[i].eGrpName,pl_scens[i].scenName);
        var integer vl_tcInstanceIdx := f_EPTF_ExecCtrl_getTrafficCaseIdx(pl_scens[i].eGrpName,pl_scens[i].scenName,pl_scens[i].tcName);
        vl_tcIdx := f_EPTF_ExecCtrl_getTcOfScenarioIdx(vl_tcInstanceIdx);
        vl_cps := pl_scens[i].timeProfile[vl_count].targetValue;
        log("*** TrafficCaseCPSChanged check")
        v_EPTF_ExecCtrl_Test_CPSChangedCallback_Called := false;
        f_EPTF_ExecCtrl_setCps_TC(vl_sIdx, vl_tcIdx, vl_cps);
        if (not v_EPTF_ExecCtrl_Test_CPSChangedCallback_Called) {
          log(%definitionId&" Error: TrafficCaseCPSChanged callback is not called for traffic case: ", vl_tcInstanceIdx);
          setverdict(fail);
        }
        f_EPTF_ExecCtrl_Test_checkScRunning(pl_scens[i]);
      }
      vl_count := vl_count + 1;
      if (vl_count < sizeof(pl_scens[0].timeProfile)) {
        t_test.start(pl_scens[0].timeProfile[vl_count].time - pl_scens[0].timeProfile[vl_count - 1].time);
      }
      repeat;
    }
  } // alt
}

function f_EPTF_ExecCtrl_Test_setCps_SC(
  in charstring pl_name,
  in integer pl_nOfClients, in EPTF_ExecCtrl_Test_SCDataList pl_scens, in float pl_time)
runs on EPTF_ExecCtrl_Test_CT
{
  var integer vl_sIdx;
  var float vl_cps;
  var integer vl_count := 0;

  f_EPTF_ExecCtrl_setManualControl(true);
  v_EPTF_ExecCtrl_Test_scenarios := pl_scens;
  f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients);
  f_EPTF_ExecCtrl_registerScenarioStateChangedCallback(refers(f_EPTF_ExecCtrl_Test_StartScenario));
  f_EPTF_ExecCtrl_registerScenarioStateChangedCallback(refers(f_EPTF_ExecCtrl_Test_UpdateScenarioState));


  t_test.start(pl_scens[0].timeProfile[vl_count].time);

  alt
  {
    [] t_test.timeout {


      for (var integer i := 0; i < sizeof(pl_scens); i := i + 1)
      {
        vl_sIdx := f_EPTF_ExecCtrl_getScenarioIdx(pl_scens[i].eGrpName,pl_scens[i].scenName);
        vl_cps := pl_scens[i].timeProfile[vl_count].targetValue;

        f_EPTF_ExecCtrl_setCps_SC(vl_sIdx, vl_cps);

        f_EPTF_ExecCtrl_Test_checkScRunning(pl_scens[i]);
      }
      vl_count := vl_count + 1;
      if (vl_count < sizeof(pl_scens[0].timeProfile)) {
        t_test.start(pl_scens[0].timeProfile[vl_count].time - pl_scens[0].timeProfile[vl_count - 1].time);
      }
      repeat;
    }
  } // alt
}

function f_EPTF_ExecCtrl_Test_scenarioCPSChangedCallbackFn(in float pl_cps, in integer pl_scIdx) runs on EPTF_ExecCtrl_Test_CT {
  v_EPTF_ExecCtrl_Test_CPSChangedCallback_Called := true;
  log(%definitionId&" ScenarioCPSChanged callback called with pl_cps: ", pl_cps, ", pl_scIdx: ", pl_scIdx, ", SC name: ", f_EPTF_ExecCtrl_getScenarioInstanceName(pl_scIdx));
}

function f_EPTF_ExecCtrl_Test_setCps_SCCPSChangedCallback(
  in charstring pl_name,
  in integer pl_nOfClients, in EPTF_ExecCtrl_Test_SCDataList pl_scens, in float pl_time)
runs on EPTF_ExecCtrl_Test_CT
{
  var integer vl_sIdx;
  var integer vl_tcIdx;
  var float vl_cps;
  var integer vl_count := 0;

  f_EPTF_ExecCtrl_setManualControl(true);
  v_EPTF_ExecCtrl_Test_scenarios := pl_scens;

  f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients);
  f_EPTF_ExecCtrl_registerScenarioStateChangedCallback(refers(f_EPTF_ExecCtrl_Test_StartScenario));
  f_EPTF_ExecCtrl_registerScenarioStateChangedCallback(refers(f_EPTF_ExecCtrl_Test_UpdateScenarioState));

  for (var integer i := 0; i < sizeof(pl_scens); i := i + 1) {
    f_EPTF_ExecCtrl_registerCPSChangedCallback_SC(
      f_EPTF_ExecCtrl_getScenarioIdx(pl_scens[i].eGrpName,pl_scens[i].scenName),
      refers(f_EPTF_ExecCtrl_Test_scenarioCPSChangedCallbackFn)
    )
    f_EPTF_ExecCtrl_startScenarioOnLGensByName(pl_scens[i].eGrpName,pl_scens[i].scenName);
  }

  t_test.start(pl_scens[0].timeProfile[vl_count].time);

  alt
  {
    [] t_test.timeout {


      for (var integer i := 0; i < sizeof(pl_scens); i := i + 1)
      {
        vl_sIdx := f_EPTF_ExecCtrl_getScenarioIdx(pl_scens[i].eGrpName,pl_scens[i].scenName);
        vl_cps := pl_scens[i].timeProfile[vl_count].targetValue;
        log("*** ScenarioCPSChanged check")
        v_EPTF_ExecCtrl_Test_CPSChangedCallback_Called := false;
        f_EPTF_ExecCtrl_setCps_SC(vl_sIdx, vl_cps);
        if (not v_EPTF_ExecCtrl_Test_CPSChangedCallback_Called) {
          log(%definitionId&" Error: ScenarioCPSChanged callback is not called for scenario: ", vl_sIdx, ", SC name: ", f_EPTF_ExecCtrl_getScenarioInstanceName(vl_sIdx));
          setverdict(fail);
        }
        f_EPTF_ExecCtrl_Test_checkScRunning(pl_scens[i]);
      }
      vl_count := vl_count + 1;
      if (vl_count < sizeof(pl_scens[0].timeProfile)) {
        t_test.start(pl_scens[0].timeProfile[vl_count].time - pl_scens[0].timeProfile[vl_count - 1].time);
      }
      repeat;
    }
  } // alt
}

function f_EPTF_ExecCtrlClient_Test_CPS(
  in charstring pl_selfName,
  in EPTF_ExecCtrl_Test_CT pl_execCtrl,
  in EPTF_ExecCtrl_Test_SCDataList pl_scens,
  in boolean pl_checkCpsToReach := true,
  in float pl_measureTime := 2.0)
runs on EPTF_ExecCtrlClient_Test_CT
{
  timer tl_test;
  var float vl_currentCPS := 0.0;
  var float vl_targetCPS := 0.0;
  var integer vl_count := 0;

  v_EPTF_ExecCtrlClient_Test_scenarios := pl_scens;

  f_EPTF_ExecCtrlClient_Test_init(pl_selfName, pl_execCtrl);
  f_EPTF_Var_setSyncInterval(0.5);

  timer t_wait := 0.0;

  var charstring vl_varName := "ExecCtrlClient.trafficCaseStatus."&pl_scens[0].eGrpName&"."&pl_scens[0].scenName&"."&pl_scens[0].tcName;
  t_wait.start;

  alt {

    [f_EPTF_Var_getId(vl_varName)!=-1 and f_EPTF_Var_getCharstringValue(f_EPTF_Var_getId(vl_varName))==c_EPTF_LGenBase_stateNames[c_EPTF_LGenBase_tcStateRunning]] t_wait.timeout {
      tl_test.start(v_EPTF_ExecCtrlClient_Test_scenarios[0].timeProfile[vl_count].time+f_EPTF_Var_getRefreshPeriod(0)*2.1);
      repeat;
    }

    [] tl_test.timeout {
      log(">>>Timeout occured, scenarios: ",v_EPTF_ExecCtrlClient_Test_scenarios);
      if(not f_EPTF_LGenBase_initialized()) {setverdict(fail);return;}

      for(var integer i := 0; i < sizeof(v_EPTF_ExecCtrlClient_Test_scenarios); i := i + 1 ) {
        var float vl_maxError := 0.001;

        if(pl_checkCpsToReach) {
          if(f_EPTF_ExecCtrlTest_isWeightedScenariobyName(pl_scens[i].eGrpName, pl_scens[i].scenName)) {
            vl_currentCPS := f_EPTF_LGenBase_getScCpsSoReachByName(pl_scens[i].eGrpName, pl_scens[i].scenName);
          } else {
            f_EPTF_LGenBase_logEntityGroups();//just to see the problem
            vl_currentCPS := f_EPTF_LGenBase_getTcCpsToReachByName(pl_scens[i].eGrpName, pl_scens[i].scenName, pl_scens[i].tcName);
          }
        } else {
          if(f_EPTF_ExecCtrlTest_isWeightedScenariobyName(pl_scens[i].eGrpName, pl_scens[i].scenName)) {
            vl_currentCPS := f_EPTF_ExecCtrlTest_getWeightedScenarioCps(pl_scens[i].eGrpName, pl_scens[i].scenName);
          } else {
            vl_currentCPS := f_EPTF_LGenBase_getMeasuredCPSByNames(pl_scens[i].eGrpName, pl_scens[i].scenName, pl_scens[i].tcName);
          }
          vl_maxError := 1.0;
        }

        vl_targetCPS := pl_scens[i].timeProfile[vl_count].targetValue;
        if(vl_currentCPS < vl_targetCPS + vl_maxError and vl_currentCPS > vl_targetCPS - vl_maxError)
        {
          log("Current CPS: ", vl_currentCPS, " expected: ", vl_targetCPS);
          setverdict(pass)
        } else {
          log("Current CPS: ", vl_currentCPS, " expected: ", vl_targetCPS);
          setverdict(fail)
        }
      }
      vl_count := vl_count + 1;
      if (vl_count < sizeof(pl_scens[0].timeProfile)) {
        tl_test.start(pl_scens[0].timeProfile[vl_count].time - pl_scens[0].timeProfile[vl_count - 1].time);
      }
      repeat;
    }
  }
}

function f_EPTF_ExecCtrlClient_Test_trafficCaseCPSChangedCallbackFn(in float pl_cps, in integer pl_tcIdx) runs on EPTF_ExecCtrlClient_Test_CT {
  v_EPTF_ExecCtrlClient_Test_CPSChangedCallback_Called := true;

  var charstring vl_eGrpName;
  var charstring vl_scName;
  var charstring vl_tcName;
  f_EPTF_LGenBase_trafficCaseIdNames(pl_tcIdx,vl_eGrpName,vl_scName,vl_tcName);
  log(%definitionId&" TrafficCaseCPSChanged callback called with pl_cps: ", pl_cps, ", pl_tcIdx: ", pl_tcIdx, ", TC name: ", vl_eGrpName,".",vl_scName,".",vl_tcName);
}

function f_EPTF_ExecCtrlClient_Test_CPSChangedCallbackCheck() runs on EPTF_ExecCtrlClient_Test_CT {
  if (not v_EPTF_ExecCtrlClient_Test_CPSChangedCallback_Called) {
    log(%definitionId&" TrafficCaseCPSChanged callback was not called.");
    setverdict(fail)
  }
  else {
    setverdict(pass);
  }
}

function f_EPTF_ExecCtrlClient_Test_cleanupWaiting() runs on EPTF_ExecCtrlClient_Test_CT
{
   f_EPTF_ExecCtrlClient_readyToStart();
   timer t1;
   t1.start(10.0);
   t1.timeout;
   if(f_EPTF_ExecCtrlClient_checkEndOfConfig()){
     setverdict(fail, "Error: EndOfConfig should not be handled during cleanup, but now it is");
   } else {
     setverdict(pass);
   }
}

function f_EPTF_ExecCtrlClient_Test_CPSChangedCallback_TC(
  in charstring pl_selfName,
  in EPTF_ExecCtrl_Test_CT pl_execCtrl,
  in EPTF_ExecCtrl_Test_SCDataList pl_scens,
  in boolean pl_checkCpsToReach := true,
  in float pl_measureTime := 2.0)
runs on EPTF_ExecCtrlClient_Test_CT
{
  timer tl_test;
  var float vl_currentCPS := 0.0;
  var float vl_targetCPS := 0.0;
  var integer vl_count := 0;

  v_EPTF_ExecCtrlClient_Test_scenarios := pl_scens;
  v_EPTF_ExecCtrlClient_Test_CPSChangedCallback_Called := false;

  f_EPTF_ExecCtrlClient_Test_init(pl_selfName, pl_execCtrl);

  f_EPTF_Base_registerCleanup(refers(f_EPTF_ExecCtrlClient_Test_CPSChangedCallbackCheck));


  tl_test.start(0.0);

  alt {
    [f_EPTF_ExecCtrlClient_checkEndOfConfig()] tl_test.timeout {
      for (var integer i := 0; i < sizeof(pl_scens); i := i + 1) {
        f_EPTF_LGenBase_registerCPSChangedCallback_TC(
          pl_scens[i].eGrpName,pl_scens[i].scenName,pl_scens[i].tcName,
          refers(f_EPTF_ExecCtrlClient_Test_trafficCaseCPSChangedCallbackFn)
        )
      }
    }
  }

  tl_test.start(v_EPTF_ExecCtrlClient_Test_scenarios[0].timeProfile[vl_count].time + pl_measureTime);

  alt {

    [] tl_test.timeout {
      for(var integer i := 0; i < sizeof(v_EPTF_ExecCtrlClient_Test_scenarios); i := i + 1 ) {
        var float vl_maxError := 0.001;

        if(pl_checkCpsToReach) {
          if(f_EPTF_ExecCtrlTest_isWeightedScenariobyName(pl_scens[i].eGrpName, pl_scens[i].scenName)) {
            vl_currentCPS := f_EPTF_LGenBase_getScCpsSoReachByName(pl_scens[i].eGrpName, pl_scens[i].scenName);
          } else {
            vl_currentCPS := f_EPTF_LGenBase_getTcCpsToReachByName(pl_scens[i].eGrpName, pl_scens[i].scenName, pl_scens[i].tcName);
          }
        } else {
          if(f_EPTF_ExecCtrlTest_isWeightedScenariobyName(pl_scens[i].eGrpName, pl_scens[i].scenName)) {
            vl_currentCPS := f_EPTF_ExecCtrlTest_getWeightedScenarioCps(pl_scens[i].eGrpName, pl_scens[i].scenName);
          } else {
            vl_currentCPS := f_EPTF_LGenBase_getMeasuredCPSByNames(pl_scens[i].eGrpName, pl_scens[i].scenName, pl_scens[i].tcName);
          }
          vl_maxError := 1.0;
        }

        vl_targetCPS := pl_scens[i].timeProfile[vl_count].targetValue;
        if(vl_currentCPS < vl_targetCPS + vl_maxError and vl_currentCPS > vl_targetCPS - vl_maxError)
        {
          log("Current CPS: ", vl_currentCPS, " expected: ", vl_targetCPS);
          setverdict(pass)
        } else {
          log("Current CPS: ", vl_currentCPS, " expected: ", vl_targetCPS);
          setverdict(fail)
        }
      }
      vl_count := vl_count + 1;
      if (vl_count < sizeof(pl_scens[0].timeProfile)) {
        tl_test.start(pl_scens[0].timeProfile[vl_count].time - pl_scens[0].timeProfile[vl_count - 1].time);
      }
      repeat;
    }
  }
}

function f_EPTF_ExecCtrlClient_Test_CPSFromTimeProfile(
  in charstring pl_selfName,
  in EPTF_ExecCtrl_Test_CT pl_execCtrl,
  in EPTF_ExecCtrl_TimeProfileItemList pl_timeProfile)
runs on EPTF_ExecCtrlClient_Test_CT
{
  timer tl_test;
  var integer vl_count := 0;
  f_EPTF_ExecCtrlClient_Test_init(pl_selfName, pl_execCtrl);
  tl_test.start(pl_timeProfile[vl_count].time + 0.7);

  alt {
    [] tl_test.timeout {
      var float vl_cps := f_EPTF_LGenBase_getCPSByNames("grp0","scenario_0_declarator2","TC0_declarator2");
      if(vl_cps < pl_timeProfile[vl_count].targetValue + 0.2 and
        vl_cps > pl_timeProfile[vl_count].targetValue - 0.2)
      {
        log("Current CPS: ", vl_cps, " expected: ", pl_timeProfile[vl_count].targetValue);
        setverdict(pass)
      } else {
        log("Current CPS: ", vl_cps, " expected: ", pl_timeProfile[vl_count].targetValue);
        setverdict(fail)
      }

      vl_count := vl_count + 1;
      log("### vl_count: ", vl_count, "sizeof(pl_timeProfile) ", sizeof(pl_timeProfile));
      if (vl_count < sizeof(pl_timeProfile)) {
        tl_test.start(pl_timeProfile[vl_count].time);
      }
      repeat;
    }
  }
}

function f_EPTF_ExecCtrl_UIHandler_Test_setCPS(
  in charstring pl_name,
  in integer pl_nOfClients, in EPTF_UIHandler_CT pl_gui, in EPTF_ExecCtrl_Test_SCDataList pl_scens, in float pl_time)
runs on EPTF_ExecCtrl_UIHandler_Test_CT
{


  f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients, pl_dataSource_compRef := pl_gui);

  var float vl_cps;
  var integer vl_varID;
  var integer vl_count := 0;
  timer t_start, t_stop;
  var EPTF_Var_DirectContent vl_Var_content;
  var charstring vl_varName;
  var float vl_now := 0.0;

  v_EPTF_ExecCtrl_Test_scenarios := pl_scens;
  f_EPTF_ExecCtrl_registerScenarioStateChangedCallback(refers(f_EPTF_ExecCtrl_Test_UpdateScenarioState));

  t_start.start(0.0);
  t_stop.start(pl_time);

  alt
  {
    [f_EPTF_ExecCtrl_checkReadyToRun()] t_start.timeout { // note: moved here so the timing of pl_scens[0].timeProfile stays in-sync with client
      vl_now := f_EPTF_Base_getRelTimeInSecs();
      f_EPTF_Var_logNames("##### Vars ####");
      for (var integer i := 0; i < sizeof(pl_scens); i := i + 1) {
        var integer vl_scIdx := f_EPTF_ExecCtrl_getScenarioIdx(pl_scens[i].eGrpName,pl_scens[i].scenName);
        if(f_EPTF_ExecCtrl_isWeightedScenario(vl_scIdx)) {
          vl_varName := "ExecCtrl.startScenario." &  pl_scens[i].eGrpName & "." & pl_scens[i].scenName;
        } else {
          vl_varName := "ExecCtrl.startTC." &  pl_scens[i].eGrpName & "." & pl_scens[i].scenName & "." & pl_scens[i].tcName;
        }
        vl_varID := f_EPTF_Var_getId(vl_varName);
        if(vl_varID != -1) {
          f_EPTF_Var_adjustContent(vl_varID, {boolVal := true});
          var float vl_remainingTime := pl_scens[0].timeProfile[0].time - vl_now;
          if(vl_remainingTime < 0.0) {
            log(%definitionId&": cannot start test timer with negative value. It is possible that the GUI took too much time to initialize.");
            f_EPTF_Base_stopAll(inconc);
          }
          t_test.start(vl_remainingTime);
        } else {
          log("There is no such Variable: ", vl_varName);
          //setverdict(fail);
          f_EPTF_Base_stopAll();
          //exit
        }
      }
      repeat;
    }
    [] t_stop.timeout {
      log("###: push Exit button")
      vl_varID := f_EPTF_Var_getId(c_EPTF_ExecCtrl_Exit);
      if(vl_varID != -1) {
        f_EPTF_Var_adjustContent(vl_varID, {intVal := 1});

      } else {
        log("There is no such Variable: ", c_EPTF_ExecCtrl_Exit);
        setverdict(fail);
        //exit
      }
      repeat;
    }
    [] t_test.timeout {


      for (var integer i := 0; i < sizeof(pl_scens); i := i + 1)
      {
        var integer vl_scInstanceIdx := f_EPTF_ExecCtrl_getScenarioIdx(
          pl_scens[i].eGrpName,
          pl_scens[i].scenName
        );

        var integer vl_tcInstanceIdx := f_EPTF_ExecCtrl_getTrafficCaseIdx(
          pl_scens[i].eGrpName,
          pl_scens[i].scenName,
          pl_scens[i].tcName
        );

        var integer vl_tcOfScIdx := f_EPTF_ExecCtrl_getTcOfScenarioIdx(vl_tcInstanceIdx);

        vl_cps := pl_scens[i].timeProfile[vl_count].targetValue;

        f_EPTF_ExecCtrl_Test_checkScRunning(pl_scens[i]);

        if(f_EPTF_ExecCtrl_isWeightedScenario(vl_scInstanceIdx)) {
          f_EPTF_ExecCtrl_setCps_SC(vl_scInstanceIdx, vl_cps);
          vl_varName := "Traffic.ScenarioCPS." &pl_scens[i].eGrpName&"."&int2str(vl_scInstanceIdx);
          //vl_varName := FIXME_ExecCtrlUI_GenerateNameForScCpsWidget(vl_scInstanceIdx); <--- FIXME: should be in EPTF_CLL_ExecCtrlUI_Functions.ttcn
        } else {
          f_EPTF_ExecCtrl_setCps_TC(vl_scInstanceIdx, vl_tcOfScIdx, vl_cps);
          vl_varName := "Traffic.TCCPS." &pl_scens[i].eGrpName&"."&int2str(vl_scInstanceIdx) &"."&int2str(vl_tcOfScIdx);
          //vl_varName := FIXME_ExecCtrlUI_GenerateNameForTcCpsWidget(vl_tcInstanceIdx); <--- FIXME: should be in EPTF_CLL_ExecCtrlUI_Functions.ttcn
        }

        vl_varID := f_EPTF_Var_getId(vl_varName);
        if (vl_varID != -1) {
          f_EPTF_Var_refreshContent(vl_varID);
          f_EPTF_Var_getContent(vl_varID, vl_Var_content);
          if (vl_Var_content.floatVal == pl_scens[i].timeProfile[vl_count].targetValue) {
            log("Expected CPS value set in the GUI: ", vl_Var_content.floatVal);
            setverdict(pass);
          } else {
            log("Unexpected CPS value set in the GUI: ", vl_Var_content.floatVal, " Expected: ", pl_scens[i].timeProfile[vl_count].targetValue);
            setverdict(fail);
          }

        } else {
          log("No such EPTF variable with name: ", vl_varName);
          setverdict(fail);
        }

        f_EPTF_ExecCtrl_Test_checkScRunning(pl_scens[i]);

      }

      vl_count := vl_count + 1;
      if (vl_count < sizeof(pl_scens[0].timeProfile)) {
        t_test.start(pl_scens[0].timeProfile[vl_count].time - pl_scens[0].timeProfile[vl_count - 1].time);
      }
      repeat;
    }
  } // alt
}

function f_EPTF_ExecCtrlClient_Test_scenarioCPSChangedCallbackFn(in float pl_cps, in integer pl_eGrpIdx, in integer pl_scIdx) runs on EPTF_ExecCtrlClient_Test_CT {
  v_EPTF_ExecCtrlClient_Test_CPSChangedCallback_Called := true;

  var charstring vl_eGrpName;
  var charstring vl_scName;
  f_EPTF_LGenBase_scenarioIdNames(pl_eGrpIdx,pl_scIdx,vl_eGrpName,vl_scName);
  log(%definitionId&" ScenarioCPSChanged callback called with pl_cps: ", pl_cps, ", pl_eGrpIdx: ", pl_eGrpIdx, ", pl_scIdx: ", pl_scIdx, ", TC name: ", vl_eGrpName,".",vl_scName);
}

function f_EPTF_ExecCtrlClient_Test_scenarioCPSChangedCallbackCheck() runs on EPTF_ExecCtrlClient_Test_CT {
  if (not v_EPTF_ExecCtrlClient_Test_CPSChangedCallback_Called) {
    log(%definitionId&" ScenarioCPSChanged callback was not called.");
    setverdict(fail)
  }
  else {
    setverdict(pass);
  }
}

function f_EPTF_ExecCtrlClient_Test_CPSChangedCallback_SC(
  in charstring pl_selfName,
  in EPTF_ExecCtrl_Test_CT pl_execCtrl,
  in EPTF_ExecCtrl_Test_SCDataList pl_scens,
  in boolean pl_checkCpsToReach := true,
  in float pl_measureTime := 2.0)
runs on EPTF_ExecCtrlClient_Test_CT
{
  timer tl_test;
  var float vl_currentCPS := 0.0;
  var float vl_targetCPS := 0.0;
  var integer vl_count := 0;

  v_EPTF_ExecCtrlClient_Test_scenarios := pl_scens;
  v_EPTF_ExecCtrlClient_Test_CPSChangedCallback_Called := false;

  f_EPTF_ExecCtrlClient_Test_init(pl_selfName, pl_execCtrl);

  f_EPTF_Base_registerCleanup(refers(f_EPTF_ExecCtrlClient_Test_CPSChangedCallbackCheck));


  tl_test.start(0.0);

  alt {
    [f_EPTF_ExecCtrlClient_checkEndOfConfig()] tl_test.timeout {
      for (var integer i := 0; i < sizeof(pl_scens); i := i + 1) {
        f_EPTF_LGenBase_registerCPSChangedCallback_SC(
          pl_scens[i].eGrpName,pl_scens[i].scenName,
          refers(f_EPTF_ExecCtrlClient_Test_scenarioCPSChangedCallbackFn)
        )
      }
    }
  }

  tl_test.start(v_EPTF_ExecCtrlClient_Test_scenarios[0].timeProfile[vl_count].time + pl_measureTime);

  alt {

    [] tl_test.timeout {
      for(var integer i := 0; i < sizeof(v_EPTF_ExecCtrlClient_Test_scenarios); i := i + 1 ) {
        var float vl_maxError := 0.001;

        if(pl_checkCpsToReach) {
          if(f_EPTF_ExecCtrlTest_isWeightedScenariobyName(pl_scens[i].eGrpName, pl_scens[i].scenName)) {
            vl_currentCPS := f_EPTF_LGenBase_getScCpsSoReachByName(pl_scens[i].eGrpName, pl_scens[i].scenName);
          } else {
            vl_currentCPS := f_EPTF_LGenBase_getTcCpsToReachByName(pl_scens[i].eGrpName, pl_scens[i].scenName, pl_scens[i].tcName);
          }
        } else {
          if(f_EPTF_ExecCtrlTest_isWeightedScenariobyName(pl_scens[i].eGrpName, pl_scens[i].scenName)) {
            vl_currentCPS := f_EPTF_ExecCtrlTest_getWeightedScenarioCps(pl_scens[i].eGrpName, pl_scens[i].scenName);
          } else {
            vl_currentCPS := f_EPTF_LGenBase_getMeasuredCPSByNames(pl_scens[i].eGrpName, pl_scens[i].scenName, pl_scens[i].tcName);
          }
          vl_maxError := 1.0;
        }

        vl_targetCPS := pl_scens[i].timeProfile[vl_count].targetValue;
        if(vl_currentCPS < vl_targetCPS + vl_maxError and vl_currentCPS > vl_targetCPS - vl_maxError)
        {
          log("Current CPS: ", vl_currentCPS, " expected: ", vl_targetCPS);
          setverdict(pass)
        } else {
          log("Current CPS: ", vl_currentCPS, " expected: ", vl_targetCPS);
          setverdict(fail)
        }
      }
      vl_count := vl_count + 1;
      if (vl_count < sizeof(pl_scens[0].timeProfile)) {
        tl_test.start(pl_scens[0].timeProfile[vl_count].time - pl_scens[0].timeProfile[vl_count - 1].time);
      }
      repeat;
    }
  }
}

function f_EPTF_ExecCtrl_UIHandler_Test_startButton(
  in charstring pl_name,
  in integer pl_nOfClients, in EPTF_UIHandler_CT pl_gui, in float pl_time)
runs on EPTF_ExecCtrl_UIHandler_Test_CT
{

  timer t_action;
  var integer vl_varID;

  f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients, pl_dataSource_compRef := pl_gui);

  f_EPTF_ExecCtrl_registerScenarioStateChangedCallback(refers(f_EPTF_ExecCtrl_Test_UpdateScenarioState));

  f_ExecCtrl_Test_storeDataFromTspScenario2Grps();
  log("v_EPTF_ExecCtrl_Test_scenarios: ",v_EPTF_ExecCtrl_Test_scenarios);
  t_action.start(0.0);

  alt
  {
    [f_EPTF_ExecCtrl_checkReadyToRun()] t_action.timeout {
      f_EPTF_Var_logNames("##### Vars ####");
      vl_varID := f_EPTF_Var_getId(c_EPTF_ExecCtrl_Start);
      if(vl_varID != -1) {
        f_EPTF_Var_adjustContent(vl_varID, {intVal := 1});
      } else {
        log("There is no such Variable: ", c_EPTF_ExecCtrl_Start);
        setverdict(fail);
        //exit
      }
      t_test.start(tsp_EPTF_Var_SyncInterval+1.0);
      repeat;
    }
    [] t_test.timeout {
      for (var integer i := 0; i < sizeof(v_EPTF_ExecCtrl_Test_scenarios); i := i + 1) {
        f_EPTF_ExecCtrl_Test_checkScRunning(v_EPTF_ExecCtrl_Test_scenarios[i]);
      }
      setverdict(pass);
      vl_varID := f_EPTF_Var_getId(c_EPTF_ExecCtrl_Exit);
      if(vl_varID != -1) {
        f_EPTF_Var_adjustContent(vl_varID, {intVal := 1});
      } else {
        log("There is no such Variable: ", c_EPTF_ExecCtrl_Exit);
        setverdict(fail);
        //exit
      }
      repeat;
    }
  } // alt
}


function f_EPTF_ExecCtrl_UIHandler_Test_stopButton(
  in charstring pl_name,
  in integer pl_nOfClients, in EPTF_UIHandler_CT pl_gui, in float pl_time)
runs on EPTF_ExecCtrl_UIHandler_Test_CT
{
  f_EPTF_ExecCtrl_setManualControl(true);
  f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients, pl_dataSource_compRef := pl_gui);

  f_EPTF_ExecCtrl_registerScenarioStateChangedCallback(refers(f_EPTF_ExecCtrl_Test_UpdateScenarioState));

  f_ExecCtrl_Test_storeDataFromTspScenario2Grps();

  var integer vl_varID;
  var charstring vl_varName;
  var EPTF_Var_DirectContent vl_Var_content;
  timer t_stop, t_test_stop;
  log("v_EPTF_ExecCtrl_Test_scenarios: ",v_EPTF_ExecCtrl_Test_scenarios);
  t_test.start(0.0);

  alt
  {
    [f_EPTF_ExecCtrl_checkReadyToRun()] t_test.timeout {
      vl_varID := f_EPTF_Var_getId(c_EPTF_ExecCtrl_Start);
      if(vl_varID != -1) {
        f_EPTF_Var_adjustContent(vl_varID, {intVal := 1});
      } else {
        log("There is no such Variable: ", c_EPTF_ExecCtrl_Start);
        setverdict(fail);
        //exit
      }
      t_test_stop.start(tsp_EPTF_Var_SyncInterval+2.0)
      repeat;
    }
    [] t_test_stop.timeout {

      for (var integer i := 0; i < sizeof(v_EPTF_ExecCtrl_Test_scenarios); i := i + 1)
      {
        f_EPTF_ExecCtrl_Test_checkScRunning(v_EPTF_ExecCtrl_Test_scenarios[i]);
      }
      vl_varID := f_EPTF_Var_getId(c_EPTF_ExecCtrl_Stop);
      if(vl_varID != -1) {
        f_EPTF_Var_adjustContent(vl_varID, {intVal := 1});
      } else {
        log("There is no such Variable: ", c_EPTF_ExecCtrl_Stop);
        setverdict(fail);
        //exit
      }
      t_stop.start(tsp_EPTF_Var_SyncInterval+2.0);
      repeat;
    }
    [] t_stop.timeout {
      for (var integer i := 0; i < sizeof(v_EPTF_ExecCtrl_Test_scenarios); i := i + 1) {
        f_EPTF_ExecCtrl_Test_checkScNotRunning(v_EPTF_ExecCtrl_Test_scenarios[i]);
      }

      for (var integer lgenidx := 0; lgenidx < pl_nOfClients; lgenidx := lgenidx + 1) {
        for(var integer eg:=0; eg<f_EPTF_ExecCtrl_getLGenNumEGroups(lgenidx); eg:=eg+1) {
          var integer vl_eGrpIdx := f_EPTF_ExecCtrl_getLGenEGrpIdx(lgenidx,eg);
          var EPTF_IntegerList vl_eGrpScenarios := f_EPTF_ExecCtrl_eGrp_scenarios(vl_eGrpIdx);
          for(var integer sc:=0; sc<sizeof(vl_eGrpScenarios);sc:=sc+1) {
            var integer vl_scIdx := vl_eGrpScenarios[sc];

            vl_varName := "StatusLED.Scenario.LGenStatus." & f_EPTF_ExecCtrl_getLGenName(lgenidx) & "." & f_EPTF_ExecCtrl_eGrp_name(vl_eGrpIdx)&
            "."&f_EPTF_ExecCtrl_getScenarioName(vl_scIdx);
            vl_varID := f_EPTF_Var_getId(vl_varName);
            if (vl_varID != -1) {
              f_EPTF_Var_refreshContent(vl_varID);
              f_EPTF_Var_getContent(vl_varID, vl_Var_content);
              if (vl_Var_content.statusLEDVal.text == "Stopped") {
                log("Expected Scenario state: ", vl_Var_content.statusLEDVal.text);
                setverdict(pass);
              } else {
                log("Unexpected Scenario state: ", vl_Var_content.statusLEDVal.text, " Expected: Stopped");
                setverdict(fail);
              }

            } else {
              log("No such EPTF variable with name: ", vl_varName);
              setverdict(fail);
            }
          }
        }
      }
      vl_varID := f_EPTF_Var_getId(c_EPTF_ExecCtrl_Exit);
      if(vl_varID != -1) {
        f_EPTF_Var_adjustContent(vl_varID, {intVal := 1});

      } else {
        log("There is no such Variable: ", c_EPTF_ExecCtrl_Exit);
        setverdict(fail);
        //exit
      }
      repeat;
    }
  } // alt
}

function f_EPTF_ExecCtrl_UIHandler_Test_stopButton_manualControl_false(
  in charstring pl_name,
  in integer pl_nOfClients, in EPTF_UIHandler_CT pl_gui, in boolean pl_manualControl := true)
runs on EPTF_ExecCtrl_UIHandler_Test_CT
{
  f_EPTF_ExecCtrl_setManualControl(pl_manualControl);
  f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients, pl_dataSource_compRef := pl_gui);

  f_EPTF_ExecCtrl_registerScenarioStateChangedCallback(refers(f_EPTF_ExecCtrl_Test_UpdateScenarioState));

  f_ExecCtrl_Test_storeDataFromTspScenario2Grps();

  var integer vl_varID;
  var charstring vl_varName;
  var EPTF_Var_DirectContent vl_Var_content;
  timer t_stop, t_test_stop;
  log("v_EPTF_ExecCtrl_Test_scenarios: ",v_EPTF_ExecCtrl_Test_scenarios);
  t_test.start(0.0);

  alt
  {
    [f_EPTF_ExecCtrl_Test_checkScRunning_withRetVal(v_EPTF_ExecCtrl_Test_scenarios[0])] t_test.timeout {
       t_test_stop.start(tsp_EPTF_Var_SyncInterval+2.0)
      repeat;
    }
    [] t_test_stop.timeout {

      var charstring vl_stopButtonName;
      f_EPTF_DataSourceClient_getData(
    	  pl_dataVarName:=vl_stopButtonName,
         pl_source := c_ExecCtrl_DataSource_sourceId,
         pl_ptcName := "",
         pl_element := c_ExecCtrl_dataElementStop,
         pl_params := {}
      );
      vl_varID := f_EPTF_Var_getId(vl_stopButtonName);

      if(vl_varID != -1) {
        f_EPTF_Var_adjustContent(vl_varID, {intVal := 1});
      } else {
        action("There is no such Variable: ", vl_stopButtonName);
        setverdict(fail);
        //exit
      }
      t_stop.start(tsp_EPTF_Var_SyncInterval+2.0);
      repeat;
    }
    [] t_stop.timeout {
      for (var integer i := 0; i < sizeof(v_EPTF_ExecCtrl_Test_scenarios); i := i + 1) {
        f_EPTF_ExecCtrl_Test_checkScNotRunning(v_EPTF_ExecCtrl_Test_scenarios[i]);
      }

      for (var integer lgenidx := 0; lgenidx < pl_nOfClients; lgenidx := lgenidx + 1) {
        for(var integer eg:=0; eg<f_EPTF_ExecCtrl_getLGenNumEGroups(lgenidx); eg:=eg+1) {
          var integer vl_eGrpIdx := f_EPTF_ExecCtrl_getLGenEGrpIdx(lgenidx,eg);
          var EPTF_IntegerList vl_eGrpScenarios := f_EPTF_ExecCtrl_eGrp_scenarios(vl_eGrpIdx);
          for(var integer sc:=0; sc<sizeof(vl_eGrpScenarios);sc:=sc+1) {
            var integer vl_scIdx := vl_eGrpScenarios[sc];

            vl_varName := "StatusLED.Scenario.LGenStatus." & f_EPTF_ExecCtrl_getLGenName(lgenidx) & "." & f_EPTF_ExecCtrl_eGrp_name(vl_eGrpIdx)&
            "."&f_EPTF_ExecCtrl_getScenarioName(vl_scIdx);
            vl_varID := f_EPTF_Var_getId(vl_varName);
            if (vl_varID != -1) {
              f_EPTF_Var_refreshContent(vl_varID);
              f_EPTF_Var_getContent(vl_varID, vl_Var_content);
              if (vl_Var_content.statusLEDVal.text == "Stopped") {
                log("Expected Scenario state: ", vl_Var_content.statusLEDVal.text);
                setverdict(pass);
              } else {
                log("Unexpected Scenario state: ", vl_Var_content.statusLEDVal.text, " Expected: Stopped");
                setverdict(fail);
              }

            } else {
              log("No such EPTF variable with name: ", vl_varName);
              setverdict(fail);
            }
          }
        }
      }
      vl_varID := f_EPTF_Var_getId(c_EPTF_ExecCtrl_Exit);
      if(vl_varID != -1) {
        f_EPTF_Var_adjustContent(vl_varID, {intVal := 1});

      } else {
        log("There is no such Variable: ", c_EPTF_ExecCtrl_Exit);
        setverdict(fail);
        //exit
      }
      repeat;
    }
  } // alt
}

type record of EPTF_Var_DirectContent EPTF_ExecCtrlTest_DirectContentList;

function f_EPTF_ExecCtrl_UIHandler_Test_resetAllButton(
  in charstring pl_name,
  in integer pl_nOfClients, in EPTF_UIHandler_CT pl_gui, in float pl_time,
  in EPTF_ExecCtrl_Test_SCDataList pl_scens)
runs on EPTF_ExecCtrl_UIHandler_Test_CT
{
  timer t_stop, t_test_stop, t_start;

  f_EPTF_ExecCtrl_setManualControl(true);
  f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients, pl_dataSource_compRef := pl_gui);

  f_EPTF_ExecCtrl_registerScenarioStateChangedCallback(refers(f_EPTF_ExecCtrl_Test_UpdateScenarioState));

  f_ExecCtrl_Test_storeDataFromTspScenario2Grps();

  var integer vl_varID;
  var charstring vl_varName;
  var EPTF_Var_DirectContent vl_Var_content;
  var EPTF_ExecCtrlTest_DirectContentList vl_Var_testedContentList;
  // Tested items ->
  const  ExecCtrl_TcStatIdList vl_testStatVarIds := {
    // c_EPTF_ExecCtrl_tcStatId_CurrentCPS,	// Not tested
    //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, // Not tested
    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 // Not tested
  };
  var charstring vl_hashIdText := %definitionId&"_checkStatisticsHash";
  var integer vl_hashId := f_EPTF_str2int_HashMap_New(vl_hashIdText);
  var integer vl_idx := 0;
  for(var integer i := 0; i < sizeof(vl_testStatVarIds); i := i + 1 ){
    vl_idx := i;
    f_EPTF_str2int_HashMap_Insert(vl_hashId, c_EPTF_ExecCtrl_tcStatNames[vl_testStatVarIds[i]], vl_idx);
  }

  log("v_EPTF_ExecCtrl_Test_scenarios: ",v_EPTF_ExecCtrl_Test_scenarios);
  action(%definitionId&">v_EPTF_ExecCtrl_Test_scenarios: ",v_EPTF_ExecCtrl_Test_scenarios);
  t_test.start(0.0);

  alt
  {
    [f_EPTF_ExecCtrl_checkReadyToRun()] t_test.timeout {
      vl_varID := f_EPTF_Var_getId(c_EPTF_ExecCtrl_Start);
      if(vl_varID != -1) {
        f_EPTF_Var_adjustContent(vl_varID, {intVal := 1});
      } else {
        log("There is no such Variable: ", c_EPTF_ExecCtrl_Start);
        setverdict(fail,"No such EPTF variable with name: "&c_EPTF_ExecCtrl_Start);
        //exit
      }
      t_start.start(5.0); // traffic runs for 5 sec
      repeat;
    }
    [] t_start.timeout {
       for (var integer i := 0; i < sizeof(v_EPTF_ExecCtrl_Test_scenarios); i := i + 1)
       {
         f_EPTF_ExecCtrl_Test_checkScRunning(v_EPTF_ExecCtrl_Test_scenarios[i]);
       }
       vl_varID := f_EPTF_Var_getId(c_EPTF_ExecCtrl_Stop);
       if(vl_varID != -1) {
         f_EPTF_Var_adjustContent(vl_varID, {intVal := 1});
        } else {
          log("There is no such Variable: ", c_EPTF_ExecCtrl_Stop);
          setverdict(fail,"No such EPTF variable with name: "&c_EPTF_ExecCtrl_Stop);
        }

       t_test_stop.start(tsp_EPTF_Var_SyncInterval+5.0);
       repeat;
    }
    [] t_test_stop.timeout {

      for (var integer i := 0; i < sizeof(v_EPTF_ExecCtrl_Test_scenarios); i := i + 1)
      {
        f_EPTF_ExecCtrl_Test_checkScNotRunning(v_EPTF_ExecCtrl_Test_scenarios[i]);
      }

      for(var integer i := 0; i < sizeof(pl_scens); i := i + 1 ) {
        //var charstring vl_varNameBase := f_EPTF_LGenBaseStats_getNamePrefix(pl_scens[i].eGrpName, pl_scens[i].scenName, pl_scens[i].tcName);
        var charstring vl_varNameBase := c_EPTF_ExecCtrl_statisticsRoot&".EG."&pl_scens[i].eGrpName&".SC."&pl_scens[i].scenName&".TC."&pl_scens[i].tcName;
        for(var integer vl_j := 0; vl_j < sizeof(c_EPTF_ExecCtrl_tcStatNames); vl_j := vl_j + 1 ){
          if (f_EPTF_str2int_HashMap_Find(vl_hashId, c_EPTF_ExecCtrl_tcStatNames[vl_j], vl_idx))
          {
            var charstring vl_statName := vl_varNameBase&"."&c_EPTF_ExecCtrl_tcStatNames[vl_j];
            vl_varID := f_EPTF_Var_getId(vl_statName);
            if (vl_varID != -1) {
              f_EPTF_Var_refreshContent(vl_varID);
              f_EPTF_Var_getContent(vl_varID, vl_Var_content);
              vl_Var_testedContentList[vl_idx] := vl_Var_content;
              action(%definitionId&">vl_variableRunningValue[pre:"&c_EPTF_ExecCtrl_tcStatNames[vl_j]&"]=",vl_Var_content);
            } else {
              log("No such EPTF variable with name: ", vl_statName);
              setverdict(fail,"No such EPTF variable with name: "&vl_statName);
            }
          }
        }
      }
      // Push -> Reset All
      var charstring vl_varResetButtonName;
      var integer vl_retCode := 0;
      vl_retCode := f_EPTF_DataSourceClient_getData(vl_varResetButtonName,"StatHandler","","ResetAll",{});
      vl_varID := f_EPTF_Var_getId(vl_varResetButtonName);
      action(%definitionId&">RESET["&vl_varResetButtonName&"]=",vl_varID);
      if(vl_varID != -1) {
        f_EPTF_Var_adjustContent(vl_varID, {intVal := 1});
      } else {
        log("There is no such Variable: ", vl_varResetButtonName);
        setverdict(fail,"No such EPTF variable with name: "&vl_varResetButtonName);
        //exit
      }
      t_stop.start(tsp_EPTF_Var_SyncInterval+5.0);
      repeat;
    }
    [] t_stop.timeout {

      action(%definitionId&">CHECK->",sizeof(pl_scens));

      for(var integer i := 0; i < sizeof(pl_scens); i := i + 1 ) {
        //var charstring vl_varNameBase := f_EPTF_LGenBaseStats_getNamePrefix(pl_scens[i].eGrpName, pl_scens[i].scenName, pl_scens[i].tcName);
        var charstring vl_varNameBase := c_EPTF_ExecCtrl_statisticsRoot&".EG."&pl_scens[i].eGrpName&".SC."&pl_scens[i].scenName&".TC."&pl_scens[i].tcName;
        for(var integer vl_j := 0; vl_j < sizeof(c_EPTF_ExecCtrl_tcStatNames); vl_j := vl_j + 1 ){
          if (f_EPTF_str2int_HashMap_Find(vl_hashId, c_EPTF_ExecCtrl_tcStatNames[vl_j], vl_idx)){
            var charstring vl_statName := vl_varNameBase&"."&c_EPTF_ExecCtrl_tcStatNames[vl_j];
            vl_varID := f_EPTF_Var_getId(vl_statName);
            if (vl_varID != -1) {
              f_EPTF_Var_refreshContent(vl_varID);
              f_EPTF_Var_getContent(vl_varID, vl_Var_content);
              action(%definitionId&">vl_variableRunningValue[POST:"&c_EPTF_ExecCtrl_tcStatNames[vl_j]&"] - ",vl_Var_testedContentList[vl_idx]," < ",vl_Var_content);
              if(ischosen(vl_Var_content.intVal)) {
                if(vl_j == c_EPTF_ExecCtrl_tcStatId_Available or vl_j == c_EPTF_ExecCtrl_tcStatId_NotFinished) {
                  if (f_EPTF_ExecCtrl_getActiveEntities(f_EPTF_ExecCtrl_getEntityGroupIdx(pl_scens[i].eGrpName)) != vl_Var_content.intVal) {
                    action(%definitionId&">Reset failed["&c_EPTF_ExecCtrl_tcStatNames[vl_j]&"]");
                    setverdict(fail,"Reset failed ["&c_EPTF_ExecCtrl_tcStatNames[vl_j]&"]!");
                  }
                }
                else if(vl_Var_testedContentList[vl_idx].intVal < 0 or vl_Var_content.intVal != 0){
                  action(%definitionId&">Reset failed["&c_EPTF_ExecCtrl_tcStatNames[vl_j]&"]");
                  setverdict(fail,"Reset failed ["&c_EPTF_ExecCtrl_tcStatNames[vl_j]&"]!");
                }
              } else if(ischosen(vl_Var_content.floatVal)) {
                if(vl_Var_testedContentList[vl_idx].floatVal < 0.0 or vl_Var_content.floatVal != 0.0){
                  action(%definitionId&">Reset failed["&c_EPTF_ExecCtrl_tcStatNames[vl_j]&"]");
                  setverdict(fail,"Reset failed ["&c_EPTF_ExecCtrl_tcStatNames[vl_j]&"]!");
                }
              }
            } else {
              log("No such EPTF variable with name: ", vl_statName);
              setverdict(fail,"No such EPTF variable with name: "&vl_statName);
            }
          }
        }
      }

      // Push -> Exit
      vl_varID := f_EPTF_Var_getId(c_EPTF_ExecCtrl_Exit);
      if(vl_varID != -1) {
        f_EPTF_Var_adjustContent(vl_varID, {intVal := 1});

      } else {
        log("There is no such Variable: ", c_EPTF_ExecCtrl_Exit);
        setverdict(fail,"No such EPTF variable with name: "&c_EPTF_ExecCtrl_Exit);
        //exit
      }
      repeat;
    }
  } // alt
}


function f_EPTF_ExecCtrl_UIHandler_Test_getScGroupStatus(in integer pl_scGrpStatusVar)
runs on EPTF_ExecCtrl_UIHandler_Test_CT return EPTF_StatusLED {
  var EPTF_Var_DirectContent vl_Var_content;
  f_EPTF_Var_refreshContent(pl_scGrpStatusVar);
  f_EPTF_Var_getContent(pl_scGrpStatusVar, vl_Var_content);
  return vl_Var_content.statusLEDVal;
}

function f_EPTF_ExecCtrl_UIHandler_Test_terminateButton(
  in charstring pl_name,
  in integer pl_nOfClients, in EPTF_UIHandler_CT pl_gui, in float pl_time, in boolean pl_createDefaultLGen := true)
runs on EPTF_ExecCtrl_UIHandler_Test_CT
{
  f_EPTF_ExecCtrl_setManualControl(true);

  if(pl_createDefaultLGen == true){
    f_EPTF_ExecCtrl_loadConfig(
      pl_EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList := c_EPTF_ExecCtrl_DefaultScenarios_EGrpList,
      pl_EPTF_LGenBase_TcMgmt_Scenarios2GrpList := c_EPTF_ExecCtrl_DefaultScenarios_Scenarios2GrpList&
      c_EPTF_ExecCtrl_DefaultScenarios_Scenarios2GrpList_scGroups,
      pl_EPTF_LGenBase_ScenarioDeclaratorList := {},
      pl_EPTF_LGenBase_tcTypeDeclaratorList := {},
      pl_EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList := {c_EPTF_ExecCtrl_DefaultScenarios_defaultTCType},
      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:= {c_EPTF_ExecCtrl_DefaultScenarios_normalScenario,c_EPTF_ExecCtrl_DefaultScenarios_weightedScenario,
        c_EPTF_ExecCtrl_DefaultScenarios_normalScenarioInScGrp,c_EPTF_ExecCtrl_DefaultScenarios_weightedScenarioInScGrp},
      pl_EPTF_ExecCtrl_ScenarioInstanceTypeList:={},
      pl_EPTF_ExecCtrl_LGenPool_Declarators:=c_EPTF_ExecCtrl_Test_defaultLGenPool_Declarators,
      pl_EPTF_ExecCtrl_EntityGroup2LGenPool_List:=c_EPTF_ExecCtrl_DefaultScenarios_EntityGroup2LGenPool_List,
      pl_EPTF_ExecCtrl_LGenFunction_Entry_List:={{
          name := omit,
          fn := refers(f_ExecCtrl_Test_createDefaultLGen)
        }},
      pl_EPTF_ExecCtrl_PhaseList_Declarators:=c_EPTF_ExecCtrl_DefaultScenarios_phases,
      pl_EPTF_ExecCtrl_ScenarioGroup_Declarators:=c_EPTF_ExecCtrl_DefaultScenarios_scGroups,
      pl_EPTF_ExecCtrl_RegulatorNames:={"LimitMaxRegulator"},
      pl_EPTF_ExecCtrl_RegulatedItems:={}
    );
  } else {
      f_EPTF_ExecCtrl_loadConfig(
      pl_EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList := c_EPTF_ExecCtrl_DefaultScenarios_EGrpList,
      pl_EPTF_LGenBase_TcMgmt_Scenarios2GrpList := c_EPTF_ExecCtrl_DefaultScenarios_Scenarios2GrpList&
      c_EPTF_ExecCtrl_DefaultScenarios_Scenarios2GrpList_scGroups,
      pl_EPTF_LGenBase_ScenarioDeclaratorList := {},
      pl_EPTF_LGenBase_tcTypeDeclaratorList := {},
      pl_EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList := {c_EPTF_ExecCtrl_DefaultScenarios_defaultTCType},
      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:= {c_EPTF_ExecCtrl_DefaultScenarios_normalScenario,c_EPTF_ExecCtrl_DefaultScenarios_weightedScenario,
        c_EPTF_ExecCtrl_DefaultScenarios_normalScenarioInScGrp,c_EPTF_ExecCtrl_DefaultScenarios_weightedScenarioInScGrp},
      pl_EPTF_ExecCtrl_ScenarioInstanceTypeList:={},
      pl_EPTF_ExecCtrl_LGenPool_Declarators:=c_EPTF_ExecCtrl_Test_slowLGenPool_Declarators,
      pl_EPTF_ExecCtrl_EntityGroup2LGenPool_List:=c_EPTF_ExecCtrl_DefaultScenarios_EntityGroup2LGenPool_List,
      pl_EPTF_ExecCtrl_LGenFunction_Entry_List:={{
          name := omit,
          fn := refers(f_ExecCtrl_Test_createDefaultLGenWithSpeed)
        }},
      pl_EPTF_ExecCtrl_PhaseList_Declarators:=c_EPTF_ExecCtrl_DefaultScenarios_phases,
      pl_EPTF_ExecCtrl_ScenarioGroup_Declarators:=c_EPTF_ExecCtrl_DefaultScenarios_scGroups,
      pl_EPTF_ExecCtrl_RegulatorNames:={"LimitMaxRegulator"},
      pl_EPTF_ExecCtrl_RegulatedItems:={}
    );

    action(%definitionId&"->f_EPTF_ExecCtrl_setNrOfExpectedClients called");
    f_EPTF_ExecCtrl_setNrOfExpectedClients();
  }

  // 2013.04.02.  f_EPTF_ExecCtrl_start();
  f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients, pl_dataSource_compRef := pl_gui);

  f_EPTF_ExecCtrl_registerScenarioStateChangedCallback(refers(f_EPTF_ExecCtrl_Test_UpdateScenarioState));
  f_ExecCtrl_Test_storeDataFromTspScenario2Grps();

  var integer vl_varID;
  var charstring vl_varName;
  const charstring cl_scGroupStateVarName := "Var.Execution_Control.PhaseLists.tabbox.DefaultPhases.tab.DefaultScGroup.GroupStatus";//"GUI.EPTF_ExecCtrl.Statistics.EG.DefaultEGrp.SC.DefaultScInScGrp.SCGrp.DefaultScGroup.GroupStatusLED";
  var integer vl_scGroupStateVarId := -1;
  var EPTF_Var_DirectContent vl_Var_content;
  timer t_stop, t_test_stop;
  log("v_EPTF_ExecCtrl_Test_scenarios: ",v_EPTF_ExecCtrl_Test_scenarios);
  t_test.start(0.0);

  alt
  {
    [f_EPTF_ExecCtrl_checkReadyToRun()] t_test.timeout {
      vl_varID := f_EPTF_Var_getId(c_EPTF_ExecCtrl_Start);
      if(vl_varID != -1) {
        f_EPTF_Var_adjustContent(vl_varID, {intVal := 1});
      } else {
        log("There is no such Variable: ", c_EPTF_ExecCtrl_Start);
        setverdict(fail);
        //exit
      }
      vl_scGroupStateVarId := f_EPTF_Var_getId(cl_scGroupStateVarName);
      if (vl_scGroupStateVarId==-1) {
        setverdict(fail, "Scenario group status LED var not found.");
        f_EPTF_Base_stopAll();
        //exit
      }
      t_test_stop.start(tsp_EPTF_Var_SyncInterval+25.0); // go to phase2 phase
      repeat;
    }
    // wait until ScGroup is running phase2
    [vl_scGroupStateVarId!=-1 and f_EPTF_ExecCtrl_UIHandler_Test_getScGroupStatus(vl_scGroupStateVarId) == {led_green, "phase2 - RUNNING"}] t_test_stop.timeout {

      for (var integer i := 0; i < sizeof(v_EPTF_ExecCtrl_Test_scenarios); i := i + 1)
      {
        f_EPTF_ExecCtrl_Test_checkScRunning(v_EPTF_ExecCtrl_Test_scenarios[i]);
      }
      vl_varID := f_EPTF_Var_getId(c_EPTF_ExecCtrl_Terminate);
      if(vl_varID != -1) {
        f_EPTF_Var_adjustContent(vl_varID, {intVal := 1});
      } else {
        log("There is no such Variable: ", c_EPTF_ExecCtrl_Terminate);
        setverdict(fail);
        //exit
      }
      t_stop.start(tsp_EPTF_Var_SyncInterval+2.0);
      repeat;
    }
    [] t_stop.timeout {
      for (var integer i := 0; i < sizeof(v_EPTF_ExecCtrl_Test_scenarios); i := i + 1) {
        f_EPTF_ExecCtrl_Test_checkScNotRunning(v_EPTF_ExecCtrl_Test_scenarios[i]);
      }

      for (var integer lgenidx := 0; lgenidx < pl_nOfClients; lgenidx := lgenidx + 1) {
        for(var integer eg:=0; eg<f_EPTF_ExecCtrl_getLGenNumEGroups(lgenidx); eg:=eg+1) {
          var integer vl_eGrpIdx := f_EPTF_ExecCtrl_getLGenEGrpIdx(lgenidx,eg);
          var EPTF_IntegerList vl_eGrpScenarios := f_EPTF_ExecCtrl_eGrp_scenarios(vl_eGrpIdx);
          for(var integer sc:=0; sc<sizeof(vl_eGrpScenarios);sc:=sc+1) {
            var integer vl_scIdx := vl_eGrpScenarios[sc];

            vl_varName := "StatusLED.Scenario.LGenStatus." & f_EPTF_ExecCtrl_getLGenName(lgenidx) & "." & f_EPTF_ExecCtrl_eGrp_name(vl_eGrpIdx)&
            "."&f_EPTF_ExecCtrl_getScenarioName(vl_scIdx);
            vl_varID := f_EPTF_Var_getId(vl_varName);
            if (vl_varID != -1) {
              f_EPTF_Var_refreshContent(vl_varID);
              f_EPTF_Var_getContent(vl_varID, vl_Var_content);
              if (vl_Var_content.statusLEDVal.text == "Stopped") {
                log("Expected Scenario state: ", vl_Var_content.statusLEDVal.text);
                setverdict(pass);
              } else {
                log("Unexpected Scenario state: ", vl_Var_content.statusLEDVal.text, " Expected: Stopped");
                setverdict(fail);
              }

            } else {
              log("No such EPTF variable with name: ", vl_varName);
              setverdict(fail);
            }
          }
        }
      }
      // check if ScGroup is in idle phase2
      if (f_EPTF_ExecCtrl_UIHandler_Test_getScGroupStatus(vl_scGroupStateVarId) != {led_blue, "phase2 - IDLE"}) {
        setverdict(fail, "Scenario group is not idle.");
        f_EPTF_Base_stopAll();
        //exit
      }
      vl_varID := f_EPTF_Var_getId(c_EPTF_ExecCtrl_Exit);
      if(vl_varID != -1) {
        f_EPTF_Var_adjustContent(vl_varID, {intVal := 1});

      } else {
        log("There is no such Variable: ", c_EPTF_ExecCtrl_Exit);
        setverdict(fail);
        //exit
      }
      repeat;
    }
  } // alt
}

function f_EPTF_ExecCtrl_UIHandler_Test_NrOfExpectedClients(
  in charstring pl_name,
  in integer pl_nOfClients, in float pl_time)
runs on EPTF_ExecCtrl_UIHandler_Test_CT
{
  f_EPTF_ExecCtrl_setManualControl(true);

  f_EPTF_ExecCtrl_init_CT(
    pl_selfName := pl_name,
    pl_nrOfClients := pl_nOfClients,
    pl_createLGenPools := true,
    pl_loadModulepars := false,
    pl_autoStart := false,
    pl_dataSource_compRef := mtc);

  f_EPTF_ExecCtrl_loadConfig(
      pl_EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList := c_EPTF_ExecCtrl_DefaultScenarios_EGrpList,
      pl_EPTF_LGenBase_TcMgmt_Scenarios2GrpList := c_EPTF_ExecCtrl_DefaultScenarios_Scenarios2GrpList&
      c_EPTF_ExecCtrl_DefaultScenarios_Scenarios2GrpList_scGroups,
      pl_EPTF_LGenBase_ScenarioDeclaratorList := {},
      pl_EPTF_LGenBase_tcTypeDeclaratorList := {},
      pl_EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList := {c_EPTF_ExecCtrl_DefaultScenarios_defaultTCType},
      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:= {c_EPTF_ExecCtrl_DefaultScenarios_normalScenario,c_EPTF_ExecCtrl_DefaultScenarios_weightedScenario,
        c_EPTF_ExecCtrl_DefaultScenarios_normalScenarioInScGrp,c_EPTF_ExecCtrl_DefaultScenarios_weightedScenarioInScGrp},
      pl_EPTF_ExecCtrl_ScenarioInstanceTypeList:={},
      pl_EPTF_ExecCtrl_LGenPool_Declarators:=c_EPTF_ExecCtrl_Test_slowLGenPool_Declarators,
      pl_EPTF_ExecCtrl_EntityGroup2LGenPool_List:=c_EPTF_ExecCtrl_DefaultScenarios_EntityGroup2LGenPool_List,
      pl_EPTF_ExecCtrl_LGenFunction_Entry_List:={{
          name := omit,
          fn := refers(f_ExecCtrl_Test_createDefaultLGenWithSpeed)
        }},
      pl_EPTF_ExecCtrl_PhaseList_Declarators:=c_EPTF_ExecCtrl_DefaultScenarios_phases,
      pl_EPTF_ExecCtrl_ScenarioGroup_Declarators:=c_EPTF_ExecCtrl_DefaultScenarios_scGroups,
      pl_EPTF_ExecCtrl_RegulatorNames:={"LimitMaxRegulator"},
      pl_EPTF_ExecCtrl_RegulatedItems:={}
    );


  f_EPTF_ExecCtrl_setNrOfExpectedClients();

  if(f_EPTF_ExecCtrl_getNrOfExpectedClients() == pl_nOfClients + c_EPTF_ExecCtrl_Test_slowLGenPool_Declarators[0].lgenPoolItems[0].num){
    setverdict(pass)
  } else {
    setverdict(fail,"NrOfexpectedClients should be : " & log2str(pl_nOfClients + c_EPTF_ExecCtrl_Test_slowLGenPool_Declarators[0].lgenPoolItems[0].num) & ", but its "& log2str(f_EPTF_ExecCtrl_getNrOfExpectedClients()))
  }
  f_EPTF_Base_cleanup_CT();
}


function f_EPTF_ExecCtrl_UIHandler_Test_ExitButton(
  in charstring pl_name,
  in integer pl_nOfClients, in EPTF_UIHandler_CT pl_gui, in float pl_time)
runs on EPTF_ExecCtrl_UIHandler_Test_CT
{

  f_EPTF_ExecCtrl_setManualControl(true);
  f_ExecCtrl_Test_storeDataFromTspScenario2Grps();

  f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients, pl_dataSource_compRef := pl_gui);

  f_EPTF_ExecCtrl_registerScenarioStateChangedCallback(refers(f_EPTF_ExecCtrl_Test_UpdateScenarioState));
  timer t_exit;
  var integer vl_varID;
  t_test.start(0.0);


  alt
  {
    [f_EPTF_ExecCtrl_checkReadyToRun()] t_test.timeout {
      vl_varID := f_EPTF_Var_getId(c_EPTF_ExecCtrl_Start);
      if(vl_varID != -1) {
        f_EPTF_Var_adjustContent(vl_varID, {intVal := 1});
      } else {
        log("There is no such Variable: ", c_EPTF_ExecCtrl_Start);
        setverdict(fail);
        //exit
      }
      t_exit.start(tsp_EPTF_Var_SyncInterval+2.0)
      repeat;
    }
    [] t_exit.timeout {

      for (var integer i := 0; i < sizeof(v_EPTF_ExecCtrl_Test_scenarios); i := i + 1)
      {
        f_EPTF_ExecCtrl_Test_checkScRunning(v_EPTF_ExecCtrl_Test_scenarios[i]);
      }
      vl_varID := f_EPTF_Var_getId(c_EPTF_ExecCtrl_Exit);
      if(vl_varID != -1) {
        setverdict(pass);
        f_EPTF_Var_adjustContent(vl_varID, {intVal := 1});
      } else {
        log("There is no such Variable: ", c_EPTF_ExecCtrl_Exit);
        setverdict(fail);
        //exit
      }
      repeat;
    }
  } // alt
}


function f_EPTF_ExecCtrl_UIHandler_Test_StartStopScenarioDisable(
  in charstring pl_name,
  in integer pl_nOfClients, in EPTF_UIHandler_CT pl_gui, in EPTF_ExecCtrl_Test_SCDataList pl_scens, in float pl_time)
runs on EPTF_ExecCtrl_UIHandler_Test_CT
{

  f_EPTF_ExecCtrl_setManualControl(true);

  f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients, pl_dataSource_compRef := pl_gui);

  f_EPTF_ExecCtrl_disableStartStopScenario({pl_scens[0].eGrpName, pl_scens[0].scenName});

  var charstring vl_varName;
  var integer vl_varID;
  var EPTF_Var_DirectContent vl_Var_content;
  timer t_start;
  t_start.start(0.0);
  alt
  {[f_EPTF_ExecCtrl_checkReadyToRun()] t_start.timeout {
      vl_varID := f_EPTF_Var_getId(c_EPTF_ExecCtrl_Start);
      if(vl_varID != -1) {
        f_EPTF_Var_adjustContent(vl_varID, {intVal := 1});
      } else {
        log("There is no such Variable: ", c_EPTF_ExecCtrl_Start);
        setverdict(fail);
        //exit
      }
      t_test.start(tsp_EPTF_Var_SyncInterval+2.0)
      repeat;
    }
    [] t_test.timeout {
      f_EPTF_Var_logNames("##### Vars ####");
      vl_varName := "ExecCtrl.stopScenario."& pl_scens[0].eGrpName &"." & pl_scens[0].scenName;
      vl_varID := f_EPTF_Var_getId(vl_varName);
      if(vl_varID != -1) {
        f_EPTF_Var_adjustContent(vl_varID, {boolVal := true});

      } else {
        log("There is no such Variable: ", vl_varName);
        setverdict(fail);
        //exit
      }
      // wait for variable update
      t_test.start(f_EPTF_Var_getRefreshPeriod(0)+1.0);
      t_test.timeout;

      vl_varName := "ExecCtrl.scenarioStatus."& pl_scens[0].eGrpName &"." & pl_scens[0].scenName;
      vl_varID := f_EPTF_Var_getId(vl_varName);
      if(vl_varID != -1) {
        timer t_wait;
        t_wait.start(20.0);
        t_test.start(0.0);
        alt {
          [f_EPTF_Var_getStatusLEDValue(vl_varID) == {led_green, "Running"}] t_test.timeout {
            setverdict(pass);
          }
          [] t_wait.timeout {
            setverdict(fail, "Scenario is not running: ", pl_scens[0].scenName)
            f_EPTF_Base_stopAll();
          }
        }

      } else {
        log("There is no such Variable: ", vl_varName);
        setverdict(fail);
        //exit
      }

      f_EPTF_ExecCtrl_enableStartStopScenario({pl_scens[0].eGrpName, pl_scens[0].scenName});
      t_test.start(1.0);
      t_test.timeout;

      vl_varName := "ExecCtrl.stopScenario."& pl_scens[0].eGrpName &"." & pl_scens[0].scenName;
      vl_varID := f_EPTF_Var_getId(vl_varName);
      if(vl_varID != -1) {
        f_EPTF_Var_adjustContent(vl_varID, {boolVal := true});

      } else {
        log("There is no such Variable: ", vl_varName);
        setverdict(fail);
        //exit
      }
      t_test.start(tsp_EPTF_Var_SyncInterval+1.0);
      t_test.timeout;
      vl_varName := "ExecCtrl.scenarioStatus."& pl_scens[0].eGrpName &"." & pl_scens[0].scenName;
      vl_varID := f_EPTF_Var_getId(vl_varName);
      if(vl_varID != -1) {
        timer t_wait;
        t_wait.start(20.0);
        t_test.start(0.0);
        alt {
          [f_EPTF_Var_getStatusLEDValue(vl_varID) == {led_blue, "Stopped"}] t_test.timeout {
            setverdict(pass);
          }
          [] t_wait.timeout {
            setverdict(fail, "Scenario is not Stopped: ", pl_scens[0].scenName, " ", f_EPTF_Var_getStatusLEDValue(vl_varID))
            f_EPTF_Base_stopAll();
          }
        }
      } else {
        log("There is no such Variable: ", vl_varName);
        setverdict(fail);
        //exit
      }

      vl_varID := f_EPTF_Var_getId(c_EPTF_ExecCtrl_Exit);
      if(vl_varID != -1) {
        f_EPTF_Var_adjustContent(vl_varID, {intVal := 1});

      } else {
        log("There is no such Variable: ", c_EPTF_ExecCtrl_Exit);
        setverdict(fail);
        //exit
      }
      repeat;
    }
  } // alt
}
function f_EPTF_ExecCtrl_UIHandler_Test_StartStopScenarioDisable2(
  in charstring pl_name,
  in integer pl_nOfClients, in EPTF_UIHandler_CT pl_gui, in EPTF_ExecCtrl_Test_SCDataList pl_scens, in float pl_time)
runs on EPTF_ExecCtrl_UIHandler_Test_CT
{

  //f_EPTF_ExecCtrl_setManualControl(false);
  f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients, pl_dataSource_compRef := pl_gui);
  f_EPTF_ExecCtrl_disableStartStopScenario({pl_scens[0].eGrpName, pl_scens[0].scenName});

  var charstring vl_varName;
  var integer vl_varID;
  var EPTF_Var_DirectContent vl_Var_content;
  t_test.start(0.0);
  alt
  {
    [f_EPTF_ExecCtrl_checkReadyToRun()] t_test.timeout {
      f_EPTF_Var_logNames("##### Vars ####");
      for (var integer i := 0; i < sizeof(pl_scens); i := i + 1) {
        vl_varName := "ExecCtrl.startTC." &  pl_scens[i].eGrpName & "." & pl_scens[i].scenName & "." & pl_scens[i].tcName

        vl_varID := f_EPTF_Var_getId(vl_varName);
        if(vl_varID != -1) {
          f_EPTF_Var_adjustContent(vl_varID, {boolVal := true});

        } else {
          log("There is no such Variable: ", vl_varName);
          //setverdict(fail);
          f_EPTF_Base_stopAll();
          //exit
        }
      }
      // wait for Running
      vl_varName := "ExecCtrl.scenarioStatus."& pl_scens[0].eGrpName &"." & pl_scens[0].scenName;
      vl_varID := f_EPTF_Var_getId(vl_varName);
      if(vl_varID != -1) {
        timer t_wait;
        t_wait.start(20.0);
        t_test.start(0.0);
        alt {
          [f_EPTF_Var_getStatusLEDValue(vl_varID) == {led_green, "Running"}] t_test.timeout {
          }
          [] t_wait.timeout {
            setverdict(fail, "Scenario is not running: ", pl_scens[0].scenName)
            f_EPTF_Base_stopAll();
          }
        }
      } else {
        log("There is no such Variable: ", vl_varName);
        setverdict(fail);
        f_EPTF_Base_stopAll();
      }

      vl_varName := "ExecCtrl.stopScenario."& pl_scens[0].eGrpName &"." & pl_scens[0].scenName;
      vl_varID := f_EPTF_Var_getId(vl_varName);
      if(vl_varID != -1) {
        f_EPTF_Var_adjustContent(vl_varID, {boolVal := true});

      } else {
        log("There is no such Variable: ", vl_varName);
        setverdict(fail);
        //exit
      }
      // wait for variable update
      t_test.start(f_EPTF_Var_getRefreshPeriod(0)+1.0);
      t_test.timeout;

      vl_varName := "ExecCtrl.scenarioStatus."& pl_scens[0].eGrpName &"." & pl_scens[0].scenName;
      vl_varID := f_EPTF_Var_getId(vl_varName);
      if(vl_varID != -1) {
        timer t_wait;
        t_wait.start(20.0);
        t_test.start(0.0);
        alt {
          [f_EPTF_Var_getStatusLEDValue(vl_varID) == {led_green, "Running"}] t_test.timeout {
            setverdict(pass);
          }
          [] t_wait.timeout {
            setverdict(fail, "Scenario is not running: ", pl_scens[0].scenName)
            f_EPTF_Base_stopAll();
          }
        }
      } else {
        log("There is no such Variable: ", vl_varName);
        setverdict(fail);
        //exit
      }

      f_EPTF_ExecCtrl_enableStartStopScenario({pl_scens[0].eGrpName, pl_scens[0].scenName});
      t_test.start(1.0);
      t_test.timeout;

      vl_varName := "ExecCtrl.stopScenario."& pl_scens[0].eGrpName &"." & pl_scens[0].scenName;
      vl_varID := f_EPTF_Var_getId(vl_varName);
      if(vl_varID != -1) {
        f_EPTF_Var_adjustContent(vl_varID, {boolVal := true});

      } else {
        log("There is no such Variable: ", vl_varName);
        setverdict(fail);
        //exit
      }
      t_test.start(tsp_EPTF_Var_SyncInterval+1.0);
      t_test.timeout;
      vl_varName := "ExecCtrl.scenarioStatus."& pl_scens[0].eGrpName &"." & pl_scens[0].scenName;
      vl_varID := f_EPTF_Var_getId(vl_varName);
      if(vl_varID != -1) {
        timer t_wait;
        t_wait.start(20.0);
        t_test.start(0.0);
        alt {
          [f_EPTF_Var_getStatusLEDValue(vl_varID) == {led_blue, "Stopped"}] t_test.timeout {
            setverdict(pass);
          }
          [] t_wait.timeout {
            setverdict(fail, "Scenario is not Stopped: ", pl_scens[0].scenName, " ", f_EPTF_Var_getStatusLEDValue(vl_varID))
            f_EPTF_Base_stopAll();
          }
        }
      } else {
        log("There is no such Variable: ", vl_varName);
        setverdict(fail);
        f_EPTF_Base_stopAll();
        //exit
      }

      vl_varID := f_EPTF_Var_getId(c_EPTF_ExecCtrl_Exit);
      if(vl_varID != -1) {
        log("Push Exit button");
        f_EPTF_Var_adjustContent(vl_varID, {intVal := 1});

      } else {
        log("There is no such Variable: ", c_EPTF_ExecCtrl_Exit);
        setverdict(fail);
        //exit
      }
      repeat;
    }
  } // alt
}
function f_EPTF_ExecCtrl_UIHandler_Test_StartStopTcDisable(
  in charstring pl_name,
  in integer pl_nOfClients, in EPTF_UIHandler_CT pl_gui, in EPTF_ExecCtrl_Test_SCDataList pl_scens, in float pl_time)
runs on EPTF_ExecCtrl_UIHandler_Test_CT
{

  //f_EPTF_ExecCtrl_setManualControl(false);
  f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients, pl_dataSource_compRef := pl_gui);

  f_EPTF_ExecCtrl_disableStartStopTC({pl_scens[0].eGrpName, pl_scens[0].scenName, pl_scens[0].tcName});

  var charstring vl_varName;
  var integer vl_varID;
  var EPTF_Var_DirectContent vl_Var_content;
  t_test.start(0.0);
  alt
  {
    [f_EPTF_ExecCtrl_checkReadyToRun()] t_test.timeout {
      f_EPTF_Var_logNames("##### Vars ####");
      for (var integer i := 0; i < sizeof(pl_scens); i := i + 1) {
        vl_varName := "ExecCtrl.startTC." &  pl_scens[i].eGrpName & "." & pl_scens[i].scenName & "." & pl_scens[i].tcName

        vl_varID := f_EPTF_Var_getId(vl_varName);
        if(vl_varID != -1) {
          f_EPTF_Var_adjustContent(vl_varID, {boolVal := true});

        } else {
          log("There is no such Variable: ", vl_varName);
          setverdict(fail);
          f_EPTF_Base_stopAll();
          //exit
        }
      }

      // wait for variable update
      t_test.start(f_EPTF_Var_getRefreshPeriod(0)+1.0);
      t_test.timeout;

      vl_varName := "ExecCtrl.scenarioStatus."& pl_scens[0].eGrpName &"." & pl_scens[0].scenName;
      vl_varID := f_EPTF_Var_getId(vl_varName);
      if(vl_varID != -1) {
        f_EPTF_Var_getContent(vl_varID, vl_Var_content);
        if (vl_Var_content.statusLEDVal.text == "Idle") {
          setverdict(pass);
        } else {
          log("Senario is not running: ", pl_scens[0].scenName);
          setverdict(fail);
        }
      } else {
        log("There is no such Variable: ", vl_varName);
        setverdict(fail);
        //exit
      }

      f_EPTF_ExecCtrl_enableStartStopTC({pl_scens[0].eGrpName, pl_scens[0].scenName, pl_scens[0].tcName});
      t_test.start(1.0);
      t_test.timeout;

      vl_varName := "ExecCtrl.startTC."& pl_scens[0].eGrpName &"." & pl_scens[0].scenName &"." & pl_scens[0].tcName;
      vl_varID := f_EPTF_Var_getId(vl_varName);
      if(vl_varID != -1) {
        f_EPTF_Var_adjustContent(vl_varID, {boolVal := true});

      } else {
        log("There is no such Variable: ", vl_varName);
        setverdict(fail);
        //exit
      }
      t_test.start(tsp_EPTF_Var_SyncInterval+1.0);
      t_test.timeout;
      vl_varName := "ExecCtrl.scenarioStatus."& pl_scens[0].eGrpName &"." & pl_scens[0].scenName;
      vl_varID := f_EPTF_Var_getId(vl_varName);
      if(vl_varID != -1) {
        f_EPTF_Var_getContent(vl_varID, vl_Var_content);
        if (vl_Var_content.statusLEDVal.text == "Running") {
          setverdict(pass);
        } else {
          log("Senario is running: ", pl_scens[0].scenName, " ", vl_Var_content.statusLEDVal.text);
          setverdict(fail);
        }
      } else {
        log("There is no such Variable: ", vl_varName);
        setverdict(fail);
        //exit
      }

      vl_varID := f_EPTF_Var_getId(c_EPTF_ExecCtrl_Exit);
      if(vl_varID != -1) {
        f_EPTF_Var_adjustContent(vl_varID, {intVal := 1});

      } else {
        log("There is no such Variable: ", c_EPTF_ExecCtrl_Exit);
        setverdict(fail);
        //exit
      }
      repeat;
    }
  } // alt
}

function f_EPTF_ExecCtrl_UIHandler_Test_Tab_EntityGroup(
  in charstring pl_name,
  in integer pl_nOfClients, in EPTF_UIHandler_CT pl_gui, in float pl_time)
runs on EPTF_ExecCtrl_UIHandler_Test_CT
{
  f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients, pl_dataSource_compRef := pl_gui);

  var integer vl_varID;
  var charstring vl_varName;
  var EPTF_Var_DirectContent vl_Var_content;
  t_test.start(0.0);
  var EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList vl_entityGrps;
  f_EPTF_ExecCtrl_get_entityGrpDeclarators(vl_entityGrps);

  timer tl_stop := pl_time;

  alt
  {
    [f_EPTF_ExecCtrl_checkReadyToRun()] t_test.timeout {
      for (var integer i := 0; i < sizeof(vl_entityGrps); i := i + 1)
      {
        vl_varName := "EntityGroup." & int2str(i);
        vl_varID := f_EPTF_Var_getId(vl_varName);
        if(vl_varID != -1) {
          f_EPTF_Var_getContent(vl_varID, vl_Var_content);
          if (vl_entityGrps[i].name == vl_Var_content.charstringVal) {
            setverdict(pass);
          } else {
            log("Wrong Entity Group Name: ", vl_Var_content.charstringVal, "Expected: ", vl_entityGrps[i].name);
            setverdict(fail);
          }
        } else {
          log("There is no such Variable: ", vl_varName);
          setverdict(fail);
          //exit
        }

        vl_varName := "EntityType." & int2str(i);
        vl_varID := f_EPTF_Var_getId(vl_varName);
        if(vl_varID != -1) {
          f_EPTF_Var_getContent(vl_varID, vl_Var_content);
          if (vl_entityGrps[i].eType == vl_Var_content.charstringVal) {
            setverdict(pass);
          } else {
            log("Wrong Entity Type Name: ", vl_Var_content.charstringVal, "Expected: ", vl_entityGrps[i].eType);
            setverdict(fail);
          }
        } else {
          log("There is no such Variable: ", vl_varName);
          setverdict(fail);
          //exit
        }
        vl_varName := "EntityNum." & int2str(i);
        vl_varID := f_EPTF_Var_getId(vl_varName);
        if(vl_varID != -1) {
          f_EPTF_Var_getContent(vl_varID, vl_Var_content);
          if (vl_entityGrps[i].eCount == vl_Var_content.intVal) {
            setverdict(pass);
          } else {
            log("Wrong Entity Number Name: ", vl_Var_content.intVal, "Expected: ", vl_entityGrps[i].eCount);
            setverdict(fail);
          }
        } else {
          log("There is no such Variable: ", vl_varName);
          setverdict(fail);
          //exit
        }
      }
      tl_stop.start;
      repeat;
    }
    []tl_stop.timeout {
      vl_varID := f_EPTF_Var_getId(c_EPTF_ExecCtrl_Exit);
      if(vl_varID != -1) {
        f_EPTF_Var_adjustContent(vl_varID, {intVal := 1});

      } else {
        log("There is no such Variable: ", c_EPTF_ExecCtrl_Exit);
        setverdict(fail);
        //exit
      }
      repeat;
    }
  } // alt
}
//not automatic
function f_EPTF_ExecCtrl_UIHandler_Test_Tab_Resources(
  in charstring pl_name,
  in integer pl_nOfClients, in EPTF_UIHandler_CT pl_gui, in float pl_time)
runs on EPTF_ExecCtrl_UIHandler_Test_CT
{
  var integer vl_varID;
  var charstring vl_varName;
  var EPTF_ExecCtrl_Test_ResourceList vl_resourceDB;
  var EPTF_Var_DirectContent vl_Var_content;
  var EPTF_IntegerList vl_Alloc;
  var integer vl_clientAlloc;
  var integer vl_clientAvailable;
  var integer vl_bMaxEntityCount;

  f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients, pl_dataSource_compRef := pl_gui);

  var EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList vl_entityGrps;
  f_EPTF_ExecCtrl_get_entityGrpDeclarators(vl_entityGrps);

  for (var integer i := 0; i < sizeof(tsp_entityTypes); i := i + 1) {
    vl_resourceDB[i] := c_empty_EPTF_ExecCtrl_Test_Resource;
    vl_resourceDB[i].eType := tsp_entityTypes[i].eType;
    vl_resourceDB[i].allocated := 0;
  }


  for (var integer i := 0; i < sizeof(tsp_behaviorTypes); i := i + 1) {
    vl_Alloc[i] := 0;
    for (var integer j := 0; j < sizeof(tsp_entityTypes); j := j + 1) {
      for (var integer k := 0; k < sizeof(tsp_entityTypes[j].behaviors); k := k + 1) {
        if(tsp_entityTypes[j].behaviors[k] == tsp_behaviorTypes[i].bName) {
          vl_resourceDB[j].available := tsp_behaviorTypes[i].eCount;
          for (var integer l := 0; l < sizeof(vl_entityGrps); l := l + 1) {
            if(vl_entityGrps[l].eType == tsp_entityTypes[j].eType) {
              vl_Alloc[i] := vl_Alloc[i] + vl_entityGrps[l].eCount;

            }
          }
        }
      }
    }
  }

  for (var integer i := 0; i < sizeof(tsp_entityTypes); i := i + 1) {
    for (var integer j := 0; j < sizeof(tsp_entityTypes[i].behaviors); j := j + 1) {
      for (var integer k := 0; k < sizeof(tsp_behaviorTypes); k := k + 1) {
        if (tsp_entityTypes[i].behaviors[j] == tsp_behaviorTypes[k].bName) {
          if (j == 0) {
            vl_resourceDB[i].maxAvailable := tsp_behaviorTypes[k].eCount;
          } else
          if (vl_resourceDB[i].maxAvailable > tsp_behaviorTypes[k].eCount) {
            vl_resourceDB[i].maxAvailable := tsp_behaviorTypes[k].eCount;
          }

          if (vl_resourceDB[i].available > tsp_behaviorTypes[k].eCount - vl_Alloc[k]) {
            vl_resourceDB[i].available := tsp_behaviorTypes[k].eCount - vl_Alloc[k]
            // vl_resourceDB[i].maxAvailable := tsp_behaviorTypes[k].eCount;
            vl_resourceDB[i].bAllocated := vl_Alloc[k];

          }
        }

      }
    }
  }
  for (var integer i := 0; i < sizeof(tsp_entityTypes); i := i + 1) {
    for(var integer j := 0; j < sizeof(vl_entityGrps); j := j + 1) {
      if (vl_resourceDB[i].eType == vl_entityGrps[j].eType) {
        vl_resourceDB[i].allocated := vl_resourceDB[i].allocated + vl_entityGrps[j].eCount;
      }
    }
  }
  t_test.start(0.0);

  timer tl_stop := pl_time;

  alt
  {
    [f_EPTF_ExecCtrl_checkReadyToRun()] t_test.timeout {
      for (var integer j := 0; j < pl_nOfClients; j := j + 1) {
        vl_varName := "Resource.LGenName." & int2str(j);
        vl_varID := f_EPTF_Var_getId(vl_varName);
        if(vl_varID != -1) {
          f_EPTF_Var_getContent(vl_varID, vl_Var_content);
          //Client name must be a number
          if (int2str(j) == vl_Var_content.charstringVal) {
            setverdict(pass);
          } else {
            log("Wrong Client Name: ", vl_Var_content.charstringVal, "Expected: ", int2str(j));
            setverdict(fail);
          }
        } else {
          log("There is no such Variable: ", vl_varName);
          setverdict(fail);
          //exit
        }
        for (var integer i := 0; i < sizeof(tsp_entityTypes); i := i + 1)
        {
          vl_varName := "Resource.EntityType." & int2str(j) & "." & int2str(i);
          vl_varID := f_EPTF_Var_getId(vl_varName);
          if(vl_varID != -1) {
            f_EPTF_Var_getContent(vl_varID, vl_Var_content);
            if (tsp_entityTypes[i].eType == vl_Var_content.charstringVal) {
              setverdict(pass);
            } else {
              log("Wrong Entity Type Name: ", vl_Var_content.charstringVal, "Expected: ", tsp_entityTypes[i].eType);
              setverdict(fail);
            }
          } else {
            log("There is no such Variable: ", vl_varName);
            setverdict(fail);
            //exit
          }


          if (vl_resourceDB[i].allocated != 0) {

            if((vl_resourceDB[i].allocated) mod pl_nOfClients > j) {
              vl_clientAlloc :=vl_resourceDB[i].maxAvailable - (vl_resourceDB[i].allocated / pl_nOfClients + 1)
            } else {
              vl_clientAlloc := vl_resourceDB[i].maxAvailable - (vl_resourceDB[i].allocated / pl_nOfClients)
            }
            vl_varName := "Resource.EntityAllocNum." & int2str(j) & "." & int2str(i);
            vl_varID := f_EPTF_Var_getId(vl_varName);
            if(vl_varID != -1) {
              f_EPTF_Var_getContent(vl_varID, vl_Var_content);
              if (vl_clientAlloc == vl_Var_content.intVal) {
                setverdict(pass);
              } else {
                log("Wrong allocation: ", vl_Var_content.intVal, " Expected: ", vl_clientAlloc);
                setverdict(fail);
              }
            } else {
              log("There is no such Variable: ", vl_varName);
              setverdict(fail);
              //exit
            }
          }
          else {
            //do nothing
          }
          if((vl_resourceDB[i].bAllocated) mod pl_nOfClients > j) {
            //     vl_clientAvailable := vl_resourceDB[i].maxAvailable - vl_resourceDB[i].bAllocated / pl_nOfClients - 1
            vl_clientAvailable := vl_resourceDB[i].maxAvailable;
          } else {
            //vl_clientAvailable := vl_resourceDB[i].maxAvailable - vl_resourceDB[i].bAllocated / pl_nOfClients
            vl_clientAvailable := vl_resourceDB[i].maxAvailable;
          }
          vl_varName := "Resource.EntityAvailNum." & int2str(j) & "." & int2str(i);
          vl_varID := f_EPTF_Var_getId(vl_varName);
          if(vl_varID != -1) {
            f_EPTF_Var_getContent(vl_varID, vl_Var_content);
            if (vl_clientAvailable == vl_Var_content.intVal) {
              log("Free resource: ", vl_Var_content.intVal, " Expected: ", vl_clientAvailable);
              setverdict(pass);
            } else {
              log("Wrong free resource: ", vl_Var_content.intVal, " Expected: ", vl_clientAvailable);
              setverdict(fail);
            }
          } else {
            log("There is no such Variable: ", vl_varName);
            setverdict(fail);
            //exit
          }
        }
      } // for
      tl_stop.start;
      repeat;
    }

    [] tl_stop.timeout {
      vl_varID := f_EPTF_Var_getId(c_EPTF_ExecCtrl_Exit);
      if(vl_varID != -1) {
        f_EPTF_Var_adjustContent(vl_varID, {intVal := 1});
      } else {
        log("There is no such Variable: ", c_EPTF_ExecCtrl_Exit);
        setverdict(fail);
        //exit
      }
      repeat;
    }
  } // alt
}


function f_EPTF_ExecCtrl_UIHandler_Test_regulatorsReady() runs on EPTF_ExecCtrl_Test_CT return boolean {
  const integer cl_lastRegulatorId := 5;
  var boolean vl_regulatorsReady := true;
  var integer vl_regulatorNum := 0;
  for (var integer vl_regulatorId:=0; vl_regulatorsReady and vl_regulatorId<f_EPTF_ExecCtrl_Regulator_getNofRegulators(); vl_regulatorId:=vl_regulatorId+1) {

    var integer vl_statusIdx := f_EPTF_ExecCtrl_Regulator_getRegulatorStatusIdxByRegulatorId(vl_regulatorId);
    var charstring vl_regulatorName := f_EPTF_ExecCtrl_Regulator_getRegulatorNameByRegulatorId(vl_regulatorId);
    // these regulators are used in the test:
    if (vl_regulatorName=="Regulator 1"
      or vl_regulatorName=="Regulator 2"
    ) {
      vl_regulatorNum := vl_regulatorNum + 1;
      vl_regulatorsReady := vl_regulatorsReady and f_EPTF_Var_getStatusLEDValue(vl_statusIdx)=={ color := led_blue,text := "Disabled" }
    }
  }
  return vl_regulatorsReady and (vl_regulatorNum == 2);
}


function f_EPTF_ExecCtrl_UIHandler_Test_Regulator(
  in charstring pl_name,
  in integer pl_nOfClients, in EPTF_UIHandler_CT pl_gui, in EPTF_ExecCtrl_Test_SCDataList pl_scens, in float pl_time)
runs on EPTF_ExecCtrl_UIHandler_Test_CT
{
  f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients, pl_dataSource_compRef := pl_gui);
  f_EPTF_ExecCtrl_setManualControl(true);

  //Waiting for regulators to start up...
  f_EPTF_ExecCtrl_waitForCondition(refers(f_EPTF_ExecCtrl_UIHandler_Test_regulatorsReady));

  var integer vl_varID;
  var charstring vl_varName;
  var charstring vl_regulatorName;
  var EPTF_Var_DirectContent vl_Var_content;
  var float vl_totalValue;
  timer t_start;
  t_start.start(0.0);

  alt
  {[f_EPTF_ExecCtrl_checkReadyToRun()] t_start.timeout {
      vl_varID := f_EPTF_Var_getId(c_EPTF_ExecCtrl_Start);
      if(vl_varID != -1) {
        f_EPTF_Var_adjustContent(vl_varID, {intVal := 1});
      } else {
        setverdict(fail,"There is no such Variable: ", c_EPTF_ExecCtrl_Start);
        //exit
      }
      t_test.start(1.0+pl_scens[0].timeProfile[0].time)
      repeat;
    }
    [] t_test.timeout {
      vl_regulatorName := f_EPTF_ExecCtrl_Regulator_getRegulatorName(pl_scens[0].state);
      f_EPTF_Var_logNames("##### Vars ####");



      vl_varName := "EPTF_ExecCtrl.Regulator.totalValue." & vl_regulatorName;
      vl_varID := f_EPTF_Var_getId(vl_varName);
      if(vl_varID != -1) {
        f_EPTF_Var_getContent(vl_varID, vl_Var_content);
        // expected: 12
        if (vl_Var_content.floatVal == pl_scens[0].timeProfile[0].targetValue ) {
          setverdict(pass);
        } else {
          setverdict(fail,"Wrong Total value: ", vl_Var_content.floatVal, "Expected: ", pl_scens[0].timeProfile[0].targetValue);
        }
      } else {
        setverdict(fail,"There is no such Variable: ", vl_varName);
        //exit
      }
      //first regulator row name

      vl_varName := "RegulatedItemName." & int2str(0);
      log("vl_varName: ", vl_varName);
      vl_varID := f_EPTF_Var_getId(vl_varName);
      var charstring vl_regulatedItemName := pl_scens[0].eGrpName & "." & pl_scens[0].scenName & "." & pl_scens[0].tcName;
      if(vl_varID != -1) {
        f_EPTF_Var_getContent(vl_varID, vl_Var_content);
        log("### vl_Var_content: ", vl_Var_content);
        if (vl_Var_content.charstringVal == vl_regulatedItemName) {
          setverdict(pass);
        } else {
          setverdict(fail,"Wrong Regulated item name on this widget: ", vl_Var_content.charstringVal, "Expected: ", vl_regulatedItemName);
        }
      } else {
        setverdict(fail,"There is no such Variable: ", vl_varName);
        //exit
      }

      vl_varName := "Traffic.Regulator." & pl_scens[0].eGrpName & "." & int2str(f_EPTF_ExecCtrl_getScenarioIdx(pl_scens[0].eGrpName, pl_scens[0].scenName)) & "." & int2str(f_EPTF_ExecCtrl_getTcOfScenarioIdx(f_EPTF_ExecCtrl_getTrafficCaseIdx(pl_scens[0].eGrpName,pl_scens[0].scenName,pl_scens[0].tcName)));
      log("vl_varName, name: ",vl_varName);
      vl_varID := f_EPTF_Var_getId(vl_varName);
      if(vl_varID != -1) {
        f_EPTF_Var_getContent(vl_varID, vl_Var_content);

        if (vl_Var_content.charstringVal == f_EPTF_ExecCtrl_Regulator_getRegulatorName(pl_scens[0].state)) {
          setverdict(pass);
        } else {
          setverdict(fail,"Wrong Regulator name on this widget: ", vl_Var_content.charstringVal, "Expected: ", vl_regulatorName);
        }
      } else {
        setverdict(fail,"There is no such Variable: ", vl_varName);
        //exit
      }
      //last regulator row
      vl_varName := "RegulatedItemWeight." & int2str(3);

      vl_varID := f_EPTF_Var_getId(vl_varName);
      if(vl_varID != -1) {
        f_EPTF_Var_adjustContent(vl_varID, {floatVal := 0.5});

      } else {
        setverdict(fail,"There is no such Variable: ", vl_varName);
        //exit
      }
      // change the regulator of the [0]-th and [1]-th item to the same: Regulator 3 (disconnected)
      vl_varName := "Traffic.Regulator." & pl_scens[1].eGrpName & "." & int2str(f_EPTF_ExecCtrl_getScenarioIdx(pl_scens[1].eGrpName, pl_scens[1].scenName));
      vl_varID := f_EPTF_Var_getId(vl_varName);
      if(vl_varID != -1) {
        f_EPTF_Var_adjustContent(vl_varID, {charstringVal := "2"});

      } else {
        setverdict(fail,"There is no such Variable: ", vl_varName);
        //exit
      }
      vl_varName := "Traffic.Regulator." & pl_scens[0].eGrpName & "." & int2str(f_EPTF_ExecCtrl_getScenarioIdx(pl_scens[0].eGrpName, pl_scens[0].scenName))
      & "." & int2str(f_EPTF_ExecCtrl_getTcOfScenarioIdx(f_EPTF_ExecCtrl_getTrafficCaseIdx(pl_scens[0].eGrpName, pl_scens[0].scenName, pl_scens[0].tcName)));
      vl_varID := f_EPTF_Var_getId(vl_varName);
      if(vl_varID != -1) {
        f_EPTF_Var_adjustContent(vl_varID, {charstringVal := "2"});

      } else {
        setverdict(fail,"There is no such Variable: ", vl_varName);
        //exit
      }
      t_test.start(tsp_EPTF_Var_SyncInterval+1.0);
      t_test.timeout;
      vl_regulatorName := f_EPTF_ExecCtrl_Regulator_getRegulatorName(pl_scens[0].state);
      vl_varName := "EPTF_ExecCtrl.Regulator.totalValue." & vl_regulatorName;
      vl_varID := f_EPTF_Var_getId(vl_varName);
      if(vl_varID != -1) {
        f_EPTF_Var_getContent(vl_varID, vl_Var_content);
        vl_totalValue := vl_Var_content.floatVal;
        // should be 6+12 = 18
        if (vl_totalValue== pl_scens[0].timeProfile[0].targetValue + pl_scens[1].timeProfile[0].targetValue) {
          setverdict(pass);
        } else {
          setverdict(fail,"Wrong Total value: ", vl_totalValue, "Expected: ", pl_scens[0].timeProfile[0].targetValue + pl_scens[1].timeProfile[0].targetValue);
        }
      } else {
        setverdict(fail,"There is no such Variable: ", vl_varName);
        //exit
      }

      vl_varName := "Traffic.ScenarioCPS." & pl_scens[1].eGrpName & "." & int2str(f_EPTF_ExecCtrl_getScenarioIdx(pl_scens[1].eGrpName, pl_scens[1].scenName));
      vl_varID := f_EPTF_Var_getId(vl_varName);
      if(vl_varID != -1) {
        f_EPTF_Var_getContent(vl_varID, vl_Var_content);

        // 18 -> (0.5,1.0) => (6,12)
        if (vl_Var_content.floatVal == 12.0) {
          setverdict(pass);
        } else {
          setverdict(fail,"Wrong CPS value: ", vl_Var_content.floatVal, "Expected: ", 12.0);
        }
      } else {
        setverdict(fail,"There is no such Variable: ", vl_varName);
        //exit
      }

      vl_varID := f_EPTF_Var_getId(c_EPTF_ExecCtrl_Exit);
      if(vl_varID != -1) {
        f_EPTF_Var_adjustContent(vl_varID, {intVal := 1});
        repeat;
      } else {
        setverdict(fail,"There is no such Variable: ", c_EPTF_ExecCtrl_Exit);
        //exit
      }
      repeat;
    }
  } // alt
}

function f_EPTF_ExecCtrl_Regulator_Test_getTotalCps(
  in charstring pl_name,
  in integer pl_nOfClients, in charstring pl_RegulatorName, in float pl_TotalValue)
runs on EPTF_ExecCtrl_Test_CT
{
  f_EPTF_ExecCtrl_setManualControl(false);
  f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients);

  var integer vl_regulatorId;
  var float vl_cps;

  t_test.start(6.0);

  alt
  {
    [] t_test.timeout {
      vl_regulatorId := f_EPTF_ExecCtrl_Regulator_getRegulatorIdByName(pl_RegulatorName);
      if (vl_regulatorId != -1) {
        vl_cps := f_EPTF_ExecCtrl_Regulator_getTotalCps(vl_regulatorId);
        if ( vl_cps == pl_TotalValue) {
          setverdict(pass);
        } else {
          log("Wrong calculated total value: ", vl_cps, ", expected: ", pl_TotalValue);
          setverdict(fail);
        }
      } else {
        log("There is no such Regulator: ", pl_RegulatorName);
        setverdict(fail);
      }
      f_EPTF_ExecCtrl_stopAllScenarios();
      repeat;
    }
  } // alt
}

function f_EPTF_ExecCtrl_Regulator_Test_getRegulatorName(
  in charstring pl_name,
  in integer pl_nOfClients, in charstring pl_RegulatorName, in integer pl_regulatorId)
runs on EPTF_ExecCtrl_Test_CT
{
  f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients);

  var integer vl_regulatorId;
  t_test.start(1.0);

  alt
  {
    [] t_test.timeout {
      vl_regulatorId := f_EPTF_ExecCtrl_Regulator_getRegulatorIdByName(pl_RegulatorName);
      if (vl_regulatorId != -1) {

        if ( vl_regulatorId == pl_regulatorId) {
          setverdict(pass);
        } else {
          log("Wrong regulator ID: ", vl_regulatorId, ", expected: ", pl_regulatorId);
          setverdict(fail);
        }
      } else {
        log("There is no such Regulator: ", pl_RegulatorName);
        setverdict(fail);
      }
      repeat;
    }
  } // alt
}

function f_EPTF_ExecCtrl_Regulator_Test_findRegulatorsForScenario(
  in charstring pl_name,
  in integer pl_nOfClients,
  in EPTF_ExecCtrl_Test_SCDataList pl_scens)
runs on EPTF_ExecCtrl_Test_CT
{
  f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients);

  var integer vl_regulatorId;
  t_test.start(1.0);
  var EPTF_IntegerList vl_regulatorIdxList

  alt
  {
    [] t_test.timeout {
      for( var integer i := 0; i < sizeof(pl_scens); i := i + 1 ){
        f_EPTF_ExecCtrl_Regulator_findRegulatorsForScenario(pl_scens[i].eGrpName, pl_scens[i].scenName, vl_regulatorIdxList);
        if (sizeof(vl_regulatorIdxList)==0) {continue;};
        if (vl_regulatorIdxList[0] == pl_scens[i].state) {
          setverdict(pass);
        }  else {
          log("Wrong regulator ID List: ", vl_regulatorIdxList[0] ,", expected: ", pl_scens[i].state);
          setverdict(fail);
        }

      }
      repeat;
    }
  } // alt
}

const float c_EPTF_ExecCtrl_Regulator_Test_regulatorStartTime := 10.0;
function f_EPTF_ExecCtrl_Regulator_Test_totalCPSWithTimeProfile(
  in charstring pl_name,
  in integer pl_nOfClients,
  in EPTF_UIHandler_CT pl_gui,
  in EPTF_ExecCtrl_Test_SCDataList pl_scens,
  in float pl_totalValue)
runs on
EPTF_ExecCtrl_Test_CT
{
  f_EPTF_ExecCtrl_loadConfig(
    pl_EPTF_ExecCtrl_RegulatedItems := {
      {
        idName := {
          cps_TC := {
            eGrpName := pl_scens[0].eGrpName,
            scName := pl_scens[0].scenName,
            tcName := pl_scens[0].tcName
          }
        },
        weight := 1.0,
        enabled := true,
        regulatorName := "Regulator 2"
      }
    }
  );
  f_EPTF_ExecCtrl_setManualControl(true);
  f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients);

  var charstring vl_regulatorName;
  var float vl_cps;

  var EPTF_IntegerList vl_regulatorIdxList;
  var EPTF_ExecCtrl_RegulatedItemName vl_idName;
  f_EPTF_ExecCtrl_Regulator_findRegulatorsForScenario(pl_scens[0].eGrpName, pl_scens[0].scenName, vl_regulatorIdxList);
  if(sizeof(vl_regulatorIdxList) == 0) {
    if(f_EPTF_ExecCtrl_getScenarioTypeByName(pl_scens[0].scenName) != 3) {
      vl_idName := { cps_TC := {
          pl_scens[0].eGrpName,
          pl_scens[0].scenName,
          pl_scens[0].tcName
        }

      }
    } else {
      vl_idName := { cps_SC := {
          pl_scens[0].eGrpName,
          pl_scens[0].scenName
        }
      }
    }
    //get Regulator Id from user code
    vl_regulatorName := f_EPTF_ExecCtrl_Regulator_getRegulatorName(pl_scens[0].state);
    //f_EPTF_ExecCtrl_Regulator_addRegulatedItem(vl_idName, vl_regulatorName, 1.0, true);

    //log("v_EPTF_ExecCtrl_RegulatedItems: ", v_EPTF_ExecCtrl_RegulatedItems, " v_EPTF_ExecCtrl_Regulators: ", v_EPTF_ExecCtrl_Regulators);
  } else {
    log("Warning, scenario has a regulator: ", f_EPTF_ExecCtrl_Regulator_getRegulatorName(vl_regulatorIdxList[0]));
  }

  t_test.start(0.0);
  var float vl_timeTolerance := f_EPTF_Var_getRefreshPeriod(0)*2.1;

  alt
  {
    [f_EPTF_ExecCtrl_checkReadyToRun()] t_test.timeout {

      // start the scenario that has no time profile to put the regulator to auto-off
      f_EPTF_ExecCtrl_startScenarioOnLGensByName("grp1", "scenario_0_declarator3");
      t_test.start(c_EPTF_ExecCtrl_Regulator_Test_regulatorStartTime);
      t_test.timeout; // wait until regulator is in auto-off

      f_EPTF_ExecCtrl_startAllScenarios();
      var float vl_startTime := f_EPTF_Base_getRelTimeInSecs();

      timer t_maxWait := 10.0;

      // check original CPS:
      var float vl_expectedCPS := tsp_LGenBase_TcMgmt_ScenarioDeclarators2[0].tcList[0].cpsToReach; // original CPS of the traffic case
      t_test.start(0.0);
      t_maxWait.start;
      alt {
        [f_EPTF_ExecCtrl_Regulator_getTotalCps(pl_scens[0].state) == vl_expectedCPS] t_test.timeout {
          var float vl_currentTime := f_EPTF_Base_getRelTimeInSecs();
          if (vl_currentTime-vl_startTime<pl_scens[0].timeProfile[0].time) {
            setverdict(pass,"Expected CPS detected at ",vl_currentTime-vl_startTime, " off the expected time");
          } else {
            setverdict(fail,"Original CPS: ", vl_expectedCPS, ", appeared too late: ", vl_currentTime-vl_startTime, " secs after start (expected time:",pl_scens[0].timeProfile[0].time,")")
          }
        }
        [] t_maxWait.timeout {
          setverdict(fail,"Expected CPS ",vl_expectedCPS," did not appear");
          f_EPTF_Base_stopAll(none);
        }
      }

      // check first item in time profile:
      vl_expectedCPS := pl_scens[0].timeProfile[0].targetValue; // first item in timeProfile
      t_test.start(0.0);
      t_maxWait.start;
      alt {
        [f_EPTF_ExecCtrl_Regulator_getTotalCps(pl_scens[0].state) == vl_expectedCPS] t_test.timeout {
          var float vl_currentTime := f_EPTF_Base_getRelTimeInSecs();
          if (  vl_currentTime-vl_startTime<pl_scens[0].timeProfile[0].time+vl_timeTolerance
            and vl_currentTime-vl_startTime>pl_scens[0].timeProfile[0].time-vl_timeTolerance) {
            setverdict(pass,"Expected CPS detected at ",vl_currentTime-vl_startTime-pl_scens[0].timeProfile[0].time, " off the expected time");
          } else {
            setverdict(fail,"Original CPS: ", vl_expectedCPS, ", appeared at: ", vl_currentTime-vl_startTime,
              ", but expected at: ",pl_scens[0].timeProfile[0].time," secs after start")
          }
        }
        [] t_maxWait.timeout {
          setverdict(fail,"Expected CPS ",vl_expectedCPS," did not appear");
          f_EPTF_Base_stopAll(none);
        }
      }

      // check last item in time profile:
      vl_expectedCPS := pl_scens[0].timeProfile[3].targetValue; // last item in timeProfile
      t_test.start(0.0);
      t_maxWait.start;
      alt {
        [f_EPTF_ExecCtrl_Regulator_getTotalCps(pl_scens[0].state) == vl_expectedCPS] t_test.timeout {
          var float vl_currentTime := f_EPTF_Base_getRelTimeInSecs();
          if (  vl_currentTime-vl_startTime<pl_scens[0].timeProfile[3].time+vl_timeTolerance
            and vl_currentTime-vl_startTime>pl_scens[0].timeProfile[3].time-vl_timeTolerance) {
            setverdict(pass,"Expected CPS detected at ",vl_currentTime-vl_startTime-pl_scens[0].timeProfile[3].time, " off the expected time");
          } else {
            setverdict(fail,"Original CPS: ", vl_expectedCPS, ", appeared at: ", vl_currentTime-vl_startTime,
              ", but expected at: ",pl_scens[0].timeProfile[3].time," secs after start")
          }
        }
        [] t_maxWait.timeout {
          setverdict(fail,"Expected CPS ",vl_expectedCPS," did not appear");
          f_EPTF_Base_stopAll(none);
        }
      }

      // stop the test:
      var integer vl_varID := f_EPTF_Var_getId(c_EPTF_ExecCtrl_Exit);
      if(vl_varID != -1) {
        f_EPTF_Var_adjustContent(vl_varID, {intVal := 1});
        repeat;
      } else {
        //setverdict(fail,"There is no such Variable: ", c_EPTF_ExecCtrl_Exit);
        f_EPTF_Base_stopAll(none);
        //exit
      }
      repeat;
    }
  } // alt
}

function f_EPTF_ExecCtrlClient_UIHandler_Test_CPS(
  in charstring pl_selfName,
  in EPTF_ExecCtrl_Test_CT pl_execCtrl,
  in EPTF_ExecCtrl_Test_SCDataList pl_scens,
  in boolean pl_checkCpsToReach := true,
  in float pl_measureAfterSet := 2.0)
runs on EPTF_ExecCtrlClient_UIHandler_Test_CT
{
  timer tl_test;
  var float vl_currentCPS := 0.0;
  var float vl_targetCPS := 0.0;
  var integer vl_count := 0;
  var integer vl_varID := -1;
  var charstring vl_varNameBase;
  var EPTF_Var_DirectContent vl_Var_content;
  var charstring vl_varName;

  v_EPTF_ExecCtrlClient_Test_scenarios := pl_scens;
  tl_test.start(pl_scens[0].timeProfile[vl_count].time + pl_measureAfterSet);

  f_EPTF_ExecCtrlClient_UIHandler_Test_init(pl_selfName, pl_execCtrl);

  alt {
    [] tl_test.timeout {

      for(var integer i := 0; i < sizeof(pl_scens); i := i + 1 ) {
        var float vl_maxError := 0.001;
        vl_varNameBase := f_EPTF_LGenBaseStats_getNamePrefix(pl_scens[i].eGrpName, pl_scens[i].scenName, pl_scens[i].tcName);
        if(pl_checkCpsToReach) {
          if(f_EPTF_ExecCtrlTest_isWeightedScenariobyName(pl_scens[i].eGrpName, pl_scens[i].scenName)) {
            vl_currentCPS := f_EPTF_LGenBase_getScCpsSoReachByName(pl_scens[i].eGrpName, pl_scens[i].scenName);
          } else {
            vl_currentCPS := f_EPTF_LGenBase_getTcCpsToReachByName(pl_scens[i].eGrpName, pl_scens[i].scenName, pl_scens[i].tcName);
          }
        } else {
          if(f_EPTF_ExecCtrlTest_isWeightedScenariobyName(pl_scens[i].eGrpName, pl_scens[i].scenName)) {
            vl_currentCPS := f_EPTF_ExecCtrlTest_getWeightedScenarioCps(pl_scens[i].eGrpName, pl_scens[i].scenName);
          } else {
            //vl_currentCPS := f_EPTF_LGenBase_getCPSByNames(pl_scens[i].eGrpName, pl_scens[i].scenName, pl_scens[i].tcName);
            vl_varName := vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcLastCps;
            vl_varID := f_EPTF_Var_getId(vl_varName);
            if(vl_varID != -1) {
              f_EPTF_Var_refreshContent(vl_varID);
              f_EPTF_Var_getContent(vl_varID, vl_Var_content);
              vl_currentCPS := vl_Var_content.floatVal
            } else {
              log("There is no such Variable: ", vl_varName);
              //setverdict(fail);
              f_EPTF_Base_stopAll();
              //exit
            }
          }
          vl_maxError := 1.0;
        }

        vl_targetCPS := pl_scens[i].timeProfile[vl_count].targetValue;
        if(vl_currentCPS < vl_targetCPS + vl_maxError and vl_currentCPS > vl_targetCPS - vl_maxError)
        {
          log("Current CPS: ", vl_currentCPS, " expected: ", vl_targetCPS);
          setverdict(pass)
        } else {
          log("Current CPS: ", vl_currentCPS, " expected: ", vl_targetCPS);
          setverdict(fail)
        }
      }
      vl_count := vl_count + 1;
      if (vl_count < sizeof(pl_scens[0].timeProfile)) {
        tl_test.start(pl_scens[0].timeProfile[vl_count].time - pl_scens[0].timeProfile[vl_count - 1].time);
      }
      repeat;
    }
  }
}

function f_EPTF_ExecCtrlClient_UIHandler_Test_behavior(
  in charstring pl_selfName,
  in EPTF_ExecCtrl_Test_CT pl_ExecCtrlRef)
runs on EPTF_ExecCtrlClient_UIHandler_Test_CT
{
  f_EPTF_ExecCtrlClient_UIHandler_Test_init(pl_selfName, pl_ExecCtrlRef);
  f_EPTF_Base_wait4Shutdown();
}
////////////////////////////////////////////////////////////////////////////////
//R3
////////////////////////////////////////////////////////////////////////////////
function f_EPTF_ExecCtrl_Test_TrafficDistribution(
  in charstring pl_name,
  in integer pl_nOfClients,
  in EPTF_ExecCtrl_Test_SCDataList pl_scens,
  in float pl_time)
runs on EPTF_ExecCtrl_Test_CT {
  f_EPTF_ExecCtrl_setManualControl(true);

  t_test.start(pl_time);
  v_EPTF_ExecCtrl_Test_scenarios := pl_scens;
  f_EPTF_ExecCtrl_loadConfig(pl_EPTF_ExecCtrl_PhaseList_Declarators := tsp_EPTF_LGenBase_PhaseList_Declarators);
  f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients);
  f_EPTF_ExecCtrl_registerScenarioStateChangedCallback(refers(f_EPTF_ExecCtrl_Test_UpdateScenarioState));

  alt
  {
    [] t_test.timeout {
      f_EPTF_ExecCtrl_Test_checkScOff(pl_scens[0]);
      f_EPTF_ExecCtrl_Test_checkScRunning(pl_scens[1]);
      log("### I am here");
      repeat;
    }
  } // alt

}

function f_EPTF_ExecCtrlClient_Test_TrafficDistribution(
  in charstring pl_name,
  in EPTF_ExecCtrl_Test_CT pl_execCtrl,
  in EPTF_ExecCtrl_Test_SCDataList pl_scens,
  in integer pl_eCount)
runs on EPTF_ExecCtrlClient_Test_CT
{
  timer tl_test;

  f_EPTF_ExecCtrlClient_Test_init(pl_name, pl_execCtrl, pl_eCount);

  f_EPTF_ExecCtrlClient_Test_CPS(pl_name, pl_execCtrl, {pl_scens[1]});
  log(">>>>Timer starts: ", pl_scens[0].timeProfile[0].time); //<<< This line is never reached!!!
  tl_test.start(pl_scens[0].timeProfile[0].time);

  alt {
    [] tl_test.timeout {
      log("v_trafficCount: ", v_trafficCount);
      repeat;

    }
  }
}

function f_EPTF_ExecCtrl_user_testCPS
(
  in charstring pl_hostname,
  in charstring pl_compName
)
runs on EPTF_ExecCtrl_Test_CT
return EPTF_ExecCtrlClient_CT
{
  // Create LGen instance
  var EPTF_ExecCtrlClient_Test_CT vc_client := EPTF_ExecCtrlClient_Test_CT.create(pl_compName, pl_hostname);
  // Connect and Start the LGen
  vc_client.start(f_EPTF_ExecCtrlClient_Test_CPS("TestPool" & pl_compName, self,
      f_setCPSforLGens(v_EPTF_ExecCtrl_Test_scenarios, 3)));

  return vc_client;
}

function f_EPTF_ExecCtrl_Test_pool(
  in charstring pl_name,
  in integer pl_nOfClients, in EPTF_ExecCtrl_Test_SCDataList pl_scens, in float pl_time)
runs on EPTF_ExecCtrl_Test_CT
{

  v_EPTF_ExecCtrl_Test_scenarios := pl_scens;
  var EPTF_ExecCtrl_LGenFunction_Entry_List vl_functions :=
  {
    {
      name := "CreateLgen",
      fn  := refers(f_EPTF_ExecCtrl_user_testCPS)
    }
  }

  f_EPTF_ExecCtrl_loadConfig(pl_EPTF_ExecCtrl_LGenFunction_Entry_List := vl_functions);

  f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients);
  f_EPTF_ExecCtrl_registerScenarioStateChangedCallback(refers(f_EPTF_ExecCtrl_Test_UpdateScenarioState));
  t_test.start(pl_time);

  alt
  {
    [] t_test.timeout {
      for (var integer i := 0; i < sizeof(pl_scens); i := i + 1) {
        f_EPTF_ExecCtrl_Test_checkScRunning(pl_scens[i]);
      }
      repeat;
    }
  } // alt
}

////////////////////////////////////////////////////////////////////////////////
//R4
////////////////////////////////////////////////////////////////////////////////
group PhaseRegulation {

  // LoadRegulator - setting the load-to-reach as cps-to-reach for simple testing
  function f_EPTF_ExecCtrl_Test_PhaseRegulator_getSutLoad()
  runs on EPTF_LoadRegulator_CT
  return float
  {
    return 1.0;
  }

  function f_EPTF_ExecCtrl_Test_PhaseRegulator_calcCPS(in float loadToReach, in float oldCps)
  runs on PhaseRegulator_CT
  return float
  {
    return loadToReach;
  }

  function f_EPTF_ExecCtrl_Test_PhaseRegulator_behavior(
    in charstring pl_selfName,
    in EPTF_Var_CT pl_execCtrlCompRef,
    in float pl_loadToReach)
  runs on PhaseRegulator_CT
  {
    f_EPTF_LoadRegulator_init_CT(pl_selfName,
      refers(f_EPTF_ExecCtrl_Test_PhaseRegulator_getSutLoad),
      refers(f_EPTF_ExecCtrl_Test_PhaseRegulator_calcCPS));
    f_EPTF_LoadRegulator_registerToExecCtrl(pl_execCtrlCompRef);
    f_EPTF_LoadRegulator_adjustTargetLoadInExecCtrl(pl_loadToReach);
    f_EPTF_Base_wait4Shutdown();
  }

// FIXME: the following three functions should be public in ExecCtrl, but they are friend:
function f_EPTF_ExecCtrl_Regulator_getNofRegulators() runs on EPTF_ExecCtrl_CT return integer {
  return sizeof(v_EPTF_ExecCtrl_Regulators);
}

function f_EPTF_ExecCtrl_Regulator_getRegulatorNameByRegulatorId(in integer pl_regulatorId) runs on EPTF_ExecCtrl_CT return charstring {
  return v_EPTF_ExecCtrl_Regulators[pl_regulatorId].name;
}

function f_EPTF_ExecCtrl_Regulator_getRegulatorStatusIdxByRegulatorId(in integer pl_regulatorId) runs on EPTF_ExecCtrl_CT return integer {
  return v_EPTF_ExecCtrl_Regulators[pl_regulatorId].statusIdx;
}

function f_EPTF_ExecCtrl_Test_regulatorsReady() runs on EPTF_ExecCtrl_Test_CT return boolean {
  const integer cl_lastRegulatorId := 5;
  var boolean vl_regulatorsReady := true;
  var integer vl_regulatorNum := 0;
  for (var integer vl_regulatorId:=0; vl_regulatorsReady and vl_regulatorId<f_EPTF_ExecCtrl_Regulator_getNofRegulators(); vl_regulatorId:=vl_regulatorId+1) {

    var integer vl_statusIdx := f_EPTF_ExecCtrl_Regulator_getRegulatorStatusIdxByRegulatorId(vl_regulatorId);
    var charstring vl_regulatorName := f_EPTF_ExecCtrl_Regulator_getRegulatorNameByRegulatorId(vl_regulatorId);
    // these regulators are used in the test:
    if (vl_regulatorName=="Regulator1"
      or vl_regulatorName=="Regulator2"
      or vl_regulatorName=="Regulator4"
      or vl_regulatorName=="Regulator5a"
      or vl_regulatorName=="Regulator5b"
      or vl_regulatorName=="RegulatorW"
    ) {
      vl_regulatorNum := vl_regulatorNum + 1;
      vl_regulatorsReady := vl_regulatorsReady and f_EPTF_Var_getStatusLEDValue(vl_statusIdx)=={ color := led_blue,text := "Disabled" }
    }
  }
  return vl_regulatorsReady and (vl_regulatorNum == 6);
}

  // ExecCtrl
  function f_EPTF_ExecCtrl_Test_phaseRegulation(
    in charstring pl_name,
    in integer pl_nOfClients)
  runs on EPTF_ExecCtrl_Test_CT {

    var EPTF_ExecCtrl_RegulatorNames vl_regulatorNames := {};
    for(var integer i:=0; i<sizeof(tsp_ExecCtrl_Test_phaseRegulationConfig.phaseRegulators); i:=i+1) {
      vl_regulatorNames[i] := tsp_ExecCtrl_Test_phaseRegulationConfig.phaseRegulators[i].regulatorName;
    }

    f_EPTF_ExecCtrl_loadConfig(
      pl_EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList := tsp_ExecCtrl_Test_phaseRegulationConfig.eGroups,
      pl_EPTF_LGenBase_TcMgmt_Scenarios2GrpList := tsp_ExecCtrl_Test_phaseRegulationConfig.sc2eGroups,
      pl_EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList := tsp_ExecCtrl_Test_phaseRegulationConfig.tcTypes,
      pl_EPTF_LGenBase_ScenarioTypeDeclaratorList := tsp_ExecCtrl_Test_phaseRegulationConfig.scTypes,
      pl_EPTF_ExecCtrl_PhaseList_Declarators := tsp_ExecCtrl_Test_phaseRegulationConfig.phases,
      pl_EPTF_ExecCtrl_ScenarioGroup_Declarators := tsp_ExecCtrl_Test_phaseRegulationConfig.scGroups,
      pl_EPTF_ExecCtrl_RegulatorNames := vl_regulatorNames,
      pl_EPTF_ExecCtrl_RegulatedItems := tsp_ExecCtrl_Test_phaseRegulationConfig.regulatedItems
    );

    f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients);

    f_EPTF_ExecCtrl_waitForCondition(refers(f_EPTF_ExecCtrl_checkReadyToRun));

    //Waiting for regulators to start up...
    f_EPTF_ExecCtrl_waitForCondition(refers(f_EPTF_ExecCtrl_Test_regulatorsReady));

    f_EPTF_ExecCtrl_startAllScenarioGroups();

    f_EPTF_Base_wait4Shutdown();
  }

  // ExecCtrlClient
  function f_EPTF_ExecCtrlClient_Test_phaseRegulationTcSuccess(in integer pl_tcAbsIdx)
  runs on EPTF_ExecCtrlClient_TestPhaseRegulation_CT
  {
    var charstring vl_eGrpName, vl_scName, vl_tcName, vl_item;
    var integer vl_eGrpIdx := f_EPTF_LGenBase_getEGrpIdxOfTc(pl_tcAbsIdx);
    var integer vl_scIdx := f_EPTF_LGenBase_getScIdxOfTc(pl_tcAbsIdx);
    f_EPTF_LGenBase_trafficCaseIdNames(pl_tcAbsIdx, vl_eGrpName, vl_scName, vl_tcName);

    var charstring vl_actualPhase := "";
    var EPTF_LGenBase_Phase_States vl_state;
    if(f_EPTF_LGenBase_getActualPhase(f_EPTF_LGenBase_scenarioAbsIdxByName(vl_eGrpName, vl_scName), vl_actualPhase, vl_state)) {
      if(f_EPTF_LGenBase_isWeightedScenario(vl_eGrpIdx, vl_scIdx)) {
        vl_item := f_EPTF_ExecCtrlClient_Test_genItemName(vl_eGrpName, vl_scName, "", vl_actualPhase);
      } else {
        vl_item := f_EPTF_ExecCtrlClient_Test_genItemName(vl_eGrpName, vl_scName, vl_tcName, vl_actualPhase);
      }
    } else {
      if(f_EPTF_LGenBase_isWeightedScenario(vl_eGrpIdx, vl_scIdx)) {
        vl_item := f_EPTF_ExecCtrlClient_Test_genItemName(vl_eGrpName, vl_scName, "", "");
      } else {
        vl_item := f_EPTF_ExecCtrlClient_Test_genItemName(vl_eGrpName, vl_scName, vl_tcName, "");
      }
    }

    var integer vl_idx := -1;
    if(f_EPTF_str2int_HashMap_Find(v_phaseRegulatedItemHash, vl_item, vl_idx)) {
      var float vl_cps;
      if(f_EPTF_LGenBase_isWeightedScenario(vl_eGrpIdx, vl_scIdx)) {
        vl_cps := f_EPTF_LGenBase_getScCpsToReachByIdx(vl_eGrpIdx, vl_scIdx);
      } else {
        vl_cps := f_EPTF_LGenBase_getTcCpsToReachByIdx(pl_tcAbsIdx);
      }
      if(v_phaseRegulatedItems[vl_idx].lastCps != vl_cps) {
        log(%definitionId&" in phase: "&vl_actualPhase&" : last CPS of item ", vl_item, " changed from ", v_phaseRegulatedItems[vl_idx].lastCps, " to ", vl_cps);
        v_phaseRegulatedItems[vl_idx].lastCps := vl_cps;
        v_phaseRegulatedItems[vl_idx].doCheck := true;
      }
    }
  }

  function f_EPTF_ExecCtrlClient_Test_phaseRegTestEnd(integer tcIdx)
  runs on EPTF_ExecCtrlClient_TestPhaseRegulation_CT
  {
    timer tWait;
    tWait.start(5.1);
    tWait.timeout; // wait for concurrently running scenarios to end
    log(%definitionId&": v_phaseRegulatedItems: ", v_phaseRegulatedItems);
    for(var integer i:=0; i<sizeof(v_phaseRegulatedItems); i:=i+1) {
      if(v_phaseRegulatedItems[i].doCheck) {
        log(%definitionId&": item: ", v_phaseRegulatedItems[i].name,
          ", expected CPS: ", v_phaseRegulatedItems[i].expectedCps,
          ", last CPS: ", v_phaseRegulatedItems[i].lastCps);
        if(v_phaseRegulatedItems[i].expectedCps == v_phaseRegulatedItems[i].lastCps) {
          setverdict(pass);
        } else {
          setverdict(fail);
        }
      }
    }
    f_EPTF_Base_stopAll(none);
  }

  function f_EPTF_ExecCtrlClient_Test_genItemName(
    in charstring pl_eGrpName,
    in charstring pl_scName,
    in charstring pl_tcName,
    in charstring pl_phase)
  return charstring
  {
    var charstring vl_name := pl_eGrpName & "." & pl_scName;
    if(pl_tcName != "") { vl_name := vl_name & "." & pl_tcName; }
    if(pl_phase != "") { vl_name := vl_name & "@" & pl_phase; }
    return vl_name;
  }

  function f_EPTFExecCtrlClient_Test_regulatedItemName2str(in EPTF_ExecCtrl_RegulatedItemName pl_name)
  runs on EPTF_Base_CT
  return charstring
  {
    if(ischosen(pl_name.cps_TC)) {
      return f_EPTF_ExecCtrlClient_Test_genItemName(
        pl_name.cps_TC.eGrpName,
        pl_name.cps_TC.scName,
        pl_name.cps_TC.tcName,
        "");
    } else if(ischosen(pl_name.cps_SC)) {
      return f_EPTF_ExecCtrlClient_Test_genItemName(
        pl_name.cps_SC.eGrpName,
        pl_name.cps_SC.scName,
        "",
        "");
    } else if(ischosen(pl_name.cps_TCInPhase)) {
      return f_EPTF_ExecCtrlClient_Test_genItemName(
        pl_name.cps_TCInPhase.eGrpName,
        pl_name.cps_TCInPhase.scName,
        pl_name.cps_TCInPhase.tcName,
        pl_name.cps_TCInPhase.phase);
    } else if(ischosen(pl_name.cps_SCInPhase)) {
      return f_EPTF_ExecCtrlClient_Test_genItemName(
        pl_name.cps_SCInPhase.eGrpName,
        pl_name.cps_SCInPhase.scName,
        "",
        pl_name.cps_SCInPhase.phase);
    } else {
      log(%definitionId&": ERROR: unsupported field for type EPTF_ExecCtrl_RegulatedItemName: ", pl_name);
      f_EPTF_Base_stopAll(inconc);
      return "";
    }
  }

  function f_EPTF_ExecCtrlClient_TestPhaseRegulation_init_CT(
    in charstring pl_name,
    in EPTF_ExecCtrl_Test_CT pl_execCtrl,
    in boolean pl_keepRegulatedCpsInSubseqentPhases)
  runs on EPTF_ExecCtrlClient_TestPhaseRegulation_CT
  {
    //    if(v_EPTF_ExecCtrlClient_Test_initialized) { return }
    f_EPTF_ExecCtrlClient_Test_init(pl_name, pl_execCtrl, -1, false);
    v_phaseRegulatedItemHash := f_EPTF_str2int_HashMap_New(c_EPTF_ExecCtrl_Test_itemHashName);
    f_EPTF_Base_registerCleanup(refers(EPTF_ExecCtrlClient_TestPhaseRegulation_cleanup_CT));
    var integer vl_idx := -1;

    // store expected CPS of regulated items
    for(var integer i:=0; i<sizeof(tsp_ExecCtrl_Test_phaseRegulationConfig.regulatedItems); i:=i+1) {
      var charstring vl_regItemName := f_EPTFExecCtrlClient_Test_regulatedItemName2str(tsp_ExecCtrl_Test_phaseRegulationConfig.regulatedItems[i].idName);
      if(f_EPTF_str2int_HashMap_Find(v_phaseRegulatedItemHash, vl_regItemName, vl_idx)) { // found
        log(%definitionId&": ERROR: regulated item redefined: ", vl_regItemName);
        f_EPTF_Base_stopAll(inconc);
      } else {
        vl_idx := sizeof(v_phaseRegulatedItems);
        v_phaseRegulatedItems[vl_idx] := c_EPTF_ExecCtrl_Test_PhaseRegulatedItem_init
        v_phaseRegulatedItems[vl_idx].name := vl_regItemName;
        f_EPTF_str2int_HashMap_Insert(v_phaseRegulatedItemHash, vl_regItemName, vl_idx);
        var charstring vl_reg := tsp_ExecCtrl_Test_phaseRegulationConfig.regulatedItems[i].regulatorName;
        for(var integer j:=0; j< sizeof(tsp_ExecCtrl_Test_phaseRegulationConfig.phaseRegulators); j:=j+1) {
          if(tsp_ExecCtrl_Test_phaseRegulationConfig.phaseRegulators[j].regulatorName == vl_reg) {
            v_phaseRegulatedItems[vl_idx].expectedCps := tsp_ExecCtrl_Test_phaseRegulationConfig.phaseRegulators[j].targetValue;
          }
        }
      }
      log(%definitionId&": expected CPS of regulated item ", vl_regItemName, ": ", v_phaseRegulatedItems[vl_idx].expectedCps);
    }

    // get expected CPS of all the remaining items (SC or TC CPSs, for which no regulated items were specified)
    for(var integer i:=0; i<sizeof(tsp_ExecCtrl_Test_phaseRegulationConfig.scTypes); i:=i+1) {
      var EPTF_CharstringList vl_phases := {};
      var boolean vl_scIsWeighted := false;
      var float vl_cps := 0.0;
      var charstring vl_itemName := "";
      for(var integer j:=0; j<sizeof(tsp_ExecCtrl_Test_phaseRegulationConfig.scTypes[i].scParamsList); j:=j+1) {
        if(ischosen(tsp_ExecCtrl_Test_phaseRegulationConfig.scTypes[i].scParamsList[j].weightedScData)) {
          vl_scIsWeighted := true;
          vl_cps := tsp_ExecCtrl_Test_phaseRegulationConfig.scTypes[i].scParamsList[j].weightedScData.cpsToReach;
          log(%definitionId&": CPS of scenario ", tsp_ExecCtrl_Test_phaseRegulationConfig.scTypes[i].name, ": ", vl_cps);
        }
        if(ischosen(tsp_ExecCtrl_Test_phaseRegulationConfig.scTypes[i].scParamsList[j].phaseListName)) {
          for(var integer k:=0; k<sizeof(tsp_ExecCtrl_Test_phaseRegulationConfig.phases); k:=k+1) {
            if( tsp_ExecCtrl_Test_phaseRegulationConfig.phases[k].name ==
              tsp_ExecCtrl_Test_phaseRegulationConfig.scTypes[i].scParamsList[j].phaseListName) {
              for(var integer l:=0; l<sizeof(tsp_ExecCtrl_Test_phaseRegulationConfig.phases[k].phases); l:=l+1) {
                vl_phases[l] := tsp_ExecCtrl_Test_phaseRegulationConfig.phases[k].phases[l].name
              }
            }
          }
          log(%definitionId&": phase list of scenario ", tsp_ExecCtrl_Test_phaseRegulationConfig.scTypes[i].name, ": ", vl_phases);
        }
      }
      if(vl_phases == {}) {
        log(%definitionId&": WARNING: no phase list for scenario ",
          tsp_ExecCtrl_Test_phaseRegulationConfig.scTypes[i].name);
      }
      if(vl_scIsWeighted) {
        for(var integer eGrpIdx:=0; eGrpIdx<sizeof(tsp_ExecCtrl_Test_phaseRegulationConfig.sc2eGroups); eGrpIdx:=eGrpIdx+1) {
          for(var integer scIdx:=0; scIdx<sizeof(tsp_ExecCtrl_Test_phaseRegulationConfig.sc2eGroups[eGrpIdx].scenarioNames); scIdx:=scIdx+1) {
            if(tsp_ExecCtrl_Test_phaseRegulationConfig.sc2eGroups[eGrpIdx].scenarioNames[scIdx] == tsp_ExecCtrl_Test_phaseRegulationConfig.scTypes[i].name) {
              var float vl_cpsOfScInstance := vl_cps; // this is needed in case the SC is assigned to more than one eGroup and one of these has no regulated item specified
              for(var integer pIdx:=0; pIdx<sizeof(vl_phases); pIdx:=pIdx+1) {
                vl_itemName := f_EPTF_ExecCtrlClient_Test_genItemName(
                  tsp_ExecCtrl_Test_phaseRegulationConfig.sc2eGroups[eGrpIdx].eGrpName,
                  tsp_ExecCtrl_Test_phaseRegulationConfig.scTypes[i].name,
                  "",
                  vl_phases[pIdx]);
                if(f_EPTF_str2int_HashMap_Find(v_phaseRegulatedItemHash, vl_itemName, vl_idx)) {
                  if(pl_keepRegulatedCpsInSubseqentPhases) {
                    vl_cpsOfScInstance := v_phaseRegulatedItems[vl_idx].expectedCps;
                  }
                } else {
                  vl_idx := sizeof(v_phaseRegulatedItems);
                  v_phaseRegulatedItems[vl_idx] := c_EPTF_ExecCtrl_Test_PhaseRegulatedItem_init
                  v_phaseRegulatedItems[vl_idx].name := vl_itemName;
                  v_phaseRegulatedItems[vl_idx].expectedCps := vl_cpsOfScInstance;
                  f_EPTF_str2int_HashMap_Insert(v_phaseRegulatedItemHash, vl_itemName, vl_idx);
                  log(%definitionId&": expected CPS of item ", vl_itemName, ": ", v_phaseRegulatedItems[vl_idx].expectedCps);
                }
              }
            }
          }
        }
      } else {
        for(var integer eGrpIdx:=0; eGrpIdx<sizeof(tsp_ExecCtrl_Test_phaseRegulationConfig.sc2eGroups); eGrpIdx:=eGrpIdx+1) {
          for(var integer scIdx:=0; scIdx<sizeof(tsp_ExecCtrl_Test_phaseRegulationConfig.sc2eGroups[eGrpIdx].scenarioNames); scIdx:=scIdx+1) {
            if(tsp_ExecCtrl_Test_phaseRegulationConfig.sc2eGroups[eGrpIdx].scenarioNames[scIdx] == tsp_ExecCtrl_Test_phaseRegulationConfig.scTypes[i].name) {
              for(var integer tcIdx:=0; tcIdx<sizeof(tsp_ExecCtrl_Test_phaseRegulationConfig.scTypes[i].tcList); tcIdx:=tcIdx+1) {
                for(var integer paramIdx:=0; paramIdx<sizeof(tsp_ExecCtrl_Test_phaseRegulationConfig.scTypes[i].tcList[tcIdx].tcParamsList); paramIdx:=paramIdx+1) {
                  if(ischosen(tsp_ExecCtrl_Test_phaseRegulationConfig.scTypes[i].tcList[tcIdx].tcParamsList[paramIdx].target)) {
                    if(ischosen(tsp_ExecCtrl_Test_phaseRegulationConfig.scTypes[i].tcList[tcIdx].tcParamsList[paramIdx].target.cpsToReach)) {
                      vl_cps := tsp_ExecCtrl_Test_phaseRegulationConfig.scTypes[i].tcList[tcIdx].tcParamsList[paramIdx].target.cpsToReach;
                    } else {
                      log("ERROR: unsupported union field in TC target for TC ", tsp_ExecCtrl_Test_phaseRegulationConfig.scTypes[i].tcList[tcIdx].tcName,
                        ": ", tsp_ExecCtrl_Test_phaseRegulationConfig.scTypes[i].tcList[tcIdx].tcParamsList[paramIdx].target);
                      f_EPTF_Base_stopAll(inconc);
                    }
                  }
                }
                for(var integer pIdx:=0; pIdx<sizeof(vl_phases); pIdx:=pIdx+1) {
                  vl_itemName := f_EPTF_ExecCtrlClient_Test_genItemName(
                    tsp_ExecCtrl_Test_phaseRegulationConfig.sc2eGroups[eGrpIdx].eGrpName,
                    tsp_ExecCtrl_Test_phaseRegulationConfig.scTypes[i].name,
                    tsp_ExecCtrl_Test_phaseRegulationConfig.scTypes[i].tcList[tcIdx].tcName,
                    vl_phases[pIdx]);
                  if(f_EPTF_str2int_HashMap_Find(v_phaseRegulatedItemHash, vl_itemName, vl_idx)) {
                    if(pl_keepRegulatedCpsInSubseqentPhases) {
                      vl_cps := v_phaseRegulatedItems[vl_idx].expectedCps;
                    }
                  } else {
                    vl_idx := sizeof(v_phaseRegulatedItems);
                    v_phaseRegulatedItems[vl_idx] := c_EPTF_ExecCtrl_Test_PhaseRegulatedItem_init;
                    v_phaseRegulatedItems[vl_idx].name := vl_itemName;
                    v_phaseRegulatedItems[vl_idx].expectedCps := vl_cps;
                    f_EPTF_str2int_HashMap_Insert(v_phaseRegulatedItemHash, vl_itemName, vl_idx);
                    log(%definitionId&": expected CPS of item ", vl_itemName, ": ", v_phaseRegulatedItems[vl_idx].expectedCps);
                  }
                }
              }
            }
          }
        }
      }
    }
  }

  function EPTF_ExecCtrlClient_TestPhaseRegulation_cleanup_CT()
  runs on EPTF_ExecCtrlClient_TestPhaseRegulation_CT
  {
    if(not v_EPTF_ExecCtrlClient_Test_initialized) { return }
    f_EPTF_LGenBase_removeTrafficSuccessFn(refers(f_EPTF_ExecCtrlClient_Test_phaseRegulationTcSuccess));
    f_EPTF_str2int_HashMap_Delete(c_EPTF_ExecCtrl_Test_itemHashName);
    v_phaseRegulatedItemHash := -1;
    v_phaseRegulatedItems := {};
  }

  function f_EPTF_ExecCtrlClient_Test_phaseRegulation(
    in charstring pl_name,
    in EPTF_ExecCtrl_Test_CT pl_execCtrl,
    in boolean pl_keepRegulatedCpsInSubseqentPhases)
  runs on EPTF_ExecCtrlClient_TestPhaseRegulation_CT
  {
    f_EPTF_ExecCtrlClient_TestPhaseRegulation_init_CT(pl_name, pl_execCtrl, pl_keepRegulatedCpsInSubseqentPhases);

    f_EPTF_LGenBase_registerTrafficSuccessFn(refers(f_EPTF_ExecCtrlClient_Test_phaseRegulationTcSuccess));

    f_EPTF_LGenBase_declareFunction("phaseRegTestEnd",
      {customPhaseAction:=refers(f_EPTF_ExecCtrlClient_Test_phaseRegTestEnd)});

    f_EPTF_ExecCtrlClient_readyToStart();

    f_EPTF_Base_wait4Shutdown();
  }

} // group PhaseRegulation

group TR_HL20955 {

  // ExecCtrl
  function f_EPTF_ExecCtrl_Test_HL20955(
    in charstring pl_name,
    in integer pl_nOfClients,
    in EPTF_UIHandler_CT pl_gui,
    in EPTF_ExecCtrl_Test_HL20955Config pl_ExecCtrl_Test_HL20955Config,
    in EPTF_ExecCtrlClient_CT pl_client)
  runs on EPTF_ExecCtrl_UIHandler_Test_CT {

    f_EPTF_ExecCtrl_setManualControl(true);
    f_EPTF_ExecCtrl_loadConfig(
      pl_EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList := pl_ExecCtrl_Test_HL20955Config.eGroups,
      pl_EPTF_LGenBase_TcMgmt_Scenarios2GrpList := pl_ExecCtrl_Test_HL20955Config.sc2eGroups,
      pl_EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList := pl_ExecCtrl_Test_HL20955Config.tcTypes,
      pl_EPTF_ExecCtrl_TimeProfileDescrList := pl_ExecCtrl_Test_HL20955Config.timeProfileDescrList,
      pl_EPTF_ExecCtrl_TimeProfileList := pl_ExecCtrl_Test_HL20955Config.timeProfileList,
      pl_EPTF_ExecCtrl_TimeProfile2TcList := pl_ExecCtrl_Test_HL20955Config.timeProfile2TcList,
      pl_EPTF_LGenBase_ScenarioTypeDeclaratorList := pl_ExecCtrl_Test_HL20955Config.scTypes
    );

    f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients, pl_dataSource_compRef := pl_gui);

    f_EPTF_ExecCtrl_waitForCondition(refers(f_EPTF_ExecCtrl_checkReadyToRun));

    var integer vl_scenFinishCounterId;
    f_EPTF_Var_subscribeRemote(pl_client,"ScenFinishCounter", realtime,vl_scenFinishCounterId);
    f_EPTF_Var_addPostProcFn(
      vl_scenFinishCounterId,
      {
        funcRef := refers(f_EPTF_ExecCtrl_Test__HL20955_pass_PostProc),
        argList := {sizeof(pl_ExecCtrl_Test_HL20955Config.scTypes)} // number of scenarios
      }
    );

    f_EPTF_ExecCtrl_startAllScenarios();

    f_EPTF_Base_wait4Shutdown();
  }

  function f_EPTF_ExecCtrl_Test__HL20955_pass_PostProc(in integer pl_idx, in EPTF_IntegerList pl_argList) runs on EPTF_ExecCtrl_UIHandler_Test_CT {
    var integer vl_currentValue := f_EPTF_Var_getIntValue(pl_idx);
    if (vl_currentValue == pl_argList[0]) {
      // the test is passed if all scenarios has finished
      log("All scenarios finished. Test is passed!");
      f_EPTF_Base_stopAll(pass);
    }
  }

  function f_EPTF_ExecCtrlClient_Test_HL20955_fail(integer tcIdx)
  runs on EPTF_ExecCtrlClient_Test_CT {
    log(%definitionId&": ExecTime expired, not enough calls generated: test failed!");
    setverdict(fail);
  }

  function f_EPTF_ExecCtrlClient_Test_HL20955_pass(integer tcIdx)
  runs on EPTF_ExecCtrlClient_Test_CT {
    log(%definitionId&": Traffic restarted after CPS was set to zero: scenario passed!");
    var integer vl_scenFinishCounterId := f_EPTF_Var_getId("ScenFinishCounter");
    var integer vl_currentValue := f_EPTF_Var_getIntValue(vl_scenFinishCounterId);
    f_EPTF_Var_adjustContent(vl_scenFinishCounterId, {intVal := vl_currentValue+1});
    //setverdict(pass);
  }

  function f_EPTF_ExecCtrlClient_Test_HL20955(
    in charstring pl_selfName,
    in EPTF_ExecCtrl_Test_CT pl_execCtrl
  )
  runs on EPTF_ExecCtrlClient_Test_CT
  {
    f_EPTF_ExecCtrlClient_Test_init(pl_selfName, pl_execCtrl, -1, false);
    f_EPTF_LGenBase_declareFunction("f_EPTF_ExecCtrlClient_Test_HL20955_fail",
      {customFinishFunction:=refers(f_EPTF_ExecCtrlClient_Test_HL20955_fail)});
    f_EPTF_LGenBase_declareFunction("f_EPTF_ExecCtrlClient_Test_HL20955_pass",
      {customFinishFunction:=refers(f_EPTF_ExecCtrlClient_Test_HL20955_pass)});

    var integer vl_scenFinishCounterId;
    f_EPTF_Var_newInt("ScenFinishCounter",0, vl_scenFinishCounterId);
    f_EPTF_ExecCtrlClient_readyToStart();

    f_EPTF_Base_wait4Shutdown();
  }

} // group TR_HL20955

group ExecTimeForSmallCPS {

  function f_EPTF_ExecCtrl_Test_waitForGUIDone() runs on myMTC_UI {
    timer T_guard, T_alt;
    T_guard.start( 10.0 );
    T_alt.start( 0.0 );
    alt{
      [] T_guard.timeout{
        setverdict(fail,"Timeout during config[waitForGUIDone:v_ready]");
      }
      [v_ready] T_alt.timeout{}
    };
    f_EPTF_UIHandler_createGUIFromFile(tsp_ExecCtrl_DS_guiXmlName,"");

    T_guard.start( 100.0 );
    T_alt.start( 0.0 );
    alt{
      [] T_guard.timeout{
        setverdict(fail,"Timeout during config[waitForGUIDone:checkReadyToRun]");
      }
      [f_EPTF_ExecCtrl_checkReadyToRun()] T_alt.timeout{}
    };

  }


  // ExecCtrl
  function f_EPTF_ExecCtrl_Test_ExecTimeForSmallCPS(
    in charstring pl_name,
    in integer pl_nOfClients,
    in EPTF_UIHandler_CT pl_gui,
    in EPTF_ExecCtrl_Test_HL20955Config pl_ExecCtrl_Test_HL20955Config,
    in EPTF_ExecCtrlClient_CT pl_client)
  runs on EPTF_ExecCtrl_UIHandler_Test_CT {

    f_EPTF_ExecCtrl_setManualControl(true);
    f_EPTF_ExecCtrl_loadConfig(
      pl_EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList := pl_ExecCtrl_Test_HL20955Config.eGroups,
      pl_EPTF_LGenBase_TcMgmt_Scenarios2GrpList := pl_ExecCtrl_Test_HL20955Config.sc2eGroups,
      pl_EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList := pl_ExecCtrl_Test_HL20955Config.tcTypes,
      pl_EPTF_ExecCtrl_TimeProfileDescrList := pl_ExecCtrl_Test_HL20955Config.timeProfileDescrList,
      pl_EPTF_ExecCtrl_TimeProfileList := pl_ExecCtrl_Test_HL20955Config.timeProfileList,
      pl_EPTF_ExecCtrl_TimeProfile2TcList := pl_ExecCtrl_Test_HL20955Config.timeProfile2TcList,
      pl_EPTF_LGenBase_ScenarioTypeDeclaratorList := pl_ExecCtrl_Test_HL20955Config.scTypes
    );

    f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients, pl_dataSource_compRef := pl_gui);

    f_EPTF_ExecCtrl_waitForCondition(refers(f_EPTF_ExecCtrl_checkReadyToRun));

    f_EPTF_ExecCtrl_startAllScenarios();
    f_EPTF_ExecCtrl_setManualControl(false);

    f_EPTF_Base_wait4Shutdown();
  }

  function f_EPTF_ExecCtrlClient_Test_execTime(integer tcIdx)
  runs on EPTF_ExecCtrlClient_Test_CT {
    var float vl_timeElapsed := f_EPTF_Base_getRelTimeInSecs();
    log(%definitionId&": Traffic execTime fired at "&float2str(vl_timeElapsed));
    if (vl_timeElapsed<30.0) {
      action("ExecTime fired too early "&float2str(vl_timeElapsed)&": test failed!");
      setverdict(fail);
    } else {
      setverdict(pass);
    }
  }

  function f_EPTF_ExecCtrlClient_Test_ExecTimeForSmallCPS(
    in charstring pl_selfName,
    in EPTF_ExecCtrl_Test_CT pl_execCtrl
  )
  runs on EPTF_ExecCtrlClient_Test_CT
  {
    f_EPTF_ExecCtrlClient_Test_init(pl_selfName, pl_execCtrl, -1, false);
    f_EPTF_LGenBase_declareFunction("f_EPTF_ExecCtrlClient_Test_execTime",
      {customFinishFunction:=refers(f_EPTF_ExecCtrlClient_Test_execTime)});

    f_EPTF_ExecCtrlClient_readyToStart();

    f_EPTF_Base_wait4Shutdown();
  }

} // group ExecTimeForSmallCPS



group HL45980 {


  modulepar EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList tsp_EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList_HL45980 := {
    {name := "grpSimpleFSM", eType := "SimpleFSM_Entity", eCount := 100}
  }

  modulepar EPTF_ExecCtrl_ScenarioInstanceTypeList tsp_EPTF_ExecCtrl_Scenario2EntityGroupList_HL45980 := {
    {scenarioName:="SC1", eGrpName:="grpSimpleFSM",name:="grpSimpleFSM.SC1"}
  };

  modulepar EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList tsp_LGenBase_TcMgmt_tcTypeDeclarators2_HL45980 := {
    {
      name := "TC_pre",
      fsmName := "LGenSimpleFSM outgoing",
      entityType := "SimpleFSM_Entity",
      customEntitySucc := ""
    },
    { // Almost nothing...
      name := "TC_lgen",
      fsmName := "LGenSimpleFSM outgoing",
      entityType := "SimpleFSM_Entity",
      customEntitySucc := ""
    },
    { // Almost nothing...
      name := "TC_post",
      fsmName := "LGenSimpleFSM outgoing",
      entityType := "SimpleFSM_Entity",
      customEntitySucc := ""
    }
  };

  modulepar EPTF_LGenBase_ScenarioTypeDeclaratorList     tsp_LGenBase_TcMgmt_ScenarioDeclarators3_HL45980 := {
    {
      name := "SC1",
      tcList := {
        {
          tcName := "TC_pre",
          tcParamsList := {
            {target := { trafficWeight := 1.0000 }},
            {enableEntitiesAtStart := true},
            {ranges := {
                {name := "subscriber id", enableSplit := true, baseOffset := 0, count := 500}
              }
            },
            {params := {
                //{aName:="OAM",pName:="trafficCasePreexecEnabled",pValue:="false" },
                //{aName:="OAM",pName:="trafficCasePostexecEnabled",pValue:="true" },
                {aName:="OAM",pName:="HSS_FE_configuration",pValue:="false" },
                {aName:="OAM",pName:="cyclic_execution",pValue:="true" },
                {aName:="OAM",pName:="cyclic_timeout",pValue:="0.25" }
              }
            },
            {trafficStartFinish := {
                //{execTime := {time := 30.000000,actions := {}}}
                {nrOfRangeLoop := {count := 1,actions := {}}}
                //{nrOfExecStart := {count := 600,actions := {}}}
              }
            }
          }
        },
        {
          tcName := "TC_lgen",
          tcParamsList := {
            {target := { trafficWeight := 1.0000 }},
            {enableEntitiesAtStart := true},
            {ranges := {
                {name := "subscriber id", enableSplit := true, baseOffset := 0, count := 500}
              }
            },
            {params := {
                //{aName:="OAM",pName:="trafficCasePreexecEnabled",pValue:="false" },
                //{aName:="OAM",pName:="trafficCasePostexecEnabled",pValue:="true" },
                {aName:="OAM",pName:="HSS_FE_configuration",pValue:="false" },
                {aName:="OAM",pName:="cyclic_execution",pValue:="true" },
                {aName:="OAM",pName:="cyclic_timeout",pValue:="0.25" }
              }
            },
            {trafficStartFinish := {
                {execTime := {time := 10.000000,actions := {}}}
                //{nrOfRangeLoop := {count := 1,actions := {}}}
                //{nrOfExecStart := {count := 600,actions := {}}}
              }
            }
          }
        },
        {
          tcName := "TC_post",
          tcParamsList := {
            {target := { trafficWeight := 1.0000 }},
            {enableEntitiesAtStart := true},
            {ranges := {
                {name := "subscriber id", enableSplit := true, baseOffset := 0, count := 500}
              }
            },
            {params := {
                //{aName:="OAM",pName:="trafficCasePreexecEnabled",pValue:="false" },
                //{aName:="OAM",pName:="trafficCasePostexecEnabled",pValue:="true" },
                {aName:="OAM",pName:="HSS_FE_configuration",pValue:="false" },
                {aName:="OAM",pName:="cyclic_execution",pValue:="true" },
                {aName:="OAM",pName:="cyclic_timeout",pValue:="0.25" }
              }
            },
            {trafficStartFinish := {
                //{execTime := {time := 30.000000,actions := {}}}
                {nrOfRangeLoop := {count := 1,actions := {}}}
                //{nrOfExecStart := {count := 600,actions := {}}}
              }
            }
          }
        }
      },
      scParamsList := {
        {weightedScData := {cpsToReach := 50.000000, lockCPS := false, deterministicMix := true, scheduler := omit}},
        {phaseListName := "ExecPhases"},
        {phaseFinishConditions := {
            {
              phase := "preexec",
              conditions := {
                { tcFinished := "TC_pre" }
              }
            },
            {
              phase := "loadgen",
              conditions := {
                { tcFinished := "TC_lgen" }
              }
            },
            {
              phase := "postexec",
              conditions := {
                { tcFinished := "TC_post" }
              }
            }
          }
        },
        {phaseStateChangeActions := {
            {
              phase := "preexec",
              state := RUNNING,
              actions := {
                { startTc := "TC_pre" }
              }
            },
            {
              phase := "preexec",
              state := STOPPING,
              actions := {
                { stopTc := "TC_pre" }
              }
            },
            {
              phase := "loadgen",
              state := RUNNING,
              actions := {
                { startTc := "TC_lgen" }
              }
            },
            {
              phase := "loadgen",
              state := STOPPING,
              actions := {
                { stopTc := "TC_lgen" }
              }
            },
            {
              phase := "postexec",
              state := RUNNING,
              actions := {
                { startTc := "TC_post" }
              }
            },
            {
              phase := "postexec",
              state := STOPPING,
              actions := {
                { stopTc := "TC_post" }
              }
            }
          }
        }
      }
    }
  }; // weighted and non weighted too

  modulepar EPTF_LGenBase_PhaseList_Declarators     tsp_EPTF_ExecCtrl_PhaseList_Declarators_HL45980 := {
    {
      name := "ExecPhases",
      phases :=
      {
        { name := "preexec", enabled := true },
        { name := "loadgen" , enabled := true },
        { name := "postexec",enabled := true }
      }
    }
  };

  modulepar   EPTF_ExecCtrl_ScenarioGroup_Declarators tsp_EPTF_ExecCtrl_ScenarioGroup_Declarators_HL45980 := {
    {
      name := "ScGroup1",
      execMode := AUTOMATIC,
      scenarioNames := { "grpSimpleFSM.SC1" },
      phaseListName := "ExecPhases"
    }
  };

  modulepar  EPTF_ExecCtrl_LGenPool_Declarators      tsp_EPTF_ExecCtrl_LGenPool_Declarators_HL45980 := {
    {
      name := "Pool_SimpleFSM",
      lgenPoolItems := {
        {
          hostname := "SimpleFSM",
          num := 2,
          createFunctionName := "EPTF_ExecCtrl_Test_Functions.f_EPTF_createLGenSimpleFSM"
        }
      }
    }
  };

  modulepar EPTF_ExecCtrl_EntityGroup2LGenPool_List tsp_EPTF_ExecCtrl_EntityGroup2LGenPool_List_HL45980 := {
    {
      eGrpName := "grpSimpleFSM",
      lgenPoolName := "Pool_SimpleFSM"
    }
  };

  modulepar float tsp_LGenSimpleFSM_T_busy := 1.0; // time until entity busy

  // Creates LGens with entity types: SimpleFSM_Entity
  function f_EPTF_createLGenSimpleFSM
  (
    in charstring pl_hostname,
    in charstring pl_componentName
  )
  runs on EPTF_ExecCtrl_UIHandler_CT
  return EPTF_ExecCtrlClient_CT {
    var LGenSimpleFSM_CT LG := LGenSimpleFSM_CT.create;
    LG.start(f_LGenSimpleFSM_behavior(pl_componentName, self, f_EPTF_UIHandlerClient_defaultUIHandler()));
    return LG;
  }

  type component LGenSimpleFSM_CT extends EPTF_LGenBase_CT, EPTF_ExecCtrlClient_UIHandler_CT
  {
    var integer v_myBIdx;
  }

  //init the "application level virtual library"
  const charstring c_LGenSimpleFSMAppLib_behaviorType := "LGenSimpleFSM_behaviorType";
  function f_LGenSimpleFSM_AppLib_init(in integer pl_numberOfResources := 100) runs on LGenSimpleFSM_CT {
    var integer i;

    v_myBIdx:=f_EPTF_LGenBase_declareBehaviorType(c_LGenSimpleFSMAppLib_behaviorType, pl_numberOfResources, null, null, null);
    log(%definitionId,": myBIdx is ", v_myBIdx);

    // declare FSM (this is just a simple FSM):
    var EPTF_LGenBase_FsmTableDeclarator vl_EPTF_LGenBase_FsmTableDeclarator := {
      name := "LGenSimpleFSM outgoing",//"SimpleFSM",
      fsmParams := {
        {timerList := {{"busyTimer",tsp_LGenSimpleFSM_T_busy}}},
        {stateList := {"idle", "busy"}}
        ,{varList :=  {
            {name := "vf_chrono", initValue := {floatVal := 0.0}, scope := TC}
            ,{name := "vf_chrono_free", initValue := {floatVal := 0.0}, scope := TC}
            ,{name := "cf_one", initValue := {intVal := 1}, scope := TC}
            ,{name := "vf_running", initValue := {intVal := 0}, scope := TC}
            ,{name := "vf_starts", initValue := {intVal := 0}, scope := TC}
          }}
        ,{statMeasStatList :=  {
            {name := "mean_rtt", varName := "vf_chrono",statType := mean, scope := TC}
            ,{name := "mean_busy", varName := "vf_running",statType := max, scope := TC}
            //,{name := "chrono_free", varName := "",statType := chrono, scope := FSM}
          }}
        ,{statMeasWithParamsList :=  {
            {
              name := "maxChrono",
              providerVarName := "vf_chrono",
              targetVarName := "",
              statMeasParams := {
                statType := max},
              scope := TC
            },
            {
              name := "chrono_busy",
              providerVarName := "",
              targetVarName := "vf_chrono",
              statMeasParams := {
                statType := chrono},
              scope := FSM
            },
            {
              name := "meanFree",
              providerVarName := "vf_chrono_free",
              targetVarName := "",
              statMeasParams := {
                statType := mean},
              scope := TC
            },
            {
              name := "chrono_free",
              providerVarName := "",
              targetVarName := "vf_chrono_free",
              statMeasParams := {
                statType := chrono},
              scope := FSM
            },
            {
              name := "density_free",
              providerVarName := "vf_chrono_free",
              targetVarName := "",
              statMeasParams := {
                params := {
                  density := {
                    scale := {
                      min := 0.0,
                      max := 19.0,
                      n := 20,
                      scale := linear}
                  }
                }
              },
              scope := TC
            },
            {
              name := "p95_free",
              providerVarName := "vf_chrono_free",
              targetVarName := "",
              statMeasParams := {
                params := {
                  percentile95 := {
                    scale := {
                      min := 0.0,
                      max := 29.0,
                      n := 30,
                      scale := linear}
                  }
                }
              },
              scope := TC
            }
          }}
        ,{statHandlerStatList :=  {
            {
              name := "MaxBusyTime",
              providers := {
                {statMeas := "maxChrono"}
              },
              statMethod := c_EPTF_StatHandler_Method_Max,
              statResetValue := {floatVal := 0.0},
              scope := TC
            },
            {
              name := "MeanFreeTime",
              providers := {
                {statMeas := "meanFree"}
              },
              statMethod := c_EPTF_StatHandler_Method_Mean,
              statResetValue := {floatVal := 0.0},
              scope := TC
            },
            {
              name := "AvrgFreeTime",
              providers := {
                {varList := {"vf_chrono_free", "cf_one"}}
              },
              statMethod := c_EPTF_StatHandler_Method_GlobalAverage,
              statResetValue := {floatVal := 0.0},
              scope := TC
            },
            {
              name := "Percentile95FreeTime",
              providers := {
                {statMeas := "p95_free"}
              },
              statMethod := c_EPTF_StatHandler_Method_Percentile95,
              statResetValue := {floatVal := 0.0},
              scope := TC
            },
            {
              name := "densityFreeTime",
              providers := {
                {statMeas := "density_free"}
              },
              statMethod := c_EPTF_StatHandler_Method_Density,
              statResetValue := {integerlistVal := {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}},
              scope := TC
            },
            {
              name := "NofBusy",
              providers := {
                {varList := {"vf_running"}}
              },
              statMethod := c_EPTF_StatHandler_Method_Sum,
              statResetValue := {intVal := 0},
              scope := TC
            },
            {
              name := "NofStarts",
              providers := {
                {varList := {"vf_starts"}}
              },
              statMethod := c_EPTF_StatHandler_Method_Sum,
              statResetValue := {intVal := 0},
              scope := TC
            }
          }
        }
      },
      table := { classicTable := {
          {eventToListen := {c_EPTF_LGenBase_behavior,c_EPTF_LGenBase_inputName_testMgmt_startTC,fsm},
            cellRow := {
              //state[0]==idle
              {{
                  {c_EPTF_LGenBase_stepName_timerStart,{timerName := "busyTimer"}}
                  ,{stepOrFunctionName := c_EPTF_LGenBase_stepName_fsmResetChrono, contextArgs :={statMeasName := "chrono_busy"}}
                  ,{stepOrFunctionName := c_EPTF_LGenBase_stepName_fsmStartChrono, contextArgs :={statMeasName := "chrono_busy"}}
                  ,{stepOrFunctionName := c_EPTF_LGenBase_stepName_fsmStopChrono, contextArgs :={statMeasName := "chrono_free"}}
                  ,{stepOrFunctionName := c_EPTF_LGenBase_stepName_fsmVarInc, contextArgs :={varParams := {"vf_running",{intVal := 1}}}}
                  ,{stepOrFunctionName := c_EPTF_LGenBase_stepName_fsmVarInc, contextArgs :={varParams := {"vf_starts",{intVal := 1}}}}
                },omit,"busy"}
              //state[1]==busy
              ,{omit,omit,omit}
            }
          },{eventToListen := {c_EPTF_LGenBase_specialBName_timerTimeout,"busyTimer",fsm},
            cellRow := {
              //state=idle
              {omit,omit,omit}
              //state==busy
              ,{{
                  {stepOrFunctionName := c_EPTF_LGenBase_stepName_fsmStopChrono, contextArgs :={statMeasName := "chrono_busy"}}
                  ,{stepOrFunctionName := c_EPTF_LGenBase_stepName_fsmResetChrono, contextArgs :={statMeasName := "chrono_free"}}
                  ,{stepOrFunctionName := c_EPTF_LGenBase_stepName_fsmStartChrono, contextArgs :={statMeasName := "chrono_free"}}
                  ,{stepOrFunctionName := c_EPTF_LGenBase_stepName_fsmVarDec, contextArgs :={varParams := {"vf_running",{intVal := 1}}}}
                  ,{c_EPTF_LGenBase_stepName_trafficSuccess,omit}
                }, omit,"idle"}
            }
          },{eventToListen := {c_EPTF_LGenBase_behavior,c_EPTF_LGenBase_inputName_testMgmt_stopTC,fsm},
            cellRow := {
              //state=idle
              {omit,omit,omit}
              //state==busy
              ,{{
                  {stepOrFunctionName := c_EPTF_LGenBase_stepName_timerCancelIfRunning, contextArgs :={timerName := "busyTimer"}},
                  {stepOrFunctionName := c_EPTF_LGenBase_stepName_entityStopped}
                }, omit,"idle"}
            }
          },{eventToListen := {c_EPTF_LGenBase_behavior,c_EPTF_LGenBase_inputName_testMgmt_abortTC,fsm},
            cellRow := {
              //state=idle
              {omit,omit,omit}
              //state==busy
              ,{{
                  {stepOrFunctionName := c_EPTF_LGenBase_stepName_timerCancelIfRunning, contextArgs :={timerName := "busyTimer"}}
                }, omit,"idle"}
            }
          }
        }}//table
    };

    vl_EPTF_LGenBase_FsmTableDeclarator.name := "LGenSimpleFSM outgoing";
    if(-1==f_EPTF_LGenBase_declareFSMTable(vl_EPTF_LGenBase_FsmTableDeclarator)){};

    vl_EPTF_LGenBase_FsmTableDeclarator.name := "LGenSimpleFSM incoming";
    if(-1==f_EPTF_LGenBase_declareFSMTable(vl_EPTF_LGenBase_FsmTableDeclarator)){};
  }

  // initialize the LGen
  function f_LGenSimpleFSM_init(in charstring pl_selfName, in EPTF_ExecCtrl_CT pl_ExecCtrlRef, in EPTF_UIHandler_CT pl_UIHandlerClient_DefaultUIHandler,
    in integer pl_numberOfResources := 100
  ) runs on LGenSimpleFSM_CT {

    f_EPTF_LGenBase_init(pl_selfName, 0, "LGenSimpleFSM");

    //initialize my FSM:
    f_LGenSimpleFSM_AppLib_init(pl_numberOfResources) ;      //behavior type index==0

    // my entity type is: SimpleFSM_Entity
    // number of entities is the same as c_myVirtualAppLib_numberOfResources
    var integer vl_eTypeIdx := f_EPTF_LGenBase_declareEntityType("SimpleFSM_Entity", {c_LGenSimpleFSMAppLib_behaviorType});
    //log("DEBUG: v_LGenBase_entityTypes = ", v_LGenBase_entityTypes);

    f_EPTF_ExecCtrlClient_UIHandler_init_CT(pl_selfName,pl_ExecCtrlRef,pl_UIHandlerClient_DefaultUIHandler);

    //log("DEBUG: v_LGenBase_behaviorTypes = ", v_LGenBase_behaviorTypes);

    f_EPTF_LGenBase_log();

  }

  // This is the LGen behaviour:
  function f_LGenSimpleFSM_behavior(in charstring pl_selfName, in EPTF_ExecCtrl_CT pl_ExecCtrlRef, in EPTF_UIHandler_CT pl_UIHandlerClient_DefaultUIHandler,
    in integer pl_numberOfResources := 100
  ) runs on LGenSimpleFSM_CT
  {
    log(%definitionId,": started...");

    f_LGenSimpleFSM_init(pl_selfName, pl_ExecCtrlRef,pl_UIHandlerClient_DefaultUIHandler,pl_numberOfResources);

    log(%definitionId,": entering main alt-loop...")
    f_EPTF_Base_wait4Shutdown();

    f_EPTF_Base_cleanup_CT();
    log(%definitionId,": finished...");
    setverdict(pass);
  }

  function f_EPTF_ExecCtrl_Test_HL45980_ExecCtrlBehaviour(in charstring pl_name) runs on EPTF_ExecCtrl_UIHandler_Test_CT {

    f_EPTF_ExecCtrl_setManualControl(true);

   f_EPTF_ExecCtrl_loadConfig(
      pl_EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList := tsp_EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList_HL45980,
      pl_EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList :=tsp_LGenBase_TcMgmt_tcTypeDeclarators2_HL45980,
      pl_EPTF_LGenBase_ScenarioTypeDeclaratorList := tsp_LGenBase_TcMgmt_ScenarioDeclarators3_HL45980,
      pl_EPTF_ExecCtrl_ScenarioInstanceTypeList := tsp_EPTF_ExecCtrl_Scenario2EntityGroupList_HL45980,
      pl_EPTF_ExecCtrl_LGenPool_Declarators := tsp_EPTF_ExecCtrl_LGenPool_Declarators_HL45980,
      pl_EPTF_ExecCtrl_EntityGroup2LGenPool_List := tsp_EPTF_ExecCtrl_EntityGroup2LGenPool_List_HL45980,
      pl_EPTF_ExecCtrl_PhaseList_Declarators := tsp_EPTF_ExecCtrl_PhaseList_Declarators_HL45980,
      pl_EPTF_ExecCtrl_ScenarioGroup_Declarators := tsp_EPTF_ExecCtrl_ScenarioGroup_Declarators_HL45980
    );

    var EPTF_ExecCtrl_LGenFunction_Entry_List vl_lgenCreatorFunctions := {
      {
        omit,
        refers(f_EPTF_createLGenSimpleFSM)
      }
    }

    f_EPTF_ExecCtrl_loadConfig(pl_EPTF_ExecCtrl_LGenFunction_Entry_List := vl_lgenCreatorFunctions);

    f_EPTF_UIHandlerClient_init_CT(pl_name, mtc); // default altsteps
    f_EPTF_ExecCtrl_init_CT(pl_name, 0, pl_dataSource_compRef := mtc);

    timer T_guard, T_alt;
    T_guard.start( 100.0 );
    T_alt.start( 0.0 );
    alt{
      [] T_guard.timeout{
        setverdict(fail,"Timeout during config[waitForGUIDone:checkReadyToRun]");
      }
      [f_EPTF_ExecCtrl_checkReadyToRun()] T_alt.timeout{}
    };

    f_EPTF_ExecCtrl_startAllScenarios();
    f_EPTF_Base_wait4Shutdown();
  }


} // group HL4598

group HP34819{ //UpdateActiveEntities during cleanup
  const EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList c_EntityGrpDeclaratorList_HP34819 := {
    {name := "grpHP34819", eType := "HP34819_Entity", eCount := 100}
  }

  const EPTF_ExecCtrl_ScenarioInstanceTypeList c_Scenario2EntityGroupList_HP34819 := {
    {scenarioName:="SC1", eGrpName:="grpHP34819",name:="grpHP34819.SC1"}
  };

  const EPTF_LGenBase_ScenarioTypeDeclaratorList c_ScenarioDeclarators_HP34819 := {
    {
      name := "SC1",
      tcList := {
        {
          tcName := "TC",
          tcParamsList := {
            {target := { trafficWeight := 1.0000 }},
            {enableEntitiesAtStart := false},
            {fsmList := {"LGenSimpleFSM"} }
          }
        }
      },
      scParamsList := {
        {weightedScData := {cpsToReach := 50.000000, lockCPS := false, deterministicMix := true, scheduler := omit}},
        {enabled := false}
      }
    }
  };

const EPTF_LGenBase_TcMgmt_tcTypeDeclarator2 c_TCTypeHP34819 := {
  name := "TC",
  fsmName := "LGenSimpleFSM",
  entityType := "HP34819_Entity",
  customEntitySucc := ""
}

  const   EPTF_ExecCtrl_ScenarioGroup_Declarators c_ScenarioGroup_Declarators_HP34819 := {
    {
      name := "ScGroup1",
      execMode := AUTOMATIC,
      scenarioNames := { "grpHP34819.SC1" },
      phaseListName := ""
    }
  };

  const  EPTF_ExecCtrl_LGenPool_Declarators      c_LGenPool_Declarators_HP34819 := {
    {
      name := "Pool_HP34819",
      lgenPoolItems := {
        {
          hostname := "SimpleFSM",
          num := 2,
          createFunctionName := "EPTF_ExecCtrl_Test_Functions.f_EPTF_createHP34819LGen"
        }
      }
    }
  };

  const EPTF_ExecCtrl_EntityGroup2LGenPool_List c_EntityGroup2LGenPool_List_HP34819 := {
    {
      eGrpName := "grpHP34819",
      lgenPoolName := "Pool_HP34819"
    }
  };
  type component HP34819LGen_CT extends EPTF_ExecCtrlClient_CT{
  }
  // This is the LGen behaviour:
  function f_LGenBehavior_HP34819(
    in charstring pl_selfName,
    in EPTF_ExecCtrl_CT pl_ExecCtrlRef)
  runs on EPTF_ExecCtrlClient_CT
  {
    f_EPTF_LGenBase_init(pl_selfName);
    var integer v_myBIdx:=f_EPTF_LGenBase_declareBehaviorType("LGen", -1, null, null, null);
    var integer vl_eTypeIdx := f_EPTF_LGenBase_declareEntityType("HP34819_Entity", {"LGen"});
    //initialize my FSM:
    const EPTF_LGenBase_FsmTableDeclarator c_fsm := {
      name := "LGenSimpleFSM",//"SimpleFSM",
      fsmParams := {
        {stateList := {"idle"} }},
      table := { classicTable := {}}
    }
    f_EPTF_LGenBase_declareFSMTable(c_fsm);

    f_EPTF_ExecCtrlClient_init_CT(pl_selfName,pl_ExecCtrlRef);
    f_EPTF_Logging_enableLocalMask(v_ExecCtrlClient_loggingMaskId, c_EPTF_ExecCtrl_loggingClassIdx_Debug);
    f_EPTF_Logging_registerPreambleFn(refers(f_HP34819_LoggingPreambleFn));
    f_EPTF_Base_wait4Shutdown();

    f_EPTF_Base_cleanup_CT();
    setverdict(pass);
  }
  function f_HP34819_LoggingPreambleFn(in charstring pl_message)runs on EPTF_ExecCtrlClient_CT{
    //action(%definitionId);
    if(f_EPTF_Base_cleanupIsInProgress() and (-1 < f_strstr(pl_message, "UpdateActiveEntities"))){
      setverdict ( fail, "EPTF_ExecCtrl_UpdateActiveEntities received during cleanup." );
    }
  }
  function f_EPTF_createHP34819LGen
  (
    in charstring pl_hostname,
    in charstring pl_componentName
  )
  runs on EPTF_ExecCtrl_CT
  return EPTF_ExecCtrlClient_CT {
    action(%definitionId," ",pl_componentName);
    var HP34819LGen_CT LG := HP34819LGen_CT.create;
    LG.start(f_LGenBehavior_HP34819(pl_componentName, self));
    return LG;
  }

}
//********************************************************************************************************

group Action {

  //********************************************************************************************************

  // ExecCtrl
  //=======================================================
  // f_EPTF_ExecCtrl_Test_Action_stop4FirstAction
  //=======================================================
  function f_EPTF_ExecCtrl_Test_Action_stop4FirstAction(
    in charstring pl_name,
    in integer pl_nOfClients,
    in EPTF_UIHandler_CT pl_gui,
    in EPTF_ExecCtrl_Test_HL20955Config pl_ExecCtrl_Test_ActionConfig,
    in EPTF_ExecCtrlClient_Test_CT_List pl_clients)
  runs on EPTF_ExecCtrl_UIHandler_Test_CT {

    f_EPTF_ExecCtrl_setManualControl(false);

    f_EPTF_ExecCtrl_loadConfig(
      pl_EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList := pl_ExecCtrl_Test_ActionConfig.eGroups,
      pl_EPTF_LGenBase_TcMgmt_Scenarios2GrpList := pl_ExecCtrl_Test_ActionConfig.sc2eGroups,
      pl_EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList := pl_ExecCtrl_Test_ActionConfig.tcTypes,
      pl_EPTF_ExecCtrl_TimeProfileDescrList := pl_ExecCtrl_Test_ActionConfig.timeProfileDescrList,
      pl_EPTF_ExecCtrl_TimeProfileList := pl_ExecCtrl_Test_ActionConfig.timeProfileList,
      pl_EPTF_ExecCtrl_TimeProfile2TcList := pl_ExecCtrl_Test_ActionConfig.timeProfile2TcList,
      pl_EPTF_LGenBase_ScenarioTypeDeclaratorList := pl_ExecCtrl_Test_ActionConfig.scTypes
    );

    f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients, pl_dataSource_compRef := pl_gui);


    f_EPTF_ExecCtrl_waitForCondition(refers(f_EPTF_ExecCtrl_checkReadyToRun));

    //===Measurement===
    var EPTF_IntegerList vl_counterIds:={};
    v_EPTF_ExecCtrl_Test_counters:={};
    v_EPTF_ExecCtrl_Test_counter:=0;

    for(var integer i:=0;i<sizeof(pl_clients); i:=i+1) {
      f_EPTF_Var_subscribeRemote(pl_clients[i],"ActionCounter", realtime,vl_counterIds[i]);

      f_EPTF_Var_addPostProcFn(
        vl_counterIds[i],
        {
          funcRef := refers(f_EPTF_ExecCtrl_Test_Action_pass_PostProc_stops4FirstPass),
          argList := {}
        }
      );

      v_EPTF_ExecCtrl_Test_counters[i]:=0;
    };//for

    f_EPTF_ExecCtrl_startAllScenarioGroups();

    f_EPTF_Base_wait4Shutdown();

  }//f_EPTF_ExecCtrl_Test_Action_stop4FirstAction

  //=======================================================
  // f_EPTF_ExecCtrl_Test_Action_stop4Condition
  //=======================================================
  function f_EPTF_ExecCtrl_Test_Action_stop4Condition(
    in charstring pl_name,
    in integer pl_nOfClients,
    in EPTF_UIHandler_CT pl_gui,
    in EPTF_ExecCtrl_Test_HL20955Config pl_ExecCtrl_Test_ActionConfig,
    in EPTF_ExecCtrlClient_Test_CT_List pl_clients,
    in integer pl_expectedValue:=-1)
  runs on EPTF_ExecCtrl_UIHandler_Test_CT {

    var integer vl_expectedValue;
    if(pl_expectedValue==-1) {
      vl_expectedValue:=sizeof(pl_ExecCtrl_Test_ActionConfig.scTypes)*pl_nOfClients;
    } else {
      vl_expectedValue:=pl_expectedValue;
    }

    // scenarios are started later
    f_EPTF_ExecCtrl_setManualControl(true);

    f_EPTF_ExecCtrl_loadConfig(
      pl_EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList := pl_ExecCtrl_Test_ActionConfig.eGroups,
      pl_EPTF_LGenBase_TcMgmt_Scenarios2GrpList := pl_ExecCtrl_Test_ActionConfig.sc2eGroups,
      pl_EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList := pl_ExecCtrl_Test_ActionConfig.tcTypes,
      pl_EPTF_ExecCtrl_TimeProfileDescrList := pl_ExecCtrl_Test_ActionConfig.timeProfileDescrList,
      pl_EPTF_ExecCtrl_TimeProfileList := pl_ExecCtrl_Test_ActionConfig.timeProfileList,
      pl_EPTF_ExecCtrl_TimeProfile2TcList := pl_ExecCtrl_Test_ActionConfig.timeProfile2TcList,
      pl_EPTF_LGenBase_ScenarioTypeDeclaratorList := pl_ExecCtrl_Test_ActionConfig.scTypes
    );

    f_EPTF_ExecCtrl_init_CT(pl_name, pl_nOfClients, pl_dataSource_compRef := pl_gui);

    f_EPTF_ExecCtrl_waitForCondition(refers(f_EPTF_ExecCtrl_checkReadyToRun));

    //===Measurement===
    var EPTF_IntegerList vl_counterIds:={};
    v_EPTF_ExecCtrl_Test_counters:={}; //unused
    v_EPTF_ExecCtrl_Test_counter:=0;

    for(var integer i:=0;i<sizeof(pl_clients); i:=i+1) {
      f_EPTF_Var_subscribeRemote(pl_clients[i],"ActionCounter", realtime,vl_counterIds[i]);
      f_EPTF_Var_addPostProcFn(
        vl_counterIds[i],
        {
          funcRef := refers(f_EPTF_ExecCtrl_Test_Action_pass_PostProc), //<<=== STOPS for condition
          argList := {vl_expectedValue} // number of scenarios
        }
      );

      //v_EPTF_ExecCtrl_Test_counters[i]:=0;
    };//for

    // start scenarios "manually":
    f_EPTF_ExecCtrl_startAllScenarios();

    f_EPTF_Base_wait4Shutdown();

  }//f_EPTF_ExecCtrl_Test_Action_stop4FirstAction

  //====================================================
  // f_EPTF_ExecCtrl_Test_Action_pass_PostProc
  //====================================================
  function f_EPTF_ExecCtrl_Test_Action_pass_PostProc(in integer pl_idx, in EPTF_IntegerList pl_argList)
  runs on EPTF_ExecCtrl_UIHandler_Test_CT {
    v_EPTF_ExecCtrl_Test_counter:= v_EPTF_ExecCtrl_Test_counter +1; //aggregated counter

    //log("Not used, but interesting: v_EPTF_ExecCtrl_Test_counters: ",f_EPTF_Var_getIntValue(pl_idx)); //<<==This line can be continued...
    //log("v_EPTF_ExecCtrl_Test_counter: ",v_EPTF_ExecCtrl_Test_counter);
    log("Expected counter: ", pl_argList[0], " Real counter value: ", v_EPTF_ExecCtrl_Test_counter);

    if ( v_EPTF_ExecCtrl_Test_counter == pl_argList[0]) {
      log("The counter reached the expected value. Test is passed!");
      f_EPTF_Base_stopAll(pass);
    }else {
      log("Sorry, not passed yet");
    }
  }

  //====================================================
  // f_EPTF_ExecCtrl_Test_Action_pass_PostProc_stops4FirstPass
  //====================================================
  function f_EPTF_ExecCtrl_Test_Action_pass_PostProc_stops4FirstPass(in integer pl_idx, in EPTF_IntegerList pl_argList)
  runs on EPTF_ExecCtrl_UIHandler_Test_CT {
    f_EPTF_Base_stopAll(pass);
  }
  //====================================================
  // f_EPTF_ExecCtrlClient_Test_Action_fail
  //====================================================
  function f_EPTF_ExecCtrlClient_Test_Action_fail(integer tcIdx)
  runs on EPTF_ExecCtrlClient_Test_CT {
    log(%definitionId&": ExecTime expired, not enough calls generated: test failed!");
    setverdict(fail);
    //f_EPTF_Base_stopAll(fail);
  }

  //====================================================
  // f_EPTF_ExecCtrlClient_Test_Action_pass
  // stops the test with pass after the first call
  //====================================================
  function f_EPTF_ExecCtrlClient_Test_Action_pass(integer tcIdx)
  runs on EPTF_ExecCtrlClient_Test_CT {
    log(%definitionId&": Action called!");
    var integer vl_ActionCounterId := f_EPTF_Var_getId("ActionCounter");
    var integer vl_currentValue := f_EPTF_Var_getIntValue(vl_ActionCounterId);
    f_EPTF_Var_adjustContent(vl_ActionCounterId, {intVal := vl_currentValue+1});
    //setverdict(pass);
    //f_EPTF_Base_stopAll(pass);
  }

  //====================================================
  // f_EPTF_ExecCtrlClient_Test_Action_action
  //====================================================
  function f_EPTF_ExecCtrlClient_Test_Action_action(integer tcIdx)
  runs on EPTF_ExecCtrlClient_Test_CT {
    log(%definitionId&": This function shall be called after groupFinished");
    var integer vl_ActionCounterId := f_EPTF_Var_getId("ActionCounter");
    var integer vl_currentValue := f_EPTF_Var_getIntValue(vl_ActionCounterId);
    f_EPTF_Var_adjustContent(vl_ActionCounterId, {intVal := vl_currentValue+1});
  }

  //====================================================
  // f_EPTF_ExecCtrlClient_Test_Action_customFinishCondition
  // derermines if the fraffic case is finished.
  //====================================================
  function f_EPTF_ExecCtrlClient_Test_Action_customFinishCondition(
    in integer pl_tcIdx,
    in integer pl_eIdx
  ) runs on EPTF_ExecCtrlClient_Test_CT
  return boolean {

    log(%definitionId&": This function shall be called to determine custom finish condition");
    if (pl_eIdx>20) {
      return true;
    }
    return false;
  }

  //====================================================
  // f_EPTF_ExecCtrlClient_Test_Action
  //====================================================
  function f_EPTF_ExecCtrlClient_Test_Action(
    in charstring pl_selfName,
    in EPTF_ExecCtrl_Test_CT pl_execCtrl
  )
  runs on EPTF_ExecCtrlClient_Test_CT
  {

    f_EPTF_ExecCtrlClient_Test_init(pl_selfName, pl_execCtrl, -1, false);
    f_EPTF_LGenBase_declareFunction("f_EPTF_ExecCtrlClient_Test_Action_fail",
      {customFinishFunction:=refers(f_EPTF_ExecCtrlClient_Test_Action_fail)});
    f_EPTF_LGenBase_declareFunction("f_EPTF_ExecCtrlClient_Test_Action_pass",
      {customFinishFunction:=refers(f_EPTF_ExecCtrlClient_Test_Action_pass)});
    f_EPTF_LGenBase_declareFunction("f_EPTF_ExecCtrlClient_Test_Action_action",
      {customFinishFunction:=refers(f_EPTF_ExecCtrlClient_Test_Action_action)});

    f_EPTF_LGenBase_declareFunction("f_EPTF_ExecCtrlClient_Test_Action_customFinishCondition",
      {customFinishCondition:=refers(f_EPTF_ExecCtrlClient_Test_Action_customFinishCondition)});

    var integer vl_scenFinishCounterId:=-1;
    f_EPTF_Var_newInt("ScenFinishCounter",0, vl_scenFinishCounterId);


    var integer vl_ActionCounterId:=-1;
    f_EPTF_Var_newInt("ActionCounter",0, vl_ActionCounterId);

    f_EPTF_ExecCtrlClient_readyToStart();

    f_EPTF_Base_wait4Shutdown();
  }

} // Action

group SetTargetCPSInAutoOff {

  function f_ExecCtrl_Regulator_Test_RegulatorBehaviour(
    in charstring pl_selfName,
    in EPTF_ExecCtrl_CT pl_execCtrlCompRef,
    in float pl_loadToReach := 0.0
  ) runs on EPTF_LoadRegulator_CT {
    f_EPTF_LoadRegulator_init_CT(pl_selfName,
      refers(f_EPTF_ExecCtrl_Test_PhaseRegulator_getSutLoad),
      refers(f_EPTF_LoadRegulator_calculateNextCps_limitMax));
    f_EPTF_LoadRegulator_registerToExecCtrl(pl_execCtrlCompRef);
    f_EPTF_LoadRegulator_adjustTargetLoadInExecCtrl(pl_loadToReach);
    f_EPTF_Base_wait4Shutdown();
  }

} //~group SetTargetCPSInAutoOff

group HL79051 {

  function f_EPTF_ExecCtrl_HL79051LGenBehaviour(
    in charstring pl_name,
    in EPTF_ExecCtrl_CT pl_execCtrlCompRef)
  runs on EPTF_ExecCtrlClient_CT {
    f_EPTF_LGenBase_init(pl_name);
    f_EPTF_LGenBase_declareBehaviorType(c_EPTF_ExecCtrl_Test_defaultBehaviorName, -1, null, null, null);
    f_EPTF_LGenBase_declareEntityType(c_EPTF_ExecCtrl_Test_defaultETypeName, {c_EPTF_ExecCtrl_Test_defaultBehaviorName});
    f_EPTF_LGenBase_declareFSMTable(c_EPTF_ExecCtrl_Test_defaultFSM);
    f_EPTF_ExecCtrlClient_init_CT(pl_name, pl_execCtrlCompRef);
    timer t_changeCPS := 10.0;
    t_changeCPS.start(0.0);

    // wait until GUI is ready:
    alt {
      [f_EPTF_ExecCtrlClient_checkGuiDone()] t_changeCPS.timeout {
        t_changeCPS.start(0.0);
      }
    }

    // wait until traffic case is running:
    var charstring vl_eGrpName := c_EPTF_ExecCtrl_DefaultScenarios_eGrpName;
    var charstring vl_scName := c_EPTF_ExecCtrl_DefaultScenarios_scNameNormal;
    var charstring vl_wscName := c_EPTF_ExecCtrl_DefaultScenarios_scNameWeighted;
    var charstring vl_tcName := c_EPTF_ExecCtrl_DefaultScenarios_tcNameTc2;
    var charstring vl_varName := "ExecCtrlClient.trafficCaseStatus."&vl_eGrpName&"."&vl_scName&"."&vl_tcName;
    var integer vl_tcStateVarIdx := f_EPTF_Var_getId(vl_varName);
    alt {
      [f_EPTF_Var_getCharstringValue(vl_tcStateVarIdx)==c_EPTF_LGenBase_stateNames[c_EPTF_LGenBase_tcStateRunning]] t_changeCPS.timeout {
      }
    }
    t_changeCPS.start(10.0); // wait 10 secs after CPS is running
    alt {
      [] t_changeCPS.timeout {
        // update the CPS:
        f_EPTF_LGenBase_setCPSByNames(vl_eGrpName,vl_scName,vl_tcName,2.0);
        f_EPTF_LGenBase_setScenarioCPS(vl_eGrpName,vl_wscName,3.0);
      }
    }

    t_changeCPS.start(10.0); // wait 10 secs after CPS was changed
    // check if the CPS stays the same:
    alt {
      [] t_changeCPS.timeout {
        // check the CPS:
        if (2.0 != f_EPTF_LGenBase_getTcCpsToReachByName(vl_eGrpName,vl_scName,vl_tcName)) {
          setverdict(fail,"Unexpected CPS value (",f_EPTF_LGenBase_getTcCpsToReachByName(vl_eGrpName,vl_scName,vl_tcName),
            ") while regulator is disconnected. Expected value: 2.0");
        }
        else {
          setverdict(pass);
        }
        // check the CPS in the weighted sc:
        if (3.0 != f_EPTF_LGenBase_getScCpsSoReachByName(vl_eGrpName,vl_wscName)) {
          setverdict(fail,"Unexpected Scenario CPS value (",f_EPTF_LGenBase_getScCpsSoReachByName(vl_eGrpName,vl_wscName),
            ") while regulator is disconnected. Expected value: 3.0");
        }
        else {
          setverdict(pass);
        }
      }
    }

    f_EPTF_Base_wait4Shutdown();
  }

  function f_ExecCtrl_Test_createHL79051LGen  (
    in charstring pl_hostname,
    in charstring pl_componentName
  ) runs on EPTF_ExecCtrl_CT return EPTF_ExecCtrlClient_CT
  {
    var EPTF_ExecCtrlClient_CT vl_lgen := EPTF_ExecCtrlClient_CT.create;
    vl_lgen.start( f_EPTF_ExecCtrl_HL79051LGenBehaviour("ExecCtrl_HL79051LGen_"&log2str(vl_lgen),self) );
    return vl_lgen;
  }

} //~group HL79051

group CR_TR00017092 {

  function f_ExecCtrl_Test_createLGenWithLimitedEntities  (
    in charstring pl_hostname,
    in charstring pl_componentName
  ) runs on EPTF_ExecCtrl_CT return EPTF_ExecCtrlClient_CT
  {
    var EPTF_ExecCtrlClient_CT vl_lgen := EPTF_ExecCtrlClient_CT.create;
    vl_lgen.start( f_EPTF_ExecCtrl_LGenWithLimitedEntitiesBehaviour(pl_componentName,self) );
    return vl_lgen;
  }

  function f_EPTF_ExecCtrl_LGenWithUnLimitedEntitiesBehaviour  (
    in charstring pl_hostname,
    in charstring pl_componentName
  ) runs on EPTF_ExecCtrl_CT return EPTF_ExecCtrlClient_CT
  {
    var EPTF_ExecCtrlClient_CT vl_lgen := EPTF_ExecCtrlClient_CT.create;
    vl_lgen.start( f_EPTF_ExecCtrl_CLITest_defaultLGenBehaviour(pl_componentName,self) );
    return vl_lgen;
  }


  function f_EPTF_ExecCtrl_LGenWithLimitedEntitiesBehaviour(
    in charstring pl_name,
    in EPTF_ExecCtrl_CT pl_execCtrlCompRef)
  runs on EPTF_ExecCtrlClient_CT {
    f_EPTF_LGenBase_init(pl_name);
    f_EPTF_LGenBase_declareBehaviorType(c_EPTF_ExecCtrl_Test_defaultBehaviorName, 20, null, null, null);
    f_EPTF_LGenBase_declareEntityType(c_EPTF_ExecCtrl_Test_defaultETypeName, {c_EPTF_ExecCtrl_Test_defaultBehaviorName});
    f_EPTF_LGenBase_declareFSMTable(c_EPTF_ExecCtrl_Test_defaultFSM);
    f_EPTF_ExecCtrlClient_init_CT(pl_name, pl_execCtrlCompRef);
    f_EPTF_Base_wait4Shutdown();
  }

} //~group CR_TR00017092

group LoadConfigFromClient {

  function f_EPTF_ExecCtrl_LoadConfigFromClient_behaviour(
    in charstring pl_name,
    in EPTF_ExecCtrl_CT pl_execCtrlCompRef)
  runs on EPTF_ExecCtrlClient_CT {
    f_EPTF_LGenBase_init(pl_name);
    f_EPTF_LGenBase_declareBehaviorType(c_EPTF_ExecCtrl_Test_defaultBehaviorName, -1, null, null, null);
    f_EPTF_LGenBase_declareEntityType(c_EPTF_ExecCtrl_Test_defaultETypeName, {c_EPTF_ExecCtrl_Test_defaultBehaviorName});
    f_EPTF_LGenBase_declareFSMTable(c_EPTF_ExecCtrl_Test_defaultFSM);
    f_EPTF_ExecCtrlClient_init_CT(pl_name, pl_execCtrlCompRef,pl_reportReady:=false);

    f_EPTF_ExecCtrlClient_loadConfig(
      pl_EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList := c_EPTF_ExecCtrl_DefaultScenarios_EGrpList,
      pl_EPTF_LGenBase_TcMgmt_Scenarios2GrpList := c_EPTF_ExecCtrl_DefaultScenarios_Scenarios2GrpList&
      c_EPTF_ExecCtrl_DefaultScenarios_Scenarios2GrpList_scGroups,
      pl_EPTF_LGenBase_ScenarioDeclaratorList := {},
      pl_EPTF_LGenBase_tcTypeDeclaratorList := {},
      pl_EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList := {c_EPTF_ExecCtrl_DefaultScenarios_defaultTCType},
      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:= {
        c_EPTF_ExecCtrl_DefaultScenarios_normalScenario,c_EPTF_ExecCtrl_DefaultScenarios_weightedScenario,
        c_EPTF_ExecCtrl_DefaultScenarios_normalScenarioInScGrp,c_EPTF_ExecCtrl_DefaultScenarios_weightedScenarioInScGrp
      },
      pl_EPTF_ExecCtrl_ScenarioInstanceTypeList:={},
      pl_EPTF_ExecCtrl_LGenPool_Declarators:=c_EPTF_ExecCtrl_Test_defaultLGenPool_Declarators,
      pl_EPTF_ExecCtrl_EntityGroup2LGenPool_List:=c_EPTF_ExecCtrl_DefaultScenarios_EntityGroup2LGenPool_List,
      //     pl_EPTF_ExecCtrl_LGenFunction_Entry_List:={{
      //       name := omit,
      //       fn := refers(f_ExecCtrl_Test_createDefaultLGen)
      //     }},
      pl_EPTF_ExecCtrl_PhaseList_Declarators:=c_EPTF_ExecCtrl_DefaultScenarios_phases,
      pl_EPTF_ExecCtrl_ScenarioGroup_Declarators:=c_EPTF_ExecCtrl_DefaultScenarios_scGroups,
      pl_EPTF_ExecCtrl_RegulatorNames:={c_EPTF_ExecCtrl_DefaultRegulatorName},
      pl_EPTF_ExecCtrl_RegulatedItems:=c_EPTF_ExecCtrl_DefaultRegulatedItems
    );

    f_EPTF_ExecCtrlClient_loadConfig(
      pl_EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList := {{
          name := "LoadedGroup",
          eType := c_EPTF_ExecCtrl_Test_defaultETypeName,
          eCount := 100
        }},
      pl_EPTF_LGenBase_TcMgmt_Scenarios2GrpList := {
        {
          eGrpName := "LoadedGroup",
          scenarioNames := {
            c_EPTF_ExecCtrl_DefaultScenarios_scNameNormal
          }
        },
        {
          eGrpName := "LoadedGroup",
          scenarioNames := {
            c_EPTF_ExecCtrl_DefaultScenarios_scNameWeighted
          }
        }
      }
    );
    f_EPTF_ExecCtrlClient_readyToStart();
    f_EPTF_Base_wait4Shutdown();
  }

  // load config after ready to start behaviour:
  function f_EPTF_ExecCtrl_LoadConfigFromClientAfterStart_behaviour(
    in charstring pl_name,
    in EPTF_ExecCtrl_CT pl_execCtrlCompRef)
  runs on EPTF_ExecCtrlClient_CT {
    f_EPTF_LGenBase_init(pl_name);
    f_EPTF_LGenBase_declareBehaviorType(c_EPTF_ExecCtrl_Test_defaultBehaviorName, -1, null, null, null);
    f_EPTF_LGenBase_declareEntityType(c_EPTF_ExecCtrl_Test_defaultETypeName, {c_EPTF_ExecCtrl_Test_defaultBehaviorName});
    f_EPTF_LGenBase_declareFSMTable(c_EPTF_ExecCtrl_Test_defaultFSM);
    f_EPTF_ExecCtrlClient_init_CT(pl_name, pl_execCtrlCompRef,pl_reportReady:=false);

    f_EPTF_ExecCtrlClient_readyToStart();

    // this will generate a warning:
    f_EPTF_ExecCtrlClient_loadConfig(
      pl_EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList := {{
          name := "EGrpLoadedAfterStartInClient",
          eType := c_EPTF_ExecCtrl_Test_defaultETypeName,
          eCount := c_EPTF_ExecCtrl_DefaultScenarios_eGrpSize
        }}
    );
    f_EPTF_Base_wait4Shutdown();
  }


  // load config from pool LGen behaviour
  function f_EPTF_ExecCtrl_loadConfigFromLGenBehaviour(
    in charstring pl_name,
    in EPTF_ExecCtrl_CT pl_execCtrlCompRef)
  runs on EPTF_ExecCtrlClient_CT {
    f_EPTF_LGenBase_init(pl_name);
    f_EPTF_LGenBase_declareBehaviorType(c_EPTF_ExecCtrl_Test_defaultBehaviorName, -1, null, null, null);
    f_EPTF_LGenBase_declareEntityType(c_EPTF_ExecCtrl_Test_defaultETypeName, {c_EPTF_ExecCtrl_Test_defaultBehaviorName});
    f_EPTF_LGenBase_declareFSMTable(c_EPTF_ExecCtrl_Test_defaultFSM);
    f_EPTF_ExecCtrlClient_init_CT(pl_name, pl_execCtrlCompRef,pl_reportReady:=false);

    // this should generate a warning:
    f_EPTF_ExecCtrlClient_loadConfig(
      pl_EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList := {{
          name := "LoadedGroupFromPool",
          eType := c_EPTF_ExecCtrl_Test_defaultETypeName,
          eCount := 100
        }},
      pl_EPTF_LGenBase_TcMgmt_Scenarios2GrpList := {
        {
          eGrpName := "LoadedGroupFromPool",
          scenarioNames := {
            c_EPTF_ExecCtrl_DefaultScenarios_scNameNormal
          }
        },
        {
          eGrpName := "LoadedGroupFromPool",
          scenarioNames := {
            c_EPTF_ExecCtrl_DefaultScenarios_scNameWeighted
          }
        }
      },
      pl_EPTF_ExecCtrl_EntityGroup2LGenPool_List:={
        {
          eGrpName := "LoadedGroupFromPool",
          lgenPoolName := "LoadConfigInPool"
        }
      }
    );
    f_EPTF_ExecCtrlClient_readyToStart();
    f_EPTF_Base_wait4Shutdown();
  }


  external function f_EPTF_runTop() return float

  function f_ExecCtrl_Test_createLoadConfigLGen  (
    in charstring pl_hostname,
    in charstring pl_componentName
  ) runs on EPTF_ExecCtrl_CT return EPTF_ExecCtrlClient_CT
  {
    var EPTF_ExecCtrlClient_CT vl_lgen := EPTF_ExecCtrlClient_CT.create;
    vl_lgen.start( f_EPTF_ExecCtrl_loadConfigFromLGenBehaviour("ExecCtrl_LoadConfigFromPool_"&log2str(vl_lgen),self) );
    return vl_lgen;
  }

} //group LoadConfigFromClient

group TerminateClientBeforeStart {

  function f_EPTF_ExecCtrl_TerminateClientBeforeStart_behaviour(
    in charstring pl_name,
    in EPTF_ExecCtrl_CT pl_execCtrlCompRef,
    in boolean pl_stopAll := true)
  runs on EPTF_ExecCtrlClient_CT {
    f_EPTF_LGenBase_init(pl_name);
    f_EPTF_LGenBase_declareBehaviorType(c_EPTF_ExecCtrl_Test_defaultBehaviorName, -1, null, null, null);
    f_EPTF_LGenBase_declareEntityType(c_EPTF_ExecCtrl_Test_defaultETypeName, {c_EPTF_ExecCtrl_Test_defaultBehaviorName});
    f_EPTF_LGenBase_declareFSMTable(c_EPTF_ExecCtrl_Test_defaultFSM);
    f_EPTF_ExecCtrlClient_init_CT(pl_name, pl_execCtrlCompRef,pl_reportReady:=false);

    f_EPTF_ExecCtrlClient_loadConfig(
      pl_EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList := c_EPTF_ExecCtrl_DefaultScenarios_EGrpList,
      pl_EPTF_LGenBase_TcMgmt_Scenarios2GrpList := c_EPTF_ExecCtrl_DefaultScenarios_Scenarios2GrpList&
      c_EPTF_ExecCtrl_DefaultScenarios_Scenarios2GrpList_scGroups,
      pl_EPTF_LGenBase_ScenarioDeclaratorList := {},
      pl_EPTF_LGenBase_tcTypeDeclaratorList := {},
      pl_EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList := {c_EPTF_ExecCtrl_DefaultScenarios_defaultTCType},
      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:= {
        c_EPTF_ExecCtrl_DefaultScenarios_normalScenario,c_EPTF_ExecCtrl_DefaultScenarios_weightedScenario,
        c_EPTF_ExecCtrl_DefaultScenarios_normalScenarioInScGrp,c_EPTF_ExecCtrl_DefaultScenarios_weightedScenarioInScGrp
      },
      pl_EPTF_ExecCtrl_ScenarioInstanceTypeList:={},
      pl_EPTF_ExecCtrl_LGenPool_Declarators:=c_EPTF_ExecCtrl_Test_defaultLGenPool_Declarators,
      pl_EPTF_ExecCtrl_EntityGroup2LGenPool_List:=c_EPTF_ExecCtrl_DefaultScenarios_EntityGroup2LGenPool_List,
      //     pl_EPTF_ExecCtrl_LGenFunction_Entry_List:={{
      //       name := omit,
      //       fn := refers(f_ExecCtrl_Test_createDefaultLGen)
      //     }},
      pl_EPTF_ExecCtrl_PhaseList_Declarators:=c_EPTF_ExecCtrl_DefaultScenarios_phases,
      pl_EPTF_ExecCtrl_ScenarioGroup_Declarators:=c_EPTF_ExecCtrl_DefaultScenarios_scGroups,
      pl_EPTF_ExecCtrl_RegulatorNames:={c_EPTF_ExecCtrl_DefaultRegulatorName},
      pl_EPTF_ExecCtrl_RegulatedItems:=c_EPTF_ExecCtrl_DefaultRegulatedItems
    );

    f_EPTF_ExecCtrlClient_loadConfig(
      pl_EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList := {{
          name := "LoadedGroup",
          eType := c_EPTF_ExecCtrl_Test_defaultETypeName,
          eCount := 100
        }},
      pl_EPTF_LGenBase_TcMgmt_Scenarios2GrpList := {
        {
          eGrpName := "LoadedGroup",
          scenarioNames := {
            c_EPTF_ExecCtrl_DefaultScenarios_scNameNormal
          }
        },
        {
          eGrpName := "LoadedGroup",
          scenarioNames := {
            c_EPTF_ExecCtrl_DefaultScenarios_scNameWeighted
          }
        }
      }
    );
    f_EPTF_ExecCtrlClient_readyToStart();
    if (pl_stopAll) {
      f_EPTF_Base_stopAll(pass);
    } else {
      f_EPTF_Base_stop(pass);
    }
    f_EPTF_Base_wait4Shutdown();
  }

} // group TerminateClientBeforeStart

group EPTF_ExecCtrl_GUIVars_Test {

  type component EPTF_ExecCtrl_GUIVars_Test_CT extends EPTF_UIHandler_CLI_CT, EPTF_ExecCtrl_UIHandler_CT {
  }

  function f_ExecCtrl_Test_GUIVars_additionalTab() runs on EPTF_ExecCtrl_GUIVars_Test_CT {
    var Tabpage v_additionalTab := {
        id := "AdditionalTab",
        label_ := "AdditionalTab"
    };
    if(sr_Fail == f_EPTF_UIHandlerClient_XSD_addElementToGUI(
        {tabpage := v_additionalTab},
        c_EPTF_GUI_Main_Tabbox_WidgetId)) {
      log(log2str(%definitionId, ": cannot add element to gui: ", v_additionalTab));
    }

    const charstring c_EPTF_ExecCtrl_AddRemoveExecCtrlGUI := "c_EPTF_ExecCtrl_AddRemoveExecCtrlGUI";
    const charstring c_EPTF_ExecCtrl_AddRemoveExecCtrlGUI2 := "c_EPTF_ExecCtrl_AddRemoveExecCtrlGUI2";
    var Button vl_xml :=
    {
        checked     := omit,//BOOLEAN OPTIONAL,
        disabled    := true,
        //disabledongui := false,
        flex		:= 1.0,
        id          := c_EPTF_ExecCtrl_AddRemoveExecCtrlGUI2,
        //imageid   := omit,
        imageid     := omit,//"image_play"
        label_      := "Add/Remove ExecCtrl GUI",
        type_       := omit
    }
    if(log2str(f_EPTF_UIHandlerClient_XSD_addElementToGUI({button := vl_xml}, "AdditionalTab"))=="fail")
    {
      log(log2str(%definitionId, ": cannot add element to gui: ", vl_xml));
    }

    f_EPTF_UIHandlerClient_subscribeMe(
      c_EPTF_ExecCtrl_AddRemoveExecCtrlGUI,
      "GUI." & c_EPTF_ExecCtrl_AddRemoveExecCtrlGUI2,
      c_EPTF_ExecCtrl_AddRemoveExecCtrlGUI2,
      realtime);

    f_EPTF_UIHandlerClient_enableGUIElement(
      c_EPTF_ExecCtrl_AddRemoveExecCtrlGUI2);


  }


} // group EPTF_ExecCtrl_GUIVars_Test

function f_EPTF_ExecCtrl_Test_DataSourceClientReady(
  in charstring pl_source,
  in charstring pl_ptcName)
runs on myMTC_UI{
  if (pl_source==c_ExecCtrl_DataSource_sourceId) {
    v_ready := true;
  }
}


function f_EPTF_ExecCtrl_Test_simpleBehavior(in EPTF_DataSource_CT pl_dataSource, in charstring pl_selfName)
runs on EPTF_ExecCtrl_Test_CT{
  f_EPTF_ExecCtrl_loadConfig(
    pl_EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList := c_EPTF_ExecCtrl_DefaultScenarios_EGrpList,
    pl_EPTF_LGenBase_TcMgmt_Scenarios2GrpList := c_EPTF_ExecCtrl_DefaultScenarios_Scenarios2GrpList&
    c_EPTF_ExecCtrl_DefaultScenarios_Scenarios2GrpList_scGroups,
    pl_EPTF_LGenBase_ScenarioDeclaratorList := {},
    pl_EPTF_LGenBase_tcTypeDeclaratorList := {},
    pl_EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList := {c_EPTF_ExecCtrl_DefaultScenarios_defaultTCType},
    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:= {
      c_EPTF_ExecCtrl_DefaultScenarios_normalScenario,c_EPTF_ExecCtrl_DefaultScenarios_weightedScenario,
      c_EPTF_ExecCtrl_DefaultScenarios_normalScenarioInScGrp,c_EPTF_ExecCtrl_DefaultScenarios_weightedScenarioInScGrp
    },
    pl_EPTF_ExecCtrl_ScenarioInstanceTypeList:={},
    pl_EPTF_ExecCtrl_LGenPool_Declarators:=c_EPTF_ExecCtrl_Test_defaultLGenPool_Declarators,
    pl_EPTF_ExecCtrl_EntityGroup2LGenPool_List:=c_EPTF_ExecCtrl_DefaultScenarios_EntityGroup2LGenPool_List,
    pl_EPTF_ExecCtrl_LGenFunction_Entry_List:={{
        name := omit,
        fn := refers(f_ExecCtrl_Test_createDefaultLGen)
      }},
    pl_EPTF_ExecCtrl_PhaseList_Declarators:=c_EPTF_ExecCtrl_DefaultScenarios_phases,
    pl_EPTF_ExecCtrl_ScenarioGroup_Declarators:=c_EPTF_ExecCtrl_DefaultScenarios_scGroups
  );

  f_EPTF_ExecCtrl_setManualControl(false);

  f_EPTF_ExecCtrl_init_CT(
    pl_selfName := pl_selfName,
    pl_nrOfClients :=0,
    pl_dataSource_compRef := pl_dataSource);

  f_EPTF_Base_wait4Shutdown();
}

function f_EPTF_ExecCtrl_Test_simpleBehaviorWithoutPhases(in EPTF_DataSource_CT pl_dataSource, in charstring pl_selfName)
runs on EPTF_ExecCtrl_Test_CT{
  f_EPTF_ExecCtrl_loadConfig(
    pl_EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList := c_EPTF_ExecCtrl_DefaultScenarios_EGrpList,
    pl_EPTF_LGenBase_TcMgmt_Scenarios2GrpList := c_EPTF_ExecCtrl_DefaultScenarios_Scenarios2GrpList,//&
    //c_EPTF_ExecCtrl_DefaultScenarios_Scenarios2GrpList_scGroups,
    pl_EPTF_LGenBase_ScenarioDeclaratorList := {},
    pl_EPTF_LGenBase_tcTypeDeclaratorList := {},
    pl_EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList := {c_EPTF_ExecCtrl_DefaultScenarios_defaultTCType},
    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:= {
      c_EPTF_ExecCtrl_DefaultScenarios_normalScenario,c_EPTF_ExecCtrl_DefaultScenarios_weightedScenario
      //c_EPTF_ExecCtrl_DefaultScenarios_normalScenarioInScGrp,c_EPTF_ExecCtrl_DefaultScenarios_weightedScenarioInScGrp
    },
    pl_EPTF_ExecCtrl_ScenarioInstanceTypeList:={},
    pl_EPTF_ExecCtrl_LGenPool_Declarators:=c_EPTF_ExecCtrl_Test_defaultLGenPool_Declarators,
    pl_EPTF_ExecCtrl_EntityGroup2LGenPool_List:=c_EPTF_ExecCtrl_DefaultScenarios_EntityGroup2LGenPool_List,
    pl_EPTF_ExecCtrl_LGenFunction_Entry_List:={{
        name := omit,
        fn := refers(f_ExecCtrl_Test_createDefaultLGen)
      }}
    //pl_EPTF_ExecCtrl_PhaseList_Declarators:=c_EPTF_ExecCtrl_DefaultScenarios_phases,
    //pl_EPTF_ExecCtrl_ScenarioGroup_Declarators:=c_EPTF_ExecCtrl_DefaultScenarios_scGroups
  );

  f_EPTF_ExecCtrl_setManualControl(false);

  f_EPTF_ExecCtrl_init_CT(
    pl_selfName := pl_selfName,
    pl_nrOfClients :=0,
    pl_dataSource_compRef := pl_dataSource);

  f_EPTF_Base_wait4Shutdown();
}

public function f_EPTF_ExecCtrl_Test_getFinalReport() runs on EPTF_ExecCtrl_CT return charstring{
  return v_EPTF_ExecCtrl_finalTestReport;
}

group EPTF_ExecCtrl_Test_SmallCPSDistribution {

  public function f_EPTF_ExecCtrl_Test_SmallCPSDistribution_execute(
    in integer pl_nofLGens,
    in EPTF_UIHandler_CT pl_gui,
    in charstring pl_eGrpName,
    in charstring pl_scName,
    in charstring pl_tcName,
    in EPTF_FloatList pl_targetCPSList,
    in integer pl_nofVarRefresh := c_EPTF_ExecCtrl_Test_SmallCPSDistribution_nofVarRefresh,
    in integer pl_nofLGenRefresh := c_EPTF_ExecCtrl_Test_SmallCPSDistribution_nofLGenRefresh,
    in EPTF_ExecCtrl_CreateLGen_FT pl_createLGenFn := refers(f_ExecCtrl_Test_createDefaultLGen)
  ) runs on ExecCtrl_Test_SmallCPSDistribution_CT
  {
    var charstring vl_wndLayout := c_EPTF_ExecCtrl_Test_defaultMainWindow_str;
    f_EPTF_UIHandlerXUL_init_CT("SmallCPSDistribution", true, vl_wndLayout);
    f_EPTF_ExecCtrl_loadConfig(
      pl_EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList := c_EPTF_ExecCtrl_DefaultScenarios_EGrpList,
      pl_EPTF_LGenBase_TcMgmt_Scenarios2GrpList := c_EPTF_ExecCtrl_DefaultScenarios_Scenarios2GrpList,
      pl_EPTF_LGenBase_ScenarioDeclaratorList := {},
      pl_EPTF_LGenBase_tcTypeDeclaratorList := {},
      pl_EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList := {c_EPTF_ExecCtrl_DefaultScenarios_defaultTCType},
      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:= {
        c_EPTF_ExecCtrl_DefaultScenarios_normalScenario,c_EPTF_ExecCtrl_DefaultScenarios_weightedScenario
      },
      pl_EPTF_ExecCtrl_ScenarioInstanceTypeList:={},
      pl_EPTF_ExecCtrl_LGenPool_Declarators:={
        {
          name := c_EPTF_ExecCtrl_Test_defaultLGenPoolName,
          lgenPoolItems := {
            {
              hostname := "localhost",
              num := pl_nofLGens,
              createFunctionName := substr(log2str(pl_createLGenFn),7,lengthof(log2str(pl_createLGenFn))-8)
            }
          }
        }
      },
      pl_EPTF_ExecCtrl_EntityGroup2LGenPool_List:=c_EPTF_ExecCtrl_DefaultScenarios_EntityGroup2LGenPool_List,
      pl_EPTF_ExecCtrl_LGenFunction_Entry_List:={{
          name := omit,
          fn := pl_createLGenFn
        }},
      pl_EPTF_ExecCtrl_RegulatorNames:={},
      pl_EPTF_ExecCtrl_RegulatedItems:={}
    );
    f_EPTF_ExecCtrl_setManualControl(true);

    f_EPTF_ExecCtrl_init_CT(f_EPTF_Base_selfName(), pl_nrOfClients := 0, pl_dataSource_compRef := pl_gui);
    f_EPTF_StatMeasure_init_CT("SmallCPSDistribution");

    timer T_guard, T_alt;
    T_guard.start( 100.0 );
    T_alt.start( 0.0 );
    alt{
      [] T_guard.timeout{
        setverdict(fail,"Timeout during config");
        f_EPTF_Base_stopAll();
      }
      [f_EPTF_ExecCtrl_checkReadyToRun()] T_alt.timeout{}
    };


    // start the scenarios, but ignore the initial transient
    //f_EPTF_ExecCtrl_startAllScenarios();
    if (pl_tcName=="") {
      f_EPTF_ExecCtrl_startScenarioOnLGensByName(pl_eGrpName,pl_scName);
    } else {
      var integer vl_scIdx := f_EPTF_ExecCtrl_getScenarioIdx(pl_eGrpName,pl_scName);
      var integer vl_tcIdx := f_EPTF_ExecCtrl_getTrafficCaseIdx(pl_eGrpName,pl_scName,pl_tcName)
      var integer vl_tcOfScIdx := f_EPTF_ExecCtrl_getTcOfScenarioIdx(vl_tcIdx);
      f_EPTF_ExecCtrl_startTCOnLGens(vl_scIdx,vl_tcOfScIdx);
    }
    timer t_wait;
    t_wait.start(f_EPTF_Var_getRefreshPeriod(0)*2.0+1.0); t_wait.timeout;

    for(var integer i:=0; i<sizeof(pl_targetCPSList); i:=i+1) {
      f_ExecCtrl_Test_SmallCPSDistribution_measure(
        pl_eGrpName := pl_eGrpName,
        pl_scName := pl_scName,
        pl_tcName := pl_tcName,
        pl_targetCps := pl_targetCPSList[i],
        pl_nofLGens := pl_nofLGens,
        pl_nofVarRefresh := pl_nofVarRefresh,
        pl_nofLGenRefresh := pl_nofLGenRefresh
      );
    }

    f_EPTF_Base_cleanup_CT();
  }


  public function f_EPTF_ExecCtrl_Test_SmallCPSDistribution_startTest_PostProc(
    //  in EPTF_IntegerList pl_argList)
    in integer pl_idx,
    in EPTF_IntegerList pl_argList)
  runs on ExecCtrl_Test_SmallCPSDistribution_CT
  {
    vl_startTest :=true;
  }

  public function f_EPTF_ExecCtrl_Test_SmallCPSDistribution_addData_EPS_PostProc(
    in integer pl_idx,
    in EPTF_IntegerList pl_argList)
  runs on ExecCtrl_Test_SmallCPSDistribution_CT
  {
    //action("AAAA, delta: ", f_EPTF_Var_getIntValue(pl_idx));
    f_EPTF_Base_assert("Invalid size",
      sizeof(pl_argList)==1);

    var integer pl_statIdx := pl_argList[0];

    f_EPTF_StatMeasure_addData_EPS(pl_statIdx, f_EPTF_Var_getIntValue(pl_idx));
    f_EPTF_StatMeasure_update_EPS(pl_statIdx);

    var float currentEPS;
    f_EPTF_StatMeasure_getStat_EPS(pl_statIdx,currentEPS);
    //action("Current EPS: ", currentEPS);

    f_EPTF_StatMeasure_resetStat_EPS(pl_statIdx);
    f_EPTF_StatMeasure_startMeasurement_EPS(pl_statIdx);
  }

  function f_ExecCtrl_Test_SmallCPSDistribution_measure(
    in charstring pl_eGrpName,
    in charstring pl_scName,
    in charstring pl_tcName,
    in float pl_targetCps,
    in integer pl_nofLGens,
    in integer pl_nofVarRefresh := c_EPTF_ExecCtrl_Test_SmallCPSDistribution_nofVarRefresh,
    in integer pl_nofLGenRefresh := c_EPTF_ExecCtrl_Test_SmallCPSDistribution_nofLGenRefresh
  ) runs on ExecCtrl_Test_SmallCPSDistribution_CT {

    //get the id of the scenario:
    var integer vl_scIdx := f_EPTF_ExecCtrl_getScenarioIdx(pl_eGrpName,pl_scName);
    if (f_EPTF_ExecCtrl_isWeightedScenario(vl_scIdx)) {
      if (pl_targetCps!=10.0) {
        //action("SC CPS is set to: ", pl_targetCps);
        f_EPTF_ExecCtrl_setCPSToReach_SC(vl_scIdx,pl_targetCps);
      }
    } else {
      // get the Id of the traffic case:
      var integer vl_tcIdx := f_EPTF_ExecCtrl_getTrafficCaseIdx(pl_eGrpName,pl_scName,pl_tcName);
      // only set CPS if it differs from original
      if (pl_targetCps!=10.0) {
        //action("TC CPS is set to: ", pl_targetCps);
        f_EPTF_ExecCtrl_setCPSToReach_TC(vl_tcIdx,pl_targetCps);
      }
    }

    // create standardDev stat for CPS:
    var charstring vl_cpsVarName;
    f_EPTF_DataSource_getData(
      vl_cpsVarName,
      c_ExecCtrl_DataSource_sourceId,"",
      c_ExecCtrl_dataElementTcStat,
      {
        {c_ExecCtrl_paramNameEntityGroup,pl_eGrpName},
        {c_ExecCtrl_paramNameScenario,pl_scName},
        {c_ExecCtrl_paramNameTrafficCase,pl_tcName},
        {c_ExecCtrl_paramNameStatistic,c_EPTF_ExecCtrl_tcStatNames[c_EPTF_ExecCtrl_tcStatId_CurrentCPS]}
      }
    );
    var integer vl_cpsVarId := f_EPTF_Var_getId(vl_cpsVarName);
    //  var integer vl_standardDevStatId := f_EPTF_StatMeasure_newStat_standardDev(vl_cpsVarId);
    var integer vl_standardDevStatId := f_EPTF_StatMeasure_newStat_standardDev();
    if (vl_cpsVarId==-1) {
      setverdict(fail,"CPS stat not found!");
      f_EPTF_Base_stopAll();
    }
    var float m,s;
    var integer vl_n_varId := f_EPTF_StatMeasure_createVarFromStat_N_standardDev(vl_standardDevStatId);
    var float currentCPS;
    var float currentEPS;

    var charstring vl_startsVarName;
    f_EPTF_DataSource_getData(
      vl_startsVarName,
      c_ExecCtrl_DataSource_sourceId,"",
      c_ExecCtrl_dataElementTcStat,
      {
        {c_ExecCtrl_paramNameEntityGroup,pl_eGrpName},
        {c_ExecCtrl_paramNameScenario,pl_scName},
        {c_ExecCtrl_paramNameTrafficCase,pl_tcName},
        {c_ExecCtrl_paramNameStatistic,c_EPTF_ExecCtrl_tcStatNames[c_EPTF_ExecCtrl_tcStatId_Starts]}
      },
      sampled
    );
    var integer vl_startsVarId := f_EPTF_Var_getId(vl_startsVarName);
    //f_EPTF_Var_newInt("CALIBRATION",0,vl_startsVarId);  //CALIBRATION
    var integer vl_deltaStatid := f_EPTF_StatMeasure_newStat_delta(vl_startsVarId);
    f_EPTF_StatMeasure_addData_delta(vl_deltaStatid,{intVal := 0});
    timer t_wait := f_EPTF_Var_getRefreshPeriod(0)+1.0;
    t_wait.start; t_wait.timeout;

    var integer vl_deltaStatVarId := f_EPTF_StatMeasure_createVarFromStat(vl_deltaStatid);
    var integer devDeltaStatId := f_EPTF_StatMeasure_newStat_standardDev(vl_deltaStatVarId);
    var integer currentStarts;
    var integer deltaStarts;
    var float meanDeltaStarts;
    var float devDeltaStarts;
    //  var float sum;
    //  var integer sumNId := f_EPTF_StatMeasure_createVarFromStat_N_mean(meanDeltaStatId);

    // create EPS from Delta:
    var integer vl_epsDeltaStatid := f_EPTF_StatMeasure_newStat_EPS();
    f_EPTF_Var_addPostProcFn(vl_deltaStatVarId,
      {refers(f_EPTF_ExecCtrl_Test_SmallCPSDistribution_addData_EPS_PostProc), {vl_epsDeltaStatid}});
    var integer vl_epsDeltaStatVarId := f_EPTF_StatMeasure_createVarFromStat(vl_epsDeltaStatid);
    var integer devEpsDeltaStatId := f_EPTF_StatMeasure_newStat_standardDev(vl_epsDeltaStatVarId);
    var float meanEpsDeltaStarts;
    var float devEpsDeltaStarts;

    // start the test at the variable sync event:
    // wait for start:
    //f_EPTF_Var_addSyncCallBackFn(refers(f_EPTF_ExecCtrl_Test_SmallCPSDistribution_startTest_PostProc), {},c_EPTF_Var_syncEnd);
    f_EPTF_Var_addPostProcFn(vl_deltaStatVarId,
      {refers(f_EPTF_ExecCtrl_Test_SmallCPSDistribution_startTest_PostProc), {}});
    vl_startTest := false;
    t_wait.start(0.0);
    //action("Waiting for var sync....");
    alt {
      [vl_startTest] t_wait.timeout;
    }
    //action("START MEASUREMENT");
    var integer vl_startsOffset :=f_EPTF_Var_getIntValue(vl_startsVarId);
    f_EPTF_StatMeasure_resetStat(devDeltaStatId);
    f_EPTF_StatMeasure_resetStat(vl_epsDeltaStatid);
    f_EPTF_StatMeasure_startMeasurement_EPS(vl_epsDeltaStatid);
    f_EPTF_StatMeasure_resetStat(devEpsDeltaStatId);

    timer t_update := 5.0;
    //t_update.start(5.0);

    timer t_measure := 0.0
    t_measure.start(f_EPTF_Var_getRefreshPeriod(0)*int2float(pl_nofVarRefresh)); // minimum time: pl_nofVarRefresh var refresh periods
    var float vl_expected_meanEpsDeltaStarts := pl_targetCps;
    var float vl_expected_meanDeltaStarts := f_EPTF_Var_getRefreshPeriod(0)*pl_targetCps;
    if (vl_expected_meanDeltaStarts<1.0) {
      vl_expected_meanDeltaStarts := 1.0;
    }
    alt {
      // min starts: 10/LGen
      [f_EPTF_Var_getIntValue(vl_startsVarId)-vl_startsOffset>=pl_nofLGens*pl_nofLGenRefresh] t_measure.timeout {
        //f_EPTF_ExecCtrl_stopAllScenarios();
        action("--------MEASURED VALUES----------");

        f_EPTF_StatMeasure_getStat_standardDev_mean(devDeltaStatId,meanDeltaStarts);
        f_EPTF_StatMeasure_getStat_standardDev(devDeltaStatId,devDeltaStarts);
        action("mean Delta Starts: ", meanDeltaStarts, " dev Delta Starts: ", devDeltaStarts);
        //      sum := meanDeltaStarts*int2float(f_EPTF_Var_getIntValue(sumNId));
        //      action("sum Delta Starts: ", sum);

        f_EPTF_StatMeasure_getStat_standardDev_mean(devEpsDeltaStatId,meanEpsDeltaStarts);
        f_EPTF_StatMeasure_getStat_standardDev(devEpsDeltaStatId,devEpsDeltaStarts);
        action("mean EPS Delta Starts: ", meanEpsDeltaStarts, " dev EPS Delta Starts: ", devEpsDeltaStarts);


        if ((vl_expected_meanEpsDeltaStarts-meanEpsDeltaStarts)*(vl_expected_meanEpsDeltaStarts-meanEpsDeltaStarts)>0.1) {
          setverdict(fail, "Actual meanEpsDeltaStarts (",meanEpsDeltaStarts,") differs from expected value (",vl_expected_meanEpsDeltaStarts,")");
          f_EPTF_Base_stop();
        } else {
          setverdict(pass, "Actual meanEpsDeltaStarts (",meanEpsDeltaStarts,") matches with expected value (",vl_expected_meanEpsDeltaStarts,")");
        }
        if ((c_EPTF_ExecCtrl_Test_SmallCPSDistribution_expected_devEpsDeltaStarts-devEpsDeltaStarts)*(c_EPTF_ExecCtrl_Test_SmallCPSDistribution_expected_devEpsDeltaStarts-devEpsDeltaStarts)>0.1) {
          setverdict(fail, "Actual devEpsDeltaStarts (",devEpsDeltaStarts,") differs from expected value (",c_EPTF_ExecCtrl_Test_SmallCPSDistribution_expected_devEpsDeltaStarts,")");
          f_EPTF_Base_stop();
        } else {
          setverdict(pass, "Actual devEpsDeltaStarts (",devEpsDeltaStarts,") matches with expected value (",c_EPTF_ExecCtrl_Test_SmallCPSDistribution_expected_devEpsDeltaStarts,")");
        }

        if ((vl_expected_meanDeltaStarts-meanDeltaStarts)*(vl_expected_meanDeltaStarts-meanDeltaStarts)>0.1) {
          setverdict(fail, "Actual meanDeltaStarts (",meanDeltaStarts,") differs from expected value (",vl_expected_meanDeltaStarts,")");
          f_EPTF_Base_stop();
        } else {
          setverdict(pass, "Actual meanDeltaStarts (",meanDeltaStarts,") matches with expected value (",vl_expected_meanDeltaStarts,")");
        }
        if ((c_EPTF_ExecCtrl_Test_SmallCPSDistribution_expected_devDeltaStarts -devDeltaStarts)*(c_EPTF_ExecCtrl_Test_SmallCPSDistribution_expected_devDeltaStarts-devDeltaStarts)>0.1) {
          setverdict(fail, "Actual devDeltaStarts (",devDeltaStarts,") differs from expected value (",c_EPTF_ExecCtrl_Test_SmallCPSDistribution_expected_devDeltaStarts,")");
          f_EPTF_Base_stop();
        } else {
          setverdict(pass, "Actual devDeltaStarts (",devDeltaStarts,") matches with expected value (",c_EPTF_ExecCtrl_Test_SmallCPSDistribution_expected_devDeltaStarts,")");
        }
        action("------MEASURED VALUES END-------");
      }
      []t_update.timeout {
        currentStarts := f_EPTF_Var_getIntValue(vl_startsVarId);
        action("Current Starts: ", currentStarts);
        action("Delta Starts: ", f_EPTF_StatMeasure_delta2str(vl_deltaStatid));

        currentCPS := f_EPTF_Var_getFloatValue(vl_cpsVarId);
        action("Current CPS: ", currentCPS);
        f_EPTF_StatMeasure_addData_standardDev(vl_standardDevStatId, currentCPS);
        if(f_EPTF_StatMeasure_getStat_standardDev_mean(vl_standardDevStatId,m)
          and f_EPTF_StatMeasure_getStat_standardDev(vl_standardDevStatId,s)) {
          action("mean(CPS): ", m, " sdev(CPS): ", s, " n: ", f_EPTF_Var_getIntValue(vl_n_varId));
        }

        //currentEPS := f_EPTF_Var_getFloatValue(vl_epsDeltaStatVarId);
        //action("Current EPS var : ", f_EPTF_Var_getFloatValue(vl_epsDeltaStatVarId));
        //f_EPTF_StatMeasure_getStat_EPS(vl_epsDeltaStatid,currentEPS);
        //action("Current EPS stat: ", currentEPS);
        f_EPTF_StatMeasure_getStat_standardDev_mean(devEpsDeltaStatId,meanEpsDeltaStarts);
        f_EPTF_StatMeasure_getStat_standardDev(devEpsDeltaStatId,devEpsDeltaStarts);
        action("mean EPS Delta Starts: ", meanEpsDeltaStarts, " dev EPS Delta Starts: ", devEpsDeltaStarts);
        t_update.start(5.0);
        //f_EPTF_Var_adjustContent(vl_startsVarId, {intVal := 5+f_EPTF_Var_getIntValue(vl_startsVarId)}); //CALIBRATION
        repeat;
      }
    }
    f_EPTF_Var_removePostProcFn(vl_deltaStatVarId,
      {refers(f_EPTF_ExecCtrl_Test_SmallCPSDistribution_addData_EPS_PostProc), {vl_epsDeltaStatid}});
    f_EPTF_Var_removePostProcFn(vl_deltaStatVarId,
      {refers(f_EPTF_ExecCtrl_Test_SmallCPSDistribution_startTest_PostProc), {}});
  }


  //LGen capable to measure TrafficStartTime:

  function f_EPTF_ExecCtrl_Test_SmallCPSDistribution_startTimeMeasure_stepFn(
    in EPTF_LGenBase_TestStepArgs pl_ptr
  ) runs on ExecCtrl_Test_SmallCPSDistribution_LGen_CT {
    v_startTimes[sizeof(v_startTimes)] := f_EPTF_Base_getRelTimeInSecs();
  }

  function f_EPTF_ExecCtrl_Test_SmallCPSDistribution_cleanup_CT() runs on ExecCtrl_Test_SmallCPSDistribution_LGen_CT {
    if (v_expectedCPS==0.0) {
      return;
    }
    var integer v_startTimeDistributionStatId := f_EPTF_StatMeasure_newStat_density({});
    var float vl_timeResolution := 1.0;
    var EPTF_FloatList vl_boundaries := {};
    for(var integer i:=0; int2float(i)<2.0+(1.0+v_startTimes[sizeof(v_startTimes)-1]-v_startTimes[0])/vl_timeResolution; i:=i+1) {
      vl_boundaries[i] := int2float(float2int(v_startTimes[0]))+int2float(i-1)*vl_timeResolution;
    }

    f_EPTF_StatMeasure_setBoundaries_density(v_startTimeDistributionStatId,vl_boundaries)
    //   f_EPTF_StatMeasure_setScale_density(
    //     v_startTimeDistributionStatId,
    //     v_startTimes[0],
    //     v_startTimes[sizeof(v_startTimes)-1],
    //     float2int(v_startTimes[sizeof(v_startTimes)-1]-v_startTimes[0])
    //   );
    for(var integer i:=0; i<sizeof(v_startTimes); i:=i+1) {
      f_EPTF_StatMeasure_addData_density(v_startTimeDistributionStatId,v_startTimes[i]);
    }
    var EPTF_IntegerList vl_densityValues;
    f_EPTF_StatMeasure_getStat_density(v_startTimeDistributionStatId,vl_densityValues);
    //action("StartTimeBoundaries  : ", f_EPTF_StatMeasure_getBoundaries_density(v_startTimeDistributionStatId));
    action("StartTimeDistribution: ", vl_densityValues);
    // check the elements of the density to determine the verdict
    var integer vl_standardDevStatId := f_EPTF_StatMeasure_newStat_standardDev();
    var float vl_standardDevStartTimeOffset := f_EPTF_Var_getRefreshPeriod(0)*2.0+2.0;
    var integer first:=-1, last:=-1, firstId, lastId;
    //var integer totalCalls := 0;
    for(var integer i:=0; i<sizeof(vl_densityValues); i:=i+1) {
      // measure standard dev, but remove initial and final transients:
      if (vl_standardDevStartTimeOffset>int2float(i-2)*vl_timeResolution) {
        continue;
      }
      if ((v_startTimes[sizeof(v_startTimes)-1]-v_startTimes[0])/vl_timeResolution<int2float(i-1)) {
        continue;
      }
      if (first==-1) {
        firstId := i;
        first := vl_densityValues[i];
      }
      lastId := i
      last := vl_densityValues[i]
      //totalCalls := totalCalls + vl_densityValues[i];
      f_EPTF_StatMeasure_addData_standardDev(vl_standardDevStatId,int2float(vl_densityValues[i]));
    }
    action("first: ",first," last: ", last);
    action("firstId: ",firstId," lastId: ", lastId, " total: ", sizeof(vl_densityValues));
    var float vl_CPSMean, vl_CPSDev;
    f_EPTF_StatMeasure_getStat_standardDev_mean(vl_standardDevStatId,vl_CPSMean)
    f_EPTF_StatMeasure_getStat_standardDev(vl_standardDevStatId,vl_CPSDev)
    action("CPSMean: ", vl_CPSMean/vl_timeResolution);
    action("CPSDev : ", vl_CPSDev);
    //action("CPSAvg : ", int2float(totalCalls)/(vl_timeResolution*int2float(lastId-firstId+1)));
    var float vl_expectedBurst := v_expectedCPS*vl_timeResolution;
    if ((vl_expectedBurst-vl_CPSMean)*(vl_expectedBurst-vl_CPSMean)>0.1) {
      setverdict(fail, "Actual CPSMean (",vl_CPSMean/vl_timeResolution,") differs from expected value (",v_expectedCPS,")");
    } else {
      setverdict(pass, "Actual CPSMean (",vl_CPSMean/vl_timeResolution,") matches with expected value (",v_expectedCPS,")");
    }
    if ((c_EPTF_ExecCtrl_Test_SmallCPSDistribution_expected_devEpsDeltaStarts-vl_CPSDev)*(c_EPTF_ExecCtrl_Test_SmallCPSDistribution_expected_devEpsDeltaStarts-vl_CPSDev)>0.1) {
      setverdict(fail, "Actual CPSDev (",vl_CPSDev,") differs from expected value (",c_EPTF_ExecCtrl_Test_SmallCPSDistribution_expected_devEpsDeltaStarts,")");
    } else {
      setverdict(pass, "Actual CPSDev (",vl_CPSDev,") matches with expected value (",c_EPTF_ExecCtrl_Test_SmallCPSDistribution_expected_devEpsDeltaStarts,")");
    }
  }

  function f_EPTF_ExecCtrl_Test_SmallCPSDistribution_startTimeMeasureBehaviour(
    in charstring pl_name,
    in EPTF_ExecCtrl_CT pl_execCtrlCompRef,
    in float pl_expectedCPS := 0.0)
  runs on ExecCtrl_Test_SmallCPSDistribution_LGen_CT {
    f_EPTF_LGenBase_init(pl_name);
    f_EPTF_Base_registerCleanup(refers(f_EPTF_ExecCtrl_Test_SmallCPSDistribution_cleanup_CT));
    v_startTimes := {};
    v_expectedCPS := pl_expectedCPS;
    f_EPTF_LGenBase_declareBehaviorType(c_EPTF_ExecCtrl_Test_defaultBehaviorName, -1, null, null, null);
    f_EPTF_LGenBase_declareEntityType(c_EPTF_ExecCtrl_Test_defaultETypeName, {c_EPTF_ExecCtrl_Test_defaultBehaviorName});
    f_EPTF_LGenBase_declareStep(c_EPTF_ExecCtrl_Test_defaultBehaviorName, {c_EPTF_ExecCtrl_Test_SmallCPSDistribution_startTimeMeasure_stepName, refers(f_EPTF_ExecCtrl_Test_SmallCPSDistribution_startTimeMeasure_stepFn)});
    f_EPTF_LGenBase_declareFSMTable(c_EPTF_ExecCtrl_Test_startTimeMeasurementFSM);
    f_EPTF_ExecCtrlClient_init_CT(pl_name, pl_execCtrlCompRef);
    f_EPTF_Base_wait4Shutdown();
  }

  function f_EPTF_ExecCtrl_Test_SmallCPSDistribution_createStartTimeMeasureLGen  (
    in charstring pl_hostname,
    in charstring pl_componentName
  ) runs on ExecCtrl_Test_SmallCPSDistribution_CT return EPTF_ExecCtrlClient_CT
  {
    var ExecCtrl_Test_SmallCPSDistribution_LGen_CT vl_lgen := ExecCtrl_Test_SmallCPSDistribution_LGen_CT.create;
    vl_lgen.start( f_EPTF_ExecCtrl_Test_SmallCPSDistribution_startTimeMeasureBehaviour("ExecCtrl_StartTimeMeasure_"&log2str(vl_lgen),self,v_expectedCPSPerLGen) );
    return vl_lgen;
  }

} // group EPTF_ExecCtrl_Test_SmallCPSDistribution

// functions and component that is needed to check expected warning messages
group CheckExcpectedWarning {

  private function f_EPTF_ExecCtrl_Test_ExpectedWarning_init() runs on EPTF_CLL_ExecCtrl_Test_ExpectedWarning_CT {
    if (v_ExecCtrl_Test_expectedWarningInitialized) {
      return;
    }
    v_ExecCtrl_Test_expectedWarningInitialized:=true;
    v_ExecCtrl_Test_expectedWarningArrived := false;
    v_ExecCtrl_Test_expectedWarningMsg:="";
    f_EPTF_Base_registerCleanup(refers(f_EPTF_ExecCtrl_Test_ExpectedWarning_cleanup));
    f_EPTF_Logging_registerPreambleFn(refers(f_EPTF_ExecCtrl_Test_ExpectedWarning_checkExpectedWarning_preamble_FT));
  }

  private function f_EPTF_ExecCtrl_Test_ExpectedWarning_cleanup() runs on EPTF_CLL_ExecCtrl_Test_ExpectedWarning_CT {
    if (not v_ExecCtrl_Test_expectedWarningInitialized) {
      return;
    }
    v_ExecCtrl_Test_expectedWarningInitialized:=false;
    if (v_ExecCtrl_Test_expectedWarningMsg != "" and not v_ExecCtrl_Test_expectedWarningArrived) {
      setverdict(fail,"Expected warning message ",v_ExecCtrl_Test_expectedWarningMsg," was not logged!");
    } else {
      setverdict(pass,"Expected warning message was logged");
    }
  }

  public function f_EPTF_ExecCtrl_Test_ExpectedWarning_setExpectedWarning(in charstring pl_expectedWarningMsg) runs on EPTF_CLL_ExecCtrl_Test_ExpectedWarning_CT {
    if (pl_expectedWarningMsg=="") {
      return;
    }
    f_EPTF_ExecCtrl_Test_ExpectedWarning_init();
    v_ExecCtrl_Test_expectedWarningMsg := pl_expectedWarningMsg;
  }

  private function f_EPTF_ExecCtrl_Test_ExpectedWarning_checkExpectedWarning_preamble_FT(in charstring pl_message) runs on EPTF_CLL_ExecCtrl_Test_ExpectedWarning_CT {
    if (not match(pl_message,pattern "*Warning*")) {
      return;
    }
    action(match(pl_message,pattern v_ExecCtrl_Test_expectedWarningMsg))
    if (match(pl_message,pattern v_ExecCtrl_Test_expectedWarningMsg)) {
      v_ExecCtrl_Test_expectedWarningArrived := true;
    }
  }

} // group CheckExcpectedWarning

group ScenarioWithFSM_no_tcTypeDeclaratorList_HO82462 {

  function f_EPTF_ExecCtrl_Test_HO82462_LGenBehaviour_1(
    in charstring pl_name,
    in EPTF_ExecCtrl_CT pl_execCtrlCompRef)
  runs on EPTF_ExecCtrlClient_CT {
    f_EPTF_LGenBase_init(pl_name);
    f_EPTF_LGenBase_declareBehaviorType(c_EPTF_ExecCtrl_Test_defaultBehaviorName&"_1", -1, null, null, null);
    f_EPTF_LGenBase_declareEntityType(c_EPTF_ExecCtrl_Test_defaultETypeName, {c_EPTF_ExecCtrl_Test_defaultBehaviorName&"_1"});
    var EPTF_LGenBase_FsmTableDeclarator vl_EPTF_ExecCtrl_Test_defaultFSM := c_EPTF_ExecCtrl_Test_defaultFSM;
    vl_EPTF_ExecCtrl_Test_defaultFSM.name := c_EPTF_ExecCtrl_Test_defaultFSMName&"_1";
    f_EPTF_LGenBase_declareFSMTable(vl_EPTF_ExecCtrl_Test_defaultFSM);
    f_EPTF_ExecCtrlClient_init_CT(pl_name, pl_execCtrlCompRef);
    f_EPTF_Base_wait4Shutdown();
  }

  function f_EPTF_ExecCtrl_Test_HO82462_LGenBehaviour_2(
    in charstring pl_name,
    in EPTF_ExecCtrl_CT pl_execCtrlCompRef)
  runs on EPTF_ExecCtrlClient_CT {
    f_EPTF_LGenBase_init(pl_name);
    f_EPTF_LGenBase_declareBehaviorType(c_EPTF_ExecCtrl_Test_defaultBehaviorName&"_2", -1, null, null, null);
    f_EPTF_LGenBase_declareEntityType(c_EPTF_ExecCtrl_Test_defaultETypeName, {c_EPTF_ExecCtrl_Test_defaultBehaviorName&"_2"});
    var EPTF_LGenBase_FsmTableDeclarator vl_EPTF_ExecCtrl_Test_defaultFSM := c_EPTF_ExecCtrl_Test_defaultFSM;
    vl_EPTF_ExecCtrl_Test_defaultFSM.name := c_EPTF_ExecCtrl_Test_defaultFSMName&"_2";
    f_EPTF_LGenBase_declareFSMTable(vl_EPTF_ExecCtrl_Test_defaultFSM);
    f_EPTF_ExecCtrlClient_init_CT(pl_name, pl_execCtrlCompRef);
    f_EPTF_Base_wait4Shutdown();
  }

  function f_ExecCtrl_Test_HO82462_createLGen_1  (
    in charstring pl_hostname,
    in charstring pl_componentName
  ) runs on EPTF_ExecCtrl_CT return EPTF_ExecCtrlClient_CT
  {
    var EPTF_ExecCtrlClient_CT vl_lgen := EPTF_ExecCtrlClient_CT.create;
    vl_lgen.start( f_EPTF_ExecCtrl_Test_HO82462_LGenBehaviour_1("ExecCtrl_LGen_"&log2str(vl_lgen),self) );
    return vl_lgen;
  }

  function f_ExecCtrl_Test_HO82462_createLGen_2  (
    in charstring pl_hostname,
    in charstring pl_componentName
  ) runs on EPTF_ExecCtrl_CT return EPTF_ExecCtrlClient_CT
  {
    var EPTF_ExecCtrlClient_CT vl_lgen := EPTF_ExecCtrlClient_CT.create;
    vl_lgen.start( f_EPTF_ExecCtrl_Test_HO82462_LGenBehaviour_2("ExecCtrl_LGen_"&log2str(vl_lgen),self) );
    return vl_lgen;
  }

} //group ScenarioWithFSM_no_tcTypeDeclaratorList_HO82462

// {Delta statistics}:
group EPTF_ExecCtrl_Test_DeltaStatFSM {

  function f_EPTF_ExecCtrl_CLITest_deltaStatLGenBehaviour(
    in charstring pl_name,
    in EPTF_ExecCtrl_CT pl_execCtrlCompRef)
  runs on EPTF_ExecCtrlClient_CT {
    f_EPTF_LGenBase_init(pl_name);
    f_EPTF_LGenBase_declareBehaviorType(c_EPTF_ExecCtrl_Test_defaultBehaviorName, -1, null, null, null);
    f_EPTF_LGenBase_declareEntityType(c_EPTF_ExecCtrl_Test_defaultETypeName, {c_EPTF_ExecCtrl_Test_defaultBehaviorName});
    f_EPTF_LGenBase_declareFSMTable(c_EPTF_ExecCtrl_Test_deltaStatFSM);
    f_EPTF_ExecCtrlClient_init_CT(pl_name, pl_execCtrlCompRef);
    f_EPTF_Base_wait4Shutdown();
  }


  function f_ExecCtrl_Test_createDefaultLGenDeltaStat  (
    in charstring pl_hostname,
    in charstring pl_componentName
  ) runs on EPTF_ExecCtrl_CT return EPTF_ExecCtrlClient_CT
  {
    var EPTF_ExecCtrlClient_CT vl_lgen := EPTF_ExecCtrlClient_CT.create;
    vl_lgen.start( f_EPTF_ExecCtrl_CLITest_deltaStatLGenBehaviour("ExecCtrl_DefaultLGen_"&log2str(vl_lgen),self) );
    return vl_lgen;
  }

} //group EPTF_ExecCtrl_Test_DeltaStatFSM


group EPTF_ExecCtrl_Test_tcFailForNotRunning {

  function f_EPTF_ExecCtrl_CLITest_tcFailForNotRunningLGenBehaviour(
    in charstring pl_name,
    in EPTF_ExecCtrl_CT pl_execCtrlCompRef)
  runs on EPTF_ExecCtrlClient_CT {
    f_EPTF_LGenBase_init(pl_name);
    f_EPTF_LGenBase_declareBehaviorType(c_EPTF_ExecCtrl_Test_defaultBehaviorName, -1, null, null, null);
    f_EPTF_LGenBase_declareEntityType(c_EPTF_ExecCtrl_Test_defaultETypeName, {c_EPTF_ExecCtrl_Test_defaultBehaviorName});
    f_EPTF_LGenBase_declareFSMTable(c_EPTF_ExecCtrl_Test_tcFailForNotRunning_FSM);
    f_EPTF_ExecCtrlClient_init_CT(pl_name, pl_execCtrlCompRef);
    f_EPTF_Base_wait4Shutdown();
  }

  function f_ExecCtrl_Test_createTcFailForNotRunningLGen  (
    in charstring pl_hostname,
    in charstring pl_componentName
  ) runs on EPTF_ExecCtrl_CT return EPTF_ExecCtrlClient_CT
  {
    var EPTF_ExecCtrlClient_CT vl_lgen := EPTF_ExecCtrlClient_CT.create;
    vl_lgen.start( f_EPTF_ExecCtrl_CLITest_tcFailForNotRunningLGenBehaviour("ExecCtrl_TcFailForNotRunningLGen_"&log2str(vl_lgen),self) );
    return vl_lgen;
  }


} // group EPTF_ExecCtrl_Test_tcFailForNotRunning

group EPTF_ExecCtrl_Test_cpsProblem {

  function f_EPTF_ExecCtrl_CLITest_cpsProblemLGenBehaviour(
    in charstring pl_name,
    in EPTF_ExecCtrl_CT pl_execCtrlCompRef)
  runs on EPTF_ExecCtrlClient_CT {
    f_EPTF_LGenBase_init(pl_name);
    f_EPTF_LGenBase_declareBehaviorType(c_EPTF_ExecCtrl_Test_defaultBehaviorName, -1, null, null, null);
    f_EPTF_LGenBase_declareEntityType(c_EPTF_ExecCtrl_Test_defaultETypeName, {c_EPTF_ExecCtrl_Test_defaultBehaviorName});
    f_EPTF_LGenBase_declareFSMTable(c_EPTF_ExecCtrl_Test_cpsProblem_FSM);
    f_EPTF_ExecCtrlClient_init_CT(pl_name, pl_execCtrlCompRef);
    f_EPTF_Base_wait4Shutdown();
  }

  function f_ExecCtrl_Test_createcpsProblemLGen  (
    in charstring pl_hostname,
    in charstring pl_componentName
  ) runs on EPTF_ExecCtrl_CT return EPTF_ExecCtrlClient_CT
  {
    var EPTF_ExecCtrlClient_CT vl_lgen := EPTF_ExecCtrlClient_CT.create;
    vl_lgen.start( f_EPTF_ExecCtrl_CLITest_cpsProblemLGenBehaviour("ExecCtrl_cpsProblemLGen_"&log2str(vl_lgen),self) );
    return vl_lgen;
  }


} // group EPTF_ExecCtrl_Test_tcFailForNotRunning

group EPTF_ExecCtrl_ExitDuringTrafficRun_Test {

  function f_ExecCtrl_Test_createExitDuringTrafficRunLGen  (
    in charstring pl_hostname,
    in charstring pl_componentName
  ) runs on ExecCtrlDSClient_Test_CT return EPTF_ExecCtrlClient_CT
  {
    var EPTF_ExecCtrl_ExitDuringTrafficRun_CT vl_lgen := EPTF_ExecCtrl_ExitDuringTrafficRun_CT.create;
    vl_lgen.start( f_EPTF_ExecCtrl_Test_ExitDuringTrafficRunLGen("ExecCtrl_DefaultLGen_"&log2str(vl_lgen),self) );
    return vl_lgen;
  }

  function f_EPTF_ExecCtrl_Test_ExitDuringTrafficRunLGen_detectCleanup_stepFn(
    in EPTF_LGenBase_TestStepArgs pl_ptr
  ) runs on EPTF_ExecCtrl_ExitDuringTrafficRun_CT {
    // action("call >> f_EPTF_ExecCtrl_Test_ExitDuringTrafficRunLGen_detectCleanup_stepFn");
    if(f_EPTF_Base_cleanupIsInProgress()==false) {
      setverdict(fail, "TEST step called under cleanup");
    }
  }

  function f_EPTF_ExecCtrl_Test_ExitDuringTrafficRunLGen_detectCleanup_timeout_stepFn(
    in EPTF_LGenBase_TestStepArgs pl_ptr
  ) runs on EPTF_ExecCtrl_ExitDuringTrafficRun_CT {
    // action("call >> f_EPTF_ExecCtrl_Test_ExitDuringTrafficRunLGen_detectCleanup_timeout_stepFn");
    if(f_EPTF_Base_cleanupIsInProgress()==false) {
      setverdict(fail, "TEST timeout step called under cleanup");
    }
  }

  function f_EPTF_ExecCtrl_Test_ExitDuringTrafficRunLGen_detectCleanup_dispatch_stepFn(
    in EPTF_LGenBase_TestStepArgs pl_ptr
  ) runs on EPTF_ExecCtrl_ExitDuringTrafficRun_CT { // EPTF_ExecCtrl_ExitDuringTrafficRun_CT
    // action("call >> f_EPTF_ExecCtrl_Test_ExitDuringTrafficRunLGen_detectCleanup_dispatch_stepFn");
    setverdict(fail, "TEST dispatchEvent called under cleanup");
  }


  function f_EPTF_ExecCtrl_Test_ExitDuringTrafficRun_Cleanup_CT()
    runs on EPTF_ExecCtrl_ExitDuringTrafficRun_CT {
    action("call >> f_EPTF_ExecCtrl_Test_ExitDuringTrafficRun_Cleanup_CT");
    f_EPTF_LGenBase_dispatchEvent( { event:={ bIdx:= v_idxBCTExitDuringTrafficRun, iIdx:= v_idxFSMEventExitDuringTrafficRun, target:=omit, source := omit}, reportedArgs:= {} });
    timer t_wait := 10.0;
    t_wait.start;
    t_wait.timeout;
    action("ENDE >> f_EPTF_ExecCtrl_Test_ExitDuringTrafficRun_Cleanup_CT");
  }

  function f_EPTF_ExecCtrl_Test_ExitDuringTrafficRunLGen(in charstring pl_name,
    in EPTF_ExecCtrl_CT pl_execCtrlCompRef)
  runs on EPTF_ExecCtrl_ExitDuringTrafficRun_CT {
    f_EPTF_LGenBase_init(pl_name);
    v_idxBCTExitDuringTrafficRun := f_EPTF_LGenBase_declareBehaviorType(c_EPTF_ExecCtrl_Test_defaultBehaviorName, -1, null, null, null);
    f_EPTF_LGenBase_declareEntityType(c_EPTF_ExecCtrl_Test_defaultETypeName, {c_EPTF_ExecCtrl_Test_defaultBehaviorName});
    f_EPTF_LGenBase_declareStep(c_EPTF_ExecCtrl_Test_defaultBehaviorName, {c_EPTF_ExecCtrl_ExitDuringTrafficRun_Test_detectCleanup, refers(f_EPTF_ExecCtrl_Test_ExitDuringTrafficRunLGen_detectCleanup_stepFn)});
    f_EPTF_LGenBase_declareStep(c_EPTF_ExecCtrl_Test_defaultBehaviorName, {c_EPTF_ExecCtrl_ExitDuringTrafficRun_Test_detectTimeoutCleanup, refers(f_EPTF_ExecCtrl_Test_ExitDuringTrafficRunLGen_detectCleanup_timeout_stepFn)});
    f_EPTF_LGenBase_declareStep(c_EPTF_ExecCtrl_Test_defaultBehaviorName, {c_EPTF_ExecCtrl_ExitDuringTrafficRun_Test_detectDispatchCleanup, refers(f_EPTF_ExecCtrl_Test_ExitDuringTrafficRunLGen_detectCleanup_dispatch_stepFn)});
    //v_idxBCTExitDuringTrafficRun := f_EPTF_LGenBase_declareBehaviorType(c_EPTF_ExecCtrl_ExitDuringTrafficRun_eventName, -1, null, null, null);
    v_idxFSMEventExitDuringTrafficRun := f_EPTF_LGenBase_declareFsmEvent(c_EPTF_ExecCtrl_Test_defaultBehaviorName, c_EPTF_ExecCtrl_ExitDuringTrafficRun_eventName);
    f_EPTF_LGenBase_declareFSMTable(c_EPTF_ExecCtrl_Test_FSMExitDuringTrafficRunLGen);
    f_EPTF_ExecCtrlClient_init_CT(pl_name, pl_execCtrlCompRef);
    f_EPTF_Base_registerCleanup(refers(f_EPTF_ExecCtrl_Test_ExitDuringTrafficRun_Cleanup_CT));
    f_EPTF_Base_wait4Shutdown();
  }

} // group EPTF_ExecCtrl_ExitDuringTrafficRun_Test


group EPTF_ExecCtrl_Test_CatchDTEInTestStep {

  function f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_shouldGenerateDTE(in EPTF_LGenBase_TestStepArgs pl_ptr)
  runs on EPTF_ExecCtrlClient_CT return boolean
  {
    // returns true if entity should generate DTE
    return pl_ptr.eIdx rem 3 == 0;
  }

  function f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_step_generateDTE(in EPTF_LGenBase_TestStepArgs pl_ptr)
  runs on EPTF_ExecCtrlClient_CT
  {
    if (not f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_shouldGenerateDTE(pl_ptr)) {
      return; // no DTE
    }
    //log(%definitionId, " started...");
    action("****Generating DTE...");
    var integer i := 1;
    log(i/(i-1));
  }

  function f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_step_checkEventAfterDTE(in EPTF_LGenBase_TestStepArgs pl_ptr)
  runs on EPTF_ExecCtrlClient_CT
  {
    if (not f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_shouldGenerateDTE(pl_ptr)) {
      return; // no DTE
    }
    //log(%definitionId, " started...");
    action("****checkEventAfterDTE...");
    setverdict(fail,"Event was processed by an entity that has generated a DTE earlier! Entity should be disabled.");
  }

  function f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_step_checkStepAfterDTE(in EPTF_LGenBase_TestStepArgs pl_ptr)
  runs on EPTF_ExecCtrlClient_CT
  {
    if (not f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_shouldGenerateDTE(pl_ptr)) {
      return; // no DTE
    }
    //log(%definitionId, " started...");
    action("****checkStepAfterDTE...");
    setverdict(fail,"Step was executed by an entity that has generated a DTE earlier! Entity should be disabled.");
  }

  function f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_step_checkStepHandleDTEEvent(in EPTF_LGenBase_TestStepArgs pl_ptr)
  runs on EPTF_ExecCtrl_Test_CatchDTEInTestStep_LGen_CT
  {
    //log(%definitionId, " started...");
    vl_LGenBase_DTE_Event_wasHandled := true;
    action("****checkStepHandleDTEEvent received for entity #",pl_ptr.eIdx,", fsm: #",pl_ptr.refContext.fCtxIdx,". Error message: ", f_EPTF_LGenBase_get_dte_str(pl_ptr.eIdx,pl_ptr.refContext.fCtxIdx));
  }

  
  function f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_LGen_cleanup_CT() runs on EPTF_ExecCtrl_Test_CatchDTEInTestStep_LGen_CT {
    if (not vl_LGenBase_DTE_Event_wasHandled) {
      setverdict(fail,"The LGenBase DTE Event was not handled in FSM!");
    } else {
      setverdict(pass,"Successfully handled the LGenBase DTE Event in FSM.");
    }
  }
  
  function f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_LGenBehaviour(
    in charstring pl_name,
    in EPTF_ExecCtrl_CT pl_execCtrlCompRef)
  runs on EPTF_ExecCtrl_Test_CatchDTEInTestStep_LGen_CT {
    f_EPTF_LGenBase_init(pl_name);
    f_EPTF_Base_registerCleanup(refers(f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_LGen_cleanup_CT));
    vl_LGenBase_DTE_Event_wasHandled := false;
    f_EPTF_LGenBase_declareBehaviorType(c_EPTF_ExecCtrl_Test_defaultBehaviorName, -1, null, null, null);
    f_EPTF_LGenBase_declareStep(c_EPTF_ExecCtrl_Test_defaultBehaviorName, {c_EPTF_ExecCtrl_Test_CatchDTEInTestStep_stepName,refers(f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_step_generateDTE)})
    f_EPTF_LGenBase_declareStep(c_EPTF_ExecCtrl_Test_defaultBehaviorName, {c_EPTF_ExecCtrl_Test_checkEventAfterDTEInTestStep_stepName,refers(f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_step_checkEventAfterDTE)})
    f_EPTF_LGenBase_declareStep(c_EPTF_ExecCtrl_Test_defaultBehaviorName, {c_EPTF_ExecCtrl_Test_checkStepAfterDTEInTestStep_stepName,refers(f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_step_checkStepAfterDTE)})
    f_EPTF_LGenBase_declareStep(c_EPTF_ExecCtrl_Test_defaultBehaviorName, {c_EPTF_ExecCtrl_Test_checkStepHandleDTEEvent_stepName,refers(f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_step_checkStepHandleDTEEvent)})
    f_EPTF_LGenBase_declareEntityType(c_EPTF_ExecCtrl_Test_defaultETypeName, {c_EPTF_ExecCtrl_Test_defaultBehaviorName});
    f_EPTF_LGenBase_declareFSMTable(c_EPTF_ExecCtrl_Test_CatchDTEInTestStep_FSM);
    f_EPTF_ExecCtrlClient_init_CT(pl_name, pl_execCtrlCompRef);
    f_EPTF_Base_setDTEHandling(true);
    f_EPTF_Base_wait4Shutdown();
  }

  function f_ExecCtrl_Test_catchDTEInTestStep_createLGen  (
    in charstring pl_hostname,
    in charstring pl_componentName
  ) runs on EPTF_ExecCtrl_CT return EPTF_ExecCtrlClient_CT
  {
    var EPTF_ExecCtrl_Test_CatchDTEInTestStep_LGen_CT vl_lgen := EPTF_ExecCtrl_Test_CatchDTEInTestStep_LGen_CT.create;
    vl_lgen.start( f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_LGenBehaviour("ExecCtrl_DefaultLGen_"&log2str(vl_lgen),self) );
    return vl_lgen;
  }

  
  // LGenBase DTE Event is not catched in FSM:
  
  function f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_DoNotHandleDTE_LGen_cleanup_CT() runs on EPTF_ExecCtrl_Test_CatchDTEInTestStep_LGen_CT {
    if (not vl_LGenBase_DTE_Event_wasHandled) {
      setverdict(pass,"The LGenBase DTE Event was not handled in FSM.");
    } else {
      setverdict(fail,"The FSM handled the LGenBase DTE Event but it should not!");
    }
  }
  
  function f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_DoNotHandleDTE_LGenBehaviour(
    in charstring pl_name,
    in EPTF_ExecCtrl_CT pl_execCtrlCompRef)
  runs on EPTF_ExecCtrl_Test_CatchDTEInTestStep_LGen_CT {
    f_EPTF_LGenBase_init(pl_name);
    f_EPTF_Base_registerCleanup(refers(f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_DoNotHandleDTE_LGen_cleanup_CT));
    vl_LGenBase_DTE_Event_wasHandled := false;
    f_EPTF_LGenBase_declareBehaviorType(c_EPTF_ExecCtrl_Test_defaultBehaviorName, -1, null, null, null);
    f_EPTF_LGenBase_declareStep(c_EPTF_ExecCtrl_Test_defaultBehaviorName, {c_EPTF_ExecCtrl_Test_CatchDTEInTestStep_stepName,refers(f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_step_generateDTE)})
    f_EPTF_LGenBase_declareStep(c_EPTF_ExecCtrl_Test_defaultBehaviorName, {c_EPTF_ExecCtrl_Test_checkEventAfterDTEInTestStep_stepName,refers(f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_step_checkEventAfterDTE)})
    f_EPTF_LGenBase_declareStep(c_EPTF_ExecCtrl_Test_defaultBehaviorName, {c_EPTF_ExecCtrl_Test_checkStepAfterDTEInTestStep_stepName,refers(f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_step_checkStepAfterDTE)})
    f_EPTF_LGenBase_declareStep(c_EPTF_ExecCtrl_Test_defaultBehaviorName, {c_EPTF_ExecCtrl_Test_checkStepHandleDTEEvent_stepName,refers(f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_step_checkStepHandleDTEEvent)})
    f_EPTF_LGenBase_declareEntityType(c_EPTF_ExecCtrl_Test_defaultETypeName, {c_EPTF_ExecCtrl_Test_defaultBehaviorName});
    f_EPTF_LGenBase_declareFSMTable(c_EPTF_ExecCtrl_Test_CatchDTEInTestStep_FSM_DoNotHandleDTEEvent);
    f_EPTF_ExecCtrlClient_init_CT(pl_name, pl_execCtrlCompRef);
    f_EPTF_Base_setDTEHandling(true);
    f_EPTF_Base_wait4Shutdown();
  }

  function f_ExecCtrl_Test_catchDTEInTestStep_DoNotHandleDTE_createLGen  (
    in charstring pl_hostname,
    in charstring pl_componentName
  ) runs on EPTF_ExecCtrl_CT return EPTF_ExecCtrlClient_CT
  {
    var EPTF_ExecCtrl_Test_CatchDTEInTestStep_LGen_CT vl_lgen := EPTF_ExecCtrl_Test_CatchDTEInTestStep_LGen_CT.create;
    vl_lgen.start( f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_DoNotHandleDTE_LGenBehaviour("ExecCtrl_DefaultLGen_"&log2str(vl_lgen),self) );
    return vl_lgen;
  }

////////////// Generate DTE Event in DTE Handler in FSM:
  
  function f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_GenerateDTEInDTEHandler_LGenBehaviour(
    in charstring pl_name,
    in EPTF_ExecCtrl_CT pl_execCtrlCompRef)
  runs on EPTF_ExecCtrl_Test_CatchDTEInTestStep_LGen_CT {
    f_EPTF_LGenBase_init(pl_name);
    f_EPTF_Base_registerCleanup(refers(f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_LGen_cleanup_CT));
    vl_LGenBase_DTE_Event_wasHandled := false;
    f_EPTF_LGenBase_declareBehaviorType(c_EPTF_ExecCtrl_Test_defaultBehaviorName, -1, null, null, null);
    f_EPTF_LGenBase_declareStep(c_EPTF_ExecCtrl_Test_defaultBehaviorName, {c_EPTF_ExecCtrl_Test_CatchDTEInTestStep_stepName,refers(f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_step_generateDTE)})
    f_EPTF_LGenBase_declareStep(c_EPTF_ExecCtrl_Test_defaultBehaviorName, {c_EPTF_ExecCtrl_Test_checkEventAfterDTEInTestStep_stepName,refers(f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_step_checkEventAfterDTE)})
    f_EPTF_LGenBase_declareStep(c_EPTF_ExecCtrl_Test_defaultBehaviorName, {c_EPTF_ExecCtrl_Test_checkStepAfterDTEInTestStep_stepName,refers(f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_step_checkStepAfterDTE)})
    f_EPTF_LGenBase_declareStep(c_EPTF_ExecCtrl_Test_defaultBehaviorName, {c_EPTF_ExecCtrl_Test_checkStepHandleDTEEvent_stepName,refers(f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_step_checkStepHandleDTEEvent)})
    f_EPTF_LGenBase_declareEntityType(c_EPTF_ExecCtrl_Test_defaultETypeName, {c_EPTF_ExecCtrl_Test_defaultBehaviorName});
    f_EPTF_LGenBase_declareFSMTable(c_EPTF_ExecCtrl_Test_CatchDTEInTestStep_FSM_GenerateDTEInDTEHandlerEvent);
    f_EPTF_ExecCtrlClient_init_CT(pl_name, pl_execCtrlCompRef);
    f_EPTF_Base_setDTEHandling(true);
    f_EPTF_Base_wait4Shutdown();
  }

  function f_ExecCtrl_Test_catchDTEInTestStep_GenerateDTEInDTEHandler_createLGen  (
    in charstring pl_hostname,
    in charstring pl_componentName
  ) runs on EPTF_ExecCtrl_CT return EPTF_ExecCtrlClient_CT
  {
    var EPTF_ExecCtrl_Test_CatchDTEInTestStep_LGen_CT vl_lgen := EPTF_ExecCtrl_Test_CatchDTEInTestStep_LGen_CT.create;
    vl_lgen.start( f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_GenerateDTEInDTEHandler_LGenBehaviour("ExecCtrl_DefaultLGen_"&log2str(vl_lgen),self) );
    return vl_lgen;
  }

////////////// Generate DTE Event in DTE Handler in FSM, no traffic failed is reported:
  
  function f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_GenerateDTEInDTEHandler2_LGenBehaviour(
    in charstring pl_name,
    in EPTF_ExecCtrl_CT pl_execCtrlCompRef)
  runs on EPTF_ExecCtrl_Test_CatchDTEInTestStep_LGen_CT {
    f_EPTF_LGenBase_init(pl_name);
    f_EPTF_Base_registerCleanup(refers(f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_LGen_cleanup_CT));
    vl_LGenBase_DTE_Event_wasHandled := false;
    f_EPTF_LGenBase_declareBehaviorType(c_EPTF_ExecCtrl_Test_defaultBehaviorName, -1, null, null, null);
    f_EPTF_LGenBase_declareStep(c_EPTF_ExecCtrl_Test_defaultBehaviorName, {c_EPTF_ExecCtrl_Test_CatchDTEInTestStep_stepName,refers(f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_step_generateDTE)})
    f_EPTF_LGenBase_declareStep(c_EPTF_ExecCtrl_Test_defaultBehaviorName, {c_EPTF_ExecCtrl_Test_checkEventAfterDTEInTestStep_stepName,refers(f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_step_checkEventAfterDTE)})
    f_EPTF_LGenBase_declareStep(c_EPTF_ExecCtrl_Test_defaultBehaviorName, {c_EPTF_ExecCtrl_Test_checkStepAfterDTEInTestStep_stepName,refers(f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_step_checkStepAfterDTE)})
    f_EPTF_LGenBase_declareStep(c_EPTF_ExecCtrl_Test_defaultBehaviorName, {c_EPTF_ExecCtrl_Test_checkStepHandleDTEEvent_stepName,refers(f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_step_checkStepHandleDTEEvent)})
    f_EPTF_LGenBase_declareEntityType(c_EPTF_ExecCtrl_Test_defaultETypeName, {c_EPTF_ExecCtrl_Test_defaultBehaviorName});
    f_EPTF_LGenBase_declareFSMTable(c_EPTF_ExecCtrl_Test_CatchDTEInTestStep_FSM_GenerateDTEInDTEHandler2Event);
    f_EPTF_ExecCtrlClient_init_CT(pl_name, pl_execCtrlCompRef);
    f_EPTF_Base_setDTEHandling(true);
    f_EPTF_Base_wait4Shutdown();
  }

  function f_ExecCtrl_Test_catchDTEInTestStep_GenerateDTEInDTEHandler2_createLGen  (
    in charstring pl_hostname,
    in charstring pl_componentName
  ) runs on EPTF_ExecCtrl_CT return EPTF_ExecCtrlClient_CT
  {
    var EPTF_ExecCtrl_Test_CatchDTEInTestStep_LGen_CT vl_lgen := EPTF_ExecCtrl_Test_CatchDTEInTestStep_LGen_CT.create;
    vl_lgen.start( f_EPTF_ExecCtrl_Test_CatchDTEInTestStep_GenerateDTEInDTEHandler2_LGenBehaviour("ExecCtrl_DefaultLGen_"&log2str(vl_lgen),self) );
    return vl_lgen;
  }

} // group EPTF_ExecCtrl_Test_CatchDTEInTestStep

// test the total counters
group EPTF_ExecCtrl_Test_TotalCounter {

  function f_EPTF_ExecCtrl_Test_TotalCounter_step_trafficHandler(
      in EPTF_LGenBase_TestStepArgs pl_ptr
  ) runs on ExecCtrl_Test_TotalCounter_LGen_CT {
    var integer vl_tcIndx := f_EPTF_LGenBase_tcIdxOfStep(pl_ptr);
    if(isbound(v_Counter[vl_tcIndx])) {
      v_Counter[vl_tcIndx] := v_Counter[vl_tcIndx] + 1;
    } else {
      v_Counter[vl_tcIndx] := 1;
    }

    if(v_Counter[vl_tcIndx] <= c_EPTF_ExecCtrl_Test_TotalCounter_executionValues[1]) {
      f_EPTF_LGenBase_step_trafficSuccess(pl_ptr);
    } else if(v_Counter[vl_tcIndx] <= c_EPTF_ExecCtrl_Test_TotalCounter_executionValues[1] + c_EPTF_ExecCtrl_Test_TotalCounter_executionValues[2]) {
      f_EPTF_LGenBase_step_trafficFailed(pl_ptr);
    } else if(v_Counter[vl_tcIndx] <= c_EPTF_ExecCtrl_Test_TotalCounter_executionValues[1] + c_EPTF_ExecCtrl_Test_TotalCounter_executionValues[2] + c_EPTF_ExecCtrl_Test_TotalCounter_executionValues[3]) {
      f_EPTF_LGenBase_step_trafficTimeout(pl_ptr);
    } else if(v_Counter[vl_tcIndx] < c_EPTF_ExecCtrl_Test_TotalCounter_executionValues[0]) {
      f_EPTF_LGenBase_step_trafficError(pl_ptr);
    } else {
      // do nothing, let FSM to report traffic error on c_EPTF_LGenBase_inputName_testMgmt_stopTC event
    }
  }

  function f_EPTF_ExecCtrl_CLITest_totalCounterLGenBehaviour(
    in charstring pl_name,
    in EPTF_ExecCtrl_CT pl_execCtrlCompRef)
  runs on ExecCtrl_Test_TotalCounter_LGen_CT {
    f_EPTF_LGenBase_init(pl_name);
    f_EPTF_Var_setSyncInterval(1.0);
    f_EPTF_LGenBase_declareBehaviorType(c_EPTF_ExecCtrl_Test_defaultBehaviorName, -1, null, null, null);
    f_EPTF_LGenBase_declareStep(c_EPTF_ExecCtrl_Test_defaultBehaviorName, {c_EPTF_ExecCtrl_Test_TotalCounter_stepName_trafficHandler,refers(f_EPTF_ExecCtrl_Test_TotalCounter_step_trafficHandler)})
    f_EPTF_LGenBase_declareEntityType(c_EPTF_ExecCtrl_Test_defaultETypeName, {c_EPTF_ExecCtrl_Test_defaultBehaviorName});
    f_EPTF_LGenBase_declareFSMTable(c_EPTF_ExecCtrl_Test_totalCounterFSM);
    f_EPTF_ExecCtrlClient_init_CT(pl_name, pl_execCtrlCompRef);
    f_EPTF_Base_wait4Shutdown();
  }


  function f_ExecCtrl_Test_createDefaultLGenTotalCounter  (
    in charstring pl_hostname,
    in charstring pl_componentName
  ) runs on EPTF_ExecCtrl_CT return EPTF_ExecCtrlClient_CT
  {
    var ExecCtrl_Test_TotalCounter_LGen_CT vl_lgen := ExecCtrl_Test_TotalCounter_LGen_CT.create;
    vl_lgen.start( f_EPTF_ExecCtrl_CLITest_totalCounterLGenBehaviour("ExecCtrl_DefaultLGen_"&log2str(vl_lgen),self) );
    return vl_lgen;
  }

} // ~group EPTF_ExecCtrl_Test_TotalCounter

}