source: trunk/ETSI-Testsuites/ETSI_auto_IOT/ttcn/AtsImsIot/AtsImsIot_Functions.ttcn @ 25

/**
 *      @author         STF 370
 *  @version    $Id: $
 *      @desc           This module provides common function for TestCoordinator component.
 */
module AtsImsIot_Functions {
 
        import from AtsImsIot_Templates {template mw_SIP_URI_Base;}

        import from LibSip_SIPTypesAndValues all;

        import from AtsImsIot_TestSystem {
                type ImsTestCoordinator, ImsInterfaceMonitor;
        }

        import from LibIot_PIXITS {modulepar PX_MAX_MSG_WAIT, PX_PRODUCTS, PX_AVAILABLE_INTERFACES;}
        import from LibIot_Functions {
                function f_setConformanceVerdict;
        }
        
        import from AtsImsIot_TypesAndValues {
                type SipMessage, SipMessageList, SkipType;
        }

        import from LibIms_UpperTester all;

        import from LibIot_TestInterface {
        type InterfaceMonitor, TestCoordinator, EquipmentUser;
    }
        
        import from LibIot_Functions {function f_getE2EVerdict;}

        import from LibIot_TypesAndValues {type DefaultList;}
        
        group ue {
                
                /**
                  * @desc
                  *     Starts user component behavior for triggering the registration
                  *     procedures at the UE from test coordinator.
                  * @return
                  *     true in case of successfull execution of the trigger command
                  *     otherwise false
                  */
                function f_mtc_userRegistration(EquipmentUser p_userCompRef, ImsUserInfo p_userInfo) 
                runs on TestCoordinator 
                return boolean {
                var boolean v_status := true; 
                // TODO Investigate if f_PR_user_home_registration is to be removed
                // Reason: Thre is no difference when triggering UE to register in home or visiting NW
                if( p_userInfo.publicId  == "dummy" ) { return false; } 
                
                v_status := f_mtc_userRegister(p_userCompRef, p_userInfo.publicId, p_userInfo.privateId, p_userInfo.password);          
                        return v_status;
                }
                
                /**
                  * @desc
                  *     Starts user component behavior for checking the successful
                  *     registration.
                  * @param p_userCompRef Reference to IMS UE user component
                  * @return
                  *     true in case of successfull execution of the trigger command
                  *     otherwise false
                  */
                function f_mtc_userCheckRegistration(EquipmentUser p_userCompRef, ImsUserInfo p_userInfo) 
            runs on TestCoordinator return boolean {
                var boolean v_status := true; 
                        if( p_userInfo.publicId  == "dummy" ) { return false; }                 
                v_status := f_mtc_userCheckRegistrationSuccessful(p_userCompRef);               
                        return v_status;
        }
                
        /**
         * @desc
         * Starts user component behavior for checking that UE
         * is not registerd.
         * @param p_userCompRef Reference to IMS UE user component
         * @return
         * true in case of successfull execution of the trigger command
         * otherwise false
         **/
                function f_mtc_userCheckNoRegistration(EquipmentUser p_userCompRef, ImsUserInfo p_userInfo) 
                        runs on TestCoordinator return boolean {
                        var boolean v_status := true; 
                        if( p_userInfo.publicId  == "dummy" ) { return true; }                  
                        v_status := f_mtc_userCheckRegistrationUnsuccessful(p_userCompRef);             
                        return v_status;
                }

                /**
                  * @desc Trigger UE given by p_ueRef to initiate an MO call 
                  * @param p_ueRef Reference to IMS UE user component
                  * @param p_calledParty ImsUserInfo of called party
                  * @return
                  *     true in case of successfull execution of the trigger command
                  *     otherwise false
                  */
                function f_mtc_userInitiateCall(EquipmentUser p_ueRef, ImsUserInfo p_calledParty) 
            runs on TestCoordinator return boolean {
                var boolean v_status := true; 
                        if( p_calledParty.publicId  == "dummy" ) { return true; }                       
                        v_status := f_mtc_userInitiateCallSuccessful(p_ueRef); 
                        return v_status;
                }

                /**
                * 
                * @desc Starts user component behaviour for checking that the User 
                *               Call has been initiated
                * @param p_userCompRef Reference to IMS UE user component
                * @return 
                *               true in case of successfull execution of the trigger command
                *               otherwise false
                */
                function f_mtc_userInitiateCallSuccessful(EquipmentUser p_userCompRef) 
                        runs on TestCoordinator return boolean {
                        var boolean v_success := false;
        
                        p_userCompRef.start(f_checkUserCallIsInitiated());
        
                        p_userCompRef.done;
        
                        if(f_getE2EVerdict() == pass) {
                                v_success := true;      
                        }
                                return v_success;
                }
        
                /**
                  * @desc Answer call 
                  * @param p_ueRef Reference to IMS UE user component
                  * @return
                  *     true in case of successfull execution of the trigger command
                  *     otherwise false
                  */
                function f_mtc_userAnswerCall(EquipmentUser p_ueRef) 
                        runs on TestCoordinator return boolean {
                        var boolean v_status := true;                   
                        v_status := f_mtc_userAnswerCallSuccessful(p_ueRef); 
                        return v_status;
                }
                
                /**
                * 
                * @desc Starts user component behaviour for checking that the User 
                *               Call has been answered
                * @param p_userCompRef Reference to IMS UE user component
                * @return 
                *               true in case of successfull execution of the trigger command
                *               otherwise false
                */
                function f_mtc_userAnswerCallSuccessful(EquipmentUser p_userCompRef) 
                        runs on TestCoordinator return boolean {
                        var boolean v_success := false;

                        p_userCompRef.start(f_checkUserCallIsAnswered());

                        p_userCompRef.done;

                        if(f_getE2EVerdict() == pass) {
                                v_success := true;      
                        }
                                return v_success;
                }               
                
                /**
                  * @desc End the call 
                  * @param p_ueRef Reference to IMS UE user component
                  * @return
                  *     true in case of successfull execution of the trigger command
                  *     otherwise false
                  */
                function f_mtc_EndCall(EquipmentUser p_ueRef) 
                        runs on TestCoordinator return boolean {
                        var boolean v_status := true;                   
                        v_status := f_mtc_userEndCallSuccessful(p_ueRef); 
                        return v_status;
                }
                
                /**
                * 
                * @desc Starts user component behaviour for checking that the User 
                *               Call has been ended
                * @param p_userCompRef Reference to IMS UE user component
                * @return 
                *               true in case of successfull execution of the trigger command
                *               otherwise false
                */
                function f_mtc_userEndCallSuccessful(EquipmentUser p_userCompRef) 
                        runs on TestCoordinator return boolean {
                        var boolean v_success := false;

                        p_userCompRef.start(f_checkUserCallIsEnded());

                        p_userCompRef.done;

                        if(f_getE2EVerdict() == pass) {
                                v_success := true;      
                        }
                                return v_success;
                }       
                
                 /**
                  * @desc Trigger UE given by p_ueRef to add a new media stream 
                  * @param p_userCompRef Reference to IMS UE user component
                  * @return
                  *     true in case of successfull execution of the trigger command
                  *     otherwise false
                  */
                function f_mtc_userAddNewMediaStream(EquipmentUser p_ueRef) 
                        runs on TestCoordinator return boolean {
                        var boolean v_status := true;                   
                        v_status := f_mtc_userAddNewMediaStreamSuccessful(p_ueRef); 
                        return v_status;
                }
                
                /**
                * 
                * @desc Starts user component behaviour for checking that  
                *               a new media stream has been added
                * @param p_userCompRef Reference to IMS UE user component
                * @return 
                *               true in case of successfull execution of the trigger command
                *               otherwise false
                */
                function f_mtc_userAddNewMediaStreamSuccessful(EquipmentUser p_userCompRef) 
                        runs on TestCoordinator return boolean {
                        var boolean v_success := false;

                        p_userCompRef.start(f_checkUserAddNewMediaStream());

                        p_userCompRef.done;

                        if(f_getE2EVerdict() == pass) {
                                v_success := true;      
                        }
                                return v_success;
                }
                
                /**
                  * @desc Trigger UE given by p_ueRef to remove a media stream 
                  * @param p_userCompRef Reference to IMS UE user component
                  * @return
                  *     true in case of successfull execution of the trigger command
                  *     otherwise false
                  */
                function f_mtc_userRemoveMediaStream(EquipmentUser p_ueRef) 
                runs on TestCoordinator return boolean {
                var boolean v_status := true;                   
                v_status := f_mtc_userRemoveNewMediaStreamSuccessful(p_ueRef); 
                return v_status;
                }               
                
        /**
        * 
        * @desc Starts user component behaviour for checking that  
        *               a new media stream has been added
        * @param p_userCompRef Reference to IMS UE user component
        * @return 
        *               true in case of successfull execution of the trigger command
        *               otherwise false
        */
        function f_mtc_userRemoveNewMediaStreamSuccessful(EquipmentUser p_userCompRef) 
                runs on TestCoordinator return boolean {
                var boolean v_success := false;
    
                p_userCompRef.start(f_checkUserRemoveNewMediaStream());
    
                p_userCompRef.done;
    
                if(f_getE2EVerdict() == pass) {
                        v_success := true;      
                }
                        return v_success;
        }
                
                
                /**
                  * @desc Trigger UE given by p_ueRef to check the remove of a media stream 
                  * @param p_userCompRef Reference to IMS UE user component
                  * @return
                  *     true in case of successfull execution of the trigger command
                  *     otherwise false
                  */
                function f_mtc_userCheckRemoveMediaStream(EquipmentUser p_ueRef) 
            runs on TestCoordinator return boolean {
                var boolean v_status := true; 
                // TODO
                        return v_status;
                }
                
                /**
                  * @desc Trigger UE given by p_ueRef to add a new media stream 
                  * @param p_userCompRef Reference to IMS UE user component
                  * @return
                  *     true in case of successfull execution of the trigger command
                  *     otherwise false
                  */
                function f_mtc_userModifiyMediaStream(EquipmentUser p_ueRef) 
            runs on TestCoordinator return boolean {
                var boolean v_status := true; 
                // TODO
                        return v_status;
                }
                
                /**
                  * @desc Trigger UE given by p_ueRef to add a new media stream 
                  * @param p_userCompRef Reference to IMS UE user component
                  * @return
                  *     true in case of successfull execution of the trigger command
                  *     otherwise false
                  */
                function f_mtc_userCheckNewMediaStream(EquipmentUser p_ueRef) 
            runs on TestCoordinator return boolean {
                var boolean v_status := true; 
                // TODO
                        return v_status;
                }
                
                
                /**
                  * @desc Trigger UE given by p_ueRef to loose conectifity 
                  * @param p_userCompRef Reference to IMS UE user component
                  * @return
                  *     true in case of successfull execution of the trigger command
                  *     otherwise false
                  */
                function f_mtc_userLooseConnection(EquipmentUser p_ueRef) 
            runs on TestCoordinator return boolean {
                var boolean v_status := true; 
                // TODO
                        return v_status;
                }

                /**
                        * @desc Trigger UE given by p_ueRef to enter CANCEL current call 
                        * @param p_userCompRef Reference to IMS UE user component
                        * @return
                        *     true in case of successfull execution of the trigger command
                        *     otherwise false
                        */
                function f_mtc_userTriggerCancelCall(EquipmentUser p_ueRef) 
                        runs on TestCoordinator return boolean {
                        var boolean v_status := true; 
                        // TODO
                        return v_status;
                }

                /**
                  * @desc Trigger UE given by p_ueRef to enter HOLD state 
                  * @param p_userCompRef Reference to IMS UE user component
                  * @return
                  *     true in case of successfull execution of the trigger command
                  *     otherwise false
                  */
                function f_mtc_userTriggerHold(EquipmentUser p_ueRef) 
            runs on TestCoordinator return boolean {
                var boolean v_status := true; 
                // TODO
                        return v_status;
                }
                /**
                  * @desc Trigger UE given by p_ueRef to leave HOLD state and resume pending call  
                  * @param p_userCompRef Reference to IMS UE user component
                  * @return
                  *     true in case of successfull execution of the trigger command
                  *     otherwise false
                  */
                function f_mtc_userTriggerResume(EquipmentUser p_ueRef) 
            runs on TestCoordinator return boolean {
                var boolean v_status := true; 
                // TODO
                        return v_status;
                }
                        
                /**
                  * @desc Check that UE given by p_ueRef is ringing
                  * @param p_userCompRef Reference to IMS UE user component
                  * @return true or false
                  */
                function f_mtc_userCheckRinging(EquipmentUser p_ueRef) 
            runs on TestCoordinator return boolean {
                var boolean v_status := true; 
                // TODO
                        return v_status;
                }

                /**
                  * @desc Check that UE given by p_ueRef reports a successfull call establishment
                  * @param p_userCompRef Reference to IMS UE user component
                  * @return true or false
                  */
                function f_mtc_userCheckCallEstablished(EquipmentUser p_ueRef) 
            runs on TestCoordinator return boolean {
                var boolean v_status := true; 
                // TODO
                        return v_status;
                }

        /**
          * @desc Check that UE given by p_ueRef reports a not successfull call establishment
          * @param p_userCompRef Reference to IMS UE user component
          * @return true or false
          */
        function f_mtc_userCheckCallCannotBeEstablished(EquipmentUser p_ueRef) 
                runs on TestCoordinator return boolean {
                var boolean v_status := true; 
                // TODO
                return v_status;
                }


                /**
                  * @desc Check that UE by p_ueRef given reports that its peer is ringing
                  * @param p_userCompRef Reference to IMS UE user component
                  * @return true or false
                  */
                function f_mtc_userCheckPeerIsRinging(EquipmentUser p_ueRef) 
            runs on TestCoordinator return boolean {
                var boolean v_status := true; 
                // TODO
                        return v_status;
                }
                /**
                  * @desc Check that UE by p_ueRef given reports HOLD state
                  * @param p_userCompRef Reference to IMS UE user component
                  * @return true or false
                  */
                function f_mtc_userCheckUserOnHold(EquipmentUser p_ueRef) 
            runs on TestCoordinator return boolean {
                var boolean v_status := true; 
                // TODO
                        return v_status;
                }
                /**
                  * @desc Check that UE by p_ueRef given reports that call has been resumed
                  * @param p_userCompRef Reference to IMS UE user component
                  * @return true or false
                  */
                function f_mtc_userCheckCallResumed(EquipmentUser p_ueRef) 
            runs on TestCoordinator return boolean {
                var boolean v_status := true; 
                // TODO
                        return v_status;
                }
                /**
                  * @desc Check that UE by p_ueRef given reports that call has ended
                  * @param p_userCompRef Reference to IMS UE user component
                  * @return true or false
                  */
                function f_mtc_userCheckCallEnded(EquipmentUser p_ueRef) 
            runs on TestCoordinator return boolean {
                var boolean v_status := true; 
                // TODO
                        return v_status;
                }
        /**
          * @desc Check that UE by p_ueRef given reports that call is terminated
          * @param p_userCompRef Reference to IMS UE user component
          * @return true or false
          */
        function f_mtc_userCheckCallTerminated(EquipmentUser p_ueRef) 
            runs on TestCoordinator return boolean {
            var boolean v_status := true; 
            // TODO
                return v_status;
            }
                /**
                        * @desc Check that UE by p_ueRef given reports that call is no longer offered
                        * @param p_userCompRef Reference to IMS UE user component
                        * @return true or false
                        */
                function f_mtc_userCheckCallNoLongerOffered(EquipmentUser p_ueRef) 
                        runs on TestCoordinator return boolean {
                        var boolean v_status := true; 
                        // TODO
                        return v_status;
                        }

                /**
                        * @desc Check that UE by p_ueRef given reports that call has been cancelled
                        * @param p_userCompRef Reference to IMS UE user component
                        * @return true or false
                        */
                function f_mtc_userCheckCallCancelled(EquipmentUser p_ueRef) 
                        runs on TestCoordinator return boolean {
                        var boolean v_status := true; 
                        // TODO
                        return v_status;
                }

                /**
                        * @desc Check that UE by p_ueRef given reports that call has been rejected due to ACR
                        * @param p_userCompRef Reference to IMS UE user component
                        * @return true or false
                        */
                function f_mtc_userCheckCallRejectedACR(EquipmentUser p_ueRef) 
                        runs on TestCoordinator return boolean {
                        var boolean v_status := true; 
                        // TODO
                        return v_status;
                }
                
                /**
                  * @desc Start capturing and monitoring traffic on all configured interfaces
                  * @return true or false
                  */
                function f_mtc_StartAllTrafficCapture() 
            runs on TestCoordinator return boolean {
                var boolean v_status := true; 
                // TODO
                        return v_status;
                }


                
                /**
                  * @desc Starts user component behaviour for registration from test coordinator
                  * @param p_userCompRef Reference to IMS UE user component
                  * @param p_publicId public user identity
                  * @param p_privateId private user identity
                  * @param p_pw user password
                  * @return
                  *     true in case of successfull execution of the trigger command
                  *     otherwise false
                  */
                function f_mtc_userRegister(EquipmentUser p_userCompRef, charstring p_publicId, charstring p_privateId, charstring p_pw) runs on TestCoordinator return boolean {
                        // TODO server address parameter may needed
                        var boolean v_success := false;
                        
                        p_userCompRef.start(f_userRegistration(p_publicId, p_privateId, p_pw));
                        
                        p_userCompRef.done;
                        
                        if(f_getE2EVerdict() == pass) {
                                v_success := true;      
                        }
                
                return v_success;
                }

                function f_mtc_userCheckRegistrationSuccessful(EquipmentUser p_userCompRef) runs on TestCoordinator return boolean {
                        var boolean v_success := false;
                        
                        p_userCompRef.start(f_checkUserIsRegistered());
                        
                        p_userCompRef.done;
                        
                        if(f_getE2EVerdict() == pass) {
                                v_success := true;      
                        }
                
                return v_success;
                }
                /**
                 * 
                 * @desc Starts user component behaviour for checking that the UE 
                 *               is not registered
                 * @param p_userCompRef Reference to IMS UE user component
                 * @return 
                 *              true in case of successfull execution of the trigger command
                 *              otherwise false
                 */
                function f_mtc_userCheckRegistrationUnsuccessful(EquipmentUser p_userCompRef) 
                        runs on TestCoordinator return boolean {
                        var boolean v_success := false;
                
                        p_userCompRef.start(f_checkUserIsNotRegistered());
                
                        p_userCompRef.done;
                
                        if(f_getE2EVerdict() == pass) {
                                v_success := true;      
                        }
                        return v_success;
                }
                
                /**
                  * @desc Starts user component behaviour for registration from test coordinator
                  * @param p_userCompRef Reference ot IMS UE user component
                  * @param publicId public user identity
                  * @return
                  *     true in case of successfull execution of the trigger command
                  *     otherwise false
                  */
                function f_mtc_userDeregister(EquipmentUser p_userCompRef, charstring p_publicId) runs on TestCoordinator return boolean {
                        var boolean v_success := false;
                        
                        p_userCompRef.start(f_userDeregistration(p_publicId));
                        
                        p_userCompRef.done;
                
                if( f_getE2EVerdict() == pass) {
                                v_success := true;      
                        }
                
                return v_success;
                }
                
                /**
                 * 
                 * @desc Starts user component behaviour for sending a message from test coordinator
                 * @param p_userCompRef Reference ot IMS UE user component
                 * @param p_content Content of meessage to be sent
                 */
                function f_mtc_userSendMessage(EquipmentUser p_userCompRef, charstring p_content) runs on TestCoordinator return boolean {
                        var boolean v_success := false;
                        
                        p_userCompRef.start(f_userSendMessage(p_content));
                        
                        p_userCompRef.done;
                
                if(f_getE2EVerdict() == pass) {
                        v_success := true;
                }
                
                return v_success;
                }
                
                /**
                 * 
                 * @desc Starts user component behaviour for checking message receipt from test coordinator 
                 * @param p_userCompRef Reference ot IMS UE user component
                 * @param p_content Content of meessage to be received
                 */
                function f_mtc_userCheckMessageReceipt(EquipmentUser p_userCompRef) runs on TestCoordinator return boolean {
                        var boolean v_success := false;
                        
                        p_userCompRef.start(f_userCheckMessageReceipt());
                        
                        p_userCompRef.done;
                
            if(f_getE2EVerdict() == pass) {
                        v_success := true;
                        }
                
                return v_success;
                }
                
                /**
                 * 
                 * @desc Starts user component behaviour for checking message receipt from test coordinator 
                 * @param p_userCompRef Reference ot IMS UE user component
                 * @param p_content Content of meessage to be received
                 */
                function f_mtc_userCheckMessageNotDelivered(EquipmentUser p_userCompRef) runs on TestCoordinator return boolean {
                        var boolean v_success := false;
                        
                        p_userCompRef.start(f_userCheckMessageNotDelivered());
                        
                        p_userCompRef.done;
                
            if(f_getE2EVerdict() == pass) {
                        v_success := true;
                        }
                
                return v_success;
                }


                /**
                        * @desc Trigger IMS Network to deregister UE given by p_ueRef
                        * @param p_imsRef Reference to IMS network component 
                        * @param p_ueRef Reference to IMS UE user component
                        * @return true or false
                        */
                function f_mtc_imsTriggerUeDeregistration(EquipmentUser p_imsRef, EquipmentUser p_ueRef) 
                        runs on TestCoordinator return boolean {
                        var boolean v_status := true; 
                        // TODO
                        return v_status;
                }
                
        
        
        
                
          /*
          * 
          * @desc Looks for genUser (any) of a specific product
          * @param p_productIdx Index of the product 
          * @return genUser
          */ 
                function f_getAnyValidUser(integer p_productIdx) return ImsUserInfo {
                        var integer v_size := sizeof(PX_IMS_USER_DATA);
                        const ImsUserInfo c_dummyInfo := { "dummy", "dummy", "dummy", "dummy", "dummy" };
            var ImsUserIdentity v_userid;
                          
                for(var integer i := 0; i < v_size; i := i+1) {
                        if(PX_IMS_USER_DATA[i].productIndex == p_productIdx) {
                                var integer v_size_j := sizeof(PX_IMS_USER_DATA[i].userIds);
                                for(var integer j := 0; j < v_size_j; j := j+1) {
                                if ( ischosen(PX_IMS_USER_DATA[i].userIds[j].genUserId )) {
                                        return PX_IMS_USER_DATA[i].userIds[j].genUserId;
                                }  // end if
                                } // end for j
                                log("f_getAnyValidUser: Did not find specified user id in specified product in PX_IMS_USER_DATA");
                                return c_dummyInfo;
                        } // end if
                } // end for i
                log("f_getAnyValidUser: Did not find specified product in PX_IMS_USER_DATA");
                return c_dummyInfo;
                }
                        
          /*
          * 
          * @desc Looks for TelUser of a specific product
          * @param p_productIdx Index of the product 
          * @return TelUser
          */            
                        function f_getTelUserId(integer p_productIdx) return ImsUserInfo {
                var integer v_size := sizeof(PX_IMS_USER_DATA);
                const ImsUserInfo c_dummyInfo := { "dummy", "dummy", "dummy", "dummy", "dummy" };
                var ImsUserIdentity v_userid;
                          
                for(var integer i := 0; i < v_size; i := i+1) {
                        if(PX_IMS_USER_DATA[i].productIndex == p_productIdx) {
                                var integer v_size_j := sizeof(PX_IMS_USER_DATA[i].userIds);
                                for(var integer j := 0; j < v_size_j; j := j+1) {
                                if ( ischosen(PX_IMS_USER_DATA[i].userIds[j].telUserId )) {
                                        return PX_IMS_USER_DATA[i].userIds[j].telUserId;
                                }  // end if
                                } // end for j
                                log("f_getTelUserId: Did not find specified user id in specified product in PX_IMS_USER_DATA");
                                return c_dummyInfo;
                        } // end if
                } // end for i
                log("f_getTelUserId: Did not find specified product in PX_IMS_USER_DATA");
                return c_dummyInfo;
                }
                        
          /*
          * 
          * @desc Looks for SipUser of a specific product
          * @param p_productIdx Index of the product 
          * @return SipUser
          */            
                        function f_getSipUserId(integer p_productIdx) return ImsUserInfo {
                var integer v_size := sizeof(PX_IMS_USER_DATA);
                const ImsUserInfo c_dummyInfo := { "dummy", "dummy", "dummy", "dummy", "dummy" };
                var ImsUserIdentity v_userid;
                          
                for(var integer i := 0; i < v_size; i := i+1) {
                        if(PX_IMS_USER_DATA[i].productIndex == p_productIdx) {
                                var integer v_size_j := sizeof(PX_IMS_USER_DATA[i].userIds);
                                for(var integer j := 0; j < v_size_j; j := j+1) {
                                if ( ischosen(PX_IMS_USER_DATA[i].userIds[j].sipUserId )) {
                                        return PX_IMS_USER_DATA[i].userIds[j].sipUserId;
                                }  // end if
                                } // end for j
                                log("f_getSipUserId: Did not find specified user id in specified product in PX_IMS_USER_DATA");
                                return c_dummyInfo;
                        } // end if
                } // end for i
                log("f_getSipUserId: Did not find specified product in PX_IMS_USER_DATA");
                return c_dummyInfo;
                }
                        
           /*
            * 
            * @desc Looks for ARCUser for a specific product
           * @param p_productIdx Index of the product 
           * @return ARCUser
            */
                        function f_getACRUser(integer p_productIdx) return ImsUserInfo {
                                var integer v_size := sizeof(PX_IMS_USER_DATA);
                const ImsUserInfo c_dummyInfo := { "dummy", "dummy", "dummy", "dummy", "dummy" };
                var ImsUserIdentity v_userid;
          
                        for(var integer i := 0; i < v_size; i := i+1) {
                        if(PX_IMS_USER_DATA[i].productIndex == p_productIdx) {
                                var integer v_size_j := sizeof(PX_IMS_USER_DATA[i].userIds);
                                for(var integer j := 0; j < v_size_j; j := j+1) {
                                        if ( ischosen(PX_IMS_USER_DATA[i].userIds[j].acrUserId )) {
                                                return PX_IMS_USER_DATA[i].userIds[j].acrUserId;
                                        }  // end if
                                } // end for j
                                log("f_getACRUser: Did not find specified user id in specified product in PX_IMS_USER_DATA");
                                return c_dummyInfo;
                        } // end if
                        } // end for i
                log("f_getACRUser: Did not find specified product in PX_IMS_USER_DATA");
                return c_dummyInfo;
                }
                
          /*
          * 
          * @desc Looks for OIPUser for a specific product
          * @param p_productIdx Index of the product 
          * @return OIPUser
          */
                        function f_getOIPUser(integer p_productIdx) return ImsUserInfo {
                        var integer v_size := sizeof(PX_IMS_USER_DATA);
                        const ImsUserInfo c_dummyInfo := { "dummy", "dummy", "dummy", "dummy", "dummy" };
                        var ImsUserIdentity v_userid;
          
                        for(var integer i := 0; i < v_size; i := i+1) {
                        if(PX_IMS_USER_DATA[i].productIndex == p_productIdx) {
                                var integer v_size_j := sizeof(PX_IMS_USER_DATA[i].userIds);
                                for(var integer j := 0; j < v_size_j; j := j+1) {
                                        if ( ischosen(PX_IMS_USER_DATA[i].userIds[j].oipUserId )) {
                                                return PX_IMS_USER_DATA[i].userIds[j].oipUserId;
                                        }  // end if
                                } // end for j
                                log("f_getOIPUser: Did not find specified user id in specified product in PX_IMS_USER_DATA");
                                return c_dummyInfo;
                        } // end if
                        } // end for i
                        log("f_getOIPUser: Did not find specified product in PX_IMS_USER_DATA");
                        return c_dummyInfo;
                }
                        
          /*
          * 
          * @desc Looks for OIRUser for a specific product
          * @param p_productIdx Index of the product 
          * @return OIRUser
          */
                        function f_getOIRUser(integer p_productIdx) return ImsUserInfo {
                var integer v_size := sizeof(PX_IMS_USER_DATA);
                const ImsUserInfo c_dummyInfo := { "dummy", "dummy", "dummy", "dummy", "dummy" };
                var ImsUserIdentity v_userid;
          
                        for(var integer i := 0; i < v_size; i := i+1) {
                        if(PX_IMS_USER_DATA[i].productIndex == p_productIdx) {
                                var integer v_size_j := sizeof(PX_IMS_USER_DATA[i].userIds);
                                for(var integer j := 0; j < v_size_j; j := j+1) {
                                        if ( ischosen(PX_IMS_USER_DATA[i].userIds[j].oirUserId )) {
                                                return PX_IMS_USER_DATA[i].userIds[j].oirUserId;
                                        }  // end if
                                } // end for j
                                log("f_getOIRUser: Did not find specified user id in specified product in PX_IMS_USER_DATA");
                                return c_dummyInfo;
                        } // end if
                        } // end for i
                        log("f_getOIRUser: Did not find specified product in PX_IMS_USER_DATA");
                        return c_dummyInfo;     
                }       

                /*
                * 
                * @desc Looks for HoldUser for a specific product
                * @param p_productIdx Index of the product 
                * @return HoldUser
                */
                        function f_getHoldUser(integer p_productIdx) return ImsUserInfo {
                                var integer v_size := sizeof(PX_IMS_USER_DATA);
                                const ImsUserInfo c_dummyInfo := { "dummy", "dummy", "dummy", "dummy", "dummy" };
                                var ImsUserIdentity v_userid;
  
                                for(var integer i := 0; i < v_size; i := i+1) {
                                        if(PX_IMS_USER_DATA[i].productIndex == p_productIdx) {
                                                var integer v_size_j := sizeof(PX_IMS_USER_DATA[i].userIds);
                                                for(var integer j := 0; j < v_size_j; j := j+1) {
                                                        if ( ischosen(PX_IMS_USER_DATA[i].userIds[j].holdUserId )) {
                                                                return PX_IMS_USER_DATA[i].userIds[j].holdUserId;
                                                        }  // end if
                                                } // end for j
                                                log("f_getHoldUser: Did not find specified user id in specified product in PX_IMS_USER_DATA");
                                                return c_dummyInfo;
                                        } // end if
                                } // end for i
                                log("f_getHoldUser: Did not find specified product in PX_IMS_USER_DATA");
                                return c_dummyInfo;     
                        }       
                
                // TODO 
                function f_getUEHostname(integer p_ID, out charstring p_hostname) 
                                return boolean {
                
                        // TODO
                                
                        return true;            
                } 
                
        /**
         * @desc
         *     Preamble to handle user registration in home network from test coordinator
         * @param p_userCompRef Reference ot IMS UE user component
         * @return true in case of successfull execution otherwise false
         */
        function f_PR_user_home_registration(EquipmentUser p_userCompRef, ImsUserInfo p_userInfo) 
        runs on TestCoordinator return boolean {
                var boolean v_status := true; 
                        if( p_userInfo.publicId  == "" ) { return false; } 
                
                v_status := f_mtc_userRegister(p_userCompRef, p_userInfo.publicId, p_userInfo.privateId, p_userInfo.password); 
                
                return v_status;
        }
        
        /**
         * @desc
         *     Postamble to handle user deregistration in home network from test coordinator
         * @param p_userCompRef Reference ot IMS UE user component
         * @return true in case of successfull execution otherwise false
         */
        function f_PO_user_home_deregistration(EquipmentUser p_userCompRef) runs on ImsTestCoordinator return boolean {
                var boolean v_status := true; 
                
                v_status := f_mtc_userDeregister(p_userCompRef, "*"); // deregister all previous users
                
                return v_status;
        }
        
        /**
         * @desc
         *     Preamble to handle user registration in roaming network from test coordinator
         * @param p_userCompRef Reference ot IMS UE user component
         * @return true in case of successfull execution otherwise false
         */
        function f_PR_user_roaming_registration(EquipmentUser p_userCompRef, ImsUserInfo p_userInfo) 
        runs on TestCoordinator return boolean {
                var boolean v_status := true; 
                        if( p_userInfo.publicId  == "" ) { return false; } 
                
                // TODO check roaming registration
                v_status := f_mtc_userRegister(p_userCompRef, p_userInfo.publicId, p_userInfo.privateId, p_userInfo.password); 
                
                return v_status;
        }
        
        /**
         * @desc
         *     Postamble to handle user deregistration in roaming network from test coordinator
         * @param p_userCompRef Reference ot IMS UE user component
         * @return true in case of successfull execution otherwise false
         */
        function f_PO_user_roaming_deregistration(EquipmentUser p_userCompRef) runs on ImsTestCoordinator return boolean {
                var boolean v_status := true; 
                
                // TODO check roaming de-registration
                v_status := f_mtc_userDeregister(p_userCompRef, "*"); // deregister all previous users
                
                return v_status;
        }

        /**
         * @desc Get the S-CSCF FQDN address of referenced EUT 
         * @return if a S-CSCF is avaiable, the domainname of the S-CSCF, 
         *         otherwise error_string
         */
       function f_GetEUTScscfAddress(integer p_ProductIdx) return charstring {
                        var integer v_size_interfaces := sizeof(PX_PRODUCTS[p_ProductIdx].monitorInterfaces);
                        var integer v_size_ipinterfaceinfo;
                        var integer v_interface := -1;
                        var integer v_ipinterfaceinfo := -1;
                        var charstring v_domainname;
  
                        for(var integer i := 0; i < v_size_interfaces; i := i+1) {
                                if (match(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[i].interfaceName, pattern "[Mm][Ww]")){
                                        v_interface := i;
                                        break;
                                }
                        }
                        if (v_interface > -1) {
                                v_size_ipinterfaceinfo := sizeof(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo);
                        for(var integer i := 0; i < v_size_ipinterfaceinfo; i := i+1) {
                                        if(ispresent(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[i].domainName)) {
                                        v_domainname := PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[i].domainName;
                                                if (match(substr(v_domainname, 0, 5), pattern "[Ss][Cc][Ss][Cc][Ff]") 
                                                or match(substr(v_domainname, 0, 5), pattern "[Ss][Tt][Ee][Cc][Hh]")) {
                                                v_ipinterfaceinfo := i;
                                                break;
                                        }
                                        }
                        }
                        } else {
                                log ("S-CSCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found.");
                                return "S-CSCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found.";
                        }
                        if (v_ipinterfaceinfo > -1) {
                                return PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[v_ipinterfaceinfo].domainName;
                        } else {
                                log ("S-CSCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found.");
                                return "S-CSCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found.";
                        }
        }

        /**
         * @desc Get the S-CSCF FQDN address of referenced EUT 
         * @return if a S-CSCF is avaiable, the IP Address of the S-CSCF, 
         *         otherwise error_string
         */
       function f_GetEUTScscfIpAddress(integer p_ProductIdx) return charstring {
                        var integer v_size_interfaces := sizeof(PX_PRODUCTS[p_ProductIdx].monitorInterfaces);
                        var integer v_size_ipinterfaceinfo;
                        var integer v_interface := -1;
                        var integer v_ipinterfaceinfo := -1;
                        var charstring v_domainname;
  
                        for(var integer i := 0; i < v_size_interfaces; i := i+1) {
                                if (match(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[i].interfaceName, pattern "[Mm][Ww]")){
                                        v_interface := i;
                                }
                        }
                        if (v_interface > -1) {
                                v_size_ipinterfaceinfo := sizeof(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo);
                        for(var integer i := 0; i < v_size_ipinterfaceinfo; i := i+1) {
                                        if(ispresent(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[i].domainName)) {
                                v_domainname := PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[i].domainName;
                                if (match(substr(v_domainname, 0, 5), pattern "[Ss][Cc][Ss][Cc][Ff]")
                                or match(substr(v_domainname, 0, 5), pattern "[Ss][Tt][Ee][Cc][Hh]")) {
                                        v_ipinterfaceinfo := i;
                                }
                                }
                        }
                        } else {
                                log ("S-CSCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found.");
                                return "S-CSCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found.";
                        }
                        if (v_ipinterfaceinfo > -1) {
                                return PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[v_ipinterfaceinfo].IpAddress;
                        } else {
                                log ("S-CSCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found.");
                                return "S-CSCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found.";
                        }
        }
        
        /**
         * @desc Get the P-CSCF FQDN address of referenced EUT 
         * @return if a PCSCF is avaiable, the domainname of the PCSCF, 
         *         otherwise error_string
         */
        function f_GetEUTPcscfAddress(integer p_ProductIdx) return charstring {
                  var integer v_size_interfaces := sizeof(PX_PRODUCTS[p_ProductIdx].monitorInterfaces);
                  var integer v_size_ipinterfaceinfo;
                  var integer v_interface := -1;
                  var integer v_ipinterfaceinfo := -1;
                  var charstring v_domainname;
                  
                  for(var integer i := 0; i < v_size_interfaces; i := i+1) {
                        if (match(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[i].interfaceName, pattern "[Gg][Mm]")){
                          v_interface := i;
                          break;
                        }
                  }
                  if (v_interface > -1) {
                  v_size_ipinterfaceinfo := sizeof(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo);
                  for(var integer i := 0; i < v_size_ipinterfaceinfo; i := i+1) {
                   if(ispresent(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[i].domainName)) {
                        v_domainname := PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[i].domainName;
                        if (match(substr(v_domainname, 0, 5), pattern "[Pp][Cc][Ss][Cc][Ff]")
                        or match(substr(v_domainname, 0, 5), pattern "[Pp][Tt][Ee][Cc][Hh]")) {
                          v_ipinterfaceinfo := i;
                }
                   }
                  }
                  } else {
                        log ("P-CSCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found.");
                        return "P-CSCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found.";
                  }
                  if (v_ipinterfaceinfo > -1) {
                return PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[v_ipinterfaceinfo].domainName;
                  } else {
                        log ("P-CSCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found.");
                        return "P-CSCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found.";
                  }
        }

        /**
         * @desc Get the P-CSCF IP address of referenced EUT 
         * @return if a PCSCF is avaiable, the IP address of the PCSCF, 
         *         otherwise error_string
         */
        function f_GetEUTPcscfIpAddress(integer p_ProductIdx) return charstring {
                  var integer v_size_interfaces := sizeof(PX_PRODUCTS[p_ProductIdx].monitorInterfaces);
                  var integer v_size_ipinterfaceinfo;
                  var integer v_interface := -1;
                  var integer v_ipinterfaceinfo := -1;
                  var charstring v_domainname;
                  
                  for(var integer i := 0; i < v_size_interfaces; i := i+1) {
                        if (match(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[i].interfaceName, pattern "[Gg][Mm]")){
                          v_interface := i;
                          break;
                        }
                  }
                  if (v_interface > -1) {
                  v_size_ipinterfaceinfo := sizeof(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo);
                  for(var integer i := 0; i < v_size_ipinterfaceinfo; i := i+1) {
                   if(ispresent(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[i].domainName)) {
                        v_domainname := PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[i].domainName;
                        if (match(substr(v_domainname, 0, 5), pattern "[Pp][Cc][Ss][Cc][Ff]")
                        or match(substr(v_domainname, 0, 5), pattern "[Pp][Tt][Ee][Cc][Hh]")) {
                          v_ipinterfaceinfo := i;
                }
                   }
                  }
                  } else {
                        log ("P-CSCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found.");
                        return "P-CSCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found.";
                  }
                  if (v_ipinterfaceinfo > -1) {
                return PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[v_ipinterfaceinfo].IpAddress;
                  } else {
                        log ("P-CSCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found.");
                        return "P-CSCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found.";
                  }
        }
        
        /**
         * @desc Get the IBCF FQDN address of referenced EUT 
         * @return if a IBCF is avaiable, the domainname of the IBCF, 
         *         otherwise error_string
         */
        function f_GetEUTIbcfAddress(integer p_ProductIdx) return charstring {
                  var integer v_size_interfaces := sizeof(PX_PRODUCTS[p_ProductIdx].monitorInterfaces);
                  var integer v_size_ipinterfaceinfo;
                  var integer v_interface := -1;
                  var integer v_ipinterfaceinfo := -1;
                  var charstring v_domainname;
                  
                  for(var integer i := 0; i < v_size_interfaces; i := i+1) {
                        if (match(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[i].interfaceName, pattern "[Mm][Ww]")){
                          v_interface := i;
                        }
                  }
                  if (v_interface > -1) {
                  v_size_ipinterfaceinfo := sizeof(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo);
                  for(var integer i := 0; i < v_size_ipinterfaceinfo; i := i+1) {
                                if(ispresent(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[i].domainName)) {
                        v_domainname := PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[i].domainName;
                        if (match(substr(v_domainname, 0, 5), pattern "[Ii][Bb][Cc][Ff]")) {
                          v_ipinterfaceinfo := i;
                }
                                }
                  }
                  } else {
                        log ("IBCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found.");
                        return "IBCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found.";
                  }
                  if (v_ipinterfaceinfo > -1) {
                return PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[v_ipinterfaceinfo].domainName;
                  } else {
                        log ("IBCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found.");
                        return "IBCF of " & PX_PRODUCTS[p_ProductIdx].productName & " not found.";
                  }
        }

                /**
                * @desc Get the Public Id of referenced UE
                * @param p_ProductIdx index of the product the UE belongs to 
                * @return PublicID of the UE of the productIdx
                */
                function f_GetUEPublicId(integer p_ProductIdx) return charstring {
                        
                        var ImsUserInfo v_uePublicId := f_getSipUserId(p_ProductIdx);
                        
                        return v_uePublicId.publicId;
                }
                
                
        /**
         * @desc Get the UE URI containing the IP address of referenced EUT
         */
        function f_getUeIpAddress(integer p_ProductIdx) return template SipUrl {
          // TODO
          return mw_SIP_URI_Base;
        }

        /**
         * @desc Get the Public Id of referenced EUT 
         */
        function f_GetEUTPublicId(integer p_ProductIdx) return charstring {
          // TODO
          return "TODO";
        }
        
                /**
         * @desc Get the AS server FQDN  of referenced EUT 
         */
        function f_GetEUTASServerAddress(integer p_ProductIdx) return charstring {
           var integer v_size_interfaces := sizeof(PX_PRODUCTS[p_ProductIdx].monitorInterfaces);
           var integer v_size_ipinterfaceinfo;
           var integer v_interface := -1;
           var integer v_ipinterfaceinfo := -1;
           var charstring v_domainname;
      
           for(var integer i := 0; i < v_size_interfaces; i := i+1) {
            if (match(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[i].interfaceName, pattern "[Ii][Ss][Cc]")){
             v_interface := i;
            }
           }
           if (v_interface > -1) {
            v_size_ipinterfaceinfo := sizeof(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo);
               for(var integer i := 0; i < v_size_ipinterfaceinfo; i := i+1) {
                v_domainname := PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[i].domainName;
                if (match(substr(v_domainname, 0, 2), pattern "[Aa][Ss]") 
                or match(substr(v_domainname, 2, 2), pattern "[Aa][Ss]")
                or match(substr(v_domainname, 9, 2), pattern "[Aa][Ss]")) {
                 v_ipinterfaceinfo := i;
                }
               }
           } else {
            log ("AS of " & PX_PRODUCTS[p_ProductIdx].productName & " not found.");
            return "AS of " & PX_PRODUCTS[p_ProductIdx].productName & " not found.";
           }
           if (v_ipinterfaceinfo > -1) {
            return PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[v_ipinterfaceinfo].domainName;
           } else {
            log ("AS of " & PX_PRODUCTS[p_ProductIdx].productName & " not found.");
            return "AS of " & PX_PRODUCTS[p_ProductIdx].productName & " not found.";
           }
        }

        }
 
