///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2000-2018 Ericsson Telecom AB
//
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// which accompanies this distribution, and is available at
// http://www.eclipse.org/legal/epl-v10.html
///////////////////////////////////////////////////////////////////////////////
//
//  File:     EPTF_MBT_LGen_Functions.ttcn
//  Rev:      <RnXnn>
//  Prodnr:   CNL 113 659
//  Updated:  2010-10-01
//  Contact:  http://ttcn.ericsson.se
///////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////
//  Module: EPTF_MBT_LGen_Functions
//
//  Purpose:
//    Functions of the MBT Applib
//
//  Module depends on:
//    - <EPTF_MBT_LGen_Definitions>
//    - <EPTF_CLL_Logging_Definitions>
//    - <EPTF_CLL_Logging_Functions>
//    - <EPTF_CLL_Common_Definitions>
//    - <EPTF_CLL_Variable_Definitions>
//    - <EPTF_CLL_Variable_Functions>
//    - <EPTF_CLL_Scheduler_Definitions>
//    - <EPTF_CLL_Base_Definitions>
//    - <EPTF_CLL_Base_Functions>
//    - <EPTF_CLL_LGenBase_ConfigDefinitions>
//    - <EPTF_CLL_LGenBase_ConfigFunctions>
//    - <EPTF_CLL_LGenBase_Functions>
//    - <EPTF_CLL_LGenBase_Definitions>
//    - <EPTF_CLL_LGenBase_EventHandlingFunctions>
//    - <EPTF_CLL_LGenBase_StepFunctions>
//    - <EPTF_CLL_RBTScheduler_Functions>
//    - <EPTF_CLL_Semaphore_Functions>
//////////////////////////////////////////////////// 
module EPTF_MBT_LGen_Functions
{

import from EPTF_MBT_LGen_Definitions all;
import from EPTF_CLL_Logging_Definitions all;
import from EPTF_CLL_Logging_Functions all;
import from EPTF_CLL_Common_Definitions all;
import from EPTF_CLL_Variable_Definitions all;
import from EPTF_CLL_Variable_Functions all;
import from EPTF_CLL_Scheduler_Definitions all;
import from EPTF_CLL_Base_Definitions all;
import from EPTF_CLL_Base_Functions all;
import from EPTF_CLL_LGenBase_ConfigDefinitions all;
import from EPTF_CLL_LGenBase_ConfigFunctions all;
import from EPTF_CLL_LGenBase_Functions all;
import from EPTF_CLL_LGenBase_Definitions all;
import from EPTF_CLL_LGenBase_EventHandlingFunctions all;
import from EPTF_CLL_LGenBase_StepFunctions all;
import from EPTF_CLL_RBTScheduler_Functions all;
import from EPTF_CLL_Semaphore_Functions all;


///////////////////////////////////////////////////////////////////////////////
//  Function: f_EPTF_MBT_init
// 
//  Purpose:
//    Function to initialize MBT behaviour
// 
//  Parameters:
//    pl_selfName - *in* *charstring* - the components self name
//    pl_selfId - *in* *integer* - component self id
//    pl_entityNamePrefix - *in* *charstring* - entity name prefix
//    pl_numEntities - *in* *integer* - number of entities
//    pl_bind - *in* <EPTF_LGenBase_BehaviorContextBinder_FT> - behaviour  
//        context bind callback function
//    pl_reset - *in* <EPTF_LGenBase_BehaviorContextHandler_FT> - behaviour  
//        context reset callback function
//    pl_unbind - *in* <EPTF_LGenBase_BehaviorContextHandler_FT> - behaviour  
//        context unbind callback function
//   
//  Return Value:
//    -
// 
//  Errors:
//    -
//
//  Detailed Comments:
//    -
//
///////////////////////////////////////////////////////////////////////////////
function f_EPTF_MBT_init
(
  in charstring pl_selfName,
  in integer pl_selfId,
  in charstring pl_entityNamePrefix,
  in integer pl_numEntities := 0,
  in EPTF_LGenBase_BehaviorContextBinder_FT pl_bind := refers(f_EPTF_MBT_bindEntity),
  in EPTF_LGenBase_BehaviorContextHandler_FT pl_reset := refers(f_EPTF_MBT_resetEntity),  
  in EPTF_LGenBase_BehaviorContextHandler_FT pl_unbind := refers(f_EPTF_MBT_unbindEntity)
)
runs on EPTF_MBT_LGen_CT
{
  if(v_EPTF_MBT_initialized)
  {
    f_EPTF_Logging_warning(true,%definitionId&": The FTD applib on this component is already initialized!");
    return;
  }

  f_EPTF_LGenBase_init(pl_selfName);
  f_EPTF_Logging_init_CT(pl_selfName);
  f_EPTF_Semaphore_init_CT(pl_selfName);
  
  f_EPTF_Base_registerCleanup(refers(f_EPTF_MBT_cleanup_CT));
  
  v_EPTF_MBT_myBIdx := 
    f_EPTF_LGenBase_declareBehaviorType
    (c_EPTF_MBT_myBName, 
      -1,
      pl_reset,
      pl_bind, 
      pl_unbind
    );
  
  f_EPTF_MBT_declareEvents();
  f_EPTF_MBT_declareTestSteps();
  
  v_EPTF_MBT_LoggingMaskId := f_EPTF_Logging_registerComponentMasks("FTD_Logging", {"ERROR", "WARNING", "DEBUG"}, EPTF_Logging_CLL);
  f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, %definitionId & ": myBIdx is " & int2str(v_EPTF_MBT_myBIdx));
  
  activate(as_EPTF_MBT_PCO_Handler());
  
  //map(self:EPTF_MBT_PCO, system:EPTF_MBT_PCO);
  
