///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2000-2019 Ericsson Telecom AB
//
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v2.0
// which accompanies this distribution, and is available at
// https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
///////////////////////////////////////////////////////////////////////////////
//  File:               EPTF_LwM2M_LGen_Definitions.ttcn
//  Description:
//  Rev:                R1A
//  Prodnr:             CNL 113 859
//  Updated:            2019-08-27
//  Contact:            http://ttcn.ericsson.se
///////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////
//  Module: EPTF_LwM2M_LGen_Definitions
// 
//  Purpose:
//    This module contains the definitions for the LWM2M load generator component
//
//  Module depends on:
//    - <EPTF_LwM2M_Object_Definitions>
//    - <EPTF_LwM2M_Transport_Definitions>
//    - <EPTF_CLL_LGenBase_Definitions>
//    - <EPTF_CLL_Logging_Definitions>
//    - <EPTF_CLL_FBQ_Definitions>
//    - <LightweightM2M_Types>
// 
//  Module Parameters:
//    tsp_EPTF_LwM2M_LGen_log_error - <tsp_EPTF_LwM2M_LGen_log_error> - *boolean* - Enabled/disable error logging
//    tsp_EPTF_LwM2M_LGen_log_warning - <tsp_EPTF_LwM2M_LGen_log_warning> - *boolean* - Enabled/disable warning logging
//    tsp_EPTF_LwM2M_LGen_debug - <tsp_EPTF_LwM2M_LGen_debug> - *boolean* - Enabled/disable debug logging
//    tsp_EPTF_LwM2M_LGen_debugVerbose - <tsp_EPTF_LwM2M_LGen_debugVerbose> - *boolean* - Enabled/disable verbose debug logging
//    tsp_EPTF_LwM2M_LGen_templates - <tsp_EPTF_LwM2M_LGen_templates> - <LwM2M_Template_List> - LWM2M template definitions for sending
//    tsp_EPTF_LwM2M_LGen_objectSpecifications - <tsp_EPTF_LwM2M_LGen_objectSpecifications> - <LwM2M_ObjectSpecification_List> - Additional smart object specifications to be loaded
//
//  Events:
//    LWM2M Register request - <c_LwM2M_eventIdx_Register>, <c_LwM2M_eventName_Register>
//    LWM2M Update request - <c_LwM2M_eventIdx_Update>, <c_LwM2M_eventName_Update>
//    LWM2M Deregister request - <c_LwM2M_eventIdx_Deregister>, <c_LwM2M_eventName_Deregister>
//    LWM2M Read request - <c_LwM2M_eventIdx_Read>, <c_LwM2M_eventName_Read>
//    LWM2M Write request - <c_LwM2M_eventIdx_Write>, <c_LwM2M_eventName_Write>
//    LWM2M Execute request - <c_LwM2M_eventIdx_Execute>, <c_LwM2M_eventName_Execute>
//    LWM2M Create request - <c_LwM2M_eventIdx_Create>, <c_LwM2M_eventName_Create>
//    LWM2M Delete request - <c_LwM2M_eventIdx_Delete>, <c_LwM2M_eventName_Delete>
//    LWM2M 1xx response - <c_LwM2M_eventIdx_1xx>, <c_LwM2M_eventName_1xx>
//    LWM2M 2xx response - <c_LwM2M_eventIdx_2xx>, <c_LwM2M_eventName_2xx>
//    LWM2M 3xx response - <c_LwM2M_eventIdx_3xx>, <c_LwM2M_eventName_3xx>
//    LWM2M 4xx response - <c_LwM2M_eventIdx_4xx>, <c_LwM2M_eventName_4xx>
//    LWM2M 5xx response - <c_LwM2M_eventIdx_5xx>, <c_LwM2M_eventName_5xx>
//    LWM2M 6xx response - <c_LwM2M_eventIdx_6xx>, <c_LwM2M_eventName_6xx>
//    LWM2M 3xxto6xx response - <c_LwM2M_eventIdx_3xxto6xx>, <c_LwM2M_eventName_3xxto6xx>
//    LWM2M resource not observed any more indication - <c_LwM2M_eventIdx_resourceNotObservedIndication>, <c_LwM2M_eventName_resourceNotObservedIndication>
//
//  TestSteps:
//    LWM2M load template - <f_LwM2M_step_loadTemplate_byIntIdx>, <c_LwM2M_stepName_loadTemplate_byIntIdx>, <c_LwM2M_stepIdx_loadTemplate_byIntIdx>
//                          <f_LwM2M_step_loadTemplate_byStringId>, <c_LwM2M_stepName_send>, <c_LwM2M_stepIdx_loadTemplate_byStringId>
//    LWM2M send - <f_LwM2M_step_send>, <c_LwM2M_stepName_send>, <c_LwM2M_stepIdx_send>
//    LWM2M create device - <f_LwM2M_step_createDevice>, <c_LwM2M_stepName_createDevice>, <c_LwM2M_stepIdx_createDevice>
//    LWM2M clean up device - <f_LwM2M_step_cleanupDevice>, <c_LwM2M_stepName_cleanupDevice>, <c_LwM2M_stepIdx_cleanupDevice>
//    LWM2M log device - <f_LwM2M_step_logDevice>, <c_LwM2M_stepName_logDevice>, <c_LwM2M_stepIdx_logDevice>
//    LWM2M create object - <f_LwM2M_step_createObject>, <c_LwM2M_stepName_createObject>, <c_LwM2M_stepIdx_createObject>
//    LWM2M create object instance - <f_LwM2M_step_createObjectInstance>, <c_LwM2M_stepName_createObjectInstance>, <c_LwM2M_stepIdx_createObjectInstance>
//    LWM2M handle READ request - <f_LwM2M_step_handleReadRequest>, <c_LwM2M_stepName_handleReadRequest>, <c_LwM2M_stepIdx_handleReadRequest>
//    LWM2M handle WRITE request - <f_LwM2M_step_handleWriteRequest>, <c_LwM2M_stepName_handleWriteRequest>, <c_LwM2M_stepIdx_handleWriteRequest>
//    LWM2M handle EXECUTE request - <f_LwM2M_step_handleExecuteRequest>, <c_LwM2M_stepName_handleExecuteRequest>, <c_LwM2M_stepIdx_handleExecuteRequest>
//    LWM2M send NOTIFICATION - <f_LwM2M_step_sendNotificationForObservedResources>, <c_LwM2M_stepName_sendNotificationForObservedResources>, <c_LwM2M_stepIdx_sendNotificationForObservedResources>
//
//  Class Diagram:
//   (see EPTF_LwM2M_LGen_Definitions.classes.jpg)
//
///////////////////////////////////////////////////////////////
module EPTF_LwM2M_LGen_Definitions
{
  import from EPTF_CLL_LGenBase_Definitions all;
  import from EPTF_CLL_Logging_Definitions all;
  import from EPTF_CLL_FBQ_Definitions all;
  import from EPTF_LwM2M_Object_Definitions all;
  import from EPTF_LwM2M_Transport_Definitions all;
  import from LightweightM2M_Types all;

  ///////////////////////////////////////////////////////////
  //  Module parameter: tsp_EPTF_LwM2M_LGen_log_error
  // 
  //  Purpose:
  //    Enabled/disable error logging
  //  
  //  Type:
  //     *boolean*
  //
  //  Default value:
  //     *true*
  ///////////////////////////////////////////////////////////
  modulepar boolean tsp_EPTF_LwM2M_LGen_log_error := true;