                /**
         * @desc Get the AS server IP Address  of referenced EUT 
         */
        function f_GetEUTASServerIpAddress(integer p_ProductIdx) return charstring {
           var integer v_size_interfaces := sizeof(PX_PRODUCTS[p_ProductIdx].monitorInterfaces);
           var integer v_size_ipinterfaceinfo;
           var integer v_interface := -1;
           var integer v_ipinterfaceinfo := -1;
           var charstring v_domainname;
      
           for(var integer i := 0; i < v_size_interfaces; i := i+1) {
            if (match(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[i].interfaceName, pattern "[Ii][Ss][Cc]")){
             v_interface := i;
            }
           }
           if (v_interface > -1) {
            v_size_ipinterfaceinfo := sizeof(PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo);
               for(var integer i := 0; i < v_size_ipinterfaceinfo; i := i+1) {
                v_domainname := PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[i].domainName;
                if (match(substr(v_domainname, 0, 2), pattern "[Aa][Ss]") 
                or match(substr(v_domainname, 2, 2), pattern "[Aa][Ss]")
                or (lengthof(v_domainname) >= 11 and match(substr(v_domainname, 9, 2), pattern "[Aa][Ss]"))) {
                 v_ipinterfaceinfo := i;
                }
               }
           } else {
            log ("AS of " & PX_PRODUCTS[p_ProductIdx].productName & " not found.");
            return "AS of " & PX_PRODUCTS[p_ProductIdx].productName & " not found.";
           }
           if (v_ipinterfaceinfo > -1) {
            return PX_PRODUCTS[p_ProductIdx].monitorInterfaces[v_interface].interfaceInfo.IpInterfaceInfo[v_ipinterfaceinfo].IpAddress;
           } else {
            log ("AS of " & PX_PRODUCTS[p_ProductIdx].productName & " not found.");
            return "AS of " & PX_PRODUCTS[p_ProductIdx].productName & " not found.";
           }
        }

 
        group interComponent {
                /**
                  * @desc
                  *     This function waits for a sip message send from a given monitor
                  *     component to mtc.
                  * @param p_monitor Reference of Interface Monitor component
                  * @param p_msg The Sip message
                  */
                function f_getSipMsgFromMonitor(InterfaceMonitor p_monitor, out SipMessage p_msg) runs on ImsTestCoordinator {
            timer t_local := PX_MAX_MSG_WAIT;
            t_local.start;            
            alt {
                []icpPort.receive (SipMessage:?) /*from p_monitor*/ -> value p_msg {
                   t_local.stop;
                   setverdict(pass, self, "***f_getMsgFromMonitor: SIP message received***");   
                }
                []t_local.timeout {
                        setverdict(fail, self, "***f_getMsgFromMonitor: SIP message not received***");    
                }
            }
        }       
        }
        