  v_EPTF_MBT_initialized := true;
}
///////////////////////////////////////////////////////////////////////////////
//  Function: f_EPTF_MBT_cleanup_CT
// 
//  Purpose:
//    Cleanup function of the MBT Applib
// 
//  Parameters:
//   -
//   
//  Return Value:
//    -
// 
//  Errors:
//    -
//
//  Detailed Comments:
//    Unmaps the TestPorts from teh System 
//
///////////////////////////////////////////////////////////////////////////////
function f_EPTF_MBT_cleanup_CT()
runs on EPTF_MBT_LGen_CT
{
  f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, "### " & %definitionId);
  
  if (v_EPTF_MBT_initialized)
  {
    //unmap(self:EPTF_MBT_PCO, system:EPTF_MBT_PCO);
    
    v_EPTF_MBT_initialized := false;
  }
}
///////////////////////////////////////////////////////////////////////////////
//  Function: f_EPTF_MBT_declareEvents
// 
//  Purpose:
//    Register the EVents used by the MBT AppLib
// 
//  Parameters:
//   -
//   
//  Return Value:
//    -
// 
//  Errors:
//    -
//
//  Detailed Comments:
//    -
//
///////////////////////////////////////////////////////////////////////////////
function f_EPTF_MBT_declareEvents()
runs on EPTF_MBT_LGen_CT
{
  f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, "### " & %definitionId);
  var integer vl_temp := -1;

  vl_temp := f_EPTF_LGenBase_declareFsmEvent(c_EPTF_MBT_myBName,c_EPTF_MBT_inputName_incomingUserRequest);
  f_EPTF_Base_assert(%definitionId&": Error during registration of "&c_EPTF_MBT_inputName_incomingUserRequest, vl_temp == c_EPTF_MBT_inputIdx_incomingUserRequest);
  vl_temp := f_EPTF_LGenBase_declareFsmEvent(c_EPTF_MBT_myBName,c_EPTF_MBT_inputName_incomingTestStepRequest);
  f_EPTF_Base_assert(%definitionId&": Error during registration of "&c_EPTF_MBT_inputName_incomingTestStepRequest, vl_temp == c_EPTF_MBT_inputIdx_incomingTestStepRequest);
  vl_temp := f_EPTF_LGenBase_declareFsmEvent(c_EPTF_MBT_myBName,c_EPTF_MBT_inputName_reportedVerdict);
  f_EPTF_Base_assert(%definitionId&": Error during registration of "&c_EPTF_MBT_inputName_reportedVerdict, vl_temp == c_EPTF_MBT_inputIdx_reportedVerdict);
  
}
///////////////////////////////////////////////////////////////////////////////
//  Function: f_EPTF_MBT_declareTestSteps
// 
//  Purpose:
//    Register the TestSteps used by the MBT AppLib
// 
//  Parameters:
//   -
//   
//  Return Value:
//    -
// 
//  Errors:
//    -
//
//  Detailed Comments:
//    -
//
///////////////////////////////////////////////////////////////////////////////
function f_EPTF_MBT_declareTestSteps()
runs on EPTF_MBT_LGen_CT
{
  f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, "### " & %definitionId);
  
  f_EPTF_LGenBase_declareStep(
    pl_bName:=c_EPTF_MBT_myBName, 
    pl_step:={name:=c_EPTF_MBT_stepName_invokeTestStep,
      step:=refers(f_EPTF_MBT_TestStep_invokeTestStep)});
  f_EPTF_LGenBase_declareStep(
    pl_bName:=c_EPTF_MBT_myBName, 
    pl_step:={name:=c_EPTF_MBT_stepName_invokeUserFunction,
      step:=refers(f_EPTF_MBT_TestStep_invokeUserFunction)});
  f_EPTF_LGenBase_declareStep(
    pl_bName:=c_EPTF_MBT_myBName, 
    pl_step:={name:=c_EPTF_MBT_stepName_sendUserResponse,
      step:=refers(f_EPTF_MBT_TestStep_sendUserResponse)});
  f_EPTF_LGenBase_declareStep(
    pl_bName:=c_EPTF_MBT_myBName, 
    pl_step:={name:=c_EPTF_MBT_stepName_setMainFSM,
      step:=refers(f_EPTF_MBT_TestStep_setMainFSM)});
  f_EPTF_LGenBase_declareStep(
    pl_bName:=c_EPTF_MBT_myBName, 
    pl_step:={name:=c_EPTF_MBT_stepName_reportVerdict,
      step:=refers(f_EPTF_MBT_TestStep_reportVerdict)});
}

///////////////////////////////////////////////////////////////////////////////
//  Function: f_EPTF_MBT_bindEntity
// 
//  Purpose:
//   Bind function of the MBT AppLib
// 
//  Parameters:
//   -
//   
//  Return Value:
//    -
// 
//  Errors:
//    -
//
//  Detailed Comments:
//    -
//
///////////////////////////////////////////////////////////////////////////////
function f_EPTF_MBT_bindEntity(in integer pl_eIdx)
runs on EPTF_MBT_LGen_CT 
return EPTF_IntegerList
{
  f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, "### " & %definitionId & "() with eIdx: " & int2str(pl_eIdx));
  
  //var integer v_EPTF_MBT_index := sizeof(v_EPTF_MBT_Contexts);
  //v_EPTF_MBT_Contexts[v_EPTF_MBT_index] := c_MBT_DefaultCtx;
  //v_EPTF_MBT_Contexts[v_EPTF_MBT_index].eIdx := pl_eIdx;
  //return {v_EPTF_MBT_index};
  
  return {-1};
}
///////////////////////////////////////////////////////////////////////////////
//  Function: f_EPTF_MBT_unbindEntity
// 
//  Purpose:
//   Unbind function of the MBT AppLib
// 
//  Parameters:
//   -
//   
//  Return Value:
//    -
// 
//  Errors:
//    -
//
//  Detailed Comments:
//    -
//
///////////////////////////////////////////////////////////////////////////////
function f_EPTF_MBT_unbindEntity(in integer pl_eIdx)
runs on EPTF_MBT_LGen_CT
{
  f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, "### " & %definitionId & "() with eIdx: " & int2str(pl_eIdx));
}
///////////////////////////////////////////////////////////////////////////////
//  Function: f_EPTF_MBT_resetEntity
// 
//  Purpose:
//   Reset function of the MBT AppLib
// 
//  Parameters:
//   -
//   
//  Return Value:
//    -
// 
//  Errors:
//    -
//
//  Detailed Comments:
//    -
//
//////////////////////////////////////////////////////////////////////////////////
function f_EPTF_MBT_resetEntity(
  in integer pl_eIdx)
runs on EPTF_MBT_LGen_CT
{
  f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, "### " & %definitionId & "() with eIdx: " & int2str(pl_eIdx));
}


//*****************************************************************************
//                TestSteps of the MBT AppLib
//*****************************************************************************

