LibItsCalm_Interface.ttcn

/**
 *    @author     ETSI / STF405
 *    @version    $URL$
 *                $Id$
 *    @desc       Module containing PTCs and interface ports definitions for ITS
 *
 */
module LibItsCalm_Interface {
    
    // LibCommon
    import from LibCommon_Time {modulepar all;}
    import from LibCommon_Sync all;
    
    // LibIts - IP Protocols
    import from LibItsExternal_TypesAndValues all;
    //  LibIts - Non IP Protocols
    import from CALMiitsscu language "ASN.1:1997" all;
    import from CALMmanagement language "ASN.1:1997" all;
    import from CALMllsap language "ASN.1:1997" {
        type 
            INsapPrimitivesUp, INsapPrimitivesDown
    };
    import from CALMmsap language "ASN.1:1997" all;
    import from CALMfntp language "ASN.1:1997" all;
    import from LibItsMgt_TypesAndValues all;
    import from LibItsFntp_TypesAndValues all;
    import from LibItsFsap_TypesAndValues all;
    import from LibItsIicp_TypesAndValues all;
    // LibIts
    import from LibItsCommon_TypesAndValues all;
    import from LibItsCommon_TestSystem all;
    
    group adapterInterface {
        
        group portDefinitions {
            
            /**
             * @desc Adapter control port
             */
            type port AdapterControlPort message {
                out 
                    AcFntpPrimitive, AcFsapPrimitive; // Non IP Protocols
            } // end AdapterControlPort
            
            /**
             * @desc Upper Tester port
             */
            type port UpperTesterPort message {
                out 
                    UtInitialize, UtTrigger, UtCheck, UtCommandRequest;
                in 
                    UtResult, UtCommandConfirm, UtCommandIndication
            } // end UpperTesterPort
            
        } // end portDefinitions    

    } // adapterInterface     
    
    group interfaceComponents {
        
        /**
         * @desc Test component for ITS Management layer 
         */
        type component ItsMgt extends ItsBaseComponent {
            
            port UpperTesterPort utPort;
            port AdapterControlPort acPort;
            
            // MGT1 ports - Used to send remote command to/from 
            port IicpPort iicpPort; // ITS station-internal management communications protocol 
            // MGT2 ports - Used to send command to/from through SAP interfaces
            port FsapPort fsapPort; // Fast Service Advertisement Protocol 
            port MgtMfSapPort mgtMfSapPort; 
            port MgtMnSapPort mgtMnSapPort;
            
            // timers
            
            // variables
            var CommandRef vc_commandRef := 0; // Cyclic counter identifying a NF-FNTP-COM.request
            var PduCounter vc_pduCounter := 0; // Cyclic counter identifying a PDU counter
            var integer vc_noFntpFwtEntry := 0;
            
        } // End of component ItsCalm

        /**
         * @desc Test component for ITS Network and Transport layer 
         */
        type component ItsCalm extends ItsMgt {
            
            
            // NT3 ports
            port FntpPort fntpPort; // Fast Network & Transport layer Protocol 
            port MgtMnSapPort cfPort; // FNTP configuration port 
            
            // timers
            
            // Variables for Fntp
            var charstring vc_componentName := "";
            var PortNumber vc_portNumber := { portLong := 0 };
            var UtCommandConfirm vc_utCommandConf; 
            
        } // End of component ItsNt
        
    } // End of group interfaceComponents
    
    group interfacePorts {
        
                
        group managementPorts {
            
            group mgt1Ports {
                
                /**
                 * @desc MGT1 IISC Port (IISC/LAN) 
                 */
                type port IicpPort message {
                    inout
                        IicpReq,
                        IicpResp;
                } // End of port IicpPort
                
            } // End of group mgt1Ports
            
            group mgt2Ports {
                
                /**
                 * @desc MGT2 Fsap Port
                 */
                type port FsapPort message {
                    in 
                        FsapReq; 
                    out
                        FsapResp; 
                } // End of port FsapPort
                
                /**
                 * @desc MGT2 Management Port - MF-SAP service primitives
                 */
                type port MgtMfSapPort message {
                    inout 
                        MgtMfSapRequestReq; 
                    in 
                        MgtMfSapCommandReq, MgtMfSapCommandConfirm, 
                        MgtMfSapRequestConfirm; 
                } // End of port MgtMfSapPort
                
                /**
                 * @desc MGT2 Management Port - MN-SAP service primitives
                 */
                type port MgtMnSapPort message { 
                    inout 
                        MgtMnSapCommandReq, 
                        MgtMnSapRequestReq;
                    in 
                        MgtMnSapCommandConfirm, 
                        MgtMnSapRequestConfirm;
                } // End of port MgtMnSapPort
                
            } // End of group mgt2Ports
            
        } // End of group managementPorts

        group networkAndTransportPorts {
            
                    
            group nt3Ports {
                
                /**
                 * @desc NT3 Fntp Port
                 */
                type port FntpPort message {
                    inout 
                        INsapPrimitivesUp,
                        INsapPrimitivesDown
                } // End of port FntpPort
                
            } // End of group nt3Ports
            
        } // End of group networkAndTransportPorts
    
    } // End of group interfacePorts