  ///////////////////////////////////////////////////////////
  //  Module parameter: tsp_EPTF_LwM2M_LGen_log_warning
  // 
  //  Purpose:
  //    Enabled/disable warning logging
  //  
  //  Type:
  //     *boolean*
  //
  //  Default value:
  //     *true*
  ///////////////////////////////////////////////////////////
  modulepar boolean tsp_EPTF_LwM2M_LGen_log_warning := true;
  
  ///////////////////////////////////////////////////////////
  //  Module parameter: tsp_EPTF_LwM2M_LGen_debug
  // 
  //  Purpose:
  //    Enabled/disable debug logging
  //  
  //  Type:
  //     *boolean*
  //
  //  Default value:
  //     *false*
  ///////////////////////////////////////////////////////////
  modulepar boolean tsp_EPTF_LwM2M_LGen_debug := false;

  ///////////////////////////////////////////////////////////
  //  Module parameter: tsp_EPTF_LwM2M_LGen_debugVerbose
  // 
  //  Purpose:
  //    Enabled/disable verbose debug logging
  //
  //  Type:
  //     *boolean*
  //
  //  Default value:
  //     *false*
  ///////////////////////////////////////////////////////////
  modulepar boolean tsp_EPTF_LwM2M_LGen_debugVerbose := false;

  modulepar integer tsp_EPTF_LwM2M_LGen_maxBindableCtx := -1;

  ///////////////////////////////////////////////////////////
  //  Module parameter: tsp_EPTF_LwM2M_LGen_templates
  // 
  //  Purpose:
  //    List of LWM2M messages for sending
  //
  //  Type:
  //     <LwM2M_Template_List>
  //
  //  Default value:
  //     Empty list: {}
  ///////////////////////////////////////////////////////////
  modulepar LwM2M_Template_List tsp_EPTF_LwM2M_LGen_templates := {};

  ///////////////////////////////////////////////////////////
  //  Module parameter: tsp_EPTF_LwM2M_LGen_objectSpecifications
  // 
  //  Purpose:
  //    List of smart object specifications (needed for creating smart object instances)
  //
  //  Type:
  //     <LwM2M_ObjectSpecification_List>
  //
  //  Default value:
  //     Empty list: {}
  ///////////////////////////////////////////////////////////
  modulepar LwM2M_ObjectSpecification_List tsp_EPTF_LwM2M_LGen_objectSpecifications := {};

  const integer c_LwM2M_LGen_Logging_WARNING := 0;
  const integer c_LwM2M_LGen_Logging_DEBUG := 1;
  const integer c_LwM2M_LGen_Logging_DEBUGV := 2;
  const integer c_LwM2M_LGen_Logging_ERROR := 3;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_behaviorType
  //
  //  Purpose:
  //    Constant for LWM2M behaviour name
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_behaviorType := "LWM2M Behavior";
  

 /*****************************************************************
   @startuml EPTF_LwM2M_LGen_Definitions.classes.jpg

     class EPTF_LwM2M_LGen_CT {
       boolean v_LwM2M_initialized
       integer v_LwM2M_bIdx
       integer v_LwM2M_loggingMaskId
       LwM2M_ObjectSpecificationDB v_LwM2M_ObjectSpecificationDB
       LwM2M_EntityCtx_DB v_LwM2M_EntityCtxDB
       LwM2M_Device_DB v_LwM2M_DeviceDB
       LwM2M_Template_DB v_LwM2M_templateDB
       LwM2M_StepCtx v_LwM2M_ctx
       EPTF_LwM2M_PDU v_LwM2M_msgToProcess
       EPTF_LwM2M_PDU v_LwM2M_msgToSend
       EPTF_LwM2M_Event v_LwM2M_eventToProcess
       f_EPTF_LwM2M_LGen_init(in charstring pl_name)
       f_LwM2M_cleanUp()
       f_LwM2M_eCtxBind(in integer pl_eIdx)
       f_LwM2M_eCtxUnbind(in integer pl_eIdx)
       f_LwM2M_eCtxReset(in integer pl_eIdx)
       f_EPTF_LwM2M_Logging_VERBOSE(in @lazy charstring pl_message)
       f_EPTF_LwM2M_Logging_DEBUG(in @lazy charstring pl_message)
       f_EPTF_LwM2M_Logging_WARNING(in @lazy charstring pl_message)
       f_EPTF_LwM2M_Logging_ERROR(in @lazy charstring pl_message)
       f_EPTF_LwM2M_LGen_receiveMessage(in EPTF_LwM2M_PDU pl_message)
       f_EPTF_LwM2M_LGen_receiveEvent(in EPTF_LwM2M_Event pl_event)
       f_EPTF_LwM2M_declareEvents()
       f_EPTF_LwM2M_declareSteps()
       f_EPTF_LwM2M_setStepCtx(in EPTF_LGenBase_TestStepArgs pl_ptr, inout LwM2M_StepCtx p_ctx)
       f_EPTF_LwM2M_setCtx(in integer p_eIdx, in integer p_fsmIdx, inout LwM2M_StepCtx p_ctx)
       f_EPTF_LwM2M_hasDevice(in LwM2M_StepCtx p_ctx)
       f_EPTF_LwM2M_stack_fromApp(inout EPTF_LwM2M_PDU p_pdu, in LwM2M_StepCtx p_ctx)
       f_EPTF_LwM2M_stack_fromEnv(in EPTF_LwM2M_PDU p_pdu)
       f_EPTF_LwM2M_dispatchEventsForPDU(in LWM2M_PDU pl_pdu, in integer pl_eIdx, in integer pl_fsmCtx, in EPTF_IntegerList pl_reportedArgs)
       f_EPTF_LwM2M_dispatchEvent(in integer pl_eventIdx, in integer pl_eIdx, in integer pl_fsmCtx, in EPTF_IntegerList pl_reportedArgs)
     }
     EPTF_LwM2M_LGen_CT "1" --> "1\n.v_LwM2M_ObjectSpecificationDB" LwM2M_ObjectSpecificationDB
     EPTF_LwM2M_LGen_CT "1" --> "1\n.v_LwM2M_EntityCtxDB" LwM2M_EntityCtx_DB
     EPTF_LwM2M_LGen_CT "1" --> "1\n.v_LwM2M_DeviceDB" LwM2M_Device_DB
     EPTF_LwM2M_LGen_CT "1" --> "1\n.v_LwM2M_templateDB" LwM2M_Template_DB

     class LwM2M_EntityCtx {
       integer eIdx
       integer currentDevice
     }
     LwM2M_EntityCtx "1" --> "1\n.currentDevice" LwM2M_Device

     class LwM2M_EntityCtx_DB {
       EPTF_FreeBusyQueue  queue
       LwM2M_EntityCtx_List data
       integer             hashRef
       f_EPTF_LwM2M_EntityCtxDB_init()
       f_EPTF_LwM2M_EntityCtxDB_cleanUp()
     }
     LwM2M_EntityCtx_DB "1" --> "*\n.data[]" LwM2M_EntityCtx

     class LwM2M_Device {
       Location registeredLocation
       LwM2M_ObjectDB objects
       LwM2M_Device_State state
     }

     class LwM2M_Device_DB {
       EPTF_FreeBusyQueue    queue
       LwM2M_Device_List data
       integer hashRef
       f_EPTF_LwM2M_DeviceDB_init()
       f_EPTF_LwM2M_DeviceDB_add(in LwM2M_Device p_device)
       f_EPTF_LwM2M_DeviceDB_remove(in integer p_idx)
       f_EPTF_LwM2M_DeviceDB_setLocationKey(in Location p_location, in integer p_idx)
       f_EPTF_LwM2M_DeviceDB_locationHash(in Location p_location)
       f_EPTF_LwM2M_DeviceDB_cleanUp()
     }
     LwM2M_Device_DB "1" --> "*\n.data[]" LwM2M_Device

     class LwM2M_Template_DB {
       EPTF_FreeBusyQueue    queue
       LwM2M_Template_List data
       integer hashRef
       f_EPTF_LwM2M_TemplateDB_init()
       f_EPTF_LwM2M_TemplateDB_add(in LwM2M_Template p_template)
       f_EPTF_LwM2M_TemplateDB_lookUp(in charstring p_id)
       f_EPTF_LwM2M_TemplateDB_get(in integer p_idx, inout LWM2M_PDU p_pdu)
       f_EPTF_LwM2M_TemplateDB_cleanUp()
     }
     LwM2M_Template_DB "1" --> "*\n.data[]" LwM2M_Template

   @enduml
  ******************************************************************/

