| ///////////////////////////////////////////////////////////////////////////////
|
| // //
|
| // Copyright (c) 2000-2017 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 //
|
| ///////////////////////////////////////////////////////////////////////////////
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Module: EPTF_SimpleHello_LGen_Functions
|
| //
|
| // Purpose:
|
| // This module contains functions for SimpleHello LoadGen component.
|
| //
|
| // Module Parameters:
|
| // See in <EPTF_SimpleHello_LGen_Definitions>
|
| //
|
| // Module depends on:
|
| // <EPTF_CLL_Common_Definitions>
|
| // <EPTF_CLL_Base_Functions>
|
| // <EPTF_CLL_LGenBase_Definitions>
|
| // <EPTF_CLL_LGenBase_Functions>
|
| // <EPTF_CLL_LGenBase_ConfigFunctions>
|
| // <EPTF_CLL_LGenBase_EventHandlingFunctions>
|
| // <EPTF_CLL_LGenBase_TemplateFunctions>
|
| // <EPTF_SimpleHello_Definitions>
|
| // <EPTF_SimpleHello_LGen_Definitions>
|
| // <EPTF_SimpleHello_Transport_Definitions>
|
| // <EPTF_CLL_Variable_Functions>
|
| // <EPTF_CLL_Logging_Functions>
|
| // <EPTF_CLL_Logging_Definitions>
|
| //
|
| // Current Owner:
|
| // Attila Fulop (EFLOATT), Bence Molnar(EBENMOL)
|
| //
|
| // Last Review Date:
|
| // 2009-04-03
|
| //
|
| // Detailed Comments:
|
| // This module contains functions for SimpleHello LoadGen component.
|
| //
|
| ///////////////////////////////////////////////////////////////
|
| module EPTF_SimpleHello_LGen_Functions
|
| {
|
|
|
| //=========================================================================
|
| // Import Part
|
| //=========================================================================
|
| import from EPTF_CLL_Common_Definitions all;
|
| import from EPTF_CLL_Base_Functions all;
|
| import from EPTF_CLL_LGenBase_Definitions all;
|
| import from EPTF_CLL_LGenBase_Functions all;
|
| import from EPTF_CLL_LGenBase_ConfigFunctions all;
|
| import from EPTF_CLL_LGenBase_EventHandlingFunctions all;
|
| import from EPTF_CLL_LGenBase_TemplateFunctions all;
|
| import from EPTF_SimpleHello_Definitions all;
|
| import from EPTF_SimpleHello_LGen_Definitions all;
|
| import from EPTF_SimpleHello_Transport_Definitions all;
|
| import from EPTF_CLL_Variable_Functions all;
|
| import from EPTF_CLL_Logging_Functions all;
|
| import from EPTF_CLL_Logging_Definitions all;
|
|
|
| //=========================================================================
|
| // Functions - initialization
|
| //=========================================================================
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_SimpleHello_init
|
| //
|
| // Purpose:
|
| // initialize SimpleHello behaviour
|
| //
|
| // Parameters:
|
| // - pl_behavior - *in* - *charstring* - behaviour name
|
| // - pl_maxCount - *in* *integer* - number of maximal entities
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // -
|
| //
|
| ///////////////////////////////////////////////////////////
|
| function f_EPTF_SimpleHello_init(in charstring pl_behavior, in integer pl_maxCount)
|
| runs on EPTF_SimpleHello_LGen_CT
|
| {
|
| if (not v_EPTF_SimpleHello_LGen_initialized) {
|
| v_EPTF_SimpleHello_LGen_initialized := true;
|
| f_EPTF_Base_registerCleanup(refers(f_EPTF_SimpleHello_cleanup_CT));
|
|
|
| // Log masks for SimpleHello AppLib
|
| v_EPTF_SimpleHello_loggingMaskId :=
|
| f_EPTF_Logging_registerComponentMasks(
|
| tsp_EPTF_SimpleHello_loggingComponentMask,
|
| c_EPTF_SimpleHello_loggingEventClasses,
|
| EPTF_Logging_CLL);
|
|
|
| if (tsp_EPTF_SimpleHello_logEnabled)
|
| {
|
| f_EPTF_Logging_enableLocalMask(
|
| v_EPTF_SimpleHello_loggingMaskId,
|
| c_EPTF_SimpleHello_loggingClassIdx_Debug);
|
| }
|
| else
|
| {
|
| f_EPTF_Logging_disableLocalMask(
|
| v_EPTF_SimpleHello_loggingMaskId,
|
| c_EPTF_SimpleHello_loggingClassIdx_Debug);
|
| }
|
|
|
| v_EPTF_SimpleHello_contexts := {};
|
|
|
| vf_EPTF_SimpleHello_sendRequest := refers(f_EPTF_SimpleHello_defaultSendRequest);
|
| v_EPTF_SimpleHello_myBIdx := f_EPTF_LGenBase_declareBehaviorType(
|
| pl_behavior,
|
| pl_maxCount,
|
| refers(f_EPTF_SimpleHello_ResetEntity4Behavior),
|
| refers(f_EPTF_SimpleHello_BindEntity4Behavior),
|
| refers(f_EPTF_SimpleHello_UnbindEntity4Behavior)
|
| );
|
|
|
| f_EPTF_SimpleHello_initStats();
|
| if(
|
| //Steps
|
| // server steps
|
| c_EPTF_SimpleHello_stepIdx_sendSimple != f_EPTF_LGenBase_declareStep(pl_behavior, {c_EPTF_SimpleHello_stepName_sendSimple,refers(f_EPTF_SimpleHello_step_sendSimple)})//0
|
| or c_EPTF_SimpleHello_stepIdx_sendHello != f_EPTF_LGenBase_declareStep(pl_behavior, {c_EPTF_SimpleHello_stepName_sendHello,refers(f_EPTF_SimpleHello_step_sendHello)})//1
|
| or c_EPTF_SimpleHello_stepIdx_sendBye != f_EPTF_LGenBase_declareStep(pl_behavior, {c_EPTF_SimpleHello_stepName_sendBye,refers(f_EPTF_SimpleHello_step_sendBye)})//2
|
| or c_EPTF_SimpleHello_stepIdx_over != f_EPTF_LGenBase_declareStep(pl_behavior, {c_EPTF_SimpleHello_stepName_over,refers(f_EPTF_SimpleHello_step_over)})//3
|
| // client steps
|
| or c_EPTF_SimpleHello_stepIdx_sendAck_forSimple != f_EPTF_LGenBase_declareStep(pl_behavior, {c_EPTF_SimpleHello_stepName_sendAck_forSimple,refers(f_EPTF_SimpleHello_step_sendAck_forSimple)})//4
|
| or c_EPTF_SimpleHello_stepIdx_sendAck_forHello != f_EPTF_LGenBase_declareStep(pl_behavior, {c_EPTF_SimpleHello_stepName_sendAck_forHello,refers(f_EPTF_SimpleHello_step_sendAck_forHello)})//5
|
| or c_EPTF_SimpleHello_stepIdx_sendAck_forBye != f_EPTF_LGenBase_declareStep(pl_behavior, {c_EPTF_SimpleHello_stepName_sendAck_forBye,refers(f_EPTF_SimpleHello_step_sendAck_forBye)})//6
|
| /*
|
| or c_EPTF_SimpleHello_stepIdx_sendfoo != f_EPTF_LGenBase_declareStep(pl_behavior, {c_EPTF_SimpleHello_stepName_sendfoo,refers(f_EPTF_SimpleHello_step_sendfoo)}) //7
|
| */
|
| //Inputs
|
| or c_EPTF_SimpleHello_inputIdx_receivedSimple != f_EPTF_LGenBase_declareFsmEvent(c_EPTF_SimpleHello_behaviorType_server,c_EPTF_SimpleHello_inputName_receivedSimple)//0
|
| or c_EPTF_SimpleHello_inputIdx_receivedHello != f_EPTF_LGenBase_declareFsmEvent(c_EPTF_SimpleHello_behaviorType_server,c_EPTF_SimpleHello_inputName_receivedHello)//1
|
| or c_EPTF_SimpleHello_inputIdx_receivedBye != f_EPTF_LGenBase_declareFsmEvent(c_EPTF_SimpleHello_behaviorType_server,c_EPTF_SimpleHello_inputName_receivedBye)//2
|
| //Inputs for clients
|
| or c_EPTF_SimpleHello_inputIdx_receivedAck_forSimple != f_EPTF_LGenBase_declareFsmEvent(c_EPTF_SimpleHello_behaviorType_server,c_EPTF_SimpleHello_inputName_receivedAck_forSimple)//3
|
| or c_EPTF_SimpleHello_inputIdx_receivedAck_forHello != f_EPTF_LGenBase_declareFsmEvent(c_EPTF_SimpleHello_behaviorType_server,c_EPTF_SimpleHello_inputName_receivedAck_forHello)//4
|
| or c_EPTF_SimpleHello_inputIdx_receivedAck_forBye != f_EPTF_LGenBase_declareFsmEvent(c_EPTF_SimpleHello_behaviorType_server,c_EPTF_SimpleHello_inputName_receivedAck_forBye)//5
|
| ){
|
| f_EPTF_SimpleHello_loggingError(%definitionId&": Error in declareStep or declareFsmevent.");
|
| }
|
| var integer vl_fsmTableIdx := f_EPTF_LGenBase_declareIndexedCompactFsmTable( f_EPTF_SimpleHello_compactIndexedFsm_BasicIncomingCall());
|
|
|
| f_EPTF_SimpleHello_loggingDebug(%definitionId&": The Idx of the declared FSM table: "&int2str(vl_fsmTableIdx));
|
| f_EPTF_SimpleHello_loggingDebug(%definitionId&": The declared FSM table: "&log2str(v_LGenBase_fsmTables[vl_fsmTableIdx]));
|
|
|
| //Declare external template types
|
| v_EPTF_SimpleHello_templId_customRequest := f_EPTF_LGenBase_getExtTemplIdx(c_EPTF_SimpleHello_templName_CustomRequest);
|
| if( v_EPTF_SimpleHello_templId_customRequest <0) {
|
| f_EPTF_SimpleHello_loggingDebug(%definitionId&": No external template has been declared");
|
| } else {
|
| f_EPTF_SimpleHello_loggingDebug(%definitionId&": External template has been declared");
|
| v_EPTF_SimpleHello_templTypeId_customRequest := f_EPTF_LGenBase_declareTemplateType(
|
| {behaviourType:=pl_behavior, templateName:=c_EPTF_SimpleHello_templName_CustomRequest},
|
| {"senderId","msg"}, {} );
|
|
|
| v_EPTF_SimpleHello_setId_customRequest := f_EPTF_LGenBase_createTemplateSet();
|
|
|
| f_EPTF_SimpleHello_loggingDebug(%definitionId&": The external template indices of template: "&c_EPTF_SimpleHello_templName_CustomRequest&
|
| "\n setId: "&log2str(v_EPTF_SimpleHello_setId_customRequest)&
|
| "\n templTypeId: "&log2str(v_EPTF_SimpleHello_templTypeId_customRequest)&
|
| "\n extTemplId: "&log2str(v_EPTF_SimpleHello_templId_customRequest)
|
| );
|
| if(f_EPTF_LGenBase_assignExtTemplToTemplType(v_EPTF_SimpleHello_setId_customRequest, v_EPTF_SimpleHello_templTypeId_customRequest, v_EPTF_SimpleHello_templId_customRequest)<0){
|
| f_EPTF_SimpleHello_loggingError(%definitionId&": Error in external template assignment.");
|
| }
|
| }
|
|
|
| f_EPTF_SimpleHello_loggingDebug(%definitionId&": SimpleHello init Finished");
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_SimpleHello_compactIndexedFsm_BasicIncomingCall
|
| //
|
| // Purpose:
|
| // Sample Basic FSM table for SimpleHello
|
| //
|
| // Parameters:
|
| // -
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // This is a Sample FSM table can be rewritten at any time. The demo uses the FSM table in the config file instead of it.
|
| //
|
| ///////////////////////////////////////////////////////////
|
| function f_EPTF_SimpleHello_compactIndexedFsm_BasicIncomingCall()
|
| runs on EPTF_SimpleHello_LGen_CT return EPTF_LGenBase_IndexedCompactFsmTable
|
| {
|
| return {
|
| name := c_EPTF_SimpleHello_fsmName_basicSHCall,//c_A_fsmName_basicIngoingCall,
|
| stateList := {"idle","connected"},
|
| timerList := {},
|
| table := {
|
| {eventToListen := {v_EPTF_SimpleHello_myBIdx,c_EPTF_SimpleHello_inputIdx_receivedSimple,fsm},
|
| cellRow := {
|
| //state=idle
|
| {omit, omit,1}
|
| //state==connected
|
| ,{omit,omit,omit}
|
| }
|
| }
|
| }//table
|
| }//fsm
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_SimpleHello_cleanup_CT
|
| //
|
| // Purpose:
|
| // The SimpleHello AppLib cleanup function
|
| //
|
| // Parameters:
|
| // -
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // -
|
| //
|
| ///////////////////////////////////////////////////////////
|
| function f_EPTF_SimpleHello_cleanup_CT()
|
| runs on EPTF_SimpleHello_LGen_CT{
|
|
|
| if (not v_EPTF_SimpleHello_LGen_initialized) { return }
|
| v_EPTF_SimpleHello_LGen_initialized := false;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_SimpleHello_BindEntity4Behavior
|
| //
|
| // Purpose:
|
| // Function to bind entity for the behaviour
|
| //
|
| // Parameters:
|
| // pl_eIdx - *in* *integer* - entity index
|
| //
|
| // Return Value:
|
| // <EPTF_IntegerList> - behaviour integer list
|
| //
|
| // Errors:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // -
|
| //
|
| ///////////////////////////////////////////////////////////
|
| function f_EPTF_SimpleHello_BindEntity4Behavior(
|
| in integer pl_eIdx)
|
| runs on EPTF_SimpleHello_LGen_CT
|
| return EPTF_IntegerList
|
| {
|
| var integer vl_EPTF_SimpleHello_index := sizeof(v_EPTF_SimpleHello_contexts);
|
| v_EPTF_SimpleHello_contexts[vl_EPTF_SimpleHello_index] := {
|
| userId := -1,
|
| userName := "",
|
| sessionId := -1
|
| }
|
| return {vl_EPTF_SimpleHello_index};
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_SimpleHello_UnbindEntity4Behavior
|
| //
|
| // Purpose:
|
| // Function to unbind entity
|
| //
|
| // Parameters:
|
| // pl_eIdx - *in* *integer* - entity index
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // -
|
| //
|
| ///////////////////////////////////////////////////////////
|
| function f_EPTF_SimpleHello_UnbindEntity4Behavior(
|
| in integer pl_eIdx)
|
| runs on EPTF_SimpleHello_LGen_CT {
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_SimpleHello_ResetEntity4Behavior
|
| //
|
| // Purpose:
|
| // Function to reset entity
|
| //
|
| // Parameters:
|
| // pl_eIdx - *in* *integer* - entity index
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // -
|
| //
|
| ///////////////////////////////////////////////////////////
|
| function f_EPTF_SimpleHello_ResetEntity4Behavior(
|
| in integer pl_eIdx)
|
| runs on EPTF_SimpleHello_LGen_CT {
|
| var integer vl_EPTF_SimpleHello_myCtx := v_LGenBase_entities[pl_eIdx].bCtxList[v_EPTF_SimpleHello_myBIdx][0];
|
| v_EPTF_SimpleHello_contexts[vl_EPTF_SimpleHello_myCtx]:=
|
| {
|
| userId := -1,
|
| userName := "",
|
| sessionId := -1
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_SimpleHello_initStats
|
| //
|
| // Purpose:
|
| // Function to initialize SH statistics
|
| //
|
| // Parameters:
|
| // -
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // -
|
| //
|
| ///////////////////////////////////////////////////////////
|
| function f_EPTF_SimpleHello_initStats()
|
| runs on EPTF_SimpleHello_LGen_CT
|
| {
|
| v_EPTF_SimpleHello_statistics := {0, 0, 0, 0};
|
| v_EPTF_SimpleHello_statistics_keys := {0, 0, 0, 0};
|
|
|
| f_EPTF_Var_newIntRef(c_EPTF_SimpleHello_statName_nof_initiatedSessions,
|
| v_EPTF_SimpleHello_statistics.sessionsStarted,
|
| v_EPTF_SimpleHello_statistics_keys.sessionsStarted);
|
|
|
| f_EPTF_Var_newIntRef(c_EPTF_SimpleHello_statName_nof_acks,
|
| v_EPTF_SimpleHello_statistics.sessionsACK,
|
| v_EPTF_SimpleHello_statistics_keys.sessionsACK);
|
|
|
| f_EPTF_Var_newIntRef(c_EPTF_SimpleHello_statName_nof_nacks,
|
| v_EPTF_SimpleHello_statistics.sessionsNACK,
|
| v_EPTF_SimpleHello_statistics_keys.sessionsNACK);
|
|
|
| f_EPTF_Var_newIntRef(c_EPTF_SimpleHello_statName_nof_timeoutedSessions,
|
| v_EPTF_SimpleHello_statistics.sessionsTimeout,
|
| v_EPTF_SimpleHello_statistics_keys.sessionsTimeout);
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_SimpleHello_setSendRequestFunction
|
| //
|
| // Purpose:
|
| // set the sending function info for entity
|
| //
|
| // Parameters:
|
| // pl_sendFunction - *in* <f_EPTF_SimpleHello_messageProcess_FT> - sendRequest function
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // -
|
| //
|
| ///////////////////////////////////////////////////////////
|
| function f_EPTF_SimpleHello_setSendRequestFunction(in f_EPTF_SimpleHello_messageProcess_FT pl_sendFunction) runs on EPTF_SimpleHello_LGen_CT
|
| {
|
| vf_EPTF_SimpleHello_sendRequest := pl_sendFunction;
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_SimpleHello_defaultSendRequest
|
| //
|
| // Purpose:
|
| // This function is the default send request function
|
| //
|
| // Parameters:
|
| // pl_Message - *in* octetstring - the outgoing SH message
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // -
|
| //
|
| ///////////////////////////////////////////////////////////
|
| function f_EPTF_SimpleHello_defaultSendRequest(
|
| in octetstring pl_Message)
|
| runs on EPTF_SimpleHello_LGen_CT
|
| {
|
| f_EPTF_SimpleHello_loggingWarning(
|
| %definitionId&": "&
|
| "You should set your sender function with f_EPTF_SimpleHello_setSendRequestFunction");
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_SimpleHello_sendRequest
|
| //
|
| // Purpose:
|
| // calls the registered callback function
|
| //
|
| // Parameters:
|
| // pl_message - *in* *charstring* -message to send
|
| // pl_senderId - *in* *integer* - sender ID
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // -
|
| //
|
| ///////////////////////////////////////////////////////////
|
| function f_EPTF_SimpleHello_sendRequest(in charstring pl_message, in integer pl_senderId) runs on EPTF_SimpleHello_LGen_CT
|
| {
|
| f_EPTF_SimpleHello_loggingDebug(%definitionId&": sendRequest called");
|
| var PDU_SimpleHello_Request vl_request := {
|
| header := {
|
| 0.0,
|
| 0.0,
|
| 0.0
|
| },
|
| transId := 7,
|
| senderId := pl_senderId,
|
| msg :=pl_message,
|
| payload := omit //char2oct("This is something else than Hello!")
|
| } ;
|
| vf_EPTF_SimpleHello_sendRequest.apply(f_enc_SimpleHello_Request(vl_request));
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_SimpleHello_createRequest
|
| //
|
| // Purpose:
|
| // creates a request message from external template
|
| //
|
| // Parameters:
|
| // pl_ptr - *in* *integer* - the entity index
|
| // pl_ptr - *in* *charstring* - the type of the Request eg. Simple, Hello, Bye,
|
| // pl_msg - *out* *charstring* - the created request message
|
| //
|
| // Return Value:
|
| // *boolean* - the request message successfully created
|
| //
|
| // Errors:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // This function creates a request string from an external string template. This request string will be converted into an octetsring format
|
| // (octetsring format is the format of the encoded message) and will be sent out.
|
| // Two parameters will be changed "senderId" and "msg". These two parameters should be converted into octetstring format in order to fit into the
|
| // encoded octetstring.
|
| //
|
| ///////////////////////////////////////////////////////////
|
| function f_EPTF_SimpleHello_createRequest(
|
| in integer pl_eIdx,
|
| in charstring pl_requestType,
|
| out charstring pl_msg)
|
| runs on EPTF_SimpleHello_LGen_CT
|
| return boolean
|
| {
|
| f_EPTF_SimpleHello_loggingDebug(%definitionId&": creating Message from external template");
|
| pl_msg := "";
|
|
|
| if( v_EPTF_SimpleHello_templId_customRequest <0) {
|
| f_EPTF_SimpleHello_loggingDebug(%definitionId&": No external template has been declared");
|
| return false;
|
| }
|
| //converting "senderId"
|
| var octetstring vl_senderOctetId := int2oct(pl_eIdx,4);
|
| var octetstring vl_senderOctetId2 := vl_senderOctetId[3]&vl_senderOctetId[2]&vl_senderOctetId[1]&vl_senderOctetId[0];
|
| var charstring vl_senderId := oct2str(vl_senderOctetId2);
|
| //converting "msg"
|
| var charstring vl_requestType := oct2str(char2oct(pl_requestType));
|
|
|
| if(f_EPTF_LGenBase_getTemplateContentFast(
|
| v_EPTF_SimpleHello_setId_customRequest,
|
| v_EPTF_SimpleHello_templId_customRequest,
|
| { vl_senderId, vl_requestType },
|
| pl_msg
|
| )) {
|
| f_EPTF_SimpleHello_loggingDebug(%definitionId&": The created template is: "&pl_msg);
|
| return true;
|
| } else {
|
| // substitution is failed
|
| f_EPTF_SimpleHello_loggingDebug(%definitionId&": Template substitution is failed");
|
| return false;
|
| }
|
| }
|
|
|
| //=========================================================================
|
| // Functions - FSM Steps
|
| //=========================================================================
|
|
|
| //****************************************************************************************************************************
|
| //Teststeps For Clients
|
| //****************************************************************************************************************************
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_SimpleHello_step_sendfoo
|
| //
|
| // Purpose:
|
| // Sample teststep which is sending foo messages
|
| //
|
| // Parameters:
|
| // pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // Sends a "foo" charstring.
|
| // This test step is not used now.
|
| ///////////////////////////////////////////////////////////
|
| function f_EPTF_SimpleHello_step_sendfoo(in EPTF_LGenBase_TestStepArgs pl_ptr) runs on EPTF_SimpleHello_LGen_CT
|
| {
|
|
|
| var PDU_SimpleHello_Request vl_request := {
|
| header := {
|
| 0.0,
|
| 0.0,
|
| 0.0
|
| },
|
| transId := 7,
|
| senderId := 1,
|
| msg :="foo",
|
| payload := omit //char2oct("This is something else than Hello!")
|
| } ;
|
| //vf_EPTF_SimpleHello_sendRequest.apply(f_enc_SimpleHello_Request(vl_request));
|
|
|
| f_EPTF_SimpleHello_loggingDebug(%definitionId&": BBBBBBBBBBBBBBBBBB");
|
| f_EPTF_SimpleHello_loggingDebug(%definitionId&": "&log2str(t_LGenBase_finishedTcSuccess(pl_ptr.eIdx, f_EPTF_LGenBase_tcIdxOfStep(pl_ptr))));
|
|
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_SimpleHello_step_sendSimple
|
| //
|
| // Purpose:
|
| // Implements the sendSimple test step
|
| //
|
| // Parameters:
|
| // pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // Sends a "Simple" charstring.
|
| ///////////////////////////////////////////////////////////
|
| function f_EPTF_SimpleHello_step_sendSimple(in EPTF_LGenBase_TestStepArgs pl_ptr) runs on EPTF_SimpleHello_LGen_CT
|
| {
|
| f_EPTF_SimpleHello_loggingDebug(%definitionId&": sendSimple called");
|
| var charstring vl_request := "";
|
| var octetstring vl_encodedRequest;
|
|
|
| if(f_EPTF_SimpleHello_createRequest(pl_ptr.eIdx,"Simple", vl_request)) {
|
| vl_encodedRequest := str2oct(vl_request);
|
| } else {
|
| var PDU_SimpleHello_Request vl_simple := {
|
| header := {
|
| 0.0,
|
| 0.0,
|
| 0.0
|
| },
|
| transId := 7,
|
| senderId := pl_ptr.eIdx,
|
| msg :="Simple",
|
| payload := omit //char2oct("This is something else than Hello!")
|
| };
|
| vl_encodedRequest := f_enc_SimpleHello_Request(vl_simple);
|
| }
|
|
|
| vf_EPTF_SimpleHello_sendRequest.apply(vl_encodedRequest);
|
|
|
| f_EPTF_SimpleHello_loggingDebug(%definitionId&": sendSimple finished");
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_SimpleHello_step_sendHello
|
| //
|
| // Purpose:
|
| // Implements the sendHello test step
|
| //
|
| // Parameters:
|
| // pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // Sends a "Hello" charstring
|
| ///////////////////////////////////////////////////////////
|
| function f_EPTF_SimpleHello_step_sendHello(in EPTF_LGenBase_TestStepArgs pl_ptr) runs on EPTF_SimpleHello_LGen_CT
|
| {
|
| f_EPTF_SimpleHello_loggingDebug(%definitionId&": sendHello called");
|
| var charstring vl_request := "";
|
| var octetstring vl_encodedRequest;
|
|
|
| if(f_EPTF_SimpleHello_createRequest(pl_ptr.eIdx,"Hello", vl_request)) {
|
| vl_encodedRequest := str2oct(vl_request);
|
| } else {
|
|
|
| var PDU_SimpleHello_Request vl_hello := {
|
| header := {
|
| 0.0,
|
| 0.0,
|
| 0.0
|
| },
|
| transId := 7,
|
| senderId := pl_ptr.eIdx,
|
| msg :="Hello",
|
| payload := omit //char2oct("This is something else than Hello!")
|
| };
|
| vl_encodedRequest := f_enc_SimpleHello_Request(vl_hello);
|
| }
|
|
|
| vf_EPTF_SimpleHello_sendRequest.apply(vl_encodedRequest);
|
|
|
| f_EPTF_SimpleHello_loggingDebug(%definitionId&": sendHello finished");
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_SimpleHello_step_sendBye
|
| //
|
| // Purpose:
|
| // Implements the sendBye test step
|
| //
|
| // Parameters:
|
| // pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // Sends a "Bye" charstring
|
| ///////////////////////////////////////////////////////////
|
| function f_EPTF_SimpleHello_step_sendBye(in EPTF_LGenBase_TestStepArgs pl_ptr) runs on EPTF_SimpleHello_LGen_CT
|
| {
|
| f_EPTF_SimpleHello_loggingDebug(%definitionId&": sendBye called");
|
| var charstring vl_request := "";
|
| var octetstring vl_encodedRequest;
|
|
|
| if(f_EPTF_SimpleHello_createRequest(pl_ptr.eIdx,"Bye", vl_request)) {
|
| vl_encodedRequest := str2oct(vl_request);
|
| } else {
|
|
|
| var PDU_SimpleHello_Request vl_bye := {
|
| header := {
|
| 0.0,
|
| 0.0,
|
| 0.0
|
| },
|
| transId := 7,
|
| senderId := pl_ptr.eIdx,
|
| msg :="Bye",
|
| payload := omit //char2oct("This is something else than Hello!")
|
| };
|
| vl_encodedRequest := f_enc_SimpleHello_Request(vl_bye);
|
| }
|
|
|
| vf_EPTF_SimpleHello_sendRequest.apply(vl_encodedRequest);
|
|
|
| f_EPTF_SimpleHello_loggingDebug(%definitionId&": sendBye finished");
|
| }
|
|
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_SimpleHello_step_over
|
| //
|
| // Purpose:
|
| // Implements the over test step
|
| //
|
| // Parameters:
|
| // pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // This step is used for dispatch Tc success and takes the FSM back to IDLE
|
| ///////////////////////////////////////////////////////////
|
| function f_EPTF_SimpleHello_step_over(in EPTF_LGenBase_TestStepArgs pl_ptr) runs on EPTF_SimpleHello_LGen_CT{
|
| f_EPTF_SimpleHello_loggingDebug(%definitionId&": "&log2str(t_LGenBase_finishedTcSuccess(pl_ptr.eIdx, f_EPTF_LGenBase_tcIdxOfStep(pl_ptr))));
|
| f_EPTF_LGenBase_dispatchEvent(valueof(t_LGenBase_finishedTcSuccess(pl_ptr.eIdx, f_EPTF_LGenBase_tcIdxOfStep(pl_ptr))));
|
|
|
| }
|
|
|
| //****************************************************************************************************************************
|
| //Teststeps For Servers
|
| //****************************************************************************************************************************
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_SimpleHello_step_sendAck_forSimple
|
| //
|
| // Purpose:
|
| // Implements the sendAck_forSimple test step
|
| //
|
| // Parameters:
|
| // pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // Client sends an "Ack_forSimple" charstring, when a "Simple" charstring message arrives
|
| ///////////////////////////////////////////////////////////
|
| function f_EPTF_SimpleHello_step_sendAck_forSimple(in EPTF_LGenBase_TestStepArgs pl_ptr) runs on EPTF_SimpleHello_LGen_CT
|
| {
|
| timer t:=100.0;
|
|
|
| var PDU_SimpleHello_Request vl_ack := {
|
| header := {
|
| 0.0,
|
| 0.0,
|
| 0.0
|
| },
|
| transId := 7,
|
| senderId := pl_ptr.eIdx,
|
| msg :="Ack_forSimple",
|
| payload := omit //char2oct("This is something else than Hello!")
|
| } ;
|
| vf_EPTF_SimpleHello_sendRequest.apply(f_enc_SimpleHello_Request(vl_ack));
|
|
|
| //t.start;
|
| //t.timeout;
|
|
|
| f_EPTF_SimpleHello_loggingDebug(%definitionId&": XXXXXXXXXXXXXXXXXXXXXXXXXXX");
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_SimpleHello_step_sendAck_forHello
|
| //
|
| // Purpose:
|
| // Implements the sendAck_forHello test step
|
| //
|
| // Parameters:
|
| // pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // Client sends an "Ack_forHello" charstring, when a "Hello" charstring message arrives
|
| ///////////////////////////////////////////////////////////
|
| function f_EPTF_SimpleHello_step_sendAck_forHello(in EPTF_LGenBase_TestStepArgs pl_ptr) runs on EPTF_SimpleHello_LGen_CT
|
| {
|
| timer t:=100.0;
|
|
|
| var PDU_SimpleHello_Request vl_ack := {
|
| header := {
|
| 0.0,
|
| 0.0,
|
| 0.0
|
| },
|
| transId := 7,
|
| senderId := pl_ptr.eIdx,
|
| msg :="Ack_forHello",
|
| payload := omit //char2oct("This is something else than Hello!")
|
| } ;
|
| vf_EPTF_SimpleHello_sendRequest.apply(f_enc_SimpleHello_Request(vl_ack));
|
|
|
| //t.start;
|
| //t.timeout;
|
|
|
| f_EPTF_SimpleHello_loggingDebug(%definitionId&": XXXXXXXXXXXXXXXXXXXXXXXXXXX");
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_SimpleHello_step_sendAck_forBye
|
| //
|
| // Purpose:
|
| // Implements the sendAck_forBye test step
|
| //
|
| // Parameters:
|
| // pl_ptr - *in* <EPTF_LGenBase_TestStepArgs> - test step args
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // Client sends an "Ack_forBye" charstring, when a "Bye" charstring message arrives
|
| ///////////////////////////////////////////////////////////
|
| function f_EPTF_SimpleHello_step_sendAck_forBye(in EPTF_LGenBase_TestStepArgs pl_ptr) runs on EPTF_SimpleHello_LGen_CT
|
| {
|
| timer t:=100.0;
|
|
|
| var PDU_SimpleHello_Request vl_ack := {
|
| header := {
|
| 0.0,
|
| 0.0,
|
| 0.0
|
| },
|
| transId := 7,
|
| senderId := pl_ptr.eIdx,
|
| msg :="Ack_forBye",
|
| payload := omit //char2oct("This is something else than Hello!")
|
| } ;
|
| vf_EPTF_SimpleHello_sendRequest.apply(f_enc_SimpleHello_Request(vl_ack));
|
|
|
| //t.start;
|
| //t.timeout;
|
| f_EPTF_LGenBase_dispatchEvent(valueof(t_LGenBase_finishedTcSuccess(pl_ptr.eIdx, f_EPTF_LGenBase_tcIdxOfStep(pl_ptr))));
|
| f_EPTF_SimpleHello_loggingDebug(%definitionId&": XXXXXXXXXXXXXXXXXXXXXXXXXXX");
|
| }
|
| /*
|
| function f_SH_step_sendRequest(in EPTF_LGenBase_TestStepArgs pl_ptr) runs on SimpleHello_LGen_CT
|
| {
|
| var PDU_SimpleHello_Request vl_request := {
|
| header := {
|
| 1.4,
|
| 2.5,
|
| 3.6
|
| },
|
| transId := 7,
|
| senderId := 8,
|
| msg :="Hello World",
|
| payload := char2oct("World Hello")
|
| } ;
|
| v_SH_sendRequest.apply(vl_request);
|
| }
|
|
|
| //Server Behavior
|
| function f_SH_step_receivedRequest(in EPTF_LGenBase_TestStepArgs pl_ptr) runs on SimpleHello_LGen_CT
|
| {
|
|
|
| }
|
|
|
|
|
| function f_SH_step_sendResponse(in EPTF_LGenBase_TestStepArgs pl_ptr) runs on SimpleHello_LGen_CT
|
| {
|
| var integer myCtx := v_LGenBase_entities[pl_ptr.eIdx].bCtxList[v_SH_myBIdx][0];
|
| var integer fCtx := pl_ptr.refContext.fCtxIdx;
|
|
|
| }
|
|
|
| function f_SH_step_handleTimeout(in EPTF_LGenBase_TestStepArgs pl_ptr) runs on SimpleHello_LGen_CT
|
| {
|
| var integer myCtx := v_LGenBase_entities[pl_ptr.eIdx].bCtxList[v_SH_myBIdx][0];
|
| var integer fCtx := pl_ptr.refContext.fCtxIdx;
|
|
|
| }
|
| */
|
|
|
| //=========================================================================
|
| // Functions - Other
|
| //=========================================================================
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_SimpleHello_messageReceived
|
| //
|
| // Purpose:
|
| // hanldle received message
|
| //
|
| // Parameters:
|
| // pl_Message - *in* *octetstring* - received message
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // -
|
| //
|
| ///////////////////////////////////////////////////////////
|
| function f_EPTF_SimpleHello_messageReceived(in octetstring pl_Message) runs on EPTF_SimpleHello_LGen_CT
|
| {
|
| //f_EPTF_SimpleHello_loggingDebug(%definitionId&": The Received message: "&log2str(f_dec_SimpleHello_Response(pl_Message)));
|
| f_EPTF_SimpleHello_loggingDebug(%definitionId&": IIIIIIIIIIIIIII");
|
|
|
| var PDU_SimpleHello_Request vl_EPTF_SimpleHello_msg := f_dec_SimpleHello_Request(pl_Message);
|
| f_EPTF_SimpleHello_loggingDebug(%definitionId&": "&log2str(vl_EPTF_SimpleHello_msg));
|
| f_EPTF_SimpleHello_loggingDebug(%definitionId&": "&log2str(tr_SimpleHello_simplehello("simple")));
|
|
|
| f_EPTF_SimpleHello_loggingDebug(
|
| %definitionId&": "&
|
| ": The Received message: "&
|
| "\ntransId: "&int2str(vl_EPTF_SimpleHello_msg.transId)&
|
| "\nsenderId: "&int2str(vl_EPTF_SimpleHello_msg.senderId)&
|
| "\nmsg: "&vl_EPTF_SimpleHello_msg.msg
|
| );
|
| select(vl_EPTF_SimpleHello_msg)
|
| {
|
| case (tr_SimpleHello_simplehello("Simple")){
|
| f_EPTF_LGenBase_dispatchEvent({{ v_EPTF_SimpleHello_myBIdx, c_EPTF_SimpleHello_inputIdx_receivedSimple,{(vl_EPTF_SimpleHello_msg.senderId-tsp_EPTF_SimpleHelloNoOfEntities),omit},omit},{}});
|
|
|
| var integer myCtx := v_LGenBase_entities[vl_EPTF_SimpleHello_msg.senderId].bCtxList[v_EPTF_SimpleHello_myBIdx][0];
|
| v_EPTF_SimpleHello_contexts[vl_EPTF_SimpleHello_msg.senderId].msg:=vl_EPTF_SimpleHello_msg.msg;
|
| f_EPTF_SimpleHello_loggingDebug(%definitionId&": DDDDDDDDDDDDDDDD Simple");
|
| }
|
| case (tr_SimpleHello_simplehello("Hello")){
|
| f_EPTF_LGenBase_dispatchEvent({{v_EPTF_SimpleHello_myBIdx,c_EPTF_SimpleHello_inputIdx_receivedHello,{(vl_EPTF_SimpleHello_msg.senderId-tsp_EPTF_SimpleHelloNoOfEntities),omit},omit},{}});
|
|
|
| var integer myCtx := v_LGenBase_entities[vl_EPTF_SimpleHello_msg.senderId].bCtxList[v_EPTF_SimpleHello_myBIdx][0];
|
| v_EPTF_SimpleHello_contexts[vl_EPTF_SimpleHello_msg.senderId].msg:=vl_EPTF_SimpleHello_msg.msg;
|
| f_EPTF_SimpleHello_loggingDebug(%definitionId&": DDDDDDDDDDDDDDDD Hello");
|
| }
|
| case (tr_SimpleHello_simplehello("Bye")){
|
| f_EPTF_LGenBase_dispatchEvent({{v_EPTF_SimpleHello_myBIdx,c_EPTF_SimpleHello_inputIdx_receivedBye,{(vl_EPTF_SimpleHello_msg.senderId-tsp_EPTF_SimpleHelloNoOfEntities),omit},omit},{}});
|
|
|
| var integer myCtx := v_LGenBase_entities[vl_EPTF_SimpleHello_msg.senderId].bCtxList[v_EPTF_SimpleHello_myBIdx][0];
|
| v_EPTF_SimpleHello_contexts[vl_EPTF_SimpleHello_msg.senderId].msg:=vl_EPTF_SimpleHello_msg.msg;
|
| f_EPTF_SimpleHello_loggingDebug(%definitionId&": DDDDDDDDDDDDDDDD bye");
|
| }
|
| case (tr_SimpleHello_simplehello("Ack_forSimple")){
|
| f_EPTF_LGenBase_dispatchEvent({{v_EPTF_SimpleHello_myBIdx,c_EPTF_SimpleHello_inputIdx_receivedAck_forSimple,{(vl_EPTF_SimpleHello_msg.senderId+tsp_EPTF_SimpleHelloNoOfEntities),omit},omit},{}});
|
|
|
| var integer myCtx := v_LGenBase_entities[vl_EPTF_SimpleHello_msg.senderId].bCtxList[v_EPTF_SimpleHello_myBIdx][0];
|
| v_EPTF_SimpleHello_contexts[vl_EPTF_SimpleHello_msg.senderId].msg:=vl_EPTF_SimpleHello_msg.msg;
|
| f_EPTF_SimpleHello_loggingDebug(%definitionId&": DDDDDDDDDDDDDDDD Ack_forsimple");
|
| }
|
| case (tr_SimpleHello_simplehello("Ack_forHello")){
|
| f_EPTF_LGenBase_dispatchEvent({{v_EPTF_SimpleHello_myBIdx,c_EPTF_SimpleHello_inputIdx_receivedAck_forHello,{(vl_EPTF_SimpleHello_msg.senderId+tsp_EPTF_SimpleHelloNoOfEntities),omit},omit},{}});
|
|
|
| var integer myCtx := v_LGenBase_entities[vl_EPTF_SimpleHello_msg.senderId].bCtxList[v_EPTF_SimpleHello_myBIdx][0];
|
| v_EPTF_SimpleHello_contexts[vl_EPTF_SimpleHello_msg.senderId].msg:=vl_EPTF_SimpleHello_msg.msg;
|
| f_EPTF_SimpleHello_loggingDebug(%definitionId&": DDDDDDDDDDDDDDDD Ack_Hello");
|
| }
|
| case (tr_SimpleHello_simplehello("Ack_forBye")){
|
| f_EPTF_LGenBase_dispatchEvent({{v_EPTF_SimpleHello_myBIdx,c_EPTF_SimpleHello_inputIdx_receivedAck_forBye,{(vl_EPTF_SimpleHello_msg.senderId+tsp_EPTF_SimpleHelloNoOfEntities),omit},omit},{}});
|
|
|
| var integer myCtx := v_LGenBase_entities[vl_EPTF_SimpleHello_msg.senderId].bCtxList[v_EPTF_SimpleHello_myBIdx][0];
|
| v_EPTF_SimpleHello_contexts[vl_EPTF_SimpleHello_msg.senderId].msg:=vl_EPTF_SimpleHello_msg.msg;
|
| f_EPTF_SimpleHello_loggingDebug(%definitionId&": DDDDDDDDDDDDDDDD Ack_forbye");
|
| }
|
| }
|
| }
|
|
|
| ///////////////////////////////////////////////////////////////////////////////
|
| // Group: EPTF_SimpleHello_Logging
|
| //
|
| // Purpose:
|
| // The functions of the EPTF SimpleHello Logging
|
| // Wrapper functions for logging debug, error, warning, etc.
|
| //
|
| ///////////////////////////////////////////////////////////////////////////////
|
| group EPTF_SimpleHello_Logging
|
| {
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_SimpleHello_loggingError
|
| //
|
| // Purpose:
|
| // Function to log an error from SimpleHello Applib.
|
| //
|
| // Parameters:
|
| // - pl_message - *in* *charstring* - the message to log
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors & assertions:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // -
|
| //
|
| ///////////////////////////////////////////////////////////
|
| function f_EPTF_SimpleHello_loggingError(
|
| in charstring pl_message)
|
| runs on EPTF_SimpleHello_LGen_CT
|
| {
|
| f_EPTF_Logging_errorV2(pl_message,
|
| v_EPTF_SimpleHello_loggingMaskId,
|
| {c_EPTF_SimpleHello_loggingClassIdx_Error});
|
| f_EPTF_Base_stopAll();
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_SimpleHello_loggingWarning
|
| //
|
| // Purpose:
|
| // Function to log a warning from SimpleHello Applib.
|
| //
|
| // Parameters:
|
| // - pl_message - *in* *charstring* - the message to log
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors & assertions:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // -
|
| //
|
| ///////////////////////////////////////////////////////////
|
| function f_EPTF_SimpleHello_loggingWarning(
|
| in charstring pl_message)
|
| runs on EPTF_SimpleHello_LGen_CT
|
| {
|
| f_EPTF_Logging_warningV2(pl_message,
|
| v_EPTF_SimpleHello_loggingMaskId,
|
| {c_EPTF_SimpleHello_loggingClassIdx_Warning});
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_SimpleHello_loggingDebug
|
| //
|
| // Purpose:
|
| // Function to log a debug message from SimpleHello Applib.
|
| //
|
| // Parameters:
|
| // - pl_message - *in* *charstring* - the message to log
|
| //
|
| // Return Value:
|
| // -
|
| //
|
| // Errors & assertions:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // -
|
| //
|
| ///////////////////////////////////////////////////////////
|
| function f_EPTF_SimpleHello_loggingDebug(
|
| in charstring pl_message)
|
| runs on EPTF_SimpleHello_LGen_CT
|
| {
|
| f_EPTF_Logging_debugV2(pl_message,
|
| v_EPTF_SimpleHello_loggingMaskId,
|
| {c_EPTF_SimpleHello_loggingClassIdx_Debug});
|
| }
|
|
|
| ///////////////////////////////////////////////////////////
|
| // Function: f_EPTF_SimpleHello_debugEnabled
|
| //
|
| // Purpose:
|
| // Function to check if debug is enabled for SimpleHello Applib
|
| //
|
| // Parameters:
|
| // -
|
| //
|
| // Return Value:
|
| // *boolean* - true if debug enabled
|
| //
|
| // Errors & assertions:
|
| // -
|
| //
|
| // Detailed Comments:
|
| // -
|
| //
|
| ///////////////////////////////////////////////////////////
|
| function f_EPTF_SimpleHello_debugEnabled()
|
| runs on EPTF_SimpleHello_LGen_CT
|
| return boolean
|
| {
|
| return f_EPTF_Logging_isEnabled(
|
| v_EPTF_SimpleHello_loggingMaskId,
|
| c_EPTF_SimpleHello_loggingClassIdx_Debug);
|
| }
|
| } // group Logging
|
|
|
| } //end-of-module
|
