<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>IOT_LGen_Steps - IoT_Load_Test_Framework</title><link rel="stylesheet" type="text/css" href="../styles/main.css"><script language=JavaScript src="../javascript/main.js"></script><script language=JavaScript src="../javascript/prettify.js"></script></head><body class="FramedContentPage" onLoad="NDOnLoad();prettyPrint();"><script language=JavaScript><!--
if (browserType) {document.write("<div class=" + browserType + ">");if (browserVer) {document.write("<div class=" + browserVer + ">"); }}// --></script>

<!--  Generated by Natural Docs, version 1.52 -->
<!--  http://www.naturaldocs.org  -->

<!-- saved from url=(0026)http://www.naturaldocs.org -->




<div id=Content><div class="CFile"><div class=CTopic id=MainTopic><h1 class=CTitle><a name="IOT_LGen_Steps"></a>IOT_LGen_Steps</h1><div class=CBody><h4 class=CHeading>Purpose</h4><p>This module contains test step functions for an IoT load generator component</p><h4 class=CHeading>See also</h4><p><a href="IOT_LGen_Definitions-ttcn.html#IOT_LGen_Definitions" class=LFile id=link49 onMouseOver="ShowTip(event, 'tt49', 'link49')" onMouseOut="HideTip('tt49')">IOT_LGen_Definitions</a></p><h4 class=CHeading>Module depends on</h4><ul><li><a href="IOT_LGen_Definitions-ttcn.html#IOT_LGen_Definitions" class=LFile id=link50 onMouseOver="ShowTip(event, 'tt49', 'link50')" onMouseOut="HideTip('tt49')">IOT_LGen_Definitions</a></li><li>&lt;EPTF_MQTT_LGen_Functions&gt;</li><li>&lt;EPTF_COAP_LGen_Definitions&gt;</li><li>&lt;EPTF_COAP_LGen_Functions&gt;</li><li>&lt;EPTF_LwM2M_LGen_Functions&gt;</li><li>&lt;EPTF_LwM2M_Object_Definitions&gt;</li><li>&lt;EPTF_LwM2M_Object_Functions&gt;</li><li>&lt;EPTF_HTTP_Functions&gt;</li><li>&lt;EPTF_HTTP_Transport_Functions&gt;</li><li>&lt;EPTF_CLL_Common_Definitions&gt;</li><li>&lt;EPTF_CLL_ExecCtrlClient_Functions&gt;</li><li>&lt;EPTF_CLL_LGenBase_Definitions&gt;</li><li>&lt;EPTF_CLL_LGenBase_StepFunctions&gt;</li><li>&lt;EPTF_CLL_LGenBase_ConfigFunctions&gt;</li><li>&lt;EPTF_CLL_Variable_Definitions&gt;</li><li>&lt;EPTF_CLL_Variable_Functions&gt;</li></ul><h4 class=CHeading>Test Steps [Generic]</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>testcase finished</td><td class=CDLDescription><a href="#f_IOT_LGen_step_tcFinished_withVerdict" class=LFunction id=link51 onMouseOver="ShowTip(event, 'tt40', 'link51')" onMouseOut="HideTip('tt40')">f_IOT_LGen_step_tcFinished_withVerdict</a>, <a href="#c_IOT_stepName_tcFinished_withVerdict" class=LConstant id=link52 onMouseOver="ShowTip(event, 'tt1', 'link52')" onMouseOut="HideTip('tt1')">c_IOT_stepName_tcFinished_withVerdict</a></td></tr><tr><td class=CDLEntry>print</td><td class=CDLDescription><a href="#f_IOT_LGen_step_print_stringParam" class=LFunction id=link53 onMouseOver="ShowTip(event, 'tt41', 'link53')" onMouseOut="HideTip('tt41')">f_IOT_LGen_step_print_stringParam</a>, <a href="#c_IOT_stepName_print_stringParam" class=LConstant id=link54 onMouseOver="ShowTip(event, 'tt2', 'link54')" onMouseOut="HideTip('tt2')">c_IOT_stepName_print_stringParam</a></td></tr><tr><td class=CDLEntry>RND generator</td><td class=CDLDescription><a href="#f_IOT_LGen_step_genRndValue_varParams" class=LFunction id=link55 onMouseOver="ShowTip(event, 'tt48', 'link55')" onMouseOut="HideTip('tt48')">f_IOT_LGen_step_genRndValue_varParams</a>, <a href="#c_IOT_stepName_genRndValue_varParams" class=LConstant id=link56 onMouseOver="ShowTip(event, 'tt3', 'link56')" onMouseOut="HideTip('tt3')">c_IOT_stepName_genRndValue_varParams</a></td></tr></table><h4 class=CHeading>Test Steps [COAP]</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>set local address</td><td class=CDLDescription><a href="#f_IOT_LGen_step_COAP_setLocalAddress_byVars" class=LFunction id=link57 onMouseOver="ShowTip(event, 'tt26', 'link57')" onMouseOut="HideTip('tt26')">f_IOT_LGen_step_COAP_setLocalAddress_byVars</a>, <a href="#c_IOT_stepName_COAP_setLocalAddress_byVars" class=LConstant id=link58 onMouseOver="ShowTip(event, 'tt4', 'link58')" onMouseOut="HideTip('tt4')">c_IOT_stepName_COAP_setLocalAddress_byVars</a></td></tr></table><h4 class=CHeading>Test Steps [LwM2M]</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>set client name</td><td class=CDLDescription><a href="#f_IOT_LGen_step_LwM2M_setClientNameInRegister" class=LFunction id=link59 onMouseOver="ShowTip(event, 'tt29', 'link59')" onMouseOut="HideTip('tt29')">f_IOT_LGen_step_LwM2M_setClientNameInRegister</a>, <a href="#c_IOT_stepName_LwM2M_setClientNameInRegister" class=LConstant id=link60 onMouseOver="ShowTip(event, 'tt7', 'link60')" onMouseOut="HideTip('tt7')">c_IOT_stepName_LwM2M_setClientNameInRegister</a> <a href="#f_IOT_LGen_step_LwM2M_setClientNameInRegister_stringVar" class=LFunction id=link61 onMouseOver="ShowTip(event, 'tt30', 'link61')" onMouseOut="HideTip('tt30')">f_IOT_LGen_step_LwM2M_setClientNameInRegister_stringVar</a>, <a href="#c_IOT_stepName_LwM2M_setClientNameInRegister_stringVar" class=LConstant id=link62 onMouseOver="ShowTip(event, 'tt8', 'link62')" onMouseOut="HideTip('tt8')">c_IOT_stepName_LwM2M_setClientNameInRegister_stringVar</a></td></tr></table><h4 class=CHeading>Test Steps [MQTT]</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>set local address</td><td class=CDLDescription><a href="#f_IOT_LGen_step_MQTT_setLocalAddress_byVars" class=LFunction id=link63 onMouseOver="ShowTip(event, 'tt27', 'link63')" onMouseOut="HideTip('tt27')">f_IOT_LGen_step_MQTT_setLocalAddress_byVars</a>, <a href="#c_IOT_stepName_MQTT_setLocalAddress_byVars" class=LConstant id=link64 onMouseOver="ShowTip(event, 'tt5', 'link64')" onMouseOut="HideTip('tt5')">c_IOT_stepName_MQTT_setLocalAddress_byVars</a> <a href="#f_IOT_LGen_step_MQTT_setClientId_stringParam" class=LFunction id=link65 onMouseOver="ShowTip(event, 'tt28', 'link65')" onMouseOut="HideTip('tt28')">f_IOT_LGen_step_MQTT_setClientId_stringParam</a>, <a href="#c_IOT_stepName_MQTT_setClientId_stringParam" class=LConstant id=link66 onMouseOver="ShowTip(event, 'tt6', 'link66')" onMouseOut="HideTip('tt6')">c_IOT_stepName_MQTT_setClientId_stringParam</a></td></tr></table><h4 class=CHeading>Test Steps [HTTP]</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>init entity context</td><td class=CDLDescription><a href="#f_IOT_LGen_step_HTTP_initEntityContext" class=LFunction id=link67 onMouseOver="ShowTip(event, 'tt31', 'link67')" onMouseOut="HideTip('tt31')">f_IOT_LGen_step_HTTP_initEntityContext</a>, <a href="#c_IOT_stepName_HTTP_initEntityContext" class=LConstant id=link68 onMouseOver="ShowTip(event, 'tt9', 'link68')" onMouseOut="HideTip('tt9')">c_IOT_stepName_HTTP_initEntityContext</a></td></tr><tr><td class=CDLEntry>open connection</td><td class=CDLDescription><a href="#f_IOT_LGen_step_HTTP_openConnection_byVars" class=LFunction id=link69 onMouseOver="ShowTip(event, 'tt32', 'link69')" onMouseOut="HideTip('tt32')">f_IOT_LGen_step_HTTP_openConnection_byVars</a>, <a href="#c_IOT_stepName_HTTP_openConnection_byVars" class=LConstant id=link70 onMouseOver="ShowTip(event, 'tt10', 'link70')" onMouseOut="HideTip('tt10')">c_IOT_stepName_HTTP_openConnection_byVars</a></td></tr><tr><td class=CDLEntry>close connection</td><td class=CDLDescription><a href="#f_IOT_LGen_step_HTTP_closeConnection" class=LFunction id=link71 onMouseOver="ShowTip(event, 'tt33', 'link71')" onMouseOut="HideTip('tt33')">f_IOT_LGen_step_HTTP_closeConnection</a>, <a href="#c_IOT_stepName_HTTP_closeConnection" class=LConstant id=link72 onMouseOver="ShowTip(event, 'tt11', 'link72')" onMouseOut="HideTip('tt11')">c_IOT_stepName_HTTP_closeConnection</a></td></tr><tr><td class=CDLEntry>set HTTP method</td><td class=CDLDescription><a href="#f_IOT_LGen_step_HTTP_setMethod_stringParam" class=LFunction id=link73 onMouseOver="ShowTip(event, 'tt37', 'link73')" onMouseOut="HideTip('tt37')">f_IOT_LGen_step_HTTP_setMethod_stringParam</a>, <a href="#c_IOT_stepName_HTTP_setMethod_stringParam" class=LConstant id=link74 onMouseOver="ShowTip(event, 'tt12', 'link74')" onMouseOut="HideTip('tt12')">c_IOT_stepName_HTTP_setMethod_stringParam</a></td></tr><tr><td class=CDLEntry>set HTTP URI</td><td class=CDLDescription><a href="#f_IOT_LGen_step_HTTP_setUri_stringParam" class=LFunction id=link75 onMouseOver="ShowTip(event, 'tt34', 'link75')" onMouseOut="HideTip('tt34')">f_IOT_LGen_step_HTTP_setUri_stringParam</a>, <a href="#c_IOT_stepName_HTTP_addToUri_stringParam" class=LConstant id=link76 onMouseOver="ShowTip(event, 'tt14', 'link76')" onMouseOut="HideTip('tt14')">c_IOT_stepName_HTTP_addToUri_stringParam</a> <a href="#f_IOT_LGen_step_HTTP_addToUri_byVars" class=LFunction id=link77 onMouseOver="ShowTip(event, 'tt36', 'link77')" onMouseOut="HideTip('tt36')">f_IOT_LGen_step_HTTP_addToUri_byVars</a>, <a href="#c_IOT_stepName_HTTP_addToUri_byVars" class=LConstant id=link78 onMouseOver="ShowTip(event, 'tt15', 'link78')" onMouseOut="HideTip('tt15')">c_IOT_stepName_HTTP_addToUri_byVars</a></td></tr><tr><td class=CDLEntry>add HTTP Host header</td><td class=CDLDescription><a href="#f_IOT_LGen_step_HTTP_addHostHeader_byVars" class=LFunction id=link79 onMouseOver="ShowTip(event, 'tt38', 'link79')" onMouseOut="HideTip('tt38')">f_IOT_LGen_step_HTTP_addHostHeader_byVars</a>, <a href="#c_IOT_stepName_HTTP_addHostHeader_byVars" class=LConstant id=link80 onMouseOver="ShowTip(event, 'tt16', 'link80')" onMouseOut="HideTip('tt16')">c_IOT_stepName_HTTP_addHostHeader_byVars</a></td></tr></table><h4 class=CHeading>Test Steps [Leshan]</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>get client name</td><td class=CDLDescription><a href="#f_IOT_LGen_step_Leshan_getClientFromResponse_intoVar" class=LFunction id=link81 onMouseOver="ShowTip(event, 'tt39', 'link81')" onMouseOut="HideTip('tt39')">f_IOT_LGen_step_Leshan_getClientFromResponse_intoVar</a>, <a href="#c_IOT_stepName_Leshan_getClientFromResponse_intoVar" class=LConstant id=link82 onMouseOver="ShowTip(event, 'tt17', 'link82')" onMouseOut="HideTip('tt17')">c_IOT_stepName_Leshan_getClientFromResponse_intoVar</a></td></tr></table><h4 class=CHeading>Test Steps [RegDereg FSM]</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>init resource values</td><td class=CDLDescription><a href="#f_IOT_LGen_step_FSM_RegDereg_initResourceValues" class=LFunction id=link83 onMouseOver="ShowTip(event, 'tt42', 'link83')" onMouseOut="HideTip('tt42')">f_IOT_LGen_step_FSM_RegDereg_initResourceValues</a>, <a href="#c_IOT_stepName_FSM_RegDereg_initResourceValues" class=LConstant id=link84 onMouseOver="ShowTip(event, 'tt18', 'link84')" onMouseOut="HideTip('tt18')">c_IOT_stepName_FSM_RegDereg_initResourceValues</a></td></tr></table><h4 class=CHeading>Test Steps [SimDev FSM]</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>create resources</td><td class=CDLDescription><a href="#f_IOT_LGen_step_FSM_SimDevice_createResources" class=LFunction id=link85 onMouseOver="ShowTip(event, 'tt43', 'link85')" onMouseOut="HideTip('tt43')">f_IOT_LGen_step_FSM_SimDevice_createResources</a>, <a href="#c_IOT_stepName_FSM_SimDevice_createResources" class=LConstant id=link86 onMouseOver="ShowTip(event, 'tt19', 'link86')" onMouseOut="HideTip('tt19')">c_IOT_stepName_FSM_SimDevice_createResources</a></td></tr><tr><td class=CDLEntry>init resource values</td><td class=CDLDescription><a href="#f_IOT_LGen_step_FSM_SimDevice_initResourceValues" class=LFunction id=link87 onMouseOver="ShowTip(event, 'tt45', 'link87')" onMouseOut="HideTip('tt45')">f_IOT_LGen_step_FSM_SimDevice_initResourceValues</a>, <a href="#c_IOT_stepName_FSM_SimDevice_initResourceValues" class=LConstant id=link88 onMouseOver="ShowTip(event, 'tt20', 'link88')" onMouseOut="HideTip('tt20')">c_IOT_stepName_FSM_SimDevice_initResourceValues</a></td></tr><tr><td class=CDLEntry>init transport</td><td class=CDLDescription><a href="#f_IOT_LGen_step_FSM_SimDevice_initTransport_boolVar" class=LFunction id=link89 onMouseOver="ShowTip(event, 'tt44', 'link89')" onMouseOut="HideTip('tt44')">f_IOT_LGen_step_FSM_SimDevice_initTransport_boolVar</a>, <a href="#c_IOT_stepName_FSM_SimDevice_initTransport_boolVar" class=LConstant id=link90 onMouseOver="ShowTip(event, 'tt21', 'link90')" onMouseOut="HideTip('tt21')">c_IOT_stepName_FSM_SimDevice_initTransport_boolVar</a></td></tr><tr><td class=CDLEntry>update resource values</td><td class=CDLDescription><a href="#f_IOT_LGen_step_FSM_SimDevice_updateResourceValues" class=LFunction id=link91 onMouseOver="ShowTip(event, 'tt46', 'link91')" onMouseOut="HideTip('tt46')">f_IOT_LGen_step_FSM_SimDevice_updateResourceValues</a>, <a href="#c_IOT_stepName_FSM_SimDevice_updateResourceValues" class=LConstant id=link92 onMouseOver="ShowTip(event, 'tt22', 'link92')" onMouseOut="HideTip('tt22')">c_IOT_stepName_FSM_SimDevice_updateResourceValues</a></td></tr><tr><td class=CDLEntry>handle EXECUTE</td><td class=CDLDescription><a href="#f_IOT_LGen_step_FSM_SimDevice_handleExecute" class=LFunction id=link93 onMouseOver="ShowTip(event, 'tt47', 'link93')" onMouseOut="HideTip('tt47')">f_IOT_LGen_step_FSM_SimDevice_handleExecute</a>, <a href="#c_IOT_stepName_FSM_SimDevice_handleExecute" class=LConstant id=link94 onMouseOver="ShowTip(event, 'tt23', 'link94')" onMouseOut="HideTip('tt23')">c_IOT_stepName_FSM_SimDevice_handleExecute</a></td></tr></table><!--START_ND_SUMMARY--><div class=Summary><div class=STitle>Summary</div><div class=SBorder><table border=0 cellspacing=0 cellpadding=0 class=STable><tr class="SMain"><td class=SEntry><a href="#IOT_LGen_Steps" >IOT_LGen_Steps</a></td><td class=SDescription>This module contains test step functions for an IoT load generator component</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_IOT_stepName_tcFinished_withVerdict" id=link1 onMouseOver="ShowTip(event, 'tt1', 'link1')" onMouseOut="HideTip('tt1')">c_IOT_stepName_tcFinished_withVerdict</a></td><td class=SDescription>Charstring constant for the RIoT test case finished test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_IOT_stepName_print_stringParam" id=link2 onMouseOver="ShowTip(event, 'tt2', 'link2')" onMouseOut="HideTip('tt2')">c_IOT_stepName_print_stringParam</a></td><td class=SDescription>Charstring constant for the RIoT print string test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_IOT_stepName_genRndValue_varParams" id=link3 onMouseOver="ShowTip(event, 'tt3', 'link3')" onMouseOut="HideTip('tt3')">c_IOT_stepName_genRndValue_varParams</a></td><td class=SDescription>Charstring constant for the RIoT random number generator test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_IOT_stepName_COAP_setLocalAddress_byVars" id=link4 onMouseOver="ShowTip(event, 'tt4', 'link4')" onMouseOut="HideTip('tt4')">c_IOT_stepName_COAP_setLocalAddress_byVars</a></td><td class=SDescription>Charstring constant for setting the COAP local address test step</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_IOT_stepName_MQTT_setLocalAddress_byVars" id=link5 onMouseOver="ShowTip(event, 'tt5', 'link5')" onMouseOut="HideTip('tt5')">c_IOT_stepName_MQTT_setLocalAddress_byVars</a></td><td class=SDescription>Charstring constant for setting the MQTT local address test step</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_IOT_stepName_MQTT_setClientId_stringParam" id=link6 onMouseOver="ShowTip(event, 'tt6', 'link6')" onMouseOut="HideTip('tt6')">c_IOT_stepName_MQTT_setClientId_stringParam</a></td><td class=SDescription>Charstring constant for the test step that sets the MQTT client id</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_IOT_stepName_LwM2M_setClientNameInRegister" id=link7 onMouseOver="ShowTip(event, 'tt7', 'link7')" onMouseOut="HideTip('tt7')">c_IOT_stepName_LwM2M_setClientNameInRegister</a></td><td class=SDescription>Charstring constant for the test step that sets the LwM2M endpoint name in the Register message</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_IOT_stepName_LwM2M_setClientNameInRegister_stringVar" id=link8 onMouseOver="ShowTip(event, 'tt8', 'link8')" onMouseOut="HideTip('tt8')">c_IOT_stepName_LwM2M_setClientNameInRegister_stringVar</a></td><td class=SDescription>Charstring constant for the test step that sets the LwM2M endpoint name in the Register message</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_IOT_stepName_HTTP_initEntityContext" id=link9 onMouseOver="ShowTip(event, 'tt9', 'link9')" onMouseOut="HideTip('tt9')">c_IOT_stepName_HTTP_initEntityContext</a></td><td class=SDescription>Charstring constant for the test step that initializes the HTTP entity context</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_IOT_stepName_HTTP_openConnection_byVars" id=link10 onMouseOver="ShowTip(event, 'tt10', 'link10')" onMouseOut="HideTip('tt10')">c_IOT_stepName_HTTP_openConnection_byVars</a></td><td class=SDescription>Charstring constant for the test step that opens an HTTP connection</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_IOT_stepName_HTTP_closeConnection" id=link11 onMouseOver="ShowTip(event, 'tt11', 'link11')" onMouseOut="HideTip('tt11')">c_IOT_stepName_HTTP_closeConnection</a></td><td class=SDescription>Charstring constant for the test step that closes the opened HTTP connection</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_IOT_stepName_HTTP_setMethod_stringParam" id=link12 onMouseOver="ShowTip(event, 'tt12', 'link12')" onMouseOut="HideTip('tt12')">c_IOT_stepName_HTTP_setMethod_stringParam</a></td><td class=SDescription>Charstring constant for the test step that sets the HTTP method for the HTTP message to be sent</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_IOT_stepName_HTTP_setUri_stringParam" id=link13 onMouseOver="ShowTip(event, 'tt13', 'link13')" onMouseOut="HideTip('tt13')">c_IOT_stepName_HTTP_setUri_stringParam</a></td><td class=SDescription>Charstring constant for the test step that sets the HTTP request URI for the HTTP message to be sent</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_IOT_stepName_HTTP_addToUri_stringParam" id=link14 onMouseOver="ShowTip(event, 'tt14', 'link14')" onMouseOut="HideTip('tt14')">c_IOT_stepName_HTTP_addToUri_stringParam</a></td><td class=SDescription>Charstring constant for the test step that concatenates a string to the HTTP request URI for the HTTP message to be sent</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_IOT_stepName_HTTP_addToUri_byVars" id=link15 onMouseOver="ShowTip(event, 'tt15', 'link15')" onMouseOut="HideTip('tt15')">c_IOT_stepName_HTTP_addToUri_byVars</a></td><td class=SDescription>Charstring constant for the test step that concatenates a string to the HTTP request URI for the HTTP message to be sent</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_IOT_stepName_HTTP_addHostHeader_byVars" id=link16 onMouseOver="ShowTip(event, 'tt16', 'link16')" onMouseOut="HideTip('tt16')">c_IOT_stepName_HTTP_addHostHeader_byVars</a></td><td class=SDescription>Charstring constant for the test step that adds a Host header to the HTTP message to be sent</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_IOT_stepName_Leshan_getClientFromResponse_intoVar" id=link17 onMouseOver="ShowTip(event, 'tt17', 'link17')" onMouseOut="HideTip('tt17')">c_IOT_stepName_Leshan_getClientFromResponse_intoVar</a></td><td class=SDescription>Charstring constant for the test step that loads the client name into a variable from an HTTP response</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_IOT_stepName_FSM_RegDereg_initResourceValues" id=link18 onMouseOver="ShowTip(event, 'tt18', 'link18')" onMouseOut="HideTip('tt18')">c_IOT_stepName_FSM_RegDereg_initResourceValues</a></td><td class=SDescription>Charstring constant for the test step that inits the resources of the RegDereg FSM</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_IOT_stepName_FSM_SimDevice_createResources" id=link19 onMouseOver="ShowTip(event, 'tt19', 'link19')" onMouseOut="HideTip('tt19')">c_IOT_stepName_FSM_SimDevice_createResources</a></td><td class=SDescription>Charstring constant for the test step that creates the resources of the SimDevice FSM</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_IOT_stepName_FSM_SimDevice_initResourceValues" id=link20 onMouseOver="ShowTip(event, 'tt20', 'link20')" onMouseOut="HideTip('tt20')">c_IOT_stepName_FSM_SimDevice_initResourceValues</a></td><td class=SDescription>Charstring constant for the test step that inits the resources of the SimDevice FSM</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_IOT_stepName_FSM_SimDevice_initTransport_boolVar" id=link21 onMouseOver="ShowTip(event, 'tt21', 'link21')" onMouseOut="HideTip('tt21')">c_IOT_stepName_FSM_SimDevice_initTransport_boolVar</a></td><td class=SDescription>Charstring constant for the test step that inits the transport (UDP, or DTLS-PSK) for the SimDev FSM&rsquo;s LwM2M protocol</td></tr><tr class="SConstant"><td class=SEntry><a href="#c_IOT_stepName_FSM_SimDevice_updateResourceValues" id=link22 onMouseOver="ShowTip(event, 'tt22', 'link22')" onMouseOut="HideTip('tt22')">c_IOT_stepName_FSM_SimDevice_updateResourceValues</a></td><td class=SDescription>Charstring constant for the test step that updates the resource values of the SimDevice FSM</td></tr><tr class="SConstant SMarked"><td class=SEntry><a href="#c_IOT_stepName_FSM_SimDevice_handleExecute" id=link23 onMouseOver="ShowTip(event, 'tt23', 'link23')" onMouseOut="HideTip('tt23')">c_IOT_stepName_FSM_SimDevice_handleExecute</a></td><td class=SDescription>Charstring constant for the test step that handles LwM2M EXECUTE requests on the SimDevice FSM</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_IOT_LGen_declareSteps" id=link24 onMouseOver="ShowTip(event, 'tt24', 'link24')" onMouseOut="HideTip('tt24')">f_IOT_LGen_declareSteps</a></td><td class=SDescription>Function to declare all the RIoT application related test steps</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_IOT_LGen_getEntityIdxinEntityGroup" id=link25 onMouseOver="ShowTip(event, 'tt25', 'link25')" onMouseOut="HideTip('tt25')">f_IOT_LGen_getEntityIdxinEntityGroup</a></td><td class=SDescription>Calculates the index of the entity inside its entity group</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_IOT_LGen_step_COAP_setLocalAddress_byVars" id=link26 onMouseOver="ShowTip(event, 'tt26', 'link26')" onMouseOut="HideTip('tt26')">f_IOT_LGen_step_COAP_setLocalAddress_byVars</a></td><td class=SDescription>Test step to set the local address in the COAP entity context &lt;COAP_EntityCtx&gt;. </td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_IOT_LGen_step_MQTT_setLocalAddress_byVars" id=link27 onMouseOver="ShowTip(event, 'tt27', 'link27')" onMouseOut="HideTip('tt27')">f_IOT_LGen_step_MQTT_setLocalAddress_byVars</a></td><td class=SDescription>Test step to set the local address in the MQTT entity context. </td></tr><tr class="SFunction"><td class=SEntry><a href="#f_IOT_LGen_step_MQTT_setClientId_stringParam" id=link28 onMouseOver="ShowTip(event, 'tt28', 'link28')" onMouseOut="HideTip('tt28')">f_IOT_LGen_step_MQTT_setClientId_stringParam</a></td><td class=SDescription>Test step to set the client id the MQTT entity context. </td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_IOT_LGen_step_LwM2M_setClientNameInRegister" id=link29 onMouseOver="ShowTip(event, 'tt29', 'link29')" onMouseOut="HideTip('tt29')">f_IOT_LGen_step_LwM2M_setClientNameInRegister</a></td><td class=SDescription>Test step to set the endpoint client name in the LWM2M Register message that must be previously loaded into <b>v_LwM2M_msgToSend</b>. </td></tr><tr class="SFunction"><td class=SEntry><a href="#f_IOT_LGen_step_LwM2M_setClientNameInRegister_stringVar" id=link30 onMouseOver="ShowTip(event, 'tt30', 'link30')" onMouseOut="HideTip('tt30')">f_IOT_LGen_step_LwM2M_setClientNameInRegister_stringVar</a></td><td class=SDescription>Test step to set the endpoint client name in the LWM2M Register message that must be previously loaded into <b>v_LwM2M_msgToSend</b>. </td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_IOT_LGen_step_HTTP_initEntityContext" id=link31 onMouseOver="ShowTip(event, 'tt31', 'link31')" onMouseOut="HideTip('tt31')">f_IOT_LGen_step_HTTP_initEntityContext</a></td><td class=SDescription>Test step to initialize the HTTP entity context by calling &lt;f_EPTF_HTTP_setEntityContext&gt;.</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_IOT_LGen_step_HTTP_openConnection_byVars" id=link32 onMouseOver="ShowTip(event, 'tt32', 'link32')" onMouseOut="HideTip('tt32')">f_IOT_LGen_step_HTTP_openConnection_byVars</a></td><td class=SDescription>Test step to open a TCP connection for HTTP. </td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_IOT_LGen_step_HTTP_closeConnection" id=link33 onMouseOver="ShowTip(event, 'tt33', 'link33')" onMouseOut="HideTip('tt33')">f_IOT_LGen_step_HTTP_closeConnection</a></td><td class=SDescription>Test step to close an already opened TCP connection for HTTP</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_IOT_LGen_step_HTTP_setUri_stringParam" id=link34 onMouseOver="ShowTip(event, 'tt34', 'link34')" onMouseOut="HideTip('tt34')">f_IOT_LGen_step_HTTP_setUri_stringParam</a></td><td class=SDescription></td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_IOT_LGen_step_HTTP_addToUri_stringParam" id=link35 onMouseOver="ShowTip(event, 'tt35', 'link35')" onMouseOut="HideTip('tt35')">f_IOT_LGen_step_HTTP_addToUri_stringParam</a></td><td class=SDescription></td></tr><tr class="SFunction"><td class=SEntry><a href="#f_IOT_LGen_step_HTTP_addToUri_byVars" id=link36 onMouseOver="ShowTip(event, 'tt36', 'link36')" onMouseOut="HideTip('tt36')">f_IOT_LGen_step_HTTP_addToUri_byVars</a></td><td class=SDescription></td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_IOT_LGen_step_HTTP_setMethod_stringParam" id=link37 onMouseOver="ShowTip(event, 'tt37', 'link37')" onMouseOut="HideTip('tt37')">f_IOT_LGen_step_HTTP_setMethod_stringParam</a></td><td class=SDescription></td></tr><tr class="SFunction"><td class=SEntry><a href="#f_IOT_LGen_step_HTTP_addHostHeader_byVars" id=link38 onMouseOver="ShowTip(event, 'tt38', 'link38')" onMouseOut="HideTip('tt38')">f_IOT_LGen_step_HTTP_addHostHeader_byVars</a></td><td class=SDescription>Test step to add a Host header to the HTTP messager to be sent. </td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_IOT_LGen_step_Leshan_getClientFromResponse_intoVar" id=link39 onMouseOver="ShowTip(event, 'tt39', 'link39')" onMouseOut="HideTip('tt39')">f_IOT_LGen_step_Leshan_getClientFromResponse_intoVar</a></td><td class=SDescription>Test step to fetch the client name of an HTTP response sent by Leshan into a variable</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_IOT_LGen_step_tcFinished_withVerdict" id=link40 onMouseOver="ShowTip(event, 'tt40', 'link40')" onMouseOut="HideTip('tt40')">f_IOT_LGen_step_tcFinished_withVerdict</a></td><td class=SDescription>Test step to set the final verdict reported by the FSM using a verdict variable as parameter.</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_IOT_LGen_step_print_stringParam" id=link41 onMouseOver="ShowTip(event, 'tt41', 'link41')" onMouseOut="HideTip('tt41')">f_IOT_LGen_step_print_stringParam</a></td><td class=SDescription>Test step to print a string parameter as a TTCN-3 action() statement</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_IOT_LGen_step_FSM_RegDereg_initResourceValues" id=link42 onMouseOver="ShowTip(event, 'tt42', 'link42')" onMouseOut="HideTip('tt42')">f_IOT_LGen_step_FSM_RegDereg_initResourceValues</a></td><td class=SDescription>Test step to init resources of the RegDereg FSM</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_IOT_LGen_step_FSM_SimDevice_createResources" id=link43 onMouseOver="ShowTip(event, 'tt43', 'link43')" onMouseOut="HideTip('tt43')">f_IOT_LGen_step_FSM_SimDevice_createResources</a></td><td class=SDescription>Test step to create resources of the SimDevice FSM</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_IOT_LGen_step_FSM_SimDevice_initTransport_boolVar" id=link44 onMouseOver="ShowTip(event, 'tt44', 'link44')" onMouseOut="HideTip('tt44')">f_IOT_LGen_step_FSM_SimDevice_initTransport_boolVar</a></td><td class=SDescription>Test step to initialize the COAP transport (either UDP, or DTLS-PSK) of the SimDevice FSM. </td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_IOT_LGen_step_FSM_SimDevice_initResourceValues" id=link45 onMouseOver="ShowTip(event, 'tt45', 'link45')" onMouseOut="HideTip('tt45')">f_IOT_LGen_step_FSM_SimDevice_initResourceValues</a></td><td class=SDescription>Test step to init the resource values of the SimDevice FSM</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_IOT_LGen_step_FSM_SimDevice_updateResourceValues" id=link46 onMouseOver="ShowTip(event, 'tt46', 'link46')" onMouseOut="HideTip('tt46')">f_IOT_LGen_step_FSM_SimDevice_updateResourceValues</a></td><td class=SDescription>Test step to update the resource values of the SimDevice FSM</td></tr><tr class="SFunction SMarked"><td class=SEntry><a href="#f_IOT_LGen_step_FSM_SimDevice_handleExecute" id=link47 onMouseOver="ShowTip(event, 'tt47', 'link47')" onMouseOut="HideTip('tt47')">f_IOT_LGen_step_FSM_SimDevice_handleExecute</a></td><td class=SDescription>Test step to handle incoming LwM2M EXECUTE request in the SimDevice FSM</td></tr><tr class="SFunction"><td class=SEntry><a href="#f_IOT_LGen_step_genRndValue_varParams" id=link48 onMouseOver="ShowTip(event, 'tt48', 'link48')" onMouseOut="HideTip('tt48')">f_IOT_LGen_step_genRndValue_varParams</a></td><td class=SDescription>Test step to generate a random number and load it into an integer variable. </td></tr></table></div></div><!--END_ND_SUMMARY--></div></div></div>

