///////////////////////////////////////////////////////////////////////////////
//
// 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 v2.0
// which accompanies this distribution, and is available at
// https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
///////////////////////////////////////////////////////////////////////////////
//  File:               IOT_LGen_Steps.ttcn
//  Description:
//  Rev:                R1A
//  Prodnr:             LPA 108 661
//  Updated:            2017-09-01
//  Contact:            http://ttcn.ericsson.se
///////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////
//
// 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 v2.0
// which accompanies this distribution, and is available at
// https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
///////////////////////////////////////////////////////////////////////////////
//  File:               IOT_LGen_Functions.ttcn
//  Description:
//  Rev:                R1A
//  Prodnr:             LPA 108 661
//  Updated:            2017-09-01
//  Contact:            http://ttcn.ericsson.se
///////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////
//  Module: IOT_LGen_Steps
// 
//  Purpose:
//    This module contains test step functions for RIoT's load generator component
//
//  See also:
//    <IOT_LGen_Definitions>
//
//  Module depends on:
//    - <IOT_LGen_Definitions>
//    - <EPTF_MQTT_LGen_Functions>
//    - <EPTF_COAP_LGen_Definitions>
//    - <EPTF_COAP_LGen_Functions>
//    - <EPTF_LwM2M_LGen_Functions>
//    - <EPTF_LwM2M_Object_Definitions>
//    - <EPTF_LwM2M_Object_Functions>
//    - <EPTF_HTTP_Functions>
//    - <EPTF_HTTP_Transport_Functions>
//    - <EPTF_CLL_Common_Definitions>
//    - <EPTF_CLL_ExecCtrlClient_Functions>
//    - <EPTF_CLL_LGenBase_Definitions>
//    - <EPTF_CLL_LGenBase_StepFunctions>
//    - <EPTF_CLL_LGenBase_ConfigFunctions>
//    - <EPTF_CLL_Variable_Definitions>
//    - <EPTF_CLL_Variable_Functions>
//
//  Test Steps [Generic]:
//    testcase finished - <f_IOT_LGen_step_tcFinished_withVerdict>, <c_IOT_stepName_tcFinished_withVerdict>
//    print - <f_IOT_LGen_step_print_stringParam>, <c_IOT_stepName_print_stringParam>
//    RND generator - <f_IOT_LGen_step_genRndValue_varParams>, <c_IOT_stepName_genRndValue_varParams>
//
//  Test Steps [COAP]:
//    set local address - <f_IOT_LGen_step_COAP_setLocalAddress_byVars>, <c_IOT_stepName_COAP_setLocalAddress_byVars>
//
//  Test Steps [LwM2M]:
//    set client name - <f_IOT_LGen_step_LwM2M_setClientNameInRegister>, <c_IOT_stepName_LwM2M_setClientNameInRegister>
//                      <f_IOT_LGen_step_LwM2M_setClientNameInRegister_stringVar>, <c_IOT_stepName_LwM2M_setClientNameInRegister_stringVar>
//
//  Test Steps [MQTT]:
//    set local address - <f_IOT_LGen_step_MQTT_setLocalAddress_byVars>, <c_IOT_stepName_MQTT_setLocalAddress_byVars>
//                        <f_IOT_LGen_step_MQTT_setClientId_stringParam>, <c_IOT_stepName_MQTT_setClientId_stringParam>
//
//  Test Steps [HTTP]:
//    init entity context - <f_IOT_LGen_step_HTTP_initEntityContext>, <c_IOT_stepName_HTTP_initEntityContext>
//    open connection - <f_IOT_LGen_step_HTTP_openConnection_byVars>, <c_IOT_stepName_HTTP_openConnection_byVars>
//    close connection - <f_IOT_LGen_step_HTTP_closeConnection>, <c_IOT_stepName_HTTP_closeConnection>
//    set HTTP method - <f_IOT_LGen_step_HTTP_setMethod_stringParam>, <c_IOT_stepName_HTTP_setMethod_stringParam>
//    set HTTP URI - <f_IOT_LGen_step_HTTP_setUri_stringParam>, <c_IOT_stepName_HTTP_addToUri_stringParam>
//                   <f_IOT_LGen_step_HTTP_addToUri_byVars>, <c_IOT_stepName_HTTP_addToUri_byVars>
//    add HTTP Host header - <f_IOT_LGen_step_HTTP_addHostHeader_byVars>, <c_IOT_stepName_HTTP_addHostHeader_byVars>
//
//  Test Steps [Leshan]:
//    get client name - <f_IOT_LGen_step_Leshan_getClientFromResponse_intoVar>, <c_IOT_stepName_Leshan_getClientFromResponse_intoVar>
//
//  Test Steps [RegDereg FSM]:
//    init resource values - <f_IOT_LGen_step_FSM_RegDereg_initResourceValues>, <c_IOT_stepName_FSM_RegDereg_initResourceValues>
//
//  Test Steps [SimDev FSM]:
//    create resources - <f_IOT_LGen_step_FSM_SimDevice_createResources>, <c_IOT_stepName_FSM_SimDevice_createResources>
//    init resource values - <f_IOT_LGen_step_FSM_SimDevice_initResourceValues>, <c_IOT_stepName_FSM_SimDevice_initResourceValues>
//    init transport - <f_IOT_LGen_step_FSM_SimDevice_initTransport_boolVar>, <c_IOT_stepName_FSM_SimDevice_initTransport_boolVar>
//    update resource values - <f_IOT_LGen_step_FSM_SimDevice_updateResourceValues>, <c_IOT_stepName_FSM_SimDevice_updateResourceValues>
//    handle EXECUTE - <f_IOT_LGen_step_FSM_SimDevice_handleExecute>, <c_IOT_stepName_FSM_SimDevice_handleExecute>
///////////////////////////////////////////////////////////////
module IOT_LGen_Steps {

  import from JSON_Types all;
  import from IOT_LGen_Definitions all;
  import from EPTF_COAP_LGen_Definitions all;
  import from EPTF_COAP_LGen_Functions all;
  import from EPTF_MQTT_LGen_Functions all;
  import from EPTF_LwM2M_LGen_Functions all;
  import from EPTF_LwM2M_Object_Definitions all;
  import from EPTF_LwM2M_Object_Functions all;
  import from LightweightM2M_Types all;
  import from EPTF_HTTP_Functions all;
  import from EPTF_HTTP_Transport_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_LGenBase_Definitions all;
  import from EPTF_CLL_LGenBase_StepFunctions all;
  import from EPTF_CLL_LGenBase_ConfigFunctions all;
  import from EPTF_CLL_ExecCtrlClient_Functions all;

  //////////////////////
  // Generic
  //////////////////////

  ///////////////////////////////////////////////////////////
  //  const: c_IOT_stepName_tcFinished_withVerdict
  //
  //  Purpose:
  //    Charstring constant for the RIoT test case finished test step
  //
  //  Related Function:
  //    - <f_IOT_LGen_step_tcFinished_withVerdict>
  ///////////////////////////////////////////////////////////
  const charstring c_IOT_stepName_tcFinished_withVerdict := "IOT App: tcFinished_withVerdict";

  ///////////////////////////////////////////////////////////
  //  const: c_IOT_stepName_print_stringParam
  //
  //  Purpose:
  //    Charstring constant for the RIoT print string test step
  //
  //  Related Function:
  //    - <f_IOT_LGen_step_print_stringParam>
  ///////////////////////////////////////////////////////////
  const charstring c_IOT_stepName_print_stringParam := "IOT App: print_stringParam";

  ///////////////////////////////////////////////////////////
  //  const: c_IOT_stepName_genRndValue_varParams
  //
  //  Purpose:
  //    Charstring constant for the RIoT random number generator test step
  //
  //  Related Function:
  //    - <f_IOT_LGen_step_genRndValue_varParams>
  ///////////////////////////////////////////////////////////
  const charstring c_IOT_stepName_genRndValue_varParams := "IOT App: genRndValue_varParams";

  //////////////////////
  // COAP
  //////////////////////

  ///////////////////////////////////////////////////////////
  //  const: c_IOT_stepName_COAP_setLocalAddress_byVars
  //
  //  Purpose:
  //    Charstring constant for setting the COAP local address test step
  //
  //  Related Function:
  //    - <f_IOT_LGen_step_COAP_setLocalAddress_byVars>
  ///////////////////////////////////////////////////////////
  const charstring c_IOT_stepName_COAP_setLocalAddress_byVars := "IOT App COAP: setLocalAddress_byVars";

  //////////////////////
  // MQTT
  //////////////////////

  ///////////////////////////////////////////////////////////
  //  const: c_IOT_stepName_MQTT_setLocalAddress_byVars
  //
  //  Purpose:
  //    Charstring constant for setting the MQTT local address test step
  //
  //  Related Function:
  //    - <f_IOT_LGen_step_MQTT_setLocalAddress_byVars>
  ///////////////////////////////////////////////////////////
  const charstring c_IOT_stepName_MQTT_setLocalAddress_byVars := "IOT App MQTT: setLocalAddress_byVars";

  ///////////////////////////////////////////////////////////
  //  const: c_IOT_stepName_MQTT_setClientId_stringParam
  //
  //  Purpose:
  //    Charstring constant for the test step that sets the MQTT client id
  //
  //  Related Function:
  //    - <f_IOT_LGen_step_MQTT_setClientId_stringParam>
  ///////////////////////////////////////////////////////////
  const charstring c_IOT_stepName_MQTT_setClientId_stringParam := "IOT App MQTT: setClientId_stringParam";