 /*****************************************************************
   @startuml EPTF_LwM2M_LGen_Definitions.LwM2M_EntityCtx.jpg
     class LwM2M_EntityCtx {
       integer eIdx
       integer currentDevice
     }
   @enduml
  ******************************************************************/

  ///////////////////////////////////////////////////////////
  //  Type: LwM2M_EntityCtx
  //
  //  Purpose:
  //    A LWM2M entity is a simulated LWM2M device, this structure stores an association for one simulated device and an entity
  //
  //  Class:
  //    (see EPTF_LwM2M_LGen_Definitions.LwM2M_EntityCtx.jpg)
  //
  //  Elements:
  //    eIdx  - *integer* - pointer to the entity itself
  //    currentDevice  - *integer* - pointer to the simulated <LwM2M_Device> in *v_LwM2M_DeviceDB*
  //
  //  Related Functions:
  //    - <f_LwM2M_step_createDevice> (in <EPTF_LGenBase_TestStepArgs> pl_ptr)
  //    - <f_LwM2M_step_cleanupDevice> (in <EPTF_LGenBase_TestStepArgs> pl_ptr)
  ///////////////////////////////////////////////////////////
  type record LwM2M_EntityCtx
  {
    integer eIdx,
    integer currentDevice
  }

  const LwM2M_EntityCtx c_LwM2M_EntityCtx_init :=
  {
    eIdx := -1,
    currentDevice := -1
  }

  ///////////////////////////////////////////////////////////
  //  Type: LwM2M_EntityCtx_List
  //
  //  Purpose:
  //    List of <LwM2M_EntityCtx>
  ///////////////////////////////////////////////////////////
  type record of LwM2M_EntityCtx LwM2M_EntityCtx_List;

  /*****************************************************************
   @startuml EPTF_LwM2M_LGen_Definitions.LwM2M_EntityCtx_DB.jpg
     class LwM2M_EntityCtx_DB {
       EPTF_FreeBusyQueue  queue
       LwM2M_EntityCtx_List data
       integer             hashRef
       f_EPTF_LwM2M_EntityCtxDB_init()
       f_EPTF_LwM2M_EntityCtxDB_cleanUp()
     }
   @enduml
  ******************************************************************/
  ///////////////////////////////////////////////////////////
  //  Type: LwM2M_EntityCtx_DB
  //
  //  Purpose:
  //    Storing LWM2M entity contexts
  //
  //  Class:
  //    (see EPTF_LwM2M_LGen_Definitions.LwM2M_EntityCtx_DB.jpg)
  //
  //  Elements:
  //    queue  - <EPTF_FreeBusyQueue> - FBQ for the stored elements
  //    data  - <LwM2M_EntityCtx_List> - elements
  //
  //  Related Functions:
  //    - <f_EPTF_LwM2M_EntityCtxDB_init> ()
  //    - <f_EPTF_LwM2M_EntityCtxDB_cleanUp> ()
  ///////////////////////////////////////////////////////////
  type record LwM2M_EntityCtx_DB 
  {
    EPTF_FreeBusyQueue   queue, 
    LwM2M_EntityCtx_List data,
    integer              hashRef
  }
  
 /*****************************************************************
   @startuml EPTF_LwM2M_LGen_Definitions.LwM2M_Device.jpg
     class LwM2M_Device {
       Location registeredLocation
       LwM2M_ObjectDB objects
       LwM2M_Device_State state
     }
   @enduml
  ******************************************************************/
  ///////////////////////////////////////////////////////////
  //  Type: LwM2M_Device
  //
  //  Purpose:
  //    Storing the state and smart object of a simulated LWM2M device
  //
  //  Class:
  //    (see EPTF_LwM2M_LGen_Definitions.LwM2M_Device.jpg)
  //
  //  Elements:
  //    registeredLocation  - <Location> - id acquired during registration
  //    objects  - <LwM2M_ObjectDB> - smart objects and their instances
  //    state - <LwM2M_Device_State> - tracking the state of the device
  //
  //  Related Functions:
  //    - <f_EPTF_LwM2M_sendNotificationForResource> (in <EPTF_LGenBase_TestStepArgs> pl_ptr, <LwM2M_Resource> v_res)
  ///////////////////////////////////////////////////////////
  type record LwM2M_Device
  {
    Location 		   registeredLocation,
    LwM2M_ObjectDB	   objects,
    LwM2M_Block1_Handling  block1Handling,
    LwM2M_Device_State     state
  }
  
  ///////////////////////////////////////////////////////////
  //  Enum: LwM2M_Device_State
  //
  //  Purpose:
  //    States of a <LwM2M_Device> simulated LWM2M device
  //
  //  Elements:
  //    - NOT_REGISTERED
  //    - REGISTERED
  ///////////////////////////////////////////////////////////
  type enumerated LwM2M_Device_State
  {
    NOT_REGISTERED,
    REGISTERED,
    BOOTSTRAPPING
  }
  
  ///////////////////////////////////////////////////////////
  //  Enum: LwM2M_Block1_Handling
  //
  //  Purpose:
  //    Block1 handling strategy of a <LwM2M_Device> simulated LWM2M device
  //
  //  Elements:
  //    - STATELESS
  //    - ATOMIC
  ///////////////////////////////////////////////////////////
  type enumerated LwM2M_Block1_Handling
  {
    STATELESS,
    ATOMIC
  }
  
  const LwM2M_Device c_LwM2M_Device_init :=
  {
    registeredLocation := {},
    objects := c_LwM2M_ObjectDB_init,
    block1Handling := STATELESS,
    state := NOT_REGISTERED
  }
  
  ///////////////////////////////////////////////////////////
  //  Type: LwM2M_Device_List
  //
  //  Purpose:
  //    List of <LwM2M_Device>
  ///////////////////////////////////////////////////////////
  type record of LwM2M_Device LwM2M_Device_List;
  