<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_IOT_stepName_tcFinished_withVerdict"></a>c_IOT_stepName_tcFinished_withVerdict</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_tcFinished_withVerdict := &quot;IOT App: tcFinished_withVerdict&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the RIoT test case finished test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="#f_IOT_LGen_step_tcFinished_withVerdict" class=LFunction id=link95 onMouseOver="ShowTip(event, 'tt40', 'link95')" onMouseOut="HideTip('tt40')">f_IOT_LGen_step_tcFinished_withVerdict</a></li></ul></div></div></div>

<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_IOT_stepName_print_stringParam"></a>c_IOT_stepName_print_stringParam</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_print_stringParam := &quot;IOT App: print_stringParam&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the RIoT print string test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="#f_IOT_LGen_step_print_stringParam" class=LFunction id=link96 onMouseOver="ShowTip(event, 'tt41', 'link96')" onMouseOut="HideTip('tt41')">f_IOT_LGen_step_print_stringParam</a></li></ul></div></div></div>

<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_IOT_stepName_genRndValue_varParams"></a>c_IOT_stepName_genRndValue_varParams</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_genRndValue_varParams := &quot;IOT App: genRndValue_varParams&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the RIoT random number generator test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="#f_IOT_LGen_step_genRndValue_varParams" class=LFunction id=link97 onMouseOver="ShowTip(event, 'tt48', 'link97')" onMouseOut="HideTip('tt48')">f_IOT_LGen_step_genRndValue_varParams</a></li></ul></div></div></div>