///////////////////////////////////////////////////////////////////////////////
//  Function: f_EPTF_MBT_TestStep_invokeTestStep
// 
//  Purpose:
//   General Purpose wrapper TestStep to select the Proper TestStep based on its 
//   actual parameters and invokes it. Otherwise generates a log&console statement 
//
//  Parameters:
//   in EPTF_LGenBase_TestStepArgs pl_ptr
//   
//  Return Value:
//    -
// 
//  Errors:
//    -
//
//  Detailed Comments:
//    -
//
///////////////////////////////////////////////////////////////////////////////
function f_EPTF_MBT_TestStep_invokeTestStep(in EPTF_LGenBase_TestStepArgs pl_ptr) runs on EPTF_MBT_LGen_CT
{
  f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, log2str("### " & %definitionId & "() "));
  f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, log2str(%definitionId & "() pl_ptr: ", pl_ptr));
  f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, log2str(%definitionId & "() v_EPTF_MBT_TestStepRequest: ", v_EPTF_MBT_TestStepRequest));

  //var integer vl_fnIdx := f_EPTF_LGenBase_functionNameIndex(v_EPTF_MBT_TestStepRequest.stepName);
  //var EPTF_LGenBase_TestStepFunction_FT vl_fn:=null;
  var EPTF_LGenBase_RegisteredFunctions vl_fn;

  if (f_EPTF_LGenBase_functionReferenceByName(v_EPTF_MBT_TestStepRequest.stepName, vl_fn))
  {
    pl_ptr.refContext.fRefArgs := v_EPTF_MBT_TestStepRequest.stepArgs;
    if (ispresent(v_EPTF_MBT_TestStepRequest.addr))
    {
      pl_ptr.eIdx := v_EPTF_MBT_TestStepRequest.addr.eIdx;
      pl_ptr.refContext.fCtxIdx := v_EPTF_MBT_TestStepRequest.addr.fIdx;
    }
    f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, log2str(%definitionId & "() executing ", v_EPTF_MBT_TestStepRequest.stepName));
    f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, log2str(%definitionId & "() with pl_ptr: ", pl_ptr));

    //f_EPTF_LGenBase_getTesStepFunctionRef(v_EPTF_MBT_TestStepRequest.stepName, vl_fn);
    f_EPTF_LGenBase_functionReferenceByName(v_EPTF_MBT_TestStepRequest.stepName, vl_fn);
    if (ischosen(vl_fn.testStepFunction))
    {
      vl_fn.testStepFunction.apply(pl_ptr);
      if(ispresent(v_EPTF_MBT_TestStepRequest.lock) and v_EPTF_MBT_TestStepRequest.lock > -1)
      {
        f_EPTF_Semaphore_unlock(v_EPTF_MBT_TestStepRequest.lock);
      }
    }
    else
    {
      f_EPTF_Logging_warning(true, log2str(%definitionId & "(): Function was found, but not a test step: " & v_EPTF_MBT_TestStepRequest.stepName));
    }
  }
  else
  {
    f_EPTF_Logging_warning(true, log2str(%definitionId & "(): Step was not found: " & v_EPTF_MBT_TestStepRequest.stepName));
  }
  
}

///////////////////////////////////////////////////////////////////////////////
//  Function: f_EPTF_MBT_TestStep_sendUserResponse
// 
//  Purpose:
//   TestStep function to generate the User response,. It shall be invoked in case
//    of the unhandled events (FSM description) based on the generated event it 
//    sends back a response towards the Tester component
//
//  Parameters:
//   in EPTF_LGenBase_TestStepArgs pl_ptr
//   
//  Return Value:
//    -
// 
//  Errors:
//    -
//
//  Detailed Comments:
//    -
//
///////////////////////////////////////////////////////////////////////////////
function f_EPTF_MBT_TestStep_sendUserResponse(in EPTF_LGenBase_TestStepArgs pl_ptr) runs on EPTF_MBT_LGen_CT
{
  f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, log2str("### " & %definitionId & "() "));
  f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, log2str(%definitionId & "() pl_ptr: ", pl_ptr));
  f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, log2str(%definitionId & "() vf_EPTF_MBT_createUserResponse: ", vf_EPTF_MBT_createUserResponse));

  var boolean vl_autoResp := true;

  if(vf_EPTF_MBT_createUserResponse!=null)
  {
    vl_autoResp := not vf_EPTF_MBT_createUserResponse.apply(pl_ptr);           
  }

  if (vl_autoResp)
  {
    f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, log2str(%definitionId & "() v_LGenBase_reportedEvent: ",pl_ptr.reportedEvent));


    var integer vl_grpIdx := f_EPTF_LGenBase_getEGrpOfEntity(pl_ptr.eIdx);
    var integer vl_eIdx := pl_ptr.eIdx - f_EPTF_LGenBase_getEGrpBaseOffset(vl_grpIdx);

    var EPTF_MBT_TestStepResponse vl_resp :=
    {
      bName := f_EPTF_LGenBase_bIdx2Str(pl_ptr.reportedEvent.event.bIdx),
      iName := f_EPTF_LGenBase_iIdx2Str(pl_ptr.reportedEvent.event.bIdx,pl_ptr.reportedEvent.event.iIdx),  //TODO later one of the TestStep args will decsribe the events that has been dispatcehd
      addr :=
      {
        entityGroupName := f_EPTF_LGenBase_entityGroupName(vl_grpIdx),
        eIdx := pl_ptr.eIdx,
        fIdx := pl_ptr.refContext.fCtxIdx
      },
      args := pl_ptr.reportedEvent.reportedArgs
    }
    f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, log2str(%definitionId & "() user response: ", vl_resp));
    
    var EPTF_IntegerList vl_ctx := f_EPTF_LGenBase_getBehaviorCtx(pl_ptr.eIdx, v_EPTF_MBT_myBIdx);
    EPTF_MBT_PCO.send(vl_resp) to f_EPTF_Base_downcast(vl_ctx[0]);
  }    
}