 /*****************************************************************
   @startuml EPTF_LwM2M_LGen_Definitions.LwM2M_Device_DB.jpg
     class LwM2M_Device_DB {
       EPTF_FreeBusyQueue    queue
       LwM2M_Device_List data
       integer hashRef
       f_EPTF_LwM2M_DeviceDB_init()
       f_EPTF_LwM2M_DeviceDB_add(in LwM2M_Device p_device)
       f_EPTF_LwM2M_DeviceDB_remove(in integer p_idx)
       f_EPTF_LwM2M_DeviceDB_setLocationKey(in Location p_location, in integer p_idx)
       f_EPTF_LwM2M_DeviceDB_locationHash(in Location p_location)
       f_EPTF_LwM2M_DeviceDB_cleanUp()
     }
   @enduml
  ******************************************************************/
 ///////////////////////////////////////////////////////////
  //  Type: LwM2M_Device_DB
  //
  //  Purpose:
  //    Storing <LwM2M_Device> instances
  //
  //  Class:
  //    (see EPTF_LwM2M_LGen_Definitions.LwM2M_Device_DB.jpg)
  //
  //  Elements:
  //    queue  - <EPTF_FreeBusyQueue> - FBQ for the stored elements
  //    data  - <LwM2M_Device_List> - elements
  //    hashFref - *integer* - hashmap id used for looking up devices
  //
  //  Related Functions:
  //    - <f_EPTF_LwM2M_DeviceDB_init> ()
  //    - <f_EPTF_LwM2M_DeviceDB_add> (in <LwM2M_Device> p_device)
  //    - <f_EPTF_LwM2M_DeviceDB_remove> (in *integer* p_idx)
  //    - <f_EPTF_LwM2M_DeviceDB_setLocationKey> (in <Location> p_location, in *integer* p_idx)
  //    - <f_EPTF_LwM2M_DeviceDB_locationHash> (in <Location> p_location)
  //    - <f_EPTF_LwM2M_DeviceDB_cleanUp> ()
  ///////////////////////////////////////////////////////////
  type record LwM2M_Device_DB 
  {
    EPTF_FreeBusyQueue  queue, 
    LwM2M_Device_List 	data,
    integer             hashRef
  }  
  
  ///////////////////////////////////////////////////////////
  //  Type: LwM2M_Template
  //
  //  Purpose:
  //    Grouping a <LWM2M_PDU> with an id so that the message can be loaded from an FSM later by using the id
  //
  //  Elements:
  //    id  - *charstring* - identifier
  //    msg  - <LWM2M_PDU> - LWM2M PDU
  ///////////////////////////////////////////////////////////
  type record LwM2M_Template
  {
    charstring id,
    LWM2M_PDU msg
  }

  ///////////////////////////////////////////////////////////
  //  Type: LwM2M_Template_List
  //
  //  Purpose:
  //    List of <LwM2M_Template>
  ///////////////////////////////////////////////////////////
  type record of LwM2M_Template LwM2M_Template_List;
  
 /*****************************************************************
   @startuml EPTF_LwM2M_LGen_Definitions.LwM2M_Template_DB.jpg
     class LwM2M_Template_DB {
       EPTF_FreeBusyQueue    queue
       LwM2M_Template_List data
       integer hashRef
       f_EPTF_LwM2M_TemplateDB_init()
       f_EPTF_LwM2M_TemplateDB_add(in LwM2M_Template p_template)
       f_EPTF_LwM2M_TemplateDB_lookUp(in charstring p_id)
       f_EPTF_LwM2M_TemplateDB_get(in integer p_idx, inout LWM2M_PDU p_pdu)
       f_EPTF_LwM2M_TemplateDB_cleanUp()
     }
   @enduml
  ******************************************************************/
  ///////////////////////////////////////////////////////////
  //  Type: LwM2M_Template_DB
  //
  //  Purpose:
  //    Storing <LwM2M_Template> instances
  //
  //  Class:
  //    (see EPTF_LwM2M_LGen_Definitions.LwM2M_Template_DB.jpg)
  //
  //  Elements:
  //    data  - <LwM2M_Template_List> - elements
  //
  //  Related Functions:
  //    - <f_EPTF_LwM2M_templateDB_init> ()
  //    - <f_EPTF_LwM2M_templateDB_add> (in <LwM2M_Template> p_template)
  //    - <f_EPTF_LwM2M_templateDB_lookUp> (in *charstring* p_id)
  //    - <f_EPTF_LwM2M_templateDB_get> (in *integer* p_idx, inout <LWM2M_PDU> p_pdu)
  //    - <f_EPTF_LwM2M_templateDB_cleanUp> ()
  ///////////////////////////////////////////////////////////
  type record LwM2M_Template_DB
  {
    LwM2M_Template_List data,
    integer hashRef
  }  

  ///////////////////////////////////////////////////////////
  //  Type: LwM2M_StepCtx
  //
  //  Purpose:
  //    Stores the most important pointers that are used from a test steps
  //
  //  Elements:
  //    eIdx  - *integer* - entity index
  //    fsmIdx - *integer* - fsm index
  //    eCtxIdx - *integer* - entity context index <LwM2M_EntityCtx> in *v_LwM2M_EntityCtxDB*
  //    deviceIdx - *integer* - device instance index <LwM2M_Device> in *v_LwM2M_DeviceDB*
  ///////////////////////////////////////////////////////////  
  type record LwM2M_StepCtx
  {
    integer eIdx,
    integer fsmIdx,
    integer eCtxIdx,
    integer deviceIdx
  }

  const LwM2M_StepCtx c_LwM2M_StepCtx_empty :=
  {
    eIdx := -1,
    fsmIdx := -1,
    eCtxIdx := -1,
    deviceIdx := -1
  }