<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_IOT_stepName_COAP_setLocalAddress_byVars"></a>c_IOT_stepName_COAP_setLocalAddress_byVars</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_COAP_setLocalAddress_byVars := &quot;IOT App COAP: setLocalAddress_byVars&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for setting the COAP local address test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="#f_IOT_LGen_step_COAP_setLocalAddress_byVars" class=LFunction id=link98 onMouseOver="ShowTip(event, 'tt26', 'link98')" onMouseOut="HideTip('tt26')">f_IOT_LGen_step_COAP_setLocalAddress_byVars</a></li></ul></div></div></div>

<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_IOT_stepName_MQTT_setLocalAddress_byVars"></a>c_IOT_stepName_MQTT_setLocalAddress_byVars</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_MQTT_setLocalAddress_byVars := &quot;IOT App MQTT: setLocalAddress_byVars&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for setting the MQTT local address test step</p><h4 class=CHeading>Related Function</h4><ul><li><a href="#f_IOT_LGen_step_MQTT_setLocalAddress_byVars" class=LFunction id=link99 onMouseOver="ShowTip(event, 'tt27', 'link99')" onMouseOut="HideTip('tt27')">f_IOT_LGen_step_MQTT_setLocalAddress_byVars</a></li></ul></div></div></div>

<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_IOT_stepName_MQTT_setClientId_stringParam"></a>c_IOT_stepName_MQTT_setClientId_stringParam</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_MQTT_setClientId_stringParam := &quot;IOT App MQTT: setClientId_stringParam&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the test step that sets the MQTT client id</p><h4 class=CHeading>Related Function</h4><ul><li><a href="#f_IOT_LGen_step_MQTT_setClientId_stringParam" class=LFunction id=link100 onMouseOver="ShowTip(event, 'tt28', 'link100')" onMouseOut="HideTip('tt28')">f_IOT_LGen_step_MQTT_setClientId_stringParam</a></li></ul></div></div></div>