    group interfacePrimitives { 
        
                
        group managementPrimitives {
            
            group mgt1Primitives {
                
                /**
                 * @desc MGT1 IISC Indication Primitive 
                 */
                type record IicpResp {
                    IIC_Response msgInOut
                }
                
                /**
                 * @desc MGT1 IISC Request Primitive 
                 */
                type record IicpReq {
                    IIC_Request msgInOut
                }
                
            } // End of group mgt1Primitives
            
            /**
             * @desc    MGT2 Management Service Primitives
             * @see     ISO/CD 24102-3
             */
            group mgt2Primitives { 
                
                /**
                 * @desc TODO
                 */
                type union FsapReq { 
                    MF_Command_request mfCommandRequestIn,
                    MF_Command_confirm mfCommandConfirmIn
                }
                
                /**
                 * @desc TODO
                 */
                type union FsapResp {
                    MF_Request_request mfRequestRequestOut,
                    MF_Command_confirm mfCommandConfirmOut
                }
                
                /**
                 * @desc    MF-SAP service primitives
                 * @see     ISO/CD 24102-3 Clause 8.1
                 */
                group mfSap {
                    
//                    /**
//                     * @desc    Management service primitive MF-COMMAND.request
//                     * @see     ISO/CD 24102-3 Clause 8.2.2
//                     */
//                    type record MgtMFSapCommandInd {
//                        MF_Command_request msgIn
//                    }
//                    
                    /**
                     * @desc    Management service primitive MF-REQUEST.confirm
                     * @see     ISO/CD 24102-3 Clause 8.3.3
                     */
                    type record MgtMfSapRequestConfirm {
                        MF_Request_confirm msgIn
                    }
                    
//                    /**
//                     * @desc MGT2 Management Request Primitive 
//                     */
//                    type record MgtMFSapRequestInd { // FIXME To be removed
//                        MF_Request_request msgIn
//                    }
                    
                    /**
                     * @desc    Management service primitive MF-COMMAND.request
                     * @see     ISO/CD 24102-3 Clause 8.2.3
                     */
                    type record MgtMfSapCommandReq {
                        MF_Command_request msgIn
                    }
                    
                    /**
                     * @desc    Management service primitive MF-COMMAND.confirm
                     * @see     ISO/CD 24102-3 Clause 8.2.3
                     */
                    type record MgtMfSapCommandConfirm {
                        MF_Command_confirm msgIn
                    }

                    /**
                     * @desc    Management service primitive MF-REQUEST.request
                     * @see     ISO/CD 24102-3 Clause 8.3.2
                     */
                    type record MgtMfSapRequestReq {
                        MF_Request_request msgInOut
                    }
                    
                } // End of group mfSap
                
                /**
                 * @desc    MF-SAP service primitives
                 * @see     ISO/CD 24102-3 Clause 7.1
                 */
                group mnSap {
                    
                    /**
                     * @desc    Management service primitive MN-COMMAND.request
                     * @see     ISO/CD 24102-3 Clause 7.2.2
                     */
                    type record MgtMnSapCommandReq {
                        MN_Command_request msgInOut
                    }
                    
                    /**
                     * @desc    Management service primitive MN-REQUEST.request
                     * @see     ISO/CD 24102-3 Clause 7.3.2
                     */
                    type record MgtMnSapRequestReq {
                        MN_Request_request msgInOut
                    }
                    
                    /**
                     * @desc    Management service primitive MN-COMMAND.confirm
                     * @see     ISO/CD 24102-3 Clause 7.2.3
                     */
                    type record MgtMnSapCommandConfirm {
                        MN_Command_confirm msgIn
                    }
                    
                    /**
                     * @desc    Management service primitive MN-REQUEST.confirm
                     * @see     ISO/CD 24102-3 Clause 7.3.3
                     */
                    type record MgtMnSapRequestConfirm {
                        MN_Request_confirm msgIn
                    }
                    
                } // End of group mnSap
                
            } // End of group mgt2Primitives
            
        } // End of group managementPrimitives 
        
        group networkAndTransportPrimitives { 
            
                    
            
            group nt3Primitives {
                
            } // end nt3Primitives
            
        } // End of group networkAndTransportPrimitives
        
    }
    