///////////////////////////////////////////////////////////////////////////////
//  Function: f_EPTF_MBT_TestStep_invokeUserFunction
// 
//  Purpose:
//   TestStep function to invoke user specific function
//
//  Parameters:
//   in EPTF_LGenBase_TestStepArgs pl_ptr
//   
//  Return Value:
//    -
// 
//  Errors:
//    -
//
//  Detailed Comments:
//    It seraches for the user declared function basedon its name 
//    (stored in a component variable) and invokes it.) 
//
///////////////////////////////////////////////////////////////////////////////
function f_EPTF_MBT_TestStep_invokeUserFunction(in EPTF_LGenBase_TestStepArgs pl_ptr) runs on EPTF_MBT_LGen_CT
{
  f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, log2str("### " & %definitionId & "() "));
  f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, log2str(%definitionId & "() pl_ptr: ", pl_ptr));
  f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, log2str(%definitionId & "() v_EPTF_MBT_UserRequest: ", v_EPTF_MBT_UserRequest));

  var integer vl_fnIdx := f_EPTF_LGenBase_functionNameIndex(v_EPTF_MBT_UserRequest.functionName);
  var EPTF_LGenBase_RegisteredFunctions vl_fn;
  if (vl_fnIdx > 0)
  {
    f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, log2str(%definitionId & "() v_EPTF_MBT_UserRequest: ",v_EPTF_MBT_UserRequest));
    //vl_fn.apply(pl_ptr);
    //f_EPTF_LGenBase_getTesStepFunctionRef(v_EPTF_MBT_TestStepRequest.stepName, vl_fn);

    if (f_EPTF_LGenBase_functionReferenceByName(v_EPTF_MBT_TestStepRequest.stepName, vl_fn))
    {
      if (ischosen(vl_fn.testStepFunction))
      {
        vl_fn.testStepFunction.apply(pl_ptr);
      }
      else
      {
        f_EPTF_Logging_warning(true, log2str(%definitionId & "(): Function was found, but not a test step: " & v_EPTF_MBT_TestStepRequest.stepName));
      }
    }
    else
    {
      f_EPTF_Logging_warning(true, log2str(%definitionId & "(): Step was not found: " & v_EPTF_MBT_TestStepRequest.stepName));
    }
  }
  else
  {
    f_EPTF_Logging_warning(true, log2str(%definitionId & "(): Step was not found: " & v_EPTF_MBT_UserRequest.functionName));
  }

  var integer vl_grpIdx := f_EPTF_LGenBase_getEGrpOfEntity(pl_ptr.eIdx);
  var integer vl_eIdx := pl_ptr.eIdx - f_EPTF_LGenBase_getEGrpBaseOffset(vl_grpIdx);

  var EPTF_MBT_TestStepResponse vl_resp :=
  {
    bName := c_EPTF_MBT_myBName,
    iName :=f_EPTF_LGenBase_iIdx2Str(v_EPTF_MBT_myBIdx,pl_ptr.reportedEvent.event.iIdx),  //TODO later one of the TestStep args will decsribe the events that has been dispatcehd
    addr :=
    {
      entityGroupName := f_EPTF_LGenBase_entityGroupName(vl_grpIdx),
      eIdx := pl_ptr.eIdx,
      fIdx := pl_ptr.refContext.fCtxIdx
    },
    args := pl_ptr.reportedEvent.reportedArgs
  }
  var EPTF_IntegerList vl_ctx := f_EPTF_LGenBase_getBehaviorCtx(pl_ptr.eIdx, v_EPTF_MBT_myBIdx);
  f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, log2str(%definitionId & "() user response: ", vl_resp));
  EPTF_MBT_PCO.send(vl_resp) to f_EPTF_Base_downcast(vl_ctx[0]);  
}

function f_EPTF_MBT_TestStep_setMainFSM(in EPTF_LGenBase_TestStepArgs pl_ptr) runs on EPTF_MBT_LGen_CT
{
  if (sizeof(pl_ptr.refContext.fRefArgs)==2)
  {
    var integer vl_eIdx := pl_ptr.refContext.fRefArgs[0];
    var integer vl_fIdx := pl_ptr.refContext.fRefArgs[1];

    f_EPTF_LGenBase_setBehaviorCtxItem(pl_ptr.eIdx, v_EPTF_MBT_myBIdx, 1, vl_eIdx);
    f_EPTF_LGenBase_setBehaviorCtxItem(pl_ptr.eIdx, v_EPTF_MBT_myBIdx, 2, vl_fIdx);
  }
  else
  {
    f_EPTF_Logging_warning(true, log2str("### " & %definitionId & "(): Invalid parametrization, two parameters are required ", pl_ptr.refContext.fRefArgs));
  }
}

function f_EPTF_MBT_TestStep_reportVerdict(in EPTF_LGenBase_TestStepArgs pl_ptr) runs on EPTF_MBT_LGen_CT
{
  if (sizeof(pl_ptr.refContext.fRefArgs)==1)
  {
    var integer vl_verdict := pl_ptr.refContext.fRefArgs[0];

    var integer vl_eIdx := f_EPTF_LGenBase_getBehaviorCtxItem(pl_ptr.eIdx, v_EPTF_MBT_myBIdx, 1);
    var integer vl_fIdx := f_EPTF_LGenBase_getBehaviorCtxItem(pl_ptr.eIdx, v_EPTF_MBT_myBIdx, 2);

    f_EPTF_LGenBase_postEvent({{v_EPTF_MBT_myBIdx, c_EPTF_MBT_inputIdx_reportedVerdict,{vl_eIdx, vl_fIdx}, omit},{vl_verdict}});
  }
  else
  {
    f_EPTF_Logging_warning(true, log2str("### " & %definitionId & "(): Invalid parametrization, one parameter is required ", pl_ptr.refContext.fRefArgs));
  }
}

///////////////////////////////////////////////////////////////////////////////
//  Function: f_EPTF_MBT_Listener_catchEntityEvents
// 
//  Purpose:
//   This is a listener to catch all entity level events. Because unhandled
//   events in the FSM descriptor can catch only FSM level events.
//
//  Parameters:
//   in EPTF_LGenBase_ReportedEventDescriptor pl_event
//   in EPTF_IntegerList pl_listenerArgs
//   
//  Return Value:
//    -
// 
//  Errors:
//    -
//
//  Detailed Comments:
//    -
//
///////////////////////////////////////////////////////////////////////////////
function f_EPTF_MBT_Listener_catchEntityEvents(
    EPTF_LGenBase_ReportedEventDescriptor pl_event,
    EPTF_IntegerList pl_listenerArgs
) runs on EPTF_MBT_LGen_CT
{
  f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, log2str("### " & %definitionId & "() "));

  if (ispresent(pl_event.event.target) and not ispresent(pl_event.event.target.fsmCtxIdx))
  {
    // Only for entity level events
    f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, log2str(%definitionId & "() entity level event caught, calling sendUserResponse"));
    var EPTF_LGenBase_TestStepArgs vl_args :=
    {
      eIdx := pl_event.event.target.eIdx,
      refContext :=
      {
        fCtxIdx := -1, //related FSM context of the entity, if invoked via FSM
        fRefArgs := {} //args supplied in the context from which the step is referenced
      }, //FSM cell & context if invoked from FSM
      stepArgs:= {},
     reportedEvent:=pl_event
    }
    f_EPTF_MBT_TestStep_sendUserResponse(vl_args);
  }
  else
  {
    f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, log2str(%definitionId & "() dropping"));
  }
}