  //////////////////////
  // LwM2M
  //////////////////////

  ///////////////////////////////////////////////////////////
  //  const: c_IOT_stepName_LwM2M_setClientNameInRegister
  //
  //  Purpose:
  //    Charstring constant for the test step that sets the LwM2M endpoint name in the Register message
  //
  //  Related Function:
  //    - <f_IOT_LGen_step_LwM2M_setClientNameInRegister>
  ///////////////////////////////////////////////////////////
  const charstring c_IOT_stepName_LwM2M_setClientNameInRegister := "IOT App LwM2M: setClientNameInRegister";

  ///////////////////////////////////////////////////////////
  //  const: c_IOT_stepName_LwM2M_setClientNameInRegister_stringVar
  //
  //  Purpose:
  //    Charstring constant for the test step that sets the LwM2M endpoint name in the Register message
  //
  //  Related Function:
  //    - <f_IOT_LGen_step_LwM2M_setClientNameInRegister_stringVar>
  ///////////////////////////////////////////////////////////
  const charstring c_IOT_stepName_LwM2M_setClientNameInRegister_stringVar := "IOT App LwM2M: setClientNameInRegister_stringVar";

  //////////////////////
  // HTTP
  //////////////////////

  ///////////////////////////////////////////////////////////
  //  const: c_IOT_stepName_HTTP_initEntityContext
  //
  //  Purpose:
  //    Charstring constant for the test step that initializes the HTTP entity context
  //
  //  Related Function:
  //    - <f_IOT_LGen_step_HTTP_initEntityContext>
  ///////////////////////////////////////////////////////////
  const charstring c_IOT_stepName_HTTP_initEntityContext := "IOT App HTTP: initEntityContext";

  ///////////////////////////////////////////////////////////
  //  const: c_IOT_stepName_HTTP_openConnection_byVars
  //
  //  Purpose:
  //    Charstring constant for the test step that opens an HTTP connection
  //
  //  Related Function:
  //    - <f_IOT_LGen_step_HTTP_openConnection_byVars>
  ///////////////////////////////////////////////////////////
  const charstring c_IOT_stepName_HTTP_openConnection_byVars := "IOT App HTTP: openConnection_byVars";

  ///////////////////////////////////////////////////////////
  //  const: c_IOT_stepName_HTTP_closeConnection
  //
  //  Purpose:
  //    Charstring constant for the test step that closes the opened HTTP connection
  //
  //  Related Function:
  //    - <f_IOT_LGen_step_HTTP_closeConnection>
  ///////////////////////////////////////////////////////////
  const charstring c_IOT_stepName_HTTP_closeConnection := "IOT App HTTP: closeConnection";

  ///////////////////////////////////////////////////////////
  //  const: c_IOT_stepName_HTTP_setMethod_stringParam
  //
  //  Purpose:
  //    Charstring constant for the test step that sets the HTTP method for the HTTP message to be sent
  //
  //  Related Function:
  //    - <f_IOT_LGen_step_HTTP_setMethod_stringParam>
  ///////////////////////////////////////////////////////////
  const charstring c_IOT_stepName_HTTP_setMethod_stringParam := "IOT App HTTP: setMethod_stringParam";

  ///////////////////////////////////////////////////////////
  //  const: c_IOT_stepName_HTTP_setUri_stringParam
  //
  //  Purpose:
  //    Charstring constant for the test step that sets the HTTP request URI for the HTTP message to be sent
  //
  //  Related Function:
  //    - <f_IOT_LGen_step_HTTP_setUri_stringParam>
  ///////////////////////////////////////////////////////////
  const charstring c_IOT_stepName_HTTP_setUri_stringParam := "IOT App HTTP: setUri_stringParam";

  ///////////////////////////////////////////////////////////
  //  const: c_IOT_stepName_HTTP_addToUri_stringParam
  //
  //  Purpose:
  //    Charstring constant for the test step that concatenates a string to the HTTP request URI for the HTTP message to be sent
  //
  //  Related Function:
  //    - <f_IOT_LGen_step_HTTP_addToUri_stringParam>
  ///////////////////////////////////////////////////////////
  const charstring c_IOT_stepName_HTTP_addToUri_stringParam := "IOT App HTTP: addToUri_stringParam";

  ///////////////////////////////////////////////////////////
  //  const: c_IOT_stepName_HTTP_addToUri_byVars
  //
  //  Purpose:
  //    Charstring constant for the test step that concatenates a string to the HTTP request URI for the HTTP message to be sent
  //
  //  Related Function:
  //    - <f_IOT_LGen_step_HTTP_addToUri_byVars>
  ///////////////////////////////////////////////////////////
  const charstring c_IOT_stepName_HTTP_addToUri_byVars := "IOT App HTTP: addToUri_byVars";

  ///////////////////////////////////////////////////////////
  //  const: c_IOT_stepName_HTTP_addHostHeader_byVars
  //
  //  Purpose:
  //    Charstring constant for the test step that adds a Host header to the HTTP message to be sent
  //
  //  Related Function:
  //    - <f_IOT_LGen_step_HTTP_addHostHeader_byVars>
  ///////////////////////////////////////////////////////////
  const charstring c_IOT_stepName_HTTP_addHostHeader_byVars := "IOT App HTTP: addHostHeader_byVars";

  //////////////////////
  // Leshan
  //////////////////////

  ///////////////////////////////////////////////////////////
  //  const: c_IOT_stepName_Leshan_getClientFromResponse_intoVar
  //
  //  Purpose:
  //    Charstring constant for the test step that loads the client name into a variable from an HTTP response
  //
  //  Related Function:
  //    - <f_IOT_LGen_step_Leshan_getClientFromResponse_intoVar>
  ///////////////////////////////////////////////////////////
  const charstring c_IOT_stepName_Leshan_getClientFromResponse_intoVar := "IOT App Leshan: getClientFromResponse_intoVar";

  //////////////////////
  //  FSM_RegDereg
  //////////////////////

  ///////////////////////////////////////////////////////////
  //  const: c_IOT_stepName_FSM_RegDereg_initResourceValues
  //
  //  Purpose:
  //    Charstring constant for the test step that inits the resources of the RegDereg FSM
  //
  //  Related Function:
  //    - <f_IOT_LGen_step_FSM_RegDereg_initResourceValues>
  ///////////////////////////////////////////////////////////
  const charstring c_IOT_stepName_FSM_RegDereg_initResourceValues := "IOT Fsm LWM2M_RegDereg: initResourceValues";

  //////////////////////
  // FSM SimDevice
  //////////////////////

  ///////////////////////////////////////////////////////////
  //  const: c_IOT_stepName_FSM_SimDevice_createResources
  //
  //  Purpose:
  //    Charstring constant for the test step that creates the resources of the SimDevice FSM
  //
  //  Related Function:
  //    - <f_IOT_LGen_step_FSM_SimDevice_createResources>
  ///////////////////////////////////////////////////////////
  const charstring c_IOT_stepName_FSM_SimDevice_createResources := "IOT Fsm LWM2M_SimDevice: createResources";

  ///////////////////////////////////////////////////////////
  //  const: c_IOT_stepName_FSM_SimDevice_initResourceValues
  //
  //  Purpose:
  //    Charstring constant for the test step that inits the resources of the SimDevice FSM
  //
  //  Related Function:
  //    - <f_IOT_LGen_step_FSM_SimDevice_initResourceValues>
  ///////////////////////////////////////////////////////////
  const charstring c_IOT_stepName_FSM_SimDevice_initResourceValues := "IOT Fsm LWM2M_SimDevice: initResourceValues";

  ///////////////////////////////////////////////////////////
  //  const: c_IOT_stepName_FSM_SimDevice_initTransport_boolVar
  //
  //  Purpose:
  //    Charstring constant for the test step that inits the transport (UDP, or DTLS-PSK) for the SimDev FSM's LwM2M protocol
  //
  //  Related Function:
  //    - <f_IOT_LGen_step_FSM_SimDevice_initTransport_boolVar>
  ///////////////////////////////////////////////////////////
  const charstring c_IOT_stepName_FSM_SimDevice_initTransport_boolVar := "IOT Fsm LWM2M_SimDevice: initTransport_boolVar";

  ///////////////////////////////////////////////////////////
  //  const: c_IOT_stepName_FSM_SimDevice_updateResourceValues
  //
  //  Purpose:
  //    Charstring constant for the test step that updates the resource values of the SimDevice FSM
  //
  //  Related Function:
  //    - <f_IOT_LGen_step_FSM_SimDevice_updateResourceValues>
  ///////////////////////////////////////////////////////////
  const charstring c_IOT_stepName_FSM_SimDevice_updateResourceValues := "IOT Fsm LWM2M_SimDevice: updateResourceValues";

  ///////////////////////////////////////////////////////////
  //  const: c_IOT_stepName_FSM_SimDevice_handleExecute
  //
  //  Purpose:
  //    Charstring constant for the test step that handles LwM2M EXECUTE requests on the SimDevice FSM
  //
  //  Related Function:
  //    - <f_IOT_LGen_step_FSM_SimDevice_handleExecute>
  ///////////////////////////////////////////////////////////
  const charstring c_IOT_stepName_FSM_SimDevice_handleExecute := "IOT Fsm LWM2M_SimDevice: handleExecute";