    group upperTester {
        
        /**
         * @desc Upper Tester message to initialize IUT 
         */
        type union UtInitialize {
            // Non IP Protocols
            UtFntpInitialize utFntpInitialize,
            UtFsapInitialize utFsapInitialize,
            UtIicpInitialize utIicpInitialize
        }

        /**
         * @desc Upper Tester message to trigger an action on IUT 
         */
        type record UtTrigger {
            UtEvent utEvent
        }

        /**
         * @desc Upper Tester message to check event/status on IUT 
         */    
        type record UtCheck {
            UtEvent utEvent
        }

        /**
         * @desc Upper Tester message describing an action/event 
         */
        type union UtEvent {
            // Non IP Protocols
            UtFntpEvent utFntpEvent,
            UtFsapEvent utFsapEvent
        }

        /**
         * @desc Upper Tester message describing an action/event 
         */
        type union UtCommandRequest {
            UtFntpCommandRequest utFntpCommandRequest,
            UtFsapCommandRequest utFsapCommandRequest
        }

        /**
         * @desc Upper Tester message describing an action/event 
         */
        type union UtCommandConfirm {
            UtFntpCommandConfirm utFntpCommandConfirm
//           FIXME To be removed       UtFsapCommandConfirm utFsapCommandConfirm
        }

        /**
         * @desc Upper Tester message describing an action/event 
         */
        type union UtCommandIndication {
            UtFntpCommandIndication utFntpCommandIndication
            //UtFsapCommandIndication utFsapCommandIndication
        }

        /**
         * @desc Upper Tester response message  
         */    
        type boolean UtResult;
        
            /**
             * @desc Upper tester functions
             */
            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 ItsCalm {
                
                    utPort.send(p_init);
                    tc_wait.start;
                    alt {
                        [] utPort.receive(UtResult:true) {
                            tc_wait.stop;
                            log("*** f_utInitializeIut: INFO: IUT initialized ***");
                        }
                        [] utPort.receive {
                            tc_wait.stop;
                            log("*** f_utInitializeIut: INFO: IUT could not be initialized ***");
                            f_selfOrClientSyncAndVerdict("error", e_error);
                        }
                        [] tc_wait.timeout {
                            log("*** f_utInitializeIut: INFO: IUT could not be initialized in time ***");
                            f_selfOrClientSyncAndVerdict("error", e_timeout);
                        }
                        [else] { // Shortcut defaults
                            repeat; 
                        }
                    }
                
                }
                
                /**
                 * @desc    Triggers event from the application layer
                 * @param   p_event The event to trigger.
                 */
                function f_utTriggerEvent(template (value) UtEvent p_event) runs on ItsCalm {
                    var template (value) UtTrigger v_utMsg := { p_event };
                
                    utPort.send(v_utMsg);
                    alt {
                        [] utPort.receive(UtResult:true) {
                            tc_wait.stop;
                        }
                        [] utPort.receive {
                            tc_wait.stop;
                        }
                        [] tc_wait.timeout {
                        }
                        [else] { // Shortcut defaults
                            repeat; 
                        }
                    }
                }
                
                /**
                 * @desc Checks that the event was indicated at the application layer
                 * @param p_event The event to check.
                 * @param   p_discard The event should not appear. Default value: FALSE.
                 */
                function f_utCheckEvent(template (value) UtEvent p_event, boolean p_discard) runs on ItsCalm {
                    var template (value) UtCheck v_utMsg := { p_event };
                
                    utPort.send(v_utMsg);
                    tc_wait.start;
                    alt {
                        [] utPort.receive(UtResult:true) {
                            tc_wait.stop;
                            if (p_discard == false) {
                                log("*** f_utCheckEvent: INFO: Event correctly indicated at application layer ***");
                            }
                            else {
                                log("*** f_utCheckEvent: ERROR: Event indicated at application layer where it should be discarded ***");
                                f_selfOrClientSyncAndVerdict("error", e_error);
                            }
                        }
                        [] utPort.receive(UtResult:false) {
                            tc_wait.stop;
                            if (p_discard == false) {
                                log("*** f_utCheckEvent: ERROR: Event not correctly indicated at application layer ***");
                                f_selfOrClientSyncAndVerdict("error", e_error);
                            }
                            else {
                                log("*** f_utCheckEvent: INFO: Event not indicated at application layer***");
                            }
                        }
                        [] tc_wait.timeout {
                            log("*** f_utCheckEvent: ERROR: Timeout while waiting for event check result ***");
                            f_selfOrClientSyncAndVerdict("error", e_timeout);                    
                        }
                        [else] { // Shortcut defaults
                            repeat; 
                        }
                    }
                }
                
                /**
                 * @desc    Send a command request primitive and wait for the command confirm response
                 * @param   p_commandReq    The command request
                 * @param   p_commandConf   The command confirm response
                 * @param   p_discard       Set to true if command confirm responses shall be discard, otherwise the function failed 
                 * @param   p_result        The command/request confirm response
                 * @verdict Unchanged on success, fail otherwise
                 */
                function f_utCommandRequestConfirm(
                    in template (value) UtCommandRequest p_commandReq, 
                    in template (present) UtCommandConfirm p_commandConf, 
                    in boolean p_discard, 
                    out UtCommandConfirm p_result) 
                runs on ItsCalm {
                    
                    utPort.send(p_commandReq);
                    tc_wait.start;
                    alt {
                        [] utPort.receive(p_commandConf) -> value p_result{
                            tc_wait.stop;
                        }
                        [] utPort.receive {
                            tc_wait.stop;
                            if (p_discard == false) {
                                log("*** f_utCommandRequestConfirm: ERROR: Event not correctly indicated at application layer ***");
                                f_selfOrClientSyncAndVerdict("error", e_error);
                            }
                            else {
                                log("*** f_utCommandRequestConfirm: INFO: Another event indicated at application layer, repeating check ***");
                                repeat;
                            }
                        }
                        [] tc_wait.timeout {
                            if (p_discard == false) {
                                log("*** f_utCommandRequestConfirm: ERROR: Timeout while waiting for event check result ***");
                                f_selfOrClientSyncAndVerdict("error", e_timeout);
                            }
                            else {
                                log("*** f_utCommandRequestConfirm: INFO: Event not indicated at application layer ***");
                            }
                        }
                    } // end of 'alt' statement
                    
                } // End of function f_utCommandRequestConfirm
                
                /**
                 * @desc    Send a command request primitive and do not wait for the command confirm response
                 * @param   p_commandReq    The command request
                 * @verdict Unchanged on success, fail otherwise
                 */
                function f_utCommandRequestWithoutConfirm(
                    in template (value) UtCommandRequest p_commandReq 
                ) runs on ItsCalm {
                    utPort.send(p_commandReq);
                } // End of function f_utCommandRequestWithoutConfirm
                
                /**
                 * @desc Capture the next event sent to the Upper Tester
                 * @param   p_event     Receive template of the expected event
                 * @param   p_result    Return the value of the received event if template matchs
                 */
                function f_utCommandIndication( 
                    in template UtCommandIndication p_event,
                    out UtCommandIndication p_result
                ) runs on ItsCalm {
                    
                    tc_wait.start;
                    alt {
                        [] utPort.receive(p_event) -> value p_result {
                            tc_wait.stop;
                        }
                        [] utPort.receive {
                            tc_wait.stop;
                            log("*** f_utCommandIndication: INFO: Another event indicated at application layer, repeating check ***");
                        }
                        [] tc_wait.timeout {
                            log("*** f_utCommandIndication: ERROR: Timeout while waiting for event check result ***");
                        }
                    } // end of 'alt' statement
                
                } // End of function f_utCommandIndication
            
            } // End of group utFunctions
            
    } // End of group upper tester 
    with {
        encode "LibIts_Interface"
    } // End of group interfacePrimitives
    
} // End of module LibItsCalm_Interface