///////////////////////////////////////////////////////////////////////////////
//  Function: f_EPTF_MBT_Listener_catchGenericEvents
// 
//  Purpose:
//   This is a listener to catch all generic level events. Because unhandled
//   events in the FSM descriptor can catch only FSM level events.
//
//  Parameters:
//   in EPTF_LGenBase_ReportedEventDescriptor pl_event
//   in EPTF_IntegerList pl_listenerArgs
//   
//  Return Value:
//    -
// 
//  Errors:
//    -
//
//  Detailed Comments:
//    -
//
///////////////////////////////////////////////////////////////////////////////
function f_EPTF_MBT_Listener_catchGenericEvents(
    EPTF_LGenBase_ReportedEventDescriptor pl_event,
    EPTF_IntegerList pl_listenerArgs
) runs on EPTF_MBT_LGen_CT
{
  f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, log2str("### " & %definitionId & "() "));

  if (true /*ispresent(pl_event.event.target) and not ispresent(pl_event.event.target.fsmCtxIdx)*/)
  {
    // Only for entity level events
    /*
    f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, log2str(%definitionId & "() generic level event caught, calling sendUserResponse"));
    var EPTF_LGenBase_TestStepArgs vl_args :=
    {
      eIdx := pl_event.event.target.eIdx,
      refContext :=
      {
        fCtxIdx := -1, //related FSM context of the entity, if invoked via FSM
        fRefArgs := {} //args supplied in the context from which the step is referenced
      }, //FSM cell & context if invoked from FSM
      stepArgs:= {},
     reportedEvent:=pl_event
    }
    f_EPTF_MBT_TestStep_sendUserResponse(vl_args);
    */
    action("Generic caught: ", pl_event);
  }
  else
  {
    f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, log2str(%definitionId & "() dropping"));
  }
}

