src/LGenBase/EPTF_CLL_LGenBase_ConfigDefinitions.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_CLL_LGenBase_ConfigDefinitions
// 
//  Purpose:
//    This module provides common data structures in TitanSim load generators
//    necessary to describe or process test descriptions from config files
// 
//  Module Parameters:
//    tsp_EPTF_LGenBase_FSMdumpPath - *charstring* - The path used for creating FSM files. FSM Dumping is enabled if not empty. Default: ""
// 
//  Module depends on:
//    <EPTF_CLL_Common_Definitions>
//    <EPTF_CLL_LGenBase_TemplateDefinitions>
// 
//  Current Owner:
//    ELSZSKU
// 
//  Last Review Date:
//    2009-01-27
// 
//  Detailed Comments:
//    Using this definition module the features that want to process config 
//    descriptions but won't extend LGenBase, don't have to import the whole
//    definitions of the LGenBase, but only this definition module. 
///////////////////////////////////////////////////////////
module EPTF_CLL_LGenBase_ConfigDefinitions
{
import from EPTF_CLL_Common_Definitions all;
import from EPTF_CLL_LGenBase_PhaseDefinitions all;
import from EPTF_CLL_LGenBase_TemplateDefinitions all;
import from EPTF_CLL_Variable_Definitions all;
import from EPTF_CLL_StatMeasure_Definitions all;
import from EPTF_CLL_StatHandlerClient_Definitions all;

modulepar EPTF_CharstringList tsp_LGenBase_FSMDefaultEvents := c_EPTF_LGenBase_DefaultFSMEvents;
modulepar charstring tsp_EPTF_LGenBase_FSMdumpPath := "";

///////////////////////////////////////////////////////////
// Type: EPTF_LGenBase_EntityGrpDeclarator
//
// Purpose:
//   Used in declaring an entity group in TITAN config file.
//
// Elements:
//   - name - *charstring* - the name of the entity group
//   - eType - *charstring* - the type of the entities within the group
//   - cCount - *integer* - the amount of entities within the group
// 
// Detailed Comments:
//   Entity types should be declared during the init phase 
//   via f_EPTF_LGenBase_declareEntityType()
///////////////////////////////////////////////////////////
type record EPTF_LGenBase_EntityGrpDeclarator {
  charstring name,
  charstring eType,
  integer    eCount
}

///////////////////////////////////////////////////////////
// Type: EPTF_LGenBase_EntityGrpDeclaratorList
//
// Purpose:
//   Record of <EPTF_LGenBase_EntityGrpDeclarator> to provide a container for
//   arbitrary number of <EPTF_LGenBase_EntityGrpDeclarator> values
//
// Elements:
//   record of <EPTF_LGenBase_EntityGrpDeclarator>
//////////////////////////////////////////////////////////
type record of EPTF_LGenBase_EntityGrpDeclarator EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList;

///////////////////////////////////////////////////////////
// Type: EPTF_LGenBase_Scenario2Grp
//
// Purpose:
//   Contains an entity group - scenario association record
//
// Elements:
//   - eGrpName - *charstring* - refers the name of the entity group
//   - scenarioName - *charstring* - refers the name of the traffic scenario
//
// Detailed Comments:
//   OBSOLETE, kept only for compatibility reasons, use 
//   <EPTF_LGenBase_Scenarios2Grp> instead!
// 
///////////////////////////////////////////////////////////
type record EPTF_LGenBase_Scenario2Grp{
  charstring eGrpName, //name of the group
  charstring scenarioName
}

///////////////////////////////////////////////////////////
// Type: EPTF_LGenBase_Scenario2GrpList
//
// Purpose:
//   Record of <EPTF_LGenBase_Scenario2Grp> to provide a container for
//   arbitrary number of <EPTF_LGenBase_Scenario2Grp> values
//
// Elements:
//   record of <EPTF_LGenBase_Scenario2Grp>
//
// Detailed Comments:
//   OBSOLETE, kept only for compatibility reasons, use 
//   <EPTF_LGenBase_Scenarios2GrpList> instead!
//////////////////////////////////////////////////////////
type record of EPTF_LGenBase_Scenario2Grp EPTF_LGenBase_Scenario2GrpList;

///////////////////////////////////////////////////////////
// Group: unionDecl
//
// Purpose:
//   Type definitions to declare a FSM-s.
//
// Developer comments:
//   The main purpose was to create declarators which are
//   flexible enough to allow extending them with new declarators.
//   The other goal of this type of declaration is that the users
//   don't have to write down parameters which have default
//   initial values.
///////////////////////////////////////////////////////////
group unionDecl{
  group TrafficCase{
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_TrafficCaseTypeParams
    //
    // Purpose:
    //   The collection of the available parameters of a traffic case type
    //
    // Elements:
    //   customEntitySucc - *charstring* - the registered name of
    //       a user-defined function to evaluate the state of the entity
    //       at the end of a traffic. If it's empty, the 
    //       <f_EPTF_LGenBase_successSucNoFail> will be called.
    ///////////////////////////////////////////////////////////
    type union EPTF_LGenBase_TrafficCaseTypeParams{
      charstring customEntitySucc
    }
    
    type record of EPTF_LGenBase_TrafficCaseTypeParams EPTF_LGenBase_TrafficCaseTypeParamsList;
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_TrafficCaseTypeDeclarator
    //
    // Purpose:
    //   Used to declare a traffic case type in TITAN config file and in
    //   <f_EPTF_LGenBase_declareTrafficCaseType> function. 
    // 
    // Elements:
    //   name - *charstring* - the name of the traffic case type
    //   fsmName - *charstring* - FSM table name of the TC
    //   entityType - *charstring* - the type of the entity executing the traffic case
    //   tcParams - <EPTF_LGenBase_TrafficCaseTypeParamsList> - the parameters of the traffic case type
    //
    // Detailed Comments:
    //   The customEntitySucc must contain the name of a previously declared 
    //   <EPTF_LGenBase_evaluateSuccess4EntityAtEntityGroup2_FT> function or can be empty.
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_TrafficCaseTypeDeclarator {
      charstring name,
      charstring fsmName,
      charstring entityType,
      EPTF_LGenBase_TrafficCaseTypeParamsList tcParams
    }
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_TrafficCaseTypeDeclaratorList
    //
    // Purpose: List of <EPTF_LGenBase_TrafficCaseTypeDeclarator> records.
    ///////////////////////////////////////////////////////////
    type record of EPTF_LGenBase_TrafficCaseTypeDeclarator EPTF_LGenBase_TrafficCaseTypeDeclaratorList;
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_NrOfExecStart
    //
    // Purpose:
    //   Declares the required amount of starts of the entities in a traffic case
    //   and the actions to be executed when the condition becomes true.  
    //
    // Elements:
    //   count - *integer* - the amount of starts
    //   actions - <EPTF_LGenBase_TcMgmt_GroupActionsList> - the actions to be executed
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_NrOfExecStart{
      integer count,
      EPTF_LGenBase_TcMgmt_GroupActionsList actions
    }
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_NrOfSuccesses
    //
    // Purpose:
    //   Declares the required amount of successful execution of the entities in a traffic case
    //   and the actions to be executed when the condition becomes true.  
    //
    // Elements:
    //   count - *integer* - the amount of successful executions
    //   actions - <EPTF_LGenBase_TcMgmt_GroupActionsList> - the actions to be executed
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_NrOfSuccesses{
      integer count,
      EPTF_LGenBase_TcMgmt_GroupActionsList actions
    }
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_NrOfFails
    //
    // Purpose:
    //   Declares the required amount of failed execution of the entities in a traffic case
    //   and the actions to be executed when the condition becomes true.  
    //
    // Elements:
    //   count - *integer* - the amount of failed executions
    //   actions - <EPTF_LGenBase_TcMgmt_GroupActionsList> - the actions to be executed
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_NrOfFails{
      integer count,
      EPTF_LGenBase_TcMgmt_GroupActionsList actions
    }
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_NrOfErrors
    //
    // Purpose:
    //   Declares the required amount of errorous execution of the entities in a traffic case
    //   and the actions to be executed when the condition becomes true.  
    //
    // Elements:
    //   count - *integer* - the amount of errorous executions
    //   actions - <EPTF_LGenBase_TcMgmt_GroupActionsList> - the actions to be executed
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_NrOfErrors{
      integer count,
      EPTF_LGenBase_TcMgmt_GroupActionsList actions
    }
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_NrOfTimeouts
    //
    // Purpose:
    //   Declares the required amount of timed out execution of the entities in a traffic case
    //   and the actions to be executed when the condition becomes true.  
    //
    // Elements:
    //   count - *integer* - the amount of timed out executions
    //   actions - <EPTF_LGenBase_TcMgmt_GroupActionsList> - the actions to be executed
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_NrOfTimeouts{
      integer count,
      EPTF_LGenBase_TcMgmt_GroupActionsList actions
    }
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_NrOfRangeLoop
    //
    // Purpose:
    //   Declares the required amount of loop of range parameters in a traffic case
    //   and the actions to be executed when the condition becomes true.  
    //
    // Elements:
    //   count - *integer* - the required amount of loop of range parameters
    //   actions - <EPTF_LGenBase_TcMgmt_GroupActionsList> - the actions to be executed
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_NrOfRangeLoop{
      integer count,
      EPTF_LGenBase_TcMgmt_GroupActionsList actions
    }
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_ExecTime
    //
    // Purpose:
    //   Declares the required time of execution of a traffic case
    //   and the actions to be executed when the condition becomes true.  
    //
    // Elements:
    //   time - *float* - the required time of execution
    //   actions - <EPTF_LGenBase_TcMgmt_GroupActionsList> - the actions to be executed
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_ExecTime{
      float time,
      EPTF_LGenBase_TcMgmt_GroupActionsList actions
    }
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_EntitiesFinished
    //
    // Purpose:
    //   Declares that the execution of a traffic case should be finished when
    //   all the entities in the traffic case finished,
    //   and declares the actions to be executed when the condition becomes true.  
    //
    // Elements:
    //   actions - <EPTF_LGenBase_TcMgmt_GroupActionsList> - the actions to be executed
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_EntitiesFinished{
      EPTF_LGenBase_TcMgmt_GroupActionsList actions
    }
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_AvailableEntitiesFinished
    //
    // Purpose:
    //   Declares that the execution of a traffic case should be finished when
    //   all the available entities in the traffic case finished,
    //   and declares the actions to be executed when the condition becomes true.  
    //
    // Elements:
    //   actions - <EPTF_LGenBase_TcMgmt_GroupActionsList> - the actions to be executed
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_AvailableEntitiesFinished{
      EPTF_LGenBase_TcMgmt_GroupActionsList actions
    }
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_AnythingFinished
    //
    // Purpose:
    //   Declares the actions to be executed when any of the conditions becomes true.  
    //
    // Elements:
    //   actions - <EPTF_LGenBase_TcMgmt_GroupActionsList> - the actions to be executed
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_AnythingFinished{
      EPTF_LGenBase_TcMgmt_GroupActionsList actions
    }
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_CustomFinish
    //
    // Purpose:
    //   Declares a function which must be executed every time when the execution 
    //   of an entity of a traffic case started or finished. This function must decide 
    //   whether the execution of the traffic case must be continued or finished 
    //
    // Elements:
    //   functionName - *charstring* - the name of a 
    //      previously declared <EPTF_LGenBase_customFinishFunction_FT> function.
    //      See also <f_EPTF_LGenBase_declareFunction>.  
    //   actions - <EPTF_LGenBase_TcMgmt_GroupActionsList> - the actions to be executed
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_CustomFinish{
      charstring functionName,
      EPTF_LGenBase_TcMgmt_GroupActionsList actions
    }
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_TcFinishCondition
    //
    // Purpose:
    //   The collection of the available finish condition types
    //
    // Elements:
    //   nrOfExecStart - <EPTF_LGenBase_NrOfExecStart> - See <EPTF_LGenBase_NrOfExecStart> 
    //   nrOfSuccesses - <EPTF_LGenBase_NrOfSuccesses> - See <EPTF_LGenBase_NrOfSuccesses> 
    //   nrOfFails - <EPTF_LGenBase_NrOfFails> - See <EPTF_LGenBase_NrOfFails> 
    //   nrOfRangeLoop - <EPTF_LGenBase_NrOfRangeLoop> - See <EPTF_LGenBase_NrOfRangeLoop> 
    //   nrOfErrors - <EPTF_LGenBase_NrOfErrors>
    //   nrOfTimeouts - <EPTF_LGenBase_NrOfTimeouts>
    //   execTime - <EPTF_LGenBase_ExecTime> - See <EPTF_LGenBase_ExecTime> 
    //   entitiesFinished - <EPTF_LGenBase_EntitiesFinished> - See <EPTF_LGenBase_EntitiesFinished> 
    //   availableEntitiesFinished - <EPTF_LGenBase_AvailableEntitiesFinished>
    //   customFinish - <EPTF_LGenBase_CustomFinish> - See <EPTF_LGenBase_CustomFinish> 
    //   anythingFinished - <EPTF_LGenBase_AnythingFinished> - See <EPTF_LGenBase_AnythingFinished> 
    ///////////////////////////////////////////////////////////
    type union EPTF_LGenBase_TcFinishCondition {
      EPTF_LGenBase_NrOfExecStart nrOfExecStart,
      EPTF_LGenBase_NrOfSuccesses nrOfSuccesses,
      EPTF_LGenBase_NrOfFails nrOfFails,
      EPTF_LGenBase_NrOfRangeLoop nrOfRangeLoop,
      EPTF_LGenBase_NrOfErrors nrOfErrors,
      EPTF_LGenBase_NrOfTimeouts nrOfTimeouts,
      EPTF_LGenBase_ExecTime execTime,
      EPTF_LGenBase_EntitiesFinished entitiesFinished,
      EPTF_LGenBase_AvailableEntitiesFinished availableEntitiesFinished,
      EPTF_LGenBase_CustomFinish customFinish,
      EPTF_LGenBase_AnythingFinished anythingFinished
    }
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_TcFinishConditionList
    //
    // Purpose: List of <EPTF_LGenBase_TcFinishCondition> records.
    //   Enumerates the finish conditions of a traffic case in the declarators. 
    ///////////////////////////////////////////////////////////
    type record of EPTF_LGenBase_TcFinishCondition EPTF_LGenBase_TcFinishConditionList;
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_EntityFinishCondition
    //
    // Purpose: When one of these conditions becomes true, the launch of the 
    // traffic on the specified entity of the specified traffic case will stop, and the
    // sepcified actions will be executed.
    // See also <EPTF_LGenBase_TcMgmt_EntityActionsList>,
    // <EPTF_LGenBase_tcTypeDeclarator>, <EPTF_LGenBase_TcMgmt_TcOfScenario2>, <EPTF_LGenBase_TcMgmt_TcOfScenario3>,
    // <EPTF_LGenBase_TcMgmt_ScenarioDeclarator2>, <EPTF_LGenBase_ScenarioTypeDeclarator>  
    //////////////////////////////////////////////////////////
    type union EPTF_LGenBase_EntityFinishCondition {
      integer nrOfExecStart,
      integer nrOfSuccesses,
      integer nrOfFails,
      integer nrOfErrors,
      integer nrOfTimeouts,
      charstring customFinishCondition
    }
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_EntityFinishConditionList
    //
    // Purpose: List of <EPTF_LGenBase_EntityFinishCondition> records. 
    ///////////////////////////////////////////////////////////
    type record of EPTF_LGenBase_EntityFinishCondition EPTF_LGenBase_EntityFinishConditionList;
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_TrafficType
    //
    // Purpose: Specifies the type of the traffic performed by the traffic case  
    //
    // Elements:
    //   - originating - The traffic case starts the traffic
    //   - terminating - The traffic case reacts to incoming events
    ///////////////////////////////////////////////////////////
    type enumerated EPTF_LGenBase_TrafficType {originating, terminating}
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_SiblingFSM
    //
    // Purpose: Specifies a sibling FSM of the traffic case  
    //
    // Elements:
    //   - siblingName - The sibling-name of the FSM in the TC
    //   - fsmType - The type of the (sibling) FSM
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_SiblingFSM {
      charstring siblingName,
      charstring fsmType
    }
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_SiblingFsmList
    //
    // Purpose: List of sibling FSMs in the traffic case  
    //
    // Elements:
    //   - <EPTF_LGenBase_SiblingFSM>
    ///////////////////////////////////////////////////////////
    type record of EPTF_LGenBase_SiblingFSM EPTF_LGenBase_SiblingFsmList;
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_tcParams
    //
    // Purpose: Describes the parameters of a traffic case of a scenario
    //
    // Elements:
    //   - startDelay - *float* - traffic case should start only after the specified amount of time (given in seconds)
    //   - enableEntitiesAtStart - *boolean* - the entities have to be in enabled or disabled state after creating the traffic case
    //   - enabledAtStart - *boolean* - the traffic case will be enabled or disabled after creation    
    //   - target - <EPTF_LGenBase_TcMgmt_TcProperty2Reach> - target "cps" or "traffic weight" to reach
    //   - scheduler - <EPTF_LGenBase_burstFuncName> - the chosen scheduling strategy (burst calculation method) of the normal traffic case
    //   - entitySelection - <EPTF_LGenBase_EntitySelectionType> - the method of selecting a new entity
    //   - ranges - <EPTF_LGenBase_TcMgmt_ParamRangeDeclaratorList> - Range descriptors for the traffic case. 
    //       The dispatched <c_EPTF_LGenBase_inputIdx_testMgmt_startTC> events of <c_EPTF_LGenBase_bIdx> 
    //       behavior get their traffic parameter from this range. See also: <t_startTcOfFsm>, <f_EPTF_LGenBase_doTrafficCaseTimerAction>.  
    //   - params - <EPTF_LGenBase_TcMgmt_tcCustomParamDeclaratorList> - Retrievable charstring parameters. See <f_EPTF_LGenBase_getCharstringParamValue>
    //   - entityFinishConditions - <EPTF_LGenBase_EntityFinishConditionList> - When one of these conditions becomes true, the launch of the 
    // 	     traffic on the specified entity of the specified traffic case will stop, and the
    //       actions described in the entityFinishActions will be fired.
    //   - entityFinishActions - <EPTF_LGenBase_TcMgmt_EntityActionsList> - List of actions that will be executed when an
    // 	     entity finish condition becomes true.
    //   - trafficStartFinish - <EPTF_LGenBase_TcFinishConditionList> - List of traffic case finish conditions       
    //   - trafficFinishedActions - <EPTF_LGenBase_TcMgmt_GroupActionsList> - List of actions that will be executed when a
    //       group finish condition becomes true or the last traffic of the traffic case returns the acknowledgement.
    //   - templateSet - <EPTF_LGenBase_TemplateList> - Defines the template set of traffic case as list of template assignments
    //   - tcTypeName - *charstring* - The name of the traffic case type descriptor. If it's not present, the name of the tc of sc must be the name of the tc type
    //   - restoreTCAtStartTC - *boolean* - if true: ExecCtrl will call restoreTC when TC is started by pressing the StartTC button on the GUI or via CLI. Default: true
    // 
    //   The finish conditions and actions declared in the <EPTF_LGenBase_TcOfScenarioDeclarator> for a
    //   traffic case will overwrite the conditions occasionally declared in <EPTF_LGenBase_tcTypeDeclarator> 
    ///////////////////////////////////////////////////////////
    type union EPTF_LGenBase_tcParams{
      float startDelay,
      boolean enableEntitiesAtStart,
      boolean enabledAtStart,
      EPTF_LGenBase_TcMgmt_TcProperty2Reach target,
      EPTF_LGenBase_burstFuncName scheduler,
      EPTF_LGenBase_EntitySelectionType entitySelection,
      EPTF_LGenBase_TcMgmt_ParamRangeDeclaratorList ranges,
      EPTF_LGenBase_TcMgmt_tcCustomParamDeclaratorList params,
      EPTF_LGenBase_EntityFinishConditionList entityFinishConditions,
      EPTF_LGenBase_TcMgmt_EntityActionsList entityFinishActions,
      EPTF_LGenBase_TcFinishConditionList trafficStartFinish,
      EPTF_LGenBase_TcMgmt_GroupActionsList trafficFinishedActions,
      EPTF_LGenBase_TemplateList templateSet,
      charstring tcTypeName,
      EPTF_CharstringList fsmList,
      EPTF_LGenBase_SiblingFsmList siblingFsmList,
      charstring customEntitySucc,
      boolean restoreTCAtStartTC // if true: ExecCtrl will call restoreTC when TC is started
    }
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_tcParamsList
    //
    // Purpose: List of parameters of a traffic case.
    ///////////////////////////////////////////////////////////
    type record of EPTF_LGenBase_tcParams EPTF_LGenBase_tcParamsList;
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_TcOfScenarioDeclarator
    //
    // Purpose: Describes a traffic case in a for TitanSim R3.
    //
    // Elements:
    //   - tcName - *charstring* - refers the name of the traffic case type
    //   - tcParamsList - <EPTF_LGenBase_tcParamsList> - the parameters of the traffic case
    ///////////////////////////////////////////////////////////    
    type record EPTF_LGenBase_TcOfScenarioDeclarator{
      charstring tcName,
      EPTF_LGenBase_tcParamsList tcParamsList 
    }
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_TcOfScenarioDeclaratorList
    //
    // Purpose: List of <EPTF_LGenBase_TcOfScenarioDeclarator> declarators.
    ///////////////////////////////////////////////////////////
    type record of EPTF_LGenBase_TcOfScenarioDeclarator EPTF_LGenBase_TcOfScenarioDeclaratorList;
    
  }
  group Scenario{
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_WeightedScData
    //
    // Purpose: Additional data needed for the weighted scenario declaration
    //
    // Elements:
    //   cpsToReach - *float* - cps to reach
    //   lockCPS - *boolean* - lock cps
    //   deterministicMix - *boolean* - the traffic case selection will be counted before the start of traffic generation,
    //                                  or the traffic cases will be chosen runtime randomly
    //   scheduler - <EPTF_LGenBase_burstFuncName> - the chosen scheduling strategy (burst calculation method) for the weighted scenario
    //
    // Detailed Comments:
    //   If the parameter exists in the <EPTF_LGenBase_ScenarioTypeParamsList> scParamsList field of the 
    //   <EPTF_LGenBase_ScenarioTypeDeclarator>, the scenario will be weighted, normal otherwise
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_WeightedScData{    
      float cpsToReach,
      boolean lockCPS,  
      boolean deterministicMix,
      EPTF_LGenBase_burstFuncName scheduler optional  
    }
    
    ///////////////////////////////////////////////////////////
    // Constant: c_EPTF_LGenBase_emptyWeightedScData
    //
    // Purpose: An empty initializer structure of <EPTF_LGenBase_WeightedScData>
    ///////////////////////////////////////////////////////////
    const EPTF_LGenBase_WeightedScData c_EPTF_LGenBase_emptyWeightedScData := {0.0,false,false,omit};
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_TcMgmt_TcProperty2Reach
    //
    // Purpose: a union for storing "cps to reach" or "traffic weight" value
    //
    // Elements:
    //   dummy - *float* - a dummy value
    //   cpsToReach - *float* - cps to reach in a normal traffic case
    //   trafficWeight - *float* - weight of the traffic in a weighted traffic case
    ///////////////////////////////////////////////////////////
    type union EPTF_LGenBase_TcMgmt_TcProperty2Reach{
      float dummy,  
      float cpsToReach,
      float trafficWeight
    }
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_ScenarioTypeParams
    //
    // Purpose: Describes the parameters of a traffic case of a scenario
    //
    // Elements:
    //   phaseListName - *charstring* - the name of the declared phaselist assigned to the scenario
    //   weightedScData - <EPTF_LGenBase_WeightedScData> - See <EPTF_LGenBase_WeightedScData>
    //   enabled - *boolean* - The enabled state of the scenario at startup. The default value is true.
    //     The scenario can start automatically if the value is true
    //   phaseFinishConditions - <EPTF_LGenBase_TcMgmt_PhaseFinishConditionList> - See <EPTF_LGenBase_TcMgmt_PhaseFinishConditionList>
    //   phaseStateChangeActions - <EPTF_LGenBase_TcMgmt_PhaseActionList> - See <EPTF_LGenBase_TcMgmt_PhaseActionList>
    ///////////////////////////////////////////////////////////
    type union EPTF_LGenBase_ScenarioTypeParams{
      charstring phaseListName, 
      EPTF_LGenBase_WeightedScData weightedScData, // omit -> normal scenario  
      boolean enabled,
      EPTF_LGenBase_TcMgmt_PhaseFinishConditionList phaseFinishConditions,
      EPTF_LGenBase_TcMgmt_PhaseActionList phaseStateChangeActions,    
      EPTF_LGenBase_TrafficType trafficType
    }
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_ScenarioTypeParamsList
    //
    // Purpose: A list of <EPTF_LGenBase_ScenarioTypeParams>  
    ///////////////////////////////////////////////////////////    
    type record of EPTF_LGenBase_ScenarioTypeParams EPTF_LGenBase_ScenarioTypeParamsList;
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_TcMgmt_ScenarioDeclarator
    //
    // Purpose: Declares a list of traffic cases as a scenario for TitanSimR3. The scenario can be normal or weighted.
    //
    // Elements:
    //   name - *charstring* - name of the scenario
    //   tcList - <EPTF_LGenBase_TcOfScenarioDeclaratorList> - list of traffic cases assigned to the scenario
    //   scParamsList - <EPTF_LGenBase_ScenarioTypeParamsList> - stores various scenario parameters such as weighted scenario data, phase data etc.
    //
    // Detailed Comments:
    //    R3 scenario type declarator
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_ScenarioTypeDeclarator{
      charstring name,
      EPTF_LGenBase_TcOfScenarioDeclaratorList tcList,
      EPTF_LGenBase_ScenarioTypeParamsList scParamsList
    }
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_TcMgmt_ScenarioDeclaratorList
    //
    // Purpose: List of <EPTF_LGenBase_ScenarioTypeDeclarator> records.
    ///////////////////////////////////////////////////////////
    type record of EPTF_LGenBase_ScenarioTypeDeclarator EPTF_LGenBase_ScenarioTypeDeclaratorList;
    
    ///////////////////////////////////////////////////////////
    // Constant: c_EPTF_LGenBase_emptyScenarioTypeDeclarator
    //
    // Purpose: An empty initializer structure of <EPTF_LGenBase_ScenarioTypeDeclarator>
    ///////////////////////////////////////////////////////////
    const EPTF_LGenBase_ScenarioTypeDeclarator c_EPTF_LGenBase_emptyScenarioTypeDeclarator := {
      "", {}, {}
    }
  } // group Scenario
} // group unionDecl

///////////////////////////////////////////////////////////
// Type: EPTF_LGenBase_Scenarios2Grp
//
// Purpose:
//   Contains an entity group - scenario list association record
//
// Elements:
//   - eGrpName - *charstring* - refers the name of the entity group
//   - scenarioNames - <EPTF_CharstringList> - the list of the traffic scenario names
//
// Detailed Comments:
// 
///////////////////////////////////////////////////////////
type record EPTF_LGenBase_Scenarios2Grp{
  charstring eGrpName, //name of the group
  EPTF_CharstringList scenarioNames
}


///////////////////////////////////////////////////////////
// Type: EPTF_LGenBase_TcMgmt_Scenarios2GrpList
//
// Purpose:
//   Record of <EPTF_LGenBase_Scenarios2Grp> to provide a container for
//   arbitrary number of <EPTF_LGenBase_Scenarios2Grp> values
//
// Elements:
//   record of <EPTF_LGenBase_Scenarios2Grp>
//
// Detailed Comments:
//
//////////////////////////////////////////////////////////
type record of EPTF_LGenBase_Scenarios2Grp EPTF_LGenBase_TcMgmt_Scenarios2GrpList;

///////////////////////////////////////////////////////////
// Type: EPTF_LGenBase_TcMgmt_EntityAvailabilityGroupTransferMode
//
// Purpose: This transfer mode is used in group finish actions.
//
// Elements:
//   noChangeuntouched - the enabling state of the entities in the specified
//   traffic case(es) will be 
//   enableIfPreviousSuccess - only the successful entities in the terminating 
//   traffic case(es) will be enabled in the specified traffic case
//   available - all the entities in the specified traffic case
//   will be enabled
//   non_available - none of the entities in the specified traffic case(es)
//   will be enabled
//
// See also:
//   <EPTF_LGenBase_TcMgmt_Action_EnableAllTc>, 
//   <EPTF_LGenBase_TcMgmt_Action_DisableAllTc>,
//   <EPTF_LGenBase_TcMgmt_Action_EnableTc4Group>,
//   <EPTF_LGenBase_TcMgmt_Action_DisableTc>
///////////////////////////////////////////////////////////
type enumerated EPTF_LGenBase_TcMgmt_EntityAvailabilityGroupTransferMode {
  // use for enableTc@groupFinishAction
  noChange, enableIfPreviousSuccess, available, non_available}
///////////////////////////////////////////////////////////
// Type: EPTF_LGenBase_TcMgmt_EntityAvailabilityEntityTransferMode
//
// Purpose: See <EPTF_LGenBase_TcMgmt_EntityFinishConditions>.
//
// See also:
//   <EPTF_LGenBase_TcMgmt_Action_EnableTc4Entity>,
//   <EPTF_LGenBase_TcMgmt_Action_DisableTc4Entity>
///////////////////////////////////////////////////////////
type EPTF_LGenBase_TcMgmt_EntityAvailabilityGroupTransferMode EPTF_LGenBase_TcMgmt_EntityAvailabilityEntityTransferMode

///////////////////////////////////////////////////////////
// Type: EPTF_LGenBase_TcMgmt_Action_EnableAllTc
//
// Purpose: Enables all traffic cases in the scenario.
///////////////////////////////////////////////////////////
type record EPTF_LGenBase_TcMgmt_Action_EnableAllTc {
  EPTF_LGenBase_TcMgmt_EntityAvailabilityGroupTransferMode aMode //availibility transfer mode
}
///////////////////////////////////////////////////////////
// Type: EPTF_LGenBase_TcMgmt_Action_DisableAllTc
//
// Purpose: Disables all traffic cases in the scenario.
///////////////////////////////////////////////////////////
type record EPTF_LGenBase_TcMgmt_Action_DisableAllTc {
  EPTF_LGenBase_TcMgmt_EntityAvailabilityGroupTransferMode aMode //availibility transfer mode
}

///////////////////////////////////////////////////////////
// Type: EPTF_LGenBase_TcMgmt_Action_GenerateGenericEvent
//
// Purpose: Descriptor of dispatching a generic event   
// in group finish actions. The behavior of the event == c_EPTF_LGenBase_bIdx
///////////////////////////////////////////////////////////
type record EPTF_LGenBase_TcMgmt_Action_GenerateGenericEvent{
  integer iIdx  
}
///////////////////////////////////////////////////////////
// Type: EPTF_LGenBase_TcMgmt_Action_GenerateFsmEvent
//
// Purpose: Descriptor of dispatching an FSM event   
// in entity finish actions. 
// The behavior of the event == c_EPTF_LGenBase_bIdx
// The target FSM is the FSM of the traffic case
///////////////////////////////////////////////////////////
type record EPTF_LGenBase_TcMgmt_Action_GenerateFsmEvent{
  integer iIdx 
}

///////////////////////////////////////////////////////////
// Type: EPTF_LGenBase_TcMgmt_Action_TestFinished
//
// Purpose: Declares that the test finished
///////////////////////////////////////////////////////////
type record EPTF_LGenBase_TcMgmt_Action_TestFinished{}

///////////////////////////////////////////////////////////
// Type: EPTF_LGenBase_TcMgmt_GroupActions
//
// Purpose: Types of actions that will be executed when a
// group finish condition becomes true.
//
// Elements: 
//   enableTc - <EPTF_LGenBase_TcMgmt_Action_EnableTc4Group> - Enables the traffic case
//   disableTc - <EPTF_LGenBase_TcMgmt_Action_DisableTc> - Disables the traffic case
//   enableAllTc - <EPTF_LGenBase_TcMgmt_Action_EnableAllTc> - Enables all the traffic cases in the scenario
//   disableAllTc - <EPTF_LGenBase_TcMgmt_Action_DisableAllTc> - Disables all the traffic cases in the scenario 
//   generateGenericEvent - <EPTF_LGenBase_TcMgmt_Action_GenerateGenericEvent> - Generates a generic event 
//   customFinishFunction - *charstring* - the name of a 
//      previously declared <EPTF_LGenBase_customFinishFunction_FT> function.
//      See <f_EPTF_LGenBase_declareFunction>.  
///////////////////////////////////////////////////////////
type union EPTF_LGenBase_TcMgmt_GroupActions {
  EPTF_LGenBase_TcMgmt_Action_EnableTc4Group     enableTc, 
  EPTF_LGenBase_TcMgmt_Action_DisableTc    disableTc, 
  EPTF_LGenBase_TcMgmt_Action_EnableAllTc  enableAllTc, 
  EPTF_LGenBase_TcMgmt_Action_DisableAllTc disableAllTc, 
  EPTF_LGenBase_TcMgmt_Action_GenerateGenericEvent generateGenericEvent,
  charstring customFinishFunction,
  EPTF_LGenBase_TcMgmt_Action_TestFinished testFinished
}
///////////////////////////////////////////////////////////
// Type: EPTF_LGenBase_TcMgmt_GroupActionsList
//
// Purpose: A list of <EPTF_LGenBase_TcMgmt_GroupActions>
///////////////////////////////////////////////////////////
type record of EPTF_LGenBase_TcMgmt_GroupActions EPTF_LGenBase_TcMgmt_GroupActionsList 

///////////////////////////////////////////////////////////
// Type: EPTF_LGenBase_TcMgmt_EntityActions
//
// Purpose: Types of actions that will be executed when an
// entity finish condition becomes true.
//
// Elements: 
// - enableEntity4Tc - <EPTF_LGenBase_TcMgmt_Action_EnableTc4Entity> - Sets the
//   enabled state of the entity ragarding the 
//   <EPTF_LGenBase_TcMgmt_EntityAvailabilityEntityTransferMode> aMode in the
//   specified traffic case.      
// - disableEntity4Tc - <EPTF_LGenBase_TcMgmt_Action_DisableTc4Entity> - Obsolete action. Use enableEntity4Tc instead.
// - generateFsmEvent - <EPTF_LGenBase_TcMgmt_Action_GenerateFsmEvent> - Generates an FSM event
//   customFinishFunction - *charstring* - the name of a 
//      previously declared <EPTF_LGenBase_customFinishFunction_FT> function.
//      See <f_EPTF_LGenBase_declareFunction>.  
///////////////////////////////////////////////////////////
type union EPTF_LGenBase_TcMgmt_EntityActions {
  EPTF_LGenBase_TcMgmt_Action_EnableTc4Entity     enableEntity4Tc,  
  EPTF_LGenBase_TcMgmt_Action_DisableTc           disableEntity4Tc, 
  EPTF_LGenBase_TcMgmt_Action_GenerateFsmEvent    generateFsmEvent,
  charstring customFinishFunction
}
///////////////////////////////////////////////////////////
// Type: EPTF_LGenBase_TcMgmt_EntityActionsList
//
// Purpose: List of <EPTF_LGenBase_TcMgmt_EntityActions>
///////////////////////////////////////////////////////////
type record of EPTF_LGenBase_TcMgmt_EntityActions EPTF_LGenBase_TcMgmt_EntityActionsList 

///////////////////////////////////////////////////////////
// Type: EPTF_LGenBase_TcMgmt_Action_EnableTc4Group
//
// Purpose: Enables a traffic cases in the scenario.
//
// Elements: 
// - tcName - *charstring* - The name of the traffic case. 
// - aMode - <EPTF_LGenBase_TcMgmt_EntityAvailabilityGroupTransferMode> - availibility transfer mode
///////////////////////////////////////////////////////////
type record EPTF_LGenBase_TcMgmt_Action_EnableTc4Group {
  charstring tcName,
  EPTF_LGenBase_TcMgmt_EntityAvailabilityGroupTransferMode aMode //availibility transfer mode
}

///////////////////////////////////////////////////////////
// Type: EPTF_LGenBase_TcMgmt_Action_EnableTc4Entity
//
// Purpose: Enables/disables an entity in a traffic case.
//
// Elements: 
// - tcName - *charstring* - The name of the traffic case. 
// - aMode - <EPTF_LGenBase_TcMgmt_EntityAvailabilityEntityTransferMode> - availibility transfer mode
///////////////////////////////////////////////////////////
type record EPTF_LGenBase_TcMgmt_Action_EnableTc4Entity {
  charstring tcName,
  EPTF_LGenBase_TcMgmt_EntityAvailabilityEntityTransferMode aMode //availibility transfer mode
}

///////////////////////////////////////////////////////////
// Type: EPTF_LGenBase_TcMgmt_Action_DisableTc
//
// Purpose: Disables a traffic cases in the scenario. See <EPTF_LGenBase_TcMgmt_GroupActions>.
//
// Elements: 
// - tcName - *charstring* - The name of the traffic case. 
///////////////////////////////////////////////////////////
type record EPTF_LGenBase_TcMgmt_Action_DisableTc {
  charstring tcName
}

///////////////////////////////////////////////////////////
// Type: EPTF_LGenBase_TcMgmt_tcCustomParamDeclarator
//
// Purpose: Retrievable charstring parameters. See <f_EPTF_LGenBase_getCharstringParamValue>
//
// Elements: 
// - aName  - *charstring* - The name of the application owns this parameter
// - pName  - *charstring* - The name of the parameter
// - pValue - *charstring* - The charstring representation of the parameter value
///////////////////////////////////////////////////////////
type record EPTF_LGenBase_TcMgmt_tcCustomParamDeclarator
{
  charstring  aName,  // name of the application owns this parameter
  charstring  pName,  // the name of the parameter
  charstring  pValue  // the charstring representation of the parameter value
}

///////////////////////////////////////////////////////////
// Type: EPTF_LGenBase_TcMgmt_tcCustomParamDeclaratorList
//
// Purpose: List of <EPTF_LGenBase_TcMgmt_tcCustomParamDeclarator> records.
///////////////////////////////////////////////////////////
type record of EPTF_LGenBase_TcMgmt_tcCustomParamDeclarator EPTF_LGenBase_TcMgmt_tcCustomParamDeclaratorList;

///////////////////////////////////////////////////////////
// Type: EPTF_LGenBase_TcMgmt_ParamRangeDeclarator
//
// Purpose: Describes a parameter range.
//
// Elements: 
// - name - *charstring* - The name of the parameter range. 
// - baseOffset - *integer - The starting value of the parameter.
// - count - *integer - The maximal count of parameters in the range.
//
// Detailed Comments:
//     The dispatched <c_EPTF_LGenBase_inputIdx_testMgmt_startTC> events of <c_EPTF_LGenBase_bIdx> 
//     behavior get their traffic parameter from this range. See also: <t_startTcOfFsm>, <f_EPTF_LGenBase_doTrafficCaseTimerAction>.  
///////////////////////////////////////////////////////////
type record EPTF_LGenBase_TcMgmt_ParamRangeDeclarator{
  charstring name,
  boolean enableSplit,
  integer baseOffset,
  integer count
}

///////////////////////////////////////////////////////////
// Type: EPTF_LGenBase_TcMgmt_ParamRangeDeclarator
//
// Purpose: List of <EPTF_LGenBase_TcMgmt_ParamRangeDeclarator> records.
///////////////////////////////////////////////////////////
type record of EPTF_LGenBase_TcMgmt_ParamRangeDeclarator EPTF_LGenBase_TcMgmt_ParamRangeDeclaratorList;

const EPTF_LGenBase_TcMgmt_ParamRangeDeclarator c_EPTF_LGenBase_TcMgmt_emptyParamRangeDeclarator := {
  "", false, -1, 0
}

///////////////////////////////////////////////////////////
//  Type: EPTF_LGenBase_EntitySelectionType
// 
//  Purpose:
//    Enumerated type for choosing the entity selection type
// 
//  Elements:
//    - round_robin - Selecting using round robin algorithm
//    - random - Randomly selecting 
//
//  Detailed Comments:
//      The round_robin selection type uses the Free Busy Queue for selecting a new entity,
//      The random selection type uses the Random N Array for selecting a new entity
/////////////////////////////////////////////////////////
type enumerated EPTF_LGenBase_EntitySelectionType {round_robin(0), random(1)}

///////////////////////////////////////////////////////////
//  Type: EPTF_LGenBase_burstFunc
// 
//  Purpose:
//    Enumerated type for chosing the burst precalculation and postcalculation functions
// 
//  Elements:
//    - userDefined - user defined burst pre- and post-calculation function
//    - orig - Original burst pre- and post-calculation function
//    - imst - IMST type burst pre- and post-calculation function
//    - imst2 - IMST type burst pre- and post-calculation function with faster algorithm
//    - cs - cs type burst pre- and post-calculation function
//    - poisson - poisson distribution based burst pre- and post-calculation function
//    - terminating - no scheduler is activated for the traffic case, entities will be started due to an external event
//
//  Detailed Comments:
//      -
/////////////////////////////////////////////////////////
type enumerated EPTF_LGenBase_burstFunc {userDefined(-1), orig(0), imst(1), imst2(2), cs(3), poisson(4), terminating(5)}

///////////////////////////////////////////////////////////
//  Type: EPTF_LGenBase_burstFuncName
// 
//  Purpose:
//    Union for chosing the burst precalculation and postcalculation functions
// 
//  Elements:
//    - preDefinedName - <EPTF_LGenBase_burstFunc> - name of the pre defined burst pre- and post-calculation function
//    - userDefinedName - *charstring* -  name of the user defined burst pre- and post-calculation function
//
//  Detailed Comments:
//      -
/////////////////////////////////////////////////////////
type union EPTF_LGenBase_burstFuncName {
  EPTF_LGenBase_burstFunc preDefinedName,
  charstring userDefinedName
}

group FSM{
  
  ///////////////////////////////////////////////////////////
  //  Type: EPTF_LGenBase_ReportableEventType
  // 
  //  Purpose:
  //    Enumerated type for descripting classes of reportable events
  // 
  //  Elements:
  //    - general - Event not possible to associate to a specific entity
  //    - entity - Event associated to a specific entity
  //    - fsm - Event associated to a specific FSM context of a specific entity
  //
  //  Detailed Comments:
  //      -
  /////////////////////////////////////////////////////////
  type enumerated EPTF_LGenBase_ReportableEventType {general(0), entity(1),fsm(2)}
  
  group compactDeclarators{  
    ///////////////////////////////////////////////////////////
    //  Type: EPTF_LGenBase_EventDeclarator
    // 
    //  Purpose:
    //    Record type for describing events that can be listened to by event listeners
    // 
    //  Elements:
    //    - bName - *charstring* - the behaviorType of the reportable event 
    //    - iName - *charstring* - the name of the reportable event w.r.t. to bName
    //    - eventType - <EPTF_LGenBase_ReportableEventType>  - the event-level
    //      class of the reportable event. 
    // 
    //  Detailed Comments:
    //      -
    /////////////////////////////////////////////////////////
    type record EPTF_LGenBase_EventDeclarator{
      charstring bName,
      charstring iName,
      EPTF_LGenBase_ReportableEventType eventType
    }
    
    ///////////////////////////////////////////////////////////
    //  Type: EPTF_LGenBase_EventArrayDeclarator
    // 
    //  Purpose:
    //    Record type for describing event properties for defining an array of events that have to be created
    // 
    //  Elements:
    //    - eventConstant - *integer* - the constant value mapped to the event 
    //    - eventName - *charstring* - the name of the event
    //
    //  Detailed Comments:
    //      -
    /////////////////////////////////////////////////////////
    type record EPTF_LGenBase_EventArrayDeclarator{
      integer eventConstant,
      charstring eventName
    }
    
    ///////////////////////////////////////////////////////////
    //  Type: EPTF_LGenBase_EventArrayDeclaratorList
    // 
    //  Purpose:
    //    List of events
    // 
    /////////////////////////////////////////////////////////
    type record of EPTF_LGenBase_EventArrayDeclarator EPTF_LGenBase_EventArrayDeclaratorList
    
    ///////////////////////////////////////////////////////////
    //  Type: EPTF_LGenBase_FsmNextStateCalcDeclarator
    // 
    //  Purpose:
    //    Record type for describing next state calculation functions
    // 
    //  Elements:
    //    - fnName - *charstring* - name of the registered function 
    //    - argsList - <EPTF_IntegerList> - arguments for the function
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_FsmNextStateCalcDeclarator{
      charstring fnName, //EPTF_LGenBase_NextStateCalc_FT fn,
      EPTF_IntegerList argsList optional
    }
    
    ///////////////////////////////////////////////////////////
    //  Type: EPTF_LGenBase_FsmNextStateCalcWithParamsDeclarator
    // 
    //  Purpose:
    //    Record type for describing next state calculation functions
    // 
    //  Elements:
    //    - fnName - *charstring* - name of the registered function 
    //    - argsList - <EPTF_LGenBase_FsmActionArgsDeclarator> - arguments for the function
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_FsmNextStateCalcWithParamsDeclarator{
      charstring fnName, //EPTF_LGenBase_NextStateCalc_FT fn,
      EPTF_LGenBase_FsmActionArgsDeclarator argsList
    }
    
    ///////////////////////////////////////////////////////////
    //  Type: EPTF_LGenBase_FsmVarParams
    // 
    //  Purpose:
    //    Record type for describing EPTF variable arguments in FSMs
    // 
    //  Elements:
    //    - varName - *charstring* - name of the variable 
    //    - paramValue - <EPTF_Var_DirectContent> - additional constant argument
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_FsmVarParams{
      charstring varName,
      EPTF_Var_DirectContent paramValue optional
    }
    
    ///////////////////////////////////////////////////////////
    //  Type: EPTF_LGenBase_FsmStatMeasParams
    // 
    //  Purpose:
    //    Record type for describing <EPTF_StatMeasure_Statistics> arguments in FSMs
    // 
    //  Elements:
    //    - statMeasName - *charstring* - name of the stat 
    //    - paramValue - <EPTF_Var_DirectContent> - additional constant argument
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_FsmStatMeasParams{
      charstring statMeasName,
      EPTF_Var_DirectContent paramValue optional
    }
    
    ///////////////////////////////////////////////////////////
    //  Type: EPTF_LGenBase_EventToSibling
    // 
    //  Purpose:
    //    Record type for describing an <EPTF_LGenBase_ReportedEventDescriptor> 
    //    arguments in FSMs.
    //    See also <f_EPTF_LGenBase_step_dispatchEventToSibling>
    // 
    //  Elements:
    //    - siblingName - *charstring* - the sibling name of the target FSM 
    //    - behaviorName - *charstring* - the name of the behavior of the event to be dispatched 
    //    - inputName - *charstring* - the name of the input of the event to be dispatched 
    //    - argVarName - *charstring* - the name of an FSM variable to pass parameters to the target FSM
    //      The variable must be declared in the source FSM 
    //
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_EventToSibling{
      charstring siblingName,
      charstring behaviorName,
      charstring inputName,
      charstring argVarName optional
    }
    
    ///////////////////////////////////////////////////////////
    //  Type: EPTF_LGenBase_EventToTC
    // 
    //  Purpose:
    //    Record type for describing an <EPTF_LGenBase_ReportedEventDescriptor> 
    //    arguments in FSMs.
    //    See also <f_EPTF_LGenBase_step_dispatchEventToTC>
    // 
    //  Elements:
    //    - tcName - *charstring* - the name of the target traffic case 
    //    - siblingName - *charstring* - the sibling name of the target FSM 
    //    - behaviorName - *charstring* - the name of the behavior of the
    //      event to be dispatched 
    //    - inputName - *charstring* - the name of the input of the
    //      event to be dispatched 
    //    - argVarName - *charstring* - the name of an FSM variable to 
    //      pass parameters to the target FSM
    //      The variable must be declared in the source FSM 
    //
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_EventToTC{
      charstring tcName,
      charstring behaviorName,
      charstring inputName,
      charstring argVarName optional
    }
    
    ///////////////////////////////////////////////////////////
    //  Type: EPTF_LGenBase_ReplyEvent
    // 
    //  Purpose:
    //    Record type for describing an <EPTF_LGenBase_ReportedEventDescriptor> 
    //    arguments in FSMs.
    //    See also <f_EPTF_LGenBase_step_dispatchReply>
    // 
    //  Elements:
    //    - behaviorName - *charstring* - the name of the behavior of the event to be dispatched 
    //    - inputName - *charstring* - the name of the input of the event to be dispatched 
    //    - argVarName - *charstring* - the name of an FSM variable to pass parameters to the target FSM
    //      The variable must be declared in the source FSM 
    //
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_ReplyEvent{
      charstring behaviorName,
      charstring inputName,
      charstring argVarName optional
    }
    
    ///////////////////////////////////////////////////////////
    //  Type: EPTF_LGenBase_ReplyEventOfFsm
    // 
    //  Purpose:
    //    Record type for describing an <EPTF_LGenBase_ReportedEventDescriptor> 
    //    arguments in FSMs.
    //    See also <f_EPTF_LGenBase_step_dispatchReplyOfFsm>
    // 
    //  Elements:
    //    - inputName - *charstring* - the name of the input of the event to be dispatched 
    //    - argVarName - *charstring* - the name of an FSM variable to pass parameters to the target FSM
    //      The variable must be declared in the source FSM 
    //
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_EventOfFsm{
      charstring inputName,
      charstring argVarName optional
    }
    
    ///////////////////////////////////////////////////////////
    //  Type: EPTF_LGenBase_VerdictArg
    // 
    //  Purpose:
    //    Record type for describing a verdict with reason 
    //    arguments in FSMs.
    // 
    //  Elements:
    //    - verdict - *verdicttype* - the verdict 
    //    - reason - *charstring* - the reason phrase
    //
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_VerdictArg{
      verdicttype verdict,
      charstring reason optional
    }
    ///////////////////////////////////////////////////////////
    //  Type: EPTF_LGenBase_FsmActionArgsDeclarator
    // 
    //  Purpose:
    //    Record type for describing arguments for steps in FSMs
    // 
    //  Elements:
    //    - stepContextArgs - <EPTF_IntegerList> - step arguments in <EPTF_IntegerList> form
    //    - timerName -  charstring - FSM timer
    //    - varNames -  <EPTF_CharstringList> - List of the names of the referred FSM variables
    //    - varParams -  <EPTF_LGenBase_FsmVarParams> - The name of an FSM variable and an optional constant 
    //    - statMeasParams - <EPTF_LGenBase_FsmStatMeasParams> - The name of an FSM statMeasure stat and an optional constant
    //    - statName - *charstring* - statHandler statistics
    //    - statMeasName - *charstring* - statMeasure statistics
    //    - eventToSibling - <EPTF_LGenBase_EventToSibling> - describs an <EPTF_LGenBase_ReportedEventDescriptor> 
    //  Detailed Comments:
    //    The FSM declaration process translates these arguments into an <EPTF_IntegerList> form.
    //    The LGenBase provides functions for the step functions to get back the represented data.
    ///////////////////////////////////////////////////////////
    type union EPTF_LGenBase_FsmActionArgsDeclarator{
      EPTF_IntegerList stepContextArgs,
      charstring timerName,
      EPTF_CharstringList varNames,
      EPTF_LGenBase_FsmVarParams varParams,
      EPTF_LGenBase_FsmStatMeasParams statMeasParams,
      charstring statName,
      charstring statMeasName,
      EPTF_LGenBase_EventToSibling eventToSibling,
      EPTF_LGenBase_ReplyEvent replyEvent,
      EPTF_LGenBase_EventToTC eventToTC,
      EPTF_LGenBase_EventOfFsmToSibling eventOfFsmToSibling,
      EPTF_LGenBase_EventOfFsm eventOfFsm,
      charstring charstringValue,
      EPTF_LGenBase_VerdictArg verdict
    }
    
    ///////////////////////////////////////////////////////////
    //  Type: EPTF_LGenBase_EventOfFsmToSibling
    // 
    //  Purpose:
    //    Record type for describing an <EPTF_LGenBase_ReportedEventDescriptor> 
    //    arguments in FSMs.
    //    See also <f_EPTF_LGenBase_step_dispatchEventOfFsmToSibling>
    // 
    //  Elements:
    //    - siblingName - *charstring* - the sibling name of the target FSM 
    //    - inputName - *charstring* - the name of the input of the event to be dispatched 
    //    - argVarName - *charstring* - the name of an FSM variable to pass parameters to the target FSM
    //      The variable must be declared in the source FSM 
    //
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_EventOfFsmToSibling{
      charstring siblingName,
      charstring inputName,
      charstring argVarName optional
    }
    
    ///////////////////////////////////////////////////////////
    //  Type: EPTF_LGenBase_FsmActionDeclarator
    // 
    //  Purpose:
    //    Record type for describing steps in FSMs
    // 
    //  Elements:
    //    - stepOrFunctionName -  *charstring* - Step function
    //    - contextArgs - <EPTF_LGenBase_FsmActionArgsDeclarator> - step argument
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_FsmActionDeclarator {
      charstring stepOrFunctionName, //EPTF_LGenBase_TestStepFunction_FT
      EPTF_LGenBase_FsmActionArgsDeclarator contextArgs optional
    }
    
    ///////////////////////////////////////////////////////////
    //  Type: EPTF_LGenBase_FsmActionDeclaratorList
    // 
    //  Purpose:
    //    Record of EPTF_LGenBase_FsmActionDeclarators
    ///////////////////////////////////////////////////////////
    type record of EPTF_LGenBase_FsmActionDeclarator EPTF_LGenBase_FsmActionDeclaratorList
    
    ///////////////////////////////////////////////////////////
    //  Type: EPTF_LGenBase_FsmActionDeclarator
    // 
    //  Purpose:
    //    Record to declare a list of steps to be inserted by
    //    the <f_EPTF_LGenBase_insertFsmSteps> function
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_FsmActionListInsertDeclarator{
      charstring name,
      EPTF_LGenBase_FsmActionDeclaratorList actions
    }
    
    ///////////////////////////////////////////////////////////
    //  Type: EPTF_LGenBase_FsmActionListInsertDeclaratorList
    // 
    //  Purpose:
    //    Record of <EPTF_LGenBase_FsmActionListInsertDeclarator>
    ///////////////////////////////////////////////////////////
    type record of EPTF_LGenBase_FsmActionListInsertDeclarator EPTF_LGenBase_FsmActionListInsertDeclaratorList;
    ///////////////////////////////////////////////////////////
    //  Type: EPTF_LGenBase_FsmTableCellDeclarator
    // 
    //  Purpose:
    //    Record type for describing a cell of an FSM
    // 
    //  Elements:
    //    - actionList -  <EPTF_LGenBase_FsmActionDeclaratorList> - List of steps with their arguments
    //    - nextStateCalculation - <EPTF_LGenBase_FsmNextStateCalcDeclarator> - Function to calculate the next state after the execution of the steps 
    //    - nextState - *charstring* - Next state after the execution of the steps 
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_FsmTableCellDeclarator {
      EPTF_LGenBase_FsmActionDeclaratorList actionList optional,
      EPTF_LGenBase_FsmNextStateCalcDeclarator nextStateCalculation optional, //calc method for the next state    
      charstring nextState optional //pointer to the next state
    }
    
    ///////////////////////////////////////////////////////////
    //  Type: EPTF_LGenBase_FsmTableCellDeclaratorList
    // 
    //  Purpose:
    //    Record of <EPTF_LGenBase_FsmTableCellDeclarator>
    ///////////////////////////////////////////////////////////
    type record of EPTF_LGenBase_FsmTableCellDeclarator EPTF_LGenBase_FsmTableCellDeclaratorList;
    
    type record EPTF_LGenBase_FsmTableCellWithExtNext {
      EPTF_LGenBase_FsmActionDeclaratorList actionList optional,
      EPTF_LGenBase_FsmNextStateCalcWithParamsDeclarator nextStateCalculation //calc method and params for the next state    
    }
    ///////////////////////////////////////////////////////////
    //  Type: EPTF_LGenBase_FsmTableCellAnyUndefinedState
    // 
    //  Purpose:
    //    Declares that the associated cell in the <EPTF_LGenBase_FsmStatedTableCellDeclarator>
    //    must be used in all states which don't have associated cells. 
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_FsmTableCellAnyUndefinedState{}
    
    ///////////////////////////////////////////////////////////
    //  Type: EPTF_LGenBase_FsmTableCellStateDeclarator
    // 
    //  Purpose:
    //    This union contains the available state descriptions used
    //    in <EPTF_LGenBase_FsmStatedTableCellDeclarator> 
    ///////////////////////////////////////////////////////////
    type union EPTF_LGenBase_FsmTableCellStateDeclarator{
      charstring state,
      EPTF_CharstringList stateList,
      EPTF_LGenBase_FsmTableCellAnyUndefinedState anyUndefinedState
    }
    
    ///////////////////////////////////////////////////////////
    //  Type: EPTF_LGenBase_FsmStatedTableCellDeclarator
    // 
    //  Purpose:
    //    Declares an FSM cell with the state(s) in which it must be executed. 
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_FsmStatedTableCellDeclarator {
      EPTF_LGenBase_FsmTableCellStateDeclarator inState,
      EPTF_LGenBase_FsmTableCellDeclarator cell
    }
    
    ///////////////////////////////////////////////////////////
    //  Type: EPTF_LGenBase_FsmStatedTableCellDeclaratorList
    // 
    //  Purpose:
    //    Record of EPTF_LGenBase_FsmStatedTableCellDeclarator. 
    ///////////////////////////////////////////////////////////
    type record of EPTF_LGenBase_FsmStatedTableCellDeclarator EPTF_LGenBase_FsmStatedTableCellDeclaratorList;
    
    ///////////////////////////////////////////////////////////
    //  Type: EPTF_LGenBase_FsmStatedTableCellExtendedDeclarator
    // 
    //  Purpose:
    //    Declares an FSM cell with the state(s) and more sophisticated
    //    parameters for the next state calculation function. 
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_FsmStatedTableCellExtendedDeclarator {
      EPTF_LGenBase_FsmTableCellStateDeclarator inState,
      EPTF_LGenBase_FsmTableCellWithExtNext cell
    }
    
    ///////////////////////////////////////////////////////////
    //  Type: EPTF_LGenBase_FsmStatedTableCellExtendedDeclaratorList
    // 
    //  Purpose:
    //    Record of <EPTF_LGenBase_FsmStatedTableCellExtendedDeclarator>. 
    ///////////////////////////////////////////////////////////
    type record of EPTF_LGenBase_FsmStatedTableCellExtendedDeclarator EPTF_LGenBase_FsmStatedTableCellExtendedDeclaratorList
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_FsmTableRowDeclarator
    //
    // Purpose:
    //   Data type to declare the rows of an FSM table.
    //
    // Elements:
    //   - eventToListen - <EPTF_LGenBase_EventDescriptor> reference to the event that
    //     is used as input for the row of the FSM table
    //   - cellRow - <EPTF_LGenBase_FsmTableCellList> cells of the row of the FSM table 
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_FsmTableRowDeclarator {
      EPTF_LGenBase_EventDeclarator eventToListen,
      EPTF_LGenBase_FsmTableCellDeclaratorList cellRow
    }
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_FsmTableRowDeclaratorList
    //
    // Purpose:
    //   List of <EPTF_LGenBase_FsmTableRowDeclarator>s
    //
    // Elements:
    //   record of <EPTF_LGenBase_FsmTableRowDeclarator>
    ///////////////////////////////////////////////////////////
    type record of EPTF_LGenBase_FsmTableRowDeclarator EPTF_LGenBase_FsmTableRowDeclaratorList;
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_ExtendedFsmTableRowDeclaratorList
    //
    // Purpose:
    //   List of <EPTF_LGenBase_ExtendedFsmTableRowDeclarator>s
    //
    // Elements:
    //   record of <EPTF_LGenBase_ExtendedFsmTableRowDeclarator>
    ///////////////////////////////////////////////////////////
    type record of EPTF_LGenBase_ExtendedFsmTableRowDeclarator EPTF_LGenBase_ExtendedFsmTableRowDeclaratorList;
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_ExtendedFsmTableRowDeclarator
    //
    // Purpose:
    //   Data type to declare the rows of an extended FSM table.
    //
    // Elements:
    //   - events2Listen - <EPTF_LGenBase_Events2ListenDeclarator> defines a set of events that
    //     is used as input for the row of the FSM table
    //   - cellRow - <EPTF_LGenBase_UnionFsmTableCellRowDeclarator> cells of the row of the FSM table 
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_ExtendedFsmTableRowDeclarator {
      EPTF_LGenBase_Events2ListenDeclarator events2Listen,
      EPTF_LGenBase_UnionFsmTableCellRowDeclarator cellRow
    }
    
    
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_EventsFromSibling
    //
    // Purpose:
    //   Data type to declare events from a sibling FSM to be listened to
    //
    // Elements:
    //   - singleEventFromSibling - <EPTF_LGenBase_EventFromSiblingDeclarator>
    //   - eventListFromSibling - <EPTF_LGenBase_EventListFromSiblingDeclarator> 
    //   - eventRangeFromSibling - <EPTF_LGenBase_EventRangeFromSiblingDeclarator> 
    ///////////////////////////////////////////////////////////
    type union EPTF_LGenBase_EventsFromSibling{
      EPTF_LGenBase_EventFromSiblingDeclarator singleEventFromSibling,
      EPTF_LGenBase_EventListFromSiblingDeclarator eventListFromSibling,
      EPTF_LGenBase_EventRangeFromSiblingDeclarator eventRangeFromSibling
    }
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_Events2ListenDeclarator
    //
    // Purpose:
    //   Data type to declare a set of events.
    //
    // Elements:
    //   - events - <EPTF_LGenBase_EventSet> defines a set of events
    //   - catchAll - <EPTF_LGenBase_EventCatchAll> special event type: any event 
    //   - unhandled - <EPTF_LGenBase_EventCatchAll> special event type: unhandled events 
    ///////////////////////////////////////////////////////////
    type union EPTF_LGenBase_Events2ListenDeclarator{
      EPTF_LGenBase_EventSet events,
      EPTF_LGenBase_EventCatchAll catchAll,
      EPTF_LGenBase_EventUnhandled unhandled,
      EPTF_LGenBase_EventsFromSibling siblingEvents
    }
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_EventSet
    //
    // Purpose:
    //   Data a set of events
    ///////////////////////////////////////////////////////////
    type record of EPTF_LGenBase_EventSetItem EPTF_LGenBase_EventSet; 
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_EventSetItem
    //
    // Purpose:
    //   Data type to declare a single event or an event range or a list of events.
    //
    // Elements:
    //   - singleEvent - <EPTF_LGenBase_EventDeclarator> defines one event
    //   - eventList - <EPTF_LGenBase_EventListDeclarator> defines a list of events
    //   - eventRange - <EPTF_LGenBase_EventRangeDeclarator> defines a range of events 
    ///////////////////////////////////////////////////////////
    type union EPTF_LGenBase_EventSetItem{
      EPTF_LGenBase_EventDeclarator singleEvent,
      EPTF_LGenBase_EventListDeclarator eventList,
      EPTF_LGenBase_EventRangeDeclarator eventRange
    }
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_EventListDeclarator
    //
    // Purpose:
    //   Data type to declare a list of events
    //
    // Elements:
    //   - bName - <charstring> behaior of events
    //   - iNameList - <EPTF_CharstringList> list of input event names
    //   - eventType - <EPTF_LGenBase_ReportableEventType> scope of events 
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_EventListDeclarator {
      charstring bName,
      EPTF_CharstringList iNameList,
      EPTF_LGenBase_ReportableEventType eventType
    }
    
    ///////////////////////////////////////////////////////////
    //  Type: EPTF_LGenBase_EventRangeDeclarator
    // 
    //  Purpose:
    //    Record type for describing an event range that can be listened by event listeners
    // 
    //  Elements:
    //    - bName - *charstring* - the behaviorType of the reportable event 
    //    - iNameMin - *charstring* - the name of the first reportable event or the range
    //    - iNameMax - *optional charstring* - the name of the last reportable event or the range
    //            if omit, the structures referres 1 event instead of a range of events
    //    - eventType - <EPTF_LGenBase_ReportableEventType>  - the event-level
    //      class of the reportable event. 
    /////////////////////////////////////////////////////////
    type record EPTF_LGenBase_EventRangeDeclarator {
      charstring bName,
      charstring iNameMin,
      charstring iNameMax,
      EPTF_LGenBase_ReportableEventType eventType
    }
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_EventCatchAll
    //
    // Purpose:
    //   Type for describing any event - used by event listener to catch all events
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_EventCatchAll{}
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_EventUnhandled
    //
    // Purpose:
    //   Type for describing unhandled events - used to handle events are not listened
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_EventUnhandled{}
    
    group SiblingEvents{
      ///////////////////////////////////////////////////////////
      //  Type: EPTF_LGenBase_EventFromSiblingDeclarator
      // 
      //  Purpose:
      //    Record type for describing events
      //    sent by a specified sibling FSM
      // 
      //  Elements:
      //    - siblingName - *charstring* - the sibling name of the FSM which sent the event 
      //    - iName - *charstring* - the name of the reportable event w.r.t. to bName
      //    - eventType - <EPTF_LGenBase_ReportableEventType>  - the event-level
      //      class of the reportable event. 
      // 
      //  Detailed Comments:
      //      -
      /////////////////////////////////////////////////////////
      type record EPTF_LGenBase_EventFromSiblingDeclarator{
        charstring siblingName,
        charstring iName,
        EPTF_LGenBase_ReportableEventType eventType
      }
      
      ///////////////////////////////////////////////////////////
      // Type: EPTF_LGenBase_EventListFromSiblingDeclarator
      //
      // Purpose:
      //    Data type to declare a list of events
      //    sent by a specified sibling FSM
      //
      // Elements:
      //    - siblingName - *charstring* - the sibling name of the FSM which sent the event 
      //    - iNameList - <EPTF_CharstringList> list of input names
      //    - eventType - <EPTF_LGenBase_ReportableEventType>  - the event-level
      //      class of the reportable event. 
      ///////////////////////////////////////////////////////////
      type record EPTF_LGenBase_EventListFromSiblingDeclarator {
        charstring siblingName,
        EPTF_CharstringList iNameList,
        EPTF_LGenBase_ReportableEventType eventType
      }
      
      ///////////////////////////////////////////////////////////
      //  Type: EPTF_LGenBase_EventRangeFromSiblingDeclarator
      // 
      //  Purpose:
      //    Record type for describing an event range 
      //    sent by a specified sibling FSM
      // 
      //  Elements:
      //    - siblingName - *charstring* - the sibling name of the FSM which sent the event 
      //    - iNameMin - *charstring* - the name of the first reportable event or the range
      //    - iNameMax - *optional charstring* - the name of the last reportable event 
      //      or the range 
      //      if omit, the structure refers 1 event instead of a range of events
      //    - eventType - <EPTF_LGenBase_ReportableEventType>  - the event-level
      //      class of the reportable event. 
      /////////////////////////////////////////////////////////
      type record EPTF_LGenBase_EventRangeFromSiblingDeclarator {
        charstring siblingName,
        charstring iNameMin,
        charstring iNameMax,
        EPTF_LGenBase_ReportableEventType eventType
      }
      
    }
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_UnionFsmTableCellRowDeclarator
    //
    // Purpose:
    //   Data type to declare the rows of cells in an FSM table.
    //
    // Elements:
    //   - classicCellRow - <EPTF_LGenBase_FsmTableCellDeclaratorList> list of cells 
    ///////////////////////////////////////////////////////////
    type union EPTF_LGenBase_UnionFsmTableCellRowDeclarator{
      EPTF_LGenBase_FsmTableCellDeclaratorList classicCellRow,
      EPTF_LGenBase_FsmStatedTableCellDeclaratorList statedCellRow,
      EPTF_LGenBase_FsmStatedTableCellExtendedDeclaratorList extStatedCellRow
    }
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_FsmLocalStateList
    //
    // Purpose:
    //   Data type for declaring states of given FSM table. 
    //
    // Elements:
    //   record of *charstring*
    ///////////////////////////////////////////////////////////
    type record of charstring EPTF_LGenBase_FsmLocalStateList;
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_FsmLocalTimer
    //
    // Purpose:
    //   Data type for declaring a static timer of a given FSM table. 
    //
    // Elements:
    //   name - *charstring* - The name of the timer. Used in FSM declarations
    //   startValue - *float* - The time in sec when the timer times out from its start
    ///////////////////////////////////////////////////////////
    type record  EPTF_LGenBase_FsmLocalTimer {
      charstring name,
      float startValue
    } 
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_FsmLocalTimerList
    //
    // Purpose:
    //   Data type for declaring timers of a given FSM table. 
    //
    // Elements:
    //   record of <EPTF_LGenBase_FsmLocalTimer>
    ///////////////////////////////////////////////////////////
    type record of EPTF_LGenBase_FsmLocalTimer EPTF_LGenBase_FsmLocalTimerList;
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_FSMTimerParameters
    //
    // Purpose:
    //   Data type for declaring the parameters of the type
    //   <EPTF_LGenBase_FsmTimer>, which declares a timer
    //   of a given FSM table. 
    //
    // Elements:
    //   - static - <EPTF_LGenBase_FSMTimerParamsStatic>
    //   - random - <EPTF_LGenBase_FSMTimerParamsRandom>
    //   - randomGauss - <EPTF_LGenBase_FSMTimerParamsRandomGauss>
    ///////////////////////////////////////////////////////////
    type union EPTF_LGenBase_FSMTimerParameters{
      EPTF_LGenBase_FSMTimerParamsStatic static,
      EPTF_LGenBase_FSMTimerParamsRandom random,
      EPTF_LGenBase_FSMTimerParamsRandomGauss randomGauss
    }

    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_FSMTimerParametersList
    //
    // Purpose:
    //   Data type for declaring the parameters of timers of a given FSM table. 
    //
    // Elements:
    //   record of <EPTF_LGenBase_FSMTimerParameters>
    ///////////////////////////////////////////////////////////    
    type record of EPTF_LGenBase_FSMTimerParameters EPTF_LGenBase_FSMTimerParametersList;
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_FSMTimerParamsStatic
    //
    // Purpose:
    //   Data type for declaring the parameters of a static timer
    //   of a given FSM table. 
    //
    // Elements:
    //   startValue - *float* - The time in sec when the timer times out from its start
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_FSMTimerParamsStatic{
      float startValue
    }
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_FSMTimerParamsRandom
    //
    // Purpose:
    //   Data type for declaring parameters of a timer of a given FSM table.
    //
    // Elements:
    //   name - *charstring* - The name of the timer. Used in FSM declarations
    //   timeoutMin - *float* - The minimal time in sec when the timer times out from its start
    //   timeoutMax - *float* - The maximal time in sec when the timer times out from its start
    //
    // Detailed Comments:
    //   The timer times out randomly after a delay between the
    //   minimal and maximal timeout values.
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_FSMTimerParamsRandom{
      float timeoutMin,
      float timeoutMax
    }
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_FSMTimerParamsRandomGauss
    //
    // Purpose:
    //   Data type for declaring parameters of a timer of a given FSM table.
    //
    // Elements:
    //   name - *charstring* - The name of the timer. Used in FSM declarations
    //   timeoutMin - *float* - The minimal time in sec when the timer times out from its start
    //   timeoutMax - *float* - The maximal time in sec when the timer times out from its start
    //
    // Detailed Comments:
    //   The timer times out randomly after a delay between the
    //   minimal and maximal timeout values. The random values
    //   follow normal (Gaussian) distribution.
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_FSMTimerParamsRandomGauss{
      float mean,
      float deviation
    }
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_FsmTimer
    //
    // Purpose:
    //   Data type for declaring a timer of a given FSM table. 
    //
    // Elements:
    //   - name - *charstring* - The name of the timer. Used in FSM declarations
    //   - timerParams - <EPTF_LGenBase_FSMTimerParameters> - The required
    //     arguments according to the specified behavior of the
    //     timer
    //
    // Detailed Comments:
    //   The timer can have different behaviors according to the
    //   selected *timerParams* parameter. See the different
    //   choices of the <EPTF_LGenBase_FSMTimerParameters> type.
    ///////////////////////////////////////////////////////////
    type record  EPTF_LGenBase_FsmTimer {
      charstring name,
      EPTF_LGenBase_FSMTimerParameters timerParams
    }
    
    type record of EPTF_LGenBase_FsmTimer EPTF_LGenBase_FsmTimerList;
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_FsmRandomTimer
    //
    // Purpose:
    //   Data type for declaring a timer of a given FSM table. 
    //
    // Elements:
    //   name - *charstring* - The name of the timer. Used in FSM declarations
    //   timeoutMin - *float* - The minimal time in sec when the timer times out from its start
    //   timeoutMax - *float* - The maximal time in sec when the timer times out from its start
    ///////////////////////////////////////////////////////////
    type record  EPTF_LGenBase_FsmRandomTimer {
      charstring name,
      float timeoutMin,
      float timeoutMax
    } 
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_FsmRandomTimer
    //
    // Purpose:
    //   Data type for declaring random timers of a given FSM table. 
    //
    // Elements:
    //   record of <EPTF_LGenBase_FsmRandomTimer>
    ///////////////////////////////////////////////////////////
    type record of EPTF_LGenBase_FsmRandomTimer EPTF_LGenBase_FsmRandomTimerList
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_CompactFsmTableDeclarator
    //
    // Purpose:
    //   Data type for declaring compact FSM table. 
    //
    // Elements:
    //   name - *charstring* - The name ID of the FSM
    //   stateList - <EPTF_LGenBase_FsmLocalStateList> - The states in the FSM  
    //   timerList - <EPTF_LGenBase_FsmLocalTimerList> - The FSM timers
    //   table - <EPTF_LGenBase_FsmTableRowDeclaratorList> - The 2D description 
    //   of the FSM cells 
    ///////////////////////////////////////////////////////////
    type record EPTF_LGenBase_CompactFsmTableDeclarator {
      charstring name,
      EPTF_LGenBase_FsmLocalStateList stateList,
      EPTF_LGenBase_FsmLocalTimerList timerList,
      EPTF_LGenBase_FsmTableRowDeclaratorList table
    }
    
    ///////////////////////////////////////////////////////////
    // Type: EPTF_LGenBase_CompactFsmTableDeclaratorList
    //
    // Purpose:
    //   Data type for declaring list of compact FSM tables. 
    ///////////////////////////////////////////////////////////
    type record of EPTF_LGenBase_CompactFsmTableDeclarator EPTF_LGenBase_TcMgmt_CompactFsmTableDeclaratorList;
    
    type EPTF_LGenBase_CompactFsmTableDeclarator EPTF_LGenBase_IndexedFsmTableDeclarator;
    
    type record of EPTF_LGenBase_IndexedFsmTableDeclarator EPTF_LGenBase_TcMgmt_IndexedFsmTableDeclaratorList;
  }
}//FSM

group FSMR3{
  //FSMSibling2
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_FsmObjectScopeDeclarator
  //
  // Purpose:
  //   Declares the scope of a variable or statistic used in FSM declaration 
  //
  // Elements:
  //   FSM - all the FSM contexts will have their own specimen of the object
  //   TC - There will be a single common object in the traffic case
  //   SiblingFSM - Each sibling FSM of the same entity share the same object
  ///////////////////////////////////////////////////////////
  type enumerated EPTF_LGenBase_FsmObjectScopeDeclarator {FSM, TC, SiblingFSM}
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_FsmVarDeclarator
  //
  // Purpose:
  //   Declares a variable in an FSM 
  //
  // Elements:
  //   name - *charstring* - The name ID of the variable
  //   initValue - <EPTF_Var_DirectContent> - The initial value of the variable
  //   scope - <EPTF_LGenBase_FSMVarScope> - describes where to store the variable.
  //     The created variable will be unique in the specified scope.
  ///////////////////////////////////////////////////////////
  type record EPTF_LGenBase_FsmVarDeclarator{
    charstring name,
    EPTF_Var_DirectContent initValue,
    EPTF_LGenBase_FsmObjectScopeDeclarator scope 
  }
  ///////////////////////////////////////////////////////////
  // Type: c_EPTF_LGenBase_emptyFsmVarDeclarator
  //
  // Purpose:
  //   Empty default initializer value of an <EPTF_LGenBase_FsmVarDeclarator>
  ///////////////////////////////////////////////////////////
  const EPTF_LGenBase_FsmVarDeclarator c_EPTF_LGenBase_emptyFsmVarDeclarator := {
    "", {intVal := 0}, FSM
  }
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_FsmVarDeclaratorList
  //
  // Purpose:
  //   A record of <EPTF_LGenBase_FsmVarDeclarator> records
  ///////////////////////////////////////////////////////////
  type record of EPTF_LGenBase_FsmVarDeclarator EPTF_LGenBase_FsmVarDeclaratorList;
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_FsmStatProviderVars
  //
  // Purpose:
  //   The names of the data providers of the specified statistic
  ///////////////////////////////////////////////////////////
  type EPTF_CharstringList EPTF_LGenBase_FsmStatProviderVars
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_FsmStatProviderVarsList
  //
  // Purpose:
  //   List of <EPTF_LGenBase_FsmStatProviderVars>
  ///////////////////////////////////////////////////////////
  type record of EPTF_LGenBase_FsmStatProviderVars EPTF_LGenBase_FsmStatProviderVarsList;
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_FsmStatDeclarator
  //
  // Purpose:
  //   Declares statistics used in FSM steps 
  //
  // Elements:
  //   name - *charstring* - The name ID of the variable
  //   refType - <EPTF_Var_RefType> - The type of the content of the variable
  //   scope - <EPTF_LGenBase_FsmVarScope> - describes where to store the variable.
  //     The created variable will be unique in the specified scope.
  ///////////////////////////////////////////////////////////
  type record EPTF_LGenBase_FsmStatDeclarator{
    charstring name,
    EPTF_LGenBase_FsmStatProviderVarsList providersList,
    charstring statMethod,
    EPTF_Var_DirectContent statResetValue,
    EPTF_LGenBase_FsmObjectScopeDeclarator scope 
  }
  ///////////////////////////////////////////////////////////
  // Type: c_EPTF_LGenBase_emptyFsmStatDeclarator
  //
  // Purpose:
  //   Empty default initializer value of an <EPTF_LGenBase_FsmStatDeclarator>
  ///////////////////////////////////////////////////////////
  const EPTF_LGenBase_FsmStatDeclarator c_EPTF_LGenBase_emptyFsmStatDeclarator := {
    "",{},"", {intVal := 0}, FSM
  }
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_FsmStatDeclaratorList
  //
  // Purpose:
  //   A record of <EPTF_LGenBase_FsmStatDeclarator> records
  ///////////////////////////////////////////////////////////
  type record of EPTF_LGenBase_FsmStatDeclarator EPTF_LGenBase_FsmStatDeclaratorList;
  
  type union EPTF_LGenBase_FsmStatHandlerProvider{
    EPTF_CharstringList varList,
    charstring statMeas,
    charstring statHandler
  }
  
  type record of EPTF_LGenBase_FsmStatHandlerProvider EPTF_LGenBase_FsmStatHandlerProviderList 
  
  type record EPTF_LGenBase_FsmStatHandlerDeclarator{
    charstring name,
    EPTF_LGenBase_FsmStatHandlerProviderList providers,
    charstring statMethod,
    EPTF_Var_DirectContent statResetValue,
    EPTF_LGenBase_FsmObjectScopeDeclarator scope 
  }
  type record of EPTF_LGenBase_FsmStatHandlerDeclarator EPTF_LGenBase_FsmStatHandlerDeclaratorList
  type record EPTF_LGenBase_FsmStatMeasDeclarator{
    charstring name,
    charstring varName,
    EPTF_StatMeasure_statType statType,
    EPTF_LGenBase_FsmObjectScopeDeclarator scope 
  }
  const EPTF_LGenBase_FsmStatMeasDeclarator c_EPTF_LGenBase_emptyFsmStatMeasDeclarator :={
    "", "", content, FSM
  }
  type record of EPTF_LGenBase_FsmStatMeasDeclarator EPTF_LGenBase_FsmStatMeasDeclaratorList
  
  type union EPTF_LGenBase_FSMStatMeasParams{
    EPTF_StatMeasure_statType statType,
    EPTF_StatMeasure_StatParams params
  }  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_FsmStatMeasWithParamsDeclarator
  //
  // Purpose:
  //   Declares parameters of statMeas statistic declarations where
  //   the statMeas statistic requires boundaries
  ///////////////////////////////////////////////////////////
  type record EPTF_LGenBase_FsmStatMeasWithParamsDeclarator{
    charstring name,
    charstring providerVarName,
    charstring targetVarName optional,
    EPTF_LGenBase_FSMStatMeasParams statMeasParams,
    EPTF_LGenBase_FsmObjectScopeDeclarator scope 
  }
  const EPTF_LGenBase_FsmStatMeasWithParamsDeclarator c_EPTF_LGenBase_emptyFsmStatMeasWithParamsDeclarator :={
    "", "", "", {statType := content}, FSM
  }
  type record of EPTF_LGenBase_FsmStatMeasWithParamsDeclarator EPTF_LGenBase_FsmStatMeasWithParamsDeclaratorList
  
  //FSMSibling2
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_declareEvents
  //
  // Purpose:
  //   Declares the enlisted FSM events with the behavior 
  //   having the name of the FSM.
  //
  // Elements:
  //   useDefaultEvents - *boolean* - Declare the events
  //     enlisted in the <tsp_LGenBase_FSMDefaultEvents>
  //   eventList - <EPTF_CharstringList> - The list of user-defined
  //     events to be declared 
  //
  ///////////////////////////////////////////////////////////
  type record EPTF_LGenBase_declareEvents{
    boolean useDefaultEvents,
    EPTF_CharstringList eventList
  }
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_FsmParams
  //
  // Purpose:
  //   Collects the descriptors of the FSM environment
  //
  // Developer Comments:
  //   First, we can extend the FSM environment without the necessity of rewriting 
  //   the previously written user code.
  //   In second, using this union we can make it optional to declare the elements of 
  //   the FSM environment. E.g. users don't have to declare an empty list
  //   of variables if they don't use them.
  ///////////////////////////////////////////////////////////
  type union EPTF_LGenBase_FsmParams{
    EPTF_LGenBase_FsmLocalStateList stateList,
    EPTF_LGenBase_FsmLocalTimerList timerList,
    EPTF_LGenBase_FsmVarDeclaratorList varList,
    EPTF_LGenBase_FsmStatDeclaratorList statisticList,
    EPTF_LGenBase_FsmStatMeasDeclaratorList statMeasStatList,
    EPTF_LGenBase_FsmStatMeasWithParamsDeclaratorList statMeasWithParamsList,
    EPTF_LGenBase_FsmStatHandlerDeclaratorList statHandlerStatList,
    EPTF_LGenBase_FsmRandomTimerList randomTimerList,
    EPTF_LGenBase_declareEvents declareEvents,
    EPTF_LGenBase_FsmTimerList fsmTimerList
  }
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_FSMParamsList
  //
  // Purpose:
  //   Record of <EPTF_LGenBase_FSMParams> records
  ///////////////////////////////////////////////////////////
  type record of EPTF_LGenBase_FsmParams EPTF_LGenBase_FsmParamsList;
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_FlexFsmTableRowDeclarator
  //
  // Purpose:
  //   A union of type declarator for the FSM table rows.
  //   This is declared as a union because of later modifications
  ///////////////////////////////////////////////////////////
  type union EPTF_LGenBase_FlexFsmTableRowDeclarator {
    EPTF_LGenBase_FsmTableRowDeclaratorList classicTable,
    EPTF_LGenBase_ExtendedFsmTableRowDeclaratorList extendedTable
  }
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_FsmTableDeclarator
  //
  // Purpose:
  //   Data type for declaring FSM table. 
  //
  // Elements:
  //   name - *charstring* - The name ID of the FSM
  //   fsmParams - <EPTF_LGenBase_FSMParamsList> - The FSM basic descriptor of the working 
  //     environment of the FSM.
  //   table - <EPTF_LGenBase_FlexFsmTableRowDeclaratorList> - The 2D description 
  //     of the FSM cells 
  ///////////////////////////////////////////////////////////
  type record EPTF_LGenBase_FsmTableDeclarator {
    charstring name,
    EPTF_LGenBase_FsmParamsList fsmParams,
    EPTF_LGenBase_FlexFsmTableRowDeclarator table
  }
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_FsmTableDeclaratorList
  //
  // Purpose:
  //   List of <EPTF_LGenBase_FsmTableDeclarator> records
  ///////////////////////////////////////////////////////////
  type record of EPTF_LGenBase_FsmTableDeclarator EPTF_LGenBase_FsmTableDeclaratorList
  
  type record EPTF_LGenBase_StatisticOfTC{
    charstring declaredName,
    charstring statName,
    EPTF_StatHandler_StatMethod statMethod,
    EPTF_Var_DirectContent statResetValue
  }
  type record of EPTF_LGenBase_StatisticOfTC EPTF_LGenBase_StatisticOfTCList
  
  type record EPTF_LGenBase_StatisticListOfTC{
    charstring entityGroup,
    charstring scenario,
    charstring tc,
    EPTF_LGenBase_StatisticOfTCList stats
  }
  const EPTF_LGenBase_StatisticListOfTC c_EPTF_LGenBase_emptyStatisticListOfTC := {
    "","","",{}
  }
  type record of EPTF_LGenBase_StatisticListOfTC EPTF_LGenBase_StatisticListOfTCList
}//FSMR3

group Obsolete{
  modulepar EPTF_LGenBase_ScenarioDeclaratorList  tsp_LGenBase_ScenarioDeclarators := {};
  modulepar EPTF_LGenBase_tcTypeDeclaratorList    tsp_LGenBase_tcTypeDeclarators := {};
  
  // Declarator2
  modulepar EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList tsp_LGenBase_EntityGrpDeclarators := {};
  modulepar EPTF_LGenBase_TcMgmt_Scenarios2GrpList       tsp_LGenBase_Scenarios2Grps := {};
  modulepar EPTF_LGenBase_ScenarioTypeDeclaratorList     tsp_LGenBase_TcMgmt_ScenarioDeclarators3 := {}; // weighted and non weighted too
  
  modulepar EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList tsp_LGenBase_TcMgmt_tcTypeDeclarators2 := {};
  modulepar EPTF_LGenBase_TcMgmt_WeightedScenarioDeclaratorList tsp_LGenBase_TcMgmt_WeightedScenarioDeclarators := {}
  modulepar EPTF_LGenBase_TcMgmt_ScenarioDeclaratorList tsp_LGenBase_TcMgmt_ScenarioDeclarators2 := {};
  
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TcMgmt_GroupFinishActionListType
  //
  // Purpose: Types of actions that will be executed when a
  // group finish condition becomes true or a traffic launch ends.
  //
  // Elements:
  //  - onGroupFinishCondition - The actions will be fired when the <groupFinishConditions> of
  //    a traffic case becomes true. See <EPTF_LGenBase_TcOfScenario2>.
  //  - onLaunchFinish - The actions will be fired when the last traffic of the traffic case returns the acknowledgement.
  ///////////////////////////////////////////////////////////
  type enumerated EPTF_LGenBase_TcMgmt_GroupFinishActionListType{
    onGroupFinishCondition, onLaunchFinish
  }
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TcMgmt_tcTypeDeclarator2
  //
  // Purpose:
  //   Used to declare a traffic case type in TITAN config file and in
  //   <f_EPTF_LGenBase_declareTcType2> and <f_EPTF_LGenBase_declareTcType3> function. 
  // 
  // Elements:
  //   - name - *charstring* - the name of the traffic case type
  //   - fsmName - *charstring* - FSM table name of the TC
  //   - entityType - *charstring* - the type of the entity executing the traffic case
  //   - customEntitySucc - *charstring* - the registered name of
  //                                       a user-defined function to evaluate the state of the entity
  //										 at the end of a traffic. If it's empty, the <f_EPTF_LGenBase_successSucNoFail> will be called.
  //
  // Detailed Comments:
  //   It doesn't contain the fields that have default initial values,
  //   so it simplifies the declaration code.
  //
  //   The customEntitySucc must contain the name of a previously declared 
  //   <EPTF_LGenBase_evaluateSuccess4EntityAtEntityGroup2_FT> function or can be empty.
  ///////////////////////////////////////////////////////////
  type record EPTF_LGenBase_TcMgmt_tcTypeDeclarator2 {
    charstring name,
    charstring fsmName,
    charstring entityType,
    charstring customEntitySucc  //if EMPTY then default
  }
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TcMgmt_tcDeclarator2List
  //
  // Purpose: List of <EPTF_LGenBase_TcMgmt_tcTypeDeclarator2> records.
  ///////////////////////////////////////////////////////////
  type record of EPTF_LGenBase_TcMgmt_tcTypeDeclarator2 EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList;
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TcMgmt_GroupActions2
  //
  // Purpose: Describes what to do when a group finish condition of
  // a traffic case becomes true, or when the last traffic of the traffic case returns the acknowledgement.
  //
  // Elements:
  // - actionsType - <EPTF_LGenBase_TcMgmt_GroupFinishActionListType> - When to do the actions. 
  // - actions - <EPTF_LGenBase_TcMgmt_GroupActionsList> - The actions to be executed.
  ///////////////////////////////////////////////////////////
  type record EPTF_LGenBase_TcMgmt_GroupActions2 {
    EPTF_LGenBase_TcMgmt_GroupFinishActionListType actionsType, 
    EPTF_LGenBase_TcMgmt_GroupActionsList actions
  }
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TcMgmt_GroupActions2List
  //
  // Purpose: List of <EPTF_LGenBase_TcMgmt_GroupActions2> records.
  type record of EPTF_LGenBase_TcMgmt_GroupActions2 EPTF_LGenBase_TcMgmt_GroupActions2List;
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TcMgmt_GroupFinishConditions
  //
  // Purpose: When one of these conditions becomes true, the launch of the 
  // traffic of the specified traffic case will stop, and the
  // actions described in the <EPTF_LGenBase_TcMgmt_GroupActionsList> of the
  // <EPTF_LGenBase_tcTypeDeclarator> structures will be fired. 
  //////////////////////////////////////////////////////////
  type record EPTF_LGenBase_TcMgmt_GroupFinishConditions {
    integer nrOfExecStart optional,
    integer nrOfSuccesses optional,
    integer nrOfFails optional,
    integer nrOfGrpLoop optional,
    integer nrOfRangeLoop optional,
    float execTime optional,
    charstring customFinishCondition optional
  }
  
  ///////////////////////////////////////////////////////////
  // Constant: c_EPTF_LGenBase_TcMgmt_emptyGroupFinishConditions
  //
  // Purpose: An empty initializer structure of <EPTF_LGenBase_TcMgmt_GroupFinishConditions>
  ///////////////////////////////////////////////////////////
  const EPTF_LGenBase_TcMgmt_GroupFinishConditions c_EPTF_LGenBase_TcMgmt_emptyGroupFinishConditions := {omit, omit, omit, omit, omit, omit, omit};
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TcMgmt_GroupFinishConditions
  //
  // Purpose: When one of these conditions becomes true, the launch of the 
  // traffic of the specified traffic case will stop, and the
  // actions described in the <EPTF_LGenBase_TcMgmt_TcOfScenario2> or <EPTF_LGenBase_TcMgmt_TcOfScenario3> structure
  // of the record <EPTF_LGenBase_TcMgmt_ScenarioDeclarator2> or <EPTF_LGenBase_TcMgmt_ScenarioDeclarator3> will be fired. 
  //////////////////////////////////////////////////////////
  type record EPTF_LGenBase_TcMgmt_GroupFinishConditions2 {
    integer nrOfExecStart optional,
    integer nrOfSuccesses optional,
    integer nrOfFails optional,
    integer nrOfGrpLoop optional,
    integer nrOfRangeLoop optional,
    float execTime optional,
    boolean entitiesFinished optional,
    charstring customFinishCondition optional
  }
  
  ///////////////////////////////////////////////////////////
  // Constant: c_EPTF_LGenBase_TcMgmt_emptyGroupFinishConditions2
  //
  // Purpose: An empty initializer structure of <EPTF_LGenBase_TcMgmt_GroupFinishConditions>
  ///////////////////////////////////////////////////////////
  const EPTF_LGenBase_TcMgmt_GroupFinishConditions2 c_EPTF_LGenBase_TcMgmt_emptyGroupFinishConditions2 := {omit, omit, omit, omit, omit, omit, omit, omit};
  
  /////////////////////////////////////////
  // Template: EPTF_LGenBase_TcMgmt_GroupFinishConditions2
  //
  // Purpose: Template to make it easy to fill the newer EPTF_LGenBase_TcMgmt_GroupFinishConditions2 
  // structure from an earlier EPTF_LGenBase_TcMgmt_GroupFinishConditions.
  /////////////////////////////////////////
  template EPTF_LGenBase_TcMgmt_GroupFinishConditions2 
  EPTF_LGenBase_TcMgmt_GroupFinishConditions2FromPrev(EPTF_LGenBase_TcMgmt_GroupFinishConditions pl_prev):={
    pl_prev.nrOfExecStart,
    pl_prev.nrOfSuccesses,
    pl_prev.nrOfFails,
    pl_prev.nrOfGrpLoop,
    pl_prev.nrOfRangeLoop,
    pl_prev.execTime,
    omit,
    pl_prev.customFinishCondition
  }
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TcMgmt_EntityFinishConditions
  //
  // Purpose: When one of these conditions becomes true, the launch of the 
  // traffic on the specified entity of the specified traffic case will stop, and the
  // actions described in the <EPTF_LGenBase_TcMgmt_EntityActionsList> of the
  // <EPTF_LGenBase_tcTypeDeclarator> or in the <EPTF_LGenBase_TcMgmt_TcOfScenario2> or <EPTF_LGenBase_TcMgmt_TcOfScenario3> structure
  // of the record <EPTF_LGenBase_TcMgmt_ScenarioDeclarator2> or <EPTF_LGenBase_TcMgmt_ScenarioDeclarator3> will be fired. 
  //////////////////////////////////////////////////////////
  type record EPTF_LGenBase_TcMgmt_EntityFinishConditions {
    integer nrOfExecStart optional,
    integer nrOfSuccesses optional,
    integer nrOfFails optional,
    charstring customFinishCondition optional
  }
  ///////////////////////////////////////////////////////////
  // Constant: c_EPTF_LGenBase_TcMgmt_emptyEntityFinishConditions
  //
  // Purpose: An empty initializer structure of <EPTF_LGenBase_TcMgmt_EntityFinishConditions>
  ///////////////////////////////////////////////////////////
  const EPTF_LGenBase_TcMgmt_EntityFinishConditions c_EPTF_LGenBase_TcMgmt_emptyEntityFinishConditions := {omit, omit, omit, omit};
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_WeightedScenarioExtraData
  //
  // Purpose: Additional data for the weighted scenario declarator
  //
  // Elements:
  //   deterministicMix - *boolean* - the traffic case selection will be counted
  //   before the start of traffic generation, or the traffic cases will be
  //   chosen runtime rundomly
  ///////////////////////////////////////////////////////////
  type record EPTF_LGenBase_WeightedScenarioExtraData{    
    //float cpsToReach ,
    boolean deterministicMix 
  }
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TcMgmt_ScenarioDeclarator2
  //
  // Purpose: Declares a list of traffic cases as a scenario.
  ///////////////////////////////////////////////////////////
  type record EPTF_LGenBase_TcMgmt_ScenarioDeclarator2{
    charstring name,
    EPTF_LGenBase_TcMgmt_TcOfScenario2List tcList
  }
  
  const EPTF_LGenBase_TcMgmt_ScenarioDeclarator2 c_EPTF_LGenBase_TcMgmt_emptyScenarioDeclarator2 := {"", {} }
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TcMgmt_WeightedScenarioDeclarator
  //
  // Purpose: Declares a list of weighted traffic cases in scenario
  ///////////////////////////////////////////////////////////
  type record EPTF_LGenBase_TcMgmt_WeightedScenarioDeclarator{
    charstring name,
    boolean enabled,
    float cpsToReach,
    boolean lockCPS,
    EPTF_LGenBase_WeightedScenarioExtraData weightedScData,
    EPTF_LGenBase_TcMgmt_TcOfWeightedScenarioList tcList
  }  
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TcMgmt_TcOfScenario2List
  //
  // Purpose: List of <EPTF_LGenBase_TcMgmt_TcOfScenario2> records.
  ///////////////////////////////////////////////////////////
  type record of EPTF_LGenBase_TcMgmt_TcOfScenario2 EPTF_LGenBase_TcMgmt_TcOfScenario2List;
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TcMgmt_TcOfWeightedScenarioList
  //
  // Purpose: List of <EPTF_LGenBase_TcMgmt_TcOfWeightedScenario> records.
  ///////////////////////////////////////////////////////////
  type record of EPTF_LGenBase_TcMgmt_TcOfWeightedScenario EPTF_LGenBase_TcMgmt_TcOfWeightedScenarioList;
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TcMgmt_ScenarioDeclaratorList
  //
  // Purpose: List of <EPTF_LGenBase_TcMgmt_ScenarioDeclarator2> records.
  ///////////////////////////////////////////////////////////
  type record of EPTF_LGenBase_TcMgmt_ScenarioDeclarator2 EPTF_LGenBase_TcMgmt_ScenarioDeclaratorList;    
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TcMgmt_WeightedScenarioDeclaratorList
  //
  // Purpose: List of <EPTF_LGenBase_TcMgmt_WeightedScenarioDeclarator> records.
  ///////////////////////////////////////////////////////////
  type record of EPTF_LGenBase_TcMgmt_WeightedScenarioDeclarator EPTF_LGenBase_TcMgmt_WeightedScenarioDeclaratorList;
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TcMgmt_TcOfScenario2
  //
  // Purpose: Describes the parameters of a traffic case in the specified scenario.
  //
  // Elements:
  //   - tcName - *charstring* - refers the name of the traffic case type
  //   - startDelay - *float* - traffic case should start only after the specified amount of time (given in seconds)
  //   - cpsToReach - *float* - cps value for this traffic case instance. The actual value may be decomposed when the traffic case running distributed on several LGens
  //   - enableEntities - *boolean* - the entities have to be in enabled or disabled state after creating the traffic case
  //   - enable - *boolean* - the traffic case will be enabled or disabled after creation
  //   - ranges - <EPTF_LGenBase_TcMgmt_ParamRangeDeclaratorList> - Range descriptors for the traffic case. 
  //     The dispatched <c_EPTF_LGenBase_inputIdx_testMgmt_startTC> events of <c_EPTF_LGenBase_bIdx> 
  //     behavior get their traffic parameter from this range. See also: <t_startTcOfFsm>, <f_EPTF_LGenBase_doTrafficCaseTimerAction>.  
  //   - params - <EPTF_LGenBase_TcMgmt_tcCustomParamDeclaratorList> - Retrievable charstring parameters. See <f_EPTF_LGenBase_getCharstringParamValue>
  //   - groupFinishConditions - <EPTF_LGenBase_TcMgmt_GroupFinishConditions> - When one of these conditions becomes true, the launch of the 
  //     traffic of the specified traffic case will stop, and the
  //     actions described in the groupFinishActions will be fired.
  //   - entityFinishConditions - <EPTF_LGenBase_TcMgmt_EntityFinishConditions> - When one of these conditions becomes true, the launch of the 
  // 	 traffic on the specified entity of the specified traffic case will stop, and the
  //     actions described in the entityFinishActions will be fired.
  //   - tcFinishActions - <EPTF_LGenBase_TcMgmt_GroupActions2List> - List of actions that will be executed when a
  //     group finish condition becomes true or the last traffic of the traffic case returns the acknowledgement.
  //   - entityFinishActions - <EPTF_LGenBase_TcMgmt_EntityActionsList> - List of actions that will be executed when an
  // 	 entity finish condition becomes true.
  //   The finish conditions and actions declared in the <EPTF_LGenBase_TcMgmt_TcOfScenario2> for a
  //   traffic case will overwrite the conditions occasionally declared in <EPTF_LGenBase_tcTypeDeclarator>
  type record EPTF_LGenBase_TcMgmt_TcOfScenario2{
    charstring tcName,
    float startDelay optional,
    float cpsToReach,
    boolean enableEntities,
    boolean enable, 
    EPTF_LGenBase_TcMgmt_ParamRangeDeclaratorList ranges optional,
    EPTF_LGenBase_TcMgmt_tcCustomParamDeclaratorList params optional,
    //finishConditions
    EPTF_LGenBase_TcMgmt_GroupFinishConditions2 groupFinishConditions optional,
    EPTF_LGenBase_TcMgmt_EntityFinishConditions entityFinishConditions optional,
    //actionLists
    EPTF_LGenBase_TcMgmt_EntityActionsList entityFinishActions optional,
    EPTF_LGenBase_TcMgmt_GroupActions2List tcFinishActions optional
  }
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TcMgmt_TcOfWeightedScenario
  //
  // Purpose: Describes the parameters of a traffic case in the specified scenario.
  //
  // Elements:  
  //   - tcName - *charstring* - refers the name of the traffic case type
  //   - tcWeight - *float* - The weight of the tc in the scenario
  //   - enableEntities - *boolean* - the entities have to be in enabled or disabled state after creating the traffic case
  //   - enable - *boolean* - the traffic case will be enabled or disabled after creation
  //   - ranges - <EPTF_LGenBase_TcMgmt_ParamRangeDeclaratorList> - Range descriptors for the traffic case. 
  //     The dispatched <c_EPTF_LGenBase_inputIdx_testMgmt_startTC> events of <c_EPTF_LGenBase_bIdx> 
  //     behavior get their traffic parameter from this range. See also: <t_startTcOfFsm>, <f_EPTF_LGenBase_doTrafficCaseTimerAction>.  
  //   - params - <EPTF_LGenBase_TcMgmt_tcCustomParamDeclaratorList> - Retrievable charstring parameters. See <f_EPTF_LGenBase_getCharstringParamValue>
  //   - groupFinishConditions - <EPTF_LGenBase_TcMgmt_GroupFinishConditions> - When one of these conditions becomes true, the launch of the 
  //     traffic of the specified traffic case will stop, and the
  //     actions described in the groupFinishActions will be fired.
  //   - entityFinishConditions - <EPTF_LGenBase_TcMgmt_EntityFinishConditions> - When one of these conditions becomes true, the launch of the 
  //     traffic on the specified entity of the specified traffic case will stop, and the
  //     actions described in the entityFinishActions will be fired.
  //   - tcFinishActions - <EPTF_LGenBase_TcMgmt_GroupActions2List> - List of actions that will be executed when a
  //     group finish condition becomes true or the last traffic of the traffic case returns the acknowledgement.
  //   - entityFinishActions - <EPTF_LGenBase_TcMgmt_EntityActionsList> - List of actions that will be executed when an
  //     entity finish condition becomes true.
  //   The finish conditions and actions declared in the <EPTF_LGenBase_TcMgmt_TcOfWeightedScenario> for a
  //   traffic case will overwrite the conditions occasionally declared in <EPTF_LGenBase_tcTypeDeclarator>
  type record EPTF_LGenBase_TcMgmt_TcOfWeightedScenario{
    charstring tcName, 
    //float startDelay,
    float tcWeight,   
    boolean enableEntities,
    boolean enable, 
    EPTF_LGenBase_TcMgmt_ParamRangeDeclaratorList ranges optional,
    EPTF_LGenBase_TcMgmt_tcCustomParamDeclaratorList params optional,
    //finishConditions
    EPTF_LGenBase_TcMgmt_GroupFinishConditions2 groupFinishConditions optional,
    EPTF_LGenBase_TcMgmt_EntityFinishConditions entityFinishConditions optional,
    //actionLists
    EPTF_LGenBase_TcMgmt_EntityActionsList entityFinishActions optional,
    EPTF_LGenBase_TcMgmt_GroupActions2List tcFinishActions optional
  }
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_tcTypeDeclarator
  //
  // Purpose:
  //   Obsolete structure to declare a traffic case type in TITAN config file. 
  // 
  // Elements:
  //   - name - *charstring* - the name of the traffic case type
  //   - fsmName - *charstring* - FSM table name of the TC
  //   - cCount - *integer* - the amount of entities within the group
  //   - entityType - *charstring* - the type of the entity executing the traffic case
  //   - customEntitySucc - *charstring* - the registered name of
  //                                       a user-defined function to evaluate the traffic
  //                                       case result. If EMPTY then default
  //   - groupFinishConditions - <EPTF_LGenBase_TcMgmt_GroupFinishConditions> - When one of these conditions becomes true, the launch of the 
  //     traffic of the specified traffic case will stop, and the
  //     actions described in the groupFinishActions will be fired.
  //   - entityFinishConditions - <EPTF_LGenBase_TcMgmt_EntityFinishConditions> - When one of these conditions becomes true, the launch of the 
  // 	 traffic on the specified entity of the specified traffic case will stop, and the
  //     actions described in the entityFinishActions will be fired.
  //   - groupFinishActions - <EPTF_LGenBase_TcMgmt_GroupActionsList> - List of actions that will be executed when a
  //     group finish condition becomes true.
  //   - entityFinishActions - <EPTF_LGenBase_TcMgmt_EntityActionsList> - List of actions that will be executed when an
  // 	 entity finish condition becomes true.
  //   - params - <EPTF_LGenBase_TcMgmt_tcCustomParamDeclaratorList> - Retrievable charstring parameters. See <f_EPTF_LGenBase_getCharstringParamValue>
  //
  // Detailed Comments:
  //   It doesn't contain the fields that have default initial values,
  //   so it simplifies the declaration code.
  //
  //   The customEntitySucc must contain the name of a previously declared 
  //   <EPTF_LGenBase_evaluateSuccess4EntityAtEntityGroup_FT> function or can be empty.
  ///////////////////////////////////////////////////////////
  type record EPTF_LGenBase_tcTypeDeclarator {
    charstring name,
    charstring fsmName,
    charstring entityType,
    charstring customEntitySucc,  //if EMPTY then default
    //finishConditions
    EPTF_LGenBase_TcMgmt_GroupFinishConditions groupFinishConditions,
    EPTF_LGenBase_TcMgmt_EntityFinishConditions entityFinishConditions,
    //actionLists
    EPTF_LGenBase_TcMgmt_GroupActionsList  groupFinishActions,
    EPTF_LGenBase_TcMgmt_EntityActionsList entityFinishActions,
    // custom tc params
    EPTF_LGenBase_TcMgmt_tcCustomParamDeclaratorList params
  }
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_tcTypeDeclaratorList
  //
  // Purpose:
  //   Record of <EPTF_LGenBase_tcTypeDeclarator> to provide a container for
  //   arbitrary number of <EPTF_LGenBase_tcTypeDeclarator> values
  //
  // Elements:
  //   record of <EPTF_LGenBase_tcTypeDeclarator>
  //////////////////////////////////////////////////////////
  type record of EPTF_LGenBase_tcTypeDeclarator EPTF_LGenBase_tcTypeDeclaratorList;
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_ScenarioDeclarator
  //
  // Purpose:
  //   Used in declaring a traffic scenario in TITAN config file. 
  //
  // Elements:
  //   - name - *charstring* - the name of the traffic scenario
  //   - tcList - <EPTF_LGenBase_TcOfScenarioList> - list of traffic cases associated with this scenario
  // 
  // Detailed Comments:
  //   It doesn't contain the fields that have default initial values,
  //   so it simplifies the declaration code.
  ///////////////////////////////////////////////////////////
  type record EPTF_LGenBase_ScenarioDeclarator{
    charstring name,
    EPTF_LGenBase_TcOfScenarioList tcList
  }
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_ScenarioDeclaratorList
  //
  // Purpose:
  //   Record of <EPTF_LGenBase_ScenarioDeclarator> to provide a container for
  //   arbitrary number of <EPTF_LGenBase_ScenarioDeclarator> values
  //
  // Elements:
  //   record of <EPTF_LGenBase_ScenarioDeclarator>
  //////////////////////////////////////////////////////////
  type record of EPTF_LGenBase_ScenarioDeclarator EPTF_LGenBase_ScenarioDeclaratorList;
  
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TcOfScenario
  //
  // Purpose:
  //   Obsolete structure to declare a traffic case of a scenario in TITAN config file. 
  //
  // Elements:
  //   - tcName - *charstring* - refers the name of the traffic case type
  //   - startDelay - *float* - traffic case should start only after the specified amount of time (given in seconds)
  //   - cpsToReach - *float* - cps value for this traffic case instance. The actual value may be decomposed when the traffic case running distributed on several LGens
  //   - enableEntities - *boolean* - the entities have to be in enabled or disabled state after creating the traffic case
  //   - enable - *boolean* - the traffic case will be enabled or disabled after creation
  //   - ranges - <EPTF_LGenBase_TcMgmt_ParamRangeDeclaratorList> - ranges to be given as parameters of the start traffic steps
  //
  // Detailed Comments:
  //   It doesn't contain the fields that have default initial values,
  //   so it simplifies the declaration code.
  ///////////////////////////////////////////////////////////
  type record EPTF_LGenBase_TcOfScenario{
    charstring tcName,
    float startDelay,
    float cpsToReach,
    boolean enableEntities,
    boolean enable,
    EPTF_LGenBase_TcMgmt_ParamRangeDeclaratorList ranges
  }
  
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LGenBase_TcOfScenarioList
  //
  // Purpose:
  //   Record of <EPTF_LGenBase_TcOfScenario> to provide a container for
  //   arbitrary number of <EPTF_LGenBase_TcOfScenario> values
  //
  // Elements:
  //   record of <EPTF_LGenBase_TcOfScenario>
  //////////////////////////////////////////////////////////
  type record of EPTF_LGenBase_TcOfScenario EPTF_LGenBase_TcOfScenarioList;
  
}
//FSMSibling2
const charstring c_EPTF_LGenBase_FSMEventFinishedSuccess := "FSM finished successfully"
const charstring c_EPTF_LGenBase_FSMEventFinishedFail := "FSM finished with failure"
const charstring c_EPTF_LGenBase_FSMEventFinishedError := "FSM finished with error"
const charstring c_EPTF_LGenBase_FSMEventFinishedTimeout := "FSM finished with timeout"

const EPTF_CharstringList c_EPTF_LGenBase_DefaultFSMEvents := {
  c_EPTF_LGenBase_FSMEventFinishedSuccess,
  c_EPTF_LGenBase_FSMEventFinishedFail,
  c_EPTF_LGenBase_FSMEventFinishedError,
  c_EPTF_LGenBase_FSMEventFinishedTimeout
}

}  // end of module