  /*****************************************************************
   @startuml EPTF_LwM2M_LGen_Definitions.EPTF_LwM2M_LGen_CT.jpg
     class EPTF_LwM2M_LGen_CT {
       boolean v_LwM2M_initialized
       integer v_LwM2M_bIdx
       integer v_LwM2M_loggingMaskId
       LwM2M_ObjectSpecificationDB v_LwM2M_ObjectSpecificationDB
       LwM2M_EntityCtx_DB v_LwM2M_EntityCtxDB
       LwM2M_Device_DB v_LwM2M_DeviceDB
       LwM2M_Template_DB v_LwM2M_templateDB
       LwM2M_StepCtx v_LwM2M_ctx
       EPTF_LwM2M_PDU v_LwM2M_msgToProcess
       EPTF_LwM2M_PDU v_LwM2M_msgToSend
       EPTF_LwM2M_Event v_LwM2M_eventToProcess
       f_EPTF_LwM2M_LGen_init(in charstring pl_name)
       f_LwM2M_cleanUp()
       f_LwM2M_eCtxBind(in integer pl_eIdx)
       f_LwM2M_eCtxUnbind(in integer pl_eIdx)
       f_LwM2M_eCtxReset(in integer pl_eIdx)
       f_EPTF_LwM2M_Logging_VERBOSE(in @lazy charstring pl_message)
       f_EPTF_LwM2M_Logging_DEBUG(in @lazy charstring pl_message)
       f_EPTF_LwM2M_Logging_WARNING(in @lazy charstring pl_message)
       f_EPTF_LwM2M_Logging_ERROR(in @lazy charstring pl_message)
       f_EPTF_LwM2M_LGen_receiveMessage(in EPTF_LwM2M_PDU pl_message)
       f_EPTF_LwM2M_LGen_receiveEvent(in EPTF_LwM2M_Event pl_event)
       f_EPTF_LwM2M_declareEvents()
       f_EPTF_LwM2M_declareSteps()
       f_EPTF_LwM2M_setStepCtx(in EPTF_LGenBase_TestStepArgs pl_ptr, inout LwM2M_StepCtx p_ctx)
       f_EPTF_LwM2M_setCtx(in integer p_eIdx, in integer p_fsmIdx, inout LwM2M_StepCtx p_ctx)
       f_EPTF_LwM2M_hasDevice(in LwM2M_StepCtx p_ctx)
       f_EPTF_LwM2M_stack_fromApp(inout EPTF_LwM2M_PDU p_pdu, in LwM2M_StepCtx p_ctx)
       f_EPTF_LwM2M_stack_fromEnv(in EPTF_LwM2M_PDU p_pdu)
       f_EPTF_LwM2M_dispatchEventsForPDU(in LWM2M_PDU pl_pdu, in integer pl_eIdx, in integer pl_fsmCtx, in EPTF_IntegerList pl_reportedArgs)
       f_EPTF_LwM2M_dispatchEvent(in integer pl_eventIdx, in integer pl_eIdx, in integer pl_fsmCtx, in EPTF_IntegerList pl_reportedArgs)
     }
   @enduml
  *****************************************************************/
  ///////////////////////////////////////////////////////////
  // Type: EPTF_LwM2M_LGen_CT
  //
  // Purpose:
  //   LWM2M load generator component
  //
  // Class:
  //   (see EPTF_LwM2M_LGen_Definitions.EPTF_LwM2M_LGen_CT.jpg)
  //
  // Extensions:
  //  - <EPTF_LwM2M_Transport_User_CT>
  //  - <EPTF_LGenBase_CT>
  //  - <EPTF_Logging_CT>
  //
  // Ports:
  //   -
  //
  // Timers:
  //   -
  //
  // Variables:
  //   v_LwM2M_initialized  - *boolean* - Flag to indicate that if init function was already called
  //   v_LwM2M_bIdx  - *integer* - Name of the LWM2M LGen component
  //   v_LwM2M_loggingMaskId - *integer* - logging mask id
  //
  //   v_LwM2M_ctx - <LwM2M_StepCtx> - collection of the most important pointers
  //
  //   v_LwM2M_msgToProcess - <EPTF_LwM2M_PDU> - message from the transport layer to process
  //   v_LwM2M_msgToSend - <EPTF_LwM2M_PDU> - message to send to the transport layer
  //   v_LwM2M_eventToProcess - <EPTF_LwM2M_Event> - incoming event from the transport layer to process
  // 
  // Instance databases:
  //   v_LwM2M_templateDB - <LwM2M_Template_DB> - template database <LwM2M_Template>
  //   v_LwM2M_EntityCtxDB - <LwM2M_EntityCtx_DB> - database of entity contexts <LwM2M_EntityCtx>
  //   v_LwM2M_DeviceDB - <LwM2M_Device_DB> - database of <LwM2M_Device> instances
  //   v_LwM2M_ObjectSpecificationDB - <LwM2M_ObjectSpecificationDB> - object specification database <LwM2M_ObjectSpecification>
  //
  // Related Functions:
  //   - <f_EPTF_LwM2M_LGen_init> (in *charstring* pl_name)
  //   - <f_LwM2M_cleanUp> ()
  //   - <f_LwM2M_eCtxBind> (in *integer* pl_eIdx)
  //   - <f_LwM2M_eCtxUnbind> (in *integer* pl_eIdx)
  //   - <f_LwM2M_eCtxReset> (in *integer* pl_eIdx)
  //   - <f_EPTF_LwM2M_Logging_VERBOSE> (in @lazy *charstring* pl_message)
  //   - <f_EPTF_LwM2M_Logging_DEBUG> (in @lazy *charstring* pl_message)
  //   - <f_EPTF_LwM2M_Logging_WARNING> (in @lazy *charstring* pl_message)
  //   - <f_EPTF_LwM2M_Logging_ERROR> (in @lazy *charstring* pl_message)
  //   - <f_EPTF_LwM2M_LGen_receiveMessage> (in <EPTF_LwM2M_PDU> pl_message)
  //   - <f_EPTF_LwM2M_LGen_receiveEvent> (in <EPTF_LwM2M_Event> pl_event)
  //   - <f_EPTF_LwM2M_declareEvents> ()
  //   - <f_EPTF_LwM2M_declareSteps> ()
  //   - <f_EPTF_LwM2M_setStepCtx> (in <EPTF_LGenBase_TestStepArgs> pl_ptr, inout <LwM2M_StepCtx> p_ctx)
  //   - <f_EPTF_LwM2M_setCtx> (in *integer* p_eIdx, in *integer* p_fsmIdx, inout <LwM2M_StepCtx> p_ctx)
  //   - <f_EPTF_LwM2M_hasDevice> (in <LwM2M_StepCtx> p_ctx)
  //   - <f_EPTF_LwM2M_stack_fromApp> (inout <EPTF_LwM2M_PDU> p_pdu, in <LwM2M_StepCtx> p_ctx)
  //   - <f_EPTF_LwM2M_stack_fromEnv> (in <EPTF_LwM2M_PDU> p_pdu)
  //   - <f_EPTF_LwM2M_dispatchEventsForPDU> (in <LWM2M_PDU> pl_pdu, in *integer* pl_eIdx, in *integer* pl_fsmCtx, in <EPTF_IntegerList> pl_reportedArgs)
  //   - <f_EPTF_LwM2M_dispatchEvent>(in *integer* pl_eventIdx, in *integer* pl_eIdx, in *integer* pl_fsmCtx, in <EPTF_IntegerList> pl_reportedArgs)
  ///////////////////////////////////////////////////////////
  type component EPTF_LwM2M_LGen_CT extends EPTF_LwM2M_Transport_User_CT, EPTF_LGenBase_CT, EPTF_Logging_CT
  {
    var boolean v_LwM2M_initialized := false;

    var integer v_LwM2M_bIdx;

    var integer v_LwM2M_loggingMaskId := -1;

    var LwM2M_ObjectSpecificationDB v_LwM2M_ObjectSpecificationDB;
    var LwM2M_EntityCtx_DB   v_LwM2M_EntityCtxDB;
    var LwM2M_Device_DB   	 v_LwM2M_DeviceDB;
    var LwM2M_Template_DB    v_LwM2M_templateDB := {};

    var LwM2M_StepCtx v_LwM2M_ctx := c_LwM2M_StepCtx_empty;

    var EPTF_LwM2M_PDU   v_LwM2M_msgToProcess;
    var EPTF_LwM2M_PDU   v_LwM2M_msgToSend;
    var EPTF_LwM2M_Event v_LwM2M_eventToProcess;

    var EPTF_LwM2M_LGen_Statistics v_LwM2M_stats := c_EPTF_LwM2M_LGen_Statistics_empty;
  }
  