//////////////////////////////////////////////////////////////////
//
//
//                      Event Handler
//
//
////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////////////
//  Function: as_EPTF_MBT_PCO_Handler
// 
//  Purpose:
//   EventHandler of the MBT AppLib
//
//  Parameters:
//   -
//   
//  Return Value:
//    -
// 
//  Errors:
//    -
//
//  Detailed Comments:
//   Handles the following  cases 
//     In case of an incomming TestStep Request dispatches the
//                         c_EPTF_MBT_inputIdx_incomingTestStepRequest event 
//                   incomming Config Request configure the LoadGens creates the 
//                         entity goups activate the fsms...etc  
//                   incomming Command Request executes the requested command                        
//                         -
//	                 incomming User Request dispatches the
//						   c_EPTF_MBT_inputIdx_incomingUserRequest event
///////////////////////////////////////////////////////////////////////////////
altstep as_EPTF_MBT_PCO_Handler() runs on EPTF_MBT_LGen_CT
{
  var EPTF_MBT_Tester_CT vc_from;

  [] EPTF_MBT_PCO.receive(EPTF_MBT_TestStepRequest:?) -> value v_EPTF_MBT_TestStepRequest sender vc_from
    {
      f_EPTF_SchedulerComp_refreshSnapshotTime();
      f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, log2str("### " & %definitionId & "(): incoming v_EPTF_FTD_TestStepRequest: ",v_EPTF_MBT_TestStepRequest));

      var integer vl_eIdx := 0;
      var integer vl_fIdx := 0;    
      if (ispresent(v_EPTF_MBT_TestStepRequest.addr))
      {
        var integer vl_grpIdx := f_EPTF_LGenBase_entityGrpNameIndex(v_EPTF_MBT_TestStepRequest.addr.entityGroupName);
        vl_eIdx := f_EPTF_LGenBase_getEGrpBaseOffset(vl_grpIdx);
        if (ispresent(v_EPTF_MBT_TestStepRequest.addr.eIdx)) { vl_eIdx := vl_eIdx + v_EPTF_MBT_TestStepRequest.addr.eIdx }
        if (ispresent(v_EPTF_MBT_TestStepRequest.addr.fIdx)) { vl_fIdx := v_EPTF_MBT_TestStepRequest.addr.fIdx }
      }    
      f_EPTF_LGenBase_dispatchEvent({{v_EPTF_MBT_myBIdx, c_EPTF_MBT_inputIdx_incomingTestStepRequest,{vl_eIdx, vl_fIdx}, omit},{}});
      repeat;
    }
  [] EPTF_MBT_PCO.receive(EPTF_MBT_EventDispatchRequest:?) -> value v_EPTF_MBT_EventDispatchRequest sender vc_from
    {
      f_EPTF_SchedulerComp_refreshSnapshotTime();
      f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, log2str("### " & %definitionId & "(): incoming v_EPTF_MBT_EventDispatchRequest: ",v_EPTF_MBT_EventDispatchRequest));

      var integer vl_eIdx := 0;
      var integer vl_fIdx := 0;    

      var integer vl_grpIdx := f_EPTF_LGenBase_entityGrpNameIndex(v_EPTF_MBT_EventDispatchRequest.addr.entityGroupName);
      vl_eIdx := f_EPTF_LGenBase_getEGrpBaseOffset(vl_grpIdx);
      if (ispresent(v_EPTF_MBT_EventDispatchRequest.addr.eIdx)) { vl_eIdx := vl_eIdx + v_EPTF_MBT_EventDispatchRequest.addr.eIdx }
      if (ispresent(v_EPTF_MBT_EventDispatchRequest.addr.fIdx)) { vl_fIdx := v_EPTF_MBT_EventDispatchRequest.addr.fIdx }
        
      var integer vl_bIdx := f_EPTF_LGenBase_behaviorTypeNameIndex(v_EPTF_MBT_EventDispatchRequest.bName);
      var integer vl_iIdx := v_EPTF_MBT_EventDispatchRequest.iName
      f_EPTF_LGenBase_dispatchEvent({{vl_bIdx, vl_iIdx,{vl_eIdx, vl_fIdx}, omit},{}});
      repeat;
    }
  [] EPTF_MBT_PCO.receive(EPTF_MBT_ConfigRequest:?) -> value v_EPTF_MBT_ConfigRequest sender vc_from
    {
      f_EPTF_SchedulerComp_refreshSnapshotTime();
      f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, log2str("### " & %definitionId & "(): incoming v_EPTF_MBT_ConfigRequest: ", v_EPTF_MBT_ConfigRequest));

      var integer vl_senderInt := f_EPTF_Base_upcast(vc_from);    
      f_EPTF_LGenBase_declareEntityType
      (
        v_EPTF_MBT_ConfigRequest.entityGroupName & "_Type",
        v_EPTF_MBT_ConfigRequest.behaviors
      );    
      f_EPTF_LGenBase_createEntityGroup
      (
        {
          v_EPTF_MBT_ConfigRequest.entityGroupName, 
          v_EPTF_MBT_ConfigRequest.entityGroupName & "_Type", 
          v_EPTF_MBT_ConfigRequest.noEntities
        }
      );    
      if (vf_EPTF_MBT_entityGroupCreated != null)
      {
        f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, log2str(%definitionId & "(): calling ", vf_EPTF_MBT_entityGroupCreated));
        vf_EPTF_MBT_entityGroupCreated.apply(v_EPTF_MBT_ConfigRequest);
      }    
      var integer vl_grpIdx := f_EPTF_LGenBase_entityGrpNameIndex(v_EPTF_MBT_ConfigRequest.entityGroupName);
      var integer vl_entityIdx := f_EPTF_LGenBase_getEGrpBaseOffset(vl_grpIdx);
      var integer vl_fsmTableIdx := f_EPTF_LGenBase_fsmNameIndex(v_EPTF_MBT_ConfigRequest.fsmName);    
      for (var integer i:=0; i<v_EPTF_MBT_ConfigRequest.noEntities; i:=i+1)
      {
        f_EPTF_LGenBase_activateFsm(i + vl_entityIdx, vl_fsmTableIdx, 0, -1);
        f_EPTF_LGenBase_setBehaviorCtx(i + vl_entityIdx, v_EPTF_MBT_myBIdx, {vl_senderInt});
        f_EPTF_LGenBase_addEntityIdxListener(i + vl_entityIdx, refers(f_EPTF_MBT_Listener_catchEntityEvents), {})
      }

      EPTF_MBT_PCO.send(EPTF_MBT_ConfigResponse:{}) to vc_from;    
      repeat;
    }
  [] EPTF_MBT_PCO.receive(EPTF_MBT_CreateFSMRequest:?) -> value v_EPTF_MBT_CreateFSMRequest sender vc_from
    {
      f_EPTF_SchedulerComp_refreshSnapshotTime();
      f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, log2str("### " & %definitionId & "(): incoming v_EPTF_MBT_CreateFSMRequest: ", v_EPTF_MBT_CreateFSMRequest));

      var integer vl_senderInt := f_EPTF_Base_upcast(vc_from);    

      var integer vl_grpIdx := f_EPTF_LGenBase_entityGrpNameIndex(v_EPTF_MBT_CreateFSMRequest.entityGroupName);
      var integer vl_entityIdx := f_EPTF_LGenBase_getEGrpBaseOffset(vl_grpIdx) + v_EPTF_MBT_CreateFSMRequest.eIdx;
      var integer vl_fsmTableIdx := f_EPTF_LGenBase_fsmNameIndex(v_EPTF_MBT_CreateFSMRequest.fsmName);    

      var integer vl_fIdx := f_EPTF_LGenBase_activateFsm(vl_entityIdx, vl_fsmTableIdx, 0, -1);
      f_EPTF_LGenBase_setBehaviorCtx(vl_entityIdx, v_EPTF_MBT_myBIdx, {vl_senderInt});
      //f_EPTF_LGenBase_addEntityIdxListener(vl_entityIdx, refers(f_EPTF_MBT_Listener_catchEntityEvents), {}); // FIXME: only if MBT_FSM is actiavted on a new entity

      var EPTF_MBT_CreateFSMResponse vl_resp :=
      {
        result := 0,
        addr := 
        {
          entityGroupName := v_EPTF_MBT_CreateFSMRequest.entityGroupName,
          eIdx := v_EPTF_MBT_CreateFSMRequest.eIdx,
          fIdx := vl_fIdx
        }
      }

      EPTF_MBT_PCO.send(vl_resp) to vc_from;    
      repeat;
    }
  [] EPTF_MBT_PCO.receive(EPTF_MBT_RemoveFSMRequest:?) -> value v_EPTF_MBT_RemoveFSMRequest sender vc_from
    {
      f_EPTF_SchedulerComp_refreshSnapshotTime();
      f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, log2str("### " & %definitionId & "(): incoming v_EPTF_MBT_RemoveFSMRequest: ", v_EPTF_MBT_RemoveFSMRequest));

      var integer vl_senderInt := f_EPTF_Base_upcast(vc_from);    

      var integer vl_grpIdx := f_EPTF_LGenBase_entityGrpNameIndex(v_EPTF_MBT_RemoveFSMRequest.addr.entityGroupName);
      var integer vl_entityIdx := f_EPTF_LGenBase_getEGrpBaseOffset(vl_grpIdx) + v_EPTF_MBT_RemoveFSMRequest.addr.eIdx;
      var integer vl_fsmIdx := v_EPTF_MBT_RemoveFSMRequest.addr.fIdx;

      f_EPTF_LGenBase_deactivateFsm(vl_entityIdx, vl_fsmIdx);

      var EPTF_MBT_RemoveFSMResponse vl_resp :=
      {
        result := 0
      }
      
      EPTF_MBT_PCO.send(vl_resp) to vc_from;
      repeat;
    }
  [] EPTF_MBT_PCO.receive(EPTF_MBT_CommandRequest:?) -> value v_EPTF_MBT_CommandRequest sender vc_from
    {
      f_EPTF_SchedulerComp_refreshSnapshotTime();
      f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, log2str("### " & %definitionId & "(): incoming v_EPTF_MBT_CommandRequest: ",v_EPTF_MBT_CommandRequest));

      if (ischosen(v_EPTF_MBT_CommandRequest.quit))
      {
        f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, log2str(%definitionId & "(): calling Base_stopAll"));
        f_EPTF_Base_stopAll(pass, true); // FIXME noCleanup should be false.      
      }
      else
      {
        f_EPTF_Logging_warning(true, log2str(%definitionId & "(): unhandled command: ", v_EPTF_MBT_CommandRequest));
        repeat;
      }
      EPTF_MBT_PCO.send(EPTF_MBT_CommandResponse:{ quitAck := {} }) to vc_from;
    }
  [] EPTF_MBT_PCO.receive(EPTF_MBT_UserRequest:?) -> value v_EPTF_MBT_UserRequest sender vc_from
    {    
      f_EPTF_SchedulerComp_refreshSnapshotTime();
      f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, log2str("### " & %definitionId & "(): incoming v_EPTF_MBT_UserRequest: ",v_EPTF_MBT_UserRequest));

      var integer vl_eIdx := 0;
      var integer vl_fIdx := 0;
    
      if (ispresent(v_EPTF_MBT_UserRequest.addr))
      {
        var integer vl_grpIdx := f_EPTF_LGenBase_entityGrpNameIndex(v_EPTF_MBT_UserRequest.addr.entityGroupName);
        vl_eIdx := f_EPTF_LGenBase_getEGrpBaseOffset(vl_grpIdx);
        if (ispresent(v_EPTF_MBT_UserRequest.addr.eIdx)) { vl_eIdx := vl_eIdx + v_EPTF_MBT_UserRequest.addr.eIdx }
        if (ispresent(v_EPTF_MBT_UserRequest.addr.fIdx)) { vl_fIdx := v_EPTF_MBT_UserRequest.addr.fIdx }
      } 
    
      f_EPTF_LGenBase_dispatchEvent({{v_EPTF_MBT_myBIdx, c_EPTF_MBT_inputIdx_incomingUserRequest,{vl_eIdx, vl_fIdx}, omit},{}});    
    }
  [] EPTF_MBT_PCO.receive
    {
      f_EPTF_SchedulerComp_refreshSnapshotTime();
      f_EPTF_Logging_warning(true, "### " & %definitionId & "(): dropping message");
      repeat;
    }
}

