LibItsRtcmem_Functions.ttcn

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;
        }
        
        /**
         * @desc    Terminates an event at the application layer
         * @param   p_event The event to terminate.
         */
        function f_utTerminateEvent(template (value) UtRtcmemTermination p_event) runs on ItsRtcmem {
            
            //deactivate rtcmemPort default alts
            vc_rtcmemDefaultActive := false;
            
            utPort.send(p_event);
            tc_wait.start;
            alt {
                [] utPort.receive(UtRtcmemResults: { utRtcmemTerminationResult := ?}) {
                    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
                }
            }
            
            //activate rtcmemPort default alts
            vc_rtcmemDefaultActive := true;
            
        }
        
    } // 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_utEvents[lengthof(vc_utEvents)] := v_rtcmemevent;
                repeat;
            }
            [] utPort.receive {
                log("*** " & testcasename() & ": INFO: Received unhandled/unknown UT message from IUT ***");
                repeat;
            }
        }
        
    } // End of group altsteps

    group rtcmemConfigurationFunctions {
        
        /**
         * @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 rtcmemConfigurationFunctions
    
    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