module LibItsRtcmem_Functions { // LibCommon import from LibCommon_Sync all; import from LibCommon_Time all; import from LibCommon_VerdictControl all; // LibIts import from ITS_Container language "ASN.1:1997" all; import from RTCMEM_PDU_Descriptions language "ASN.1:1997" all; // LibItsCommon import from LibItsCommon_TypesAndValues all; import from LibItsCommon_Templates all; import from LibItsCommon_Functions all; import from LibItsCommon_Pixits all; // LibItsRtcmem import from LibItsRtcmem_TestSystem all; import from LibItsRtcmem_TypesAndValues all; import from LibItsRtcmem_Templates all; import from LibItsRtcmem_Pics all; import from LibItsRtcmem_Pixits all; group utFuntions { /** * @desc Requests to bring the IUT in an initial state * @param p_init The initialisation to trigger. */ function f_utInitializeIut(template (value) UtRtcmemInitialize p_init) runs on ItsRtcmem { //deactivate rtcmemPort default alts vc_rtcmemDefaultActive := false; utPort.send(p_init); tc_wait.start; alt { [] utPort.receive(UtRtcmemResults: { utRtcmemInitializeResult := true }) { tc_wait.stop; log("*** " & testcasename() & ": INFO: IUT initialized ***"); } [] tc_wait.timeout { log("*** " & testcasename() & ": INFO: Could not receive expected UT message from IUT in time ***"); f_selfOrClientSyncAndVerdict("error", e_timeout); } } //deactivate rtcmemPort default alts vc_rtcmemDefaultActive := true; } /** * @desc Triggers an event from the application layer * @param p_event The event to trigger. */ function f_utTriggerEvent( in template (value) UtRtcmemTrigger p_event ) runs on ItsRtcmem { //deactivate rtcmemPort default alts vc_rtcmemDefaultActive := false; utPort.send ( p_event ); tc_wait.start; alt { [] utPort.receive ( UtRtcmemResults: { utRtcmemTriggerResult := true }) { tc_wait.stop; } [] utPort.receive ( UtRtcmemResults: { utRtcmemTriggerResult := false }) { tc_wait.stop; f_selfOrClientSyncAndVerdict("SREM Trigger failed", e_error); } [] 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; } /** * @desc Updates an event from the application layer * @param p_event The event to trigger. */ function f_utUpdateEvent( in template (value) UtRtcmemUpdate p_event ) runs on ItsRtcmem { utPort.send ( p_event ); tc_wait.start; alt { [] utPort.receive ( UtRtcmemResults: { utRtcmemUpdateResult := true }) { tc_wait.stop; } [] utPort.receive ( UtRtcmemResults: { utRtcmemUpdateResult := false }) { tc_wait.stop; f_selfOrClientSyncAndVerdict("SREM Update failed", e_error); } [] tc_wait.timeout { log("*** " & testcasename() & ": INFO: Could not receive expected UT message from IUT in time ***"); f_selfOrClientSyncAndVerdict("error", e_timeout); } } //activate rtcmemPort default alts vc_rtcmemDefaultActive := true; return; } } // End of group utFuntions group adapterControl { /** * @desc Initialise secure mode if required */ function f_initialiseSecuredMode( in charstring p_certificateId := PX_CERT_FOR_TS ) runs on ItsRtcmem { 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 ItsRtcmem { 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 ItsRtcmem 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 altsteps { /** * @desc Default handling cf01 de-initialisation. */ altstep a_cf01Down() runs on ItsRtcmem { [] a_shutdown() { f_poDefault(); f_cfDown(); log("*** a_cf01Down: INFO: TEST COMPONENT NOW STOPPING ITSELF! ***"); stop; } } /** * @desc The base default. */ altstep a_default() runs on ItsRtcmem { [vc_rtcmemDefaultActive] rtcmemPort.receive(mw_rtcmemInd(mw_rtcmemPdu(mw_defaultRtcmem))) { log("*** " & testcasename() & ": INFO: SREMM received in default ***"); vc_rtcmemReceived := true; repeat; } [vc_rtcmemDefaultActive] rtcmemPort.receive { log("*** " & testcasename() & ": ERROR: Received an unexpected message ***"); f_selfOrClientSyncAndVerdict("error", e_error); } [] any timer.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 ItsRtcmem { var UtRtcmemEventInd v_rtcmemevent; [] utPort.receive(UtRtcmemEventInd:?) -> value v_rtcmemevent { //store every upper tester indication received vc_utRtcmemEvents[lengthof(vc_utRtcmemEvents)] := v_rtcmemevent; repeat; } [] utPort.receive { log("*** " & testcasename() & ": INFO: Received unhandled/unknown UT message from IUT ***"); repeat; } } } // End of group altsteps group rtcmemSsemConfigurationFunctions { /** * @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 ItsRtcmem system ItsRtcmemSystem { map(self:acPort, system:acPort); map(self:utPort, system:utPort); map(self:rtcmemPort, system:rtcmemPort); // Connect f_connect4SelfOrClientSync(); activate(a_cf01Down()); // Initialise secured mode f_initialiseSecuredMode(p_certificateId); //Initialze the IUT f_prInitialState(); } // End of f_cfUp /** * @desc Deletes default configuration */ function f_cfDown() runs on ItsRtcmem system ItsRtcmemSystem { // Initialise secured mode f_uninitialiseSecuredMode(); unmap(self:utPort, system:utPort); unmap(self:acPort, system:acPort); unmap(self:rtcmemPort, system:rtcmemPort); f_disconnect4SelfOrClientSync(); } // End of f_cfDown } // End of of rtcmemSsemConfigurationFunctions group preambles { /** * @desc The default preamble. */ function f_prDefault() runs on ItsRtcmem { vc_default := activate(a_default()); activate(a_utDefault()); } /** * @desc Brings the IUT into an initial state. * @return FncRetCode */ function f_prInitialState() runs on ItsRtcmem return FncRetCode { var FncRetCode v_ret := e_success; f_utInitializeIut(m_rtcmemInitialize); f_prDefault(); return v_ret; } } // End of group preambles group postambles { /** * @desc The default postamble. */ function f_poDefault() runs on ItsRtcmem { //empty } } // End of group postambles group sendFunctions { } // End of group sendFunctions group receiveFunctions { /** * @desc Awaits a SREM and returns it * @param p_rcvMsg The expected message to be received. * @param p_rcvdMsg The received message - OUT. */ function f_awaitRtcmeMessage( in template (present) RtcmemInd p_rcvMsg, out RtcmemInd p_rcvdMsg ) runs on ItsRtcmem { tc_ac.start; alt { [] rtcmemPort.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 } // End of module LibItsRtcmem_Functions