///////////////////////////////////////////////////////////////////////////////
//  Function: f_EPTF_MBT_initLGenFsm
// 
//  Purpose:
//    This function inits the MBT FSM
//
//  Parameters:
//   in fcb_EPTF_MBT_customUserFunction p_userFunc - sets the callback that shall create the UserResponses
//   in fcb_EPTF_MBT_entityGroupCreated p_entityGroupCreateFunc - sets the callback to handle entity group created
//   
//  Return Value:
//    -
// 
//  Errors:
//    -
//
//  Detailed Comments:
//    -
//
///////////////////////////////////////////////////////////////////////////////
function f_EPTF_MBT_initLGenFsm
(
  in fcb_EPTF_MBT_customUserFunction   p_userFunc,
  in fcb_EPTF_MBT_entityGroupCreated   p_entityGroupCreateFunc
)
runs on EPTF_MBT_LGen_CT
{
  f_EPTF_Logging_debug(tsp_EPTF_MBT_LGen_debug, log2str("### " & %definitionId & "() "));

  vf_EPTF_MBT_createUserResponse := p_userFunc;

  vf_EPTF_MBT_entityGroupCreated := p_entityGroupCreateFunc;

  var integer v_dummyInt := f_EPTF_LGenBase_declareFSMTable(
    {
      //DOT: digraph FSM_MBT {  
      name := "FSM_MBT",
      fsmParams := 
      {
        {
          stateList := { "main" }
        }
      },
      table := 
      {
        extendedTable := {
          {events2Listen :={  
              events:=  {
                {singleEvent:={
                  bName:=c_EPTF_LGenBase_behavior, 
                  iName:=c_EPTF_LGenBase_inputName_testMgmt_startTC, 
                  eventType:=fsm}
              }}},
            cellRow := {
              classicCellRow := {
                {//state[0]==main
                  //DOT: main -> main [label="i:startTC\n"]
                  actionList:=omit,
                  nextStateCalculation:=omit,
                  nextState:="main" 
                }
              } // classicCellRow
            } // cellRow
          },
          {events2Listen := { 
              events:=  {
                {singleEvent:={
                  bName:=c_EPTF_MBT_myBName, 
                  iName:=c_EPTF_MBT_inputName_incomingTestStepRequest, 
                  eventType:=fsm}
              }}},
            cellRow := {
              classicCellRow := {
                {//state[0]==main
                  //DOT: main -> main [label="i:incomingTestStepRequest\n a:step_invokeTestStep"]
                  actionList:={{stepOrFunctionName:=c_EPTF_MBT_stepName_invokeTestStep,contextArgs:=omit}},
                  nextStateCalculation:=omit,
                  nextState:="main" 
                }
              } // classicCellRow
            } // cellRow
          },
          {events2Listen := { 
              events:=  {
              {  singleEvent:={
                  bName:=c_EPTF_MBT_myBName, 
                  iName:=c_EPTF_MBT_inputName_incomingUserRequest, 
                  eventType:=fsm}
              }}},
            cellRow := {
              classicCellRow := {
                {//state[0]==main
                  //DOT: main -> main [label="i:incomingUserRequest\n a:step_invokeUserFunction"]
                  actionList:={{stepOrFunctionName:=c_EPTF_MBT_stepName_invokeUserFunction,contextArgs:=omit}},
                  nextStateCalculation:=omit,
                  nextState:="main" 
                }
              } // classicCellRow
            } // cellRow
          },
          {events2Listen := { 
              unhandled:={}
              //catchAll:={}
              },
            cellRow := {
              classicCellRow := {
                {//state[0]==main
                  //DOT: main -> main [label="i:unhandled\n a:step_sendUserResponse"]
                  actionList:={{stepOrFunctionName:=c_EPTF_MBT_stepName_sendUserResponse,contextArgs:=omit}},
                  nextStateCalculation:=omit,
                  nextState:="main" 
                }
              } // classicCellRow
            } // cellRow
          }

        } // extendedTable
      } // table
    }
  );
} 

///////// Tester part

///////////////////////////////////////////////////////////////////////////////
//  Function: f_EPTF_MBT_Tester_init
// 
//  Purpose:
//    This function inits the EPTF_MBT_Tester_CT
//
//  Parameters:
//   - *in* *charstring* pl_selfName - local internal name for the MBT Tester component
//   
//  Return Value:
//    -
// 
//  Errors:
//    -
//
//  Detailed Comments:
//    -
//
///////////////////////////////////////////////////////////////////////////////
function f_EPTF_MBT_Tester_init
(
  in charstring pl_selfName
)
runs on EPTF_MBT_Tester_CT
{
  f_EPTF_Base_init_CT(pl_selfName);
  f_EPTF_Semaphore_init_CT(pl_selfName);
}

