/** * @author ETSI / STF517 * @version $URL$ * $Id$ * @desc Module containing functions for IVIM * @copyright ETSI Copyright Notification * No part may be reproduced except as authorized by written permission. * The copyright and the foregoing restriction extend to reproduction in all media. * All rights reserved. * */ module LibItsIvim_Functions { // LibCommon import from LibCommon_Sync all; import from LibCommon_VerdictControl all; import from LibCommon_Time all; // LibItsCommon import from LibItsCommon_Templates all; import from LibItsCommon_TypesAndValues all; import from LibItsCommon_Functions all; import from LibItsCommon_Pixits all; // LibItsIvim import from ITS_Container language "ASN.1:1997" all; import from IVIM_PDU_Descriptions language "ASN.1:1997" all; import from IVI language "ASN.1:1997" all; import from EfcDsrcGeneric language "ASN.1:1997" all; import from EfcDsrcApplication language "ASN.1:1997" all; // LibItsIvim import from LibItsIvim_TestSystem all; import from LibItsIvim_TypesAndValues all; import from LibItsIvim_Templates all; import from LibItsIvim_Pics all; import from LibItsIvim_Pixits all; group itsFunction { /** * @desc Gets the Provifr of test system * @return Test system's Provider value * @see PX_PROVIDER */ function f_getProvider() return Provider { return PX_PROVIDER; } // End of function f_getProvider } // End of group itsFunction group utFuntions { /** * @desc Requests to bring the IUT in an initial state * @param p_init The initialisation to trigger. */ function f_utInitializeIut(template (value) UtInitialize p_init) runs on ItsIvim { utPort.send(p_init); tc_wait.start; alt { [] utPort.receive(UtInitializeResult:true) { tc_wait.stop; log("*** " & testcasename() & ": INFO: IUT initialized ***"); } [] a_utDefault() { //empty on purpose } [] tc_wait.timeout { log("*** " & testcasename() & ": INFO: Could not receive expected UT message from IUT in time ***"); f_selfOrClientSyncAndVerdict("error", e_timeout); } [else] { // Shortcut defaults // //f_sleep(0.050); // 50 ms repeat; } } } /** * @desc Triggers an event from the application layer * @param p_event The event to trigger. */ function f_utTriggerEvent( in template (value) UtIvimTrigger p_event ) runs on ItsIvim return IviIdentificationNumber { var IviIdentificationNumber v_iviIdentificationNumber; var UtIvimTriggerResult v_result; utPort.send(p_event); tc_wait.start; alt { [] utPort.receive(UtIvimTriggerResult:?) -> value v_result { tc_wait.stop; v_iviIdentificationNumber := v_result.iviIdentificationNumber; if ( not v_result.result ) { f_selfOrClientSyncAndVerdict("IVIM Trigger failed", e_error); } } [] a_utDefault() { //empty on purpose } [] tc_wait.timeout { log("*** " & testcasename() & ": INFO: Could not receive expected UT message from IUT in time ***"); f_selfOrClientSyncAndVerdict("error", e_timeout); } [else] { // Shortcut defaults // //f_sleep(0.050); // 50 ms repeat; } } return v_iviIdentificationNumber; } /** * @desc Updates an event at the application layer * @param p_event The event to update. */ function f_utUpdateEvent( in template (value) UtIvimUpdate p_event ) runs on ItsIvim return IviIdentificationNumber { var IviIdentificationNumber v_iviIdentificationNumber; var UtIvimUpdateResult v_result; utPort.send(p_event); tc_wait.start; alt { [] utPort.receive(UtIvimUpdateResult:?) -> value v_result { tc_wait.stop; v_iviIdentificationNumber := v_result.iviIdentificationNumber; } [] a_utDefault() { //empty on purpose } [] tc_wait.timeout { log("*** " & testcasename() & ": INFO: Could not receive expected UT message from IUT in time ***"); f_selfOrClientSyncAndVerdict("error", e_timeout); } [else] { // Shortcut defaults // //f_sleep(0.050); // 50 ms repeat; } } return v_iviIdentificationNumber; } /** * @desc Terminates an event at the application layer * @param p_event The event to terminate. */ function f_utTerminateEvent(template (value) UtIvimTermination p_event) runs on ItsIvim { utPort.send(p_event); tc_wait.start; alt { [] utPort.receive(UtIvimTerminationResult:?) { tc_wait.stop; } [] tc_wait.timeout { log("*** " & testcasename() & ": INFO: Could not receive expected UT message from IUT in time ***"); f_selfOrClientSyncAndVerdict("error", e_timeout); } [] a_utDefault() { //empty on purpose } [else] { // Shortcut defaults // //f_sleep(0.050); // 50 ms repeat; } } } } // End of group utFunctions group adapterControl { /** * @desc Initialise secure mode if required */ function f_initialiseSecuredMode( in charstring p_certificateId := PX_CERT_FOR_TS ) runs on ItsIvim { if (PICS_IS_IUT_SECURED == true) { if(e_success != f_acTriggerSecEvent(m_acEnableSecurity(p_certificateId))) { log("*** INFO: TEST CASE NOW STOPPING ITSELF! ***"); stop; } } } // End of function f_initialiseSecuredMode() function f_uninitialiseSecuredMode() runs on ItsIvim { if (PICS_IS_IUT_SECURED == true) { f_acTriggerSecEvent(m_acDisableSecurity); } } // End of function f_initialiseSecuredMode() /** * @desc Triggers event in the test system adaptation. * @param p_event The event to trigger * @return FncRetCode */ function f_acTriggerSecEvent(template (value) AcSecPrimitive p_event) runs on ItsIvim return FncRetCode { var FncRetCode v_ret := e_success; acPort.send(p_event); tc_ac.start; alt { [] acPort.receive(m_acSecResponseSuccess) { tc_ac.stop; } [] acPort.receive { tc_ac.stop; log("*** " & __SCOPE__ & ": ERROR: Received unexpected message ***"); f_selfOrClientSyncAndVerdict("error", e_error); } [] tc_ac.timeout { log("*** " & __SCOPE__ & ": ERROR: Timeout while waiting for adapter control event result ***"); f_selfOrClientSyncAndVerdict("error", e_timeout); } } return v_ret; } } // End of group adapterControl group ivimConfigurationFunctions { /** * @desc Setups default configuration * @param p_certificateId The certificate identifier the TA shall use in case of secured IUT */ function f_cfUp( in charstring p_certificateId := PX_CERT_FOR_TS ) runs on ItsIvim /* TITAN TODO: system ItsIvimSystem */{ map(self:acPort, system:acPort); map(self:utPort, system:utPort); map(self:ivimPort, system:ivimPort); f_connect4SelfOrClientSync(); // Initialise secured mode f_initialiseSecuredMode(p_certificateId); } // End of function f_cfUp /** * @desc Deletes default configuration */ function f_cfDown() runs on ItsIvim /* TITAN TODO: system ItsIvimSystem */{ // Initialise secured mode f_uninitialiseSecuredMode(); unmap(self:acPort, system:acPort); unmap(self:utPort, system:utPort); unmap(self:ivimPort, system:ivimPort); f_disconnect4SelfOrClientSync(); } // End of function f_cfDown } // End of group ivimConfigurationFunctions group altsteps { /** * @desc The base default. */ altstep a_default() runs on ItsIvim { [] ivimPort.receive( mw_ivimInd( mw_ivimPdu( mw_ivimStructure ))) { log("*** " & testcasename() & ": INFO: IVIM received in default ***"); vc_ivimReceived := true; repeat; } [] ivimPort.receive { log("*** " & testcasename() & ": ERROR: Received an unexpected message ***"); f_selfOrClientSyncAndVerdict("error", e_error); } [] tc_wait.timeout { log("*** " & testcasename() & ": INCONC: Timeout while awaiting reaction of the IUT prior to Upper Tester action ***"); f_selfOrClientSyncAndVerdict("error", e_timeout); } [] tc_ac.timeout { log("*** " & testcasename() & ": INCONC: Timeout while awaiting the reception of a message ***"); f_selfOrClientSyncAndVerdict("error", e_timeout); } [] a_shutdown() { f_poDefault(); f_cfDown(); log("*** " & testcasename() & ": INFO: TEST COMPONENT NOW STOPPING ITSELF! ***"); stop; } } /** * @desc The default for handling upper tester messages. */ altstep a_utDefault() runs on ItsIvim { var UtIvimEventInd v_event; [] utPort.receive(UtIvimEventInd:?) -> value v_event { //store every upper tester indication received vc_utEvents[lengthof(vc_utEvents)] := v_event; repeat; } [] utPort.receive { log("*** " & testcasename() & ": INFO: Received unhandled/unknown UT message from IUT ***"); repeat; } } } // End of group altsteps group preambles { /** * @desc The default preamble. */ function f_prDefault() runs on ItsIvim { vc_default := activate(a_default()); activate(a_utDefault()); } /** * @desc Brings the IUT into an initial state. * @return FncRetCode */ function f_prInitialState(Scenario p_scenario := e_staticPosition) runs on ItsIvim return FncRetCode { var FncRetCode v_ret := e_success; f_utInitializeIut(m_ivimStructureInitialize); f_prDefault(); return v_ret; } } // End of group preambles group postambles { /** * @desc The default postamble. */ function f_poDefault() runs on ItsIvim { // Nothing to do } /** * @desc Postamble including cancellation of an event. * @param p_trigger Indicates if the cancellation have to be raised by the test system(e_ets) * or at the application layer of the IUT(e_iut). * @param p_actionId The action ID of the event to be cancelled */ function f_poCancelEvent( in template (value) Trigger p_trigger, in template (value) IviIdentificationNumber p_iviIdentificationNumber ) runs on ItsIvim { var FncRetCode v_ret := e_success; if (valueof(p_trigger) == e_ets) { f_sendIviMessage(valueof(m_ivimStructureCancellation(p_iviIdentificationNumber))); f_sleep(PX_TNOAC); } else { f_utTerminateEvent(m_utEventCancellation(p_iviIdentificationNumber)); } f_poDefault(); } } // End of group postambles group sendFunctions { /** * @desc Sends a IVI message * @param p_sendMsg The IVI message to send. * @param p_overrideSeqNo Overrides the sequence number with the stored one. */ function f_sendIviMessage( in template (value) IviStructure p_ivim ) runs on ItsIvim { ivimPort.send( m_ivimReq( m_ivimStructurePdu( p_ivim ) ) ); } } // End of group sendFunctions group receiveFunctions { /** * @desc Awaits a IVI message and returns it * @param p_rcvMsg The expected message to be received. * @param p_rcvdMsg The received message - OUT. */ function f_awaitIviMessage( in template (present) IvimInd p_rcvMsg, out IvimInd p_rcvdMsg ) runs on ItsIvim { tc_ac.start; alt { [] ivimPort.receive(p_rcvMsg) -> value p_rcvdMsg { tc_ac.stop; } [] tc_ac.timeout { log("*** " & testcasename() & ": INFO: Timeout while awaiting the reception of a message ***"); f_selfOrClientSyncAndVerdict("error", e_timeout); } } } } // End of group receiveFunctions group miscellaneousFunctions { /** * @desc Increases the IviIdentification number and handles the special case where the * IviIdentification number reaches the limit of 32768 and will be reset to 0. * @param p_iviIdentificationNumber The IviIdentification number to increase. * @return The increased IviIdentification number. */ function f_increaseIviIdentificationNumber( in IviIdentificationNumber p_iviIdentificationNumber ) return IviIdentificationNumber { // if maximum number of 32768 reached, reset it to 0 return ((p_iviIdentificationNumber + 1) mod 32768); } } // End of group miscellaneousFunctions } // End of module LibItsIvim_Functions