| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // Copyright (c) 2000-2020 Ericsson Telecom AB |
| // |
| // All rights reserved. This program and the accompanying materials |
| // are made available under the terms of the Eclipse Public License v2.0 |
| // which accompanies this distribution, and is available at |
| // https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html |
| /////////////////////////////////////////////////////////////////////////////// |
| // File: EPTF_LwM2M_LGen_Functions.ttcn |
| // Description: |
| // Rev: R1A |
| // Prodnr: CNL 113 859 |
| // Updated: 2020-03-04 |
| // Contact: http://ttcn.ericsson.se |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| /////////////////////////////////////////////////////////// |
| // Module: EPTF_LwM2M_LGen_Functions |
| // |
| // Purpose: |
| // This module contains the functions of the LWM2M load generator component |
| // |
| // See also: |
| // <EPTF_LwM2M_LGen_Definitions> |
| /////////////////////////////////////////////////////////////// |
| module EPTF_LwM2M_LGen_Functions |
| { |
| import from EPTF_LwM2M_LGen_Definitions all; |
| import from EPTF_LwM2M_Object_Definitions all; |
| import from EPTF_LwM2M_Object_Functions all; |
| import from EPTF_LwM2M_Object_Decoders all; |
| import from EPTF_LwM2M_Transport_Definitions all; |
| import from LightweightM2M_Types all; |
| |
| import from EPTF_CLL_Base_Functions all; |
| import from EPTF_CLL_Common_Definitions all; |
| import from EPTF_CLL_LGenBase_Definitions all; |
| import from EPTF_CLL_LGenBase_ConfigFunctions all; |
| import from EPTF_CLL_LGenBase_Functions all; |
| import from EPTF_CLL_LGenBase_EventHandlingFunctions all; |
| import from EPTF_CLL_Logging_Definitions all; |
| import from EPTF_CLL_Logging_Functions all; |
| import from EPTF_CLL_FBQ_Functions all; |
| import from EPTF_CLL_HashMapStr2Int_Functions all; |
| import from EPTF_CLL_HashMapOct2Int_Functions all; |
| import from EPTF_CLL_RBTScheduler_Functions all; |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_LGen_init |
| // |
| // Purpose: |
| // The main initialization function for the <EPTF_LwM2M_LGen_CT> component type |
| // |
| // Parameters: |
| // pl_name - *in* *charstring* - the name for the component instance |
| // |
| // Related Type: |
| // <EPTF_LwM2M_LGen_CT> |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_LGen_init(in charstring pl_name) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| if (v_LwM2M_initialized){return;} |
| |
| f_EPTF_LGenBase_init(pl_name, 0, pl_name); |
| f_EPTF_Logging_init_CT(pl_name); |
| f_EPTF_str2int_HashMap_Init(); |
| f_EPTF_oct2int_HashMap_Init(); |
| |
| v_LwM2M_bIdx := f_EPTF_LGenBase_declareBehaviorType( |
| pl_name := c_LwM2M_behaviorType, |
| pl_maxCount := tsp_EPTF_LwM2M_LGen_maxBindableCtx, |
| pl_resetFn := refers(f_LwM2M_eCtxReset), |
| pl_bindFn := null, |
| pl_unbindFn := refers(f_LwM2M_eCtxUnbind), |
| pl_bindWithAbsIdxFn := refers(f_LwM2M_eCtxBind) |
| ); |
| |
| f_EPTF_LwM2M_LGen_initLogging(); |
| |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId,": my behavior idx is ", v_LwM2M_bIdx)); |
| |
| f_LwM2M_ObjectSpecificationDB_init(v_LwM2M_ObjectSpecificationDB, 0); |
| f_EPTF_LwM2M_EntityCtxDB_init(); |
| f_EPTF_LwM2M_DeviceDB_init(); |
| f_EPTF_LwM2M_TemplateDB_init(); |
| |
| f_EPTF_LwM2M_declareSteps(); |
| f_EPTF_LwM2M_declareEvents(); |
| |
| f_LwM2M_ObjectSpecificationDB_fillInOmaSpecs(v_LwM2M_ObjectSpecificationDB); |
| for (var integer i:=0; i<sizeof(tsp_EPTF_LwM2M_LGen_objectSpecifications); i:=i+1) |
| { |
| f_LwM2M_ObjectSpecificationDB_add(v_LwM2M_ObjectSpecificationDB, tsp_EPTF_LwM2M_LGen_objectSpecifications[i]); |
| } |
| |
| f_EPTF_Base_registerCleanup(refers(f_LwM2M_cleanUp)); |
| |
| v_LwM2M_initialized := true; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_LGen_initLogging |
| // |
| // Purpose: |
| // Initializing CLL's logging feature on the <EPTF_LwM2M_LGen_CT> component type |
| // |
| // Related Type: |
| // <EPTF_LwM2M_LGen_CT> |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_LGen_initLogging() |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| f_EPTF_Logging_init_CT("LwM2M_LGen"); |
| v_LwM2M_loggingMaskId := |
| f_EPTF_Logging_registerComponentMasks( |
| "LwM2M_LGen_Logging", |
| {"WARNING", "DEBUG", "DEBUGV", "ERROR"}, |
| EPTF_Logging_CLL |
| ); |
| |
| if(tsp_EPTF_LwM2M_LGen_log_error){ |
| f_EPTF_Logging_enableLocalMask(v_LwM2M_loggingMaskId, c_LwM2M_LGen_Logging_ERROR); |
| } |
| else { |
| f_EPTF_Logging_disableLocalMask(v_LwM2M_loggingMaskId, c_LwM2M_LGen_Logging_ERROR); |
| } |
| |
| if(tsp_EPTF_LwM2M_LGen_log_warning){ |
| f_EPTF_Logging_enableLocalMask(v_LwM2M_loggingMaskId, c_LwM2M_LGen_Logging_WARNING); |
| } |
| else { |
| f_EPTF_Logging_disableLocalMask(v_LwM2M_loggingMaskId, c_LwM2M_LGen_Logging_WARNING); |
| } |
| |
| if(tsp_EPTF_LwM2M_LGen_debug){ |
| f_EPTF_Logging_enableLocalMask(v_LwM2M_loggingMaskId, c_LwM2M_LGen_Logging_DEBUG); |
| } |
| else { |
| f_EPTF_Logging_disableLocalMask(v_LwM2M_loggingMaskId, c_LwM2M_LGen_Logging_DEBUG); |
| } |
| |
| if(tsp_EPTF_LwM2M_LGen_debugVerbose) { |
| f_EPTF_Logging_enableLocalMask(v_LwM2M_loggingMaskId, c_LwM2M_LGen_Logging_DEBUGV); |
| } |
| else { |
| f_EPTF_Logging_disableLocalMask(v_LwM2M_loggingMaskId, c_LwM2M_LGen_Logging_DEBUGV); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_LwM2M_cleanUp |
| // |
| // Purpose: |
| // The main clean up function for the <EPTF_LwM2M_LGen_CT> component type |
| // |
| // Related Type: |
| // <EPTF_LwM2M_LGen_CT> |
| /////////////////////////////////////////////////////////// |
| function f_LwM2M_cleanUp() |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| f_EPTF_LwM2M_EntityCtxDB_cleanUp(); |
| f_EPTF_LwM2M_DeviceDB_cleanUp(); |
| f_LwM2M_ObjectSpecificationDB_cleanUp(v_LwM2M_ObjectSpecificationDB); |
| f_EPTF_LwM2M_TemplateDB_cleanUp(); |
| |
| v_LwM2M_initialized := false; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_LwM2M_eCtxBind |
| // |
| // Purpose: |
| // This function is called by the CLL for each entity instance created on a particular instace of <EPTF_LwM2M_LGen_CT> |
| // The function will allocate and initialize an instance of <LwM2M_EntityCtx> in *v_LwM2M_EntityCtxDB* <LwM2M_EntityCtx_DB> |
| // |
| // Parameters: |
| // pl_eIdx - *in* *integer* - the index of the entity instance on this load generator component instance |
| // |
| // Returns: |
| // <EPTF_IntegerList> - The list will contain the index of the <LwM2M_EntityCtx_DB> instance in the *v_LwM2M_EntityCtxDB* |
| // |
| // Related Type: |
| // <EPTF_LwM2M_LGen_CT> |
| /////////////////////////////////////////////////////////// |
| function f_LwM2M_eCtxBind(in integer pl_eIdx) |
| runs on EPTF_LwM2M_LGen_CT |
| return EPTF_IntegerList |
| { |
| var integer vl_eCtxIdx := f_EPTF_FBQ_getOrCreateFreeSlot(v_LwM2M_EntityCtxDB.queue); |
| f_EPTF_FBQ_moveFromFreeHeadToBusyTail(v_LwM2M_EntityCtxDB.queue); |
| |
| v_LwM2M_EntityCtxDB.data[vl_eCtxIdx] := c_LwM2M_EntityCtx_init; |
| v_LwM2M_EntityCtxDB.data[vl_eCtxIdx].eIdx := pl_eIdx; |
| |
| return {vl_eCtxIdx}; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_LwM2M_eCtxUnbind |
| // |
| // Purpose: |
| // The reverse operation of <f_LwM2M_eCtxBind>. Cleans up resources reserved during <f_LwM2M_eCtxBind>. Called by the CLL. |
| // |
| // Parameters: |
| // pl_eIdx - *in* *integer* - the index of the entity instance on this load generator component instance |
| // |
| // Related Type: |
| // <EPTF_LwM2M_LGen_CT> |
| /////////////////////////////////////////////////////////// |
| function f_LwM2M_eCtxUnbind(in integer pl_eIdx) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| if (not v_LwM2M_initialized) {return;} |
| |
| var integer vl_eCtxIdx:= f_EPTF_LGenBase_getBehaviorCtxItem(pl_eIdx, v_LwM2M_bIdx, 0); |
| |
| f_EPTF_FBQ_moveFromBusyToFreeTail(vl_eCtxIdx, v_LwM2M_EntityCtxDB.queue); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_LwM2M_eCtxReset |
| // |
| // Purpose: |
| // The resources reserved during <f_LwM2M_eCtxBind> are reinitalized (reset). Called by the CLL. |
| // |
| // Parameters: |
| // pl_eIdx - *in* *integer* - the index of the entity instance on this load generator component instance |
| // |
| // Related Type: |
| // <EPTF_LwM2M_LGen_CT> |
| /////////////////////////////////////////////////////////// |
| function f_LwM2M_eCtxReset(in integer pl_eIdx) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| var integer vl_eCtxIdx:= f_EPTF_LGenBase_getBehaviorCtxItem(pl_eIdx, v_LwM2M_bIdx, 0); |
| |
| v_LwM2M_EntityCtxDB.data[vl_eCtxIdx] := c_LwM2M_EntityCtx_init; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_EntityCtxDB_init |
| // |
| // Purpose: |
| // Initializes the *v_LwM2M_EntityCtxDB* <LwM2M_EntityCtx_DB> database |
| // |
| // Related Type: |
| // <LwM2M_EntityCtx_DB> |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_EntityCtxDB_init() |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| f_EPTF_FBQ_initFreeBusyQueue(v_LwM2M_EntityCtxDB.queue); |
| v_LwM2M_EntityCtxDB.data := {}; |
| v_LwM2M_EntityCtxDB.hashRef := f_EPTF_str2int_HashMap_New("EPTF_LwM2M_EnityCtxDB_Hash"); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_EntityCtxDB_cleanUp |
| // |
| // Purpose: |
| // Cleans up the reserved resources of the *v_LwM2M_EntityCtxDB* <LwM2M_EntityCtx_DB> database |
| // |
| // Related Type: |
| // <LwM2M_EntityCtx_DB> |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_EntityCtxDB_cleanUp() |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| f_EPTF_FBQ_initFreeBusyQueue(v_LwM2M_EntityCtxDB.queue); |
| v_LwM2M_EntityCtxDB.data :={} |
| f_EPTF_str2int_HashMap_Delete("EPTF_LwM2M_EnityCtxDB_Hash"); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_DeviceDB_init |
| // |
| // Purpose: |
| // Initializes the *v_LwM2M_DeviceDB* <LwM2M_Device_DB> database |
| // |
| // Related Type: |
| // <LwM2M_Device_DB> |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_DeviceDB_init() |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| f_EPTF_FBQ_initFreeBusyQueue(v_LwM2M_DeviceDB.queue); |
| v_LwM2M_DeviceDB.data := {}; |
| v_LwM2M_DeviceDB.hashRef := f_EPTF_oct2int_HashMap_New("EPTF_LwM2M_DeviceDB_Hash"); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_DeviceDB_add |
| // |
| // Purpose: |
| // Adds a new element to the *v_LwM2M_DeviceDB* <LwM2M_Device_DB> database |
| // |
| // Parameters: |
| // p_device - *in* <LwM2M_Device> - the element to be added |
| // |
| // Returns: |
| // p_idx - *out* *integer* - the index of the added element in the database |
| // |
| // Related Type: |
| // <LwM2M_Device_DB> |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_DeviceDB_add(in LwM2M_Device p_device) |
| runs on EPTF_LwM2M_LGen_CT |
| return integer |
| { |
| var integer v_idx := f_EPTF_FBQ_getOrCreateFreeSlot(v_LwM2M_DeviceDB.queue); |
| f_EPTF_FBQ_moveFromFreeHeadToBusyTail(v_LwM2M_DeviceDB.queue); |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(": "," adding device ", v_idx, " ", p_device)); |
| if (sizeof(p_device.registeredLocation) > 0) { |
| f_EPTF_LwM2M_DeviceDB_setLocationKey(p_device.registeredLocation, v_idx); |
| } |
| v_LwM2M_DeviceDB.data[v_idx] := p_device; |
| |
| return v_idx; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_DeviceDB_remove |
| // |
| // Purpose: |
| // Removes an element from the *v_LwM2M_DeviceDB* <LwM2M_Device_DB> database and frees up its reserved resources |
| // |
| // Parameters: |
| // p_idx - *in* *integer* - the index of the element to be removed |
| // |
| // Related Type: |
| // <LwM2M_Device_DB> |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_DeviceDB_remove(in integer p_idx) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| f_EPTF_LwM2M_Logging_DEBUG(log2str("removing device with idx: ",p_idx," device: ", v_LwM2M_DeviceDB.data[p_idx])); |
| |
| v_LwM2M_DeviceDB.data[p_idx] := c_LwM2M_Device_init; |
| f_EPTF_FBQ_moveFromBusyToFreeTail(p_idx, v_LwM2M_DeviceDB.queue); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_DeviceDB_setLocationKey |
| // |
| // Purpose: |
| // Sets the hashmap key for lookups used by the *v_LwM2M_DeviceDB* <LwM2M_Device_DB> database |
| // |
| // Parameters: |
| // p_location - *in* <Location> - the location (of a <LwM2M_Device>) |
| // p_idx - *in* *integer* - the index of the <LwM2M_Device> in the *v_LwM2M_DeviceDB* database |
| // |
| // Related Type: |
| // <LwM2M_Device_DB> |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_DeviceDB_setLocationKey(in Location p_location, in integer p_idx) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| f_EPTF_oct2int_HashMap_Insert(v_LwM2M_DeviceDB.hashRef, f_EPTF_LwM2M_DeviceDB_locationHash(p_location), p_idx); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_DeviceDB_locationHash |
| // |
| // Purpose: |
| // Hash function for lookups used by the *v_LwM2M_DeviceDB* <LwM2M_Device_DB> database |
| // |
| // Parameters: |
| // p_location - *in* <Location> - the location (of a <LwM2M_Device>) |
| // |
| // Returns: |
| // *charstring* - string hash unique for the <Location> parameter |
| // |
| // Related Type: |
| // <LwM2M_Device_DB> |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_DeviceDB_locationHash(in Location p_location) |
| return octetstring |
| { |
| var octetstring v_loc := ''O; |
| for (var integer i:=0; i<sizeof(p_location); i:=i+1) { |
| v_loc := v_loc & unichar2oct(p_location[i]); |
| } |
| |
| return v_loc; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_DeviceDB_cleanUp |
| // |
| // Purpose: |
| // Cleans up the reserved resources of the *v_LwM2M_DeviceDB* <LwM2M_Device_DB> database |
| // |
| // Related Type: |
| // <LwM2M_Device_DB> |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_DeviceDB_cleanUp() |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| // for each device: clean up object db if initialized |
| for (var integer i:=0; i < f_EPTF_FBQ_getLengthOfQueue(v_LwM2M_DeviceDB.queue); i:=i+1) { |
| if(f_EPTF_FBQ_itemIsBusy(i, v_LwM2M_DeviceDB.queue)) { |
| if (v_LwM2M_DeviceDB.data[i].objects.id >= 0) { |
| f_LwM2M_ObjectDB_cleanUp(v_LwM2M_DeviceDB.data[i].objects); |
| } |
| } |
| } |
| f_EPTF_FBQ_initFreeBusyQueue(v_LwM2M_DeviceDB.queue); |
| v_LwM2M_DeviceDB.data :={} |
| f_EPTF_oct2int_HashMap_Delete("EPTF_LwM2M_DeviceDB_Hash"); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_TemplateDB_init |
| // |
| // Purpose: |
| // Initializes the *v_LwM2M_templateDB* <LwM2M_Template_DB> database by adding the templates given in <tsp_EPTF_LwM2M_LGen_templates> |
| // |
| // Related Type: |
| // <LwM2M_Template_DB> |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_TemplateDB_init() |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| v_LwM2M_templateDB.data := {}; |
| v_LwM2M_templateDB.hashRef := f_EPTF_str2int_HashMap_New("EPTF_LwM2M_templateDB_Hash"); |
| |
| for (var integer i:=0; i<sizeof(tsp_EPTF_LwM2M_LGen_templates); i:=i+1) { |
| f_EPTF_LwM2M_TemplateDB_add(tsp_EPTF_LwM2M_LGen_templates[i]); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_TemplateDB_add |
| // |
| // Purpose: |
| // Adds a new element to the *v_LwM2M_templateDB* <LwM2M_Template_DB> database |
| // |
| // Parameters: |
| // p_template - *in* <LwM2M_Template> - the element to be added |
| // |
| // Returns: |
| // *integer* - the index of the added element in the database |
| // |
| // Related Type: |
| // <LwM2M_Template_DB> |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_TemplateDB_add(in LwM2M_Template p_template) |
| runs on EPTF_LwM2M_LGen_CT |
| return integer |
| { |
| if (f_EPTF_LwM2M_TemplateDB_lookUp(p_template.id)!=-1) |
| { |
| f_EPTF_LwM2M_Logging_WARNING(log2str(%definitionId, " template is already added with id: ", p_template.id)); |
| return -1; |
| } |
| |
| var integer v_idx := sizeof(v_LwM2M_templateDB.data); |
| v_LwM2M_templateDB.data[v_idx] := p_template; |
| f_EPTF_str2int_HashMap_Insert(v_LwM2M_templateDB.hashRef, p_template.id, v_idx); |
| |
| f_EPTF_LwM2M_Logging_VERBOSE(log2str(%definitionId, " template was added with id: ", p_template.id, " at idx: ",v_idx)); |
| |
| return v_idx; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_TemplateDB_lookUp |
| // |
| // Purpose: |
| // Gets the index of an <LwM2M_Template> element in *v_LwM2M_templateDB* <LwM2M_Template_DB> database |
| // |
| // Parameters: |
| // p_id - *in* *charstring* - the id of the <LwM2M_Template> |
| // |
| // Returns: |
| // *integer* - the index of the added element in the database, or -1 if not found |
| // |
| // Related Type: |
| // <LwM2M_Template_DB> |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_TemplateDB_lookUp(in charstring p_id) |
| runs on EPTF_LwM2M_LGen_CT |
| return integer |
| { |
| var integer vl_idx := -1; |
| if (not f_EPTF_str2int_HashMap_Find(v_LwM2M_templateDB.hashRef, p_id, vl_idx)) |
| { |
| vl_idx := -1; |
| } |
| |
| return vl_idx; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_TemplateDB_get |
| // |
| // Purpose: |
| // Retrieves an element from the *v_LwM2M_templateDB* <LwM2M_Template_DB> database |
| // |
| // Parameters: |
| // p_idx - *in* *integer* - the index of the element to be retrieved |
| // |
| // Returns: |
| // p_or - *inout* <LWM2M_PDU> - the retrieved element |
| // |
| // Related Type: |
| // <LwM2M_Template_DB> |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_TemplateDB_get(in integer p_idx, inout LWM2M_PDU p_pdu) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| if (p_idx < sizeof(v_LwM2M_templateDB.data) and p_idx >= 0) |
| { |
| f_EPTF_LwM2M_Logging_VERBOSE(log2str(%definitionId, " template is fetched with idx: ", p_idx)); |
| p_pdu := v_LwM2M_templateDB.data[p_idx].msg; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_TemplateDB_cleanUp |
| // |
| // Purpose: |
| // Cleans up the reserved resources of the *v_LwM2M_templateDB* <LwM2M_Template_DB> database |
| // |
| // Related Type: |
| // <LwM2M_Template_DB> |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_TemplateDB_cleanUp() |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| v_LwM2M_templateDB.data := {}; |
| f_EPTF_str2int_HashMap_Delete("EPTF_LwM2M_templateDB_Hash"); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_Logging_VERBOSE |
| // |
| // Purpose: |
| // Logging functions for the VERBOSE log level |
| // |
| // Parameters: |
| // pl_message - *in* *charstring* - string to be logged |
| // |
| // Related Types: |
| // <EPTF_LwM2M_LGen_CT> |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_Logging_VERBOSE(in @lazy charstring pl_message) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| if (c_EPTF_Common_debugSwitch) { |
| f_EPTF_Logging_debugV2(pl_message, v_LwM2M_loggingMaskId, {c_LwM2M_LGen_Logging_DEBUGV}); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_Logging_DEBUG |
| // |
| // Purpose: |
| // Logging functions for the DEBUG log level |
| // |
| // Parameters: |
| // pl_message - *in* *charstring* - string to be logged |
| // |
| // Related Types: |
| // <EPTF_LwM2M_LGen_CT> |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_Logging_DEBUG(in @lazy charstring pl_message) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| if (c_EPTF_Common_debugSwitch) { |
| f_EPTF_Logging_debugV2(pl_message, v_LwM2M_loggingMaskId, {c_LwM2M_LGen_Logging_DEBUG}); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_Logging_WARNING |
| // |
| // Purpose: |
| // Logging functions for the WARNING log level |
| // |
| // Parameters: |
| // pl_message - *in* *charstring* - string to be logged |
| // |
| // Related Types: |
| // <EPTF_LwM2M_LGen_CT> |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_Logging_WARNING(in @lazy charstring pl_message) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| if (c_EPTF_Common_debugSwitch) { |
| f_EPTF_Logging_debugV2(pl_message, v_LwM2M_loggingMaskId, {c_LwM2M_LGen_Logging_WARNING}); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_Logging_ERROR |
| // |
| // Purpose: |
| // Logging functions for the ERROR log level |
| // |
| // Parameters: |
| // pl_message - *in* *charstring* - string to be logged |
| // |
| // Related Types: |
| // <EPTF_LwM2M_LGen_CT> |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_Logging_ERROR(in @lazy charstring pl_message) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| if (c_EPTF_Common_debugSwitch) { |
| f_EPTF_Logging_debugV2(pl_message, v_LwM2M_loggingMaskId, {c_LwM2M_LGen_Logging_ERROR}); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_LGen_receiveMessage |
| // |
| // Purpose: |
| // The transport layer implementation <EPTF_LwM2M_Transport_Provider_CT> can report received <EPTF_LwM2M_PDU> message |
| // to the load generator layer <EPTF_LwM2M_Transport_User_CT> extended by <EPTF_LwM2M_LGen_CT> using this function. |
| // |
| // Parameters: |
| // pl_message - *in* <EPTF_LwM2M_PDU> - received message |
| // |
| // Related Types: |
| // - <EPTF_LwM2M_LGen_CT> |
| // - <fcb_EPTF_LwM2M_Transport_receiveMessage> |
| // - <EPTF_LwM2M_Transport_Provider_CT> |
| // - <EPTF_LwM2M_Transport_User_CT> |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_LGen_receiveMessage(in EPTF_LwM2M_PDU pl_message) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| f_EPTF_LwM2M_Logging_VERBOSE(log2str(%definitionId, " ", pl_message)); |
| |
| v_LwM2M_msgToProcess := pl_message; |
| |
| f_EPTF_LwM2M_updateMessageStatistics(v_LwM2M_stats.incoming, v_LwM2M_msgToProcess); |
| |
| f_EPTF_LwM2M_stack_fromEnv(v_LwM2M_msgToProcess); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_LGen_receiveEvent |
| // |
| // Purpose: |
| // The transport layer implementation <EPTF_LwM2M_Transport_Provider_CT> can report received <EPTF_LwM2M_Event> events |
| // to the load generator layer <EPTF_LwM2M_Transport_User_CT> extended by <EPTF_LwM2M_LGen_CT> using this function. |
| // |
| // Parameters: |
| // pl_event - *in* <EPTF_LwM2M_Event> - received event |
| // |
| // Related Types: |
| // - <EPTF_LwM2M_LGen_CT> |
| // - <fcb_EPTF_LwM2M_Transport_receiveEvent> |
| // - <EPTF_LwM2M_Transport_Provider_CT> |
| // - <EPTF_LwM2M_Transport_User_CT> |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_LGen_receiveEvent(in EPTF_LwM2M_Event pl_event) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| f_EPTF_LwM2M_Logging_VERBOSE(log2str(%definitionId, " ", pl_event)); |
| |
| v_LwM2M_eventToProcess := pl_event; |
| |
| f_EPTF_LwM2M_setCtx(v_LwM2M_eventToProcess.eIdx, -1, v_LwM2M_ctx); |
| |
| if (ischosen(v_LwM2M_eventToProcess.event.resourceNotObserved)) |
| { |
| if (f_LwM2M_ObjectPath_isResource(v_LwM2M_eventToProcess.event.resourceNotObserved)) |
| { |
| f_LwM2M_ObjectDB_setResourceObserved( |
| v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects, |
| v_LwM2M_eventToProcess.event.resourceNotObserved.objectId, |
| v_LwM2M_eventToProcess.event.resourceNotObserved.objectInstanceId, |
| v_LwM2M_eventToProcess.event.resourceNotObserved.resourceId, |
| false |
| ); |
| |
| f_EPTF_LwM2M_dispatchEvent(c_LwM2M_eventIdx_resourceNotObservedIndication, v_LwM2M_eventToProcess.eIdx, -1, {}); |
| } |
| } |
| else if (ischosen(v_LwM2M_eventToProcess.event.atomicBlock1Finished)) |
| { |
| if ( |
| f_LwM2M_ObjectPath_isResource(v_LwM2M_eventToProcess.event.atomicBlock1Finished.path) and |
| sizeof(v_LwM2M_eventToProcess.event.atomicBlock1Finished.resources) == 1 and |
| v_LwM2M_eventToProcess.event.atomicBlock1Finished.method == WRITE |
| ) |
| { |
| // refresh the smart object value |
| var LwM2M_Resource v_res; |
| var boolean vl_found := false, vl_typeMatched := false; |
| |
| f_EPTF_LwM2M_setCtx(v_LwM2M_eventToProcess.eIdx, -1, v_LwM2M_ctx); |
| |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " Looking up resource")); |
| vl_found := f_LwM2M_ObjectDB_getResource( |
| v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects, |
| v_LwM2M_msgToProcess.pdu.Write.path.objectId, |
| v_LwM2M_msgToProcess.pdu.Write.path.objectInstanceId, |
| v_LwM2M_msgToProcess.pdu.Write.path.resourceId, |
| v_res |
| ); |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " resource found: ", v_res)); |
| |
| if (vl_found) |
| { |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " resource found: true")); |
| // Value type matching |
| if (ischosen(v_res.val.boolValue) and ispresent(v_LwM2M_msgToProcess.pdu.Write.resources[0].val.boolValue)) |
| { v_res.val := v_LwM2M_msgToProcess.pdu.Write.resources[0].val; vl_typeMatched := true; } |
| else if (ischosen(v_res.val.strValue) and ispresent(v_LwM2M_msgToProcess.pdu.Write.resources[0].val.strValue)) |
| { v_res.val := v_LwM2M_msgToProcess.pdu.Write.resources[0].val; vl_typeMatched := true; } |
| else if (ischosen(v_res.val.floatValue) and ispresent(v_LwM2M_msgToProcess.pdu.Write.resources[0].val.floatValue)) |
| { v_res.val := v_LwM2M_msgToProcess.pdu.Write.resources[0].val; vl_typeMatched := true; } |
| else if (ischosen(v_res.val.intValue) and ispresent(v_LwM2M_msgToProcess.pdu.Write.resources[0].val.floatValue)) |
| { v_res.val.intValue := float2int(v_LwM2M_msgToProcess.pdu.Write.resources[0].val.floatValue); vl_typeMatched := true; } |
| else if (ischosen(v_res.val.opaqueValue) and ispresent(v_LwM2M_msgToProcess.pdu.Write.resources[0].val.opaqueValue)) |
| { v_res.val.opaqueValue := v_LwM2M_msgToProcess.pdu.Write.resources[0].val.opaqueValue; vl_typeMatched := true; } |
| if (vl_typeMatched) |
| { |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " type match: true")); |
| f_LwM2M_ObjectDB_setResourceValue( |
| v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects, |
| v_LwM2M_msgToProcess.pdu.Write.path.objectId, |
| v_LwM2M_msgToProcess.pdu.Write.path.objectInstanceId, |
| v_LwM2M_msgToProcess.pdu.Write.path.resourceId, |
| v_res.val |
| ); |
| } |
| } |
| } |
| f_EPTF_LwM2M_dispatchEvent(c_LwM2M_eventIdx_atomicBlock1Finished, v_LwM2M_eventToProcess.eIdx, -1, {}); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_LGen_isBootstrap |
| // |
| // Purpose: |
| // Sets p_isBootstrap true if the device is in bootstrapping state. |
| // |
| // Parameters: |
| // pl_eIdx - *in* integer - device index |
| // p_isBootstrap - *inout* boolean - is the device bootsrapping |
| // |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_LGen_isBootstrap(in integer pl_eIdx, inout boolean p_isBootstrap) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| f_EPTF_LwM2M_Logging_VERBOSE(log2str(%definitionId, " ", pl_eIdx)); |
| |
| f_EPTF_LwM2M_setCtx(pl_eIdx, -1, v_LwM2M_ctx); |
| |
| if (v_LwM2M_ctx.deviceIdx > 0) |
| { |
| if (v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].state == BOOTSTRAPPING) |
| { |
| p_isBootstrap := true; |
| return; |
| } |
| } |
| p_isBootstrap := false; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_declareEvents |
| // |
| // Purpose: |
| // Declares the FSM events to the CLL framework implemented by <EPTF_LwM2M_LGen_CT> |
| // |
| // Related Types: |
| // <EPTF_LwM2M_LGen_CT> |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_declareEvents() |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| var integer vl_dummy; |
| |
| if ( |
| c_LwM2M_eventIdx_Register != f_EPTF_LGenBase_declareFsmEvent(c_LwM2M_behaviorType, c_LwM2M_eventName_Register) or |
| c_LwM2M_eventIdx_Update != f_EPTF_LGenBase_declareFsmEvent(c_LwM2M_behaviorType, c_LwM2M_eventName_Update) or |
| c_LwM2M_eventIdx_Deregister != f_EPTF_LGenBase_declareFsmEvent(c_LwM2M_behaviorType, c_LwM2M_eventName_Deregister) or |
| c_LwM2M_eventIdx_Read != f_EPTF_LGenBase_declareFsmEvent(c_LwM2M_behaviorType, c_LwM2M_eventName_Read) or |
| c_LwM2M_eventIdx_Write != f_EPTF_LGenBase_declareFsmEvent(c_LwM2M_behaviorType, c_LwM2M_eventName_Write) or |
| c_LwM2M_eventIdx_Execute != f_EPTF_LGenBase_declareFsmEvent(c_LwM2M_behaviorType, c_LwM2M_eventName_Execute) or |
| c_LwM2M_eventIdx_Create != f_EPTF_LGenBase_declareFsmEvent(c_LwM2M_behaviorType, c_LwM2M_eventName_Create) or |
| c_LwM2M_eventIdx_Delete != f_EPTF_LGenBase_declareFsmEvent(c_LwM2M_behaviorType, c_LwM2M_eventName_Delete) or |
| c_LwM2M_eventIdx_Observe != f_EPTF_LGenBase_declareFsmEvent(c_LwM2M_behaviorType, c_LwM2M_eventName_Observe) or |
| c_LwM2M_eventIdx_WriteFWUri != f_EPTF_LGenBase_declareFsmEvent(c_LwM2M_behaviorType, c_LwM2M_eventName_WriteFWUri) or |
| c_LwM2M_eventIdx_WriteFWPackage != f_EPTF_LGenBase_declareFsmEvent(c_LwM2M_behaviorType, c_LwM2M_eventName_WriteFWPackage) or |
| c_LwM2M_eventIdx_WriteFWPackage_firstBlock != f_EPTF_LGenBase_declareFsmEvent(c_LwM2M_behaviorType, c_LwM2M_eventName_WriteFWPackage_firstBlock) or |
| c_LwM2M_eventIdx_WriteFWPackage_lastBlock != f_EPTF_LGenBase_declareFsmEvent(c_LwM2M_behaviorType, c_LwM2M_eventName_WriteFWPackage_lastBlock) or |
| c_LwM2M_eventIdx_ExecuteFWUpdate != f_EPTF_LGenBase_declareFsmEvent(c_LwM2M_behaviorType, c_LwM2M_eventName_ExecuteFWUpdate) or |
| c_LwM2M_eventIdx_BS_Delete != f_EPTF_LGenBase_declareFsmEvent(c_LwM2M_behaviorType, c_LwM2M_eventName_BS_Delete) or |
| c_LwM2M_eventIdx_BS_Finish != f_EPTF_LGenBase_declareFsmEvent(c_LwM2M_behaviorType, c_LwM2M_eventName_BS_Finish) or |
| c_LwM2M_eventIdx_BS_Discover != f_EPTF_LGenBase_declareFsmEvent(c_LwM2M_behaviorType, c_LwM2M_eventName_BS_Discover) |
| ){ |
| f_EPTF_LGenBase_log(); |
| log("error"); mtc.stop; |
| } |
| |
| for (var integer i:=17; i<700; i:=i+1) |
| { |
| vl_dummy := f_EPTF_LGenBase_declareFsmEvent(c_LwM2M_behaviorType, "LWM2M rsp: "&int2str(i)); |
| } |
| |
| if ( |
| c_LwM2M_eventIdx_1xx != f_EPTF_LGenBase_declareFsmEvent(c_LwM2M_behaviorType, c_LwM2M_eventName_1xx) or |
| c_LwM2M_eventIdx_2xx != f_EPTF_LGenBase_declareFsmEvent(c_LwM2M_behaviorType, c_LwM2M_eventName_2xx) or |
| c_LwM2M_eventIdx_3xx != f_EPTF_LGenBase_declareFsmEvent(c_LwM2M_behaviorType, c_LwM2M_eventName_3xx) or |
| c_LwM2M_eventIdx_4xx != f_EPTF_LGenBase_declareFsmEvent(c_LwM2M_behaviorType, c_LwM2M_eventName_4xx) or |
| c_LwM2M_eventIdx_5xx != f_EPTF_LGenBase_declareFsmEvent(c_LwM2M_behaviorType, c_LwM2M_eventName_5xx) or |
| c_LwM2M_eventIdx_6xx != f_EPTF_LGenBase_declareFsmEvent(c_LwM2M_behaviorType, c_LwM2M_eventName_6xx) or |
| c_LwM2M_eventIdx_3xxto6xx != f_EPTF_LGenBase_declareFsmEvent(c_LwM2M_behaviorType, c_LwM2M_eventName_3xxto6xx) or |
| c_LwM2M_eventIdx_resourceNotObservedIndication != f_EPTF_LGenBase_declareFsmEvent(c_LwM2M_behaviorType, c_LwM2M_eventName_resourceNotObservedIndication) or |
| c_LwM2M_eventIdx_atomicBlock1Finished != f_EPTF_LGenBase_declareFsmEvent(c_LwM2M_behaviorType, c_LwM2M_eventName_atomicBlock1Finished) |
| ){ |
| f_EPTF_LGenBase_log(); |
| log("error"); mtc.stop |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_declareSteps |
| // |
| // Purpose: |
| // Declares the FSM steps to the CLL framework implemented by <EPTF_LwM2M_LGen_CT> |
| // |
| // Related Types: |
| // <EPTF_LwM2M_LGen_CT> |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_declareSteps() |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| if ( |
| c_LwM2M_stepIdx_loadTemplate_byIntIdx != f_EPTF_LGenBase_declareStep(c_LwM2M_behaviorType,{c_LwM2M_stepName_loadTemplate_byIntIdx, refers(f_LwM2M_step_loadTemplate_byIntIdx)}) or |
| c_LwM2M_stepIdx_send != f_EPTF_LGenBase_declareStep(c_LwM2M_behaviorType,{c_LwM2M_stepName_send, refers(f_LwM2M_step_send)}) or |
| c_LwM2M_stepIdx_createDevice != f_EPTF_LGenBase_declareStep(c_LwM2M_behaviorType,{c_LwM2M_stepName_createDevice, refers(f_LwM2M_step_createDevice)}) or |
| c_LwM2M_stepIdx_cleanupDevice != f_EPTF_LGenBase_declareStep(c_LwM2M_behaviorType,{c_LwM2M_stepName_cleanupDevice, refers(f_LwM2M_step_cleanupDevice)}) or |
| c_LwM2M_stepIdx_logDevice != f_EPTF_LGenBase_declareStep(c_LwM2M_behaviorType,{c_LwM2M_stepName_logDevice, refers(f_LwM2M_step_logDevice)}) or |
| c_LwM2M_stepIdx_createObject != f_EPTF_LGenBase_declareStep(c_LwM2M_behaviorType,{c_LwM2M_stepName_createObject, refers(f_LwM2M_step_createObject)}) or |
| c_LwM2M_stepIdx_createObjectInstance != f_EPTF_LGenBase_declareStep(c_LwM2M_behaviorType,{c_LwM2M_stepName_createObjectInstance, refers(f_LwM2M_step_createObjectInstance)}) or |
| c_LwM2M_stepIdx_handleReadRequest != f_EPTF_LGenBase_declareStep(c_LwM2M_behaviorType,{c_LwM2M_stepName_handleReadRequest, refers(f_LwM2M_step_handleReadRequest)}) or |
| c_LwM2M_stepIdx_handleWriteRequest != f_EPTF_LGenBase_declareStep(c_LwM2M_behaviorType,{c_LwM2M_stepName_handleWriteRequest, refers(f_LwM2M_step_handleWriteRequest)}) or |
| c_LwM2M_stepIdx_handleExecuteRequest != f_EPTF_LGenBase_declareStep(c_LwM2M_behaviorType,{c_LwM2M_stepName_handleExecuteRequest, refers(f_LwM2M_step_handleExecuteRequest)}) or |
| c_LwM2M_stepIdx_loadTemplate_byStringId != f_EPTF_LGenBase_declareStep(c_LwM2M_behaviorType,{c_LwM2M_stepName_loadTemplate_byStringId, refers(f_LwM2M_step_loadTemplate_byStringId)}) or |
| c_LwM2M_stepIdx_sendNotificationForObservedResources != f_EPTF_LGenBase_declareStep(c_LwM2M_behaviorType,{c_LwM2M_stepName_sendNotificationForObservedResources, refers(f_LwM2M_step_sendNotificationForObservedResources)}) or |
| c_LwM2M_stepIdx_setFirmwareUpdateState != f_EPTF_LGenBase_declareStep(c_LwM2M_behaviorType,{c_LwM2M_stepName_setFirmwareUpdateState, refers(f_LwM2M_step_setFirmwareUpdateState)}) or |
| c_LwM2M_stepIdx_setFirmwareUpdateResult != f_EPTF_LGenBase_declareStep(c_LwM2M_behaviorType,{c_LwM2M_stepName_setFirmwareUpdateResult, refers(f_LwM2M_step_setFirmwareUpdateResult)}) or |
| c_LwM2M_stepIdx_setBootstrapState != f_EPTF_LGenBase_declareStep(c_LwM2M_behaviorType,{c_LwM2M_stepName_setBootstrapState, refers(f_LwM2M_step_setBootstrapState)}) or |
| c_LwM2M_stepIdx_setNotRegisteredState != f_EPTF_LGenBase_declareStep(c_LwM2M_behaviorType,{c_LwM2M_stepName_setNotRegisteredState, refers(f_LwM2M_step_setNotRegisteredState)}) or |
| c_LwM2M_stepIdx_setBlock1Handling_stateless != f_EPTF_LGenBase_declareStep(c_LwM2M_behaviorType,{c_LwM2M_stepName_setBlock1Handling_stateless, refers(f_LwM2M_step_setBlock1Handling_stateless)}) or |
| c_LwM2M_stepIdx_setBlock1Handling_atomic != f_EPTF_LGenBase_declareStep(c_LwM2M_behaviorType,{c_LwM2M_stepName_setBlock1Handling_atomic, refers(f_LwM2M_step_setBlock1Handling_atomic)}) or |
| c_LwM2M_stepIdx_setContentFormats != f_EPTF_LGenBase_declareStep(c_LwM2M_behaviorType,{c_LwM2M_stepName_setContentFormats, refers(f_LwM2M_step_setContentFormats)}) |
| //c_LwM2M_stepIdx_writeOrCreateObject_BS != f_EPTF_LGenBase_declareStep(c_LwM2M_behaviorType,{c_LwM2M_stepName_writeOrCreateObject_BS, refers(f_LwM2M_step_writeOrCreateObject_BS)}) |
| ){ |
| f_EPTF_LGenBase_log(); |
| log("EPTF_LwM2M_LGen declaration error"); mtc.stop |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_LwM2M_step_loadTemplate_byIntIdx |
| // |
| // Purpose: |
| // Test step to load a <LwM2M_Template> from <tsp_EPTF_LwM2M_LGen_templates> into *v_LwM2M_msgToSend* |
| // (which can be sent using the send test step). Integer parameter required. |
| // |
| // Parameters: |
| // pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args |
| // pl_ptr.refContext.fRefArgs[0] - *integer* - Index of the template to load into *v_LwM2M_msgToSend* |
| // |
| // Related Constants: |
| // - <c_LwM2M_stepIdx_loadTemplate_byIntIdx> |
| // - <c_LwM2M_stepName_loadTemplate_byIntIdx> |
| // |
| // Related Steps: |
| // <f_LwM2M_step_send> |
| /////////////////////////////////////////////////////////// |
| function f_LwM2M_step_loadTemplate_byIntIdx(in EPTF_LGenBase_TestStepArgs pl_ptr) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId)); |
| |
| var integer vl_templateIdx := -1; |
| f_EPTF_LwM2M_getIntValue(pl_ptr.refContext.fRefArgs, 0, vl_templateIdx); |
| |
| f_EPTF_LwM2M_TemplateDB_get(vl_templateIdx, v_LwM2M_msgToSend.pdu); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_LwM2M_step_loadTemplate_byStringId |
| // |
| // Purpose: |
| // Test step to load a <LwM2M_Template> from <tsp_EPTF_LwM2M_LGen_templates> into *v_LwM2M_msgToSend* |
| // (which can be sent using the send test step). String parameter required. |
| // |
| // Parameters: |
| // pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args |
| // contextArgs.charstringVal - *charstring* - ID the template to load into *v_LwM2M_msgToSend* |
| // |
| // Related Constants: |
| // - <c_LwM2M_stepIdx_loadTemplate_byStringId> |
| // - <c_LwM2M_stepName_loadTemplate_byStringId> |
| // |
| // Related Steps: |
| // <f_LwM2M_step_send> |
| /////////////////////////////////////////////////////////// |
| function f_LwM2M_step_loadTemplate_byStringId(in EPTF_LGenBase_TestStepArgs pl_ptr) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId)); |
| |
| var charstring vl_templateId := f_EPTF_LGenBase_charstringValOfStep(pl_ptr); |
| var integer vl_templateIdx := f_EPTF_LwM2M_TemplateDB_lookUp(vl_templateId); |
| |
| if (vl_templateIdx >= 0) |
| { |
| f_EPTF_LwM2M_TemplateDB_get(vl_templateIdx, v_LwM2M_msgToSend.pdu); |
| } |
| else |
| { |
| f_EPTF_LwM2M_Logging_WARNING(log2str(%definitionId," Couldn't find template with id: ", vl_templateId)); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_LwM2M_step_send |
| // |
| // Purpose: |
| // Test step to send out a LWM2M message from *v_LwM2M_msgToSend*. |
| // The message will be processed by the Applib's LWM2M stack |
| // The step expects that a device was created for the entity |
| // |
| // Parameters: |
| // pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args |
| // |
| // Related Constants: |
| // - <c_LwM2M_stepIdx_send> |
| // - <c_LwM2M_stepName_send> |
| // |
| // Related Steps: |
| // - <f_LwM2M_step_loadTemplate_byIntIdx> |
| // - <f_LwM2M_step_loadTemplate_byStringId> |
| // |
| // Related functions: |
| // <f_EPTF_LwM2M_stack_fromApp> |
| /////////////////////////////////////////////////////////// |
| function f_LwM2M_step_send(in EPTF_LGenBase_TestStepArgs pl_ptr) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId)); |
| |
| f_EPTF_LwM2M_setStepCtx(pl_ptr, v_LwM2M_ctx); |
| |
| v_LwM2M_msgToSend.eIdx := v_LwM2M_ctx.eIdx; |
| v_LwM2M_msgToSend.fsmIdx := v_LwM2M_ctx.fsmIdx; |
| |
| f_EPTF_LwM2M_stack_fromApp(v_LwM2M_msgToSend, v_LwM2M_ctx); |
| |
| f_EPTF_SchedulerComp_refreshSnapshotTime(); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_LwM2M_step_createDevice |
| // |
| // Purpose: |
| // Test Step to dynamically allocate and initialize a simulated <LwM2M_Device> and associate it to the |
| // caller entity's <LwM2M_EntityCtx>. Prerequisite to call any other LWM2M test step. |
| // |
| // Parameters: |
| // pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args |
| // |
| // Related Constants: |
| // - <c_LwM2M_stepIdx_createDevice> |
| // - <c_LwM2M_stepName_createDevice> |
| // |
| // Related Functions: |
| // - <f_LwM2M_step_cleanupDevice> |
| // |
| // Related Types: |
| // - <LwM2M_Device> |
| /////////////////////////////////////////////////////////// |
| function f_LwM2M_step_createDevice(in EPTF_LGenBase_TestStepArgs pl_ptr) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId)); |
| f_EPTF_LwM2M_setStepCtx(pl_ptr, v_LwM2M_ctx); |
| |
| var LwM2M_Device vl_device := c_LwM2M_Device_init; |
| |
| var integer vl_idx := f_EPTF_LwM2M_DeviceDB_add(vl_device); |
| |
| f_LwM2M_ObjectDB_init(v_LwM2M_DeviceDB.data[vl_idx].objects, vl_idx); |
| |
| v_LwM2M_EntityCtxDB.data[v_LwM2M_ctx.eCtxIdx].currentDevice := vl_idx; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_LwM2M_step_cleanupDevice |
| // |
| // Purpose: |
| // Test Step to free up the <LwM2M_EntityCtx> for the caller entity. Frees up all allocated instances that were used by this FSM instance. |
| // |
| // Parameters: |
| // pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args |
| // |
| // Related Functions: |
| // - <f_LwM2M_step_createDevice> |
| // |
| // Related Constants: |
| // - <c_LwM2M_stepIdx_cleanupDevice> |
| // - <c_LwM2M_stepName_cleanupDevice> |
| /////////////////////////////////////////////////////////// |
| function f_LwM2M_step_cleanupDevice(in EPTF_LGenBase_TestStepArgs pl_ptr) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId)); |
| f_EPTF_LwM2M_setStepCtx(pl_ptr, v_LwM2M_ctx); |
| |
| if (v_LwM2M_ctx.deviceIdx >= 0) |
| { |
| f_EPTF_LwM2M_Logging_DEBUG(log2str("cleaning up objectDB id: ", v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects.id)); |
| f_LwM2M_ObjectDB_cleanUp(v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects); |
| f_EPTF_LwM2M_DeviceDB_remove(v_LwM2M_ctx.deviceIdx); |
| v_LwM2M_EntityCtxDB.data[v_LwM2M_ctx.eCtxIdx].currentDevice := -1; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_LwM2M_step_logDevice |
| // |
| // Purpose: |
| // Test Step to log the contents of the <LwM2M_Device> associated to the |
| // caller entity's <LwM2M_EntityCtx> |
| // |
| // Parameters: |
| // pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args |
| // |
| // Related Constants: |
| // - <c_LwM2M_stepIdx_logDevice> |
| // - <c_LwM2M_stepName_logDevice> |
| /////////////////////////////////////////////////////////// |
| function f_LwM2M_step_logDevice(in EPTF_LGenBase_TestStepArgs pl_ptr) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId)); |
| f_EPTF_LwM2M_setStepCtx(pl_ptr, v_LwM2M_ctx); |
| |
| if (v_LwM2M_ctx.deviceIdx >= 0) |
| { |
| if (tsp_EPTF_LwM2M_LGen_debug) { log("device: \n", v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx]); } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_LwM2M_step_setBootstrapState |
| // |
| // Purpose: |
| // Test Step to set the state of the device to BOOTSTRAPPING. Consequently, |
| // the bootstrap related LWM2M decoder functions will be used. |
| // |
| // Parameters: |
| // pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args |
| // |
| // Related Constants: |
| // - <c_LwM2M_stepIdx_setBootstrapState> |
| // - <c_LwM2M_stepName_setBootstrapState> |
| /////////////////////////////////////////////////////////// |
| function f_LwM2M_step_setBootstrapState(in EPTF_LGenBase_TestStepArgs pl_ptr) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId)); |
| f_EPTF_LwM2M_setStepCtx(pl_ptr, v_LwM2M_ctx); |
| |
| if (v_LwM2M_ctx.deviceIdx >= 0) |
| { |
| v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].state := BOOTSTRAPPING; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_LwM2M_step_setBlock1Handling_stateless |
| // |
| // Purpose: |
| // Test Step to set the block1 handling strategy of the device to stateless |
| // |
| // Parameters: |
| // pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args |
| // |
| // Related Constants: |
| // - <c_LwM2M_stepIdx_setBlock1Handling_stateless> |
| // - <c_LwM2M_stepName_setBlock1Handling_stateless> |
| /////////////////////////////////////////////////////////// |
| function f_LwM2M_step_setBlock1Handling_stateless(in EPTF_LGenBase_TestStepArgs pl_ptr) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId)); |
| f_EPTF_LwM2M_setStepCtx(pl_ptr, v_LwM2M_ctx); |
| |
| if (v_LwM2M_ctx.deviceIdx >= 0) |
| { |
| v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].block1Handling := STATELESS; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_LwM2M_step_setBlock1Handling_atomic |
| // |
| // Purpose: |
| // Test Step to set the block1 handling strategy of the device to atomic |
| // |
| // Parameters: |
| // pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args |
| // |
| // Related Constants: |
| // - <c_LwM2M_stepIdx_setBlock1Handling_atomic> |
| // - <c_LwM2M_stepName_setBlock1Handling_atomic> |
| /////////////////////////////////////////////////////////// |
| function f_LwM2M_step_setBlock1Handling_atomic(in EPTF_LGenBase_TestStepArgs pl_ptr) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId)); |
| f_EPTF_LwM2M_setStepCtx(pl_ptr, v_LwM2M_ctx); |
| |
| if (v_LwM2M_ctx.deviceIdx >= 0) |
| { |
| v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].block1Handling := ATOMIC; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_LwM2M_step_setNotRegisteredState |
| // |
| // Purpose: |
| // Test Step to set the state of the device to NOT_REGISTERED. |
| // |
| // Parameters: |
| // pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args |
| // |
| // Related Constants: |
| // - <c_LwM2M_stepIdx_setNotRegisteredState> |
| // - <c_LwM2M_stepName_setNotRegisteredState> |
| /////////////////////////////////////////////////////////// |
| function f_LwM2M_step_setNotRegisteredState(in EPTF_LGenBase_TestStepArgs pl_ptr) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId)); |
| f_EPTF_LwM2M_setStepCtx(pl_ptr, v_LwM2M_ctx); |
| |
| if (v_LwM2M_ctx.deviceIdx >= 0) |
| { |
| v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].state := NOT_REGISTERED; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_LwM2M_step_writeOrCreateObject_BS |
| // |
| // Purpose: |
| // Test Step to handling the bootstrap write messge. |
| // |
| // Parameters: |
| // pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args |
| // |
| // Related Constants: |
| // - <c_LwM2M_stepIdx_writeOrCreateObject_BS> |
| // - <c_LwM2M_stepName_writeOrCreateObject_BS> |
| /////////////////////////////////////////////////////////// |
| function f_LwM2M_step_writeOrCreateObject_BS(in EPTF_LGenBase_TestStepArgs pl_ptr) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId)); |
| f_EPTF_LwM2M_setStepCtx(pl_ptr, v_LwM2M_ctx); |
| |
| if (v_LwM2M_ctx.deviceIdx >= 0) |
| { |
| //f_EPTF_LwM2M_dispatchEvent(c_LwM2M_eventIdx_startHttpGetFirmware, v_LwM2M_msgToProcess.eIdx, v_LwM2M_msgToProcess.fsmIdx, {}) |
| } |
| } |
| |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_LwM2M_step_createObject |
| // |
| // Purpose: |
| // Test Step to create an <LwM2M_Object> instance on the caller entity's associated <LwM2M_Device> |
| // |
| // Parameters: |
| // pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args |
| // |
| // Related Constants: |
| // - <c_LwM2M_stepIdx_createObject> |
| // - <c_LwM2M_stepName_createObject> |
| /////////////////////////////////////////////////////////// |
| function f_LwM2M_step_createObject(in EPTF_LGenBase_TestStepArgs pl_ptr) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId)); |
| f_EPTF_LwM2M_setStepCtx(pl_ptr, v_LwM2M_ctx); |
| |
| if (v_LwM2M_ctx.deviceIdx >= 0) |
| { |
| var integer vl_objectId := -1; |
| if (f_EPTF_LwM2M_getIntValue(pl_ptr.refContext.fRefArgs, 0, vl_objectId) and v_LwM2M_ctx.deviceIdx >= 0) |
| { |
| var integer vl_specIdx := f_LwM2M_ObjectSpecificationDB_lookUp(v_LwM2M_ObjectSpecificationDB, vl_objectId); |
| if (vl_specIdx >= 0) |
| { |
| var integer v_ret := f_LwM2M_ObjectDB_createObject( |
| v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects, |
| v_LwM2M_ObjectSpecificationDB.specs[vl_specIdx] |
| ); |
| if (v_ret < 0) { f_EPTF_LwM2M_Logging_VERBOSE(log2str("couldn't create object for id: ", vl_objectId)); } |
| } |
| else { f_EPTF_LwM2M_Logging_VERBOSE(log2str("specification is not for for id ", vl_objectId)); } |
| } |
| else { f_EPTF_LwM2M_Logging_VERBOSE(log2str("parameter is not set for test step")); } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_LwM2M_step_createObjectInstance |
| // |
| // Purpose: |
| // Test Step to create an <LwM2M_ObjectInstance> instance on the caller entity's associated <LwM2M_Device> |
| // the instance will also created the <LwM2M_Resource> instances according to the object instance's <LwM2M_ObjectSpecification> |
| // |
| // Parameters: |
| // pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args |
| // |
| // Related Constants: |
| // - <c_LwM2M_stepIdx_createObjectInstance> |
| // - <c_LwM2M_stepName_createObjectInstance> |
| /////////////////////////////////////////////////////////// |
| function f_LwM2M_step_createObjectInstance(in EPTF_LGenBase_TestStepArgs pl_ptr) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId)); |
| f_EPTF_LwM2M_setStepCtx(pl_ptr, v_LwM2M_ctx); |
| |
| var integer vl_objectId := -1; |
| if (f_EPTF_LwM2M_getIntValue(pl_ptr.refContext.fRefArgs, 0, vl_objectId) and v_LwM2M_ctx.deviceIdx >= 0) |
| { |
| var boolean vl_addResources := true; |
| var integer vl_secondParam := -1; |
| if (f_EPTF_LwM2M_getIntValue(pl_ptr.refContext.fRefArgs, 1, vl_secondParam) and v_LwM2M_ctx.deviceIdx >= 0) { |
| vl_addResources := vl_secondParam != c_LwM2M_stepParam_createObjectInstance_DoNotAddResources; |
| } |
| var integer v_ret := f_LwM2M_ObjectDB_createObjectInstance( |
| v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects, |
| v_LwM2M_ObjectSpecificationDB, |
| vl_objectId, |
| vl_addResources |
| ); |
| if (v_ret < 0) { f_EPTF_LwM2M_Logging_VERBOSE(log2str("couldn't create object instance for id: ", vl_objectId)); } |
| } |
| else { f_EPTF_LwM2M_Logging_VERBOSE(log2str("parameter is not set for test step")); } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_LwM2M_step_handleReadRequest |
| // |
| // Purpose: |
| // The test step can be called from an FSM to handle a reported LWM2M READ request. |
| // The test step will bind the current request to the caller FSM, look up the <LwM2M_Resource> |
| // addressed in the request and create a response with <Code> 205 and content according to the |
| // resource value. |
| // In case the READ request also includes observation, the <LwM2M_Resource> will be marked as observed |
| // |
| // Parameters: |
| // pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args |
| // |
| // Related Constants: |
| // - <c_LwM2M_stepIdx_handleReadRequest> |
| // - <c_LwM2M_stepName_handleReadRequest> |
| /////////////////////////////////////////////////////////// |
| function f_LwM2M_step_handleReadRequest(in EPTF_LGenBase_TestStepArgs pl_ptr) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId)); |
| f_EPTF_LwM2M_setStepCtx(pl_ptr, v_LwM2M_ctx); |
| |
| if (ischosen(v_LwM2M_msgToProcess.pdu.Read_) and v_LwM2M_ctx.deviceIdx >= 0) |
| { |
| var LwM2M_Resource_List v_resources := {}; |
| var integer vl_contentFormat := -1; |
| var boolean vl_found := false; |
| |
| // Resource |
| if (f_LwM2M_ObjectPath_isResource(v_LwM2M_msgToProcess.pdu.Read_.path)) |
| { |
| var LwM2M_Resource v_res := c_LwM2M_Resource_init; |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " Looking up resource")); |
| vl_found := f_LwM2M_ObjectDB_getResource( |
| v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects, |
| v_LwM2M_msgToProcess.pdu.Read_.path.objectId, |
| v_LwM2M_msgToProcess.pdu.Read_.path.objectInstanceId, |
| v_LwM2M_msgToProcess.pdu.Read_.path.resourceId, |
| v_res |
| ); |
| if (vl_found) |
| { |
| if (f_LwM2M_Resource_checkSpecification(v_res, v_LwM2M_ObjectSpecificationDB, t_LwM2M_ResourceSpecification_Readable)) |
| { |
| v_resources[sizeof(v_resources)] := v_res; |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " resource found: ", v_resources)); |
| |
| if (ispresent(v_LwM2M_msgToProcess.pdu.Read_.observe)) |
| { |
| vl_contentFormat := |
| f_EPTF_LwM2M_getEncodingContentFormat( |
| v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].contentFormats, |
| v_LwM2M_msgToProcess.pdu.Read_.accept, |
| v_resources |
| ); |
| |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " setting resource observed with contentFormat: ", vl_contentFormat)); |
| |
| f_LwM2M_ObjectDB_setResourceObserved( |
| v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects, |
| v_LwM2M_msgToProcess.pdu.Read_.path.objectId, |
| v_LwM2M_msgToProcess.pdu.Read_.path.objectInstanceId, |
| v_LwM2M_msgToProcess.pdu.Read_.path.resourceId, |
| true, |
| vl_contentFormat |
| ); |
| } |
| } |
| else { |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " resource found, but not readable: ", v_LwM2M_msgToProcess.pdu.Read_.path)); |
| } |
| } |
| } |
| |
| // Object instance |
| else if (f_LwM2M_ObjectPath_isObjectInstance(v_LwM2M_msgToProcess.pdu.Read_.path)) |
| { |
| var LwM2M_ObjectInstance v_objInst := c_LwM2M_ObjectInstance_init; |
| vl_found := f_LwM2M_ObjectDB_getObjectInstance( |
| v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects, |
| v_LwM2M_msgToProcess.pdu.Read_.path.objectId, |
| v_LwM2M_msgToProcess.pdu.Read_.path.objectInstanceId, |
| v_objInst |
| ); |
| if (vl_found) |
| { |
| for (var integer i:=0; i<sizeof(v_objInst.resources); i:=i+1) { |
| if (f_LwM2M_Resource_checkSpecification( |
| v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects.resources[v_objInst.resources[i]], |
| v_LwM2M_ObjectSpecificationDB, t_LwM2M_ResourceSpecification_Readable)) |
| { |
| v_resources[sizeof(v_resources)] := v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects.resources[v_objInst.resources[i]]; |
| } |
| } |
| } |
| } |
| |
| // Object |
| else if (f_LwM2M_ObjectPath_isObject(v_LwM2M_msgToProcess.pdu.Read_.path)) |
| { |
| var LwM2M_Object v_obj := c_LwM2M_Object_init; |
| |
| vl_found := f_LwM2M_ObjectDB_getObject( |
| v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects, |
| v_LwM2M_msgToProcess.pdu.Read_.path.objectId, |
| v_obj |
| ); |
| |
| if (vl_found) |
| { |
| for (var integer v_inst:=0; v_inst<sizeof(v_obj.instances); v_inst:=v_inst+1) |
| { |
| for (var integer i:=0; i<sizeof(v_obj.instances[v_inst].resources); i:=i+1) { |
| if (f_LwM2M_Resource_checkSpecification( |
| v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects.resources[v_obj.instances[v_inst].resources[i]], |
| v_LwM2M_ObjectSpecificationDB, t_LwM2M_ResourceSpecification_Readable)) |
| { |
| v_resources[sizeof(v_resources)] := v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects.resources[v_obj.instances[v_inst].resources[i]]; |
| } |
| } |
| } |
| } |
| } |
| |
| v_LwM2M_msgToSend.eIdx := v_LwM2M_ctx.eIdx; |
| v_LwM2M_msgToSend.fsmIdx := v_LwM2M_ctx.fsmIdx; |
| |
| if (vl_found and sizeof(v_resources)>0) |
| { |
| if (vl_contentFormat == -1) |
| { |
| vl_contentFormat := |
| f_EPTF_LwM2M_getEncodingContentFormat( |
| v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].contentFormats, |
| v_LwM2M_msgToProcess.pdu.Read_.accept, |
| v_resources |
| ); |
| } |
| |
| //v_res.objId := -1; v_res.objInstId := -1; v_res.id := -1; |
| v_LwM2M_msgToSend.pdu := c_LWM2M_Response_init; |
| v_LwM2M_msgToSend.pdu.Response.code := 205; |
| v_LwM2M_msgToSend.pdu.Response.contentFormat := vl_contentFormat; |
| v_LwM2M_msgToSend.pdu.Response.resources := v_resources; |
| } |
| else |
| { |
| v_LwM2M_msgToSend.pdu := c_LWM2M_Response_init; |
| v_LwM2M_msgToSend.pdu.Response.code := 404; |
| v_LwM2M_msgToSend.pdu.Response.contentFormat := omit; |
| v_LwM2M_msgToSend.pdu.Response.resources := {}; |
| } |
| |
| f_EPTF_LwM2M_updateMessageStatistics(v_LwM2M_stats.outgoing, v_LwM2M_msgToSend); |
| vf_EPTF_LwM2M_Transport_send.apply(v_LwM2M_msgToSend); |
| } |
| else { f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " not read pdu, or no device available, returning")); } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_LwM2M_step_handleWriteRequest |
| // |
| // Purpose: |
| // The test step can be called from an FSM to handle a reported LWM2M WRITE request. |
| // The test step will bind the current request to the caller FSM, look up the <LwM2M_Resource> |
| // addressed in the request and load the updated value from the request. Finally, it will |
| // create a response with <Code> 204 in case the resource was found (404 otherwise). |
| // |
| // Parameters: |
| // pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args |
| // |
| // Related Constants: |
| // - <c_LwM2M_stepIdx_handleWriteRequest> |
| // - <c_LwM2M_stepName_handleWriteRequest> |
| /////////////////////////////////////////////////////////// |
| function f_LwM2M_step_handleWriteRequest(in EPTF_LGenBase_TestStepArgs pl_ptr) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId)); |
| f_EPTF_LwM2M_setStepCtx(pl_ptr, v_LwM2M_ctx); |
| |
| var boolean vl_found := false; |
| var boolean vl_typeMatched := false; |
| var boolean vl_block1 := ispresent(v_LwM2M_msgToProcess.pdu.Write.block1); |
| |
| if (ischosen(v_LwM2M_msgToProcess.pdu.Write) and v_LwM2M_ctx.deviceIdx >= 0) |
| { |
| var LwM2M_Resource v_res; |
| |
| if (f_LwM2M_ObjectPath_isResource(v_LwM2M_msgToProcess.pdu.Write.path) and |
| (sizeof(v_LwM2M_msgToProcess.pdu.Write.resources) == 1 or vl_block1) |
| ) |
| { |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " Looking up resource")); |
| vl_found := f_LwM2M_ObjectDB_getResource( |
| v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects, |
| v_LwM2M_msgToProcess.pdu.Write.path.objectId, |
| v_LwM2M_msgToProcess.pdu.Write.path.objectInstanceId, |
| v_LwM2M_msgToProcess.pdu.Write.path.resourceId, |
| v_res |
| ); |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " resource found: ", v_res)); |
| |
| if (vl_found) |
| { |
| if (not vl_block1) |
| { |
| // Decoding the incoming value if needed e.g. plain, opaque |
| if (v_LwM2M_msgToProcess.pdu.Write.contentFormat == 0 or v_LwM2M_msgToProcess.pdu.Write.contentFormat == 42) |
| { |
| var LwM2M_ResourceSpecification v_spec; |
| if (f_LwM2M_Resource_getSpecification(v_res, v_LwM2M_ObjectSpecificationDB, v_spec)) |
| { |
| f_LwM2M_Resource_decode(v_LwM2M_msgToProcess.pdu.Write.resources[0], v_spec, v_LwM2M_msgToProcess.pdu.Write.contentFormat); |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " resource decoded: ", v_res.val)); |
| } |
| else { |
| f_EPTF_LwM2M_Logging_WARNING(log2str(%definitionId, " no spec found for: ", v_LwM2M_msgToProcess)) |
| } |
| } |
| |
| if (f_LwM2M_Resource_checkSpecification(v_res, v_LwM2M_ObjectSpecificationDB, t_LwM2M_ResourceSpecification_Writeable)) |
| { |
| // Value type matching |
| if (ischosen(v_res.val.boolValue) and ispresent(v_LwM2M_msgToProcess.pdu.Write.resources[0].val.boolValue)) |
| { v_res.val := v_LwM2M_msgToProcess.pdu.Write.resources[0].val; vl_typeMatched := true; } |
| else if (ischosen(v_res.val.strValue) and ispresent(v_LwM2M_msgToProcess.pdu.Write.resources[0].val.strValue)) |
| { v_res.val := v_LwM2M_msgToProcess.pdu.Write.resources[0].val; vl_typeMatched := true; } |
| else if (ischosen(v_res.val.floatValue) and ispresent(v_LwM2M_msgToProcess.pdu.Write.resources[0].val.floatValue)) |
| { v_res.val := v_LwM2M_msgToProcess.pdu.Write.resources[0].val; vl_typeMatched := true; } |
| else if (ischosen(v_res.val.intValue) and ispresent(v_LwM2M_msgToProcess.pdu.Write.resources[0].val.intValue)) |
| { v_res.val := v_LwM2M_msgToProcess.pdu.Write.resources[0].val; vl_typeMatched := true; } |
| else if (ischosen(v_res.val.opaqueValue) and ispresent(v_LwM2M_msgToProcess.pdu.Write.resources[0].val.opaqueValue)) |
| { v_res.val := v_LwM2M_msgToProcess.pdu.Write.resources[0].val; vl_typeMatched := true; } |
| |
| if (vl_typeMatched) |
| { |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " type match: true")); |
| |
| f_LwM2M_ObjectDB_setResourceValue( |
| v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects, |
| v_LwM2M_msgToProcess.pdu.Write.path.objectId, |
| v_LwM2M_msgToProcess.pdu.Write.path.objectInstanceId, |
| v_LwM2M_msgToProcess.pdu.Write.path.resourceId, |
| v_res.val |
| ); |
| } |
| else { f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " type match: false")); } |
| } |
| else { f_EPTF_LwM2M_Logging_WARNING(log2str(%definitionId, " resource not writeable")); } |
| } |
| else // if block1 Write |
| { |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " block1 arrived")); |
| |
| if (v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].block1Handling == STATELESS) |
| { |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " statless block1 handling: to be done")); |
| } |
| else // atomic block1 handling |
| { |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " atomic block1 handling: will wait for final block")); |
| } |
| } |
| } |
| } |
| |
| v_LwM2M_msgToSend.eIdx := v_LwM2M_ctx.eIdx; |
| v_LwM2M_msgToSend.fsmIdx := v_LwM2M_ctx.fsmIdx; |
| |
| if (vl_found and (vl_typeMatched or vl_block1)) |
| { |
| v_LwM2M_msgToSend.pdu := c_LWM2M_Response_init; |
| v_LwM2M_msgToSend.pdu.Response.code := 204; |
| if (ispresent(v_LwM2M_msgToProcess.pdu.Write.block1) and v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].block1Handling == ATOMIC) |
| { |
| v_LwM2M_msgToSend.pdu.Response.code := 231; |
| } |
| if (v_LwM2M_msgToProcess.pdu.Write.path.objectId == 5) |
| { |
| if (v_LwM2M_msgToProcess.pdu.Write.path.resourceId == 0) { |
| if (not vl_block1) { |
| f_EPTF_LwM2M_dispatchEvent(c_LwM2M_eventIdx_WriteFWPackage, v_LwM2M_msgToProcess.eIdx, -1, {}); |
| } |
| else { // vl_block1 |
| if (v_LwM2M_msgToProcess.pdu.Write.block1.option.num == 0) { |
| f_EPTF_LwM2M_dispatchEvent(c_LwM2M_eventIdx_WriteFWPackage_firstBlock, v_LwM2M_msgToProcess.eIdx, -1, {}); |
| } |
| if (v_LwM2M_msgToProcess.pdu.Write.block1.option.m == false) { |
| f_EPTF_LwM2M_dispatchEvent(c_LwM2M_eventIdx_WriteFWPackage_lastBlock, v_LwM2M_msgToProcess.eIdx, -1, {}); |
| } |
| } |
| } |
| if (v_LwM2M_msgToProcess.pdu.Write.path.resourceId == 1) { f_EPTF_LwM2M_dispatchEvent(c_LwM2M_eventIdx_WriteFWUri, v_LwM2M_msgToProcess.eIdx, -1, { }); } |
| } |
| } |
| else |
| { |
| v_LwM2M_msgToSend.pdu := c_LWM2M_Response_init; |
| v_LwM2M_msgToSend.pdu.Response.code := 404; |
| } |
| f_EPTF_LwM2M_updateMessageStatistics(v_LwM2M_stats.outgoing, v_LwM2M_msgToSend); |
| vf_EPTF_LwM2M_Transport_send.apply(v_LwM2M_msgToSend); |
| } |
| else { f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " not write pdu, or no device available, returning")); } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_LwM2M_step_handleExecuteRequest |
| // |
| // Purpose: |
| // The test step can be called from an FSM to handle a reported LWM2M EXECUTE request. |
| // The test step will bind the current request to the caller FSM, look up the <LwM2M_Resource> |
| // addressed in the request and create a response with <Code> 204 in case the resource |
| // was found (404 otherwise). |
| // |
| // Parameters: |
| // pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args |
| // |
| // Related Constants: |
| // - <c_LwM2M_stepIdx_handleExecuteRequest> |
| // - <c_LwM2M_stepName_handleExecuteRequest> |
| /////////////////////////////////////////////////////////// |
| function f_LwM2M_step_handleExecuteRequest(in EPTF_LGenBase_TestStepArgs pl_ptr) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId)); |
| f_EPTF_LwM2M_setStepCtx(pl_ptr, v_LwM2M_ctx); |
| |
| if (ischosen(v_LwM2M_msgToProcess.pdu.Execute) and v_LwM2M_ctx.deviceIdx >= 0) |
| { |
| var LwM2M_Resource v_res; |
| var boolean vl_found := false; |
| var boolean vl_succExecute := false; |
| if (f_LwM2M_ObjectPath_isResource(v_LwM2M_msgToProcess.pdu.Execute.path)) |
| { |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " Looking up resource")); |
| vl_found := f_LwM2M_ObjectDB_getResource( |
| v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects, |
| v_LwM2M_msgToProcess.pdu.Execute.path.objectId, |
| v_LwM2M_msgToProcess.pdu.Execute.path.objectInstanceId, |
| v_LwM2M_msgToProcess.pdu.Execute.path.resourceId, |
| v_res |
| ); |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " resource found: ", v_res)); |
| |
| if (vl_found) |
| { |
| var LwM2M_ResourceSpecification v_spec; |
| if (f_LwM2M_ObjectSpecificationDB_getResourceSpecification( |
| v_LwM2M_ObjectSpecificationDB, |
| v_LwM2M_msgToProcess.pdu.Execute.path.objectId, |
| v_LwM2M_msgToProcess.pdu.Execute.path.resourceId, |
| v_spec)) |
| { |
| if (f_LwM2M_Resource_checkSpecification(v_res, v_LwM2M_ObjectSpecificationDB, t_LwM2M_ResourceSpecification_Executable)) |
| { |
| //action("executed: ", v_res); |
| |
| v_LwM2M_msgToSend.eIdx := v_LwM2M_ctx.eIdx; |
| v_LwM2M_msgToSend.fsmIdx := v_LwM2M_ctx.fsmIdx; |
| |
| v_LwM2M_msgToSend.pdu := c_LWM2M_Response_init; |
| v_LwM2M_msgToSend.pdu.Response.code := 204; |
| f_EPTF_LwM2M_updateMessageStatistics(v_LwM2M_stats.outgoing, v_LwM2M_msgToSend); |
| vf_EPTF_LwM2M_Transport_send.apply(v_LwM2M_msgToSend); |
| vl_succExecute := true; |
| |
| if (v_LwM2M_msgToProcess.pdu.Execute.path.objectId == 5 and v_LwM2M_msgToProcess.pdu.Execute.path.resourceId == 2) |
| { |
| f_EPTF_LwM2M_dispatchEvent(c_LwM2M_eventIdx_ExecuteFWUpdate, v_LwM2M_msgToProcess.eIdx, v_LwM2M_msgToProcess.fsmIdx, {}); |
| } |
| } |
| else { f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " resource is not executable")); } |
| } |
| else { f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " could not get resource specification")); } |
| } |
| else { f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " could not find resource instance")); } |
| } |
| else { f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " Only resource can be executed, ignoring request")); } |
| |
| if (not vl_succExecute) |
| { |
| v_LwM2M_msgToSend.eIdx := v_LwM2M_ctx.eIdx; |
| v_LwM2M_msgToSend.fsmIdx := v_LwM2M_ctx.fsmIdx; |
| |
| v_LwM2M_msgToSend.pdu := c_LWM2M_Response_init; |
| v_LwM2M_msgToSend.pdu.Response.code := 404; |
| f_EPTF_LwM2M_updateMessageStatistics(v_LwM2M_stats.outgoing, v_LwM2M_msgToSend); |
| vf_EPTF_LwM2M_Transport_send.apply(v_LwM2M_msgToSend); |
| } |
| } |
| else { f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId, " not execute pdu, or no device available, returning")); } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_LwM2M_step_sendNotificationForObservedResources |
| // |
| // Purpose: |
| // The test step will iterate through the observed resources of the caller entity's <LwM2M_Device> |
| // and creates and sends a NOTIFICATION for each. |
| // |
| // Parameters: |
| // pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args |
| // |
| // Related Constants: |
| // - <c_LwM2M_stepIdx_sendNotificationForObservedResources> |
| // - <c_LwM2M_stepName_sendNotificationForObservedResources> |
| /////////////////////////////////////////////////////////// |
| function f_LwM2M_step_sendNotificationForObservedResources(in EPTF_LGenBase_TestStepArgs pl_ptr) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId)); |
| f_EPTF_LwM2M_setStepCtx(pl_ptr, v_LwM2M_ctx); |
| |
| if (v_LwM2M_ctx.deviceIdx >= 0) |
| { |
| // Should be made faster by keeping track of the observed resources in a separate list |
| for (var integer i:=0; i<sizeof(v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects.resources); i:=i+1) |
| { |
| if (v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects.resources[i].observed) |
| { |
| f_EPTF_LwM2M_sendNotificationForResource( |
| pl_ptr, |
| v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects.resources[i] |
| ); |
| } |
| } |
| } |
| else { f_EPTF_LwM2M_Logging_VERBOSE(log2str("device is not initialized")); } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_LwM2M_step_setFirmwareUpdateState |
| // |
| // Purpose: |
| // The test step will set the firmware update state resource value. |
| // |
| // Parameters: |
| // pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args |
| // |
| // Related Constants: |
| // - <c_LwM2M_stepIdx_setFirmwareUpdateState> |
| // - <c_LwM2M_stepName_setFirmwareUpdateState> |
| /////////////////////////////////////////////////////////// |
| function f_LwM2M_step_setFirmwareUpdateState(in EPTF_LGenBase_TestStepArgs pl_ptr) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId)); |
| f_EPTF_LwM2M_setStepCtx(pl_ptr, v_LwM2M_ctx); |
| |
| var integer v_state := -1; |
| if (f_EPTF_LwM2M_getIntValue(pl_ptr.refContext.fRefArgs, 0, v_state) and v_LwM2M_ctx.deviceIdx >= 0){ |
| var LwM2M_ResourceValue vl_state; |
| vl_state.intValue := v_state; |
| f_LwM2M_ObjectDB_setResourceValue(v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects, 5, 0, 3, vl_state); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_LwM2M_step_setFirmwareUpdateResult |
| // |
| // Purpose: |
| // The test step will set the firmware update result resource value. |
| // |
| // Parameters: |
| // pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args |
| // |
| // Related Constants: |
| // - <c_LwM2M_stepIdx_setFirmwareUpdateResult> |
| // - <c_LwM2M_stepName_setFirmwareUpdateReslut> |
| /////////////////////////////////////////////////////////// |
| function f_LwM2M_step_setFirmwareUpdateResult(in EPTF_LGenBase_TestStepArgs pl_ptr) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId)); |
| f_EPTF_LwM2M_setStepCtx(pl_ptr, v_LwM2M_ctx); |
| |
| var integer v_res := -1; |
| if (f_EPTF_LwM2M_getIntValue(pl_ptr.refContext.fRefArgs, 0, v_res) and v_LwM2M_ctx.deviceIdx >= 0){ |
| var LwM2M_ResourceValue vl_res; |
| vl_res.intValue := v_res; |
| f_LwM2M_ObjectDB_setResourceValue(v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].objects, 5, 0, 5, vl_res); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_LwM2M_step_setContentFormats |
| // |
| // Purpose: |
| // Test Step to set the preferred encoding content format for a <LwM2M_Device> |
| // |
| // Parameters: |
| // pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args |
| // pl_ptr.refContext.fRefArgs[0] - *in integer* - content format code |
| // |
| // Related Constants: |
| // - <c_LwM2M_stepIdx_createObject> |
| // - <c_LwM2M_stepName_createObject> |
| /////////////////////////////////////////////////////////// |
| function f_LwM2M_step_setContentFormats(in EPTF_LGenBase_TestStepArgs pl_ptr) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| f_EPTF_LwM2M_Logging_DEBUG(log2str(%definitionId)); |
| f_EPTF_LwM2M_setStepCtx(pl_ptr, v_LwM2M_ctx); |
| |
| if (v_LwM2M_ctx.deviceIdx >= 0) |
| { |
| if (sizeof(pl_ptr.refContext.fRefArgs) > 0 and v_LwM2M_ctx.deviceIdx >= 0) |
| { |
| v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].contentFormats := |
| pl_ptr.refContext.fRefArgs; |
| } |
| else { f_EPTF_LwM2M_Logging_VERBOSE(log2str("parameter is not set for test step")); } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_setStepCtx |
| // |
| // Purpose: |
| // This sets the instance pointers of <LwM2M_StepCtx> to the related instances of a simulated device (entity) |
| // calculated from the test step args <EPTF_LGenBase_TestStepArgs> |
| // |
| // Parameters: |
| // pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args |
| // p_ctx - <LwM2M_StepCtx> - step context with pointers to the related instances |
| // |
| // Related Types: |
| // - <LwM2M_EntityCtx> |
| // - <LwM2M_StepCtx> |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_setStepCtx(in EPTF_LGenBase_TestStepArgs pl_ptr, inout LwM2M_StepCtx p_ctx) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| p_ctx.eIdx := pl_ptr.eIdx; |
| p_ctx.fsmIdx := pl_ptr.refContext.fCtxIdx; |
| p_ctx.eCtxIdx := f_EPTF_LGenBase_getBehaviorCtxItem(pl_ptr.eIdx, v_LwM2M_bIdx, 0); |
| p_ctx.deviceIdx := v_LwM2M_EntityCtxDB.data[v_LwM2M_ctx.eCtxIdx].currentDevice; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_setCtx |
| // |
| // Purpose: |
| // This sets the instance pointers of <LwM2M_StepCtx> to the related instances of a simulated device (entity) |
| // calculated from the test step args <EPTF_LGenBase_TestStepArgs> |
| // |
| // Parameters: |
| // p_eIdx - *in* *integer* - entity index |
| // p_fsmIdx - *in* *integer* - fsm instace index |
| // |
| // Returns: |
| // *inout* p_ctx - <LwM2M_StepCtx> - step context with pointers to the related instances |
| // |
| // Related Types: |
| // - <LwM2M_EntityCtx> |
| // - <LwM2M_StepCtx> |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_setCtx(in integer p_eIdx, in integer p_fsmIdx, inout LwM2M_StepCtx p_ctx) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| p_ctx.eIdx := p_eIdx; |
| p_ctx.fsmIdx := p_fsmIdx; |
| p_ctx.eCtxIdx := f_EPTF_LGenBase_getBehaviorCtxItem(p_eIdx, v_LwM2M_bIdx, 0); |
| p_ctx.deviceIdx := v_LwM2M_EntityCtxDB.data[v_LwM2M_ctx.eCtxIdx].currentDevice; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_hasDevice |
| // |
| // Purpose: |
| // Checks if the <LwM2M_EntityCtx> instance of the actual entity has an associated device or not |
| // |
| // Parameters: |
| // p_ctx - *in* <LwM2M_StepCtx> - pointer related to the actual entity |
| // |
| // Returns: |
| // *boolean* - TRUE if the <LwM2M_EntityCtx> has an associated device, FALSE otherwise |
| // |
| // Related Types: |
| // <LwM2M_EntityCtx> |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_hasDevice(in LwM2M_StepCtx p_ctx) |
| return boolean |
| { |
| return p_ctx.deviceIdx >= 0; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_stack_fromApp |
| // |
| // Purpose: |
| // This is the main entry point for the LwM2M stack realization of the <EPTF_LwM2M_LGen_CT> |
| // component that handles messages received from the application layer (e.g. FSMs) |
| // |
| // Parameters: |
| // p_msg - *inout* <EPTF_LwM2M_PDU> - message that enters into the stack (will be modified by the stack) |
| // p_ctx - *in* <LwM2M_StepCtx> - pointers for the instances related to a particular simulated entity |
| // |
| // Related Types: |
| // <EPTF_LwM2M_LGen_CT> |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_stack_fromApp(inout EPTF_LwM2M_PDU p_pdu, in LwM2M_StepCtx p_ctx) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| if (p_ctx.deviceIdx >= 0) |
| { |
| // State: NOT_REGISTERED |
| if (v_LwM2M_DeviceDB.data[p_ctx.deviceIdx].state == NOT_REGISTERED) |
| { |
| // Register available objects |
| if (ischosen(p_pdu.pdu.Register) and |
| v_LwM2M_DeviceDB.data[p_ctx.deviceIdx].objects.id != -1) { |
| f_LwM2M_ObjectDB_getObjectPaths(v_LwM2M_DeviceDB.data[p_ctx.deviceIdx].objects, p_pdu.pdu.Register.objectsAndObjectInstances); |
| } |
| } |
| // State: REGISTERED |
| else if (v_LwM2M_DeviceDB.data[p_ctx.deviceIdx].state == REGISTERED) |
| { |
| // Include registered location in the outgoing message |
| if (sizeof(v_LwM2M_DeviceDB.data[p_ctx.deviceIdx].registeredLocation) > 0) { |
| if (ischosen(p_pdu.pdu.Update)) { |
| p_pdu.pdu.Update.location := v_LwM2M_DeviceDB.data[p_ctx.deviceIdx].registeredLocation; |
| } |
| else if (ischosen(p_pdu.pdu.Deregister)) { |
| p_pdu.pdu.Deregister.location := v_LwM2M_DeviceDB.data[p_ctx.deviceIdx].registeredLocation; |
| v_LwM2M_DeviceDB.data[p_ctx.deviceIdx].state := NOT_REGISTERED; |
| } |
| } |
| } |
| } |
| f_EPTF_LwM2M_updateMessageStatistics(v_LwM2M_stats.outgoing, p_pdu); |
| vf_EPTF_LwM2M_Transport_send.apply(p_pdu); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_stack_fromEnv |
| // |
| // Purpose: |
| // This is the main entry point for the LwM2M stack realization of the <EPTF_LwM2M_LGen_CT> |
| // component that handles messages received from the environment layer (e.g. transport layer) |
| // |
| // Parameters: |
| // p_msg - *inout* <EPTF_LwM2M_PDU> - message that enters into the stack (will be modified by the stack) |
| // |
| // Returns: |
| // *boolean* - true, if the *p_msg* message was a duplicate, false if it was not |
| // |
| // Related Types: |
| // <EPTF_LwM2M_LGen_CT> |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_stack_fromEnv(in EPTF_LwM2M_PDU p_pdu) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| f_EPTF_LwM2M_setCtx(p_pdu.eIdx, p_pdu.fsmIdx, v_LwM2M_ctx); |
| |
| if (v_LwM2M_ctx.deviceIdx >= 0) |
| { |
| // State: NOT_REGISTERED |
| if (v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].state == NOT_REGISTERED) |
| { |
| // Save registered location |
| if (ischosen(p_pdu.pdu.Response) and p_pdu.pdu.Response.code == 201) { |
| v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].registeredLocation := p_pdu.pdu.Response.location; |
| v_LwM2M_DeviceDB.data[v_LwM2M_ctx.deviceIdx].state := REGISTERED; |
| } |
| } |
| } |
| |
| f_EPTF_LwM2M_dispatchEventsForPDU(p_pdu.pdu, p_pdu.eIdx, p_pdu.fsmIdx, {}); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_dispatchEventsForPDU |
| // |
| // Purpose: |
| // Dispatches events to an entity/fsm based on the LWM2M PDU givenas a parameter |
| // |
| // Parameters: |
| // pl_pdu - *in* <LWM2M_PDU> - the LWM2M PDU |
| // pl_eIdx - *in* *integer* - the index of the entity |
| // pl_fsmCtx - *in* *integer* - the index of FSM |
| // pl_reportedArgs - *in* <EPTF_IntegerList> - additional arguments to be reported to the entity/FSM |
| // |
| // Related Types: |
| // <EPTF_LwM2M_LGen_CT> |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_dispatchEventsForPDU(in LWM2M_PDU pl_pdu, in integer pl_eIdx, in integer pl_fsmCtx, in EPTF_IntegerList pl_reportedArgs) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| var integer vl_eventIdx := f_EPTF_LwM2M_PduToEventIdx(pl_pdu); |
| |
| if (vl_eventIdx == -1) { |
| f_EPTF_LwM2M_Logging_ERROR(log2str(%definitionId," Couldn't find eventIdx for PDU: ", pl_pdu)); |
| return; |
| } |
| |
| f_EPTF_LwM2M_dispatchEvent(vl_eventIdx, pl_eIdx, pl_fsmCtx, {}); |
| |
| if (100 <= vl_eventIdx and vl_eventIdx <= 199) |
| { |
| f_EPTF_LwM2M_dispatchEvent(c_LwM2M_eventIdx_1xx, pl_eIdx, pl_fsmCtx, {}); |
| } |
| else if (200 <= vl_eventIdx and vl_eventIdx <= 299) |
| { |
| f_EPTF_LwM2M_dispatchEvent(c_LwM2M_eventIdx_2xx, pl_eIdx, pl_fsmCtx, {}); |
| } |
| else if (300 <= vl_eventIdx and vl_eventIdx <= 699) |
| { |
| if (300 <= vl_eventIdx and vl_eventIdx <= 399) |
| { |
| f_EPTF_LwM2M_dispatchEvent(c_LwM2M_eventIdx_3xx, pl_eIdx, pl_fsmCtx, {}); |
| } |
| else if (400 <= vl_eventIdx and vl_eventIdx <= 499) |
| { |
| f_EPTF_LwM2M_dispatchEvent(c_LwM2M_eventIdx_4xx, pl_eIdx, pl_fsmCtx, {}); |
| } |
| else if (500 <= vl_eventIdx and vl_eventIdx <= 599) |
| { |
| f_EPTF_LwM2M_dispatchEvent(c_LwM2M_eventIdx_4xx, pl_eIdx, pl_fsmCtx, {}); |
| } |
| f_EPTF_LwM2M_dispatchEvent(c_LwM2M_eventIdx_3xxto6xx, pl_eIdx, pl_fsmCtx, {}); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_sendNotificationForResource |
| // |
| // Purpose: |
| // The function sends a LwM2M NOTIFICATION for a resource owned by the entity addressed by the *pl_ptr* parameter |
| // |
| // Parameters: |
| // pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args |
| // v_res - *in* <LwM2M_Resource> - resource for notification |
| // |
| // Related Types: |
| // - <LwM2M_Device> |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_sendNotificationForResource(in EPTF_LGenBase_TestStepArgs pl_ptr, in LwM2M_Resource v_res) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| if (v_res.observed) |
| { |
| //v_res.objId := -1; v_res.objInstId := -1; v_res.id := -1; |
| |
| v_LwM2M_msgToSend.pdu := c_LWM2M_Notification_init; |
| v_LwM2M_msgToSend.pdu.Notification.path := { v_res.objId, v_res.objInstId, v_res.id }; |
| v_LwM2M_msgToSend.pdu.Notification.code := 205; |
| v_LwM2M_msgToSend.pdu.Notification.resources := { v_res } |
| if (ispresent(v_res.contentFormat)) |
| { |
| v_LwM2M_msgToSend.pdu.Notification.contentFormat := v_res.contentFormat; |
| } |
| else |
| { |
| v_LwM2M_msgToSend.pdu.Notification.contentFormat := tsp_EPTF_LwM2M_LGen_defaultContentFormat; |
| } |
| f_LwM2M_step_send(pl_ptr); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_PduToEventIdx |
| // |
| // Purpose: |
| // Maps a <LWM2M_PDU> to an event id (integer number) that represents the PDU's type |
| // |
| // Parameters: |
| // p_code - *in* <LWM2M_PDU> - the LwM2M PDU |
| // |
| // Returns: |
| // *integer* - the returned id |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_PduToEventIdx(in LWM2M_PDU p_pdu) |
| return integer |
| { |
| if (ischosen(p_pdu.Register)) { return c_LwM2M_eventIdx_Register; } |
| else if (ischosen(p_pdu.Update)) { return c_LwM2M_eventIdx_Update; } |
| else if (ischosen(p_pdu.Deregister)) { return c_LwM2M_eventIdx_Deregister; } |
| else if (ischosen(p_pdu.Read_)) { return c_LwM2M_eventIdx_Read; } |
| else if (ischosen(p_pdu.Write)) { return c_LwM2M_eventIdx_Write; } |
| else if (ischosen(p_pdu.Execute)) { return c_LwM2M_eventIdx_Execute; } |
| else if (ischosen(p_pdu.Create)) { return c_LwM2M_eventIdx_Create; } |
| else if (ischosen(p_pdu.Delete)) { return c_LwM2M_eventIdx_Delete; } |
| else if (ischosen(p_pdu.BS_Delete)) { return c_LwM2M_eventIdx_BS_Delete; } |
| else if (ischosen(p_pdu.BS_Request_Finish)) { return c_LwM2M_eventIdx_BS_Finish; } |
| else if (ischosen(p_pdu.Response)) { return p_pdu.Response.code; } |
| else { |
| return -1; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_dispatchEvent |
| // |
| // Purpose: |
| // Wrapper for CLL's <f_EPTF_LGenBase_postEvent> to handle multi level event (generic, entity, FSM) reporting |
| // |
| // Parameters: |
| // pl_eventIdx - *in* *integer* - index of the vent to be reported |
| // pl_eIdx - *in* *integer* - the index of the entity, in case it's -1 the reported event will be *generic* level |
| // pl_fsmCtx - *in* *integer* - the index of FSM, , in case it's -1 the reported event will be *entity* level |
| // pl_reportedArgs - *in* <EPTF_IntegerList> - additional arguments to be reported to the entity/FSM |
| // |
| // Related Types: |
| // <EPTF_LwM2M_LGen_CT> |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_dispatchEvent(in integer pl_eventIdx, in integer pl_eIdx, in integer pl_fsmCtx, in EPTF_IntegerList pl_reportedArgs) |
| runs on EPTF_LwM2M_LGen_CT |
| { |
| if (pl_eIdx < 0) |
| { |
| f_EPTF_LGenBase_postEvent( |
| { |
| { |
| v_LwM2M_bIdx, |
| pl_eventIdx, |
| omit, |
| omit |
| }, |
| pl_reportedArgs |
| }); |
| } |
| else |
| { |
| if (pl_fsmCtx < 0) |
| { |
| f_EPTF_LGenBase_postEvent( |
| { |
| { |
| v_LwM2M_bIdx, |
| pl_eventIdx, |
| { |
| pl_eIdx, |
| omit |
| }, omit |
| }, |
| pl_reportedArgs |
| }); |
| } |
| else |
| { |
| f_EPTF_LGenBase_postEvent( |
| { |
| { |
| v_LwM2M_bIdx, |
| pl_eventIdx, |
| { |
| pl_eIdx, |
| pl_fsmCtx |
| }, omit |
| }, |
| pl_reportedArgs |
| }); |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_getIntValue |
| // |
| // Purpose: |
| // Retreives an element of an <EPTF_IntegerList> if it exists |
| // |
| // Parameters: |
| // pl_intList - *in* <EPTF_IntegerList> - list of integers |
| // pl_number - *in* *integer* - index of the integer to be retrieved |
| // |
| // Returns: |
| // pl_value - *inout* *integer* - value of the retrieved integer |
| // *boolean* - true if the element existed in the integer list |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_getIntValue( |
| in EPTF_IntegerList pl_intList, |
| in integer pl_number, |
| inout integer pl_value) |
| return boolean |
| { |
| if (sizeof(pl_intList) > pl_number) |
| { |
| pl_value := pl_intList[pl_number]; |
| return true; |
| } |
| return false; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_updateMessageStatistics |
| // |
| // Purpose: |
| // Updates the message statistics based on the incoming PDU |
| // |
| // Parameters: |
| // p_stats - *inout* <EPTF_LwM2M_Message_Statistics> - the updated statistics |
| // p_pdu - *in* <EPTF_LwM2M_PDU> - the incoming PDU |
| // |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_updateMessageStatistics(inout EPTF_LwM2M_Message_Statistics p_stats, in EPTF_LwM2M_PDU p_pdu) |
| { |
| if (ischosen(p_pdu.pdu.Register)) { p_stats.noRegister := p_stats.noRegister + 1 } |
| else if (ischosen(p_pdu.pdu.Update)) { p_stats.noUpdate := p_stats.noUpdate + 1 } |
| else if (ischosen(p_pdu.pdu.Deregister)) { p_stats.noDeregister := p_stats.noDeregister + 1 } |
| else if (ischosen(p_pdu.pdu.Response)) |
| { |
| if (p_pdu.pdu.Response.code < 300) { p_stats.noPosResp := p_stats.noPosResp + 1 } |
| else { p_stats.noNegResp := p_stats.noNegResp + 1 } |
| } |
| else if (ischosen(p_pdu.pdu.Notification)) { p_stats.noNotification := p_stats.noNotification + 1 } |
| else if (ischosen(p_pdu.pdu.Read_)) { p_stats.noRead := p_stats.noRead + 1 } |
| else if (ischosen(p_pdu.pdu.Write)) { p_stats.noWrite := p_stats.noWrite + 1 } |
| else if (ischosen(p_pdu.pdu.Execute)) { p_stats.noExecute := p_stats.noExecute + 1 } |
| else if (ischosen(p_pdu.pdu.Create)) { p_stats.noCreate := p_stats.noCreate + 1 } |
| else if (ischosen(p_pdu.pdu.Delete)) { p_stats.noDelete := p_stats.noDelete + 1 } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_getEncodingContentFormat |
| // |
| // Purpose: |
| // Negotiates an encoding format based on this side's preferred, the other side's accepted |
| // and the list of resources to be encoded |
| // |
| // Parameters: |
| // p_preferred - *in* <LwM2M_Format_List> - this side's preferred format |
| // p_accepted - *in* <Integer_List> - the other side's accepted list |
| // p_resources - *in* <LwM2M_Resource_List> - resources to be encoded |
| // |
| // Returns: |
| // *integer* - the negotiated content format |
| // |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_getEncodingContentFormat( |
| in LwM2M_Format_List p_preferred, |
| in Integer_List p_accepted, |
| in LwM2M_Resource_List p_resources |
| ) |
| return integer |
| { |
| for (var integer i:=0; i<sizeof(p_preferred); i:=i+1) |
| { |
| if (f_EPTF_LwM2M_isInList(p_preferred[i], p_accepted)) |
| { |
| if (f_EPTF_LwM2M_canEncode(p_preferred[i], p_resources)) |
| { |
| return p_preferred[i]; |
| } |
| } |
| } |
| |
| return tsp_EPTF_LwM2M_LGen_defaultContentFormat; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LwM2M_canEncode |
| // |
| // Purpose: |
| // Finds out if a list of resources can be encoded with a certain content format |
| // |
| // Parameters: |
| // p_code - *in integer* - content format code |
| // p_resources - *in* <LwM2M_Resource_List> - resources to be encoded |
| // |
| // Returns: |
| // *boolean* - true if they can be encoded with that content format |
| // |
| /////////////////////////////////////////////////////////// |
| function f_EPTF_LwM2M_canEncode(in integer p_code, in LwM2M_Resource_List p_resources) |
| return boolean |
| { |
| // LwM2M JSON |
| if (p_code == 11543) { return true; } |
| |
| // SenML JSON |
| else if (p_code == 110) { return true; } |
| |
| // TLV encode is not yet supported in codec |
| //if (p_code == 11542) { return true; } |
| |
| // Plain Text |
| else if (p_code == 0) |
| { |
| if ( |
| sizeof(p_resources)==1 and |
| (ischosen(p_resources[0].val.intValue) or ischosen(p_resources[0].val.floatValue) or ischosen(p_resources[0].val.strValue)) |
| ) |
| { return true; } |
| else { return false; } |
| } |
| |
| // Opaque |
| else if (p_code == 42) |
| { |
| if (sizeof(p_resources)==1 and ischosen(p_resources[0].val.opaqueValue)) { return true; } |
| else { return false; } |
| } |
| |
| return false; |
| } |
| |
| function f_EPTF_LwM2M_isInList(in integer p_i, in Integer_List p_list) |
| return boolean |
| { |
| for (var integer i:=0; i<sizeof(p_list); i:=i+1) |
| { |
| if (p_i == p_list[i]) { return true; } |
| } |
| return false; |
| } |
| } |