<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_IOT_stepName_LwM2M_setClientNameInRegister"></a>c_IOT_stepName_LwM2M_setClientNameInRegister</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_LwM2M_setClientNameInRegister := &quot;IOT App LwM2M: setClientNameInRegister&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the test step that sets the LwM2M endpoint name in the Register message</p><h4 class=CHeading>Related Function</h4><ul><li><a href="#f_IOT_LGen_step_LwM2M_setClientNameInRegister" class=LFunction id=link101 onMouseOver="ShowTip(event, 'tt29', 'link101')" onMouseOut="HideTip('tt29')">f_IOT_LGen_step_LwM2M_setClientNameInRegister</a></li></ul></div></div></div>

<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_IOT_stepName_LwM2M_setClientNameInRegister_stringVar"></a>c_IOT_stepName_LwM2M_setClientNameInRegister_stringVar</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_LwM2M_setClientNameInRegister_stringVar := &quot;IOT App LwM2M: setClientNameInRegister_stringVar&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the test step that sets the LwM2M endpoint name in the Register message</p><h4 class=CHeading>Related Function</h4><ul><li><a href="#f_IOT_LGen_step_LwM2M_setClientNameInRegister_stringVar" class=LFunction id=link102 onMouseOver="ShowTip(event, 'tt30', 'link102')" onMouseOut="HideTip('tt30')">f_IOT_LGen_step_LwM2M_setClientNameInRegister_stringVar</a></li></ul></div></div></div>

<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_IOT_stepName_HTTP_initEntityContext"></a>c_IOT_stepName_HTTP_initEntityContext</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_HTTP_initEntityContext := &quot;IOT App HTTP: initEntityContext&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the test step that initializes the HTTP entity context</p><h4 class=CHeading>Related Function</h4><ul><li><a href="#f_IOT_LGen_step_HTTP_initEntityContext" class=LFunction id=link103 onMouseOver="ShowTip(event, 'tt31', 'link103')" onMouseOut="HideTip('tt31')">f_IOT_LGen_step_HTTP_initEntityContext</a></li></ul></div></div></div>