///////////////////////////////////////////////////////////////////////////////
//  Function: f_MBT_execute
// 
//  Purpose:
//    This function executes a test step on specifid FSM (which must run the FSM_MBT)
//    FSM. It is possible to make the function blocking until the test stepis executed
//    by setting the p_lock parameter to true, but it will only work in case
//    the component extends the EPTF_MBT_Tester_CT and EPTF_MBT_LGen_CT as well!
//
//  Parameters:
//    - *in* *charstring* p_name - name of the test step
//    - *in* <FsmAddr> p_addr - address of the FSM
//    - *in* <EPTF_IntegerList> - p_params - parameters for the test step
//    - *in* *boolean* - p_lock - Enables/disables waiting for the test step to finish executing.
//   
//  Return Value:
//    -
// 
//  Errors:
//    -
//
//  Detailed Comments:
//    -
//
///////////////////////////////////////////////////////////////////////////////
function f_MBT_execute(in charstring p_name, in EPTF_MBT_LGen_Definitions.FsmAddr p_addr, in EPTF_IntegerList p_params := {}, in boolean p_lock := true)
runs on EPTF_MBT_Tester_CT
{
  action(%definitionId, " TestStep: ", p_name)
  if (p_lock)
  {
    var integer v_lock := f_EPTF_Semaphore_new();
    EPTF_MBT_TESTER_PCO.send(EPTF_MBT_TestStepRequest: {p_name, p_params, p_addr, v_lock});
    f_EPTF_Semaphore_waitForUnlock(v_lock, tsp_EPTG_MBT_execute_lockTimeout);
  }
  else
  {
    EPTF_MBT_TESTER_PCO.send(EPTF_MBT_TestStepRequest: {p_name, p_params, p_addr, omit});
  }
}

///////////////////////////////////////////////////////////////////////////////
//  Function: f_MBT_waitFor
// 
//  Purpose:
//    This function waits for specified EPTF event to arrive. Please note, that
//    until the waiting time runs out all the other incoming events are dropped.
//
//  Parameters:
//    - *in* *charstring* p_behavior - behavior name of the expected event
//    - *in* *charstring* p_name - name of the expected event
//    - *in* <FsmAddr> - p_addr - the event must arrive from this FSM.
//    - *in* *float* - p_timeout - Maximum waiting time for the expected event
//   
//  Return Value:
//    - *boolean* - True if the expected emssage was caught.
// 
//  Errors:
//    -
//
//  Detailed Comments:
//    -
//
///////////////////////////////////////////////////////////////////////////////
function f_MBT_waitFor(
  in charstring p_behavior, in template charstring p_name, 
  in template EPTF_MBT_LGen_Definitions.FsmAddr p_addr, in float p_timeout := 30.0)
runs on EPTF_MBT_Tester_CT
return boolean
{
  var EPTF_MBT_TestStepResponse vl_testStepResp;
  
  timer t_wait;
  t_wait.start(p_timeout);
  alt
  {
    [] EPTF_MBT_TESTER_PCO.receive(EPTF_MBT_TestStepResponse:{ bName := p_behavior, iName := p_name, addr := p_addr, args := *})
      { 
        t_wait.stop; 
        action(%definitionId, " Received: ", p_name)
        return true;
      }
    [] t_wait.timeout
      {
        action(%definitionId, " Timeout!")
        return false;
      }
  }
  return true;
}

///////////////////////////////////////////////////////////////////////////////
//  Function: f_MBT_dispatch
// 
//  Purpose:
//    This function sends an EPTF event to an FSM.
//
//  Parameters:
//    - *in* *charstring* p_bName - behavior name of the event
//    - *in* *integer* p_iIndex - index of the event
//    - *in* <FsmAddr> - p_addr - the event will be sent to this FSM.
//   
//  Return Value:
//    -
// 
//  Errors:
//    -
//
//  Detailed Comments:
//    -
//
///////////////////////////////////////////////////////////////////////////////
function f_MBT_dispatch(in charstring p_bName, in integer p_iIndex, in EPTF_MBT_LGen_Definitions.FsmAddr p_addr)
runs on EPTF_MBT_Tester_CT
{
  action(%definitionId, " Dispatching: ", p_bName, ":",p_iIndex, " to ",p_addr)
  EPTF_MBT_TESTER_PCO.send(EPTF_MBT_EventDispatchRequest: {p_bName, p_iIndex, p_addr});
}


///////////////////////////////////////////////////////////////////////////////
//  Function: f_MBT_activateFsm
// 
//  Purpose:
//    This function activates an FSM on an entity.
//
//  Parameters:
//    - *in* *charstring* p_entityGroupName - entity group name of the entity
//    - *in* *integer* p_eIdx - index of the entity
//    - *in* *charstring* - p_fsmName - the event will be sent to this FSM.
//    - *out* *FsmAddr* - p_fsmAddr - The address of the activated FSM if succesful
//   
//  Return Value:
//    - *integer* - the result of the FSM activation (-1 if unsuccesful)
// 
//  Errors:
//    -
//
//  Detailed Comments:
//    -
//
///////////////////////////////////////////////////////////////////////////////
function f_MBT_activateFsm(in charstring p_entityGroupName, in integer p_eIdx, in charstring p_fsmName, out FsmAddr p_fsmAddr)
runs on EPTF_MBT_Tester_CT
return integer
{
    action(%definitionId, " Activating: ", p_fsmName, " on entity: ",p_eIdx)
    EPTF_MBT_TESTER_PCO.send(EPTF_MBT_CreateFSMRequest:
    {
      entityGroupName := p_entityGroupName,
      eIdx := 0,
      fsmName := p_fsmName
    }
  )

  var EPTF_MBT_CreateFSMResponse vl_resp;
  EPTF_MBT_TESTER_PCO.receive(EPTF_MBT_CreateFSMResponse:?) -> value vl_resp;

  p_fsmAddr := vl_resp.addr;
  return vl_resp.result;
}

///////////////////////////////////////////////////////////////////////////////
//  Function: f_convert_FsmAddr2TestStepArgs
// 
//  Purpose:
//    Utility function to convert an FsmAddr address to a TestStepArgs value.
//
//  Parameters:
//    - *in* *FsmAddr* - p_fsmAddr - An FSM address
//   
//  Return Value:
//    - <EPTF_LGenBase_TestStepArgs> - the corresponding TestStapArgs value
// 
//  Errors:
//    -
//
//  Detailed Comments:
//    -
//
///////////////////////////////////////////////////////////////////////////////
function f_convert_FsmAddr2TestStepArgs(in EPTF_MBT_LGen_Definitions.FsmAddr p_addr)
return EPTF_LGenBase_TestStepArgs
{
  // FIXME: entity group check!
  var EPTF_LGenBase_TestStepArgs vl_ret :=
  {
    eIdx := p_addr.eIdx,
    refContext :=
    {
      fCtxIdx := p_addr.fIdx,
      fRefArgs := {}
    },
    stepArgs := {},
    reportedEvent := c_EPTF_LGenBase_emptyReportedEventDescriptor
  }
  return vl_ret;
}

}