        group altsteps {
                
                altstep a_default(in charstring p_TP) runs on ImsInterfaceMonitor {
                        [] dPort.receive(Request:?) {
                                log(self, "### a_default: Request default for " & p_TP );
                                repeat; 
                        }
                        [] dPort.receive(Response:?) {
                                log(self, "### a_default: Response default for " & p_TP );
                                repeat; 
                        }
                        [] dPort.receive {
                                log(self, "*** a_default: Received/ignored unexpected message when waiting for message complying to " & p_TP );
                //setverdict(fail, self, "### YANN: If execution is here, this means that the message was not properly decoded due to sip/sdp-codets exception, check MMagic logs");    
                                //stop; // YANN: If execution is here, this means that the message was not properly decoded 
                                repeat; 
                        }
                }
        
                /**
                * @desc This altstep add one alternative checking for a very specifc SIP request.
                                                                                If it matches then the conformance verdict is set to requested verdict
                * @param p_message The expected SIP request
                * @param p_verdict Verdict to be used in case of match
                * @param p_tpId The test purpose identifier
                * * @param p_forwardMtc indicates if the received request should be forwarded to mtc
                */
                altstep a_receive_sipRequest(
                        in template Request p_message,
                        in verdicttype p_verdict,
                        in charstring p_tpId,
                        in boolean p_forwardMtc,
                        in boolean p_checkMessage
                ) runs on ImsInterfaceMonitor {
                        var Request v_message;
                        [not p_checkMessage] dPort.receive(p_message) -> value v_message {
                                f_setConformanceVerdict(p_verdict, "***a_receive_sipRequest: Received expected SIP request complying to " & p_tpId & " on interface " & vc_interfaceName & " ***");
                                if(p_forwardMtc) {
                                        var SipMessage v_msg;
                                        v_msg.request := v_message;
                                        log("### Forwarding message to MTC");   
                                        icpPort.send(v_msg);
                                }
                        }
                        [p_checkMessage] dPort.check(receive(p_message) -> value v_message) {
                                f_setConformanceVerdict(p_verdict, "***a_receive_sipRequest: Checked expected SIP request complying to " & p_tpId & " on interface " & vc_interfaceName & " ***");
                                if(p_forwardMtc) {
                                        var SipMessage v_msg;
                                        v_msg.request := v_message;
                                        log("### Forwarding message to MTC");
                                        icpPort.send(v_msg);
                                }
                        }
                }
        
                /**
                * @desc This altstep add one alternative checking for a very specifc SIP response.
                                                                                If it matches then the conformance verdict is set to requested verdict
                * @param p_message The expected SIP response
                * @param p_verdict Verdict to be used in case of match
                * @param p_tpId The test purpose identifier
                * @param p_forwardMtc indicates if the received reponse should be forwarded to mtc
                */
                altstep a_receive_sipResponse(
                                                in template Response p_message,
                                                in verdicttype p_verdict,
                                                in charstring p_tpId,
                                                in boolean p_forwardMtc,
                                                in boolean p_checkMessage
                ) runs on ImsInterfaceMonitor {
                        var Response v_message;
                        [not p_checkMessage] dPort.receive(p_message) -> value v_message {
                                f_setConformanceVerdict(p_verdict, "***a_receive_sipResponse: Received expected SIP request complying to " & p_tpId & " on interface " & vc_interfaceName & " ***");
                                if(p_forwardMtc) {
                                        var SipMessage v_msg;
                                        v_msg.response := v_message;
                                        icpPort.send(v_msg);
                                }
                        }
                        [p_checkMessage] dPort.check(receive(p_message) -> value v_message) {
                                f_setConformanceVerdict(p_verdict, "***a_receive_sipResponse: Checked expected SIP request complying to " & p_tpId & " on interface " & vc_interfaceName & " ***");
                                if(p_forwardMtc) {
                                        var SipMessage v_msg;
                                        v_msg.response := v_message;
                                        icpPort.send(v_msg);
                                }
                        }
                }
        
        }// end group
        