  ///////////////////////////////////////////////////////////
  //  Type: EPTF_LwM2M_LGen_Statistics
  //
  //  Purpose:
  //    Storing counters for load generator related statistics
  //
  //  Elements:
  //    incoming - <EPTF_COAP_Message_Statistics> - statistics of incoming messages
  //    outgoing - <EPTF_COAP_Message_Statistics> - statistics of outgoing messages
  ///////////////////////////////////////////////////////////  
  type record EPTF_LwM2M_LGen_Statistics
  {
    EPTF_LwM2M_Message_Statistics incoming,
    EPTF_LwM2M_Message_Statistics outgoing
  }

  const EPTF_LwM2M_LGen_Statistics c_EPTF_LwM2M_LGen_Statistics_empty :=
  {
    incoming := c_EPTF_LwM2M_Message_Statistics_empty,
    outgoing := c_EPTF_LwM2M_Message_Statistics_empty
  }

  ///////////////////////////////////////////////////////////
  //  Type: EPTF_LwM2M_Message_Statistics
  //
  //  Purpose:
  //    Storing counters for message related statistics
  //
  //  Elements:
  //    noRegister  - *integer* - number of Register requests
  //    noUpdate - *integer* - number of Update request
  //    noDeregister - *integer* - number of Deregister request
  //    noNotification - *integer* - number of Notifications
  //    noRead - *integer* - number of Read requests
  //    noWrite - *integer* - number of Write requests
  //    noExecute - *integer* - number of Execute requests
  //    noCreate - *integer* - number of Create requests
  //    noDelete - *integer* - number of Delete requests
  //    noPosResp - *integer* - number of positive (2.xx) repsonses
  //    noNegResp - *integer* - number of negative (3.xx - 6.xx) repsonses
  /////////////////////////////////////////////////////////// 
  type record EPTF_LwM2M_Message_Statistics
  {
    integer noRegister,
    integer noUpdate,
    integer noDeregister,
    integer noNotification,
    integer noRead,
    integer noWrite,
    integer noExecute,
    integer noCreate,
    integer noDelete,
    integer noPosResp,
    integer noNegResp
  }

  const EPTF_LwM2M_Message_Statistics c_EPTF_LwM2M_Message_Statistics_empty :=
  {
    noRegister := 0,
    noUpdate := 0,
    noDeregister := 0,
    noNotification := 0,
    noRead := 0,
    noWrite := 0,
    noExecute := 0,
    noCreate := 0,
    noDelete := 0,
    noPosResp := 0,
    noNegResp := 0
  }
  
  // FSM AppData
  
  const integer c_LwM2M_AppData_deviceIdx := 0;
  
  // Events

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventIdx_Register
  //
  //  Purpose:
  //    Integer constant for the LWM2M Register request event
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_eventIdx_Register := 0;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventName_Register
  //
  //  Purpose:
  //    Charstring constant for the LWM2M Register request event
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_eventName_Register := "LWM2M req: Register";

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventIdx_Update
  //
  //  Purpose:
  //    Integer constant for the LWM2M Update request event
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_eventIdx_Update := 1;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventName_Update
  //
  //  Purpose:
  //    Charstring constant for the LWM2M Update request event
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_eventName_Update := "LWM2M req: Update";

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventIdx_Deregister
  //
  //  Purpose:
  //    Integer constant for the LWM2M Deregister request event
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_eventIdx_Deregister := 2;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventName_Deregister
  //
  //  Purpose:
  //    Charstring constant for the LWM2M Deregister request event
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_eventName_Deregister := "LWM2M req: Deregister";
  
  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventIdx_Read
  //
  //  Purpose:
  //    Integer constant for the LWM2M Read request event
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_eventIdx_Read := 3;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventName_Read
  //
  //  Purpose:
  //    Charstring constant for the LWM2M Read request event
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_eventName_Read := "LWM2M req: Read";
  
  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventIdx_Write
  //
  //  Purpose:
  //    Integer constant for the LWM2M Write request event
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_eventIdx_Write := 4;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventName_Write
  //
  //  Purpose:
  //    Charstring constant for the LWM2M Write request event
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_eventName_Write := "LWM2M req: Write";
  
  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventIdx_Execute
  //
  //  Purpose:
  //    Integer constant for the LWM2M Execute request event
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_eventIdx_Execute := 5;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventName_Execute
  //
  //  Purpose:
  //    Charstring constant for the LWM2M Execute request event
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_eventName_Execute := "LWM2M req: Execute";
  
  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventIdx_Create
  //
  //  Purpose:
  //    Integer constant for the LWM2M Create request event
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_eventIdx_Create := 6;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventName_Create
  //
  //  Purpose:
  //    Charstring constant for the LWM2M Create request event
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_eventName_Create := "LWM2M req: Create";
  
  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventIdx_Delete
  //
  //  Purpose:
  //    Integer constant for the LWM2M Delete request event
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_eventIdx_Delete := 7;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventName_Delete
  //
  //  Purpose:
  //    Charstring constant for the LWM2M Delete request event
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_eventName_Delete := "LWM2M req: Delete";
  
  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventIdx_Observe
  //
  //  Purpose:
  //    Integer constant for the LWM2M Observe request event
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_eventIdx_Observe := 8;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventName_Observe
  //
  //  Purpose:
  //    Charstring constant for the LWM2M Observe request event
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_eventName_Observe := "LWM2M req: Observe";
  

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventIdx_WriteFWUri
  //
  //  Purpose:
  //    Integer constant for the LWM2M WriteFWUri request event
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_eventIdx_WriteFWUri := 9;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventName_WriteFWUri
  //
  //  Purpose:
  //    Charstring constant for the LWM2M WriteFWUri request event
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_eventName_WriteFWUri := "LWM2M req: WriteFWUri";
  

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventIdx_WriteFWPackage
  //
  //  Purpose:
  //    Integer constant for the LWM2M WriteFWPackage request event
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_eventIdx_WriteFWPackage := 10;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventName_WriteFWPackage
  //
  //  Purpose:
  //    Charstring constant for the LWM2M WriteFWPackage request event
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_eventName_WriteFWPackage := "LWM2M req: WriteFWPackage";  

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventIdx_ExecuteFWUpdate
  //
  //  Purpose:
  //    Integer constant for the LWM2M ExecuteFWUpdate request event
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_eventIdx_ExecuteFWUpdate := 11;


  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventName_ExecuteFWUpdate
  //
  //  Purpose:
  //    Charstring constant for the LWM2M ExecuteFWUpdate request event
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_eventName_ExecuteFWUpdate := "LWM2M req: ExecuteFWUpdate";

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventIdx_BS_Delete
  //
  //  Purpose:
  //    Integer constant for the LWM2M BS_Delete request event
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_eventIdx_BS_Delete := 12;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventName_BS_Delete
  //
  //  Purpose:
  //    Charstring constant for the LWM2M BS_Delete request event
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_eventName_BS_Delete := "LWM2M req: BS_Delete";

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventIdx_BS_Finish
  //
  //  Purpose:
  //    Integer constant for the LWM2M BS_Finish request event
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_eventIdx_BS_Finish := 13;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventName_BS_Finish
  //
  //  Purpose:
  //    Charstring constant for the LWM2M BS_Finish request event
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_eventName_BS_Finish := "LWM2M req: BS_Finish";

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventIdx_BS_Discover
  //
  //  Purpose:
  //    Integer constant for the LWM2M BS_Discover request event
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_eventIdx_BS_Discover := 14;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventName_BS_Discover
  //
  //  Purpose:
  //    Charstring constant for the LWM2M BS_Discover request event
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_eventName_BS_Discover := "LWM2M req: BS_Discover";