  ///////////////////////////////////////////////////////////
  //  Function: f_IOT_LGen_declareSteps
  //
  //  Purpose:
  //    Function to declare all the RIoT application related test steps
  //
  //  Related Types:
  //    <IOT_LGen_CT>
  ///////////////////////////////////////////////////////////
  function f_IOT_LGen_declareSteps()
  runs on IOT_LGen_CT
  {
    // COAP
    f_EPTF_LGenBase_declareStep(c_IOT_behaviorType, {c_IOT_stepName_COAP_setLocalAddress_byVars, refers(f_IOT_LGen_step_COAP_setLocalAddress_byVars)});
    // MQTT
    f_EPTF_LGenBase_declareStep(c_IOT_behaviorType, {c_IOT_stepName_MQTT_setLocalAddress_byVars, refers(f_IOT_LGen_step_MQTT_setLocalAddress_byVars)});
    f_EPTF_LGenBase_declareStep(c_IOT_behaviorType, {c_IOT_stepName_MQTT_setClientId_stringParam, refers(f_IOT_LGen_step_MQTT_setClientId_stringParam)});
    // LwM2M
    f_EPTF_LGenBase_declareStep(c_IOT_behaviorType, {c_IOT_stepName_FSM_RegDereg_initResourceValues, refers(f_IOT_LGen_step_FSM_RegDereg_initResourceValues)});
    f_EPTF_LGenBase_declareStep(c_IOT_behaviorType, {c_IOT_stepName_FSM_SimDevice_createResources, refers(f_IOT_LGen_step_FSM_SimDevice_createResources)});
    f_EPTF_LGenBase_declareStep(c_IOT_behaviorType, {c_IOT_stepName_FSM_SimDevice_initResourceValues, refers(f_IOT_LGen_step_FSM_SimDevice_initResourceValues)});
    f_EPTF_LGenBase_declareStep(c_IOT_behaviorType, {c_IOT_stepName_FSM_SimDevice_initTransport_boolVar, refers(f_IOT_LGen_step_FSM_SimDevice_initTransport_boolVar)});
    f_EPTF_LGenBase_declareStep(c_IOT_behaviorType, {c_IOT_stepName_FSM_SimDevice_updateResourceValues, refers(f_IOT_LGen_step_FSM_SimDevice_updateResourceValues)});
    f_EPTF_LGenBase_declareStep(c_IOT_behaviorType, {c_IOT_stepName_FSM_SimDevice_handleExecute, refers(f_IOT_LGen_step_FSM_SimDevice_handleExecute)});
    f_EPTF_LGenBase_declareStep(c_IOT_behaviorType, {c_IOT_stepName_LwM2M_setClientNameInRegister, refers(f_IOT_LGen_step_LwM2M_setClientNameInRegister)});
    f_EPTF_LGenBase_declareStep(c_IOT_behaviorType, {c_IOT_stepName_LwM2M_setClientNameInRegister_stringVar, refers(f_IOT_LGen_step_LwM2M_setClientNameInRegister_stringVar)});
    // HTTP
    f_EPTF_LGenBase_declareStep(c_IOT_behaviorType, {c_IOT_stepName_HTTP_initEntityContext, refers(f_IOT_LGen_step_HTTP_initEntityContext)});
    f_EPTF_LGenBase_declareStep(c_IOT_behaviorType, {c_IOT_stepName_HTTP_openConnection_byVars, refers(f_IOT_LGen_step_HTTP_openConnection_byVars)});
    f_EPTF_LGenBase_declareStep(c_IOT_behaviorType, {c_IOT_stepName_HTTP_closeConnection, refers(f_IOT_LGen_step_HTTP_closeConnection)});
    f_EPTF_LGenBase_declareStep(c_IOT_behaviorType, {c_IOT_stepName_HTTP_setMethod_stringParam, refers(f_IOT_LGen_step_HTTP_setMethod_stringParam)});
    f_EPTF_LGenBase_declareStep(c_IOT_behaviorType, {c_IOT_stepName_HTTP_setUri_stringParam, refers(f_IOT_LGen_step_HTTP_setUri_stringParam)});
    f_EPTF_LGenBase_declareStep(c_IOT_behaviorType, {c_IOT_stepName_HTTP_addToUri_stringParam, refers(f_IOT_LGen_step_HTTP_addToUri_stringParam)});
    f_EPTF_LGenBase_declareStep(c_IOT_behaviorType, {c_IOT_stepName_HTTP_addToUri_byVars, refers(f_IOT_LGen_step_HTTP_addToUri_byVars)});
    f_EPTF_LGenBase_declareStep(c_IOT_behaviorType, {c_IOT_stepName_HTTP_addHostHeader_byVars, refers(f_IOT_LGen_step_HTTP_addHostHeader_byVars)});
    // Leshan
    f_EPTF_LGenBase_declareStep(c_IOT_behaviorType, {c_IOT_stepName_Leshan_getClientFromResponse_intoVar, refers(f_IOT_LGen_step_Leshan_getClientFromResponse_intoVar)});
    // Common
    f_EPTF_LGenBase_declareStep(c_IOT_behaviorType, {c_IOT_stepName_tcFinished_withVerdict, refers(f_IOT_LGen_step_tcFinished_withVerdict)});
    f_EPTF_LGenBase_declareStep(c_IOT_behaviorType, {c_IOT_stepName_print_stringParam, refers(f_IOT_LGen_step_print_stringParam)});
    f_EPTF_LGenBase_declareStep(c_IOT_behaviorType, {c_IOT_stepName_genRndValue_varParams, refers(f_IOT_LGen_step_genRndValue_varParams)});
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_IOT_LGen_getEntityIdxinEntityGroup
  //
  //  Purpose:
  //    Calculates the index of the entity inside its entity group
  //
  //  Parameters:
  //    pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step parameters
  ///////////////////////////////////////////////////////////
  function f_IOT_LGen_getEntityIdxinEntityGroup(in EPTF_LGenBase_TestStepArgs pl_ptr)
  runs on IOT_LGen_CT
  return integer
  {
    var integer vl_eGrpIdx := f_EPTF_LGenBase_getEGrpOfEntity(pl_ptr.eIdx);
    var charstring vl_eGrpName := f_EPTF_LGenBase_entityGroupName(vl_eGrpIdx);
    
    var integer vl_eRelIdxInEGrp :=
      f_EPTF_ExecCtrlClient_getFirstEntityOffsetInEGrp(vl_eGrpName) + 
      f_EPTF_LGenBase_getERelIdx(pl_ptr.eIdx);
      
    //action("========================");
    //action("f_EPTF_ExecCtrlClient_getEntityGroupSize: ", f_EPTF_ExecCtrlClient_getEntityGroupSize(eGrpName));
    //action("f_EPTF_ExecCtrlClient_getFirstEntityGlobalOffset: ", f_EPTF_ExecCtrlClient_getFirstEntityGlobalOffset(eGrpName));
    //action("f_EPTF_ExecCtrlClient_getEntityGroupGlobalOffset: ", f_EPTF_ExecCtrlClient_getEntityGroupGlobalOffset(eGrpName));
    //action("f_EPTF_ExecCtrlClient_getFirstEntityOffsetInEGrp: ", f_EPTF_ExecCtrlClient_getFirstEntityOffsetInEGrp(eGrpName));
    //action("f_EPTF_LGenBase_getERelIdx(pl_ptr.eIdx): ", f_EPTF_LGenBase_getERelIdx(pl_ptr.eIdx));    
    //action("eIdx: ", pl_ptr.eIdx);
      
    return vl_eRelIdxInEGrp;
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_IOT_LGen_step_COAP_setLocalAddress_byVars
  //
  //  Purpose:
  //    Test step to set the local address in the COAP entity context <COAP_EntityCtx>. Parameters are required.
  //    The function will take the base port number from the parameters and adds the entity's offset
  //    inside its entity group (or in case the 3rd parameter is present, then the value found there)
  //    to get its assigned port number.
  //
  //  Parameters:
  //    pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args
  //    contextArgs.varNames[0] - *charstring variable* - local host
  //    contextArgs.varNames[1] - *integer variable* - local port
  //    contextArgs.varNames[2] - *integer variable* - offset [optional]
  //
  //  Related Constants:
  //    - <c_IOT_stepName_COAP_setLocalAddress_byVars>
  ///////////////////////////////////////////////////////////
  function f_IOT_LGen_step_COAP_setLocalAddress_byVars(in EPTF_LGenBase_TestStepArgs pl_ptr)
  runs on IOT_LGen_CT
  {
    // 1st param: localHost: charstring
    // 2nd param: localPort: integer
    // 3rd param: offset: integer
    f_EPTF_COAP_Logging_DEBUG(log2str(%definitionId, pl_ptr));

    if (not f_EPTF_COAP_setStepCtx(pl_ptr, v_COAP_ctx)) { return; }
    
    var integer vl_eRelIdxInEGrp := f_IOT_LGen_getEntityIdxinEntityGroup(pl_ptr);
    
    var EPTF_IntegerList vl_varIds := {};
    f_EPTF_LGenBase_fsmVarIdListFromStep(pl_ptr, vl_varIds);
    
    if (sizeof(vl_varIds)>=2)
    {
      var EPTF_Var_DirectContent vl_host, vl_port, vl_offset;
      f_EPTF_Var_getContent(vl_varIds[0], vl_host);
      f_EPTF_Var_getContent(vl_varIds[1], vl_port);
      if (sizeof(vl_varIds)==3) { f_EPTF_Var_getContent(vl_varIds[2], vl_offset); }
      else { vl_offset.intVal := vl_eRelIdxInEGrp; }
      
      if (not ischosen(vl_host.charstringVal)) {
        f_EPTF_COAP_Logging_WARNING(log2str(%definitionId, " first param is not charstring variable!"));
        return;
      }
      if (not ischosen(vl_port.intVal)) {
        f_EPTF_COAP_Logging_WARNING(log2str(%definitionId, " second param is not integer variable!"));
        return;
      }
      if (not ischosen(vl_offset.intVal)) {
        f_EPTF_COAP_Logging_WARNING(log2str(%definitionId, " third param is not integer variable!"));
        return;
      }
      
      var integer vl_localPort := vl_port.intVal + vl_offset.intVal;
	  f_EPTF_COAP_Logging_VERBOSE(log2str(%definitionId, " calculated local port ",vl_localPort));
      
      if (vl_localPort < 65535)
      {
        f_EPTF_COAP_transportEndpointDB_add(
          { 
            socket := {
              hostName := vl_host.charstringVal,
              portNumber := vl_localPort
            },
            proto := { udp := {} }
          },
          v_COAP_EntityCtxDB.data[v_COAP_ctx.eCtxIdx].localAddressIdx
        );
      }
      else {
        f_EPTF_COAP_Logging_WARNING(log2str(%definitionId, " calculated local port ",vl_localPort," would be larger than 65536! step aborted."));
      }
    }
    else {
      f_EPTF_COAP_Logging_WARNING(log2str(%definitionId, " at least two variables are needed as params!"));
    }
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_IOT_LGen_step_MQTT_setLocalAddress_byVars
  //
  //  Purpose:
  //    Test step to set the local address in the MQTT entity context. Parameters are required.
  //    The function will take the base port number from the parameters and adds the entity's offset
  //    inside its entity group (or in case the 3rd parameter is present, then the value found there)
  //    to get its assigned port number.
  //
  //  Parameters:
  //    pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args
  //    contextArgs.varNames[0] - *charstring variable* - local host
  //    contextArgs.varNames[1] - *integer variable* - local port
  //    contextArgs.varNames[2] - *integer variable* - offset [optional]
  //
  //  Related Constants:
  //    - <c_IOT_stepName_MQTT_setLocalAddress_byVars>
  ///////////////////////////////////////////////////////////
  function f_IOT_LGen_step_MQTT_setLocalAddress_byVars(in EPTF_LGenBase_TestStepArgs pl_ptr)
  runs on IOT_LGen_CT
  {
    // 1st param: localHost: charstring
    // 2nd param: localPort: integer
    // 3rd param: offset: integer
    f_EPTF_MQTT_Logging_DEBUG(log2str(%definitionId, pl_ptr));
    
    if (not f_EPTF_MQTT_setStepCtx(pl_ptr, v_MQTT_ctx)) { return; }
    
    var integer vl_eRelIdxInEGrp := f_IOT_LGen_getEntityIdxinEntityGroup(pl_ptr);
    
    var EPTF_IntegerList vl_varIds := {};
    f_EPTF_LGenBase_fsmVarIdListFromStep(pl_ptr, vl_varIds);
    
    if (sizeof(vl_varIds)>=2)
    {
      var EPTF_Var_DirectContent vl_host, vl_port, vl_offset;
      f_EPTF_Var_getContent(vl_varIds[0], vl_host);
      f_EPTF_Var_getContent(vl_varIds[1], vl_port);
      if (sizeof(vl_varIds)==3) { f_EPTF_Var_getContent(vl_varIds[2], vl_offset); }
      else { vl_offset.intVal := vl_eRelIdxInEGrp; }
      
      if (not ischosen(vl_host.charstringVal)) {
        f_EPTF_MQTT_Logging_WARNING(log2str(%definitionId, " first param is not charstring variable!"));
        return;
      }
      if (not ischosen(vl_port.intVal)) {
        f_EPTF_MQTT_Logging_WARNING(log2str(%definitionId, " second param is not integer variable!"));
        return;
      }
      if (not ischosen(vl_offset.intVal)) {
        f_EPTF_MQTT_Logging_WARNING(log2str(%definitionId, " third param is not integer variable!"));
        return;
      }
      
      var integer vl_localPort := vl_port.intVal + vl_offset.intVal;
	  f_EPTF_MQTT_Logging_VERBOSE(log2str(%definitionId, " calculated local port ",vl_localPort));
      
      if (vl_localPort < 65535)
      {
        f_EPTF_MQTT_addressDB_add(
          { 
            hostName := vl_host.charstringVal,
            portNumber := vl_localPort
          },
          v_MQTT_sessionDB.data[v_MQTT_ctx.sessionIdx].localAddrIdx
        );
      }
      else {
        f_EPTF_MQTT_Logging_WARNING(log2str(%definitionId, " calculated local port ",vl_localPort," would be larger than 65536! step aborted."));
      }
    }
    else {
      f_EPTF_MQTT_Logging_WARNING(log2str(%definitionId, " at least two variables are needed as params!"));
    }
  }

  ///////////////////////////////////////////////////////////
  //  Function: f_IOT_LGen_step_MQTT_setClientId_stringParam
  //
  //  Purpose:
  //    Test step to set the client id the MQTT entity context. Parameters are required.
  //    The function will take the entity's offset inside its entity group and concatenate it
  //    to the string parameter of the test step
  //
  //  Parameters:
  //    pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args
  //    contextArgs.charstringVal - *charstring* - base client id
  //
  //  Related Constants:
  //    - <c_IOT_stepName_MQTT_setClientId_stringParam>
  ///////////////////////////////////////////////////////////
  function f_IOT_LGen_step_MQTT_setClientId_stringParam(in EPTF_LGenBase_TestStepArgs pl_ptr)
  runs on IOT_LGen_CT
  {
    f_EPTF_MQTT_Logging_DEBUG(log2str(%definitionId));
    
    if (not f_EPTF_MQTT_setStepCtx(pl_ptr, v_MQTT_ctx)) { return; }

	var charstring vl_clientId := f_EPTF_LGenBase_charstringValOfStep(pl_ptr);
	
	var integer vl_eRelIdxInEGrp := f_IOT_LGen_getEntityIdxinEntityGroup(pl_ptr);
	
    v_MQTT_sessionDB.data[v_MQTT_ctx.sessionIdx].clientId := vl_clientId & int2str(vl_eRelIdxInEGrp);
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_IOT_LGen_step_LwM2M_setClientNameInRegister
  //
  //  Purpose:
  //    Test step to set the endpoint client name in the LWM2M Register message
  //    that must be previously loaded into *v_LwM2M_msgToSend*. The test step
  //    currently hard codes the base name to "eantwuhDev_" and concatenates the entity's index
  //    inside its entity group
  //
  //  Parameters:
  //    pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args
  //
  //  Related Constants:
  //    - <c_IOT_stepName_LwM2M_setClientNameInRegister>
  //
  //  Related test steps:
  //    - <f_COAP_step_loadTemplate_byStringId>
  ///////////////////////////////////////////////////////////
  function f_IOT_LGen_step_LwM2M_setClientNameInRegister(in EPTF_LGenBase_TestStepArgs pl_ptr)
  runs on IOT_LGen_CT
  {
    f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId));
    
    var integer vl_eRelIdxInEGrp := f_IOT_LGen_getEntityIdxinEntityGroup(pl_ptr);
    
    v_LwM2M_msgToSend.pdu.Register.endpointClientName := "eantwuhDev_" & int2str(vl_eRelIdxInEGrp);
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_IOT_LGen_step_LwM2M_setClientNameInRegister_stringVar
  //
  //  Purpose:
  //    Test step to set the endpoint client name in the LWM2M Register message
  //    that must be previously loaded into *v_LwM2M_msgToSend*. The test step
  //    expects the base name to be passed as a string parameter and concatenates the entity's index
  //    inside its entity group
  //
  //  Parameters:
  //    pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args
  //    contextArgs.varNames[0] - *charstring variable* - base name
  //
  //  Related Constants:
  //    - <c_IOT_stepName_LwM2M_setClientNameInRegister_stringVar>
  //
  //  Related test steps:
  //    - <f_COAP_step_loadTemplate_byStringId>
  ///////////////////////////////////////////////////////////
  function f_IOT_LGen_step_LwM2M_setClientNameInRegister_stringVar(in EPTF_LGenBase_TestStepArgs pl_ptr)
  runs on IOT_LGen_CT
  {
    f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId));
    
    var EPTF_IntegerList vl_varIds := {};
    f_EPTF_LGenBase_fsmVarIdListFromStep(pl_ptr, vl_varIds);

    if (sizeof(vl_varIds)==1)
    {
      var EPTF_Var_DirectContent vl_endpoint;
      f_EPTF_Var_getContent(vl_varIds[0], vl_endpoint);

      if (not ischosen(vl_endpoint.charstringVal)) {
        f_EPTF_COAP_Logging_WARNING(log2str(%definitionId, " first param is not charstring variable!"));
        return;
      }
      
      var integer vl_eRelIdxInEGrp := f_IOT_LGen_getEntityIdxinEntityGroup(pl_ptr);
      v_LwM2M_msgToSend.pdu.Register.endpointClientName := vl_endpoint.charstringVal & int2str(vl_eRelIdxInEGrp);
    }
    else {
      f_EPTF_COAP_Logging_WARNING(log2str(%definitionId, " one variable (base name) is needed as parameter!"));
    }
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_IOT_LGen_step_HTTP_initEntityContext
  //
  //  Purpose:
  //    Test step to initialize the HTTP entity context by calling
  //    <f_EPTF_HTTP_setEntityContext>.
  //
  //  Parameters:
  //    pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args
  //
  //  Related Constants:
  //    - <c_IOT_stepName_HTTP_initEntityContext>
  ///////////////////////////////////////////////////////////
  function f_IOT_LGen_step_HTTP_initEntityContext(in EPTF_LGenBase_TestStepArgs pl_ptr)
  runs on IOT_LGen_CT
  {
    f_EPTF_HTTP_setEntityContext(
      pl_eIdx := pl_ptr.eIdx,
      pl_method := "GET", pl_uri := "",
      pl_version_major := 1, pl_version_minor := 1,
      pl_headerlines := {{"Connection","Keep-Alive"}},
      pl_connId := -1, //v_HTTP_portGroupConnectionHandle,
      pl_authDetails := -,    
      pl_body := { charVal := "" });
  }

  ///////////////////////////////////////////////////////////
  //  Function: f_IOT_LGen_step_HTTP_openConnection_byVars
  //
  //  Purpose:
  //    Test step to open a TCP connection for HTTP. Requires parameters
  //
  //  Parameters:
  //    pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args
  //    contextArgs.varNames[0] - *charstring variable* - local host
  //    contextArgs.varNames[1] - *integer variable* - local port
  //    contextArgs.varNames[2] - *charstring variable* - remote host
  //    contextArgs.varNames[3] - *integer variable* - remote port
  //
  //  Related Constants:
  //    - <c_IOT_stepName_HTTP_openConnection_byVars>
  ///////////////////////////////////////////////////////////
  function f_IOT_LGen_step_HTTP_openConnection_byVars(in EPTF_LGenBase_TestStepArgs pl_ptr)
  runs on IOT_LGen_CT
  {
    // 1st param: localHost: charstring
    // 2nd param: localPort: integer
    // 3rd param: remoteHost: charstring
    // 4th param: remotePort: integer
    f_EPTF_COAP_Logging_DEBUG(log2str(%definitionId, pl_ptr));
    
    var integer vl_eRelIdxInEGrp := f_IOT_LGen_getEntityIdxinEntityGroup(pl_ptr);
    
    var EPTF_IntegerList vl_varIds := {};
    f_EPTF_LGenBase_fsmVarIdListFromStep(pl_ptr, vl_varIds);
    
    if (sizeof(vl_varIds)==4)
    {
      var EPTF_Var_DirectContent vl_localHost, vl_localPort, vl_remoteHost, vl_remotePort;
      f_EPTF_Var_getContent(vl_varIds[0], vl_localHost);
      f_EPTF_Var_getContent(vl_varIds[1], vl_localPort);
      f_EPTF_Var_getContent(vl_varIds[2], vl_remoteHost);
      f_EPTF_Var_getContent(vl_varIds[3], vl_remotePort);
      
      if (not ischosen(vl_localHost.charstringVal)) {
        f_EPTF_COAP_Logging_WARNING(log2str(%definitionId, " first param is not charstring variable!"));
        return;
      }
      if (not ischosen(vl_localPort.intVal)) {
        f_EPTF_COAP_Logging_WARNING(log2str(%definitionId, " second param is not integer variable!"));
        return;
      }      
      if (not ischosen(vl_remoteHost.charstringVal)) {
        f_EPTF_COAP_Logging_WARNING(log2str(%definitionId, " third param is not charstring variable!"));
        return;
      }
      if (not ischosen(vl_remotePort.intVal)) {
        f_EPTF_COAP_Logging_WARNING(log2str(%definitionId, " fourth param is not integer variable!"));
        return;
      }
      
      var integer vl_clientPort := vl_localPort.intVal + vl_eRelIdxInEGrp;
	  f_EPTF_COAP_Logging_VERBOSE(log2str(%definitionId, " calculated local port ", vl_clientPort));
      
      if (vl_clientPort < 65535)
      {
        var integer vl_portGroupId := f_EPTF_HTTP_LocalTransport_newPort({
          name := "httpPort_"&int2str(vl_eRelIdxInEGrp),
          localHostInformation := { vl_localHost.charstringVal, vl_clientPort},
	  	  remoteHostInformation := { vl_remoteHost.charstringVal, vl_remotePort.intVal},
          instantConnOpen := true,
          instantConnClose := false, 
          useSSL := false, 
          userFunctions := omit
        });
        
        f_EPTF_HTTP_setEntityContextConnectionId(pl_ptr.eIdx, vl_portGroupId);
      }
      else {
        f_EPTF_COAP_Logging_WARNING(log2str(%definitionId, " calculated local port ",vl_clientPort," would be larger than 65536! step aborted."));
      }
    }
    else {
      f_EPTF_COAP_Logging_WARNING(log2str(%definitionId, " exactly 4 variables are needed as params!"));
    }
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_IOT_LGen_step_HTTP_closeConnection
  //
  //  Purpose:
  //    Test step to close an already opened TCP connection for HTTP
  //
  //  Parameters:
  //    pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args
  //
  //  Related Constants:
  //    - <c_IOT_stepName_HTTP_closeConnection>
  ///////////////////////////////////////////////////////////
  function f_IOT_LGen_step_HTTP_closeConnection(in EPTF_LGenBase_TestStepArgs pl_ptr)
  runs on IOT_LGen_CT
  {
    f_EPTF_COAP_Logging_DEBUG(log2str(%definitionId, pl_ptr));
    
    var integer vl_portGroupId := f_EPTF_HTTP_getEntityContextConnectionId(pl_ptr.eIdx);

    f_EPTF_HTTP_LocalTransport_deletePort(vl_portGroupId);
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_IOT_LGen_step_HTTP_setUri_stringParam
  //
  //  Purpose:
  //    Test step to set a string - specified as a parameter - to the HTTP request URI
  //    of the message to be sent
  //
  //  Parameters:
  //    pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args
  //    contextArgs.charstringVal - *charstring* - URI to be set
  //
  //  Related Constants:
  //    - <c_IOT_stepName_HTTP_setUri_stringParam>
  ///////////////////////////////////////////////////////////
  function f_IOT_LGen_step_HTTP_setUri_stringParam(in EPTF_LGenBase_TestStepArgs pl_ptr)
  runs on IOT_LGen_CT
  {
  	var charstring vl_param := f_EPTF_LGenBase_charstringValOfStep(pl_ptr);
    f_EPTF_HTTP_setEntityContextURI(pl_ptr.eIdx, vl_param);
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_IOT_LGen_step_HTTP_addToUri_stringParam
  //
  //  Purpose:
  //    Test step to add a string - specified as a parameter - to the HTTP request URI
  //    of the message to be sent
  //
  //  Parameters:
  //    pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args
  //    contextArgs.charstringVal - *charstring* - URI part to be concatenated
  //
  //  Related Constants:
  //    - <c_IOT_stepName_HTTP_addToUri_stringParam>
  ///////////////////////////////////////////////////////////
  function f_IOT_LGen_step_HTTP_addToUri_stringParam(in EPTF_LGenBase_TestStepArgs pl_ptr)
  runs on IOT_LGen_CT
  {
  	var charstring vl_param := f_EPTF_LGenBase_charstringValOfStep(pl_ptr);
  	var charstring vl_uri := f_EPTF_HTTP_getEntityContextURI(pl_ptr.eIdx);
    f_EPTF_HTTP_setEntityContextURI(pl_ptr.eIdx, vl_uri & vl_param);
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_IOT_LGen_step_HTTP_addToUri_byVars
  //
  //  Purpose:
  //    Test step to add a string - specified as variadic parameter - to the HTTP request URI
  //    of the message to be sent
  //
  //  Parameters:
  //    pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args
  //    contextArgs.varNames[*] - *charstring variable* - string to be added
  //
  //  Related Constants:
  //    - <c_IOT_stepName_HTTP_addToUri_stringParam>
  ///////////////////////////////////////////////////////////
  function f_IOT_LGen_step_HTTP_addToUri_byVars(in EPTF_LGenBase_TestStepArgs pl_ptr)
  runs on IOT_LGen_CT
  { 
  	var EPTF_IntegerList vl_varIds := {};
    f_EPTF_LGenBase_fsmVarIdListFromStep(pl_ptr, vl_varIds);
    
    var EPTF_Var_DirectContent vl_var;
    var charstring vl_vars := ""
    
    for (var integer i:=0; i<sizeof(vl_varIds); i:=i+1) {
      f_EPTF_Var_getContent(vl_varIds[i], vl_var);
      if (ischosen(vl_var.charstringVal)) {
        vl_vars := vl_vars & vl_var.charstringVal;
      }
      // Could handle charstring list as well
    }
      
  	var charstring vl_uri := f_EPTF_HTTP_getEntityContextURI(pl_ptr.eIdx);
    f_EPTF_HTTP_setEntityContextURI(pl_ptr.eIdx, vl_uri & vl_vars);
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_IOT_LGen_step_HTTP_setMethod_stringParam
  //
  //  Purpose:
  //    Test step to set the method - specified as a string parameter - of the 
  //    HTTP request to be sent
  //
  //  Parameters:
  //    pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args
  //    contextArgs.charstringVal - *charstring* - method to be set
  //
  //  Related Constants:
  //    - <c_IOT_stepName_HTTP_setMethod_stringParam>
  ///////////////////////////////////////////////////////////
  function f_IOT_LGen_step_HTTP_setMethod_stringParam(in EPTF_LGenBase_TestStepArgs pl_ptr)
  runs on IOT_LGen_CT
  {
    var charstring vl_param := f_EPTF_LGenBase_charstringValOfStep(pl_ptr);
    f_EPTF_HTTP_setEntityContextMethod(pl_ptr.eIdx, vl_param);
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_IOT_LGen_step_HTTP_addHostHeader_byVars
  //
  //  Purpose:
  //    Test step to add a Host header to the HTTP messager to be sent. Requires parameters.
  //
  //  Parameters:
  //    pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args
  //    contextArgs.varNames[0] - *charstring variable* - host name
  //    contextArgs.varNames[1] - *integer variable* - port name
  //
  //  Related Constants:
  //    - <c_IOT_stepName_HTTP_addHostHeader_byVars>
  ///////////////////////////////////////////////////////////
  function f_IOT_LGen_step_HTTP_addHostHeader_byVars(in EPTF_LGenBase_TestStepArgs pl_ptr)
  runs on IOT_LGen_CT
  {
    // 1st param: remoteHost: charstring
    // 2nd param: remotePort: integer

    //f_EPTF_HTTP_setEntityContextMethod(pl_ptr.eIdx, vl_param);
    
    var EPTF_IntegerList vl_varIds := {};
    f_EPTF_LGenBase_fsmVarIdListFromStep(pl_ptr, vl_varIds);
    
    if (sizeof(vl_varIds)==2)
    {
      var EPTF_Var_DirectContent vl_host, vl_port;
      f_EPTF_Var_getContent(vl_varIds[0], vl_host);
      f_EPTF_Var_getContent(vl_varIds[1], vl_port);
      
      if (not ischosen(vl_host.charstringVal)) {
        f_EPTF_COAP_Logging_WARNING(log2str(%definitionId, " first param is not charstring variable!"));
        return;
      }
      if (not ischosen(vl_port.intVal)) {
        f_EPTF_COAP_Logging_WARNING(log2str(%definitionId, " second param is not integer variable!"));
        return;
      }
      
	  f_EPTF_HTTP_setEntityContextAddCustomHeader(pl_ptr.eIdx,
	    "Host",
	    vl_host.charstringVal & ":" & int2str(vl_port.intVal)
	  )
	  
    }
    else {
      f_EPTF_COAP_Logging_WARNING(log2str(%definitionId, " two variables are needed as params!"));
    }
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_IOT_LGen_step_Leshan_getClientFromResponse_intoVar
  //
  //  Purpose:
  //    Test step to fetch the client name of an HTTP response sent by Leshan
  //    into a variable
  //
  //  Parameters:
  //    pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args
  //    contextArgs.varNames[0] - *charstring variable* - client name will be loaded here
  //
  //  Related Constants:
  //    - <c_IOT_stepName_Leshan_getClientFromResponse_intoVar>
  ///////////////////////////////////////////////////////////
  function f_IOT_LGen_step_Leshan_getClientFromResponse_intoVar(in EPTF_LGenBase_TestStepArgs pl_ptr)
  runs on IOT_LGen_CT
  {
    var EPTF_IntegerList vl_varIds := {};
    f_EPTF_LGenBase_fsmVarIdListFromStep(pl_ptr, vl_varIds);
    
    if (sizeof(vl_varIds)!=1) { 
      f_EPTF_COAP_Logging_WARNING(log2str(%definitionId, " one variable is needed!"));
      return;
    } 
    
    //action("HTTP resp: ", v_EPTF_HTTP_incomingMessage,"\n");
    var JSON_PDU vl_json := dec_JSON(char2oct(v_EPTF_HTTP_incomingMessage.response.body));
    //action("JSON resp:" , vl_json,"\n");
    
    var EPTF_CharstringList vl_clients := {};
    
    // Let's fetch the first
    if (ischosen(vl_json.json_array) and sizeof(vl_json.json_array)>0) {
      if (ischosen(vl_json.json_array[0].json_object)) {
        for (var integer valIdx :=0; valIdx<sizeof(vl_json.json_array[0].json_object); valIdx:=valIdx+1) {
          if (vl_json.json_array[0].json_object[valIdx].json_name == "endpoint") {
            vl_clients[sizeof(vl_clients)] := unichar2char(vl_json.json_array[0].json_object[valIdx].json_value.json_string);
            break;
          }
        }
      }
    }
    
    /*
    if (ischosen(vl_json.json_array)) {
      for (var integer objIdx:=0; objIdx<sizeof(vl_json.json_array); objIdx:=objIdx+1) {
        if (ischosen(vl_json.json_array[objIdx].json_object)) {
          for (var integer valIdx :=0; valIdx<sizeof(vl_json.json_array[objIdx].json_object); valIdx:=valIdx+1) {
            if (vl_json.json_array[objIdx].json_object[valIdx].json_name == "endpoint") {
              vl_clients[sizeof(vl_clients)] := vl_json.json_array[objIdx].json_object[valIdx].json_value.json_string;
              break;
            }
          }
        }
      }
    }
	*/   
    /*
	JSON resp:=
	{
      json_array :=
	  {
        {
          json_object :=
          {
            { json_name := "endpoint",  json_value := { json_string := "client_0" } },
            { json_name := "registrationId", json_value := { json_string := "V18qVv4RL8" } },
            { json_name := "registrationDate", json_value := { json_string := "2017-02-01T14:20:39+01:00" } },
            { json_name := "lastUpdate", json_value := { json_string := "2017-02-01T14:20:39+01:00" } },
            { json_name := "address", json_value := { json_string := "127.0.0.1:30000" } },
            { json_name := "lwM2mVersion", json_value := { json_string := "1.0" } },
            { json_name := "lifetime", json_value := { json_number := 30 } },
            { json_name := "bindingMode", json_value := { json_string := "U" } },
            { json_name := "rootPath", json_value := { json_string := "/" } },
            { json_name := "objectLinks", json_value := {
              json_array := {
                { json_object := {
                  { json_name := "url", json_value := { json_string := "/3/0" } },
                  { json_name := "attributes", json_value := { json_object := { } } }
                } } }
              }
            },
            { json_name := "secure", json_value := { json_false := { } } },
            { json_name := "additionalRegistrationAttributes", json_value := { json_object := { } } }
          }
        }
      }
    }
    */
    //action("clients: ", vl_clients,"\n");
    
    if (sizeof(vl_clients)>0)
	{
      // Selecting and loading the last one:
      //action("selected client: ", vl_clients[sizeof(vl_clients)-1],"\n");
      f_EPTF_Var_setContent(vl_varIds[0], { charstringVal := vl_clients[0]});
    }
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_IOT_LGen_step_tcFinished_withVerdict
  //
  //  Purpose:
  //    Test step to set the final verdict reported by the FSM using a verdict variable as parameter.
  //
  //  Parameters:
  //    pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args
  //    contextArgs.verdict - *verdicttype* - verdict to be reported
  //
  //  Related Constants:
  //    - <c_IOT_stepName_tcFinished_withVerdict>
  ///////////////////////////////////////////////////////////
  function f_IOT_LGen_step_tcFinished_withVerdict(in EPTF_LGenBase_TestStepArgs pl_ptr)
  runs on IOT_LGen_CT
  {
    var charstring vl_reason := "";
 	var verdicttype vl_verdict := pass;
 	
    var charstring vl_behavior := "behavior ["&f_EPTF_LGenBase_bIdx2Str(pl_ptr.reportedEvent.event.bIdx)&"]";
    var charstring vl_event := "event ["&
      f_EPTF_LGenBase_iIdx2Str(
        pl_ptr.reportedEvent.event.bIdx, 
        pl_ptr.reportedEvent.event.iIdx,
        f_EPTF_LGenBase_getFsmIndexByCtxIdx(pl_ptr.eIdx, pl_ptr.refContext.fCtxIdx)
      )&"]";
 	
 	f_EPTF_LGenBase_verdictOfStep(pl_ptr, vl_verdict, vl_reason);

	var charstring vl_state := "state ["&f_EPTF_LGenBase_getFsmStateNameByStepArgs(pl_ptr)&"]";
	
    f_EPTF_LGenBase_step_cancelAllTimers(pl_ptr);
    f_COAP_step_cleanUp(pl_ptr);
    f_MQTT_step_cleanUp(pl_ptr);
    f_LwM2M_step_cleanupDevice(pl_ptr);

    if (vl_verdict == pass)
    {
      action("=> pass");
      f_EPTF_LGenBase_step_trafficSuccess(pl_ptr);
    }
    else if (vl_verdict == fail)
    {
      action(vl_state); action(vl_behavior); action(vl_event);
      action("=> fail");
      f_EPTF_LGenBase_step_trafficFailed(pl_ptr);
    }
    else if (vl_verdict == inconc)
    {
      action(vl_state); action(vl_behavior); action(vl_event);
      action("=> inconc");
      f_EPTF_LGenBase_step_trafficTimeout(pl_ptr);
    }
    else if (vl_verdict == error)
    {
      action(vl_state); action(vl_behavior); action(vl_event);
      action("=> error");
      f_EPTF_LGenBase_step_trafficError(pl_ptr);
    }
  }
 
  ///////////////////////////////////////////////////////////
  //  Function: f_IOT_LGen_step_print_stringParam
  //
  //  Purpose:
  //    Test step to print a string parameter as a TTCN-3 action() statement
  //
  //  Parameters:
  //    pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args
  //    contextArgs.charstringVal - *charstring* - the string to be printed
  //
  //  Related Constants:
  //    - <c_IOT_stepName_print_stringParam>
  ///////////////////////////////////////////////////////////
  function f_IOT_LGen_step_print_stringParam(in EPTF_LGenBase_TestStepArgs pl_ptr)
  runs on IOT_LGen_CT
  {
    f_EPTF_MQTT_Logging_DEBUG(log2str(%definitionId));
    
    var charstring vl_toPrint := f_EPTF_LGenBase_charstringValOfStep(pl_ptr);
	
    action(vl_toPrint);
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_IOT_LGen_step_FSM_RegDereg_initResourceValues
  //
  //  Purpose:
  //    Test step to init resources of the RegDereg FSM
  //
  //  Parameters:
  //    pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args
  //
  //  Related Constants:
  //    - <c_IOT_stepName_FSM_RegDereg_initResourceValues>
  ///////////////////////////////////////////////////////////
  function f_IOT_LGen_step_FSM_RegDereg_initResourceValues(in EPTF_LGenBase_TestStepArgs pl_ptr)
  runs on IOT_LGen_CT
  {
    f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId));
    f_EPTF_LwM2M_setStepCtx(pl_ptr, v_LwM2M_ctx);
    
    if (v_LwM2M_ctx.deviceIdx >= 0)
    {
      f_LwM2M_ObjectDB_setResourceValue(
        p_db := v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects, 
        p_objId := c_LwM2M_Device_obj_id, p_objInstId := 0, p_resourceId := c_LwM2M_Device_Manufacturer,
        p_value := { strValue := "TitanSim" }
      );
    }
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_IOT_LGen_step_FSM_SimDevice_createResources
  //
  //  Purpose:
  //    Test step to create resources of the SimDevice FSM
  //
  //  Parameters:
  //    pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args
  //
  //  Related Constants:
  //    - <c_IOT_stepName_FSM_SimDevice_createResources>
  ///////////////////////////////////////////////////////////
  function f_IOT_LGen_step_FSM_SimDevice_createResources(in EPTF_LGenBase_TestStepArgs pl_ptr)
  runs on IOT_LGen_CT
  {
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_IOT_LGen_step_FSM_SimDevice_initTransport_boolVar
  //
  //  Purpose:
  //    Test step to initialize the COAP transport (either UDP, or DTLS-PSK)
  //    of the SimDevice FSM. Requires parameter.
  //
  //  Parameters:
  //    pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args
  //    contextArgs.varNames[0] - *boolean variable* - will use DTLS-PSK when true, UDP otherwise
  //
  //  Related Constants:
  //    - <c_IOT_stepName_FSM_SimDevice_initTransport_boolVar>
  ///////////////////////////////////////////////////////////
  function f_IOT_LGen_step_FSM_SimDevice_initTransport_boolVar(in EPTF_LGenBase_TestStepArgs pl_ptr)
  runs on IOT_LGen_CT
  {
    f_EPTF_COAP_Logging_DEBUG(log2str(%definitionId));

    if (not f_EPTF_COAP_setStepCtx(pl_ptr, v_COAP_ctx)) { return; }

    var EPTF_IntegerList vl_varIds := {};
    f_EPTF_LGenBase_fsmVarIdListFromStep(pl_ptr, vl_varIds);

    if (sizeof(vl_varIds)==1)
    {
      var EPTF_Var_DirectContent vl_dtlsOn;
      f_EPTF_Var_getContent(vl_varIds[0], vl_dtlsOn);

      if (not ischosen(vl_dtlsOn.boolVal)) {
        f_EPTF_COAP_Logging_WARNING(log2str(%definitionId, " first param is not boolean variable!"));
        return;
      }
      
      // If we have to use DTLS
      if (vl_dtlsOn.boolVal == true)
      {
        // We need to adjust the local and remote protocol to dtls
        if (v_COAP_FsmCtxDB.data[v_COAP_ctx.fsmCtxIdx].remoteAddressIdx >= 0)
        {
          v_COAP_transportEndpointDB.data[v_COAP_EntityCtxDB.data[v_COAP_ctx.eCtxIdx].localAddressIdx].proto :=
            { dtls := { udp := {} }};
          v_COAP_transportEndpointDB.data[v_COAP_FsmCtxDB.data[v_COAP_ctx.fsmCtxIdx].remoteAddressIdx].proto :=
            { dtls := { udp := {} }};
        }
        // We also need to initialize the DTLS connection:
        //  - we need to set the identity and the keys first into the fsmCtx
        //      we will use the tsp_EPTF_COAP_LGen_psks module par as a base and add the entity index inside the group to create the identity
        if (sizeof(tsp_EPTF_COAP_LGen_psks) >= 1)
        {
          var integer vl_eRelIdxInEGrp := f_IOT_LGen_getEntityIdxinEntityGroup(pl_ptr);
          v_COAP_FsmCtxDB.data[v_COAP_ctx.fsmCtxIdx].psk.identity := tsp_EPTF_COAP_LGen_psks[0].identity & int2str(vl_eRelIdxInEGrp);
          v_COAP_FsmCtxDB.data[v_COAP_ctx.fsmCtxIdx].psk.key := tsp_EPTF_COAP_LGen_psks[0].key;
          f_COAP_step_startDTLS(pl_ptr);
        }
        else {
          f_EPTF_COAP_Logging_WARNING(log2str(%definitionId, " we want to use the first item in tsp_EPTF_COAP_LGen_psks to generate the identity and key!"));
        }
      }
      // If we use plain UDP
      else
      {
        f_COAP_step_startListening(pl_ptr);
      }
    }
    else {
      f_EPTF_COAP_Logging_WARNING(log2str(%definitionId, " one variable (useDTLS) is needed as parameter!"));
    }
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_IOT_LGen_step_FSM_SimDevice_initResourceValues
  //
  //  Purpose:
  //    Test step to init the resource values of the SimDevice FSM
  //
  //  Parameters:
  //    pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args
  //
  //  Related Constants:
  //    - <c_IOT_stepName_FSM_SimDevice_initResourceValues>
  ///////////////////////////////////////////////////////////
  function f_IOT_LGen_step_FSM_SimDevice_initResourceValues(in EPTF_LGenBase_TestStepArgs pl_ptr)
  runs on IOT_LGen_CT
  {
    f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId));
    f_EPTF_LwM2M_setStepCtx(pl_ptr, v_LwM2M_ctx);
    
    if (v_LwM2M_ctx.deviceIdx >= 0)
    {
      var LwM2M_Resource v_res;
      
      // Manufacturer
      f_LwM2M_ObjectDB_setResourceValue(
        p_db := v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects, 
        p_objId := c_LwM2M_Device_obj_id, p_objInstId := 0, p_resourceId := c_LwM2M_Device_Manufacturer,
        p_value := { strValue := "RIoT" }
      );
      
      // Latitude
      f_LwM2M_ObjectDB_getResource(
        p_db := v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects, 
        p_objId := 6, p_objInstId := 0, p_resourceId := 0,
        p_resource := v_res
      );      
      v_res.dataSample := {
        samplesName := "Latitude",
	    samplesPointer := -1,
	    valuePointer := -1
      }
      f_LwM2M_Resource_setNextDataSample(v_res, v_IOT_LGen_DataSamples_DB);
      f_LwM2M_ObjectDB_setResource(
        p_db := v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects, 
        p_objId := 6, p_objInstId := 0, p_resourceId := 0,
        p_resource := v_res
      );     
      /* f_LwM2M_ObjectDB_setResourceValue(
        p_db := v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects, 
        p_objId := 6, p_objInstId := 0, p_resourceId := 0,
        p_value := { floatValue := 47.475096 }
      );*/
      
      //Longitude
      f_LwM2M_ObjectDB_getResource(
        p_db := v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects, 
        p_objId := 6, p_objInstId := 0, p_resourceId := 1,
        p_resource := v_res
      );     
      v_res.dataSample := {
        samplesName := "Longitude",
	    samplesPointer := -1,
	    valuePointer := -1
      }
      f_LwM2M_Resource_setNextDataSample(v_res, v_IOT_LGen_DataSamples_DB);      
      f_LwM2M_ObjectDB_setResource(
        p_db := v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects, 
        p_objId := 6, p_objInstId := 0, p_resourceId := 1,
        p_resource := v_res
      );
      /*f_LwM2M_ObjectDB_setResourceValue(
        p_db := v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects, 
        p_objId := 6, p_objInstId := 0, p_resourceId := 1,
        p_value := { floatValue := 19.057871 }
      );*/
      
      // Altitude
      f_LwM2M_ObjectDB_setResourceValue(
        p_db := v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects, 
        p_objId := 6, p_objInstId := 0, p_resourceId := 2,
        p_value := { floatValue := 12.0 }
      );
      
      // Temperature
      f_LwM2M_ObjectDB_setResourceValue(
        p_db := v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects, 
        p_objId := 3303, p_objInstId := 0, p_resourceId := 5700,
        p_value := { floatValue := 34.35 }
      );
      
      // Dropped
      f_LwM2M_ObjectDB_setResourceValue(
        p_db := v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects, 
        p_objId := 3400, p_objInstId := 0, p_resourceId := 1,
        p_value := { boolValue := false }
      );
    }
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_IOT_LGen_step_FSM_SimDevice_updateResourceValues
  //
  //  Purpose:
  //    Test step to update the resource values of the SimDevice FSM
  //
  //  Parameters:
  //    pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args
  //
  //  Related Constants:
  //    - <c_IOT_stepName_FSM_SimDevice_updateResourceValues>
  ///////////////////////////////////////////////////////////
  function f_IOT_LGen_step_FSM_SimDevice_updateResourceValues(in EPTF_LGenBase_TestStepArgs pl_ptr)
  runs on IOT_LGen_CT
  {
    f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId));
    f_EPTF_LwM2M_setStepCtx(pl_ptr, v_LwM2M_ctx);
    
    var LwM2M_Resource v_res;
      
    //////////////////
    // Dropped
    
    if(
      f_LwM2M_ObjectDB_getResource(
        p_db := v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects, 
        p_objId := 3400, p_objInstId := 0, p_resourceId := 1,
        p_resource := v_res
      )
    ){
      var boolean droppableChanged := false;
      if (v_res.val.boolValue) {
        v_res.val.boolValue := false;
        droppableChanged := true;
        action("Drop cleared")
      }
      else {
        var float v_rnd := rnd();
        if (v_rnd>=0.5) { 
          v_res.val.boolValue := true;
          droppableChanged := true;
          action("Dropped: ",v_rnd);
        }
      }
    
      if (droppableChanged)
      {
        f_LwM2M_ObjectDB_setResource(
          p_db := v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects, 
          p_objId := 3400, p_objInstId := 0, p_resourceId := 1,
          p_resource := v_res
        );
        f_EPTF_LwM2M_sendNotificationForResource(pl_ptr, v_res);
      }
    }
      
    //////////////////
    // Temperature
    
    if (
      f_LwM2M_ObjectDB_getResource(
        p_db := v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects, 
        p_objId := 3303, p_objInstId := 0, p_resourceId := 5700,
        p_resource := v_res //{ floatValue := int2float(vl_randomVal) }
      )
    ){      
      v_res.val.floatValue := int2float(32 - 10 +1)*rnd() + 10.0;      
      f_LwM2M_ObjectDB_setResource(
        p_db := v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects, 
        p_objId := 3303, p_objInstId := 0, p_resourceId := 5700,
        p_resource := v_res
      );      
      f_EPTF_LwM2M_sendNotificationForResource(pl_ptr, v_res);
    }
            
    //////////////////
    // Latitude
      
    if (
      f_LwM2M_ObjectDB_getResource(
        p_db := v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects, 
        p_objId := 6, p_objInstId := 0, p_resourceId := 0,
        p_resource := v_res
      )
    ){    
      f_LwM2M_Resource_setNextDataSample(v_res, v_IOT_LGen_DataSamples_DB);      
      f_LwM2M_ObjectDB_setResource(
        p_db := v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects, 
        p_objId := 6, p_objInstId := 0, p_resourceId := 0,
        p_resource := v_res
      );      
      f_EPTF_LwM2M_sendNotificationForResource(pl_ptr, v_res);
    }
      
    //////////////////
    // Longitude
      
    if (
      f_LwM2M_ObjectDB_getResource(
        p_db := v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects, 
        p_objId := 6, p_objInstId := 0, p_resourceId := 1,
        p_resource := v_res
      )
    ){      
      f_LwM2M_Resource_setNextDataSample(v_res, v_IOT_LGen_DataSamples_DB);
      f_LwM2M_ObjectDB_setResource(
        p_db := v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects, 
        p_objId := 6, p_objInstId := 0, p_resourceId := 1,
        p_resource := v_res
      );      
      f_EPTF_LwM2M_sendNotificationForResource(pl_ptr, v_res);
    }
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_IOT_LGen_step_FSM_SimDevice_handleExecute
  //
  //  Purpose:
  //    Test step to handle incoming LwM2M EXECUTE request in
  //    the SimDevice FSM
  //
  //  Parameters:
  //    pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args
  //
  //  Related Constants:
  //    - <c_IOT_stepName_FSM_SimDevice_handleExecute>
  ///////////////////////////////////////////////////////////
  function f_IOT_LGen_step_FSM_SimDevice_handleExecute(in EPTF_LGenBase_TestStepArgs pl_ptr)
  runs on IOT_LGen_CT
  {
    f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId));
    f_EPTF_LwM2M_setStepCtx(pl_ptr, v_LwM2M_ctx);
        
    if (ischosen(v_LwM2M_msgToProcess.pdu.Execute) and v_LwM2M_ctx.deviceIdx >= 0)
    {
      var LwM2M_Resource v_res;
      var boolean vl_found := false;
	  if (f_LwM2M_ObjectPath_isResource(v_LwM2M_msgToProcess.pdu.Execute.path))
	  {
	    f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " Looking up resource"));
	    vl_found := f_LwM2M_ObjectDB_getResource(
  	      v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects,
  	      v_LwM2M_msgToProcess.pdu.Execute.path.objectId,
  	      v_LwM2M_msgToProcess.pdu.Execute.path.objectInstanceId,
  	      v_LwM2M_msgToProcess.pdu.Execute.path.resourceId,
  	      v_res
	    );
	    f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " resource found: ", v_res));
	    
	    action("executed: ", v_res);
	    
        v_LwM2M_msgToSend.eIdx := v_LwM2M_ctx.eIdx;
        v_LwM2M_msgToSend.fsmIdx := v_LwM2M_ctx.fsmIdx;
  	    v_LwM2M_msgToSend.pdu :=
	    {
	      Response := {
	        location := {},
	        code := 204,
	        contentFormat := omit,
	        resources := {}
	      }
	    }  	    
	    vf_EPTF_LwM2M_Transport_send.apply(v_LwM2M_msgToSend);
	  }
	  else { f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " Only resource can be executed, ignoring request")); }
	}
	else { f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " not execute pdu, or no device available, returning")); }
  }
  