        function f_setInterfaceNameOnComponent(charstring p_name) runs on ImsInterfaceMonitor{
                vc_interfaceName := p_name;
        }
        
        group general_td_functions {

                /**
         * @desc
         *     Generic function for reading and verifying messages on the
         *     interface associated to the ImsInterfaceMonitor instance. This
         *     functions works as follows: First, messages are skipped according
         *     to the p_skip template. The p_skip template contains a message
         *     template and a counter indicating the number of received messages
         *     matching the message template to be skipped. If not enough
         *     messages matching the message template arrive at the interface,
         *     the function fails after timout. Next, messages are consumed from
         *     the interface and matched against the p_passCriteria template
         *     list and the p_failCriteria template list. The function
         *     terminates with pass if a message is received matching a
         *     pass-template and terminates with fail if a fail-template
         *     matches. Matching against pass-templates occurs bevor matching
         *     agains fail-templates. If neither pass-templates nor
         *     fail-templates match, then the functions continues reading from
         *     the interface until a match arises, or timeout. The timeout value
         *     is given by PX_MAX_MSG_WAIT [5.0 seconds, FFS]. Finally, if
         *     p_forwardMtc is set to true, the last received message is stored
         *     to be fetched and used later by the main test component. Some
         *     special use cases: - Set p_skip.skipCounter to 0 to avoid
         *     skipping, i.e. no skippin - Set p_skip.skipCounter to 0 and
         *     p_skip.skipMessage to ? to skip exactly one message of any type
         *     will be skipped. - If the list of fail-templates is empty, then
         *     the function will wait for the first message maching a
         *     pass-message, or fail after timeout.
         * @param p_passCriteria list of message templates which lead to pass
         * @param p_failCriteria list of message templates which lead to fail
         * @param p_skip
         *     Indicate how many messages from a specific sip template should be
         *     skipped prior to checking
         * @param p_tpId The Test Purpose identifier
         * @param p_forwardMtc
         *     indicate if the received Sip message should be forwarded to the
         *     mtc
         * @param p_checkMessage
         *     indicate if the incomming message should only be checked
         *     (port.check) or consumed (port.receive). The check operation
         *     allows read access to the top element of incoming port queues
         *     without removing the top element from the queue.
         */     
        function f_imsIot_receive( 
          in template SipMessageList p_passCriteria,
          in template SipMessageList p_failCriteria,
          in template SkipType p_skip,
          in charstring p_tpId,
          in boolean p_forwardMtc,
          in boolean p_checkMessage
        ) runs on ImsInterfaceMonitor { 
            var integer v_size := sizeof(p_failCriteria); 
            var DefaultList v_defaultArray;
                        var integer i := 0;
                        var integer v_size_ai := sizeof(PX_AVAILABLE_INTERFACES);

log ("### f_imsIot_receive: passCriteria=", p_passCriteria);
log ("### f_imsIot_receive: failCriteria=", p_failCriteria);
                        
                        // check if interface is available
                        for(i := 0; i < v_size_ai; i := i+1) {
                                if (PX_AVAILABLE_INTERFACES[i].interfaceName == vc_interfaceName) {
                                        if (PX_AVAILABLE_INTERFACES[i].available == false) {
                                                setverdict(inconc, self, "******f_imsIot_receive: Interface " & PX_AVAILABLE_INTERFACES[i].interfaceName & " not available and is not evaluated******" );
                                        } else { // Interface is available
                                                v_defaultArray[0] := activate(a_default(p_tpId));
                                                f_activateImsSipDefaults(v_defaultArray, 1, p_failCriteria, fail, p_tpId, p_forwardMtc, p_checkMessage);
                                                f_activateImsSipDefaults(v_defaultArray, v_size + 1, p_passCriteria, pass, p_tpId, p_forwardMtc, p_checkMessage);
                                                f_gen_receive(p_tpId, p_skip);
        
                                                for (i := 0; i < sizeof(v_defaultArray); i := i + 1) {
                                                        deactivate(v_defaultArray[i]);
                                                }
                                        }
                                        break; // Exit loop
                                }       
                        } // 'for' loop           
                }
                
                /**
         * @desc This function implements skipping of messages as well as timeout handling.
                 *       Prior to calling this function the message to be cheked for should be added
                 *       as defaults.
                 *       This function is independent of a specific interface component.
         * @param p_tpId The Test Purpose identifier
         * @param p_skipCount Indicate how many messages should be skipped prior to checking
         */     
        function f_gen_receive( 
          in charstring p_tpId,
          in template SkipType p_skip
        ) runs on ImsInterfaceMonitor {
                var integer skipCount := valueof(p_skip.skipCount);
                                tc_wait.start;

                alt {
                // preamble (consume prior messages)
                [skipCount > 0 and ischosen(p_skip.skipMessage.request)] dPort.receive (p_skip.skipMessage.request) {
                        skipCount := skipCount - 1;
                        log("***f_gen_receive: Message skipped (intentionally) when checking for " & p_tpId & " at interface " & vc_interfaceName & " ****");
                                        repeat;
                }
                [skipCount > 0 and ispresent(p_skip.skipMessage) and ischosen(p_skip.skipMessage.response)] dPort.receive (p_skip.skipMessage.response) {
                        skipCount := skipCount - 1;
                        log("***f_gen_receive: Message skipped (intentionally) when checking for " & p_tpId & " at interface " & vc_interfaceName & " ****");
                                        repeat;
                }
                    [] tc_wait.timeout {
                        f_setConformanceVerdict(inconc, "***f_gen_receive: Timer tc_wait expired when waiting for incoming message in " & p_tpId & " at interface " & vc_interfaceName & " ****");
                    }
            }
            
        }
        
                /**
                * @desc Activates for each entry in a expected IMS SIP message list a default 
                *       for receiving that message and setting the verdict as desired
                * @param p_default Reference to default array where deaults are to be added
                * @param p_startIdx Index into default array after which references for 
                *                   defaults created in this function should be added
                * @param p_list List of expected messages to be checked in default
                * @param p_verdict Verdict to be set in case the incoming message matches 
                                   any of the expcted messages 
                * @param p_tpId Test Purpose identifir
                */
                function f_activateImsSipDefaults(
                        inout DefaultList p_default,
                        in integer p_startIdx,
                        in template SipMessageList p_list,
                        in verdicttype p_verdict,
                        in charstring p_tpId,
                        in boolean p_forwardMtc,
                        in boolean p_checkMessage
                ) runs on ImsInterfaceMonitor {
                        var integer v_size := sizeof(p_list); 
                        var integer v_idx := p_startIdx;

                        for (var integer i := 0; i < v_size; i := i + 1) {
                                if (ischosen(p_list[i].request)) {
                                        p_default[v_idx] := activate(
                                                a_receive_sipRequest(p_list[i].request,p_verdict, p_tpId, p_forwardMtc, p_checkMessage)
                                        );
                                } else {
                                        p_default[v_idx] := activate(
                                                a_receive_sipResponse(p_list[i].response,p_verdict, p_tpId, p_forwardMtc, p_checkMessage)
                                        );
                                }
                                v_idx := v_idx + 1;
                        }
//log ("### f_activateImsSipDefaults: ended");
                }
        
        }//end group
        
        
        group misc {
                
                /**
          * @desc
          *     This function generate a charstring with a given length used as
          *     message body.
          * @param p_length length of the message body
          * @return message body (charstring)
          */
                function f_getMessageBody(in integer p_length) return charstring {
                        var charstring v_rtn := "";
                        
                        for(var integer i := 0; i < p_length; i:=i+1) {
                                v_rtn := v_rtn & "a";   
                        }
                        
                        return v_rtn;
                }
                
                        function f_getContactAddr(in Contact contact) return SipUrl {
                                var SipUrl v_SipUrl;
                                
                                var ContactAddress addr := contact.contactBody.contactAddresses[0];

                                if (ischosen (addr.addressField.nameAddr)) {
                                        v_SipUrl := addr.addressField.nameAddr.addrSpec;
                                } else {
                                        v_SipUrl := addr.addressField.addrSpecUnion;
                                }
                                
                                return (v_SipUrl);
                        }
                        
        }
 
}