  template charstring c_LwM2M_eventName(in integer p_code) := "LWM2M rsp: "&int2str(p_code);

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventIdx_1xx
  //
  //  Purpose:
  //    Integer constant for the LWM2M 1xx reponse event
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_eventIdx_1xx := 700;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventName_1xx
  //
  //  Purpose:
  //    Charstring constant for the LWM2M 1xx response event
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_eventName_1xx := "LWM2M rsp: 1xx";

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventIdx_2xx
  //
  //  Purpose:
  //    Integer constant for the LWM2M 2xx reponse event
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_eventIdx_2xx := 701;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventName_2xx
  //
  //  Purpose:
  //    Charstring constant for the LWM2M 2xx response event
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_eventName_2xx := "LWM2M rsp: 2xx";

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventIdx_3xx
  //
  //  Purpose:
  //    Integer constant for the LWM2M 3xx reponse event
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_eventIdx_3xx := 702;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventName_3xx
  //
  //  Purpose:
  //    Charstring constant for the LWM2M 3xx response event
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_eventName_3xx := "LWM2M rsp: 3xx";

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventIdx_4xx
  //
  //  Purpose:
  //    Integer constant for the LWM2M 4xx reponse event
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_eventIdx_4xx := 703;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventName_4xx
  //
  //  Purpose:
  //    Charstring constant for the LWM2M 4xx response event
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_eventName_4xx := "LWM2M rsp: 4xx";

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventIdx_5xx
  //
  //  Purpose:
  //    Integer constant for the LWM2M 5xx reponse event
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_eventIdx_5xx := 704;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventName_5xx
  //
  //  Purpose:
  //    Charstring constant for the LWM2M 5xx response event
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_eventName_5xx := "LWM2M rsp: 5xx";

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventIdx_6xx
  //
  //  Purpose:
  //    Integer constant for the LWM2M 6xx reponse event
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_eventIdx_6xx := 705;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventName_6xx
  //
  //  Purpose:
  //    Charstring constant for the LWM2M 6xx response event
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_eventName_6xx := "LWM2M rsp: 6xx";

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventIdx_3xxto6xx
  //
  //  Purpose:
  //    Integer constant for the LWM2M 6xx reponse event
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_eventIdx_3xxto6xx := 706;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventName_3xxto6xx
  //
  //  Purpose:
  //    Charstring constant for the LWM2M 6xx response event
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_eventName_3xxto6xx := "LWM2M rsp: 3xxto6xx";
  
  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventIdx_resourceNotObservedIndication
  //
  //  Purpose:
  //    Integer constant for the resource not observed any more indication
  //    This event occurs after all subscribers unsubscribed from a resource
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_eventIdx_resourceNotObservedIndication := 707;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventName_resourceNotObservedIndication
  //
  //  Purpose:
  //    Charstring constant for the resource not observed any more indication
  //    This event occurs after all subscribers unsubscribed from a resource
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_eventName_resourceNotObservedIndication := "LWM2M ind: resource not observed";
  
  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventIdx_atomicBlock1Finished
  //
  //  Purpose:
  //    Integer constant for indicating that a block1 transfer was finished
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_eventIdx_atomicBlock1Finished := 708;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_eventName_atomicBlock1Finished
  //
  //  Purpose:
  //    Charstring constant for indicating that a block1 transfer was finished
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_eventName_atomicBlock1Finished := "LWM2M ind: atomic Block1 transfer finished";
  