<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_IOT_stepName_HTTP_openConnection_byVars"></a>c_IOT_stepName_HTTP_openConnection_byVars</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_HTTP_openConnection_byVars := &quot;IOT App HTTP: openConnection_byVars&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the test step that opens an HTTP connection</p><h4 class=CHeading>Related Function</h4><ul><li><a href="#f_IOT_LGen_step_HTTP_openConnection_byVars" class=LFunction id=link104 onMouseOver="ShowTip(event, 'tt32', 'link104')" onMouseOut="HideTip('tt32')">f_IOT_LGen_step_HTTP_openConnection_byVars</a></li></ul></div></div></div>

<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_IOT_stepName_HTTP_closeConnection"></a>c_IOT_stepName_HTTP_closeConnection</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_HTTP_closeConnection := &quot;IOT App HTTP: closeConnection&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the test step that closes the opened HTTP connection</p><h4 class=CHeading>Related Function</h4><ul><li><a href="#f_IOT_LGen_step_HTTP_closeConnection" class=LFunction id=link105 onMouseOver="ShowTip(event, 'tt33', 'link105')" onMouseOut="HideTip('tt33')">f_IOT_LGen_step_HTTP_closeConnection</a></li></ul></div></div></div>

<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_IOT_stepName_HTTP_setMethod_stringParam"></a>c_IOT_stepName_HTTP_setMethod_stringParam</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_HTTP_setMethod_stringParam := &quot;IOT App HTTP: setMethod_stringParam&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the test step that sets the HTTP method for the HTTP message to be sent</p><h4 class=CHeading>Related Function</h4><ul><li><a href="#f_IOT_LGen_step_HTTP_setMethod_stringParam" class=LFunction id=link106 onMouseOver="ShowTip(event, 'tt37', 'link106')" onMouseOut="HideTip('tt37')">f_IOT_LGen_step_HTTP_setMethod_stringParam</a></li></ul></div></div></div>

<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_IOT_stepName_HTTP_setUri_stringParam"></a>c_IOT_stepName_HTTP_setUri_stringParam</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_HTTP_setUri_stringParam := &quot;IOT App HTTP: setUri_stringParam&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the test step that sets the HTTP request URI for the HTTP message to be sent</p><h4 class=CHeading>Related Function</h4><ul><li><a href="#f_IOT_LGen_step_HTTP_setUri_stringParam" class=LFunction id=link107 onMouseOver="ShowTip(event, 'tt34', 'link107')" onMouseOut="HideTip('tt34')">f_IOT_LGen_step_HTTP_setUri_stringParam</a></li></ul></div></div></div>

<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_IOT_stepName_HTTP_addToUri_stringParam"></a>c_IOT_stepName_HTTP_addToUri_stringParam</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_HTTP_addToUri_stringParam := &quot;IOT App HTTP: addToUri_stringParam&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the test step that concatenates a string to the HTTP request URI for the HTTP message to be sent</p><h4 class=CHeading>Related Function</h4><ul><li><a href="#f_IOT_LGen_step_HTTP_addToUri_stringParam" class=LFunction id=link108 onMouseOver="ShowTip(event, 'tt35', 'link108')" onMouseOut="HideTip('tt35')">f_IOT_LGen_step_HTTP_addToUri_stringParam</a></li></ul></div></div></div>

<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_IOT_stepName_HTTP_addToUri_byVars"></a>c_IOT_stepName_HTTP_addToUri_byVars</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_HTTP_addToUri_byVars := &quot;IOT App HTTP: addToUri_byVars&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the test step that concatenates a string to the HTTP request URI for the HTTP message to be sent</p><h4 class=CHeading>Related Function</h4><ul><li><a href="#f_IOT_LGen_step_HTTP_addToUri_byVars" class=LFunction id=link109 onMouseOver="ShowTip(event, 'tt36', 'link109')" onMouseOut="HideTip('tt36')">f_IOT_LGen_step_HTTP_addToUri_byVars</a></li></ul></div></div></div>

<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_IOT_stepName_HTTP_addHostHeader_byVars"></a>c_IOT_stepName_HTTP_addHostHeader_byVars</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_HTTP_addHostHeader_byVars := &quot;IOT App HTTP: addHostHeader_byVars&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the test step that adds a Host header to the HTTP message to be sent</p><h4 class=CHeading>Related Function</h4><ul><li><a href="#f_IOT_LGen_step_HTTP_addHostHeader_byVars" class=LFunction id=link110 onMouseOver="ShowTip(event, 'tt38', 'link110')" onMouseOut="HideTip('tt38')">f_IOT_LGen_step_HTTP_addHostHeader_byVars</a></li></ul></div></div></div>

<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_IOT_stepName_Leshan_getClientFromResponse_intoVar"></a>c_IOT_stepName_Leshan_getClientFromResponse_intoVar</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_Leshan_getClientFromResponse_intoVar := &quot;IOT App Leshan: getClientFromResponse_intoVar&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the test step that loads the client name into a variable from an HTTP response</p><h4 class=CHeading>Related Function</h4><ul><li><a href="#f_IOT_LGen_step_Leshan_getClientFromResponse_intoVar" class=LFunction id=link111 onMouseOver="ShowTip(event, 'tt39', 'link111')" onMouseOut="HideTip('tt39')">f_IOT_LGen_step_Leshan_getClientFromResponse_intoVar</a></li></ul></div></div></div>

<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_IOT_stepName_FSM_RegDereg_initResourceValues"></a>c_IOT_stepName_FSM_RegDereg_initResourceValues</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_FSM_RegDereg_initResourceValues := &quot;IOT Fsm LWM2M_RegDereg: initResourceValues&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the test step that inits the resources of the RegDereg FSM</p><h4 class=CHeading>Related Function</h4><ul><li><a href="#f_IOT_LGen_step_FSM_RegDereg_initResourceValues" class=LFunction id=link112 onMouseOver="ShowTip(event, 'tt42', 'link112')" onMouseOut="HideTip('tt42')">f_IOT_LGen_step_FSM_RegDereg_initResourceValues</a></li></ul></div></div></div>

<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_IOT_stepName_FSM_SimDevice_createResources"></a>c_IOT_stepName_FSM_SimDevice_createResources</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_FSM_SimDevice_createResources := &quot;IOT Fsm LWM2M_SimDevice: createResources&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the test step that creates the resources of the SimDevice FSM</p><h4 class=CHeading>Related Function</h4><ul><li><a href="#f_IOT_LGen_step_FSM_SimDevice_createResources" class=LFunction id=link113 onMouseOver="ShowTip(event, 'tt43', 'link113')" onMouseOut="HideTip('tt43')">f_IOT_LGen_step_FSM_SimDevice_createResources</a></li></ul></div></div></div>

<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_IOT_stepName_FSM_SimDevice_initResourceValues"></a>c_IOT_stepName_FSM_SimDevice_initResourceValues</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_FSM_SimDevice_initResourceValues := &quot;IOT Fsm LWM2M_SimDevice: initResourceValues&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the test step that inits the resources of the SimDevice FSM</p><h4 class=CHeading>Related Function</h4><ul><li><a href="#f_IOT_LGen_step_FSM_SimDevice_initResourceValues" class=LFunction id=link114 onMouseOver="ShowTip(event, 'tt45', 'link114')" onMouseOut="HideTip('tt45')">f_IOT_LGen_step_FSM_SimDevice_initResourceValues</a></li></ul></div></div></div>

<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_IOT_stepName_FSM_SimDevice_initTransport_boolVar"></a>c_IOT_stepName_FSM_SimDevice_initTransport_boolVar</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_FSM_SimDevice_initTransport_boolVar := &quot;IOT Fsm LWM2M_SimDevice: initTransport_boolVar&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the test step that inits the transport (UDP, or DTLS-PSK) for the SimDev FSM&rsquo;s LwM2M protocol</p><h4 class=CHeading>Related Function</h4><ul><li><a href="#f_IOT_LGen_step_FSM_SimDevice_initTransport_boolVar" class=LFunction id=link115 onMouseOver="ShowTip(event, 'tt44', 'link115')" onMouseOut="HideTip('tt44')">f_IOT_LGen_step_FSM_SimDevice_initTransport_boolVar</a></li></ul></div></div></div>

<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_IOT_stepName_FSM_SimDevice_updateResourceValues"></a>c_IOT_stepName_FSM_SimDevice_updateResourceValues</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_FSM_SimDevice_updateResourceValues := &quot;IOT Fsm LWM2M_SimDevice: updateResourceValues&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the test step that updates the resource values of the SimDevice FSM</p><h4 class=CHeading>Related Function</h4><ul><li><a href="#f_IOT_LGen_step_FSM_SimDevice_updateResourceValues" class=LFunction id=link116 onMouseOver="ShowTip(event, 'tt46', 'link116')" onMouseOut="HideTip('tt46')">f_IOT_LGen_step_FSM_SimDevice_updateResourceValues</a></li></ul></div></div></div>

<div class="CConstant"><div class=CTopic><h3 class=CTitle><a name="c_IOT_stepName_FSM_SimDevice_handleExecute"></a>c_IOT_stepName_FSM_SimDevice_handleExecute</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_FSM_SimDevice_handleExecute := &quot;IOT Fsm LWM2M_SimDevice: handleExecute&quot;</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Charstring constant for the test step that handles LwM2M EXECUTE requests on the SimDevice FSM</p><h4 class=CHeading>Related Function</h4><ul><li><a href="#f_IOT_LGen_step_FSM_SimDevice_handleExecute" class=LFunction id=link117 onMouseOver="ShowTip(event, 'tt47', 'link117')" onMouseOut="HideTip('tt47')">f_IOT_LGen_step_FSM_SimDevice_handleExecute</a></li></ul></div></div></div>