  ///////////////////////////////////////////////////////////
  //  Function: f_IOT_LGen_step_genRndValue_varParams
  //
  //  Purpose:
  //    Test step to generate a random number and load it into an integer variable.
  //    The generated random number will be between two integers provided as parameters
  //    to set the limits for RNG.
  //
  //  Parameters:
  //    pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args
  //    contextArgs.varNames[0] - *in integer variable* - min value
  //    contextArgs.varNames[1] - *in integer variable* - max value
  //    contextArgs.varNames[2] - *out integer variable* - generated value
  //
  //  Related Constants:
  //    - <c_IOT_stepName_FSM_SimDevice_genRndValue_varParams>
  ///////////////////////////////////////////////////////////
  function f_IOT_LGen_step_genRndValue_varParams(in EPTF_LGenBase_TestStepArgs pl_ptr)
  runs on IOT_LGen_CT
  {
    // 1st param: min value (in): integer
    // 2nd param: max value (in): integer
    // 3rd param: rnd value (out): integer
    f_EPTF_COAP_Logging_DEBUG(log2str(%definitionId, pl_ptr));
    
    var EPTF_IntegerList vl_varIds := {};
    f_EPTF_LGenBase_fsmVarIdListFromStep(pl_ptr, vl_varIds);
    
    if (sizeof(vl_varIds)==3)
    {
      var EPTF_Var_DirectContent vl_min, vl_max, vl_rnd;
      f_EPTF_Var_getContent(vl_varIds[0], vl_min);
      f_EPTF_Var_getContent(vl_varIds[1], vl_max);
      f_EPTF_Var_getContent(vl_varIds[2], vl_rnd);
      
      if (not ischosen(vl_min.intVal)) {
        f_EPTF_COAP_Logging_WARNING(log2str(%definitionId, " first param is not integer variable!"));
        return;
      }
      if (not ischosen(vl_max.intVal)) {
        f_EPTF_COAP_Logging_WARNING(log2str(%definitionId, " second param is not integer variable!"));
        return;
      }
      
      var integer vl_randomVal := float2int(int2float(vl_max.intVal - vl_min.intVal +1)*rnd()) + vl_min.intVal;
	  f_EPTF_COAP_Logging_VERBOSE(log2str(%definitionId, " calculated random value ",vl_randomVal));
      
      f_EPTF_Var_setContent(vl_varIds[2], { intVal := vl_randomVal });
    }
    else {
      f_EPTF_COAP_Logging_WARNING(log2str(%definitionId, " at least three variables are needed as params!"));
    }
  }
}

  //    contextArgs.varNames[0] - *in variable* - min value