  // Steps

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepIdx_loadTemplate_byIntIdx
  //
  //  Purpose:
  //    Integer constant for the LWM2M loadTemplate (param: integer index) test step
  //
  //  Related Function:
  //    - <f_LwM2M_step_loadTemplate_byIntIdx>
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_stepIdx_loadTemplate_byIntIdx := 0;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepName_loadTemplate_byIntIdx
  //
  //  Purpose:
  //    Charstring constant for the LWM2M loadTemplate (param: integer index) test step
  //
  //  Related Function:
  //    - <f_LwM2M_step_loadTemplate_byIntIdx>
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_stepName_loadTemplate_byIntIdx := "LWM2M Applib: loadTemplate_byIntIdx";

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepIdx_send
  //
  //  Purpose:
  //    Integer constant for the LWM2M send test step
  //
  //  Related Function:
  //    - <f_LwM2M_step_send>
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_stepIdx_send := 1;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepName_send
  //
  //  Purpose:
  //    Charstring constant for the LWM2M send test step
  //
  //  Related Function:
  //    - <f_LwM2M_step_send>
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_stepName_send := "LWM2M Applib: send";
  
  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepIdx_createDevice
  //
  //  Purpose:
  //    Integer constant for the LWM2M create device test step
  //
  //  Related Function:
  //    - <f_LwM2M_step_createDevice>
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_stepIdx_createDevice := 2;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepName_createDevice
  //
  //  Purpose:
  //    Charstring constant for the LWM2M create device test step
  //
  //  Related Function:
  //    - <f_LwM2M_step_createDevice>
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_stepName_createDevice := "LWM2M Applib: createDevice";
  
  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepIdx_cleanupDevice
  //
  //  Purpose:
  //    Integer constant for the LWM2M clean up device test step
  //
  //  Related Function:
  //    - <f_LwM2M_step_cleanupDevice>
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_stepIdx_cleanupDevice := 3;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepName_cleanupDevice
  //
  //  Purpose:
  //    Charstring constant for the LWM2M clean up device test step
  //
  //  Related Function:
  //    - <f_LwM2M_step_cleanupDevice>
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_stepName_cleanupDevice := "LWM2M Applib: cleanupDevice";
  
  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepIdx_logDevice
  //
  //  Purpose:
  //    Integer constant for the LWM2M log device test step
  //
  //  Related Function:
  //    - <f_LwM2M_step_logDevice>
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_stepIdx_logDevice := 4;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepName_logDevice
  //
  //  Purpose:
  //    Charstring constant for the LWM2M log device test step
  //
  //  Related Function:
  //    - <f_LwM2M_step_logDevice>
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_stepName_logDevice := "LWM2M Applib: logDevice";
  
  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepIdx_createObject
  //
  //  Purpose:
  //    Integer constant for the LWM2M create object test step
  //
  //  Related Function:
  //    - <f_LwM2M_step_createObject>
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_stepIdx_createObject := 5;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepName_createObject
  //
  //  Purpose:
  //    Charstring constant for the LWM2M create object test step
  //
  //  Related Function:
  //    - <f_LwM2M_step_createObject>
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_stepName_createObject := "LWM2M Applib: createObject";
  
  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepIdx_createObjectInstance
  //
  //  Purpose:
  //    Integer constant for the LWM2M create object instance test step
  //
  //  Related Function:
  //    - <f_LwM2M_step_createObjectInstance>
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_stepIdx_createObjectInstance := 6;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepName_createObjectInstance
  //
  //  Purpose:
  //    Charstring constant for the LWM2M create object instance test step
  //
  //  Related Function:
  //    - <f_LwM2M_step_createObjectInstance>
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_stepName_createObjectInstance := "LWM2M Applib: createObjectInstance";
  
  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepIdx_handleReadRequest
  //
  //  Purpose:
  //    Integer constant for the LWM2M handle READ request test step
  //
  //  Related Function:
  //    - <f_LwM2M_step_handleReadRequest>
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_stepIdx_handleReadRequest := 7;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepName_handleReadRequest
  //
  //  Purpose:
  //    Charstring constant for the LWM2M handle READ request test step
  //
  //  Related Function:
  //    - <f_LwM2M_step_handleReadRequest>
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_stepName_handleReadRequest := "LWM2M Applib: handleReadRequest";
  
  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepIdx_handleWriteRequest
  //
  //  Purpose:
  //    Integer constant for the LWM2M handle WRITE request test step
  //
  //  Related Function:
  //    - <f_LwM2M_step_handleWriteRequest>
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_stepIdx_handleWriteRequest := 8;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepName_handleWriteRequest
  //
  //  Purpose:
  //    Charstring constant for the LWM2M handle WRITE request test step
  //
  //  Related Function:
  //    - <f_LwM2M_step_handleWriteRequest>
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_stepName_handleWriteRequest := "LWM2M Applib: handleWriteRequest";
  
  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepIdx_handleExecuteRequest
  //
  //  Purpose:
  //    Integer constant for the LWM2M handle EXECUTE request test step
  //
  //  Related Function:
  //    - <f_LwM2M_step_handleExecuteRequest>
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_stepIdx_handleExecuteRequest := 9;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepName_handleExecuteRequest
  //
  //  Purpose:
  //    Charstring constant for the LWM2M handle EXECUTE request test step
  //
  //  Related Function:
  //    - <f_LwM2M_step_handleExecuteRequest>
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_stepName_handleExecuteRequest := "LWM2M Applib: handleExecuteRequest";
      
  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepIdx_loadTemplate_byStringId
  //
  //  Purpose:
  //    Integer constant for the LWM2M load template (param: string id of the template) test step
  //
  //  Related Function:
  //    - <f_LwM2M_step_loadTemplate_byStringId>
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_stepIdx_loadTemplate_byStringId := 10;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepName_loadTemplate_byStringId
  //
  //  Purpose:
  //    Charstring constant for the LWM2M load template (param: string id of the template) test step
  //
  //  Related Function:
  //    - <f_LwM2M_step_loadTemplate_byStringId>
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_stepName_loadTemplate_byStringId := "LWM2M Applib: loadTemplate_byStringId";
  
  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepIdx_sendNotificationForObservedResources
  //
  //  Purpose:
  //    Integer constant for the LWM2M send notification for observed resources test step
  //
  //  Related Function:
  //    - <c_LwM2M_stepName_sendNotificationForObservedResources>
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_stepIdx_sendNotificationForObservedResources := 11;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepName_sendNotificationForObservedResources
  //
  //  Purpose:
  //    Charstring constant for the LWM2M send notification for observed resources test step
  //
  //  Related Function:
  //    - <c_LwM2M_stepName_sendNotificationForObservedResources>
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_stepName_sendNotificationForObservedResources := "LWM2M Applib: sendNotificationForObservedResources";
  
    ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepName_setFirmwareUpdateState
  //
  //  Purpose:
  //    Integer constant for the LWM2M set firmware update state test step
  //
  //  Related Function:
  //    - <c_LwM2M_stepName_setFirmwareUpdateState>
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_stepIdx_setFirmwareUpdateState := 12;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepName_setFirmwareUpdateState
  //
  //  Purpose:
  //    Charstring constant for the LWM2M set firmware update state test step
  //
  //  Related Function:
  //    - <c_LwM2M_stepName_setFirmwareUpdateState>
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_stepName_setFirmwareUpdateState := "LWM2M Applib: setFirmwareUpdateState";
  
  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepIdx_setFirmwareUpdateResult
  //
  //  Purpose:
  //    Integer constant for the LWM2M set firmware update result test step
  //
  //  Related Function:
  //    - <c_LwM2M_stepName_setFirmwareUpdateResult>
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_stepIdx_setFirmwareUpdateResult := 13;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepName_setFirmwareUpdateState
  //
  //  Purpose:
  //    Charstring constant for the LWM2M set furmware update result test step
  //
  //  Related Function:
  //    - <c_LwM2M_stepName_setFirmwareUpdateResult>
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_stepName_setFirmwareUpdateResult := "LWM2M Applib: setFirmwareUpdateResult";

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepIdx_setBootstrapState
  //
  //  Purpose:
  //    Integer constant for the  LWM2M set bootstrap state test step
  //
  //  Related Function:
  //    - <f_LwM2M_step_setBootstrapState>
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_stepIdx_setBootstrapState := 14;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepName_setBootstrapState
  //
  //  Purpose:
  //    Charstring constant for the LWM2M set bootstrap state test step
  //
  //  Related Function:
  //    - <f_LwM2M_step_setBootstrapState>
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_stepName_setBootstrapState := "LWM2M Applib: setBootstrapState";
  
  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepIdx_setNotRegisteredState
  //
  //  Purpose:
  //    Integer constant for the  LWM2M set not registered state test step
  //
  //  Related Function:
  //    - <f_LwM2M_step_setNotRegisteredState>
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_stepIdx_setNotRegisteredState := 15;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepName_setBootstrapState
  //
  //  Purpose:
  //    Charstring constant for the LWM2M set not registered state test step
  //
  //  Related Function:
  //    - <f_LwM2M_step_setNotRegisteredState>
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_stepName_setNotRegisteredState := "LWM2M Applib: setNotRegisteredState";
  
  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepIdx_setBlock1Handling_stateless
  //
  //  Purpose:
  //    Integer constant for the  LWM2M set block1 handling stateless test step
  //
  //  Related Function:
  //    - <f_LwM2M_step_setBlock1Handling_stateless>
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_stepIdx_setBlock1Handling_stateless := 16;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepName_setBlock1Handling_stateless
  //
  //  Purpose:
  //    Charstring constant for the LWM2M set block1 handling stateless test step
  //
  //  Related Function:
  //    - <f_LwM2M_step_setBlock1Handling_stateless>
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_stepName_setBlock1Handling_stateless := "LWM2M Applib: setBlock1Handling_stateless";
  
  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepIdx_setBlock1Handling_atomic
  //
  //  Purpose:
  //    Integer constant for the  LWM2M set block1 handling atomic test step
  //
  //  Related Function:
  //    - <f_LwM2M_step_setBlock1Handling_atomic>
  ///////////////////////////////////////////////////////////
  const integer c_LwM2M_stepIdx_setBlock1Handling_atomic := 17;

  ///////////////////////////////////////////////////////////
  //  const: c_LwM2M_stepName_setBlock1Handling_atomic
  //
  //  Purpose:
  //    Charstring constant for the LWM2M set block1 handling atomic test step
  //
  //  Related Function:
  //    - <f_LwM2M_step_setBlock1Handling_atomic>
  ///////////////////////////////////////////////////////////
  const charstring c_LwM2M_stepName_setBlock1Handling_atomic := "LWM2M Applib: setBlock1Handling_atomic";
  
  const integer c_LwM2M_stepParam_createObjectInstance_DoNotAddResources := 0;
}