<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_IOT_LGen_declareSteps"></a>f_IOT_LGen_declareSteps</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_IOT_LGen_declareSteps() runs on IOT_LGen_CT</td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Function to declare all the RIoT application related test steps</p><h4 class=CHeading>Related Types</h4><p><a href="IOT_LGen_Definitions-ttcn.html#IOT_LGen_CT" class=LType id=link118 onMouseOver="ShowTip(event, 'tt50', 'link118')" onMouseOut="HideTip('tt50')">IOT_LGen_CT</a></p></div></div></div>

<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_IOT_LGen_getEntityIdxinEntityGroup"></a>f_IOT_LGen_getEntityIdxinEntityGroup</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_getEntityIdxinEntityGroup(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT return integer</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Calculates the index of the entity inside its entity group</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step parameters</td></tr></table></div></div></div>

<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_IOT_LGen_step_COAP_setLocalAddress_byVars"></a>f_IOT_LGen_step_COAP_setLocalAddress_byVars</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_COAP_setLocalAddress_byVars(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test step to set the local address in the COAP entity context &lt;COAP_EntityCtx&gt;.&nbsp; Parameters are required.&nbsp; The function will take the base port number from the parameters and adds the entity&rsquo;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.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr><tr><td class=CDLEntry>contextArgs.varNames[0]</td><td class=CDLDescription><b>charstring variable</b> - local host</td></tr><tr><td class=CDLEntry>contextArgs.varNames[1]</td><td class=CDLDescription><b>integer variable</b> - local port</td></tr><tr><td class=CDLEntry>contextArgs.varNames[2]</td><td class=CDLDescription><b>integer variable</b> - offset [optional]</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="#c_IOT_stepName_COAP_setLocalAddress_byVars" class=LConstant id=link119 onMouseOver="ShowTip(event, 'tt4', 'link119')" onMouseOut="HideTip('tt4')">c_IOT_stepName_COAP_setLocalAddress_byVars</a></li></ul></div></div></div>

<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_IOT_LGen_step_MQTT_setLocalAddress_byVars"></a>f_IOT_LGen_step_MQTT_setLocalAddress_byVars</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_MQTT_setLocalAddress_byVars(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test step to set the local address in the MQTT entity context.&nbsp; Parameters are required.&nbsp; The function will take the base port number from the parameters and adds the entity&rsquo;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.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr><tr><td class=CDLEntry>contextArgs.varNames[0]</td><td class=CDLDescription><b>charstring variable</b> - local host</td></tr><tr><td class=CDLEntry>contextArgs.varNames[1]</td><td class=CDLDescription><b>integer variable</b> - local port</td></tr><tr><td class=CDLEntry>contextArgs.varNames[2]</td><td class=CDLDescription><b>integer variable</b> - offset [optional]</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="#c_IOT_stepName_MQTT_setLocalAddress_byVars" class=LConstant id=link120 onMouseOver="ShowTip(event, 'tt5', 'link120')" onMouseOut="HideTip('tt5')">c_IOT_stepName_MQTT_setLocalAddress_byVars</a></li></ul></div></div></div>

<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_IOT_LGen_step_MQTT_setClientId_stringParam"></a>f_IOT_LGen_step_MQTT_setClientId_stringParam</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_MQTT_setClientId_stringParam(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test step to set the client id the MQTT entity context.&nbsp; Parameters are required.&nbsp; The function will take the entity&rsquo;s offset inside its entity group and concatenate it to the string parameter of the test step</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr><tr><td class=CDLEntry>contextArgs.charstringVal</td><td class=CDLDescription><b>charstring</b> - base client id</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="#c_IOT_stepName_MQTT_setClientId_stringParam" class=LConstant id=link121 onMouseOver="ShowTip(event, 'tt6', 'link121')" onMouseOut="HideTip('tt6')">c_IOT_stepName_MQTT_setClientId_stringParam</a></li></ul></div></div></div>

<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_IOT_LGen_step_LwM2M_setClientNameInRegister"></a>f_IOT_LGen_step_LwM2M_setClientNameInRegister</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_LwM2M_setClientNameInRegister(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test step to set the endpoint client name in the LWM2M Register message that must be previously loaded into <b>v_LwM2M_msgToSend</b>.&nbsp; The test step currently hard codes the base name to &ldquo;eantwuhDev_&rdquo; and concatenates the entity&rsquo;s index inside its entity group</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="#c_IOT_stepName_LwM2M_setClientNameInRegister" class=LConstant id=link122 onMouseOver="ShowTip(event, 'tt7', 'link122')" onMouseOut="HideTip('tt7')">c_IOT_stepName_LwM2M_setClientNameInRegister</a></li></ul><h4 class=CHeading>Related test steps</h4><ul><li>&lt;f_COAP_step_loadTemplate_byStringId&gt;</li></ul></div></div></div>

<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_IOT_LGen_step_LwM2M_setClientNameInRegister_stringVar"></a>f_IOT_LGen_step_LwM2M_setClientNameInRegister_stringVar</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_LwM2M_setClientNameInRegister_stringVar(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test step to set the endpoint client name in the LWM2M Register message that must be previously loaded into <b>v_LwM2M_msgToSend</b>.&nbsp; The test step expects the base name to be passed as a string parameter and concatenates the entity&rsquo;s index inside its entity group</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr><tr><td class=CDLEntry>contextArgs.varNames[0]</td><td class=CDLDescription><b>charstring variable</b> - base name</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="#c_IOT_stepName_LwM2M_setClientNameInRegister_stringVar" class=LConstant id=link123 onMouseOver="ShowTip(event, 'tt8', 'link123')" onMouseOut="HideTip('tt8')">c_IOT_stepName_LwM2M_setClientNameInRegister_stringVar</a></li></ul><h4 class=CHeading>Related test steps</h4><ul><li>&lt;f_COAP_step_loadTemplate_byStringId&gt;</li></ul></div></div></div>

<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_IOT_LGen_step_HTTP_initEntityContext"></a>f_IOT_LGen_step_HTTP_initEntityContext</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_HTTP_initEntityContext(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test step to initialize the HTTP entity context by calling &lt;f_EPTF_HTTP_setEntityContext&gt;.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="#c_IOT_stepName_HTTP_initEntityContext" class=LConstant id=link124 onMouseOver="ShowTip(event, 'tt9', 'link124')" onMouseOut="HideTip('tt9')">c_IOT_stepName_HTTP_initEntityContext</a></li></ul></div></div></div>

<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_IOT_LGen_step_HTTP_openConnection_byVars"></a>f_IOT_LGen_step_HTTP_openConnection_byVars</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_HTTP_openConnection_byVars(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test step to open a TCP connection for HTTP.&nbsp; Requires parameters</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr><tr><td class=CDLEntry>contextArgs.varNames[0]</td><td class=CDLDescription><b>charstring variable</b> - local host</td></tr><tr><td class=CDLEntry>contextArgs.varNames[1]</td><td class=CDLDescription><b>integer variable</b> - local port</td></tr><tr><td class=CDLEntry>contextArgs.varNames[2]</td><td class=CDLDescription><b>charstring variable</b> - remote host</td></tr><tr><td class=CDLEntry>contextArgs.varNames[3]</td><td class=CDLDescription><b>integer variable</b> - remote port</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="#c_IOT_stepName_HTTP_openConnection_byVars" class=LConstant id=link125 onMouseOver="ShowTip(event, 'tt10', 'link125')" onMouseOut="HideTip('tt10')">c_IOT_stepName_HTTP_openConnection_byVars</a></li></ul></div></div></div>

<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_IOT_LGen_step_HTTP_closeConnection"></a>f_IOT_LGen_step_HTTP_closeConnection</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_HTTP_closeConnection(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test step to close an already opened TCP connection for HTTP</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="#c_IOT_stepName_HTTP_closeConnection" class=LConstant id=link126 onMouseOver="ShowTip(event, 'tt11', 'link126')" onMouseOut="HideTip('tt11')">c_IOT_stepName_HTTP_closeConnection</a></li></ul></div></div></div>

<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_IOT_LGen_step_HTTP_setUri_stringParam"></a>f_IOT_LGen_step_HTTP_setUri_stringParam</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_HTTP_setUri_stringParam(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>Test step to set a string</td><td class=CDLDescription>specified as a parameter - to the HTTP request URI of the message to be sent</td></tr></table><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr><tr><td class=CDLEntry>contextArgs.charstringVal</td><td class=CDLDescription><b>charstring</b> - URI to be set</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="#c_IOT_stepName_HTTP_setUri_stringParam" class=LConstant id=link127 onMouseOver="ShowTip(event, 'tt13', 'link127')" onMouseOut="HideTip('tt13')">c_IOT_stepName_HTTP_setUri_stringParam</a></li></ul></div></div></div>

<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_IOT_LGen_step_HTTP_addToUri_stringParam"></a>f_IOT_LGen_step_HTTP_addToUri_stringParam</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_HTTP_addToUri_stringParam(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>Test step to add a string</td><td class=CDLDescription>specified as a parameter - to the HTTP request URI of the message to be sent</td></tr></table><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr><tr><td class=CDLEntry>contextArgs.charstringVal</td><td class=CDLDescription><b>charstring</b> - URI part to be concatenated</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="#c_IOT_stepName_HTTP_addToUri_stringParam" class=LConstant id=link128 onMouseOver="ShowTip(event, 'tt14', 'link128')" onMouseOut="HideTip('tt14')">c_IOT_stepName_HTTP_addToUri_stringParam</a></li></ul></div></div></div>

<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_IOT_LGen_step_HTTP_addToUri_byVars"></a>f_IOT_LGen_step_HTTP_addToUri_byVars</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_HTTP_addToUri_byVars(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>Test step to add a string</td><td class=CDLDescription>specified as variadic parameter - to the HTTP request URI of the message to be sent</td></tr></table><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr><tr><td class=CDLEntry>contextArgs.varNames[*]</td><td class=CDLDescription><b>charstring variable</b> - string to be added</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="#c_IOT_stepName_HTTP_addToUri_stringParam" class=LConstant id=link129 onMouseOver="ShowTip(event, 'tt14', 'link129')" onMouseOut="HideTip('tt14')">c_IOT_stepName_HTTP_addToUri_stringParam</a></li></ul></div></div></div>

<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_IOT_LGen_step_HTTP_setMethod_stringParam"></a>f_IOT_LGen_step_HTTP_setMethod_stringParam</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_HTTP_setMethod_stringParam(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>Test step to set the method</td><td class=CDLDescription>specified as a string parameter - of the HTTP request to be sent</td></tr></table><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr><tr><td class=CDLEntry>contextArgs.charstringVal</td><td class=CDLDescription><b>charstring</b> - method to be set</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="#c_IOT_stepName_HTTP_setMethod_stringParam" class=LConstant id=link130 onMouseOver="ShowTip(event, 'tt12', 'link130')" onMouseOut="HideTip('tt12')">c_IOT_stepName_HTTP_setMethod_stringParam</a></li></ul></div></div></div>

<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_IOT_LGen_step_HTTP_addHostHeader_byVars"></a>f_IOT_LGen_step_HTTP_addHostHeader_byVars</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_HTTP_addHostHeader_byVars(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test step to add a Host header to the HTTP messager to be sent.&nbsp; Requires parameters.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr><tr><td class=CDLEntry>contextArgs.varNames[0]</td><td class=CDLDescription><b>charstring variable</b> - host name</td></tr><tr><td class=CDLEntry>contextArgs.varNames[1]</td><td class=CDLDescription><b>integer variable</b> - port name</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="#c_IOT_stepName_HTTP_addHostHeader_byVars" class=LConstant id=link131 onMouseOver="ShowTip(event, 'tt16', 'link131')" onMouseOut="HideTip('tt16')">c_IOT_stepName_HTTP_addHostHeader_byVars</a></li></ul></div></div></div>

<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_IOT_LGen_step_Leshan_getClientFromResponse_intoVar"></a>f_IOT_LGen_step_Leshan_getClientFromResponse_intoVar</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_Leshan_getClientFromResponse_intoVar(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test step to fetch the client name of an HTTP response sent by Leshan into a variable</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr><tr><td class=CDLEntry>contextArgs.varNames[0]</td><td class=CDLDescription><b>charstring variable</b> - client name will be loaded here</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="#c_IOT_stepName_Leshan_getClientFromResponse_intoVar" class=LConstant id=link132 onMouseOver="ShowTip(event, 'tt17', 'link132')" onMouseOut="HideTip('tt17')">c_IOT_stepName_Leshan_getClientFromResponse_intoVar</a></li></ul></div></div></div>

<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_IOT_LGen_step_tcFinished_withVerdict"></a>f_IOT_LGen_step_tcFinished_withVerdict</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_tcFinished_withVerdict(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test step to set the final verdict reported by the FSM using a verdict variable as parameter.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr><tr><td class=CDLEntry>contextArgs.verdict</td><td class=CDLDescription><b>verdicttype</b> - verdict to be reported</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="#c_IOT_stepName_tcFinished_withVerdict" class=LConstant id=link133 onMouseOver="ShowTip(event, 'tt1', 'link133')" onMouseOut="HideTip('tt1')">c_IOT_stepName_tcFinished_withVerdict</a></li></ul></div></div></div>

<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_IOT_LGen_step_print_stringParam"></a>f_IOT_LGen_step_print_stringParam</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_print_stringParam(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test step to print a string parameter as a TTCN-3 action() statement</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr><tr><td class=CDLEntry>contextArgs.charstringVal</td><td class=CDLDescription><b>charstring</b> - the string to be printed</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="#c_IOT_stepName_print_stringParam" class=LConstant id=link134 onMouseOver="ShowTip(event, 'tt2', 'link134')" onMouseOut="HideTip('tt2')">c_IOT_stepName_print_stringParam</a></li></ul></div></div></div>

<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_IOT_LGen_step_FSM_RegDereg_initResourceValues"></a>f_IOT_LGen_step_FSM_RegDereg_initResourceValues</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_FSM_RegDereg_initResourceValues(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test step to init resources of the RegDereg FSM</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="#c_IOT_stepName_FSM_RegDereg_initResourceValues" class=LConstant id=link135 onMouseOver="ShowTip(event, 'tt18', 'link135')" onMouseOut="HideTip('tt18')">c_IOT_stepName_FSM_RegDereg_initResourceValues</a></li></ul></div></div></div>

<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_IOT_LGen_step_FSM_SimDevice_createResources"></a>f_IOT_LGen_step_FSM_SimDevice_createResources</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_FSM_SimDevice_createResources(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test step to create resources of the SimDevice FSM</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="#c_IOT_stepName_FSM_SimDevice_createResources" class=LConstant id=link136 onMouseOver="ShowTip(event, 'tt19', 'link136')" onMouseOut="HideTip('tt19')">c_IOT_stepName_FSM_SimDevice_createResources</a></li></ul></div></div></div>

<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_IOT_LGen_step_FSM_SimDevice_initTransport_boolVar"></a>f_IOT_LGen_step_FSM_SimDevice_initTransport_boolVar</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_FSM_SimDevice_initTransport_boolVar(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test step to initialize the COAP transport (either UDP, or DTLS-PSK) of the SimDevice FSM.&nbsp; Requires parameter.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr><tr><td class=CDLEntry>contextArgs.varNames[0]</td><td class=CDLDescription><b>boolean variable</b> - will use DTLS-PSK when true, UDP otherwise</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="#c_IOT_stepName_FSM_SimDevice_initTransport_boolVar" class=LConstant id=link137 onMouseOver="ShowTip(event, 'tt21', 'link137')" onMouseOut="HideTip('tt21')">c_IOT_stepName_FSM_SimDevice_initTransport_boolVar</a></li></ul></div></div></div>

<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_IOT_LGen_step_FSM_SimDevice_initResourceValues"></a>f_IOT_LGen_step_FSM_SimDevice_initResourceValues</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_FSM_SimDevice_initResourceValues(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test step to init the resource values of the SimDevice FSM</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="#c_IOT_stepName_FSM_SimDevice_initResourceValues" class=LConstant id=link138 onMouseOver="ShowTip(event, 'tt20', 'link138')" onMouseOut="HideTip('tt20')">c_IOT_stepName_FSM_SimDevice_initResourceValues</a></li></ul></div></div></div>

<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_IOT_LGen_step_FSM_SimDevice_updateResourceValues"></a>f_IOT_LGen_step_FSM_SimDevice_updateResourceValues</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_FSM_SimDevice_updateResourceValues(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test step to update the resource values of the SimDevice FSM</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="#c_IOT_stepName_FSM_SimDevice_updateResourceValues" class=LConstant id=link139 onMouseOver="ShowTip(event, 'tt22', 'link139')" onMouseOut="HideTip('tt22')">c_IOT_stepName_FSM_SimDevice_updateResourceValues</a></li></ul></div></div></div>

<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_IOT_LGen_step_FSM_SimDevice_handleExecute"></a>f_IOT_LGen_step_FSM_SimDevice_handleExecute</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_FSM_SimDevice_handleExecute(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test step to handle incoming LwM2M EXECUTE request in the SimDevice FSM</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li><a href="#c_IOT_stepName_FSM_SimDevice_handleExecute" class=LConstant id=link140 onMouseOver="ShowTip(event, 'tt23', 'link140')" onMouseOut="HideTip('tt23')">c_IOT_stepName_FSM_SimDevice_handleExecute</a></li></ul></div></div></div>

<div class="CFunction"><div class=CTopic><h3 class=CTitle><a name="f_IOT_LGen_step_genRndValue_varParams"></a>f_IOT_LGen_step_genRndValue_varParams</h3><div class=CBody><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_genRndValue_varParams(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote><h4 class=CHeading>Purpose</h4><p>Test step to generate a random number and load it into an integer variable.&nbsp; The generated random number will be between two integers provided as parameters to set the limits for RNG.</p><h4 class=CHeading>Parameters</h4><table border=0 cellspacing=0 cellpadding=0 class=CDescriptionList><tr><td class=CDLEntry>pl_ptr</td><td class=CDLDescription><b>in</b> &lt;EPTF_LGenBase_TestStepArgs&gt; - test step args</td></tr><tr><td class=CDLEntry>contextArgs.varNames[0]</td><td class=CDLDescription><b>in integer variable</b> - min value</td></tr><tr><td class=CDLEntry>contextArgs.varNames[1]</td><td class=CDLDescription><b>in integer variable</b> - max value</td></tr><tr><td class=CDLEntry>contextArgs.varNames[2]</td><td class=CDLDescription><b>out integer variable</b> - generated value</td></tr></table><h4 class=CHeading>Related Constants</h4><ul><li>&lt;c_IOT_stepName_FSM_SimDevice_genRndValue_varParams&gt;</li></ul></div></div></div>

</div><!--Content-->



<!--START_ND_TOOLTIPS-->
<div class=CToolTip id="tt1"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_tcFinished_withVerdict := &quot;IOT App: tcFinished_withVerdict&quot;</td></tr></table></blockquote>Charstring constant for the RIoT test case finished test step</div></div><div class=CToolTip id="tt2"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_print_stringParam := &quot;IOT App: print_stringParam&quot;</td></tr></table></blockquote>Charstring constant for the RIoT print string test step</div></div><div class=CToolTip id="tt3"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_genRndValue_varParams := &quot;IOT App: genRndValue_varParams&quot;</td></tr></table></blockquote>Charstring constant for the RIoT random number generator test step</div></div><div class=CToolTip id="tt4"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_COAP_setLocalAddress_byVars := &quot;IOT App COAP: setLocalAddress_byVars&quot;</td></tr></table></blockquote>Charstring constant for setting the COAP local address test step</div></div><div class=CToolTip id="tt5"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_MQTT_setLocalAddress_byVars := &quot;IOT App MQTT: setLocalAddress_byVars&quot;</td></tr></table></blockquote>Charstring constant for setting the MQTT local address test step</div></div><div class=CToolTip id="tt6"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_MQTT_setClientId_stringParam := &quot;IOT App MQTT: setClientId_stringParam&quot;</td></tr></table></blockquote>Charstring constant for the test step that sets the MQTT client id</div></div><div class=CToolTip id="tt7"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_LwM2M_setClientNameInRegister := &quot;IOT App LwM2M: setClientNameInRegister&quot;</td></tr></table></blockquote>Charstring constant for the test step that sets the LwM2M endpoint name in the Register message</div></div><div class=CToolTip id="tt8"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_LwM2M_setClientNameInRegister_stringVar := &quot;IOT App LwM2M: setClientNameInRegister_stringVar&quot;</td></tr></table></blockquote>Charstring constant for the test step that sets the LwM2M endpoint name in the Register message</div></div><div class=CToolTip id="tt9"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_HTTP_initEntityContext := &quot;IOT App HTTP: initEntityContext&quot;</td></tr></table></blockquote>Charstring constant for the test step that initializes the HTTP entity context</div></div><div class=CToolTip id="tt10"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_HTTP_openConnection_byVars := &quot;IOT App HTTP: openConnection_byVars&quot;</td></tr></table></blockquote>Charstring constant for the test step that opens an HTTP connection</div></div><div class=CToolTip id="tt11"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_HTTP_closeConnection := &quot;IOT App HTTP: closeConnection&quot;</td></tr></table></blockquote>Charstring constant for the test step that closes the opened HTTP connection</div></div><div class=CToolTip id="tt12"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_HTTP_setMethod_stringParam := &quot;IOT App HTTP: setMethod_stringParam&quot;</td></tr></table></blockquote>Charstring constant for the test step that sets the HTTP method for the HTTP message to be sent</div></div><div class=CToolTip id="tt13"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_HTTP_setUri_stringParam := &quot;IOT App HTTP: setUri_stringParam&quot;</td></tr></table></blockquote>Charstring constant for the test step that sets the HTTP request URI for the HTTP message to be sent</div></div><div class=CToolTip id="tt14"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_HTTP_addToUri_stringParam := &quot;IOT App HTTP: addToUri_stringParam&quot;</td></tr></table></blockquote>Charstring constant for the test step that concatenates a string to the HTTP request URI for the HTTP message to be sent</div></div><div class=CToolTip id="tt15"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_HTTP_addToUri_byVars := &quot;IOT App HTTP: addToUri_byVars&quot;</td></tr></table></blockquote>Charstring constant for the test step that concatenates a string to the HTTP request URI for the HTTP message to be sent</div></div><div class=CToolTip id="tt16"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_HTTP_addHostHeader_byVars := &quot;IOT App HTTP: addHostHeader_byVars&quot;</td></tr></table></blockquote>Charstring constant for the test step that adds a Host header to the HTTP message to be sent</div></div><div class=CToolTip id="tt17"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_Leshan_getClientFromResponse_intoVar := &quot;IOT App Leshan: getClientFromResponse_intoVar&quot;</td></tr></table></blockquote>Charstring constant for the test step that loads the client name into a variable from an HTTP response</div></div><div class=CToolTip id="tt18"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_FSM_RegDereg_initResourceValues := &quot;IOT Fsm LWM2M_RegDereg: initResourceValues&quot;</td></tr></table></blockquote>Charstring constant for the test step that inits the resources of the RegDereg FSM</div></div><div class=CToolTip id="tt19"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_FSM_SimDevice_createResources := &quot;IOT Fsm LWM2M_SimDevice: createResources&quot;</td></tr></table></blockquote>Charstring constant for the test step that creates the resources of the SimDevice FSM</div></div><div class=CToolTip id="tt20"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_FSM_SimDevice_initResourceValues := &quot;IOT Fsm LWM2M_SimDevice: initResourceValues&quot;</td></tr></table></blockquote>Charstring constant for the test step that inits the resources of the SimDevice FSM</div></div><div class=CToolTip id="tt21"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_FSM_SimDevice_initTransport_boolVar := &quot;IOT Fsm LWM2M_SimDevice: initTransport_boolVar&quot;</td></tr></table></blockquote>Charstring constant for the test step that inits the transport (UDP, or DTLS-PSK) for the SimDev FSM&rsquo;s LwM2M protocol</div></div><div class=CToolTip id="tt22"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_FSM_SimDevice_updateResourceValues := &quot;IOT Fsm LWM2M_SimDevice: updateResourceValues&quot;</td></tr></table></blockquote>Charstring constant for the test step that updates the resource values of the SimDevice FSM</div></div><div class=CToolTip id="tt23"><div class=CConstant><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">const charstring c_IOT_stepName_FSM_SimDevice_handleExecute := &quot;IOT Fsm LWM2M_SimDevice: handleExecute&quot;</td></tr></table></blockquote>Charstring constant for the test step that handles LwM2M EXECUTE requests on the SimDevice FSM</div></div><div class=CToolTip id="tt24"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">function f_IOT_LGen_declareSteps() runs on IOT_LGen_CT</td></tr></table></blockquote>Function to declare all the RIoT application related test steps</div></div><div class=CToolTip id="tt25"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_getEntityIdxinEntityGroup(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT return integer</td></tr></table></td></tr></table></blockquote>Calculates the index of the entity inside its entity group</div></div><div class=CToolTip id="tt26"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_COAP_setLocalAddress_byVars(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to set the local address in the COAP entity context COAP_EntityCtx. </div></div><div class=CToolTip id="tt27"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_MQTT_setLocalAddress_byVars(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to set the local address in the MQTT entity context. </div></div><div class=CToolTip id="tt28"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_MQTT_setClientId_stringParam(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to set the client id the MQTT entity context. </div></div><div class=CToolTip id="tt29"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_LwM2M_setClientNameInRegister(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to set the endpoint client name in the LWM2M Register message that must be previously loaded into <b>v_LwM2M_msgToSend</b>. </div></div><div class=CToolTip id="tt30"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_LwM2M_setClientNameInRegister_stringVar(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to set the endpoint client name in the LWM2M Register message that must be previously loaded into <b>v_LwM2M_msgToSend</b>. </div></div><div class=CToolTip id="tt31"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_HTTP_initEntityContext(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to initialize the HTTP entity context by calling f_EPTF_HTTP_setEntityContext.</div></div><div class=CToolTip id="tt32"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_HTTP_openConnection_byVars(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to open a TCP connection for HTTP. </div></div><div class=CToolTip id="tt33"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_HTTP_closeConnection(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to close an already opened TCP connection for HTTP</div></div><div class=CToolTip id="tt34"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_HTTP_setUri_stringParam(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote></div></div><div class=CToolTip id="tt35"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_HTTP_addToUri_stringParam(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote></div></div><div class=CToolTip id="tt36"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_HTTP_addToUri_byVars(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote></div></div><div class=CToolTip id="tt37"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_HTTP_setMethod_stringParam(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote></div></div><div class=CToolTip id="tt38"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_HTTP_addHostHeader_byVars(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to add a Host header to the HTTP messager to be sent. </div></div><div class=CToolTip id="tt39"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_Leshan_getClientFromResponse_intoVar(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to fetch the client name of an HTTP response sent by Leshan into a variable</div></div><div class=CToolTip id="tt40"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_tcFinished_withVerdict(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to set the final verdict reported by the FSM using a verdict variable as parameter.</div></div><div class=CToolTip id="tt41"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_print_stringParam(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to print a string parameter as a TTCN-3 action() statement</div></div><div class=CToolTip id="tt42"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_FSM_RegDereg_initResourceValues(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to init resources of the RegDereg FSM</div></div><div class=CToolTip id="tt43"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_FSM_SimDevice_createResources(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to create resources of the SimDevice FSM</div></div><div class=CToolTip id="tt44"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_FSM_SimDevice_initTransport_boolVar(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to initialize the COAP transport (either UDP, or DTLS-PSK) of the SimDevice FSM. </div></div><div class=CToolTip id="tt45"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_FSM_SimDevice_initResourceValues(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to init the resource values of the SimDevice FSM</div></div><div class=CToolTip id="tt46"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_FSM_SimDevice_updateResourceValues(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to update the resource values of the SimDevice FSM</div></div><div class=CToolTip id="tt47"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_FSM_SimDevice_handleExecute(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to handle incoming LwM2M EXECUTE request in the SimDevice FSM</div></div><div class=CToolTip id="tt48"><div class=CFunction><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td><table border=0 cellspacing=0 cellpadding=0><tr><td class="PBeforeParameters  prettyprint "colspan=4>function f_IOT_LGen_step_genRndValue_varParams(</td></tr><tr><td>&nbsp;&nbsp;&nbsp;</td><td class="PTypePrefix  prettyprint " nowrap>in&nbsp;</td><td class="PType  prettyprint " nowrap>EPTF_LGenBase_TestStepArgs&nbsp;</td><td class="PParameter  prettyprint " nowrap width=100%>pl_ptr</td></tr><tr><td class="PAfterParameters  prettyprint "colspan=4>) runs on IOT_LGen_CT</td></tr></table></td></tr></table></blockquote>Test step to generate a random number and load it into an integer variable. </div></div><div class=CToolTip id="tt49"><div class=CFile>This module contains the definitions for an IoT load generator component</div></div><div class=CToolTip id="tt50"><div class=CType><blockquote><table border=0 cellspacing=0 cellpadding=0 class="Prototype"><tr><td class="prettyprint">type component IOT_LGen_CT</td></tr></table></blockquote>IoT load generator component</div></div><!--END_ND_TOOLTIPS-->

<script language=JavaScript><!--
if (browserType) {if (browserVer) {document.write("</div>"); }document.write("</div>");}// --></script></body></html>